From ff61ef9ef7fe5377e36a0e5551fcd5b595a864e9 Mon Sep 17 00:00:00 2001
From: Shawn Willden <swillden@google.com>
Date: Thu, 17 Feb 2022 15:49:27 -0700
Subject: [PATCH 0001/1487] Provide alternate SE RoT provisioning path.

On some devices it is infeasible to provision the KeyMint RoT bits in
the Android Bootloader.  This provides an alternate path to provision
them from the TEE during early boot.

Bug: 219076736
Test: VtsAidlKeyMintTargetTest
Change-Id: Ibae9050b9a102dad3710f9495d3dfa43fa1d1b3f
---
 .../trusty_keymaster/TrustyKeyMintDevice.h        | 10 ++++++++--
 trusty/keymaster/keymint/TrustyKeyMintDevice.cpp  | 15 ++++++++++++++-
 2 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/trusty/keymaster/include/trusty_keymaster/TrustyKeyMintDevice.h b/trusty/keymaster/include/trusty_keymaster/TrustyKeyMintDevice.h
index 5fd628f3c92c..c8d8932c429b 100644
--- a/trusty/keymaster/include/trusty_keymaster/TrustyKeyMintDevice.h
+++ b/trusty/keymaster/include/trusty_keymaster/TrustyKeyMintDevice.h
@@ -27,6 +27,7 @@ namespace aidl::android::hardware::security::keymint::trusty {
 using ::keymaster::TrustyKeymaster;
 using ::ndk::ScopedAStatus;
 using secureclock::TimeStampToken;
+using ::std::array;
 using ::std::optional;
 using ::std::shared_ptr;
 using ::std::vector;
@@ -77,8 +78,13 @@ class TrustyKeyMintDevice : public BnKeyMintDevice {
                                const optional<TimeStampToken>& timestampToken) override;
     ScopedAStatus earlyBootEnded() override;
 
-    ScopedAStatus convertStorageKeyToEphemeral(const std::vector<uint8_t>& storageKeyBlob,
-                                               std::vector<uint8_t>* ephemeralKeyBlob) override;
+    ScopedAStatus convertStorageKeyToEphemeral(const vector<uint8_t>& storageKeyBlob,
+                                               vector<uint8_t>* ephemeralKeyBlob) override;
+
+    ScopedAStatus getRootOfTrustChallenge(array<uint8_t, 16>* challenge) override;
+    ScopedAStatus getRootOfTrust(const array<uint8_t, 16>& challenge,
+                                 vector<uint8_t>* rootOfTrust) override;
+    ScopedAStatus sendRootOfTrust(const vector<uint8_t>& rootOfTrust) override;
 
   protected:
     std::shared_ptr<TrustyKeymaster> impl_;
diff --git a/trusty/keymaster/keymint/TrustyKeyMintDevice.cpp b/trusty/keymaster/keymint/TrustyKeyMintDevice.cpp
index 68a791259f7d..44780e835c28 100644
--- a/trusty/keymaster/keymint/TrustyKeyMintDevice.cpp
+++ b/trusty/keymaster/keymint/TrustyKeyMintDevice.cpp
@@ -306,7 +306,7 @@ ScopedAStatus TrustyKeyMintDevice::earlyBootEnded() {
 }
 
 ScopedAStatus TrustyKeyMintDevice::convertStorageKeyToEphemeral(
-        const std::vector<uint8_t>& storageKeyBlob, std::vector<uint8_t>* ephemeralKeyBlob) {
+        const vector<uint8_t>& storageKeyBlob, vector<uint8_t>* ephemeralKeyBlob) {
     keymaster::ExportKeyRequest request(impl_->message_version());
     request.SetKeyMaterial(storageKeyBlob.data(), storageKeyBlob.size());
     request.key_format = KM_KEY_FORMAT_RAW;
@@ -321,4 +321,17 @@ ScopedAStatus TrustyKeyMintDevice::convertStorageKeyToEphemeral(
     return ScopedAStatus::ok();
 }
 
+ScopedAStatus TrustyKeyMintDevice::getRootOfTrustChallenge(array<uint8_t, 16>* /* challenge */) {
+    return kmError2ScopedAStatus(KM_ERROR_UNIMPLEMENTED);
+}
+
+ScopedAStatus TrustyKeyMintDevice::getRootOfTrust(const array<uint8_t, 16>& /* challenge */,
+                                                  vector<uint8_t>* /* rootOfTrust */) {
+    return kmError2ScopedAStatus(KM_ERROR_UNIMPLEMENTED);
+}
+
+ScopedAStatus TrustyKeyMintDevice::sendRootOfTrust(const vector<uint8_t>& /* rootOfTrust */) {
+    return kmError2ScopedAStatus(KM_ERROR_UNIMPLEMENTED);
+}
+
 }  // namespace aidl::android::hardware::security::keymint::trusty

From 24d3ac349a98350ce12b5f8a3bc1917dd4d16a7a Mon Sep 17 00:00:00 2001
From: Atneya Nair <atneya@google.com>
Date: Fri, 11 Feb 2022 17:26:28 -0500
Subject: [PATCH 0002/1487] Fix OkOrFail<status_t> conversion ambiguities

OkOrFail<status_t> has specialized conversions for Result<int, StatusT>
to avoid ambiguous implicit conversion sequences. Since user conversion
operators sequences can be followed by integral promotion, specializing
for integral types is necessary.

Specialize ResultError<StatusT> so calling code() returns a status_t
instead of a StatusT and message() is implemented even when not carrying
a string.
Eventually, these classes should be combined.

Add equality operators for ResultError<StatusT>.

Bug: 219580167
Test: atest Errors_test.cpp
Ignore-AOSP-First: Internal topic dependencies
Change-Id: I14acecfd2aef33c40e79ddb091e2f4af9291d837
---
 libutils/Errors_test.cpp              |  62 +++++++++++++++
 libutils/include/utils/ErrorsMacros.h | 108 +++++++++++++++++++++++++-
 2 files changed, 166 insertions(+), 4 deletions(-)

diff --git a/libutils/Errors_test.cpp b/libutils/Errors_test.cpp
index 873c9949059d..0d13bb03c815 100644
--- a/libutils/Errors_test.cpp
+++ b/libutils/Errors_test.cpp
@@ -108,3 +108,65 @@ TEST(errors, result_in_status) {
     status_t b = g(false);
     EXPECT_EQ(PERMISSION_DENIED, b);
 }
+
+TEST(errors, conversion_promotion) {
+    constexpr size_t successVal = 10ull;
+    auto f = [&](bool success) -> Result<size_t, StatusT> {
+        OR_RETURN(success_or_fail(success));
+        return successVal;
+    };
+    auto s = f(true);
+    ASSERT_TRUE(s.ok());
+    EXPECT_EQ(s.value(), successVal);
+    auto r = f(false);
+    EXPECT_TRUE(!r.ok());
+    EXPECT_EQ(PERMISSION_DENIED, r.error().code());
+}
+
+TEST(errors, conversion_promotion_bool) {
+    constexpr size_t successVal = true;
+    auto f = [&](bool success) -> Result<bool, StatusT> {
+        OR_RETURN(success_or_fail(success));
+        return successVal;
+    };
+    auto s = f(true);
+    ASSERT_TRUE(s.ok());
+    EXPECT_EQ(s.value(), successVal);
+    auto r = f(false);
+    EXPECT_TRUE(!r.ok());
+    EXPECT_EQ(PERMISSION_DENIED, r.error().code());
+}
+
+TEST(errors, conversion_promotion_char) {
+    constexpr char successVal = 'a';
+    auto f = [&](bool success) -> Result<unsigned char, StatusT> {
+        OR_RETURN(success_or_fail(success));
+        return successVal;
+    };
+    auto s = f(true);
+    ASSERT_TRUE(s.ok());
+    EXPECT_EQ(s.value(), successVal);
+    auto r = f(false);
+    EXPECT_TRUE(!r.ok());
+    EXPECT_EQ(PERMISSION_DENIED, r.error().code());
+}
+
+struct IntContainer {
+  // Implicit conversion from int is desired
+  IntContainer(int val) : val_(val) {}
+  int val_;
+};
+
+TEST(errors, conversion_construct) {
+    constexpr int successVal = 10;
+    auto f = [&](bool success) -> Result<IntContainer, StatusT> {
+        OR_RETURN(success_or_fail(success));
+        return successVal;
+    };
+    auto s = f(true);
+    ASSERT_TRUE(s.ok());
+    EXPECT_EQ(s.value().val_, successVal);
+    auto r = f(false);
+    EXPECT_TRUE(!r.ok());
+    EXPECT_EQ(PERMISSION_DENIED, r.error().code());
+}
diff --git a/libutils/include/utils/ErrorsMacros.h b/libutils/include/utils/ErrorsMacros.h
index 048c5386f159..fdc46e617923 100644
--- a/libutils/include/utils/ErrorsMacros.h
+++ b/libutils/include/utils/ErrorsMacros.h
@@ -25,6 +25,7 @@
 // [1] build/soong/cc/config/global.go#commonGlobalIncludes
 #include <android-base/errors.h>
 #include <android-base/result.h>
+#include <log/log_main.h>
 
 #include <assert.h>
 
@@ -44,13 +45,58 @@ struct StatusT {
     status_t val_;
 };
 
+
 namespace base {
+// TODO(b/221235365) StatusT fulfill ResultError contract and cleanup.
+
+// Unlike typical ResultError types, the underlying code should be a status_t
+// instead of a StatusT. We also special-case message generation.
+template<>
+struct ResultError<StatusT, false> {
+    ResultError(status_t s) : val_(s) {
+        LOG_FATAL_IF(s == OK, "Result error should not hold success");
+    }
+
+    template <typename T>
+    operator expected<T, ResultError<StatusT, false>>() const {
+        return unexpected(*this);
+    }
+
+    std::string message() const { return statusToString(val_); }
+    status_t code() const { return val_; }
+
+ private:
+    const status_t val_;
+};
+
+template<>
+struct ResultError<StatusT, true> {
+    template <typename T>
+    ResultError(T&& message, status_t s) : val_(s), message_(std::forward<T>(message)) {
+        LOG_FATAL_IF(s == OK, "Result error should not hold success");
+    }
+
+    ResultError(status_t s) : val_(s) {}
+
+    template <typename T>
+    operator expected<T, ResultError<StatusT, true>>() const {
+        return unexpected(*this);
+    }
+
+    status_t code() const { return val_; }
+
+    std::string message() const { return statusToString(val_) + message_; }
+ private:
+    const status_t val_;
+    std::string message_;
+};
 
 // Specialization of android::base::OkOrFail<V> for V = status_t. This is used to use the OR_RETURN
 // and OR_FATAL macros with statements that yields a value of status_t. See android-base/errors.h
 // for the detailed contract.
 template <>
 struct OkOrFail<status_t> {
+    static_assert(std::is_same_v<status_t, int>);
     // Tests if status_t is a success value of not.
     static bool IsOk(const status_t& s) { return s == OK; }
 
@@ -71,16 +117,70 @@ struct OkOrFail<status_t> {
 
     // Or converts into Result<T, StatusT>. This is used when OR_RETURN is used in a function whose
     // return type is Result<T, StatusT>.
-    template <typename T, typename = std::enable_if_t<!std::is_same_v<T, status_t>>>
+
+    template <typename T>
     operator Result<T, StatusT>() && {
-        return Error<StatusT>(std::move(val_));
+        return ResultError<StatusT>(std::move(val_));
     }
 
-    operator Result<int, StatusT>() && { return Error<StatusT>(std::move(val_)); }
+    template<typename T>
+    operator Result<T, StatusT, false>() && {
+        return ResultError<StatusT, false>(std::move(val_));
+    }
 
+    // Since user defined conversion can be followed by numeric conversion,
+    // we have to specialize all conversions to results holding numeric types to
+    // avoid conversion ambiguities with the constructor of expected.
+#pragma push_macro("SPECIALIZED_CONVERSION")
+#define SPECIALIZED_CONVERSION(type)\
+  operator Result<type, StatusT>() && { return ResultError<StatusT>(std::move(val_)); }\
+  operator Result<type, StatusT, false>() && { return ResultError<StatusT, false>(std::move(val_));}
+
+    SPECIALIZED_CONVERSION(int)
+    SPECIALIZED_CONVERSION(short int)
+    SPECIALIZED_CONVERSION(unsigned short int)
+    SPECIALIZED_CONVERSION(unsigned int)
+    SPECIALIZED_CONVERSION(long int)
+    SPECIALIZED_CONVERSION(unsigned long int)
+    SPECIALIZED_CONVERSION(long long int)
+    SPECIALIZED_CONVERSION(unsigned long long int)
+    SPECIALIZED_CONVERSION(bool)
+    SPECIALIZED_CONVERSION(char)
+    SPECIALIZED_CONVERSION(unsigned char)
+    SPECIALIZED_CONVERSION(signed char)
+    SPECIALIZED_CONVERSION(wchar_t)
+    SPECIALIZED_CONVERSION(char16_t)
+    SPECIALIZED_CONVERSION(char32_t)
+    SPECIALIZED_CONVERSION(float)
+    SPECIALIZED_CONVERSION(double)
+    SPECIALIZED_CONVERSION(long double)
+#undef SPECIALIZED_CONVERSION
+#pragma pop_macro("SPECIALIZED_CONVERSION")
     // String representation of the error value.
     static std::string ErrorMessage(const status_t& s) { return statusToString(s); }
 };
-
 }  // namespace base
+
+
+// These conversions make StatusT directly comparable to status_t in order to
+// avoid calling code whenever comparisons are desired.
+
+template <bool include_message>
+bool operator==(const base::ResultError<StatusT, include_message>& l, const status_t& r) {
+    return (l.code() == r);
+}
+template <bool include_message>
+bool operator==(const status_t& l, const base::ResultError<StatusT, include_message>& r) {
+    return (l == r.code());
+}
+
+template <bool include_message>
+bool operator!=(const base::ResultError<StatusT, include_message>& l, const status_t& r) {
+    return (l.code() != r);
+}
+template <bool include_message>
+bool operator!=(const status_t& l, const base::ResultError<StatusT, include_message>& r) {
+    return (l != r.code());
+}
+
 }  // namespace android

From 206e8a4f827254173ea04461a772cccf2f0c558c Mon Sep 17 00:00:00 2001
From: Almaz Mingaleev <mingaleev@google.com>
Date: Tue, 31 May 2022 09:25:17 +0100
Subject: [PATCH 0003/1487] Remove TZUvA feature.

The feature was superseded by tzdata mainline module(s).

Ignore-AOSP-First: merge conflict on aosp/master -> goog/master

Bug: 148144561
Test: see system/timezone

Change-Id: If87e9a71a725f665bfc977d95e52c04668447081
---
 rootdir/init.rc | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 70a3736cb55b..b811e977391d 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1021,10 +1021,6 @@ on post-fs-data
     # completed and apexd.status becomes "ready".
     exec_start apexd-snapshotde
 
-    # Check any timezone data in /data is newer than the copy in the time zone data
-    # module, delete if not.
-    exec - system system -- /system/bin/tzdatacheck /apex/com.android.tzdata/etc/tz /data/misc/zoneinfo
-
     # sys.memfd_use set to false by default, which keeps it disabled
     # until it is confirmed that apps and vendor processes don't make
     # IOCTLs on ashmem fds any more.

From 7d8c25b0c99bc5628ea9464f89e7771a82077283 Mon Sep 17 00:00:00 2001
From: Suchang Woo <suchang.woo@samsung.com>
Date: Mon, 20 Dec 2021 13:23:28 +0900
Subject: [PATCH 0004/1487] ueventd: Wait for runtime apex before running
 external firmware handler

External firmware handlers cannot run until com.android.runtime.apex is
activated. However, it may be possible to request firmware from the
kernel before apex activation. Waiting for runtime apex is required
before running an external firmware handler.

Test: atest CtsInitTestCases
Change-Id: Id63b7f29084d3cecb901049162d3e5cd0055566f
Signed-off-by: Suchang Woo <suchang.woo@samsung.com>
---
 init/firmware_handler.cpp | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/init/firmware_handler.cpp b/init/firmware_handler.cpp
index 30e808d9fcd3..b682cd0aec7c 100644
--- a/init/firmware_handler.cpp
+++ b/init/firmware_handler.cpp
@@ -33,6 +33,7 @@
 #include <android-base/chrono_utils.h>
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include <android-base/properties.h>
 #include <android-base/scopeguard.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
@@ -43,6 +44,7 @@ using android::base::Split;
 using android::base::Timer;
 using android::base::Trim;
 using android::base::unique_fd;
+using android::base::WaitForProperty;
 using android::base::WriteFully;
 
 namespace android {
@@ -82,6 +84,33 @@ static bool IsBooting() {
     return access("/dev/.booting", F_OK) == 0;
 }
 
+static bool IsApexActivated() {
+    static bool apex_activated = []() {
+        // Wait for com.android.runtime.apex activation
+        // Property name and value must be kept in sync with system/apexd/apex/apex_constants.h
+        // 60s is the default firmware sysfs fallback timeout. (/sys/class/firmware/timeout)
+        if (!WaitForProperty("apexd.status", "activated", 60s)) {
+            LOG(ERROR) << "Apexd activation wait timeout";
+            return false;
+        }
+        return true;
+    }();
+
+    return apex_activated;
+}
+
+static bool NeedsRerunExternalHandler() {
+    static bool first = true;
+
+    // Rerun external handler only on the first try and when apex is activated
+    if (first) {
+        first = false;
+        return IsApexActivated();
+    }
+
+    return first;
+}
+
 ExternalFirmwareHandler::ExternalFirmwareHandler(std::string devpath, uid_t uid, gid_t gid,
                                                  std::string handler_path)
     : devpath(std::move(devpath)), uid(uid), gid(gid), handler_path(std::move(handler_path)) {
@@ -210,6 +239,11 @@ std::string FirmwareHandler::GetFirmwarePath(const Uevent& uevent) const {
 
             auto result = RunExternalHandler(external_handler.handler_path, external_handler.uid,
                                              external_handler.gid, uevent);
+            if (!result.ok() && NeedsRerunExternalHandler()) {
+                auto res = RunExternalHandler(external_handler.handler_path, external_handler.uid,
+                                              external_handler.gid, uevent);
+                result = std::move(res);
+            }
             if (!result.ok()) {
                 LOG(ERROR) << "Using default firmware; External firmware handler failed: "
                            << result.error();

From 123d45e1d3825a0e54f84c9d7c2895155f69873f Mon Sep 17 00:00:00 2001
From: Yifan Hong <elsk@google.com>
Date: Fri, 8 Jul 2022 18:22:34 -0700
Subject: [PATCH 0005/1487] libsnapshot: fix integer overflow when calculating
 sector id.

Ignore-AOSP-First: fuzzer-detected overflow
Test: WIP
Bug: 237639416
Change-Id: I91dedc1ccfab8dcf40e5b4756e199697e62b1f3c
---
 fs_mgr/libsnapshot/partition_cow_creator.cpp | 21 ++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/partition_cow_creator.cpp b/fs_mgr/libsnapshot/partition_cow_creator.cpp
index 5569da03834b..acbcbe2193d8 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator.cpp
+++ b/fs_mgr/libsnapshot/partition_cow_creator.cpp
@@ -131,15 +131,28 @@ bool OptimizeSourceCopyOperation(const InstallOperation& operation, InstallOpera
     return is_optimized;
 }
 
-void WriteExtent(DmSnapCowSizeCalculator* sc, const chromeos_update_engine::Extent& de,
+bool WriteExtent(DmSnapCowSizeCalculator* sc, const chromeos_update_engine::Extent& de,
                  unsigned int sectors_per_block) {
     const auto block_boundary = de.start_block() + de.num_blocks();
     for (auto b = de.start_block(); b < block_boundary; ++b) {
         for (unsigned int s = 0; s < sectors_per_block; ++s) {
-            const auto sector_id = b * sectors_per_block + s;
+            // sector_id = b * sectors_per_block + s;
+            uint64_t block_start_sector_id;
+            if (__builtin_mul_overflow(b, sectors_per_block, &block_start_sector_id)) {
+                LOG(ERROR) << "Integer overflow when calculating sector id (" << b << " * "
+                           << sectors_per_block << ")";
+                return false;
+            }
+            uint64_t sector_id;
+            if (__builtin_add_overflow(block_start_sector_id, s, &sector_id)) {
+                LOG(ERROR) << "Integer overflow when calculating sector id ("
+                           << block_start_sector_id << " + " << s << ")";
+                return false;
+            }
             sc->WriteSector(sector_id);
         }
     }
+    return true;
 }
 
 std::optional<uint64_t> PartitionCowCreator::GetCowSize() {
@@ -167,7 +180,7 @@ std::optional<uint64_t> PartitionCowCreator::GetCowSize() {
     // Allocate space for extra extents (if any). These extents are those that can be
     // used for error corrections or to store verity hash trees.
     for (const auto& de : extra_extents) {
-        WriteExtent(&sc, de, sectors_per_block);
+        if (!WriteExtent(&sc, de, sectors_per_block)) return std::nullopt;
     }
 
     if (update == nullptr) return sc.cow_size_bytes();
@@ -182,7 +195,7 @@ std::optional<uint64_t> PartitionCowCreator::GetCowSize() {
         }
 
         for (const auto& de : written_op->dst_extents()) {
-            WriteExtent(&sc, de, sectors_per_block);
+            if (!WriteExtent(&sc, de, sectors_per_block)) return std::nullopt;
         }
     }
 

From e6281db539133e7958ec77e37f6c545a6185a587 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 26 Jul 2022 16:37:58 +0000
Subject: [PATCH 0006/1487] libprocessgroup: Add support for SetUserProfiles

Provide SetUserProfiles API to apply profiles at UID level.

This enables applying the freezer profile to an entire UID instead of
just individual process cgroups.

Test: bash arg: -p
Test: bash arg: com.haok.nirvana
Test: bash arg: 1
Test: args: [-p, com.haok.nirvana, 1]
Test: arg: "-p"
Test: arg: "com.haok.nirvana"
Test: arg: "1"
Test: data="com.haok.nirvana"
Test: Events injected: 1
Test: ## Network stats: elapsed time=14ms (0ms mobile, 0ms wifi, 14ms not connected)
Test: raven:/ $ ps -eo pid,uid,ppid,name|grep 10266
Test: 2499 10266   823 com.haok.nirvana
Test: 2577 10266   823 com.haok.nirvana:resident
Test: 2584 10266   823 android.media
Test: 2669 10266     1 app_d
Test: 2672 10266     1 app_d
Test: raven:/ $ am force-stop com.haok.nirvana
Test: raven:/ $ ps -eo pid,uid,ppid,name|grep 10266
Test: 1|raven:/ $
Ignore-AOSP-First: Topic with AMS changes which is developed on git_master
Bug: 236708592
Change-Id: I45e34244f9943c217757cf346c9410672a1ce365
---
 .../include/processgroup/processgroup.h       |  1 +
 libprocessgroup/processgroup.cpp              |  4 ++
 libprocessgroup/task_profiles.cpp             | 66 +++++++++++++++++++
 libprocessgroup/task_profiles.h               |  6 ++
 libprocessgroup/task_profiles_test.cpp        |  4 ++
 5 files changed, 81 insertions(+)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 39b9f3fc024c..32479e45844a 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -32,6 +32,7 @@ bool CgroupGetAttributePathForTask(const std::string& attr_name, int tid, std::s
 
 bool SetTaskProfiles(int tid, const std::vector<std::string>& profiles, bool use_fd_cache = false);
 bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles);
+bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles);
 
 #ifndef __ANDROID_VNDK__
 
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 51c810e9886e..b1ce8af1f033 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -174,6 +174,10 @@ extern "C" bool android_set_process_profiles(uid_t uid, pid_t pid, size_t num_pr
     return SetProcessProfiles(uid, pid, profiles_);
 }
 
+bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles) {
+    return TaskProfiles::GetInstance().SetUserProfiles(uid, profiles, false);
+}
+
 static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
     return StringPrintf("%s/uid_%d", cgroup, uid);
 }
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index e1c5934073c1..9dfc0ba9a435 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -139,6 +139,19 @@ bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
     return true;
 }
 
+bool ProfileAttribute::GetPathForUID(uid_t uid, std::string* path) const
+{
+    if (path == nullptr) {
+        return true;
+    }
+
+    const std::string& file_name =
+            controller()->version() == 2 && !file_v2_name_.empty() ? file_v2_name_ : file_name_;
+    *path = StringPrintf("%s/uid_%d/%s", controller()->path(), uid, file_name.c_str());
+    return true;
+}
+
+
 bool SetClampsAction::ExecuteForProcess(uid_t, pid_t) const {
     // TODO: add support when kernel supports util_clamp
     LOG(WARNING) << "SetClampsAction::ExecuteForProcess is not supported";
@@ -225,6 +238,31 @@ bool SetAttributeAction::ExecuteForTask(int tid) const {
     return true;
 }
 
+bool SetAttributeAction::ExecuteForUID(uid_t uid) const
+{
+    std::string path;
+
+    if (!attribute_->GetPathForUID(uid, &path)) {
+        LOG(ERROR) << "Failed to find cgroup for uid " << uid;
+        return false;
+    }
+
+    if (!WriteStringToFile(value_, path)) {
+        if (access(path.c_str(), F_OK) < 0) {
+            if (optional_) {
+                return true;
+            } else {
+                LOG(ERROR) << "No such cgroup attribute: " << path;
+                return false;
+            }
+        }
+        PLOG(ERROR) << "Failed to write '" << value_ << "' to " << path;
+        return false;
+    }
+    return true;
+}
+
+
 SetCgroupAction::SetCgroupAction(const CgroupController& c, const std::string& p)
     : controller_(c), path_(p) {
     FdCacheHelper::Init(controller_.GetTasksFilePath(path_), fd_[ProfileAction::RCT_TASK]);
@@ -552,6 +590,16 @@ bool TaskProfile::ExecuteForTask(int tid) const {
     return true;
 }
 
+bool TaskProfile::ExecuteForUID(uid_t uid) const {
+    for (const auto& element : elements_) {
+        if (!element->ExecuteForUID(uid)) {
+            LOG(VERBOSE) << "Applying profile action " << element->Name() << " failed";
+            return false;
+        }
+    }
+    return true;
+}
+
 void TaskProfile::EnableResourceCaching(ProfileAction::ResourceCacheType cache_type) {
     if (res_cached_) {
         return;
@@ -804,6 +852,24 @@ const IProfileAttribute* TaskProfiles::GetAttribute(const std::string& name) con
     return nullptr;
 }
 
+bool TaskProfiles::SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles,
+                                   bool use_fd_cache) {
+    for (const auto& name : profiles) {
+        TaskProfile* profile = GetProfile(name);
+        if (profile != nullptr) {
+            if (use_fd_cache) {
+                profile->EnableResourceCaching(ProfileAction::RCT_PROCESS);
+            }
+            if (!profile->ExecuteForUID(uid)) {
+                PLOG(WARNING) << "Failed to apply " << name << " process profile";
+            }
+        } else {
+            PLOG(WARNING) << "Failed to find " << name << "process profile";
+        }
+    }
+    return true;
+}
+
 bool TaskProfiles::SetProcessProfiles(uid_t uid, pid_t pid,
                                       const std::vector<std::string>& profiles, bool use_fd_cache) {
     bool success = true;
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index df08f65c7604..cdd9b42a28d2 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -33,6 +33,7 @@ class IProfileAttribute {
     virtual const CgroupController* controller() const = 0;
     virtual const std::string& file_name() const = 0;
     virtual bool GetPathForTask(int tid, std::string* path) const = 0;
+    virtual bool GetPathForUID(uid_t uid, std::string* path) const = 0;
 };
 
 class ProfileAttribute : public IProfileAttribute {
@@ -50,6 +51,7 @@ class ProfileAttribute : public IProfileAttribute {
     void Reset(const CgroupController& controller, const std::string& file_name) override;
 
     bool GetPathForTask(int tid, std::string* path) const override;
+    bool GetPathForUID(uid_t uid, std::string* path) const override;
 
   private:
     CgroupController controller_;
@@ -69,6 +71,7 @@ class ProfileAction {
     // Default implementations will fail
     virtual bool ExecuteForProcess(uid_t, pid_t) const { return false; };
     virtual bool ExecuteForTask(int) const { return false; };
+    virtual bool ExecuteForUID(uid_t) const { return false; };
 
     virtual void EnableResourceCaching(ResourceCacheType) {}
     virtual void DropResourceCaching(ResourceCacheType) {}
@@ -113,6 +116,7 @@ class SetAttributeAction : public ProfileAction {
     const char* Name() const override { return "SetAttribute"; }
     bool ExecuteForProcess(uid_t uid, pid_t pid) const override;
     bool ExecuteForTask(int tid) const override;
+    bool ExecuteForUID(uid_t uid) const override;
 
   private:
     const IProfileAttribute* attribute_;
@@ -176,6 +180,7 @@ class TaskProfile {
 
     bool ExecuteForProcess(uid_t uid, pid_t pid) const;
     bool ExecuteForTask(int tid) const;
+    bool ExecuteForUID(uid_t uid) const;
     void EnableResourceCaching(ProfileAction::ResourceCacheType cache_type);
     void DropResourceCaching(ProfileAction::ResourceCacheType cache_type);
 
@@ -212,6 +217,7 @@ class TaskProfiles {
     bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles,
                             bool use_fd_cache);
     bool SetTaskProfiles(int tid, const std::vector<std::string>& profiles, bool use_fd_cache);
+    bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles, bool use_fd_cache);
 
   private:
     std::map<std::string, std::shared_ptr<TaskProfile>> profiles_;
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index 09ac44c6b254..fed819e5320e 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -121,6 +121,10 @@ class ProfileAttributeMock : public IProfileAttribute {
         return true;
     };
 
+    bool GetPathForUID(uid_t, std::string *) const override {
+        return false;
+    }
+
   private:
     const std::string file_name_;
 };

From aee11b0a3da5bbfd09d258278700b358a8691151 Mon Sep 17 00:00:00 2001
From: Dan Shi <dshi@google.com>
Date: Fri, 19 Aug 2022 18:40:14 +0000
Subject: [PATCH 0007/1487] Revert "libprocessgroup: Add support for
 SetUserProfiles"

Revert "Freeze package cgroup before killing"

Revert submission 19436294-freeze_kill

Reason for revert: b/243096961
Reverted Changes:
I06aaa5a08:Freeze package cgroup before killing
I45e34244f:libprocessgroup: Add support for SetUserProfiles

Bug: 243096961
Change-Id: I32162341d6a38f458a9c59d63e0cdc56a97f1efe
---
 .../include/processgroup/processgroup.h       |  1 -
 libprocessgroup/processgroup.cpp              |  4 --
 libprocessgroup/task_profiles.cpp             | 66 -------------------
 libprocessgroup/task_profiles.h               |  6 --
 libprocessgroup/task_profiles_test.cpp        |  4 --
 5 files changed, 81 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 32479e45844a..39b9f3fc024c 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -32,7 +32,6 @@ bool CgroupGetAttributePathForTask(const std::string& attr_name, int tid, std::s
 
 bool SetTaskProfiles(int tid, const std::vector<std::string>& profiles, bool use_fd_cache = false);
 bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles);
-bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles);
 
 #ifndef __ANDROID_VNDK__
 
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index b1ce8af1f033..51c810e9886e 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -174,10 +174,6 @@ extern "C" bool android_set_process_profiles(uid_t uid, pid_t pid, size_t num_pr
     return SetProcessProfiles(uid, pid, profiles_);
 }
 
-bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles) {
-    return TaskProfiles::GetInstance().SetUserProfiles(uid, profiles, false);
-}
-
 static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
     return StringPrintf("%s/uid_%d", cgroup, uid);
 }
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 9dfc0ba9a435..e1c5934073c1 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -139,19 +139,6 @@ bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
     return true;
 }
 
-bool ProfileAttribute::GetPathForUID(uid_t uid, std::string* path) const
-{
-    if (path == nullptr) {
-        return true;
-    }
-
-    const std::string& file_name =
-            controller()->version() == 2 && !file_v2_name_.empty() ? file_v2_name_ : file_name_;
-    *path = StringPrintf("%s/uid_%d/%s", controller()->path(), uid, file_name.c_str());
-    return true;
-}
-
-
 bool SetClampsAction::ExecuteForProcess(uid_t, pid_t) const {
     // TODO: add support when kernel supports util_clamp
     LOG(WARNING) << "SetClampsAction::ExecuteForProcess is not supported";
@@ -238,31 +225,6 @@ bool SetAttributeAction::ExecuteForTask(int tid) const {
     return true;
 }
 
-bool SetAttributeAction::ExecuteForUID(uid_t uid) const
-{
-    std::string path;
-
-    if (!attribute_->GetPathForUID(uid, &path)) {
-        LOG(ERROR) << "Failed to find cgroup for uid " << uid;
-        return false;
-    }
-
-    if (!WriteStringToFile(value_, path)) {
-        if (access(path.c_str(), F_OK) < 0) {
-            if (optional_) {
-                return true;
-            } else {
-                LOG(ERROR) << "No such cgroup attribute: " << path;
-                return false;
-            }
-        }
-        PLOG(ERROR) << "Failed to write '" << value_ << "' to " << path;
-        return false;
-    }
-    return true;
-}
-
-
 SetCgroupAction::SetCgroupAction(const CgroupController& c, const std::string& p)
     : controller_(c), path_(p) {
     FdCacheHelper::Init(controller_.GetTasksFilePath(path_), fd_[ProfileAction::RCT_TASK]);
@@ -590,16 +552,6 @@ bool TaskProfile::ExecuteForTask(int tid) const {
     return true;
 }
 
-bool TaskProfile::ExecuteForUID(uid_t uid) const {
-    for (const auto& element : elements_) {
-        if (!element->ExecuteForUID(uid)) {
-            LOG(VERBOSE) << "Applying profile action " << element->Name() << " failed";
-            return false;
-        }
-    }
-    return true;
-}
-
 void TaskProfile::EnableResourceCaching(ProfileAction::ResourceCacheType cache_type) {
     if (res_cached_) {
         return;
@@ -852,24 +804,6 @@ const IProfileAttribute* TaskProfiles::GetAttribute(const std::string& name) con
     return nullptr;
 }
 
-bool TaskProfiles::SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles,
-                                   bool use_fd_cache) {
-    for (const auto& name : profiles) {
-        TaskProfile* profile = GetProfile(name);
-        if (profile != nullptr) {
-            if (use_fd_cache) {
-                profile->EnableResourceCaching(ProfileAction::RCT_PROCESS);
-            }
-            if (!profile->ExecuteForUID(uid)) {
-                PLOG(WARNING) << "Failed to apply " << name << " process profile";
-            }
-        } else {
-            PLOG(WARNING) << "Failed to find " << name << "process profile";
-        }
-    }
-    return true;
-}
-
 bool TaskProfiles::SetProcessProfiles(uid_t uid, pid_t pid,
                                       const std::vector<std::string>& profiles, bool use_fd_cache) {
     bool success = true;
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index cdd9b42a28d2..df08f65c7604 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -33,7 +33,6 @@ class IProfileAttribute {
     virtual const CgroupController* controller() const = 0;
     virtual const std::string& file_name() const = 0;
     virtual bool GetPathForTask(int tid, std::string* path) const = 0;
-    virtual bool GetPathForUID(uid_t uid, std::string* path) const = 0;
 };
 
 class ProfileAttribute : public IProfileAttribute {
@@ -51,7 +50,6 @@ class ProfileAttribute : public IProfileAttribute {
     void Reset(const CgroupController& controller, const std::string& file_name) override;
 
     bool GetPathForTask(int tid, std::string* path) const override;
-    bool GetPathForUID(uid_t uid, std::string* path) const override;
 
   private:
     CgroupController controller_;
@@ -71,7 +69,6 @@ class ProfileAction {
     // Default implementations will fail
     virtual bool ExecuteForProcess(uid_t, pid_t) const { return false; };
     virtual bool ExecuteForTask(int) const { return false; };
-    virtual bool ExecuteForUID(uid_t) const { return false; };
 
     virtual void EnableResourceCaching(ResourceCacheType) {}
     virtual void DropResourceCaching(ResourceCacheType) {}
@@ -116,7 +113,6 @@ class SetAttributeAction : public ProfileAction {
     const char* Name() const override { return "SetAttribute"; }
     bool ExecuteForProcess(uid_t uid, pid_t pid) const override;
     bool ExecuteForTask(int tid) const override;
-    bool ExecuteForUID(uid_t uid) const override;
 
   private:
     const IProfileAttribute* attribute_;
@@ -180,7 +176,6 @@ class TaskProfile {
 
     bool ExecuteForProcess(uid_t uid, pid_t pid) const;
     bool ExecuteForTask(int tid) const;
-    bool ExecuteForUID(uid_t uid) const;
     void EnableResourceCaching(ProfileAction::ResourceCacheType cache_type);
     void DropResourceCaching(ProfileAction::ResourceCacheType cache_type);
 
@@ -217,7 +212,6 @@ class TaskProfiles {
     bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles,
                             bool use_fd_cache);
     bool SetTaskProfiles(int tid, const std::vector<std::string>& profiles, bool use_fd_cache);
-    bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles, bool use_fd_cache);
 
   private:
     std::map<std::string, std::shared_ptr<TaskProfile>> profiles_;
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index fed819e5320e..09ac44c6b254 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -121,10 +121,6 @@ class ProfileAttributeMock : public IProfileAttribute {
         return true;
     };
 
-    bool GetPathForUID(uid_t, std::string *) const override {
-        return false;
-    }
-
   private:
     const std::string file_name_;
 };

From 7f47b5204180a6f98e3d64280eb8142b43392668 Mon Sep 17 00:00:00 2001
From: Sanjana Sunil <sanjanasunil@google.com>
Date: Mon, 28 Mar 2022 19:05:36 +0000
Subject: [PATCH 0008/1487] Create misc_ce and misc_de mirror storage

Create a mirror directory for misc_ce and misc_de storage by bind
mounting the respective directories. This is done for the defaul null
volume only, and other volumes are handled at a later staged.

When an SDK sandbox process is spawned and data isolation needs to
occur, the sdksandbox directories present in the misc directories will
be used to bind mount from, after tmpfs is mounted on the original.

Bug: 214241165
Test: atest SdkSandboxStorageHostTest
Ignore-AOSP-First: Will cherry pick based on other CLs in the topic

Change-Id: Icb1dc7d7fbd53a5c3853acf2f9d4d75b278d7295
---
 rootdir/init.rc | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 60bf57bef2e0..e791b31ed3e5 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -939,22 +939,28 @@ on post-fs-data
     restorecon /data/media
     exec - media_rw media_rw -- /system/bin/chattr +F /data/media
 
-    # A tmpfs directory, which will contain all apps CE DE data directory that
-    # bind mount from the original source.
+    # A tmpfs directory, which will contain all apps and sdk sandbox CE and DE
+    # data directory that bind mount from the original source.
     mount tmpfs tmpfs /data_mirror nodev noexec nosuid mode=0700,uid=0,gid=1000
     restorecon /data_mirror
     mkdir /data_mirror/data_ce 0700 root root
     mkdir /data_mirror/data_de 0700 root root
+    mkdir /data_mirror/misc_ce 0700 root root
+    mkdir /data_mirror/misc_de 0700 root root
 
     # Create CE and DE data directory for default volume
     mkdir /data_mirror/data_ce/null 0700 root root
     mkdir /data_mirror/data_de/null 0700 root root
+    mkdir /data_mirror/misc_ce/null 0700 root root
+    mkdir /data_mirror/misc_de/null 0700 root root
 
     # Bind mount CE and DE data directory to mirror's default volume directory.
     # The 'slave' option (MS_SLAVE) is needed to cause the later bind mount of
     # /data/data onto /data/user/0 to propagate to /data_mirror/data_ce/null/0.
     mount none /data/user /data_mirror/data_ce/null bind rec slave
     mount none /data/user_de /data_mirror/data_de/null bind rec
+    mount none /data/misc_ce /data_mirror/misc_ce/null bind rec
+    mount none /data/misc_de /data_mirror/misc_de/null bind rec
 
     # Create mirror directory for jit profiles
     mkdir /data_mirror/cur_profiles 0700 root root

From 673da5b972e751b723b735a63ae57bd54d956b7e Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Mon, 22 Aug 2022 21:25:09 +0000
Subject: [PATCH 0009/1487] Revert "Revert "libprocessgroup: Add support for
 SetUserProfiles""

This reverts commit aee11b0a3da5bbfd09d258278700b358a8691151.

This change was originally reverted because its only user was reverted
under b/243096961 at ag/19679188. We bring it back now with a fixed user.

Bug: 236708592
Bug: 148425913
Ignore-AOSP-First: Topic with AMS changes which is developed on git_master

Change-Id: I2a8ae0d9faabe7950b758a09870d128889be4d0a
---
 .../include/processgroup/processgroup.h       |  1 +
 libprocessgroup/processgroup.cpp              |  5 ++
 libprocessgroup/task_profiles.cpp             | 64 +++++++++++++++++++
 libprocessgroup/task_profiles.h               |  7 ++
 libprocessgroup/task_profiles_test.cpp        |  4 ++
 5 files changed, 81 insertions(+)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 45a723f74c26..f3cd421dd1dd 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -35,6 +35,7 @@ bool CgroupGetAttributePathForTask(const std::string& attr_name, int tid, std::s
 
 bool SetTaskProfiles(int tid, const std::vector<std::string>& profiles, bool use_fd_cache = false);
 bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles);
+bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles);
 
 __END_DECLS
 
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index bdda1020c7d4..393936ca7bd0 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -195,6 +195,11 @@ extern "C" bool android_set_process_profiles(uid_t uid, pid_t pid, size_t num_pr
     return SetProcessProfiles(uid, pid, std::span<const std::string_view>(profiles_));
 }
 
+bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles) {
+    return TaskProfiles::GetInstance().SetUserProfiles(uid, std::span<const std::string>(profiles),
+                                                       false);
+}
+
 static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
     return StringPrintf("%s/uid_%d", cgroup, uid);
 }
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 744710f3b25b..0fbfc8c079d7 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -139,6 +139,17 @@ bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
     return true;
 }
 
+bool ProfileAttribute::GetPathForUID(uid_t uid, std::string* path) const {
+    if (path == nullptr) {
+        return true;
+    }
+
+    const std::string& file_name =
+            controller()->version() == 2 && !file_v2_name_.empty() ? file_v2_name_ : file_name_;
+    *path = StringPrintf("%s/uid_%d/%s", controller()->path(), uid, file_name.c_str());
+    return true;
+}
+
 bool SetClampsAction::ExecuteForProcess(uid_t, pid_t) const {
     // TODO: add support when kernel supports util_clamp
     LOG(WARNING) << "SetClampsAction::ExecuteForProcess is not supported";
@@ -225,6 +236,29 @@ bool SetAttributeAction::ExecuteForTask(int tid) const {
     return true;
 }
 
+bool SetAttributeAction::ExecuteForUID(uid_t uid) const {
+    std::string path;
+
+    if (!attribute_->GetPathForUID(uid, &path)) {
+        LOG(ERROR) << "Failed to find cgroup for uid " << uid;
+        return false;
+    }
+
+    if (!WriteStringToFile(value_, path)) {
+        if (access(path.c_str(), F_OK) < 0) {
+            if (optional_) {
+                return true;
+            } else {
+                LOG(ERROR) << "No such cgroup attribute: " << path;
+                return false;
+            }
+        }
+        PLOG(ERROR) << "Failed to write '" << value_ << "' to " << path;
+        return false;
+    }
+    return true;
+}
+
 SetCgroupAction::SetCgroupAction(const CgroupController& c, const std::string& p)
     : controller_(c), path_(p) {
     FdCacheHelper::Init(controller_.GetTasksFilePath(path_), fd_[ProfileAction::RCT_TASK]);
@@ -552,6 +586,16 @@ bool TaskProfile::ExecuteForTask(int tid) const {
     return true;
 }
 
+bool TaskProfile::ExecuteForUID(uid_t uid) const {
+    for (const auto& element : elements_) {
+        if (!element->ExecuteForUID(uid)) {
+            LOG(VERBOSE) << "Applying profile action " << element->Name() << " failed";
+            return false;
+        }
+    }
+    return true;
+}
+
 void TaskProfile::EnableResourceCaching(ProfileAction::ResourceCacheType cache_type) {
     if (res_cached_) {
         return;
@@ -804,6 +848,24 @@ const IProfileAttribute* TaskProfiles::GetAttribute(std::string_view name) const
     return nullptr;
 }
 
+template <typename T>
+bool TaskProfiles::SetUserProfiles(uid_t uid, std::span<const T> profiles, bool use_fd_cache) {
+    for (const auto& name : profiles) {
+        TaskProfile* profile = GetProfile(name);
+        if (profile != nullptr) {
+            if (use_fd_cache) {
+                profile->EnableResourceCaching(ProfileAction::RCT_PROCESS);
+            }
+            if (!profile->ExecuteForUID(uid)) {
+                PLOG(WARNING) << "Failed to apply " << name << " process profile";
+            }
+        } else {
+            PLOG(WARNING) << "Failed to find " << name << "process profile";
+        }
+    }
+    return true;
+}
+
 template <typename T>
 bool TaskProfiles::SetProcessProfiles(uid_t uid, pid_t pid, std::span<const T> profiles,
                                       bool use_fd_cache) {
@@ -857,3 +919,5 @@ template bool TaskProfiles::SetTaskProfiles(int tid, std::span<const std::string
                                             bool use_fd_cache);
 template bool TaskProfiles::SetTaskProfiles(int tid, std::span<const std::string_view> profiles,
                                             bool use_fd_cache);
+template bool TaskProfiles::SetUserProfiles(uid_t uid, std::span<const std::string> profiles,
+                                            bool use_fd_cache);
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index 85b3f9162f7c..a8ecb873d88e 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -36,6 +36,7 @@ class IProfileAttribute {
     virtual const CgroupController* controller() const = 0;
     virtual const std::string& file_name() const = 0;
     virtual bool GetPathForTask(int tid, std::string* path) const = 0;
+    virtual bool GetPathForUID(uid_t uid, std::string* path) const = 0;
 };
 
 class ProfileAttribute : public IProfileAttribute {
@@ -53,6 +54,7 @@ class ProfileAttribute : public IProfileAttribute {
     void Reset(const CgroupController& controller, const std::string& file_name) override;
 
     bool GetPathForTask(int tid, std::string* path) const override;
+    bool GetPathForUID(uid_t uid, std::string* path) const override;
 
   private:
     CgroupController controller_;
@@ -72,6 +74,7 @@ class ProfileAction {
     // Default implementations will fail
     virtual bool ExecuteForProcess(uid_t, pid_t) const { return false; };
     virtual bool ExecuteForTask(int) const { return false; };
+    virtual bool ExecuteForUID(uid_t) const { return false; };
 
     virtual void EnableResourceCaching(ResourceCacheType) {}
     virtual void DropResourceCaching(ResourceCacheType) {}
@@ -116,6 +119,7 @@ class SetAttributeAction : public ProfileAction {
     const char* Name() const override { return "SetAttribute"; }
     bool ExecuteForProcess(uid_t uid, pid_t pid) const override;
     bool ExecuteForTask(int tid) const override;
+    bool ExecuteForUID(uid_t uid) const override;
 
   private:
     const IProfileAttribute* attribute_;
@@ -179,6 +183,7 @@ class TaskProfile {
 
     bool ExecuteForProcess(uid_t uid, pid_t pid) const;
     bool ExecuteForTask(int tid) const;
+    bool ExecuteForUID(uid_t uid) const;
     void EnableResourceCaching(ProfileAction::ResourceCacheType cache_type);
     void DropResourceCaching(ProfileAction::ResourceCacheType cache_type);
 
@@ -216,6 +221,8 @@ class TaskProfiles {
     bool SetProcessProfiles(uid_t uid, pid_t pid, std::span<const T> profiles, bool use_fd_cache);
     template <typename T>
     bool SetTaskProfiles(int tid, std::span<const T> profiles, bool use_fd_cache);
+    template <typename T>
+    bool SetUserProfiles(uid_t uid, std::span<const T> profiles, bool use_fd_cache);
 
   private:
     TaskProfiles();
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index 09ac44c6b254..aa74f9d2563e 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -121,6 +121,10 @@ class ProfileAttributeMock : public IProfileAttribute {
         return true;
     };
 
+    bool GetPathForUID(uid_t, std::string*) const override {
+        return false;
+    }
+
   private:
     const std::string file_name_;
 };

From 43a172fb1d6fbf9b92f4de8ee12b89d886cef705 Mon Sep 17 00:00:00 2001
From: Rajesh Nyamagoud <nyamagoud@google.com>
Date: Thu, 22 Sep 2022 20:25:52 +0000
Subject: [PATCH 0010/1487] Changes to adapt confirmationui AIDL spec.

Replaced HIDL spec implementation with AIDL spec in confirmationui
module.

Ignore-AOSP-First: Dependent on internal change.
Bug: b/205760172
Test: Run confirmation UI test using CTS Verifier, atest VtsHalConfirmationUITargetTest
Change-Id: I49b9cb6d93fa35fd611003f7545d2ce4976eec7c
---
 trusty/confirmationui/Android.bp              |  23 ++--
 .../confirmationui/TrustyConfirmationUI.cpp   | 124 +++++++++---------
 trusty/confirmationui/TrustyConfirmationUI.h  |  52 ++++----
 ....hardware.confirmationui-service.trusty.rc |   5 +
 ...ardware.confirmationui-service.trusty.xml} |   5 +-
 ...dware.confirmationui@1.0-service.trusty.rc |   4 -
 .../include/TrustyConfirmationuiHal.h         |  16 +--
 trusty/confirmationui/service.cpp             |  25 ++--
 8 files changed, 124 insertions(+), 130 deletions(-)
 create mode 100644 trusty/confirmationui/android.hardware.confirmationui-service.trusty.rc
 rename trusty/confirmationui/{android.hardware.confirmationui@1.0-service.trusty.xml => android.hardware.confirmationui-service.trusty.xml} (71%)
 delete mode 100644 trusty/confirmationui/android.hardware.confirmationui@1.0-service.trusty.rc

diff --git a/trusty/confirmationui/Android.bp b/trusty/confirmationui/Android.bp
index 092241528f26..29ef3c098d16 100644
--- a/trusty/confirmationui/Android.bp
+++ b/trusty/confirmationui/Android.bp
@@ -24,21 +24,23 @@ package {
 }
 
 cc_binary {
-    name: "android.hardware.confirmationui@1.0-service.trusty",
+    name: "android.hardware.confirmationui-service.trusty",
     relative_install_path: "hw",
     vendor: true,
     shared_libs: [
-        "android.hardware.confirmationui@1.0",
+        "android.hardware.confirmationui-V1-ndk",
         "android.hardware.confirmationui.not-so-secure-input",
-        "android.hardware.confirmationui@1.0-lib.trusty",
+        "android.hardware.confirmationui-lib.trusty",
+        "libbinder_ndk",
+        "libteeui_hal_support",
         "libbase",
         "libhidlbase",
         "libutils",
     ],
 
-    init_rc: ["android.hardware.confirmationui@1.0-service.trusty.rc"],
+    init_rc: ["android.hardware.confirmationui-service.trusty.rc"],
 
-    vintf_fragments: ["android.hardware.confirmationui@1.0-service.trusty.xml"],
+    vintf_fragments: ["android.hardware.confirmationui-service.trusty.xml"],
 
     srcs: [
         "service.cpp",
@@ -52,17 +54,20 @@ cc_binary {
 }
 
 cc_library {
-    name: "android.hardware.confirmationui@1.0-lib.trusty",
+    name: "android.hardware.confirmationui-lib.trusty",
+    defaults: [
+        "keymint_use_latest_hal_aidl_ndk_shared",
+    ],
     vendor: true,
     shared_libs: [
-        "android.hardware.confirmationui@1.0",
-        "android.hardware.keymaster@4.0",
+        "android.hardware.confirmationui-V1-ndk",
         "libbase",
+        "libcutils",
         "libdmabufheap",
-        "libhidlbase",
         "libteeui_hal_support",
         "libtrusty",
         "libutils",
+        "libbinder_ndk",
     ],
 
     export_include_dirs: ["include"],
diff --git a/trusty/confirmationui/TrustyConfirmationUI.cpp b/trusty/confirmationui/TrustyConfirmationUI.cpp
index c6625e0a1aa3..f01a4e1e9fee 100644
--- a/trusty/confirmationui/TrustyConfirmationUI.cpp
+++ b/trusty/confirmationui/TrustyConfirmationUI.cpp
@@ -18,8 +18,6 @@
 #include "TrustyConfirmationUI.h"
 
 #include <android-base/logging.h>
-#include <android/hardware/confirmationui/1.0/types.h>
-#include <android/hardware/keymaster/4.0/types.h>
 #include <fcntl.h>
 #include <linux/input.h>
 #include <poll.h>
@@ -42,12 +40,7 @@
 #include <tuple>
 #include <vector>
 
-namespace android {
-namespace hardware {
-namespace confirmationui {
-namespace V1_0 {
-namespace implementation {
-
+namespace aidl::android::hardware::confirmationui {
 using namespace secure_input;
 
 using ::android::trusty::confirmationui::TrustyAppError;
@@ -64,8 +57,6 @@ using ::teeui::ResultMsg;
 
 using ::secure_input::createSecureInput;
 
-using ::android::hardware::keymaster::V4_0::HardwareAuthToken;
-
 using ::std::tie;
 
 using TeeuiRc = ::teeui::ResponseCode;
@@ -87,46 +78,47 @@ class Finalize {
     void release() { f_ = {}; }
 };
 
-ResponseCode convertRc(TeeuiRc trc) {
+int convertRc(TeeuiRc trc) {
     static_assert(
-        uint32_t(TeeuiRc::OK) == uint32_t(ResponseCode::OK) &&
-            uint32_t(TeeuiRc::Canceled) == uint32_t(ResponseCode::Canceled) &&
-            uint32_t(TeeuiRc::Aborted) == uint32_t(ResponseCode::Aborted) &&
-            uint32_t(TeeuiRc::OperationPending) == uint32_t(ResponseCode::OperationPending) &&
-            uint32_t(TeeuiRc::Ignored) == uint32_t(ResponseCode::Ignored) &&
-            uint32_t(TeeuiRc::SystemError) == uint32_t(ResponseCode::SystemError) &&
-            uint32_t(TeeuiRc::Unimplemented) == uint32_t(ResponseCode::Unimplemented) &&
-            uint32_t(TeeuiRc::Unexpected) == uint32_t(ResponseCode::Unexpected) &&
-            uint32_t(TeeuiRc::UIError) == uint32_t(ResponseCode::UIError) &&
-            uint32_t(TeeuiRc::UIErrorMissingGlyph) == uint32_t(ResponseCode::UIErrorMissingGlyph) &&
+        uint32_t(TeeuiRc::OK) == uint32_t(IConfirmationUI::OK) &&
+            uint32_t(TeeuiRc::Canceled) == uint32_t(IConfirmationUI::CANCELED) &&
+            uint32_t(TeeuiRc::Aborted) == uint32_t(IConfirmationUI::ABORTED) &&
+            uint32_t(TeeuiRc::OperationPending) == uint32_t(IConfirmationUI::OPERATION_PENDING) &&
+            uint32_t(TeeuiRc::Ignored) == uint32_t(IConfirmationUI::IGNORED) &&
+            uint32_t(TeeuiRc::SystemError) == uint32_t(IConfirmationUI::SYSTEM_ERROR) &&
+            uint32_t(TeeuiRc::Unimplemented) == uint32_t(IConfirmationUI::UNIMPLEMENTED) &&
+            uint32_t(TeeuiRc::Unexpected) == uint32_t(IConfirmationUI::UNEXPECTED) &&
+            uint32_t(TeeuiRc::UIError) == uint32_t(IConfirmationUI::UI_ERROR) &&
+            uint32_t(TeeuiRc::UIErrorMissingGlyph) ==
+                uint32_t(IConfirmationUI::UI_ERROR_MISSING_GLYPH) &&
             uint32_t(TeeuiRc::UIErrorMessageTooLong) ==
-                uint32_t(ResponseCode::UIErrorMessageTooLong) &&
+                uint32_t(IConfirmationUI::UI_ERROR_MESSAGE_TOO_LONG) &&
             uint32_t(TeeuiRc::UIErrorMalformedUTF8Encoding) ==
-                uint32_t(ResponseCode::UIErrorMalformedUTF8Encoding),
+                uint32_t(IConfirmationUI::UI_ERROR_MALFORMED_UTF8ENCODING),
         "teeui::ResponseCode and "
         "::android::hardware::confirmationui::V1_0::Responsecude are out of "
         "sync");
-    return ResponseCode(trc);
+    return static_cast<int>(trc);
 }
 
 teeui::UIOption convertUIOption(UIOption uio) {
-    static_assert(uint32_t(UIOption::AccessibilityInverted) ==
+    static_assert(uint32_t(UIOption::ACCESSIBILITY_INVERTED) ==
                           uint32_t(teeui::UIOption::AccessibilityInverted) &&
-                      uint32_t(UIOption::AccessibilityMagnified) ==
+                      uint32_t(UIOption::ACCESSIBILITY_MAGNIFIED) ==
                           uint32_t(teeui::UIOption::AccessibilityMagnified),
                   "teeui::UIOPtion and ::android::hardware::confirmationui::V1_0::UIOption "
-                  "anre out of sync");
+                  "are out of sync");
     return teeui::UIOption(uio);
 }
 
-inline MsgString hidl2MsgString(const hidl_string& s) {
+inline MsgString stdString2MsgString(const string& s) {
     return {s.c_str(), s.c_str() + s.size()};
 }
-template <typename T> inline MsgVector<T> hidl2MsgVector(const hidl_vec<T>& v) {
+template <typename T> inline MsgVector<T> stdVector2MsgVector(const vector<T>& v) {
     return {v};
 }
 
-inline MsgVector<teeui::UIOption> hidl2MsgVector(const hidl_vec<UIOption>& v) {
+inline MsgVector<teeui::UIOption> stdVector2MsgVector(const vector<UIOption>& v) {
     MsgVector<teeui::UIOption> result(v.size());
     for (unsigned int i = 0; i < v.size(); ++i) {
         result[i] = convertUIOption(v[i]);
@@ -137,7 +129,7 @@ inline MsgVector<teeui::UIOption> hidl2MsgVector(const hidl_vec<UIOption>& v) {
 }  // namespace
 
 TrustyConfirmationUI::TrustyConfirmationUI()
-    : listener_state_(ListenerState::None), prompt_result_(ResponseCode::Ignored) {}
+    : listener_state_(ListenerState::None), prompt_result_(IConfirmationUI::IGNORED) {}
 
 TrustyConfirmationUI::~TrustyConfirmationUI() {
     ListenerState state = listener_state_;
@@ -385,15 +377,16 @@ TrustyConfirmationUI::promptUserConfirmation_(const MsgString& promptText,
     //  ############################## Start 4th Phase - cleanup ##################################
 }
 
-// Methods from ::android::hardware::confirmationui::V1_0::IConfirmationUI
+// Methods from ::aidl::android::hardware::confirmationui::IConfirmationUI
 // follow.
-Return<ResponseCode> TrustyConfirmationUI::promptUserConfirmation(
-    const sp<IConfirmationResultCallback>& resultCB, const hidl_string& promptText,
-    const hidl_vec<uint8_t>& extraData, const hidl_string& locale,
-    const hidl_vec<UIOption>& uiOptions) {
+::ndk::ScopedAStatus TrustyConfirmationUI::promptUserConfirmation(
+    const shared_ptr<IConfirmationResultCallback>& resultCB, const vector<uint8_t>& promptTextBytes,
+    const vector<uint8_t>& extraData, const string& locale, const vector<UIOption>& uiOptions) {
     std::unique_lock<std::mutex> stateLock(listener_state_lock_, std::defer_lock);
+    string promptText(promptTextBytes.begin(), promptTextBytes.end());
     if (!stateLock.try_lock()) {
-        return ResponseCode::OperationPending;
+        return ndk::ScopedAStatus(
+            AStatus_fromServiceSpecificError(IConfirmationUI::OPERATION_PENDING));
     }
     switch (listener_state_) {
     case ListenerState::None:
@@ -401,23 +394,25 @@ Return<ResponseCode> TrustyConfirmationUI::promptUserConfirmation(
     case ListenerState::Starting:
     case ListenerState::SetupDone:
     case ListenerState::Interactive:
-        return ResponseCode::OperationPending;
+        return ndk::ScopedAStatus(
+            AStatus_fromServiceSpecificError(IConfirmationUI::OPERATION_PENDING));
     case ListenerState::Terminating:
         callback_thread_.join();
         listener_state_ = ListenerState::None;
         break;
     default:
-        return ResponseCode::Unexpected;
+        return ndk::ScopedAStatus(AStatus_fromServiceSpecificError(IConfirmationUI::UNEXPECTED));
     }
 
     assert(listener_state_ == ListenerState::None);
 
     callback_thread_ = std::thread(
-        [this](sp<IConfirmationResultCallback> resultCB, hidl_string promptText,
-               hidl_vec<uint8_t> extraData, hidl_string locale, hidl_vec<UIOption> uiOptions) {
-            auto [trc, msg, token] =
-                promptUserConfirmation_(hidl2MsgString(promptText), hidl2MsgVector(extraData),
-                                        hidl2MsgString(locale), hidl2MsgVector(uiOptions));
+        [this](const shared_ptr<IConfirmationResultCallback>& resultCB, const string& promptText,
+               const vector<uint8_t>& extraData, const string& locale,
+               const vector<UIOption>& uiOptions) {
+            auto [trc, msg, token] = promptUserConfirmation_(
+                stdString2MsgString(promptText), stdVector2MsgVector(extraData),
+                stdString2MsgString(locale), stdVector2MsgVector(uiOptions));
             bool do_callback = (listener_state_ == ListenerState::Interactive ||
                                 listener_state_ == ListenerState::SetupDone) &&
                                resultCB;
@@ -426,7 +421,7 @@ Return<ResponseCode> TrustyConfirmationUI::promptUserConfirmation(
             if (do_callback) {
                 auto error = resultCB->result(prompt_result_, msg, token);
                 if (!error.isOk()) {
-                    LOG(ERROR) << "Result callback failed " << error.description();
+                    LOG(ERROR) << "Result callback failed " << error.getDescription();
                 }
             } else {
                 listener_state_condv_.notify_all();
@@ -442,14 +437,14 @@ Return<ResponseCode> TrustyConfirmationUI::promptUserConfirmation(
     if (listener_state_ == ListenerState::Terminating) {
         callback_thread_.join();
         listener_state_ = ListenerState::None;
-        return prompt_result_;
+        return ndk::ScopedAStatus(AStatus_fromServiceSpecificError(prompt_result_));
     }
-    return ResponseCode::OK;
+    return ndk::ScopedAStatus::ok();
 }
 
-Return<ResponseCode>
+::ndk::ScopedAStatus
 TrustyConfirmationUI::deliverSecureInputEvent(const HardwareAuthToken& secureInputToken) {
-    ResponseCode rc = ResponseCode::Ignored;
+    int rc = IConfirmationUI::IGNORED;
     {
         /*
          * deliverSecureInputEvent is only used by the VTS test to mock human input. A correct
@@ -467,13 +462,17 @@ TrustyConfirmationUI::deliverSecureInputEvent(const HardwareAuthToken& secureInp
         listener_state_condv_.wait(stateLock,
                                    [this] { return listener_state_ != ListenerState::SetupDone; });
 
-        if (listener_state_ != ListenerState::Interactive) return ResponseCode::Ignored;
+        if (listener_state_ != ListenerState::Interactive)
+            return ndk::ScopedAStatus(AStatus_fromServiceSpecificError(IConfirmationUI::IGNORED));
         auto sapp = app_.lock();
-        if (!sapp) return ResponseCode::Ignored;
+        if (!sapp)
+            return ndk::ScopedAStatus(AStatus_fromServiceSpecificError(IConfirmationUI::IGNORED));
         auto [error, response] =
             sapp->issueCmd<DeliverTestCommandMessage, DeliverTestCommandResponse>(
                 static_cast<teeui::TestModeCommands>(secureInputToken.challenge));
-        if (error != TrustyAppError::OK) return ResponseCode::SystemError;
+        if (error != TrustyAppError::OK)
+            return ndk::ScopedAStatus(
+                AStatus_fromServiceSpecificError(IConfirmationUI::SYSTEM_ERROR));
         auto& [trc] = response;
         if (trc != TeeuiRc::Ignored) secureInputDelivered_ = true;
         rc = convertRc(trc);
@@ -484,11 +483,14 @@ TrustyConfirmationUI::deliverSecureInputEvent(const HardwareAuthToken& secureInp
     // Canceled into OK. Canceled is only returned if the delivered event canceled
     // the operation, which means that the event was successfully delivered. Thus
     // we return OK.
-    if (rc == ResponseCode::Canceled) return ResponseCode::OK;
-    return rc;
+    if (rc == IConfirmationUI::CANCELED) return ndk::ScopedAStatus::ok();
+    if (rc != IConfirmationUI::OK) {
+        return ndk::ScopedAStatus(AStatus_fromServiceSpecificError(rc));
+    }
+    return ndk::ScopedAStatus::ok();
 }
 
-Return<void> TrustyConfirmationUI::abort() {
+::ndk::ScopedAStatus TrustyConfirmationUI::abort() {
     {
         std::unique_lock<std::mutex> stateLock(listener_state_lock_);
         if (listener_state_ == ListenerState::SetupDone ||
@@ -499,15 +501,11 @@ Return<void> TrustyConfirmationUI::abort() {
         }
     }
     listener_state_condv_.notify_all();
-    return Void();
+    return ndk::ScopedAStatus::ok();
 }
 
-android::sp<IConfirmationUI> createTrustyConfirmationUI() {
-    return new TrustyConfirmationUI();
+std::shared_ptr<IConfirmationUI> createTrustyConfirmationUI() {
+    return ndk::SharedRefBase::make<TrustyConfirmationUI>();
 }
 
-}  // namespace implementation
-}  // namespace V1_0
-}  // namespace confirmationui
-}  // namespace hardware
-}  // namespace android
+}  // namespace aidl::android::hardware::confirmationui
diff --git a/trusty/confirmationui/TrustyConfirmationUI.h b/trusty/confirmationui/TrustyConfirmationUI.h
index 0bd703c9fd36..6e85704b61c7 100644
--- a/trusty/confirmationui/TrustyConfirmationUI.h
+++ b/trusty/confirmationui/TrustyConfirmationUI.h
@@ -17,9 +17,11 @@
 #ifndef ANDROID_HARDWARE_CONFIRMATIONUI_V1_0_TRUSTY_CONFIRMATIONUI_H
 #define ANDROID_HARDWARE_CONFIRMATIONUI_V1_0_TRUSTY_CONFIRMATIONUI_H
 
-#include <android/hardware/confirmationui/1.0/IConfirmationUI.h>
-#include <android/hardware/keymaster/4.0/types.h>
-#include <hidl/Status.h>
+#include <aidl/android/hardware/confirmationui/BnConfirmationUI.h>
+#include <aidl/android/hardware/confirmationui/IConfirmationResultCallback.h>
+#include <aidl/android/hardware/confirmationui/UIOption.h>
+#include <aidl/android/hardware/security/keymint/HardwareAuthToken.h>
+#include <android/binder_manager.h>
 
 #include <atomic>
 #include <condition_variable>
@@ -30,35 +32,29 @@
 
 #include "TrustyApp.h"
 
-namespace android {
-namespace hardware {
-namespace confirmationui {
-namespace V1_0 {
-namespace implementation {
+namespace aidl::android::hardware::confirmationui {
 
-using ::android::sp;
-using ::android::hardware::hidl_array;
-using ::android::hardware::hidl_string;
-using ::android::hardware::hidl_vec;
-using ::android::hardware::Return;
-using ::android::hardware::Void;
+using std::shared_ptr;
+using std::string;
+using std::vector;
 
+using ::aidl::android::hardware::security::keymint::HardwareAuthToken;
 using ::android::trusty::confirmationui::TrustyApp;
 
-class TrustyConfirmationUI : public IConfirmationUI {
+class TrustyConfirmationUI : public BnConfirmationUI {
   public:
     TrustyConfirmationUI();
     virtual ~TrustyConfirmationUI();
-    // Methods from ::android::hardware::confirmationui::V1_0::IConfirmationUI
+    // Methods from ::aidl::android::hardware::confirmationui::IConfirmationUI
     // follow.
-    Return<ResponseCode> promptUserConfirmation(const sp<IConfirmationResultCallback>& resultCB,
-                                                const hidl_string& promptText,
-                                                const hidl_vec<uint8_t>& extraData,
-                                                const hidl_string& locale,
-                                                const hidl_vec<UIOption>& uiOptions) override;
-    Return<ResponseCode> deliverSecureInputEvent(
-        const ::android::hardware::keymaster::V4_0::HardwareAuthToken& secureInputToken) override;
-    Return<void> abort() override;
+    ::ndk::ScopedAStatus
+    promptUserConfirmation(const shared_ptr<IConfirmationResultCallback>& resultCB,
+                           const vector<uint8_t>& promptText, const vector<uint8_t>& extraData,
+                           const string& locale, const vector<UIOption>& uiOptions) override;
+    ::ndk::ScopedAStatus
+    deliverSecureInputEvent(const HardwareAuthToken& secureInputToken) override;
+
+    ::ndk::ScopedAStatus abort() override;
 
   private:
     std::weak_ptr<TrustyApp> app_;
@@ -85,7 +81,7 @@ class TrustyConfirmationUI : public IConfirmationUI {
     bool abort_called_;
     std::mutex listener_state_lock_;
     std::condition_variable listener_state_condv_;
-    ResponseCode prompt_result_;
+    int prompt_result_;
     bool secureInputDelivered_;
 
     std::tuple<teeui::ResponseCode, teeui::MsgVector<uint8_t>, teeui::MsgVector<uint8_t>>
@@ -95,10 +91,6 @@ class TrustyConfirmationUI : public IConfirmationUI {
                             const teeui::MsgVector<teeui::UIOption>& uiOptions);
 };
 
-}  // namespace implementation
-}  // namespace V1_0
-}  // namespace confirmationui
-}  // namespace hardware
-}  // namespace android
+}  // namespace aidl::android::hardware::confirmationui
 
 #endif  // ANDROID_HARDWARE_CONFIRMATIONUI_V1_0_TRUSTY_CONFIRMATIONUI_H
diff --git a/trusty/confirmationui/android.hardware.confirmationui-service.trusty.rc b/trusty/confirmationui/android.hardware.confirmationui-service.trusty.rc
new file mode 100644
index 000000000000..b5c315986747
--- /dev/null
+++ b/trusty/confirmationui/android.hardware.confirmationui-service.trusty.rc
@@ -0,0 +1,5 @@
+service vendor.confirmationui_default /vendor/bin/hw/android.hardware.confirmationui-service.trusty
+    interface aidl android.hardware.confirmationui.IConfirmationUI/default
+    class hal
+    user system
+    group drmrpc input system
diff --git a/trusty/confirmationui/android.hardware.confirmationui@1.0-service.trusty.xml b/trusty/confirmationui/android.hardware.confirmationui-service.trusty.xml
similarity index 71%
rename from trusty/confirmationui/android.hardware.confirmationui@1.0-service.trusty.xml
rename to trusty/confirmationui/android.hardware.confirmationui-service.trusty.xml
index 9008b872e68e..afa2e8e66e89 100644
--- a/trusty/confirmationui/android.hardware.confirmationui@1.0-service.trusty.xml
+++ b/trusty/confirmationui/android.hardware.confirmationui-service.trusty.xml
@@ -1,8 +1,7 @@
 <manifest version="1.0" type="device">
-    <hal format="hidl">
+    <hal format="aidl">
         <name>android.hardware.confirmationui</name>
-        <transport>hwbinder</transport>
-        <version>1.0</version>
+        <version>1</version>
         <interface>
         <name>IConfirmationUI</name>
             <instance>default</instance>
diff --git a/trusty/confirmationui/android.hardware.confirmationui@1.0-service.trusty.rc b/trusty/confirmationui/android.hardware.confirmationui@1.0-service.trusty.rc
deleted file mode 100644
index 3ba6fc04b9b3..000000000000
--- a/trusty/confirmationui/android.hardware.confirmationui@1.0-service.trusty.rc
+++ /dev/null
@@ -1,4 +0,0 @@
-service confirmationui-1-0 /vendor/bin/hw/android.hardware.confirmationui@1.0-service.trusty
-    class hal
-    user system
-    group drmrpc input system
diff --git a/trusty/confirmationui/include/TrustyConfirmationuiHal.h b/trusty/confirmationui/include/TrustyConfirmationuiHal.h
index 2ab9389b1b72..8000ee2f0678 100644
--- a/trusty/confirmationui/include/TrustyConfirmationuiHal.h
+++ b/trusty/confirmationui/include/TrustyConfirmationuiHal.h
@@ -16,18 +16,10 @@
 
 #pragma once
 
-#include <android/hardware/confirmationui/1.0/IConfirmationUI.h>
+#include <aidl/android/hardware/confirmationui/IConfirmationUI.h>
 
-namespace android {
-namespace hardware {
-namespace confirmationui {
-namespace V1_0 {
-namespace implementation {
+namespace aidl::android::hardware::confirmationui {
 
-android::sp<IConfirmationUI> createTrustyConfirmationUI();
+std::shared_ptr<IConfirmationUI> createTrustyConfirmationUI();
 
-}  // namespace implementation
-}  // namespace V1_0
-}  // namespace confirmationui
-}  // namespace hardware
-}  // namespace android
+}  // namespace aidl::android::hardware::confirmationui
diff --git a/trusty/confirmationui/service.cpp b/trusty/confirmationui/service.cpp
index dd7e84b444fd..b286c0a985ab 100644
--- a/trusty/confirmationui/service.cpp
+++ b/trusty/confirmationui/service.cpp
@@ -15,21 +15,28 @@
  */
 
 #include <android-base/logging.h>
-#include <hidl/HidlTransportSupport.h>
+#include <android/binder_manager.h>
+#include <android/binder_process.h>
 
 #include <TrustyConfirmationuiHal.h>
 
-using android::sp;
-using android::hardware::confirmationui::V1_0::implementation::createTrustyConfirmationUI;
+using ::aidl::android::hardware::confirmationui::createTrustyConfirmationUI;
+using ::aidl::android::hardware::confirmationui::IConfirmationUI;
 
 int main() {
-    ::android::hardware::configureRpcThreadpool(1, true /*willJoinThreadpool*/);
-    auto service = createTrustyConfirmationUI();
-    auto status = service->registerAsService();
-    if (status != android::OK) {
-        LOG(FATAL) << "Could not register service for ConfirmationUI 1.0 (" << status << ")";
+    ABinderProcess_setThreadPoolMaxThreadCount(0);
+
+    auto confirmationui = createTrustyConfirmationUI();
+
+    const auto instance = std::string(IConfirmationUI::descriptor) + "/default";
+    binder_status_t status =
+        AServiceManager_addService(confirmationui->asBinder().get(), instance.c_str());
+
+    if (status != STATUS_OK) {
+        LOG(FATAL) << "Could not register service for " << instance.c_str() << "(" << status << ")";
         return -1;
     }
-    ::android::hardware::joinRpcThreadpool();
+
+    ABinderProcess_joinThreadPool();
     return -1;
 }

From 23d35bbfafc784a7dfe686e7954a53cac60caf2b Mon Sep 17 00:00:00 2001
From: Wayne Ma <waynema@google.com>
Date: Wed, 28 Sep 2022 15:23:04 +0800
Subject: [PATCH 0011/1487] Make libstatspull_bindgen available to resolv apex.

Test: m successed
Change-Id: Ia367ab5a87794c82238291b27a783278f319e767
(cherry picked from commit 8044045a1ecf2afae948a9877341b1ea372f2a80)
Merged-In: Ia367ab5a87794c82238291b27a783278f319e767
---
 libstats/pull_rust/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libstats/pull_rust/Android.bp b/libstats/pull_rust/Android.bp
index 4ffa98d1446f..cc9f5b4cf5a9 100644
--- a/libstats/pull_rust/Android.bp
+++ b/libstats/pull_rust/Android.bp
@@ -47,6 +47,7 @@ rust_bindgen {
     min_sdk_version: "apex_inherit",
     apex_available: [
         "//apex_available:platform",
+        "com.android.resolv",
         "com.android.virt",
     ]
 }

From b5f75c4ecbcfeff6f4bc78b8d24e638b51339e51 Mon Sep 17 00:00:00 2001
From: Seth Moore <sethmo@google.com>
Date: Wed, 2 Nov 2022 21:41:58 -0700
Subject: [PATCH 0012/1487] Add dependency on split out RKP HAL

Bug: 254112961
Test: N/A
Ignore-AOSP-First: need to fix internal-only dependencies first
Change-Id: Ia13374cbc4f29964d91da3ce31d5fffa4d54d5ce
---
 trusty/keymaster/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/trusty/keymaster/Android.bp b/trusty/keymaster/Android.bp
index adc9fdffb72d..31f0a7224998 100644
--- a/trusty/keymaster/Android.bp
+++ b/trusty/keymaster/Android.bp
@@ -109,6 +109,7 @@ cc_binary {
         "keymint_use_latest_hal_aidl_ndk_shared",
     ],
     shared_libs: [
+        "android.hardware.security.rkp-V3-ndk",
         "android.hardware.security.secureclock-V1-ndk",
         "android.hardware.security.sharedsecret-V1-ndk",
         "lib_android_keymaster_keymint_utils",

From 9d99701bead30ffc6a9849fb33024680082ca782 Mon Sep 17 00:00:00 2001
From: Seth Moore <sethmo@google.com>
Date: Fri, 4 Nov 2022 16:40:46 +0000
Subject: [PATCH 0013/1487] Revert "Add dependency on split out RKP HAL"

Revert "Add dependency on split out RKP HAL"

Revert "Split rkp from keymint."

Revert "Add dependency on newly-split RKP HAL"

Revert "Add dependencies on newly-split RKP HAL"

Revert "Add dependency on split out RKP HAL"

Revert submission 20364235-split-rkp-aidl

Reason for revert: Build break in android.hardware.identity-api
Reverted Changes:
Ib86454bbb:Update dependencies on HAL types moved from keymin...
I501c967e2:Add dependencies on newly-split RKP HAL
I08560f9af:Add dependency on split out RKP HAL
I87133e385:Add dependency on split out RKP HAL
Ia13374cbc:Add dependency on split out RKP HAL
I72bc1774c:Add dependency on newly-split RKP HAL
I71ac265e3:Add dependency on newly-split RKP HAL
Ie0e17bb2c:Update the RKP aidl dependency
I5d24f47ce:Update README and CHANGELOG for RKP
I4b2498dd1:Split rkp from keymint.
I266009d75:Add dependency on newly-split rkp HAL

Change-Id: Ibac15817a4d2170e4c8c36956d7be1ad0f3cb8a8
---
 trusty/keymaster/Android.bp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/trusty/keymaster/Android.bp b/trusty/keymaster/Android.bp
index 31f0a7224998..adc9fdffb72d 100644
--- a/trusty/keymaster/Android.bp
+++ b/trusty/keymaster/Android.bp
@@ -109,7 +109,6 @@ cc_binary {
         "keymint_use_latest_hal_aidl_ndk_shared",
     ],
     shared_libs: [
-        "android.hardware.security.rkp-V3-ndk",
         "android.hardware.security.secureclock-V1-ndk",
         "android.hardware.security.sharedsecret-V1-ndk",
         "lib_android_keymaster_keymint_utils",

From 681abb61a2ad8b626019b8c117055856019e8a1d Mon Sep 17 00:00:00 2001
From: Seth Moore <sethmo@google.com>
Date: Fri, 4 Nov 2022 17:39:05 +0000
Subject: [PATCH 0014/1487] Revert^2 "Add dependency on split out RKP HAL"

9d99701bead30ffc6a9849fb33024680082ca782

Change-Id: I9dcb9b94b0e22466cd42592f4921eec3e4fcb13d
---
 trusty/keymaster/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/trusty/keymaster/Android.bp b/trusty/keymaster/Android.bp
index adc9fdffb72d..31f0a7224998 100644
--- a/trusty/keymaster/Android.bp
+++ b/trusty/keymaster/Android.bp
@@ -109,6 +109,7 @@ cc_binary {
         "keymint_use_latest_hal_aidl_ndk_shared",
     ],
     shared_libs: [
+        "android.hardware.security.rkp-V3-ndk",
         "android.hardware.security.secureclock-V1-ndk",
         "android.hardware.security.sharedsecret-V1-ndk",
         "lib_android_keymaster_keymint_utils",

From ecfbf9c6f48915b76a62c2668137a985e04d1436 Mon Sep 17 00:00:00 2001
From: Jiakai Zhang <jiakaiz@google.com>
Date: Tue, 6 Dec 2022 15:42:48 +0000
Subject: [PATCH 0015/1487] Add task profile "Dex2OatBackground".

Bug: 261557677
Test: Presubmit
Ignore-AOSP-First: Will cherry-pick as soon as the CL is merged.
Change-Id: I33f4d1d2270da82cf90a772ef52b450bcecafec2
---
 libprocessgroup/profiles/task_profiles.json | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 15f95fcff3fb..39c124e94f4c 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -805,6 +805,10 @@
       "Name": "Dex2OatBootComplete",
       "Profiles": [ "Dex2oatPerformance", "LowIoPriority", "TimerSlackHigh" ]
     },
+    {
+      "Name": "Dex2OatBootBackground",
+      "Profiles": [ "Dex2OatBootComplete" ]
+    },
     {
       "Name": "OtaProfiles",
       "Profiles": [ "ServiceCapacityLow", "LowIoPriority", "HighEnergySaving" ]

From ab9b5df4b84d83426006d1e84b0c361ae8c9b18e Mon Sep 17 00:00:00 2001
From: Zhi Dou <zhidou@google.com>
Date: Fri, 9 Dec 2022 22:30:57 +0000
Subject: [PATCH 0016/1487] Replace "apex_inherit" min_sdk_version

Replace "apex_inherit" min_sdk_version to a conditional setting. If
environment veriable KEEP_APEX_INHERIT is set, using "apex_inherit" as
the min_sdk_version, otherwise set the number to "29". For more detail
please refer
https://docs.google.com/document/d/1R2vZw0cQa-haAMgFyQ682uSq9aGBNQrzMHKIsU17-XY/edit?usp=sharing&resourcekey=0-gUbs463r9LCKs7vdP_Xkmg

Test: build APEX uses this library, and presubmit
Bug: 254634795
Ignore-AOSP-First: Need to submit with other changes.
Change-Id: Ie6984128e6b84ba73de3f4c08eca5560657c5ca2
---
 libutils/Android.bp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/libutils/Android.bp b/libutils/Android.bp
index af4a3dc5d565..d77efd6dfb6a 100644
--- a/libutils/Android.bp
+++ b/libutils/Android.bp
@@ -21,11 +21,13 @@ cc_library_headers {
     vendor_ramdisk_available: true,
     host_supported: true,
     native_bridge_supported: true,
+    defaults: [
+        "apex-lowest-min-sdk-version",
+    ],
     apex_available: [
         "//apex_available:platform",
         "//apex_available:anyapex",
     ],
-    min_sdk_version: "apex_inherit",
 
     header_libs: [
         "libbase_headers",
@@ -124,7 +126,10 @@ cc_defaults {
 
 cc_defaults {
     name: "libutils_impl_defaults",
-    defaults: ["libutils_defaults"],
+    defaults: [
+        "libutils_defaults",
+        "apex-lowest-min-sdk-version",
+    ],
     native_bridge_supported: true,
 
     srcs: [
@@ -167,7 +172,6 @@ cc_defaults {
         "//apex_available:anyapex",
         "//apex_available:platform",
     ],
-    min_sdk_version: "apex_inherit",
 
     afdo: true,
 }

From 473f03bfd9497abe614ea34d96c8b6305c31a1ff Mon Sep 17 00:00:00 2001
From: Jiakai Zhang <jiakaiz@google.com>
Date: Fri, 9 Dec 2022 23:50:58 +0000
Subject: [PATCH 0017/1487] Rename "Dex2OatBootBackground" to
 "Dex2OatBackground".

Bug: 261557677
Change-Id: I52e778d13cffcae4212acb05ef2bd62b827fbaf3
Test: Presubmit
Ignore-AOSP-First: Will cherry-pick as soon as the CL is merged.
---
 libprocessgroup/profiles/task_profiles.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 39c124e94f4c..c485097882fc 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -806,7 +806,7 @@
       "Profiles": [ "Dex2oatPerformance", "LowIoPriority", "TimerSlackHigh" ]
     },
     {
-      "Name": "Dex2OatBootBackground",
+      "Name": "Dex2OatBackground",
       "Profiles": [ "Dex2OatBootComplete" ]
     },
     {

From 8ef2a47c0aae39188d40e6c1936b6dd03776fa7d Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 23 Mar 2022 18:40:02 +0000
Subject: [PATCH 0018/1487] snapuserd: Update verification

Initiate update verification from daemon. This will help
in two ways:

1: We avoid reading everything into page-cache. Since,
low end devices are already short on memory, we don't
want to read and populate page-cache which can slow
down boot.

2: During boot, once the selinux transition is done, daemon
is all ready to kick off the verification since verity is
already setup. Note that we are still guarded by update_verifier.
Update_verifier will still block marking new slot as
boot success until the verification is completed. So, there
is no change in the behavior.

Bug: 193863442
Bug: 261913544
Test: Full and incremental OTA on Pixel 6

Incremental OTA of 500M (Monthly OTA)

Boot-time (Without this patch): 38 seconds
Boot-time (With this patch): 32 seconds

Full OTA of 2.2G:

Boot-time (Without this patch): 27 seconds
Boot-time (With this patch): 21 seconds

Signed-off-by: Akilesh Kailash <akailash@google.com>
Merged-In: I4f17db19bdd0dd261902c670be6212862d861fe1
Change-Id: I4f17db19bdd0dd261902c670be6212862d861fe1
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   7 +
 .../include/snapuserd/snapuserd_client.h      |   4 +
 .../snapuserd/snapuserd_client.cpp            |  10 +
 .../user-space-merge/snapuserd_core.cpp       | 242 +-----------------
 .../user-space-merge/snapuserd_core.h         |  45 +++-
 .../user-space-merge/snapuserd_server.cpp     |  26 ++
 .../user-space-merge/snapuserd_server.h       |   3 +
 .../user-space-merge/snapuserd_verify.cpp     | 222 ++++++++++++++++
 8 files changed, 320 insertions(+), 239 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index bc2bcebbf2d5..d751fb88f875 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -47,6 +47,7 @@ cc_library_static {
         "libbase",
         "liblog",
     ],
+    export_include_dirs: ["include"],
     ramdisk_available: true,
 }
 
@@ -68,6 +69,7 @@ cc_defaults {
         "user-space-merge/snapuserd_readahead.cpp",
         "user-space-merge/snapuserd_transitions.cpp",
         "user-space-merge/snapuserd_server.cpp",
+        "user-space-merge/snapuserd_verify.cpp",
     ],
 
     cflags: [
@@ -88,6 +90,11 @@ cc_defaults {
         "libext4_utils",
         "liburing",
     ],
+
+    header_libs: [
+        "libstorage_literals_headers",
+    ],
+
     include_dirs: ["bionic/libc/kernel"],
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h
index cebda1ccb0d4..9a69d588cf32 100644
--- a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h
@@ -89,6 +89,10 @@ class SnapuserdClient {
 
     // Return the status of the snapshot
     std::string QuerySnapshotStatus(const std::string& misc_name);
+
+    // Check the update verification status - invoked by update_verifier during
+    // boot
+    bool QueryUpdateVerification();
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
index 7b1c7a3a662a..e08cf9b590ed 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
@@ -269,5 +269,15 @@ std::string SnapuserdClient::QuerySnapshotStatus(const std::string& misc_name) {
     return Receivemsg();
 }
 
+bool SnapuserdClient::QueryUpdateVerification() {
+    std::string msg = "update-verify";
+    if (!Sendmsg(msg)) {
+        LOG(ERROR) << "Failed to send message " << msg << " to snapuserd";
+        return false;
+    }
+    std::string response = Receivemsg();
+    return response == "success";
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 718c13ce0b40..8939b786c28c 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -18,6 +18,7 @@
 
 #include <sys/utsname.h>
 
+#include <android-base/chrono_utils.h>
 #include <android-base/properties.h>
 #include <android-base/scopeguard.h>
 #include <android-base/strings.h>
@@ -70,6 +71,9 @@ bool SnapshotHandler::InitializeWorkers() {
 
     read_ahead_thread_ = std::make_unique<ReadAhead>(cow_device_, backing_store_device_, misc_name_,
                                                      GetSharedPtr());
+
+    update_verify_ = std::make_unique<UpdateVerify>(misc_name_);
+
     return true;
 }
 
@@ -307,206 +311,6 @@ bool SnapshotHandler::InitCowDevice() {
     return ReadMetadata();
 }
 
-void SnapshotHandler::FinalizeIouring() {
-    io_uring_queue_exit(ring_.get());
-}
-
-bool SnapshotHandler::InitializeIouring(int io_depth) {
-    ring_ = std::make_unique<struct io_uring>();
-
-    int ret = io_uring_queue_init(io_depth, ring_.get(), 0);
-    if (ret) {
-        LOG(ERROR) << "io_uring_queue_init failed with ret: " << ret;
-        return false;
-    }
-
-    LOG(INFO) << "io_uring_queue_init success with io_depth: " << io_depth;
-    return true;
-}
-
-bool SnapshotHandler::ReadBlocksAsync(const std::string& dm_block_device,
-                                      const std::string& partition_name, size_t size) {
-    // 64k block size with io_depth of 64 is optimal
-    // for a single thread. We just need a single thread
-    // to read all the blocks from all dynamic partitions.
-    size_t io_depth = 64;
-    size_t bs = (64 * 1024);
-
-    if (!InitializeIouring(io_depth)) {
-        return false;
-    }
-
-    LOG(INFO) << "ReadBlockAsync start "
-              << " Block-device: " << dm_block_device << " Partition-name: " << partition_name
-              << " Size: " << size;
-
-    auto scope_guard = android::base::make_scope_guard([this]() -> void { FinalizeIouring(); });
-
-    std::vector<std::unique_ptr<struct iovec>> vecs;
-    using AlignedBuf = std::unique_ptr<void, decltype(free)*>;
-    std::vector<AlignedBuf> alignedBufVector;
-
-    /*
-     * TODO: We need aligned memory for DIRECT-IO. However, if we do
-     * a DIRECT-IO and verify the blocks then we need to inform
-     * update-verifier that block verification has been done and
-     * there is no need to repeat the same. We are not there yet
-     * as we need to see if there are any boot time improvements doing
-     * a DIRECT-IO.
-     *
-     * Also, we could you the same function post merge for block verification;
-     * again, we can do a DIRECT-IO instead of thrashing page-cache and
-     * hurting other applications.
-     *
-     * For now, we will just create aligned buffers but rely on buffered
-     * I/O until we have perf numbers to justify DIRECT-IO.
-     */
-    for (int i = 0; i < io_depth; i++) {
-        auto iovec = std::make_unique<struct iovec>();
-        vecs.push_back(std::move(iovec));
-
-        struct iovec* iovec_ptr = vecs[i].get();
-
-        if (posix_memalign(&iovec_ptr->iov_base, BLOCK_SZ, bs)) {
-            LOG(ERROR) << "posix_memalign failed";
-            return false;
-        }
-
-        iovec_ptr->iov_len = bs;
-        alignedBufVector.push_back(
-                std::unique_ptr<void, decltype(free)*>(iovec_ptr->iov_base, free));
-    }
-
-    android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(dm_block_device.c_str(), O_RDONLY)));
-    if (fd.get() == -1) {
-        SNAP_PLOG(ERROR) << "File open failed - block-device " << dm_block_device
-                         << " partition-name: " << partition_name;
-        return false;
-    }
-
-    loff_t offset = 0;
-    size_t remain = size;
-    size_t read_sz = io_depth * bs;
-
-    while (remain > 0) {
-        size_t to_read = std::min(remain, read_sz);
-        size_t queue_size = to_read / bs;
-
-        for (int i = 0; i < queue_size; i++) {
-            struct io_uring_sqe* sqe = io_uring_get_sqe(ring_.get());
-            if (!sqe) {
-                SNAP_LOG(ERROR) << "io_uring_get_sqe() failed";
-                return false;
-            }
-
-            struct iovec* iovec_ptr = vecs[i].get();
-
-            io_uring_prep_read(sqe, fd.get(), iovec_ptr->iov_base, iovec_ptr->iov_len, offset);
-            sqe->flags |= IOSQE_ASYNC;
-            offset += bs;
-        }
-
-        int ret = io_uring_submit(ring_.get());
-        if (ret != queue_size) {
-            SNAP_LOG(ERROR) << "submit got: " << ret << " wanted: " << queue_size;
-            return false;
-        }
-
-        for (int i = 0; i < queue_size; i++) {
-            struct io_uring_cqe* cqe;
-
-            int ret = io_uring_wait_cqe(ring_.get(), &cqe);
-            if (ret) {
-                SNAP_PLOG(ERROR) << "wait_cqe failed" << ret;
-                return false;
-            }
-
-            if (cqe->res < 0) {
-                SNAP_LOG(ERROR) << "io failed with res: " << cqe->res;
-                return false;
-            }
-            io_uring_cqe_seen(ring_.get(), cqe);
-        }
-
-        remain -= to_read;
-    }
-
-    LOG(INFO) << "ReadBlockAsync complete: "
-              << " Block-device: " << dm_block_device << " Partition-name: " << partition_name
-              << " Size: " << size;
-    return true;
-}
-
-void SnapshotHandler::ReadBlocksToCache(const std::string& dm_block_device,
-                                        const std::string& partition_name, off_t offset,
-                                        size_t size) {
-    android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(dm_block_device.c_str(), O_RDONLY)));
-    if (fd.get() == -1) {
-        SNAP_PLOG(ERROR) << "Error reading " << dm_block_device
-                         << " partition-name: " << partition_name;
-        return;
-    }
-
-    size_t remain = size;
-    off_t file_offset = offset;
-    // We pick 4M I/O size based on the fact that the current
-    // update_verifier has a similar I/O size.
-    size_t read_sz = 1024 * BLOCK_SZ;
-    std::vector<uint8_t> buf(read_sz);
-
-    while (remain > 0) {
-        size_t to_read = std::min(remain, read_sz);
-
-        if (!android::base::ReadFullyAtOffset(fd.get(), buf.data(), to_read, file_offset)) {
-            SNAP_PLOG(ERROR) << "Failed to read block from block device: " << dm_block_device
-                             << " at offset: " << file_offset
-                             << " partition-name: " << partition_name << " total-size: " << size
-                             << " remain_size: " << remain;
-            return;
-        }
-
-        file_offset += to_read;
-        remain -= to_read;
-    }
-
-    SNAP_LOG(INFO) << "Finished reading block-device: " << dm_block_device
-                   << " partition: " << partition_name << " size: " << size
-                   << " offset: " << offset;
-}
-
-void SnapshotHandler::ReadBlocks(const std::string partition_name,
-                                 const std::string& dm_block_device) {
-    SNAP_LOG(DEBUG) << "Reading partition: " << partition_name
-                    << " Block-Device: " << dm_block_device;
-
-    uint64_t dev_sz = 0;
-
-    unique_fd fd(TEMP_FAILURE_RETRY(open(dm_block_device.c_str(), O_RDONLY | O_CLOEXEC)));
-    if (fd < 0) {
-        SNAP_LOG(ERROR) << "Cannot open block device";
-        return;
-    }
-
-    dev_sz = get_block_device_size(fd.get());
-    if (!dev_sz) {
-        SNAP_PLOG(ERROR) << "Could not determine block device size: " << dm_block_device;
-        return;
-    }
-
-    int num_threads = 2;
-    size_t num_blocks = dev_sz >> BLOCK_SHIFT;
-    size_t num_blocks_per_thread = num_blocks / num_threads;
-    size_t read_sz_per_thread = num_blocks_per_thread << BLOCK_SHIFT;
-    off_t offset = 0;
-
-    for (int i = 0; i < num_threads; i++) {
-        std::async(std::launch::async, &SnapshotHandler::ReadBlocksToCache, this, dm_block_device,
-                   partition_name, offset, read_sz_per_thread);
-
-        offset += read_sz_per_thread;
-    }
-}
-
 /*
  * Entry point to launch threads
  */
@@ -527,42 +331,22 @@ bool SnapshotHandler::Start() {
                 std::async(std::launch::async, &Worker::RunThread, worker_threads_[i].get()));
     }
 
-    bool second_stage_init = true;
+    bool partition_verification = true;
 
-    // We don't want to read the blocks during first stage init.
+    // We don't want to read the blocks during first stage init or
+    // during post-install phase.
     if (android::base::EndsWith(misc_name_, "-init") || is_socket_present_) {
-        second_stage_init = false;
-    }
-
-    if (second_stage_init) {
-        SNAP_LOG(INFO) << "Reading blocks to cache....";
-        auto& dm = DeviceMapper::Instance();
-        auto dm_block_devices = dm.FindDmPartitions();
-        if (dm_block_devices.empty()) {
-            SNAP_LOG(ERROR) << "No dm-enabled block device is found.";
-        } else {
-            auto parts = android::base::Split(misc_name_, "-");
-            std::string partition_name = parts[0];
-
-            const char* suffix_b = "_b";
-            const char* suffix_a = "_a";
-
-            partition_name.erase(partition_name.find_last_not_of(suffix_b) + 1);
-            partition_name.erase(partition_name.find_last_not_of(suffix_a) + 1);
-
-            if (dm_block_devices.find(partition_name) == dm_block_devices.end()) {
-                SNAP_LOG(ERROR) << "Failed to find dm block device for " << partition_name;
-            } else {
-                ReadBlocks(partition_name, dm_block_devices.at(partition_name));
-            }
-        }
-    } else {
-        SNAP_LOG(INFO) << "Not reading block device into cache";
+        partition_verification = false;
     }
 
     std::future<bool> merge_thread =
             std::async(std::launch::async, &Worker::RunMergeThread, merge_thread_.get());
 
+    // Now that the worker threads are up, scan the partitions.
+    if (partition_verification) {
+        update_verify_->VerifyUpdatePartition();
+    }
+
     bool ret = true;
     for (auto& t : threads) {
         ret = t.get() && ret;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index c6805e5d9434..42237ef602c0 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -45,12 +45,14 @@
 #include <liburing.h>
 #include <snapuserd/snapuserd_buffer.h>
 #include <snapuserd/snapuserd_kernel.h>
+#include <storage_literals/storage_literals.h>
 
 namespace android {
 namespace snapshot {
 
 using android::base::unique_fd;
 using namespace std::chrono_literals;
+using namespace android::storage_literals;
 
 static constexpr size_t PAYLOAD_BUFFER_SZ = (1UL << 20);
 static_assert(PAYLOAD_BUFFER_SZ >= BLOCK_SZ);
@@ -170,6 +172,36 @@ class ReadAhead {
     std::unique_ptr<struct io_uring> ring_;
 };
 
+class UpdateVerify {
+  public:
+    UpdateVerify(const std::string& misc_name);
+    void VerifyUpdatePartition();
+    bool CheckPartitionVerification();
+
+  private:
+    enum class UpdateVerifyState {
+        VERIFY_UNKNOWN,
+        VERIFY_FAILED,
+        VERIFY_SUCCESS,
+    };
+
+    std::string misc_name_;
+    UpdateVerifyState state_;
+    std::mutex m_lock_;
+    std::condition_variable m_cv_;
+
+    int kMinThreadsToVerify = 1;
+    int kMaxThreadsToVerify = 4;
+    uint64_t kThresholdSize = 512_MiB;
+    uint64_t kBlockSizeVerify = 1_MiB;
+
+    bool IsBlockAligned(uint64_t read_size) { return ((read_size & (BLOCK_SZ - 1)) == 0); }
+    void UpdatePartitionVerificationState(UpdateVerifyState state);
+    bool VerifyPartition(const std::string& partition_name, const std::string& dm_block_device);
+    bool VerifyBlocks(const std::string& partition_name, const std::string& dm_block_device,
+                      off_t offset, int skip_blocks, uint64_t dev_sz);
+};
+
 class Worker {
   public:
     Worker(const std::string& cow_device, const std::string& backing_device,
@@ -352,24 +384,16 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     MERGE_GROUP_STATE ProcessMergingBlock(uint64_t new_block, void* buffer);
 
     bool IsIouringSupported();
+    bool CheckPartitionVerification() { return update_verify_->CheckPartitionVerification(); }
 
   private:
     bool ReadMetadata();
     sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
     chunk_t SectorToChunk(sector_t sector) { return sector >> CHUNK_SHIFT; }
-    bool IsBlockAligned(int read_size) { return ((read_size & (BLOCK_SZ - 1)) == 0); }
+    bool IsBlockAligned(uint64_t read_size) { return ((read_size & (BLOCK_SZ - 1)) == 0); }
     struct BufferState* GetBufferState();
     void UpdateMergeCompletionPercentage();
 
-    void ReadBlocks(const std::string partition_name, const std::string& dm_block_device);
-    void ReadBlocksToCache(const std::string& dm_block_device, const std::string& partition_name,
-                           off_t offset, size_t size);
-
-    bool InitializeIouring(int io_depth);
-    void FinalizeIouring();
-    bool ReadBlocksAsync(const std::string& dm_block_device, const std::string& partition_name,
-                         size_t size);
-
     // COW device
     std::string cow_device_;
     // Source device
@@ -422,6 +446,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     bool scratch_space_ = false;
 
     std::unique_ptr<struct io_uring> ring_;
+    std::unique_ptr<UpdateVerify> update_verify_;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index 5d93f01a749d..1e7daed3995f 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -55,6 +55,7 @@ DaemonOps UserSnapshotServer::Resolveop(std::string& input) {
     if (input == "initiate_merge") return DaemonOps::INITIATE;
     if (input == "merge_percent") return DaemonOps::PERCENTAGE;
     if (input == "getstatus") return DaemonOps::GETSTATUS;
+    if (input == "update-verify") return DaemonOps::UPDATE_VERIFY;
 
     return DaemonOps::INVALID;
 }
@@ -290,6 +291,14 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 return Sendmsg(fd, merge_status);
             }
         }
+        case DaemonOps::UPDATE_VERIFY: {
+            std::lock_guard<std::mutex> lock(lock_);
+            if (!UpdateVerification(&lock)) {
+                return Sendmsg(fd, "fail");
+            }
+
+            return Sendmsg(fd, "success");
+        }
         default: {
             LOG(ERROR) << "Received unknown message type from client";
             Sendmsg(fd, "fail");
@@ -750,5 +759,22 @@ bool UserSnapshotServer::RunForSocketHandoff() {
     return true;
 }
 
+bool UserSnapshotServer::UpdateVerification(std::lock_guard<std::mutex>* proof_of_lock) {
+    CHECK(proof_of_lock);
+
+    bool status = true;
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        auto& th = (*iter)->thread();
+        if (th.joinable() && status) {
+            status = (*iter)->snapuserd()->CheckPartitionVerification() && status;
+        } else {
+            // return immediately if there is a failure
+            return false;
+        }
+    }
+
+    return status;
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index e0844aeb1a66..c2af61fbfd6f 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -50,6 +50,7 @@ enum class DaemonOps {
     INITIATE,
     PERCENTAGE,
     GETSTATUS,
+    UPDATE_VERIFY,
     INVALID,
 };
 
@@ -130,6 +131,8 @@ class UserSnapshotServer {
     double GetMergePercentage(std::lock_guard<std::mutex>* proof_of_lock);
     void TerminateMergeThreads(std::lock_guard<std::mutex>* proof_of_lock);
 
+    bool UpdateVerification(std::lock_guard<std::mutex>* proof_of_lock);
+
   public:
     UserSnapshotServer();
     ~UserSnapshotServer();
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp
new file mode 100644
index 000000000000..18c1dfcd9288
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp
@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "snapuserd_core.h"
+
+#include <android-base/chrono_utils.h>
+#include <android-base/scopeguard.h>
+#include <android-base/strings.h>
+
+namespace android {
+namespace snapshot {
+
+using namespace android;
+using namespace android::dm;
+using android::base::unique_fd;
+
+UpdateVerify::UpdateVerify(const std::string& misc_name)
+    : misc_name_(misc_name), state_(UpdateVerifyState::VERIFY_UNKNOWN) {}
+
+bool UpdateVerify::CheckPartitionVerification() {
+    auto now = std::chrono::system_clock::now();
+    auto deadline = now + 10s;
+    {
+        std::unique_lock<std::mutex> cv_lock(m_lock_);
+        while (state_ == UpdateVerifyState::VERIFY_UNKNOWN) {
+            auto status = m_cv_.wait_until(cv_lock, deadline);
+            if (status == std::cv_status::timeout) {
+                return false;
+            }
+        }
+    }
+
+    return (state_ == UpdateVerifyState::VERIFY_SUCCESS);
+}
+
+void UpdateVerify::UpdatePartitionVerificationState(UpdateVerifyState state) {
+    {
+        std::lock_guard<std::mutex> lock(m_lock_);
+        state_ = state;
+    }
+    m_cv_.notify_all();
+}
+
+void UpdateVerify::VerifyUpdatePartition() {
+    bool succeeded = false;
+
+    auto scope_guard = android::base::make_scope_guard([this, &succeeded]() -> void {
+        if (!succeeded) {
+            UpdatePartitionVerificationState(UpdateVerifyState::VERIFY_FAILED);
+        }
+    });
+
+    auto& dm = DeviceMapper::Instance();
+    auto dm_block_devices = dm.FindDmPartitions();
+    if (dm_block_devices.empty()) {
+        SNAP_LOG(ERROR) << "No dm-enabled block device is found.";
+        return;
+    }
+
+    const auto parts = android::base::Split(misc_name_, "-");
+    std::string partition_name = parts[0];
+
+    constexpr auto&& suffix_b = "_b";
+    constexpr auto&& suffix_a = "_a";
+
+    partition_name.erase(partition_name.find_last_not_of(suffix_b) + 1);
+    partition_name.erase(partition_name.find_last_not_of(suffix_a) + 1);
+
+    if (dm_block_devices.find(partition_name) == dm_block_devices.end()) {
+        SNAP_LOG(ERROR) << "Failed to find dm block device for " << partition_name;
+        return;
+    }
+
+    if (!VerifyPartition(partition_name, dm_block_devices.at(partition_name))) {
+        SNAP_LOG(ERROR) << "Partition: " << partition_name
+                        << " Block-device: " << dm_block_devices.at(partition_name)
+                        << " verification failed";
+    }
+    succeeded = true;
+}
+
+bool UpdateVerify::VerifyBlocks(const std::string& partition_name,
+                                const std::string& dm_block_device, off_t offset, int skip_blocks,
+                                uint64_t dev_sz) {
+    unique_fd fd(TEMP_FAILURE_RETRY(open(dm_block_device.c_str(), O_RDONLY | O_DIRECT)));
+    if (fd < 0) {
+        SNAP_LOG(ERROR) << "open failed: " << dm_block_device;
+        return false;
+    }
+
+    loff_t file_offset = offset;
+    const uint64_t read_sz = kBlockSizeVerify;
+
+    void* addr;
+    ssize_t page_size = getpagesize();
+    if (posix_memalign(&addr, page_size, read_sz) < 0) {
+        SNAP_PLOG(ERROR) << "posix_memalign failed "
+                         << " page_size: " << page_size << " read_sz: " << read_sz;
+        return false;
+    }
+
+    std::unique_ptr<void, decltype(&::free)> buffer(addr, ::free);
+
+    uint64_t bytes_read = 0;
+
+    while (true) {
+        size_t to_read = std::min((dev_sz - file_offset), read_sz);
+
+        if (!android::base::ReadFullyAtOffset(fd.get(), buffer.get(), to_read, file_offset)) {
+            SNAP_PLOG(ERROR) << "Failed to read block from block device: " << dm_block_device
+                             << " partition-name: " << partition_name
+                             << " at offset: " << file_offset << " read-size: " << to_read
+                             << " block-size: " << dev_sz;
+            return false;
+        }
+
+        bytes_read += to_read;
+        file_offset += (skip_blocks * kBlockSizeVerify);
+        if (file_offset >= dev_sz) {
+            break;
+        }
+    }
+
+    SNAP_LOG(DEBUG) << "Verification success with bytes-read: " << bytes_read
+                    << " dev_sz: " << dev_sz << " partition_name: " << partition_name;
+
+    return true;
+}
+
+bool UpdateVerify::VerifyPartition(const std::string& partition_name,
+                                   const std::string& dm_block_device) {
+    android::base::Timer timer;
+
+    SNAP_LOG(INFO) << "VerifyPartition: " << partition_name << " Block-device: " << dm_block_device;
+
+    bool succeeded = false;
+    auto scope_guard = android::base::make_scope_guard([this, &succeeded]() -> void {
+        if (!succeeded) {
+            UpdatePartitionVerificationState(UpdateVerifyState::VERIFY_FAILED);
+        }
+    });
+
+    unique_fd fd(TEMP_FAILURE_RETRY(open(dm_block_device.c_str(), O_RDONLY | O_DIRECT)));
+    if (fd < 0) {
+        SNAP_LOG(ERROR) << "open failed: " << dm_block_device;
+        return false;
+    }
+
+    uint64_t dev_sz = get_block_device_size(fd.get());
+    if (!dev_sz) {
+        SNAP_PLOG(ERROR) << "Could not determine block device size: " << dm_block_device;
+        return false;
+    }
+
+    if (!IsBlockAligned(dev_sz)) {
+        SNAP_LOG(ERROR) << "dev_sz: " << dev_sz << " is not block aligned";
+        return false;
+    }
+
+    /*
+     * Not all partitions are of same size. Some partitions are as small as
+     * 100Mb. We can just finish them in a single thread. For bigger partitions
+     * such as product, 4 threads are sufficient enough.
+     *
+     * TODO: With io_uring SQ_POLL support, we can completely cut this
+     * down to just single thread for all partitions and potentially verify all
+     * the partitions with zero syscalls. Additionally, since block layer
+     * supports polling, IO_POLL could be used which will further cut down
+     * latency.
+     */
+    int num_threads = kMinThreadsToVerify;
+    if (dev_sz > kThresholdSize) {
+        num_threads = kMaxThreadsToVerify;
+    }
+
+    std::vector<std::future<bool>> threads;
+    off_t start_offset = 0;
+    const int skip_blocks = num_threads;
+
+    while (num_threads) {
+        threads.emplace_back(std::async(std::launch::async, &UpdateVerify::VerifyBlocks, this,
+                                        partition_name, dm_block_device, start_offset, skip_blocks,
+                                        dev_sz));
+        start_offset += kBlockSizeVerify;
+        num_threads -= 1;
+        if (start_offset >= dev_sz) {
+            break;
+        }
+    }
+
+    bool ret = true;
+    for (auto& t : threads) {
+        ret = t.get() && ret;
+    }
+
+    if (ret) {
+        succeeded = true;
+        UpdatePartitionVerificationState(UpdateVerifyState::VERIFY_SUCCESS);
+        SNAP_LOG(INFO) << "Partition: " << partition_name << " Block-device: " << dm_block_device
+                       << " Size: " << dev_sz
+                       << " verification success. Duration : " << timer.duration().count() << " ms";
+        return true;
+    }
+
+    return false;
+}
+
+}  // namespace snapshot
+}  // namespace android

From d5e026e1af9a3e0d28793cbaa33b28bee953501d Mon Sep 17 00:00:00 2001
From: Alessandra Loro <aloro@google.com>
Date: Thu, 1 Sep 2022 10:33:35 +0000
Subject: [PATCH 0019/1487] Resolve ro.debuggable at build time

Ignore-AOSP-First: cherry-pick for tm-qpr-dev
Test: n/a
Bug: 193912100
Bug: 243645021

Merged-In: I83b0021b91536335c63d19f8a65933bad1b26b4e
Change-Id: I42c4b1e81383d83c73a565c5e74ac22f17389faf
---
 debuggerd/Android.bp                  | 6 ++++++
 debuggerd/include/debuggerd/handler.h | 7 ++++---
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index ad0231d8ddbc..51988727d459 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -14,9 +14,15 @@ cc_defaults {
         "-Wno-nullability-completeness",
         "-Os",
         "-fno-finite-loops",
+        "-DANDROID_DEBUGGABLE=0",
     ],
 
     local_include_dirs: ["include"],
+    product_variables: {
+        debuggable: {
+            cflags: ["-UANDROID_DEBUGGABLE", "-DANDROID_DEBUGGABLE=1"],
+        }
+    },
 }
 
 cc_library_headers {
diff --git a/debuggerd/include/debuggerd/handler.h b/debuggerd/include/debuggerd/handler.h
index bc08327a1c75..68b2e678b830 100644
--- a/debuggerd/include/debuggerd/handler.h
+++ b/debuggerd/include/debuggerd/handler.h
@@ -62,10 +62,11 @@ void debuggerd_init(debuggerd_callbacks_t* callbacks);
 #define DEBUGGER_SIGNAL BIONIC_SIGNAL_DEBUGGER
 
 static void __attribute__((__unused__)) debuggerd_register_handlers(struct sigaction* action) {
+  bool enabled = true;
+#if ANDROID_DEBUGGABLE
   char value[PROP_VALUE_MAX] = "";
-  bool enabled =
-      !(__system_property_get("ro.debuggable", value) > 0 && !strcmp(value, "1") &&
-        __system_property_get("debug.debuggerd.disable", value) > 0 && !strcmp(value, "1"));
+  enabled = !(__system_property_get("debug.debuggerd.disable", value) > 0 && !strcmp(value, "1"));
+#endif
   if (enabled) {
     sigaction(SIGABRT, action, nullptr);
     sigaction(SIGBUS, action, nullptr);

From 3182e9c2a29900f08c92ce5980af461723dda8ec Mon Sep 17 00:00:00 2001
From: Kalesh Singh <kaleshsingh@google.com>
Date: Wed, 14 Dec 2022 11:24:56 -0800
Subject: [PATCH 0020/1487] init: Take wakelock on zygote restart

If the framework is restarting (and cannot yet aquire
wakelocks to block suspend). Take a kernel wakelock
to allow the system to make sufficient progress before
autosuspend can be triggered.

The wakelock is later disable when the framework has
and invokeds enableAutosuspend() on the suspend service.

Bug: 255898234
Bug: 265513788
Bug: 266077359
Test: adb shell "echo mem > /sys/power/state && killall system_server"
Change-Id: Id8cff6564ef05d8c22a8264c51dd313263cb6a9d
Merged-In: Id8cff6564ef05d8c22a8264c51dd313263cb6a9d
---
 rootdir/init.zygote32.rc | 3 +++
 rootdir/init.zygote64.rc | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/rootdir/init.zygote32.rc b/rootdir/init.zygote32.rc
index 63b09c0d6334..2f0ec8a17d4c 100644
--- a/rootdir/init.zygote32.rc
+++ b/rootdir/init.zygote32.rc
@@ -7,6 +7,9 @@ service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-sys
     socket usap_pool_primary stream 660 root system
     onrestart exec_background - system system -- /system/bin/vdc volume abort_fuse
     onrestart write /sys/power/state on
+    # NOTE: If the wakelock name here is changed, then also
+    # update it in SystemSuspend.cpp
+    onrestart write /sys/power/wake_lock zygote_kwl
     onrestart restart audioserver
     onrestart restart cameraserver
     onrestart restart media
diff --git a/rootdir/init.zygote64.rc b/rootdir/init.zygote64.rc
index 5bde5f469bf2..805267d1dd2b 100644
--- a/rootdir/init.zygote64.rc
+++ b/rootdir/init.zygote64.rc
@@ -7,6 +7,9 @@ service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-s
     socket usap_pool_primary stream 660 root system
     onrestart exec_background - system system -- /system/bin/vdc volume abort_fuse
     onrestart write /sys/power/state on
+    # NOTE: If the wakelock name here is changed, then also
+    # update it in SystemSuspend.cpp
+    onrestart write /sys/power/wake_lock zygote_kwl
     onrestart restart audioserver
     onrestart restart cameraserver
     onrestart restart media

From 90879edeea0b2fd1e766428693d736163f39c511 Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Fri, 20 Jan 2023 13:52:35 -0800
Subject: [PATCH 0021/1487] Listen on property_service_for_system socket

It is easy to dos the property_service socket, since it will wait for a
complete data packet from one command before moving on to the next one.
To prevent low privilege apps interfering with system and root apps,
add a second property_service socket that only they can use

Bug: 262237198
Test: Run POC in one shell, set properties as root and system in another
Ignore-AOSP-First: Security fix
Change-Id: I1d6fec833fc24352546bb90f770d3c4b675f5716
---
 init/property_service.cpp | 53 +++++++++++++++++++++++----------------
 1 file changed, 32 insertions(+), 21 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index 87ffdb917bf7..14e55b36abbf 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -57,12 +57,12 @@
 #include <android-base/result.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
+#include <private/android_filesystem_config.h>
 #include <property_info_parser/property_info_parser.h>
 #include <property_info_serializer/property_info_serializer.h>
 #include <selinux/android.h>
 #include <selinux/label.h>
 #include <selinux/selinux.h>
-
 #include "debug_ramdisk.h"
 #include "epoll.h"
 #include "init.h"
@@ -111,12 +111,13 @@ constexpr auto API_LEVEL_CURRENT = 10000;
 
 static bool persistent_properties_loaded = false;
 
-static int property_set_fd = -1;
 static int from_init_socket = -1;
 static int init_socket = -1;
 static bool accept_messages = false;
 static std::mutex accept_messages_lock;
 static std::thread property_service_thread;
+static std::thread property_service_for_system_thread;
+static std::mutex set_property_lock;
 
 static std::unique_ptr<PersistWriteThread> persist_write_thread;
 
@@ -394,6 +395,7 @@ static std::optional<uint32_t> PropertySet(const std::string& name, const std::s
         return {PROP_ERROR_INVALID_VALUE};
     }
 
+    auto lock = std::lock_guard{set_property_lock};
     prop_info* pi = (prop_info*)__system_property_find(name.c_str());
     if (pi != nullptr) {
         // ro.* properties are actually "write-once".
@@ -582,10 +584,10 @@ uint32_t HandlePropertySetNoSocket(const std::string& name, const std::string& v
     return *ret;
 }
 
-static void handle_property_set_fd() {
+static void handle_property_set_fd(int fd) {
     static constexpr uint32_t kDefaultSocketTimeout = 2000; /* ms */
 
-    int s = accept4(property_set_fd, nullptr, nullptr, SOCK_CLOEXEC);
+    int s = accept4(fd, nullptr, nullptr, SOCK_CLOEXEC);
     if (s == -1) {
         return;
     }
@@ -1422,19 +1424,21 @@ static void HandleInitSocket() {
     }
 }
 
-static void PropertyServiceThread() {
+static void PropertyServiceThread(int fd, bool listen_init) {
     Epoll epoll;
     if (auto result = epoll.Open(); !result.ok()) {
         LOG(FATAL) << result.error();
     }
 
-    if (auto result = epoll.RegisterHandler(property_set_fd, handle_property_set_fd);
+    if (auto result = epoll.RegisterHandler(fd, std::bind(handle_property_set_fd, fd));
         !result.ok()) {
         LOG(FATAL) << result.error();
     }
 
-    if (auto result = epoll.RegisterHandler(init_socket, HandleInitSocket); !result.ok()) {
-        LOG(FATAL) << result.error();
+    if (listen_init) {
+        if (auto result = epoll.RegisterHandler(init_socket, HandleInitSocket); !result.ok()) {
+            LOG(FATAL) << result.error();
+        }
     }
 
     while (true) {
@@ -1485,6 +1489,23 @@ void PersistWriteThread::Write(std::string name, std::string value, SocketConnec
     cv_.notify_all();
 }
 
+void StartThread(const char* name, int mode, int gid, std::thread& t, bool listen_init) {
+    int fd = -1;
+    if (auto result = CreateSocket(name, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
+                                   /*passcred=*/false, /*should_listen=*/false, mode, /*uid=*/0,
+                                   /*gid=*/gid, /*socketcon=*/{});
+        result.ok()) {
+        fd = *result;
+    } else {
+        LOG(FATAL) << "start_property_service socket creation failed: " << result.error();
+    }
+
+    listen(fd, 8);
+
+    auto new_thread = std::thread(PropertyServiceThread, fd, listen_init);
+    t.swap(new_thread);
+}
+
 void StartPropertyService(int* epoll_socket) {
     InitPropertySet("ro.property_service.version", "2");
 
@@ -1496,19 +1517,9 @@ void StartPropertyService(int* epoll_socket) {
     init_socket = sockets[1];
     StartSendingMessages();
 
-    if (auto result = CreateSocket(PROP_SERVICE_NAME, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
-                                   /*passcred=*/false, /*should_listen=*/false, 0666, /*uid=*/0,
-                                   /*gid=*/0, /*socketcon=*/{});
-        result.ok()) {
-        property_set_fd = *result;
-    } else {
-        LOG(FATAL) << "start_property_service socket creation failed: " << result.error();
-    }
-
-    listen(property_set_fd, 8);
-
-    auto new_thread = std::thread{PropertyServiceThread};
-    property_service_thread.swap(new_thread);
+    StartThread(PROP_SERVICE_FOR_SYSTEM_NAME, 0660, AID_SYSTEM, property_service_for_system_thread,
+                true);
+    StartThread(PROP_SERVICE_NAME, 0666, 0, property_service_thread, false);
 
     auto async_persist_writes =
             android::base::GetBoolProperty("ro.property_service.async_persist_writes", false);

From bc680ab1fafffc811896e9723cded4dbde46f39b Mon Sep 17 00:00:00 2001
From: Nicolas Gagnon <nicolasgagnon@google.com>
Date: Wed, 14 Sep 2022 17:48:18 +0000
Subject: [PATCH 0022/1487] Port ADB's new handling of the USB packet
 ClearFeature(HALT) to Fastboot.

This patch addresses Fastboot/Fastbootd connection issues seen on ARM Mac devices.

Original ADB patch: https://android-review.googlesource.com/c/platform/packages/modules/adb/+/1699250/

Bug: 238779161
Test: 'fastboot update <path_to_update_archive>.zip' now works on ARM Mac.

Signed-off-by: Nicolas Gagnon <nicolasgagnon@google.com>
Merged-In: Id67904d91abc8b66ef1a00962e1fd57c97df98a7
Change-Id: Id67904d91abc8b66ef1a00962e1fd57c97df98a7
(cherry picked from commit 3efef5694ee242f0fbeeaaa15c128dfb84418798)
---
 fastboot/device/usb.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/fastboot/device/usb.cpp b/fastboot/device/usb.cpp
index 4115a6d28bfe..1257055dea15 100644
--- a/fastboot/device/usb.cpp
+++ b/fastboot/device/usb.cpp
@@ -171,6 +171,16 @@ static int usb_ffs_do_aio(usb_handle* h, const void* data, int len, bool read) {
         if (num_bufs == 1 && aiob->events[0].res == -EINTR) {
             continue;
         }
+        if (read && aiob->events[0].res == -EPIPE) {
+            // On initial connection, some clients will send a ClearFeature(HALT) to
+            // attempt to resynchronize host and device after the fastboot server is killed.
+            // On newer device kernels, the reads we've already dispatched will be cancelled.
+            // Instead of treating this as a failure, which will tear down the interface and
+            // lead to the client doing the same thing again, just resubmit if this happens
+            // before we've actually read anything.
+            PLOG(ERROR) << "aio: got -EPIPE on first read attempt. Re-submitting read... ";
+            continue;
+        }
         int ret = 0;
         for (int i = 0; i < num_bufs; i++) {
             if (aiob->events[i].res < 0) {

From b5e68a67f1a0710753a9e59c8517826f0646da46 Mon Sep 17 00:00:00 2001
From: Hongwei Wang <hwwang@google.com>
Date: Fri, 20 Jan 2023 12:15:28 -0800
Subject: [PATCH 0023/1487] Grant wmtrace access to platform_app:systemui

Grant read/write access to anyone for /data/misc/wmtrace folder on
debuggable builds, it's further protected by the selinux policy.

This is to allow systemui process to write proto logs to the same folder
on device as WindowManager, both can contribute to the transitions like
PiP, Split-Screen and etc.

Bug: 251513116
Test: adb shell dumpsys activity service SystemUIService \
      WMShell protolog [start | stop]
Ignore-AOSP-First: cherry-pick of aosp/2397772
Merged-In: Ice57efa17c61d132b02c0a11a762c24d772bd90a
Change-Id: Ice57efa17c61d132b02c0a11a762c24d772bd90a
---
 rootdir/init.rc | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 02e51d2c4ad9..c3216da52c2c 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1269,11 +1269,13 @@ service console /system/bin/sh
     setenv HOSTNAME console
 
 on property:ro.debuggable=1
-    # Give writes to anyone for the trace folder on debug builds.
+    # Give writes to the same group for the trace folder on debug builds,
+    # it's further protected by selinux policy.
     # The folder is used to store method traces.
     chmod 0773 /data/misc/trace
-    # Give reads to anyone for the window trace folder on debug builds.
-    chmod 0775 /data/misc/wmtrace
+    # Give writes and reads to anyone for the window trace folder on debug builds,
+    # it's further protected by selinux policy.
+    chmod 0777 /data/misc/wmtrace
     # Give reads to anyone for the accessibility trace folder on debug builds.
     chmod 0775 /data/misc/a11ytrace
 

From 719b97add040eb4d60e8a6b87d1e2f35ab73e6a0 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Tue, 31 Jan 2023 17:50:22 -0800
Subject: [PATCH 0024/1487] Display offset in backtraces if necessary.

When moving to a proto tombstone, backtraces no longer contain
an offset when a frame is in a shared library from an apk.
Add the offset display again if needed, and add a test to
verify this behavior.

Bug: 267341682

Test: All unit tests pass.
Test: Dumped a process running through an apk to verify the offset
Test: is present.
Change-Id: Ib720ccb5bfcc8531d1e407f3d01817e8a0b9128c
(cherry picked from commit 22035ccb01693da3e0ec94776c86988c7d5c617e)
---
 debuggerd/debuggerd_test.cpp                  | 60 ++++++++++++++++++-
 .../libdebuggerd/tombstone_proto_to_text.cpp  | 10 +++-
 2 files changed, 66 insertions(+), 4 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index e1133081970c..9163ca0ab789 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -36,6 +36,7 @@
 #include <string>
 #include <thread>
 
+#include <android/dlext.h>
 #include <android/fdsan.h>
 #include <android/set_abort_message.h>
 #include <bionic/malloc.h>
@@ -1842,7 +1843,7 @@ TEST_F(CrasherTest, stack_overflow) {
   ASSERT_MATCH(result, R"(Cause: stack pointer[^\n]*stack overflow.\n)");
 }
 
-static bool CopySharedLibrary(const char* tmp_dir, std::string* tmp_so_name) {
+static std::string GetTestLibraryPath() {
   std::string test_lib(testing::internal::GetArgvs()[0]);
   auto const value = test_lib.find_last_of('/');
   if (value == std::string::npos) {
@@ -1850,7 +1851,62 @@ static bool CopySharedLibrary(const char* tmp_dir, std::string* tmp_so_name) {
   } else {
     test_lib = test_lib.substr(0, value + 1) + "./";
   }
-  test_lib += "libcrash_test.so";
+  return test_lib + "libcrash_test.so";
+}
+
+static void CreateEmbeddedLibrary(int out_fd) {
+  std::string test_lib(GetTestLibraryPath());
+  android::base::unique_fd fd(open(test_lib.c_str(), O_RDONLY | O_CLOEXEC));
+  ASSERT_NE(fd.get(), -1);
+  off_t file_size = lseek(fd, 0, SEEK_END);
+  ASSERT_EQ(lseek(fd, 0, SEEK_SET), 0);
+  std::vector<uint8_t> contents(file_size);
+  ASSERT_TRUE(android::base::ReadFully(fd, contents.data(), contents.size()));
+
+  // Put the shared library data at a pagesize() offset.
+  ASSERT_EQ(lseek(out_fd, 4 * getpagesize(), SEEK_CUR), 4 * getpagesize());
+  ASSERT_EQ(static_cast<size_t>(write(out_fd, contents.data(), contents.size())), contents.size());
+}
+
+TEST_F(CrasherTest, non_zero_offset_in_library) {
+  int intercept_result;
+  unique_fd output_fd;
+  TemporaryFile tf;
+  CreateEmbeddedLibrary(tf.fd);
+  StartProcess([&tf]() {
+    android_dlextinfo extinfo{};
+    extinfo.flags = ANDROID_DLEXT_USE_LIBRARY_FD | ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET;
+    extinfo.library_fd = tf.fd;
+    extinfo.library_fd_offset = 4 * getpagesize();
+    void* handle = android_dlopen_ext(tf.path, RTLD_NOW, &extinfo);
+    if (handle == nullptr) {
+      _exit(1);
+    }
+    void (*crash_func)() = reinterpret_cast<void (*)()>(dlsym(handle, "crash"));
+    if (crash_func == nullptr) {
+      _exit(1);
+    }
+    crash_func();
+  });
+
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGSEGV);
+  FinishIntercept(&intercept_result);
+
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+
+  // Verify the crash includes an offset value in the backtrace.
+  std::string match_str = android::base::StringPrintf("%s\\!libcrash_test.so \\(offset 0x%x\\)",
+                                                      tf.path, 4 * getpagesize());
+  ASSERT_MATCH(result, match_str);
+}
+
+static bool CopySharedLibrary(const char* tmp_dir, std::string* tmp_so_name) {
+  std::string test_lib(GetTestLibraryPath());
 
   *tmp_so_name = std::string(tmp_dir) + "/libcrash_test.so";
   std::string cp_cmd = android::base::StringPrintf("cp %s %s", test_lib.c_str(), tmp_dir);
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index 026564112d64..0696601bc0c0 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -168,8 +168,14 @@ static void print_backtrace(CallbackType callback, const Tombstone& tombstone,
       build_id = StringPrintf(" (BuildId: %s)", frame.build_id().c_str());
     }
 
-    CB(should_log, "      #%02d pc %0*" PRIx64 "  %s%s%s", index++, pointer_width(tombstone) * 2,
-       frame.rel_pc(), frame.file_name().c_str(), function.c_str(), build_id.c_str());
+    std::string line =
+        StringPrintf("      #%02d pc %0*" PRIx64 "  %s", index++, pointer_width(tombstone) * 2,
+                     frame.rel_pc(), frame.file_name().c_str());
+    if (frame.file_map_offset() != 0) {
+      line += StringPrintf(" (offset 0x%" PRIx64 ")", frame.file_map_offset());
+    }
+    line += function + build_id;
+    CB(should_log, "%s", line.c_str());
   }
 }
 

From f4846e2d08aca746622dbb5826e9f33cdf02ab6d Mon Sep 17 00:00:00 2001
From: AleX Pelosi <apelosi@google.com>
Date: Fri, 17 Feb 2023 01:39:21 +0000
Subject: [PATCH 0025/1487] BatteryMonitor: batteryStateOfHealth should be a
 property

Bug: 251427118
Test: m
Ignore-AOSP-First: will cherry-pick to aosp later
Change-Id: I21bcd160f51cf8818d0c3c8c54c615314808e586
Signed-off-by: AleX Pelosi <apelosi@google.com>
---
 healthd/BatteryMonitor.cpp | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index b180a58fec83..66e1e63ef62e 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -392,12 +392,13 @@ void BatteryMonitor::updateValues(void) {
         mHealthInfo->batteryFullChargeDesignCapacityUah =
                 getIntField(mHealthdConfig->batteryFullChargeDesignCapacityUahPath);
 
-    if (!mHealthdConfig->batteryStateOfHealthPath.isEmpty())
-        mHealthInfo->batteryStateOfHealth = getIntField(mHealthdConfig->batteryStateOfHealthPath);
-
     if (!mHealthdConfig->batteryHealthStatusPath.isEmpty())
         mBatteryHealthStatus = getIntField(mHealthdConfig->batteryHealthStatusPath);
 
+    if (!mHealthdConfig->batteryStateOfHealthPath.isEmpty())
+        mHealthInfo->batteryHealthData->batteryStateOfHealth =
+                getIntField(mHealthdConfig->batteryStateOfHealthPath);
+
     if (!mHealthdConfig->batteryManufacturingDatePath.isEmpty())
         mHealthInfo->batteryHealthData->batteryManufacturingDateSeconds =
                 getIntField(mHealthdConfig->batteryManufacturingDatePath);
@@ -591,6 +592,10 @@ int BatteryMonitor::getBatteryHealthData(int id) {
         if (!mHealthdConfig->batteryFirstUsageDatePath.isEmpty())
             return getIntField(mHealthdConfig->batteryFirstUsageDatePath);
     }
+    if (id == BATTERY_PROP_STATE_OF_HEALTH) {
+        if (!mHealthdConfig->batteryStateOfHealthPath.isEmpty())
+            return getIntField(mHealthdConfig->batteryStateOfHealthPath);
+    }
     return 0;
 }
 
@@ -669,6 +674,11 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
         ret = OK;
         break;
 
+    case BATTERY_PROP_STATE_OF_HEALTH:
+        val->valueInt64 = getBatteryHealthData(BATTERY_PROP_STATE_OF_HEALTH);
+        ret = OK;
+        break;
+
     default:
         break;
     }

From 6f7f7c8bcdd73df2c4b8d956442b797c593beaed Mon Sep 17 00:00:00 2001
From: Jack Wu <wjack@google.com>
Date: Sun, 19 Feb 2023 01:38:45 +0800
Subject: [PATCH 0026/1487] Revert "BatteryMonitor: batteryStateOfHealth should
 be a property"

This reverts commit f4846e2d08aca746622dbb5826e9f33cdf02ab6d.

Reason for revert: merge to aosp first
Bug: 251427118
Test: m
Ignore-AOSP-First: merge to aosp first

Change-Id: I84bf3d2059303172161466333db7ad45da5d5270
Signed-off-by: Jack Wu <wjack@google.com>
---
 healthd/BatteryMonitor.cpp | 16 +++-------------
 1 file changed, 3 insertions(+), 13 deletions(-)

diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index 66e1e63ef62e..b180a58fec83 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -392,13 +392,12 @@ void BatteryMonitor::updateValues(void) {
         mHealthInfo->batteryFullChargeDesignCapacityUah =
                 getIntField(mHealthdConfig->batteryFullChargeDesignCapacityUahPath);
 
+    if (!mHealthdConfig->batteryStateOfHealthPath.isEmpty())
+        mHealthInfo->batteryStateOfHealth = getIntField(mHealthdConfig->batteryStateOfHealthPath);
+
     if (!mHealthdConfig->batteryHealthStatusPath.isEmpty())
         mBatteryHealthStatus = getIntField(mHealthdConfig->batteryHealthStatusPath);
 
-    if (!mHealthdConfig->batteryStateOfHealthPath.isEmpty())
-        mHealthInfo->batteryHealthData->batteryStateOfHealth =
-                getIntField(mHealthdConfig->batteryStateOfHealthPath);
-
     if (!mHealthdConfig->batteryManufacturingDatePath.isEmpty())
         mHealthInfo->batteryHealthData->batteryManufacturingDateSeconds =
                 getIntField(mHealthdConfig->batteryManufacturingDatePath);
@@ -592,10 +591,6 @@ int BatteryMonitor::getBatteryHealthData(int id) {
         if (!mHealthdConfig->batteryFirstUsageDatePath.isEmpty())
             return getIntField(mHealthdConfig->batteryFirstUsageDatePath);
     }
-    if (id == BATTERY_PROP_STATE_OF_HEALTH) {
-        if (!mHealthdConfig->batteryStateOfHealthPath.isEmpty())
-            return getIntField(mHealthdConfig->batteryStateOfHealthPath);
-    }
     return 0;
 }
 
@@ -674,11 +669,6 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
         ret = OK;
         break;
 
-    case BATTERY_PROP_STATE_OF_HEALTH:
-        val->valueInt64 = getBatteryHealthData(BATTERY_PROP_STATE_OF_HEALTH);
-        ret = OK;
-        break;
-
     default:
         break;
     }

From 65d8e53b606e4ae7387f421c5277a942f8e729d8 Mon Sep 17 00:00:00 2001
From: Suren Baghdasaryan <surenb@google.com>
Date: Thu, 2 Mar 2023 14:12:49 -0800
Subject: [PATCH 0027/1487] libprocessgroup: fix boot time performance
 regression

The way processes are accounted in DoKillProcessGroupOnce has been
changed recently, which affects retries in KillProcessGroup. More specifically, initialPid was not counted before and would not
cause a retry with 5ms sleep.
Restore previous behavior to avoid boot time regressions.

Bug: 271198843
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Change-Id: Ibc1bdd855898688a4a03806671e6ac31570aedf9
(cherry picked from commit on android-review.googlesource.com host: 4f7cc8c3455b2a28984e2682c1b8075cb57d67fe)
Merged-In: Ibc1bdd855898688a4a03806671e6ac31570aedf9
---
 libprocessgroup/processgroup.cpp | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 92a27efb70d7..71ba7ced2b25 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -377,6 +377,7 @@ static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid,
     std::set<pid_t> pgids;
     pgids.emplace(initialPid);
     std::set<pid_t> pids;
+    int processes = 0;
 
     std::unique_ptr<FILE, decltype(&fclose)> fd(nullptr, fclose);
 
@@ -395,6 +396,7 @@ static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid,
         pid_t pid;
         bool file_is_empty = true;
         while (fscanf(fd.get(), "%d\n", &pid) == 1 && pid >= 0) {
+            processes++;
             file_is_empty = false;
             if (pid == 0) {
                 // Should never happen...  but if it does, trying to kill this
@@ -424,15 +426,12 @@ static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid,
         }
     }
 
-    int processes = 0;
     // Kill all process groups.
     for (const auto pgid : pgids) {
         LOG(VERBOSE) << "Killing process group " << -pgid << " in uid " << uid
                      << " as part of process cgroup " << initialPid;
 
-        if (kill(-pgid, signal) == 0) {
-            processes++;
-        } else if (errno != ESRCH) {
+        if (kill(-pgid, signal) == -1 && errno != ESRCH) {
             PLOG(WARNING) << "kill(" << -pgid << ", " << signal << ") failed";
         }
     }
@@ -442,9 +441,7 @@ static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid,
         LOG(VERBOSE) << "Killing pid " << pid << " in uid " << uid << " as part of process cgroup "
                      << initialPid;
 
-        if (kill(pid, signal) == 0) {
-            processes++;
-        } else if (errno != ESRCH) {
+        if (kill(pid, signal) == -1 && errno != ESRCH) {
             PLOG(WARNING) << "kill(" << pid << ", " << signal << ") failed";
         }
     }

From 8301b33dad51cafd9d08876fc91a7e5fa556dcd3 Mon Sep 17 00:00:00 2001
From: Pete Bentley <prb@google.com>
Date: Thu, 7 Jul 2022 15:18:55 +0100
Subject: [PATCH 0028/1487] Move boringssl self tests from early-init to init.

In previous releases, these self tests had a secondary purpose
of writing a flag file to save future processes from running
some slow self checks.  This is no longer true in T.

However running the tests from early-init has caused issues
on some devices as the kernel's entropy pool is not yet
initialised, causing the process to block for a second or more.

Bug: 231946889
Bug: 249037600
Test: m && flashall
Change-Id: I2116f2029ca6a21e4359407dfff4dc79edd39084
Merged-In: I2116f2029ca6a21e4359407dfff4dc79edd39084
---
 rootdir/init.rc | 53 +++++++++++++++++++++++++------------------------
 1 file changed, 27 insertions(+), 26 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index c3216da52c2c..2b53d883eade 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -86,32 +86,6 @@ on early-init
     mkdir /dev/sys/fs 0755 system system
     mkdir /dev/sys/block 0755 system system
 
-# Run boringssl self test for each ABI so that later processes can skip it. http://b/139348610
-on early-init && property:ro.product.cpu.abilist32=*
-    exec_start boringssl_self_test32
-on early-init && property:ro.product.cpu.abilist64=*
-    exec_start boringssl_self_test64
-on property:apexd.status=ready && property:ro.product.cpu.abilist32=*
-    exec_start boringssl_self_test_apex32
-on property:apexd.status=ready && property:ro.product.cpu.abilist64=*
-    exec_start boringssl_self_test_apex64
-
-service boringssl_self_test32 /system/bin/boringssl_self_test32
-    reboot_on_failure reboot,boringssl-self-check-failed
-    stdio_to_kmsg
-
-service boringssl_self_test64 /system/bin/boringssl_self_test64
-    reboot_on_failure reboot,boringssl-self-check-failed
-    stdio_to_kmsg
-
-service boringssl_self_test_apex32 /apex/com.android.conscrypt/bin/boringssl_self_test32
-    reboot_on_failure reboot,boringssl-self-check-failed
-    stdio_to_kmsg
-
-service boringssl_self_test_apex64 /apex/com.android.conscrypt/bin/boringssl_self_test64
-    reboot_on_failure reboot,boringssl-self-check-failed
-    stdio_to_kmsg
-
 on init
     sysclktz 0
 
@@ -502,6 +476,33 @@ on init
     start hwservicemanager
     start vndservicemanager
 
+# Run boringssl self test for each ABI.  Any failures trigger reboot to firmware.
+on init && property:ro.product.cpu.abilist32=*
+    exec_start boringssl_self_test32
+on init && property:ro.product.cpu.abilist64=*
+    exec_start boringssl_self_test64
+on property:apexd.status=ready && property:ro.product.cpu.abilist32=*
+    exec_start boringssl_self_test_apex32
+on property:apexd.status=ready && property:ro.product.cpu.abilist64=*
+    exec_start boringssl_self_test_apex64
+
+service boringssl_self_test32 /system/bin/boringssl_self_test32
+    reboot_on_failure reboot,boringssl-self-check-failed
+    stdio_to_kmsg
+
+service boringssl_self_test64 /system/bin/boringssl_self_test64
+    reboot_on_failure reboot,boringssl-self-check-failed
+    stdio_to_kmsg
+
+service boringssl_self_test_apex32 /apex/com.android.conscrypt/bin/boringssl_self_test32
+    reboot_on_failure reboot,boringssl-self-check-failed
+    stdio_to_kmsg
+
+service boringssl_self_test_apex64 /apex/com.android.conscrypt/bin/boringssl_self_test64
+    reboot_on_failure reboot,boringssl-self-check-failed
+    stdio_to_kmsg
+
+
 # Healthd can trigger a full boot from charger mode by signaling this
 # property when the power button is held.
 on property:sys.boot_from_charger_mode=1

From 691d805d30548dc8010a6aad24ef5365fbdf5775 Mon Sep 17 00:00:00 2001
From: David Tracy <dtracy@squareup.com>
Date: Thu, 23 Mar 2023 17:51:11 -0700
Subject: [PATCH 0029/1487] bootstat: Adds additional reboot reason patterns

- Adding allowance for arbitrary ota subreason details, such as
  success or failure conditions
- Adding the new subreason "periodic", which is useful for POS devices
  which require e.g. daily reboots as part of security requirements
Test: Full Android build

Change-Id: Id0a6d38ed902e2b25fbb050980c763912c948f27
Signed-off-by: David Tracy <dtracy@squareup.com>
---
 bootstat/bootstat.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/bootstat/bootstat.cpp b/bootstat/bootstat.cpp
index 844357cfcb63..3b8866e51afb 100644
--- a/bootstat/bootstat.cpp
+++ b/bootstat/bootstat.cpp
@@ -459,6 +459,8 @@ const std::map<std::string, int32_t> kBootReasonMap = {
     {"reboot,sys_ldo_ok,pmic,main", 227},
     {"reboot,sys_ldo_ok,pmic,sub", 228},
     {"reboot,smpl_timeout,pmic,main", 229},
+    {"reboot,ota,.*", 230},
+    {"reboot,periodic,.*", 231},
 };
 
 // Converts a string value representing the reason the system booted to an

From 606afc7b7451aba90e3634076d9b59a5ef08186b Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Fri, 24 Mar 2023 14:31:57 -0700
Subject: [PATCH 0030/1487] Fix deadlock caused by two-threaded property
 controls

Two threaded property controls were introduced in ag/21063815 to prevent
DOS for power controls. However, this causes deadlocks, so limit the
second thread to just sys.powerctl messages.

Bug: 273785601
Test: Boots, power messages work
Ignore-AOSP-First: Security fix
Change-Id: Ie27dc3b0cd9e2d28e94f2ad398c55ee27bc35835
---
 init/property_service.cpp | 50 +++++++++++++++++++++------------------
 1 file changed, 27 insertions(+), 23 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index 2d084db46d2a..4242912ed0af 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -117,7 +117,6 @@ static bool accept_messages = false;
 static std::mutex accept_messages_lock;
 static std::thread property_service_thread;
 static std::thread property_service_for_system_thread;
-static std::mutex set_property_lock;
 
 static std::unique_ptr<PersistWriteThread> persist_write_thread;
 
@@ -395,32 +394,37 @@ static std::optional<uint32_t> PropertySet(const std::string& name, const std::s
         return {PROP_ERROR_INVALID_VALUE};
     }
 
-    auto lock = std::lock_guard{set_property_lock};
-    prop_info* pi = (prop_info*)__system_property_find(name.c_str());
-    if (pi != nullptr) {
-        // ro.* properties are actually "write-once".
-        if (StartsWith(name, "ro.")) {
-            *error = "Read-only property was already set";
-            return {PROP_ERROR_READ_ONLY_PROPERTY};
-        }
-
-        __system_property_update(pi, value.c_str(), valuelen);
+    if (name == "sys.powerctl") {
+        // No action here - NotifyPropertyChange will trigger the appropriate action, and since this
+        // can come to the second thread, we mustn't call out to the __system_property_* functions
+        // which support multiple readers but only one mutator.
     } else {
-        int rc = __system_property_add(name.c_str(), name.size(), value.c_str(), valuelen);
-        if (rc < 0) {
-            *error = "__system_property_add failed";
-            return {PROP_ERROR_SET_FAILED};
+        prop_info* pi = (prop_info*)__system_property_find(name.c_str());
+        if (pi != nullptr) {
+            // ro.* properties are actually "write-once".
+            if (StartsWith(name, "ro.")) {
+                *error = "Read-only property was already set";
+                return {PROP_ERROR_READ_ONLY_PROPERTY};
+            }
+
+            __system_property_update(pi, value.c_str(), valuelen);
+        } else {
+            int rc = __system_property_add(name.c_str(), name.size(), value.c_str(), valuelen);
+            if (rc < 0) {
+                *error = "__system_property_add failed";
+                return {PROP_ERROR_SET_FAILED};
+            }
         }
-    }
 
-    // Don't write properties to disk until after we have read all default
-    // properties to prevent them from being overwritten by default values.
-    if (socket && persistent_properties_loaded && StartsWith(name, "persist.")) {
-        if (persist_write_thread) {
-            persist_write_thread->Write(name, value, std::move(*socket));
-            return {};
+        // Don't write properties to disk until after we have read all default
+        // properties to prevent them from being overwritten by default values.
+        if (socket && persistent_properties_loaded && StartsWith(name, "persist.")) {
+            if (persist_write_thread) {
+                persist_write_thread->Write(name, value, std::move(*socket));
+                return {};
+            }
+            WritePersistentProperty(name, value);
         }
-        WritePersistentProperty(name, value);
     }
 
     NotifyPropertyChange(name, value);

From 763e869b381bbcec58e799670344e859292f2db2 Mon Sep 17 00:00:00 2001
From: "Chung-Kai (Michael) Mei" <chungkai@google.com>
Date: Wed, 1 Mar 2023 04:24:10 +0000
Subject: [PATCH 0031/1487] Revert "Revert "libmodprobe: LPM: Load all modules
 in *.load with *.dep satisfied""

This reverts commit a0e6703f738bcf863847088cdcd4b3689e8c9ae6.

Reason for revert: the failed devices has disabled the feature now, we'll fixed the problem later so releand this patch first

Change-Id: Ib12b84edbd9489d769a4988908bb89f45c13ca43
---
 libmodprobe/libmodprobe.cpp | 81 ++++++++++++++++++++-----------------
 1 file changed, 45 insertions(+), 36 deletions(-)

diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index e071c96d97f8..4fbb19d1af5c 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -439,54 +439,58 @@ bool Modprobe::IsBlocklisted(const std::string& module_name) {
     return module_blocklist_.count(canonical_name) > 0;
 }
 
-// Another option to load kernel modules. load in independent modules in parallel
-// and then update dependency list of other remaining modules, repeat these steps
-// until all modules are loaded.
+// Another option to load kernel modules. load independent modules dependencies
+// in parallel and then update dependency list of other remaining modules,
+// repeat these steps until all modules are loaded.
+// Discard all blocklist.
+// Softdeps are taken care in InsmodWithDeps().
 bool Modprobe::LoadModulesParallel(int num_threads) {
     bool ret = true;
-    int count = -1;
-    std::map<std::string, std::set<std::string>> mod_with_deps;
+    std::unordered_map<std::string, std::vector<std::string>> mod_with_deps;
 
     // Get dependencies
     for (const auto& module : module_load_) {
-        auto dependencies = GetDependencies(MakeCanonical(module));
-
-        for (auto dep = dependencies.rbegin(); dep != dependencies.rend(); dep++) {
-            mod_with_deps[module].emplace(*dep);
-        }
-    }
-
-    // Get soft dependencies
-    for (const auto& [it_mod, it_softdep] : module_pre_softdep_) {
-        if (mod_with_deps.find(MakeCanonical(it_softdep)) != mod_with_deps.end()) {
-            mod_with_deps[MakeCanonical(it_mod)].emplace(
-                GetDependencies(MakeCanonical(it_softdep))[0]);
+        // Skip blocklist modules
+        if (IsBlocklisted(module)) {
+            LOG(VERBOSE) << "LMP: Blocklist: Module " << module << " skipping...";
+            continue;
         }
-    }
-
-    // Get soft post dependencies
-    for (const auto& [it_mod, it_softdep] : module_post_softdep_) {
-        if (mod_with_deps.find(MakeCanonical(it_softdep)) != mod_with_deps.end()) {
-            mod_with_deps[MakeCanonical(it_softdep)].emplace(
-                GetDependencies(MakeCanonical(it_mod))[0]);
+        auto dependencies = GetDependencies(MakeCanonical(module));
+        if (dependencies.empty()) {
+            LOG(ERROR) << "LMP: Hard-dep: Module " << module
+                       << " not in .dep file";
+            return false;
         }
+        mod_with_deps[MakeCanonical(module)] = dependencies;
     }
 
-    while (!mod_with_deps.empty() &&  count != module_loaded_.size()) {
+    while (!mod_with_deps.empty()) {
         std::vector<std::thread> threads;
         std::vector<std::string> mods_path_to_load;
         std::mutex vector_lock;
-        count = module_loaded_.size();
 
         // Find independent modules
         for (const auto& [it_mod, it_dep] : mod_with_deps) {
-            if (it_dep.size() == 1) {
-                if (module_options_[it_mod].find("load_sequential=1") != std::string::npos) {
-                    if (!LoadWithAliases(it_mod, true) && !IsBlocklisted(it_mod)) {
-                      return false;
-                    }
-                } else {
-                    mods_path_to_load.emplace_back(it_mod);
+            auto itd_last = it_dep.rbegin();
+            if (itd_last == it_dep.rend())
+                continue;
+
+            auto cnd_last = MakeCanonical(*itd_last);
+            // Hard-dependencies cannot be blocklisted
+            if (IsBlocklisted(cnd_last)) {
+                LOG(ERROR) << "LMP: Blocklist: Module-dep " << cnd_last
+                           << " : failed to load module " << it_mod;
+                return false;
+            }
+
+            if (module_options_[cnd_last].find("load_sequential=1") != std::string::npos) {
+                if (!LoadWithAliases(cnd_last, true)) {
+                    return false;
+                }
+            } else {
+                if (std::find(mods_path_to_load.begin(), mods_path_to_load.end(),
+                            cnd_last) == mods_path_to_load.end()) {
+                    mods_path_to_load.emplace_back(cnd_last);
                 }
             }
         }
@@ -502,7 +506,7 @@ bool Modprobe::LoadModulesParallel(int num_threads) {
                 lk.unlock();
                 ret_load &= LoadWithAliases(mod_to_load, true);
                 lk.lock();
-                if (!ret_load && !IsBlocklisted(mod_to_load)) {
+                if (!ret_load) {
                     ret &= ret_load;
                 }
             }
@@ -521,13 +525,18 @@ bool Modprobe::LoadModulesParallel(int num_threads) {
         std::lock_guard guard(module_loaded_lock_);
         // Remove loaded module form mod_with_deps and soft dependencies of other modules
         for (const auto& module_loaded : module_loaded_) {
-            mod_with_deps.erase(module_loaded);
+            if (mod_with_deps.find(module_loaded) != mod_with_deps.end()) {
+                mod_with_deps.erase(module_loaded);
+            }
         }
 
         // Remove loaded module form dependencies of other modules which are not loaded yet
         for (const auto& module_loaded_path : module_loaded_paths_) {
             for (auto& [mod, deps] : mod_with_deps) {
-                deps.erase(module_loaded_path);
+                auto it = std::find(deps.begin(), deps.end(), module_loaded_path);
+                if (it != deps.end()) {
+                    deps.erase(it);
+                }
             }
         }
     }

From ecd154e702aaf7896739c1c2b2b0c796ae872030 Mon Sep 17 00:00:00 2001
From: Wasim Nazir <quic_wasimn@quicinc.com>
Date: Thu, 6 Apr 2023 15:07:22 +0530
Subject: [PATCH 0032/1487] libmodprobe: LPM: Cleanup of redundant check

Removing find-check while removing modules in loop.

Test: Normal/Recovery Boot to home
Bug: 261678056
Change-Id: I5ff41b3e8cf633dc687f819a146404b863d2ae0a
Signed-off-by: Wasim Nazir <quic_wasimn@quicinc.com>
---
 libmodprobe/libmodprobe.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index 4fbb19d1af5c..6c5ca99b94d7 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -524,11 +524,8 @@ bool Modprobe::LoadModulesParallel(int num_threads) {
 
         std::lock_guard guard(module_loaded_lock_);
         // Remove loaded module form mod_with_deps and soft dependencies of other modules
-        for (const auto& module_loaded : module_loaded_) {
-            if (mod_with_deps.find(module_loaded) != mod_with_deps.end()) {
-                mod_with_deps.erase(module_loaded);
-            }
-        }
+        for (const auto& module_loaded : module_loaded_)
+            mod_with_deps.erase(module_loaded);
 
         // Remove loaded module form dependencies of other modules which are not loaded yet
         for (const auto& module_loaded_path : module_loaded_paths_) {

From d87b6018d25cbbd33b345dc58c634718bf5d0def Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 4 Apr 2023 18:41:13 +0000
Subject: [PATCH 0033/1487] libprocessgroup: Add sendSignalToProcessGroup

Add a function which sends signals to all members of a process group,
but does not wait for the processes to exit, or for the associated
cgroup to be removed.

Bug: 274646058
Ignore-AOSP-First: Dependency of ActivityManager change which developed on interal git_master
Test: Force-stop of chrome with 15 tabs completes ~500ms faster
Test: Full Play store update causes no ANR
Change-Id: I37dbdecb3394101abbee8495e71f6912b3c031f5
---
 libprocessgroup/include/processgroup/processgroup.h | 5 +++++
 libprocessgroup/processgroup.cpp                    | 9 +++++++++
 2 files changed, 14 insertions(+)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 8fa9fd552328..48bc0b7f32e1 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -76,6 +76,11 @@ int killProcessGroup(uid_t uid, int initialPid, int signal, int* max_processes =
 // that it only returns 0 in the case that the cgroup exists and it contains no processes.
 int killProcessGroupOnce(uid_t uid, int initialPid, int signal, int* max_processes = nullptr);
 
+// Sends the provided signal to all members of a process group, but does not wait for processes to
+// exit, or for the cgroup to be removed. Callers should also ensure that killProcessGroup is called
+// later to ensure the cgroup is fully removed, otherwise system resources may leak.
+int sendSignalToProcessGroup(uid_t uid, int initialPid, int signal);
+
 int createProcessGroup(uid_t uid, int initialPid, bool memControl = false);
 
 // Set various properties of a process group. For these functions to work, the process group must
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index ae9914d645ee..a02159401f88 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -542,6 +542,15 @@ int killProcessGroupOnce(uid_t uid, int initialPid, int signal, int* max_process
     return KillProcessGroup(uid, initialPid, signal, 0 /*retries*/, max_processes);
 }
 
+int sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
+    std::string hierarchy_root_path;
+    if (CgroupsAvailable()) {
+        CgroupGetControllerPath(CGROUPV2_CONTROLLER_NAME, &hierarchy_root_path);
+    }
+    const char* cgroup = hierarchy_root_path.c_str();
+    return DoKillProcessGroupOnce(cgroup, uid, initialPid, signal);
+}
+
 static int createProcessGroupInternal(uid_t uid, int initialPid, std::string cgroup,
                                       bool activate_controllers) {
     auto uid_path = ConvertUidToPath(cgroup.c_str(), uid);

From d3dc653d22f97820742c86b4bc4edb627a0dfd21 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 4 Apr 2023 18:41:13 +0000
Subject: [PATCH 0034/1487] libprocessgroup: Add sendSignalToProcessGroup

Add a function which sends signals to all members of a process group,
but does not wait for the processes to exit, or for the associated
cgroup to be removed.

Bug: 274646058
Ignore-AOSP-First: Dependency of ActivityManager change which developed on interal git_master
Test: Force-stop of chrome with 15 tabs completes ~500ms faster
Test: Full Play store update causes no ANR
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:d87b6018d25cbbd33b345dc58c634718bf5d0def)
Merged-In: I37dbdecb3394101abbee8495e71f6912b3c031f5
Change-Id: I37dbdecb3394101abbee8495e71f6912b3c031f5
---
 libprocessgroup/include/processgroup/processgroup.h | 5 +++++
 libprocessgroup/processgroup.cpp                    | 9 +++++++++
 2 files changed, 14 insertions(+)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 8fa9fd552328..48bc0b7f32e1 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -76,6 +76,11 @@ int killProcessGroup(uid_t uid, int initialPid, int signal, int* max_processes =
 // that it only returns 0 in the case that the cgroup exists and it contains no processes.
 int killProcessGroupOnce(uid_t uid, int initialPid, int signal, int* max_processes = nullptr);
 
+// Sends the provided signal to all members of a process group, but does not wait for processes to
+// exit, or for the cgroup to be removed. Callers should also ensure that killProcessGroup is called
+// later to ensure the cgroup is fully removed, otherwise system resources may leak.
+int sendSignalToProcessGroup(uid_t uid, int initialPid, int signal);
+
 int createProcessGroup(uid_t uid, int initialPid, bool memControl = false);
 
 // Set various properties of a process group. For these functions to work, the process group must
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index ae9914d645ee..a02159401f88 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -542,6 +542,15 @@ int killProcessGroupOnce(uid_t uid, int initialPid, int signal, int* max_process
     return KillProcessGroup(uid, initialPid, signal, 0 /*retries*/, max_processes);
 }
 
+int sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
+    std::string hierarchy_root_path;
+    if (CgroupsAvailable()) {
+        CgroupGetControllerPath(CGROUPV2_CONTROLLER_NAME, &hierarchy_root_path);
+    }
+    const char* cgroup = hierarchy_root_path.c_str();
+    return DoKillProcessGroupOnce(cgroup, uid, initialPid, signal);
+}
+
 static int createProcessGroupInternal(uid_t uid, int initialPid, std::string cgroup,
                                       bool activate_controllers) {
     auto uid_path = ConvertUidToPath(cgroup.c_str(), uid);

From 3a81dda861c85b15b1ea614b6c15b2274105d113 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Mon, 24 Apr 2023 18:14:53 -0700
Subject: [PATCH 0035/1487] Re-add code to skip gettings logs on logd crashes.

Also add new unit tests to verify this behavior.

Bug: 276934420

Test: New unit tests pass.
Test: Ran new unit tests without pthread_setname_np call and verified
Test: the tests fail.
Test: Force crash logd and verify log messages are not gathered.
Test: Force crash a logd thread and verify log messages are not gathered.
Change-Id: If8effef68f629432923cdc89e57d28ef5b8b4ce2
Merged-In: If8effef68f629432923cdc89e57d28ef5b8b4ce2
(cherry picked from commit bda106416096d51d872bffacfd251e586f982004)
---
 debuggerd/debuggerd_test.cpp               | 56 ++++++++++++++++++++++
 debuggerd/libdebuggerd/tombstone_proto.cpp |  9 +++-
 2 files changed, 64 insertions(+), 1 deletion(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index a00a2026f520..39d7fff1ca86 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -20,6 +20,7 @@
 #include <fcntl.h>
 #include <linux/prctl.h>
 #include <malloc.h>
+#include <pthread.h>
 #include <stdlib.h>
 #include <sys/capability.h>
 #include <sys/mman.h>
@@ -2703,3 +2704,58 @@ TEST_F(CrasherTest, verify_build_id) {
   }
   ASSERT_TRUE(found_valid_elf) << "Did not find any elf files with valid BuildIDs to check.";
 }
+
+const char kLogMessage[] = "Should not see this log message.";
+
+// Verify that the logd process does not read the log.
+TEST_F(CrasherTest, logd_skips_reading_logs) {
+  StartProcess([]() {
+    pthread_setname_np(pthread_self(), "logd");
+    LOG(INFO) << kLogMessage;
+    abort();
+  });
+
+  unique_fd output_fd;
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  int intercept_result;
+  FinishIntercept(&intercept_result);
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  // logd should not contain our log message.
+  ASSERT_NOT_MATCH(result, kLogMessage);
+}
+
+// Verify that the logd process does not read the log when the non-main
+// thread crashes.
+TEST_F(CrasherTest, logd_skips_reading_logs_not_main_thread) {
+  StartProcess([]() {
+    pthread_setname_np(pthread_self(), "logd");
+    LOG(INFO) << kLogMessage;
+
+    std::thread thread([]() {
+      pthread_setname_np(pthread_self(), "not_logd_thread");
+      // Raise the signal on the side thread.
+      raise_debugger_signal(kDebuggerdTombstone);
+    });
+    thread.join();
+    _exit(0);
+  });
+
+  unique_fd output_fd;
+  StartIntercept(&output_fd, kDebuggerdTombstone);
+  FinishCrasher();
+  AssertDeath(0);
+
+  int intercept_result;
+  FinishIntercept(&intercept_result);
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_BACKTRACE_FRAME(result, "raise_debugger_signal");
+  ASSERT_NOT_MATCH(result, kLogMessage);
+}
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index 9a565deb669e..acd814efa68b 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -690,7 +690,14 @@ void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder*
 
   // Only dump logs on debuggable devices.
   if (android::base::GetBoolProperty("ro.debuggable", false)) {
-    dump_logcat(&result, main_thread.pid);
+    // Get the thread that corresponds to the main pid of the process.
+    const ThreadInfo& thread = threads.at(main_thread.pid);
+
+    // Do not attempt to dump logs of the logd process because the gathering
+    // of logs can hang until a timeout occurs.
+    if (thread.thread_name != "logd") {
+      dump_logcat(&result, main_thread.pid);
+    }
   }
 
   dump_open_fds(&result, open_files);

From 4a8c1461ff2135e29bb00bcd32989567108e776a Mon Sep 17 00:00:00 2001
From: Suren Baghdasaryan <surenb@google.com>
Date: Wed, 12 Apr 2023 01:24:23 +0000
Subject: [PATCH 0036/1487] libprocessgroup: implement task profile validity
 checks

Provide profile validity check functions for cases when user wants to
check whether a profile can be successfully applied before actually
applying it. Add test cases to cover new APIs.

Also add a wrapper function for framework code to call it.

Bug: 277233783
Test: atest task_profiles_test
Test: manually verify freezer with outdated cgroup configuration
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Signed-off-by: Li Li <dualli@google.com>
Change-Id: Iefb321dead27adbe67721972f164efea213c06cb
Merged-In: Iefb321dead27adbe67721972f164efea213c06cb
---
 .../include/processgroup/processgroup.h       |   4 +
 libprocessgroup/processgroup.cpp              |  10 ++
 libprocessgroup/task_profiles.cpp             | 121 ++++++++++++++++++
 libprocessgroup/task_profiles.h               |  20 ++-
 libprocessgroup/task_profiles_test.cpp        |  50 ++++++++
 5 files changed, 202 insertions(+), 3 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 48bc0b7f32e1..dbaeb93977bf 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -96,6 +96,10 @@ void removeAllEmptyProcessGroups(void);
 // Returns false in case of error, true in case of success
 bool getAttributePathForTask(const std::string& attr_name, int tid, std::string* path);
 
+// Check if a profile can be applied without failing.
+// Returns true if it can be applied without failing, false otherwise
+bool isProfileValidForProcess(const std::string& profile_name, int uid, int pid);
+
 #endif // __ANDROID_VNDK__
 
 __END_DECLS
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index a02159401f88..234b793d4a00 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -657,3 +657,13 @@ bool setProcessGroupLimit(uid_t, int pid, int64_t limit_in_bytes) {
 bool getAttributePathForTask(const std::string& attr_name, int tid, std::string* path) {
     return CgroupGetAttributePathForTask(attr_name, tid, path);
 }
+
+bool isProfileValidForProcess(const std::string& profile_name, int uid, int pid) {
+    const TaskProfile* tp = TaskProfiles::GetInstance().GetProfile(profile_name);
+
+    if (tp == nullptr) {
+        return false;
+    }
+
+    return tp->IsValidForProcess(uid, pid);
+}
\ No newline at end of file
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 17318289fb99..44dba2a16694 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -259,6 +259,31 @@ bool SetAttributeAction::ExecuteForUID(uid_t uid) const {
     return true;
 }
 
+bool SetAttributeAction::IsValidForProcess(uid_t, pid_t pid) const {
+    return IsValidForTask(pid);
+}
+
+bool SetAttributeAction::IsValidForTask(int tid) const {
+    std::string path;
+
+    if (!attribute_->GetPathForTask(tid, &path)) {
+        return false;
+    }
+
+    if (!access(path.c_str(), W_OK)) {
+        // operation will succeed
+        return true;
+    }
+
+    if (!access(path.c_str(), F_OK)) {
+        // file exists but not writable
+        return false;
+    }
+
+    // file does not exist, ignore if optional
+    return optional_;
+}
+
 SetCgroupAction::SetCgroupAction(const CgroupController& c, const std::string& p)
     : controller_(c), path_(p) {
     FdCacheHelper::Init(controller_.GetTasksFilePath(path_), fd_[ProfileAction::RCT_TASK]);
@@ -396,6 +421,39 @@ void SetCgroupAction::DropResourceCaching(ResourceCacheType cache_type) {
     FdCacheHelper::Drop(fd_[cache_type]);
 }
 
+bool SetCgroupAction::IsValidForProcess(uid_t uid, pid_t pid) const {
+    std::lock_guard<std::mutex> lock(fd_mutex_);
+    if (FdCacheHelper::IsCached(fd_[ProfileAction::RCT_PROCESS])) {
+        return true;
+    }
+
+    if (fd_[ProfileAction::RCT_PROCESS] == FdCacheHelper::FDS_INACCESSIBLE) {
+        return false;
+    }
+
+    std::string procs_path = controller()->GetProcsFilePath(path_, uid, pid);
+    return access(procs_path.c_str(), W_OK) == 0;
+}
+
+bool SetCgroupAction::IsValidForTask(int) const {
+    std::lock_guard<std::mutex> lock(fd_mutex_);
+    if (FdCacheHelper::IsCached(fd_[ProfileAction::RCT_TASK])) {
+        return true;
+    }
+
+    if (fd_[ProfileAction::RCT_TASK] == FdCacheHelper::FDS_INACCESSIBLE) {
+        return false;
+    }
+
+    if (fd_[ProfileAction::RCT_TASK] == FdCacheHelper::FDS_APP_DEPENDENT) {
+        // application-dependent path can't be used with tid
+        return false;
+    }
+
+    std::string tasks_path = controller()->GetTasksFilePath(path_);
+    return access(tasks_path.c_str(), W_OK) == 0;
+}
+
 WriteFileAction::WriteFileAction(const std::string& task_path, const std::string& proc_path,
                                  const std::string& value, bool logfailures)
     : task_path_(task_path), proc_path_(proc_path), value_(value), logfailures_(logfailures) {
@@ -532,6 +590,37 @@ void WriteFileAction::DropResourceCaching(ResourceCacheType cache_type) {
     FdCacheHelper::Drop(fd_[cache_type]);
 }
 
+bool WriteFileAction::IsValidForProcess(uid_t, pid_t) const {
+    std::lock_guard<std::mutex> lock(fd_mutex_);
+    if (FdCacheHelper::IsCached(fd_[ProfileAction::RCT_PROCESS])) {
+        return true;
+    }
+
+    if (fd_[ProfileAction::RCT_PROCESS] == FdCacheHelper::FDS_INACCESSIBLE) {
+        return false;
+    }
+
+    return access(proc_path_.empty() ? task_path_.c_str() : proc_path_.c_str(), W_OK) == 0;
+}
+
+bool WriteFileAction::IsValidForTask(int) const {
+    std::lock_guard<std::mutex> lock(fd_mutex_);
+    if (FdCacheHelper::IsCached(fd_[ProfileAction::RCT_TASK])) {
+        return true;
+    }
+
+    if (fd_[ProfileAction::RCT_TASK] == FdCacheHelper::FDS_INACCESSIBLE) {
+        return false;
+    }
+
+    if (fd_[ProfileAction::RCT_TASK] == FdCacheHelper::FDS_APP_DEPENDENT) {
+        // application-dependent path can't be used with tid
+        return false;
+    }
+
+    return access(task_path_.c_str(), W_OK) == 0;
+}
+
 bool ApplyProfileAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
     for (const auto& profile : profiles_) {
         profile->ExecuteForProcess(uid, pid);
@@ -558,6 +647,24 @@ void ApplyProfileAction::DropResourceCaching(ResourceCacheType cache_type) {
     }
 }
 
+bool ApplyProfileAction::IsValidForProcess(uid_t uid, pid_t pid) const {
+    for (const auto& profile : profiles_) {
+        if (!profile->IsValidForProcess(uid, pid)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool ApplyProfileAction::IsValidForTask(int tid) const {
+    for (const auto& profile : profiles_) {
+        if (!profile->IsValidForTask(tid)) {
+            return false;
+        }
+    }
+    return true;
+}
+
 void TaskProfile::MoveTo(TaskProfile* profile) {
     profile->elements_ = std::move(elements_);
     profile->res_cached_ = res_cached_;
@@ -620,6 +727,20 @@ void TaskProfile::DropResourceCaching(ProfileAction::ResourceCacheType cache_typ
     res_cached_ = false;
 }
 
+bool TaskProfile::IsValidForProcess(uid_t uid, pid_t pid) const {
+    for (const auto& element : elements_) {
+        if (!element->IsValidForProcess(uid, pid)) return false;
+    }
+    return true;
+}
+
+bool TaskProfile::IsValidForTask(int tid) const {
+    for (const auto& element : elements_) {
+        if (!element->IsValidForTask(tid)) return false;
+    }
+    return true;
+}
+
 void TaskProfiles::DropResourceCaching(ProfileAction::ResourceCacheType cache_type) const {
     for (auto& iter : profiles_) {
         iter.second->DropResourceCaching(cache_type);
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index a8ecb873d88e..a62c5b0a9e8c 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -72,12 +72,14 @@ class ProfileAction {
     virtual const char* Name() const = 0;
 
     // Default implementations will fail
-    virtual bool ExecuteForProcess(uid_t, pid_t) const { return false; };
-    virtual bool ExecuteForTask(int) const { return false; };
-    virtual bool ExecuteForUID(uid_t) const { return false; };
+    virtual bool ExecuteForProcess(uid_t, pid_t) const { return false; }
+    virtual bool ExecuteForTask(int) const { return false; }
+    virtual bool ExecuteForUID(uid_t) const { return false; }
 
     virtual void EnableResourceCaching(ResourceCacheType) {}
     virtual void DropResourceCaching(ResourceCacheType) {}
+    virtual bool IsValidForProcess(uid_t uid, pid_t pid) const { return false; }
+    virtual bool IsValidForTask(int tid) const { return false; }
 
   protected:
     enum CacheUseResult { SUCCESS, FAIL, UNUSED };
@@ -103,6 +105,8 @@ class SetTimerSlackAction : public ProfileAction {
 
     const char* Name() const override { return "SetTimerSlack"; }
     bool ExecuteForTask(int tid) const override;
+    bool IsValidForProcess(uid_t uid, pid_t pid) const override { return true; }
+    bool IsValidForTask(int tid) const override { return true; }
 
   private:
     unsigned long slack_;
@@ -120,6 +124,8 @@ class SetAttributeAction : public ProfileAction {
     bool ExecuteForProcess(uid_t uid, pid_t pid) const override;
     bool ExecuteForTask(int tid) const override;
     bool ExecuteForUID(uid_t uid) const override;
+    bool IsValidForProcess(uid_t uid, pid_t pid) const override;
+    bool IsValidForTask(int tid) const override;
 
   private:
     const IProfileAttribute* attribute_;
@@ -137,6 +143,8 @@ class SetCgroupAction : public ProfileAction {
     bool ExecuteForTask(int tid) const override;
     void EnableResourceCaching(ResourceCacheType cache_type) override;
     void DropResourceCaching(ResourceCacheType cache_type) override;
+    bool IsValidForProcess(uid_t uid, pid_t pid) const override;
+    bool IsValidForTask(int tid) const override;
 
     const CgroupController* controller() const { return &controller_; }
 
@@ -161,6 +169,8 @@ class WriteFileAction : public ProfileAction {
     bool ExecuteForTask(int tid) const override;
     void EnableResourceCaching(ResourceCacheType cache_type) override;
     void DropResourceCaching(ResourceCacheType cache_type) override;
+    bool IsValidForProcess(uid_t uid, pid_t pid) const override;
+    bool IsValidForTask(int tid) const override;
 
   private:
     std::string task_path_, proc_path_, value_;
@@ -186,6 +196,8 @@ class TaskProfile {
     bool ExecuteForUID(uid_t uid) const;
     void EnableResourceCaching(ProfileAction::ResourceCacheType cache_type);
     void DropResourceCaching(ProfileAction::ResourceCacheType cache_type);
+    bool IsValidForProcess(uid_t uid, pid_t pid) const;
+    bool IsValidForTask(int tid) const;
 
   private:
     const std::string name_;
@@ -204,6 +216,8 @@ class ApplyProfileAction : public ProfileAction {
     bool ExecuteForTask(int tid) const override;
     void EnableResourceCaching(ProfileAction::ResourceCacheType cache_type) override;
     void DropResourceCaching(ProfileAction::ResourceCacheType cache_type) override;
+    bool IsValidForProcess(uid_t uid, pid_t pid) const override;
+    bool IsValidForTask(int tid) const override;
 
   private:
     std::vector<std::shared_ptr<TaskProfile>> profiles_;
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index 6a5b48bf3fd1..eadbe7697b07 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -175,6 +175,32 @@ TEST_P(SetAttributeFixture, SetAttribute) {
     }
 }
 
+class TaskProfileFixture : public TestWithParam<TestParam> {
+  public:
+    ~TaskProfileFixture() = default;
+};
+
+TEST_P(TaskProfileFixture, TaskProfile) {
+    // Treehugger runs host tests inside a container without cgroupv2 support.
+    if (!IsCgroupV2MountedRw()) {
+        GTEST_SKIP();
+        return;
+    }
+    const TestParam params = GetParam();
+    ProfileAttributeMock pa(params.attr_name);
+    // Test simple profile with one action
+    std::shared_ptr<TaskProfile> tp = std::make_shared<TaskProfile>("test_profile");
+    tp->Add(std::make_unique<SetAttributeAction>(&pa, params.attr_value, params.optional_attr));
+    EXPECT_EQ(tp->IsValidForProcess(getuid(), getpid()), params.result);
+    EXPECT_EQ(tp->IsValidForTask(getpid()), params.result);
+    // Test aggregate profile
+    TaskProfile tp2("meta_profile");
+    std::vector<std::shared_ptr<TaskProfile>> profiles = {tp};
+    tp2.Add(std::make_unique<ApplyProfileAction>(profiles));
+    EXPECT_EQ(tp2.IsValidForProcess(getuid(), getpid()), params.result);
+    EXPECT_EQ(tp2.IsValidForTask(getpid()), params.result);
+}
+
 // Test the four combinations of optional_attr {false, true} and cgroup attribute { does not exist,
 // exists }.
 INSTANTIATE_TEST_SUITE_P(
@@ -215,4 +241,28 @@ INSTANTIATE_TEST_SUITE_P(
                         .log_prefix = "Failed to write",
                         .log_suffix = geteuid() == 0 ? "Invalid argument" : "Permission denied"}));
 
+// Test TaskProfile IsValid calls.
+INSTANTIATE_TEST_SUITE_P(
+        TaskProfileTestSuite, TaskProfileFixture,
+        Values(
+                // Test operating on non-existing cgroup attribute fails.
+                TestParam{.attr_name = "no-such-attribute",
+                          .attr_value = ".",
+                          .optional_attr = false,
+                          .result = false},
+                // Test operating on optional non-existing cgroup attribute succeeds.
+                TestParam{.attr_name = "no-such-attribute",
+                          .attr_value = ".",
+                          .optional_attr = true,
+                          .result = true},
+                // Test operating on existing cgroup attribute succeeds.
+                TestParam{.attr_name = "cgroup.procs",
+                          .attr_value = ".",
+                          .optional_attr = false,
+                          .result = true},
+                // Test operating on optional existing cgroup attribute succeeds.
+                TestParam{.attr_name = "cgroup.procs",
+                          .attr_value = ".",
+                          .optional_attr = true,
+                          .result = true}));
 }  // namespace

From e80a6b6dd403ef0cabb35dfefa798a6e72d775d3 Mon Sep 17 00:00:00 2001
From: Vincent Donnefort <vdonnefort@google.com>
Date: Fri, 28 Apr 2023 09:30:23 +0100
Subject: [PATCH 0037/1487] ramdisk_node_list: Add urandom node

Bionic requires random numbers to init the shadow call stack. Those
numbers are obtained via the syscall getrandom (non-blocking) and will
fallback to /dev/urandom if the former fails.

When loading pKVM modules, we are so early in the boot process that the
only source of entropy for the linux RNG are the architecture random
number generators... which might be available on some platforms. Without
any source of entropy, the only way of generating a random number is to
try to generate some, which is what the bionic fallback expects via
urandom.

As a consequence, add the urandom node to the initramfs.

Bug: 274876849
Merged-In: I111e2db53fabd63d070b8e9ab9c52faebf484ab3
Change-Id: I34a0e3f7c72de7344512366d4a96183b445edc2e
---
 rootdir/ramdisk_node_list | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rootdir/ramdisk_node_list b/rootdir/ramdisk_node_list
index d3ab8a66ea89..4f45faaec47e 100644
--- a/rootdir/ramdisk_node_list
+++ b/rootdir/ramdisk_node_list
@@ -1,3 +1,4 @@
 dir dev 0755 0 0
 nod dev/null 0600 0 0 c 1 3
 nod dev/console 0600 0 0 c 5 1
+nod dev/urandom 0600 0 0 c 1 9

From ac9fbbcb05254d00d5b4f5c8d3d2827c28370ef6 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 2 May 2023 22:09:32 +0000
Subject: [PATCH 0038/1487] libsnapshot: Turn off vabc_legacy_tests on
 presubmit

Temporarily turn off these tests until root cause is found.

Bug: 279009697
Test: presubmit
Signed-off-by: Akilesh Kailash <akailash@google.com>
(cherry picked from https://android-review.googlesource.com/q/commit:defe8381aac9d461f6de8690b5917771b5f6752f)
Merged-In: I90f695fac318b71871ff60c1f74c90265437687d
Change-Id: I90f695fac318b71871ff60c1f74c90265437687d
---
 fs_mgr/TEST_MAPPING | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index db27cf000322..d357e4571dcf 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -24,9 +24,8 @@
     {
       "name": "vab_legacy_tests"
     },
-    {
-      "name": "vabc_legacy_tests"
-    },
+    // TODO: b/279009697
+    //{"name": "vabc_legacy_tests"},
     {
       "name": "cow_api_test"
     }
@@ -43,9 +42,8 @@
     },
     {
       "name": "vab_legacy_tests"
-    },
-    {
-      "name": "vabc_legacy_tests"
     }
+    // TODO: b/279009697
+    //{"name": "vabc_legacy_tests"}
   ]
 }

From 3f96053b3895f09b2887ee08ceda2bfcb857053d Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 3 May 2023 11:26:13 -0700
Subject: [PATCH 0039/1487] DO NOT MERGE: libsnapshot: Fix test failures on
 certain configurations.

Due to how CF is built and tested, VABC is enabled even when not
supported by the kernel. To work around this add some logic in
libsnapshot and the test harness to recognize this situation and
silently flip off the VABC flag.

This also fixes the -force_mode option to vts_libsnapshot_test, so that
it will skip tests that aren't supported by the device.

Bug: 264279496
Test: vts_libsnapshot_test on android13-gsi with 11-5.4 kernel
Change-Id: I9279d8d400cac5cd504a7ae91f254aae57fa856d
---
 fs_mgr/libsnapshot/snapshot.cpp      | 3 ++-
 fs_mgr/libsnapshot/snapshot_test.cpp | 4 ++--
 fs_mgr/libsnapshot/utility.cpp       | 7 +++++++
 fs_mgr/libsnapshot/utility.h         | 1 +
 4 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 019b64a44392..cd4c56048c20 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -3166,7 +3166,8 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
               << " writer.GetCowVersion(): " << writer.GetCowVersion();
 
     bool use_compression = IsCompressionEnabled() && dap_metadata.vabc_enabled() &&
-                           !device_->IsRecovery() && cow_format_support;
+                           !device_->IsRecovery() && cow_format_support &&
+                           KernelSupportsCompressedSnapshots();
 
     std::string compression_algorithm;
     if (use_compression) {
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index e7ffb1600cd1..a741134b8b6d 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2760,7 +2760,7 @@ bool IsDaemonRequired() {
         return true;
     }
 
-    return IsUserspaceSnapshotsEnabled();
+    return IsUserspaceSnapshotsEnabled() && KernelSupportsCompressedSnapshots();
 }
 
 bool ShouldUseCompression() {
@@ -2770,7 +2770,7 @@ bool ShouldUseCompression() {
     if (FLAGS_force_config == "vabc") {
         return true;
     }
-    return IsCompressionEnabled();
+    return IsCompressionEnabled() && KernelSupportsCompressedSnapshots();
 }
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/utility.cpp b/fs_mgr/libsnapshot/utility.cpp
index f01bec938788..841acf459168 100644
--- a/fs_mgr/libsnapshot/utility.cpp
+++ b/fs_mgr/libsnapshot/utility.cpp
@@ -26,7 +26,9 @@
 #include <android-base/properties.h>
 #include <android-base/strings.h>
 #include <fs_mgr/roots.h>
+#include <libdm/dm.h>
 
+using android::dm::DeviceMapper;
 using android::dm::kSectorSize;
 using android::fiemap::FiemapStatus;
 using android::fs_mgr::EnsurePathMounted;
@@ -208,5 +210,10 @@ bool IsDmSnapshotTestingEnabled() {
     return android::base::GetBoolProperty("snapuserd.test.dm.snapshots", false);
 }
 
+bool KernelSupportsCompressedSnapshots() {
+    auto& dm = DeviceMapper::Instance();
+    return dm.GetTargetByName("user", nullptr);
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/utility.h b/fs_mgr/libsnapshot/utility.h
index 0ef3234fd8ac..0794154c02c2 100644
--- a/fs_mgr/libsnapshot/utility.h
+++ b/fs_mgr/libsnapshot/utility.h
@@ -129,6 +129,7 @@ std::ostream& operator<<(std::ostream& os, const Now&);
 void AppendExtent(google::protobuf::RepeatedPtrField<chromeos_update_engine::Extent>* extents,
                   uint64_t start_block, uint64_t num_blocks);
 
+bool KernelSupportsCompressedSnapshots();
 bool IsCompressionEnabled();
 
 bool IsUserspaceSnapshotsEnabled();

From 778d7e80a6d9967a874944e3f02f0c04213bf31a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= <maze@google.com>
Date: Thu, 27 Apr 2023 19:27:23 +0000
Subject: [PATCH 0040/1487] remove inprocess tethering

Test: TreeHugger
Bug: 279942846
(cherry picked from https://android-review.googlesource.com/q/commit:e37468b295851b97db07936e15f53af660607cb4)
Merged-In: Ia3a5d289cceac96d310e04fbae3588789cc859ca
Change-Id: Ia3a5d289cceac96d310e04fbae3588789cc859ca
---
 libcutils/fs_config.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/libcutils/fs_config.cpp b/libcutils/fs_config.cpp
index 79d79dd4466f..f90a1bc3ca98 100644
--- a/libcutils/fs_config.cpp
+++ b/libcutils/fs_config.cpp
@@ -84,14 +84,12 @@ static const struct fs_path_config android_dirs[] = {
     { 00777, AID_ROOT,         AID_ROOT,         0, "sdcard" },
     { 00751, AID_ROOT,         AID_SDCARD_R,     0, "storage" },
     { 00750, AID_ROOT,         AID_SYSTEM,       0, "system/apex/com.android.tethering/bin/for-system" },
-    { 00750, AID_ROOT,         AID_SYSTEM,       0, "system/apex/com.android.tethering.inprocess/bin/for-system" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "system/bin" },
     { 00755, AID_ROOT,         AID_ROOT,         0, "system/etc/ppp" },
     { 00755, AID_ROOT,         AID_SHELL,        0, "system/vendor" },
     { 00750, AID_ROOT,         AID_SHELL,        0, "system/xbin" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "system/apex/*/bin" },
     { 00750, AID_ROOT,         AID_SYSTEM,       0, "system_ext/apex/com.android.tethering/bin/for-system" },
-    { 00750, AID_ROOT,         AID_SYSTEM,       0, "system_ext/apex/com.android.tethering.inprocess/bin/for-system" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "system_ext/bin" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "system_ext/apex/*/bin" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "vendor/bin" },
@@ -199,9 +197,7 @@ static const struct fs_path_config android_files[] = {
     // the following files have enhanced capabilities and ARE included
     // in user builds.
     { 06755, AID_CLAT,      AID_CLAT,      0, "system/apex/com.android.tethering/bin/for-system/clatd" },
-    { 06755, AID_CLAT,      AID_CLAT,      0, "system/apex/com.android.tethering.inprocess/bin/for-system/clatd" },
     { 06755, AID_CLAT,      AID_CLAT,      0, "system_ext/apex/com.android.tethering/bin/for-system/clatd" },
-    { 06755, AID_CLAT,      AID_CLAT,      0, "system_ext/apex/com.android.tethering.inprocess/bin/for-system/clatd" },
     { 00700, AID_SYSTEM,    AID_SHELL,     CAP_MASK_LONG(CAP_BLOCK_SUSPEND),
                                               "system/bin/inputflinger" },
     { 00750, AID_ROOT,      AID_SHELL,     CAP_MASK_LONG(CAP_SETUID) |

From 7c9c8f52e75daf30ae0cc6130c321769a23e320d Mon Sep 17 00:00:00 2001
From: Martin Stjernholm <mast@google.com>
Date: Thu, 11 May 2023 16:02:30 +0100
Subject: [PATCH 0041/1487] Run art_boot before odsign.

It's necessary to have the right dalvik.vm.* flags in place when they
are validated by odrefresh.

Test: See the other CL in the topic.
Bug: 281850017
Ignore-AOSP-First: Will cherry-pick to AOSP later
Change-Id: Ib64790dde97faaa6b62ead2c1c8dd53c97f97f9c
---
 rootdir/init.rc | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 7326783c838a..41c60a7f9dda 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1024,6 +1024,11 @@ on post-fs-data
     exec_start derive_classpath
     load_exports /data/system/environ/classpath
 
+    # Start ART's oneshot boot service to propagate boot experiment flags to
+    # dalvik.vm.*. This needs to be done before odsign since odrefresh uses and
+    # validates those properties against the signed cache-info.xml.
+    exec_start art_boot
+
     # Start the on-device signing daemon, and wait for it to finish, to ensure
     # ART artifacts are generated if needed.
     # Must start after 'derive_classpath' to have *CLASSPATH variables set.

From 6f742376bc81df0f281579ca5ef1824ea798e08b Mon Sep 17 00:00:00 2001
From: "Isaac J. Manjarres" <isaacmanjarres@google.com>
Date: Tue, 18 Apr 2023 18:01:30 -0700
Subject: [PATCH 0042/1487] Add support for reading modules.load.charger when
 booting into charger mode

When booting up, Android can boot into one of three modes: normal,
recovery, and charger mode. The set of modules that should be loaded
during first stage init in each mode can differ, which is why init
reads the list of modules to load from modules.load.recovery when
booting into recovery, and modules.load otherwise.

This means that init will read the list of modules to load during first
stage init from modules.load even when booting into charger mode. This
is not ideal, as it causes modules that need to be loaded during
first stage init only when booting into charger mode to also be loaded
during first stage init of normal boot, which can degrade boot time.

Thus, add support for reading modules.load.charger, which contains the
list of modules that need to be loaded during first stage init when
booting into charger mode.

Bug: 266752750
Change-Id: Ib9178bdfe5a6aac57b86b6d453b03625e95d5b48
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
---
 init/first_stage_init.cpp | 57 ++++++++++++++++++++++++++++++++-------
 1 file changed, 47 insertions(+), 10 deletions(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index 107e99a31554..bff80c5c731f 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -58,6 +58,12 @@ namespace init {
 
 namespace {
 
+enum class BootMode {
+    NORMAL_MODE,
+    RECOVERY_MODE,
+    CHARGER_MODE,
+};
+
 void FreeRamdisk(DIR* dir, dev_t dev) {
     int dfd = dirfd(dir);
 
@@ -149,13 +155,27 @@ void PrepareSwitchRoot() {
 }
 }  // namespace
 
-std::string GetModuleLoadList(bool recovery, const std::string& dir_path) {
-    auto module_load_file = "modules.load";
-    if (recovery) {
-        struct stat fileStat;
-        std::string recovery_load_path = dir_path + "/modules.load.recovery";
-        if (!stat(recovery_load_path.c_str(), &fileStat)) {
+std::string GetModuleLoadList(BootMode boot_mode, const std::string& dir_path) {
+    std::string module_load_file;
+
+    switch (boot_mode) {
+        case BootMode::NORMAL_MODE:
+            module_load_file = "modules.load";
+            break;
+        case BootMode::RECOVERY_MODE:
             module_load_file = "modules.load.recovery";
+            break;
+        case BootMode::CHARGER_MODE:
+            module_load_file = "modules.load.charger";
+            break;
+    }
+
+    if (module_load_file != "modules.load") {
+        struct stat fileStat;
+        std::string load_path = dir_path + "/" + module_load_file;
+        // Fall back to modules.load if the other files aren't accessible
+        if (stat(load_path.c_str(), &fileStat)) {
+            module_load_file = "modules.load";
         }
     }
 
@@ -163,7 +183,8 @@ std::string GetModuleLoadList(bool recovery, const std::string& dir_path) {
 }
 
 #define MODULE_BASE_DIR "/lib/modules"
-bool LoadKernelModules(bool recovery, bool want_console, bool want_parallel, int& modules_loaded) {
+bool LoadKernelModules(BootMode boot_mode, bool want_console, bool want_parallel,
+                       int& modules_loaded) {
     struct utsname uts;
     if (uname(&uts)) {
         LOG(FATAL) << "Failed to get kernel version.";
@@ -203,7 +224,7 @@ bool LoadKernelModules(bool recovery, bool want_console, bool want_parallel, int
     for (const auto& module_dir : module_dirs) {
         std::string dir_path = MODULE_BASE_DIR "/";
         dir_path.append(module_dir);
-        Modprobe m({dir_path}, GetModuleLoadList(recovery, dir_path));
+        Modprobe m({dir_path}, GetModuleLoadList(boot_mode, dir_path));
         bool retval = m.LoadListedModules(!want_console);
         modules_loaded = m.GetModuleCount();
         if (modules_loaded > 0) {
@@ -211,7 +232,7 @@ bool LoadKernelModules(bool recovery, bool want_console, bool want_parallel, int
         }
     }
 
-    Modprobe m({MODULE_BASE_DIR}, GetModuleLoadList(recovery, MODULE_BASE_DIR));
+    Modprobe m({MODULE_BASE_DIR}, GetModuleLoadList(boot_mode, MODULE_BASE_DIR));
     bool retval = (want_parallel) ? m.LoadModulesParallel(std::thread::hardware_concurrency())
                                   : m.LoadListedModules(!want_console);
     modules_loaded = m.GetModuleCount();
@@ -221,6 +242,21 @@ bool LoadKernelModules(bool recovery, bool want_console, bool want_parallel, int
     return true;
 }
 
+static bool IsChargerMode(const std::string& cmdline, const std::string& bootconfig) {
+    return bootconfig.find("androidboot.mode = \"charger\"") != std::string::npos ||
+            cmdline.find("androidboot.mode=charger") != std::string::npos;
+}
+
+static BootMode GetBootMode(const std::string& cmdline, const std::string& bootconfig)
+{
+    if (IsChargerMode(cmdline, bootconfig))
+        return BootMode::CHARGER_MODE;
+    else if (IsRecoveryMode() && !ForceNormalBoot(cmdline, bootconfig))
+        return BootMode::RECOVERY_MODE;
+
+    return BootMode::NORMAL_MODE;
+}
+
 int FirstStageMain(int argc, char** argv) {
     if (REBOOT_BOOTLOADER_ON_PANIC) {
         InstallRebootSignalHandlers();
@@ -328,7 +364,8 @@ int FirstStageMain(int argc, char** argv) {
 
     boot_clock::time_point module_start_time = boot_clock::now();
     int module_count = 0;
-    if (!LoadKernelModules(IsRecoveryMode() && !ForceNormalBoot(cmdline, bootconfig), want_console,
+    BootMode boot_mode = GetBootMode(cmdline, bootconfig);
+    if (!LoadKernelModules(boot_mode, want_console,
                            want_parallel, module_count)) {
         if (want_console != FirstStageConsoleParam::DISABLED) {
             LOG(ERROR) << "Failed to load kernel modules, starting console";

From 878406e7f1d6ecec51bca80f834011e0ba2f1126 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Fri, 12 May 2023 16:29:02 -0700
Subject: [PATCH 0043/1487] Revert "task_profiles.json: Convert tabs into
 spaces"

This reverts commit 6ad747ac2d3d0508a9a9223c8d0a2acbad513c29.

Bug: 261857030
Ignore-AOSP-First: this change is for the U branch only.
Change-Id: I93447b71146e6e9297ef49026d90dc4c35b91244
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 libprocessgroup/profiles/task_profiles.json | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index e44d3bf727df..4b8fc19db7c6 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -462,7 +462,7 @@
           {
             "Controller": "blkio",
             "Path": "background"
-          }
+	  }
         },
         {
           "Name": "SetAttribute",
@@ -502,7 +502,7 @@
           {
             "Controller": "blkio",
             "Path": ""
-          }
+	  }
         },
         {
           "Name": "SetAttribute",
@@ -542,7 +542,7 @@
           {
             "Controller": "blkio",
             "Path": ""
-          }
+	  }
         },
         {
           "Name": "SetAttribute",
@@ -582,7 +582,7 @@
           {
             "Controller": "blkio",
             "Path": ""
-          }
+	  }
         },
         {
           "Name": "SetAttribute",

From f4a3d72ee8f35fb7bd8e750c1d7b3bd182bb3c3e Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Fri, 12 May 2023 16:29:39 -0700
Subject: [PATCH 0044/1487] Revert "Updating Attributes on task_profiles.json"

This reverts commit 92153fb955cd2c59cf9eba07461ddaba1c3d7792.

Bug: 261857030
Ignore-AOSP-First: this change is for the U branch only.
Change-Id: I99417707f0d0b8c7dca3927b6ce9d52436621f4e
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 libprocessgroup/profiles/task_profiles.json | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 4b8fc19db7c6..c485097882fc 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -80,20 +80,17 @@
     {
       "Name": "BfqWeight",
       "Controller": "io",
-      "File": "blkio.bfq.weight",
-      "FileV2": "io.bfq.weight"
+      "File": "io.bfq.weight"
     },
     {
       "Name": "CfqGroupIdle",
       "Controller": "io",
-      "File": "blkio.group_idle",
-      "FileV2": "io.group_idle"
+      "File": "io.group_idle"
     },
     {
       "Name": "CfqWeight",
       "Controller": "io",
-      "File": "blkio.weight",
-      "FileV2": "io.weight"
+      "File": "io.weight"
     }
   ],
 

From 9fe04000806f9f4d74771e6421e8d3c078fe1887 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Fri, 12 May 2023 16:29:43 -0700
Subject: [PATCH 0045/1487] Revert "libprocessgroup: Add I/O scheduler
 attributes to task_profiles.json"

This reverts commit 9c0fcbb0f7107d455a004719f40435a2a2318fda.

Bug: 261857030
Ignore-AOSP-First: this change is for the U branch only.
Change-Id: Id4bd3494b33dd6bc0644406d599c9bfd597c7435
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 libprocessgroup/profiles/task_profiles.json | 123 --------------------
 1 file changed, 123 deletions(-)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index c485097882fc..1fc66ba10a64 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -76,21 +76,6 @@
       "Name": "FreezerState",
       "Controller": "freezer",
       "File": "cgroup.freeze"
-    },
-    {
-      "Name": "BfqWeight",
-      "Controller": "io",
-      "File": "io.bfq.weight"
-    },
-    {
-      "Name": "CfqGroupIdle",
-      "Controller": "io",
-      "File": "io.group_idle"
-    },
-    {
-      "Name": "CfqWeight",
-      "Controller": "io",
-      "File": "io.weight"
     }
   ],
 
@@ -459,33 +444,6 @@
           {
             "Controller": "blkio",
             "Path": "background"
-	  }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "BfqWeight",
-            "Value": "10",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "CfqGroupIdle",
-            "Value": "0",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "CfqWeight",
-            "Value": "200",
-            "Optional": "true"
           }
         }
       ]
@@ -499,33 +457,6 @@
           {
             "Controller": "blkio",
             "Path": ""
-	  }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "BfqWeight",
-            "Value": "100",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "CfqGroupIdle",
-            "Value": "0",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "CfqWeight",
-            "Value": "1000",
-            "Optional": "true"
           }
         }
       ]
@@ -539,33 +470,6 @@
           {
             "Controller": "blkio",
             "Path": ""
-	  }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "BfqWeight",
-            "Value": "100",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "CfqGroupIdle",
-            "Value": "0",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "CfqWeight",
-            "Value": "1000",
-            "Optional": "true"
           }
         }
       ]
@@ -579,33 +483,6 @@
           {
             "Controller": "blkio",
             "Path": ""
-	  }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "BfqWeight",
-            "Value": "100",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "CfqGroupIdle",
-            "Value": "0",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "CfqWeight",
-            "Value": "1000",
-            "Optional": "true"
           }
         }
       ]

From a37c4d2796779444a59f6cac8384b62e66e78f1e Mon Sep 17 00:00:00 2001
From: JW Wang <wangchun@google.com>
Date: Sat, 18 Feb 2023 15:16:17 +0800
Subject: [PATCH 0046/1487] Export active dsu slot to system prop

The prop can be consumed by init scripts to do customized setup:

on property:ro.gsid.dsu_slot=oemtest
    # Do setup for test
on property:ro.gsid.dsu_slot=oemdemo
    # Do setup for demo

Bug: 277691885
Test: m
Change-Id: I7bd78b9ba31021b27d57c6f092dad5d7ebf6e59b
---
 init/init.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/init/init.cpp b/init/init.cpp
index be1ebeed7cc0..da63fdc3bda5 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -1043,6 +1043,12 @@ int SecondStageMain(int argc, char** argv) {
     SetProperty(gsi::kGsiBootedProp, is_running);
     auto is_installed = android::gsi::IsGsiInstalled() ? "1" : "0";
     SetProperty(gsi::kGsiInstalledProp, is_installed);
+    if (android::gsi::IsGsiRunning()) {
+        std::string dsu_slot;
+        if (android::gsi::GetActiveDsu(&dsu_slot)) {
+            SetProperty(gsi::kDsuSlotProp, dsu_slot);
+        }
+    }
 
     am.QueueBuiltinAction(SetupCgroupsAction, "SetupCgroups");
     am.QueueBuiltinAction(SetKptrRestrictAction, "SetKptrRestrict");

From 655a03f7c2126e34fb7854840ade17a0380adb69 Mon Sep 17 00:00:00 2001
From: Martin Stjernholm <mast@google.com>
Date: Mon, 15 May 2023 19:29:00 +0000
Subject: [PATCH 0047/1487] Run art_boot before odsign.

It's necessary to have the right dalvik.vm.* flags in place when they
are validated by odrefresh.

Test: See the other CL in the topic.
Bug: 281850017
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:7c9c8f52e75daf30ae0cc6130c321769a23e320d)
Merged-In: Ib64790dde97faaa6b62ead2c1c8dd53c97f97f9c
Change-Id: Ib64790dde97faaa6b62ead2c1c8dd53c97f97f9c
---
 rootdir/init.rc | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index d755b503d670..fdad27397473 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1004,6 +1004,11 @@ on post-fs-data
     exec_start derive_classpath
     load_exports /data/system/environ/classpath
 
+    # Start ART's oneshot boot service to propagate boot experiment flags to
+    # dalvik.vm.*. This needs to be done before odsign since odrefresh uses and
+    # validates those properties against the signed cache-info.xml.
+    exec_start art_boot
+
     # Start the on-device signing daemon, and wait for it to finish, to ensure
     # ART artifacts are generated if needed.
     # Must start after 'derive_classpath' to have *CLASSPATH variables set.

From d2d320ab0b442a887a0ef2457d28ab4cdd214f28 Mon Sep 17 00:00:00 2001
From: Pawan Wagh <waghpawan@google.com>
Date: Mon, 15 May 2023 22:25:55 +0000
Subject: [PATCH 0048/1487] Return error from gatekeeperd

Instead of crashing the gatekeeperd on incorrect
inputs to AIDL interface, return errors from the
service.

Test: m gatekeeperd, booted device
Bug: 279970163
Change-Id: Ifd3330e749f4ce147db5886f1f2dbb00c322bed2
---
 gatekeeperd/gatekeeperd.cpp | 39 +++++++++++++++++++++++++++++--------
 gatekeeperd/gatekeeperd.h   |  2 +-
 2 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/gatekeeperd/gatekeeperd.cpp b/gatekeeperd/gatekeeperd.cpp
index e5241b5842a7..7987167662dc 100644
--- a/gatekeeperd/gatekeeperd.cpp
+++ b/gatekeeperd/gatekeeperd.cpp
@@ -144,14 +144,22 @@ void GateKeeperProxy::clear_sid(uint32_t userId) {
     }
 }
 
-uint32_t GateKeeperProxy::adjust_userId(uint32_t userId) {
+Status GateKeeperProxy::adjust_userId(uint32_t userId, uint32_t* hw_userId) {
     static constexpr uint32_t kGsiOffset = 1000000;
-    CHECK(userId < kGsiOffset);
-    CHECK((aidl_hw_device != nullptr) || (hw_device != nullptr));
+    if (userId >= kGsiOffset) {
+        return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT);
+    }
+
+    if ((aidl_hw_device == nullptr) && (hw_device == nullptr)) {
+        return Status::fromExceptionCode(Status::EX_ILLEGAL_STATE);
+    }
+
     if (is_running_gsi) {
-        return userId + kGsiOffset;
+        *hw_userId = userId + kGsiOffset;
+        return Status::ok();
     }
-    return userId;
+    *hw_userId = userId;
+    return Status::ok();
 }
 
 #define GK_ERROR *gkResponse = GKResponse::error(), Status::ok()
@@ -201,7 +209,12 @@ Status GateKeeperProxy::enroll(int32_t userId,
     android::hardware::hidl_vec<uint8_t> newPwd;
     newPwd.setToExternal(const_cast<uint8_t*>(desiredPassword.data()), desiredPassword.size());
 
-    uint32_t hw_userId = adjust_userId(userId);
+    uint32_t hw_userId = 0;
+    Status result = adjust_userId(userId, &hw_userId);
+    if (!result.isOk()) {
+        return result;
+    }
+
     uint64_t secureUserId = 0;
     if (aidl_hw_device) {
         // AIDL gatekeeper service
@@ -300,7 +313,12 @@ Status GateKeeperProxy::verifyChallenge(int32_t userId, int64_t challenge,
         }
     }
 
-    uint32_t hw_userId = adjust_userId(userId);
+    uint32_t hw_userId = 0;
+    Status result = adjust_userId(userId, &hw_userId);
+    if (!result.isOk()) {
+        return result;
+    }
+
     android::hardware::hidl_vec<uint8_t> curPwdHandle;
     curPwdHandle.setToExternal(const_cast<uint8_t*>(enrolledPasswordHandle.data()),
                                enrolledPasswordHandle.size());
@@ -410,7 +428,12 @@ Status GateKeeperProxy::clearSecureUserId(int32_t userId) {
     }
     clear_sid(userId);
 
-    uint32_t hw_userId = adjust_userId(userId);
+    uint32_t hw_userId = 0;
+    Status result = adjust_userId(userId, &hw_userId);
+    if (!result.isOk()) {
+        return result;
+    }
+
     if (aidl_hw_device) {
         aidl_hw_device->deleteUser(hw_userId);
     } else if (hw_device) {
diff --git a/gatekeeperd/gatekeeperd.h b/gatekeeperd/gatekeeperd.h
index 29873da29381..b1f08c6113b9 100644
--- a/gatekeeperd/gatekeeperd.h
+++ b/gatekeeperd/gatekeeperd.h
@@ -47,7 +47,7 @@ class GateKeeperProxy : public BnGateKeeperService {
 
     // This should only be called on userIds being passed to the GateKeeper HAL. It ensures that
     // secure storage shared across a GSI image and a host image will not overlap.
-    uint32_t adjust_userId(uint32_t userId);
+    Status adjust_userId(uint32_t userId, uint32_t* hw_userId);
 
 #define GK_ERROR *gkResponse = GKResponse::error(), Status::ok()
 

From ce09cdff6213522f4429cabf72950bffaf0f6c1e Mon Sep 17 00:00:00 2001
From: JW Wang <wangchun@google.com>
Date: Sat, 18 Feb 2023 15:16:17 +0800
Subject: [PATCH 0049/1487] Export active dsu slot to system prop

The prop can be consumed by init scripts to do customized setup:

on property:ro.gsid.dsu_slot=oemtest
    # Do setup for test
on property:ro.gsid.dsu_slot=oemdemo
    # Do setup for demo

Bug: 277691885
Test: m
Change-Id: I7bd78b9ba31021b27d57c6f092dad5d7ebf6e59b
Merged-In: I7bd78b9ba31021b27d57c6f092dad5d7ebf6e59b
Cherry-picked from aosp/2588465
---
 init/init.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/init/init.cpp b/init/init.cpp
index be1ebeed7cc0..da63fdc3bda5 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -1043,6 +1043,12 @@ int SecondStageMain(int argc, char** argv) {
     SetProperty(gsi::kGsiBootedProp, is_running);
     auto is_installed = android::gsi::IsGsiInstalled() ? "1" : "0";
     SetProperty(gsi::kGsiInstalledProp, is_installed);
+    if (android::gsi::IsGsiRunning()) {
+        std::string dsu_slot;
+        if (android::gsi::GetActiveDsu(&dsu_slot)) {
+            SetProperty(gsi::kDsuSlotProp, dsu_slot);
+        }
+    }
 
     am.QueueBuiltinAction(SetupCgroupsAction, "SetupCgroups");
     am.QueueBuiltinAction(SetKptrRestrictAction, "SetKptrRestrict");

From 4066926374ef7cadbd29789c8ddf6698801557ab Mon Sep 17 00:00:00 2001
From: Mike McTernan <mikemcternan@google.com>
Date: Tue, 16 May 2023 09:05:29 +0100
Subject: [PATCH 0050/1487] confirmationui:fuzzer: update contact details

Bug: None
Test: make trusty_confirmationui_tipc_fuzzer
Change-Id: Ie81bf916c41498abc226389f63b22b57da55d446
---
 trusty/confirmationui/fuzz/Android.bp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/trusty/confirmationui/fuzz/Android.bp b/trusty/confirmationui/fuzz/Android.bp
index 47809433a449..96804bd4bdad 100644
--- a/trusty/confirmationui/fuzz/Android.bp
+++ b/trusty/confirmationui/fuzz/Android.bp
@@ -26,7 +26,8 @@ cc_fuzz {
         "-DTRUSTY_APP_FILENAME=\"confirmationui.syms.elf\"",
     ],
     fuzz_config: {
-       cc: ["trong@google.com"],
+       cc: ["mikemcternan@google.com"],
+       componentid: 1290237,
     },
 
 }
@@ -40,7 +41,8 @@ cc_fuzz {
         "libdmabufheap",
     ],
     fuzz_config: {
-       cc: ["trong@google.com"],
+       cc: ["mikemcternan@google.com"],
+       componentid: 1290237,
     },
 
     // The initial corpus for this fuzzer was derived by dumping messages from/to

From 880656af8191a3bb906134dd23cd5ea680f9087a Mon Sep 17 00:00:00 2001
From: David Drysdale <drysdale@google.com>
Date: Tue, 16 May 2023 10:41:36 +0100
Subject: [PATCH 0051/1487] Add tipc fuzzer for KeyMint/Rust

Also update fuzz config for the KeyMint/C++ fuzzer

Test: trusty_keymint_fuzzer
Change-Id: Ic96c572ff6d154afefba280667c23e4e324d7751
---
 trusty/keymaster/fuzz/Android.bp              |   4 +-
 trusty/keymint/fuzz/Android.bp                |  37 ++++++++++++++++++
 .../keymint/fuzz/corpus/keymint-reqs-821180-0 |   1 +
 .../fuzz/corpus/keymint-reqs-82128140-0       |   1 +
 .../fuzz/corpus/keymint-reqs-82128143-0       |   1 +
 .../fuzz/corpus/keymint-reqs-82128158-0       |   1 +
 .../fuzz/corpus/keymint-reqs-82128158-1       |   2 +
 .../fuzz/corpus/keymint-reqs-82138285-0       | Bin 0 -> 48 bytes
 .../fuzz/corpus/keymint-reqs-82138285-1       | Bin 0 -> 48 bytes
 .../fuzz/corpus/keymint-reqs-82138285-2       | Bin 0 -> 48 bytes
 .../fuzz/corpus/keymint-reqs-82138285-3       | Bin 0 -> 48 bytes
 .../fuzz/corpus/keymint-reqs-82138286-0       | Bin 0 -> 61 bytes
 .../fuzz/corpus/keymint-reqs-82138286-1       | Bin 0 -> 61 bytes
 .../fuzz/corpus/keymint-reqs-82138286-2       | Bin 0 -> 61 bytes
 .../fuzz/corpus/keymint-reqs-82138286-3       | Bin 0 -> 55 bytes
 .../fuzz/corpus/keymint-reqs-82138287-0       | Bin 0 -> 68 bytes
 .../fuzz/corpus/keymint-reqs-82138287-1       | Bin 0 -> 68 bytes
 .../fuzz/corpus/keymint-reqs-82138287-2       | Bin 0 -> 68 bytes
 .../fuzz/corpus/keymint-reqs-82138287-3       | Bin 0 -> 67 bytes
 .../fuzz/corpus/keymint-reqs-82138288-0       | Bin 0 -> 1481 bytes
 .../fuzz/corpus/keymint-reqs-82138288-1       | Bin 0 -> 75 bytes
 .../fuzz/corpus/keymint-reqs-82138288-2       | Bin 0 -> 65 bytes
 .../fuzz/corpus/keymint-reqs-82138288-3       | Bin 0 -> 73 bytes
 .../fuzz/corpus/keymint-reqs-82138289-0       | Bin 0 -> 80 bytes
 .../fuzz/corpus/keymint-reqs-82138289-1       | Bin 0 -> 392 bytes
 .../fuzz/corpus/keymint-reqs-82138289-2       | Bin 0 -> 407 bytes
 .../fuzz/corpus/keymint-reqs-82138289-3       | Bin 0 -> 1494 bytes
 .../fuzz/corpus/keymint-reqs-8213828a-0       | Bin 0 -> 466 bytes
 .../fuzz/corpus/keymint-reqs-8213828a-1       | Bin 0 -> 1504 bytes
 .../fuzz/corpus/keymint-reqs-8213828a-2       | Bin 0 -> 1502 bytes
 .../fuzz/corpus/keymint-reqs-8213828a-3       | Bin 0 -> 130 bytes
 .../fuzz/corpus/keymint-reqs-8213828b-0       | Bin 0 -> 139 bytes
 .../fuzz/corpus/keymint-reqs-8213828b-1       | Bin 0 -> 1555 bytes
 .../fuzz/corpus/keymint-reqs-8213828b-2       | Bin 0 -> 130 bytes
 .../fuzz/corpus/keymint-reqs-8213828b-3       | Bin 0 -> 1553 bytes
 .../fuzz/corpus/keymint-reqs-8213828c-0       | Bin 0 -> 137 bytes
 .../fuzz/corpus/keymint-reqs-8213828c-1       | Bin 0 -> 1518 bytes
 .../fuzz/corpus/keymint-reqs-8213828c-2       | Bin 0 -> 146 bytes
 .../fuzz/corpus/keymint-reqs-8213828c-3       | Bin 0 -> 1542 bytes
 .../fuzz/corpus/keymint-reqs-8213828d-0       | Bin 0 -> 140 bytes
 .../fuzz/corpus/keymint-reqs-8213828d-1       | Bin 0 -> 124 bytes
 .../fuzz/corpus/keymint-reqs-8213828d-2       | Bin 0 -> 139 bytes
 .../fuzz/corpus/keymint-reqs-8213828d-3       | Bin 0 -> 139 bytes
 .../fuzz/corpus/keymint-reqs-8213828e-0       | Bin 0 -> 129 bytes
 .../fuzz/corpus/keymint-reqs-8213828e-1       | Bin 0 -> 151 bytes
 .../fuzz/corpus/keymint-reqs-8213828e-2       | Bin 0 -> 151 bytes
 .../fuzz/corpus/keymint-reqs-8213828e-3       | Bin 0 -> 151 bytes
 .../fuzz/corpus/keymint-reqs-8213828f-0       | Bin 0 -> 370 bytes
 .../fuzz/corpus/keymint-reqs-8213828f-1       | Bin 0 -> 370 bytes
 .../fuzz/corpus/keymint-reqs-8213828f-2       | Bin 0 -> 286 bytes
 .../fuzz/corpus/keymint-reqs-8213828f-3       | Bin 0 -> 280 bytes
 .../fuzz/corpus/keymint-reqs-82138290-0       | Bin 0 -> 131 bytes
 .../fuzz/corpus/keymint-reqs-82138290-1       | Bin 0 -> 131 bytes
 .../fuzz/corpus/keymint-reqs-82138292-0       | Bin 0 -> 145 bytes
 .../fuzz/corpus/keymint-reqs-82148485-0       | Bin 0 -> 83 bytes
 .../fuzz/corpus/keymint-reqs-82148485-1       | Bin 0 -> 59 bytes
 .../fuzz/corpus/keymint-reqs-82148485-2       | Bin 0 -> 83 bytes
 .../fuzz/corpus/keymint-reqs-82148485-3       | Bin 0 -> 59 bytes
 .../fuzz/corpus/keymint-reqs-82148486-0       | Bin 0 -> 106 bytes
 .../fuzz/corpus/keymint-reqs-82148486-1       | Bin 0 -> 90 bytes
 .../fuzz/corpus/keymint-reqs-82148486-2       | Bin 0 -> 106 bytes
 .../fuzz/corpus/keymint-reqs-82148486-3       | Bin 0 -> 106 bytes
 .../fuzz/corpus/keymint-reqs-82148487-0       | Bin 0 -> 79 bytes
 .../fuzz/corpus/keymint-reqs-82148487-1       | Bin 0 -> 80 bytes
 .../fuzz/corpus/keymint-reqs-82148487-2       | Bin 0 -> 80 bytes
 .../fuzz/corpus/keymint-reqs-82148487-3       | Bin 0 -> 80 bytes
 .../fuzz/corpus/keymint-reqs-82148488-0       | Bin 0 -> 222 bytes
 .../fuzz/corpus/keymint-reqs-82148488-1       | Bin 0 -> 210 bytes
 .../fuzz/corpus/keymint-reqs-82148488-2       | Bin 0 -> 107 bytes
 .../fuzz/corpus/keymint-reqs-82148488-3       | Bin 0 -> 706 bytes
 .../fuzz/corpus/keymint-reqs-82148489-0       | Bin 0 -> 715 bytes
 .../fuzz/corpus/keymint-reqs-82148489-1       | Bin 0 -> 719 bytes
 .../fuzz/corpus/keymint-reqs-82148489-2       | Bin 0 -> 217 bytes
 .../fuzz/corpus/keymint-reqs-82148489-3       | Bin 0 -> 217 bytes
 .../fuzz/corpus/keymint-reqs-8214848a-0       | Bin 0 -> 1310 bytes
 .../fuzz/corpus/keymint-reqs-8214848a-1       | Bin 0 -> 104 bytes
 .../fuzz/corpus/keymint-reqs-8214848a-2       | Bin 0 -> 726 bytes
 .../fuzz/corpus/keymint-reqs-8214848a-3       | Bin 0 -> 1311 bytes
 .../fuzz/corpus/keymint-reqs-8214848b-0       | Bin 0 -> 1317 bytes
 .../fuzz/corpus/keymint-reqs-82158659-0       | Bin 0 -> 1837 bytes
 .../fuzz/corpus/keymint-reqs-82158659-1       | Bin 0 -> 1839 bytes
 .../fuzz/corpus/keymint-reqs-82158659-2       | Bin 0 -> 1837 bytes
 .../fuzz/corpus/keymint-reqs-82158659-3       | Bin 0 -> 1837 bytes
 .../fuzz/corpus/keymint-reqs-82168258-0       |   1 +
 .../fuzz/corpus/keymint-reqs-82168258-1       | Bin 0 -> 206 bytes
 .../fuzz/corpus/keymint-reqs-82178158-0       | Bin 0 -> 206 bytes
 .../fuzz/corpus/keymint-reqs-82178158-1       | Bin 0 -> 205 bytes
 .../fuzz/corpus/keymint-reqs-82178158-2       | Bin 0 -> 205 bytes
 .../fuzz/corpus/keymint-reqs-82178158-3       | Bin 0 -> 201 bytes
 .../fuzz/corpus/keymint-reqs-82178159-0       | Bin 0 -> 314 bytes
 .../fuzz/corpus/keymint-reqs-82178159-1       | Bin 0 -> 314 bytes
 .../fuzz/corpus/keymint-reqs-82178159-2       | Bin 0 -> 314 bytes
 .../fuzz/corpus/keymint-reqs-82178159-3       | Bin 0 -> 314 bytes
 .../fuzz/corpus/keymint-reqs-82181a84-0       | Bin 0 -> 326 bytes
 .../fuzz/corpus/keymint-reqs-82181a84-1       | Bin 0 -> 272 bytes
 .../fuzz/corpus/keymint-reqs-82181a84-2       | Bin 0 -> 326 bytes
 .../fuzz/corpus/keymint-reqs-82181a84-3       | Bin 0 -> 326 bytes
 .../fuzz/corpus/keymint-reqs-82181e83-0       | Bin 0 -> 208 bytes
 .../fuzz/corpus/keymint-reqs-82181e83-1       | Bin 0 -> 308 bytes
 .../fuzz/corpus/keymint-reqs-82181e83-2       | Bin 0 -> 308 bytes
 .../fuzz/corpus/keymint-reqs-82181e83-3       | Bin 0 -> 308 bytes
 .../fuzz/corpus/keymint-reqs-82183184-0       |   1 +
 .../fuzz/corpus/keymint-reqs-82183184-1       |   1 +
 .../fuzz/corpus/keymint-reqs-82183184-2       |   1 +
 .../fuzz/corpus/keymint-reqs-82183184-3       |   1 +
 .../fuzz/corpus/keymint-reqs-82183284-0       |   1 +
 .../fuzz/corpus/keymint-reqs-82183284-1       | Bin 0 -> 17 bytes
 .../fuzz/corpus/keymint-reqs-82183284-2       |   1 +
 .../fuzz/corpus/keymint-reqs-82183284-3       |   2 +
 .../fuzz/corpus/keymint-reqs-82183386-0       | Bin 0 -> 86 bytes
 .../fuzz/corpus/keymint-reqs-82183386-1       |   1 +
 .../fuzz/corpus/keymint-reqs-82183386-2       | Bin 0 -> 86 bytes
 .../fuzz/corpus/keymint-reqs-82183386-3       | Bin 0 -> 90 bytes
 .../fuzz/corpus/keymint-reqs-82183481-0       |   1 +
 .../fuzz/corpus/keymint-reqs-82183481-1       |   1 +
 .../fuzz/corpus/keymint-reqs-82183481-2       |   1 +
 .../fuzz/corpus/keymint-reqs-82183481-3       |   1 +
 .../fuzz/corpus/keymint-reqs-82184180-0       |   1 +
 .../fuzz/corpus/keymint-reqs-82184281-0       |   1 +
 .../fuzz/corpus/keymint-rsps-00035504-0       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-001e170d-0       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-00303031-0       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-00313563-0       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-00333233-0       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-00365a17-0       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-003cc0cc-0       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-003e7b1a-0       | Bin 0 -> 1975 bytes
 .../keymint/fuzz/corpus/keymint-rsps-0042-0   | Bin 0 -> 2 bytes
 .../fuzz/corpus/keymint-rsps-00646630-0       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-00820081-0       | Bin 0 -> 361 bytes
 .../fuzz/corpus/keymint-rsps-00820081-1       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-00820081-2       | Bin 0 -> 35 bytes
 .../fuzz/corpus/keymint-rsps-00820081-3       | Bin 0 -> 381 bytes
 .../fuzz/corpus/keymint-rsps-00822180-0       | Bin 0 -> 4 bytes
 .../fuzz/corpus/keymint-rsps-00822280-0       | Bin 0 -> 4 bytes
 .../fuzz/corpus/keymint-rsps-00822580-0       | Bin 0 -> 4 bytes
 .../fuzz/corpus/keymint-rsps-00822680-0       | Bin 0 -> 4 bytes
 .../fuzz/corpus/keymint-rsps-00822780-0       | Bin 0 -> 4 bytes
 .../fuzz/corpus/keymint-rsps-00822880-0       | Bin 0 -> 4 bytes
 .../fuzz/corpus/keymint-rsps-00822980-0       | Bin 0 -> 4 bytes
 .../fuzz/corpus/keymint-rsps-00822a80-0       | Bin 0 -> 4 bytes
 .../fuzz/corpus/keymint-rsps-00822b80-0       | Bin 0 -> 4 bytes
 .../fuzz/corpus/keymint-rsps-00822c80-0       | Bin 0 -> 4 bytes
 .../fuzz/corpus/keymint-rsps-00823080-0       | Bin 0 -> 4 bytes
 .../fuzz/corpus/keymint-rsps-00823480-0       | Bin 0 -> 4 bytes
 .../fuzz/corpus/keymint-rsps-00823819-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-0082381d-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-0082381e-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-00823820-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-00823825-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-00823827-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-0082382b-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-00823833-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-00823836-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-00823837-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-00823838-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-00823839-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-0082383a-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-0082383e-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-00823840-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-00823841-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-00823846-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-0082384d-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-0082384e-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-0082384f-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-00823850-0       | Bin 0 -> 5 bytes
 .../fuzz/corpus/keymint-rsps-00823903-0       | Bin 0 -> 6 bytes
 .../fuzz/corpus/keymint-rsps-009a81fa-0       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-00b5ae79-0       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-01820081-0       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-01820081-1       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-01820081-2       | Bin 0 -> 1975 bytes
 .../fuzz/corpus/keymint-rsps-01820081-3       | Bin 0 -> 1975 bytes
 173 files changed, 62 insertions(+), 1 deletion(-)
 create mode 100644 trusty/keymint/fuzz/Android.bp
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-821180-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82128140-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82128143-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82128158-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82128158-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138285-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138285-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138285-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138285-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138286-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138286-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138286-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138286-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138287-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138287-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138287-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138287-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138288-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138288-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138288-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138288-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138289-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138289-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138289-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138289-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828a-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828a-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828a-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828a-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828b-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828b-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828b-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828b-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828c-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828c-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828c-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828c-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828d-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828d-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828d-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828d-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828e-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828e-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828e-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828e-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828f-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828f-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828f-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8213828f-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138290-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138290-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82138292-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148485-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148485-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148485-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148485-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148486-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148486-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148486-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148486-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148487-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148487-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148487-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148487-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148488-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148488-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148488-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148488-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148489-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148489-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148489-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82148489-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8214848a-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8214848a-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8214848a-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8214848a-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-8214848b-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82158659-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82158659-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82158659-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82158659-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82168258-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82168258-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82178158-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82178158-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82178158-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82178158-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82178159-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82178159-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82178159-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82178159-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82181a84-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82181a84-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82181a84-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82181a84-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82181e83-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82181e83-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82181e83-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82181e83-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183184-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183184-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183184-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183184-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183284-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183284-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183284-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183284-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183386-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183386-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183386-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183386-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183481-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183481-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183481-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82183481-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82184180-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-reqs-82184281-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00035504-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-001e170d-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00303031-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00313563-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00333233-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00365a17-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-003cc0cc-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-003e7b1a-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-0042-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00646630-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00820081-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00820081-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00820081-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00820081-3
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00822180-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00822280-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00822580-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00822680-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00822780-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00822880-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00822980-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00822a80-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00822b80-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00822c80-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823080-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823480-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823819-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-0082381d-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-0082381e-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823820-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823825-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823827-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-0082382b-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823833-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823836-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823837-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823838-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823839-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-0082383a-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-0082383e-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823840-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823841-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823846-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-0082384d-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-0082384e-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-0082384f-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823850-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00823903-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-009a81fa-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-00b5ae79-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-01820081-0
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-01820081-1
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-01820081-2
 create mode 100644 trusty/keymint/fuzz/corpus/keymint-rsps-01820081-3

diff --git a/trusty/keymaster/fuzz/Android.bp b/trusty/keymaster/fuzz/Android.bp
index 5f24bc62083e..b10f7270fd2b 100644
--- a/trusty/keymaster/fuzz/Android.bp
+++ b/trusty/keymaster/fuzz/Android.bp
@@ -26,7 +26,9 @@ cc_fuzz {
         "-DTRUSTY_APP_FILENAME=\"keymaster.syms.elf\"",
     ],
     fuzz_config: {
-       cc: ["trong@google.com"],
+       cc: ["trong@google.com", "drysdale@google.com"],
+       componentid: 1084733,
+       hotlists: ["4271696"],
     },
 
     // The initial corpus for this fuzzer was derived by dumping messages from
diff --git a/trusty/keymint/fuzz/Android.bp b/trusty/keymint/fuzz/Android.bp
new file mode 100644
index 000000000000..de73db720192
--- /dev/null
+++ b/trusty/keymint/fuzz/Android.bp
@@ -0,0 +1,37 @@
+// 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.
+
+package {
+    default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+cc_fuzz {
+    name: "trusty_keymint_fuzzer",
+    defaults: ["trusty_fuzzer_defaults"],
+    srcs: [":trusty_tipc_fuzzer"],
+    cflags: [
+        "-DTRUSTY_APP_PORT=\"com.android.trusty.keymint\"",
+        "-DTRUSTY_APP_UUID=\"5f902ace-5e5c-4cd8-ae54-87b88c22ddaf\"",
+        "-DTRUSTY_APP_FILENAME=\"keymint_app.syms.elf\"",
+    ],
+    fuzz_config: {
+       cc: ["drysdale@google.com"],
+       componentid: 1084733,
+       hotlists: ["4271696"],
+    },
+
+    // The initial corpus for this fuzzer was derived by dumping messages from
+    // the HAL service while running the VTS tests for KeyMint.
+    corpus: ["corpus/*"],
+}
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-821180-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-821180-0
new file mode 100644
index 000000000000..18fce253f004
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-821180-0
@@ -0,0 +1 @@
+��
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82128140-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82128140-0
new file mode 100644
index 000000000000..906f64003e64
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82128140-0
@@ -0,0 +1 @@
+��@
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82128143-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82128143-0
new file mode 100644
index 000000000000..d629eaaee925
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82128143-0
@@ -0,0 +1 @@
+��Cfoo
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82128158-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82128158-0
new file mode 100644
index 000000000000..3aa32ab1b0e2
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82128158-0
@@ -0,0 +1 @@
+��X@T�d�����%r����1:���z���7�X��$����v`�4����rc���J!Rq��3?ZD
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82128158-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82128158-1
new file mode 100644
index 000000000000..1937534e124b
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82128158-1
@@ -0,0 +1,2 @@
+��X@�v�E)Y�0j�Iꄻ: �<q*��㺧
+#�}��4CT$d��"��YO���S��;	eP�
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138285-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138285-0
new file mode 100644
index 0000000000000000000000000000000000000000..0490f227452efab45453b835e5a0d4e7a09cb3b9
GIT binary patch
literal 48
xcmZn?Zfb3k5@29pVg^%O3{6rB3=E9yO;QOA%pZU}AoWq2f#F&CCHWf?4FKzD3xEIs

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138285-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138285-1
new file mode 100644
index 0000000000000000000000000000000000000000..ea95a46775f57dcdf819d554c2205cd3be7ef070
GIT binary patch
literal 48
xcmZn?Zfb3k5@29pVg^%OOifY>3=E9yO;QOA%pVxQ)JJIshG*rM<Znnc008T!3xWUu

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138285-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138285-2
new file mode 100644
index 0000000000000000000000000000000000000000..ffe61a4c232cc818a5feb03249a9def8aef335fe
GIT binary patch
literal 48
vcmZn?Zfb3k5@29pVg^%OKuUpufswsQDuIFd0|S`)D9ym|to)Mv4T%N->&6R%

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138285-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138285-3
new file mode 100644
index 0000000000000000000000000000000000000000..1e2767336b38b950c0b61faa7465a84dd5aa5974
GIT binary patch
literal 48
xcmZn?Zfb3k5@29pVg^%OEKO1h3=E9yO;QOA%pVxQ)JJIshG*rM<Znnc008Ud3xogw

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138286-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138286-0
new file mode 100644
index 0000000000000000000000000000000000000000..8ab6a9b60d6f29ec01ae0fc64efe9c8465ad26c1
GIT binary patch
literal 61
zcmZn?Zfa|i5@29pVr-H!U|?XD6kuqQ3SeM3A;rMR02EVTU|?i#l1gA;{s5E!QXi!m
N7@n11lD{F*003h_4Uqr<

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138286-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138286-1
new file mode 100644
index 0000000000000000000000000000000000000000..dfac2736348f1356f1f2aecf9b462cfe58761e50
GIT binary patch
literal 61
zcmZn?Zfa|i5@29pVr-H!U|?XD<Y8!%3SeM3A;rMR02EVTU|?i#l1gA;{s5E!QXi!m
N7@n11lD{F*003f@4UGT*

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138286-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138286-2
new file mode 100644
index 0000000000000000000000000000000000000000..3f0d405a1956a334e401f806578021dc3b71764b
GIT binary patch
literal 61
zcmZn?Zfa|i5@29pVr-H!U|?XD<X~u$3SeM3A;rMR02EVTU|?i#l1gA;{s5E!QXi!m
N7@n11lD{F*003d>4T%5%

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138286-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138286-3
new file mode 100644
index 0000000000000000000000000000000000000000..aef020a70abdb8cdddff75bac5ec4f47f196ac80
GIT binary patch
literal 55
zcmZn?Zfa|i5@29pVg^%O3{6rB3=E9yO;QOA%pZU}AoWq2f#F&CCHWf?5J{#606sYk
AKmY&$

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138287-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138287-0
new file mode 100644
index 0000000000000000000000000000000000000000..1036580a4bb77d61fcf9b643f0e3a63dab9012f0
GIT binary patch
literal 68
zcmZn?Zfb9m5@29pVr-H!U|?XD<X~u$3SeM3A;rMR02EVTU|?i#l1gA;{s5E!QXi!m
Q7@n11lD{DVkz{HB0K)bTNdN!<

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138287-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138287-1
new file mode 100644
index 0000000000000000000000000000000000000000..b0ead45c858f386a502f41eb0d776712d30ef1ac
GIT binary patch
literal 68
zcmZn?Zfb9m5@29pVr-H!U|?XD6kuqQ3SeM3A;rMR02EVTU|?i#l1gA;{s5E!QXi!m
Q7@n11lD{DVkz{HB0K|q4Q2+n{

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138287-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138287-2
new file mode 100644
index 0000000000000000000000000000000000000000..83754780992a583f35c4a80671389149bfa68ac8
GIT binary patch
literal 68
zcmZn?Zfb9m5@29pVr-H!U|?XD<Y8!%3SeM3A;rMR02EVTU|?i#l1gA;{s5E!QXi!m
Q7@n11lD{DVkz{HB0K>ixO#lD@

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138287-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138287-3
new file mode 100644
index 0000000000000000000000000000000000000000..32224ee1b0e7b4eaf0ab0d69dcde07f191410dd5
GIT binary patch
literal 67
zcmZn?Zfb9mGGJg}mSkjTk`iEGV3KHPl2Tw`U}OSQtSn$@4zP3q1LOCvO;QOAOnaq)
MDmqkT&a*ZE0G7@TEC2ui

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138288-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138288-0
new file mode 100644
index 0000000000000000000000000000000000000000..0d3285a5be0a5b8971998bb87391821aece0b08d
GIT binary patch
literal 1481
zcmV;)1vdJE6M~3>8V~>g0t12?5C8xQ0fHJJ00033f*K$I009Gn8gKvs_w|B0Z~y%|
zLt<faf*N1|1MmQX8ejke@f!dD=6BK`*cgF>Sp`{w0EK~q0f~Yd5C8xI0fHJJ00038
zf*LRY00S8a0D>A&0077u00962f*KG20=@u(8ZZC?!5RPpBH)4=FaQF=8UO<pLV_AF
z00Pb$0W`7Af*LRY0?!%&G_lQCAkwD>Br@}~5C`!M!lP-8p)xX`DU|AIsYm15N$DC{
zQ&0f_000310000000000007W~L!ki!pjiaJLjw$Qo{h&FMP1OtDhCBr$N0+xLj5Am
znX|`w#OjPFj?$T@+kJpLd+Bv5BDCrV#S>;{VnVKz{;p3F|5Q0Ndg3oEm_DC#vPJCQ
zI+@E>zkwSb^}07c7)&e$kV#fyv@1TKylGc=U=J>QaNaXru=w4-f7bhM_XD^bZXM!{
zO`~m&CGl=*%op6Ml3K|ivoo@Eb$yK%&@NA`1s!W#vcL1_U9_h1msvgh9Ip+$bF#j(
z04=DW$>$mR{|bgAs;H%5A+A7xpuJP9o_;9;ryC_R6u-u+VlU2JHW9fU!7jV{R9vc~
ziJIsR(a9`Hk&j+&Ds}E6?toN=H!6^@MRL{bW<ruUl9KnLixV60{$gC!0aXYU;%iw-
z6e+ix-xG9qmXd;VZq`vPrladI5jOmgYgZaZbJ?nfCzz5bIY%GlHXvv<+sNDj1x|wz
zqJaN+wzPEOgr3r*XXY3T;85cqo=TSM%c704K8tMd>Rvp<r+5Eo?we)rFDd)7@?NX<
zhbb{<aKfo6$PYmgjc4fkO$XA_S&`jmL<fG%`s@OLOLT5$f_prt{BMjFeDSb<fEy=T
zVO+hrC}{!TV!)Erh-3V<COp`if$Xp%AevLJj)!f{_h2~+<+~`hw+nm~w8}XYeZ2WX
zDQ1+zo|(^n|9XmY>nC_t=dlY_l$Oud`PU1S9_Wy9*`YoF_K<a=A)+9SRgNRclMf)V
zV|%(2xem&}$c|x^uyEd(S9vyRKvl8Vc_S%iy46GmRrvM0)h?ck65q7Eo=5z^#9aT@
zBSQRrf=cn?E(~otxJIEie>Q<S7XPVoppegRkLE|?BmuhJwUUYPi9cbAsqd3k1`xE0
z8b=L^7mNqn%<$x)<JRVZ@d>Ux^_$F;#R&%2D~IP6pUCZIQ1uiNA76%?4Vp6c9ky)D
zKQFWVX;Rg(yq)S7qK@Kn3Zsd(5QlKQIxF;a0fSKU0|qexbHa}Ec$nty%>j1hyTJ|^
zKgS>>tYX29#wSk3!icojKxNM@(l>O<9QXyLhXhE-GpKjN0gYd?@zSR?@I;>c;H%Ge
zqSWXm9RHaG^8e@gvKvDLE1gkn5Yb3KJ)!T<48cppW#F~?=B{b`n0(&um;RPIny75U
zf%p1_W2kt~hQNlbhTT+wxeUIhpQ*b+Tu?A2Tr@}R3npzP{sTe&N;}=s`uhA1tS=K7
z1xtxBxvVwMq5_#?AA=iyW>KqGY@U&`G?$jcn`Pa6<8Li&CAoh6C6_|}xHw{{hl#Y@
z>w2g6=!@nOY(~+LT4eFCC>{?#kDu?McA^zuBzOIXi%TuE)%=1;=-u}rAr8ca*~#p&
zz&=nsAXmiLppWcd&Z>=BEP|41^J%4M4?isOo`T5+oM@Bs4;Xj9##$4fx(17J41G5U
zhrZa0NTq1*JQ4N);dG9TCkX7^JiN)CEZF7eO;WF<)a^p5;@AodyQ~1uI}2Bd=V$gq
zmkx`cBK;EYIiX?HL;{WwClgtfa1bLJEZfTxse)x!-ri9!0`ZtR;kE#wX7pFwNx;3q
zK0>%>pNLmA!{ZJmHK0=BJ_gb@f5^DEb?cFHumc}sS?~c*$en=@1q$xO1#7v0fLI|g
jA2A&;8wLYa1Op5dL2hJnZ)s#8OJ#X;bZ>HHAWLO=KRK+Y

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138288-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138288-1
new file mode 100644
index 0000000000000000000000000000000000000000..73a0a5b9d4cdf7b8d3f7f8e6de752567729c1f05
GIT binary patch
literal 75
zcmZn?Zt7@~5@29pVr-H!U|?XD<X~u$3SeM3A;rMR02EVTU|?i|P|OgDy-6y8f%yYa
S8IbxY&A{-i{F3|)i3R}V=MM@1

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138288-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138288-2
new file mode 100644
index 0000000000000000000000000000000000000000..135ba176179984c685c15744fbc9438760ea06d7
GIT binary patch
literal 65
zcmZn?Zt7@~5@29pl2B-pGGJg}mSkjTl2Tw`fKiNK9t(tGlW=H~DqvvL{|ctQe{BE&
DSqKbo

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138288-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138288-3
new file mode 100644
index 0000000000000000000000000000000000000000..827854e6b0a44404e1c45dcd303d8aa6193781bd
GIT binary patch
literal 73
zcmZn?Zt7@~5@29pl2B-pGGJg}mSkjTl2Tw`fKiNK9t(tGlW=IVivRzQQ+jt}2*>U3
M$@w77j6WC~0O(*4V*mgE

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138289-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138289-0
new file mode 100644
index 0000000000000000000000000000000000000000..668b59cae74e2c31be8ae8703fd28418d47e1cc1
GIT binary patch
literal 80
zcmZn?Zt853GGJg}mS|{_5@29pl2B-pQea?UWPnhNU|9}{1TdEcD$52GE?{8%{<TRe
Rfq`kSG*Eqqip=g^4FEov5B&fD

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138289-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138289-1
new file mode 100644
index 0000000000000000000000000000000000000000..e20dcdbe54afe3d5d08b99ef777f60c446d1588d
GIT binary patch
literal 392
zcmZn?Zt8535@29pVg^%Oj7?Gs3=E7+5DF+*z`*$ZYm-&}|G(DGY5DnJmX&i-Vo{S+
z0t5301~Bzent|b2`6c-q5{=D~jC@TDt&L5L9Vi9^6@m<A2MIFm1M&<Qm<~!YFeyC%
zGY?5IFpD{XndhV!O*WndGtYyW5ej<k#+5<}=N{kMupl6}EvGs7)2r>)Q&wLS7v)|(
zS>dNa03!p?Y#@e#3(d|88JQPEH2qMn`yn$`we4}iwy<5xn&-DJx?bOuvQPGSSedPN
z)vAEq)rC_7)_O)<FP?SrO5#Ov7N#9j{%Ifkv}<1Gt>X&23sXPL@>62D++W?eopJuP
zvz+TE<)2+qa>1!fq5p*ZrYVz>s?K-$%m0yWFk)TGTt8dk(u?GE7u>c!KJe+)7lGg_
qGH2`>8X^=8<PBvFq}iB5S(tf59P?6&@-tHuyi+TSOY)0SK@0%eDvntI

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138289-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138289-2
new file mode 100644
index 0000000000000000000000000000000000000000..b23c619d273c91024c337b3c4a9a5c91a4b98e4f
GIT binary patch
literal 407
zcmZn?Zt8535@29pVg^%Oj7?Gs3=E7+5DF+*z`*$ZYm-&}|G(DGY5DnJmX&i-Vo{S+
z0t5301~Bzent|b2`6c-q5{=D~jIvD(t&L5L9oP(J2MIFm18Os1U^*zpz@+p5%seE;
zz%1qjW}cH`G}(9-%sdZfMkw6w%&eO_CBZ-{ZMTJTL(>0Uwo9~*oQnAKY}bRe%?-Sp
z0~i^Ajs{{FxX|ppkdb*o#Ki2Ti}qo1E#}G6eh2?fQI>nN=*R8-O1ceK3l2<c@teHn
zgRR^uZzi?+t51G1KYkam=W*fW6B4ujuby6RV%>cxv(x_YWZi8(+{TwyzMPeN_krKX
zlP5eD3f~gU@7b<>b<^wgnqM)`UPi=<&#HJ@r?>JSzeZc;trwHdsP4=1`10qVy24h6
z42Sw~hbqRM|Ehmwt?c{Q&=8?$Aa5vZAkD@c%EHVe;+U6Gl%JWR;GJ4oT#{du3Ss~N
DhoPAt

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138289-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138289-3
new file mode 100644
index 0000000000000000000000000000000000000000..0a51e0153451fad6ce6c6e653a194548a360de8b
GIT binary patch
literal 1494
zcmZvVc{G#@7>B=a#tb3Gk~EWyEtGvL5*Z4)m5Qe6C?U&a%@WBrpPLEIV3H*@V@74k
zk!6xCdzMmDb8KB(Q3zqkl7_i*&pr2_`=0Zj-*et`-scC&K#33<1pqJ*LhAtle3u9S
zp&bFB0}X({<_!w~Anc!jL+Bs?Tv>w50tM@4*6wb>5c)CzpWl4g3?2pm#>2Ua{qm%E
z0)hYmw@489pZm8*`2Q<V0IYt~p$EX4&;U&N(-t<P0k|A)3*VtZqq4VK$l1d4SZ+R2
z)nJj066S4h&LdKo1_lhx^eJMY?bu)T-_V4!jv%nvx4Hk$`*>?62+t)5HCV&NgXxrZ
z%+ZVQTlNVfoZ4642;tV1-)2{|N48Gg(V%j(^9Q2i4&D3~wojQoCGtwf%iA4SlD<)L
zN?PD#Y7{xDtCeNJ2q`~0Gh&wg=3D~_vuCO1fQ9@YT8LEpb8hVY7P)mqeE4Naov5H;
z!;7V>Lk+RLzXDd^Rl5TeMky!q{HbcZfU8|Q2a9MII<Xao<)LBG6uI|0r-~5@zAohr
zi<1}GPZlx>hxxmoZLbR{ude{K3mBafyVeAv393Z}kKL3?j>P4@JX=hU(S+q=)C^@C
z+Mc@WzPo55RjtsZQ@iHmQk0i?e^TN@r<Q$M$|e7OVYAA!aZU*b_NA5{4epuo!qE=W
zXe+E_8O;2KyGsw~EV5(NmvCHG^F_{xOlWup4GIb9J+1vDZ(3i<grDk*M;{CMSd^fi
zMbj{~Rs3Rt^)Vjk7z7a~<E2<}f{03X=;)tx?j!GUdGSw<V~X_S8PjiAlyZw?zxk<4
z<}LZ*0-xC&&pBPqU*!vzo-UI$^}U0d3pG0=t)wX4lWQl0xm-fpkhhI+OxM~BEY2Y`
zz#F=0p3e`wBNxRhjg7;oUvP7IS*<|?N8B4}-M2mX&-a@5=a6Pfm9h8FKBJQT->zIX
z75!SPQTakFY6ttZscdxJPn@P#dJ8?96C;RB3Z7PvI5$xy=A53v>HXO!mcC~)_1Z_K
z1+bhN#!_NoDb7@t&byM>GLM@zGSw2V8#}0O_ez6?v+y@eh)0~u`fjLbde!vUAe~p2
zYI}6($<ib2I=U^tvDHP;tAgW4L&tfeI^zCjRmYenu_h!lIYD7?ZYn1*W!!d56|5P0
zPD|t^TDm0_&fPtSM6r|5w%e0--Vq+?n*YKa>m4WYww0JK<#eUL+J@}gPo9utbbR-6
zT#}VmbWM1${l3AnLZx4qrEUeEc&4YU?%~u<7IidOG%v9dMGmSn+y5gJjCWjwBlW?M
zX6j-@*7)pO@cP%<CJA}VcC2c#dlRKi{bXD7ZFb)gPmVVCK<Mk;tBA*BA-fL4g76lQ
z;#$Gu<{Qu3(D|R9a;~$wC)IWfvJne{iJ#>dYoYxQPy3-h*jXNC&T+(>99lg;JzpCy
zA^ysW8lKJE$S}KK;MYQ0S-a&?5Wz`kOejtmaw1iW*FRwt)>^qZ>Z!RH*?t$>>#w!}
zx7s*<Xo$PE#+NA8m61m{B<fce8*^B&Y!AhFOpMp*r+7blT7^+&MoW(8P}EqUwx3#c
z%(_}8Zlmg;djUC-JvbeizcQITF70>hL+XVqyi$!ll9nlqIp%fN4p-Iib#k(UHoJ!p
z*-Z|uC@D#_-ul=%Q`TtVXpY6V_UER|xV|f*5VRoL)kWfCA4yBC1v=D;eBg6;K~g@v
zq3wbUqXwCLO+5O52)VvL+3vB=thv-O@Hv!9Q5TsRG_UKVYxRGfIC19LqwepxqS1a)
z@!Dd5b4U!IIN`l)ohgybP+pgwGiADU+rX$Obs56FAe0JPYv7G^A>@f49zLxL<7JtC
zt^}A~Kk$S0jW3%la8=%n+j!%aF$p!}+%uyVNUlk2N7ak4>9mkixS|JP9z50Ykc2{r
s&bA_atK;I%E9oifE9ha6aAzU7xU5ycmEb_)6|95jjgZj5V9($1Hx(|fuK)l5

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828a-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828a-0
new file mode 100644
index 0000000000000000000000000000000000000000..be73ca346d0fac1d255b352cdd5bcfcd86dcbaca
GIT binary patch
literal 466
zcmZn?Zt7~15@29pVg^%Oj7?Gs3=E9yO;-8;|5`hz<>!N0R?bO@MNL-q|NjU&^O!P%
z#Qq3Gs2V66DjLYMF^94+^GLWRD<qbbq!yPbWT#dtBxfXM=4IxkD;PCN6)-S<|Jo##
zz`*>00Ze_AW?*<$eo6j@L}PO#qe>G)Yhx2*Cw7OxbPF&r?E~sIU|>2Z#lWQW0L(lj
z#lS4)1ZJL-Vl>%!7R)>kW=1G*RlapoRlb?taD;1v*_SYODf`FY*6g@>YK3+C9oH(6
zZ2^o7K)(Vp3|we-UdYJ2AY!7#!B(eE4WBO8R}XJb?=$&w>?QNmdwZpJafaI7H@>_x
zWdW;4Ubpwl7e}sTdI&r`wf@}O`5HRs`q&wRFTc9_R>ZI6mzB=me!jgkOQY{P^I5rz
zc{N6<6zaR$dCC3wu_s=0*P)(;*FRjT6?cp+)7`q};HvnkMl&_uWQI)gy|Hh7g2Hh@
Z25<hg>W^H`Xqb5G6$Y$oXdo`M4FSY}rCtC4

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828a-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828a-1
new file mode 100644
index 0000000000000000000000000000000000000000..625ce230e9d968c93dbb1a2b9a35d6395a66e216
GIT binary patch
literal 1504
zcmXwz3p~>c6vzJ?%MxSF#9uP56cwAMJe$|bBacEJk;j_XFd-VPyUpv89+WZ~GKE4>
zE$Ncvb-QHp$SW*_ix849SGxCnKIilMp5Hm=a}Eo|N@ju5000%)6mbX(!~g&U`b##<
zPyn*D$kL~-uNj#6QmLDyZ|372#sa+nXqCdoFimb*mhrO`nFTgwZo~Z?^<Jr4jv4C;
zb7leYOco^R*PZ_kh_OH{0Eo!LH#Y16pa}#Zz(z|NfL3ofSOEGO1fVKIn^+41BC@8N
z_zr~N%UU+EbrW4MFRe*@lz4UkxDprSS>7dCdw%O+UJ*Zn7DXu$yt9SdLx7DRH}e1B
z$C}-Rh~&D8R@Ir#EN=<ICMQq5N1}?3);GR-JOY+q)=9hTaVW!d+L;(43LHS6xg7?F
zr_dw)%`XR-bxTkt;<%r0J3X6ULHjpNew`PHTe{2m+lt{=1-JRIVA-n#+3Q+v7wgAO
z{fEAqyEl^h6-C*~YHmkyNq47U+V&0?B0d_8YP2dYG3Hk+zWZrP+pS~ePPeV`5qAxm
zxk6PxZnlVI!?vd6F;PPm=5W<p3)md}AE7%BvqtKvsc~r&4b#QxTPP53h8BmDCe#ZL
z;rsH-dq-UI(aSo*Rm{Ch5^pFezyNJ10RLA)7Yf7SBh-TpG@qJ0z~*ZqUN>gI#)rRy
z3L!p(WkV4D5LHrKQhUZmCv-3L)(!S09@saFAamOTe~5PkkFK|=IIwA{h5UO6odn(5
zhwVZB1NGMn2({X5P&A9~MA1;w3Tk-TK|gP))Gu_nGK(xEl`~FRf3c6qZb)qMkWk<K
zLyE1@(ecLm=Jw+d^$4ZCUH1`=0m-^?S`Y2fokRCdJkk?1JRL5*BU3jzI#J*whvn?I
zd!TaeSlj!*)fZULaPgIcE`lQq=zwbs40k6bPj9Z2bH{@?{zPhT`Ra|{*GU;+DcLi!
zvB-QE?{)K(mXTp&Uz=BPl;6{<(7$O+c3>;wpKr~x+|PC|jA=9T8wLgGPFt)D=3cx<
zj$!mr>&uYNN0f__XG)J7zbV!BP_!;=Qch@VCGWExpvh@ydY!XFa7++6Tq$KIi^j_6
zX<YuE;O-Zz3CDI-=US~%)gO<mooLw_efYUedJ&|@v8~dMf=o0Oo~_m%h3Y>@4F5r3
z^iCDTF9}Y>-3%ee$RBhLcFmOtxU)wybnxX+w<RkwBy|*Mos8Mxcr2XrlKR1@i{QHc
z!tqI(oggRbD!FV&$D%mh-s4lzkY8T=GZHtEO`qrSvdp1O?tX^Hx9y`=L<Me-7qhpa
z9gq1^)63UXgv)$#MD5h{?jks+6P4+)<33fA3(e%IgqR!fD*{^r5Lx+rX^^nE2Ak5F
zIwbnBz&P@43tc*T*>FA#pB9H6kAJ4#4@0lHV+ZQILv1Jh6xJuGabvnXMIGf+vww!}
zWQ5&X%j~ztRWnwg^=t<X-*P5-00rzKHM$}x2Tv~e&_l@;rgsnu{rN&Wj=RosMnU+~
z9xAN{&qQYGnjd&|?P!5dLg3cviqe=U2d^(>c`HcO`Gdtkwb-bO*dix~cd{qA&ed>i
zo*oEYBBf@K^P{pd996?_A<HH%=1KI9WhVM*N*2;OEr~Ux=9!y#&SAe*o8r|vUMh}V
zee$FRCb94q=vK}sk6~Dib-6hnKiGC5*BFsTrCpq!n2}NLY?4>Ojfj7lvJ<4ye47Wg
zw@}HQO1^#XE_aDhJ*Qhr2uUW<+l7ITiUl)%s>F7qxF4;N!as0~`;2P%wjgV~)rk(z
z<^_#bzRhGiI{kF;z9VV?+i*6y*txpMTxh$8mOX;1vB>t^W3PZPfKOza)TFA9NfANS
z`ENX!>}-F(iePsZo!Qk=!Be%)`LJ)1V-r-Qr*B%N(|0Y(-zZnsEe+ZqqPEh?G=i<h
z<PiJhi`$taDJ61cxzYwIWekRkGFAzvh*j7k;v^~}A!8D9HjEl@7Gq7Og-1}s$Uos<
DuUV=q

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828a-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828a-2
new file mode 100644
index 0000000000000000000000000000000000000000..5ae5b067a1d3ba632e1dda49ddd024897d1821bd
GIT binary patch
literal 1502
zcmZvVdpOez7{`AbV~Me5(oZsuh>A^9a%pZWm)t@w(Z!le!-Qy9XPet0T?kp3+Y|~#
ztlJ?;I2|&%luK9$$2}ysIdYzJ{yOjTywCUZywCG~KP(h0kp;>C02IOku>c^l0}il2
zdjMzz0SK^h!vFvT`cH_kz#ss!xWLk<uCE!Gc~hyIq;KYRE|>+L1w>{xUN>S^0RX;+
ze^B})&y041xv+p(CJU1ApXFzx`2Wjf0BH3_2Nr<71_7wbz$Vs$fQX#wCcXzD__F3r
zY}rIt%u8z$A0?6H2d>2UpDFK@s=c(OKd*=%N(-ly2;SSm?IFO1Z)5)*ezaLGL?p*e
zw5rZ@dP&S5o0vH90f{O)`nKWK;~}v8s%}cI=fMoqNf%<ED6k)W`gSlJo<tAxHNWa-
z_DPa57Q_8|+qrUX1?}57{%uYmVd)|3Yb%al72M{-0_3g}<Zf!aN4*_2^&R+T?$JQ%
zRTO0_tGOS=CFD-PbnG23hkiC1)@)H+WX!Et{P59|v0KN=pK4v>BXSLzxI$GQZkC8t
z{np0B5m7@G=3v!33)n3EFQEqyvqtKwsc~%;4c5cyTPP4ygNj2)V;Y4A@jdzF-9xVV
z=p|j@D(2o5$v2cFppQ1-hyNq46NTaM5gGvoS`{V_u=(1E*9{r4(ZL^}LZBC6$q<A;
zM3oem)SkA{4cY@uzs0`71AAr=WNzDqWr_BH;q_J(M>Z|Fkbe)M8>d(Mu+87M@9oV3
zLah!P6unD#rf8~Z``1^r(=S;n^$H!Y%^(X&<&2ZoQ}&@*_3@3Kk{Y|0rP-S8?Qg78
zw;hLQgevXnypM45OVo?eerS*G7`W%~=&+!^Vz4w*wr+TMtiVei%h_l5K;`1G)(?Mb
z%(E(Su`l{v1xM!5em58x?oLYH;n`A7rYCXqiS(ZG)mz=K6EcF6vZm#tk@>FY*3FZe
zhX#$kZC=Gteod=F|DrkGj(ryUbW5J)KDI|;WUHCaASg(47PB&#ef|MCf;o&@UxIWz
zqC`oZE<JAirc}pM(YmlvIj*&Zyw|pmCa<Y=_M#nvV}i)$N-H~CG`xtI#O138e0shb
zcWhU6j@24f<MF7PL-Ur1Lr-neiXdH1tuO2-$aquX`D&eEsQ!cakYxg+d!itAQQ#1h
z8c2@Zalj?OEl1KXQ(Y^l|K-3ZOIBE5@-Wac9=YA=SP17O^`lWI!EODy(~}fCL3a3c
za@qFw1qr&n=a-@ZpS-q85;vYrpX2fFnnRh~eGJd<+lH-(3f!)<%<lR&JZ7q<o3Et^
zm;K^|+NpJ}li-p@RHjFddR0lyH<2geB5%R332X^K*o&u&{e*=z*o5}PLDA0z#$oT8
z=`s;ZhI7IAlo<4AY^6po487)o?W;Q%WIOJous%kO8PVe@>MEa{`8{YSBRGBSPOmkt
zny~_X%XZZCE@zVaP{1xygBy}^;KaNaJ&63wG!voFn=iEEc<3%=6ogcCQE4@JCi0G+
z`Tkcojuv>uUDz`DtTZy*@$6Jt-U?E6?m#h6Ek5ijzQD=mo#+avb2A*7qhEk7l9DsX
z`QdjnoK!>7k!531d6L~DcjA4tqzY*rmc$xT({w7HbI51arg*iEmyBaqpE#k3i7!kC
z-OCx}kqoPmPIsr{2U;)Z7$Z`sw5Z9kX<6lt#vLlSA&IF8J3$J~yQyDCj7siM^6q(m
zwNspWX0o}2kYEzAO?cr^v0&OqmDpw!v)mFU{0+yr&!~oP^|!`bIkcZ?n%8XM+l;rN
z(@q8KJ)#D%4QCRIU8;-Bg|_OntRYm5Mb;U0dj*66eC&=%O|r&_G!ayt`_6;O&Gh!F
z2zKA4Gdr7~@l>s|Kki-N*!UM6);F!v?YR-|Ym_7Bo&xO+R9k6b8o^d0vxz-Birbh&
vNhR`SIWh(+WekR^GFAzvh*c01aTXPklr;%FA58T-kFh4xLPDv*<e%_2Ne`$y

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828a-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828a-3
new file mode 100644
index 0000000000000000000000000000000000000000..665818c70a5ca5567a19d9237f5765dc9cc0c805
GIT binary patch
literal 130
zcmZn?Zt7~15@29pVg^%Oj7?Gs3=E9yO;-8;|5`hz<>!N0R?bO@MNL-q|NjU&^O!P#
z#Qq3Gs2V66DjLYMF^94+^GLWRD<qbbq!yPbWT#dtBxfXM=4IxkD;PFO6)-S<|Jo##
Wz`*>00Ze_AW?*<$eo6j@L<0aHg(<WE

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828b-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828b-0
new file mode 100644
index 0000000000000000000000000000000000000000..021de9d1062a2d9c78b53dc0dd2ca63ce68880b4
GIT binary patch
literal 139
zcmZn?Zt8B55@29pVr-H!U|?XD<X~u$3SeM3A;rMR02EVTU|?i#vdaJe*V;KPKOfAp
za!yJtYLY5oVEq2I$*TVUA3-PS2$0Mlfe0l71w%Ol88+rn7G@sN#FCQK;u3}I)Jlcq
jjKs{m%)E33!zQT&2IdbyYk<^8X$FR8<(K4dNHhQd;(;p`

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828b-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828b-1
new file mode 100644
index 0000000000000000000000000000000000000000..85394c22cd97b6a2d9d399b6911794c711b82e7d
GIT binary patch
literal 1555
zcma)+c{J1u6vuzFh)M~g#vnuCm3=Q{8$4NuN_J)#gT|75jTtl9CS+HmMvE7tWm-{8
zLxeI+Q9K%3Swhc}XUXt9o%jBFf4qCnJ@<3&J?DPE_n%7=CuNfm`v3q8A|W&Y03s;_
zkPv79XhQ%XV5^4&0FWTbAZ(LwhzbY`+a?1P785~2gae@EC6YnP=DMi4l-u8v^?k1L
z8c5B98qzx;XP^*a2~1QJE;0&v4i}H~3&aG428H60S|o%o0GZp8*(&o=05Bf=PPPwD
zOmh?PApsO336%A(qo3;kY3!%^mUVFB)+!AE%tioU`QdGBLI9Bc=G(|YfOMFh+t{^@
zu1Iu?5+2%2k)neJPV5KNV10LSrU@Gj_)Oj>YG6Nf2O0!y9le$RM0Xmh0tBJEK^t2f
z)r!E;OTzGxBFkOZO!Q304dTa86zma#@-qOfB*3eNf@DyJ)ioPC^y7>%1*tg`w{zRQ
zLk$$k;3<2G%T&TyNUYb77fhXrT|p*dwQ|1qKLnd4^B*Ikdk6cegu6YkIjFhoO1tE5
zxs44Kg~d5i8*kpamDX8_)q70(1Q5Mh6Z(;XI_4lo6iTjV0}!PKx;Y!I%E)_kq41Iz
z^sC#8h0`@OHu-8b?7W`(_p38PiLT$xyo{4tO>!a-a+NBhqXtJGsuFR0dGbtEw37ii
z@!W;8db83zPByYS@eWoHYr%H)*gqLj40oW+HGhsD>oIf5DRWB1%M8v~Xzi^dl4D&s
z<uGr*z2mc-G0yA5K3aJ7)hPmeFxGuYjpu2&k7ZG<=E-C|eEQDeFk>~oGpfxos3c-M
z2Ia86l)9`pTW_(s7$H{ZJVzc%X=5Z@V{7nS|7-~nrN9>#DULzeq+{l`jLd05vG>=@
zW#nWJnWz5#HXlAlgelKD!R%&BzzNSq?d_CJ<50O;E@aq%>rMT*4zjpd3ZSjq5O9@1
zJ89yLc=oDIp>^$i{A510!$+R8%0F@x7fm~9Beb?#>NQPjW(8cV)keKP_f}ir%yHq$
z%7j6x!KGmFs;44J!w+3Lny#$nLo?FFD!vli@eC(5I28{7n+oj@MDFD>F7#t(RHZSE
z5~7e5-DIm?yGn(XAX5=qjelZdM=1+yW{u1^+5sNS8!vQTQ!i#_sd9g$@eRKj<9xk3
z{WNik^)qkjy&Zu~p<rsiy&=6vUH4}Ap&_5zK1kn7XIrfi<q<+dS%r3@;+Oe|$}h&6
zYtB_(#WzEwsa_?1ijP9N&*zud3i94aw>mY#ZUCie4jyjH)BRAtkjM2!Rk5#D%WQ!x
z2hX|(YZBc{1oZNVQk~;n>fOgeBs2MvUnk=o1o$L}&z*D~Ia5ZB%$;!mG_u|4geNi4
zN%sgd?nPoP$Q${SRcE<X<JS+2Hii6A&-6Z$vD+m@a$*4nn*OfT;90WrS$jx%{>s_g
zY;mI|)eU5N(gH;~J<gf7(F8lSzznhBR;<rMjpR=A?Kfx5{J)*jJ$Z)FmXPsaf9Ja8
z8_q=Jf=&tlmWujj#yZ(Y@Rtu~o<{eJRFCfQ{(6lCXAx5{v6*EmT_x!j0T<b)GvjX^
zW9|$|qb{ZIi7Xy2$Hvq!{Rh^Bjjgzq>0I~Ff(%})uUwXf(Gq8r-gb&{rOt<<@)4w$
zh0~W(6@8Is-5^@#Yh3DOH2fTXUvcNW=snudbp9g`a|L58n>*E{!uio$*S^dr2g&Xf
z87-?!ZnY>CBz8GxH`yegpm;4{EN^hHOHFBI9|)$eTps8>4KE9(TT2&fUH1>o#^eb|
z1Y~;ZKLI?Cuk5@Smla-Fo}<ewU|DN&e-{w++YEP{v`s>1U6M6=F>wy<J{fZmhcv3K
z>;5>>GW{iPQssSw&q%rK;9PBIj<Dg{gHc^p@4?Fz3B7o2;^r-cRTqV(s2k9emxJIv
z?-_IR*5q{@+qFme{XnN%u=Z%22X@_z-Hb_p`I4KREtktaie?_VZmM8;jh9oP(c`M~
WX+EpET*2~T#ewkD)c^6GHU9z>D#D-u

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828b-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828b-2
new file mode 100644
index 0000000000000000000000000000000000000000..1c07c9ff7ca6f04a885d79775acb31d561c18207
GIT binary patch
literal 130
zcmZn?Zt8B55@29pVr-H!U|?XD<X~u$3SeM3A;rMR02EVTU|?i#vdaJe*V;8BH76$@
z%(ik)%LlUR|NjwmWB`f$5r~j55Hl1p5MpBvWnt#wPEIW<Q7A4=%2F_Dk}6<e{Qk8`
YDuIFd1JHCJ^--FE;aT}5`5O`q062>$bpQYW

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828b-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828b-3
new file mode 100644
index 0000000000000000000000000000000000000000..03094b324e8b75b4ec3ca9ab6be37551145d7408
GIT binary patch
literal 1553
zcma)+c{J1u6vuxvCQAq}!q{enkY$i{G&wV3bP_SeWK?6wlEx@XFEaD971cvyuV)K|
zv6N#cOQR+{<0)fH%97NH8ChcRJe~LcdVjoo&OP^Y?mg#zzxSUD?gf)TxGVrbAs`$D
z03yob00?&lfLCw;0&MpX000pKZ9=v-(6|dBAv<J)^C4db;WPlUvIN>hZwckFDrf$l
z2xUDrQ3w-tl&Yx6DVT_q0y!+q?@AcrqTh7{C4d}A4W#-b%s}{gKxAQCX1nlJ0AS|Y
zpBh6-j2PlBZxD!MfRMz09sN}QPh&sTx2;24w^yM6XgeH$YEJB62OJRDhuy(H;E+Sr
zy*t>qgPsWeaH)?k5^nEtnNBLeoR8Rxi`N!SO!0MptDXL-YU6pXD+Jg+dOQCKZVWCT
zB9cdhH8<o{TDmnBNI&X}ARb9%iMg!5uP?9r1=i_2ft;2qc8iH4yCaQ4e3q{zOV6Dm
z(HAW&t~kaOL2lj-FWbz%-5sG*7x@}>`hpDZ1OcXf&K>dXvCE#;c;?B@w|uVe@>W8s
z@%7h{@i>R9TDV|rULm}<yc;uj%%{1Y+kkx5THiFtRb{3ot$O?br<&tn@eJLl{#l(Q
zb9W?MJv%4Cn=em`(@@s6Gtg>$q%2cK@x8Tx;T66)n^)^)%2T*c;@T>GF*J9;)%d7y
z2&b*{`ts3TwygO_I#$(eFLm9GOhW2O#Xy`K_Uk&!w4<1(-7!5wT&h6f6bR%wKhB|R
zyoJLEN`?NGG>)t5Xj1TfcE71j2wrg5D@!I<YnUWtYm3!xkxAC^LA4U<9?UV-4oRj4
zIiTfSu^FqV(k$g-i_~JrgX+3@Xa4^1uxnS9UMKKN2944(1itYqQwHm6o}!Zut-K*B
zprkuG3e}DBUHH8iy}P&ZKxahc8#&?!Cl!oslv`WoTY-L@Pl-p~iF=)>D)~|olODp=
zC42m>6^4YwyzpIpM_Ddu(bARGKB%<VfJ)h`cbT=1i*+q;2M^K~d90(O9nZoet5)m8
zVl5A$u=p9ul^pzXJy%vt*}>hJ%vi~*c2O(;d=qN?R%=+PU6QyF@OasLmX+oY(pE|5
zhppwUtTgx2QaO&Vaw;Y%RR3xMXKs^?cViGOY;vAsEHduhxZ{bW>xs3^OOUvvjA8}B
z=u>o2Kb4xIYBxkttmJ&(>+dX?9~;D<GRoOEyvCNrXjpk0_2E>Tnlucl+O`?p$xP~#
z7NjEhQK`mrO!P=G-rInUbxgCY%>objp#y4OkjbkJo8g`S^vAtI3wTJd(6r|OazgYo
zMTWLpF>x4QiZAuMygR0`NMAvmUGo476VRvjJPj%#jH|hP>ZA!|O~IsrZ;6<V5OaCh
zkgJM~NhvRSEwsz4E!{WUZcUhy$UDoAf<ZIvejHSsk&#5Bz~6!%t8?yZcu%0yMQ7P1
z=$cD!oJM+7jN93F5A#2dy@*5eD1-@mrhVgQ4ac5Jd%Ec62Ad8u>7#SUjgMxiJ<RkS
zc_J#o>3x_OA6e2*MkTj@yB-vcXbU(IoObf*rDje3Y4+O05XZnEzx;;TjI>&*nZ-ai
zKEe1>pR!Vxj9E@ztB(k`LO+P4KcXBOIhxDAFppf#aP!xpFs8riY4(*BETZePmarQA
zZb{hY!^bg$>d`7oG1qO}pzwFX<f@it<K6lJK7#j7>w+lxt6_!@3Tat{P}<OA!7T^V
zV=b5ZTL(5Z6(tmn+E*gd2WKKyWDJ8%2W)S0ic!*r{j99eCpK#5V!h*UevQW9S9+J}
z;=$dcNin3mvmS#)D8Z!Rg_R%>*<jUmIaAfj`h#EI9x;phmG@e&oEmF%_N7kh;78V^
zjwB_&96Im!C35mq^6@sEm#{mrkxU8gafVzjzm4(hv6ACyLb0!%%<S03tscF>ilPVu
zD!1vhOY#bJYJuH_n0<bqIrD5aSiBTrUnd+0DMS0LFU=Hk?of$toi6MVC&|Jy;~W;#
Ud3j`4W<$8FPA{GQKc2JcU(8;>uK)l5

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828c-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828c-0
new file mode 100644
index 0000000000000000000000000000000000000000..3fda800bf66ae5e8c917e276e48919b98a679c1d
GIT binary patch
literal 137
zcmZn?Zt7{05@29pVr-H!U|?XD<X~u$3SeM3A;rMR02EVTU|?i#vdaJe*V;8BH76$@
z%(ik)%LlUR|NjwmWB`f$5r~j55Hl1p5MpBvWnt#wPEIW<Q7A4=%2F_Dk}6<e{Qk8`
bDuIFd1JHCJ^--FE;aT}5`5O`t8<-jZPhcoD

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828c-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828c-1
new file mode 100644
index 0000000000000000000000000000000000000000..9bedcf635127bbb9b5675024f727c93bd67b2ba7
GIT binary patch
literal 1518
zcmZvXdpOez7{`AbV~J(Wq@Nt)h^W|@a&5@UCAW}EMAlpyCPYi?Y%`ps3n43Wn?j+e
zmUKuGPKV4jx3CZnqL73+((|12&w2m(e!lPXKJWMWvQVrf7AOk<PzVde0)W_dIKToO
z0iY2CAi(+#1FY*$`RQOkoy58e10ahFEF<dLs<EX%m8!deMwWgj!*yApFCaF%e!4E7
z6#?L5benRw0yEYF=Eefzm@LSpe^Y-XNdAAgEC8)u|A7UdFF^pRI<$ecARs1hv4L+v
z2)?X&16wxG9rN6lBtS`J1%b=#V4w0XncB0P2J?ypk+f(^iSVsG+z|r&X!PF*Vh`p*
z#Bw~utLiLfmL!6)iHTEfNL10G*9|Woj)3Kt^;2@a_hnd2yAeahfxYMxH^brZBzjb!
z<>jD*-O`i^Ht*w2*C%t!=)lIwFLOdEYcIJ#drAC?@TLG3B7c=2e_hA(!s~I1z@aae
zUJayvC2@|5y5}L>rQ9i)uA}q0$oHnBS}jV8jJaj2Zvon}4r^G2<E^U#M6PiYPox&W
z%Mz2R-`touCT^n29Ikp}1^Z0@Tja&Ztde?aYTR4J!wqmoR*J;bu;K{Pgl6GBd|!Tf
z?}&RodP!fjg1K{1`V}P!7@!RW;s1>9LSeW9gl34b_G9yV*nAzt%Z3ct`0zJSG1QN+
zWCFtPqe_ZPYERhdhwXx<-{4&2gMG6IGOzvgcd3q$(Y01pXAUj7P;dvKA8$~5zdbl`
z;Pv$aLai<b6u(V(rD&<^1lK?Apr5r??iV><nMD?o${ELOKRHHb)h9H1OKa}@zJ;UJ
z(ecVQb?Xs`W~B12uDb}AphN?<&V5I8=g=Le2ZqA>$HS$Wa&@Dl69s+>SneK&d#Yy+
zx3>MIInR26i>n-T7ao{L2VG-ecsnS0hM!Bhncl?lM_YE4uiWT;c_|}2DQiYP7MbsU
za?LWSd1Tnk-|hvQ@>^OJ`d6*V4s1o-(@lBSdpKT&F|7v!hCyMPtAvg5=VxumF^nN<
zZ3)u(fO0|RMClQ;SEah%O16cKD)Fr?<lXiIGzBef-!l#ft~nx`w?)O(s-g1yG%jBw
zr2E-Q{NZ1!b8J?rnh(d-otihD-~ZGutq9WN(pu?2K_*y;PF3rULXGYvM0_VOdZ!BF
z7KKji)KGHFc0IQcj~wZsObzX@!RJHW)~u+|<WZnyGG?30;Rx<?>O0deg2&o3mq#fM
z!tCg)<g#rY3sQ7P?+-;o0eS6DNW26NeU8t+Z3$)a_AtD^ZXLBDD)M@KnZ5Pxc+97o
zUV*j}T<(JlYKQj8E`nPcQH35m?pGx<-$b5@kGTQABD5y}QI$^@2MG(SuqmCXed6y6
z%%a{j(`C;unaqXbQ`qS7xF?$ZF!ZVycA)NLnEhmc;@Sk2J!ZgH(pNb)`$yOgMtJ(_
zt$tfvHDek2n&YhHU(O^CpnzXU4IW5}-qCqKdKkIFA`_w5pD%LYdg(7^6hu7kq0(yb
zOyn&C%e^nI9V+mPKfP(XqBJJj+4oaf-ZD~cPOliKmK=4LT;OK&kM@Mrd6<mN(N9Ac
zNy!=H{OH>mE@~0!$g+tGdD6XOw-N%hWeRDX*2Ef8(@ZL!yFXyXu6U)6pN!*FA3dst
zNhnMQJ<A#8F$|lrE>D*udadVj%n&J5+J)(f899~C#_g)O5vfm84#E_gf776@1eM&W
z?BDnHa+f64XS%tBaLN4qR?+DP#lo2YHDbFd`+G~2=yx3BE~6U0IoK9&<J95PG_Tbn
zu$yd0ryUR3eLx-Hn9L>?yHyuiitIILStF<#t1KT4M@57&eBzdQO|s_L79yxN_mvNm
zpY88g74E!EXLdDL@YQUy-|b%D+65OG8d+57_g#w)G|iFsOo8@?sxP-NO<^lB*~Gr>
z#qG?Iq!NX)99d)4G6ut41*?ox!YWFLxr&QP%bACs3a190!q}2&5s}nz@(=h2s<Nsh

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828c-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828c-2
new file mode 100644
index 0000000000000000000000000000000000000000..49f8fafe142c5f3157f68283f1f13abb1157460b
GIT binary patch
literal 146
zcmZn?Zt7{05@29pVr-H!U|?XD<X~u$3SeM3A;rMR02EVTU|?i#vdaJe*V;KPKOfAp
za!yJtYLY5oVEq2I$*TVUA3-PS2$0Mlfe0l71w%Ol88+rn7G@sN#FCQK;u3}I)Jlcq
mjKs{m%)E33!zQT&2IdbyYk<^8X$FR8<(K4dNI<M&Y5)Kd)hpHj

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828c-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828c-3
new file mode 100644
index 0000000000000000000000000000000000000000..38f360c2908508bf71716175d61efe05a6253111
GIT binary patch
literal 1542
zcmZvcX*ARe7{>pzWJt?cDl?K@q?#q7!C0nTTQ@E;sBtqGOPVoaj1YfI8Ci0Xt;Lcp
zB9W9anlvf9C@nWzVrpzP-AqweI=4^vJ?A~|?>ryg=lS%23g9^qjRXKF1Vm#20EUtV
zK(r$Obf5tUu%f8}00jE;z(6zufPDT066oKTO-O!p`YI7f-p80A;q><<IV<4%4`~TW
zMq#($HenT{V6Jf3x^+}v=1H~CFz-NL>PZm&CjgsYF<Cha$^h_|HK01I6c_Klh5`bK
zaUg{AE6)#a#Q(?o8Du3mv~}eb7J%ME15l08Rpg@q*k-F$>_I~eZgj6=?<$hj_|slz
z)xz4SFNTk2+^g>A=Omv^--39H(Hjgu&_nhaa)baYwk!MJ^u?2kAh0X$aITK}j8JiD
zWMYt)%G~o@V<z}u?x8rWbuMx8Rp5d8WL_qOlH}~7%(UMXgiSZ}?+&MRH3mt0TI<$2
zx$4=7U0~PO1lrWpNM+tS`iFU{W}kChVfe!fspfJ4d(`LG)KB;g^Uj!XFnJ%_7je^H
z@^*FrG7*L_gN*5e6jI^3U^5v6)dln5cj&8}0+f_>yQRP^FBi9c9DQ@ljtwJ@9+w%H
z2d>r!94`oPNMO#eO~tnZ)v#h@e9UC^Fyct|j>h4P7gv}26rhf`?NECG^0BdUE8YQm
z>4;oo5<JdpvhP@YQv$CYble(sX=qz@`fD!ku1utH;PxjY!L_2+*twuqlZr}x3AwkY
zONIqwWo|X1Gj3vK7kcTMh~C-~`Kr|EduK1EzH^NJGV0)f-XQBltT>9{e2YrfMNOAz
z5)k8|Zx+9tf(D9C`79oBr_MB+McHr4+2_W|^q-t6emy2tnf6TY>5?&N@}1YW=dB?z
zhc?*TPDr?Eu>hw2{YNJ|l#@l=l}jPX;jraIlu~*|7`y`RnWW2+Z}%$~|J5PwcLyU&
zuGg0XaBg_W!Eb{|P{*K*k}*R%X!q57b45#*tT@*=lSwG2;V9Ka;zHHboPSF>t2bzB
z!a+Gbha8A)OEcr+h3j`Sqw@DL%+0Se0-OL7eEERHA^+k{3Xd!?Q0+ox*F&|ud=Ob$
ztif3pxuGswL^EysC*f;bhY`wKIJiID7K_-;jvAk}O!BJZ$F@AJbR<m}4~E*|vqk!S
zbC>iF*Wpi?e5QX`V9li!XepZiEr<WiP;S2V;Y{6)LplqB?M5kuk8F$VbZz@_<DChg
z!ro)D+?<7JqdMBxTABx3FT1BmM$A$Iiky9GZ5NMpTBQ+;k{cy8*=!dn&|aE7bAxJp
zX3vh>w4}bEMGl1&KQ2Dbb9>o&vbfpwXq{ZoYx&@?yNX3^+p>9V-H=9aOnzPvYOVfW
zik)Q0m$g?_P%^6WjzggL-?<-|@@VveFizczACY)@o^}_RvPr8$6r-1Jk0_Nw7H}+~
zT>%n}HrMs@-w+X9i3P#yZN<O6(b<qCF9lX;c1AYU_**XeHH)+q&RQ)XRYGq~F?M|=
zzI0|jF0&lHIu@O88ln`iOw$HtUEV7R+N-ohe1GDd*WRa7qjq}i)KzBq?9ZkaH>sN<
zBL?zEx}+N9aNGxiN`Z%S;Z%alCvI!ll9q}0`wYIt=}5_t=oJ}2I*rxrnF?7hzTXRO
z`QE?(t&&A->8Y{?p^Dg}j7Z?ScByaGib>+BIS5_Zk4S7^2C)n-ux9|d`qt#7ir|wR
zT7mnW)3dQHf~-ntH1jBt3+U)etD0g&G4R~;Xdlbe#wfz$T2s&GNf)E~*Rop5T+`@d
zm)$2HCMZ}{N81V6O>f+694kG`%NZ{JRJ*>KF7YxhYJ*D$BW`(|Z&2Z?(-%X92)R;^
zD&@HD4^R6JZ=mbfuJclSQghBGrF!Uo^E>;EYYYl+e)b$O?D+yVT{ql*#?#Pb!1zM+
z`MFHp2W}6IPIMPohz?DcH{`LCpFu>$z1m!w&rEi+??tNdHaFr%<$02-*{P5|4gSdd
aG5oH*v9V+&>}H%IR{m!x%l;~5HT=J_53#QR

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828d-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828d-0
new file mode 100644
index 0000000000000000000000000000000000000000..16388b32fc718fb5a958242e3ed8801f7b3cb71c
GIT binary patch
literal 140
zcmZn?Zt8845@29pVr-H!U|?XD<X~u$3SeM3A;rMR02EVT0MZZ&!ee7>vdaJe*V;8B
zH76$@%(ik)%g=9;Dqvvz{<X=f{{J6AXU0u-AgMnB!3Khc{06*i%%LpIJZ#0KNm&X;
aO;QOA%pZWJ0;!ME3=Gf8FUjAKXaE4RqbKD6

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828d-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828d-1
new file mode 100644
index 0000000000000000000000000000000000000000..5238d4a428949b13b9059bd1631da6581973fbae
GIT binary patch
literal 124
zcmZn?Zt884Dqvvz{<TR;fPsOD8BB38Hc2TkFfcMfD4-ya$I1dy$#4p&GJ%0<uQX7;
zQsSpr1BlD~fdNc?1d2W@za)P{qRA@%|6gm*<c!3eoYcJZR50JlIW0dQWD3)TuMGgH
Cq$SM&

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828d-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828d-2
new file mode 100644
index 0000000000000000000000000000000000000000..ce98ac33742816c46d6071b8b7ec338144f8671a
GIT binary patch
literal 139
zcmZn?Zt884Dqvvz{<TR;fPsOD8BB38Hc2TkFfcMfD4-ya$I8%TmH+>*wQELdPEJ0U
zZRMPn4`kK<|0C!mAOI5jBM>2BAZ93HAjHNT%EHXUot#=!qEK9#l%-(QB$dFx{DA>X
UeUxTkcvgN%{)PnDdi}2r0H1*=J^%m!

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828d-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828d-3
new file mode 100644
index 0000000000000000000000000000000000000000..b0bdc3ec865417bc73e254bbf54a7c6b5612c3eb
GIT binary patch
literal 139
zcmZn?Zt8845@29pVr-H!U|?XD<X~u$3SeM3A;rMR02EVTU|?i|P|RS86(|oBWMgcy
z%K!h@$~i4Rze%cqf${s-Cae1Ye*_)D5`P3DBn-q1MGS=4m_u2ZdAO5Pi%JxVOOvt`
bjGCkp7??i*jR8_0r5PBWm0yy-A<+N;Zwn**

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828e-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828e-0
new file mode 100644
index 0000000000000000000000000000000000000000..58cfa24960836bd652928d336a40ad5d78baeda5
GIT binary patch
literal 129
zcmZn?Zt8225@29pVr-H!U|?XD<X~u$3SeM3A;rMR02EVT0MZZ&%3}iaSRsO}EMOiR
zP_BT1@%z^%sRRb*4?sB}^--FE;aT}5`5O{VR{8(`E^|#RD9B6!vz^_6?3Bck#0CH+
CI3V=^

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828e-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828e-1
new file mode 100644
index 0000000000000000000000000000000000000000..ffe3bb3d826182b0a0e9fd3922b1d52e05ecdd11
GIT binary patch
literal 151
zcmZn?Zt8225@29pVr-H!U|?XD6kuqQ3SeM3A;rMR02EVTU|?i|P|RS86(|oBWMgcy
z%K!h@+BG9JCnq1wwsKC(&u@|{U|{_IwaKdf{~tj|Cy>M+fd~l$F+&jpAvWev7G@sq
l<kX@Ph2qkrECr(`sRRb*4?rV<)JJIshG*rM<Znnc007j^Dggih

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828e-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828e-2
new file mode 100644
index 0000000000000000000000000000000000000000..93f7d1cb8cbdf847eb18318f182d8c1e939413e9
GIT binary patch
literal 151
zcmZn?Zt8225@29pVr-H!U|?XD<X~u$3SeM3A;rMR02EVTU|?i|P|RS86(|oBWMgcy
z%K!h@+BG9JCnq1wwsKC(&u@|{U|{_IwaKdf{~tj|Cy>M+fd~l$F+&jpAvWev7G@sq
l<kX@Ph2qkrECr(`sRRb*4?rV<)JJIshG*rM<Znnc007XYDfs{Z

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828e-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828e-3
new file mode 100644
index 0000000000000000000000000000000000000000..ad6744f883659b409a14ef6da6e7b146b7777ca3
GIT binary patch
literal 151
zcmZn?Zt8225@29pVr-H!U|?XD<Y8!%3SeM3A;rMR02EVTU|?i|P|RS86(|oBWMgcy
z%K!h@+BG9JCnq1wwsKC(&u@|{U|{_IwaKdf{~tj|Cy>M+fd~l$F+&jpAvWev7G@sq
l<kX@Ph2qkrECr(`sRRb*4?rV<)JJIshG*rM<Znnc007duDg6Kd

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828f-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828f-0
new file mode 100644
index 0000000000000000000000000000000000000000..ce8515fb52e5a6cde066f69de02c6c380c5497b9
GIT binary patch
literal 370
zcmZn?Zt8E6GGJg}mSkjTk`iEGU}6SST#QXp3JeU4Okj$Ytx2kYf${s-CaDAl=8w`q
zWww%6Y=Am|+z$**R`vh?2s$!0S>^x#BM_lzAa5vZAkD@c%EBxx;+U6Gl%JWR;GJ4o
zT#{du3SxjvV>tB{r2emUL`Fc6ze}idh^=L^L6U*Fnu}|gr?V@J=ji7W<nQSc@9AQj
znqrb{Y^WCE>Fa81nr4!ioT}#Q@8arXYh-4TW^SS8>*yEi=I9&}8sr*eYm{VWVVJDu
z6a+ND*4)(6+}Hr*T&BH1*E4pg$g;c!TW=MSYLIMbYaq=cmYkofm!6-Wo|CGV2ywJt
zdT|;PqmqFfcFEjgCKle4UE2(mSQI2nH+?KD-_yDD{%84lDa%ehYFui2@Z#0kvLf{l
QPiXxD22}wA^P8^?0Q9PJr2qf`

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828f-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828f-1
new file mode 100644
index 0000000000000000000000000000000000000000..dd1d192d0cdada61efabb631fae3ece625fb4faf
GIT binary patch
literal 370
zcmZn?Zt8E6GGJg}mSkjTk`iEGU}6SST#QXp3JeU4Okj$Ytx2kYf${s-CaDAl=8w`q
zWww%6Y=Am|+z$**R`vh?2s$!0S>^x#BM_lzAa5vZAkD@c%EBxx;+U6Gl%JWR;GJ4o
zT#{du3SxjvV>tB{r2emUL`Fc6ze}idh^=L^L6U*Fnu}|gr?V@J=ji7W<nQSc@9AQj
znqrb{Y^WCE>Fa8nW|C@PVxi{i@8arXYh-4TW)9>y`h~hVI){V?xdz!9C7D?mCaXCG
z0S&M<H?=f3HUK%7X)n<Aj2$Yn!6jhpts+tlk_~MQq*=t0^K<pm^YhblQuPucj@C;r
zPGe$JGLXYAnOn@n!h5o7o1qemf@JBYkA>xXI+x!6EI%)0*{Mg3OKlHcygFM}r2gRv
PtzW>PDqvuK^R)p0p|Nuy

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828f-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828f-2
new file mode 100644
index 0000000000000000000000000000000000000000..c82d9a1868f943443a5831ed2676ed22a787dc33
GIT binary patch
literal 286
zcmZn?Zt8E6GGJg}mSkjTk`iEGU}6SST#QXp3JeU4Okj$Ytx2kYf${s-CaDAl=8w`q
zWww%6Y=Am|+z$**R`vh?2s$!0S>^x#BM_lzAa5vZAkD@c%EBxx;+U6Gl%JWR;GJ4o
zT#{du3SxjvV>tB{r2emUsI$Lch^t>nypyM&i))Z=a*|m}qAAE|roBL$7&}yCb*#Zk
zts+tlk_~MQq*=t0^K<pm^YhblQuPuc7U-oHr!g@q8OULm%q?bO;XT>4%}|L&L9%qy
r$HMYGolEb3mY<ih?9`*irM3qzUY#u~QvdLT)-Ry93K*E*d~E;#j`dvu

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8213828f-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-8213828f-3
new file mode 100644
index 0000000000000000000000000000000000000000..93246f883383e6003298bc7b8b58ed8a42f02b44
GIT binary patch
literal 280
zcmZn?Zt8E6GGJg}mSkjTk`iEGU}6SST#QXp3JeU4Okj$Ytx2kYf${s-CaDAl=8w`q
zWww%6Y=Am|+z$**R`vh?2s$!0S>^x#BM_lzAa5vZAkD@c%EBxx;+U6Gl%JWR;GJ4o
zT#{du3SxjvV>tB{r2en9zhgi^yq}}5tF4(unu%E&$WW%eKsy*aRAj5RffZRrq#7g}
z+8Ri+h$ZLe>ZRxBr{|>VB|?nWOD|4iVpKAa!!DUy%*4WbvTK{65{rUl>86i`<$F4p
l-v2B=FJ;-OM~zEu4_>@FTUMn0;R&r@Ko1o#Fu(cQ007dPTc!X2

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138290-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138290-0
new file mode 100644
index 0000000000000000000000000000000000000000..8865ca7a539fd259a49a29fa2ebdddd67b2c0402
GIT binary patch
literal 131
zcmZn?Zko^}Rlvab{cDqy00RRPW0RBt0|T=p2Sbxo00YAbDF#LcpqK&!kcLnY9vc&w
s#|q)GLV3&(K^6$b3ZdA*)M=oS1P100KvRI!M`;FzXXTgVZ%8x%0O;x%D*ylh

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138290-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138290-1
new file mode 100644
index 0000000000000000000000000000000000000000..36369f7339669d07e7c3762a17b42c758a64aec1
GIT binary patch
literal 131
zcmZn?Zko^}rNF>&nh`=VK`3Sj#R8#NArxDaQ~?9y_peP-0t^gHKn(^A49t=o3{6r2
v3=Aiv7#JBKhA;v}fJQPxcx(_OS%GFHFfe}r$^og5(hLmG$}h>^kZ1q^OuHNl

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82138292-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82138292-0
new file mode 100644
index 0000000000000000000000000000000000000000..ffcffbf44af4e2a6c621068245663e3ce1b527d2
GIT binary patch
literal 145
zcmZn?Zkp62Rlvab{cDqy00RRPW0RBt0|T=p2Sbxo00YAbDF#LcpqK&!10xfJVg^&J
zKzX1bD@2YJBF74qV}Z!ALMS#c#RgHy22sKWluKY>{s1%uNPU!MV0c!3N&bdJ0|4b=
B81w)D

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148485-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148485-0
new file mode 100644
index 0000000000000000000000000000000000000000..3741bdf895454e03ccf281b16fec1f478b696f3c
GIT binary patch
literal 83
zcmZn?X=!be5@29pVg^%O3{6rB3=E8HO;QOA%pZU}AoWq2f#F&CCHWf?%n=G1{0Cys
i>a!UBRsXO)^S;{GN834_&15f4wy5)I>HV+k)Bpg4of`%K

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148485-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148485-1
new file mode 100644
index 0000000000000000000000000000000000000000..74f74cd3c180e5fb3cc066a7a03981fbbc7de614
GIT binary patch
literal 59
zcmZn?X=!beDqvvz{<TR;fPsNYqM=Djfq{XM8BDRVG)WmSFmOmLVD|S&&B@6R$;d4B
LEOzuxt!w}Qz&{Uk

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148485-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148485-2
new file mode 100644
index 0000000000000000000000000000000000000000..0ed4888b36f561c4ddb5a85372b3a6e4fb44ac31
GIT binary patch
literal 83
zcmZn?X=!be5@29pVg^%OEKO1h3=E8HO;QOA%pVxQ)JJIshG*rM<ZnnYMkr+PABa7x
h&tmvj{logq`)XewZRd10lf5+AqRywK_rI=F0|13x8wdaZ

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148485-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148485-3
new file mode 100644
index 0000000000000000000000000000000000000000..e933e1c38846972d79a3924ebed252cfc62df36d
GIT binary patch
literal 59
zcmZn?X=!beDqvvz{<TR;fPsNYqM=Djfq{XM2~4rFG)WmSFmOmLVD|S&&B@6R$;d4B
LEOzuxt!w}Qz#R{B

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148486-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148486-0
new file mode 100644
index 0000000000000000000000000000000000000000..88c21067c8a8ede40326338632622673b8d30da7
GIT binary patch
literal 106
zcmZn?X=!Vc5@29pVg^%OEKO1h3=E8HV2YKYNh*PX`2&RdD9ym|to)Mv4GG2w0|PxK
zMg{{`HfHVA0v06}g_Y&Zv(}mG$n*#QyI5rFA+}WHlfL!b-lNBRbOnEvMow%10M;8F
APyhe`

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148486-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148486-1
new file mode 100644
index 0000000000000000000000000000000000000000..004c63a411850702733c370752c4fcfa4b286bee
GIT binary patch
literal 90
zcmZn?X=!VcDqvvz{<TR;fPsOD8BB4pG)XBiFfg(;NhL5ae_#MpAEg->o|RvczahaK
op^(9UAoi?2i{W4O59>4Ut9^a6ozvM&_R?gFI-i!_|GG{M0EL1c1ONa4

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148486-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148486-2
new file mode 100644
index 0000000000000000000000000000000000000000..939c47765398ff1faf83d2b096d52dbf0eecf462
GIT binary patch
literal 106
zcmZn?X=!Vc5@29pVg^%OEKO1h3=E7+5DF-mz`*>00Ze_AW?*<$eo6j@1Y?AOfgTeh
zg8?fWvvz78ixP`M2LFNBv-&KCf7L&%&%Cep_0e`tXEWJLlP&6eT6+KMIyC?Q<P9CX

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148486-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148486-3
new file mode 100644
index 0000000000000000000000000000000000000000..2a7a322e9d9219bc0019f4207f68d7d884e9116d
GIT binary patch
literal 106
zcmZn?X=!VcDqvvz{<TR;fPsOD8BB4pG)XBiFfg(;NhL5ae_#MpAEg->o|RvczahaG
zVPK%g#K>U4%Eqjnn#ZEVqL9IVAoi?2i{W4O59>4Ut9^a6ozvM&_R?gFI-i!_|GG{M
E0KIx2`2YX_

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148487-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148487-0
new file mode 100644
index 0000000000000000000000000000000000000000..4d4ed453b18264b9c4bd54de91e2da116c1b547f
GIT binary patch
literal 79
zcmZn?X=!hgDqvvz{<TR;fPsNYqM=F3fPsNoVnLIX0s{jh6NF+0i*iUj0CQQHnL}1#
G0Sy2)9~qVa

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148487-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148487-1
new file mode 100644
index 0000000000000000000000000000000000000000..5a5d90d3cf2ea98e8299eae5566254253ecbf5fd
GIT binary patch
literal 80
zcmZn?X=!hgDqvvz{<TR;fPsNYqM=F3fPsNoVnLIX0s{jh6NF+0i*iUZ0;Pe%tgOr-
ItFV9u05roHIsgCw

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148487-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148487-2
new file mode 100644
index 0000000000000000000000000000000000000000..d9666640f5375ae6b5083e9dfe81bea394f9892b
GIT binary patch
literal 80
zcmZn?X=!hgDqvvz{<TR;fPsNYqM=F3fPsNoVnLIX0s{jh6NF+0i*iUZGJyH4EX*OR
Huz&^tB`X-Y

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148487-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148487-3
new file mode 100644
index 0000000000000000000000000000000000000000..746a2dff8da4811a4635e135ff8b83435d750e05
GIT binary patch
literal 80
zcmZn?X=!hgDqvvz{<TR;fPsNYqM=F3fPsNoVnLIX0s{jh6NF+0i*iUZF@X83Y|J66
Huz&^tC3_gW

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148488-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148488-0
new file mode 100644
index 0000000000000000000000000000000000000000..fbde04ee7b3c3b8377ee6a30487b7ce0ab63c3f0
GIT binary patch
literal 222
zcmZn?Y3XQ^Dqvvz{<TR;fPsOD8BB38Hc2TkFfcMfD4-ya$I8+qmB7IKfdNc?lxARf
zR(?tTh6H28G=s*;OpFW$!ffnXZ64=rnHbqPzzk+ac9u$mawbMb7KIAsf)yvug_`eL
zd%^eohsqP8J-_Cp?~vHs*Q<E)S1FI|0xpE6g)Yoa3@ne%gvmW;yv23lJ+FB7hLe(4
z^ePWe{(Eq5j)TCBm`~^XGETC(xuyN=UF**nZoNXFVzX0g!4k_|Mw-75s2vT+&~E?$
Dwg5~n

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148488-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148488-1
new file mode 100644
index 0000000000000000000000000000000000000000..a8ec9fe97e1e4a9d4ebffe148194f9c568c1895d
GIT binary patch
literal 210
zcmZn?Y3XQ^Dqvvz{<TR;fPsOD8BB38Hc2TkFfcMfD4-ya$I8+qmB7IKfdNc?lxARf
zR(?tTh6H0omqBAY6C;CxFdMs8o5wj@CPp?6FoT(qoh8>Gn~9N;MWMJx?`(Ciq{Dtq
zgH^NrF8`k*_m<Nv`+(8R87YmQm)wY4=)&y8z_P#fdJ!-Cp^(H3>th~U%DZNX-0foW
yv%cF?dw15Rts1+JuaXY@=(l?}_l0wcdydHDZD43VZ(Md!{)(sPgH00F{~7>40!ZQj

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148488-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148488-2
new file mode 100644
index 0000000000000000000000000000000000000000..e00aa32cc412b138c42e635566b3499e40fb29b5
GIT binary patch
literal 107
zcmZn?Y3XQ^5@29pl2B-pQea?UWNeZ$U|`^oNC0zLpu%iG;Q|K6?_a@`K9EXaVA?AU
yRNtW@v+F!_ghKk?!#a8IkGx2Jy#4>l>4y^6yIniq<=Xp{>#FUMmlMCRHvj;cdnBd+

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148488-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148488-3
new file mode 100644
index 0000000000000000000000000000000000000000..1c414e4ef4fae48506954e9c55055e14e8b4918e
GIT binary patch
literal 706
zcmV;z0zLhL6oiO^8gKvs_w|ArAOHXX0)iSK00034f*KG200IGm8Xy1w1q6Z`AOHXc
z1A-c000Zy<f*N1|1MwRG0OohnAJ`ZHSps=5f&z5{0RS)!1_>&LNQU<f0RaI800e>p
zUoe6KTLJ+90)c@5#tBpj1bv1yfh}4gfp+9vLDmX&u{i<qG$L&O=XO#YT6ekQi9vgD
zz_z4K6R+gtqJUjS$=WG3t+D?MA0+Aq<|`oAc0&qHLs3^FJa3U_gToFn56jq_g~HWm
zaTb?_tP;GUM623zzp<ahO()169g^NCPe5Vq{h25SMe1!O0s{d60Rn-58{qIwoUS(*
zX&(bqI53WpR!dchpZidR(nbzuFeQEkv(Bpmmo56d*3MsU;#i)xc@gaotQO=tL`#f@
z9#l#NlQvg!_`3G8FUjM@@d8T*I>3OZvLj6RuITo}d%sW9tmh;GkiPM33qOB6-DJ)>
zwUI3L<1aa@7=u`^%*}v-0zm-ew4U`3c3nFp-QXI|s_`)L$7XP;8ey&ouSt7Kg1&9;
zkImKN_qrVW9}JRfi1>_>zpE2}x*~-ldxOJ5|9n*fK>*#WwS$~Ye{1v97&0;N1+yBZ
zivQiE$DT~iA%APhFx%y0)PQhoB<bt?t0<<;@6#l=ejE2C8*q@4!cX-9{gDDdBh)kw
z+B8Mj%_hM_5!!FuraT<YOMt10)hl?+irBugge)B>1O>b=Y#Zt!N*#16xt6nAW2h=#
zM-Qltzk)p70zeykS45iA4HXz9nqOACm?=$5YQZo3hLi-CrKN*<Z23keD@jEr(<s3n
z5hgef-UPx=k!|cH2$I_grq_Jiqfr7tcVf+tO$805Yt@mhwH4A$e9bb<pwM52ZCEuF
oy>leh^EO53?Tbnrv&>2zXP9%D@}QqvKemjB)#cd=!!(lCfNDfDK>z>%

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148489-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148489-0
new file mode 100644
index 0000000000000000000000000000000000000000..6ce48a5bb6f965fb3b8b54b427286cb2d51bc751
GIT binary patch
literal 715
zcmV;+0yO=C6oiR_8V~>g0s(>=FaQ7p83X`=8c+ZL$OD2JAOHXX0)iSK00034f*K$I
z00jVo8Xy1w1_6Q^U;qQ~0D>A|00Z$G008E9(jV9u0a*fhFoFVg0s#Op4F(A+hDe6@
z4FLfG1pows0$(tK0$TzB00M!50LBSa2?TwHG=VKzA%S+}TtU_fb+I`C@-!lB|L1m6
z99nm|<B36galp2uO%t!=<f4FGM#<VKHLbD#3?C%w2Ieau*LFh+O+!&vBRp@BXM@8I
zF%Qewn}x#FXK@yng{%_1qC~6Oa=)>k#7!s29vzb2C{I9P?fsc32Sw^_B?1Eh009Dl
zfE(cOO`NVb7-=5^Q#de=kycApiJ$vWgwjS1W-ujw1+&hp0+%iNyw=WNZsJ&;ws{fl
z53CmCIz&s1h8|Q(1(P;ca`?LTvM<Tw#qk1520Flir?MkV_^#;o#CyL_)2!zt0+7D(
zYzsesJl$l@I<=83_Tw)(s~Ce=uguMWfdWAQ<g}jk4|ZKUB;DW|&Z_Y+^2cUysTyIf
z2(L+dN`k&^?vKsY<M+B8`yULFYl!%alE14Hf4U-tB71|wLjQbK0zm-XtF?oiOn+<h
z)EF``@CCCPrHcRErN^F3&LMwm$uQgHW7L3fY$WOH{HrLY&F|ABw|*P<B^z*%lEP2*
z0sWBzKqJ&N4%#$D*v%%vL=oC=+@?Gn%}ao(iq$K4%!=5)vV<%hC<Fz(FKip?Axa%|
zD!G=kTVtpyUPlk8jlY6C-2y-xdsjr7(+w3EB${7VyO=3WOKQO{{DzbSm!+kHdTjYd
zCM!urCetXv9uX!u58edAPmyixB?yw+38vS4+oMqeKzCxzk4*&)rEArZt+f@>O?=HV
x%%IR;hHY3i6uomK)$=w*=<SP29J9<y9cP$xnew2YTR*mph}GrU3d1y#)_{e|GUfmP

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148489-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148489-1
new file mode 100644
index 0000000000000000000000000000000000000000..623ba78f86e004334e3683e7c7c65af2f6503170
GIT binary patch
literal 719
zcmV;=0x<o86oiR_8V~>g0s(>=FaQ7p83+J^8c+ZL$Ql3v00Dv;AOHXX0)iSK00034
zf*K$I00jVo8Xy1w1_6Q^U;qQ~0D>A|00Z$G008E9(jV9u0a*fhFoFVg0s#Op4F(A+
zhDe6@4FLfG1pows0$(tK0$TzB00M!50LBSa2?TwHG=VKzA%S+}TtU_fb+I`C@-!lB
z|L1m699nm|<B36galp2uO%t!=<f4FGM#<VKHLbD#3?C%w2Ieau*LFh+O+!&vBRp@B
zXM@8IF%Qewn}x#FXK@yng{%_1qC~6Oa=)>k#7!s29vzb2C{I9P?fsc32Sw^_B?1Eh
z009DlfE(cOO`NVb7-=5^Q#de=kycApiJ$vWgwjS1W-ujw1+&hp0+%iNyw=WNZsJ&;
zws{fl53CmCIz&s1h8|Q(1(P;ca`?LTvM<Tw#qk1520Flir?MkV_^#;o#CyL_)2!zt
z0+7D(YzsesJl$l@I<=83_Tw)(s~Ce=uguMWfdWAQ<g}jk4|ZKUB;DW|&Z_Y+^2cUy
zsTyIf2(L+dN`k&^?vKsY<M+B8`yULFYl!%alE14Hf4U-tB71|wLjQbK0zm-XtF?oi
zOn+<h)EF``@CCCPrHcRErN^F3&LMwm$uQgHW7L3fY$WOH{HrLY&F|ABw|*P<B^z*%
zlEP2*0sWBzKqJ&N4%#$D*v%%vL=oC=+@?Gn%}ao(iq$K4%!=5)vV<%hC<Fz(FKip?
zAxa%|D!G=kTVtpyUPlk8jlY6C-2y-xdsjr7(+w3EB${7VyO=3WOKQO{{DzbSm!+kH
zdTjYdCM!urCetXv9uX!u58edAPmyixB?yw+38vS4+oMqeKzCxzk4*&)rEArZt+f@>
zO?=HV%%IR;hHY3i6uomK)$=w*=<SP29J9<y9cP$xnew2YTR*mph}GrU3d1y#)_~|e
BGXnqs

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148489-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148489-2
new file mode 100644
index 0000000000000000000000000000000000000000..3e1a75600f5239b15e1398f0fab600dc9c8d18c6
GIT binary patch
literal 217
zcmZn?Y3Xc|Qea?UV{DQtU|{_IwMi<0f%yXinEEKq!0@d6lKc&cCMf|11}0`O#RXIf
z)WOIEp@4!w9xDT5M3+HhI};;=fiN4pR-4B;TP8*}4lsk6k)0*iAe)Jikwu}nM(=EO
zucX6%O@mdl{VxBXBKMZlEc<}b%o!<-pO@T-T<F5=#K5w@^?DI6`=OA;4C`YaTgtm;
ziQMgC^0U6%Q+s#TrmY&gkFSyr{OGrPH}{2eihGX8<ZWPRK5txhQT~dj=YvfW*8ds+
DmcdD)

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82148489-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82148489-3
new file mode 100644
index 0000000000000000000000000000000000000000..9fda99aaf21b202af6d01d7ac34b8ce768314ccc
GIT binary patch
literal 217
zcmZn?Y3Xc|Dqvvz{<TR;fPsOD8BB38Hc2TkFfcMfD4-yS#}1}gS(>C07??jWfT@qt
z3=Gf8FUjAKV2tQ8Xl!R<WH1nBW7lf)IA_bm$i@L?Ff+2V<Qil%F*33!6xZmTt?rd{
z*sp1@YPR3y|5N1Na++lyFq%0drSbEU8<7iLn4K6{_P1Uy;$=S+l9*wA%wtP=*DR5{
zT}*z~cYA8@&f2t9WB2h@(t#iScJJoCa87a05t+OV49(|_%Pz`a@$`JKNy7SH0|5Li
BNv8k+

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8214848a-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-8214848a-0
new file mode 100644
index 0000000000000000000000000000000000000000..9d8c18fc8819bb0a6833031d8691184b6f6bd73e
GIT binary patch
literal 1310
zcmV+(1>yRF6oiU`8Xy1w1_6Q^Z~y`K^@18;00Zy<f*N1|1MwRG0OohnAJ`az8V~>g
z0s(>=FaQ7p83+J^8c+ZL$Ql3v00Dv;AOHXX0)iSK00034f*K$I00jU6Sp>l_f&{$+
z0RS)!1_>&LNQU<f0RaI800e>rr!ay9qXGc{0)hbn0KU95D^}D)u_>RLYH(KQ3W<I(
zgm$H&fGOrXF4sAx7m?FB^^M14+0jW6^6l(6J?;_qF`GnD4thS#n|Zl&g5;F|toRXq
z$egbZVjp*PWmKa5Mr6O|tBYByNHh(<qI;9Is2^_4>jKbqlLr!w^W(bI1zd}S0v6w@
zR{&=YY*8lgmM_b2|1ggw1d(LS_iV!2W~benfu|J0fSqX=VKdU5gjSA;D{uSr8JpV_
zI6mSeKz|tnSn(05NmVMkXA~lR8`t)-4baPo`9^zjlR5J{|24CR3qN8YPC|yTl#ZiF
zwIozaUzj-Zp5{ZadG7e96S5%JfN3Pn_bE_t#R3BX009Dm0RU<9ck^E_SWfVDH9XB6
zsh2q0J-mE>^Iwx@&KGU{8xvZw05CL4zhA!39Y$IG?;H=rFoR3szBv(<6L-5kRyr=J
z%8yFf#EOjO{ZVRjTxKSQ$F#G+ntOv(6FzT~_mI_|uDLFR$)q!r0?gu%-vrFc`hDZ`
zs3+9+_tTDOu<UBL24q|Cbfn}74F>xbF(fu$)$V#A(@^P^jKd9)GHx3wE}r$<K#s&M
zuXBAM6qf|hrg)(HTU17dI|-5~qf*ucx`2_PWY8U2uv3@E9<3n0DhT{ikK{sucnQac
z{^YBd`FoKt&>|H++-|nZ=dk$WM?Wr*5(%~25cxI)+W`WBfdJ?{378>CLF!MElkvBH
zE}7=fFki1Vf;izO5>M*#>z5?5>U((R10zF%8i3_p9f<o9(jde18del9?1g!485i;B
z$8_;RwtYQrdwy#}gXvARl8}kpvqsgut3b>xmhJ=zM_w0PW50OM*F+O%K!brN>T*Bx
z{(qxr!7&?3P6YyifdJA#{J{0saa`UZ%Pq)mp+*xfqp)vb|0?xM^MrHtovqB{D_=~*
zEzr7eP?JZrwXwB~Ir&~kn9RFF=sf`$to1VUS;}-gg&Cg$hG7mM376L~DHj)-$+mS^
zcQO*}mL7}FdOXMpyi|s%Zc7eo^OV_625Jcax3><0q))Q|Q^5j(fdH))+8n)VNh@ZB
z8>qt;(~7qM;?LdLCZ<>bH50{4sue3R0v%?3AP0|74~o<0^ORk5sFCd&DC*Gu>g<dZ
zsOU7$Mxi|uc*&g@ln5iw-6!l=5Y>}8;KM<ftYeM|$b7pSV@jB0uAfa_veh*d_IpgO
zz(~legqi~5mtl`GaWw*gfFGj4r85|SsV$E_C>&vN2){TaPZr}+=AP6S#}z-G!x-`r
zgPdeN&x=jgeB!JzE|nLJU6n5evA=hpNfwezaP@+sKM^oa0;T6xTH-1-=TGd&w*ARJ
zlA)t_1LV&RV|Y8zF1Hq^?7RA4YY?|h0aukG=kJ8sAH^amAqd$5!2*GRd2i!_U!BZ_
z-y+q9kOp0oiHgl-z=yu5+B##uMM<}n;>`{_;EdkApU)Q{+0DfV4RrJk?T!%w#UWCo
z8)0SmI%guT&&)NXlh<QLWVnc+jXtn6@h+l^{^LgC1=BQwe|L)(?Ldbs(x1yVQ)_OM
U|FCCxX=_TIfx8NnBj!EjfElM%%K!iX

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8214848a-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-8214848a-1
new file mode 100644
index 0000000000000000000000000000000000000000..c88132a065f6bda50b93caf3d31825a4e21a676c
GIT binary patch
literal 104
zcmZn?Y3XW`Qea?UV{DQtU|{_IwMi<0f%yXinEEKq!0@d6lKc&cCMf|11}2GyCMg33
r24)Zq)WgUGp_suGD+^eXL!yB>V9DIl6v=thPY2D_nLB;I{)`3ye4QK7

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8214848a-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-8214848a-2
new file mode 100644
index 0000000000000000000000000000000000000000..8b735f45802478f15e44451d1fcd8f35217e1212
GIT binary patch
literal 726
zcmV;{0xA816oiU`8gKvs_w|Ar5C8xI0fHJZ0009S1OS2>PyhhP8UO(R0fHJJ00033
zf*K$I009Gn8Xy1w1q6Z`AOHXc1A-c000Zy<f*N1|1MwRG0OohnAJ`ZHSps=5f&z5{
z0RS)!1_>&LNQU<f0RaI800e>pUoe6KTLJ+90)c@5#tBpj1bv1yfh}4gfp+9vLDmX&
zu{i<qG$L&O=XO#YT6ekQi9vgDz_z4K6R+gtqJUjS$=WG3t+D?MA0+Aq<|`oAc0&qH
zLs3^FJa3U_gToFn56jq_g~HWmaTb?_tP;GUM623zzp<ahO()169g^NCPe5Vq{h25S
zMe1!O0s{d60Rn-58{qIwoUS(*X&(bqI53WpR!dchpZidR(nbzuFeQEkv(Bpmmo56d
z*3MsU;#i)xc@gaotQO=tL`#f@9#l#NlQvg!_`3G8FUjM@@d8T*I>3OZvLj6RuITo}
zd%sW9tmh;GkiPM33qOB6-DJ)>wUI3L<1aa@7=u`^%*}v-0zm-ew4U`3c3nFp-QXI|
zs_`)L$7XP;8ey&ouSt7Kg1&9;kImKN_qrVW9}JRfi1>_>zpE2}x*~-ldxOJ5|9n*f
zK>*#WwS$~Ye{1v97&0;N1+yBZivQiE$DT~iA%APhFx%y0)PQhoB<bt?t0<<;@6#l=
zejE2C8*q@4!cX-9{gDDdBh)kw+B8Mj%_hM_5!!FuraT<YOMt10)hl?+irBugge)B>
z1O>b=Y#Zt!N*#16xt6nAW2h=#M-Qltzk)p70zeykS45iA4HXz9nqOACm?=$5YQZo3
zhLi-CrKN*<Z23keD@jEr(<s3n5hgef-UPx=k!|cH2$I_grq_Jiqfr7tcVf+tO$805
zYt@mhwH4A$e9bb<pwM52ZCEuFy>leh^EO53?Tbnrv&>2zXP9%D@}QqvKemjB)#cd=
I!!(lCfKqHV{{R30

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8214848a-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-8214848a-3
new file mode 100644
index 0000000000000000000000000000000000000000..33148a1a6c62acecfa0b631d2ab7a47c80b345e5
GIT binary patch
literal 1311
zcmV+)1>pLE6oiU`8V~>g0s(>=FaQ7p83+J^8c+ZL$Ql3v00Dv;AOHXX0D>AI00032
zf*K$I00jhs8Xy1w1_FW_AOHXX1%eu200Zy<f*N1|1MwRG0OohnAJ`ZHSp>o`f&{(-
z0RS)!1_>&LNQU<f0RaI800e>rs4#*Aqyhl|0)hbn0ItJllO2fw&Q`Dne|>P_{AE8s
zG|`m7{?z~&`$OB4dj{rns5db^R<Xw=6$(G^hOE8ZLA!OFC{*g>Ej5H5`&<~<E6EBR
zwZYX|-y~ZCksk|u+K9v<{|>tTd<`SMF)e%5k{|l&6Gy>UKyUAHk7y=C<mJ;mX9Lz8
z4EL-H^kiHS^}#nxIEF%W5yVM(XOiH)_g(CTiXkJzXH(!Rm8orfMN3dk<AtU|;NQdM
z3d5)FNs-Xhive<}UzIlSE1^8>%(*LaeYL`VTQ6Mf31AB-YW2?)#2_Tb9pC31Dvfkl
z@r5Hyunqyzg7FWJ#&R7h?LSB}%%Z)IrYIrZRRRM6009Dm0RTf3N46yy2oWnD=Wm(w
zaT-##V+mjcY%S*v;fUBX__(<qO?X_c?ypY|bU{um+CXF<f8tLR#(IdAo7*RLZTaUA
zwlJVN+-N&pEJFwmQoiRNp02juDSBV(5ON0%7#xBt%>M{|W640eibeKt{<5F6NKG7-
z=F(T2pen8k0FVqmzex@~EZ6Rh4j{!g<lI_NmnSHQ&E0;H@+h&y*GEiMxct@_#Hm-i
z-PNsh2h1@ojhLm%_u!984QoZaLB>*LomyL<TV^*msA*z>hFhW!z1R3r=EZJ|z75;I
zB-{hC(#uReR1dJPQs6YA&}NviDCO}1<Fy(z_}H}gVSxgHfdJk)E*RE=$SEdl!$nRV
zVP+&RGTEWg1$T8mkWQ!2i~och<+{i!7ED=i0B}dR#TVO;kA&lU)tH50z4Zgs+$-BS
z_=Q7C<SaE`a$K5V`5y;};qj?*Bef*8HGki7;`Wxhx7Us`zmmF+7-Z_PBA$^nVK8)x
zZaflCkxADabTtBjfdI)<hrs#MUlV&*(AHczd|n~UB_2lrj@BwvBnim2wyb}NXS0Sp
zrbYbDNmweHp>s*wY)X}{{jLqJVJ;f_$)3}iEt5=$1VFCXgD;pv7CJ}re>owU+!6x$
zp!vNBFn|Zk9!`H)Fq3Ad-X-_L$+&=Ld<Kpi={D#Rh=Ed4sG$OZfLH&Fp@~p{vdZL!
z?+V}7k^2HQz__z)*1<OAE<lC!>RJXe5~T43qjpC_<uZYoin<3sZU84KjvPaHRc;Ra
zpy5u=8ux0@urTs^_VBAU`*WaR*s-ADLi#30={qvxZGwWX3Qgq-x3B0`0HJR~rbijp
z;<-bZBXOM2i_HTUfdYYn0J?LqyC~!M9-Gm{XmL9b5<#rS2bXM3+{}>XTV+<tF;QSx
z`73S-^RZz64mVE34S23iNqPO|tOlW^0LC5D5>yy!^9v%u1%jxgJ~aN6oL@VaRl4W8
zr?<DJy#uq1?^VcXh5T$8c)8B!?=#v^e4X~WCw%`NYN}mVtfeSMVFH1H0Ld|7e0PGK
z`x0<aE9n_rk0>yRUsv0xX;Wws=7vHx(8P0U00^N)uQs?fdVD<-nP$*TP5_fmp|0LL
zwz%ws9m!rlSC>)Zzu)3|=XjVum6KK>2O}tZ3jfTXa&Sb{j5j|UtKJ7B`WK}AO`wo0
Ve4Cr{d!`%atpeZO+K*0XB7i;MQRe^v

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-8214848b-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-8214848b-0
new file mode 100644
index 0000000000000000000000000000000000000000..a43a7fcb7c065ab7909521b7b2359bb65145c7f1
GIT binary patch
literal 1317
zcmV+=1={+86oiX{8gKvs_w|Ar5C8xI0fHJZ0009S2mpc_PyhhP8UO(R0fHJJ00033
zf*K$I009Gn8Xy1w0SAH_AOHXb1cDkM000I9f*N1|1MmQX8ejke@f!dD=6BK`*cbs>
z1i>(Z1ib<Q05A;(2`Yw2hW8Bt0RaU71cC&oFoFc50s#O5f&l>lzPvOmR@6hWDW95Z
za8~FFiGDGJcBP?!Ddsya*Eyyak<&T#jmKlz(Mb{V?d&)`?h*Den?z9#dOppYdAW0f
z<dp!d_z```oUaaIA9r<SRHFSxWWVRDi&?8kG!4I^dy}=OA8yU-0?>7n2NI3*<GR!Z
zT#JMP7T>B@0A~(tQ6}(~FUxTMFpnh!kz~yGY{J@Rr`?)?rxe0~ooN_hGt!-eR*s1)
zZ~OBZo7)sPKH?-me;ET<@e!#>RVun?6e4{a*Y>gv(94MVMtgCSIrBUJHM55cKVl$G
zLWZ!Ej-yDmBveaZm^kvD=0mV~?)aw@vLM%hX(Y|}DNu050s{d60Rn;n0BQ4g^ItDm
zPVjX#Jk1=bmpI!!ynKK2Uz29e7j69;6I!tVFf>ZPU%t;BMp^yu91p}WgG=GQIT4i;
zce_1SIxeZok4o9Zij3y{QEGEsW+sNmw6nmPdxKOHK5vuvkky{9xh{msq%)HO%;JyV
z1kB3%edF_}C)D=$(~fAc>}t0LWLxlbq~r+=2KyE<BsO2w?s_28Q0bM7!wr!#ZW}2s
zp7q;6j>IjmbA2EbmjuwJc%b`RR7Qq736dzIQq}~zfRUkO&>dQ^Q<ujctsuTC2>eoy
z<U)aX3CD;2<g1tYdyz2EA{9Q|Znn$ku=wLgKQ53G3ANi0`8EXG0Rn-60O&jkm?23)
z>Q9oB@wa|1ndZ+hU#~TSIN>G|PwMjPmn5?4dwAvpBSV53faP5si2D-KAj9+;RunJn
zg?Vim7xC!Fbn!yAeLZe_errR6=}ongkcr!~M%BHmK+G+c?gR-(UKd<rzj)8rL=$H~
zgMlaNazFF_f1_x@F&j!w1p<MA0MbDG!1dR0T;3teEy!-6MiVZhuy0}iD)meAgmd+s
zt<2*qUrfU-(7JC>lSj0*v9*jj`Cdnu%)3MAJpmc4^)mBW%5*%18J_}%VGbY(m)9{V
z7Z;kzwslx{G7{{T9*fR;Jje;WREDW;OAc!Dl-W)OY6$?hw+@1&PqP41!2*GS0Ie0;
z9KC8uD`tfosKXZ1injpb&)wN3rdR+q6U9ra6)P|T9cFzX2aiw>iqq%wlwEYFk?k5N
z>d^k`?2Hts=rqqpp*<6L$(<OK2qVwkC+t`d)ss2k!$Fv=V~z>Pe7hTCN|<D>pG{t}
z)io6MdrYptNXV;%ngZjOVUIF#H3ETvAELpfGZ=uWEss7Z9AR+?zc?gM7UNRpp41n|
z6+fQC81fN=oMb)Ei%r&i;;b<)l^2a&l`jUdzjvQW7LrSF^@5^55im{yrRP>!;wm-g
zPwdFH{mDO)p`&*L<j)RccstN8w-%@DyZT^j5VuVMSCt~??}XVO#Ud#o2-yO`0)c>e
zZ{vbroy>*bBGrbF23?bhip^!fhrX!VI%B^@Nw<~a%?>-@jNZMU&le!s&BX@|bo34F
zju8UIAyT6oVP*I_XCki8%r&Hw*JDOxxQL*QKCm?LE~1P6<3{2I(=>vAcZ(M7K!+>R
bpUXB=Yi^VOuxEH_Yf7Dgy9$&e<~`+rd`woB

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82158659-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82158659-0
new file mode 100644
index 0000000000000000000000000000000000000000..66898a78bd65c9d1d9b8bdffc8bc9b44a11c8654
GIT binary patch
literal 1837
zcmaJ>c{JOJ8vP|=-vuRNS9IDcs->~MDsAc1*4MFCpJh<3t(MwJ)Ka98s7weI`<jYf
zm1t0Fks6d1iHfmAi=wt+jQ7rY=l%2UKlk4A-E+S0e1BY|M4|&IS`!Hh2ZI0z5(MBZ
zcW?hx@XQ$1_XCSR4R+iAqUP%e&ydKW7Jf_lrJ~o;p^o3oF`S0ii9;Hu>bZB$e6v8S
zT*9cP$1#&^@|l|3Q46H1r5`yj82IZ}D}C|OPO{JvOkzi(@vo&#f7T~ql_Fu?b2nbD
z%<@Du-0(ngAp8M%F`X@^w$&+oi>-Q<+u{n@o6NFhX1PV64HIL$$~t63|8Rv4=9fn_
zdN&A6ahI{1-lGjC0Aki<J1c)>;t}&8y~5o8Nn>b_Xx@I-oB0J|L4gau&MMJ(m(UDy
zh_+Su!o6JF&f?zBr0@CcvZQNgw4AE2o&Fl6J=x9cX@WB|<g@^Wvcbr25P^xTnsd6s
z@<oFnm32)GFo;9*42egJ>-axl5U79y3{ohBfR9}fr`E9nm7I_X6%_{N1Rx57V<t~s
zQHXouanui^{;v>UnJ!!Hm2*Baz2|3siYOO>h<NmEr@Ry1Rzfr`5b}f?Sq_}RNZ@Ha
z5|oaFi2%n-kT3-R00IA||2WPQ#|b$hE-(_N2>=|@JjWqx0O*As$B%;|0J!~R1bzzx
zz)Fn2Q(zhl;E=p}B8Olg9m@L?Iea4R6~G}dXFTm46FtiPgdUvfI?Ari)YppBlMKyO
zch`4qwFUuy-|}CKpiD_1j(i75d*ibGbc4yBSA3|MUXb3^33@|R<sj?Q^185>%TQP}
zWnwDy0<GPRvw3GXL5>^}Y#K|k;javGVvAk8cW%IDZQOhs@sLdYnNh|jPNtXD@cG=g
zUVP!TC>S%Bc+Hd*>bvD`+6m8M8Xc8Z$AUNZ?aaBL8lN-Fber?Ksu?ryo%aZ`zlE~Q
zO}C;w_shGqLn1Tzl3uT+s^@6@ayoAKE&sZQ`)CU$ds&^JL#R-$%Yql-vEM&z`!=-7
zLh#0;+F{cdohQ8sya|y4*hb=BPpL2y+gj~)_X^c|r_?ev@w_jFa*=qHRfCy#!UwyP
z1ibs#gruTA!UNmf>K`@NBuM2N+w459u!O0_Avh~c0%=Yihnz994De?Wo&xr2p=Gh6
z5*(!h|73pnzz`LFg<t;y?u)(<!#Uf&m$;quxh?yMYg}V4Hi^~mME05J-aQ8#=$(GO
zOgA=q+4neL=ws<<yE^nzo!+g&(=purVnJ)2wmPyr$%67OzUWuJ&p(z|hc`QiHZ;AI
zpu|IOir=C6_F+hb`I$}6K1PwxjtV?qWnQVWrb)k777?EsFL<DiGTe9oQKML$qFtj6
zbvb%Acr!({ALGtmOU}dPk@bo<EYNO#BQm;oLl#z&?<{vcDNwk70KFuQw^dx=kqy#<
zOW_LTGPNR387~e;1Rpt85g5<yELcMLN0C(13s7B`ubsiMa+bUI)z*{iv+fcqlHxEu
zQqsH*pU6^C@*D%Pc184&uvQNfy&T=-r}D2Ic1IX`(sI+eM$V)(Jz2{&c%D?n<o#|*
zsPk^E=Ffq%*50uO2SZJR<e~7@bbZthlSrqV5F<9o_3`F#;jjcpN=<XaBM%CPAV#7U
zO)M|saoM~*_hw_mZ|dQAx-^?=)$q;RPcz}pqFHo`yMfL1{U7X=v=E4^dVg2Y*Zh2y
z!rh))Y*`VhgkvE986R){>_KgT*7wR^4cjn62=nK-Dwo+xt*6hpOCqZdt!v8~OwD3u
z5POxlhj|@R_U2ZKX4q!o%TC3)bQ4mzd<7qUOw>nG>8v6|PAF*c#Zp`XRjh@LMowq0
z;rJ6)MXD5Jl+FZ2insKQuL|*wT>J9|$|BitK&P#5@E;HVr7p5FJ+@YoslJE*&~oN5
zz@Qm>p5WsQedXuL7X$tpq}qz07^yOJ_R?mNHmZ|0wAL~^o_xO#7_G^|Kvj$>JA@Ip
zTJ9gEExPmjmzQC1UOpH3V0y9ioPY+Qh;@ivm8$D?g;fRwpOF~!PAN-|O1f1*jwT6r
z^rfD%E9p_z=&y3@bUTMBV<>&kz~N&}C%Zj%FK%?@<P^JL&{G42E4Lmv%0)TLwr9V~
zn3ox_Eb>9KvYEvIkH}{_uN_v>mO|J4RK5)Ll32gY93|q!5<Ce@+96s#6Z*YhXm7Yv
z#oLx*0~qf%s)6pe<9Jeco0x?9QcP)m2@;0x99v2byB%W)xyg$&z!oRdIJNWmU!{)b
z*8j8nY&U4kntv+ky%(4(*?pLr8rvSP(wuK9P}IIp{=*O8+O$)4`xX!02&v%5q)||n
y1IF}cy&uD<E!sA1J%LZc#1((Pmn@o-IHQ??F!0`D)y3H#m+b!s@_#!Q0R93hUq~nb

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82158659-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82158659-1
new file mode 100644
index 0000000000000000000000000000000000000000..9c2b989c1322e2bc7dfd0e542db22fade46e1675
GIT binary patch
literal 1839
zcmaJ>XHb)g7X7{uife>G5CRexga<1tm|#N3P{e>BRi!9pB5f5yuYy8YV3D%Y5~YRE
z+fqczDoc;R3KBp8iH5d-E)Z&H!DU(An|bs8yz}RrGxyBgJNL&SpN@9`qtIk990CGR
zG6-at?O7-nKE}uP@1#@z1tIe0l<qsqq@B)bFIr8stL!s#XgF!?7~Vz2Mw9iDH1Bq^
zSFfci;GQU^M9(Bx7tElyBNyn^Uv_e`rl|zWrT!SH+bBfollYE!yhmB{*B1%t=N?Ei
zW=&{IQ$i7qCT_8O+P;8H$?)=7C2qHf`Ld#+;5DrpubO$A8458XRWJUbXL-jN(M1=;
zKtV-BlUE~bQm}lvc`#LP9LS}p+gkd{=N`@+q*Pw@4QmSN70u^STK`zcEi808iCxLX
z?>%b)9inVx=LG*OX`2`1We)HEus1LDoQ=6%o!;%MO5aCq5t2`_*)_?2)AG8^r%>29
zrS5`;$hXA<pu##@6$0|1&(no40!ROWfM6jX1e7g;LXKQ9Kjz4QrN^Y-9vceb2cWV8
z@AczcVzr&cquWPDeQUKjGfv#Ls@WgT^r^6wBP!rfxLf~r;%kxZbJ|S{&+>(v<{kKh
z$Us~S8B8Hd!-1nEWNBFd0D*tge;og@<A)xT0E8@!1^_-Op`(x$0Q5;8#gBq;0Md3m
zf^<p)kaN@jq##|=0H1{6v3x5HV(SNw<<POTmv#Mku?vOTD9gQ~>n911l*owlM|la0
z@ocxWgc?4DuULV=KezlB%vd8j$XDP1Z7bbmB~qz4{O+wDUWr2cbwlUMuQcJht2)&)
z%n|kYpg+SC-ojc~H$~>=(lcKMFLCE$^^vdwj}dYko<`D1tQq*67ghNUG6Xy`W~v-(
zfL^9X$<(%6{{=2<F7CFv-P5g0;o~BLCm1ET-ayKIUxa^%{H5M9mt>E$b;Z|*0ki{6
z<L(SJEs!cIJoe$>v|6WmQSw6h(lXflSpGih!fhYAI&(AiO{s^jTE&I8FYJ7Crpg5P
zGY<-Mf+7!3;ciu<KZC3u29}%y@`Ag~>Qf|O)t_qMcc8(Jm(E&?FINg!&G$$SE4#!V
zIPT+VuRUs~I{JV6RhhKz9CNb#CcSeS70FkZz1HT!?@n<_|EoU9{F2Z&m$hUFwi!Q;
zIN@Q_XhHTV6EnDO%Jb{S@5ag1#*Ur_Y^`=uTV;d6i_Kk`1?Km6)aGN%tTVbAnQmuK
z)F!Ib(|wE_S})T_Gwq*5-BQQCx9NKlen@Mu?cEOis!=~0zzR)Zb4l4o7R|pj7QZ;Z
z`_vgxg<(eWeD?2l^Pi9<DoNG7+>cQr-Sf+eS~c@^Rz{cM?0qJK*rF)xT8$|(D5GB$
zn`o5P-@c?sBM{i3;u}@ENE||iP>CPDC=<7tj}%ixAFfT-jrVOD5>9inHt&C;3Ne>6
zxTL_F5!`6sZ6}YY)uz!e`CrUFO%$b#%YB5M@5M~_<4)<Kv%eMAC!q(&2k@0!QR`<2
z#L-yhUY-Ot{pl;A@$Yqr6HAt=i@6Y^IBbJoDa6A+$>x2L#qQw=a-d<Rd{(YM9%0uF
z05pxu_GG9WBa}M?^IUSpce=D|`Ir+Dbd;?HYALFaZC;V*P>vq8JETX}v`@!fig5LY
ztFEn9fV%qJ8fRjDrLopcb(ZvqZmLP-3=eiOlWxRd+9aP6i*5X#OUkoVoW8`&x<C+G
z#MXsuT)8u#2$OygEnZT7&fC+mr(cNn8Kk<)P3Z=+l4pf+tlVmqF0;T6O25<RTc9AJ
z55>N=_H38sHFkLvgWT}ZNOj-y-W>4O!{G{jG)Eq|%Wa8OS$v&QwSfJxRX-8@qe0oC
zp;+l+P^$^5B9ydr=(01Se#eK5%v;M)EhAJSD&%_}7<n0pay!aCY#Y9sMHn4mFD4{>
zyv@Q$9^xIVUJWHM8`R+p%n9T5h(s~{%)m7L01cBqI~m;XZ@g0F>T=YG#mgozeMVb}
zcUl;&<x!q<j*&=G-7n$6oO&ghM<rt!i@auqup19|KlHl({CuYR`o<JoDcILg>6*d8
znD&m$<nSYS@(RWD?8{AagBi_8wJ9v4S>XyZD>pUtt>miL{`w^|YXok8y2?_MlLv1W
z^5PxnJ@nq^*sQ`k)M2kBVpy**9O3Lvs{drIXVw(~KUaic8cH}!st_Im@3CU8S1<x_
zJz*ffoAm}h&iZ<OpGt4BC;J_`!THgSEQS92Pb$H8c;1DPR`8S7hYpadj{~dyoG4QZ
zbbbbv>vFeVt=M&XC``Ojhi{FNZ%1XpR-%0jJy$%YC5Tl&Yd}lhwF7q<^ub0!mbA&6
zR<7j=T`4`_w`R_4U@y~V{T@lt^4?D^Mc=h(*>PwOwW95hO7{PQ{J))xR7N8I2E2qn
AvH$=8

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82158659-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82158659-2
new file mode 100644
index 0000000000000000000000000000000000000000..8b2a6ddfd8f3a2ae4505508b8c2c999915ee782c
GIT binary patch
literal 1837
zcmY+Ec{JOJ7RP_TNF<20wWXFsliEkBrL+WXwTc#Pb?DfhS`tgePVK><l~^WYZHplG
zt*X+6AzJ&|QlnH!Ew$EO%-|XCo%7DS|9ronbHC@@d+r~XBKoT}7>1{S!4MFDQb3?|
zgfNt9rf|We?xt7cgX1DQBYsa?_+N4>D^B|r-}XAw9;a@o_6yBTTV~cndr4fRRhqhm
z(Or}}cq3li+HV?yPtc{7W}`(h1Pq;su~dg|@BAiZTE-xJXyiQ7q=#Q!72vheeJ7Ri
z(2-jDVR~`{unT4nm3Szam{7y78Lgk5X4wugG`B5-*XN~A#Kgp1<s0RFzKs%ToKnf$
z=ig}j>QBEllQr=1VdUcpcY00$y(IZ!w%RutZm$i(9flZWl<XfYSMY{?o|Pk`@hQ;C
z)qmsUv?P08+qBAvK}ANQSI4$$nKbs5Ez!!fPjk7!HCqe6C!cAqvJtT#F(5*bp6QtW
z*aR!o^HgX){wD~?g;&f&oaR2f4+I1mTo4eQ4}~030qpc4fXpM&|06mO0t29Erqq3G
zIIebPCaZ{6t)ptp=9kSZ$;B3VX|!`XU%sG1g>VjSAWx-h6Mls+qfUfLwubppfY>Ms
zNTr~JfWsja6dC|P;6L(Tf*lbIdL-Ns3JMPZT#|^xkU0RfqYmSTK_LLrc+`S4qX3B9
z#6Kwr8wGHQT|BbADDZ4e&ynprvR3G<;~_Vn^&=Gw4LqwMYPmby?^Q(pv@I4OJsi@@
z)4`dTgTOz#{IB|>FXe$;xz^Ce$8DDF_6-;p$};KmW!?c+SpMk6jxP&|rpyQvuVZ)o
zP09tBE~_IHqVX#2NeE00SQs3(!}raB;&xOPA}Z8%Iq|o?W*+T7_=JZCnI$Yva`jv3
zAN-u~t{}1=EZEUYftw@d5jiNacIvNvah`W8rpJ{S2z%GdKHX<k4K5^96&iOKDRGMK
z1obc0kdxK#Ill>ijm0_0*!xj^hH}p4w89^SO)>b!aSfEQT_Mi^?UmfOjLB*CeiLVg
zNPA{0S<tFIX^RPG_P7w6SUT#C)-%zBBrLn&>SL-IvxSRsfL$~QRWD3ys-hKkh4BpZ
zB<J|uZE`Yzr2{EXy*7n$W6Cx|^`zSNC#KcQcUIxeHHPQM7bK-GlD?fOmQ71vpRha7
z1>-Jp3E1*AH_B)!mS=y_;-&l9CQCm4YZ+9#&(%uOI)Lj{rqmff+x+Ya6*C?f-jgk`
z>+RN?`bp$m1UDl^q-16DGwM0{W&Z|YiuS3_G6P?M4U`q|fO{F6Iv_Jwc$tA^Yb`#D
zhWG2E3}5eEtMBbW+yH#Mowl7!rv%)0HCt9L53+AHQ;m?<1U!Y@%XG}_GEbcCkM2V7
zRNP&EBtVj|o2tI#{>7KGNiUk%VJ*egF00bp=B&QzcZz)tlYfzcT~T@hs%g<pXzdPW
z4Z=T<P5h#{ES}_o_&v-?ZYDXe@Kq$gBM-TvhtnJ>Bl8`Gukjs9Y!PnVxB`cs;^S7_
zMWW}oE9RYN4Bfeuii1X%8rI6!lE!1CctY)cD?_6^-S_uW9$2`}_N=7Uq7$xfiAkF6
z3dg#mIF)NEvVqF*l5DdF2+P5wY*ibQc|&?ur=+sCX8N3h)(cG3D_-bFo|Z*XrNaCt
zm8d?&05d9>KOFE%h0gwQ4jv(~f2+B9vyEYVsXLJum+Cy7_tqor(M|Hw`sRb-GLg~5
zVIM36x8u^J+I~BWAY&2wJ~Jk`_4=^<kL$-g&!eY)b+aJOeUJ0K*U&Qy5yafEm^>pN
zTkaWpN;A_&gqJwes}g_+xQ@2%jn2$#s?y_{$MwC(F%qZ#G#B+Yv51(d5ZxJ5jMx8p
zuA(d~Jf84Dt7ESoC1Lfx<VryCy0KM&FBBkEIlKMve?i$X&j;Mp#w?5H2bbgcqL4|e
zh@J&BnrNkyyY7C{z?a^cR?}mNDmPLxywN7nK<X&2LDDcB`75OA4(z}3l;j00COGk9
z)$$7GGaU5^((vtqcxw%>k94D*lqJ}BnL=18qA1V!zPud1z<PwSxfgCBNWu1q7k&^8
zb~%Vkilx+bYd42>k(VR-rAV~fCyDS%tBl&XOy1&&>@;?cQ#3h}#r?EV{FJU+C+)j4
z&2(D2D#)b(-{Q@AXwcSn({cW}M!CXM4R8S;5?+~5WTrUhs&6m(X2wC1Wu|;#MR4sN
z#p89+{<B0jI#3&B&A(eJ=VL1;(~F$W3d^b4lC&U5B+MS0T@TS>0$CLx`BRgbC#+r@
zaZ-zXx_V+Ob*lmpO5xW$@p=@Q86W5TZO3tZ_c%5Kr6<H|>)q+nzkJWADEe+w7iO_N
zu_I=M?V^7T(K0&!H*InN$4U*_B-%$C^NhK^qcv1TTA_#2s#VSj$`*8k*wq{DT?=z@
Y-*8w*XPBUNmc`!Hu)it)|8oK0->9xUYXATM

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82158659-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82158659-3
new file mode 100644
index 0000000000000000000000000000000000000000..60bb11331d1a0ebbc69f43a7f9abbd128f8d0d78
GIT binary patch
literal 1837
zcmaJ>c{tRI8vgxe#vDr=k0J({vBgPQvV>!4vM<>pGE+EY->&^+YidH8K|^DZeH&$$
z5JRIZmxeIOUS!FHh_N1B$Gy*UpZm{!|9Ri{`QGRGzUTYn#R)!e0%MeLU=#!dU^oz{
z7}I4wwvy8}e_<O)`}35*?pSDUCvP+Socw%f`L)1{Jqap?iq1qI%`=OBnk%OTy2J@=
zl+HJ?pRK3My9O=pC?)9-DzcG+C|y*#7s_7cmz`abn8mX~-C^2nvU+-~@j4$jM(3?q
z=0i6^#qj*+P2gq}ok{hRGdCy1nwtDjo^Qf33)Oe*qkb%li{8JVV9YbY-LQiYpnXxG
z9P)0`=EBnL7P8)dco?7a$u~VOJe`_~&Q@GH0}tHPbtn{qOaz5RNfx)#wVLwIsEtQB
zdWLOE&5O{NH7%-53JE9Tk?WJ}`cfj@h%H$4Wc+J>R4tp8k$UlUHAdjp*kv!+34bzb
z5TE3TXm|`OQn~;Ep-S=voXYT{|3E;n5DEd2MKH*bE9Ou>GGOU3>9^mDfN%gXWT{wy
zbgWGM!a`OVvF7*lW^`T&3N>H4EKsdy_Mgp-1Q@@JOE<_><=LV1ohS2!KxvQ@M<@=!
z-^GCh9D*M>T7p9$0RRO4P5*Hm$BqMbOmGMep#%U>5zeEKH30M=j^al_egHx{9zk9s
z0EpzLzf%x80)Pskk0k>Es@A?cmIKGq5vlEAWt@ag>F{ZE;xig)RCa#TxLcoe728J{
za$CsicxMd)f8X+74Bop^07CPfU^EF~xa}o>=dq=yS5o;08fhZbseCGmlv}a<V4tHu
zzi(m+eH9O83x6kRDB7tt*mKzX*bY%Af`!46?q{9`Zcyt?pEXH&m3QXb-TqmYyTX|d
z?#lXHgr@c~Wc6LFI2}fAE_hrn6Q+KBW3md@6|x&EulcseHpOfyyC+2T*ES{A_!Kp_
zbO@_%qo3xo{-hV%+LZrZBla6*@jN_ruJ>)%*5Vu=RZMaIz%MpF%pITn?0IT?w9Kiu
zGo77_!%jC-*(YN|JxN01c=E=#N?fHBL$PXdO*0sS>3uIj4%NLL)EP`nYc6Xg742{A
zS%W(lR&1TU+0hd9{MlUoyv#0m|8?44>*rn3aAL(G<6EbipBGj%56M@avHab`XqFEx
zcgX#UYWT|a$83PgSA!4fQY8<iM5Zg-N3J-vv)`9+E_(+l*ob+E($j*KGn6MN1(I)w
zmGkbHYK_6@%n%wY64SHHV*|nZ+BI!n=Q`*mJ@skH@V<&v)T<NQeVha3HTyJ@gD<B?
zr*&ZUr1UbhVxr{qvE1#g7ZbHW0(t4=tmcL!;qk1(^VS1r-%A@aSnKvRtO8-PskZ-C
zIa9JJaTG@i-aC|bnQ>1l>|b@LfV?z%t}WvhS@BbO{g57C=-NCS;+d`Ce3tQoN)Xkw
zO8FyaHM)!caEKX~>frvmQf(y5)|0%@;I$WVXKhp<_g<1p5t&Zhv*6q})(>K4>deEY
z<tWJ>g~k&xSIf?sAN+_v=gC)AzzSY<lMhE1#{5?BRd2GTk|6>!Qw@;oY28lDl@}D`
zEC~nU`4JnQFKac6t5<R2;^yq+7Hzbhmds3TM(abD*I_Q!P`W-jL6RrC#?Yj6OH@BN
z!-ZEc<Fw6NEosN|Sq9D1tZUL~2_IW1rgNx@P93LSzq$RP`LQ>RsWv6Pmm|GzPYvQI
zHG||sbi_$#Oda-7{Xm3kuJx0;Q~M|eaz+Xtr@$w=6G9{CRrRMW=J;$6cY6mweBEO9
zrW}{KWy=z+v`%Hx(lln4MpLjbnAQI2VeYy|sQm*zk#21jZ)QF@iDjf7jTNy;er2-7
zm#(P5HIplQ=#37L(E#N3D4GT1(Dk!<9HFwKtD_}Q*|R#PVu<@=20H$~2>-Mk0rnUr
z^OapJJjZrHNMsd0G>_<T*ElfwcAxfB!8M+>HVKrBi@GnZr>5-e0A;HohpIq)9?*83
zzwN||pPa{E@{?^_#zptDWNteMpvNg@aO<|FgmA^okq50sVel!#Up3<=IYT~0W`J(R
z8aFcJEMr_L?!EH+;aw!t6pkyZLziE+vl-2PTH9tcnF!l2C6;WA;6Jp55(jTax-Bu~
zc~dF1qp_5F*2?y@R;Wejf|+>suv@V)ahX*;rJBO%Rxj>xh|68_;50*SS=wJRH26%K
zo5o>G!(wqEXZ}k506e-;Va?U%nIyW)3AO)tgGWcNyo#<~M?$EQ`dG{Y@deZg*BWKP
z>G8h#x+M{HwtI5K6L3A4Sr?V2=nzeKL5klmzpxNHY4WiX^tfY^HQZi;cUtO?`#JsP
y8Z)7>h86XG&~8OI&dP{f)Y_IN9H)Itc7V&vx`0v{<QeaHRI>jcxc}{30QeU<6ho^3

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82168258-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82168258-0
new file mode 100644
index 000000000000..e68e2816a816
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82168258-0
@@ -0,0 +1 @@
+��X4just some garbage data which is not a valid key blob��:o���Hclientid�:o��CGappdata
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82168258-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82168258-1
new file mode 100644
index 0000000000000000000000000000000000000000..6b94220472acaef197546084c0578e5d1fed24eb
GIT binary patch
literal 206
zcmZn?Yl=A0#L(K<#Ms>=CBVSIB%#nGrNF?z$N-@j!4w;iGGJg}mS|{_Dqvvz{uQK_
zX&+FH0Rz)PDF!B`2VmwQDF$XSCouDz6r;(;vtZ_VFf&4-zxENYWcmdwKgRcYUVk^H
zyh$z-`8SJmp31+DAFOYLI06_MKo%pwg=Xi4jLZunRC!lh7b|qR$sby7`mnY7OwY_4
aTUxi-nw+z%UHGEzc+oK)&q>#W8X5o%JwP=8

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82178158-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82178158-0
new file mode 100644
index 0000000000000000000000000000000000000000..8c41bfd6d142a8284c2df4d1f1ab351c3324a50e
GIT binary patch
literal 206
zcmZn?Z;UwE#L(K<#Ms>=CBVSIB%#nGrNF?z$N-@j!4wM<m|~M~Xp%BuU|^PL04ZkL
z2UKLhz;sZGfl28Bn0ZKwfmzH6%seN>XtMDvn0X$|j8Kq%k<Z1R^6wjG`{$SqzD82h
zrP=epSjD;@VzHgH_y5PQ0gMbFn-Snbv-3hm<^>U|+y$*0o!!0id@6b^mKv<gh)Aj3
YB$)K-TgSs*?Y%Oarf@IbxR|*C0C$2sA^-pY

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82178158-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82178158-1
new file mode 100644
index 0000000000000000000000000000000000000000..69305d2878c1e2c42df1a15a35f1c261d8f14e1b
GIT binary patch
literal 205
zcmZn?Z;Uw6#L(K<#Ms>=CBVSIB%#nGrNF?z$N-@j!4wNKm|_F+3>X-gB^p3#nf3wI
z7%(s$lwx2~dH`k~l44*Ma{@EZNimviJPT%?2QwoSK3A6<==4%B?tV5!*_Z#r&VP&K
ztj@)pw*K5SHG01LLGb`a29U)FaG}|GAtUpG2vzm(c5BpqGy3^XZFW#rd!$`<UU&b5
Wh^Mu=*Pl<`>11DD`m3++TLS>WJ3jdU

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82178158-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82178158-2
new file mode 100644
index 0000000000000000000000000000000000000000..c09cc84efbd7ce9d78c2b12a2e25d7a9abbe76da
GIT binary patch
literal 205
zcmZn?Z;Uw6#L(K<#Ms>=CBVSIB%#nGrNF?z$N-@j!4wM<m|_F+3>X-gB^p3#nf3wI
z7%(s$lwx2~dH`k~l44*Ma{@EZNimviJPT%?2QwoSI7L~%h1LE$y0CqDk`#yivV;$f
z;faUVW-kvmUUBVG!t($|29U)FaG}|GAtUpG2vyazkE+R+dk#F=pS@rD;X_t~0-mfr
W+gPiM5<L6XUE~g2I>%S_K?4A*?LDvn

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82178158-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82178158-3
new file mode 100644
index 0000000000000000000000000000000000000000..63d07cb9f808fbe9fb226410611fe4510484cf46
GIT binary patch
literal 201
zcmZn?Z;Uw7#L(K<#Msd!CBVSI#0;jmSem317#JAYK|H2?3{6r73`_^57?_kEfSHG+
z7?{PJz|3<}j3yh;f|=*R%m@Xw@^dSz_8;utoBVd_8~;>}oOb=~hgzeSoxA0(`+m_2
ztpG*_pxHnS0~eZ|7cw$0h_KK|{a8K4x5bY|YC-f@<N0r%9$WupwcWW^&tq&m?I&l<
fo^#J-K_*X3`-WE2Bce0AgF`GC3kuBgwln|$l>9|3

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82178159-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82178159-0
new file mode 100644
index 0000000000000000000000000000000000000000..5d7d27a2387a333250d2bf471287a269a89f9373
GIT binary patch
literal 314
zcmZn?Z;WI#X<}$?Y+~$gk`iEGU}6SST#QXp3JeU4Okj$Ytx3v&fq_|)k)cVdfPwM*
zSCAs6eL$W81Jgk%1}3EkVCEqy24*oQF!P)gqshjzVCH!+GeRL*^JDw>y<XE)p0LL#
zZ(UN=#{KfZ41cSfpZh!GXFr#33t(gbS_#B3aG}|GAtUpGh>4yVA}^P9eS7tGLz~{p
zwCCIXkJVXJ{M+-&N%6!z!42VptN+?)B+GA{`MuZg+_%-Y<}V02$>))Je#LZgmg)`G
za_P4JKE4#+nXqBUNm1n*MbYm<uPkkSCDQ^QwaO@MO*L4O#?5e3^T+(!d%h1U!d#ek
pG98v;`F<qFM6O0a<<K_0Zyw*j*o5BI-R!;gaL{4r>px#M004#Yc2xiX

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82178159-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82178159-1
new file mode 100644
index 0000000000000000000000000000000000000000..79515cc5f6d8bc19aa1f0f7de3e6758eb5c5438c
GIT binary patch
literal 314
zcmZn?Z;WI#X<}$?Y+~$gk`iEGU}6SST#QXp3JeU4Okj$Ytx3v&fq_|)k)cVdfPwM*
zSCAs6eL$W81Jgk%1}3EkVCEqy24*oQF!P)gqshjzVCH!+GeUtUBq`$KB6p``uXXp{
zZuB_Gw8(1PEveV16ga|i;(m8M3}9pcS_#B3aG}|GAtUpGh>0^zX0_($@yg2y-g|IY
zlx5**twZ*WA9>$v1x<P_l&i@!<3mH`@niWV^|nuZ0&ZP>G_8lr=9rSezuS*(uQL|g
zWNe?#T>N&S;8ekNl|}K7+&-<dR)3-E#8lVscfk0kX79VV$-((g9|=F`F0fhiVe)m=
o=Fi(R6i@Uu{qkvFy1UN&uI>AEnfc$iEiHa=$$D>!H1ui!0Oj6vod5s;

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82178159-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82178159-2
new file mode 100644
index 0000000000000000000000000000000000000000..c5f577c4f91c6a4559ce63d767679e5933170b6e
GIT binary patch
literal 314
zcmZn?Z;WI#X<}$?Y+~$gk`iEGU}6SST#QXp3JeU4Okj$Ytx3v&fq_|)k)cVdfPwM*
zSCAs6eL$W81Jgk%1}3EkVCEqy24*oQF!P)gqshjzVCH!+GeTkSp$!ja*qF9gE?Lvj
zGOdAC;={g$X2+(i_?VQmB<t1L^Z-T%pp`%j0~eZ|7cw$0h?p4o$|6r)_|5U^rStOU
zDTJu*+I;Qtz6>Tg{YQTH(vqGjZ(jRra%AVJRdWoZOjKGlxAm5>=q`&}5#KF)r!_||
zeeJP|)0cW9iZ|SrR;`~JCG<35+U|F?e2+gx<*~X-H2%rFXdF8Az-->Y%g*U1-f0D2
ooT^r{eA`v?=|aYOI`{dOaPNJ%RNaclA;)6Nr;ln!{Doy20HPOkasU7T

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82178159-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82178159-3
new file mode 100644
index 0000000000000000000000000000000000000000..c93b24c7570384d0639e16a2e8116106a87221ae
GIT binary patch
literal 314
zcmZn?Z;WI#X<}$?Y+~$gk`iEGU}6SST#QXp3JeU4Okj$Ytx3v&fq_|)k)cVdfPwM*
zSCAs6eL$W81Jgk%1}3EkVCEqy24*oQF!P)gqshjzVCH!+GeV&wJZ8n0Esdw7n;+Vg
zlx6?ye|7uY_s8w)pL9HVFm2KV_5el(pp`%j0~eZ|7cw$0h?r>pby7;2fpXHEB^rDO
za{lnLA1=^-b4C5L*C%J6g4o<sY*+Jc%PbSwzxC5;Dbqc<|C#G~KQ~K#3Z5q|e{2F{
zRP}?@kD&|p#R|0F{G0u_X49R|2RyuMdEX=?__5c{Z(PGJ*P6Y?A#SJ2$rSI@Z)>K@
o{OWH%!rXQAf8jGTD+OlJNxT68pA0=*6y~|@UcLNR-JA~%0P*y9@Bjb+

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82181a84-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82181a84-0
new file mode 100644
index 0000000000000000000000000000000000000000..cf90447051c5c6ce847cd289ec412aa1c01602b9
GIT binary patch
literal 326
zcmZpYkZNI!_|e4B+StU{*JKs{{~xDx+Ku*`(NbTPnxq667?>m!Ks4hI#wIBR1_nk3
z2nFG>Kqxi|hbAcl1_owHkhB2<<4<Og9;SU@9@9Z71}3EkAPJ^JQVh&uPGIIaDMpix
zXTi+#U}l7Z%pn_#jUk*YbwTADF1oqBQuFe&R0t7Tvv<~qZ4K_b`2rXjKrTRl3(d|8
z8JQPEn6=;bK7LY1-TLX=pB?9SmRjl``7YkG{M+jZ0TVBp-RX2*$G_ot{qMiO@64F3
zWd7|x>ud#yIV-j{G=V*X@I_;rgcjWU42+FH*LtZ$C=|ZtydM>GZ~l#wpAO~mOq-<8
Tb*Zo+VNSvi4HFh-4Pz|;0;OxC

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82181a84-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82181a84-1
new file mode 100644
index 0000000000000000000000000000000000000000..02233d7b04c84c91e3e54baa7a0100b69f5a5574
GIT binary patch
literal 272
zcmZpYkZNIw_|e4B+StU{*JKs{{~xDx+Ku*`(NbTPnxq667?>m!Ks4hI#wIBR1_nk3
z2nFG>Kqxi|hbAcl1_owHkhB2<<4<Og9;SU@9@9Z71}3EkAPJ^JQVh&uPGIIaDMpix
zXTi+#U}l7Z%pn_#jUk*YbwTADF1oqBQuFe&R0t7Tvv<~qZ4K_b`2rXjKrTRl3(d|8
z8JQPEn6=;bK7LY1-TLX=pB?9SmRjl``7YkG{M+jZ0TVBp-RX2*$G_ot{qMiO@64F3
XWd7|x>ud#yIV-j{G=V*X@I?avkqA}-

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82181a84-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82181a84-2
new file mode 100644
index 0000000000000000000000000000000000000000..f39c95304ad948fb66086276e7a59c86d9a02ded
GIT binary patch
literal 326
zcmZpYkZNIw_|e4B+StU{*JKs{{~xDx+Ku*`(NbTPnxq667?>m!Ks4hI#wIBR1_nk3
z2nFG>Kqxi|hbAcl1_owHkhB2<<4<Og9;SU@9@9Z71}3EkAPJ^JQVh&uPGIIaDMpix
zXTi+#U}l7Z%pn_#jUk*YbwTADF1oqBQuFe&R0t7Tvv<~qZ4K_b`2rXjKrTRl3(d|8
z8JQPEn6=;bK7LY1-TLX=pB?9SmRjl``7YkG{M+jZ0TVBp-RX2*$G_ot{qMiO@64F3
zWd7|x>ud#yIV-j{G=V*X@I_;rgcjWU42+FH*LtZ$C=|ZtydM>GZ~l#wpAO~mOq-<8
Tb*Zo+VNSvi4HFh-4Pz|;0b^^T

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82181a84-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82181a84-3
new file mode 100644
index 0000000000000000000000000000000000000000..438b2be0857ad3320d027959e3fddcfe939b4674
GIT binary patch
literal 326
zcmZpYkZNIw_|e4B+StU{*JKs{{~xDx+Ku*`(NbTPnxq667?>m!Ks4hI#wIBR1_nk3
z2nFG>Kqxi|hbAcl1_owHkhB2<<4<Og9;SU@9@9Z71}3EkAPJ^JQVh&uPGIIaDMpix
zXTi+#U}l7Z%pn_#jUk*YbwTADF1oqBQuFe&R0t7Tvv<~qZ4K_b`2rXjKrTRl3(d|8
z8JQPEn6=;bK7LY1-TLX=pB?9SmRjl``7YkG{M+jZ0TVBp-RX2*$G_ot{qMiO@64F3
zWd7|x>ud#yIV-j{G=V*X@I_;rgcjWU42+FH*LtZ$C=|TrydM>GZ~l#wpAO~mOq-<8
Tb*Zo+VNSvi4HFh-4Pz|;0Yht{

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82181e83-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82181e83-0
new file mode 100644
index 0000000000000000000000000000000000000000..3f8123775e89b45f1d0c72d60dd424e4efaba6e8
GIT binary patch
literal 208
zcmZpYkZX=O(ZtZ&*u>b~BqhMWz$Bs2B&EQ>z{mih7{L?^6PRKH@(dUlm?auOYMJ%{
z)fg}^9h72VQhESp9+F~U7IOkK&q*<wY&;8Qo(D4{6gWj$zlGKQJG!uad6E=|{j!7)
zjp2!h)@CmcHePY<Qo{29Mh1|@2ymg<c_Ab7f(TXBw2!LEmwOI8*`K{%`r$)Xg94tc
ZJ=<8TixNEh)?MTdTsp^B^+AJ!0{}xqK2ZPw

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82181e83-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82181e83-1
new file mode 100644
index 0000000000000000000000000000000000000000..3fad357389d732f71a81e42a63c7163ae963b2bc
GIT binary patch
literal 308
zcmZpYkZX=))NW#EZERxfYLXIQU|?bfQ(TNqQVI+Vj7$&;C|JP2`28zLj%go5lav7i
z(?KZ)CZz{p<{>EtW-%u)^PCi;$;Pu_=6NtPLLt-h+^Nknx1DdybYpb->l?4x@oeF@
zMR%X>U9`7G{@*T^07eF&O+X9-7n+?HGBPiSn0PVnW!IghY@dXVFT38dm%)AC8oi(u
z_N7<N<~5$*XV7o^!DySlU1m=5<*M5rn=hOY+Gq4EVR=!daOEnFTRARwZzo^<R=Tc|
znTIt;<Ec)VkLVWJhe1aluRXTr<uac;|MJVzr+vA@c8h1_{ICahnLAG`kSJCx<9(I*
in`?P=R-54!Cac&h{Z9k)E?e0i((HMj@^yZLg98AFcX@39

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82181e83-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82181e83-2
new file mode 100644
index 0000000000000000000000000000000000000000..5967cadc6289ff06926958f1c8dc0746dbcb1926
GIT binary patch
literal 308
zcmZpYkZX=))NW#EZERxfYLXIQU|?bfQ(TNqQVI+Vj7$&;C|JP2`28zLj%go5lav7i
z(?KZ)CZz{p<{>EtW-%u)^PCi;$;Pu_=6NtPLc!vb+v3HH#!Q;8Q#&_Z%BqSKx;k~1
z<?h8B&WWk4T%@}ofRO=c6A;6|g=Xi4jLZunCR*+-QO!~M86PJYBm94lAom*CZ4Uh=
z=`RwVs$X}WTK2NHpXHv7=H&8<|IckIEmvr|r<RK3Iw!j|Z;!jY>Bg~V57<O^=)YsE
z>^pg0c^6mhkEPQ-^rS4?RMNHS{^w<T?{hLwVB1>xPWho%>e5ruF8&<#zm_RYd>A8T
hd*%O~T^oW+uM{M`56$2YKhn3rFtM;(Rkp#w0RRL8bEyCT

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82181e83-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82181e83-3
new file mode 100644
index 0000000000000000000000000000000000000000..705537b14a79bf52b97c1185d05e9442bbe57e84
GIT binary patch
literal 308
zcmZpYkZX=))NW#EZERxfYLXIQU|?bfQ(TNqQVI+Vj7$&;C|JP2`28zLj%go5lav7i
z(?KZ)CZz{p<{>EtW-%u)^PCi;$;Pu_=6NtPLP3>vr=#81s_zreI&=Phu>Oo-y<7hb
zOP8!W>@W6fU(37}z{mi!35a3fLbLNiM&<<(6We!AwYnu^Sdo24<fGbi{!@y(9smB#
zWjwK(<-#(~+e{PvcCHARr*r&-X14OuxlbGQYuZ#}e)}D$mGqsln7?iEVI@Yvf?DQ=
zP|HoPCrI&3GIU~|`uT_Vz3u7C=5ZOWmtD`(+;r#7*2<tsXXU(-ryM#ZdTr{ZORAkU
hp}B0f+q)0lpRTaCzTDnud3$SAJdggu3E2$}4giy<akKyc

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183184-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183184-0
new file mode 100644
index 000000000000..204f7a8d8973
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82183184-0
@@ -0,0 +1 @@
+�1�?�T���DFfoobar��
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183184-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183184-1
new file mode 100644
index 000000000000..239a31b197e1
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82183184-1
@@ -0,0 +1 @@
+�1�;Oi���^�'Ffoobar��
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183184-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183184-2
new file mode 100644
index 000000000000..88586f013ceb
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82183184-2
@@ -0,0 +1 @@
+�1�Y��͑.� Ffoobar��
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183184-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183184-3
new file mode 100644
index 000000000000..06fb12a640b7
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82183184-3
@@ -0,0 +1 @@
+�1��bxA�N`Ffoobar��
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183284-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183284-0
new file mode 100644
index 000000000000..9f819e83ca57
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82183284-0
@@ -0,0 +1 @@
+�2�;*���(���Y�aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa��
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183284-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183284-1
new file mode 100644
index 0000000000000000000000000000000000000000..305a0569da0410347a8d9649067e3ccc73c8f937
GIT binary patch
literal 17
YcmZpYFlv$Z41C1kn%ghonAp$&05T5+;{X5v

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183284-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183284-2
new file mode 100644
index 000000000000..509b24b744e6
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82183284-2
@@ -0,0 +1 @@
+�2�_��K5]rY�aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa��
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183284-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183284-3
new file mode 100644
index 000000000000..75d713d2b30b
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82183284-3
@@ -0,0 +1,2 @@
+�2�;
+�E=����Y�aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa��
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183386-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183386-0
new file mode 100644
index 0000000000000000000000000000000000000000..b96374f12bec7f84fb4cee18859dd75a11a199d4
GIT binary patch
literal 86
zcmV-c0IC0i7&C?&3Is5<F>q@dflNqcY;12JS8sA`WFdh-frc0=8)n#t*;^X*A^-t_
s8UO=IBv>GE>j~dlQr@4~$@0Q(43?50iqdg_V4Pt1C^Q5EC^IU6fGYPOa{vGU

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183386-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183386-1
new file mode 100644
index 000000000000..e07515ea2bda
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82183386-1
@@ -0,0 +1 @@
+�3��6�.[��LHello World!�@���
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183386-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183386-2
new file mode 100644
index 0000000000000000000000000000000000000000..fb70126f45351f7a3cb5755ea9de296595d191ce
GIT binary patch
literal 86
zcmV-c0IC0i7&C?&N8i#Kgs_G7flNqcY;12JS8sA`WFdh-frc0=J4Ak~_aq3MkN^RJ
s8UO=YU|1mBmf8Ro!r)i10f#a<N>X(y4*I4#md4Q26Q}2XSIf76fYECtBme*a

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183386-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183386-3
new file mode 100644
index 0000000000000000000000000000000000000000..2ec87008894ec8dd8008f2fbca30189c51a63dd2
GIT binary patch
literal 90
zcmV-g0Hyze7&C@D0F0x#&cw)ifl#G}sSc?#a$GE#1x*NkKc0a=frc0=8)n#t*;^X*
wA^-t_8UO=IBv>GE>j~dlQr@4~$@0Q(43?50iqdg_V4Pt1C^Q5EC^IU6fTHdt0{{R3

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183481-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183481-0
new file mode 100644
index 000000000000..7f4913fce35a
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82183481-0
@@ -0,0 +1 @@
+�4�;z��ʖ��
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183481-1 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183481-1
new file mode 100644
index 000000000000..9a89501f0f46
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82183481-1
@@ -0,0 +1 @@
+�4�߆���6
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183481-2 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183481-2
new file mode 100644
index 000000000000..219dbb27b925
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82183481-2
@@ -0,0 +1 @@
+�4�2���
K��
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82183481-3 b/trusty/keymint/fuzz/corpus/keymint-reqs-82183481-3
new file mode 100644
index 000000000000..f3875ac841ef
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82183481-3
@@ -0,0 +1 @@
+�4� 訢%��
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82184180-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82184180-0
new file mode 100644
index 000000000000..a0a6c554c311
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82184180-0
@@ -0,0 +1 @@
+�A�
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-reqs-82184281-0 b/trusty/keymint/fuzz/corpus/keymint-reqs-82184281-0
new file mode 100644
index 000000000000..775bb4b5ab5e
--- /dev/null
+++ b/trusty/keymint/fuzz/corpus/keymint-reqs-82184281-0
@@ -0,0 +1 @@
+�B��
\ No newline at end of file
diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00035504-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00035504-0
new file mode 100644
index 0000000000000000000000000000000000000000..8900169ffcdf6c6a7db0cb59d998877e890bd240
GIT binary patch
literal 1975
zcmai!c{J3G8pmfdO!j@x7RmaXF*EkvghAF!#AIJC(L%yx84Mz1lAR>s^=8R(361TB
zM3y3Xk&?Y6jCHuW=l*feJ)L|1dd~OzJkNih^8rCG!r0iL4mce09B>wXl9+fUy}SXm
zmk*$(hEj7!Au*mB7$0@Cr#Ao~F<5ssED9h)qycs~LV;pN*<lBR!Au}18NvxV=}$q(
z5HP4*V4i5c;Wuk0xpiet@iPOc-Q#<Vt{A^^cLcw0^-RdN8Ot^qF}K<144QWcj7>cs
zULU7b9tCSSXCtE7wH4Uk7Z^H{)X{opSjS!GW;s1F9h9wM`V3!b<C@effMVEqPue*(
z$C=n##Ms1>-CRaI%pF5<UO$eYQ)I0)(cY@hk2{4=Q;*-~1N9f42y0$~3q!67*mlny
zJayOAP(tKh!#hy*X-vs&lUUUhi+P*%fE)MzE_uz@%(-9eRV{|!0cZ}{n(maw3rkl%
zK+&VtT;w?i$@JFjAZLd`jXOP>T5@HHIUlh1tpg(s+ebep$dnZ15y8QIOXLh%u`Z%o
zd0KvCq2-uWWu|9>Z#rt-OxVOwXmZR&gta{7x_U&Q^+9)S)CTgMF)FBT%THX~Z$3?4
zgx^5uCBa!~_!=8|{3b^=?ZuCRZ}5oH(yP#n^csHZ(WCvuw6<}X4P-Kbx&j{Py7DxO
zH}7MR*JUC+Z__b|mvLt%H$*KL^wHw>D{?q3;H!6-6mxz57ab)YI6W#`>rZwC*{aa4
z9R_~XXM4MGs5X>1!|oygpDHg*cz7E7jlzTWN^7S`<uB{EW=Z&t1S}%p#?H9pdn-_{
zS3}!=Glk(SmkzD7bMEy9Cf92P5C&rr;tkFv+C$!}PBYz2ibJw<3agk50t5;MflECB
zcR>6EDRB;%0F1A(Iy^v~*N)=vD$7_F&Y=iMK2ioGeywF-LV!RFAJ%;iL`q^p*ru2S
znjVW-_ODp;0Gz)Lc){Rf7!v?J834zxg7a4agF+y%|HP2>Ul@Wx30w6oJu>wPoqXPB
zXYJ_0@0LfXzTp1wPocL+_K&y>Vq)FS|26fHU?N+=mFi`%?omF*V|uXj8J5u(Df+HL
zolsKW@@A)Lj>r|<o<w3iP>xQ>^uW>fnzotqjY`wc21dnBwwidHLT3z;tn8Qc8{BqX
zbz`JS@vxYurgbsuCI(vK%{0Qnj3B(A-(F$)%iF*GSiRS_#?x?Hxd+UB`1*03B8V?w
zfTZS3u8J33LfFuRsb{>**<{<SvTP7T*BWN4*V2~8>?ZQfwb+392~v3!_Y=WN()HD<
z5P4uwebx}OH)STz`l&LJ95ot51Qt$_@wXy2`7g@zezWm?DD~y-o{h_%wOm}iw%Iw|
zP`%L#mLs#fUIU}wMQ3)3|B@7`?j>7=e=smhgn?9x07$XDWRBp)XvTx|nvI*N3t;(+
z(%-$aXi}Q1TDx&E=?E^tI?vn7CZEyoi$N7CsmA@3ZY#^KM4@34y00K<E5vZ$*FPh3
z1}E>ncpP1w-t7L9z=&+~e|!Ih&oOcTP^NL+mAj-!Z+b=IX8S_(y!2}yR;+)#%Cg~^
z2?v<jdFIBAOo;2GXxZYTkW0?MO5_DnFXzujpSstD9h|&6=~a=0`D3^GwSDT#<K%Hi
zp*Ep*i+4u5Y-;)h?gPtF>qBr`i4f*)<u<)sX@jF8)`>|HATx;pWGL(r6at1o5TK3D
z8&7jrw#EO87eEv#3<#beb)r2kA59bhXnJd4)I6{r02%|F7Gy`E05ueV)Bx1c8qR|3
z=#z-V{5$^d=l|!(nx<Z|VqH0SO|d~G<&A@YXVrR+Dyla+6bWU^wzCkuvV=J3Rj9;C
zgy^*A1@mG;@MXj>defg6%y+>qqGy)ibV25VI^KTZNH#tFpozglz5Q6hva$fDY+6=~
z0&f{+zZM&ex~2Mj8)@5g^!%8i7(9P;`Bi&Sx5W{QOyM7gt7(lD-xRe53y4}_8FP(%
zM&U@OgdFZ?Mb9e(+9%3L)JieK!@;xT(c|>%f3U{dxj)meE)6%KoQF-<f9TnhEXfye
z?ApMO59>It!C7))Vy8#Sj;^8&8XaGZ442qlDzN|Rs?O~3gGXikK1EcNBhWG?GbFcT
z`DI75o_6P+&W#RpH;Z;vUfhC`ewy6W8ob}sXR}jYrqJ4$Xa56_M&hS{wQb)^+PfI%
z*rSyfdwFqvvw8|Bg+pJ(4aqtTe~O>fPz{hD^gV1ZNv&4sV+jXN0$v*Oo;h~YiRGM6
zYgh`E<$+wz;sw^hGah%rU2mXYC0O+?<2&bPi)xDLPcq9%d~r$g3E;~{N(+%O&8hij
zbJ}hZjksQ!<5ZK~pJRS4bUSt=ACXo>QJ4^?m(oUY2&ZxT5ccd6Rcs3Hy3hOJGJKG#
zYhLiWi65%XH{Mj1B7x8yUf48nt$1j>&S~Y}WCXHhv;gM5de|(cn6bgFgW;5a#K&dH
Pfjocb$logPcaHog&+uDU

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-001e170d-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-001e170d-0
new file mode 100644
index 0000000000000000000000000000000000000000..1d6adc0819ff47d74e9b28632bf2ec74ca94090c
GIT binary patch
literal 1975
zcmai!c{tST0>@`FO!j@x7RmaX6+`w3gRBuT*_TVSkT6*Wg9wrABnijKlI0Mx-jK*r
zBnK(kOTt)(JMMG-xX*p=bI)Jz^ZCB-``_pJfKCgtqtE~f1pqh{4vBLVWJfa)srDBF
z8b~(a6dZa9#>NJ<B@mG3fU_sW#4G9H31B?D05lqfc10nv?&?@CHH^C_03fkAS2PX<
zP$1F(I~<`vHKy*cgTY`X5R?Mp1Tpqg5DEkgDifF|nQZvX8cS|nT~qu*2Ws~Co?yzy
zuihIW?wdasvTDMyO@_^FHaLRjZT+K@FND^`;L9Rl_2(=_G`hC@`}_QZM-n<(?hb3Y
zYTYWMg{OkD)Qz4KD=eK8dIeB)OV3Gbho%@qE7K^;Sc;3&h?|LBFu~*J5p;@zPZ8~{
z{PLtz_;kkcyF8%o;!|Ob%Wz@HH36&cxr1k}=hc-EIoFA{89MDuiLH}3)g;q-%XPn-
z_y3T*?rrSYFZQ|y%Wn%b1#L}tN)v^pD;}a~5o=EJoP!ivOICoR?V$SI9u2%)X?*ra
z+ye{$aJ{zCPjNEE`MD%;VBZoYt-a_xqDpyMeq^Efm{nz_XM%4!V%=ESP)}%b%t?f`
zEa`??n7_qAcTL0w^1T5npmxhgT-;|qMP7toSLl_!qtftoHp=)dj;i*TKl8uC!%9l7
zLDN#J`7@3l@5iUKj>~Ky6YVorzyn=ZpJnpqehTooLW1XR+6C~^@6O}|p>sf=Oz*s=
zgtq&A^9+$<uIvA*rNjfLMP%WBXIGG|4DQ;Y6Gy$aw;P6Pf=M&%P6F_$vVyorr*Yq@
zJQ$CZHmX$KvQA5;g!hQwA_8vUNJzZD0`+)3wCyuf5Xy4-&>}1Qey@LG9p2A=Fd89V
z?^vuk<hklF)7_{zBs-_DicPbJK*1nzi96s5h%=ND=YR>o_!_E0{nU7^slLv#^kv~}
zs(|EUWkBNOS_UQr2t@JWT<1XK1SW)4lA*uRv4~m!iUkkAdGdf43_gZ20Z_&PaGVUB
zCj$%$fx!M#L)L$52nNM%)iw9X)Wvo3d7hoMrUkxV9?9?q_lJHCzD>4y%%vL@?Q-GI
zsYmvPvgKUK9=hvpWn(->2RmP2X?@|M@5|Nfi|d--?ljJkxB}Y}$n=NGk#Xs6g!aA0
zZRR}vlGL;Q5z&(^hHj@YX@g{Qn<brkmtE)cQPSjCSkyD4+9)+cUA%ZxyZyn8AUwa{
zMq&BuyMO##z2CaVQ-4Rf2h4r==1Hw0h|h0;jCQ0{#)>W>EZc=M&Ul!x$+ntjS|Wz7
z*Uwh1r7VqEPvn{4*?{>8a#;lTQ^5-Ijn&E^d0<d&Ru8*3Wh~G7xgwqtF&aPu7EV!!
zx5GC1FUj+MxAcA__4VDJrPH2;Tuhy&@wxNC+N0$xN5=O&21b8~&g>NZDJfFbOEC}q
zsB0V#1F04QkRlt&Y{5&B^oOa{8@Esw!Sa`+e|ToLOKGg)cVnVb5nO_`?st|AzhFKT
zfyz~q4f?6w=4M^-Lc?TCUw*<?klwzxZ(8~cLEd%oII=3W$@P~#J-pTT-Gi52$E5v3
znTB;|?&3o2=@p4vZ3|8F(r>(2alWxC%X()fY+=S1m>V|IA<mPcrHhL~PT2!1;TOrh
zoWB~pYTp!eaPn%UR)*WpAG_48?Pt6?P8_!rY87fTeXqaEhSss?J}?`#I0UyA3t{h7
zY}3k=HaN<o9hf8m3X>Q>fx;d`Az%mu0ov%i`7CE;Tl~L#0Ys6)fFMIDM)tV8G#IVa
z@Knd5-EeLI1`C`N6a}DB08$-L!>BU~ieVrU`xpNI&wtm*>c(D*Vr?0CO|f1j>8-7R
zd*ynzDyla!7zt&|vNjdHx`a6BRj43H1ZlP92J&Kqh^3?uTI26n><_^%l6$7$bbk7R
z8qsFpNH#U~ppnj#ap#GGSw%iU*{HM#1>VxjdLuR%aa;ApHqxr`=*2NzF>wCq%Imhm
zZqp+cnS$RAS5q3wzboPg^GW!Sw7CX8{ZOPsTsHUf!WR{OZ4;&Bj0!Qm!@;xTk>j)*
zzp+MJyFOR9C<!&BUVu&4eeBtjEY1_K>)IfW4{O=2!C7)(Vy8z+kFH^K8|+?=3>RBp
z&bRsItj6s2lSgI!0aa9#!{00_Jt(JR`Bg`gwr1y^*3AwR7t=OXUc!QsPKw;r8ob}g
zYqL{croh60Xa6IQdi-a<wQcXqn!8xX=%baFd$}=vv)T$Mg+p(}4ar(8f0B>XP&JSj
z@FQd|0bL{XshEQx0WS&qz#P5lz;e#3B_t_><)K{m;zicMGj8|5U2mb^Bv`et5Ig5*
z3#*H0Pt(iDd@%{~ao{WZN(<ppP04x2bDAz;4TN5q<7C6#Ut>PaG;4MwAE~{NsxTo=
zD`_7kARNYRg4nZ)RdGqY>s}v*ONjxh&bfi>hCZlP?^q*Qss!Tv@WQ69bNM5Kbxw2N
lMtzVKy%{j^*2ZNrMU4$^9SkS^Gd3nu4&?s78p%lDzW}5>S5E){

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00303031-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00303031-0
new file mode 100644
index 0000000000000000000000000000000000000000..05965d99040acafd230e7291a483404eb79b493b
GIT binary patch
literal 1975
zcmbu9c{J3G8pmfdO!j@x7ERXQ3^Ug3G6q>AVzMunXdz)@3<eQ0$xf2+db2dRgvNG5
zB1@6HNXcFj#yY%p&;8?`d){;JANQ~4e8120{P#H@5CEVsSWk5<8X!Yt0ZuqVk%FV_
zaDu^L77&yS;RgNePe8~JFsMRko?x*NFpHDky1b_Ji3!y02|UuM9KU>L1ix?nRK%_s
z%P|=>x7p|lns*G2OFI`yi`S`$fi;}571Qq83hwU<4j)PGXuUnG=c#w2f)Sko%F!}^
zim$SDPwo{$Gi`k*?OmGVP3<g6wh3epw-GN3r*Jc$??=!nvQD~qZ}q1~ouVhH$8QP%
z+WE(#+85!XkSjuV-E#*|JkM$=Bl51|9jOL%mXx+htXit&yzP3>^}BzUzUq&2?U#62
zhY@rHn!~oHJ7w{rvQ_udjF>eyB=;bh(V7$D>Nu!%yGL6`p*$(~J@%eWaI{hT=!ZnP
z(!zWKIJ9qxoJlV^i>OhVMvg4B9J8y=^h^j$$E@Q-O^rk*$K1r&D^jm%Mg`j(bl1gf
zpx&CGL+ZBzBqamp(~)9=h9WPVU6qHga*)SwaMjSCe=qzBk18v>0?o{*6{H?L+)qkx
z8<*Qar8rYpzyn>EpJemre+copM1bdSI)(5vZ_ng~spo+{Sl)U`j-&^D@r{sSrS*T-
zQ|5y+VsdnT=Twxh4)5Aw;z#|qw;PA*!U;2+ZbI;>ilW2^C$V2Cd>TIK?G%}UWrNmi
zDgTk6MFiZ$)hy-i3e@N2(00H~Q6$^NLz|r3yS>3FG@T&l!8n9ugKMeokngI?Om~yg
zko=tDDkjqz0tJJ>W!``%API+FkmQ01!2}v>B7-#f?J0ro^2}w?T#AtNLlr>k*IEuH
z0tk@=u%2@uVloTDF4Z*H{8-GYf5nCm;Qn>M4+bB@SODnH0dV~)xPKKeC<FrgcMRG8
zi6I!2xJ7H}k)tJc3izI$wP%FBT^^zOgZm>thTkMQJmfJX#d)0jW9oskseC0*nvdbS
zSH&2g`N7U7SY}_e_}fZN=TchB>z$@K0#9grGLd;-B{nh3%Z$F)w9Q&zT$XV<I3{kg
z)zs^RM&=;V+F{9{!DH9`EJ>D_03$syuP14m8tO<k)141ygyDt#4vNd4-~8?S>fN?A
zzJ^;WJz(C$SC8tIKmtJnM0Hnkb%OX3!j>*dJ>_G;A>U@5ZHpMX+Av$QmcBG*KT%+z
z!vV}s5G!JM9}8CzudP;xA%Q{7StHEe6b{M$u_}oiGa5nw7EX}yH={NMFCh89+WJ3`
z`TS<j)@{#5A)cm-J99Q%f3%YA2zSS4VDy{#%udN4(qc8eWb4THhPWgcNUa!vlsHJ|
z3SWq2-p{DrxPd+oMqZHp=9^8I(O%WrjVEOwc!cY{Z!MdC(s)+_s#Hxg>8EsCTXiLg
z3==i_3X`|OjQ0HlGqYyQke-Xju{9aZo<E$K(QScm?mhQAChQ-|HLkn!mKN(zuSnf!
zUud3}edWiF4NOp7Haa!o2*aIYZQRI$xKE0gFD{C><qoVwpC|Tm|7i59e^u1M&99eH
z9ql}S>_J=Gr@lB&8FvzC6KS`6YrM;$Zs5#&U^QxU2yQDC!Q83ZW>hF|a8<^+ut)=B
z772h1g*}8qzz_%mw9$F}N#4q~<bUu2h@(US;h#vsSonGTw9x>d?W=`R_riJs8W`ZD
zFee%fsG|Xt7NDu2<togn@iU?@|BC<p`F}aGwyBq_R9^vJQ)*C6eeEdZUA>;GhVG3G
zM?pDq>@CGFFCh+k6|2mo!t~nnL-{db_;Nx7qv>}H=9_RA!8==cx-e@&6Ynr^B%hIS
z(8T1U-g=~HRaI!FVqRW?25%YVypkA<xvBPS8)esY^z4|a6gq!&>1BIyx8)I=T+wfb
ztLcrEUzKzQ3kf<AnRAT-#*rwO#9ZE|#m}mO+9%41)G7(1!@<+zvEz(uzp=;Jdp^~&
zDT_3voP$l%-uLWDmlg;)b#36shxMG+;B0v?iIXGcM^`iq8=any442wpEOhwduF2~4
zolkZB9z|T7E7*#Z6_(er{Gy{-U$=8l?|O%Yhh@7OzuAJaLAt`!8ob}!Z?h9AS7c+t
zxBs3`E9qm<+P42i-Cc}p+|kPOz5MvTS$##c;-SCNhIBnfFf~ACs1_&)`4+L4tX?Pb
zp_I!^3SJiWjx}!6h3$-AYeXuQ?Y=_p;(7MLQ(kw#U9X{Eq}cT@;XCJNi)%|5kFzR>
z0`bYnMDQhJ<%MWcb6NpzPS+!<(X3bQIL&nT$5=oM!=4i*K%f^>6elDZW%N-qgv+=?
z7-vqY8a9=G-S6FSIX*<qJwJ5aGyvV^pI|OekwTmuUf48ruY6##&TSpoWDK%nwg49X
g`q*q1(%9hE!Eow765_KJK;D1l$iGzJ|LMp-0g1p|kN^Mx

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00313563-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00313563-0
new file mode 100644
index 0000000000000000000000000000000000000000..00d3a67743465c281738370f2598b52697dbf72b
GIT binary patch
literal 1975
zcmbW1c{J3G8pmfdO!j@x7RmaXVaA$W#vp4ZVzMunXdz*;3<eP**-6sydb2dfC1kxJ
zjVwj-A|-oC80+xXJ@=1$?s?C>=iI-Z^Zh>0^WW!uKuEN=Hrh{1)7uvSkZ6pj1_lL?
zAhG}_9HB(Ul6N@4U@!{^N`i2Me)cCIBnTKp5t=7hZUoF?rME7xDSu)D^?L%3G^@rh
z-x<N}+dLJqZ^m#;M$K)~TtV|r!SU(mBB=?wlo(j!89OnZ?ycZ~{^0PDl+M=M!}^~3
zHz<tgOi-S-#Zz3hoqI~35Q=H%JL%xkoM2{e6=#=7@^BmRvUCnN_xXMVog(RGi1*ce
zdekL)GUxbB5kNivSXAdCToiIe$i8Rp;ECs1Z52epRh(0fVFycU+ayLk&1&9mJ?Q$~
zze`{B$GQ$kysSqHIswgLThm>#I8oW^`zS`tnwugwoy2I(3vqR#Yv1nG(N(BS&VP@&
zXB!-C+&=mtNv^!OkN^(tUm|67l$}M?s!l78EVLZ6tIhOI2u#PUV@1u3MJC7G#Mmim
z*R-O7Z4Y|tV>Xa)O;I5YTLF@i0rMG(VuD5@FYvA^!&f;-<2Sf!JDz_p{tAz(sJH^n
z%B&O2IeNICoY6Kew}DK>=d6GSyDvY<<uCjY;&X`rFWhtv;b-2SDG1Xj0DZ8!^^z3X
z5%k43LWY$(@L6Al56+0m)BT-ONxmk$dxwb|_1oU24b_JeW;or1;8T>6qz5N4U&(x$
zJ{j#~nWAOG)?6w7k)TBc+|<=P_3jGP=jG6Lz)VRb+r>lMy!^X;!KqZ;AUr)DA=&6!
zt~cbn>N3;Qq&y@)r?iUB!b6~75V*n{@B}2`&<m1WFd>)#tu``9i{F79=q}G(7R@IM
zNk3Etq<*dCU?PA}oB+mi4n$00LD;961zQ}8Sr4q(@&Vkx4*0>~V;Bnn{W$=xUj_HC
z0tSUZVE>LG`#&)RgOawWExmHoq%Hy9)3XkY(6`GYIsV{*$dBPSiH;9>jN;-w&iyg<
z0B<H=#gp!1wC+V2<Fh!}`2@@Aj~0JhrG+o2w!GeHnj`Rpwx<x8_f=z)vc1eZ_L{a?
zi%cpqPY1`uPqvzQozTpp6Kx!q3>!Um-Ot9!5))x@Pb?bZw9JfjC7V0&2Q$L(;sHmc
z<<D>a_I>qk+ZtcvE!AEy@8PRQ4ay*aph2RBE2$<?d<kLKA)0f_$C5+7%_i3lF?6+Y
zwstLJY0P1w$WoUBn4ch0Vt5}5R}-(T)`Tenbgfxq^xhO!k^N(JGAU*>ga9m@AmMIC
zZ3<pc<o{~t|3K#Rn>{<XJzIqYsvh>t*>Ho=Dz+o+9iPF`Z{jmMWq(ME)%KBWBHtTf
zlVKqBQUFrsD4j2SA(nYRvu@)C>O5HSg6ucn+zuI?Ro&f$xJ(3(aD(@)WwTG3@5(?`
zYU!o}<Q^OA?qrc+qGo?_%2t^1zJFj=_Kdlr=i+f}ZDzCQ4?HuvE%42~=YGe8{X;q0
zx;t-qsloJ$)Q$Fq=6Tsye(adQM73q(Qxi@w>^WB2MmEHKQoM3;QN%5Oa3%UYv5)%)
z&9C8ANhdeIer8QHe*V~ly0)M5;y88OS)@&*-RiB$E{BF8p7+3d)b<eERxX0RQ@zcg
zsBCam#k;Ub10)s+fCPm-ghId&2m-Xxb^S@f%C_Wx@B)Y<MFHWTNWob6dHi%x0HEWm
zjn?qOcmbMd;G{4o3I%AO0HijcrK#;I%&GY^BGLbf|NZ%YIkK*)kEGl{0k0`Hs-?Yl
z67sHD&sRtF#fBrH9C;2_;+K~Y2YpJ_=2Bt$?S-NI=rCL*A%fBLI~x5>xSQaeD?DAC
zy`Y7296XZG%sgmf^5xumq-0%PY_4iiS%v~{8Rxx{pvT-)f3}UZZ#sH*%v27YKf3g?
zy|l;bh)u5Kx5L#8TGdx&U3xJ=HzI3}CSVeYbV<tReOmggI;ef3l9*F1VSGqGJsvyG
zxb_=+yo2XcZQF`SGx9muH1&P&o^*MUkaPD2ZhTnZc@5510FyX5Qh9Vm(}?E$d}O%X
z;bO7l7k4dIukU<n>-Wgw;#|SjaoJ%7oy#ven+^23_VllJT6$QutMi*Ls2FA_Os&BO
zEc`aR6y-{6P5JiU^Jyo43|iavzo@s1c8xz;dA?Ve&_8RSgi<>6SKg3rKntb?$PCp1
zMIqlJ_EI$JMLv{snM=Vd!rrmQZ@RFZ@oSAp%VE2(kiU4Ioqo#e4!HX@^ota`!6jVR
z{A_7m8RKy_g(#4aqL>7}WTLVV9oL**gq_p#h@zSI$sMPg?fw`GXkj>TA_WK?rDUZE
zNk&D-s5!!A+%b$ZuUs9I#=q|OZnzQ`qV8T8x^5PLYV%LDkS9wa&JHhZ8o5_JFkR=i
p32ZU}*)v-JOMe4QE=$}Ped}O2?H`E=xe6ffzjEYXD)9eu<e!Z#UC;mk

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00333233-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00333233-0
new file mode 100644
index 0000000000000000000000000000000000000000..608e178f66d064f35fd78781ac61f52491ca9c84
GIT binary patch
literal 1975
zcmb7^c{J3G8pmfdO!j?j*&<ngGt5}C&SVU-W+Ep0a)}laCd*(DA(EXW;q_+8atT>)
zNMtFJ7b)3G!dS<=b<h3do_pSN@40_H=lgx0=fBVSfYj0IZfF$7Lkr`rso~)T04NOB
zO&yB{s1O-|6OK@%5oo)dU@({k1f@c_K|lKw5Gn)=Di>NHn{E2e5u~;+uPc3G0JZx9
zk2ESKF5ej?9#}p_+B9Q1ro!j98l6B3_5m>|=fdh^b;=`Q4QH%HwY#?i2Koa+MiV<*
zZ;$A?>D?%&N2GzWwM?H9E3I7;`-IR8Yp*F=$L3g^jd`?n9M#o%)ZNS>1n>F%7&=YW
zNfqm>`t+zv<YXrEO+HY6{;`PmMYss$ijYmu{NWR~vs%iC+^a<UOoI-Vq_!!nTC(|q
z^@jiTyMLFu>O*iE5Pw;V5wr)IgSTh8WQZa%mG{x~$aQB0?jb6@H9OGBen{(fueOeS
zSwhZx>^-Z12&49~5Am`k1$ks}Q2#PDy`%UnqFQA}VRW&D$*wxvJ1H;|xj_)Y86l^}
zokiKpldoxp2Us2U)JATi-kP8T>$ZI*BzzZA6+{IMkuOM2$|F}fs1rB1sym*4FZc=%
zFD<<SO;4*4%shU0kdWFoA-jo6B4w_E2fHsn$>PuZ5a@Y{4A0wg2;^tnp3Mzb&jo!j
zzx9$D*5UufD^!}be&Dm7G9R2CnXU6Xr=na{NcS#-IOe^x(>PokLZ0Px7J^Tg7sfw0
ziTz6B)9_4fr%C6p7_??d`i%N7A>bxX_@uk5P|ugcJHE4pVQd$Vtg>_N_5~!>>-dv~
zVh|DyP9?g-UTcoCJxxl(a`TF7m~;{Z3I>5oJpeaA0uH?(!37h72{cxR`D^mq()?WH
z7%L(<G$E;nDuCp#wJZz?2t^BE-R41*L>7ciGA_WBDQYpWYQ+a||2p6YgPAZE0Qz$P
zT)ztLUj+;bfx!M9L-v1S2nNM(*SGY_*2i}Vc%7cJr3bxT8O`(o4}^UTxk<5m$YU5C
z<9hCo=?5g7Tm?^xr{RWs`8c2H;qE6`dVhr2+X_umNqx)f-KKdmPf&Xzg>hdcDn7#<
z-?87c!<uhgnsz!MGG?k3=YB#XeTZUdw`|bhy618>T80t_i+*BS7p;ji)RAcJARW#M
z!wUxN6jwgK`P=ukyKU=y4YyQ!!MsPW9@Qy<1pEgn>Q2<EII(4fb%#jiDNi#Fxi-rz
zYsB!?hPmqX)a7y8$$T>%4q#!DQXa|sSh$jMZLKO;0T|MpGs5go6BO7#Rwhs*#{$W~
z;t4A8X84xi1qJ@E);<rUKfl?xcHXy=kFD1woH-k!KUTqZOt|AYIQC6!cDMKsDbeaa
zs%6-FLqY-!q*eq#itVIwgfB!f?x)pk-awxRD_oHI=9SeUt-YqR7aN_1;1RC#xV3`&
zr17p8RH2$;GC=FGwCGMij!-oE3lg`3jShVL(lci93T{ixsOq$4w;v=%M4R86d(XX@
z<bxyG#tj$Vk|O<?RmmIei_Hr%ue{l@esQWRMyDq2VT5z6jhh(|mnpHbr6r_u&fsdq
zc}gGmk4EphSB0J2{Ca6s5u^pCYyJ8`<_l)hgafh-*>3*Uc#lKffW&)fF=llHZYx1z
z?o{s3%au2|Dq<X2qyQ?5I6#HM9zr2t2m}Gz?7IFWcXdbNKX?JeP$GcvPo!Wh{5;;;
zXaLam(!!{_W8DD_3~*AI6O9Jc(Ev&d(A3a!66VzS8Bv&j#sB{NzZ_Z9)JIjSD+jMD
zHK-=PwioiK+Q?Bu_eF)Epd8t@=3<wZ5r=(>m3YZuz4p8yeoQd2j2udD`W=J$CfrT-
z$P%6@$XL`Q+6^AdrKKG<G59iXJyNu&EWoRnmKCGH+eX>1#D^kpsy*95*)$zLV=|P2
z7LG5yY%l6DKW39H{OxEhwXx!>lFm>8Stm4ozEQw94CNS~!~3-8S*3sbWEmy1Qrzfh
z==4O?1pV4?>@l`(PqnN{!*H~7u$lVzz57xn`9coeo5YC`J%@ETTP{re<Y?LP6%E5i
zhv%asCAJp}?7p~YvbulgQ{A{n6BFYKu!znG&h1=z(b=r8+qJKEz0=Iqyj_hSzo=}G
zDnGprA29Xa>Qay`v@+p4c+aPm@X>#L$LFH%9>yu=c=h>yUTpuIz9L%j$VX{YstzNV
z>?=K71LOyO3*AptuSI?+;lfM8OM~CB#%wvVo$+oBP0nPyFQ2n?o_*+)`yFuiYv>nA
zcKu7lu7$axnqvCnjB<)VY@$Lu_>!^mVnlRvN<Lv;*EPHm-zUpV!R`GR_idrua-syt
z9Yr+7NeOys#~2>rIAIsenO&lWP3GV5em7D^3{-Q;3);Z>qT77pOyy{jh_fS$TZS$b
u4@@?=E&ZB|K{kvQz|2P<o5d16KD2!}lKhXj*erRF$6q<}FBSOzI`U7r1YNZN

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00365a17-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00365a17-0
new file mode 100644
index 0000000000000000000000000000000000000000..2b4acb23d52b694fc5597de4302947251ce527d4
GIT binary patch
literal 1975
zcmai!X*kr48i!{yO!j@x7Rmab)tY_6AZtWS_T>;QButFKAVMbDNfKUfmMn*m^@K#0
zB6*RLy(ElvIGpQzIM+Gv^`1}9_4_@~^X<NF5Y9=E9gPN1NHqY5!Xa@^fCiEcI0c7Z
zg0Znd?eKWyIpFL`V&awb^a3!R-T)enLc5`mSPylqw;IO73jmN<oEsX40w@q^fE|ud
zpqfy(*}-5i69`IyaDtBeQxFOS3@R0vBbu)J&X`DUUR_oE!T_pw`JQ0P#;)EQChS=}
z7qV`|u}y@}Zqz%0=IjEZlP`qT#%PvC!s^ahiD-0g2K4m?gbXLNH{Tu7cGJF9N{>hd
zWvUxLCzM;cB=iWN7*<{rHja%kM%HFzt5}Mw^RT<AeF)z3=OJ{GqM0JvQ}N|Vhwy3I
z(Ysur_Tp1vjmvOh$Tb1$uG#%(Zs*mN5ZTuWb~N2Kro@&BoNAKUoYk8D&HI0syzXP-
z)F<}38q047GzM=@bx0G0rOO|p=#i_=@|*({dUIx=lih&&-EIv{xsv#-kGKbx0TKGG
zBcI}Ait=)Z;Go_`N?Kdtc|@i1l>G2~(-Eu6boV&lROFh8u#vvd#Hh0fYiZIAweSGT
z{jTcBb>w?PRA9}fueiAHT#CF1zn;)52PdVW>ui*<TO5^bFMsBJhldvzUxTKlR`Jsg
zAMeGdw2aBDBNH8H%i#XbtIslcb3O%nULnGBHtYj=8F#0%gVEWbPiA*sQ^MN(zj=j9
zG1vBe)mGwx(<3uAe`i;atqAGdW)Mcax3=mBt3!y>?9Kx4$<q9|N2hV$sXQ3Zlvb)#
z?vieEhJ??s{{jMT=!8$azYO(!J-FpNogc<>`M@$W>wZr_Vy&jX!$34byw0geYtU=O
zak{HPaZq+vVFjD!0D*!*;9?KJ4G=#@N}K~G0OPB#4D(mxwW0dC$TF6Mv#0`+kCg$5
zleG*?2oNCi;oN3Hqy#2}b&^ql@sWsm-?AkSz<F}O3kDy-m;mVU060zx&XWQLg+O5c
zi6QI1Fa(3*Hfx)@WoqL(_`J@}*wBOCFAdXtz<pt#LvE97A9LxEqg^ljG5N^BNVbeC
z*;8-Ly>yhvcz^o~EUh;}^nIC{Ls4zh+wF!~B3Dpr0*UcZIVvvQ9pARwu*IBfP@H-;
zAToNQ*~tAACT)OZVY{eX=epx^o-9p@g^`~b*O1kW^fbjA+Z^_%1>t#pwhBvM-~H|9
z%KesAp1M2A-C*v6H&1F5L45xGB(xKyB35(}Vbvx~JL74}Cfj0>VTBmHUN=*@nzA@*
zGoEXz$p*}glS(7Gp9+?fZmd)U%L4;yGy2%wNfUY2&*kxy$dN!IFn@|dxE;R1e@UMA
zyOqx)sju&Lt(<o)<zi~JOwOGT(HSXYIW)QF*+23_bb7n+4@r^A9*RZSM?I5x7)Z4M
zfE3zFW(i)3VmwT(TEB(52$sJj{lhDxO-f@$b0>zJir^Bg@wl^O^ab;w5LBj;Y}iNb
zvM}$A7aAgAdh-%CgZ1}({L<2=@$zm9M^Tljjc&gj7!fUg?;gDLJ|gZN$kea7a2FNm
zOf5^?YMpPKlYZmPit~$AS<*i<ZU-~Dz+Atc4sn?fEm>F)a?a{sj<`tb;rvzaUGpZt
zos(BPwIae{?#Q)vb&vMyC~?eQs70vN?7hJb8(P<ad*6J-@&MdYB!s<JzC|xpTIVQ>
zc4U$SC`@7i1qyo%g@7Rt1ZchE=CkbOE%E>21rS9F1A@m$9cz!vTLT3E8eZyHv^&ln
zz+i#Xg6t?1fJOmGbwCZHer!<8aYSPO9sm0I|2eX%p@*VaQwm;HtW!yPYbW4Qv6iKZ
z>WK<LLfJBH%tWs)BKCU}%JCAx+O0W3yx3qu2{Dx3@H-a!L$H(Rks&yhmp-pXu<bvT
zO-<czVDQlHJW((&&%-MlmlUGFoBEk=#0Da7tG?JmS~ncNIASOU%^hBO-CEFPcE}==
z|J%VzN`2XPMa_XcqGo8?Y(1Yr7}7B=i~D)Oi*o<g@e&fPTulF9;Otn`82!d?tkE`Z
z&($r9!;GjGU{kdpyLTmvas})=*9l`o+V-n(mTZ{V>EV*YYZ$$H`<KH*MK+i7Y`?jv
zF}wfdQCWLH6&2+OFej%6XSXlCYH!rh>e$u3*>37;)~d>jpI6dNk(*qF_ZfR{bjZu(
zTN?80edJM(|LniI<#SnU2kR7lxcqWAC#H8sM**d9;G?)MS%c+I@|7B_0&)X?gzhGw
ztA#!lao{E3#lat#qc<E`&UrV7Cec_P%4IEFWF0u;eh=LF7Wz$sRp$z!V{WFPs*wIP
zy_CcklOP`lzG9#>A3<(R&NZ3Uat*J?_sAS28}0lW^=+ctup{}1Z3R??adCQa+Xx=v
zIA$Bno>`=dOX6Mg{xDQR2vl{+30gDqMYZ_E8p~285a);HH}qV}9vQB2TKF{>fUFr!
ffT@oTE`y0YI<UDvl=P3-m<&0P$DcX!e-!vn+v-{P

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-003cc0cc-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-003cc0cc-0
new file mode 100644
index 0000000000000000000000000000000000000000..2cfcec813001dcc267b18697a1a7cbb55169e4f5
GIT binary patch
literal 1975
zcmbW1S5(sp7KhV_0-;Dk7o~_Iwtp%`7`g<ICV>o*7EAyK22emnVt^pc0!Rc=P$^>I
zARSz!7>YEdNLlL884zhAJ+y({eVDUnpZ4jV`#bmEb05C*fwZbyI#s7DuAaOJ9EU?~
z<&<DjfJ6wYG%wIo4S6Nvx});WjC4|jgna5bK;&Qm2?p=M_yFjB0fY|%k%IsRg+O3{
z5S(8%f*7$b1O^N8fuJl181!m3rfw16>*ABK+-c)bZmbTGt2TX#{@DPUX446selNX=
zhY@a)BkzLjM@!<f>~ljC)E6F-UVOL(Xf|&xEl0&<4Dg|R<rPk%^cQcy*Q$$#r*~CI
zH7m;QH1(99jzdVEoWXoe;@81r<#`sjGVzH{GS8Mbrsj8Z8XJ^UGsBpP%E><rL?<%K
zJERzl+ZVP2bEnLXaqGNWOxyeYeiV_K&I!!DwAQV+pbT&;$tKk&6!h8FTDg;pit)Bs
zA^%M$<%jxC*^XFmg^;9ClU9z9DX^Dl7aU?nc56?Zni<DG;K_R*!sYrbMBfN2XyWC+
zpP1i1<q)Ry&IFq%kZJBrE?T|%Mn^M<9DlXyM46p^Ow`>3(S>w}QtOpntQ|;4%;@Ar
z-pofFHLChE=}CQ2z<{I<S-eONhmFs+yi-pEN9rHVzxOr;*>cl+(Ab!J31!Q!;MJQC
zUeq4ZbMG~Pc`S@ui0cbDBi?+-uZ_XCT@G*+rV1f=vVWo=rX~^0zBDaE%IE-lc`j@(
z8MNGeeja_qKeW1~M{sdQa1%SXgH*!u-{yG6F{X^dB=QFk5k2vKV~!b>&LzU5%b8s!
z<z!n$?e&4*qR0DOM`@_FdTNF2Hn$?!a9K<1y&wHV&$aB0OB?C7HTL%(Pxld@5V~UA
zZe`R>3yho(wdXSeSbTZ_3wk;g3IRhPqW0ZUFUFH;)I`hAC67QI;s1pVAd8j;B=^aJ
z@gYUsG%x_5L089PT?wuL4i6lY6vAKu%zjG15YPmQq!4z$MXUX%1vJnIK;U2*fq;^X
zjL@fnQ~y3CPoo1knj3({Vz5*U8h=e4@1};kMh5^io<PMCFaQgp`1e=9{~}lfw4Vz=
z4p8PuOgfn?d5jR{SDfe0jPC#io2YbLR*&<84pW|au9S5d0nvYVY`K&Ink0FJKDrcG
z9Hz-(!b(nC$!OHBcr`b91$0DJSKRxmMb+}-tOdn_o~aw>nr2%$Mm0)ccC6_ASM1Be
z46V&VtnRa196DT0>;jBvKX##mEX^3%#+>o=8tG%~z4m0F*y4?}#;<T`$nO%?bz@s^
zsoLsi`JelmlGr+2zUaz+!i9%slU9qKHy{5)-q)Q-X+GLefEOnLW&SHeHHxOvirG&w
zYs@(Z6_HlfTE#PO3aM57-X{&slbMl8eS{~LUO{?Qode-YX(=z9z&=giSaICf+WdLv
zhEzJHKI{peAO6&f8e%RIr499@`nw!t1UV0HsNMCl+^Q>JE}^>(Fy4hL9&&OXlQAkX
z;<{2F$&|BSeG#l4KjA!X`Hz%&_}z?*-=T4_`Qq%|R9<9EWslMlI-1P>4*pW>{5Apk
zV!)er)d~J$+0Gleb8q;$KlV9j!0b)~E0F8?C;hg<q2lHVt+QhAHRdzTcS5SlIRUln
zJEom(tE;7L1p!XOLJkt}LC(wY#AAf{2r(QjrYb@qc}Axq;kbK;=QKaufMOK=_&b!=
z(6;I^{4((HuiKW-k{&mDMHg#&l3PRh<w_`N7u)Ew_QQ4W&$KCzsm|i#$Pg$P1kShy
zPyx9E?+L>sVE@~be-|l%ItF4y@$p+fH1smwleygd-BRrT5^4BK@rO@J#o;w5`l*pC
zYd+mG9c*`SbKq#eErw01sBTE8%cVaC6Um0kS)z|<x{I!yE-~Y+^>J8SQ;=+TmKr&&
z_(RM3`!Od`pQ<Rv&eL<j;qk6U+|Bo^hm!R(Vo!N7L;EWXT?KG)tqgOUZ#pF|8;;r`
zij4cPkhjK#A!>%YnsQ}a^472<Jf+!2b!MXdw;!{QE9b;Y?wtDsKC=Bez3>bO<@tqy
zrLc1D%YNgx;!3km&`c1@mF5Xn{B6D^BYAT%-@2~!CYxv?fXQA4hk4|UWH#f*Y>vMQ
z(5g0~hu<6|stAr|N3xim-cG=j0L%2&-DPoG7392?d!oWb`=*t{rsc`7;)}%7+5x|G
zW*y!oKA?T+T#y}JfBlENOkN|)Jg`rf7zqPicm+US+sG$L+6M1Djm=;3!&rb-Y!w&i
z30wt@S<Q{GkXU|E$---QW(>!1|9lO~I{(O^Iik+|a&4s4R|c*rC2GZAkLP|pE`HcZ
zg*v?#oEKY0{Yl;ls=VI*q}*-KiMOp(y6AW$?bR<s-;euMO_fb5es&WiT)%&QM(;!~
z2}ZnhsB|eF;@B^nIXx}qko4tykOiYr<Y%c{;pdmtB1o;+oFMY#o=fo@kNt5ky2nnc
uQmV?VTYm$A)gd3*y4-2G4X#X+!avAfUE`cx63*Hesr<f3kM4^UmiiZJSZhcC

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-003e7b1a-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-003e7b1a-0
new file mode 100644
index 0000000000000000000000000000000000000000..7beac8c5835b498e7a5c3f11001b4d20a5ebe81b
GIT binary patch
literal 1975
zcmai!c{tSj9>-_3j;I-Hkv+Q9Z{{~MhB!iEIN8qNjJ06~T?|>u5;9X7oTj2iw#uHY
zM;vR7C88)xk1W^ja1`NK%6_@`{?WaEocq`3dB4Bk=kt92cs(!350P>lmlNXe321Ha
zE%){{H9OUsH#1>hrzR%Ewfk@hoLx%w?hOm)SSn%~U?Ii<7OedV90rBK4nsO>-G$zs
zZ)09fNcAnZD)$7$1cXn<na6z<gF;1-5I`4;0z?Gh_6QUTPBAsbY62$?5)!RQX8?G*
z7XX4dkcPt&JV^vE9lR$40I&oi4J6_K1!*xH2;gu4K*Z?)pp&#1xF4}P|A~LG8f4IP
zu>=y1ga<r48FXEML?C&3>UeqJy%-?qMF&{W?C%eSA|Y@V^bTadPk^zYv5+!}lm<?B
z=e9YrqYk5z!mD-=J)Z0>{Rgs&g9$zRtWdW*Kz=>f^z`fxzBkRA^|GSK{e%Is$Z#>W
zjUMJV?6HUQ9%=Agih7iQ*ae)dPv`DsBNlbsKBxATrQCLD&Ma1+^&R)N6WpjNHB&_C
zWh`YFEaQ919*$+JS1-f}C)&+`Db%Hs?Lk4b?TZ2lM*-3+Zcr=6o3By%c%f2vuKMt{
z>JjJG{3`LTI4MlmW9On1x7yQ$%ZjE6?MRQO`Mn+dhEJG8>s`&M6((ywkZeA6pH1_p
zIW2#lU}+h1l5&3nrBiJqf^xWd!Td|41kSrN_I1q~>r~uEQ`k%A)hzPQ&abFEXdt_K
zy3(e9HsG_Sv5b*;FU4Q_8GJmDv1ektBW4z(D#Xwt4`hiizHNbB-m(M~;LiVuDA&Gp
zNjowo5>-`twxV|GZOBD3B|?hikgpoMg&v3w75bRC2m6(G%uVwtnkXysC`*NdYzlhj
zpEn>Gb!L_!c&*<A28TkRIi3Iwkl&|8{t!Y6fl(;S`jPz_KO(rU-`LrEa<<-CJqS2{
z@T`K60i>>Ds!GFsb<lQkmt56$=42nnNhv<j2E-3OprOz`1QLMn58%*2A%0LG;4m2C
zdkpq@g|lE#$fM8PmPNwHivc++y+66snUP@fjTZN@f3`tplNrR`;7q2u5Xwt>tT>W7
zUYYciS`zz!^d*s!R(l1|>)2Xe;c#<?keEP4C3TGP;$?yL#){F|T@6aps+u>Ql<}wQ
z2zpcAWTA=IJ*-eyYIP-#z;lyJS@|}zuv_%HP32@BJDR7KzGNaXl~>mzbM4yI)7#-C
zGnNYc7G|f#`@!I)3QD`S$b6>l*;Xs3A%24+xlvWgIN4UeWO`9K$sQC7*>F=!G<GX=
z1({0MAC8l|3dAgcJ)T3%bxTLD_q>_8NkYP=B2y4w67VJdGP}Hev+TF2h3ykAY?Wd%
z$P>xC;O<zl=A3J&7wMSf{6e+Hfy(7XJdpU3?NVjCx(hl$43C(qpV^#yiKlTI-%#$g
zR)h{o8#+o>$m7AJLhG<rbLcJOV`WkK8R*U+=CGL=|2)P%xqh?t!tfb`F(dDfCJ3J|
zlU9<(BJQZ%+OlRY;oXm+9*1aRsLi9lV_+8Kxaff_{c}#^L&+=i?7eiz%7;@6*ux>Q
zjh+3Xi*uqI;QS6+1r)wo;CuJlj44~HYzP(CpA<adn$zH3d1!nkua8{kXs>MWb?EQ$
zlLH>(bj*4yt^VjXzdq*NioX7D!3@=Y&%$r#zh&DuQE%Ly9WcK~?BjY}$!VDt89NnA
zMVbOEq!GY^YyR7F64Vczw8?Zjjc5I)@)t<Y&Hup$IEs}8r1#0%7n_8a?!K~g86*Pe
zLG%Fdg#Qv55lj4DWC!stMD~9j$$}|=f6Bi^1{2>G8B7FrfO3J<v>SQZXUtr2)qVbN
zlRH591|}Q-wBJ3U$71tBiHvOx5j7Ywu~Ov(nWp%~{&GJ2Ia{wF8d0ffBd6QE>etck
z7uv&VtdHu}r|Ab5tViB~q>#)?EDCL0Ij^N~J2s3#J8BL4oUP?`n;Wc)E<GM(hfq`c
z(k^_MrN=$`x@a=HNme0w?|nM(+$vXA_h$iFn7@>5%fwbb&48pOoEm6BNjBso;~NHv
zrxPuwZ5DllZdWS?dYe0S9BV5lNK$~BkkyeUWeZv5!uz=O=y?|n@h;YSeG1cw(nX4T
zrK_i&ckAH*@t(C`q|uAsp_?jM8EJ0Nfc8IFclnPEgiEzYG<s%g_e4*PzWRt6iC#39
zJ!d2{*ykcAT99~IC&JHqtED`88T-Km$NY8GM_%4%nyVovc~<77qmx#5Ad1x=e5jOP
zx0JCU5RsGP55Ie-Ofq@*$>uF?L%+&0Hr_G$6ZCDfd;SA-+7OfO>?V-5;=n}jM2)6~
zfT@rn%dj?9IN$eo##JT3=N(h}T1N!dqf_*X#ZIafg*JcPvFP<$TdR6k9_ltK<{~99
wT#$K_r$AhYJA$WkU&JY;&l%P~IPTr!J1Z<;;$#|s`xBhr_HNB*G&5Z2pA-2+=>Px#

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-0042-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-0042-0
new file mode 100644
index 0000000000000000000000000000000000000000..57302ad8e75a8c2898102bc1d11dcf4e59249fa0
GIT binary patch
literal 2
JcmZQ@0ssI+07C!(

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00646630-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00646630-0
new file mode 100644
index 0000000000000000000000000000000000000000..4ecce85e86ad0359d442be5e2439e79615a5ab7c
GIT binary patch
literal 1975
zcmb7^c{J3G8pmfdO!j@x7RmaXVaA$W#vp4%O!nmxEhJ2q!5~5=*-6sydb2dfC1kxJ
zjVwj-A|-oC80+xXJ@=1$?s?C>=l=Da@ArA0|32pf^7RKaG*B8|C?wiP8||;9>Ej0g
zNHoSv1A_vH5Lti|j!+_DNjsciFqj1dB|^ACKl>99A_NSg2+iXyHv(s|(p#6;ls_?n
z`aOY1npNYM?~LH~ZJvtQH)A*^qvtkhZlHOmkc5nLQPf0TN-V7LjGdTH_g2V2e@Mhg
zYG>>1VSO+C8x%%N7AQ~K;wi4$&Lg!?2*tGXn{;q(PBgQ(inmK5db*EzTRKOW`+h%y
zP7!r8#rtYLJ?auYNj`p41W?aE7S*{37lm9AvhSHYc;a<dTLn>Y73V}Y>|jZ2o5ZN6
zTg}_82VcMYcj>DEShoR*m-T2tC!jfeYr0DoCn{TgAH|4Wb64c16B(^}p>9re?c2RN
zx(byk`R_6JY(rv<+eben%as=w;=y74OT_Gsva^U<)oI0%g_dJ>wVB=tf$7+Ftf-l>
z$mE#27&|5XnpSj(?Lkj{><03!DJryKD^OB0a6VH}OwdT=g^QcY@Kp}t_zkYwj_2Qt
zzrv#{Dy~4Yv+4xNM-TT?GTX-GHjrs9<Q4E>_vI(K{DmJveJ|nRg`3Wy{LI@k1>qV6
zpbu8JUJ|1^g1`7h%CJ%gKI^OS!5Oi6y1#QO$=5`5?=W$r{@dHMq525?45zyge2P+%
z{NN<!D~V6jH?y52Q?zW@nkyAB61<3jo4T2&-CcqDz8u;PoGFQ7yLf1umw&e}B#o*Y
z>_SgKNH)5a>kav>y3X`8DG$ldDXpTjT_8{}2wdR<cma}d=mkkGm=H{WRvQ(p#qU50
z@{ngPi{_Jrq#vpRQoq)6FcCl~UI61Y2O^}hAneo4LM)EOtOr(X`2g-;2mE00F^mO(
z{u}_;uY&tm0fRyyuz$yp{ht_uLCIUxmR>n(a+iSL=~)Lx*xTh1asYTB>SM%Bg5yIT
zqxb~RbAL=da50mw;>qweTKA@m@mU<~e1c{7$B4hJ(sC)Mw!GeHn#1#iwWku8_f_MP
zbG*$v_L{a?i%crAPKU%MOtzYNpU}*v6Koup3>!UnJ<i6<5|Uu?Pb?bZwakokC7U~3
z4rYYm#RHB?%b(x;?fdH8wl%)STdKWa-osaq8k9i-!Gi=1H)2ha_!7ddLzH~V*OEiN
z%_i3lF?6+YwstLZY0P1w$WoUBn4cg}VtF46R}-$S)`Tkpbgfxq^xhO!k^N(J3Ndyx
z6b~$%AmVODZwg*e<o{|H@IdDCn>{=CJzIrDsvh>t*$9KtDz+o+9pAyxZ{jmMWq(ME
z)%Fo>qTU-}Q(z$VQUFrsD4j2SA&z-Jt8U{4>O5HSg6ucH+zuI?Ro&gh_$&mEaD&gS
zWwTG3@5(?`Y8j>jq#hgV?i7(>f@Xhl>Q=b%en3!m&WyRD*Wz(pZC10_4;N-kThN<(
z&;5__`-gJ0br0V1QiJIgsT=JJ&GWLa{Mj)<Novc+rzV_W*mJD3jU0%_q<H1xqKJF`
z;7ZJSLLc`Jnt#Kql1^@Z{j8c8m-%B)>e@c}#c|rWvq+mryVYBhT@DRH7v2NwQQJds
zTe%4OPW3i}qO!qNmEg)E4G>u*03sCj5DEc9APCS#*Yzg_E8CL)!3!Xc6a|ETA_ZgN
z=keD;0f3I5Hd@0Q;|*w{fs?|VC={T90+8B(mZr9wFsJ6vh(!M@{`cqq<;c3GKB961
z1-z!*sFwcPNyw*WJzpKw7Z-tqa^yK!iC<nq9P}wwn@ff3w-<)-qr-8P_((?6?`ZTl
z;cmQ7uJCkm&Vm-saqvh!E9;<%$w$8RNXfdo*j&}3vJ3^@GR}J?L65zu{%jj*-*ois
zn5i5#e{|_(dufl=5u04eZ-=Xyw5qSly7XeaZe;cxO~51y>6)C+`?T~~b#VJcC4pQm
zVSGqGJsvmCxb_=+f`ivnZQF_{GtxQOH1&P&o^*MUkaPD2ZhTnZc@5510FyX5Qh9Vm
z(}?E$d}O%X;bO7l7Y{8~@9%tS>-R|F;#?ut@j2lIoy#ven+^23_VllJT6$WwtMi*L
zs2FA{Os&BOEc`dS6y-{6P5JiU^J%Ai3|`v~xTv>_c1t)~dA?Ve*gtEagi<;TP~MPk
zKntb^$_&*3MWNp!_fj?LMLv{snM=Vd!r!qbY`U_Y@o$YxC$rsG$X`6qPCw;+2i*M{
z`bCP};1aHDezvr(jPW>!LJ&wyRZIq7GErHGiEqv*!p`Y=M$^pu<c>4Uc7KcowlEwx
zkplRRQj*eyB%`8Z)EwbD?ikLQSFVmp=U?}KH(ZGeRre?iTQ>_twFM+u$djZHXNMOy
xjXbIzn67i%1T~p}?3pcqWq<)DmnD9TzI8C1{*R=@Tm_KNUpewG75M)+@=sAyUabHC

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00820081-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00820081-0
new file mode 100644
index 0000000000000000000000000000000000000000..3d4a9d30461b4fa79e0cd5c7dd86e122041bb9a8
GIT binary patch
literal 361
zcmZQ*VrXm<ZfuUY(ZtZ&*u>b|BqhMWz$Bs2B&EQ>z{mih7{L?^RFn<KHDF+1mS_Oe
z91;mlQUwf*-@k(NGVKHEF<@XiD8;~}^Z?8}B*nli<^*P*lVUX4coxh&4`xOvT&-_2
zpSo~M;)6S$xeHunn}1DxRC6=0<EzuZrd5(_9#0HlWB@q?0WLH<FJxq15TSbY&BwPf
z)|W+EUVZpDiQ|~1Nb@=QAHg~iKc2Are_p)P<lT$H<A)lW=<lf}iIm1BsRRb5z0yFZ
Lcc{qh-qipAoDFEC

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00820081-1 b/trusty/keymint/fuzz/corpus/keymint-rsps-00820081-1
new file mode 100644
index 0000000000000000000000000000000000000000..9a6182ae5e286a58f9af683277bba12c51a554a8
GIT binary patch
literal 1975
zcmcIk3s6%>6y1IAB_J3L5{LwW02WXLH$Re4QsfiMM~IEYifu(mUeL-%!4Fog<YB<5
zRUBHBIu$75-wIN-DjF3PtrcpkQmrC&u!^5f)k@Tk+D*`@&eXOuo$i}`_nx~u`?+V&
z1q?7T?xvD-C}n`z#K5JDfC~UYI*bcs1VR8H;V>*VBR~L<UJx*X=>Xd9+b0nRFhYPh
zBmhJ}m%}|Q0HkNE!)+5lY2zt}+wO2D2=&A6l-c$tRSxZTdN*+Ax(`ZSdk(JFMCLrS
zS~AvL^D7+-0p1e#=k42)xLQcoOjwyXh1auwN$-u@4W;3mjMsK+j(w;odeVF&*8g~?
zTf^IKTOLP+==~b2Y#*hz^=`RPU6XcVKmy&qaTTAM*YLV;w(7~99{!%m4PTw`2%PWl
zVH<QqsY>xOzIDYsBw#0v))`&F`C$*L7j&j{6^)N4_7E)s%6242>N}r1^zg3m-UQok
zQMyZEP08C@v@LNR4||H4|36{OV1tPfOa{b$Z=9CJLw%^5i%jXH5HaKs#1MyTNCFZB
zgvf>MJiIiaO+}FeQi}RxOzNoq{mC@7S~Ls=+Y!rMD4{czBAG(0kfJO-ZBQbGOrh7y
zjagD7Es+=v$d}KNBP7C~qfO*<q>2|H@)P+WZ~J1TJ1-{BP>?^>AWWv`7S7BspzRJy
zNA7GV$4LnI>_{YZB4Yt%x^Stysd%>eorAyX_@Sci<zdb37Qgzi;?A;zIZX$~MZGz_
z0#<EUkt=LXbdAWXHAc<qcWFxUljOq{z02w119c4i9x<>T4Z!>R421A0g)i$=jAQ%Q
zE}?8l!E<v7=tePc3yy8TX&K=H?b)##YRXuxCSDhprc&xr7Lo_WtH&qCsh^{m)Of8X
zF+L+PUPT+EdWk3~Eipx{k{P9$dO9dY6R#el5=SVEaz#)|OsZ~lOkA2ytJbQ-SrH16
zJ}6d;7f{J%O1T74T;=WE>SaIF-m6)0>Q>F2@=0ip)vR(R*nRw2&FXB5MtYG7c~hSH
z{M_*D{QT@3Iy|#4pW)esMgj&P-@hKrEhH$;i6y&40hG{d){Z+f<}_RCFW>W9YgqsF
z6;r+H(CM>le0U3gIzIdnK&IMSmdO4@KF2?@j>5?R^^OR8Gmb!O$sB?OtmZc`z-H7K
zltc-iEALenLf`@kN*Gvpv{lTF_19^2k&_#P^L*>8+ipi%IaS-W1vO&JOshGDMUc2G
zSk1B6!9~GpPGu96y(U=AnrGgNFPBUJNKN>Iis0O`iwkNpc6-0k{c{S#88OPz$;;x*
z)Y2ubzP}U}5W=u8+KZ;0SoCA6XRc;b2#+^SbFl|(2-*iGUXk-x-itS-!(RLd?&3bT
zPa|C3?3U20Ulx^=vPaaOtGo4YC1aqG)L=vsiCB^;7RmGqnNcp)(^w?3h)hX@*e)5d
z1c}86MTq4{f+ZutP$Yi_|BD)5Ehf(Vntj{L&tLZ5@A1B<x2|z{_p0;SsSCSCP8b+i
z-u>V+*C#ENN%Z}=-ZGcE=J4)EBNuQ-o;fPX>1n?|@mQ6ivrdmPk&j(S11L|5_h{p+
zgf740Kz@(%%B&+EYd7a5^hbX7;XrCI@+{{0FReUuBxFYP)=944ymq<kX2=rPOf=9w
z!QC!I79z2ES(ya&61CX?83>ed|7c;Q+wW)hH|^b27@%}ooD_b2S!Cp8@!kPD9;7@z
zl^-o0J^Ze%cWdr<pPsG|vIsP!qa*)eYiw=xNn)ky=pbaNdz!~BTT!TMCf+-LB%@w<
zsK8aPkx%N#D6#~vu<XLsaW$@vA7kd{_c8AVERY?YUOoN#z^k96@$LneAP&19u2H2n
z4uq~OfV@Rsh>tIWOC;B*#7rt_g-ntak%gqPm-vm4%3kEx4*!PVe|$Q#5%<qx$qF@5
qAb`vQlx^WDm+-*+<g3nn$z1P~>S$mt9X!u@+wlu$+Q7wet$zS4t6h@-

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00820081-2 b/trusty/keymint/fuzz/corpus/keymint-rsps-00820081-2
new file mode 100644
index 0000000000000000000000000000000000000000..3375a2ed2b51f2287f3f6ed4c541e0ae421f079d
GIT binary patch
literal 35
qcmZQ*VrXoVaBOU4PIJ%CPtQqZXv_<7bye_At@O>zD^Un>6afIqCkr9~

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00820081-3 b/trusty/keymint/fuzz/corpus/keymint-rsps-00820081-3
new file mode 100644
index 0000000000000000000000000000000000000000..41359daa920c61f783ed04039e818eecc6e548a4
GIT binary patch
literal 381
zcmZQ*VrXm<X>5*o-New^*u>b|BqhMWz$Bs2B&EQ>z{m)uSfE@sAlHC_fmxD~0nFf#
zNNAEOU|`h$3Z}jTDFFtieM}%prh`%pOiB;H%tKNP%wkSp<~b=wlZ|J=%=2Jogu?6v
z6Z$*~UwfUFPkHxj&pW3V8tL)fXQclK-&nO|bMn<00gMblmjE#gTxfP)$jH1P!fg8c
zEyl@4xkv6DGkayUn%ybSvFUruUxulnOA|uMm;Ji<cEy|@N7)7S%=gYH<eB<b)>c>J
h%+E)StW5*p&nAhK#wMu*2By8zK;Lwz$m}}b007IPaHs$P

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00822180-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00822180-0
new file mode 100644
index 0000000000000000000000000000000000000000..0ebe5ae8dace6d7a4554f84f78ace3f4ec798d67
GIT binary patch
literal 4
LcmZQ*QfvSK0!#rU

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00822280-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00822280-0
new file mode 100644
index 0000000000000000000000000000000000000000..a797c202958f3db872e8ea9e04579a43c55efdb4
GIT binary patch
literal 4
LcmZQ*QfdGI0!{%X

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00822580-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00822580-0
new file mode 100644
index 0000000000000000000000000000000000000000..3691795bd35941db25e2d1c37b50193e41ca3aaa
GIT binary patch
literal 4
LcmZQ*Qf&YL0#pGg

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00822680-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00822680-0
new file mode 100644
index 0000000000000000000000000000000000000000..dd5cbf34592140814e1f4f3f39aca7888ab24acc
GIT binary patch
literal 4
LcmZQ*QfmMJ0#*Sj

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00822780-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00822780-0
new file mode 100644
index 0000000000000000000000000000000000000000..4b7906058171da80e2c2e73e64e06a09fe150b82
GIT binary patch
literal 4
LcmZQ*Qf~kN0$2em

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00822880-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00822880-0
new file mode 100644
index 0000000000000000000000000000000000000000..e7eab4c84210ae0367faa5956bde1cf08808d9bd
GIT binary patch
literal 4
LcmZQ*(r5qx0$Kqp

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00822980-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00822980-0
new file mode 100644
index 0000000000000000000000000000000000000000..0072b55be09fe7863335185b2eae54149968a89a
GIT binary patch
literal 4
LcmZQ*(rf?#0$c$s

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00822a80-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00822a80-0
new file mode 100644
index 0000000000000000000000000000000000000000..9a60d671b997bec53d36b2c9ebb600d55b64ec60
GIT binary patch
literal 4
LcmZQ*(rN$z0$u?v

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00822b80-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00822b80-0
new file mode 100644
index 0000000000000000000000000000000000000000..88cba547f3954291e78cd5f51f9fd738b52c7d02
GIT binary patch
literal 4
LcmZQ*(ry3%0$>3y

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00822c80-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00822c80-0
new file mode 100644
index 0000000000000000000000000000000000000000..deeb51ffc5f3727ee5b2259d05fdd948d2133ea0
GIT binary patch
literal 4
LcmZQ*(rEwy0%8F#

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823080-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823080-0
new file mode 100644
index 0000000000000000000000000000000000000000..15f1535a0dc9c4bf8b2ad383de2467e062b5d955
GIT binary patch
literal 4
LcmZQ*GH3t*0%`#>

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823480-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823480-0
new file mode 100644
index 0000000000000000000000000000000000000000..291df50d62f5b8bb5f364fb948e166c67037e43c
GIT binary patch
literal 4
LcmZQ*GHCz+0&)R2

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823819-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823819-0
new file mode 100644
index 0000000000000000000000000000000000000000..75cefc85325794579a78a04167f4fefa3fbfa88f
GIT binary patch
literal 5
McmZQ*vXE>500U<MQ~&?~

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-0082381d-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-0082381d-0
new file mode 100644
index 0000000000000000000000000000000000000000..ce61cd97a446a713e8d2e4578788eed0917e30a3
GIT binary patch
literal 5
McmZQ*vXE^600VCUSO5S3

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-0082381e-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-0082381e-0
new file mode 100644
index 0000000000000000000000000000000000000000..9aa266413397bd235144df0987e66b73d4b72e2e
GIT binary patch
literal 5
McmZQ*vXE;400VIWSpWb4

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823820-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823820-0
new file mode 100644
index 0000000000000000000000000000000000000000..151c1f4a8eee6f67d1a9bdb55eed9bd2e406d924
GIT binary patch
literal 5
McmZQ*vQTIM00VUaTL1t6

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823825-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823825-0
new file mode 100644
index 0000000000000000000000000000000000000000..0356eee6b49b06b24915135f0ed2e47218a65be3
GIT binary patch
literal 5
McmZQ*vQTXR00VykU;qFB

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823827-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823827-0
new file mode 100644
index 0000000000000000000000000000000000000000..26ea013ac7e0017650662f4edbd35231af093a79
GIT binary patch
literal 5
McmZQ*vQTdT00V;oVgLXD

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-0082382b-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-0082382b-0
new file mode 100644
index 0000000000000000000000000000000000000000..c2ca9809f1f6e10b8bdfc5b7b178bdceaf5ac84c
GIT binary patch
literal 5
McmZQ*ve0e-00WBwW&i*H

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823833-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823833-0
new file mode 100644
index 0000000000000000000000000000000000000000..1d8f61e1deba2d991d40cad70b8a8f37b351b238
GIT binary patch
literal 5
McmZQ*vM_D{00Wx=ZU6uP

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823836-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823836-0
new file mode 100644
index 0000000000000000000000000000000000000000..98dd9b0d314eef92cfb11ff3a55d831f8d4c2cdc
GIT binary patch
literal 5
McmZQ*vM_4^00W@`aR2}S

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823837-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823837-0
new file mode 100644
index 0000000000000000000000000000000000000000..da79a71b35bd99b4d8421b0e00acf304edbfcaa1
GIT binary patch
literal 5
McmZQ*vM_G|00W}|asU7T

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823838-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823838-0
new file mode 100644
index 0000000000000000000000000000000000000000..101d1beb474727054b492f7c4a61f90c8667390f
GIT binary patch
literal 5
McmZQ*vao0X00X4~a{vGU

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823839-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823839-0
new file mode 100644
index 0000000000000000000000000000000000000000..92971101842846a1aa248a4636496ffe6d0436ae
GIT binary patch
literal 5
McmZQ*vaoCb00XB1bN~PV

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-0082383a-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-0082383a-0
new file mode 100644
index 0000000000000000000000000000000000000000..4cfc80473a1a331933323fb93ce445d3bdf4ad1b
GIT binary patch
literal 5
McmZQ*vao6Z00XH3bpQYW

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-0082383e-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-0082383e-0
new file mode 100644
index 0000000000000000000000000000000000000000..6fbc97890139c4fbd47fd60ceb706b880a641b40
GIT binary patch
literal 5
McmZQ*vao9a00XfBc>n+a

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823840-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823840-0
new file mode 100644
index 0000000000000000000000000000000000000000..4f73211b9d03c345426520a8161ad488197ad770
GIT binary patch
literal 5
McmZQ*vT$es00XrFdjJ3c

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823841-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823841-0
new file mode 100644
index 0000000000000000000000000000000000000000..eb9bc2a47baedc75c15ca608d1bd733ac8645337
GIT binary patch
literal 5
McmZQ*vT$qw00XxHd;kCd

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823846-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823846-0
new file mode 100644
index 0000000000000000000000000000000000000000..8f404308315c25d03981ee4ee657c2ec20385606
GIT binary patch
literal 5
McmZQ*vT$nv00Y4RfdBvi

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-0082384d-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-0082384d-0
new file mode 100644
index 0000000000000000000000000000000000000000..242516ed5d32d4e91e665832c5773af82c1a3455
GIT binary patch
literal 5
McmZQ*vhZyH00YkfhyVZp

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-0082384e-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-0082384e-0
new file mode 100644
index 0000000000000000000000000000000000000000..72f293019478922a0721ac077e52d033a3f47cf4
GIT binary patch
literal 5
McmZQ*vhZsF00Yqhi2wiq

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-0082384f-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-0082384f-0
new file mode 100644
index 0000000000000000000000000000000000000000..7cb67c34ba15b518004641b03651ebf23508f164
GIT binary patch
literal 5
McmZQ*vhZ&J00YwjiU0rr

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823850-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823850-0
new file mode 100644
index 0000000000000000000000000000000000000000..25251ccbe66c0319b503dd89b0e6d361a27ab3f6
GIT binary patch
literal 5
McmZQ*vIuAZ00Y$livR!s

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00823903-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00823903-0
new file mode 100644
index 0000000000000000000000000000000000000000..42e4206fc368ea46822bf0a312571d5dd3ccde0b
GIT binary patch
literal 6
NcmZQ*vSfbV000Hc0ww?e

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-009a81fa-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-009a81fa-0
new file mode 100644
index 0000000000000000000000000000000000000000..b5ffa781a03325ab3c429608ffe2e28f731c5c38
GIT binary patch
literal 1975
zcmai!XH=7E8irFrAQVk#Do7U?&@cIt5D*pt5dtG^0!*j|63_ucw@@V+F@i<~4boHy
zMWl)_R1HPi2ukrFWf24hhM^CL(g$|;hr2&!e?8~E-}gM{`Ei{Kk`}j7Q|`c->Kkee
zK3XzH(iW2&U$dW0sN?Gyv_I!=@SUFBdg7K@CG0{{?uaVGP?l>)lHD0*Z21M>l(sl3
zViI5>#sC(q{Rtcfg~1L&I%+%*ygA#-yqu8gS7uY@4TuYgXvbT|e-Vd5#gGs{ABzG+
zh2V||6beo;H^*uL$M+Kwtwd)4c)AY&f;f<d!xFqn1Rp)THv<5$1R@P2;s8ZiaU2NX
zZ~#EW=>edNtT?zAv3mcBf3q57(Dbnc5{`riyu2B7eSkzDd3)>mc;S5*Am~E}SkUZm
z4}~Hja2E6qWUo(vv7m8~QmK@BPIu>)C9<Oyqng62auPe1>?`{_vXX-dKmDvgzdKN2
zEyw)i^gsNrTQ(VFMU(pp17y+RB5EuBivO_JF3xwP-g_zfQ37HIaIrm^vzv`r)bp54
z?JG^W?bei8q%rL`=IbE5UR`3Lgfhrj$}n2S_mn;y&DN-zj}=LDm;zI%OT}A*!f5-K
z`BKh8q}SY#7L2bzv*Pi5h5k&{!7a5zt}S_$l3npKn6AgJg~xBSr-_snP7>OYUQhFS
zI|TKAU=nS2v?f-Vthpev<-~n9Er8~-Jo|~IW6DX&`2mzowT}qlb8|xl7fA`6x2GIy
zn>5#`xb?;>uUuEN$UnNirt+Xc?5fEMyZ-6GSuImJ6Ukmmfb28)SP)~^%zj(kB3A7H
zLx((&CAs*f85X>04Jg80{~1xHd-0-fWNaj=vgCAm&BU9q^JGed49O`^Ep8J%5EFjj
zL*g#%Iq#^4)>AZ5Ui49xDhJsZ@+=^CKsx%=G($M5-wXzaLZEzafCeb+(V`%MkU?M+
zOS8Ubx8X;G*9;pvd$p(QTs1;~WBbpl2suFJ8m6-3s-GU(A^xJf`u2?c!+05`C%S;-
z{s%M^x{E*p@Vx;@>=%;z1p*F(A-=_6k5@Pg28BGD<u)%8KAaEauk`-lR%=0mDKuE!
z$Nt$0nNDU9dqXpsmIqKivZF<j)Uk@Br_|!O2c(5WN?Oe&z@TGud4<E}4<Ru@O3E4-
z)5Tz+wTAMK(>t1!##MD+Iw|8%_Yw4lg4ui{uX|Xrw#4RAE`jH9IA!JQ)cj6iTdS&e
zE<1*&p1x!zHIZA}BNr8Q`Q+Bs;wfuIK{K<{>fK=IQaPnvS9C7Z{&b6t%aEYnncSeJ
zY?^FuSUkC?lH>@Ahpl_4Cz^T`xPwgPYY)fBUHRfxz%I`z_L{Y`&pY1K%s3%oLy0Mj
zFAiL|8O$zg-zfcMVt(tm8(X!A4Dv*C&v`nRe|F6=Hi&dia($^*?L_5rA|6OBWV=<`
zukL_O5aUDU8mBg9Ug2q+hF>Z7TFS$RWR0Dr%N6ioQi1K27E9<2)1#%)c^T-=5azIj
zh2Sj4F}ZG|<=pToqfryz4`zr93*$D@rlOvxoSM=mF5&I>;a(Cnan#0<-!L#Ma(v7{
zmf;zfv7zLZIreTkWaa&ddF;WkxQ5PtvBep&b#QJQtqO`<&iA_;HD%70DIG$^_a}vZ
za_853R!EGk<o1zkogGz-z6||zb9}&SjE-4rq17GP64b?>Sur&HC6uAo?_Kcq?AL6^
zM(WSErw1(W5&O74m-x-oqN69`s7P~wg){+JaIJrPPKx@TlQy1Cr}1omt+)m0x&A-c
z07tO$fb1Swdt#IF(ce>+K7&L6y@*}_p738HBVvi)ifljrjmZA5BUvz&Z%_G`$Y7Ft
zB7=#-_EFB4ne-qpUl_GiTJ@a!ZhRXkTgPPMpZ0qu^jK}2E0(jbCZYx-KCM)`Kqe{v
zaktK1eZe-!k3m#u*&WtzTJ`T}_Yd#kG}J|R8`2Cz^VcHpKvGB+#a0D&?wmFm+_oKK
z(1BXbK4Wiv&F*K`dAA-fvQxM@eQ5_i%rf8}X)7GhZj@I{-hG!2ys*iU*Z)yS9u^>D
z-~4Gak7h*D5lIcQq9hv&kT>fGi6;}SC+!yfLT*<n1^HUKbR2ChBS=$#>af+3Minc0
zm4f@YwU{|KP023ST3rg$h0;Zeeywkyk$dCe0P&u!f27IF-l6NNSs7^_(7^WJS$74G
zjYLXxM>Kn;YIem=e0==@GZM3CDSyU9Zm`eouvmU#uwI0}?PhaX%rf@98IJjU^@4)J
zg-NdFVd>Lyubf?Ux`R-x{!ob$LG4n;yif$69{|65r&Kz5=gGzmZhgP%GWMo(@*mJQ
zO`drV&}l<Vx~qp!+KLksy&e5AH4IFJ3|U`kWnC5c{l>VgEc~Kl!cgas&{|B2L6Nw&
wdSQ6emu;(FpU<Bw-<E}Yd=z(+5gN|Vyv|c3&c`3Z)44C>mD6X8>mD5Y3p`*)mjD0&

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-00b5ae79-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-00b5ae79-0
new file mode 100644
index 0000000000000000000000000000000000000000..c5f085ba23e77b85214287991aebdfe13862b209
GIT binary patch
literal 1975
zcmbW1cQo7!7RRTN45N=8iJFLn{H7}5=?tPpnMbr?kUSnqkOUKD^oSA@B}x)RJEE6W
zGfEOAL5NkK?h&2nqb>V(&)KtQ|JuLqx!-&4J@=2#`GBg5ecj}FZinBql{#7wObO=`
zeJcxaFheawc);Kj7!v?JEdcvjz;PD9pb!WQU}J{MgcHJd*}z~{CJ>Yg0fSyI#kQ{D
z1|2-JH~Y+N>U0$#B2D@)Q9nO}=4sCOKCcW9!g+)X|HONLtI5iQe5<11M1|F8^VHf$
zfKtc7#%5$}_6QU5zNpw`q{i9<=AEYU@%dwE^X4rnSF%F-PunpbhKS}$bJDlbi*?0D
zk8*HHc0$RUdvhztg>9cDWO70RlBCksH92Q;>Usqzl*cy?eT(J{F49{)zUuc3d##t7
zx686DXPByeGO`|_HxTujB*ipnrpiULYvKtO7&h;HJE>?5y8>H`hgeX`q+VAZn?7)o
zWEmJ_Ky>Lznp>F0J!6P^oWmA*u0}lwDQ#zzRL`s&Ua<+0c&~>^V#zVICzfyDd8ex6
zPfWPeC|P4^6&vZ7$hn$jQ)Rk!jIji%a%*3{$yoS+B}F!Mn!or|?lZ!#O5`mU!D12$
zjGufWfFm?6lswH%=lS~3V^mj{u7k9o)iXXBj^0$6P<I{Fgxy`8HsaM_u}8eCEoq6x
zb>H%FWGAs97{Y%dA^LjZ0YjO}TGo>zw9Vy^lQhs~zuXFn%R9K~>j3N80_#3z`G`jX
z1Am<77EhVe4&f^qL4*$^cum=6H`rIQPj2RX*Q+C1h^y?5{1!Dm<Ty!2?tCKE3m?+!
z1GP4lm8-p+B?p`e_H_2LESjxCW9EklFYw=ET^?n(&a+I&1zRy`15_q;fC|0(7777F
zAe>hHk*U*ZWKxoGXXSHHZ`glf0|=u80sd36U`#xmE{bRXP;^$nVI1*}02T*a<Yz-;
z0Q6~!N8?d=YkoG&X^WEoR|_bj5CF^BG6DfL*VaZ|1+M&cN|fvjV972327|_s&?uaf
z0?tJq>*NdoC>)-I!J`2xMEpNr0soU=4$x`N0y#rDk8jpaZ{zL+L3GQ0`P%dmP`Z!I
z!sZXyKkL<J7#0bb*5DDtep8!O)}UE)_u%I`z7-)#c>%D>t0qE<EnDs#?e0Fkkxlha
zzbTWHz4CVa<3Py@x<&d0Cbp4neCQ(+=i%E{H6dE220<pFR0o@0M?Fg)ZSwjtbd;(T
zE8JE%oz*OOk#^FP22>cm6IA?_SrGC&pK0sVK`u!};X3@)eSLG9DxE2+VHkfS+F;gX
z&Fx{#-$d`b60AEed@jZDngcc7TVu`Q`hwyGFVQ;z%Qn&+UDTcWWDjfeE`_Hb6_qaM
zM5GMiUl_alt2g$Igh^zkr`mx%+ka5w>2Flv#j<14y>qoEta9TY2a#g|YXm_pb%EjU
zHbSg<(GTSP+>H-fO9M7g{hDZxvaP!!B6nwFrG<Fa1U?Y0uYbFbpbmJk7t`z3(^r`N
zva^4O#>bWL(vIIUB4Qf`BsNe{MA{<wON)JOB2Vgw2l<X2bLyt02hY*d@mJoMSD+Dt
zC!eXlbhkg9AB&x<=$KKy&dt0NkgW8cO-8EFr)Bp@zt3fRyQ;g?$8Ma>hL3qPFC#4J
zB7P;D8%vID3>QmVP_0kA<l5^t4`<f2){cr<gpxmZZ{Hoy@IC+Qp>c9bOq+XDg_0Yw
zD;O?PX`Okq+j+@qytVpTx73u(5-y$yfr3HcY$t#Oh@5$k9mWSk{!dR{IvY#C1OUDu
zB%U+{qC_&mO{2Bkbx(wDbu1cl|6d{v+p4JjC{YpCjC8&-aeK$Jf1#J=3hwZo^m#-v
zd&{X76zrh$$7m8!ODdo9IazJZG4DIK?!oRfEWX`exIbT>m|0Q#b+>xTj?=R-l5+G?
zHZUx~QJcPBy?riCBRlSjdqD7Ty_O>jHol8uX!b+3(qYe5B}kkS3Jc2BEen#@Qd1JC
zp%V|r`I*x@%w!g3dVX79ifLHpu6!c<5zKYinN@ZTgmn8t!B|rZLxq39P3VF&NwOY7
zs=+YP1m1nWa-w)S_Q&_zgK2t72w--Qk{7`Bj=zBNV5!hs8t9UrP{-|$5~Nut3nHii
zeI9ne91B(dk>4h-g*4BKiEEPBOwYcF&A##Fkcyjxt13Rf^yQyFCOjj5>01>Z-+l9k
zs8Dem)zEiHjSv9?-FOW^-k6D|@LL2Py^Jf_@Io7br7gr)ofGL|ic3m+Awh9)PX02d
zCktBB*uTF4<;y+S><Di)ywwsR@Qs3PPmkR4R%f{0i%%HWmL|=g1Qy5DkbV-6{2T7|
zyr^?Iv11%cRIS-^WxoDpZ1Iv;<6O<Gc&7_1{$8lug1Y3OIgFrlu4*FzVmmCHGe0k2
zlk#QJ--y!2@w3XMtTUsDgGV{8(4RPa;!v^7pnW)r8n6^-5NI^$*Vsc~REb;%xB83^
s!3~)LxMv01J9*bP*z-?CDtao?3#TH5{UuU3XruXI?yJRZk$-FJA02XQNB{r;

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-01820081-0 b/trusty/keymint/fuzz/corpus/keymint-rsps-01820081-0
new file mode 100644
index 0000000000000000000000000000000000000000..598a377b2cad3df14248bae6af54f47a891c12df
GIT binary patch
literal 1975
zcmcIl`8(A67yo=_MwZC6GssZ5_RkDs4`aKQtl8Jh7+Xjp#&R`dCfh_wb|K|nMrG6$
z3Q-DKZzK6~$5L6s{aSKu;fv?_KHtCK`+C36^SoZ~bDr})&-vjTkOGh?LgZ9W4u1+j
zBU8Xk3i2lafPoYw3IIS(3K9YUxC9qKK{^6JHxdAWLst|4Zf+a}!rBfU5CH2y0x-F$
zW7>%X;G(9-bN~rzG5e3{;4$?;Id&-qBVN-aE5Pw{qJX;ar$<DSg#Fgw4EA62kTJvw
zM-Vvt_R#)|p;WU<5MJSlXzOxNzYB}q;1!>~Yr%8RSleV)pY+*`hF1z#c@8)#a<FR=
zptPAmZQcF}op_^wJJ+-49_IA;Md~Y1VGDLNw}k|Ec%1L<OQzNwPpGkAlkCMOAH#6T
zd(V)uBNJov@JB4+6@;nBR*%GQIc=?#dHLCr`|tZa3!5zkTfFD}gUEjEb2?W;v`j%p
zjF~KJ9}u92csd(yOUro=ngvS)IKFwfp0`+6+CeR;6~3aa@x5e;E79XS&etgEt#NiV
zQnp%kW=3DRL5)n@lcO%x#5(E25-<JguDvY99>_w~CjO4+#G7|`c#F<Q=Zo9ZR$hN0
zeP-d@vWuJ&gQX{y%rU2$$<#Qvfiht~!l~KifzJc)&iZ45HMSSR#V6vtCe_(K20yi%
z*Q)z4+Z!7Hv_H$(CiTa3JA@WQ&t5aL|FLm>Q+v6^{9rv=Fwc2~I+@bVNVwMlu|59j
ziV&cQudmY_LbE8krnZcX#qfN;Z?}u6$==e9fq^z3N24#REISFGUoL<pyb!QEuVNB!
zmV<Gl3XgkK>BRR^g#=RoO>ApWNqDKXu^;mJn{N5HJ6A~ax%6Itxq<CHC1ql4skIH)
z&PmC4rIJfquzXB6{mDw7CWosYZ*_IT1YQ4Tm{3h4f6`QgTW@FaPA(!nO|bGCxhI(6
zq%KYm27m+ko_hYrIgDS&@Jnh^0c|1z@GWez<;eMJ`K?eB{?fX@#Khjhc0A4sm9E?i
zo47Tb=e(nl&&*UC-c8*z_}hqh(YK#~CMvWn^;L}YhIB^4=wo&U6)X*GRn(bD|E5py
zPp_P9G1Ds3;jKlLnu!WuSEH-H8liWbYkc#oBBbcP1q6ks5kpsU%bGaZ@1@>4wF%z`
z3RCU9JvSG}5QK<lEq80;-fS1y0-5$c&GkDXLmT0ao70NT4v*-Mo^erdas|K4lk7S6
zDE43aE3{-y7<JOWM+K%*&$}f2aV<9KarlzgUBNEY{oMH)_u-n^a<Q4th<~>*{gl#A
zx}`|WtqFsR-xXVZ3bwvzPO7XHyFcs@GVD~_N2MjL(WKJiolEySg)gizBW#8%f2<-5
zWnK2{4wi9&e_y~_yE3{H((6V0e^|U9n7g{BRj~I!RpTK22i2eR=Z~(9v19zTGkkvE
z?zM}zlT!lXGKy3O3)0MkZgjY0kRIqVxg%2P8)<x3^QX%2*Xo#o<2$@Ymc!L)!(Neh
z(%EqrWiuheje(hp?hB0KW`COMD5#xD)R9yZczMgJRiNmiQK7Hl)C=(^3f!v#k4q;P
zbDw&f${XQ3h8H?j2X<dK_iXM_LuI)6XNszm-<lV4k_Vl$I&G5A(R|keEbb4NOD<rt
z#KJ1JZjX<+h!=%bSV`q$$^#>_0&a1L1ZDW>`~mprZE@d-&y1=r%f>SAv|FKv|HZ*c
zIEZqXw@q@)yeVV&a_*9&*Zj59M3iAu^U&yY*W%asdDRcm{?lbL6Dv*q*}Mij^)uM^
zk<+&;6GnnH$p;URmV>lX1#A%ORyLCTg7w+c56$k?<>6ELFy8MOra2SujsJn`cpZ@T
z>eX;omTXRkvLo|Mxrw~RJ$CjTh~=U6*J@^MnY=|qrC8MU|MzUAl06a55CvfmQD99K
za2N=K!6ZGPlP9>9Z&=;f<O9KzkRF;B;yD3#Mey>%T`VlnN|54_;t)b<5(D(mSY3>+
z7KA4d1N9(XtS*6|6NJ|aB5G;|1wtq>J{<@`AD&})iSz3n0*%o;yjVS~o)?5dpN6E4
z(!qH}0%Br_S7T6@h$IvtBp@_0G%^^4hA5yM#P`2?Kn?&-0r`Q$cODo81c82>%~l^v
zqDRivcR-|U3?$SnylSe8-g8Qq?N&M0pS|{hD{k@nFSfNL!`lM1mOmANQ&pBE<OEQx
zh$#=_y4fQdrs~tEpw}GPU~X*6damZuI=W#^n{`MjO<5nqbxmaWk8AB3psm`SUOdP`
zGSay)xYfDK<}&*@-kgrAX1*A)z7fK5=&bn_MaPu`voD^cmEzydK22&lqpwhpjW1~*
zugc-DUU@vnxh^wn@$R1yk)LNGK))$g>}3m9kI$Kk-KjT;vZKyyEGgGYAQCDmp(}x%
zeHnGCy#6&4n<>ePc-rVCXTy*@1{0;SVK?ti_{ul*ZhL-rN2_zD9|k|%u2tk6h`b4%
bI_#u0KL{Qm5O5d_0r4Mcp(D)!!NLCk8ZcTG

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-01820081-1 b/trusty/keymint/fuzz/corpus/keymint-rsps-01820081-1
new file mode 100644
index 0000000000000000000000000000000000000000..37f4af5a520e1c33084fcada68fdb95d3397b40e
GIT binary patch
literal 1975
zcmc&#`8(8W8~=W17|U3)#w3lUl=V9cW^fELWlJ17h9cX9$v$>EF&b&4BB`Sjlar>B
zJ-g79DBBou2u;yWmK=NKOy29g-ap~}JokNlKKJLop69xMdTx*bq%joI(mh3E7yvVk
z0cJB$+W-ItGEis$0Ac?j_!fx*TZ9nyAOL`?iVJHO0O&#iARzQ20dQsM=WST4umJ(E
zM<@WM`FcxoQ2<=oW=r;=Kzvp2mh9h>6tuG#t!7)Q%oB2Ehp(<$HR+cX=!zB5GHkUu
zHP<??S=|K$gtG|qzu=|szX`(Go+7QMe(N*PM0p<VrZ>fxEvgjGyhP&`=EJ;jWWTx8
z$eAFWGZaxgzK(ZY;;tQm*HTcn5v!K%6||6LRPH;pE9suPnnut*lSr#;3T1KMp8p_z
zMSpV3Gwts-JU~g`VC(HJ3<x!hoR1#c8*euGoFDS_mDt}^7kmrCdC#+sm*6!NE{D}Q
z9BAx$rxav9630?I-qB&7NWz(=`bLdq=Iv3G0`+P1yqJv61on(&8|v=a+VewXN%0}t
zhC)WYL5NJ)a?SjPDy?OFHrPT?4*?&>>%II`-C~y2g5z<C=q^xiS5M=)JI+H%S1=CO
z%jZvJc$~@9sn#fz;EFafYbv+v*>=?GoSVs0l$-nB7BcuK!Sq+%!ZZBQo!NX^vH2UL
zX`5Yv4?=J21~=Kv{wa2rUipYfZ#a4Q^x2#0l+8YALnj>vPo?8)*H1KV)0Wl+eq>TO
zR0Q7LY%kkZ>wu)uLyN&4OU!N7oq{;}&Nq7|&5z&LSeznH%9Y%I2o%?1`PJ8Ta%L-i
z^)8uYOjFBRj~<-%Ui+ZUGxkx<<@97>4I*nr=r?3{4okiz5R}ARLJng8Ud}xw$%=>=
zO(1x$J;UtTRa$gM&T-L3nfWl}$PKpgY2?f3x34Z~S<PWFxPtJuspSsoLsofQ78R>)
zb`NXPiKEV|3&e(pc1H3F^49@lzCoW^Dhp#99)t+`2PLbY;EcQD@s#sm;8J}8DXVOF
zHH~kTIKtU1{lwVrfB8O1)5iH;SHR$=gmu%~q@u&=bJ>FO{Q?ITFG6e0j@A{mq$`~`
zq$AeZ?r3M*lB(}j33hTx`GRYg3&~8D|Af0euK!t*X{j>O;_=Wmu`aiD6Pa7Rs>mA+
z7h=QT#(Z%*)H$DHJ=_Jjzp6TVtF`twzfwcl(VGLy$L@q^+a1;)4h)x(cR`kDYEE)O
zJ>)J~mo}WX(!Tj(|3dT3%-CrI>E4(mISIDHL=@foO)p{2(71P^qGFQ4jULQy9*{q8
z9;WH+75{nh^V-SE2+Baw>)KGo=i0N@E1V-)zr6n39$oykGo#p(p;ipCsSf#L@z@0K
zrssP-r!4Kc`<P8Re?e_r4eGVke9IP#Xb;Yz^)4AC!r)=9;K2(gN3AgbKjL<bY--mA
zSC{CtR~wI4WhuOW!~RAz`#^1!AG|96#h|Vy^zjUVseh$Qd>8dsSr_?nNkR4A&C!(j
z13bkP^*7|FOs$}IuEE8!bl=^!MI)HX&(ev`)+d?aYwc3JRrZ?WIRkt?iJuu)dC@ZY
zsu+5~j!X}IDj{y*UuI(SeW}hbaY{8=9sxT=0Xxj&w*4W<ad&-|9%`rSTDLwH(B5{n
z;MM+5A-UUqRQMieX-bOf(Bi#nlkRtvmzngr2af0LFOZXuW*_#+j-GOI4Za?iZok1v
zeCdvyD(Oj$7SX>EQMX}Vau6?L*33JG(CBj+Bz6?%?0&CRK44>b&fNK8Uf{>D8rwY+
zw{L%Z(a@mkQb2fCPkM*UA+<V@1YhoVSc~xjiY{|&W=3KVKhkd@JXX3f)uH%l-^l@l
zUb5rL-mFKz>nF!2&pXscjnm$zE@<xXZjM$_6}Ku_m(3M;2JYzJy#iN@W-q1wUq0M3
zX`UkX5JQ9vF<=#JI1GfrKpO~&kkHMr%UF>HK_o=PNI{Ya_z@8)DY!eCjM)e2{H#P3
z&^W3e5o1ii67Z0J05y;Z5sV1|0j4MX@h7M_+=)O4y<OTAf-u6f1uqp@q7WD?P8h~S
zW1<(Nj8TN-e?AA7LIzNyW6<<ie;OJKF+fd7`hQb^q5zx$$^t@P62<^QU?Qb(MpdEA
z<I}#f^vrIfAsKN0Wu}#Gaj9RGr(fW4$x;H&v{}TDwgPp#m3+tc$TNIMDPMMsAz4mN
ztgog0Z`%hu&i9YCn51VB3st5kBi1DdKbVJti`0(|1Py0p$I6VtR2<*?mNrc%L>Y2j
z%M+{RdfCf{qS{B+jpE(D!TG_;?Sdh00ZO3);@&;H9i3s~HgNmYM`V)!lgGNTT+#BY
ztsL3>6|YybE)8;r79aio&2^J}?MhS%%ht<w=t`B*W4^ji$4M@+Q|ZadRSg&A^Jyk!
zTD(42*SIC$*jUPsJkD^<torIDN`<(_s>S+e{=tilf%g46>K_vB3Se;Ip8YHB8<e*8
EFY_8kdH?_b

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-01820081-2 b/trusty/keymint/fuzz/corpus/keymint-rsps-01820081-2
new file mode 100644
index 0000000000000000000000000000000000000000..5568f4b141058c9a836e75a89faecaad1c94aae6
GIT binary patch
literal 1975
zcmcIl_g7Qd7QQzL3B4;Mh=3wRbaE32gch18Rbe0!K;hAw3`GGWAS6H#7y_aoRcX?s
zNfo6TX(D~VGUG^-p@pV65G*r+wcdJv!Ta{vYk%L~XPv#*`QaRp4$$Zlv^Yl|7dntY
zql3wGj3@xWKsrVq06-KS0|5XW%?r>mHUKby0YHFT3I@QPFZ&x|o!kNhz@B3O*s+-d
z%EAEf!^Q`61OsY39zLL>2b3buT5`Q5AJ*;h``at&&#T8-SxL9jq)>lhRVTwuM<||C
zHXy)l%k}?aEY73|gcmv@I+PUFmL<PU&rf!xhN{0iwialeeSrp@%_c3p_cv`w>dF9J
z7<TqDp_ZoupfrN-aJbJ<a{#aNS(Q3lvZ~p(J-n93->jwvnbC6jXM@z^V|KLs@cw(L
z24a5d3Y$C)^WJZ}5_OZYIiGuWaZ7tSrv?DN>jbz)`jWMaNxop9J|D`%9@~2!_C6~Q
zjXc|9)Tf`5jZ>b(G|pO3;iQ=>d~@Q!!v?=Ad45*$p=(sV?I-^7(6(sY&4uc>s7skA
zo8PAY{_y*l1kC1%1zHoJxXqRucbNv2PKz}&5H#0?F}JwZ_^uwh&5@}4Q%9@QK6K!o
z@!cT$EB`hfSjX;+-3aK^t*BJvP)0|F_#)sD8Ar5&f*T=$t<j+4sL{F-@v79N=eG({
zS8Ss9W~{6*!UDFWip$vKA5lpv=%te5I;gp;A9wd6VgBq$&)rLo9&2s-QI?0Yv>lQ&
zd>0mrKg=R4nQv5Ie<PYKthoMo*BNs2g0Q9eJg0*h3t$^oKigWMZ4GIK_d}Ax;olR`
z(rM{ohzf)=LnT?f$Gd#{&H%6XQ>*}`K}`(6Ip9I-ACsbVC5<wd^feP}i?8m7E86c0
zY-bZQLUqc0a4yv((pJ^thHra$#Av|cyp>E^7R4XxX6m!>%R)beM&)V;8yM6E``H4z
z`0@#kRc=9}OBaQsAvc81Y=9}cdZO+sMog|pP@3v9**<#Rf5(6A9?(L&FHfEcH-}I^
zQKRP8jTo-=tl0L~l{O~x#L24`_)NCi*v5Uei}m<lba#S2ZAEM_^Asfw{uIOS1k1EN
z`jlAz_=3__pR!g;{!8;B3l;Nm+}x}9FJY_LyAF2C%o(K<kJ{TN$PXM-IMezmenoa(
zb>_R5UKulWw33=RHJMa<B;Asiy7t(En5cg8i4S8eU^m&tByMi|N|(bQudWrh>0PcD
z8~Gp}81_uEsQYMU7gZ&s*&Umk6M*Jd({!=mOnF6U%Jr4Z$gU*o1dTs^aU<pB%)Mor
zf-CEK!h=npXQC;G6bINhRnsg{rAX1dWFy#+ALm#%S!nYI>iSSZUZ9Zq_PLKr!gs}y
z^orxJZnW0;8tr<wu@xn58E=WoUTs+nKK+&Shh6AknbFL{+2~xo5NW^fJ|}>6`&H?_
zo~jdUmM`h)2ltrNs8dd-RAhoZ&t!TOw<_p~UZ2RF9zr&W;W~QzD*K%5@)zUnzjSnl
zeN)tRUrlEj#@ygcvENewQQO%X^~I3y#V<zbQvZyf`Aga`wluP=X<2sLsf?t<A`dAX
zQM}3MlDAqWQ(u};y@E+)h(60;AY1J$<y%GIwPc?>$EPvtvF&|#D`C;0mq{Ifk{Yj^
z9+rI*k$oHEX_VR=r88Kk=lqUQ5H-#p(OyPo2F*TjT<DLNFs_caSf;jqbTG52bS^Is
zw*R}D{C=s#l~~k`;0;8zINffN?NA8Xy}FDND|M=pp$&g}J$6wzNUcuLRr0r*U(Hgg
zr(U$JSc>py<Tvg(PZLJ==&iK`<wR$K?ga5(^zDrdm0pK_tzU-o4A~c!%A0biNpC=Q
z@#u*TAJ4VSHm?E?;!y{Zh|H#moPK1;*fG}hrW^jWX6*m_X^p2jBFrH=!W5#z>I&g7
z5C#JQNC3%ql3~W!5duL0NE;^z@gw16grFeY-qaMQ3Mua^9tnAMFE?!*fruw+K<*x1
zp4t$RK=km?@^;to_EJ~(_Jri6gtQ<C$F&1ENsDN6fy1kF7eSk#?F1dhNkZcL$H4^!
zJiJ1$$zKg~_m{^*bnqA?^uH-U9so`UMF4J|A4Ug3AaC&NfT!lfOyfmo;5K1y{LaTo
zDX)AMdA+*`@#{71c=H^SVL^jCltW=N&%;WoiJ}|N;^NptukjO%GyTj$VVQ77I*Blk
zc$oF+XJK5+%+3?371>A8n;R#vb;Si+F58d)W4+}n=(F-34oXZO8ItSmj~#58FGQ~z
zvfB!RbPRQicRp`b)lP+Aun22RxTc%d`kzgBrE`ITPK>WC@{#5{7o)bdYul+Wfsplj
ziJf+}-m`lVV@#f`H}ck(l?IuK5{6TqYik|%T4Uf%@j<ejx`gwQ=f4D=6PQM}`<d~y
zHw(!gBIQOc{vbydO}o_k%4Fu-wtVP|xrF3niooF9AGL(`4We-%Veb9Oih$rh2m~Ak
ZLqH<?T4G=GKyYq=Xj4djH6(}t{{`S8O&9<G

literal 0
HcmV?d00001

diff --git a/trusty/keymint/fuzz/corpus/keymint-rsps-01820081-3 b/trusty/keymint/fuzz/corpus/keymint-rsps-01820081-3
new file mode 100644
index 0000000000000000000000000000000000000000..34a5f23f2e99ce21afc809a0499b4955301f68cb
GIT binary patch
literal 1975
zcmcIli8q_u7XQ8kw`Q+;k(gqrsq}tHXcG0Rgg!OYP;(nIA&T}2Zn-Im=}NC6RB`nY
zLn&254MkCITZ-0Ds#F!BYAB*+RWG&HTkkJ;zrFWbzu(?x?S0lcYn=l!06IgG9_zyI
z#sK2!43Nn{N&o;1WFS!h0RF^4LI40q903?e8vy7+0wBOET?N3cjUNkPt-JyRz}k@j
zOnLH<b|3+`l<^^bjRbY8UmeoEL+XsesGJH=tv{RXEGTi`5WLhA1ZI8yymvDA&fhx^
z>$)6qHXy(o%ZvY_KbFV_;rT9nEgyf@e?y3Lz3uen8gpf4`fT~#+2!GrE*sfwEAUbZ
z-U&Z44SK#!M&mZ$Yu8hpp2N(nU$&>E)G8tK+xwddP4nq-BOqebmdhCydEP5twv9CD
z3EP=So|AQ*dEAKE(pJq3+j%_T@!4;6{7>k{C%w5EjFiVaj$vlNuTPu98fIBm6p_4T
z_CV<OQTy&9nzjsyd<0#p!df&B&bywZoFKbys=azZWP7^n<B)$&r7teARvbHX9_bIA
zDr<^=7)=hDy<h&pucY~eOl34gU|rhb+Q3rGja<~Dn7!34<*MHGqsoB}=2tS+vOIoc
z>kZ4v0RIjYdxS~KxLYRQsuXZ%)g!3&O$x$o)D>v7ZdPxcwY<BH=&3q}DTuNhAkJN{
zy>NW1g&qOOFP~e-LcK+CH>)f$?2IJkwgq<l?-W`{VoIX=#ndkZMS|mZ^EYsUN3Egq
z4I@giM%AP{BD-b0VM}MPd$>0O-z&yNQ7q0Rk7)jjX_)<R%UdtWi3zjtmW~?zq~+v1
zlw8PORGiAm#n%3^cBID`aa*W<z_d1MI-vqbidiFq%dc4jX%ic*Sycgh4UU|R<aZwZ
z`>m!8bo?NPxRg^@VEf>4$#=Vz=@%|SbxO~yEyo!XFQOHWa!S~;abA6_g2IVEjB<Or
zl`^L7QwLQPO!UoTe!1*^)=lSQVe9%ncc><Kz}P=mYFEz5s4iUVHM^anrmOW~3r)o%
zzLB;{MgV(Qt^hu9nCzB`W{K-N(?T}G9#Vvj$)2C`NXA9${`uN2G4#p@;cppWopMN<
z=c}agP|Ekev>YVnMincn6MiD=uBNyb>8~%`it*hGIY!}X%~XZ^SX$R;subh!X;)%5
z!xhJv&WdA+>=NTZJj)Dsn%2daz3V0OWWn}VTA0j?_bv#~m`BvB4E9SSDukqAI+dkr
zH(Iyt#0Jyz67Lmuoxk~LighE=xLa$#>ZFbLre>GxDY=v52PoZk@q8lP-+EASkrtN`
z&#ccmp*GJxp{4;MQhn%(FSu$#X`%+AokGT#$u<+WZ=u*A4eg*55edwFrmkd%eqjh<
zecaPeha^mVreR){O>Vw8dD-A)JHw}DAR>9pB}XbCL@#-?=U!<>g%I+V^&fq9S5=sM
zF#?@qcld;rQc2jsgwwZ2Ud~I%nEhSWh6U1xR{SGRFH3C~NVnDG5|64|XO9ci+chgU
z^!K#9Qt%fX!6hY1Ttm2hb$cSkN#JM81Y$`Ybv8len|98)&o<om0jwq}d^M`a{jOj;
zDf`7$gxoBxIpm(^hy=EJC~06}oUAQ4^xFxVOUpZt;5-r8r!y)&U9tRj59X^U4ELw)
z&l0ne7yT#prM=Eewg=%hq>KKtS$e?b7@Pk*ZDgOi<{9V7jhkA4t@-q@E#@z7pW$pr
zDIcF*hDA`ClYDZ>r!VxWMV0E<s6u9YP>C96GNZU2)%TV2ULoB_T|{1v$yHBXTAb35
zIfxy5y5oz=U$T}E7MpN)2Cbf@f-B26nfB|Ee1)?e<U9VqdnxvB-phP`v_^vz-Oxy-
z9*de`U3c*E`0&_$k~SGpcYG%<p6aJ1XYkHcF|&03?W>so_tP3jcj0q}7<~2+1J;@k
zhk-B{A3w=F1`-w!)JiZ**b)UnVTgbhfrJF$4tydaaC=izv?iqfL-9+Zu)dxIv>qOV
z*M+>ieSHWJUJvi>jq~%;_4CDI{d^#lv?vaO&^$YYtBg2-2Q&uDb3K9{!4*<PD?_Ls
z?cgE^qbpRDCza|ON<{_wUPpQRdj<pt1d~x{hyf}?qW{|y$Pd67pg6$G3&9v52y_&8
zB1=9QgpLnusN`;I-rU>K=SWu?b!N1;s5s_G@w+FjTD{fSe{E8-vDPfPd#xZnTq&=v
zaZ#++e1Vgyb88{VF;ZOs_w}N4T7B~6EMmY~`=ryHPc%PGMedE3*S9To=1XR0n2u;^
z?iqgFOYufa7$@xk0X=Sr{JCE0x}CxW2iqswWdys$;V+~TTf+1?)Cm8c?7~FRB%`9+
zq;Ps>gkt4n{7*O-so3~@air4xBe_seVYrLD8B;ghWT;kbc>f<CI1b+}s!cW}`U+$X
zglBy#e5sY^>Cc8n=dqOsJJaPyRfuLy%k<lU$3K2swzr_#$HiK!Y6Zk4H+sY1yf3zp
dz6;T}ATi!)%8P^G0UsZncb|~>4=u^l{{h)uVNn18

literal 0
HcmV?d00001


From 32dcac7851284cad16c0ce25e60cd1f5273dfc0e Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Wed, 15 Feb 2023 16:23:46 -0800
Subject: [PATCH 0052/1487] Support ZSTD in userspace COW

Perf:
Lz4:
Update took 429 seconds
merge time 35.4s
cow size: 3.18GB

ZSTD:
Update took 676 seconds
merge time 49.4s
cow size: 2.62GB

Gz:
Update took 1057 seconds
merge time: 50.0s
cow size: 2.55GB

In summary, ZSTD is a middle point between LZ4 and GZ.

Speed: LZ4 > ZSTD > GZ
Space: LZ4 > ZSTD > GZ

Bug: 274129758

Change-Id: I203bf088b7c2a9ce429f75478799da0e7126febf
---
 fastboot/Android.bp                           |  1 +
 fs_mgr/libsnapshot/Android.bp                 |  1 +
 .../include/libsnapshot/cow_format.h          |  3 +-
 .../libsnapshot_cow/cow_compress.cpp          | 20 ++++++++
 .../libsnapshot_cow/cow_decompress.cpp        | 50 +++++++++++++++++++
 .../libsnapshot_cow/cow_decompress.h          |  1 +
 .../libsnapshot_cow/cow_reader.cpp            |  6 +++
 fs_mgr/libsnapshot/snapuserd/Android.bp       |  1 +
 init/Android.bp                               |  2 +
 9 files changed, 84 insertions(+), 1 deletion(-)

diff --git a/fastboot/Android.bp b/fastboot/Android.bp
index 7794c4b464fd..56cac88d3828 100644
--- a/fastboot/Android.bp
+++ b/fastboot/Android.bp
@@ -196,6 +196,7 @@ cc_binary {
         "libfastbootshim",
         "libsnapshot_cow",
         "liblz4",
+        "libzstd",
         "libsnapshot_nobinder",
         "update_metadata-protos",
         "liburing",
diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 3dd1f1ac4a3c..d3bd904dcb00 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -163,6 +163,7 @@ cc_defaults {
         "libbrotli",
         "libz",
         "liblz4",
+        "libzstd",
     ],
     export_include_dirs: ["include"],
 }
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 6baf4beae733..c3ca00ae034e 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -157,7 +157,8 @@ enum CowCompressionAlgorithm : uint8_t {
     kCowCompressNone = 0,
     kCowCompressGz = 1,
     kCowCompressBrotli = 2,
-    kCowCompressLz4 = 3
+    kCowCompressLz4 = 3,
+    kCowCompressZstd = 4,
 };
 
 static constexpr uint8_t kCowReadAheadNotStarted = 0;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
index d06c904ba884..a4a0ad661823 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
@@ -29,6 +29,7 @@
 #include <libsnapshot/cow_writer.h>
 #include <lz4.h>
 #include <zlib.h>
+#include <zstd.h>
 
 namespace android {
 namespace snapshot {
@@ -40,6 +41,8 @@ std::optional<CowCompressionAlgorithm> CompressionAlgorithmFromString(std::strin
         return {kCowCompressBrotli};
     } else if (name == "lz4") {
         return {kCowCompressLz4};
+    } else if (name == "zstd") {
+        return {kCowCompressZstd};
     } else if (name == "none" || name.empty()) {
         return {kCowCompressNone};
     } else {
@@ -112,6 +115,23 @@ std::basic_string<uint8_t> CompressWorker::Compress(CowCompressionAlgorithm comp
             }
             return buffer;
         }
+        case kCowCompressZstd: {
+            std::basic_string<uint8_t> buffer(ZSTD_compressBound(length), '\0');
+            const auto compressed_size =
+                    ZSTD_compress(buffer.data(), buffer.size(), data, length, 0);
+            if (compressed_size <= 0) {
+                LOG(ERROR) << "ZSTD compression failed " << compressed_size;
+                return {};
+            }
+            // Don't run compression if the compressed output is larger
+            if (compressed_size >= length) {
+                buffer.resize(length);
+                memcpy(buffer.data(), data, length);
+            } else {
+                buffer.resize(compressed_size);
+            }
+            return buffer;
+        }
         default:
             LOG(ERROR) << "unhandled compression type: " << compression;
             break;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp
index 3d34413eaeae..da90cc048169 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp
@@ -17,12 +17,15 @@
 #include "cow_decompress.h"
 
 #include <array>
+#include <cstring>
 #include <utility>
+#include <vector>
 
 #include <android-base/logging.h>
 #include <brotli/decode.h>
 #include <lz4.h>
 #include <zlib.h>
+#include <zstd.h>
 
 namespace android {
 namespace snapshot {
@@ -336,9 +339,56 @@ class Lz4Decompressor final : public IDecompressor {
     }
 };
 
+class ZstdDecompressor final : public IDecompressor {
+  public:
+    ssize_t Decompress(void* buffer, size_t buffer_size, size_t decompressed_size,
+                       size_t ignore_bytes = 0) override {
+        if (buffer_size < decompressed_size - ignore_bytes) {
+            LOG(INFO) << "buffer size " << buffer_size
+                      << " is not large enough to hold decompressed data. Decompressed size "
+                      << decompressed_size << ", ignore_bytes " << ignore_bytes;
+            return -1;
+        }
+        if (ignore_bytes == 0) {
+            if (!Decompress(buffer, decompressed_size)) {
+                return -1;
+            }
+            return decompressed_size;
+        }
+        std::vector<unsigned char> ignore_buf(decompressed_size);
+        if (!Decompress(buffer, decompressed_size)) {
+            return -1;
+        }
+        memcpy(buffer, ignore_buf.data() + ignore_bytes, buffer_size);
+        return decompressed_size;
+    }
+    bool Decompress(void* output_buffer, const size_t output_size) {
+        std::string input_buffer;
+        input_buffer.resize(stream_->Size());
+        size_t bytes_read = stream_->Read(input_buffer.data(), input_buffer.size());
+        if (bytes_read != input_buffer.size()) {
+            LOG(ERROR) << "Failed to read all input at once. Expected: " << input_buffer.size()
+                       << " actual: " << bytes_read;
+            return false;
+        }
+        const auto bytes_decompressed = ZSTD_decompress(output_buffer, output_size,
+                                                        input_buffer.data(), input_buffer.size());
+        if (bytes_decompressed != output_size) {
+            LOG(ERROR) << "Failed to decompress ZSTD block, expected output size: " << output_size
+                       << ", actual: " << bytes_decompressed;
+            return false;
+        }
+        return true;
+    }
+};
+
 std::unique_ptr<IDecompressor> IDecompressor::Lz4() {
     return std::make_unique<Lz4Decompressor>();
 }
 
+std::unique_ptr<IDecompressor> IDecompressor::Zstd() {
+    return std::make_unique<ZstdDecompressor>();
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.h b/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.h
index 9e83f3c5cf68..52b3d7671261 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.h
@@ -47,6 +47,7 @@ class IDecompressor {
     static std::unique_ptr<IDecompressor> Gz();
     static std::unique_ptr<IDecompressor> Brotli();
     static std::unique_ptr<IDecompressor> Lz4();
+    static std::unique_ptr<IDecompressor> Zstd();
 
     static std::unique_ptr<IDecompressor> FromString(std::string_view compressor);
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 4c5a8bf5ff5e..6749cf1b0363 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -30,6 +30,7 @@
 #include <zlib.h>
 
 #include "cow_decompress.h"
+#include "libsnapshot/cow_format.h"
 
 namespace android {
 namespace snapshot {
@@ -777,6 +778,11 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
         case kCowCompressBrotli:
             decompressor = IDecompressor::Brotli();
             break;
+        case kCowCompressZstd:
+            if (header_.block_size != op->data_length) {
+                decompressor = IDecompressor::Zstd();
+            }
+            break;
         case kCowCompressLz4:
             if (header_.block_size != op->data_length) {
                 decompressor = IDecompressor::Lz4();
diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 1e03683e91ee..9fe567acbc7e 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -112,6 +112,7 @@ cc_defaults {
         "liblz4",
         "libext4_utils",
         "liburing",
+        "libzstd",
     ],
 
     header_libs: [
diff --git a/init/Android.bp b/init/Android.bp
index 7b529033a968..41c7a953abc2 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -169,6 +169,7 @@ libinit_cc_defaults {
         "libfsverity_init",
         "liblmkd_utils",
         "liblz4",
+        "libzstd",
         "libmini_keyctl_static",
         "libmodprobe",
         "libprocinfo",
@@ -370,6 +371,7 @@ cc_binary {
         "libprotobuf-cpp-lite",
         "libsnapshot_cow",
         "liblz4",
+        "libzstd",
         "libsnapshot_init",
         "update_metadata-protos",
         "libprocinfo",

From e556021b5295f6a7b6041eee98990f6e4a92c84d Mon Sep 17 00:00:00 2001
From: David Drysdale <drysdale@google.com>
Date: Wed, 17 May 2023 17:37:38 +0100
Subject: [PATCH 0053/1487] Set IMEI in provisioning helper

Borrow the code from AttestKeyTest.cpp (in KeyMint VTS) for determining
the devices IMEI value(s), and use that as default value.

Also update to use the newer provisioning message if the second IMEI is
set.

Test: provision a test device
Change-Id: Ie8e183dc50ac9107c2c2c2966c591e8b6022fd20
---
 .../set_attestation_ids.cpp                   | 146 ++++++++++++++----
 1 file changed, 118 insertions(+), 28 deletions(-)

diff --git a/trusty/keymaster/set_attestation_ids/set_attestation_ids.cpp b/trusty/keymaster/set_attestation_ids/set_attestation_ids.cpp
index e944167fad4c..6b8f90fa46b2 100644
--- a/trusty/keymaster/set_attestation_ids/set_attestation_ids.cpp
+++ b/trusty/keymaster/set_attestation_ids/set_attestation_ids.cpp
@@ -17,8 +17,10 @@
 #include <getopt.h>
 
 #include <string>
+#include <vector>
 
 #include <android-base/properties.h>
+#include <android-base/strings.h>
 #include <trusty_keymaster/ipc/trusty_keymaster_ipc.h>
 
 namespace {
@@ -34,14 +36,66 @@ const struct option lopts[] = {
         {"model", required_argument, nullptr, 'm'},
         {"imei", required_argument, nullptr, 'i'},
         {"meid", required_argument, nullptr, 'c'},
+        {"imei2", required_argument, nullptr, '2'},
         {0, 0, 0, 0},
 };
 
+std::string TELEPHONY_CMD_GET_IMEI = "cmd phone get-imei ";
+
+// Run a shell command and collect the output of it. If any error, set an empty string as the
+// output.
+std::string exec_command(const std::string& command) {
+    char buffer[128];
+    std::string result = "";
+
+    FILE* pipe = popen(command.c_str(), "r");
+    if (!pipe) {
+        fprintf(stderr, "popen('%s') failed\n", command.c_str());
+        return result;
+    }
+
+    while (!feof(pipe)) {
+        if (fgets(buffer, 128, pipe) != NULL) {
+            result += buffer;
+        }
+    }
+
+    pclose(pipe);
+    return result;
+}
+
+// Get IMEI using Telephony service shell command. If any error while executing the command
+// then empty string will be returned as output.
+std::string get_imei(int slot) {
+    std::string cmd = TELEPHONY_CMD_GET_IMEI + std::to_string(slot);
+    std::string output = exec_command(cmd);
+
+    if (output.empty()) {
+        fprintf(stderr, "Retrieve IMEI command ('%s') failed\n", cmd.c_str());
+        return "";
+    }
+
+    std::vector<std::string> out =
+            ::android::base::Tokenize(::android::base::Trim(output), "Device IMEI:");
+
+    if (out.size() != 1) {
+        fprintf(stderr, "Error parsing command ('%s') output '%s'\n", cmd.c_str(), output.c_str());
+        return "";
+    }
+
+    std::string imei = ::android::base::Trim(out[0]);
+    if (imei.compare("null") == 0) {
+        fprintf(stderr, "IMEI value from command ('%s') is null, skipping", cmd.c_str());
+        return "";
+    }
+    return imei;
+}
+
 std::string buf2string(const keymaster::Buffer& buf) {
     return std::string(reinterpret_cast<const char*>(buf.peek_read()), buf.available_read());
 }
 
-void print_usage(const char* prog, const keymaster::SetAttestationIdsRequest& req) {
+void print_usage(const char* prog, const keymaster::SetAttestationIdsKM3Request& req) {
     fprintf(stderr,
             "Usage: %s [options]\n"
             "\n"
@@ -55,34 +109,53 @@ void print_usage(const char* prog, const keymaster::SetAttestationIdsRequest& re
             "  -m, --model <val>          set model (default '%s')\n"
             "  -i, --imei <val>           set IMEI (default '%s')\n"
             "  -c, --meid <val>           set MEID (default '%s')\n"
+            "  -2, --imei2 <val>          set second IMEI (default '%s')\n"
             "\n",
-            prog, buf2string(req.brand).c_str(), buf2string(req.device).c_str(),
-            buf2string(req.product).c_str(), buf2string(req.serial).c_str(),
-            buf2string(req.manufacturer).c_str(), buf2string(req.model).c_str(),
-            buf2string(req.imei).c_str(), buf2string(req.meid).c_str());
+            prog, buf2string(req.base.brand).c_str(), buf2string(req.base.device).c_str(),
+            buf2string(req.base.product).c_str(), buf2string(req.base.serial).c_str(),
+            buf2string(req.base.manufacturer).c_str(), buf2string(req.base.model).c_str(),
+            buf2string(req.base.imei).c_str(), buf2string(req.base.meid).c_str(),
+            buf2string(req.second_imei).c_str());
+}
+
+void set_to(keymaster::Buffer* buf, const std::string& value) {
+    if (!value.empty()) {
+        buf->Reinitialize(value.data(), value.size());
+    }
 }
 
 void set_from_prop(keymaster::Buffer* buf, const std::string& prop) {
     std::string prop_value = ::android::base::GetProperty(prop, /* default_value = */ "");
-    if (!prop_value.empty()) {
-        buf->Reinitialize(prop_value.data(), prop_value.size());
-    }
+    set_to(buf, prop_value);
 }
 
-void populate_ids(keymaster::SetAttestationIdsRequest* req) {
+void populate_base_ids(keymaster::SetAttestationIdsRequest* req) {
     set_from_prop(&req->brand, "ro.product.brand");
     set_from_prop(&req->device, "ro.product.device");
     set_from_prop(&req->product, "ro.product.name");
     set_from_prop(&req->serial, "ro.serialno");
     set_from_prop(&req->manufacturer, "ro.product.manufacturer");
     set_from_prop(&req->model, "ro.product.model");
+    std::string imei = get_imei(0);
+    set_to(&req->imei, imei);
+}
+
+void populate_ids(keymaster::SetAttestationIdsKM3Request* req) {
+    populate_base_ids(&req->base);
+
+    // - "What about IMEI?"
+    // - "You've already had it."
+    // - "We've had one, yes. What about second IMEI?"
+    // - "I don't think he knows about second IMEI, Pip."
+    std::string imei2 = get_imei(1);
+    set_to(&req->second_imei, imei2);
 }
 
 }  // namespace
 
 int main(int argc, char** argv) {
     // By default, set attestation IDs to the values in userspace properties.
-    keymaster::SetAttestationIdsRequest req(/* ver = */ 4);
+    keymaster::SetAttestationIdsKM3Request req(/* ver = */ 4);
     populate_ids(&req);
 
     while (true) {
@@ -94,28 +167,31 @@ int main(int argc, char** argv) {
 
         switch (c) {
             case 'b':
-                req.brand.Reinitialize(optarg, strlen(optarg));
+                req.base.brand.Reinitialize(optarg, strlen(optarg));
                 break;
             case 'd':
-                req.device.Reinitialize(optarg, strlen(optarg));
+                req.base.device.Reinitialize(optarg, strlen(optarg));
                 break;
             case 'p':
-                req.product.Reinitialize(optarg, strlen(optarg));
+                req.base.product.Reinitialize(optarg, strlen(optarg));
                 break;
             case 's':
-                req.serial.Reinitialize(optarg, strlen(optarg));
+                req.base.serial.Reinitialize(optarg, strlen(optarg));
                 break;
             case 'M':
-                req.manufacturer.Reinitialize(optarg, strlen(optarg));
+                req.base.manufacturer.Reinitialize(optarg, strlen(optarg));
                 break;
             case 'm':
-                req.model.Reinitialize(optarg, strlen(optarg));
+                req.base.model.Reinitialize(optarg, strlen(optarg));
                 break;
             case 'i':
-                req.imei.Reinitialize(optarg, strlen(optarg));
+                req.base.imei.Reinitialize(optarg, strlen(optarg));
                 break;
             case 'c':
-                req.meid.Reinitialize(optarg, strlen(optarg));
+                req.base.meid.Reinitialize(optarg, strlen(optarg));
+                break;
+            case '2':
+                req.second_imei.Reinitialize(optarg, strlen(optarg));
                 break;
             case 'h':
                 print_usage(argv[0], req);
@@ -144,19 +220,33 @@ int main(int argc, char** argv) {
            "  manufacturer: %s\n"
            "  model:        %s\n"
            "  IMEI:         %s\n"
-           "  MEID:         %s\n",
-           buf2string(req.brand).c_str(), buf2string(req.device).c_str(),
-           buf2string(req.product).c_str(), buf2string(req.serial).c_str(),
-           buf2string(req.manufacturer).c_str(), buf2string(req.model).c_str(),
-           buf2string(req.imei).c_str(), buf2string(req.meid).c_str());
+           "  MEID:         %s\n"
+           "  SECOND_IMEI:  %s\n\n",
+           buf2string(req.base.brand).c_str(), buf2string(req.base.device).c_str(),
+           buf2string(req.base.product).c_str(), buf2string(req.base.serial).c_str(),
+           buf2string(req.base.manufacturer).c_str(), buf2string(req.base.model).c_str(),
+           buf2string(req.base.imei).c_str(), buf2string(req.base.meid).c_str(),
+           buf2string(req.second_imei).c_str());
+    fflush(stdout);
 
     keymaster::EmptyKeymasterResponse rsp(/* ver = */ 4);
-    ret = trusty_keymaster_send(KM_SET_ATTESTATION_IDS, req, &rsp);
+    const char* msg;
+    if (req.second_imei.available_read() == 0) {
+        // No SECOND_IMEI set, use base command.
+        ret = trusty_keymaster_send(KM_SET_ATTESTATION_IDS, req.base, &rsp);
+        msg = "SET_ATTESTATION_IDS";
+    } else {
+        // SECOND_IMEI is set, use updated command.
+        ret = trusty_keymaster_send(KM_SET_ATTESTATION_IDS_KM3, req, &rsp);
+        msg = "SET_ATTESTATION_IDS_KM3";
+    }
+    trusty_keymaster_disconnect();
+
     if (ret) {
-        fprintf(stderr, "SET_ATTESTATION_IDS failed: %d\n", ret);
-        trusty_keymaster_disconnect();
+        fprintf(stderr, "%s failed: %d\n", msg, ret);
         return EXIT_FAILURE;
+    } else {
+        printf("done\n");
+        return EXIT_SUCCESS;
     }
-
-    return EXIT_SUCCESS;
 }

From 52205b820693b74fb2b33beef2f4cd4ba63cf738 Mon Sep 17 00:00:00 2001
From: Frederick Mayle <fmayle@google.com>
Date: Thu, 15 Dec 2022 16:08:52 -0800
Subject: [PATCH 0054/1487] debuggerd_client_test: less racy test setup

Make sure that all the threads have started up, otherwise the main part
of the test might not be testing as stressful a situation as expected.
Note that the "race" moniker is still valid because of the debuggerd
timeout.

The test is now faster (405ms) when run under good conditions.

Test: atest 'debuggerd_test:debuggerd_client#race'
Test: Ran debuggerd_client.race 1000 times on its own.
Test: Ran the whole suite of debuggerd unit tests 1000 times.
Change-Id: I487e7654a71df9f1799f09c6f385c929ddf2f234
---
 debuggerd/client/debuggerd_client_test.cpp | 30 ++++++++++++++--------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/debuggerd/client/debuggerd_client_test.cpp b/debuggerd/client/debuggerd_client_test.cpp
index ebb8d86e0bce..33ff05fd6ace 100644
--- a/debuggerd/client/debuggerd_client_test.cpp
+++ b/debuggerd/client/debuggerd_client_test.cpp
@@ -18,6 +18,7 @@
 
 #include <fcntl.h>
 #include <stdio.h>
+#include <sys/eventfd.h>
 #include <unistd.h>
 
 #include <chrono>
@@ -51,23 +52,35 @@ static int getThreadCount() {
 
 TEST(debuggerd_client, race) {
   static int THREAD_COUNT = getThreadCount();
-  pid_t forkpid = fork();
 
-  ASSERT_NE(-1, forkpid);
+  // Semaphore incremented once per thread started.
+  unique_fd barrier(eventfd(0, EFD_SEMAPHORE));
+  ASSERT_NE(-1, barrier.get());
 
+  pid_t forkpid = fork();
+  ASSERT_NE(-1, forkpid);
   if (forkpid == 0) {
     // Spawn a bunch of threads, to make crash_dump take longer.
     std::vector<std::thread> threads;
+    threads.reserve(THREAD_COUNT);
     for (int i = 0; i < THREAD_COUNT; ++i) {
-      threads.emplace_back([]() {
-        while (true) {
-          std::this_thread::sleep_for(60s);
+      threads.emplace_back([&barrier]() {
+        uint64_t count = 1;
+        ASSERT_NE(-1, write(barrier.get(), &count, sizeof(count)));
+        for (;;) {
+          pause();
         }
       });
     }
+    for (;;) {
+      pause();
+    }
+  }
 
-    std::this_thread::sleep_for(60s);
-    exit(0);
+  // Wait for the child to spawn all of its threads.
+  for (int i = 0; i < THREAD_COUNT; ++i) {
+    uint64_t count;
+    ASSERT_NE(-1, read(barrier.get(), &count, sizeof(count)));
   }
 
   unique_fd pipe_read, pipe_write;
@@ -77,9 +90,6 @@ TEST(debuggerd_client, race) {
   constexpr int PIPE_SIZE = 16 * 1024 * 1024;
   ASSERT_EQ(PIPE_SIZE, fcntl(pipe_read.get(), F_SETPIPE_SZ, PIPE_SIZE));
 
-  // Wait for a bit to let the child spawn all of its threads.
-  std::this_thread::sleep_for(1s);
-
   ASSERT_TRUE(
       debuggerd_trigger_dump(forkpid, kDebuggerdNativeBacktrace, 60000, std::move(pipe_write)));
   // Immediately kill the forked child, to make sure that the dump didn't return early.

From 59abbfe64706a7ea0c4e932ae40bc8bde9746dce Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 16 May 2023 15:53:57 -0700
Subject: [PATCH 0055/1487] ueventd: Fix a race condition in handling
 device-mapper events.

We've had flake in libdm_test for a long time, with no clear cause.
Lately however it has become particularly reproducible when running
the UeventAfterLoadTable test in isolation, and thus we've identified
the root cause.

uevents for device-mapper are fired when the sysfs node is added, but at
that time, the "dm" subnode has not yet been added. The root node and dm
node are added very close together, so usually it works, but sometimes
ueventd is too fast.

Instead of relying on sysfs, query the uuid/name node directly from
device-mapper.

Bug: 270183812
Test: libdm_test
Change-Id: I258de5de05d813c3cb7f129e82e56dbfe8bf3117
---
 fs_mgr/libdm/dm.cpp             | 19 +++++++
 fs_mgr/libdm/dm_test.cpp        | 94 +++++++++++++++++++++++----------
 fs_mgr/libdm/include/libdm/dm.h |  2 +
 init/devices.cpp                | 18 +++----
 4 files changed, 94 insertions(+), 39 deletions(-)

diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index deffae1ad6fe..1e8c14fe2c01 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -243,6 +243,25 @@ bool DeviceMapper::GetDeviceUniquePath(const std::string& name, std::string* pat
     return true;
 }
 
+bool DeviceMapper::GetDeviceNameAndUuid(dev_t dev, std::string* name, std::string* uuid) {
+    struct dm_ioctl io;
+    InitIo(&io, {});
+    io.dev = dev;
+
+    if (ioctl(fd_, DM_DEV_STATUS, &io) < 0) {
+        PLOG(ERROR) << "Failed to find device dev: " << major(dev) << ":" << minor(dev);
+        return false;
+    }
+
+    if (name) {
+        *name = io.name;
+    }
+    if (uuid) {
+        *uuid = io.uuid;
+    }
+    return true;
+}
+
 std::optional<DeviceMapper::Info> DeviceMapper::GetDetailedInfo(const std::string& name) const {
     struct dm_ioctl io;
     InitIo(&io, name);
diff --git a/fs_mgr/libdm/dm_test.cpp b/fs_mgr/libdm/dm_test.cpp
index 788cf5174853..c522eafae058 100644
--- a/fs_mgr/libdm/dm_test.cpp
+++ b/fs_mgr/libdm/dm_test.cpp
@@ -30,6 +30,7 @@
 #include <thread>
 
 #include <android-base/file.h>
+#include <android-base/logging.h>
 #include <android-base/scopeguard.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
@@ -42,16 +43,40 @@
 using namespace std;
 using namespace std::chrono_literals;
 using namespace android::dm;
-using unique_fd = android::base::unique_fd;
+using android::base::make_scope_guard;
+using android::base::unique_fd;
+
+class DmTest : public ::testing::Test {
+  protected:
+    void SetUp() override {
+        const testing::TestInfo* const test_info =
+                testing::UnitTest::GetInstance()->current_test_info();
+        test_name_ = test_info->name();
+        test_full_name_ = test_info->test_suite_name() + "/"s + test_name_;
+
+        LOG(INFO) << "Starting test: " << test_full_name_;
+    }
+    void TearDown() override {
+        LOG(INFO) << "Tearing down test: " << test_full_name_;
+
+        auto& dm = DeviceMapper::Instance();
+        ASSERT_TRUE(dm.DeleteDeviceIfExists(test_name_));
+
+        LOG(INFO) << "Teardown complete for test: " << test_full_name_;
+    }
+
+    std::string test_name_;
+    std::string test_full_name_;
+};
 
-TEST(libdm, HasMinimumTargets) {
+TEST_F(DmTest, HasMinimumTargets) {
     DmTargetTypeInfo info;
 
     DeviceMapper& dm = DeviceMapper::Instance();
     ASSERT_TRUE(dm.GetTargetByName("linear", &info));
 }
 
-TEST(libdm, DmLinear) {
+TEST_F(DmTest, DmLinear) {
     unique_fd tmp1(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp1, 0);
     unique_fd tmp2(CreateTempFile("file_2", 4096));
@@ -127,7 +152,7 @@ TEST(libdm, DmLinear) {
     ASSERT_TRUE(dev.Destroy());
 }
 
-TEST(libdm, DmSuspendResume) {
+TEST_F(DmTest, DmSuspendResume) {
     unique_fd tmp1(CreateTempFile("file_suspend_resume", 512));
     ASSERT_GE(tmp1, 0);
 
@@ -156,7 +181,7 @@ TEST(libdm, DmSuspendResume) {
     ASSERT_EQ(dm.GetState(dev.name()), DmDeviceState::ACTIVE);
 }
 
-TEST(libdm, DmVerityArgsAvb2) {
+TEST_F(DmTest, DmVerityArgsAvb2) {
     std::string device = "/dev/block/platform/soc/1da4000.ufshc/by-name/vendor_a";
     std::string algorithm = "sha1";
     std::string digest = "4be7e823b8c40f7bd5c8ccd5123f0722c5baca21";
@@ -178,7 +203,7 @@ TEST(libdm, DmVerityArgsAvb2) {
     EXPECT_EQ(target.GetParameterString(), expected);
 }
 
-TEST(libdm, DmSnapshotArgs) {
+TEST_F(DmTest, DmSnapshotArgs) {
     DmTargetSnapshot target1(0, 512, "base", "cow", SnapshotStorageMode::Persistent, 8);
     if (DmTargetSnapshot::ReportsOverflow("snapshot")) {
         EXPECT_EQ(target1.GetParameterString(), "base cow PO 8");
@@ -200,7 +225,7 @@ TEST(libdm, DmSnapshotArgs) {
     EXPECT_EQ(target3.name(), "snapshot-merge");
 }
 
-TEST(libdm, DmSnapshotOriginArgs) {
+TEST_F(DmTest, DmSnapshotOriginArgs) {
     DmTargetSnapshotOrigin target(0, 512, "base");
     EXPECT_EQ(target.GetParameterString(), "base");
     EXPECT_EQ(target.name(), "snapshot-origin");
@@ -330,7 +355,7 @@ bool CheckSnapshotAvailability() {
     return true;
 }
 
-TEST(libdm, DmSnapshot) {
+TEST_F(DmTest, DmSnapshot) {
     if (!CheckSnapshotAvailability()) {
         return;
     }
@@ -374,7 +399,7 @@ TEST(libdm, DmSnapshot) {
     ASSERT_EQ(read, data);
 }
 
-TEST(libdm, DmSnapshotOverflow) {
+TEST_F(DmTest, DmSnapshotOverflow) {
     if (!CheckSnapshotAvailability()) {
         return;
     }
@@ -421,7 +446,7 @@ TEST(libdm, DmSnapshotOverflow) {
     }
 }
 
-TEST(libdm, ParseStatusText) {
+TEST_F(DmTest, ParseStatusText) {
     DmTargetSnapshot::Status status;
 
     // Bad inputs
@@ -448,7 +473,7 @@ TEST(libdm, ParseStatusText) {
     EXPECT_TRUE(DmTargetSnapshot::ParseStatusText("Overflow", &status));
 }
 
-TEST(libdm, DmSnapshotMergePercent) {
+TEST_F(DmTest, DmSnapshotMergePercent) {
     DmTargetSnapshot::Status status;
 
     // Correct input
@@ -502,7 +527,7 @@ TEST(libdm, DmSnapshotMergePercent) {
     EXPECT_LE(DmTargetSnapshot::MergePercent(status, 0), 0.0);
 }
 
-TEST(libdm, CryptArgs) {
+TEST_F(DmTest, CryptArgs) {
     DmTargetCrypt target1(0, 512, "sha1", "abcdefgh", 50, "/dev/loop0", 100);
     ASSERT_EQ(target1.name(), "crypt");
     ASSERT_TRUE(target1.Valid());
@@ -518,7 +543,7 @@ TEST(libdm, CryptArgs) {
               "iv_large_sectors sector_size:64");
 }
 
-TEST(libdm, DefaultKeyArgs) {
+TEST_F(DmTest, DefaultKeyArgs) {
     DmTargetDefaultKey target(0, 4096, "aes-xts-plain64", "abcdef0123456789", "/dev/loop0", 0);
     target.SetSetDun();
     ASSERT_EQ(target.name(), "default-key");
@@ -529,7 +554,7 @@ TEST(libdm, DefaultKeyArgs) {
               "iv_large_sectors");
 }
 
-TEST(libdm, DefaultKeyLegacyArgs) {
+TEST_F(DmTest, DefaultKeyLegacyArgs) {
     DmTargetDefaultKey target(0, 4096, "AES-256-XTS", "abcdef0123456789", "/dev/loop0", 0);
     target.SetUseLegacyOptionsFormat();
     ASSERT_EQ(target.name(), "default-key");
@@ -537,7 +562,7 @@ TEST(libdm, DefaultKeyLegacyArgs) {
     ASSERT_EQ(target.GetParameterString(), "AES-256-XTS abcdef0123456789 /dev/loop0 0");
 }
 
-TEST(libdm, DeleteDeviceWithTimeout) {
+TEST_F(DmTest, DeleteDeviceWithTimeout) {
     unique_fd tmp(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp, 0);
     LoopDevice loop(tmp, 10s);
@@ -561,7 +586,7 @@ TEST(libdm, DeleteDeviceWithTimeout) {
     ASSERT_EQ(ENOENT, errno);
 }
 
-TEST(libdm, IsDmBlockDevice) {
+TEST_F(DmTest, IsDmBlockDevice) {
     unique_fd tmp(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp, 0);
     LoopDevice loop(tmp, 10s);
@@ -580,7 +605,7 @@ TEST(libdm, IsDmBlockDevice) {
     ASSERT_FALSE(dm.IsDmBlockDevice(loop.device()));
 }
 
-TEST(libdm, GetDmDeviceNameByPath) {
+TEST_F(DmTest, GetDmDeviceNameByPath) {
     unique_fd tmp(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp, 0);
     LoopDevice loop(tmp, 10s);
@@ -601,7 +626,7 @@ TEST(libdm, GetDmDeviceNameByPath) {
     ASSERT_EQ("libdm-test-dm-linear", *name);
 }
 
-TEST(libdm, GetParentBlockDeviceByPath) {
+TEST_F(DmTest, GetParentBlockDeviceByPath) {
     unique_fd tmp(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp, 0);
     LoopDevice loop(tmp, 10s);
@@ -621,7 +646,7 @@ TEST(libdm, GetParentBlockDeviceByPath) {
     ASSERT_EQ(loop.device(), *sub_block_device);
 }
 
-TEST(libdm, DeleteDeviceDeferredNoReferences) {
+TEST_F(DmTest, DeleteDeviceDeferredNoReferences) {
     unique_fd tmp(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp, 0);
     LoopDevice loop(tmp, 10s);
@@ -647,7 +672,7 @@ TEST(libdm, DeleteDeviceDeferredNoReferences) {
     ASSERT_EQ(ENOENT, errno);
 }
 
-TEST(libdm, DeleteDeviceDeferredWaitsForLastReference) {
+TEST_F(DmTest, DeleteDeviceDeferredWaitsForLastReference) {
     unique_fd tmp(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp, 0);
     LoopDevice loop(tmp, 10s);
@@ -682,7 +707,7 @@ TEST(libdm, DeleteDeviceDeferredWaitsForLastReference) {
     ASSERT_EQ(ENOENT, errno);
 }
 
-TEST(libdm, CreateEmptyDevice) {
+TEST_F(DmTest, CreateEmptyDevice) {
     DeviceMapper& dm = DeviceMapper::Instance();
     ASSERT_TRUE(dm.CreateEmptyDevice("empty-device"));
     auto guard =
@@ -692,9 +717,7 @@ TEST(libdm, CreateEmptyDevice) {
     ASSERT_EQ(DmDeviceState::SUSPENDED, dm.GetState("empty-device"));
 }
 
-TEST(libdm, UeventAfterLoadTable) {
-    static const char* kDeviceName = "libdm-test-uevent-load-table";
-
+TEST_F(DmTest, UeventAfterLoadTable) {
     struct utsname u;
     ASSERT_EQ(uname(&u), 0);
 
@@ -706,18 +729,31 @@ TEST(libdm, UeventAfterLoadTable) {
     }
 
     DeviceMapper& dm = DeviceMapper::Instance();
-    ASSERT_TRUE(dm.CreateEmptyDevice(kDeviceName));
+    ASSERT_TRUE(dm.CreateEmptyDevice(test_name_));
 
     DmTable table;
     table.Emplace<DmTargetError>(0, 1);
-    ASSERT_TRUE(dm.LoadTable(kDeviceName, table));
+    ASSERT_TRUE(dm.LoadTable(test_name_, table));
 
     std::string ignore_path;
-    ASSERT_TRUE(dm.WaitForDevice(kDeviceName, 5s, &ignore_path));
+    ASSERT_TRUE(dm.WaitForDevice(test_name_, 5s, &ignore_path));
 
-    auto info = dm.GetDetailedInfo(kDeviceName);
+    auto info = dm.GetDetailedInfo(test_name_);
     ASSERT_TRUE(info.has_value());
     ASSERT_TRUE(info->IsSuspended());
 
-    ASSERT_TRUE(dm.DeleteDevice(kDeviceName));
+    ASSERT_TRUE(dm.DeleteDevice(test_name_));
+}
+
+TEST_F(DmTest, GetNameAndUuid) {
+    auto& dm = DeviceMapper::Instance();
+    ASSERT_TRUE(dm.CreatePlaceholderDevice(test_name_));
+
+    dev_t dev;
+    ASSERT_TRUE(dm.GetDeviceNumber(test_name_, &dev));
+
+    std::string name, uuid;
+    ASSERT_TRUE(dm.GetDeviceNameAndUuid(dev, &name, &uuid));
+    ASSERT_EQ(name, test_name_);
+    ASSERT_FALSE(uuid.empty());
 }
diff --git a/fs_mgr/libdm/include/libdm/dm.h b/fs_mgr/libdm/include/libdm/dm.h
index dbef8f902b29..3e7ecc645eec 100644
--- a/fs_mgr/libdm/include/libdm/dm.h
+++ b/fs_mgr/libdm/include/libdm/dm.h
@@ -298,6 +298,8 @@ class DeviceMapper final : public IDeviceMapper {
     // a placeholder table containing dm-error.
     bool CreatePlaceholderDevice(const std::string& name);
 
+    bool GetDeviceNameAndUuid(dev_t dev, std::string* name, std::string* uuid);
+
   private:
     // Maximum possible device mapper targets registered in the kernel.
     // This is only used to read the list of targets from kernel so we allocate
diff --git a/init/devices.cpp b/init/devices.cpp
index 39442a0e8019..d29ffd604f4e 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -32,6 +32,7 @@
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
+#include <libdm/dm.h>
 #include <private/android_filesystem_config.h>
 #include <selinux/android.h>
 #include <selinux/selinux.h>
@@ -112,17 +113,14 @@ static bool FindVbdDevicePrefix(const std::string& path, std::string* result) {
 // the supplied buffer with the dm module's instantiated name.
 // If it doesn't start with a virtual block device, or there is some
 // error, return false.
-static bool FindDmDevice(const std::string& path, std::string* name, std::string* uuid) {
-    if (!StartsWith(path, "/devices/virtual/block/dm-")) return false;
+static bool FindDmDevice(const Uevent& uevent, std::string* name, std::string* uuid) {
+    if (!StartsWith(uevent.path, "/devices/virtual/block/dm-")) return false;
+    if (uevent.action == "remove") return false;  // Avoid error spam from ioctl
 
-    if (!ReadFileToString("/sys" + path + "/dm/name", name)) {
-        return false;
-    }
-    ReadFileToString("/sys" + path + "/dm/uuid", uuid);
+    dev_t dev = makedev(uevent.major, uevent.minor);
 
-    *name = android::base::Trim(*name);
-    *uuid = android::base::Trim(*uuid);
-    return true;
+    auto& dm = android::dm::DeviceMapper::Instance();
+    return dm.GetDeviceNameAndUuid(dev, name, uuid);
 }
 
 Permissions::Permissions(const std::string& name, mode_t perm, uid_t uid, gid_t gid,
@@ -392,7 +390,7 @@ std::vector<std::string> DeviceHandler::GetBlockDeviceSymlinks(const Uevent& uev
         type = "pci";
     } else if (FindVbdDevicePrefix(uevent.path, &device)) {
         type = "vbd";
-    } else if (FindDmDevice(uevent.path, &partition, &uuid)) {
+    } else if (FindDmDevice(uevent, &partition, &uuid)) {
         std::vector<std::string> symlinks = {"/dev/block/mapper/" + partition};
         if (!uuid.empty()) {
             symlinks.emplace_back("/dev/block/mapper/by-uuid/" + uuid);

From 0fa371076acfc89f6f5de999e92af4d0eccb790a Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 15 May 2023 16:43:53 -0700
Subject: [PATCH 0056/1487] libfiemap: Handle EAGAIN in fallocate().

When we changed our ENOSPC tests, it exposed a path in F2FS were
fallocate can return EAGAIN. This is expected if F2FS attempts GC to
acquire more chunks, and it can leave the file in a partially allocated
state.

As a fix, keep attempting fallocate() as long as (1) it returns EAGAIN,
and (2) the allocated size keeps growing. If (2) fails we return ENOSPC.

Bug: N/A
Test: treehugger
Change-Id: I5f867b5a200b9260e486985f203f9872a949b3f9
---
 fs_mgr/libfiemap/fiemap_writer.cpp            | 31 +++++++++++++++++--
 .../include/libfiemap/fiemap_status.h         |  3 +-
 2 files changed, 29 insertions(+), 5 deletions(-)

diff --git a/fs_mgr/libfiemap/fiemap_writer.cpp b/fs_mgr/libfiemap/fiemap_writer.cpp
index 275388ed9e47..06e210eca836 100644
--- a/fs_mgr/libfiemap/fiemap_writer.cpp
+++ b/fs_mgr/libfiemap/fiemap_writer.cpp
@@ -458,9 +458,34 @@ static FiemapStatus AllocateFile(int file_fd, const std::string& file_path, uint
             return FiemapStatus::Error();
     }
 
-    if (fallocate(file_fd, 0, 0, file_size)) {
-        PLOG(ERROR) << "Failed to allocate space for file: " << file_path << " size: " << file_size;
-        return FiemapStatus::FromErrno(errno);
+    // F2FS can return EAGAIN and partially fallocate. Keep trying to fallocate,
+    // and if we don't make forward progress, return ENOSPC.
+    std::optional<off_t> prev_size;
+    while (true) {
+        if (fallocate(file_fd, 0, 0, file_size) == 0) {
+            break;
+        }
+        if (errno != EAGAIN) {
+            PLOG(ERROR) << "Failed to allocate space for file: " << file_path
+                        << " size: " << file_size;
+            return FiemapStatus::FromErrno(errno);
+        }
+
+        struct stat s;
+        if (fstat(file_fd, &s) < 0) {
+            PLOG(ERROR) << "Failed to fstat after fallocate failure: " << file_path;
+            return FiemapStatus::FromErrno(errno);
+        }
+        if (!prev_size) {
+            prev_size = {s.st_size};
+            continue;
+        }
+        if (*prev_size >= s.st_size) {
+            LOG(ERROR) << "Fallocate retry failed, got " << s.st_size << ", asked for "
+                       << file_size;
+            return FiemapStatus(FiemapStatus::ErrorCode::NO_SPACE);
+        }
+        LOG(INFO) << "Retrying fallocate, got " << s.st_size << ", asked for " << file_size;
     }
 
     if (need_explicit_writes) {
diff --git a/fs_mgr/libfiemap/include/libfiemap/fiemap_status.h b/fs_mgr/libfiemap/include/libfiemap/fiemap_status.h
index d7b2cf18ecb7..1365ba4be54b 100644
--- a/fs_mgr/libfiemap/include/libfiemap/fiemap_status.h
+++ b/fs_mgr/libfiemap/include/libfiemap/fiemap_status.h
@@ -56,8 +56,7 @@ class FiemapStatus {
     // For logging and debugging only.
     std::string string() const;
 
-  protected:
-    FiemapStatus(ErrorCode code) : error_code_(code) {}
+    explicit FiemapStatus(ErrorCode code) : error_code_(code) {}
 
   private:
     ErrorCode error_code_;

From 16e08075bad3340832a860d90a959e9e1996a392 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Wed, 17 May 2023 23:18:48 +0000
Subject: [PATCH 0057/1487] init_kill_services_test: log state

It can be difficult to figure out where this test
is while it's executing, so I've added logs.

Bug: 280514080
Test: init_kill_services_test (w/o tradefed to avoid reboot), then:
:) adb logcat -d | grep init_kill_services_test
... I init_kill_services_test: hello lmkd!
... I init_kill_services_test: okay, now goodbye lmkd
... I init_kill_services_test: I said goodbye lmkd!
... I init_kill_services_test: are you still there lmkd?
... I init_kill_services_test: I'm done with lmkd
... I init_kill_services_test: hello ueventd!
... I init_kill_services_test: okay, now goodbye ueventd
... I init_kill_services_test: I said goodbye ueventd!
... I init_kill_services_test: are you still there ueventd?
... I init_kill_services_test: I'm done with ueventd
... I init_kill_services_test: hello hwservicemanager!
... I init_kill_services_test: okay, now goodbye hwservicemanager
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: I said goodbye hwservicemanager!
... I init_kill_services_test: are you still there hwservicemanager?
... I init_kill_services_test: I'm done with hwservicemanager
... I init_kill_services_test: hello servicemanager!
... I init_kill_services_test: okay, now goodbye servicemanager
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: I said goodbye servicemanager!
... I init_kill_services_test: are you still there servicemanager?
... I init_kill_services_test: I'm done with servicemanager

Change-Id: I2466f574fc06cdf1b01db82f89649f39b0f34345
---
 init/test_kill_services/init_kill_services_test.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/init/test_kill_services/init_kill_services_test.cpp b/init/test_kill_services/init_kill_services_test.cpp
index 53557032153f..227380d719dc 100644
--- a/init/test_kill_services/init_kill_services_test.cpp
+++ b/init/test_kill_services/init_kill_services_test.cpp
@@ -16,6 +16,7 @@
 
 #include <gtest/gtest.h>
 
+#include <android-base/logging.h>
 #include <android-base/properties.h>
 
 #include <iostream>
@@ -24,6 +25,7 @@ using ::android::base::GetProperty;
 using ::android::base::SetProperty;
 
 void ExpectKillingServiceRecovers(const std::string& service_name) {
+    LOG(INFO) << "hello " << service_name << "!";
     const std::string status_prop = "init.svc." + service_name;
     const std::string pid_prop = "init.svc_debug_pid." + service_name;
 
@@ -32,6 +34,7 @@ void ExpectKillingServiceRecovers(const std::string& service_name) {
     ASSERT_EQ("running", GetProperty(status_prop, "")) << status_prop;
     ASSERT_NE("", initial_pid) << pid_prop;
 
+    LOG(INFO) << "okay, now goodbye " << service_name;
     EXPECT_EQ(0, system(("kill -9 " + initial_pid).c_str()));
 
     constexpr size_t kMaxWaitMilliseconds = 10000;
@@ -42,11 +45,16 @@ void ExpectKillingServiceRecovers(const std::string& service_name) {
     for (size_t retry = 0; retry < kRetryTimes; retry++) {
         const std::string& pid = GetProperty(pid_prop, "");
         if (pid != initial_pid && pid != "") break;
+        LOG(INFO) << "I said goodbye " << service_name << "!";
         usleep(kRetryWaitMilliseconds * 1000);
     }
 
+    LOG(INFO) << "are you still there " << service_name << "?";
+
     // svc_debug_pid is set after svc property
     EXPECT_EQ("running", GetProperty(status_prop, ""));
+
+    LOG(INFO) << "I'm done with " << service_name;
 }
 
 class InitKillServicesTest : public ::testing::TestWithParam<std::string> {};

From eb13daf905d2a49f02a71629947f604834a0e08c Mon Sep 17 00:00:00 2001
From: Patrick Rohr <prohr@google.com>
Date: Thu, 18 May 2023 14:36:02 -0700
Subject: [PATCH 0058/1487] NetlinkEvent: use isKernel64Bit in KernelUtils.h

Now that the code has moved, delete the local implementation in favor of
the common one.

Test: builds
Change-Id: Ic29d7c9bcd3d623204f3e4de3a3434483021cbac
---
 libsysutils/Android.bp           |  4 +++
 libsysutils/src/NetlinkEvent.cpp | 56 ++------------------------------
 2 files changed, 6 insertions(+), 54 deletions(-)

diff --git a/libsysutils/Android.bp b/libsysutils/Android.bp
index 5f472b2abd2c..1b41a6b177cf 100644
--- a/libsysutils/Android.bp
+++ b/libsysutils/Android.bp
@@ -29,6 +29,10 @@ cc_library {
         "liblog",
     ],
 
+    header_libs: [
+        "bpf_headers",
+    ],
+
     export_include_dirs: ["include"],
 
     tidy: true,
diff --git a/libsysutils/src/NetlinkEvent.cpp b/libsysutils/src/NetlinkEvent.cpp
index 515cc1047cbf..cd9db54fa6f4 100644
--- a/libsysutils/src/NetlinkEvent.cpp
+++ b/libsysutils/src/NetlinkEvent.cpp
@@ -37,10 +37,12 @@
 #include <sys/utsname.h>
 
 #include <android-base/parseint.h>
+#include <bpf/KernelUtils.h>
 #include <log/log.h>
 #include <sysutils/NetlinkEvent.h>
 
 using android::base::ParseInt;
+using android::bpf::isKernel64Bit;
 
 /* From kernel's net/netfilter/xt_quota2.c */
 const int LOCAL_QLOG_NL_EVENT = 112;
@@ -138,60 +140,6 @@ static_assert(sizeof(ulog_packet_msg_t) == sizeof(ulog_packet_msg32_t) ||
 static_assert(sizeof(ulog_packet_msg32_t) == 168);
 static_assert(sizeof(ulog_packet_msg64_t) == 192);
 
-// Figure out the bitness of userspace.
-// Trivial and known at compile time.
-static bool isUserspace64bit(void) {
-    return sizeof(long) == 8;
-}
-
-// Figure out the bitness of the kernel.
-static bool isKernel64Bit(void) {
-    // a 64-bit userspace requires a 64-bit kernel
-    if (isUserspace64bit()) return true;
-
-    static bool init = false;
-    static bool cache = false;
-    if (init) return cache;
-
-    // Retrieve current personality - on Linux this system call *cannot* fail.
-    int p = personality(0xffffffff);
-    // But if it does just assume kernel and userspace (which is 32-bit) match...
-    if (p == -1) return false;
-
-    // This will effectively mask out the bottom 8 bits, and switch to 'native'
-    // personality, and then return the previous personality of this thread
-    // (likely PER_LINUX or PER_LINUX32) with any extra options unmodified.
-    int q = personality((p & ~PER_MASK) | PER_LINUX);
-    // Per man page this theoretically could error out with EINVAL,
-    // but kernel code analysis suggests setting PER_LINUX cannot fail.
-    // Either way, assume kernel and userspace (which is 32-bit) match...
-    if (q != p) return false;
-
-    struct utsname u;
-    (void)uname(&u);  // only possible failure is EFAULT, but u is on stack.
-
-    // Switch back to previous personality.
-    // Theoretically could fail with EINVAL on arm64 with no 32-bit support,
-    // but then we wouldn't have fetched 'p' from the kernel in the first place.
-    // Either way there's nothing meaningul we can do in case of error.
-    // Since PER_LINUX32 vs PER_LINUX only affects uname.machine it doesn't
-    // really hurt us either.  We're really just switching back to be 'clean'.
-    (void)personality(p);
-
-    // Possible values of utsname.machine observed on x86_64 desktop (arm via qemu):
-    //   x86_64 i686 aarch64 armv7l
-    // additionally observed on arm device:
-    //   armv8l
-    // presumably also might just be possible:
-    //   i386 i486 i586
-    // and there might be other weird arm32 cases.
-    // We note that the 64 is present in both 64-bit archs,
-    // and in general is likely to be present in only 64-bit archs.
-    cache = !!strstr(u.machine, "64");
-    init = true;
-    return cache;
-}
-
 /******************************************************************************/
 
 NetlinkEvent::NetlinkEvent() {

From 5be6ec751c88726ff809d9fa0b35a587660d36d4 Mon Sep 17 00:00:00 2001
From: Jack Wu <wjack@google.com>
Date: Thu, 13 Apr 2023 19:37:46 +0800
Subject: [PATCH 0059/1487] BatteryMonitor: support battery health
 NOT_AVAILABLE from health status

Battery health is supported but there is not enough information to
determine an accurate value  This is a temporary state.

Bug: 276400004
Test: m
Ignore-AOSP-First: cherry-pick from aosp
Change-Id: I0d422db20c51ef7e9dc4fa904729beda625c9fea
Merged-In: I0d422db20c51ef7e9dc4fa904729beda625c9fea
Signed-off-by: Jack Wu <wjack@google.com>
---
 healthd/BatteryMonitor.cpp               | 2 ++
 healthd/include/healthd/BatteryMonitor.h | 1 +
 2 files changed, 3 insertions(+)

diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index 66e1e63ef62e..f68d65a54d70 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -242,6 +242,8 @@ BatteryHealth getBatteryHealthStatus(int status) {
         value = BatteryHealth::DEAD;
     else if (status == BatteryMonitor::BH_FAILED)
         value = BatteryHealth::UNSPECIFIED_FAILURE;
+    else if (status == BatteryMonitor::BH_NOT_AVAILABLE)
+        value = BatteryHealth::NOT_AVAILABLE;
     else
         value = BatteryHealth::UNKNOWN;
 
diff --git a/healthd/include/healthd/BatteryMonitor.h b/healthd/include/healthd/BatteryMonitor.h
index 7b4f46c8abab..a4c013b86b33 100644
--- a/healthd/include/healthd/BatteryMonitor.h
+++ b/healthd/include/healthd/BatteryMonitor.h
@@ -62,6 +62,7 @@ class BatteryMonitor {
         BH_MARGINAL,
         BH_NEEDS_REPLACEMENT,
         BH_FAILED,
+        BH_NOT_AVAILABLE,
     };
 
     BatteryMonitor();

From 56abaa0959e8cf691d176517b1cea276da01a638 Mon Sep 17 00:00:00 2001
From: Frederick Mayle <fmayle@google.com>
Date: Tue, 13 Dec 2022 15:40:57 -0800
Subject: [PATCH 0060/1487] debuggerd: simplify output handling

Just noticed some opportunities while skimming.

Test: adb shell debuggerd $(adb shell pidof com.android.systemui)
Test: All unit tests pass (both 32 bit and 64 bit).
Test: Ran unit tests in a loop hundreds of times.
Change-Id: I428d0cf599ed603a21944b084b95594db893cbd5
---
 debuggerd/client/debuggerd_client.cpp |  7 +++++++
 debuggerd/debuggerd.cpp               | 28 ++++-----------------------
 2 files changed, 11 insertions(+), 24 deletions(-)

diff --git a/debuggerd/client/debuggerd_client.cpp b/debuggerd/client/debuggerd_client.cpp
index c9e097ea35b2..bd1e91d3459d 100644
--- a/debuggerd/client/debuggerd_client.cpp
+++ b/debuggerd/client/debuggerd_client.cpp
@@ -276,6 +276,13 @@ bool debuggerd_trigger_dump(pid_t tid, DebuggerdDumpType dump_type, unsigned int
       return false;
     }
 
+    // WARNING: It's not possible to replace the below with a splice call.
+    // Due to the way debuggerd does many small writes across the pipe,
+    // this would cause splice to copy a page for each write. The second
+    // pipe fills up based on the number of pages being copied, even
+    // though there is not much data being transferred per page. When
+    // the second pipe is full, everything stops since there is nothing
+    // reading the second pipe to clear it.
     char buf[1024];
     rc = TEMP_FAILURE_RETRY(read(pipe_read.get(), buf, sizeof(buf)));
     if (rc == 0) {
diff --git a/debuggerd/debuggerd.cpp b/debuggerd/debuggerd.cpp
index e20e8d9e1613..26726cf89747 100644
--- a/debuggerd/debuggerd.cpp
+++ b/debuggerd/debuggerd.cpp
@@ -41,22 +41,6 @@ static void usage(int exit_code) {
   _exit(exit_code);
 }
 
-static std::thread spawn_redirect_thread(unique_fd fd) {
-  return std::thread([fd{ std::move(fd) }]() {
-    while (true) {
-      char buf[BUFSIZ];
-      ssize_t rc = TEMP_FAILURE_RETRY(read(fd.get(), buf, sizeof(buf)));
-      if (rc <= 0) {
-        return;
-      }
-
-      if (!android::base::WriteFully(STDOUT_FILENO, buf, rc)) {
-        return;
-      }
-    }
-  });
-}
-
 int main(int argc, char* argv[]) {
   if (argc <= 1) usage(0);
   if (argc > 3) usage(1);
@@ -107,14 +91,11 @@ int main(int argc, char* argv[]) {
     }
   }
 
-  unique_fd piperead, pipewrite;
-  if (!Pipe(&piperead, &pipewrite)) {
-    err(1, "failed to create pipe");
+  unique_fd output_fd(fcntl(STDOUT_FILENO, F_DUPFD_CLOEXEC, 0));
+  if (output_fd.get() == -1) {
+    err(1, "failed to fcntl dup stdout");
   }
-
-  std::thread redirect_thread = spawn_redirect_thread(std::move(piperead));
-  if (!debuggerd_trigger_dump(proc_info.pid, dump_type, 0, std::move(pipewrite))) {
-    redirect_thread.join();
+  if (!debuggerd_trigger_dump(proc_info.pid, dump_type, 0, std::move(output_fd))) {
     if (pid == proc_info.pid) {
       errx(1, "failed to dump process %d", pid);
     } else {
@@ -122,6 +103,5 @@ int main(int argc, char* argv[]) {
     }
   }
 
-  redirect_thread.join();
   return 0;
 }

From d70a174e95d20788a8fba9795f9562ce601a6d96 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 2 May 2023 09:12:00 -0700
Subject: [PATCH 0061/1487] libsnapshot: Split CowReader into CowParserV2.

Remove format-specific logic from CowReader and split it out into a new
class called CowParserV2. To make reading the header easier, the
version and size bits are now in a separate CowHeaderPrefix struct.

Bug: 280529365
Test: apply OTA on CF
      inspect_cow
Change-Id: I29b5617ec094d4fb0c284485883d2e921a5bdbf8
---
 fs_mgr/libsnapshot/Android.bp                 |   1 +
 .../include/libsnapshot/cow_format.h          |  20 +-
 .../include/libsnapshot/cow_writer.h          |   2 +-
 .../libsnapshot_cow/cow_api_test.cpp          |  18 +-
 .../libsnapshot_cow/cow_reader.cpp            | 226 +----------------
 .../libsnapshot_cow/cow_writer.cpp            |  23 +-
 .../libsnapshot_cow/inspect_cow.cpp           |   5 +-
 .../libsnapshot/libsnapshot_cow/parser_v2.cpp | 238 ++++++++++++++++++
 .../libsnapshot/libsnapshot_cow/parser_v2.h   |  55 ++++
 .../snapuserd/dm-snapshot-merge/snapuserd.cpp |  10 +-
 .../user-space-merge/snapuserd_core.cpp       |  10 +-
 11 files changed, 342 insertions(+), 266 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index d3bd904dcb00..cba68446792a 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -179,6 +179,7 @@ cc_library_static {
         "libsnapshot_cow/cow_writer.cpp",
         "libsnapshot_cow/cow_format.cpp",
         "libsnapshot_cow/cow_compress.cpp",
+        "libsnapshot_cow/parser_v2.cpp",
     ],
     host_supported: true,
     recovery_available: true,
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index c3ca00ae034e..9f9469910dbd 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -52,13 +52,15 @@ static constexpr uint32_t kCowVersionManifest = 2;
 // between writing the last operation/data pair, or the footer itself. In this
 // case, the safest way to proceed is to assume the last operation is faulty.
 
-struct CowHeader {
+struct CowHeaderPrefix {
     uint64_t magic;
     uint16_t major_version;
     uint16_t minor_version;
+    uint16_t header_size;  // size of CowHeader.
+} __attribute__((packed));
 
-    // Size of this struct.
-    uint16_t header_size;
+struct CowHeader {
+    CowHeaderPrefix prefix;
 
     // Size of footer struct
     uint16_t footer_size;
@@ -88,7 +90,7 @@ struct CowFooterOperation {
     // the compression type of that data (see constants below).
     uint8_t compression;
 
-    // Length of Footer Data. Currently 64 for both checksums
+    // Length of Footer Data. Currently 64.
     uint16_t data_length;
 
     // The amount of file space used by Cow operations
@@ -98,14 +100,6 @@ struct CowFooterOperation {
     uint64_t num_ops;
 } __attribute__((packed));
 
-struct CowFooterData {
-    // SHA256 checksums of Footer op
-    uint8_t footer_checksum[32];
-
-    // SHA256 of the operation sequence.
-    uint8_t ops_checksum[32];
-} __attribute__((packed));
-
 // Cow operations are currently fixed-size entries, but this may change if
 // needed.
 struct CowOperation {
@@ -167,7 +161,7 @@ static constexpr uint8_t kCowReadAheadDone = 2;
 
 struct CowFooter {
     CowFooterOperation op;
-    CowFooterData data;
+    uint8_t unused[64];
 } __attribute__((packed));
 
 struct ScratchMetadata {
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index c7b83a8386f5..4151b0121cba 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -171,7 +171,7 @@ class CowWriter : public ICowWriter {
 
     uint64_t GetCowSize() override;
 
-    uint32_t GetCowVersion() { return header_.major_version; }
+    uint32_t GetCowVersion() { return header_.prefix.major_version; }
 
   protected:
     virtual bool EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) override;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_api_test.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_api_test.cpp
index edc9d65b230a..8f80bb34533b 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_api_test.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_api_test.cpp
@@ -65,9 +65,9 @@ TEST_F(CowTest, CopyContiguous) {
     ASSERT_TRUE(reader.Parse(cow_->fd));
 
     const auto& header = reader.GetHeader();
-    ASSERT_EQ(header.magic, kCowMagicNumber);
-    ASSERT_EQ(header.major_version, kCowVersionMajor);
-    ASSERT_EQ(header.minor_version, kCowVersionMinor);
+    ASSERT_EQ(header.prefix.magic, kCowMagicNumber);
+    ASSERT_EQ(header.prefix.major_version, kCowVersionMajor);
+    ASSERT_EQ(header.prefix.minor_version, kCowVersionMinor);
     ASSERT_EQ(header.block_size, options.block_size);
 
     CowFooter footer;
@@ -114,9 +114,9 @@ TEST_F(CowTest, ReadWrite) {
     ASSERT_TRUE(reader.Parse(cow_->fd));
 
     const auto& header = reader.GetHeader();
-    ASSERT_EQ(header.magic, kCowMagicNumber);
-    ASSERT_EQ(header.major_version, kCowVersionMajor);
-    ASSERT_EQ(header.minor_version, kCowVersionMinor);
+    ASSERT_EQ(header.prefix.magic, kCowMagicNumber);
+    ASSERT_EQ(header.prefix.major_version, kCowVersionMajor);
+    ASSERT_EQ(header.prefix.minor_version, kCowVersionMinor);
     ASSERT_EQ(header.block_size, options.block_size);
 
     CowFooter footer;
@@ -193,9 +193,9 @@ TEST_F(CowTest, ReadWriteXor) {
     ASSERT_TRUE(reader.Parse(cow_->fd));
 
     const auto& header = reader.GetHeader();
-    ASSERT_EQ(header.magic, kCowMagicNumber);
-    ASSERT_EQ(header.major_version, kCowVersionMajor);
-    ASSERT_EQ(header.minor_version, kCowVersionMinor);
+    ASSERT_EQ(header.prefix.magic, kCowMagicNumber);
+    ASSERT_EQ(header.prefix.major_version, kCowVersionMajor);
+    ASSERT_EQ(header.prefix.minor_version, kCowVersionMinor);
     ASSERT_EQ(header.block_size, options.block_size);
 
     CowFooter footer;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 6749cf1b0363..c2a7fdb39519 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -30,7 +30,7 @@
 #include <zlib.h>
 
 #include "cow_decompress.h"
-#include "libsnapshot/cow_format.h"
+#include "parser_v2.h"
 
 namespace android {
 namespace snapshot {
@@ -43,15 +43,6 @@ CowReader::CowReader(ReaderFlags reader_flag, bool is_merge)
       reader_flag_(reader_flag),
       is_merge_(is_merge) {}
 
-static void SHA256(const void*, size_t, uint8_t[]) {
-#if 0
-    SHA256_CTX c;
-    SHA256_Init(&c);
-    SHA256_Update(&c, data, length);
-    SHA256_Final(out, &c);
-#endif
-}
-
 std::unique_ptr<CowReader> CowReader::CloneCowReader() {
     auto cow = std::make_unique<CowReader>();
     cow->owned_fd_.reset();
@@ -63,7 +54,6 @@ std::unique_ptr<CowReader> CowReader::CloneCowReader() {
     cow->merge_op_start_ = merge_op_start_;
     cow->num_total_data_ops_ = num_total_data_ops_;
     cow->num_ordered_ops_to_merge_ = num_ordered_ops_to_merge_;
-    cow->has_seq_ops_ = has_seq_ops_;
     cow->data_loc_ = data_loc_;
     cow->block_pos_index_ = block_pos_index_;
     cow->is_merge_ = is_merge_;
@@ -101,217 +91,26 @@ bool CowReader::Parse(android::base::unique_fd&& fd, std::optional<uint64_t> lab
 bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> label) {
     fd_ = fd;
 
-    auto pos = lseek(fd_.get(), 0, SEEK_END);
-    if (pos < 0) {
-        PLOG(ERROR) << "lseek end failed";
-        return false;
-    }
-    fd_size_ = pos;
-
-    if (lseek(fd_.get(), 0, SEEK_SET) < 0) {
-        PLOG(ERROR) << "lseek header failed";
-        return false;
-    }
-    if (!android::base::ReadFully(fd_, &header_, sizeof(header_))) {
-        PLOG(ERROR) << "read header failed";
+    if (!ReadCowHeader(fd, &header_)) {
         return false;
     }
 
-    if (header_.magic != kCowMagicNumber) {
-        LOG(ERROR) << "Header Magic corrupted. Magic: " << header_.magic
-                   << "Expected: " << kCowMagicNumber;
-        return false;
-    }
-    if (header_.footer_size != sizeof(CowFooter)) {
-        LOG(ERROR) << "Footer size unknown, read " << header_.footer_size << ", expected "
-                   << sizeof(CowFooter);
-        return false;
-    }
-    if (header_.op_size != sizeof(CowOperation)) {
-        LOG(ERROR) << "Operation size unknown, read " << header_.op_size << ", expected "
-                   << sizeof(CowOperation);
-        return false;
-    }
-    if (header_.cluster_ops == 1) {
-        LOG(ERROR) << "Clusters must contain at least two operations to function.";
-        return false;
-    }
-    if (header_.op_size != sizeof(CowOperation)) {
-        LOG(ERROR) << "Operation size unknown, read " << header_.op_size << ", expected "
-                   << sizeof(CowOperation);
-        return false;
-    }
-    if (header_.cluster_ops == 1) {
-        LOG(ERROR) << "Clusters must contain at least two operations to function.";
+    CowParserV2 parser;
+    if (!parser.Parse(fd, header_, label)) {
         return false;
     }
 
-    if ((header_.major_version > kCowVersionMajor) || (header_.minor_version != kCowVersionMinor)) {
-        LOG(ERROR) << "Header version mismatch";
-        LOG(ERROR) << "Major version: " << header_.major_version
-                   << "Expected: " << kCowVersionMajor;
-        LOG(ERROR) << "Minor version: " << header_.minor_version
-                   << "Expected: " << kCowVersionMinor;
-        return false;
-    }
+    footer_ = parser.footer();
+    fd_size_ = parser.fd_size();
+    last_label_ = parser.last_label();
+    ops_ = std::move(parser.ops());
+    data_loc_ = parser.data_loc();
 
-    if (!ParseOps(label)) {
-        return false;
-    }
     // If we're resuming a write, we're not ready to merge
     if (label.has_value()) return true;
     return PrepMergeOps();
 }
 
-bool CowReader::ParseOps(std::optional<uint64_t> label) {
-    uint64_t pos;
-    auto data_loc = std::make_shared<std::unordered_map<uint64_t, uint64_t>>();
-
-    // Skip the scratch space
-    if (header_.major_version >= 2 && (header_.buffer_size > 0)) {
-        LOG(DEBUG) << " Scratch space found of size: " << header_.buffer_size;
-        size_t init_offset = header_.header_size + header_.buffer_size;
-        pos = lseek(fd_.get(), init_offset, SEEK_SET);
-        if (pos != init_offset) {
-            PLOG(ERROR) << "lseek ops failed";
-            return false;
-        }
-    } else {
-        pos = lseek(fd_.get(), header_.header_size, SEEK_SET);
-        if (pos != header_.header_size) {
-            PLOG(ERROR) << "lseek ops failed";
-            return false;
-        }
-        // Reading a v1 version of COW which doesn't have buffer_size.
-        header_.buffer_size = 0;
-    }
-    uint64_t data_pos = 0;
-
-    if (header_.cluster_ops) {
-        data_pos = pos + header_.cluster_ops * sizeof(CowOperation);
-    } else {
-        data_pos = pos + sizeof(CowOperation);
-    }
-
-    auto ops_buffer = std::make_shared<std::vector<CowOperation>>();
-    uint64_t current_op_num = 0;
-    uint64_t cluster_ops = header_.cluster_ops ?: 1;
-    bool done = false;
-
-    // Alternating op clusters and data
-    while (!done) {
-        uint64_t to_add = std::min(cluster_ops, (fd_size_ - pos) / sizeof(CowOperation));
-        if (to_add == 0) break;
-        ops_buffer->resize(current_op_num + to_add);
-        if (!android::base::ReadFully(fd_, &ops_buffer->data()[current_op_num],
-                                      to_add * sizeof(CowOperation))) {
-            PLOG(ERROR) << "read op failed";
-            return false;
-        }
-        // Parse current cluster to find start of next cluster
-        while (current_op_num < ops_buffer->size()) {
-            auto& current_op = ops_buffer->data()[current_op_num];
-            current_op_num++;
-            if (current_op.type == kCowXorOp) {
-                data_loc->insert({current_op.new_block, data_pos});
-            }
-            pos += sizeof(CowOperation) + GetNextOpOffset(current_op, header_.cluster_ops);
-            data_pos += current_op.data_length + GetNextDataOffset(current_op, header_.cluster_ops);
-
-            if (current_op.type == kCowClusterOp) {
-                break;
-            } else if (current_op.type == kCowLabelOp) {
-                last_label_ = {current_op.source};
-
-                // If we reach the requested label, stop reading.
-                if (label && label.value() == current_op.source) {
-                    done = true;
-                    break;
-                }
-            } else if (current_op.type == kCowFooterOp) {
-                footer_.emplace();
-                CowFooter* footer = &footer_.value();
-                memcpy(&footer_->op, &current_op, sizeof(footer->op));
-                off_t offs = lseek(fd_.get(), pos, SEEK_SET);
-                if (offs < 0 || pos != static_cast<uint64_t>(offs)) {
-                    PLOG(ERROR) << "lseek next op failed " << offs;
-                    return false;
-                }
-                if (!android::base::ReadFully(fd_, &footer->data, sizeof(footer->data))) {
-                    LOG(ERROR) << "Could not read COW footer";
-                    return false;
-                }
-
-                // Drop the footer from the op stream.
-                current_op_num--;
-                done = true;
-                break;
-            } else if (current_op.type == kCowSequenceOp) {
-                has_seq_ops_ = true;
-            }
-        }
-
-        // Position for next cluster read
-        off_t offs = lseek(fd_.get(), pos, SEEK_SET);
-        if (offs < 0 || pos != static_cast<uint64_t>(offs)) {
-            PLOG(ERROR) << "lseek next op failed " << offs;
-            return false;
-        }
-        ops_buffer->resize(current_op_num);
-    }
-
-    LOG(DEBUG) << "COW file read complete. Total ops: " << ops_buffer->size();
-    // To successfully parse a COW file, we need either:
-    //  (1) a label to read up to, and for that label to be found, or
-    //  (2) a valid footer.
-    if (label) {
-        if (!last_label_) {
-            LOG(ERROR) << "Did not find label " << label.value()
-                       << " while reading COW (no labels found)";
-            return false;
-        }
-        if (last_label_.value() != label.value()) {
-            LOG(ERROR) << "Did not find label " << label.value()
-                       << ", last label=" << last_label_.value();
-            return false;
-        }
-    } else if (!footer_) {
-        LOG(ERROR) << "No COW footer found";
-        return false;
-    }
-
-    uint8_t csum[32];
-    memset(csum, 0, sizeof(uint8_t) * 32);
-
-    if (footer_) {
-        if (ops_buffer->size() != footer_->op.num_ops) {
-            LOG(ERROR) << "num ops does not match, expected " << footer_->op.num_ops << ", found "
-                       << ops_buffer->size();
-            return false;
-        }
-        if (ops_buffer->size() * sizeof(CowOperation) != footer_->op.ops_size) {
-            LOG(ERROR) << "ops size does not match ";
-            return false;
-        }
-        SHA256(&footer_->op, sizeof(footer_->op), footer_->data.footer_checksum);
-        if (memcmp(csum, footer_->data.ops_checksum, sizeof(csum)) != 0) {
-            LOG(ERROR) << "ops checksum does not match";
-            return false;
-        }
-        SHA256(ops_buffer->data(), footer_->op.ops_size, csum);
-        if (memcmp(csum, footer_->data.ops_checksum, sizeof(csum)) != 0) {
-            LOG(ERROR) << "ops checksum does not match";
-            return false;
-        }
-    }
-
-    ops_ = ops_buffer;
-    ops_->shrink_to_fit();
-    data_loc_ = data_loc;
-
-    return true;
-}
-
 //
 // This sets up the data needed for MergeOpIter. MergeOpIter presents
 // data in the order we intend to merge in.
@@ -446,7 +245,8 @@ bool CowReader::PrepMergeOps() {
             continue;
         }
 
-        if (!has_seq_ops_ && IsOrderedOp(current_op)) {
+        // Sequence ops must be the first ops in the stream.
+        if (seq_ops_set.empty() && IsOrderedOp(current_op)) {
             merge_op_blocks->emplace_back(current_op.new_block);
         } else if (seq_ops_set.count(current_op.new_block) == 0) {
             other_ops.push_back(current_op.new_block);
@@ -718,8 +518,8 @@ std::unique_ptr<ICowOpIter> CowReader::GetMergeOpIter(bool ignore_progress) {
 
 bool CowReader::GetRawBytes(uint64_t offset, void* buffer, size_t len, size_t* read) {
     // Validate the offset, taking care to acknowledge possible overflow of offset+len.
-    if (offset < header_.header_size || offset >= fd_size_ - sizeof(CowFooter) || len >= fd_size_ ||
-        offset + len > fd_size_ - sizeof(CowFooter)) {
+    if (offset < header_.prefix.header_size || offset >= fd_size_ - sizeof(CowFooter) ||
+        len >= fd_size_ || offset + len > fd_size_ - sizeof(CowFooter)) {
         LOG(ERROR) << "invalid data offset: " << offset << ", " << len << " bytes";
         return false;
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_writer.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_writer.cpp
index 0e189794713e..1eaa0385ee26 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_writer.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_writer.cpp
@@ -186,10 +186,10 @@ void CowWriter::SetupWriteOptions() {
 
 void CowWriter::SetupHeaders() {
     header_ = {};
-    header_.magic = kCowMagicNumber;
-    header_.major_version = kCowVersionMajor;
-    header_.minor_version = kCowVersionMinor;
-    header_.header_size = sizeof(CowHeader);
+    header_.prefix.magic = kCowMagicNumber;
+    header_.prefix.major_version = kCowVersionMajor;
+    header_.prefix.minor_version = kCowVersionMinor;
+    header_.prefix.header_size = sizeof(CowHeader);
     header_.footer_size = sizeof(CowFooter);
     header_.op_size = sizeof(CowOperation);
     header_.block_size = options_.block_size;
@@ -614,17 +614,6 @@ bool CowWriter::EmitClusterIfNeeded() {
     return true;
 }
 
-// TODO: Fix compilation issues when linking libcrypto library
-// when snapuserd is compiled as part of ramdisk.
-static void SHA256(const void*, size_t, uint8_t[]) {
-#if 0
-    SHA256_CTX c;
-    SHA256_Init(&c);
-    SHA256_Update(&c, data, length);
-    SHA256_Final(out, &c);
-#endif
-}
-
 bool CowWriter::Finalize() {
     if (!FlushCluster()) {
         LOG(ERROR) << "Finalize: FlushCluster() failed";
@@ -665,10 +654,8 @@ bool CowWriter::Finalize() {
         PLOG(ERROR) << "Failed to seek to footer position.";
         return false;
     }
-    memset(&footer_.data.ops_checksum, 0, sizeof(uint8_t) * 32);
-    memset(&footer_.data.footer_checksum, 0, sizeof(uint8_t) * 32);
+    memset(&footer_.unused, 0, sizeof(footer_.unused));
 
-    SHA256(&footer_.op, sizeof(footer_.op), footer_.data.footer_checksum);
     // Write out footer at end of file
     if (!android::base::WriteFully(fd_, reinterpret_cast<const uint8_t*>(&footer_),
                                    sizeof(footer_))) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
index 917cec4242b3..c2c86eefdda3 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
@@ -104,8 +104,9 @@ static bool Inspect(const std::string& path, Options opt) {
     if (reader.GetFooter(&footer)) has_footer = true;
 
     if (!opt.silent) {
-        std::cout << "Version: " << header.major_version << "." << header.minor_version << "\n";
-        std::cout << "Header size: " << header.header_size << "\n";
+        std::cout << "Version: " << header.prefix.major_version << "."
+                  << header.prefix.minor_version << "\n";
+        std::cout << "Header size: " << header.prefix.header_size << "\n";
         std::cout << "Footer size: " << header.footer_size << "\n";
         std::cout << "Block size: " << header.block_size << "\n";
         std::cout << "Merge ops: " << header.num_merge_ops << "\n";
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
new file mode 100644
index 000000000000..fdb5c5911d1c
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
@@ -0,0 +1,238 @@
+// Copyright (C) 2023 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 "parser_v2.h"
+
+#include <unistd.h>
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+
+namespace android {
+namespace snapshot {
+
+using android::base::borrowed_fd;
+
+bool ReadCowHeader(android::base::borrowed_fd fd, CowHeader* header) {
+    if (lseek(fd.get(), 0, SEEK_SET) < 0) {
+        PLOG(ERROR) << "lseek header failed";
+        return false;
+    }
+
+    memset(header, 0, sizeof(*header));
+
+    if (!android::base::ReadFully(fd, &header->prefix, sizeof(header->prefix))) {
+        return false;
+    }
+    if (header->prefix.magic != kCowMagicNumber) {
+        LOG(ERROR) << "Header Magic corrupted. Magic: " << header->prefix.magic
+                   << "Expected: " << kCowMagicNumber;
+        return false;
+    }
+    if (header->prefix.header_size > sizeof(CowHeader)) {
+        LOG(ERROR) << "Unknown CowHeader size (got " << header->prefix.header_size
+                   << " bytes, expected at most " << sizeof(CowHeader) << " bytes)";
+        return false;
+    }
+
+    if (lseek(fd.get(), 0, SEEK_SET) < 0) {
+        PLOG(ERROR) << "lseek header failed";
+        return false;
+    }
+    return android::base::ReadFully(fd, header, header->prefix.header_size);
+}
+
+bool CowParserV2::Parse(borrowed_fd fd, const CowHeader& header, std::optional<uint64_t> label) {
+    auto pos = lseek(fd.get(), 0, SEEK_END);
+    if (pos < 0) {
+        PLOG(ERROR) << "lseek end failed";
+        return false;
+    }
+    fd_size_ = pos;
+    header_ = header;
+
+    if (header_.footer_size != sizeof(CowFooter)) {
+        LOG(ERROR) << "Footer size unknown, read " << header_.footer_size << ", expected "
+                   << sizeof(CowFooter);
+        return false;
+    }
+    if (header_.op_size != sizeof(CowOperation)) {
+        LOG(ERROR) << "Operation size unknown, read " << header_.op_size << ", expected "
+                   << sizeof(CowOperation);
+        return false;
+    }
+    if (header_.cluster_ops == 1) {
+        LOG(ERROR) << "Clusters must contain at least two operations to function.";
+        return false;
+    }
+    if (header_.op_size != sizeof(CowOperation)) {
+        LOG(ERROR) << "Operation size unknown, read " << header_.op_size << ", expected "
+                   << sizeof(CowOperation);
+        return false;
+    }
+    if (header_.cluster_ops == 1) {
+        LOG(ERROR) << "Clusters must contain at least two operations to function.";
+        return false;
+    }
+
+    if ((header_.prefix.major_version > kCowVersionMajor) ||
+        (header_.prefix.minor_version != kCowVersionMinor)) {
+        LOG(ERROR) << "Header version mismatch, "
+                   << "major version: " << header_.prefix.major_version
+                   << ", expected: " << kCowVersionMajor
+                   << ", minor version: " << header_.prefix.minor_version
+                   << ", expected: " << kCowVersionMinor;
+        return false;
+    }
+
+    return ParseOps(fd, label);
+}
+
+bool CowParserV2::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
+    uint64_t pos;
+    auto data_loc = std::make_shared<std::unordered_map<uint64_t, uint64_t>>();
+
+    // Skip the scratch space
+    if (header_.prefix.major_version >= 2 && (header_.buffer_size > 0)) {
+        LOG(DEBUG) << " Scratch space found of size: " << header_.buffer_size;
+        size_t init_offset = header_.prefix.header_size + header_.buffer_size;
+        pos = lseek(fd.get(), init_offset, SEEK_SET);
+        if (pos != init_offset) {
+            PLOG(ERROR) << "lseek ops failed";
+            return false;
+        }
+    } else {
+        pos = lseek(fd.get(), header_.prefix.header_size, SEEK_SET);
+        if (pos != header_.prefix.header_size) {
+            PLOG(ERROR) << "lseek ops failed";
+            return false;
+        }
+        // Reading a v1 version of COW which doesn't have buffer_size.
+        header_.buffer_size = 0;
+    }
+    uint64_t data_pos = 0;
+
+    if (header_.cluster_ops) {
+        data_pos = pos + header_.cluster_ops * sizeof(CowOperation);
+    } else {
+        data_pos = pos + sizeof(CowOperation);
+    }
+
+    auto ops_buffer = std::make_shared<std::vector<CowOperation>>();
+    uint64_t current_op_num = 0;
+    uint64_t cluster_ops = header_.cluster_ops ?: 1;
+    bool done = false;
+
+    // Alternating op clusters and data
+    while (!done) {
+        uint64_t to_add = std::min(cluster_ops, (fd_size_ - pos) / sizeof(CowOperation));
+        if (to_add == 0) break;
+        ops_buffer->resize(current_op_num + to_add);
+        if (!android::base::ReadFully(fd, &ops_buffer->data()[current_op_num],
+                                      to_add * sizeof(CowOperation))) {
+            PLOG(ERROR) << "read op failed";
+            return false;
+        }
+        // Parse current cluster to find start of next cluster
+        while (current_op_num < ops_buffer->size()) {
+            auto& current_op = ops_buffer->data()[current_op_num];
+            current_op_num++;
+            if (current_op.type == kCowXorOp) {
+                data_loc->insert({current_op.new_block, data_pos});
+            }
+            pos += sizeof(CowOperation) + GetNextOpOffset(current_op, header_.cluster_ops);
+            data_pos += current_op.data_length + GetNextDataOffset(current_op, header_.cluster_ops);
+
+            if (current_op.type == kCowClusterOp) {
+                break;
+            } else if (current_op.type == kCowLabelOp) {
+                last_label_ = {current_op.source};
+
+                // If we reach the requested label, stop reading.
+                if (label && label.value() == current_op.source) {
+                    done = true;
+                    break;
+                }
+            } else if (current_op.type == kCowFooterOp) {
+                footer_.emplace();
+                CowFooter* footer = &footer_.value();
+                memcpy(&footer_->op, &current_op, sizeof(footer->op));
+                off_t offs = lseek(fd.get(), pos, SEEK_SET);
+                if (offs < 0 || pos != static_cast<uint64_t>(offs)) {
+                    PLOG(ERROR) << "lseek next op failed " << offs;
+                    return false;
+                }
+                if (!android::base::ReadFully(fd, &footer->unused, sizeof(footer->unused))) {
+                    LOG(ERROR) << "Could not read COW footer";
+                    return false;
+                }
+
+                // Drop the footer from the op stream.
+                current_op_num--;
+                done = true;
+                break;
+            }
+        }
+
+        // Position for next cluster read
+        off_t offs = lseek(fd.get(), pos, SEEK_SET);
+        if (offs < 0 || pos != static_cast<uint64_t>(offs)) {
+            PLOG(ERROR) << "lseek next op failed " << offs;
+            return false;
+        }
+        ops_buffer->resize(current_op_num);
+    }
+
+    LOG(DEBUG) << "COW file read complete. Total ops: " << ops_buffer->size();
+    // To successfully parse a COW file, we need either:
+    //  (1) a label to read up to, and for that label to be found, or
+    //  (2) a valid footer.
+    if (label) {
+        if (!last_label_) {
+            LOG(ERROR) << "Did not find label " << label.value()
+                       << " while reading COW (no labels found)";
+            return false;
+        }
+        if (last_label_.value() != label.value()) {
+            LOG(ERROR) << "Did not find label " << label.value()
+                       << ", last label=" << last_label_.value();
+            return false;
+        }
+    } else if (!footer_) {
+        LOG(ERROR) << "No COW footer found";
+        return false;
+    }
+
+    uint8_t csum[32];
+    memset(csum, 0, sizeof(uint8_t) * 32);
+
+    if (footer_) {
+        if (ops_buffer->size() != footer_->op.num_ops) {
+            LOG(ERROR) << "num ops does not match, expected " << footer_->op.num_ops << ", found "
+                       << ops_buffer->size();
+            return false;
+        }
+        if (ops_buffer->size() * sizeof(CowOperation) != footer_->op.ops_size) {
+            LOG(ERROR) << "ops size does not match ";
+            return false;
+        }
+    }
+
+    ops_ = ops_buffer;
+    ops_->shrink_to_fit();
+    data_loc_ = data_loc;
+    return true;
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
new file mode 100644
index 000000000000..afcf687fd67a
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
@@ -0,0 +1,55 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <stdint.h>
+
+#include <memory>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+#include <android-base/unique_fd.h>
+#include <libsnapshot/cow_format.h>
+
+namespace android {
+namespace snapshot {
+
+class CowParserV2 {
+  public:
+    bool Parse(android::base::borrowed_fd fd, const CowHeader& header,
+               std::optional<uint64_t> label = {});
+
+    const CowHeader& header() const { return header_; }
+    const std::optional<CowFooter>& footer() const { return footer_; }
+    std::shared_ptr<std::vector<CowOperation>> ops() { return ops_; }
+    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const { return data_loc_; }
+    uint64_t fd_size() const { return fd_size_; }
+    const std::optional<uint64_t>& last_label() const { return last_label_; }
+
+  private:
+    bool ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label);
+
+    CowHeader header_ = {};
+    std::optional<CowFooter> footer_;
+    std::shared_ptr<std::vector<CowOperation>> ops_;
+    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
+    uint64_t fd_size_;
+    std::optional<uint64_t> last_label_;
+};
+
+bool ReadCowHeader(android::base::borrowed_fd fd, CowHeader* header);
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
index efa43b79d03e..da9bd113f6d4 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
@@ -628,8 +628,8 @@ bool Snapuserd::ReadMetadata() {
 bool Snapuserd::MmapMetadata() {
     const auto& header = reader_->GetHeader();
 
-    if (header.major_version >= 2 && header.buffer_size > 0) {
-        total_mapped_addr_length_ = header.header_size + BUFFER_REGION_DEFAULT_SIZE;
+    if (header.prefix.major_version >= 2 && header.buffer_size > 0) {
+        total_mapped_addr_length_ = header.prefix.header_size + BUFFER_REGION_DEFAULT_SIZE;
         read_ahead_feature_ = true;
     } else {
         // mmap the first 4k page - older COW format
@@ -823,7 +823,7 @@ bool Snapuserd::Start() {
 uint64_t Snapuserd::GetBufferMetadataOffset() {
     const auto& header = reader_->GetHeader();
 
-    size_t size = header.header_size + sizeof(BufferState);
+    size_t size = header.prefix.header_size + sizeof(BufferState);
     return size;
 }
 
@@ -845,7 +845,7 @@ size_t Snapuserd::GetBufferMetadataSize() {
 size_t Snapuserd::GetBufferDataOffset() {
     const auto& header = reader_->GetHeader();
 
-    return (header.header_size + GetBufferMetadataSize());
+    return (header.prefix.header_size + GetBufferMetadataSize());
 }
 
 /*
@@ -862,7 +862,7 @@ struct BufferState* Snapuserd::GetBufferState() {
     const auto& header = reader_->GetHeader();
 
     struct BufferState* ra_state =
-            reinterpret_cast<struct BufferState*>((char*)mapped_addr_ + header.header_size);
+            reinterpret_cast<struct BufferState*>((char*)mapped_addr_ + header.prefix.header_size);
     return ra_state;
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index a51963985381..c3343b8c642a 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -240,9 +240,9 @@ bool SnapshotHandler::ReadMetadata() {
 bool SnapshotHandler::MmapMetadata() {
     const auto& header = reader_->GetHeader();
 
-    total_mapped_addr_length_ = header.header_size + BUFFER_REGION_DEFAULT_SIZE;
+    total_mapped_addr_length_ = header.prefix.header_size + BUFFER_REGION_DEFAULT_SIZE;
 
-    if (header.major_version >= 2 && header.buffer_size > 0) {
+    if (header.prefix.major_version >= 2 && header.buffer_size > 0) {
         scratch_space_ = true;
     }
 
@@ -362,7 +362,7 @@ bool SnapshotHandler::Start() {
 uint64_t SnapshotHandler::GetBufferMetadataOffset() {
     const auto& header = reader_->GetHeader();
 
-    return (header.header_size + sizeof(BufferState));
+    return (header.prefix.header_size + sizeof(BufferState));
 }
 
 /*
@@ -390,7 +390,7 @@ size_t SnapshotHandler::GetBufferMetadataSize() {
 size_t SnapshotHandler::GetBufferDataOffset() {
     const auto& header = reader_->GetHeader();
 
-    return (header.header_size + GetBufferMetadataSize());
+    return (header.prefix.header_size + GetBufferMetadataSize());
 }
 
 /*
@@ -413,7 +413,7 @@ struct BufferState* SnapshotHandler::GetBufferState() {
     const auto& header = reader_->GetHeader();
 
     struct BufferState* ra_state =
-            reinterpret_cast<struct BufferState*>((char*)mapped_addr_ + header.header_size);
+            reinterpret_cast<struct BufferState*>((char*)mapped_addr_ + header.prefix.header_size);
     return ra_state;
 }
 

From 85c65e98cd7ec5f774f1f874d86aebdd2bfe59dd Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 8 May 2023 14:48:45 -0700
Subject: [PATCH 0062/1487] libsnapshot: Remove unused SupportsCopyOperation.

This function is never used. It was intended to allow update_engine to
unify all writes through ISnapshotWriter, but that never came to pass.

Bug: 280529365
Test: builds
Change-Id: I7e418ffee404cd63faa5a5659d8971988f8d0e03
---
 fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h           | 3 ---
 fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot_writer.h | 3 ---
 2 files changed, 6 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 8458517994fe..7881f35099dd 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -93,9 +93,6 @@ class ICowWriter {
     // Return number of bytes the cow image occupies on disk.
     virtual uint64_t GetCowSize() = 0;
 
-    // Returns true if AddCopy() operations are supported.
-    virtual bool SupportsCopyOperation() const { return true; }
-
     const CowOptions& options() { return options_; }
 
   protected:
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot_writer.h
index 29828bcfba63..d798e25e3c4c 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot_writer.h
@@ -31,9 +31,6 @@ class MockSnapshotWriter : public ISnapshotWriter {
     // Return number of bytes the cow image occupies on disk.
     MOCK_METHOD(uint64_t, GetCowSize, (), (override));
 
-    // Returns true if AddCopy() operations are supported.
-    MOCK_METHOD(bool, SupportsCopyOperation, (), (const override));
-
     MOCK_METHOD(bool, EmitCopy, (uint64_t, uint64_t, uint64_t), (override));
     MOCK_METHOD(bool, EmitRawBlocks, (uint64_t, const void*, size_t), (override));
     MOCK_METHOD(bool, EmitXorBlocks, (uint32_t, const void*, size_t, uint32_t, uint16_t),

From 0ec7115779ff9002353c31b82d4b4a75c15599b5 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 4 May 2023 09:39:58 -0700
Subject: [PATCH 0063/1487] libsnapshot: Reject bad cow versions.

Remove CowWriter::GetCowVersion. Instead, reject any update that asks
for VABC but has an unsupported version field. Do not fallback to legacy
VAB as the update was likely built improperly.

Bug: 280529365
Test: vts_libsnapshot_test
Change-Id: Ibc0f981801fd47bf39d7a19944134e4b3c66e5bf
---
 .../include/libsnapshot/cow_format.h          |  3 ++
 .../include/libsnapshot/cow_writer.h          |  2 -
 fs_mgr/libsnapshot/snapshot.cpp               | 40 +++++++++----------
 fs_mgr/libsnapshot/snapshot_test.cpp          | 18 +++++++++
 4 files changed, 39 insertions(+), 24 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 9f9469910dbd..b228dff8d72c 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -28,6 +28,9 @@ static constexpr uint32_t kCowVersionMinor = 0;
 
 static constexpr uint32_t kCowVersionManifest = 2;
 
+static constexpr uint32_t kMinCowVersion = 1;
+static constexpr uint32_t kMaxCowVersion = 2;
+
 // This header appears as the first sequence of bytes in the COW. All fields
 // in the layout are little-endian encoded. The on-disk layout is:
 //
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 4151b0121cba..8458517994fe 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -171,8 +171,6 @@ class CowWriter : public ICowWriter {
 
     uint64_t GetCowSize() override;
 
-    uint32_t GetCowVersion() { return header_.prefix.major_version; }
-
   protected:
     virtual bool EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) override;
     virtual bool EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) override;
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 26614827ba64..b0c4a8371e01 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -3202,39 +3202,20 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
     CHECK(current_metadata->GetBlockDevicePartitionName(0) == LP_METADATA_DEFAULT_PARTITION_NAME &&
           target_metadata->GetBlockDevicePartitionName(0) == LP_METADATA_DEFAULT_PARTITION_NAME);
 
-    std::map<std::string, SnapshotStatus> all_snapshot_status;
-
-    // In case of error, automatically delete devices that are created along the way.
-    // Note that "lock" is destroyed after "created_devices", so it is safe to use |lock| for
-    // these devices.
-    AutoDeviceList created_devices;
-
     const auto& dap_metadata = manifest.dynamic_partition_metadata();
-    CowOptions options;
-    CowWriter writer(options);
-    bool cow_format_support = true;
-    if (dap_metadata.cow_version() < writer.GetCowVersion()) {
-        cow_format_support = false;
-    }
-
-    LOG(INFO) << " dap_metadata.cow_version(): " << dap_metadata.cow_version()
-              << " writer.GetCowVersion(): " << writer.GetCowVersion();
-
-    // Deduce supported features.
-    bool userspace_snapshots = CanUseUserspaceSnapshots();
-    bool legacy_compression = GetLegacyCompressionEnabledProperty();
 
     std::string vabc_disable_reason;
     if (!dap_metadata.vabc_enabled()) {
         vabc_disable_reason = "not enabled metadata";
     } else if (device_->IsRecovery()) {
         vabc_disable_reason = "recovery";
-    } else if (!cow_format_support) {
-        vabc_disable_reason = "cow format not supported";
     } else if (!KernelSupportsCompressedSnapshots()) {
         vabc_disable_reason = "kernel missing userspace block device support";
     }
 
+    // Deduce supported features.
+    bool userspace_snapshots = CanUseUserspaceSnapshots();
+    bool legacy_compression = GetLegacyCompressionEnabledProperty();
     if (!vabc_disable_reason.empty()) {
         if (userspace_snapshots) {
             LOG(INFO) << "Userspace snapshots disabled: " << vabc_disable_reason;
@@ -3246,6 +3227,16 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
         legacy_compression = false;
     }
 
+    if (legacy_compression || userspace_snapshots) {
+        if (dap_metadata.cow_version() < kMinCowVersion ||
+            dap_metadata.cow_version() > kMaxCowVersion) {
+            LOG(ERROR) << "Manifest cow version is out of bounds (got: "
+                       << dap_metadata.cow_version() << ", min: " << kMinCowVersion
+                       << ", max: " << kMaxCowVersion << ")";
+            return Return::Error();
+        }
+    }
+
     const bool using_snapuserd = userspace_snapshots || legacy_compression;
     if (!using_snapuserd) {
         LOG(INFO) << "Using legacy Virtual A/B (dm-snapshot)";
@@ -3278,6 +3269,11 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
         cow_creator.batched_writes = dap_metadata.vabc_feature_set().batch_writes();
     }
 
+    // In case of error, automatically delete devices that are created along the way.
+    // Note that "lock" is destroyed after "created_devices", so it is safe to use |lock| for
+    // these devices.
+    AutoDeviceList created_devices;
+    std::map<std::string, SnapshotStatus> all_snapshot_status;
     auto ret = CreateUpdateSnapshotsInternal(lock.get(), manifest, &cow_creator, &created_devices,
                                              &all_snapshot_status);
     if (!ret.is_ok()) {
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 22731e7b7487..f08f9139ccbb 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2688,6 +2688,24 @@ TEST_F(SnapshotUpdateTest, QueryStatusError) {
     ASSERT_EQ(UpdateState::MergeCompleted, init->ProcessUpdateState());
 }
 
+TEST_F(SnapshotUpdateTest, BadCowVersion) {
+    if (!snapuserd_required_) {
+        GTEST_SKIP() << "VABC only";
+    }
+
+    ASSERT_TRUE(sm->BeginUpdate());
+
+    auto dynamic_partition_metadata = manifest_.mutable_dynamic_partition_metadata();
+    dynamic_partition_metadata->set_cow_version(kMinCowVersion - 1);
+    ASSERT_FALSE(sm->CreateUpdateSnapshots(manifest_));
+
+    dynamic_partition_metadata->set_cow_version(kMaxCowVersion + 1);
+    ASSERT_FALSE(sm->CreateUpdateSnapshots(manifest_));
+
+    dynamic_partition_metadata->set_cow_version(kMaxCowVersion);
+    ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
+}
+
 class FlashAfterUpdateTest : public SnapshotUpdateTest,
                              public WithParamInterface<std::tuple<uint32_t, bool>> {
   public:

From 95b26e1d0cddec1e0063c4238842d45fa95dc2be Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 9 May 2023 12:30:06 -0700
Subject: [PATCH 0064/1487] libsnapshot: Remove OnlineKernelSnapshotWriter.

This was never used or tested. The idea was to unify update_engine's
write paths on ISnapshotWriter. But given that legacy VAB is "legacy",
it doesn't make sense to begin refactoring that code and potentially
introducing bugs. Let's just remove this instead.

Bug: 280529365
Test: builds
Change-Id: Ie2f531bd140e183dfde4b65a144f3b4acc28e78a
---
 .../include/libsnapshot/snapshot.h            |  4 -
 .../include/libsnapshot/snapshot_writer.h     | 33 -------
 fs_mgr/libsnapshot/snapshot.cpp               | 39 ++------
 fs_mgr/libsnapshot/snapshot_test.cpp          | 39 +++++---
 fs_mgr/libsnapshot/snapshot_writer.cpp        | 90 -------------------
 5 files changed, 34 insertions(+), 171 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index 9eb89b6124d3..ecf1d1531710 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -697,10 +697,6 @@ class SnapshotManager final : public ISnapshotManager {
             LockedFile* lock, const std::optional<std::string>& source_device,
             const std::string& partition_name, const SnapshotStatus& status,
             const SnapshotPaths& paths);
-    std::unique_ptr<ISnapshotWriter> OpenKernelSnapshotWriter(
-            LockedFile* lock, const std::optional<std::string>& source_device,
-            const std::string& partition_name, const SnapshotStatus& status,
-            const SnapshotPaths& paths);
 
     // Map the base device, COW devices, and snapshot device.
     bool MapPartitionWithSnapshot(LockedFile* lock, CreateLogicalPartitionParams params,
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot_writer.h
index 0e3b1db6b90e..8f6344c3b741 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot_writer.h
@@ -89,38 +89,5 @@ class CompressedSnapshotWriter final : public ISnapshotWriter {
     std::unique_ptr<CowWriter> cow_;
 };
 
-// Write directly to a dm-snapshot device.
-class OnlineKernelSnapshotWriter final : public ISnapshotWriter {
-  public:
-    OnlineKernelSnapshotWriter(const CowOptions& options);
-
-    // Set the device used for all writes.
-    void SetSnapshotDevice(android::base::unique_fd&& snapshot_fd, uint64_t cow_size);
-
-    bool Initialize() override { return true; }
-    bool InitializeAppend(uint64_t) override { return true; }
-
-    bool Finalize() override;
-    uint64_t GetCowSize() override { return cow_size_; }
-    std::unique_ptr<FileDescriptor> OpenReader() override;
-
-    // Online kernel snapshot writer doesn't care about merge sequences.
-    // So ignore.
-    bool VerifyMergeOps() const noexcept override { return true; }
-
-  protected:
-    bool EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) override;
-    bool EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) override;
-    bool EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size, uint32_t old_block,
-                       uint16_t offset) override;
-    bool EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) override;
-    bool EmitLabel(uint64_t label) override;
-    bool EmitSequenceData(size_t num_ops, const uint32_t* data) override;
-
-  private:
-    android::base::unique_fd snapshot_fd_;
-    uint64_t cow_size_ = 0;
-};
-
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index b0c4a8371e01..e114d255654e 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -3647,12 +3647,13 @@ std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenSnapshotWriter(
         return nullptr;
     }
 
-    if (status.using_snapuserd()) {
-        return OpenCompressedSnapshotWriter(lock.get(), source_device, params.GetPartitionName(),
-                                            status, paths);
+    if (!status.using_snapuserd()) {
+        LOG(ERROR) << "Can only create snapshot writers with userspace or compressed snapshots";
+        return nullptr;
     }
-    return OpenKernelSnapshotWriter(lock.get(), source_device, params.GetPartitionName(), status,
-                                    paths);
+
+    return OpenCompressedSnapshotWriter(lock.get(), source_device, params.GetPartitionName(),
+                                        status, paths);
 #endif
 }
 
@@ -3700,34 +3701,6 @@ std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenCompressedSnapshotWriter(
 
     return writer;
 }
-
-std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenKernelSnapshotWriter(
-        LockedFile* lock, const std::optional<std::string>& source_device,
-        [[maybe_unused]] const std::string& partition_name, const SnapshotStatus& status,
-        const SnapshotPaths& paths) {
-    CHECK(lock);
-
-    CowOptions cow_options;
-    cow_options.max_blocks = {status.device_size() / cow_options.block_size};
-
-    auto writer = std::make_unique<OnlineKernelSnapshotWriter>(cow_options);
-
-    std::string path = paths.snapshot_device.empty() ? paths.target_device : paths.snapshot_device;
-    unique_fd fd(open(path.c_str(), O_RDWR | O_CLOEXEC));
-    if (fd < 0) {
-        PLOG(ERROR) << "open failed: " << path;
-        return nullptr;
-    }
-
-    if (source_device) {
-        writer->SetSourceDevice(*source_device);
-    }
-
-    uint64_t cow_size = status.cow_partition_size() + status.cow_file_size();
-    writer->SetSnapshotDevice(std::move(fd), cow_size);
-
-    return writer;
-}
 #endif  // !defined(LIBSNAPSHOT_NO_COW_WRITE)
 
 bool SnapshotManager::UnmapUpdateSnapshot(const std::string& target_partition_name) {
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index f08f9139ccbb..7cdb8ed0aef1 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -643,21 +643,38 @@ TEST_F(SnapshotTest, FirstStageMountAfterRollback) {
 TEST_F(SnapshotTest, Merge) {
     ASSERT_TRUE(AcquireLock());
 
-    static const uint64_t kDeviceSize = 1024 * 1024;
+    static constexpr uint64_t kDeviceSize = 1024 * 1024;
+    static constexpr uint32_t kBlockSize = 4096;
+
+    std::string test_string = "This is a test string.";
+    test_string.resize(kBlockSize);
 
-    std::unique_ptr<ISnapshotWriter> writer;
-    ASSERT_TRUE(PrepareOneSnapshot(kDeviceSize, &writer));
+    bool userspace_snapshots = false;
+    if (snapuserd_required_) {
+        std::unique_ptr<ISnapshotWriter> writer;
+        ASSERT_TRUE(PrepareOneSnapshot(kDeviceSize, &writer));
 
-    bool userspace_snapshots = sm->UpdateUsesUserSnapshots(lock_.get());
+        userspace_snapshots = sm->UpdateUsesUserSnapshots(lock_.get());
 
-    // Release the lock.
-    lock_ = nullptr;
+        // Release the lock.
+        lock_ = nullptr;
 
-    std::string test_string = "This is a test string.";
-    test_string.resize(writer->options().block_size);
-    ASSERT_TRUE(writer->AddRawBlocks(0, test_string.data(), test_string.size()));
-    ASSERT_TRUE(writer->Finalize());
-    writer = nullptr;
+        ASSERT_TRUE(writer->AddRawBlocks(0, test_string.data(), test_string.size()));
+        ASSERT_TRUE(writer->Finalize());
+        writer = nullptr;
+    } else {
+        ASSERT_TRUE(PrepareOneSnapshot(kDeviceSize));
+
+        // Release the lock.
+        lock_ = nullptr;
+
+        std::string path;
+        ASSERT_TRUE(dm_.GetDmDevicePathByName("test_partition_b", &path));
+
+        unique_fd fd(open(path.c_str(), O_WRONLY));
+        ASSERT_GE(fd, 0);
+        ASSERT_TRUE(android::base::WriteFully(fd, test_string.data(), test_string.size()));
+    }
 
     // Done updating.
     ASSERT_TRUE(sm->FinishedSnapshotWrites(false));
diff --git a/fs_mgr/libsnapshot/snapshot_writer.cpp b/fs_mgr/libsnapshot/snapshot_writer.cpp
index 82a7fd7d6343..6a3906ead22c 100644
--- a/fs_mgr/libsnapshot/snapshot_writer.cpp
+++ b/fs_mgr/libsnapshot/snapshot_writer.cpp
@@ -149,95 +149,5 @@ bool CompressedSnapshotWriter::InitializeAppend(uint64_t label) {
     return cow_->InitializeAppend(cow_device_, label);
 }
 
-OnlineKernelSnapshotWriter::OnlineKernelSnapshotWriter(const CowOptions& options)
-    : ISnapshotWriter(options) {}
-
-void OnlineKernelSnapshotWriter::SetSnapshotDevice(android::base::unique_fd&& snapshot_fd,
-                                                   uint64_t cow_size) {
-    snapshot_fd_ = std::move(snapshot_fd);
-    cow_size_ = cow_size;
-}
-
-bool OnlineKernelSnapshotWriter::Finalize() {
-    if (fsync(snapshot_fd_.get()) < 0) {
-        PLOG(ERROR) << "fsync";
-        return false;
-    }
-    return true;
-}
-
-bool OnlineKernelSnapshotWriter::EmitRawBlocks(uint64_t new_block_start, const void* data,
-                                               size_t size) {
-    uint64_t offset = new_block_start * options_.block_size;
-    if (lseek(snapshot_fd_.get(), offset, SEEK_SET) < 0) {
-        PLOG(ERROR) << "EmitRawBlocks lseek to offset " << offset;
-        return false;
-    }
-    if (!android::base::WriteFully(snapshot_fd_, data, size)) {
-        PLOG(ERROR) << "EmitRawBlocks write";
-        return false;
-    }
-    return true;
-}
-
-bool OnlineKernelSnapshotWriter::EmitXorBlocks(uint32_t, const void*, size_t, uint32_t, uint16_t) {
-    LOG(ERROR) << "EmitXorBlocks not implemented.";
-    return false;
-}
-
-bool OnlineKernelSnapshotWriter::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
-    std::string zeroes(options_.block_size, 0);
-    for (uint64_t i = 0; i < num_blocks; i++) {
-        if (!EmitRawBlocks(new_block_start + i, zeroes.data(), zeroes.size())) {
-            return false;
-        }
-    }
-    return true;
-}
-
-bool OnlineKernelSnapshotWriter::EmitCopy(uint64_t new_block, uint64_t old_block,
-                                          uint64_t num_blocks) {
-    auto source_fd = GetSourceFd();
-    if (source_fd < 0) {
-        return false;
-    }
-
-    CHECK(num_blocks != 0);
-
-    for (size_t i = 0; i < num_blocks; i++) {
-        std::string buffer(options_.block_size, 0);
-        uint64_t offset = (old_block + i) * options_.block_size;
-        if (!android::base::ReadFullyAtOffset(source_fd, buffer.data(), buffer.size(), offset)) {
-            PLOG(ERROR) << "EmitCopy read";
-            return false;
-        }
-        if (!EmitRawBlocks(new_block + i, buffer.data(), buffer.size())) {
-            PLOG(ERROR) << "EmitRawBlocks failed";
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool OnlineKernelSnapshotWriter::EmitLabel(uint64_t) {
-    // Not Needed
-    return true;
-}
-
-bool OnlineKernelSnapshotWriter::EmitSequenceData(size_t, const uint32_t*) {
-    // Not Needed
-    return true;
-}
-
-std::unique_ptr<FileDescriptor> OnlineKernelSnapshotWriter::OpenReader() {
-    unique_fd fd(dup(snapshot_fd_.get()));
-    if (fd < 0) {
-        PLOG(ERROR) << "dup2 failed in OpenReader";
-        return nullptr;
-    }
-    return std::make_unique<ReadFdFileDescriptor>(std::move(fd));
-}
-
 }  // namespace snapshot
 }  // namespace android

From 5729d860cd543ff504efcd08e3e6da579e05c79e Mon Sep 17 00:00:00 2001
From: Devin Moore <devinmoore@google.com>
Date: Tue, 23 May 2023 00:24:04 +0000
Subject: [PATCH 0065/1487] Remove libdiskconfig as it is no longer used

Test: m
Bug: 280829178
Change-Id: I1da275ef13dea92b8c1021aa3d658569c4cf782e
---
 libdiskconfig/Android.bp                      |  36 --
 libdiskconfig/config_mbr.c                    | 351 ------------
 libdiskconfig/diskconfig.c                    | 535 ------------------
 libdiskconfig/diskutils.c                     | 118 ----
 libdiskconfig/dump_diskconfig.c               |  43 --
 libdiskconfig/include/diskconfig/diskconfig.h | 130 -----
 libdiskconfig/write_lst.c                     |  92 ---
 7 files changed, 1305 deletions(-)
 delete mode 100644 libdiskconfig/Android.bp
 delete mode 100644 libdiskconfig/config_mbr.c
 delete mode 100644 libdiskconfig/diskconfig.c
 delete mode 100644 libdiskconfig/diskutils.c
 delete mode 100644 libdiskconfig/dump_diskconfig.c
 delete mode 100644 libdiskconfig/include/diskconfig/diskconfig.h
 delete mode 100644 libdiskconfig/write_lst.c

diff --git a/libdiskconfig/Android.bp b/libdiskconfig/Android.bp
deleted file mode 100644
index f523d4e70c28..000000000000
--- a/libdiskconfig/Android.bp
+++ /dev/null
@@ -1,36 +0,0 @@
-package {
-    default_applicable_licenses: ["Android-Apache-2.0"],
-}
-
-cc_library {
-    name: "libdiskconfig",
-    vendor_available: true,
-    vndk: {
-        enabled: true,
-    },
-    srcs: [
-        "diskconfig.c",
-        "diskutils.c",
-        "write_lst.c",
-        "config_mbr.c",
-    ],
-
-    shared_libs: [
-        "libcutils",
-        "liblog",
-    ],
-    cflags: ["-Werror"],
-    export_include_dirs: ["include"],
-    local_include_dirs: ["include"],
-
-    target: {
-        darwin: {
-            enabled: false,
-        },
-        host_linux: {
-            cflags: [
-                "-D_LARGEFILE64_SOURCE",
-            ],
-        },
-    },
-}
diff --git a/libdiskconfig/config_mbr.c b/libdiskconfig/config_mbr.c
deleted file mode 100644
index ace9bbfb1ea2..000000000000
--- a/libdiskconfig/config_mbr.c
+++ /dev/null
@@ -1,351 +0,0 @@
-/* libs/diskconfig/diskconfig.c
- *
- * Copyright 2008, 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.
- */
-
-#define LOG_TAG "config_mbr"
-
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <diskconfig/diskconfig.h>
-#include <log/log.h>
-
-/* start and len are in LBA units */
-static void
-cfg_pentry(struct pc_partition *pentry, uint8_t status, uint8_t type,
-           uint32_t start, uint32_t len)
-{
-    if (len > 0) {
-        /* seems that somes BIOSens can get wedged on boot while verifying
-         * the mbr if these are 0 */
-        memset(&pentry->start, 0xff, sizeof(struct chs));
-        memset(&pentry->end, 0xff, sizeof(struct chs));
-    } else {
-        /* zero out the c/h/s entries.. they are not used */
-        memset(&pentry->start, 0, sizeof(struct chs));
-        memset(&pentry->end, 0, sizeof(struct chs));
-    }
-
-    pentry->status = status;
-    pentry->type = type;
-    pentry->start_lba = start;
-    pentry->len_lba = len;
-
-    ALOGI("Configuring pentry. status=0x%x type=0x%x start_lba=%u len_lba=%u",
-         pentry->status, pentry->type, pentry->start_lba, pentry->len_lba);
-}
-
-
-static inline uint32_t
-kb_to_lba(uint32_t len_kb, uint32_t sect_size)
-{
-    uint64_t lba;
-
-    lba = (uint64_t)len_kb * 1024;
-    /* bump it up to the next LBA boundary just in case  */
-    lba = (lba + (uint64_t)sect_size - 1) & ~((uint64_t)sect_size - 1);
-    lba /= (uint64_t)sect_size;
-    if (lba >= 0xffffffffULL)
-        ALOGE("Error converting kb -> lba. 32bit overflow, expect weirdness");
-    return (uint32_t)(lba & 0xffffffffULL);
-}
-
-
-static struct write_list *
-mk_pri_pentry(struct disk_info *dinfo, struct part_info *pinfo, int pnum,
-              uint32_t *lba)
-{
-    struct write_list *item;
-    struct pc_partition *pentry;
-
-    if (pnum >= PC_NUM_BOOT_RECORD_PARTS) {
-        ALOGE("Maximum number of primary partition exceeded.");
-        return NULL;
-    }
-
-    if (!(item = alloc_wl(sizeof(struct pc_partition)))) {
-        ALOGE("Unable to allocate memory for partition entry.");
-        return NULL;
-    }
-
-    {
-        /* DO NOT DEREFERENCE */
-        struct pc_boot_record *mbr = (void *)PC_MBR_DISK_OFFSET; 
-        /* grab the offset in mbr where to write this partition entry. */
-        item->offset = (loff_t)((uintptr_t)((uint8_t *)(&mbr->ptable[pnum])));
-    }
-
-    pentry = (struct pc_partition *) &item->data;
-
-    /* need a standard primary partition entry */
-    if (pinfo) {
-        /* need this to be 64 bit in case len_kb is large */
-        uint64_t len_lba; 
-
-        if (pinfo->len_kb != (uint32_t)-1) {
-            /* bump it up to the next LBA boundary just in case */
-            len_lba = ((uint64_t)pinfo->len_kb * 1024);
-            len_lba += ((uint64_t)dinfo->sect_size - 1);
-            len_lba &= ~((uint64_t)dinfo->sect_size - 1);
-            len_lba /= (uint64_t)dinfo->sect_size;
-        } else {
-            /* make it fill the rest of disk */
-            len_lba = dinfo->num_lba - *lba;
-        }
-
-        cfg_pentry(pentry, ((pinfo->flags & PART_ACTIVE_FLAG) ?
-                            PC_PART_ACTIVE : PC_PART_NORMAL),
-                   pinfo->type, *lba, (uint32_t)len_lba);
-
-        pinfo->start_lba = *lba;
-        *lba += (uint32_t)len_lba;
-    } else {
-        /* this should be made an extended partition, and should take
-         * up the rest of the disk as a primary partition */
-        cfg_pentry(pentry, PC_PART_NORMAL, PC_PART_TYPE_EXTENDED,
-                   *lba, dinfo->num_lba - *lba);
-
-        /* note that we do not update the *lba because we now have to
-         * create a chain of extended partition tables, and first one is at
-         * *lba */
-    }
-
-    return item;
-}
-
-
-/* This function configures an extended boot record at the beginning of an
- * extended partition. This creates a logical partition and a pointer to
- * the next EBR.
- *
- * ext_lba == The start of the toplevel extended partition (pointed to by the
- * entry in the MBR).
- */
-static struct write_list *
-mk_ext_pentry(struct disk_info *dinfo, struct part_info *pinfo, uint32_t *lba,
-              uint32_t ext_lba, struct part_info *pnext)
-{
-    struct write_list *item;
-    struct pc_boot_record *ebr;
-    uint32_t len; /* in lba units */
-
-    if (!(item = alloc_wl(sizeof(struct pc_boot_record)))) {
-        ALOGE("Unable to allocate memory for EBR.");
-        return NULL;
-    }
-
-    /* we are going to write the ebr at the current LBA, and then bump the
-     * lba counter since that is where the logical data partition will start */
-    item->offset = ((loff_t)(*lba)) * dinfo->sect_size;
-    (*lba)++;
-
-    ebr = (struct pc_boot_record *) &item->data;
-    memset(ebr, 0, sizeof(struct pc_boot_record));
-    ebr->mbr_sig = PC_BIOS_BOOT_SIG;
-
-    if (pinfo->len_kb != (uint32_t)-1)
-        len = kb_to_lba(pinfo->len_kb, dinfo->sect_size);
-    else {
-        if (pnext) {
-            ALOGE("Only the last partition can be specified to fill the disk "
-                 "(name = '%s')", pinfo->name);
-            goto fail;
-        }
-        len = dinfo->num_lba - *lba;
-        /* update the pinfo structure to reflect the new size, for
-         * bookkeeping */
-        pinfo->len_kb =
-            (uint32_t)(((uint64_t)len * (uint64_t)dinfo->sect_size) /
-                       ((uint64_t)1024));
-    }
-
-    cfg_pentry(&ebr->ptable[PC_EBR_LOGICAL_PART], PC_PART_NORMAL,
-               pinfo->type, 1, len);
-
-    pinfo->start_lba = *lba;
-    *lba += len;
-
-    /* If this is not the last partition, we have to create a link to the
-     * next extended partition.
-     *
-     * Otherwise, there's nothing to do since the "pointer entry" is
-     * already zero-filled.
-     */
-    if (pnext) {
-        /* The start lba for next partition is an offset from the beginning
-         * of the top-level extended partition */
-        uint32_t next_start_lba = *lba - ext_lba;
-        uint32_t next_len_lba;
-        if (pnext->len_kb != (uint32_t)-1)
-            next_len_lba = 1 + kb_to_lba(pnext->len_kb, dinfo->sect_size);
-        else
-            next_len_lba = dinfo->num_lba - *lba;
-        cfg_pentry(&ebr->ptable[PC_EBR_NEXT_PTR_PART], PC_PART_NORMAL,
-                   PC_PART_TYPE_EXTENDED, next_start_lba, next_len_lba);
-    }
-
-    return item;
-
-fail:
-    free_wl(item);
-    return NULL;
-}
-
-
-static struct write_list *
-mk_mbr_sig()
-{
-    struct write_list *item;
-    if (!(item = alloc_wl(sizeof(uint16_t)))) {
-        ALOGE("Unable to allocate memory for MBR signature.");
-        return NULL;
-    }
-
-    {
-        /* DO NOT DEREFERENCE */
-        struct pc_boot_record *mbr = (void *)PC_MBR_DISK_OFFSET;
-        /* grab the offset in mbr where to write mbr signature. */
-        item->offset = (loff_t)((uintptr_t)((uint8_t *)(&mbr->mbr_sig)));
-    }
-
-    *((uint16_t*)item->data) = PC_BIOS_BOOT_SIG;
-    return item;
-}
-
-struct write_list *
-config_mbr(struct disk_info *dinfo)
-{
-    struct part_info *pinfo;
-    uint32_t cur_lba = dinfo->skip_lba;
-    uint32_t ext_lba = 0;
-    struct write_list *wr_list = NULL;
-    struct write_list *temp_wr = NULL;
-    int cnt = 0;
-    int extended = 0;
-
-    if (!dinfo->part_lst)
-        return NULL;
-
-    for (cnt = 0; cnt < dinfo->num_parts; ++cnt) {
-        pinfo = &dinfo->part_lst[cnt];
-
-        /* Should we create an extedned partition? */
-        if (cnt == (PC_NUM_BOOT_RECORD_PARTS - 1)) {
-            if (cnt + 1 < dinfo->num_parts) {
-                extended = 1;
-                ext_lba = cur_lba;
-                if ((temp_wr = mk_pri_pentry(dinfo, NULL, cnt, &cur_lba)))
-                    wlist_add(&wr_list, temp_wr);
-                else {
-                    ALOGE("Cannot create primary extended partition.");
-                    goto fail;
-                }
-            }
-        }
-
-        /* if extended, need 1 lba for ebr */
-        if ((cur_lba + extended) >= dinfo->num_lba)
-            goto nospace;
-        else if (pinfo->len_kb != (uint32_t)-1) {
-            uint32_t sz_lba = (pinfo->len_kb / dinfo->sect_size) * 1024;
-            if ((cur_lba + sz_lba + extended) > dinfo->num_lba)
-                goto nospace;
-        }
-
-        if (!extended)
-            temp_wr = mk_pri_pentry(dinfo, pinfo, cnt, &cur_lba);
-        else {
-            struct part_info *pnext;
-            pnext = cnt + 1 < dinfo->num_parts ? &dinfo->part_lst[cnt+1] : NULL;
-            temp_wr = mk_ext_pentry(dinfo, pinfo, &cur_lba, ext_lba, pnext);
-        }
-
-        if (temp_wr)
-            wlist_add(&wr_list, temp_wr);
-        else {
-            ALOGE("Cannot create partition %d (%s).", cnt, pinfo->name);
-            goto fail;
-        }
-    }
-
-    /* fill in the rest of the MBR with empty parts (if needed). */
-    for (; cnt < PC_NUM_BOOT_RECORD_PARTS; ++cnt) {
-        struct part_info blank;
-        cur_lba = 0;
-        memset(&blank, 0, sizeof(struct part_info));
-        if (!(temp_wr = mk_pri_pentry(dinfo, &blank, cnt, &cur_lba))) {
-            ALOGE("Cannot create blank partition %d.", cnt);
-            goto fail;
-        }
-        wlist_add(&wr_list, temp_wr);
-    }
-
-    if ((temp_wr = mk_mbr_sig()))
-        wlist_add(&wr_list, temp_wr);
-    else {
-        ALOGE("Cannot set MBR signature");
-        goto fail;
-    }
-
-    return wr_list;
-
-nospace:
-    ALOGE("Not enough space to add parttion '%s'.", pinfo->name);
-
-fail:
-    wlist_free(wr_list);
-    return NULL;
-}
-
-
-/* Returns the device path of the partition referred to by 'name'
- * Must be freed by the caller.
- */
-char *
-find_mbr_part(struct disk_info *dinfo, const char *name)
-{
-    struct part_info *plist = dinfo->part_lst;
-    int num = 0;
-    char *dev_name = NULL;
-    int has_extended = (dinfo->num_parts > PC_NUM_BOOT_RECORD_PARTS);
-
-    for(num = 1; num <= dinfo->num_parts; ++num) {
-        if (!strcmp(plist[num-1].name, name))
-            break;
-    }
-
-    if (num > dinfo->num_parts)
-        return NULL;
-
-    if (has_extended && (num >= PC_NUM_BOOT_RECORD_PARTS))
-        num++;
-
-    if (!(dev_name = malloc(MAX_NAME_LEN))) {
-        ALOGE("Cannot allocate memory.");
-        return NULL;
-    }
-
-    num = snprintf(dev_name, MAX_NAME_LEN, "%s%d", dinfo->device, num);
-    if (num >= MAX_NAME_LEN) {
-        ALOGE("Device name is too long?!");
-        free(dev_name);
-        return NULL;
-    }
-
-    return dev_name;
-}
diff --git a/libdiskconfig/diskconfig.c b/libdiskconfig/diskconfig.c
deleted file mode 100644
index 5f34748b0989..000000000000
--- a/libdiskconfig/diskconfig.c
+++ /dev/null
@@ -1,535 +0,0 @@
-/* libs/diskconfig/diskconfig.c
- *
- * Copyright 2008, 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.
- */
-
-#define LOG_TAG "diskconfig"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <inttypes.h>
-#include <linux/fs.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-#include <cutils/config_utils.h>
-#include <log/log.h>
-
-#include <diskconfig/diskconfig.h>
-
-static int
-parse_len(const char *str, uint64_t *plen)
-{
-    char tmp[64];
-    int len_str;
-    uint32_t multiple = 1;
-
-    strncpy(tmp, str, sizeof(tmp));
-    tmp[sizeof(tmp)-1] = '\0';
-    len_str = strlen(tmp);
-    if (!len_str) {
-        ALOGE("Invalid disk length specified.");
-        return 1;
-    }
-
-    switch(tmp[len_str - 1]) {
-        case 'M': case 'm':
-            /* megabyte */
-            multiple <<= 10;
-        case 'K': case 'k':
-            /* kilobytes */
-            multiple <<= 10;
-            tmp[len_str - 1] = '\0';
-            break;
-        default:
-            break;
-    }
-
-    *plen = strtoull(tmp, NULL, 0);
-    if (!*plen) {
-        ALOGE("Invalid length specified: %s", str);
-        return 1;
-    }
-
-    if (*plen == (uint64_t)-1) {
-        if (multiple > 1) {
-            ALOGE("Size modifier illegal when len is -1");
-            return 1;
-        }
-    } else {
-        /* convert len to kilobytes */
-        if (multiple > 1024)
-            multiple >>= 10;
-        *plen *= multiple;
-
-        if (*plen > 0xffffffffULL) {
-            ALOGE("Length specified is too large!: %"PRIu64" KB", *plen);
-            return 1;
-        }
-    }
-
-    return 0;
-}
-
-
-static int
-load_partitions(cnode *root, struct disk_info *dinfo)
-{
-    cnode *partnode;
-
-    dinfo->num_parts = 0;
-    for (partnode = root->first_child; partnode; partnode = partnode->next) {
-        struct part_info *pinfo = &dinfo->part_lst[dinfo->num_parts];
-        const char *tmp;
-
-        /* bleh, i will leak memory here, but i DONT CARE since
-         * the only right thing to do when this function fails
-         * is to quit */
-        pinfo->name = strdup(partnode->name);
-
-        if(config_bool(partnode, "active", 0))
-            pinfo->flags |= PART_ACTIVE_FLAG;
-
-        if (!(tmp = config_str(partnode, "type", NULL))) {
-            ALOGE("Partition type required: %s", pinfo->name);
-            return 1;
-        }
-
-        /* possible values are: linux, fat32 */
-        if (!strcmp(tmp, "linux")) {
-            pinfo->type = PC_PART_TYPE_LINUX;
-        } else if (!strcmp(tmp, "fat32")) {
-            pinfo->type = PC_PART_TYPE_FAT32;
-        } else {
-            ALOGE("Unsupported partition type found: %s", tmp);
-            return 1;
-        }
-
-        if ((tmp = config_str(partnode, "len", NULL)) != NULL) {
-            uint64_t len;
-            if (parse_len(tmp, &len))
-                return 1;
-            pinfo->len_kb = (uint32_t) len;
-        } else 
-            pinfo->len_kb = 0;
-
-        ++dinfo->num_parts;
-    }
-
-    return 0;
-}
-
-struct disk_info *
-load_diskconfig(const char *fn, char *path_override)
-{
-    struct disk_info *dinfo;
-    cnode *devroot;
-    cnode *partnode;
-    cnode *root = config_node("", "");
-    const char *tmp;
-
-    if (!(dinfo = malloc(sizeof(struct disk_info)))) {
-        ALOGE("Could not malloc disk_info");
-        return NULL;
-    }
-    memset(dinfo, 0, sizeof(struct disk_info));
-
-    if (!(dinfo->part_lst = malloc(MAX_NUM_PARTS * sizeof(struct part_info)))) {
-        ALOGE("Could not malloc part_lst");
-        goto fail;
-    }
-    memset(dinfo->part_lst, 0,
-           (MAX_NUM_PARTS * sizeof(struct part_info)));
-
-    config_load_file(root, fn);
-    if (root->first_child == NULL) {
-        ALOGE("Could not read config file %s", fn);
-        goto fail;
-    }
-
-    if (!(devroot = config_find(root, "device"))) {
-        ALOGE("Could not find device section in config file '%s'", fn);
-        goto fail;
-    }
-
-
-    if (!(tmp = config_str(devroot, "path", path_override))) {
-        ALOGE("device path is requried");
-        goto fail;
-    }
-    dinfo->device = strdup(tmp);
-
-    /* find the partition scheme */
-    if (!(tmp = config_str(devroot, "scheme", NULL))) {
-        ALOGE("partition scheme is required");
-        goto fail;
-    } else if (!strcmp(tmp, "mbr")) {
-        dinfo->scheme = PART_SCHEME_MBR;
-    } else if (!strcmp(tmp, "gpt")) {
-        ALOGE("'gpt' partition scheme not supported yet.");
-        goto fail;
-    } else {
-        ALOGE("Unknown partition scheme specified: %s", tmp);
-        goto fail;
-    }
-
-    /* grab the sector size (in bytes) */
-    tmp = config_str(devroot, "sector_size", "512");
-    dinfo->sect_size = strtol(tmp, NULL, 0);
-    if (!dinfo->sect_size) {
-        ALOGE("Invalid sector size: %s", tmp);
-        goto fail;
-    }
-
-    /* first lba where the partitions will start on disk */
-    if (!(tmp = config_str(devroot, "start_lba", NULL))) {
-        ALOGE("start_lba must be provided");
-        goto fail;
-    }
-
-    if (!(dinfo->skip_lba = strtol(tmp, NULL, 0))) {
-        ALOGE("Invalid starting LBA (or zero): %s", tmp);
-        goto fail;
-    }
-
-    /* Number of LBAs on disk */
-    if (!(tmp = config_str(devroot, "num_lba", NULL))) {
-        ALOGE("num_lba is required");
-        goto fail;
-    }
-    dinfo->num_lba = strtoul(tmp, NULL, 0);
-
-    if (!(partnode = config_find(devroot, "partitions"))) {
-        ALOGE("Device must specify partition list");
-        goto fail;
-    }
-
-    if (load_partitions(partnode, dinfo))
-        goto fail;
-
-    return dinfo;
-
-fail:
-    if (dinfo->part_lst)
-        free(dinfo->part_lst);
-    if (dinfo->device)
-        free(dinfo->device);
-    free(dinfo);
-    return NULL;
-}
-
-static int
-sync_ptable(int fd)
-{
-    struct stat stat;
-    int rv;
-
-    sync();
-
-    if (fstat(fd, &stat)) {
-       ALOGE("Cannot stat, errno=%d.", errno);
-       return -1;
-    }
-
-    if (S_ISBLK(stat.st_mode) && ((rv = ioctl(fd, BLKRRPART, NULL)) < 0)) {
-        ALOGE("Could not re-read partition table. REBOOT!. (errno=%d)", errno);
-        return -1;
-    }
-
-    return 0;
-}
-
-/* This function verifies that the disk info provided is valid, and if so,
- * returns an open file descriptor.
- *
- * This does not necessarily mean that it will later be successfully written
- * though. If we use the pc-bios partitioning scheme, we must use extended
- * partitions, which eat up some hd space. If the user manually provisioned
- * every single partition, but did not account for the extra needed space,
- * then we will later fail.
- *
- * TODO: Make validation more complete.
- */
-static int
-validate(struct disk_info *dinfo)
-{
-    int fd;
-    int sect_sz;
-    uint64_t disk_size;
-    uint64_t total_size;
-    int cnt;
-    struct stat stat;
-
-    if (!dinfo)
-        return -1;
-
-    if ((fd = open(dinfo->device, O_RDWR)) < 0) {
-        ALOGE("Cannot open device '%s' (errno=%d)", dinfo->device, errno);
-        return -1;
-    }
-
-    if (fstat(fd, &stat)) {
-        ALOGE("Cannot stat file '%s', errno=%d.", dinfo->device, errno);
-        goto fail;
-    }
-
-
-    /* XXX: Some of the code below is kind of redundant and should probably
-     * be refactored a little, but it will do for now. */
-
-    /* Verify that we can operate on the device that was requested.
-     * We presently only support block devices and regular file images. */
-    if (S_ISBLK(stat.st_mode)) {
-        /* get the sector size and make sure we agree */
-        if (ioctl(fd, BLKSSZGET, &sect_sz) < 0) {
-            ALOGE("Cannot get sector size (errno=%d)", errno);
-            goto fail;
-        }
-
-        if (!sect_sz || sect_sz != dinfo->sect_size) {
-            ALOGE("Device sector size is zero or sector sizes do not match!");
-            goto fail;
-        }
-
-        /* allow the user override the "disk size" if they provided num_lba */
-        if (!dinfo->num_lba) {
-            if (ioctl(fd, BLKGETSIZE64, &disk_size) < 0) {
-                ALOGE("Could not get block device size (errno=%d)", errno);
-                goto fail;
-            }
-            /* XXX: we assume that the disk has < 2^32 sectors :-) */
-            dinfo->num_lba = (uint32_t)(disk_size / (uint64_t)dinfo->sect_size);
-        } else
-            disk_size = (uint64_t)dinfo->num_lba * (uint64_t)dinfo->sect_size;
-    } else if (S_ISREG(stat.st_mode)) {
-        ALOGI("Requesting operation on a regular file, not block device.");
-        if (!dinfo->sect_size) {
-            ALOGE("Sector size for regular file images cannot be zero");
-            goto fail;
-        }
-        if (dinfo->num_lba)
-            disk_size = (uint64_t)dinfo->num_lba * (uint64_t)dinfo->sect_size;
-        else {
-            dinfo->num_lba = (uint32_t)(stat.st_size / dinfo->sect_size);
-            disk_size = (uint64_t)stat.st_size;
-        }
-    } else {
-        ALOGE("Device does not refer to a regular file or a block device!");
-        goto fail;
-    }
-
-#if 1
-    ALOGV("Device/file %s: size=%" PRIu64 " bytes, num_lba=%u, sect_size=%d",
-         dinfo->device, disk_size, dinfo->num_lba, dinfo->sect_size);
-#endif
-
-    /* since this is our offset into the disk, we start off with that as
-     * our size of needed partitions */
-    total_size = dinfo->skip_lba * dinfo->sect_size;
-
-    /* add up all the partition sizes and make sure it fits */
-    for (cnt = 0; cnt < dinfo->num_parts; ++cnt) {
-        struct part_info *part = &dinfo->part_lst[cnt];
-        if (part->len_kb != (uint32_t)-1) {
-            total_size += part->len_kb * 1024;
-        } else if (part->len_kb == 0) {
-            ALOGE("Zero-size partition '%s' is invalid.", part->name);
-            goto fail;
-        } else {
-            /* the partition requests the rest of the disk. */
-            if (cnt + 1 != dinfo->num_parts) {
-                ALOGE("Only the last partition in the list can request to fill "
-                     "the rest of disk.");
-                goto fail;
-            }
-        }
-
-        if ((part->type != PC_PART_TYPE_LINUX) &&
-            (part->type != PC_PART_TYPE_FAT32)) {
-            ALOGE("Unknown partition type (0x%x) encountered for partition "
-                 "'%s'\n", part->type, part->name);
-            goto fail;
-        }
-    }
-
-    /* only matters for disks, not files */
-    if (S_ISBLK(stat.st_mode) && total_size > disk_size) {
-        ALOGE("Total requested size of partitions (%"PRIu64") is greater than disk "
-             "size (%"PRIu64").", total_size, disk_size);
-        goto fail;
-    }
-
-    return fd;
-
-fail:
-    close(fd);
-    return -1;
-}
-
-static int
-validate_and_config(struct disk_info *dinfo, int *fd, struct write_list **lst)
-{
-    *lst = NULL;
-    *fd = -1;
-
-    if ((*fd = validate(dinfo)) < 0)
-        return 1;
-
-    switch (dinfo->scheme) {
-        case PART_SCHEME_MBR:
-            *lst = config_mbr(dinfo);
-            return *lst == NULL;
-        case PART_SCHEME_GPT:
-            /* not supported yet */
-        default:
-            ALOGE("Unknown partition scheme.");
-            break;
-    }
-
-    close(*fd);
-    *lst = NULL;
-    return 1;
-}
-
-/* validate and process the disk layout configuration.
- * This will cause an update to the partitions' start lba.
- *
- * Basically, this does the same thing as apply_disk_config in test mode,
- * except that wlist_commit is not called to print out the data to be
- * written.
- */
-int
-process_disk_config(struct disk_info *dinfo)
-{
-    struct write_list *lst;
-    int fd;
-
-    if (validate_and_config(dinfo, &fd, &lst) != 0)
-        return 1;
-
-    close(fd);
-    wlist_free(lst);
-    return 0;
-}
-
-
-int
-apply_disk_config(struct disk_info *dinfo, int test)
-{
-    int fd;
-    struct write_list *wr_lst = NULL;
-    int rv;
-
-    if (validate_and_config(dinfo, &fd, &wr_lst) != 0) {
-        ALOGE("Configuration is invalid.");
-        goto fail;
-    }
-
-    if ((rv = wlist_commit(fd, wr_lst, test)) >= 0)
-        rv = test ? 0 : sync_ptable(fd);
-
-    close(fd);
-    wlist_free(wr_lst);
-    return rv;
-
-fail:
-    close(fd);
-    if (wr_lst)
-        wlist_free(wr_lst);
-    return 1;
-}
-
-int
-dump_disk_config(struct disk_info *dinfo)
-{
-    int cnt;
-    struct part_info *part;
-
-    printf("Device: %s\n", dinfo->device);
-    printf("Scheme: ");
-    switch (dinfo->scheme) {
-        case PART_SCHEME_MBR:
-            printf("MBR");
-            break;
-        case PART_SCHEME_GPT:
-            printf("GPT (unsupported)");
-            break;
-        default:
-            printf("Unknown");
-            break;
-    }
-    printf ("\n");
-
-    printf("Sector size: %d\n", dinfo->sect_size);
-    printf("Skip leading LBAs: %u\n", dinfo->skip_lba);
-    printf("Number of LBAs: %u\n", dinfo->num_lba);
-    printf("Partitions:\n");
-
-    for (cnt = 0; cnt < dinfo->num_parts; ++cnt) {
-        part = &dinfo->part_lst[cnt];
-        printf("\tname = %s\n", part->name);
-        printf("\t\tflags = %s\n",
-               part->flags & PART_ACTIVE_FLAG ? "Active" : "None");
-        printf("\t\ttype = %s\n",
-               part->type == PC_PART_TYPE_LINUX ? "Linux" : "Unknown");
-        if (part->len_kb == (uint32_t)-1)
-            printf("\t\tlen = rest of disk\n");
-        else
-            printf("\t\tlen = %uKB\n", part->len_kb);
-    }
-    printf("Total number of partitions: %d\n", cnt);
-    printf("\n");
-
-    return 0;
-}
-
-struct part_info *
-find_part(struct disk_info *dinfo, const char *name)
-{
-    struct part_info *pinfo;
-    int cnt;
-
-    for (cnt = 0; cnt < dinfo->num_parts; ++cnt) {
-        pinfo = &dinfo->part_lst[cnt];
-        if (!strcmp(pinfo->name, name))
-            return pinfo;
-    }
-
-    return NULL;
-}
-
-/* NOTE: If the returned ptr is non-NULL, it must be freed by the caller. */
-char *
-find_part_device(struct disk_info *dinfo, const char *name)
-{
-    switch (dinfo->scheme) {
-        case PART_SCHEME_MBR:
-            return find_mbr_part(dinfo, name);
-        case PART_SCHEME_GPT:
-            ALOGE("GPT is presently not supported");
-            break;
-        default:
-            ALOGE("Unknown partition table scheme");
-            break;
-    }
-
-    return NULL;
-}
-
-
diff --git a/libdiskconfig/diskutils.c b/libdiskconfig/diskutils.c
deleted file mode 100644
index fe1b4c180a79..000000000000
--- a/libdiskconfig/diskutils.c
+++ /dev/null
@@ -1,118 +0,0 @@
-/* libs/diskconfig/diskutils.c
- *
- * Copyright 2008, 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.
- */
-
-#define LOG_TAG "diskutils"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <inttypes.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-#include <log/log.h>
-
-#include <diskconfig/diskconfig.h>
-
-int
-write_raw_image(const char *dst, const char *src, loff_t offset, int test)
-{
-    int dst_fd = -1;
-    int src_fd = -1;
-    uint8_t buffer[2048];
-    ssize_t nr_bytes;
-    ssize_t tmp;
-    int done = 0;
-    uint64_t total = 0;
-
-    ALOGI("Writing RAW image '%s' to '%s' (offset=%llu)", src, dst, (unsigned long long)offset);
-    if ((src_fd = open(src, O_RDONLY)) < 0) {
-        ALOGE("Could not open %s for reading (errno=%d).", src, errno);
-        goto fail;
-    }
-
-    if (!test) {
-        if ((dst_fd = open(dst, O_RDWR)) < 0) {
-            ALOGE("Could not open '%s' for read/write (errno=%d).", dst, errno);
-            goto fail;
-        }
-
-        if (lseek64(dst_fd, offset, SEEK_SET) != offset) {
-            ALOGE("Could not seek to offset %lld in %s.", (long long)offset, dst);
-            goto fail;
-        }
-    }
-
-    while (!done) {
-        if ((nr_bytes = read(src_fd, buffer, sizeof(buffer))) < 0) {
-            /* XXX: Should we not even bother with EINTR? */
-            if (errno == EINTR)
-                continue;
-            ALOGE("Error (%d) while reading from '%s'", errno, src);
-            goto fail;
-        }
-
-        if (!nr_bytes) {
-            /* we're done. */
-            done = 1;
-            break;
-        }
-
-        total += nr_bytes;
-
-        /* skip the write loop if we're testing */
-        if (test)
-            nr_bytes = 0;
-
-        while (nr_bytes > 0) {
-            if ((tmp = write(dst_fd, buffer, nr_bytes)) < 0) {
-                /* XXX: Should we not even bother with EINTR? */
-                if (errno == EINTR)
-                    continue;
-                ALOGE("Error (%d) while writing to '%s'", errno, dst);
-                goto fail;
-            }
-            if (!tmp)
-                continue;
-            nr_bytes -= tmp;
-        }
-    }
-
-    if (!done) {
-        ALOGE("Exited read/write loop without setting flag! WTF?!");
-        goto fail;
-    }
-
-    if (dst_fd >= 0)
-        fsync(dst_fd);
-
-    ALOGI("Wrote %" PRIu64 " bytes to %s @ %lld", total, dst, (long long)offset);
-
-    close(src_fd);
-    if (dst_fd >= 0)
-        close(dst_fd);
-    return 0;
-
-fail:
-    if (dst_fd >= 0)
-        close(dst_fd);
-    if (src_fd >= 0)
-        close(src_fd);
-    return 1;
-}
diff --git a/libdiskconfig/dump_diskconfig.c b/libdiskconfig/dump_diskconfig.c
deleted file mode 100644
index 3c4f620058e6..000000000000
--- a/libdiskconfig/dump_diskconfig.c
+++ /dev/null
@@ -1,43 +0,0 @@
-/* libs/diskconfig/dump_diskconfig.c
- *
- * Copyright 2008, 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.
- */
-
-#define LOG_TAG "dump_diskconfig"
-
-#include <stdio.h>
-
-#include <log/log.h>
-
-#include "diskconfig.h"
-
-int
-main(int argc, char *argv[])
-{
-    struct disk_info *dinfo;
-
-    if (argc < 2) {
-        ALOGE("usage: %s <conf file>", argv[0]);
-        return 1;
-    }
-
-    if (!(dinfo = load_diskconfig(argv[1], NULL)))
-        return 1;
-
-    dump_disk_config(dinfo);
-
-    return 0;
-}
-
diff --git a/libdiskconfig/include/diskconfig/diskconfig.h b/libdiskconfig/include/diskconfig/diskconfig.h
deleted file mode 100644
index d45b99e24872..000000000000
--- a/libdiskconfig/include/diskconfig/diskconfig.h
+++ /dev/null
@@ -1,130 +0,0 @@
-/* system/core/include/diskconfig/diskconfig.h
- *
- * Copyright 2008, 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.
- */
-
-#ifndef __LIBS_DISKCONFIG_H
-#define __LIBS_DISKCONFIG_H
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define MAX_NAME_LEN                 512
-#define MAX_NUM_PARTS                16
-
-/* known partition schemes */
-#define PART_SCHEME_MBR              0x1
-#define PART_SCHEME_GPT              0x2
-
-/* PC Bios partition status */
-#define PC_PART_ACTIVE               0x80
-#define PC_PART_NORMAL               0x0
-
-/* Known (rather, used by us) partition types */
-#define PC_PART_TYPE_LINUX           0x83
-#define PC_PART_TYPE_EXTENDED        0x05
-#define PC_PART_TYPE_FAT32           0x0c
-
-#define PC_NUM_BOOT_RECORD_PARTS     4
-
-#define PC_EBR_LOGICAL_PART          0
-#define PC_EBR_NEXT_PTR_PART         1
-
-#define PC_BIOS_BOOT_SIG             0xAA55
-
-#define PC_MBR_DISK_OFFSET           0
-#define PC_MBR_SIZE                  512
-
-#define PART_ACTIVE_FLAG             0x1
-
-struct chs {
-    uint8_t head;
-    uint8_t sector;
-    uint8_t cylinder;
-} __attribute__((__packed__));
-
-/* 16 byte pc partition descriptor that sits in MBR and EPBR.
- * Note: multi-byte entities have little-endian layout on disk */
-struct pc_partition {
-    uint8_t status;     /* byte  0     */
-    struct chs start;   /* bytes 1-3   */
-    uint8_t type;       /* byte  4     */
-    struct chs end;     /* bytes 5-7   */
-    uint32_t start_lba; /* bytes 8-11  */
-    uint32_t len_lba;   /* bytes 12-15 */
-} __attribute__((__packed__));
-
-struct pc_boot_record {
-    uint8_t code[440];                                      /* bytes 0-439   */
-    uint32_t disk_sig;                                      /* bytes 440-443 */
-    uint16_t pad;                                           /* bytes 444-445 */
-    struct pc_partition ptable[PC_NUM_BOOT_RECORD_PARTS];   /* bytes 446-509 */
-    uint16_t mbr_sig;                                       /* bytes 510-511 */
-} __attribute__((__packed__));
-
-struct part_info {
-    char *name;
-    uint8_t flags;
-    uint8_t type;
-    uint32_t len_kb;       /* in 1K-bytes */
-    uint32_t start_lba;    /* the LBA where this partition begins */
-};
-
-struct disk_info {
-    char *device;
-    uint8_t scheme;
-    int sect_size;       /* expected sector size in bytes. MUST BE POWER OF 2 */
-    uint32_t skip_lba;   /* in sectors (1 unit of LBA) */
-    uint32_t num_lba;    /* the size of the disk in LBA units */
-    struct part_info *part_lst;
-    int num_parts;
-};
-
-struct write_list {
-    struct write_list *next;
-    loff_t offset;
-    uint32_t len;
-    uint8_t data[0];
-};
-
-
-struct write_list *alloc_wl(uint32_t data_len);
-void free_wl(struct write_list *item);
-struct write_list *wlist_add(struct write_list **lst, struct write_list *item);
-void wlist_free(struct write_list *lst);
-int wlist_commit(int fd, struct write_list *lst, int test);
-
-struct disk_info *load_diskconfig(const char *fn, char *path_override);
-int dump_disk_config(struct disk_info *dinfo);
-int apply_disk_config(struct disk_info *dinfo, int test);
-char *find_part_device(struct disk_info *dinfo, const char *name);
-int process_disk_config(struct disk_info *dinfo);
-struct part_info *find_part(struct disk_info *dinfo, const char *name);
-
-int write_raw_image(const char *dst, const char *src, loff_t offset, int test);
-
-/* For MBR partition schemes */
-struct write_list *config_mbr(struct disk_info *dinfo);
-char *find_mbr_part(struct disk_info *dinfo, const char *name);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __LIBS_DISKCONFIG_H */
diff --git a/libdiskconfig/write_lst.c b/libdiskconfig/write_lst.c
deleted file mode 100644
index c3d5c0ac1b9c..000000000000
--- a/libdiskconfig/write_lst.c
+++ /dev/null
@@ -1,92 +0,0 @@
-/* libs/diskconfig/write_lst.c
- *
- * Copyright 2008, 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.
- */
-
-#define LOG_TAG "write_lst"
-
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <diskconfig/diskconfig.h>
-#include <log/log.h>
-
-struct write_list *
-alloc_wl(uint32_t data_len)
-{
-    struct write_list *item;
-
-    if (!(item = malloc(sizeof(struct write_list) + data_len))) {
-        ALOGE("Unable to allocate memory.");
-        return NULL;
-    }
-
-    item->len = data_len;
-    return item;
-}
-
-void
-free_wl(struct write_list *item)
-{
-    if (item)
-        free(item);
-}
-
-struct write_list *
-wlist_add(struct write_list **lst, struct write_list *item)
-{
-    item->next = (*lst);
-    *lst = item;
-    return item;
-}
-
-void
-wlist_free(struct write_list *lst)
-{
-    struct write_list *temp_wr;
-    while (lst) {
-        temp_wr = lst->next;
-        free_wl(lst);
-        lst = temp_wr;
-    }
-}
-
-int
-wlist_commit(int fd, struct write_list *lst, int test)
-{
-    for(; lst; lst = lst->next) {
-        if (lseek64(fd, lst->offset, SEEK_SET) != (loff_t)lst->offset) {
-            ALOGE("Cannot seek to the specified position (%lld).", (long long)lst->offset);
-            goto fail;
-        }
-
-        if (!test) {
-            if (write(fd, lst->data, lst->len) != (int)lst->len) {
-                ALOGE("Failed writing %u bytes at position %lld.", lst->len,
-                     (long long)lst->offset);
-                goto fail;
-            }
-        } else
-            ALOGI("Would write %d bytes @ offset %lld.", lst->len, (long long)lst->offset);
-    }
-
-    return 0;
-
-fail:
-    return -1;
-}

From 702a779edb5d71d9f1be82713482a51ff69a8a3d Mon Sep 17 00:00:00 2001
From: Ray Chin <raychin@google.com>
Date: Tue, 23 May 2023 17:43:50 +0800
Subject: [PATCH 0066/1487] Fix overflow issue when computing ideal size of
 scratch partition

The type of f_frsize is `unsigned long` which is 32 bit for some system so it will overflow after multiplied by f_bfree. This solution adds one more type casting to ensure the type is 64 bit unsigned integer during the computing.

Bug: 281599020
Test: adb root; adb shell disable-verity
Change-Id: I377ed722d5e245c235c3ae12ff66ac7e91d1d6e8
---
 fs_mgr/fs_mgr_overlayfs.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/fs_mgr_overlayfs.cpp b/fs_mgr/fs_mgr_overlayfs.cpp
index ef436e580023..f04fc8d2f1b5 100644
--- a/fs_mgr/fs_mgr_overlayfs.cpp
+++ b/fs_mgr/fs_mgr_overlayfs.cpp
@@ -1083,7 +1083,7 @@ static inline uint64_t GetIdealDataScratchSize() {
         return 0;
     }
 
-    auto ideal_size = std::min(super_info.size, uint64_t(s.f_frsize * s.f_bfree * 0.85));
+    auto ideal_size = std::min(super_info.size, uint64_t(uint64_t(s.f_frsize) * s.f_bfree * 0.85));
 
     // Align up to the filesystem block size.
     if (auto remainder = ideal_size % s.f_bsize; remainder > 0) {

From 5a9905a62bf819d9eca4a7439ee51a8b5d12ef9d Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 23 May 2023 10:51:01 -0700
Subject: [PATCH 0067/1487] Fixing constructors to match header files

Constructor in cpp file doesn't match header file

Test: m fastboot, fastboot flashall -w
Change-Id: I2c720bb594efca5af1e5a374277543a522ced5ef
---
 fastboot/task.cpp | 4 ++--
 fastboot/task.h   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index ce46e91d5095..e98effb26d26 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -26,9 +26,9 @@
 #include "util.h"
 
 using namespace std::string_literals;
-FlashTask::FlashTask(const std::string& _slot, const std::string& _pname, const std::string& _fname,
+FlashTask::FlashTask(const std::string& slot, const std::string& pname, const std::string& fname,
                      const bool apply_vbmeta)
-    : pname_(_pname), fname_(_fname), slot_(_slot), apply_vbmeta_(apply_vbmeta) {}
+    : pname_(pname), fname_(fname), slot_(slot), apply_vbmeta_(apply_vbmeta) {}
 
 void FlashTask::Run() {
     auto flash = [&](const std::string& partition) {
diff --git a/fastboot/task.h b/fastboot/task.h
index 34e3e92aaebd..d113f18d585b 100644
--- a/fastboot/task.h
+++ b/fastboot/task.h
@@ -118,7 +118,7 @@ class ResizeTask : public Task {
 
 class DeleteTask : public Task {
   public:
-    DeleteTask(const FlashingPlan* _fp, const std::string& _pname);
+    DeleteTask(const FlashingPlan* fp, const std::string& pname);
     void Run() override;
 
   private:

From 4350592133f3b52671d680f91203f1596183033c Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Mon, 22 May 2023 22:21:46 +0000
Subject: [PATCH 0068/1487] init_kill_services_test: special case apexd

apexd restarts the device, so it causes flakes here,
especially in presubmit.

Bug: 280514080
Test: init_kill_services_test

Change-Id: I4455704795961f3ae94e29bdf098eca739130973
---
 init/test_kill_services/init_kill_services_test.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/init/test_kill_services/init_kill_services_test.cpp b/init/test_kill_services/init_kill_services_test.cpp
index 227380d719dc..d9fcd9d45376 100644
--- a/init/test_kill_services/init_kill_services_test.cpp
+++ b/init/test_kill_services/init_kill_services_test.cpp
@@ -23,8 +23,15 @@
 
 using ::android::base::GetProperty;
 using ::android::base::SetProperty;
+using ::android::base::WaitForProperty;
+using std::literals::chrono_literals::operator""s;
 
 void ExpectKillingServiceRecovers(const std::string& service_name) {
+    // b/280514080 - servicemanager will restart apexd, and apexd will restart the
+    // system when crashed. This is fine as the device recovers, but it causes
+    // flakes in this test.
+    ASSERT_TRUE(WaitForProperty("init.svc.apexd", "stopped", 60s)) << "apexd won't stop";
+
     LOG(INFO) << "hello " << service_name << "!";
     const std::string status_prop = "init.svc." + service_name;
     const std::string pid_prop = "init.svc_debug_pid." + service_name;

From 8231c3fe2da24bacdeb0d38edecd99aa098fa34c Mon Sep 17 00:00:00 2001
From: Jack Wu <wjack@google.com>
Date: Fri, 19 May 2023 14:31:53 +0800
Subject: [PATCH 0069/1487] BatteryMonitor: support battery health INCONSISTENT
 from health status

Report Battery health INCONSISTENT when there is a battery recalibration
pending.

Bug: 283182048
Test: m
Change-Id: I8b944ddac7cc919fc95b1b71b015101642a62f96
Signed-off-by: Jack Wu <wjack@google.com>
---
 healthd/BatteryMonitor.cpp               | 2 ++
 healthd/include/healthd/BatteryMonitor.h | 1 +
 2 files changed, 3 insertions(+)

diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index f68d65a54d70..bd7955a7f8b4 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -244,6 +244,8 @@ BatteryHealth getBatteryHealthStatus(int status) {
         value = BatteryHealth::UNSPECIFIED_FAILURE;
     else if (status == BatteryMonitor::BH_NOT_AVAILABLE)
         value = BatteryHealth::NOT_AVAILABLE;
+    else if (status == BatteryMonitor::BH_INCONSISTENT)
+        value = BatteryHealth::INCONSISTENT;
     else
         value = BatteryHealth::UNKNOWN;
 
diff --git a/healthd/include/healthd/BatteryMonitor.h b/healthd/include/healthd/BatteryMonitor.h
index a4c013b86b33..e9998ba7a3af 100644
--- a/healthd/include/healthd/BatteryMonitor.h
+++ b/healthd/include/healthd/BatteryMonitor.h
@@ -63,6 +63,7 @@ class BatteryMonitor {
         BH_NEEDS_REPLACEMENT,
         BH_FAILED,
         BH_NOT_AVAILABLE,
+        BH_INCONSISTENT,
     };
 
     BatteryMonitor();

From 98d6242dc767d6f5fa15e4f63643391ae8e7c47f Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Wed, 24 May 2023 20:01:10 +0000
Subject: [PATCH 0070/1487] Limit the number of log messages in a tombstone.

Some testing environments can have a test that is sending many
thousands of messages to the log. When this type of process crashes
all of these log messages are captured and can cause OOM errors
while creating the tombstone.

Added a test to verify the log messages are truncated. Leaving this
test disabled for now since it is inherently flaky due to having to
assume that 500 messages are in the log.

Added a test for a newline in a log message since it's somewhat
related to this change.

NOTE: The total number of messages is capped at 500, but if a message
contains multiple newlines, the total messages will exceed 500.
Counting messages this way seems to be in the spirit of the cap,
that a process logging a large message with multiple newlines does
not completely fill the tombstone log data.

Bug: 269182937
Bug: 282661754

Test: All unit tests pass.
Test: The disabled max_log_messages test passes.
Change-Id: If18e62b29f899c2c4670101b402e37762bffbec6
---
 debuggerd/debuggerd_test.cpp               | 45 ++++++++++++++++++++++
 debuggerd/libdebuggerd/tombstone_proto.cpp |  7 +++-
 2 files changed, 50 insertions(+), 2 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 39d7fff1ca86..4cd619337167 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -2759,3 +2759,48 @@ TEST_F(CrasherTest, logd_skips_reading_logs_not_main_thread) {
   ASSERT_BACKTRACE_FRAME(result, "raise_debugger_signal");
   ASSERT_NOT_MATCH(result, kLogMessage);
 }
+
+// Disable this test since there is a high liklihood that this would
+// be flaky since it requires 500 messages being in the log.
+TEST_F(CrasherTest, DISABLED_max_log_messages) {
+  StartProcess([]() {
+    for (size_t i = 0; i < 600; i++) {
+      LOG(INFO) << "Message number " << i;
+    }
+    abort();
+  });
+
+  unique_fd output_fd;
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  int intercept_result;
+  FinishIntercept(&intercept_result);
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_NOT_MATCH(result, "Message number 99");
+  ASSERT_MATCH(result, "Message number 100");
+  ASSERT_MATCH(result, "Message number 599");
+}
+
+TEST_F(CrasherTest, log_with_newline) {
+  StartProcess([]() {
+    LOG(INFO) << "This line has a newline.\nThis is on the next line.";
+    abort();
+  });
+
+  unique_fd output_fd;
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  int intercept_result;
+  FinishIntercept(&intercept_result);
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_MATCH(result, ":\\s*This line has a newline.");
+  ASSERT_MATCH(result, ":\\s*This is on the next line.");
+}
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index acd814efa68b..7b2e0689e440 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -70,6 +70,9 @@
 
 using android::base::StringPrintf;
 
+// The maximum number of messages to save in the protobuf per file.
+static constexpr size_t kMaxLogMessages = 500;
+
 // Use the demangler from libc++.
 extern "C" char* __cxa_demangle(const char*, char*, size_t*, int* status);
 
@@ -491,8 +494,8 @@ static void dump_mappings(Tombstone* tombstone, unwindstack::Maps* maps,
 }
 
 static void dump_log_file(Tombstone* tombstone, const char* logger, pid_t pid) {
-  logger_list* logger_list =
-      android_logger_list_open(android_name_to_log_id(logger), ANDROID_LOG_NONBLOCK, 0, pid);
+  logger_list* logger_list = android_logger_list_open(android_name_to_log_id(logger),
+                                                      ANDROID_LOG_NONBLOCK, kMaxLogMessages, pid);
 
   LogBuffer buffer;
 

From 7003fba5f2864ad5138a42fb4bef36bea0cbc944 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Wed, 24 May 2023 20:01:10 +0000
Subject: [PATCH 0071/1487] Limit the number of log messages in a tombstone.

Some testing environments can have a test that is sending many
thousands of messages to the log. When this type of process crashes
all of these log messages are captured and can cause OOM errors
while creating the tombstone.

Added a test to verify the log messages are truncated. Leaving this
test disabled for now since it is inherently flaky due to having to
assume that 500 messages are in the log.

Added a test for a newline in a log message since it's somewhat
related to this change.

NOTE: The total number of messages is capped at 500, but if a message
contains multiple newlines, the total messages will exceed 500.
Counting messages this way seems to be in the spirit of the cap,
that a process logging a large message with multiple newlines does
not completely fill the tombstone log data.

Bug: 269182937
Bug: 282661754

Test: All unit tests pass.
Test: The disabled max_log_messages test passes.
Change-Id: If18e62b29f899c2c4670101b402e37762bffbec6
Merged-In: If18e62b29f899c2c4670101b402e37762bffbec6
(cherry picked from commit 98d6242dc767d6f5fa15e4f63643391ae8e7c47f)
---
 debuggerd/debuggerd_test.cpp               | 45 ++++++++++++++++++++++
 debuggerd/libdebuggerd/tombstone_proto.cpp |  7 +++-
 2 files changed, 50 insertions(+), 2 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 39d7fff1ca86..4cd619337167 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -2759,3 +2759,48 @@ TEST_F(CrasherTest, logd_skips_reading_logs_not_main_thread) {
   ASSERT_BACKTRACE_FRAME(result, "raise_debugger_signal");
   ASSERT_NOT_MATCH(result, kLogMessage);
 }
+
+// Disable this test since there is a high liklihood that this would
+// be flaky since it requires 500 messages being in the log.
+TEST_F(CrasherTest, DISABLED_max_log_messages) {
+  StartProcess([]() {
+    for (size_t i = 0; i < 600; i++) {
+      LOG(INFO) << "Message number " << i;
+    }
+    abort();
+  });
+
+  unique_fd output_fd;
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  int intercept_result;
+  FinishIntercept(&intercept_result);
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_NOT_MATCH(result, "Message number 99");
+  ASSERT_MATCH(result, "Message number 100");
+  ASSERT_MATCH(result, "Message number 599");
+}
+
+TEST_F(CrasherTest, log_with_newline) {
+  StartProcess([]() {
+    LOG(INFO) << "This line has a newline.\nThis is on the next line.";
+    abort();
+  });
+
+  unique_fd output_fd;
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  int intercept_result;
+  FinishIntercept(&intercept_result);
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_MATCH(result, ":\\s*This line has a newline.");
+  ASSERT_MATCH(result, ":\\s*This is on the next line.");
+}
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index acd814efa68b..7b2e0689e440 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -70,6 +70,9 @@
 
 using android::base::StringPrintf;
 
+// The maximum number of messages to save in the protobuf per file.
+static constexpr size_t kMaxLogMessages = 500;
+
 // Use the demangler from libc++.
 extern "C" char* __cxa_demangle(const char*, char*, size_t*, int* status);
 
@@ -491,8 +494,8 @@ static void dump_mappings(Tombstone* tombstone, unwindstack::Maps* maps,
 }
 
 static void dump_log_file(Tombstone* tombstone, const char* logger, pid_t pid) {
-  logger_list* logger_list =
-      android_logger_list_open(android_name_to_log_id(logger), ANDROID_LOG_NONBLOCK, 0, pid);
+  logger_list* logger_list = android_logger_list_open(android_name_to_log_id(logger),
+                                                      ANDROID_LOG_NONBLOCK, kMaxLogMessages, pid);
 
   LogBuffer buffer;
 

From 4d8f37edae8e471e8524a3bd3b88f46700200d4d Mon Sep 17 00:00:00 2001
From: liwentao <liwentao@eswincomputing.com>
Date: Thu, 25 May 2023 18:03:43 +0800
Subject: [PATCH 0072/1487] Updated the policy file associated with riscv64

The generate.sh script can generate the file, but current policy file does not match it.
And the rules are not appropriate, like missing "sysinfo", causing the
debuggerd_test to fail in system model. So we match the policy to
what it should be.

Test: make debuggerd_test

Change-Id: I57ebd7713f2ab939d01bfefcc7935e234fdd3e13
Signed-off-by: liwentao <liwentao@eswincomputing.com>
---
 debuggerd/seccomp_policy/crash_dump.riscv64.policy | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/debuggerd/seccomp_policy/crash_dump.riscv64.policy b/debuggerd/seccomp_policy/crash_dump.riscv64.policy
index 21887abe0799..281e231b0135 100644
--- a/debuggerd/seccomp_policy/crash_dump.riscv64.policy
+++ b/debuggerd/seccomp_policy/crash_dump.riscv64.policy
@@ -19,12 +19,13 @@ getdents64: 1
 faccessat: 1
 recvmsg: 1
 recvfrom: 1
+sysinfo: 1
 process_vm_readv: 1
 tgkill: 1
 rt_sigprocmask: 1
 rt_sigaction: 1
 rt_tgsigqueueinfo: 1
-prctl: arg0 == PR_GET_NO_NEW_PRIVS || arg0 == 0x53564d41 || arg0 == PR_PAC_RESET_KEYS
+prctl: arg0 == PR_GET_NO_NEW_PRIVS || arg0 == 0x53564d41
 madvise: 1
 mprotect: arg2 in 0x1|0x2
 munmap: 1

From 004a16739d4c746b3b5e082d986a30bb21476f40 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Wed, 24 May 2023 13:47:37 -0700
Subject: [PATCH 0073/1487] Check get_gwp_asan_callbacks before calling.

When using the bootstrap linker, the get_gwp_asan_callbacks is
not set. Therefore, check it is not nullptr before calling it
during crash processing.

Bug: 284098779

Test: Ran crasher64 using /system/bin/bootstrap/linker64 and verify
Test: debuggerd code does not crash.
Test: All unit tests pass.
Change-Id: Ifc710fe4bef24661700444a1b69432bfc29d580f
---
 debuggerd/handler/debuggerd_handler.cpp | 32 ++++++++++++++-----------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index baa5bfb50677..c6a535ad6d7f 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -566,20 +566,23 @@ static void debuggerd_signal_handler(int signal_number, siginfo_t* info, void* c
     process_info = g_callbacks.get_process_info();
   }
 
-  // GWP-ASan catches use-after-free and heap-buffer-overflow by using PROT_NONE
-  // guard pages, which lead to SEGV. Normally, debuggerd prints a bug report
-  // and the process terminates, but in some cases, we actually want to print
-  // the bug report and let the signal handler return, and restart the process.
-  // In order to do that, we need to disable GWP-ASan's guard pages. The
-  // following callbacks handle this case.
-  gwp_asan_callbacks_t gwp_asan_callbacks = g_callbacks.get_gwp_asan_callbacks();
-  if (signal_number == SIGSEGV && signal_has_si_addr(info) &&
-      gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery &&
-      gwp_asan_callbacks.debuggerd_gwp_asan_pre_crash_report &&
-      gwp_asan_callbacks.debuggerd_gwp_asan_post_crash_report &&
-      gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery(info->si_addr)) {
-    gwp_asan_callbacks.debuggerd_gwp_asan_pre_crash_report(info->si_addr);
-    process_info.recoverable_gwp_asan_crash = true;
+  gwp_asan_callbacks_t gwp_asan_callbacks = {};
+  if (g_callbacks.get_gwp_asan_callbacks != nullptr) {
+    // GWP-ASan catches use-after-free and heap-buffer-overflow by using PROT_NONE
+    // guard pages, which lead to SEGV. Normally, debuggerd prints a bug report
+    // and the process terminates, but in some cases, we actually want to print
+    // the bug report and let the signal handler return, and restart the process.
+    // In order to do that, we need to disable GWP-ASan's guard pages. The
+    // following callbacks handle this case.
+    gwp_asan_callbacks = g_callbacks.get_gwp_asan_callbacks();
+    if (signal_number == SIGSEGV && signal_has_si_addr(info) &&
+        gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery &&
+        gwp_asan_callbacks.debuggerd_gwp_asan_pre_crash_report &&
+        gwp_asan_callbacks.debuggerd_gwp_asan_post_crash_report &&
+        gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery(info->si_addr)) {
+      gwp_asan_callbacks.debuggerd_gwp_asan_pre_crash_report(info->si_addr);
+      process_info.recoverable_gwp_asan_crash = true;
+    }
   }
 
   // If sival_int is ~0, it means that the fallback handler has been called
@@ -764,6 +767,7 @@ void debuggerd_init(debuggerd_callbacks_t* callbacks) {
 bool debuggerd_handle_signal(int signal_number, siginfo_t* info, void* context) {
   if (signal_number != SIGSEGV || !signal_has_si_addr(info)) return false;
 
+  if (g_callbacks.get_gwp_asan_callbacks == nullptr) return false;
   gwp_asan_callbacks_t gwp_asan_callbacks = g_callbacks.get_gwp_asan_callbacks();
   if (gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery == nullptr ||
       gwp_asan_callbacks.debuggerd_gwp_asan_pre_crash_report == nullptr ||

From 791a83bb4565b3b2a4e3d40ea2c0ec592cfb0d04 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 23 May 2023 10:42:39 -0700
Subject: [PATCH 0074/1487] Chang flash task to take in source

Old changes didn't actually take into account sources. fastboot update
{update.zip} should read fastboot-info from the update package. It was
instead flashing local images + reading local fastboot-info.txt

Test: m fastboot, fastboot update, fastboot flashall
Bug: 283330320

Change-Id: I9587a7735ddfbfb661153eb12ebc3caa7c32f141
---
 fastboot/fastboot.cpp | 47 +++++++++++++++++++++----------------------
 fastboot/fastboot.h   |  3 ++-
 fastboot/task.cpp     |  6 +++---
 fastboot/task.h       |  3 ++-
 4 files changed, 30 insertions(+), 29 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index f09616a49507..f5fd3a1ea350 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1487,13 +1487,20 @@ static std::string repack_ramdisk(const char* pname, struct fastboot_buffer* buf
     return partition;
 }
 
-void do_flash(const char* pname, const char* fname, const bool apply_vbmeta) {
+void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,
+              const FlashingPlan* fp) {
     verbose("Do flash %s %s", pname, fname);
     struct fastboot_buffer buf;
 
-    if (!load_buf(fname, &buf)) {
+    if (fp->source) {
+        unique_fd fd = fp->source->OpenFile(fname);
+        if (fd < 0 || !load_buf_fd(std::move(fd), &buf)) {
+            die("could not load '%s': %s", fname, strerror(errno));
+        }
+    } else if (!load_buf(fname, &buf)) {
         die("cannot load '%s': %s", fname, strerror(errno));
     }
+
     if (is_logical(pname)) {
         fb->ResizePartition(pname, std::to_string(buf.image_size));
     }
@@ -1592,7 +1599,7 @@ std::unique_ptr<FlashTask> ParseFlashCommand(const FlashingPlan* fp,
     if (img_name.empty()) {
         img_name = partition + ".img";
     }
-    return std::make_unique<FlashTask>(slot, partition, img_name, apply_vbmeta);
+    return std::make_unique<FlashTask>(slot, partition, img_name, apply_vbmeta, fp);
 }
 
 std::unique_ptr<RebootTask> ParseRebootCommand(const FlashingPlan* fp,
@@ -1666,7 +1673,7 @@ void AddResizeTasks(const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>*
 }
 
 static bool IsIgnore(const std::vector<std::string>& command) {
-    if (command[0][0] == '#') {
+    if (command.size() == 0 || command[0][0] == '#') {
         return true;
     }
     return false;
@@ -1748,16 +1755,6 @@ std::vector<std::unique_ptr<Task>> ParseFastbootInfo(const FlashingPlan* fp,
     return tasks;
 }
 
-std::vector<std::unique_ptr<Task>> ParseFastbootInfo(const FlashingPlan* fp, std::ifstream& fs) {
-    std::string text;
-    std::vector<std::string> file;
-    // Get os_partitions that need to be resized
-    while (std::getline(fs, text)) {
-        file.emplace_back(text);
-    }
-    return ParseFastbootInfo(fp, file);
-}
-
 FlashAllTool::FlashAllTool(FlashingPlan* fp) : fp_(fp) {}
 
 void FlashAllTool::Flash() {
@@ -1777,16 +1774,17 @@ void FlashAllTool::Flash() {
 
     CancelSnapshotIfNeeded();
 
-    std::string path = find_item_given_name("fastboot-info.txt");
-    std::ifstream stream(path);
-    if (!stream || stream.eof()) {
+    std::vector<char> contents;
+    if (!fp_->source->ReadFile("fastboot-info.txt", &contents)) {
         LOG(VERBOSE) << "Flashing from hardcoded images. fastboot-info.txt is empty or does not "
                         "exist";
         HardcodedFlash();
         return;
     }
 
-    std::vector<std::unique_ptr<Task>> tasks = ParseFastbootInfo(fp_, stream);
+    std::vector<std::unique_ptr<Task>> tasks =
+            ParseFastbootInfo(fp_, Split({contents.data(), contents.size()}, "\n"));
+
     if (tasks.empty()) {
         LOG(FATAL) << "Invalid fastboot-info.txt file.";
     }
@@ -2115,7 +2113,7 @@ bool should_flash_in_userspace(const std::string& partition_name) {
 }
 
 static bool wipe_super(const android::fs_mgr::LpMetadata& metadata, const std::string& slot,
-                       std::string* message) {
+                       std::string* message, const FlashingPlan* fp) {
     auto super_device = GetMetadataSuperBlockDevice(metadata);
     auto block_size = metadata.geometry.logical_block_size;
     auto super_bdev_name = android::fs_mgr::GetBlockDevicePartitionName(*super_device);
@@ -2155,7 +2153,7 @@ static bool wipe_super(const android::fs_mgr::LpMetadata& metadata, const std::s
 
         auto image_path = temp_dir.path + "/"s + image_name;
         auto flash = [&](const std::string& partition_name) {
-            do_flash(partition_name.c_str(), image_path.c_str(), false);
+            do_flash(partition_name.c_str(), image_path.c_str(), false, fp);
         };
         do_for_partitions(partition, slot, flash, force_slot);
 
@@ -2164,7 +2162,8 @@ static bool wipe_super(const android::fs_mgr::LpMetadata& metadata, const std::s
     return true;
 }
 
-static void do_wipe_super(const std::string& image, const std::string& slot_override) {
+static void do_wipe_super(const std::string& image, const std::string& slot_override,
+                          const FlashingPlan* fp) {
     if (access(image.c_str(), R_OK) != 0) {
         die("Could not read image: %s", image.c_str());
     }
@@ -2179,7 +2178,7 @@ static void do_wipe_super(const std::string& image, const std::string& slot_over
     }
 
     std::string message;
-    if (!wipe_super(*metadata.get(), slot, &message)) {
+    if (!wipe_super(*metadata.get(), slot, &message, fp)) {
         die(message);
     }
 }
@@ -2476,7 +2475,7 @@ int FastBootTool::Main(int argc, char* argv[]) {
             }
             if (fname.empty()) die("cannot determine image filename for '%s'", pname.c_str());
 
-            FlashTask task(fp->slot_override, pname, fname, is_vbmeta_partition(pname));
+            FlashTask task(fp->slot_override, pname, fname, is_vbmeta_partition(pname), fp.get());
             task.Run();
         } else if (command == "flash:raw") {
             std::string partition = next_arg(&args);
@@ -2571,7 +2570,7 @@ int FastBootTool::Main(int argc, char* argv[]) {
             } else {
                 image = next_arg(&args);
             }
-            do_wipe_super(image, fp->slot_override);
+            do_wipe_super(image, fp->slot_override, fp.get());
         } else if (command == "snapshot-update") {
             std::string arg;
             if (!args.empty()) {
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index 80b77a0e95e3..0a1f1eb66773 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -124,7 +124,8 @@ class FlashAllTool {
 
 bool should_flash_in_userspace(const std::string& partition_name);
 bool is_userspace_fastboot();
-void do_flash(const char* pname, const char* fname, const bool apply_vbmeta);
+void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,
+              const FlashingPlan* fp);
 void do_for_partitions(const std::string& part, const std::string& slot,
                        const std::function<void(const std::string&)>& func, bool force_slot);
 std::string find_item(const std::string& item);
diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index e98effb26d26..cb12060b8624 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -27,8 +27,8 @@
 
 using namespace std::string_literals;
 FlashTask::FlashTask(const std::string& slot, const std::string& pname, const std::string& fname,
-                     const bool apply_vbmeta)
-    : pname_(pname), fname_(fname), slot_(slot), apply_vbmeta_(apply_vbmeta) {}
+                     const bool apply_vbmeta, const FlashingPlan* fp)
+    : pname_(pname), fname_(fname), slot_(slot), apply_vbmeta_(apply_vbmeta), fp_(fp) {}
 
 void FlashTask::Run() {
     auto flash = [&](const std::string& partition) {
@@ -41,7 +41,7 @@ void FlashTask::Run() {
                 "And try again. If you are intentionally trying to "
                 "overwrite a fixed partition, use --force.");
         }
-        do_flash(partition.c_str(), fname_.c_str(), apply_vbmeta_);
+        do_flash(partition.c_str(), fname_.c_str(), apply_vbmeta_, fp_);
     };
     do_for_partitions(pname_, slot_, flash, true);
 }
diff --git a/fastboot/task.h b/fastboot/task.h
index d113f18d585b..82e8ebf51e01 100644
--- a/fastboot/task.h
+++ b/fastboot/task.h
@@ -46,7 +46,7 @@ class Task {
 class FlashTask : public Task {
   public:
     FlashTask(const std::string& slot, const std::string& pname, const std::string& fname,
-              const bool apply_vbmeta);
+              const bool apply_vbmeta, const FlashingPlan* fp);
     virtual FlashTask* AsFlashTask() override { return this; }
 
     std::string GetPartition() { return pname_; }
@@ -60,6 +60,7 @@ class FlashTask : public Task {
     const std::string fname_;
     const std::string slot_;
     const bool apply_vbmeta_;
+    const FlashingPlan* fp_;
 };
 
 class RebootTask : public Task {

From 2775df617e5ea96e1f9adf9fb55758d7bd0cdfe7 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 25 May 2023 15:14:59 -0700
Subject: [PATCH 0075/1487] Removing should_flash_in_userspace check

This check isn't needed as super_flash_helper.cpp calls a different
should_flash_in_userspace that isn't reliant on $ANDROID_PRODUCT_OUT
being set. Current code will fail when calling fastboot update

Test: fastboot update update.zip without calling lunch
Bug: 283330320
Change-Id: Icefe6092befb747b7f419ea997e0834602808d69
---
 fastboot/task.cpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index cb12060b8624..9ce2cfd201d7 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -214,11 +214,9 @@ std::unique_ptr<FlashSuperLayoutTask> FlashSuperLayoutTask::InitializeFromTasks(
 
     for (const auto& task : tasks) {
         if (auto flash_task = task->AsFlashTask()) {
-            if (should_flash_in_userspace(flash_task->GetPartitionAndSlot())) {
-                auto partition = flash_task->GetPartitionAndSlot();
-                if (!helper->AddPartition(partition, flash_task->GetImageName(), false)) {
-                    return nullptr;
-                }
+            auto partition = flash_task->GetPartitionAndSlot();
+            if (!helper->AddPartition(partition, flash_task->GetImageName(), false)) {
+                return nullptr;
             }
         }
     }

From 30e648b346599d9bd745e083148e545afa4142f2 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 25 May 2023 15:56:29 -0700
Subject: [PATCH 0076/1487] Keeping naming consistent

Test: m fastboot
Change-Id: I46d798fa2ce78a255dc0ea414f5e25782f45c4d1
---
 fastboot/fastboot.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index f5fd3a1ea350..fcad0d915ddc 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -775,7 +775,7 @@ static int make_temporary_fd(const char* what) {
 
 #endif
 
-static unique_fd unzip_to_file(ZipArchiveHandle zip, const char* entry_name) {
+static unique_fd UnzipToFile(ZipArchiveHandle zip, const char* entry_name) {
     unique_fd fd(make_temporary_fd(entry_name));
 
     ZipEntry64 zip_entry;
@@ -1928,7 +1928,7 @@ bool ZipImageSource::ReadFile(const std::string& name, std::vector<char>* out) c
 }
 
 unique_fd ZipImageSource::OpenFile(const std::string& name) const {
-    return unzip_to_file(zip_, name.c_str());
+    return UnzipToFile(zip_, name.c_str());
 }
 
 static void do_update(const char* filename, FlashingPlan* fp) {

From d278f1d01822e47fa1e7292f6bbe87967d8db297 Mon Sep 17 00:00:00 2001
From: Will McVicker <willmcvicker@google.com>
Date: Thu, 25 May 2023 16:43:31 -0700
Subject: [PATCH 0077/1487] toolbox/modprobe: Fix fallback path when mod_dirs
 is empty

Due to GKI, the kernel UTS release string will not always (if ever)
match the vendor's UTS release string that is used to create the
initramfs file structure -- /lib/modules/<vendor uname>. This causes
module load failures when `-d DIR` is omitted. To fix this, we can
include all of the versions under /lib/modules that match the kernel's
major and minor version instead of directly using the value of uname().
In addition, we can also support modules being loaded directly from
/lib/modules.

Test: verify GKI kernel + initramfs with different UTS strings
Test: verify GKI kernel + initramfs with modules directly in /lib/modules
Fixes: 83207784251c ("toolbox/modprobe: Fallback to /lib/modules/<uname> ")
Bug: 282917063
Bug: 254835242
Change-Id: I5368f5cff139ba3165323a6a91066be38bfa0736
---
 toolbox/modprobe.cpp | 44 ++++++++++++++++++++++++++++++++++++--------
 1 file changed, 36 insertions(+), 8 deletions(-)

diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index 17f815697ef3..17d4e319b6b5 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -85,6 +85,26 @@ void MyLogger(android::base::LogId id, android::base::LogSeverity severity, cons
     }
 }
 
+// Find directories in format of "/lib/modules/x.y.z-*".
+static int KernelVersionNameFilter(const dirent* de) {
+    unsigned int major, minor;
+    static std::string kernel_version;
+    utsname uts;
+
+    if (kernel_version.empty()) {
+        if ((uname(&uts) != 0) || (sscanf(uts.release, "%u.%u", &major, &minor) != 2)) {
+            LOG(ERROR) << "Could not parse the kernel version from uname";
+            return 0;
+        }
+        kernel_version = android::base::StringPrintf("%u.%u", major, minor);
+    }
+
+    if (android::base::StartsWith(de->d_name, kernel_version)) {
+        return 1;
+    }
+    return 0;
+}
+
 }  // anonymous namespace
 
 extern "C" int modprobe_main(int argc, char** argv) {
@@ -192,9 +212,22 @@ extern "C" int modprobe_main(int argc, char** argv) {
     }
 
     if (mod_dirs.empty()) {
-        utsname uts;
-        uname(&uts);
-        mod_dirs.emplace_back(android::base::StringPrintf("/lib/modules/%s", uts.release));
+        static constexpr auto LIB_MODULES_PREFIX = "/lib/modules/";
+        dirent** kernel_dirs = NULL;
+
+        int n = scandir(LIB_MODULES_PREFIX, &kernel_dirs, KernelVersionNameFilter, NULL);
+        if (n == -1) {
+            PLOG(ERROR) << "Failed to scan dir " << LIB_MODULES_PREFIX;
+            return EXIT_FAILURE;
+        } else if (n > 0) {
+            while (n--) {
+                mod_dirs.emplace_back(LIB_MODULES_PREFIX + std::string(kernel_dirs[n]->d_name));
+            }
+        }
+        free(kernel_dirs);
+
+        // Allow modules to be directly inside /lib/modules
+        mod_dirs.emplace_back(LIB_MODULES_PREFIX);
     }
 
     LOG(DEBUG) << "mode is " << mode;
@@ -212,11 +245,6 @@ extern "C" int modprobe_main(int argc, char** argv) {
             return EXIT_FAILURE;
         }
     }
-    if (mod_dirs.empty()) {
-        LOG(ERROR) << "No module configuration directories given.";
-        print_usage();
-        return EXIT_FAILURE;
-    }
     if (parameter_count && modules.size() > 1) {
         LOG(ERROR) << "Only one module may be loaded when specifying module parameters.";
         print_usage();

From cf140fb761dc0437af9c2268d4869e2778c24900 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Wed, 24 May 2023 13:47:37 -0700
Subject: [PATCH 0078/1487] Check get_gwp_asan_callbacks before calling.

When using the bootstrap linker, the get_gwp_asan_callbacks is
not set. Therefore, check it is not nullptr before calling it
during crash processing.

Bug: 284098779

Test: Ran crasher64 using /system/bin/bootstrap/linker64 and verify
Test: debuggerd code does not crash.
Test: All unit tests pass.
Change-Id: Ifc710fe4bef24661700444a1b69432bfc29d580f
Merged-In: Ifc710fe4bef24661700444a1b69432bfc29d580f
(cherry picked from commit 004a16739d4c746b3b5e082d986a30bb21476f40)
---
 debuggerd/handler/debuggerd_handler.cpp | 32 ++++++++++++++-----------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index baa5bfb50677..c6a535ad6d7f 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -566,20 +566,23 @@ static void debuggerd_signal_handler(int signal_number, siginfo_t* info, void* c
     process_info = g_callbacks.get_process_info();
   }
 
-  // GWP-ASan catches use-after-free and heap-buffer-overflow by using PROT_NONE
-  // guard pages, which lead to SEGV. Normally, debuggerd prints a bug report
-  // and the process terminates, but in some cases, we actually want to print
-  // the bug report and let the signal handler return, and restart the process.
-  // In order to do that, we need to disable GWP-ASan's guard pages. The
-  // following callbacks handle this case.
-  gwp_asan_callbacks_t gwp_asan_callbacks = g_callbacks.get_gwp_asan_callbacks();
-  if (signal_number == SIGSEGV && signal_has_si_addr(info) &&
-      gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery &&
-      gwp_asan_callbacks.debuggerd_gwp_asan_pre_crash_report &&
-      gwp_asan_callbacks.debuggerd_gwp_asan_post_crash_report &&
-      gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery(info->si_addr)) {
-    gwp_asan_callbacks.debuggerd_gwp_asan_pre_crash_report(info->si_addr);
-    process_info.recoverable_gwp_asan_crash = true;
+  gwp_asan_callbacks_t gwp_asan_callbacks = {};
+  if (g_callbacks.get_gwp_asan_callbacks != nullptr) {
+    // GWP-ASan catches use-after-free and heap-buffer-overflow by using PROT_NONE
+    // guard pages, which lead to SEGV. Normally, debuggerd prints a bug report
+    // and the process terminates, but in some cases, we actually want to print
+    // the bug report and let the signal handler return, and restart the process.
+    // In order to do that, we need to disable GWP-ASan's guard pages. The
+    // following callbacks handle this case.
+    gwp_asan_callbacks = g_callbacks.get_gwp_asan_callbacks();
+    if (signal_number == SIGSEGV && signal_has_si_addr(info) &&
+        gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery &&
+        gwp_asan_callbacks.debuggerd_gwp_asan_pre_crash_report &&
+        gwp_asan_callbacks.debuggerd_gwp_asan_post_crash_report &&
+        gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery(info->si_addr)) {
+      gwp_asan_callbacks.debuggerd_gwp_asan_pre_crash_report(info->si_addr);
+      process_info.recoverable_gwp_asan_crash = true;
+    }
   }
 
   // If sival_int is ~0, it means that the fallback handler has been called
@@ -764,6 +767,7 @@ void debuggerd_init(debuggerd_callbacks_t* callbacks) {
 bool debuggerd_handle_signal(int signal_number, siginfo_t* info, void* context) {
   if (signal_number != SIGSEGV || !signal_has_si_addr(info)) return false;
 
+  if (g_callbacks.get_gwp_asan_callbacks == nullptr) return false;
   gwp_asan_callbacks_t gwp_asan_callbacks = g_callbacks.get_gwp_asan_callbacks();
   if (gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery == nullptr ||
       gwp_asan_callbacks.debuggerd_gwp_asan_pre_crash_report == nullptr ||

From e067e96da26111e446c5deadefd839a6451dd6d1 Mon Sep 17 00:00:00 2001
From: Will McVicker <willmcvicker@google.com>
Date: Thu, 25 May 2023 16:43:31 -0700
Subject: [PATCH 0079/1487] toolbox/modprobe: Fix fallback path when mod_dirs
 is empty

Due to GKI, the kernel UTS release string will not always (if ever)
match the vendor's UTS release string that is used to create the
initramfs file structure -- /lib/modules/<vendor uname>. This causes
module load failures when `-d DIR` is omitted. To fix this, we can
include all of the versions under /lib/modules that match the kernel's
major and minor version instead of directly using the value of uname().
In addition, we can also support modules being loaded directly from
/lib/modules.

Test: verify GKI kernel + initramfs with different UTS strings
Test: verify GKI kernel + initramfs with modules directly in /lib/modules
Fixes: 83207784251c ("toolbox/modprobe: Fallback to /lib/modules/<uname> ")
Bug: 282917063
Bug: 254835242
Merged-In: I5368f5cff139ba3165323a6a91066be38bfa0736
Change-Id: I5368f5cff139ba3165323a6a91066be38bfa0736
---
 toolbox/modprobe.cpp | 44 ++++++++++++++++++++++++++++++++++++--------
 1 file changed, 36 insertions(+), 8 deletions(-)

diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index 17f815697ef3..17d4e319b6b5 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -85,6 +85,26 @@ void MyLogger(android::base::LogId id, android::base::LogSeverity severity, cons
     }
 }
 
+// Find directories in format of "/lib/modules/x.y.z-*".
+static int KernelVersionNameFilter(const dirent* de) {
+    unsigned int major, minor;
+    static std::string kernel_version;
+    utsname uts;
+
+    if (kernel_version.empty()) {
+        if ((uname(&uts) != 0) || (sscanf(uts.release, "%u.%u", &major, &minor) != 2)) {
+            LOG(ERROR) << "Could not parse the kernel version from uname";
+            return 0;
+        }
+        kernel_version = android::base::StringPrintf("%u.%u", major, minor);
+    }
+
+    if (android::base::StartsWith(de->d_name, kernel_version)) {
+        return 1;
+    }
+    return 0;
+}
+
 }  // anonymous namespace
 
 extern "C" int modprobe_main(int argc, char** argv) {
@@ -192,9 +212,22 @@ extern "C" int modprobe_main(int argc, char** argv) {
     }
 
     if (mod_dirs.empty()) {
-        utsname uts;
-        uname(&uts);
-        mod_dirs.emplace_back(android::base::StringPrintf("/lib/modules/%s", uts.release));
+        static constexpr auto LIB_MODULES_PREFIX = "/lib/modules/";
+        dirent** kernel_dirs = NULL;
+
+        int n = scandir(LIB_MODULES_PREFIX, &kernel_dirs, KernelVersionNameFilter, NULL);
+        if (n == -1) {
+            PLOG(ERROR) << "Failed to scan dir " << LIB_MODULES_PREFIX;
+            return EXIT_FAILURE;
+        } else if (n > 0) {
+            while (n--) {
+                mod_dirs.emplace_back(LIB_MODULES_PREFIX + std::string(kernel_dirs[n]->d_name));
+            }
+        }
+        free(kernel_dirs);
+
+        // Allow modules to be directly inside /lib/modules
+        mod_dirs.emplace_back(LIB_MODULES_PREFIX);
     }
 
     LOG(DEBUG) << "mode is " << mode;
@@ -212,11 +245,6 @@ extern "C" int modprobe_main(int argc, char** argv) {
             return EXIT_FAILURE;
         }
     }
-    if (mod_dirs.empty()) {
-        LOG(ERROR) << "No module configuration directories given.";
-        print_usage();
-        return EXIT_FAILURE;
-    }
     if (parameter_count && modules.size() > 1) {
         LOG(ERROR) << "Only one module may be loaded when specifying module parameters.";
         print_usage();

From 4a7d98402c01c896a204e8b428f39e98dac598c6 Mon Sep 17 00:00:00 2001
From: Jack Wu <wjack@google.com>
Date: Fri, 19 May 2023 14:31:53 +0800
Subject: [PATCH 0080/1487] BatteryMonitor: support battery health INCONSISTENT
 from health status

Report Battery health INCONSISTENT when there is a battery recalibration
pending.

Bug: 283182048
Test: m
Ignore-AOSP-First: cherry-pick from aosp
Change-Id: I8b944ddac7cc919fc95b1b71b015101642a62f96
Merged-In: I8b944ddac7cc919fc95b1b71b015101642a62f96
Signed-off-by: Jack Wu <wjack@google.com>
---
 healthd/BatteryMonitor.cpp               | 2 ++
 healthd/include/healthd/BatteryMonitor.h | 1 +
 2 files changed, 3 insertions(+)

diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index f68d65a54d70..bd7955a7f8b4 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -244,6 +244,8 @@ BatteryHealth getBatteryHealthStatus(int status) {
         value = BatteryHealth::UNSPECIFIED_FAILURE;
     else if (status == BatteryMonitor::BH_NOT_AVAILABLE)
         value = BatteryHealth::NOT_AVAILABLE;
+    else if (status == BatteryMonitor::BH_INCONSISTENT)
+        value = BatteryHealth::INCONSISTENT;
     else
         value = BatteryHealth::UNKNOWN;
 
diff --git a/healthd/include/healthd/BatteryMonitor.h b/healthd/include/healthd/BatteryMonitor.h
index a4c013b86b33..e9998ba7a3af 100644
--- a/healthd/include/healthd/BatteryMonitor.h
+++ b/healthd/include/healthd/BatteryMonitor.h
@@ -63,6 +63,7 @@ class BatteryMonitor {
         BH_NEEDS_REPLACEMENT,
         BH_FAILED,
         BH_NOT_AVAILABLE,
+        BH_INCONSISTENT,
     };
 
     BatteryMonitor();

From 997ce15d5e50e1e8ff5b8f7ac3a8d45f4519ea47 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 30 May 2023 09:24:46 -0700
Subject: [PATCH 0081/1487] Update add resizetasks to work in update

Old should_flash_in_userspace doesn't work if $ANDROID_PRODUCT_OUT is
not set. Also adding in a check to see if resizetasks were added
correctly

Test: fastboot update update.zip without $ANDROID_PRODUCT_OUT and
removing the flashsuperlayout code.
Bug: 283330320

Change-Id: Ib72f6a1cf07745daf70fffae3d1a6b8352e3f79c
---
 fastboot/fastboot.cpp | 20 +++++++++++++++-----
 fastboot/fastboot.h   |  2 +-
 2 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index fcad0d915ddc..3a135bc4699d 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1646,14 +1646,22 @@ std::unique_ptr<Task> ParseFastbootInfoLine(const FlashingPlan* fp,
     return task;
 }
 
-void AddResizeTasks(const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>* tasks) {
+bool AddResizeTasks(const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>* tasks) {
     // expands "resize-partitions" into individual commands : resize {os_partition_1}, resize
     // {os_partition_2}, etc.
     std::vector<std::unique_ptr<Task>> resize_tasks;
     std::optional<size_t> loc;
+    std::vector<char> contents;
+    if (!fp->source->ReadFile("super_empty.img", &contents)) {
+        return false;
+    }
+    auto metadata = android::fs_mgr::ReadFromImageBlob(contents.data(), contents.size());
+    if (!metadata) {
+        return false;
+    }
     for (size_t i = 0; i < tasks->size(); i++) {
         if (auto flash_task = tasks->at(i)->AsFlashTask()) {
-            if (should_flash_in_userspace(flash_task->GetPartitionAndSlot())) {
+            if (should_flash_in_userspace(*metadata.get(), flash_task->GetPartitionAndSlot())) {
                 if (!loc) {
                     loc = i;
                 }
@@ -1665,11 +1673,11 @@ void AddResizeTasks(const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>*
     // if no logical partitions (although should never happen since system will always need to be
     // flashed)
     if (!loc) {
-        return;
+        return false;
     }
     tasks->insert(tasks->begin() + loc.value(), std::make_move_iterator(resize_tasks.begin()),
                   std::make_move_iterator(resize_tasks.end()));
-    return;
+    return true;
 }
 
 static bool IsIgnore(const std::vector<std::string>& command) {
@@ -1750,7 +1758,9 @@ std::vector<std::unique_ptr<Task>> ParseFastbootInfo(const FlashingPlan* fp,
         }
         tasks.insert(it, std::move(flash_super_task));
     } else {
-        AddResizeTasks(fp, &tasks);
+        if (!AddResizeTasks(fp, &tasks)) {
+            LOG(WARNING) << "Failed to add resize tasks";
+        };
     }
     return tasks;
 }
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index 0a1f1eb66773..abdf63695053 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -144,7 +144,7 @@ std::unique_ptr<WipeTask> ParseWipeCommand(const FlashingPlan* fp,
                                            const std::vector<std::string>& parts);
 std::unique_ptr<Task> ParseFastbootInfoLine(const FlashingPlan* fp,
                                             const std::vector<std::string>& command);
-void AddResizeTasks(const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>& tasks);
+bool AddResizeTasks(const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>& tasks);
 std::vector<std::unique_ptr<Task>> ParseFastbootInfo(const FlashingPlan* fp,
                                                      const std::vector<std::string>& file);
 

From 3e8ad4d546d401ad9da77c3d67ebd6ca19cd2c59 Mon Sep 17 00:00:00 2001
From: Hans Boehm <hboehm@google.com>
Date: Wed, 31 May 2023 10:19:54 -0700
Subject: [PATCH 0082/1487] Halve iteration count for some RefBase tests

The RacingDestructors test was occasionally timing out, by non-huge
amounts. Halve the number of iterations for long-running tests here.

Bug: 284964396
Test: Treehugger
Change-Id: If639ce98fbeb783431f07006dece4cd69f9f8b50
---
 libutils/RefBase_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libutils/RefBase_test.cpp b/libutils/RefBase_test.cpp
index aed3b9b40b4f..d6755980508e 100644
--- a/libutils/RefBase_test.cpp
+++ b/libutils/RefBase_test.cpp
@@ -28,7 +28,7 @@
 
 using namespace android;
 
-static constexpr int NITERS = 1000000;
+static constexpr int NITERS = 500000;
 
 static constexpr int INITIAL_STRONG_VALUE = 1 << 28;  // Mirroring RefBase definition.
 

From f8a9ba13f5a1202a8b2d4cf53f69ca1226df6b8c Mon Sep 17 00:00:00 2001
From: Edward Liaw <edliaw@google.com>
Date: Wed, 31 May 2023 17:29:17 +0000
Subject: [PATCH 0083/1487] TEST_MAPPING: enable KernelLibcutilsTest in
 kernel-presubmit

Bug: 284307085
Bug: 258819618
Test: atest :kernel-presubmit
Change-Id: Ifa3427d3b7ff66d25ba58f5d16d0d62a709274a0
Signed-off-by: Edward Liaw <edliaw@google.com>
---
 libcutils/TEST_MAPPING | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/libcutils/TEST_MAPPING b/libcutils/TEST_MAPPING
index eb63aa5e7ce9..78b3e44e276d 100644
--- a/libcutils/TEST_MAPPING
+++ b/libcutils/TEST_MAPPING
@@ -12,6 +12,9 @@
   "kernel-presubmit": [
     {
       "name": "libcutils_test"
+    },
+    {
+      "name": "KernelLibcutilsTest"
     }
   ]
 }

From 2a56592d589e52928d86729301a367efd0c9817f Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 31 May 2023 11:20:08 -0700
Subject: [PATCH 0084/1487] Reverting code to old flashing code

Falling back on old flashing code until fastboot-info is fixed

Test: m fastboot, fastboot flashall
Change-Id: I10146ec75f75d57d4a4049d35def370533619401
---
 fastboot/fastboot.cpp | 24 ++----------------------
 1 file changed, 2 insertions(+), 22 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 3a135bc4699d..bec4ef1e9447 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1784,28 +1784,8 @@ void FlashAllTool::Flash() {
 
     CancelSnapshotIfNeeded();
 
-    std::vector<char> contents;
-    if (!fp_->source->ReadFile("fastboot-info.txt", &contents)) {
-        LOG(VERBOSE) << "Flashing from hardcoded images. fastboot-info.txt is empty or does not "
-                        "exist";
-        HardcodedFlash();
-        return;
-    }
-
-    std::vector<std::unique_ptr<Task>> tasks =
-            ParseFastbootInfo(fp_, Split({contents.data(), contents.size()}, "\n"));
-
-    if (tasks.empty()) {
-        LOG(FATAL) << "Invalid fastboot-info.txt file.";
-    }
-    LOG(VERBOSE) << "Flashing from fastboot-info.txt";
-    for (auto& task : tasks) {
-        task->Run();
-    }
-    if (fp_->wants_wipe) {
-        // avoid adding duplicate wipe tasks in fastboot main code.
-        fp_->wants_wipe = false;
-    }
+    HardcodedFlash();
+    return;
 }
 
 void FlashAllTool::CheckRequirements() {

From c786b6d332266c5f6ab877fa04805cb4c176a536 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 12 Aug 2022 23:43:43 -0700
Subject: [PATCH 0085/1487] libsnapshot: Use SnapshotManager to delete devices.

Diagnosing DM_DEV_REMOVE failures in the test harness is quite
difficult, and it's not clear if failures are spurious or not. Instead
use SnapshotManager's helper function, which can retry on failure, and
will self-diagnose issues on legitimate failures.

Bug: N/A
Test: vts_libsnapshot_test
Change-Id: Ibcaa8406e8b1e8758b99a8e9b58c58d68ed57685
Merged-In: Ibcaa8406e8b1e8758b99a8e9b58c58d68ed57685
(cherry picked from commit e02ef9e9ce4203c9132779521fb4118dd5667a79)
---
 fs_mgr/libsnapshot/snapshot_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 9291b03f89a4..027e10fea673 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -289,7 +289,7 @@ class SnapshotTest : public ::testing::Test {
     }
 
     AssertionResult DeleteDevice(const std::string& device) {
-        if (!dm_.DeleteDeviceIfExists(device)) {
+        if (!sm->DeleteDeviceIfExists(device, 1s)) {
             return AssertionFailure() << "Can't delete " << device;
         }
         return AssertionSuccess();

From 1136e2fc30f3cf30a8ced10f9cf85a22760ab5df Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 11 Aug 2022 22:12:19 -0700
Subject: [PATCH 0086/1487] libsnapshot: Remove flaky image creation test.

This test has always been flaky, and is not testing something super
valuable: we know that image creation succeeds throughout the rest of
the suite, so it's not very interesting to know that it can succeed in a
low-space scenario.

The inverse test is much more valuable, since we want the correct status
code when creation fails due to low space.

Bug: 240391002
Test: vts_libsnapshot_test
Merged-In: I6235d11033d2f30efe530077b877863ba2574810
Change-Id: I6235d11033d2f30efe530077b877863ba2574810
(cherry picked from commit 97e8a2f0e963cea957ffd135be4436de3b3afd6a)
---
 fs_mgr/libsnapshot/snapshot_test.cpp | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 9291b03f89a4..381497c68ec3 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2417,7 +2417,6 @@ class ImageManagerTest : public SnapshotTest, public WithParamInterface<uint64_t
     }
     void TearDown() override {
         RETURN_IF_NON_VIRTUAL_AB();
-        return;  // BUG(149738928)
 
         EXPECT_TRUE(!image_manager_->BackingImageExists(kImageName) ||
                     image_manager_->DeleteBackingImage(kImageName));
@@ -2426,19 +2425,6 @@ class ImageManagerTest : public SnapshotTest, public WithParamInterface<uint64_t
     std::unique_ptr<LowSpaceUserdata> userdata_;
 };
 
-TEST_P(ImageManagerTest, CreateImageEnoughAvailSpace) {
-    if (userdata_->available_space() == 0) {
-        GTEST_SKIP() << "/data is full (" << userdata_->available_space()
-                     << " bytes available), skipping";
-    }
-    ASSERT_TRUE(image_manager_->CreateBackingImage(kImageName, userdata_->available_space(),
-                                                   IImageManager::CREATE_IMAGE_DEFAULT))
-            << "Should be able to create image with size = " << userdata_->available_space()
-            << " bytes";
-    ASSERT_TRUE(image_manager_->DeleteBackingImage(kImageName))
-            << "Should be able to delete created image";
-}
-
 TEST_P(ImageManagerTest, CreateImageNoSpace) {
     uint64_t to_allocate = userdata_->free_space() + userdata_->bsize();
     auto res = image_manager_->CreateBackingImage(kImageName, to_allocate,

From ab5e5250509e06ce3f6cf7cdbd106909870086b4 Mon Sep 17 00:00:00 2001
From: Vova Sharaienko <sharaienko@google.com>
Date: Tue, 30 May 2023 19:47:07 +0000
Subject: [PATCH 0087/1487] Increasing length of the datagram for Unix Domain
 Socket

- address p99 StatsD socket loss issue

Bug: 284508851
Test: atest statsd_test
Test: atest statsd_benchmark
Ignore-AOSP-First: mitigate data loss in Android U
Change-Id: I4124ba8d4d78733eb666073f6d29dfe0c0552c0f
Merged-In: I4124ba8d4d78733eb666073f6d29dfe0c0552c0f
---
 rootdir/init.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index fdad27397473..0ee85c7412b9 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -295,7 +295,7 @@ on init
     write /proc/sys/kernel/randomize_va_space 2
     write /proc/sys/vm/mmap_min_addr 32768
     write /proc/sys/net/ipv4/ping_group_range "0 2147483647"
-    write /proc/sys/net/unix/max_dgram_qlen 600
+    write /proc/sys/net/unix/max_dgram_qlen 2400
 
     # Assign reasonable ceiling values for socket rcv/snd buffers.
     # These should almost always be overridden by the target per the

From 99b308c9f6ce20a8758e8b5295268fc69602d42a Mon Sep 17 00:00:00 2001
From: Vova Sharaienko <sharaienko@google.com>
Date: Tue, 30 May 2023 19:47:07 +0000
Subject: [PATCH 0088/1487] Increasing length of the datagram for Unix Domain
 Socket

- address p99 StatsD socket loss issue

Bug: 284508851
Test: atest statsd_test
Test: atest statsd_benchmark
Ignore-AOSP-First: mitigate data loss in Android U
Change-Id: I4124ba8d4d78733eb666073f6d29dfe0c0552c0f
Merged-In: I4124ba8d4d78733eb666073f6d29dfe0c0552c0f
---
 rootdir/init.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 41c60a7f9dda..1e6918d0022c 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -315,7 +315,7 @@ on init
     write /proc/sys/kernel/randomize_va_space 2
     write /proc/sys/vm/mmap_min_addr 32768
     write /proc/sys/net/ipv4/ping_group_range "0 2147483647"
-    write /proc/sys/net/unix/max_dgram_qlen 600
+    write /proc/sys/net/unix/max_dgram_qlen 2400
 
     # Assign reasonable ceiling values for socket rcv/snd buffers.
     # These should almost always be overridden by the target per the

From 6c008ff888c8c79c3322f8d06587407cf5a098b0 Mon Sep 17 00:00:00 2001
From: Dmitrii Merkurev <dimorinny@google.com>
Date: Fri, 2 Jun 2023 12:44:31 +0100
Subject: [PATCH 0089/1487] Avoid creating a storage folder for fastboot
 devices command

Bug: 284267164
Bug: 284786311
Test: fastboot devices doesn't create a .fastboot folder
Change-Id: I3e44c2a838e4287e6220c18f6e805cc71e0c9669
Signed-off-by: Dmitrii Merkurev <dimorinny@google.com>
---
 fastboot/fastboot.cpp |  2 +-
 fastboot/filesystem.h |  1 +
 fastboot/storage.cpp  | 22 ++++++++++------------
 fastboot/storage.h    |  4 +++-
 4 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index bec4ef1e9447..ee99c1788747 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -396,7 +396,7 @@ static Transport* NetworkDeviceConnected(bool print = false) {
 
     ConnectedDevicesStorage storage;
     std::set<std::string> devices;
-    {
+    if (storage.Exists()) {
         FileLock lock = storage.Lock();
         devices = storage.ReadDevices(lock);
     }
diff --git a/fastboot/filesystem.h b/fastboot/filesystem.h
index 5f41fbc9fcfa..c5f9c948d68f 100644
--- a/fastboot/filesystem.h
+++ b/fastboot/filesystem.h
@@ -31,6 +31,7 @@ const char kPathSeparator =
 #endif
 
 std::string GetHomeDirPath();
+bool FileExists(const std::string& path);
 bool EnsureDirectoryExists(const std::string& directory_path);
 
 class FileLock {
diff --git a/fastboot/storage.cpp b/fastboot/storage.cpp
index d6e00cffaf73..dc733b99464e 100644
--- a/fastboot/storage.cpp
+++ b/fastboot/storage.cpp
@@ -23,24 +23,19 @@
 #include "util.h"
 
 ConnectedDevicesStorage::ConnectedDevicesStorage() {
-    const std::string home_path = GetHomeDirPath();
-    if (home_path.empty()) {
-        return;
-    }
-
-    const std::string home_fastboot_path = home_path + kPathSeparator + ".fastboot";
-
-    if (!EnsureDirectoryExists(home_fastboot_path)) {
-        LOG(FATAL) << "Cannot create directory: " << home_fastboot_path;
-    }
+    home_fastboot_path_ = GetHomeDirPath() + kPathSeparator + ".fastboot";
+    devices_path_ = home_fastboot_path_ + kPathSeparator + "devices";
 
     // We're using a separate file for locking because the Windows LockFileEx does not
     // permit opening a file stream for the locked file, even within the same process. So,
     // we have to use fd or handle API to manipulate the storage files, which makes it
     // nearly impossible to fully rewrite a file content without having to recreate it.
     // Unfortunately, this is not an option during holding a lock.
-    devices_path_ = home_fastboot_path + kPathSeparator + "devices";
-    devices_lock_path_ = home_fastboot_path + kPathSeparator + "devices.lock";
+    devices_lock_path_ = home_fastboot_path_ + kPathSeparator + "devices.lock";
+}
+
+bool ConnectedDevicesStorage::Exists() const {
+    return FileExists(devices_path_);
 }
 
 void ConnectedDevicesStorage::WriteDevices(const FileLock&, const std::set<std::string>& devices) {
@@ -63,5 +58,8 @@ void ConnectedDevicesStorage::Clear(const FileLock&) {
 }
 
 FileLock ConnectedDevicesStorage::Lock() const {
+    if (!EnsureDirectoryExists(home_fastboot_path_)) {
+        LOG(FATAL) << "Cannot create directory: " << home_fastboot_path_;
+    }
     return FileLock(devices_lock_path_);
 }
\ No newline at end of file
diff --git a/fastboot/storage.h b/fastboot/storage.h
index 0cc3d86d670a..ae9d846e65b1 100644
--- a/fastboot/storage.h
+++ b/fastboot/storage.h
@@ -24,13 +24,15 @@
 class ConnectedDevicesStorage {
   public:
     ConnectedDevicesStorage();
+
+    bool Exists() const;
     void WriteDevices(const FileLock&, const std::set<std::string>& devices);
     std::set<std::string> ReadDevices(const FileLock&);
     void Clear(const FileLock&);
-
     FileLock Lock() const;
 
   private:
+    std::string home_fastboot_path_;
     std::string devices_path_;
     std::string devices_lock_path_;
 };
\ No newline at end of file

From e2aba20f1997857f8ec11c2baf89fc1102db02bf Mon Sep 17 00:00:00 2001
From: Edward Liaw <edliaw@google.com>
Date: Fri, 2 Jun 2023 23:33:41 +0000
Subject: [PATCH 0090/1487] KernelLibcutilsTest: change test file push location

Upload files to /data/local/tests/unrestricted instead to improve data
collection in the event of a crash.

Bug: 284307085
Bug: 258819618
Bug: 199904562
Test: atest KernelLibcutilsTest
Change-Id: Iff816fd3276b24507c60eddc1bcd3f2c2184c27d
Signed-off-by: Edward Liaw <edliaw@google.com>
---
 libcutils/KernelLibcutilsTest.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libcutils/KernelLibcutilsTest.xml b/libcutils/KernelLibcutilsTest.xml
index 40e4ef414be8..9750cbfa28b0 100644
--- a/libcutils/KernelLibcutilsTest.xml
+++ b/libcutils/KernelLibcutilsTest.xml
@@ -22,11 +22,11 @@
 
     <target_preparer class="com.android.tradefed.targetprep.PushFilePreparer">
         <option name="cleanup" value="true" />
-        <option name="push" value="KernelLibcutilsTest->/data/local/tmp/KernelLibcutilsTest" />
+        <option name="push" value="KernelLibcutilsTest->/data/local/tests/unrestricted/KernelLibcutilsTest" />
     </target_preparer>
 
     <test class="com.android.tradefed.testtype.GTest" >
-        <option name="native-test-device-path" value="/data/local/tmp" />
+        <option name="native-test-device-path" value="/data/local/tests/unrestricted" />
         <option name="module-name" value="KernelLibcutilsTest" />
         <option name="include-filter" value="*AshmemTest*" />
     </test>

From cc4a15b97a642a35a014e14dc8e5105b02695615 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers@google.com>
Date: Mon, 5 Jun 2023 14:35:11 +0000
Subject: [PATCH 0091/1487] fs_mgr_fstab: allow fileencryption without equals
 sign

A point of confusion that has been encountered recently is that the
fileencryption argument is optional (since Android 11), yet the fstab
parser requires the equals sign in "fileencryption=".  Thus, someone
wanting to use the default options must use "...,fileencryption=,...".

Make "fileencryption" by itself mean the same thing so that it works as
expected.

Test: atest CtsFsMgrTestCases
Change-Id: I65ce6b9513942bec2107838396835e7aafb3bf37
---
 fs_mgr/fs_mgr_fstab.cpp      | 4 +++-
 fs_mgr/tests/fs_mgr_test.cpp | 1 +
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/fs_mgr_fstab.cpp b/fs_mgr/fs_mgr_fstab.cpp
index 598a3d2ecb4d..c3c10ba62701 100644
--- a/fs_mgr/fs_mgr_fstab.cpp
+++ b/fs_mgr/fs_mgr_fstab.cpp
@@ -242,7 +242,9 @@ bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
                     LWARNING << "Warning: zramsize= flag malformed: " << arg;
                 }
             }
-        } else if (StartsWith(flag, "fileencryption=")) {
+        } else if (StartsWith(flag, "fileencryption=") || flag == "fileencryption") {
+            // "fileencryption" enables file-based encryption.  It's normally followed by an = and
+            // then the encryption options.  But that can be omitted to use the default options.
             ParseFileEncryption(arg, entry);
         } else if (StartsWith(flag, "max_comp_streams=")) {
             if (!ParseInt(arg, &entry->max_comp_streams)) {
diff --git a/fs_mgr/tests/fs_mgr_test.cpp b/fs_mgr/tests/fs_mgr_test.cpp
index e33681c3f66d..5f889caee5e7 100644
--- a/fs_mgr/tests/fs_mgr_test.cpp
+++ b/fs_mgr/tests/fs_mgr_test.cpp
@@ -497,6 +497,7 @@ source none1       swap   defaults      fileencryption=,keydirectory=,length=,sw
     EXPECT_EQ("none0", entry->mount_point);
     {
         FstabEntry::FsMgrFlags flags = {};
+        flags.file_encryption = true;
         EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
     }
     EXPECT_EQ("", entry->metadata_key_dir);

From 303fb49cc042d029cbbbba7c35a5d00116014a1c Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 5 Jun 2023 10:30:44 -0700
Subject: [PATCH 0092/1487] Adding in wipe tasks before other tasks run.

if we call -w and a reboot task runs beforehand, we don't actually wipe
the given partitions. We want the wipe to occur before reboots.

Test: fastboot flashall -w
Change-Id: If327c5de0858e222cf5fc14531bc20fb741c2960
---
 fastboot/fastboot.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index bec4ef1e9447..3c34ec259281 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -2583,10 +2583,13 @@ int FastBootTool::Main(int argc, char* argv[]) {
         if (fp->force_flash) {
             CancelSnapshotIfNeeded();
         }
+        std::vector<std::unique_ptr<Task>> wipe_tasks;
         std::vector<std::string> partitions = {"userdata", "cache", "metadata"};
         for (const auto& partition : partitions) {
-            tasks.emplace_back(std::make_unique<WipeTask>(fp.get(), partition));
+            wipe_tasks.emplace_back(std::make_unique<WipeTask>(fp.get(), partition));
         }
+        tasks.insert(tasks.begin(), std::make_move_iterator(wipe_tasks.begin()),
+                     std::make_move_iterator(wipe_tasks.end()));
     }
     if (fp->wants_set_active) {
         fb->SetActive(next_active);

From 07533c520c428932945cdbdc73c25fe27bd376e2 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 2 Jun 2023 12:00:12 -0700
Subject: [PATCH 0093/1487] init: Fix ramdump when enabling shutdown
 animations.

Fix a bug where services weren't stopped properly if shutdown animations
were enabled.

Bug: 285241485
Test: Pixel w/ ro.init.shutdown_animation=true
Change-Id: I7f35572b5223f03f3f5a341fa7b5e90c01d56ce3
---
 init/reboot.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/init/reboot.cpp b/init/reboot.cpp
index 27a7876db881..3351c4c452da 100644
--- a/init/reboot.cpp
+++ b/init/reboot.cpp
@@ -680,8 +680,8 @@ static void DoReboot(unsigned int cmd, const std::string& reason, const std::str
                            << "': " << result.error();
             }
             s->SetShutdownCritical();
-        } else if (do_shutdown_animation) {
-            continue;
+        } else if (do_shutdown_animation && s->classnames().count("animation") > 0) {
+            // Need these for shutdown animations.
         } else if (s->IsShutdownCritical()) {
             // Start shutdown critical service if not started.
             if (auto result = s->Start(); !result.ok()) {

From b3e1993ee55269694c345743191a67fbdc443e97 Mon Sep 17 00:00:00 2001
From: Hao Chen <chenhaosjtuacm@google.com>
Date: Wed, 31 May 2023 14:18:59 -0700
Subject: [PATCH 0094/1487] Add the Missing Header

`stderror` is used in this file and it is defined in `string.h/cstring`, so
the header file needs to be directly included.

Test: build
Bug: 285204695
Change-Id: Idf34126626ad0e9bb397df3d5da50439bf18381d
---
 libutils/Errors.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libutils/Errors.cpp b/libutils/Errors.cpp
index 74f3befacf31..dfb4d9b95c05 100644
--- a/libutils/Errors.cpp
+++ b/libutils/Errors.cpp
@@ -15,6 +15,8 @@
  */
 #include <utils/Errors.h>
 
+#include <string.h>
+
 namespace android {
 
 std::string statusToString(status_t s) {

From 665a460e8a2409040e2965d1ca920e98bc8a2ed4 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 5 Jun 2023 11:24:59 -0700
Subject: [PATCH 0095/1487] Adding GetInfo method for tasks

Using for easier debugging. Replacing old getter methods in flash task
with GetInfo(key)

Test: fastboot_test
Change-Id: If42df86c4b0278c3dc5525b1058f1947f0b34794
---
 fastboot/task.cpp | 30 ++++++++++++++++++++++++++++++
 fastboot/task.h   | 14 +++++++++++---
 2 files changed, 41 insertions(+), 3 deletions(-)

diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index 9ce2cfd201d7..03f9b8942bb2 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -46,6 +46,14 @@ void FlashTask::Run() {
     do_for_partitions(pname_, slot_, flash, true);
 }
 
+std::string FlashTask::ToString() {
+    std::string apply_vbmeta_string = "";
+    if (apply_vbmeta_) {
+        apply_vbmeta_string = " --apply_vbmeta";
+    }
+    return "flash" + apply_vbmeta_string + " " + pname_ + " " + fname_;
+}
+
 std::string FlashTask::GetPartitionAndSlot() {
     auto slot = slot_;
     if (slot.empty()) {
@@ -84,6 +92,10 @@ void RebootTask::Run() {
     }
 }
 
+std::string RebootTask::ToString() {
+    return "reboot " + reboot_target_;
+}
+
 FlashSuperLayoutTask::FlashSuperLayoutTask(const std::string& super_name,
                                            std::unique_ptr<SuperFlashHelper> helper,
                                            SparsePtr sparse_layout, uint64_t super_size)
@@ -106,6 +118,9 @@ void FlashSuperLayoutTask::Run() {
     // Send the data to the device.
     flash_partition_files(super_name_, files);
 }
+std::string FlashSuperLayoutTask::ToString() {
+    return "optimized-flash-super";
+}
 
 std::unique_ptr<FlashSuperLayoutTask> FlashSuperLayoutTask::Initialize(
         const FlashingPlan* fp, std::vector<ImageEntry>& os_images) {
@@ -263,6 +278,9 @@ void UpdateSuperTask::Run() {
     }
     fp_->fb->RawCommand(command, "Updating super partition");
 }
+std::string UpdateSuperTask::ToString() {
+    return "update-super";
+}
 
 ResizeTask::ResizeTask(const FlashingPlan* fp, const std::string& pname, const std::string& size,
                        const std::string& slot)
@@ -277,12 +295,20 @@ void ResizeTask::Run() {
     do_for_partitions(pname_, slot_, resize_partition, false);
 }
 
+std::string ResizeTask::ToString() {
+    return "resize " + pname_;
+}
+
 DeleteTask::DeleteTask(const FlashingPlan* fp, const std::string& pname) : fp_(fp), pname_(pname){};
 
 void DeleteTask::Run() {
     fp_->fb->DeletePartition(pname_);
 }
 
+std::string DeleteTask::ToString() {
+    return "delete " + pname_;
+}
+
 WipeTask::WipeTask(const FlashingPlan* fp, const std::string& pname) : fp_(fp), pname_(pname){};
 
 void WipeTask::Run() {
@@ -298,3 +324,7 @@ void WipeTask::Run() {
     }
     fb_perform_format(pname_, 1, partition_type, "", fp_->fs_options);
 }
+
+std::string WipeTask::ToString() {
+    return "erase " + pname_;
+}
diff --git a/fastboot/task.h b/fastboot/task.h
index 82e8ebf51e01..500655dbb7c3 100644
--- a/fastboot/task.h
+++ b/fastboot/task.h
@@ -35,6 +35,8 @@ class Task {
   public:
     Task() = default;
     virtual void Run() = 0;
+    virtual std::string ToString() = 0;
+
     virtual FlashTask* AsFlashTask() { return nullptr; }
     virtual RebootTask* AsRebootTask() { return nullptr; }
     virtual UpdateSuperTask* AsUpdateSuperTask() { return nullptr; }
@@ -49,11 +51,12 @@ class FlashTask : public Task {
               const bool apply_vbmeta, const FlashingPlan* fp);
     virtual FlashTask* AsFlashTask() override { return this; }
 
+    void Run() override;
+    std::string ToString() override;
     std::string GetPartition() { return pname_; }
     std::string GetImageName() { return fname_; }
-    std::string GetPartitionAndSlot();
     std::string GetSlot() { return slot_; }
-    void Run() override;
+    std::string GetPartitionAndSlot();
 
   private:
     const std::string pname_;
@@ -69,6 +72,7 @@ class RebootTask : public Task {
     RebootTask(const FlashingPlan* fp, const std::string& reboot_target);
     virtual RebootTask* AsRebootTask() override { return this; }
     void Run() override;
+    std::string ToString() override;
 
   private:
     const std::string reboot_target_ = "";
@@ -85,6 +89,7 @@ class FlashSuperLayoutTask : public Task {
             const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>& tasks);
     using ImageEntry = std::pair<const Image*, std::string>;
     void Run() override;
+    std::string ToString() override;
 
   private:
     const std::string super_name_;
@@ -99,6 +104,7 @@ class UpdateSuperTask : public Task {
     virtual UpdateSuperTask* AsUpdateSuperTask() override { return this; }
 
     void Run() override;
+    std::string ToString() override;
 
   private:
     const FlashingPlan* fp_;
@@ -109,6 +115,7 @@ class ResizeTask : public Task {
     ResizeTask(const FlashingPlan* fp, const std::string& pname, const std::string& size,
                const std::string& slot);
     void Run() override;
+    std::string ToString() override;
 
   private:
     const FlashingPlan* fp_;
@@ -121,6 +128,7 @@ class DeleteTask : public Task {
   public:
     DeleteTask(const FlashingPlan* fp, const std::string& pname);
     void Run() override;
+    std::string ToString() override;
 
   private:
     const FlashingPlan* fp_;
@@ -131,8 +139,8 @@ class WipeTask : public Task {
   public:
     WipeTask(const FlashingPlan* fp, const std::string& pname);
     virtual WipeTask* AsWipeTask() override { return this; }
-
     void Run() override;
+    std::string ToString() override;
 
   private:
     const FlashingPlan* fp_;

From 6cef6905d781e5f676d77f75d39f497e3cbe0b6b Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 5 Jun 2023 15:00:30 -0700
Subject: [PATCH 0096/1487] Move ENOSPC tests to libfiemap.

These tests are still giving us trouble. Move them to libfiemap, which
(1) is closer to the source of implementation, and (2) allows us to
re-use the temporary filesystem code. This won't perturb the state of
the actual device.

The new test creates a 64MB ext4 or f2fs mount point as a sandbox, which
should be much safer.

Bug: 285197715
Test: fiemap_writer_test
Change-Id: I33502d49613be4f269a80e5c632514fc56a0246a
---
 fs_mgr/libfiemap/Android.bp                   |   3 +
 fs_mgr/libfiemap/fiemap_writer_test.cpp       | 118 ++++++++++++------
 fs_mgr/libsnapshot/snapshot_test.cpp          |  86 -------------
 .../storage_literals/storage_literals.h       |   6 +
 4 files changed, 87 insertions(+), 126 deletions(-)

diff --git a/fs_mgr/libfiemap/Android.bp b/fs_mgr/libfiemap/Android.bp
index 5deba659dd56..ddda648d8e88 100644
--- a/fs_mgr/libfiemap/Android.bp
+++ b/fs_mgr/libfiemap/Android.bp
@@ -93,6 +93,9 @@ cc_test {
     test_options: {
         min_shipping_api_level: 29,
     },
+    header_libs: [
+        "libstorage_literals_headers",
+    ],
     require_root: true,
 }
 
diff --git a/fs_mgr/libfiemap/fiemap_writer_test.cpp b/fs_mgr/libfiemap/fiemap_writer_test.cpp
index c65481b78d36..bd97a78ae8f7 100644
--- a/fs_mgr/libfiemap/fiemap_writer_test.cpp
+++ b/fs_mgr/libfiemap/fiemap_writer_test.cpp
@@ -22,21 +22,25 @@
 #include <string.h>
 #include <sys/mount.h>
 #include <sys/stat.h>
+#include <sys/statvfs.h>
 #include <sys/types.h>
 #include <sys/vfs.h>
 #include <unistd.h>
 
 #include <string>
+#include <utility>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
 #include <android-base/unique_fd.h>
+#include <fstab/fstab.h>
 #include <gtest/gtest.h>
 #include <libdm/loop_control.h>
 #include <libfiemap/fiemap_writer.h>
 #include <libfiemap/split_fiemap_writer.h>
 #include <libgsi/libgsi.h>
+#include <storage_literals/storage_literals.h>
 
 #include "utility.h"
 
@@ -46,6 +50,7 @@ namespace fiemap {
 using namespace std;
 using namespace std::string_literals;
 using namespace android::fiemap;
+using namespace android::storage_literals;
 using unique_fd = android::base::unique_fd;
 using LoopDevice = android::dm::LoopDevice;
 
@@ -427,90 +432,123 @@ TEST_F(SplitFiemapTest, WritePastEnd) {
     ASSERT_FALSE(ptr->Write(buffer.get(), kSize));
 }
 
-class VerifyBlockWritesExt4 : public ::testing::Test {
+// Get max file size and free space.
+std::pair<uint64_t, uint64_t> GetBigFileLimit(const std::string& mount_point) {
+    struct statvfs fs;
+    if (statvfs(mount_point.c_str(), &fs) < 0) {
+        PLOG(ERROR) << "statfs failed";
+        return {0, 0};
+    }
+
+    auto fs_limit = static_cast<uint64_t>(fs.f_blocks) * (fs.f_bsize - 1);
+    auto fs_free = static_cast<uint64_t>(fs.f_bfree) * fs.f_bsize;
+
+    LOG(INFO) << "Big file limit: " << fs_limit << ", free space: " << fs_free;
+
+    return {fs_limit, fs_free};
+}
+
+class FsTest : public ::testing::Test {
+  protected:
     // 2GB Filesystem and 4k block size by default
     static constexpr uint64_t block_size = 4096;
-    static constexpr uint64_t fs_size = 2147483648;
+    static constexpr uint64_t fs_size = 64 * 1024 * 1024;
+
+    void SetUp() {
+        android::fs_mgr::Fstab fstab;
+        ASSERT_TRUE(android::fs_mgr::ReadFstabFromFile("/proc/mounts", &fstab));
+
+        ASSERT_EQ(access(tmpdir_.path, F_OK), 0);
+        fs_path_ = tmpdir_.path + "/fs_image"s;
+        mntpoint_ = tmpdir_.path + "/mnt_point"s;
+
+        auto entry = android::fs_mgr::GetEntryForMountPoint(&fstab, "/data");
+        ASSERT_NE(entry, nullptr);
+        if (entry->fs_type == "ext4") {
+            SetUpExt4();
+        } else if (entry->fs_type == "f2fs") {
+            SetUpF2fs();
+        } else {
+            FAIL() << "Unrecognized fs_type: " << entry->fs_type;
+        }
+    }
 
-  protected:
-    void SetUp() override {
-        fs_path = std::string(getenv("TMPDIR")) + "/ext4_2G.img";
+    void SetUpExt4() {
         uint64_t count = fs_size / block_size;
         std::string dd_cmd =
                 ::android::base::StringPrintf("/system/bin/dd if=/dev/zero of=%s bs=%" PRIu64
                                               " count=%" PRIu64 " > /dev/null 2>&1",
-                                              fs_path.c_str(), block_size, count);
+                                              fs_path_.c_str(), block_size, count);
         std::string mkfs_cmd =
-                ::android::base::StringPrintf("/system/bin/mkfs.ext4 -q %s", fs_path.c_str());
+                ::android::base::StringPrintf("/system/bin/mkfs.ext4 -q %s", fs_path_.c_str());
         // create mount point
-        mntpoint = std::string(getenv("TMPDIR")) + "/fiemap_mnt";
-        ASSERT_EQ(mkdir(mntpoint.c_str(), S_IRWXU), 0);
+        ASSERT_EQ(mkdir(mntpoint_.c_str(), S_IRWXU), 0);
         // create file for the file system
         int ret = system(dd_cmd.c_str());
         ASSERT_EQ(ret, 0);
         // Get and attach a loop device to the filesystem we created
-        LoopDevice loop_dev(fs_path, 10s);
+        LoopDevice loop_dev(fs_path_, 10s);
         ASSERT_TRUE(loop_dev.valid());
         // create file system
         ret = system(mkfs_cmd.c_str());
         ASSERT_EQ(ret, 0);
 
         // mount the file system
-        ASSERT_EQ(mount(loop_dev.device().c_str(), mntpoint.c_str(), "ext4", 0, nullptr), 0);
-    }
-
-    void TearDown() override {
-        umount(mntpoint.c_str());
-        rmdir(mntpoint.c_str());
-        unlink(fs_path.c_str());
+        ASSERT_EQ(mount(loop_dev.device().c_str(), mntpoint_.c_str(), "ext4", 0, nullptr), 0);
     }
 
-    std::string mntpoint;
-    std::string fs_path;
-};
-
-class VerifyBlockWritesF2fs : public ::testing::Test {
-    // 2GB Filesystem and 4k block size by default
-    static constexpr uint64_t block_size = 4096;
-    static constexpr uint64_t fs_size = 2147483648;
-
-  protected:
-    void SetUp() override {
-        fs_path = std::string(getenv("TMPDIR")) + "/f2fs_2G.img";
+    void SetUpF2fs() {
         uint64_t count = fs_size / block_size;
         std::string dd_cmd =
                 ::android::base::StringPrintf("/system/bin/dd if=/dev/zero of=%s bs=%" PRIu64
                                               " count=%" PRIu64 " > /dev/null 2>&1",
-                                              fs_path.c_str(), block_size, count);
+                                              fs_path_.c_str(), block_size, count);
         std::string mkfs_cmd =
-                ::android::base::StringPrintf("/system/bin/make_f2fs -q %s", fs_path.c_str());
+                ::android::base::StringPrintf("/system/bin/make_f2fs -q %s", fs_path_.c_str());
         // create mount point
-        mntpoint = std::string(getenv("TMPDIR")) + "/fiemap_mnt";
-        ASSERT_EQ(mkdir(mntpoint.c_str(), S_IRWXU), 0);
+        ASSERT_EQ(mkdir(mntpoint_.c_str(), S_IRWXU), 0);
         // create file for the file system
         int ret = system(dd_cmd.c_str());
         ASSERT_EQ(ret, 0);
         // Get and attach a loop device to the filesystem we created
-        LoopDevice loop_dev(fs_path, 10s);
+        LoopDevice loop_dev(fs_path_, 10s);
         ASSERT_TRUE(loop_dev.valid());
         // create file system
         ret = system(mkfs_cmd.c_str());
         ASSERT_EQ(ret, 0);
 
         // mount the file system
-        ASSERT_EQ(mount(loop_dev.device().c_str(), mntpoint.c_str(), "f2fs", 0, nullptr), 0);
+        ASSERT_EQ(mount(loop_dev.device().c_str(), mntpoint_.c_str(), "f2fs", 0, nullptr), 0);
     }
 
     void TearDown() override {
-        umount(mntpoint.c_str());
-        rmdir(mntpoint.c_str());
-        unlink(fs_path.c_str());
+        umount(mntpoint_.c_str());
+        rmdir(mntpoint_.c_str());
+        unlink(fs_path_.c_str());
     }
 
-    std::string mntpoint;
-    std::string fs_path;
+    TemporaryDir tmpdir_;
+    std::string mntpoint_;
+    std::string fs_path_;
 };
 
+TEST_F(FsTest, LowSpaceError) {
+    auto limits = GetBigFileLimit(mntpoint_);
+    ASSERT_GE(limits.first, 0);
+
+    FiemapUniquePtr ptr;
+
+    auto test_file = mntpoint_ + "/big_file";
+    auto status = FiemapWriter::Open(test_file, limits.first, &ptr);
+    ASSERT_FALSE(status.is_ok());
+    ASSERT_EQ(status.error_code(), FiemapStatus::ErrorCode::NO_SPACE);
+
+    // Also test for EFBIG.
+    status = FiemapWriter::Open(test_file, 16_TiB, &ptr);
+    ASSERT_FALSE(status.is_ok());
+    ASSERT_NE(status.error_code(), FiemapStatus::ErrorCode::NO_SPACE);
+}
+
 bool DetermineBlockSize() {
     struct statfs s;
     if (statfs(gTestDir.c_str(), &s)) {
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 22731e7b7487..d45dac134c38 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2372,60 +2372,6 @@ TEST_F(SnapshotUpdateTest, Overflow) {
             << "FinishedSnapshotWrites should detect overflow of CoW device.";
 }
 
-// Get max file size and free space.
-std::pair<uint64_t, uint64_t> GetBigFileLimit() {
-    struct statvfs fs;
-    if (statvfs("/data", &fs) < 0) {
-        PLOG(ERROR) << "statfs failed";
-        return {0, 0};
-    }
-
-    auto fs_limit = static_cast<uint64_t>(fs.f_blocks) * (fs.f_bsize - 1);
-    auto fs_free = static_cast<uint64_t>(fs.f_bfree) * fs.f_bsize;
-
-    LOG(INFO) << "Big file limit: " << fs_limit << ", free space: " << fs_free;
-
-    return {fs_limit, fs_free};
-}
-
-TEST_F(SnapshotUpdateTest, LowSpace) {
-    // To make the low space test more reliable, we force a large cow estimate.
-    // However legacy VAB ignores the COW estimate and uses InstallOperations
-    // to compute the exact size required for dm-snapshot. It's difficult to
-    // make this work reliably (we'd need to somehow fake an extremely large
-    // super partition, and we don't have that level of dependency injection).
-    //
-    // For now, just skip this test on legacy VAB.
-    if (!snapuserd_required_) {
-        GTEST_SKIP() << "Skipping test on legacy VAB";
-    }
-
-    auto fs = GetBigFileLimit();
-    ASSERT_NE(fs.first, 0);
-
-    constexpr uint64_t partition_size = 10_MiB;
-    SetSize(sys_, partition_size);
-    SetSize(vnd_, partition_size);
-    SetSize(prd_, partition_size);
-    sys_->set_estimate_cow_size(fs.first);
-    vnd_->set_estimate_cow_size(fs.first);
-    prd_->set_estimate_cow_size(fs.first);
-
-    AddOperationForPartitions();
-
-    // Execute the update.
-    ASSERT_TRUE(sm->BeginUpdate());
-    auto res = sm->CreateUpdateSnapshots(manifest_);
-    ASSERT_FALSE(res);
-    ASSERT_EQ(Return::ErrorCode::NO_SPACE, res.error_code());
-
-    // It's hard to predict exactly how much free space is needed, since /data
-    // is writable and the test is not the only process running. Divide by two
-    // as a rough lower bound, and adjust this in the future as necessary.
-    auto expected_delta = fs.first - fs.second;
-    ASSERT_GE(res.required_size(), expected_delta / 2);
-}
-
 TEST_F(SnapshotUpdateTest, AddPartition) {
     group_->add_partition_names("dlkm");
 
@@ -2796,38 +2742,6 @@ INSTANTIATE_TEST_SUITE_P(Snapshot, FlashAfterUpdateTest, Combine(Values(0, 1), B
                                     "Merge"s;
                          });
 
-class ImageManagerTest : public SnapshotTest {
-  protected:
-    void SetUp() override {
-        SKIP_IF_NON_VIRTUAL_AB();
-        SnapshotTest::SetUp();
-    }
-    void TearDown() override {
-        RETURN_IF_NON_VIRTUAL_AB();
-        CleanUp();
-        SnapshotTest::TearDown();
-    }
-    void CleanUp() {
-        if (!image_manager_) {
-            return;
-        }
-        EXPECT_TRUE(!image_manager_->BackingImageExists(kImageName) ||
-                    image_manager_->DeleteBackingImage(kImageName));
-    }
-
-    static constexpr const char* kImageName = "my_image";
-};
-
-TEST_F(ImageManagerTest, CreateImageNoSpace) {
-    auto fs = GetBigFileLimit();
-    ASSERT_NE(fs.first, 0);
-
-    auto res = image_manager_->CreateBackingImage(kImageName, fs.first,
-                                                  IImageManager::CREATE_IMAGE_DEFAULT);
-    ASSERT_FALSE(res);
-    ASSERT_EQ(res.error_code(), FiemapStatus::ErrorCode::NO_SPACE) << res.string();
-}
-
 bool Mkdir(const std::string& path) {
     if (mkdir(path.c_str(), 0700) && errno != EEXIST) {
         std::cerr << "Could not mkdir " << path << ": " << strerror(errno) << std::endl;
diff --git a/fs_mgr/libstorage_literals/storage_literals/storage_literals.h b/fs_mgr/libstorage_literals/storage_literals/storage_literals.h
index ac0dfbdb7004..bbeabd5c987b 100644
--- a/fs_mgr/libstorage_literals/storage_literals/storage_literals.h
+++ b/fs_mgr/libstorage_literals/storage_literals/storage_literals.h
@@ -37,6 +37,7 @@ using B = Size<0>;
 using KiB = Size<10>;
 using MiB = Size<20>;
 using GiB = Size<30>;
+using TiB = Size<40>;
 
 constexpr B operator""_B(unsigned long long v) {  // NOLINT
     return B{v};
@@ -54,6 +55,10 @@ constexpr GiB operator""_GiB(unsigned long long v) {  // NOLINT
     return GiB{v};
 }
 
+constexpr TiB operator""_TiB(unsigned long long v) {  // NOLINT
+    return TiB{v};
+}
+
 template <typename Dest, typename Src>
 constexpr Dest size_cast(Src src) {
     if (Src::power < Dest::power) {
@@ -69,6 +74,7 @@ static_assert(1_B == 1);
 static_assert(1_KiB == 1 << 10);
 static_assert(1_MiB == 1 << 20);
 static_assert(1_GiB == 1 << 30);
+static_assert(1_TiB == 1ULL << 40);
 static_assert(size_cast<KiB>(1_B).count() == 0);
 static_assert(size_cast<KiB>(1024_B).count() == 1);
 static_assert(size_cast<KiB>(1_MiB).count() == 1024);

From 40b59a61fc92b742814b3d92b6a888bc91b2a880 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Tue, 6 Jun 2023 17:52:39 +0000
Subject: [PATCH 0097/1487] libcutils_test: static libjsoncpp

The 32-bit variant of libjsoncpp is not always installed
on 64-bit devices, so it must always be statically included.

We should probably collapse libcutils_test with
libcutils_test_static in the future.

Bug: 285357054
Test: libcutils_test
Change-Id: Ic84901ce5af766338b2cab07c3cf10841ba9a150
---
 libcutils/Android.bp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index b135e57bc378..0b5c1254ea2a 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -286,11 +286,14 @@ cc_defaults {
     ],
 }
 
+always_static_test_libraries = [
+    "libjsoncpp",
+]
+
 test_libraries = [
     "libcutils",
     "liblog",
     "libbase",
-    "libjsoncpp",
     "libprocessgroup",
     "libcgrouprc",
 ]
@@ -301,6 +304,7 @@ cc_test {
     defaults: ["libcutils_test_default"],
     host_supported: true,
     shared_libs: test_libraries,
+    static_libs: always_static_test_libraries,
     require_root: true,
 }
 
@@ -310,7 +314,7 @@ cc_defaults {
     static_libs: [
         "libc",
         "libcgrouprc_format",
-    ] + test_libraries,
+    ] + test_libraries + always_static_test_libraries,
     stl: "libc++_static",
     require_root: true,
 

From 447b4a4bf032a550ada6621a33d6b1e188357eb2 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Tue, 6 Jun 2023 17:52:39 +0000
Subject: [PATCH 0098/1487] libcutils_test: static libjsoncpp

The 32-bit variant of libjsoncpp is not always installed
on 64-bit devices, so it must always be statically included.

We should probably collapse libcutils_test with
libcutils_test_static in the future.

Bug: 285357054
Test: libcutils_test
Merged-In: Ic84901ce5af766338b2cab07c3cf10841ba9a150
Change-Id: Ic84901ce5af766338b2cab07c3cf10841ba9a150
---
 libcutils/Android.bp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index 68b21c6a0209..b9e0bb7eecb2 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -302,11 +302,14 @@ cc_defaults {
     ],
 }
 
+always_static_test_libraries = [
+    "libjsoncpp",
+]
+
 test_libraries = [
     "libcutils",
     "liblog",
     "libbase",
-    "libjsoncpp",
     "libprocessgroup",
     "libcgrouprc",
 ]
@@ -317,6 +320,7 @@ cc_test {
     defaults: ["libcutils_test_default"],
     host_supported: true,
     shared_libs: test_libraries,
+    static_libs: always_static_test_libraries,
     require_root: true,
 }
 
@@ -326,7 +330,7 @@ cc_defaults {
     static_libs: [
         "libc",
         "libcgrouprc_format",
-    ] + test_libraries,
+    ] + test_libraries + always_static_test_libraries,
     stl: "libc++_static",
     require_root: true,
 

From 084c94e43eb2916c84c72de524c6e8c3d5ec2d4f Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 6 Jun 2023 16:45:05 -0700
Subject: [PATCH 0099/1487] vts_fs_test: Relax filesystem constraints for fixed
 partitions.

Adjust this test to align with VSR. First, skip the test if kernel is
< 5.10 or < Android 13. Second, allow non-dynamic partitions to be vfat.

Bug: 286038059
Test: vts_fs_test on CF
Change-Id: I5bd874f68296f7155d8c4366ebc13fe3d59c3ee6
---
 fs_mgr/tests/vts_fs_test.cpp | 36 +++++++++++++++++++++---------------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/fs_mgr/tests/vts_fs_test.cpp b/fs_mgr/tests/vts_fs_test.cpp
index bb2ceb9b5681..4d771fa046d6 100644
--- a/fs_mgr/tests/vts_fs_test.cpp
+++ b/fs_mgr/tests/vts_fs_test.cpp
@@ -55,6 +55,21 @@ TEST(fs, ErofsSupported) {
 }
 
 TEST(fs, PartitionTypes) {
+    // Requirements only apply to Android 13+, 5.10+ devices.
+    int vsr_level = GetVsrLevel();
+    if (vsr_level < __ANDROID_API_T__) {
+        GTEST_SKIP();
+    }
+
+    struct utsname uts;
+    ASSERT_EQ(uname(&uts), 0);
+
+    unsigned int major, minor;
+    ASSERT_EQ(sscanf(uts.release, "%u.%u", &major, &minor), 2);
+    if (major < 5 || (major == 5 && minor < 10)) {
+        GTEST_SKIP();
+    }
+
     android::fs_mgr::Fstab fstab;
     ASSERT_TRUE(android::fs_mgr::ReadFstabFromFile("/proc/mounts", &fstab));
 
@@ -64,12 +79,7 @@ TEST(fs, PartitionTypes) {
     ASSERT_TRUE(android::base::Readlink("/dev/block/by-name/super", &super_bdev));
     ASSERT_TRUE(android::base::Readlink("/dev/block/by-name/userdata", &userdata_bdev));
 
-    int vsr_level = GetVsrLevel();
-
-    std::vector<std::string> must_be_f2fs;
-    if (vsr_level >= __ANDROID_API_T__) {
-        must_be_f2fs.emplace_back("/data");
-    }
+    std::vector<std::string> must_be_f2fs = {"/data"};
     if (vsr_level >= __ANDROID_API_U__) {
         must_be_f2fs.emplace_back("/metadata");
     }
@@ -98,17 +108,13 @@ TEST(fs, PartitionTypes) {
             continue;
         }
 
-        if (vsr_level < __ANDROID_API_T__) {
-            continue;
-        }
-        if (vsr_level == __ANDROID_API_T__ && parent_bdev != super_bdev) {
-            // Only check for dynamic partitions at this VSR level.
-            continue;
-        }
-
         if (entry.flags & MS_RDONLY) {
-            std::vector<std::string> allowed = {"erofs", "ext4", "f2fs"};
+            if (parent_bdev != super_bdev) {
+                // Ignore non-AOSP partitions (eg anything outside of super).
+                continue;
+            }
 
+            std::vector<std::string> allowed = {"erofs", "ext4", "f2fs"};
             EXPECT_NE(std::find(allowed.begin(), allowed.end(), entry.fs_type), allowed.end())
                     << entry.mount_point;
         } else {

From e55e3dcd3f59008f1e3a770b5265be88b332f22c Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 6 Jun 2023 16:45:05 -0700
Subject: [PATCH 0100/1487] vts_fs_test: Relax filesystem constraints for fixed
 partitions.

Adjust this test to align with VSR. First, skip the test if kernel is
< 5.10 or < Android 13. Second, allow non-dynamic partitions to be vfat.

Bug: 286038059
Test: vts_fs_test on CF
(cherry picked from https://android-review.googlesource.com/q/commit:084c94e43eb2916c84c72de524c6e8c3d5ec2d4f)
Merged-In: I5bd874f68296f7155d8c4366ebc13fe3d59c3ee6
Change-Id: I5bd874f68296f7155d8c4366ebc13fe3d59c3ee6
---
 fs_mgr/tests/vts_fs_test.cpp | 36 +++++++++++++++++++++---------------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/fs_mgr/tests/vts_fs_test.cpp b/fs_mgr/tests/vts_fs_test.cpp
index bb2ceb9b5681..4d771fa046d6 100644
--- a/fs_mgr/tests/vts_fs_test.cpp
+++ b/fs_mgr/tests/vts_fs_test.cpp
@@ -55,6 +55,21 @@ TEST(fs, ErofsSupported) {
 }
 
 TEST(fs, PartitionTypes) {
+    // Requirements only apply to Android 13+, 5.10+ devices.
+    int vsr_level = GetVsrLevel();
+    if (vsr_level < __ANDROID_API_T__) {
+        GTEST_SKIP();
+    }
+
+    struct utsname uts;
+    ASSERT_EQ(uname(&uts), 0);
+
+    unsigned int major, minor;
+    ASSERT_EQ(sscanf(uts.release, "%u.%u", &major, &minor), 2);
+    if (major < 5 || (major == 5 && minor < 10)) {
+        GTEST_SKIP();
+    }
+
     android::fs_mgr::Fstab fstab;
     ASSERT_TRUE(android::fs_mgr::ReadFstabFromFile("/proc/mounts", &fstab));
 
@@ -64,12 +79,7 @@ TEST(fs, PartitionTypes) {
     ASSERT_TRUE(android::base::Readlink("/dev/block/by-name/super", &super_bdev));
     ASSERT_TRUE(android::base::Readlink("/dev/block/by-name/userdata", &userdata_bdev));
 
-    int vsr_level = GetVsrLevel();
-
-    std::vector<std::string> must_be_f2fs;
-    if (vsr_level >= __ANDROID_API_T__) {
-        must_be_f2fs.emplace_back("/data");
-    }
+    std::vector<std::string> must_be_f2fs = {"/data"};
     if (vsr_level >= __ANDROID_API_U__) {
         must_be_f2fs.emplace_back("/metadata");
     }
@@ -98,17 +108,13 @@ TEST(fs, PartitionTypes) {
             continue;
         }
 
-        if (vsr_level < __ANDROID_API_T__) {
-            continue;
-        }
-        if (vsr_level == __ANDROID_API_T__ && parent_bdev != super_bdev) {
-            // Only check for dynamic partitions at this VSR level.
-            continue;
-        }
-
         if (entry.flags & MS_RDONLY) {
-            std::vector<std::string> allowed = {"erofs", "ext4", "f2fs"};
+            if (parent_bdev != super_bdev) {
+                // Ignore non-AOSP partitions (eg anything outside of super).
+                continue;
+            }
 
+            std::vector<std::string> allowed = {"erofs", "ext4", "f2fs"};
             EXPECT_NE(std::find(allowed.begin(), allowed.end(), entry.fs_type), allowed.end())
                     << entry.mount_point;
         } else {

From 4866d284f81dec3068c8f4f015d82c0db46c2b85 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 16 May 2023 15:53:57 -0700
Subject: [PATCH 0101/1487] ueventd: Fix a race condition in handling
 device-mapper events.

We've had flake in libdm_test for a long time, with no clear cause.
Lately however it has become particularly reproducible when running
the UeventAfterLoadTable test in isolation, and thus we've identified
the root cause.

uevents for device-mapper are fired when the sysfs node is added, but at
that time, the "dm" subnode has not yet been added. The root node and dm
node are added very close together, so usually it works, but sometimes
ueventd is too fast.

Instead of relying on sysfs, query the uuid/name node directly from
device-mapper.

Bug: 286011429
Test: libdm_test
(cherry picked from https://android-review.googlesource.com/q/commit:59abbfe64706a7ea0c4e932ae40bc8bde9746dce)
Merged-In: I258de5de05d813c3cb7f129e82e56dbfe8bf3117

Change-Id: I85e240807e0ce5ade211ec65453ab06d4066992a
---
 fs_mgr/libdm/dm.cpp             | 19 +++++++
 fs_mgr/libdm/dm_test.cpp        | 94 +++++++++++++++++++++++----------
 fs_mgr/libdm/include/libdm/dm.h |  2 +
 init/devices.cpp                | 18 +++----
 4 files changed, 94 insertions(+), 39 deletions(-)

diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index deffae1ad6fe..1e8c14fe2c01 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -243,6 +243,25 @@ bool DeviceMapper::GetDeviceUniquePath(const std::string& name, std::string* pat
     return true;
 }
 
+bool DeviceMapper::GetDeviceNameAndUuid(dev_t dev, std::string* name, std::string* uuid) {
+    struct dm_ioctl io;
+    InitIo(&io, {});
+    io.dev = dev;
+
+    if (ioctl(fd_, DM_DEV_STATUS, &io) < 0) {
+        PLOG(ERROR) << "Failed to find device dev: " << major(dev) << ":" << minor(dev);
+        return false;
+    }
+
+    if (name) {
+        *name = io.name;
+    }
+    if (uuid) {
+        *uuid = io.uuid;
+    }
+    return true;
+}
+
 std::optional<DeviceMapper::Info> DeviceMapper::GetDetailedInfo(const std::string& name) const {
     struct dm_ioctl io;
     InitIo(&io, name);
diff --git a/fs_mgr/libdm/dm_test.cpp b/fs_mgr/libdm/dm_test.cpp
index 788cf5174853..c522eafae058 100644
--- a/fs_mgr/libdm/dm_test.cpp
+++ b/fs_mgr/libdm/dm_test.cpp
@@ -30,6 +30,7 @@
 #include <thread>
 
 #include <android-base/file.h>
+#include <android-base/logging.h>
 #include <android-base/scopeguard.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
@@ -42,16 +43,40 @@
 using namespace std;
 using namespace std::chrono_literals;
 using namespace android::dm;
-using unique_fd = android::base::unique_fd;
+using android::base::make_scope_guard;
+using android::base::unique_fd;
+
+class DmTest : public ::testing::Test {
+  protected:
+    void SetUp() override {
+        const testing::TestInfo* const test_info =
+                testing::UnitTest::GetInstance()->current_test_info();
+        test_name_ = test_info->name();
+        test_full_name_ = test_info->test_suite_name() + "/"s + test_name_;
+
+        LOG(INFO) << "Starting test: " << test_full_name_;
+    }
+    void TearDown() override {
+        LOG(INFO) << "Tearing down test: " << test_full_name_;
+
+        auto& dm = DeviceMapper::Instance();
+        ASSERT_TRUE(dm.DeleteDeviceIfExists(test_name_));
+
+        LOG(INFO) << "Teardown complete for test: " << test_full_name_;
+    }
+
+    std::string test_name_;
+    std::string test_full_name_;
+};
 
-TEST(libdm, HasMinimumTargets) {
+TEST_F(DmTest, HasMinimumTargets) {
     DmTargetTypeInfo info;
 
     DeviceMapper& dm = DeviceMapper::Instance();
     ASSERT_TRUE(dm.GetTargetByName("linear", &info));
 }
 
-TEST(libdm, DmLinear) {
+TEST_F(DmTest, DmLinear) {
     unique_fd tmp1(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp1, 0);
     unique_fd tmp2(CreateTempFile("file_2", 4096));
@@ -127,7 +152,7 @@ TEST(libdm, DmLinear) {
     ASSERT_TRUE(dev.Destroy());
 }
 
-TEST(libdm, DmSuspendResume) {
+TEST_F(DmTest, DmSuspendResume) {
     unique_fd tmp1(CreateTempFile("file_suspend_resume", 512));
     ASSERT_GE(tmp1, 0);
 
@@ -156,7 +181,7 @@ TEST(libdm, DmSuspendResume) {
     ASSERT_EQ(dm.GetState(dev.name()), DmDeviceState::ACTIVE);
 }
 
-TEST(libdm, DmVerityArgsAvb2) {
+TEST_F(DmTest, DmVerityArgsAvb2) {
     std::string device = "/dev/block/platform/soc/1da4000.ufshc/by-name/vendor_a";
     std::string algorithm = "sha1";
     std::string digest = "4be7e823b8c40f7bd5c8ccd5123f0722c5baca21";
@@ -178,7 +203,7 @@ TEST(libdm, DmVerityArgsAvb2) {
     EXPECT_EQ(target.GetParameterString(), expected);
 }
 
-TEST(libdm, DmSnapshotArgs) {
+TEST_F(DmTest, DmSnapshotArgs) {
     DmTargetSnapshot target1(0, 512, "base", "cow", SnapshotStorageMode::Persistent, 8);
     if (DmTargetSnapshot::ReportsOverflow("snapshot")) {
         EXPECT_EQ(target1.GetParameterString(), "base cow PO 8");
@@ -200,7 +225,7 @@ TEST(libdm, DmSnapshotArgs) {
     EXPECT_EQ(target3.name(), "snapshot-merge");
 }
 
-TEST(libdm, DmSnapshotOriginArgs) {
+TEST_F(DmTest, DmSnapshotOriginArgs) {
     DmTargetSnapshotOrigin target(0, 512, "base");
     EXPECT_EQ(target.GetParameterString(), "base");
     EXPECT_EQ(target.name(), "snapshot-origin");
@@ -330,7 +355,7 @@ bool CheckSnapshotAvailability() {
     return true;
 }
 
-TEST(libdm, DmSnapshot) {
+TEST_F(DmTest, DmSnapshot) {
     if (!CheckSnapshotAvailability()) {
         return;
     }
@@ -374,7 +399,7 @@ TEST(libdm, DmSnapshot) {
     ASSERT_EQ(read, data);
 }
 
-TEST(libdm, DmSnapshotOverflow) {
+TEST_F(DmTest, DmSnapshotOverflow) {
     if (!CheckSnapshotAvailability()) {
         return;
     }
@@ -421,7 +446,7 @@ TEST(libdm, DmSnapshotOverflow) {
     }
 }
 
-TEST(libdm, ParseStatusText) {
+TEST_F(DmTest, ParseStatusText) {
     DmTargetSnapshot::Status status;
 
     // Bad inputs
@@ -448,7 +473,7 @@ TEST(libdm, ParseStatusText) {
     EXPECT_TRUE(DmTargetSnapshot::ParseStatusText("Overflow", &status));
 }
 
-TEST(libdm, DmSnapshotMergePercent) {
+TEST_F(DmTest, DmSnapshotMergePercent) {
     DmTargetSnapshot::Status status;
 
     // Correct input
@@ -502,7 +527,7 @@ TEST(libdm, DmSnapshotMergePercent) {
     EXPECT_LE(DmTargetSnapshot::MergePercent(status, 0), 0.0);
 }
 
-TEST(libdm, CryptArgs) {
+TEST_F(DmTest, CryptArgs) {
     DmTargetCrypt target1(0, 512, "sha1", "abcdefgh", 50, "/dev/loop0", 100);
     ASSERT_EQ(target1.name(), "crypt");
     ASSERT_TRUE(target1.Valid());
@@ -518,7 +543,7 @@ TEST(libdm, CryptArgs) {
               "iv_large_sectors sector_size:64");
 }
 
-TEST(libdm, DefaultKeyArgs) {
+TEST_F(DmTest, DefaultKeyArgs) {
     DmTargetDefaultKey target(0, 4096, "aes-xts-plain64", "abcdef0123456789", "/dev/loop0", 0);
     target.SetSetDun();
     ASSERT_EQ(target.name(), "default-key");
@@ -529,7 +554,7 @@ TEST(libdm, DefaultKeyArgs) {
               "iv_large_sectors");
 }
 
-TEST(libdm, DefaultKeyLegacyArgs) {
+TEST_F(DmTest, DefaultKeyLegacyArgs) {
     DmTargetDefaultKey target(0, 4096, "AES-256-XTS", "abcdef0123456789", "/dev/loop0", 0);
     target.SetUseLegacyOptionsFormat();
     ASSERT_EQ(target.name(), "default-key");
@@ -537,7 +562,7 @@ TEST(libdm, DefaultKeyLegacyArgs) {
     ASSERT_EQ(target.GetParameterString(), "AES-256-XTS abcdef0123456789 /dev/loop0 0");
 }
 
-TEST(libdm, DeleteDeviceWithTimeout) {
+TEST_F(DmTest, DeleteDeviceWithTimeout) {
     unique_fd tmp(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp, 0);
     LoopDevice loop(tmp, 10s);
@@ -561,7 +586,7 @@ TEST(libdm, DeleteDeviceWithTimeout) {
     ASSERT_EQ(ENOENT, errno);
 }
 
-TEST(libdm, IsDmBlockDevice) {
+TEST_F(DmTest, IsDmBlockDevice) {
     unique_fd tmp(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp, 0);
     LoopDevice loop(tmp, 10s);
@@ -580,7 +605,7 @@ TEST(libdm, IsDmBlockDevice) {
     ASSERT_FALSE(dm.IsDmBlockDevice(loop.device()));
 }
 
-TEST(libdm, GetDmDeviceNameByPath) {
+TEST_F(DmTest, GetDmDeviceNameByPath) {
     unique_fd tmp(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp, 0);
     LoopDevice loop(tmp, 10s);
@@ -601,7 +626,7 @@ TEST(libdm, GetDmDeviceNameByPath) {
     ASSERT_EQ("libdm-test-dm-linear", *name);
 }
 
-TEST(libdm, GetParentBlockDeviceByPath) {
+TEST_F(DmTest, GetParentBlockDeviceByPath) {
     unique_fd tmp(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp, 0);
     LoopDevice loop(tmp, 10s);
@@ -621,7 +646,7 @@ TEST(libdm, GetParentBlockDeviceByPath) {
     ASSERT_EQ(loop.device(), *sub_block_device);
 }
 
-TEST(libdm, DeleteDeviceDeferredNoReferences) {
+TEST_F(DmTest, DeleteDeviceDeferredNoReferences) {
     unique_fd tmp(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp, 0);
     LoopDevice loop(tmp, 10s);
@@ -647,7 +672,7 @@ TEST(libdm, DeleteDeviceDeferredNoReferences) {
     ASSERT_EQ(ENOENT, errno);
 }
 
-TEST(libdm, DeleteDeviceDeferredWaitsForLastReference) {
+TEST_F(DmTest, DeleteDeviceDeferredWaitsForLastReference) {
     unique_fd tmp(CreateTempFile("file_1", 4096));
     ASSERT_GE(tmp, 0);
     LoopDevice loop(tmp, 10s);
@@ -682,7 +707,7 @@ TEST(libdm, DeleteDeviceDeferredWaitsForLastReference) {
     ASSERT_EQ(ENOENT, errno);
 }
 
-TEST(libdm, CreateEmptyDevice) {
+TEST_F(DmTest, CreateEmptyDevice) {
     DeviceMapper& dm = DeviceMapper::Instance();
     ASSERT_TRUE(dm.CreateEmptyDevice("empty-device"));
     auto guard =
@@ -692,9 +717,7 @@ TEST(libdm, CreateEmptyDevice) {
     ASSERT_EQ(DmDeviceState::SUSPENDED, dm.GetState("empty-device"));
 }
 
-TEST(libdm, UeventAfterLoadTable) {
-    static const char* kDeviceName = "libdm-test-uevent-load-table";
-
+TEST_F(DmTest, UeventAfterLoadTable) {
     struct utsname u;
     ASSERT_EQ(uname(&u), 0);
 
@@ -706,18 +729,31 @@ TEST(libdm, UeventAfterLoadTable) {
     }
 
     DeviceMapper& dm = DeviceMapper::Instance();
-    ASSERT_TRUE(dm.CreateEmptyDevice(kDeviceName));
+    ASSERT_TRUE(dm.CreateEmptyDevice(test_name_));
 
     DmTable table;
     table.Emplace<DmTargetError>(0, 1);
-    ASSERT_TRUE(dm.LoadTable(kDeviceName, table));
+    ASSERT_TRUE(dm.LoadTable(test_name_, table));
 
     std::string ignore_path;
-    ASSERT_TRUE(dm.WaitForDevice(kDeviceName, 5s, &ignore_path));
+    ASSERT_TRUE(dm.WaitForDevice(test_name_, 5s, &ignore_path));
 
-    auto info = dm.GetDetailedInfo(kDeviceName);
+    auto info = dm.GetDetailedInfo(test_name_);
     ASSERT_TRUE(info.has_value());
     ASSERT_TRUE(info->IsSuspended());
 
-    ASSERT_TRUE(dm.DeleteDevice(kDeviceName));
+    ASSERT_TRUE(dm.DeleteDevice(test_name_));
+}
+
+TEST_F(DmTest, GetNameAndUuid) {
+    auto& dm = DeviceMapper::Instance();
+    ASSERT_TRUE(dm.CreatePlaceholderDevice(test_name_));
+
+    dev_t dev;
+    ASSERT_TRUE(dm.GetDeviceNumber(test_name_, &dev));
+
+    std::string name, uuid;
+    ASSERT_TRUE(dm.GetDeviceNameAndUuid(dev, &name, &uuid));
+    ASSERT_EQ(name, test_name_);
+    ASSERT_FALSE(uuid.empty());
 }
diff --git a/fs_mgr/libdm/include/libdm/dm.h b/fs_mgr/libdm/include/libdm/dm.h
index dbef8f902b29..3e7ecc645eec 100644
--- a/fs_mgr/libdm/include/libdm/dm.h
+++ b/fs_mgr/libdm/include/libdm/dm.h
@@ -298,6 +298,8 @@ class DeviceMapper final : public IDeviceMapper {
     // a placeholder table containing dm-error.
     bool CreatePlaceholderDevice(const std::string& name);
 
+    bool GetDeviceNameAndUuid(dev_t dev, std::string* name, std::string* uuid);
+
   private:
     // Maximum possible device mapper targets registered in the kernel.
     // This is only used to read the list of targets from kernel so we allocate
diff --git a/init/devices.cpp b/init/devices.cpp
index 39442a0e8019..d29ffd604f4e 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -32,6 +32,7 @@
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
+#include <libdm/dm.h>
 #include <private/android_filesystem_config.h>
 #include <selinux/android.h>
 #include <selinux/selinux.h>
@@ -112,17 +113,14 @@ static bool FindVbdDevicePrefix(const std::string& path, std::string* result) {
 // the supplied buffer with the dm module's instantiated name.
 // If it doesn't start with a virtual block device, or there is some
 // error, return false.
-static bool FindDmDevice(const std::string& path, std::string* name, std::string* uuid) {
-    if (!StartsWith(path, "/devices/virtual/block/dm-")) return false;
+static bool FindDmDevice(const Uevent& uevent, std::string* name, std::string* uuid) {
+    if (!StartsWith(uevent.path, "/devices/virtual/block/dm-")) return false;
+    if (uevent.action == "remove") return false;  // Avoid error spam from ioctl
 
-    if (!ReadFileToString("/sys" + path + "/dm/name", name)) {
-        return false;
-    }
-    ReadFileToString("/sys" + path + "/dm/uuid", uuid);
+    dev_t dev = makedev(uevent.major, uevent.minor);
 
-    *name = android::base::Trim(*name);
-    *uuid = android::base::Trim(*uuid);
-    return true;
+    auto& dm = android::dm::DeviceMapper::Instance();
+    return dm.GetDeviceNameAndUuid(dev, name, uuid);
 }
 
 Permissions::Permissions(const std::string& name, mode_t perm, uid_t uid, gid_t gid,
@@ -392,7 +390,7 @@ std::vector<std::string> DeviceHandler::GetBlockDeviceSymlinks(const Uevent& uev
         type = "pci";
     } else if (FindVbdDevicePrefix(uevent.path, &device)) {
         type = "vbd";
-    } else if (FindDmDevice(uevent.path, &partition, &uuid)) {
+    } else if (FindDmDevice(uevent, &partition, &uuid)) {
         std::vector<std::string> symlinks = {"/dev/block/mapper/" + partition};
         if (!uuid.empty()) {
             symlinks.emplace_back("/dev/block/mapper/by-uuid/" + uuid);

From 874fdaed435009dfba8255bae4a2dbdc1900b2a4 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 8 May 2023 21:17:32 -0700
Subject: [PATCH 0102/1487] libsnapshot: Add CowWriterBase, clean up CowWriter.

To support multiple implementations of CowWriter, we will need to move
direct usage of CowWriter to ICowWriter. This CL does this while also
adding some small cleanups:

- Move ICowWriter implementation methods to a new CowWriterBase class.
  This keeps ICowWriter as a clean interface.
- Make the "Add" methods pure virtual, move the "Emit" methods to
  CowWriterBase as an implementation detail.
- Simplify Initialize/InitializeAppend so they can be shared.
- Rename CowWriter to CowWriterV2.
- Rename cow_writer.cpp to writer_v2.cpp.
- Rename cow_api_test.cpp to test_v2.cpp.
- Remove ICowWriter::options, replace with GetBlockSize.
- Add a CreateCowWriter helper to avoid implementation details in
  update_engine.

Bug: 280529365
Test: builds
Change-Id: If50faf03b292c6c8b23a6170e3f37329fb759ff6
---
 fs_mgr/libsnapshot/Android.bp                 |   9 +-
 .../include/libsnapshot/cow_format.h          |   4 +
 .../include/libsnapshot/cow_writer.h          | 150 ++----------
 .../libsnapshot/mock_snapshot_writer.h        |  25 +-
 .../include/libsnapshot/snapshot_writer.h     |  50 ++--
 .../libsnapshot_cow/cow_format.cpp            |  25 ++
 .../{cow_api_test.cpp => test_v2.cpp}         | 154 ++++++------
 .../libsnapshot_cow/writer_base.cpp           | 163 ++++++++++++
 .../libsnapshot/libsnapshot_cow/writer_base.h |  71 ++++++
 .../{cow_writer.cpp => writer_v2.cpp}         | 231 ++++--------------
 .../libsnapshot/libsnapshot_cow/writer_v2.h   |  94 +++++++
 fs_mgr/libsnapshot/snapshot.cpp               |   5 +-
 fs_mgr/libsnapshot/snapshot_test.cpp          |  12 +-
 fs_mgr/libsnapshot/snapshot_writer.cpp        |  68 ++++--
 .../dm-snapshot-merge/cow_snapuserd_test.cpp  | 209 +++++++---------
 .../user-space-merge/snapuserd_test.cpp       | 111 ++++-----
 16 files changed, 748 insertions(+), 633 deletions(-)
 rename fs_mgr/libsnapshot/libsnapshot_cow/{cow_api_test.cpp => test_v2.cpp} (91%)
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/writer_base.cpp
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
 rename fs_mgr/libsnapshot/libsnapshot_cow/{cow_writer.cpp => writer_v2.cpp} (75%)
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index cba68446792a..e931bec39ff0 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -174,12 +174,13 @@ cc_library_static {
         "libsnapshot_cow_defaults",
     ],
     srcs: [
+        "libsnapshot_cow/cow_compress.cpp",
         "libsnapshot_cow/cow_decompress.cpp",
-        "libsnapshot_cow/cow_reader.cpp",
-        "libsnapshot_cow/cow_writer.cpp",
         "libsnapshot_cow/cow_format.cpp",
-        "libsnapshot_cow/cow_compress.cpp",
+        "libsnapshot_cow/cow_reader.cpp",
         "libsnapshot_cow/parser_v2.cpp",
+        "libsnapshot_cow/writer_base.cpp",
+        "libsnapshot_cow/writer_v2.cpp",
     ],
     host_supported: true,
     recovery_available: true,
@@ -371,7 +372,7 @@ cc_test {
         "libsnapshot_cow_defaults",
     ],
     srcs: [
-        "libsnapshot_cow/cow_api_test.cpp",
+        "libsnapshot_cow/test_v2.cpp",
     ],
     cflags: [
         "-D_FILE_OFFSET_BITS=64",
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index b228dff8d72c..dd626bc4683a 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -31,6 +31,10 @@ static constexpr uint32_t kCowVersionManifest = 2;
 static constexpr uint32_t kMinCowVersion = 1;
 static constexpr uint32_t kMaxCowVersion = 2;
 
+// Normally, this should be kMaxCowVersion. When a new version is under testing
+// it may be the previous value of kMaxCowVersion.
+static constexpr uint32_t kDefaultCowVersion = 2;
+
 // This header appears as the first sequence of bytes in the COW. All fields
 // in the layout are little-endian encoded. The on-disk layout is:
 //
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 7881f35099dd..af2d3efc521a 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -1,16 +1,16 @@
-// Copyright (C) 2019 The Android Open Source Project
+// 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
+// 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
+//      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.
+// unless required by applicable law or agreed to in writing, software
+// distributed under the license is distributed on an "as is" basis,
+// without warranties or conditions of any kind, either express or implied.
+// see the license for the specific language governing permissions and
+// limitations under the license.
 
 #pragma once
 
@@ -61,30 +61,28 @@ struct CowOptions {
 // will occur in the sequence they were added to the COW.
 class ICowWriter {
   public:
-    explicit ICowWriter(const CowOptions& options) : options_(options) {}
-
     virtual ~ICowWriter() {}
 
     // Encode an operation that copies the contents of |old_block| to the
     // location of |new_block|. 'num_blocks' is the number of contiguous
     // COPY operations from |old_block| to |new_block|.
-    bool AddCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1);
+    virtual bool AddCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) = 0;
 
     // Encode a sequence of raw blocks. |size| must be a multiple of the block size.
-    bool AddRawBlocks(uint64_t new_block_start, const void* data, size_t size);
+    virtual bool AddRawBlocks(uint64_t new_block_start, const void* data, size_t size) = 0;
 
     // Add a sequence of xor'd blocks. |size| must be a multiple of the block size.
-    bool AddXorBlocks(uint32_t new_block_start, const void* data, size_t size, uint32_t old_block,
-                      uint16_t offset);
+    virtual bool AddXorBlocks(uint32_t new_block_start, const void* data, size_t size,
+                              uint32_t old_block, uint16_t offset) = 0;
 
     // Encode a sequence of zeroed blocks. |size| must be a multiple of the block size.
-    bool AddZeroBlocks(uint64_t new_block_start, uint64_t num_blocks);
+    virtual bool AddZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) = 0;
 
     // Add a label to the op sequence.
-    bool AddLabel(uint64_t label);
+    virtual bool AddLabel(uint64_t label) = 0;
 
     // Add sequence data for op merging. Data is a list of the destination block numbers.
-    bool AddSequenceData(size_t num_ops, const uint32_t* data);
+    virtual bool AddSequenceData(size_t num_ops, const uint32_t* data) = 0;
 
     // Flush all pending writes. This must be called before closing the writer
     // to ensure that the correct headers and footers are written.
@@ -93,21 +91,8 @@ class ICowWriter {
     // Return number of bytes the cow image occupies on disk.
     virtual uint64_t GetCowSize() = 0;
 
-    const CowOptions& options() { return options_; }
-
-  protected:
-    virtual bool EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) = 0;
-    virtual bool EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) = 0;
-    virtual bool EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size,
-                               uint32_t old_block, uint16_t offset) = 0;
-    virtual bool EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) = 0;
-    virtual bool EmitLabel(uint64_t label) = 0;
-    virtual bool EmitSequenceData(size_t num_ops, const uint32_t* data) = 0;
-
-    bool ValidateNewBlock(uint64_t new_block);
-
-  protected:
-    CowOptions options_;
+    virtual uint32_t GetBlockSize() const = 0;
+    virtual std::optional<uint32_t> GetMaxBlocks() const = 0;
 };
 
 class CompressWorker {
@@ -146,96 +131,15 @@ class CompressWorker {
                         std::vector<std::basic_string<uint8_t>>* compressed_data);
 };
 
-class CowWriter : public ICowWriter {
-  public:
-    explicit CowWriter(const CowOptions& options);
-    ~CowWriter();
-
-    // Set up the writer.
-    // The file starts from the beginning.
-    //
-    // If fd is < 0, the CowWriter will be opened against /dev/null. This is for
-    // computing COW sizes without using storage space.
-    bool Initialize(android::base::unique_fd&& fd);
-    bool Initialize(android::base::borrowed_fd fd);
-    // Set up a writer, assuming that the given label is the last valid label.
-    // This will result in dropping any labels that occur after the given on, and will fail
-    // if the given label does not appear.
-    bool InitializeAppend(android::base::unique_fd&&, uint64_t label);
-    bool InitializeAppend(android::base::borrowed_fd fd, uint64_t label);
-
-    bool Finalize() override;
-
-    uint64_t GetCowSize() override;
-
-  protected:
-    virtual bool EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) override;
-    virtual bool EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) override;
-    virtual bool EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size,
-                               uint32_t old_block, uint16_t offset) override;
-    virtual bool EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) override;
-    virtual bool EmitLabel(uint64_t label) override;
-    virtual bool EmitSequenceData(size_t num_ops, const uint32_t* data) override;
+// Create an ICowWriter not backed by any file. This is useful for estimating
+// the final size of a cow file.
+std::unique_ptr<ICowWriter> CreateCowEstimator(uint32_t version, const CowOptions& options);
 
-  private:
-    bool EmitCluster();
-    bool EmitClusterIfNeeded();
-    bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
-                    uint16_t offset, uint8_t type);
-    void SetupHeaders();
-    void SetupWriteOptions();
-    bool ParseOptions();
-    bool OpenForWrite();
-    bool OpenForAppend(uint64_t label);
-    bool GetDataPos(uint64_t* pos);
-    bool WriteRawData(const void* data, size_t size);
-    bool WriteOperation(const CowOperation& op, const void* data = nullptr, size_t size = 0);
-    void AddOperation(const CowOperation& op);
-    void InitPos();
-    void InitBatchWrites();
-    void InitWorkers();
-    bool FlushCluster();
-
-    bool CompressBlocks(size_t num_blocks, const void* data);
-    bool SetFd(android::base::borrowed_fd fd);
-    bool Sync();
-    bool Truncate(off_t length);
-    bool EnsureSpaceAvailable(const uint64_t bytes_needed) const;
-
-  private:
-    android::base::unique_fd owned_fd_;
-    android::base::borrowed_fd fd_;
-    CowHeader header_{};
-    CowFooter footer_{};
-    CowCompressionAlgorithm compression_ = kCowCompressNone;
-    uint64_t current_op_pos_ = 0;
-    uint64_t next_op_pos_ = 0;
-    uint64_t next_data_pos_ = 0;
-    uint64_t current_data_pos_ = 0;
-    ssize_t total_data_written_ = 0;
-    uint32_t cluster_size_ = 0;
-    uint32_t current_cluster_size_ = 0;
-    uint64_t current_data_size_ = 0;
-    bool is_dev_null_ = false;
-    bool merge_in_progress_ = false;
-    bool is_block_device_ = false;
-    uint64_t cow_image_size_ = INT64_MAX;
-
-    int num_compress_threads_ = 1;
-    std::vector<std::unique_ptr<CompressWorker>> compress_threads_;
-    std::vector<std::future<bool>> threads_;
-    std::vector<std::basic_string<uint8_t>> compressed_buf_;
-    std::vector<std::basic_string<uint8_t>>::iterator buf_iter_;
-
-    std::vector<std::unique_ptr<CowOperation>> opbuffer_vec_;
-    std::vector<std::unique_ptr<uint8_t[]>> databuffer_vec_;
-    std::unique_ptr<struct iovec[]> cowop_vec_;
-    int op_vec_index_ = 0;
-
-    std::unique_ptr<struct iovec[]> data_vec_;
-    int data_vec_index_ = 0;
-    bool batch_write_ = false;
-};
+// Create an ICowWriter of the given version and options. If a label is given,
+// the writer is opened in append mode.
+std::unique_ptr<ICowWriter> CreateCowWriter(uint32_t version, const CowOptions& options,
+                                            android::base::unique_fd&& fd,
+                                            std::optional<uint64_t> label = {});
 
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot_writer.h
index d798e25e3c4c..52e3a9c4eb34 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot_writer.h
@@ -23,30 +23,23 @@ class MockSnapshotWriter : public ISnapshotWriter {
   public:
     using FileDescriptor = ISnapshotWriter::FileDescriptor;
 
-    explicit MockSnapshotWriter(const CowOptions& options) : ISnapshotWriter(options) {}
-    MockSnapshotWriter() : ISnapshotWriter({}) {}
-
     MOCK_METHOD(bool, Finalize, (), (override));
 
     // Return number of bytes the cow image occupies on disk.
     MOCK_METHOD(uint64_t, GetCowSize, (), (override));
 
-    MOCK_METHOD(bool, EmitCopy, (uint64_t, uint64_t, uint64_t), (override));
-    MOCK_METHOD(bool, EmitRawBlocks, (uint64_t, const void*, size_t), (override));
-    MOCK_METHOD(bool, EmitXorBlocks, (uint32_t, const void*, size_t, uint32_t, uint16_t),
+    MOCK_METHOD(bool, AddCopy, (uint64_t, uint64_t, uint64_t), (override));
+    MOCK_METHOD(bool, AddRawBlocks, (uint64_t, const void*, size_t), (override));
+    MOCK_METHOD(bool, AddXorBlocks, (uint32_t, const void*, size_t, uint32_t, uint16_t),
                 (override));
-    MOCK_METHOD(bool, EmitZeroBlocks, (uint64_t, uint64_t), (override));
-    MOCK_METHOD(bool, EmitLabel, (uint64_t), (override));
-    MOCK_METHOD(bool, EmitSequenceData, (size_t, const uint32_t*), (override));
-
-    // Open the writer in write mode (no append).
+    MOCK_METHOD(bool, AddZeroBlocks, (uint64_t, uint64_t), (override));
+    MOCK_METHOD(bool, AddLabel, (uint64_t), (override));
+    MOCK_METHOD(bool, AddSequenceData, (size_t, const uint32_t*), (override));
     MOCK_METHOD(bool, Initialize, (), (override));
+    MOCK_METHOD(bool, InitializeAppend, (uint64_t), (override));
     MOCK_METHOD(bool, VerifyMergeOps, (), (override, const, noexcept));
-
-    // Open the writer in append mode, with the last label to resume
-    // from. See CowWriter::InitializeAppend.
-    MOCK_METHOD(bool, InitializeAppend, (uint64_t label), (override));
-
     MOCK_METHOD(std::unique_ptr<FileDescriptor>, OpenReader, (), (override));
+    MOCK_METHOD(uint32_t, GetBlockSize, (), (override, const));
+    MOCK_METHOD(std::optional<uint32_t>, GetMaxBlocks, (), (override, const));
 };
 }  // namespace android::snapshot
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot_writer.h
index 8f6344c3b741..2653a6053026 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot_writer.h
@@ -31,13 +31,7 @@ class ISnapshotWriter : public ICowWriter {
   public:
     using FileDescriptor = chromeos_update_engine::FileDescriptor;
 
-    explicit ISnapshotWriter(const CowOptions& options);
-
-    // Set the source device. This is used for AddCopy() operations, if the
-    // underlying writer needs the original bytes (for example if backed by
-    // dm-snapshot or if writing directly to an unsnapshotted region). The
-    // device is only opened on the first operation that requires it.
-    void SetSourceDevice(const std::string& source_device);
+    virtual ~ISnapshotWriter() {}
 
     // Open the writer in write mode (no append).
     virtual bool Initialize() = 0;
@@ -47,15 +41,8 @@ class ISnapshotWriter : public ICowWriter {
     virtual bool InitializeAppend(uint64_t label) = 0;
 
     virtual std::unique_ptr<FileDescriptor> OpenReader() = 0;
-    virtual bool VerifyMergeOps() const noexcept = 0;
 
-  protected:
-    android::base::borrowed_fd GetSourceFd();
-
-    std::optional<std::string> source_device_;
-
-  private:
-    android::base::unique_fd source_fd_;
+    virtual bool VerifyMergeOps() const noexcept = 0;
 };
 
 // Send writes to a COW or a raw device directly, based on a threshold.
@@ -63,6 +50,8 @@ class CompressedSnapshotWriter final : public ISnapshotWriter {
   public:
     CompressedSnapshotWriter(const CowOptions& options);
 
+    void SetSourceDevice(const std::string& source_device);
+
     // Sets the COW device; this is required.
     bool SetCowDevice(android::base::unique_fd&& cow_device);
 
@@ -70,23 +59,34 @@ class CompressedSnapshotWriter final : public ISnapshotWriter {
     bool InitializeAppend(uint64_t label) override;
     bool Finalize() override;
     uint64_t GetCowSize() override;
+    uint32_t GetBlockSize() const override;
+    std::optional<uint32_t> GetMaxBlocks() const override;
     std::unique_ptr<FileDescriptor> OpenReader() override;
     bool VerifyMergeOps() const noexcept;
 
-  protected:
-    bool EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) override;
-    bool EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) override;
-    bool EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size, uint32_t old_block,
-                       uint16_t offset) override;
-    bool EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) override;
-    bool EmitLabel(uint64_t label) override;
-    bool EmitSequenceData(size_t num_ops, const uint32_t* data) override;
+    bool AddCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) override;
+    bool AddRawBlocks(uint64_t new_block_start, const void* data, size_t size) override;
+    bool AddXorBlocks(uint32_t new_block_start, const void* data, size_t size, uint32_t old_block,
+                      uint16_t offset) override;
+    bool AddZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) override;
+    bool AddLabel(uint64_t label) override;
+    bool AddSequenceData(size_t num_ops, const uint32_t* data) override;
 
   private:
     std::unique_ptr<CowReader> OpenCowReader() const;
-    android::base::unique_fd cow_device_;
+    android::base::borrowed_fd GetSourceFd();
 
-    std::unique_ptr<CowWriter> cow_;
+    CowOptions options_;
+
+    // Set the source device. This is used for AddCopy() operations, if the
+    // underlying writer needs the original bytes (for example if backed by
+    // dm-snapshot or if writing directly to an unsnapshotted region). The
+    // device is only opened on the first operation that requires it.
+    std::optional<std::string> source_device_;
+    android::base::unique_fd source_fd_;
+
+    android::base::unique_fd cow_device_;
+    std::unique_ptr<ICowWriter> cow_;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
index 2157d0fa94cb..ff3ccecb86aa 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
@@ -19,10 +19,13 @@
 #include <unistd.h>
 
 #include <android-base/logging.h>
+#include "writer_v2.h"
 
 namespace android {
 namespace snapshot {
 
+using android::base::unique_fd;
+
 std::ostream& operator<<(std::ostream& os, CowOperation const& op) {
     os << "CowOperation(type:";
     if (op.type == kCowCopyOp)
@@ -103,5 +106,27 @@ bool IsOrderedOp(const CowOperation& op) {
     }
 }
 
+std::unique_ptr<ICowWriter> CreateCowWriter(uint32_t version, const CowOptions& options,
+                                            unique_fd&& fd, std::optional<uint64_t> label) {
+    std::unique_ptr<CowWriterBase> base;
+    switch (version) {
+        case 1:
+        case 2:
+            base = std::make_unique<CowWriterV2>(options, std::move(fd));
+            break;
+        default:
+            LOG(ERROR) << "Cannot create unknown cow version: " << version;
+            return nullptr;
+    }
+    if (!base->Initialize(label)) {
+        return nullptr;
+    }
+    return base;
+}
+
+std::unique_ptr<ICowWriter> CreateCowEstimator(uint32_t version, const CowOptions& options) {
+    return CreateCowWriter(version, options, unique_fd{-1}, std::nullopt);
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_api_test.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
similarity index 91%
rename from fs_mgr/libsnapshot/libsnapshot_cow/cow_api_test.cpp
rename to fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 8f80bb34533b..120b2c062c83 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_api_test.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -25,7 +25,9 @@
 #include <libsnapshot/cow_reader.h>
 #include <libsnapshot/cow_writer.h>
 #include "cow_decompress.h"
+#include "writer_v2.h"
 
+using android::base::unique_fd;
 using testing::AssertionFailure;
 using testing::AssertionResult;
 using testing::AssertionSuccess;
@@ -42,6 +44,8 @@ class CowTest : public ::testing::Test {
 
     virtual void TearDown() override { cow_ = nullptr; }
 
+    unique_fd GetCowFd() { return unique_fd{dup(cow_->fd)}; }
+
     std::unique_ptr<TemporaryFile> cow_;
 };
 
@@ -53,9 +57,9 @@ static inline bool ReadData(CowReader& reader, const CowOperation* op, void* buf
 TEST_F(CowTest, CopyContiguous) {
     CowOptions options;
     options.cluster_ops = 0;
-    CowWriter writer(options);
+    CowWriterV2 writer(options, GetCowFd());
 
-    ASSERT_TRUE(writer.Initialize(cow_->fd));
+    ASSERT_TRUE(writer.Initialize());
 
     ASSERT_TRUE(writer.AddCopy(10, 1000, 100));
     ASSERT_TRUE(writer.Finalize());
@@ -96,9 +100,9 @@ TEST_F(CowTest, CopyContiguous) {
 TEST_F(CowTest, ReadWrite) {
     CowOptions options;
     options.cluster_ops = 0;
-    CowWriter writer(options);
+    CowWriterV2 writer(options, GetCowFd());
 
-    ASSERT_TRUE(writer.Initialize(cow_->fd));
+    ASSERT_TRUE(writer.Initialize());
 
     std::string data = "This is some data, believe it";
     data.resize(options.block_size, '\0');
@@ -175,9 +179,9 @@ TEST_F(CowTest, ReadWrite) {
 TEST_F(CowTest, ReadWriteXor) {
     CowOptions options;
     options.cluster_ops = 0;
-    CowWriter writer(options);
+    CowWriterV2 writer(options, GetCowFd());
 
-    ASSERT_TRUE(writer.Initialize(cow_->fd));
+    ASSERT_TRUE(writer.Initialize());
 
     std::string data = "This is some data, believe it";
     data.resize(options.block_size, '\0');
@@ -256,9 +260,9 @@ TEST_F(CowTest, CompressGz) {
     CowOptions options;
     options.cluster_ops = 0;
     options.compression = "gz";
-    CowWriter writer(options);
+    CowWriterV2 writer(options, GetCowFd());
 
-    ASSERT_TRUE(writer.Initialize(cow_->fd));
+    ASSERT_TRUE(writer.Initialize());
 
     std::string data = "This is some data, believe it";
     data.resize(options.block_size, '\0');
@@ -296,9 +300,9 @@ TEST_P(CompressionTest, ThreadedBatchWrites) {
     options.compression = GetParam();
     options.num_compress_threads = 2;
 
-    CowWriter writer(options);
+    CowWriterV2 writer(options, GetCowFd());
 
-    ASSERT_TRUE(writer.Initialize(cow_->fd));
+    ASSERT_TRUE(writer.Initialize());
 
     std::string xor_data = "This is test data-1. Testing xor";
     xor_data.resize(options.block_size, '\0');
@@ -374,9 +378,9 @@ TEST_P(CompressionTest, NoBatchWrites) {
     options.num_compress_threads = 1;
     options.cluster_ops = 0;
 
-    CowWriter writer(options);
+    CowWriterV2 writer(options, GetCowFd());
 
-    ASSERT_TRUE(writer.Initialize(cow_->fd));
+    ASSERT_TRUE(writer.Initialize());
 
     std::string data = "Testing replace ops without batch writes";
     data.resize(options.block_size * 1024, '\0');
@@ -497,9 +501,9 @@ TEST_F(CowTest, ClusterCompressGz) {
     CowOptions options;
     options.compression = "gz";
     options.cluster_ops = 2;
-    CowWriter writer(options);
+    CowWriterV2 writer(options, GetCowFd());
 
-    ASSERT_TRUE(writer.Initialize(cow_->fd));
+    ASSERT_TRUE(writer.Initialize());
 
     std::string data = "This is some data, believe it";
     data.resize(options.block_size, '\0');
@@ -562,9 +566,9 @@ TEST_F(CowTest, CompressTwoBlocks) {
     CowOptions options;
     options.compression = "gz";
     options.cluster_ops = 0;
-    CowWriter writer(options);
+    CowWriterV2 writer(options, GetCowFd());
 
-    ASSERT_TRUE(writer.Initialize(cow_->fd));
+    ASSERT_TRUE(writer.Initialize());
 
     std::string data = "This is some data, believe it";
     data.resize(options.block_size * 2, '\0');
@@ -595,12 +599,12 @@ TEST_F(CowTest, CompressTwoBlocks) {
 TEST_F(CowTest, GetSize) {
     CowOptions options;
     options.cluster_ops = 0;
-    CowWriter writer(options);
+    CowWriterV2 writer(options, GetCowFd());
     if (ftruncate(cow_->fd, 0) < 0) {
         perror("Fails to set temp file size");
         FAIL();
     }
-    ASSERT_TRUE(writer.Initialize(cow_->fd));
+    ASSERT_TRUE(writer.Initialize());
 
     std::string data = "This is some data, believe it";
     data.resize(options.block_size, '\0');
@@ -621,8 +625,8 @@ TEST_F(CowTest, GetSize) {
 TEST_F(CowTest, AppendLabelSmall) {
     CowOptions options;
     options.cluster_ops = 0;
-    auto writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->Initialize(cow_->fd));
+    auto writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize());
 
     std::string data = "This is some data, believe it";
     data.resize(options.block_size, '\0');
@@ -632,8 +636,8 @@ TEST_F(CowTest, AppendLabelSmall) {
 
     ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
 
-    writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->InitializeAppend(cow_->fd, 3));
+    writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize({3}));
 
     std::string data2 = "More data!";
     data2.resize(options.block_size, '\0');
@@ -688,8 +692,8 @@ TEST_F(CowTest, AppendLabelSmall) {
 TEST_F(CowTest, AppendLabelMissing) {
     CowOptions options;
     options.cluster_ops = 0;
-    auto writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->Initialize(cow_->fd));
+    auto writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize());
 
     ASSERT_TRUE(writer->AddLabel(0));
     std::string data = "This is some data, believe it";
@@ -701,9 +705,9 @@ TEST_F(CowTest, AppendLabelMissing) {
 
     ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
 
-    writer = std::make_unique<CowWriter>(options);
-    ASSERT_FALSE(writer->InitializeAppend(cow_->fd, 1));
-    ASSERT_TRUE(writer->InitializeAppend(cow_->fd, 0));
+    writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_FALSE(writer->Initialize({1}));
+    ASSERT_TRUE(writer->Initialize({0}));
 
     ASSERT_TRUE(writer->AddZeroBlocks(51, 1));
     ASSERT_TRUE(writer->Finalize());
@@ -740,8 +744,8 @@ TEST_F(CowTest, AppendLabelMissing) {
 TEST_F(CowTest, AppendExtendedCorrupted) {
     CowOptions options;
     options.cluster_ops = 0;
-    auto writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->Initialize(cow_->fd));
+    auto writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize());
 
     ASSERT_TRUE(writer->AddLabel(5));
 
@@ -763,8 +767,8 @@ TEST_F(CowTest, AppendExtendedCorrupted) {
 
     ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
 
-    writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->InitializeAppend(cow_->fd, 5));
+    writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize({5}));
 
     ASSERT_TRUE(writer->Finalize());
 
@@ -791,8 +795,8 @@ TEST_F(CowTest, AppendExtendedCorrupted) {
 TEST_F(CowTest, AppendbyLabel) {
     CowOptions options;
     options.cluster_ops = 0;
-    auto writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->Initialize(cow_->fd));
+    auto writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize());
 
     std::string data = "This is some data, believe it";
     data.resize(options.block_size * 2, '\0');
@@ -810,9 +814,9 @@ TEST_F(CowTest, AppendbyLabel) {
 
     ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
 
-    writer = std::make_unique<CowWriter>(options);
-    ASSERT_FALSE(writer->InitializeAppend(cow_->fd, 12));
-    ASSERT_TRUE(writer->InitializeAppend(cow_->fd, 5));
+    writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_FALSE(writer->Initialize({12}));
+    ASSERT_TRUE(writer->Initialize({5}));
 
     // This should drop label 6
     ASSERT_TRUE(writer->Finalize());
@@ -879,8 +883,8 @@ TEST_F(CowTest, AppendbyLabel) {
 TEST_F(CowTest, ClusterTest) {
     CowOptions options;
     options.cluster_ops = 4;
-    auto writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->Initialize(cow_->fd));
+    auto writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize());
 
     std::string data = "This is some data, believe it";
     data.resize(options.block_size, '\0');
@@ -976,16 +980,16 @@ TEST_F(CowTest, ClusterTest) {
 TEST_F(CowTest, ClusterAppendTest) {
     CowOptions options;
     options.cluster_ops = 3;
-    auto writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->Initialize(cow_->fd));
+    auto writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize());
 
     ASSERT_TRUE(writer->AddLabel(50));
     ASSERT_TRUE(writer->Finalize());  // Adds a cluster op, should be dropped on append
 
     ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
 
-    writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->InitializeAppend(cow_->fd, 50));
+    writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize({50}));
 
     std::string data2 = "More data!";
     data2.resize(options.block_size, '\0');
@@ -1037,8 +1041,8 @@ TEST_F(CowTest, ClusterAppendTest) {
 TEST_F(CowTest, AppendAfterFinalize) {
     CowOptions options;
     options.cluster_ops = 0;
-    auto writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->Initialize(cow_->fd));
+    auto writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize());
 
     std::string data = "This is some data, believe it";
     data.resize(options.block_size, '\0');
@@ -1058,8 +1062,8 @@ TEST_F(CowTest, AppendAfterFinalize) {
     ASSERT_TRUE(reader.Parse(cow_->fd));
 }
 
-AssertionResult WriteDataBlock(CowWriter* writer, uint64_t new_block, std::string data) {
-    data.resize(writer->options().block_size, '\0');
+AssertionResult WriteDataBlock(ICowWriter* writer, uint64_t new_block, std::string data) {
+    data.resize(writer->GetBlockSize(), '\0');
     if (!writer->AddRawBlocks(new_block, data.data(), data.size())) {
         return AssertionFailure() << "Failed to add raw block";
     }
@@ -1088,8 +1092,8 @@ AssertionResult CompareDataBlock(CowReader* reader, const CowOperation* op,
 TEST_F(CowTest, ResumeMidCluster) {
     CowOptions options;
     options.cluster_ops = 7;
-    auto writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->Initialize(cow_->fd));
+    auto writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize());
 
     ASSERT_TRUE(WriteDataBlock(writer.get(), 1, "Block 1"));
     ASSERT_TRUE(WriteDataBlock(writer.get(), 2, "Block 2"));
@@ -1099,8 +1103,8 @@ TEST_F(CowTest, ResumeMidCluster) {
     ASSERT_TRUE(WriteDataBlock(writer.get(), 4, "Block 4"));
     ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
 
-    writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->InitializeAppend(cow_->fd, 1));
+    writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize({1}));
     ASSERT_TRUE(WriteDataBlock(writer.get(), 4, "Block 4"));
     ASSERT_TRUE(WriteDataBlock(writer.get(), 5, "Block 5"));
     ASSERT_TRUE(WriteDataBlock(writer.get(), 6, "Block 6"));
@@ -1145,8 +1149,8 @@ TEST_F(CowTest, ResumeEndCluster) {
     CowOptions options;
     int cluster_ops = 5;
     options.cluster_ops = cluster_ops;
-    auto writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->Initialize(cow_->fd));
+    auto writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize());
 
     ASSERT_TRUE(WriteDataBlock(writer.get(), 1, "Block 1"));
     ASSERT_TRUE(WriteDataBlock(writer.get(), 2, "Block 2"));
@@ -1160,8 +1164,8 @@ TEST_F(CowTest, ResumeEndCluster) {
     ASSERT_TRUE(WriteDataBlock(writer.get(), 8, "Block 8"));
     ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
 
-    writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->InitializeAppend(cow_->fd, 1));
+    writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize({1}));
     ASSERT_TRUE(WriteDataBlock(writer.get(), 4, "Block 4"));
     ASSERT_TRUE(WriteDataBlock(writer.get(), 5, "Block 5"));
     ASSERT_TRUE(WriteDataBlock(writer.get(), 6, "Block 6"));
@@ -1205,8 +1209,8 @@ TEST_F(CowTest, ResumeEndCluster) {
 TEST_F(CowTest, DeleteMidCluster) {
     CowOptions options;
     options.cluster_ops = 7;
-    auto writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->Initialize(cow_->fd));
+    auto writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize());
 
     ASSERT_TRUE(WriteDataBlock(writer.get(), 1, "Block 1"));
     ASSERT_TRUE(WriteDataBlock(writer.get(), 2, "Block 2"));
@@ -1218,8 +1222,8 @@ TEST_F(CowTest, DeleteMidCluster) {
     ASSERT_TRUE(WriteDataBlock(writer.get(), 6, "Block 6"));
     ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
 
-    writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->InitializeAppend(cow_->fd, 1));
+    writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize({1}));
     ASSERT_TRUE(writer->Finalize());
     ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
 
@@ -1255,14 +1259,14 @@ TEST_F(CowTest, DeleteMidCluster) {
 
 TEST_F(CowTest, BigSeqOp) {
     CowOptions options;
-    CowWriter writer(options);
+    CowWriterV2 writer(options, GetCowFd());
     const int seq_len = std::numeric_limits<uint16_t>::max() / sizeof(uint32_t) + 1;
     uint32_t sequence[seq_len];
     for (int i = 0; i < seq_len; i++) {
         sequence[i] = i + 1;
     }
 
-    ASSERT_TRUE(writer.Initialize(cow_->fd));
+    ASSERT_TRUE(writer.Initialize());
 
     ASSERT_TRUE(writer.AddSequenceData(seq_len, sequence));
     ASSERT_TRUE(writer.AddZeroBlocks(1, seq_len));
@@ -1287,14 +1291,14 @@ TEST_F(CowTest, BigSeqOp) {
 
 TEST_F(CowTest, MissingSeqOp) {
     CowOptions options;
-    CowWriter writer(options);
+    CowWriterV2 writer(options, GetCowFd());
     const int seq_len = 10;
     uint32_t sequence[seq_len];
     for (int i = 0; i < seq_len; i++) {
         sequence[i] = i + 1;
     }
 
-    ASSERT_TRUE(writer.Initialize(cow_->fd));
+    ASSERT_TRUE(writer.Initialize());
 
     ASSERT_TRUE(writer.AddSequenceData(seq_len, sequence));
     ASSERT_TRUE(writer.AddZeroBlocks(1, seq_len - 1));
@@ -1308,14 +1312,14 @@ TEST_F(CowTest, MissingSeqOp) {
 
 TEST_F(CowTest, ResumeSeqOp) {
     CowOptions options;
-    auto writer = std::make_unique<CowWriter>(options);
+    auto writer = std::make_unique<CowWriterV2>(options, GetCowFd());
     const int seq_len = 10;
     uint32_t sequence[seq_len];
     for (int i = 0; i < seq_len; i++) {
         sequence[i] = i + 1;
     }
 
-    ASSERT_TRUE(writer->Initialize(cow_->fd));
+    ASSERT_TRUE(writer->Initialize());
 
     ASSERT_TRUE(writer->AddSequenceData(seq_len, sequence));
     ASSERT_TRUE(writer->AddZeroBlocks(1, seq_len / 2));
@@ -1328,8 +1332,8 @@ TEST_F(CowTest, ResumeSeqOp) {
     auto itr = reader->GetRevMergeOpIter();
     ASSERT_TRUE(itr->AtEnd());
 
-    writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->InitializeAppend(cow_->fd, 1));
+    writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize({1}));
     ASSERT_TRUE(writer->AddZeroBlocks(1 + seq_len / 2, seq_len / 2));
     ASSERT_TRUE(writer->Finalize());
 
@@ -1358,10 +1362,10 @@ TEST_F(CowTest, RevMergeOpItrTest) {
     CowOptions options;
     options.cluster_ops = 5;
     options.num_merge_ops = 1;
-    CowWriter writer(options);
+    CowWriterV2 writer(options, GetCowFd());
     uint32_t sequence[] = {2, 10, 6, 7, 3, 5};
 
-    ASSERT_TRUE(writer.Initialize(cow_->fd));
+    ASSERT_TRUE(writer.Initialize());
 
     ASSERT_TRUE(writer.AddSequenceData(6, sequence));
     ASSERT_TRUE(writer.AddCopy(6, 13));
@@ -1408,9 +1412,9 @@ TEST_F(CowTest, LegacyRevMergeOpItrTest) {
     CowOptions options;
     options.cluster_ops = 5;
     options.num_merge_ops = 1;
-    CowWriter writer(options);
+    CowWriterV2 writer(options, GetCowFd());
 
-    ASSERT_TRUE(writer.Initialize(cow_->fd));
+    ASSERT_TRUE(writer.Initialize());
 
     ASSERT_TRUE(writer.AddCopy(2, 11));
     ASSERT_TRUE(writer.AddCopy(10, 12));
@@ -1459,10 +1463,10 @@ TEST_F(CowTest, InvalidMergeOrderTest) {
     options.num_merge_ops = 1;
     std::string data = "This is some data, believe it";
     data.resize(options.block_size, '\0');
-    auto writer = std::make_unique<CowWriter>(options);
+    auto writer = std::make_unique<CowWriterV2>(options, GetCowFd());
     CowReader reader;
 
-    ASSERT_TRUE(writer->Initialize(cow_->fd));
+    ASSERT_TRUE(writer->Initialize());
 
     ASSERT_TRUE(writer->AddCopy(3, 2));
     ASSERT_TRUE(writer->AddCopy(2, 1));
@@ -1471,14 +1475,14 @@ TEST_F(CowTest, InvalidMergeOrderTest) {
     ASSERT_TRUE(reader.Parse(cow_->fd));
     ASSERT_TRUE(reader.VerifyMergeOps());
 
-    ASSERT_TRUE(writer->InitializeAppend(cow_->fd, 1));
+    ASSERT_TRUE(writer->Initialize({1}));
     ASSERT_TRUE(writer->AddCopy(4, 2));
     ASSERT_TRUE(writer->Finalize());
     ASSERT_TRUE(reader.Parse(cow_->fd));
     ASSERT_FALSE(reader.VerifyMergeOps());
 
-    writer = std::make_unique<CowWriter>(options);
-    ASSERT_TRUE(writer->Initialize(cow_->fd));
+    writer = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize());
     ASSERT_TRUE(writer->AddCopy(2, 1));
     ASSERT_TRUE(writer->AddXorBlocks(3, &data, data.size(), 1, 1));
     ASSERT_TRUE(writer->Finalize());
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.cpp
new file mode 100644
index 000000000000..22e63d0a323d
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.cpp
@@ -0,0 +1,163 @@
+// Copyright (C) 2023 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 "writer_base.h"
+
+#include <fcntl.h>
+#include <linux/fs.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <android-base/logging.h>
+
+// The info messages here are spammy, but as useful for update_engine. Disable
+// them when running on the host.
+#ifdef __ANDROID__
+#define LOG_INFO LOG(INFO)
+#else
+#define LOG_INFO LOG(VERBOSE)
+#endif
+
+namespace android {
+namespace snapshot {
+
+using android::base::borrowed_fd;
+using android::base::unique_fd;
+
+namespace {
+std::string GetFdPath(borrowed_fd fd) {
+    const auto fd_path = "/proc/self/fd/" + std::to_string(fd.get());
+    std::string file_path(512, '\0');
+    const auto err = readlink(fd_path.c_str(), file_path.data(), file_path.size());
+    if (err <= 0) {
+        PLOG(ERROR) << "Failed to determine path for fd " << fd.get();
+        file_path.clear();
+    } else {
+        file_path.resize(err);
+    }
+    return file_path;
+}
+}  // namespace
+
+CowWriterBase::CowWriterBase(const CowOptions& options, unique_fd&& fd)
+    : options_(options), fd_(std::move(fd)) {}
+
+bool CowWriterBase::InitFd() {
+    if (fd_.get() < 0) {
+        fd_.reset(open("/dev/null", O_RDWR | O_CLOEXEC));
+        if (fd_ < 0) {
+            PLOG(ERROR) << "open /dev/null failed";
+            return false;
+        }
+        is_dev_null_ = true;
+        return true;
+    }
+
+    struct stat stat {};
+    if (fstat(fd_.get(), &stat) < 0) {
+        PLOG(ERROR) << "fstat failed";
+        return false;
+    }
+    const auto file_path = GetFdPath(fd_);
+    is_block_device_ = S_ISBLK(stat.st_mode);
+    if (is_block_device_) {
+        uint64_t size_in_bytes = 0;
+        if (ioctl(fd_.get(), BLKGETSIZE64, &size_in_bytes)) {
+            PLOG(ERROR) << "Failed to get total size for: " << fd_.get();
+            return false;
+        }
+        cow_image_size_ = size_in_bytes;
+        LOG_INFO << "COW image " << file_path << " has size " << size_in_bytes;
+    } else {
+        LOG_INFO << "COW image " << file_path
+                 << " is not a block device, assuming unlimited space.";
+    }
+    return true;
+}
+
+bool CowWriterBase::AddCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks) {
+    CHECK(num_blocks != 0);
+
+    for (size_t i = 0; i < num_blocks; i++) {
+        if (!ValidateNewBlock(new_block + i)) {
+            return false;
+        }
+    }
+
+    return EmitCopy(new_block, old_block, num_blocks);
+}
+
+bool CowWriterBase::AddRawBlocks(uint64_t new_block_start, const void* data, size_t size) {
+    if (size % options_.block_size != 0) {
+        LOG(ERROR) << "AddRawBlocks: size " << size << " is not a multiple of "
+                   << options_.block_size;
+        return false;
+    }
+
+    uint64_t num_blocks = size / options_.block_size;
+    uint64_t last_block = new_block_start + num_blocks - 1;
+    if (!ValidateNewBlock(last_block)) {
+        return false;
+    }
+    return EmitRawBlocks(new_block_start, data, size);
+}
+
+bool CowWriterBase::AddXorBlocks(uint32_t new_block_start, const void* data, size_t size,
+                                 uint32_t old_block, uint16_t offset) {
+    if (size % options_.block_size != 0) {
+        LOG(ERROR) << "AddRawBlocks: size " << size << " is not a multiple of "
+                   << options_.block_size;
+        return false;
+    }
+
+    uint64_t num_blocks = size / options_.block_size;
+    uint64_t last_block = new_block_start + num_blocks - 1;
+    if (!ValidateNewBlock(last_block)) {
+        return false;
+    }
+    if (offset >= options_.block_size) {
+        LOG(ERROR) << "AddXorBlocks: offset " << offset << " is not less than "
+                   << options_.block_size;
+    }
+    return EmitXorBlocks(new_block_start, data, size, old_block, offset);
+}
+
+bool CowWriterBase::AddZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
+    uint64_t last_block = new_block_start + num_blocks - 1;
+    if (!ValidateNewBlock(last_block)) {
+        return false;
+    }
+    return EmitZeroBlocks(new_block_start, num_blocks);
+}
+
+bool CowWriterBase::AddLabel(uint64_t label) {
+    return EmitLabel(label);
+}
+
+bool CowWriterBase::AddSequenceData(size_t num_ops, const uint32_t* data) {
+    return EmitSequenceData(num_ops, data);
+}
+
+bool CowWriterBase::ValidateNewBlock(uint64_t new_block) {
+    if (options_.max_blocks && new_block >= options_.max_blocks.value()) {
+        LOG(ERROR) << "New block " << new_block << " exceeds maximum block count "
+                   << options_.max_blocks.value();
+        return false;
+    }
+    return true;
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
new file mode 100644
index 000000000000..8fa90656fe6b
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
@@ -0,0 +1,71 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <libsnapshot/cow_writer.h>
+
+namespace android {
+namespace snapshot {
+
+class CowWriterBase : public ICowWriter {
+  public:
+    CowWriterBase(const CowOptions& options, android::base::unique_fd&& fd);
+    virtual ~CowWriterBase() {}
+
+    // Set up the writer.
+    // The file starts from the beginning.
+    //
+    // If fd is < 0, the CowWriter will be opened against /dev/null. This is for
+    // computing COW sizes without using storage space.
+    //
+    // If a label is given, any operations after the given label will be dropped.
+    // If the given label is not found, Initialize will fail.
+    virtual bool Initialize(std::optional<uint64_t> label = {}) = 0;
+
+    bool AddCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) override;
+    bool AddRawBlocks(uint64_t new_block_start, const void* data, size_t size) override;
+    bool AddXorBlocks(uint32_t new_block_start, const void* data, size_t size, uint32_t old_block,
+                      uint16_t offset) override;
+    bool AddZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) override;
+    bool AddLabel(uint64_t label) override;
+    bool AddSequenceData(size_t num_ops, const uint32_t* data) override;
+    uint32_t GetBlockSize() const override { return options_.block_size; }
+    std::optional<uint32_t> GetMaxBlocks() const override { return options_.max_blocks; }
+
+    const CowOptions& options() const { return options_; }
+
+  protected:
+    virtual bool EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) = 0;
+    virtual bool EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) = 0;
+    virtual bool EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size,
+                               uint32_t old_block, uint16_t offset) = 0;
+    virtual bool EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) = 0;
+    virtual bool EmitLabel(uint64_t label) = 0;
+    virtual bool EmitSequenceData(size_t num_ops, const uint32_t* data) = 0;
+
+    bool InitFd();
+    bool ValidateNewBlock(uint64_t new_block);
+
+    CowOptions options_;
+    CowHeader header_{};
+
+    android::base::unique_fd fd_;
+    bool is_dev_null_ = false;
+    bool is_block_device_ = false;
+    uint64_t cow_image_size_ = INT64_MAX;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_writer.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
similarity index 75%
rename from fs_mgr/libsnapshot/libsnapshot_cow/cow_writer.cpp
rename to fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index 1eaa0385ee26..b6603da52edf 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_writer.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -37,6 +37,8 @@
 #include <sys/ioctl.h>
 #include <unistd.h>
 
+#include "writer_v2.h"
+
 // The info messages here are spammy, but as useful for update_engine. Disable
 // them when running on the host.
 #ifdef __ANDROID__
@@ -48,104 +50,17 @@
 namespace android {
 namespace snapshot {
 
-namespace {
-std::string GetFdPath(int fd) {
-    const auto fd_path = "/proc/self/fd/" + std::to_string(fd);
-    std::string file_path(512, '\0');
-    const auto err = readlink(fd_path.c_str(), file_path.data(), file_path.size());
-    if (err <= 0) {
-        PLOG(ERROR) << "Failed to determine path for fd " << fd;
-        file_path.clear();
-    } else {
-        file_path.resize(err);
-    }
-    return file_path;
-}
-}  // namespace
-
 static_assert(sizeof(off_t) == sizeof(uint64_t));
 
-using android::base::borrowed_fd;
 using android::base::unique_fd;
 
-bool ICowWriter::AddCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks) {
-    CHECK(num_blocks != 0);
-
-    for (size_t i = 0; i < num_blocks; i++) {
-        if (!ValidateNewBlock(new_block + i)) {
-            return false;
-        }
-    }
-
-    return EmitCopy(new_block, old_block, num_blocks);
-}
-
-bool ICowWriter::AddRawBlocks(uint64_t new_block_start, const void* data, size_t size) {
-    if (size % options_.block_size != 0) {
-        LOG(ERROR) << "AddRawBlocks: size " << size << " is not a multiple of "
-                   << options_.block_size;
-        return false;
-    }
-
-    uint64_t num_blocks = size / options_.block_size;
-    uint64_t last_block = new_block_start + num_blocks - 1;
-    if (!ValidateNewBlock(last_block)) {
-        return false;
-    }
-    return EmitRawBlocks(new_block_start, data, size);
-}
-
-bool ICowWriter::AddXorBlocks(uint32_t new_block_start, const void* data, size_t size,
-                              uint32_t old_block, uint16_t offset) {
-    if (size % options_.block_size != 0) {
-        LOG(ERROR) << "AddRawBlocks: size " << size << " is not a multiple of "
-                   << options_.block_size;
-        return false;
-    }
-
-    uint64_t num_blocks = size / options_.block_size;
-    uint64_t last_block = new_block_start + num_blocks - 1;
-    if (!ValidateNewBlock(last_block)) {
-        return false;
-    }
-    if (offset >= options_.block_size) {
-        LOG(ERROR) << "AddXorBlocks: offset " << offset << " is not less than "
-                   << options_.block_size;
-    }
-    return EmitXorBlocks(new_block_start, data, size, old_block, offset);
-}
-
-bool ICowWriter::AddZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
-    uint64_t last_block = new_block_start + num_blocks - 1;
-    if (!ValidateNewBlock(last_block)) {
-        return false;
-    }
-    return EmitZeroBlocks(new_block_start, num_blocks);
-}
-
-bool ICowWriter::AddLabel(uint64_t label) {
-    return EmitLabel(label);
-}
-
-bool ICowWriter::AddSequenceData(size_t num_ops, const uint32_t* data) {
-    return EmitSequenceData(num_ops, data);
-}
-
-bool ICowWriter::ValidateNewBlock(uint64_t new_block) {
-    if (options_.max_blocks && new_block >= options_.max_blocks.value()) {
-        LOG(ERROR) << "New block " << new_block << " exceeds maximum block count "
-                   << options_.max_blocks.value();
-        return false;
-    }
-    return true;
-}
-
-CowWriter::CowWriter(const CowOptions& options) : ICowWriter(options), fd_(-1) {
+CowWriterV2::CowWriterV2(const CowOptions& options, unique_fd&& fd)
+    : CowWriterBase(options, std::move(fd)) {
     SetupHeaders();
     SetupWriteOptions();
 }
 
-CowWriter::~CowWriter() {
+CowWriterV2::~CowWriterV2() {
     for (size_t i = 0; i < compress_threads_.size(); i++) {
         CompressWorker* worker = compress_threads_[i].get();
         if (worker) {
@@ -164,7 +79,7 @@ CowWriter::~CowWriter() {
     compress_threads_.clear();
 }
 
-void CowWriter::SetupWriteOptions() {
+void CowWriterV2::SetupWriteOptions() {
     num_compress_threads_ = options_.num_compress_threads;
 
     if (!num_compress_threads_) {
@@ -184,7 +99,7 @@ void CowWriter::SetupWriteOptions() {
     }
 }
 
-void CowWriter::SetupHeaders() {
+void CowWriterV2::SetupHeaders() {
     header_ = {};
     header_.prefix.magic = kCowMagicNumber;
     header_.prefix.major_version = kCowVersionMajor;
@@ -201,7 +116,7 @@ void CowWriter::SetupHeaders() {
     footer_.op.type = kCowFooterOp;
 }
 
-bool CowWriter::ParseOptions() {
+bool CowWriterV2::ParseOptions() {
     auto algorithm = CompressionAlgorithmFromString(options_.compression);
     if (!algorithm) {
         LOG(ERROR) << "unrecognized compression: " << options_.compression;
@@ -216,42 +131,7 @@ bool CowWriter::ParseOptions() {
     return true;
 }
 
-bool CowWriter::SetFd(android::base::borrowed_fd fd) {
-    if (fd.get() < 0) {
-        owned_fd_.reset(open("/dev/null", O_RDWR | O_CLOEXEC));
-        if (owned_fd_ < 0) {
-            PLOG(ERROR) << "open /dev/null failed";
-            return false;
-        }
-        fd_ = owned_fd_;
-        is_dev_null_ = true;
-    } else {
-        fd_ = fd;
-
-        struct stat stat {};
-        if (fstat(fd.get(), &stat) < 0) {
-            PLOG(ERROR) << "fstat failed";
-            return false;
-        }
-        const auto file_path = GetFdPath(fd.get());
-        is_block_device_ = S_ISBLK(stat.st_mode);
-        if (is_block_device_) {
-            uint64_t size_in_bytes = 0;
-            if (ioctl(fd.get(), BLKGETSIZE64, &size_in_bytes)) {
-                PLOG(ERROR) << "Failed to get total size for: " << fd.get();
-                return false;
-            }
-            cow_image_size_ = size_in_bytes;
-            LOG_INFO << "COW image " << file_path << " has size " << size_in_bytes;
-        } else {
-            LOG_INFO << "COW image " << file_path
-                     << " is not a block device, assuming unlimited space.";
-        }
-    }
-    return true;
-}
-
-void CowWriter::InitBatchWrites() {
+void CowWriterV2::InitBatchWrites() {
     if (batch_write_) {
         cowop_vec_ = std::make_unique<struct iovec[]>(header_.cluster_ops);
         data_vec_ = std::make_unique<struct iovec[]>(header_.cluster_ops);
@@ -277,7 +157,7 @@ void CowWriter::InitBatchWrites() {
     LOG_INFO << "Batch writes: " << batch_write;
 }
 
-void CowWriter::InitWorkers() {
+void CowWriterV2::InitWorkers() {
     if (num_compress_threads_ <= 1) {
         LOG_INFO << "Not creating new threads for compression.";
         return;
@@ -291,44 +171,27 @@ void CowWriter::InitWorkers() {
     LOG_INFO << num_compress_threads_ << " thread used for compression";
 }
 
-bool CowWriter::Initialize(unique_fd&& fd) {
-    owned_fd_ = std::move(fd);
-    return Initialize(borrowed_fd{owned_fd_});
-}
-
-bool CowWriter::Initialize(borrowed_fd fd) {
-    if (!SetFd(fd) || !ParseOptions()) {
+bool CowWriterV2::Initialize(std::optional<uint64_t> label) {
+    if (!InitFd() || !ParseOptions()) {
         return false;
     }
-
-    if (!OpenForWrite()) {
-        return false;
-    }
-
-    InitWorkers();
-    return true;
-}
-
-bool CowWriter::InitializeAppend(android::base::unique_fd&& fd, uint64_t label) {
-    owned_fd_ = std::move(fd);
-    return InitializeAppend(android::base::borrowed_fd{owned_fd_}, label);
-}
-
-bool CowWriter::InitializeAppend(android::base::borrowed_fd fd, uint64_t label) {
-    if (!SetFd(fd) || !ParseOptions()) {
-        return false;
+    if (!label) {
+        if (!OpenForWrite()) {
+            return false;
+        }
+    } else {
+        if (!OpenForAppend(*label)) {
+            return false;
+        }
     }
 
-    bool ret = OpenForAppend(label);
-
-    if (ret && !compress_threads_.size()) {
+    if (!compress_threads_.size()) {
         InitWorkers();
     }
-
-    return ret;
+    return true;
 }
 
-void CowWriter::InitPos() {
+void CowWriterV2::InitPos() {
     next_op_pos_ = sizeof(header_) + header_.buffer_size;
     cluster_size_ = header_.cluster_ops * sizeof(CowOperation);
     if (header_.cluster_ops) {
@@ -340,7 +203,7 @@ void CowWriter::InitPos() {
     current_data_size_ = 0;
 }
 
-bool CowWriter::OpenForWrite() {
+bool CowWriterV2::OpenForWrite() {
     // This limitation is tied to the data field size in CowOperation.
     if (header_.block_size > std::numeric_limits<uint16_t>::max()) {
         LOG(ERROR) << "Block size is too large";
@@ -388,7 +251,7 @@ bool CowWriter::OpenForWrite() {
     return true;
 }
 
-bool CowWriter::OpenForAppend(uint64_t label) {
+bool CowWriterV2::OpenForAppend(uint64_t label) {
     auto reader = std::make_unique<CowReader>();
     std::queue<CowOperation> toAdd;
 
@@ -424,7 +287,7 @@ bool CowWriter::OpenForAppend(uint64_t label) {
     return EmitClusterIfNeeded();
 }
 
-bool CowWriter::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks) {
+bool CowWriterV2::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks) {
     CHECK(!merge_in_progress_);
 
     for (size_t i = 0; i < num_blocks; i++) {
@@ -440,16 +303,16 @@ bool CowWriter::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_bl
     return true;
 }
 
-bool CowWriter::EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) {
+bool CowWriterV2::EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) {
     return EmitBlocks(new_block_start, data, size, 0, 0, kCowReplaceOp);
 }
 
-bool CowWriter::EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size,
-                              uint32_t old_block, uint16_t offset) {
+bool CowWriterV2::EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size,
+                                uint32_t old_block, uint16_t offset) {
     return EmitBlocks(new_block_start, data, size, old_block, offset, kCowXorOp);
 }
 
-bool CowWriter::CompressBlocks(size_t num_blocks, const void* data) {
+bool CowWriterV2::CompressBlocks(size_t num_blocks, const void* data) {
     size_t num_threads = (num_blocks == 1) ? 1 : num_compress_threads_;
     size_t num_blocks_per_thread = num_blocks / num_threads;
     const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
@@ -483,8 +346,8 @@ bool CowWriter::CompressBlocks(size_t num_blocks, const void* data) {
     return true;
 }
 
-bool CowWriter::EmitBlocks(uint64_t new_block_start, const void* data, size_t size,
-                           uint64_t old_block, uint16_t offset, uint8_t type) {
+bool CowWriterV2::EmitBlocks(uint64_t new_block_start, const void* data, size_t size,
+                             uint64_t old_block, uint16_t offset, uint8_t type) {
     CHECK(!merge_in_progress_);
     const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
 
@@ -558,7 +421,7 @@ bool CowWriter::EmitBlocks(uint64_t new_block_start, const void* data, size_t si
     return true;
 }
 
-bool CowWriter::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
+bool CowWriterV2::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
     CHECK(!merge_in_progress_);
     for (uint64_t i = 0; i < num_blocks; i++) {
         CowOperation op = {};
@@ -570,7 +433,7 @@ bool CowWriter::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
     return true;
 }
 
-bool CowWriter::EmitLabel(uint64_t label) {
+bool CowWriterV2::EmitLabel(uint64_t label) {
     CHECK(!merge_in_progress_);
     CowOperation op = {};
     op.type = kCowLabelOp;
@@ -578,7 +441,7 @@ bool CowWriter::EmitLabel(uint64_t label) {
     return WriteOperation(op) && Sync();
 }
 
-bool CowWriter::EmitSequenceData(size_t num_ops, const uint32_t* data) {
+bool CowWriterV2::EmitSequenceData(size_t num_ops, const uint32_t* data) {
     CHECK(!merge_in_progress_);
     size_t to_add = 0;
     size_t max_ops = (header_.block_size * 2) / sizeof(uint32_t);
@@ -598,7 +461,7 @@ bool CowWriter::EmitSequenceData(size_t num_ops, const uint32_t* data) {
     return true;
 }
 
-bool CowWriter::EmitCluster() {
+bool CowWriterV2::EmitCluster() {
     CowOperation op = {};
     op.type = kCowClusterOp;
     // Next cluster starts after remainder of current cluster and the next data block.
@@ -606,7 +469,7 @@ bool CowWriter::EmitCluster() {
     return WriteOperation(op);
 }
 
-bool CowWriter::EmitClusterIfNeeded() {
+bool CowWriterV2::EmitClusterIfNeeded() {
     // If there isn't room for another op and the cluster end op, end the current cluster
     if (cluster_size_ && cluster_size_ < current_cluster_size_ + 2 * sizeof(CowOperation)) {
         if (!EmitCluster()) return false;
@@ -614,7 +477,7 @@ bool CowWriter::EmitClusterIfNeeded() {
     return true;
 }
 
-bool CowWriter::Finalize() {
+bool CowWriterV2::Finalize() {
     if (!FlushCluster()) {
         LOG(ERROR) << "Finalize: FlushCluster() failed";
         return false;
@@ -688,7 +551,7 @@ bool CowWriter::Finalize() {
     return Sync();
 }
 
-uint64_t CowWriter::GetCowSize() {
+uint64_t CowWriterV2::GetCowSize() {
     if (current_data_size_ > 0) {
         return next_data_pos_ + sizeof(footer_);
     } else {
@@ -696,7 +559,7 @@ uint64_t CowWriter::GetCowSize() {
     }
 }
 
-bool CowWriter::GetDataPos(uint64_t* pos) {
+bool CowWriterV2::GetDataPos(uint64_t* pos) {
     off_t offs = lseek(fd_.get(), 0, SEEK_CUR);
     if (offs < 0) {
         PLOG(ERROR) << "lseek failed";
@@ -706,7 +569,7 @@ bool CowWriter::GetDataPos(uint64_t* pos) {
     return true;
 }
 
-bool CowWriter::EnsureSpaceAvailable(const uint64_t bytes_needed) const {
+bool CowWriterV2::EnsureSpaceAvailable(const uint64_t bytes_needed) const {
     if (bytes_needed > cow_image_size_) {
         LOG(ERROR) << "No space left on COW device. Required: " << bytes_needed
                    << ", available: " << cow_image_size_;
@@ -716,7 +579,7 @@ bool CowWriter::EnsureSpaceAvailable(const uint64_t bytes_needed) const {
     return true;
 }
 
-bool CowWriter::FlushCluster() {
+bool CowWriterV2::FlushCluster() {
     ssize_t ret;
 
     if (op_vec_index_) {
@@ -745,7 +608,7 @@ bool CowWriter::FlushCluster() {
     return true;
 }
 
-bool CowWriter::WriteOperation(const CowOperation& op, const void* data, size_t size) {
+bool CowWriterV2::WriteOperation(const CowOperation& op, const void* data, size_t size) {
     if (!EnsureSpaceAvailable(next_op_pos_ + sizeof(op))) {
         return false;
     }
@@ -793,7 +656,7 @@ bool CowWriter::WriteOperation(const CowOperation& op, const void* data, size_t
     return EmitClusterIfNeeded();
 }
 
-void CowWriter::AddOperation(const CowOperation& op) {
+void CowWriterV2::AddOperation(const CowOperation& op) {
     footer_.op.num_ops++;
 
     if (op.type == kCowClusterOp) {
@@ -808,14 +671,14 @@ void CowWriter::AddOperation(const CowOperation& op) {
     next_op_pos_ += sizeof(CowOperation) + GetNextOpOffset(op, header_.cluster_ops);
 }
 
-bool CowWriter::WriteRawData(const void* data, const size_t size) {
+bool CowWriterV2::WriteRawData(const void* data, const size_t size) {
     if (!android::base::WriteFullyAtOffset(fd_, data, size, next_data_pos_)) {
         return false;
     }
     return true;
 }
 
-bool CowWriter::Sync() {
+bool CowWriterV2::Sync() {
     if (is_dev_null_) {
         return true;
     }
@@ -826,7 +689,7 @@ bool CowWriter::Sync() {
     return true;
 }
 
-bool CowWriter::Truncate(off_t length) {
+bool CowWriterV2::Truncate(off_t length) {
     if (is_dev_null_ || is_block_device_) {
         return true;
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
new file mode 100644
index 000000000000..809ae5747935
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
@@ -0,0 +1,94 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "writer_base.h"
+
+namespace android {
+namespace snapshot {
+
+class CowWriterV2 : public CowWriterBase {
+  public:
+    explicit CowWriterV2(const CowOptions& options, android::base::unique_fd&& fd);
+    ~CowWriterV2() override;
+
+    bool Initialize(std::optional<uint64_t> label = {}) override;
+    bool Finalize() override;
+    uint64_t GetCowSize() override;
+
+  protected:
+    virtual bool EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) override;
+    virtual bool EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) override;
+    virtual bool EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size,
+                               uint32_t old_block, uint16_t offset) override;
+    virtual bool EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) override;
+    virtual bool EmitLabel(uint64_t label) override;
+    virtual bool EmitSequenceData(size_t num_ops, const uint32_t* data) override;
+
+  private:
+    bool EmitCluster();
+    bool EmitClusterIfNeeded();
+    bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
+                    uint16_t offset, uint8_t type);
+    void SetupHeaders();
+    void SetupWriteOptions();
+    bool ParseOptions();
+    bool OpenForWrite();
+    bool OpenForAppend(uint64_t label);
+    bool GetDataPos(uint64_t* pos);
+    bool WriteRawData(const void* data, size_t size);
+    bool WriteOperation(const CowOperation& op, const void* data = nullptr, size_t size = 0);
+    void AddOperation(const CowOperation& op);
+    void InitPos();
+    void InitBatchWrites();
+    void InitWorkers();
+    bool FlushCluster();
+
+    bool CompressBlocks(size_t num_blocks, const void* data);
+    bool Sync();
+    bool Truncate(off_t length);
+    bool EnsureSpaceAvailable(const uint64_t bytes_needed) const;
+
+  private:
+    CowFooter footer_{};
+    CowCompressionAlgorithm compression_ = kCowCompressNone;
+    uint64_t current_op_pos_ = 0;
+    uint64_t next_op_pos_ = 0;
+    uint64_t next_data_pos_ = 0;
+    uint64_t current_data_pos_ = 0;
+    ssize_t total_data_written_ = 0;
+    uint32_t cluster_size_ = 0;
+    uint32_t current_cluster_size_ = 0;
+    uint64_t current_data_size_ = 0;
+    bool merge_in_progress_ = false;
+
+    int num_compress_threads_ = 1;
+    std::vector<std::unique_ptr<CompressWorker>> compress_threads_;
+    std::vector<std::future<bool>> threads_;
+    std::vector<std::basic_string<uint8_t>> compressed_buf_;
+    std::vector<std::basic_string<uint8_t>>::iterator buf_iter_;
+
+    std::vector<std::unique_ptr<CowOperation>> opbuffer_vec_;
+    std::vector<std::unique_ptr<uint8_t[]>> databuffer_vec_;
+    std::unique_ptr<struct iovec[]> cowop_vec_;
+    int op_vec_index_ = 0;
+
+    std::unique_ptr<struct iovec[]> data_vec_;
+    int data_vec_index_ = 0;
+    bool batch_write_ = false;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index e114d255654e..5920bc22fa8c 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -45,6 +45,7 @@
 #include <android/snapshot/snapshot.pb.h>
 #include <libsnapshot/snapshot_stats.h>
 #include "device_info.h"
+#include "libsnapshot_cow/writer_v2.h"
 #include "partition_cow_creator.h"
 #include "snapshot_metadata_updater.h"
 #include "snapshot_reader.h"
@@ -3557,8 +3558,8 @@ Return SnapshotManager::InitializeUpdateSnapshots(
             }
             options.compression = it->second.compression_algorithm();
 
-            CowWriter writer(options);
-            if (!writer.Initialize(fd) || !writer.Finalize()) {
+            CowWriterV2 writer(options, std::move(fd));
+            if (!writer.Initialize(std::nullopt) || !writer.Finalize()) {
                 LOG(ERROR) << "Could not initialize COW device for " << target_partition->name();
                 return Return::Error();
             }
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 757f6f181590..dac1b771b83d 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -1220,13 +1220,13 @@ class SnapshotUpdateTest : public SnapshotTest {
         SHA256_CTX ctx;
         SHA256_Init(&ctx);
 
-        if (!writer->options().max_blocks) {
+        if (!writer->GetMaxBlocks()) {
             LOG(ERROR) << "CowWriter must specify maximum number of blocks";
             return false;
         }
-        const auto num_blocks = writer->options().max_blocks.value();
+        const auto num_blocks = writer->GetMaxBlocks().value();
 
-        const auto block_size = writer->options().block_size;
+        const auto block_size = writer->GetBlockSize();
         std::string block(block_size, '\0');
         for (uint64_t i = 0; i < num_blocks; i++) {
             if (!ReadFully(rand, block.data(), block.size())) {
@@ -1254,13 +1254,13 @@ class SnapshotUpdateTest : public SnapshotTest {
         if (auto res = MapUpdateSnapshot(name, &writer); !res) {
             return res;
         }
-        if (!writer->options().max_blocks || !*writer->options().max_blocks) {
+        if (!writer->GetMaxBlocks() || !*writer->GetMaxBlocks()) {
             return AssertionFailure() << "No max blocks set for " << name << " writer";
         }
 
-        uint64_t src_block = (old_size / writer->options().block_size) - 1;
+        uint64_t src_block = (old_size / writer->GetBlockSize()) - 1;
         uint64_t dst_block = 0;
-        uint64_t max_blocks = *writer->options().max_blocks;
+        uint64_t max_blocks = *writer->GetMaxBlocks();
         while (dst_block < max_blocks && dst_block < src_block) {
             if (!writer->AddCopy(dst_block, src_block)) {
                 return AssertionFailure() << "Unable to add copy for " << name << " for blocks "
diff --git a/fs_mgr/libsnapshot/snapshot_writer.cpp b/fs_mgr/libsnapshot/snapshot_writer.cpp
index 6a3906ead22c..0ea424c7e9d9 100644
--- a/fs_mgr/libsnapshot/snapshot_writer.cpp
+++ b/fs_mgr/libsnapshot/snapshot_writer.cpp
@@ -19,6 +19,7 @@
 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <payload_consumer/file_descriptor.h>
+#include "libsnapshot_cow/writer_v2.h"
 #include "snapshot_reader.h"
 
 namespace android {
@@ -28,13 +29,11 @@ using android::base::borrowed_fd;
 using android::base::unique_fd;
 using chromeos_update_engine::FileDescriptor;
 
-ISnapshotWriter::ISnapshotWriter(const CowOptions& options) : ICowWriter(options) {}
-
-void ISnapshotWriter::SetSourceDevice(const std::string& source_device) {
+void CompressedSnapshotWriter::SetSourceDevice(const std::string& source_device) {
     source_device_ = {source_device};
 }
 
-borrowed_fd ISnapshotWriter::GetSourceFd() {
+borrowed_fd CompressedSnapshotWriter::GetSourceFd() {
     if (!source_device_) {
         LOG(ERROR) << "Attempted to read from source device but none was set";
         return borrowed_fd{-1};
@@ -50,12 +49,10 @@ borrowed_fd ISnapshotWriter::GetSourceFd() {
     return source_fd_;
 }
 
-CompressedSnapshotWriter::CompressedSnapshotWriter(const CowOptions& options)
-    : ISnapshotWriter(options) {}
+CompressedSnapshotWriter::CompressedSnapshotWriter(const CowOptions& options) : options_(options) {}
 
 bool CompressedSnapshotWriter::SetCowDevice(android::base::unique_fd&& cow_device) {
     cow_device_ = std::move(cow_device);
-    cow_ = std::make_unique<CowWriter>(options_);
     return true;
 }
 
@@ -106,47 +103,76 @@ std::unique_ptr<FileDescriptor> CompressedSnapshotWriter::OpenReader() {
         reader->SetSourceDevice(*source_device_);
     }
 
-    const auto& cow_options = options();
-    if (cow_options.max_blocks) {
-        reader->SetBlockDeviceSize(*cow_options.max_blocks * cow_options.block_size);
+    if (options_.max_blocks) {
+        reader->SetBlockDeviceSize(*options_.max_blocks * options_.block_size);
     }
 
     return reader;
 }
 
-bool CompressedSnapshotWriter::EmitCopy(uint64_t new_block, uint64_t old_block,
-                                        uint64_t num_blocks) {
+bool CompressedSnapshotWriter::AddCopy(uint64_t new_block, uint64_t old_block,
+                                       uint64_t num_blocks) {
     return cow_->AddCopy(new_block, old_block, num_blocks);
 }
 
-bool CompressedSnapshotWriter::EmitRawBlocks(uint64_t new_block_start, const void* data,
-                                             size_t size) {
+bool CompressedSnapshotWriter::AddRawBlocks(uint64_t new_block_start, const void* data,
+                                            size_t size) {
     return cow_->AddRawBlocks(new_block_start, data, size);
 }
 
-bool CompressedSnapshotWriter::EmitXorBlocks(uint32_t new_block_start, const void* data,
-                                             size_t size, uint32_t old_block, uint16_t offset) {
+bool CompressedSnapshotWriter::AddXorBlocks(uint32_t new_block_start, const void* data, size_t size,
+                                            uint32_t old_block, uint16_t offset) {
     return cow_->AddXorBlocks(new_block_start, data, size, old_block, offset);
 }
 
-bool CompressedSnapshotWriter::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
+bool CompressedSnapshotWriter::AddZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
     return cow_->AddZeroBlocks(new_block_start, num_blocks);
 }
 
-bool CompressedSnapshotWriter::EmitLabel(uint64_t label) {
+bool CompressedSnapshotWriter::AddLabel(uint64_t label) {
     return cow_->AddLabel(label);
 }
 
-bool CompressedSnapshotWriter::EmitSequenceData(size_t num_ops, const uint32_t* data) {
+bool CompressedSnapshotWriter::AddSequenceData(size_t num_ops, const uint32_t* data) {
     return cow_->AddSequenceData(num_ops, data);
 }
 
 bool CompressedSnapshotWriter::Initialize() {
-    return cow_->Initialize(cow_device_);
+    unique_fd cow_fd(dup(cow_device_.get()));
+    if (cow_fd < 0) {
+        PLOG(ERROR) << "dup COW device";
+        return false;
+    }
+
+    auto cow = std::make_unique<CowWriterV2>(options_, std::move(cow_fd));
+    if (!cow->Initialize(std::nullopt)) {
+        return false;
+    }
+    cow_ = std::move(cow);
+    return true;
 }
 
 bool CompressedSnapshotWriter::InitializeAppend(uint64_t label) {
-    return cow_->InitializeAppend(cow_device_, label);
+    unique_fd cow_fd(dup(cow_device_.get()));
+    if (cow_fd < 0) {
+        PLOG(ERROR) << "dup COW device";
+        return false;
+    }
+
+    auto cow = std::make_unique<CowWriterV2>(options_, std::move(cow_fd));
+    if (!cow->Initialize(label)) {
+        return false;
+    }
+    cow_ = std::move(cow);
+    return true;
+}
+
+uint32_t CompressedSnapshotWriter::GetBlockSize() const {
+    return cow_->GetBlockSize();
+}
+
+std::optional<uint32_t> CompressedSnapshotWriter::GetMaxBlocks() const {
+    return cow_->GetMaxBlocks();
 }
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/cow_snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/cow_snapuserd_test.cpp
index 3c4ab2ef7cf0..737c480a8b48 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/cow_snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/cow_snapuserd_test.cpp
@@ -122,6 +122,7 @@ class CowSnapuserdTest final {
     void SimulateDaemonRestart();
     void StartMerge();
 
+    std::unique_ptr<ICowWriter> CreateCowDeviceInternal();
     void CreateCowDevice();
     void CreateCowDeviceOrderedOps();
     void CreateCowDeviceOrderedOpsInverted();
@@ -164,6 +165,7 @@ class CowSnapuserdMetadataTest final {
 
   private:
     void InitMetadata();
+    std::unique_ptr<ICowWriter> CreateCowDeviceInternal();
     void CreateCowDevice();
     void CreateCowPartialFilledArea();
 
@@ -258,6 +260,19 @@ void CowSnapuserdTest::StartSnapuserdDaemon() {
     }
 }
 
+std::unique_ptr<ICowWriter> CowSnapuserdTest::CreateCowDeviceInternal() {
+    std::string path = android::base::GetExecutableDirectory();
+    cow_system_ = std::make_unique<TemporaryFile>(path);
+
+    CowOptions options;
+    options.compression = "gz";
+
+    unique_fd fd(cow_system_->fd);
+    cow_system_->fd = -1;
+
+    return CreateCowWriter(kDefaultCowVersion, options, std::move(fd));
+}
+
 void CowSnapuserdTest::ReadLastBlock() {
     unique_fd rnd_fd;
     total_base_size_ = BLOCK_SZ * 2;
@@ -280,9 +295,6 @@ void CowSnapuserdTest::ReadLastBlock() {
     base_loop_ = std::make_unique<LoopDevice>(base_fd_, 10s);
     ASSERT_TRUE(base_loop_->valid());
 
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
-
     std::unique_ptr<uint8_t[]> random_buffer_1_ = std::make_unique<uint8_t[]>(total_base_size_);
     loff_t offset = 0;
 
@@ -294,16 +306,13 @@ void CowSnapuserdTest::ReadLastBlock() {
         offset += BLOCK_SZ;
     }
 
-    CowOptions options;
-    options.compression = "gz";
-    CowWriter writer(options);
-
-    ASSERT_TRUE(writer.Initialize(cow_system_->fd));
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
 
-    ASSERT_TRUE(writer.AddRawBlocks(0, random_buffer_1_.get(), BLOCK_SZ));
-    ASSERT_TRUE(writer.AddRawBlocks(1, (char*)random_buffer_1_.get() + BLOCK_SZ, BLOCK_SZ));
+    ASSERT_TRUE(writer->AddRawBlocks(0, random_buffer_1_.get(), BLOCK_SZ));
+    ASSERT_TRUE(writer->AddRawBlocks(1, (char*)random_buffer_1_.get() + BLOCK_SZ, BLOCK_SZ));
 
-    ASSERT_TRUE(writer.Finalize());
+    ASSERT_TRUE(writer->Finalize());
 
     SetDeviceControlName();
 
@@ -381,22 +390,16 @@ void CowSnapuserdTest::ReadSnapshotDeviceAndValidate() {
 }
 
 void CowSnapuserdTest::CreateCowDeviceWithCopyOverlap_2() {
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
-
-    CowOptions options;
-    options.compression = "gz";
-    CowWriter writer(options);
-
-    ASSERT_TRUE(writer.Initialize(cow_system_->fd));
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
 
-    size_t num_blocks = size_ / options.block_size;
+    size_t num_blocks = size_ / writer->GetBlockSize();
     size_t x = num_blocks;
     size_t blk_src_copy = 0;
 
     // Create overlapping copy operations
     while (1) {
-        ASSERT_TRUE(writer.AddCopy(blk_src_copy, blk_src_copy + 1));
+        ASSERT_TRUE(writer->AddCopy(blk_src_copy, blk_src_copy + 1));
         x -= 1;
         if (x == 1) {
             break;
@@ -405,7 +408,7 @@ void CowSnapuserdTest::CreateCowDeviceWithCopyOverlap_2() {
     }
 
     // Flush operations
-    ASSERT_TRUE(writer.Finalize());
+    ASSERT_TRUE(writer->Finalize());
 
     // Construct the buffer required for validation
     orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
@@ -433,22 +436,16 @@ void CowSnapuserdTest::CreateCowDeviceWithCopyOverlap_2() {
 }
 
 void CowSnapuserdTest::CreateCowDeviceWithCopyOverlap_1() {
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
 
-    CowOptions options;
-    options.compression = "gz";
-    CowWriter writer(options);
-
-    ASSERT_TRUE(writer.Initialize(cow_system_->fd));
-
-    size_t num_blocks = size_ / options.block_size;
+    size_t num_blocks = size_ / writer->GetBlockSize();
     size_t x = num_blocks;
     size_t blk_src_copy = num_blocks - 1;
 
     // Create overlapping copy operations
     while (1) {
-        ASSERT_TRUE(writer.AddCopy(blk_src_copy + 1, blk_src_copy));
+        ASSERT_TRUE(writer->AddCopy(blk_src_copy + 1, blk_src_copy));
         x -= 1;
         if (x == 0) {
             ASSERT_EQ(blk_src_copy, 0);
@@ -458,7 +455,7 @@ void CowSnapuserdTest::CreateCowDeviceWithCopyOverlap_1() {
     }
 
     // Flush operations
-    ASSERT_TRUE(writer.Finalize());
+    ASSERT_TRUE(writer->Finalize());
 
     // Construct the buffer required for validation
     orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
@@ -468,10 +465,11 @@ void CowSnapuserdTest::CreateCowDeviceWithCopyOverlap_1() {
               true);
 
     // Merged operations
-    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), options.block_size, 0),
+    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), writer->GetBlockSize(),
+                                               0),
               true);
     ASSERT_EQ(android::base::ReadFullyAtOffset(
-                      base_fd_, (char*)orig_buffer_.get() + options.block_size, size_, 0),
+                      base_fd_, (char*)orig_buffer_.get() + writer->GetBlockSize(), size_, 0),
               true);
 }
 
@@ -479,8 +477,8 @@ void CowSnapuserdTest::CreateCowDeviceOrderedOpsInverted() {
     unique_fd rnd_fd;
     loff_t offset = 0;
 
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
 
     rnd_fd.reset(open("/dev/random", O_RDONLY));
     ASSERT_TRUE(rnd_fd > 0);
@@ -495,13 +493,7 @@ void CowSnapuserdTest::CreateCowDeviceOrderedOpsInverted() {
         offset += 1_MiB;
     }
 
-    CowOptions options;
-    options.compression = "gz";
-    CowWriter writer(options);
-
-    ASSERT_TRUE(writer.Initialize(cow_system_->fd));
-
-    size_t num_blocks = size_ / options.block_size;
+    size_t num_blocks = size_ / writer->GetBlockSize();
     size_t blk_end_copy = num_blocks * 3;
     size_t source_blk = num_blocks - 1;
     size_t blk_src_copy = blk_end_copy - 1;
@@ -509,7 +501,7 @@ void CowSnapuserdTest::CreateCowDeviceOrderedOpsInverted() {
 
     size_t x = num_blocks;
     while (1) {
-        ASSERT_TRUE(writer.AddCopy(source_blk, blk_src_copy));
+        ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
         x -= 1;
         if (x == 0) {
             break;
@@ -519,12 +511,12 @@ void CowSnapuserdTest::CreateCowDeviceOrderedOpsInverted() {
     }
 
     for (size_t i = num_blocks; i > 0; i--) {
-        ASSERT_TRUE(writer.AddXorBlocks(num_blocks + i - 1,
-                                        &random_buffer_1_.get()[options.block_size * (i - 1)],
-                                        options.block_size, 2 * num_blocks + i - 1, xor_offset));
+        ASSERT_TRUE(writer->AddXorBlocks(
+                num_blocks + i - 1, &random_buffer_1_.get()[writer->GetBlockSize() * (i - 1)],
+                writer->GetBlockSize(), 2 * num_blocks + i - 1, xor_offset));
     }
     // Flush operations
-    ASSERT_TRUE(writer.Finalize());
+    ASSERT_TRUE(writer->Finalize());
     // Construct the buffer required for validation
     orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
     // Read the entire base device
@@ -542,8 +534,8 @@ void CowSnapuserdTest::CreateCowDeviceOrderedOps() {
     unique_fd rnd_fd;
     loff_t offset = 0;
 
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
 
     rnd_fd.reset(open("/dev/random", O_RDONLY));
     ASSERT_TRUE(rnd_fd > 0);
@@ -559,20 +551,14 @@ void CowSnapuserdTest::CreateCowDeviceOrderedOps() {
     }
     memset(random_buffer_1_.get(), 0, size_);
 
-    CowOptions options;
-    options.compression = "gz";
-    CowWriter writer(options);
-
-    ASSERT_TRUE(writer.Initialize(cow_system_->fd));
-
-    size_t num_blocks = size_ / options.block_size;
+    size_t num_blocks = size_ / writer->GetBlockSize();
     size_t x = num_blocks;
     size_t source_blk = 0;
     size_t blk_src_copy = 2 * num_blocks;
     uint16_t xor_offset = 5;
 
     while (1) {
-        ASSERT_TRUE(writer.AddCopy(source_blk, blk_src_copy));
+        ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
 
         x -= 1;
         if (x == 0) {
@@ -582,10 +568,10 @@ void CowSnapuserdTest::CreateCowDeviceOrderedOps() {
         blk_src_copy += 1;
     }
 
-    ASSERT_TRUE(writer.AddXorBlocks(num_blocks, random_buffer_1_.get(), size_, 2 * num_blocks,
-                                    xor_offset));
+    ASSERT_TRUE(writer->AddXorBlocks(num_blocks, random_buffer_1_.get(), size_, 2 * num_blocks,
+                                     xor_offset));
     // Flush operations
-    ASSERT_TRUE(writer.Finalize());
+    ASSERT_TRUE(writer->Finalize());
     // Construct the buffer required for validation
     orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
     // Read the entire base device
@@ -603,8 +589,8 @@ void CowSnapuserdTest::CreateCowDevice() {
     unique_fd rnd_fd;
     loff_t offset = 0;
 
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
 
     rnd_fd.reset(open("/dev/random", O_RDONLY));
     ASSERT_TRUE(rnd_fd > 0);
@@ -619,13 +605,7 @@ void CowSnapuserdTest::CreateCowDevice() {
         offset += 1_MiB;
     }
 
-    CowOptions options;
-    options.compression = "gz";
-    CowWriter writer(options);
-
-    ASSERT_TRUE(writer.Initialize(cow_system_->fd));
-
-    size_t num_blocks = size_ / options.block_size;
+    size_t num_blocks = size_ / writer->GetBlockSize();
     size_t blk_end_copy = num_blocks * 2;
     size_t source_blk = num_blocks - 1;
     size_t blk_src_copy = blk_end_copy - 1;
@@ -639,11 +619,11 @@ void CowSnapuserdTest::CreateCowDevice() {
     for (int i = 0; i < num_blocks; i++) {
         sequence[num_blocks + i] = 5 * num_blocks - 1 - i;
     }
-    ASSERT_TRUE(writer.AddSequenceData(2 * num_blocks, sequence));
+    ASSERT_TRUE(writer->AddSequenceData(2 * num_blocks, sequence));
 
     size_t x = num_blocks;
     while (1) {
-        ASSERT_TRUE(writer.AddCopy(source_blk, blk_src_copy));
+        ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
         x -= 1;
         if (x == 0) {
             break;
@@ -655,24 +635,24 @@ void CowSnapuserdTest::CreateCowDevice() {
     source_blk = num_blocks;
     blk_src_copy = blk_end_copy;
 
-    ASSERT_TRUE(writer.AddRawBlocks(source_blk, random_buffer_1_.get(), size_));
+    ASSERT_TRUE(writer->AddRawBlocks(source_blk, random_buffer_1_.get(), size_));
 
     size_t blk_zero_copy_start = source_blk + num_blocks;
     size_t blk_zero_copy_end = blk_zero_copy_start + num_blocks;
 
-    ASSERT_TRUE(writer.AddZeroBlocks(blk_zero_copy_start, num_blocks));
+    ASSERT_TRUE(writer->AddZeroBlocks(blk_zero_copy_start, num_blocks));
 
     size_t blk_random2_replace_start = blk_zero_copy_end;
 
-    ASSERT_TRUE(writer.AddRawBlocks(blk_random2_replace_start, random_buffer_1_.get(), size_));
+    ASSERT_TRUE(writer->AddRawBlocks(blk_random2_replace_start, random_buffer_1_.get(), size_));
 
     size_t blk_xor_start = blk_random2_replace_start + num_blocks;
     size_t xor_offset = BLOCK_SZ / 2;
-    ASSERT_TRUE(writer.AddXorBlocks(blk_xor_start, random_buffer_1_.get(), size_, num_blocks,
-                                    xor_offset));
+    ASSERT_TRUE(writer->AddXorBlocks(blk_xor_start, random_buffer_1_.get(), size_, num_blocks,
+                                     xor_offset));
 
     // Flush operations
-    ASSERT_TRUE(writer.Finalize());
+    ASSERT_TRUE(writer->Finalize());
     // Construct the buffer required for validation
     orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
     std::string zero_buffer(size_, 0);
@@ -902,29 +882,36 @@ void CowSnapuserdTest::MergeInterrupt() {
     ASSERT_TRUE(Merge());
 }
 
-void CowSnapuserdMetadataTest::CreateCowPartialFilledArea() {
+std::unique_ptr<ICowWriter> CowSnapuserdMetadataTest::CreateCowDeviceInternal() {
     std::string path = android::base::GetExecutableDirectory();
     cow_system_ = std::make_unique<TemporaryFile>(path);
 
     CowOptions options;
     options.compression = "gz";
-    CowWriter writer(options);
 
-    ASSERT_TRUE(writer.Initialize(cow_system_->fd));
+    unique_fd fd(cow_system_->fd);
+    cow_system_->fd = -1;
+
+    return CreateCowWriter(kDefaultCowVersion, options, std::move(fd));
+}
+
+void CowSnapuserdMetadataTest::CreateCowPartialFilledArea() {
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
 
     // Area 0 is completely filled with 256 exceptions
     for (int i = 0; i < 256; i++) {
-        ASSERT_TRUE(writer.AddCopy(i, 256 + i));
+        ASSERT_TRUE(writer->AddCopy(i, 256 + i));
     }
 
     // Area 1 is partially filled with 2 copy ops and 10 zero ops
-    ASSERT_TRUE(writer.AddCopy(500, 1000));
-    ASSERT_TRUE(writer.AddCopy(501, 1001));
+    ASSERT_TRUE(writer->AddCopy(500, 1000));
+    ASSERT_TRUE(writer->AddCopy(501, 1001));
 
-    ASSERT_TRUE(writer.AddZeroBlocks(300, 10));
+    ASSERT_TRUE(writer->AddZeroBlocks(300, 10));
 
     // Flush operations
-    ASSERT_TRUE(writer.Finalize());
+    ASSERT_TRUE(writer->Finalize());
 }
 
 void CowSnapuserdMetadataTest::ValidatePartialFilledArea() {
@@ -956,8 +943,8 @@ void CowSnapuserdMetadataTest::CreateCowDevice() {
     unique_fd rnd_fd;
     loff_t offset = 0;
 
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
 
     rnd_fd.reset(open("/dev/random", O_RDONLY));
     ASSERT_TRUE(rnd_fd > 0);
@@ -972,50 +959,44 @@ void CowSnapuserdMetadataTest::CreateCowDevice() {
         offset += 1_MiB;
     }
 
-    CowOptions options;
-    options.compression = "gz";
-    CowWriter writer(options);
-
-    ASSERT_TRUE(writer.Initialize(cow_system_->fd));
-
-    size_t num_blocks = size_ / options.block_size;
+    size_t num_blocks = size_ / writer->GetBlockSize();
 
     // Overlapping region. This has to be split
     // into two batch operations
-    ASSERT_TRUE(writer.AddCopy(23, 20));
-    ASSERT_TRUE(writer.AddCopy(22, 19));
-    ASSERT_TRUE(writer.AddCopy(21, 18));
-    ASSERT_TRUE(writer.AddCopy(20, 17));
-    ASSERT_TRUE(writer.AddCopy(19, 16));
-    ASSERT_TRUE(writer.AddCopy(18, 15));
+    ASSERT_TRUE(writer->AddCopy(23, 20));
+    ASSERT_TRUE(writer->AddCopy(22, 19));
+    ASSERT_TRUE(writer->AddCopy(21, 18));
+    ASSERT_TRUE(writer->AddCopy(20, 17));
+    ASSERT_TRUE(writer->AddCopy(19, 16));
+    ASSERT_TRUE(writer->AddCopy(18, 15));
 
     // Contiguous region but blocks in ascending order
     // Daemon has to ensure that these blocks are merged
     // in a batch
-    ASSERT_TRUE(writer.AddCopy(50, 75));
-    ASSERT_TRUE(writer.AddCopy(51, 76));
-    ASSERT_TRUE(writer.AddCopy(52, 77));
-    ASSERT_TRUE(writer.AddCopy(53, 78));
+    ASSERT_TRUE(writer->AddCopy(50, 75));
+    ASSERT_TRUE(writer->AddCopy(51, 76));
+    ASSERT_TRUE(writer->AddCopy(52, 77));
+    ASSERT_TRUE(writer->AddCopy(53, 78));
 
     // Dis-contiguous region
-    ASSERT_TRUE(writer.AddCopy(110, 130));
-    ASSERT_TRUE(writer.AddCopy(105, 125));
-    ASSERT_TRUE(writer.AddCopy(100, 120));
+    ASSERT_TRUE(writer->AddCopy(110, 130));
+    ASSERT_TRUE(writer->AddCopy(105, 125));
+    ASSERT_TRUE(writer->AddCopy(100, 120));
 
     // Overlap
-    ASSERT_TRUE(writer.AddCopy(25, 30));
-    ASSERT_TRUE(writer.AddCopy(30, 31));
+    ASSERT_TRUE(writer->AddCopy(25, 30));
+    ASSERT_TRUE(writer->AddCopy(30, 31));
 
     size_t source_blk = num_blocks;
 
-    ASSERT_TRUE(writer.AddRawBlocks(source_blk, random_buffer_1_.get(), size_));
+    ASSERT_TRUE(writer->AddRawBlocks(source_blk, random_buffer_1_.get(), size_));
 
     size_t blk_zero_copy_start = source_blk + num_blocks;
 
-    ASSERT_TRUE(writer.AddZeroBlocks(blk_zero_copy_start, num_blocks));
+    ASSERT_TRUE(writer->AddZeroBlocks(blk_zero_copy_start, num_blocks));
 
     // Flush operations
-    ASSERT_TRUE(writer.Finalize());
+    ASSERT_TRUE(writer->Finalize());
 }
 
 void CowSnapuserdMetadataTest::InitMetadata() {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 57f9e7ac1a03..efe0c1443215 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -125,6 +125,7 @@ class SnapuserdTest : public ::testing::Test {
 
     void SimulateDaemonRestart();
 
+    std::unique_ptr<ICowWriter> CreateCowDeviceInternal();
     void CreateCowDevice();
     void CreateCowDeviceOrderedOps();
     void CreateCowDeviceOrderedOpsInverted();
@@ -277,23 +278,30 @@ void SnapuserdTest::ReadSnapshotDeviceAndValidate() {
     ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + (size_ * 4), size_), 0);
 }
 
-void SnapuserdTest::CreateCowDeviceWithCopyOverlap_2() {
+std::unique_ptr<ICowWriter> SnapuserdTest::CreateCowDeviceInternal() {
     std::string path = android::base::GetExecutableDirectory();
     cow_system_ = std::make_unique<TemporaryFile>(path);
 
     CowOptions options;
     options.compression = "gz";
-    CowWriter writer(options);
 
-    ASSERT_TRUE(writer.Initialize(cow_system_->fd));
+    unique_fd fd(cow_system_->fd);
+    cow_system_->fd = -1;
+
+    return CreateCowWriter(kDefaultCowVersion, options, std::move(fd));
+}
+
+void SnapuserdTest::CreateCowDeviceWithCopyOverlap_2() {
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
 
-    size_t num_blocks = size_ / options.block_size;
+    size_t num_blocks = size_ / writer->GetBlockSize();
     size_t x = num_blocks;
     size_t blk_src_copy = 0;
 
     // Create overlapping copy operations
     while (1) {
-        ASSERT_TRUE(writer.AddCopy(blk_src_copy, blk_src_copy + 1));
+        ASSERT_TRUE(writer->AddCopy(blk_src_copy, blk_src_copy + 1));
         x -= 1;
         if (x == 1) {
             break;
@@ -302,7 +310,7 @@ void SnapuserdTest::CreateCowDeviceWithCopyOverlap_2() {
     }
 
     // Flush operations
-    ASSERT_TRUE(writer.Finalize());
+    ASSERT_TRUE(writer->Finalize());
 
     // Construct the buffer required for validation
     orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
@@ -330,22 +338,16 @@ void SnapuserdTest::CreateCowDeviceWithCopyOverlap_2() {
 }
 
 void SnapuserdTest::CreateCowDeviceWithCopyOverlap_1() {
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
 
-    CowOptions options;
-    options.compression = "gz";
-    CowWriter writer(options);
-
-    ASSERT_TRUE(writer.Initialize(cow_system_->fd));
-
-    size_t num_blocks = size_ / options.block_size;
+    size_t num_blocks = size_ / writer->GetBlockSize();
     size_t x = num_blocks;
     size_t blk_src_copy = num_blocks - 1;
 
     // Create overlapping copy operations
     while (1) {
-        ASSERT_TRUE(writer.AddCopy(blk_src_copy + 1, blk_src_copy));
+        ASSERT_TRUE(writer->AddCopy(blk_src_copy + 1, blk_src_copy));
         x -= 1;
         if (x == 0) {
             ASSERT_EQ(blk_src_copy, 0);
@@ -355,7 +357,7 @@ void SnapuserdTest::CreateCowDeviceWithCopyOverlap_1() {
     }
 
     // Flush operations
-    ASSERT_TRUE(writer.Finalize());
+    ASSERT_TRUE(writer->Finalize());
 
     // Construct the buffer required for validation
     orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
@@ -365,10 +367,11 @@ void SnapuserdTest::CreateCowDeviceWithCopyOverlap_1() {
               true);
 
     // Merged operations
-    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), options.block_size, 0),
+    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), writer->GetBlockSize(),
+                                               0),
               true);
     ASSERT_EQ(android::base::ReadFullyAtOffset(
-                      base_fd_, (char*)orig_buffer_.get() + options.block_size, size_, 0),
+                      base_fd_, (char*)orig_buffer_.get() + writer->GetBlockSize(), size_, 0),
               true);
 }
 
@@ -376,8 +379,8 @@ void SnapuserdTest::CreateCowDeviceOrderedOpsInverted() {
     unique_fd rnd_fd;
     loff_t offset = 0;
 
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
 
     rnd_fd.reset(open("/dev/random", O_RDONLY));
     ASSERT_TRUE(rnd_fd > 0);
@@ -392,13 +395,7 @@ void SnapuserdTest::CreateCowDeviceOrderedOpsInverted() {
         offset += 1_MiB;
     }
 
-    CowOptions options;
-    options.compression = "gz";
-    CowWriter writer(options);
-
-    ASSERT_TRUE(writer.Initialize(cow_system_->fd));
-
-    size_t num_blocks = size_ / options.block_size;
+    size_t num_blocks = size_ / writer->GetBlockSize();
     size_t blk_end_copy = num_blocks * 3;
     size_t source_blk = num_blocks - 1;
     size_t blk_src_copy = blk_end_copy - 1;
@@ -406,7 +403,7 @@ void SnapuserdTest::CreateCowDeviceOrderedOpsInverted() {
 
     size_t x = num_blocks;
     while (1) {
-        ASSERT_TRUE(writer.AddCopy(source_blk, blk_src_copy));
+        ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
         x -= 1;
         if (x == 0) {
             break;
@@ -416,12 +413,12 @@ void SnapuserdTest::CreateCowDeviceOrderedOpsInverted() {
     }
 
     for (size_t i = num_blocks; i > 0; i--) {
-        ASSERT_TRUE(writer.AddXorBlocks(num_blocks + i - 1,
-                                        &random_buffer_1_.get()[options.block_size * (i - 1)],
-                                        options.block_size, 2 * num_blocks + i - 1, xor_offset));
+        ASSERT_TRUE(writer->AddXorBlocks(
+                num_blocks + i - 1, &random_buffer_1_.get()[writer->GetBlockSize() * (i - 1)],
+                writer->GetBlockSize(), 2 * num_blocks + i - 1, xor_offset));
     }
     // Flush operations
-    ASSERT_TRUE(writer.Finalize());
+    ASSERT_TRUE(writer->Finalize());
     // Construct the buffer required for validation
     orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
     // Read the entire base device
@@ -439,8 +436,8 @@ void SnapuserdTest::CreateCowDeviceOrderedOps() {
     unique_fd rnd_fd;
     loff_t offset = 0;
 
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
 
     rnd_fd.reset(open("/dev/random", O_RDONLY));
     ASSERT_TRUE(rnd_fd > 0);
@@ -456,20 +453,14 @@ void SnapuserdTest::CreateCowDeviceOrderedOps() {
     }
     memset(random_buffer_1_.get(), 0, size_);
 
-    CowOptions options;
-    options.compression = "gz";
-    CowWriter writer(options);
-
-    ASSERT_TRUE(writer.Initialize(cow_system_->fd));
-
-    size_t num_blocks = size_ / options.block_size;
+    size_t num_blocks = size_ / writer->GetBlockSize();
     size_t x = num_blocks;
     size_t source_blk = 0;
     size_t blk_src_copy = 2 * num_blocks;
     uint16_t xor_offset = 5;
 
     while (1) {
-        ASSERT_TRUE(writer.AddCopy(source_blk, blk_src_copy));
+        ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
 
         x -= 1;
         if (x == 0) {
@@ -479,10 +470,10 @@ void SnapuserdTest::CreateCowDeviceOrderedOps() {
         blk_src_copy += 1;
     }
 
-    ASSERT_TRUE(writer.AddXorBlocks(num_blocks, random_buffer_1_.get(), size_, 2 * num_blocks,
-                                    xor_offset));
+    ASSERT_TRUE(writer->AddXorBlocks(num_blocks, random_buffer_1_.get(), size_, 2 * num_blocks,
+                                     xor_offset));
     // Flush operations
-    ASSERT_TRUE(writer.Finalize());
+    ASSERT_TRUE(writer->Finalize());
     // Construct the buffer required for validation
     orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
     // Read the entire base device
@@ -500,8 +491,8 @@ void SnapuserdTest::CreateCowDevice() {
     unique_fd rnd_fd;
     loff_t offset = 0;
 
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
 
     rnd_fd.reset(open("/dev/random", O_RDONLY));
     ASSERT_TRUE(rnd_fd > 0);
@@ -516,13 +507,7 @@ void SnapuserdTest::CreateCowDevice() {
         offset += 1_MiB;
     }
 
-    CowOptions options;
-    options.compression = "gz";
-    CowWriter writer(options);
-
-    ASSERT_TRUE(writer.Initialize(cow_system_->fd));
-
-    size_t num_blocks = size_ / options.block_size;
+    size_t num_blocks = size_ / writer->GetBlockSize();
     size_t blk_end_copy = num_blocks * 2;
     size_t source_blk = num_blocks - 1;
     size_t blk_src_copy = blk_end_copy - 1;
@@ -536,11 +521,11 @@ void SnapuserdTest::CreateCowDevice() {
     for (int i = 0; i < num_blocks; i++) {
         sequence[num_blocks + i] = 5 * num_blocks - 1 - i;
     }
-    ASSERT_TRUE(writer.AddSequenceData(2 * num_blocks, sequence));
+    ASSERT_TRUE(writer->AddSequenceData(2 * num_blocks, sequence));
 
     size_t x = num_blocks;
     while (1) {
-        ASSERT_TRUE(writer.AddCopy(source_blk, blk_src_copy));
+        ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
         x -= 1;
         if (x == 0) {
             break;
@@ -552,24 +537,24 @@ void SnapuserdTest::CreateCowDevice() {
     source_blk = num_blocks;
     blk_src_copy = blk_end_copy;
 
-    ASSERT_TRUE(writer.AddRawBlocks(source_blk, random_buffer_1_.get(), size_));
+    ASSERT_TRUE(writer->AddRawBlocks(source_blk, random_buffer_1_.get(), size_));
 
     size_t blk_zero_copy_start = source_blk + num_blocks;
     size_t blk_zero_copy_end = blk_zero_copy_start + num_blocks;
 
-    ASSERT_TRUE(writer.AddZeroBlocks(blk_zero_copy_start, num_blocks));
+    ASSERT_TRUE(writer->AddZeroBlocks(blk_zero_copy_start, num_blocks));
 
     size_t blk_random2_replace_start = blk_zero_copy_end;
 
-    ASSERT_TRUE(writer.AddRawBlocks(blk_random2_replace_start, random_buffer_1_.get(), size_));
+    ASSERT_TRUE(writer->AddRawBlocks(blk_random2_replace_start, random_buffer_1_.get(), size_));
 
     size_t blk_xor_start = blk_random2_replace_start + num_blocks;
     size_t xor_offset = BLOCK_SZ / 2;
-    ASSERT_TRUE(writer.AddXorBlocks(blk_xor_start, random_buffer_1_.get(), size_, num_blocks,
-                                    xor_offset));
+    ASSERT_TRUE(writer->AddXorBlocks(blk_xor_start, random_buffer_1_.get(), size_, num_blocks,
+                                     xor_offset));
 
     // Flush operations
-    ASSERT_TRUE(writer.Finalize());
+    ASSERT_TRUE(writer->Finalize());
     // Construct the buffer required for validation
     orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
     std::string zero_buffer(size_, 0);

From 7a0611b00611512b43a9739b7ca4a2c1e74c6db0 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers@google.com>
Date: Thu, 8 Jun 2023 20:54:49 +0000
Subject: [PATCH 0103/1487] Remove write permission from file mode of top-level
 user dirs

Due to the work done for b/156305599 ("Ensure no process except vold can
create directories like /data/system_ce/0"), the SELinux policy now
enforces that vold is the only process that can write to directories
that contain per-user encrypted subdirectories.  This is essential to
prevent bugs where directories that are supposed to be encrypted get
created too early so are not actually encrypted as intended.

However, this only works when SELinux is in enforcing mode.  When
SELinux is in permissive mode, only DAC is enforced, and the file modes
allow other processes to write to many of these directories.  That
allows system_server to break things once again.

Therefore, remove the write bit from the file modes so that write access
is always denied to processes that don't have CAP_DAC_OVERRIDE.  This is
not as strong a restriction as the SELinux policy, which still applies
independently, but it does keep out system_server by itself.

Also remove the sticky bit from /data/misc_ce and /data/misc_de, since
there is no reason for it.  (It probably was originally copied from
/data/misc, which might need it.  But misc_{ce,de} don't need it.)

Bug: 285239971
Test: Booted Cuttlefish
Change-Id: I1213a4d18c5f851acf213d786400d79d73777ed0
---
 rootdir/init.rc | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 0ee85c7412b9..53443685263a 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -919,15 +919,22 @@ on post-fs-data
     # encryption policies apply recursively.  These directories should never
     # contain any subdirectories other than the per-user ones.  /data/media/obb
     # is an exception that exists for legacy reasons.
-    mkdir /data/media 0770 media_rw media_rw encryption=None
-    mkdir /data/misc_ce 01771 system misc encryption=None
-    mkdir /data/misc_de 01771 system misc encryption=None
-    mkdir /data/system_ce 0770 system system encryption=None
-    mkdir /data/system_de 0770 system system encryption=None
-    mkdir /data/user 0711 system system encryption=None
-    mkdir /data/user_de 0711 system system encryption=None
-    mkdir /data/vendor_ce 0771 root root encryption=None
-    mkdir /data/vendor_de 0771 root root encryption=None
+    #
+    # Don't use any write mode bits (0222) for any of these directories, since
+    # the only process that should write to them directly is vold (since it
+    # needs to set up file-based encryption on the subdirectories), which runs
+    # as root with CAP_DAC_OVERRIDE.  This is also fully enforced via the
+    # SELinux policy.  But we also set the DAC file modes accordingly, to try to
+    # minimize differences in behavior if SELinux is set to permissive mode.
+    mkdir /data/media 0550 media_rw media_rw encryption=None
+    mkdir /data/misc_ce 0551 system misc encryption=None
+    mkdir /data/misc_de 0551 system misc encryption=None
+    mkdir /data/system_ce 0550 system system encryption=None
+    mkdir /data/system_de 0550 system system encryption=None
+    mkdir /data/user 0511 system system encryption=None
+    mkdir /data/user_de 0511 system system encryption=None
+    mkdir /data/vendor_ce 0551 root root encryption=None
+    mkdir /data/vendor_de 0551 root root encryption=None
 
     # Set the casefold flag on /data/media.  For upgrades, a restorecon can be
     # needed first to relabel the directory from media_rw_data_file.

From 0d277d777f290729fd9708b88f7ed57f0e0e49eb Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Fri, 9 Jun 2023 09:52:49 +0900
Subject: [PATCH 0104/1487] init: non-crashing service can restart immediately

This CL allows restart_period to be set to a value shorter than 5s.
Previously this was prohibited to rate limit crashing services. That
behavior is considered to be a bit too conservative because some
services don't crash, but exit deliverately.

adbd is the motivating example. When adb root or adb unroot is
requested, it changes its mode of operation (via sysprop), exits itself,
and restarts (by init) to enter into the mode. However, due to the 5s
delay, the mode change can complete no earlier than 5 seconds after adbd
was started last time. This can slow the mode change when it is
requested right after the boot.

With this CL, restart_period can be set to a value smaller than 5. And
services like adbd can make use of it. However, in ordef to rate limit
crashing service, the default is enforced if the service was crashed
last time. In addition, such intended restart is not counted as crashes
when monitoring successive crashes during booting.

Bug: 286061817
Test: /packages/modules/Virtualization/vm/vm_shell.sh start-microdroid \
 --auto-connect -- --protected
* with this change: within 2s
* without this change: over 6s

Change-Id: I1b3f0c92d349e8c8760821cf50fb69997b67b242
---
 init/README.md          | 13 ++++++++-----
 init/service.cpp        |  4 +++-
 init/service.h          | 17 +++++++++++++++--
 init/service_parser.cpp |  4 ++--
 4 files changed, 28 insertions(+), 10 deletions(-)

diff --git a/init/README.md b/init/README.md
index 6bdff4afead7..5fced19b076f 100644
--- a/init/README.md
+++ b/init/README.md
@@ -344,11 +344,14 @@ runs the service.
   intended to be used with the `exec_start` builtin for any must-have checks during boot.
 
 `restart_period <seconds>`
-> If a non-oneshot service exits, it will be restarted at its start time plus
-  this period. It defaults to 5s to rate limit crashing services.
-  This can be increased for services that are meant to run periodically. For
-  example, it may be set to 3600 to indicate that the service should run every hour
-  or 86400 to indicate that the service should run every day.
+> If a non-oneshot service exits, it will be restarted at its previous start time plus this period.
+  The default value is 5s. This can be used to implement periodic services together with the
+  `timeout_period` command below. For example, it may be set to 3600 to indicate that the service
+  should run every hour or 86400 to indicate that the service should run every day. This can be set
+  to a value shorter than 5s for example 0, but the minimum 5s delay is enforced if the restart was
+  due to a crash. This is to rate limit persistentally crashing services. In other words,
+  `<seconds>` smaller than 5 is respected only when the service exits deliverately and successfully
+  (i.e. by calling exit(0)).
 
 `rlimit <resource> <cur> <max>`
 > This applies the given rlimit to the service. rlimits are inherited by child
diff --git a/init/service.cpp b/init/service.cpp
index c1520818a807..29457084b05f 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -308,6 +308,7 @@ void Service::Reap(const siginfo_t& siginfo) {
     pid_ = 0;
     flags_ &= (~SVC_RUNNING);
     start_order_ = 0;
+    was_last_exit_ok_ = siginfo.si_code == CLD_EXITED && siginfo.si_status == 0;
 
     // Oneshot processes go into the disabled state on exit,
     // except when manually restarted.
@@ -361,7 +362,8 @@ void Service::Reap(const siginfo_t& siginfo) {
     // If we crash > 4 times in 'fatal_crash_window_' minutes or before boot_completed,
     // reboot into bootloader or set crashing property
     boot_clock::time_point now = boot_clock::now();
-    if (((flags_ & SVC_CRITICAL) || is_process_updatable) && !(flags_ & SVC_RESTART)) {
+    if (((flags_ & SVC_CRITICAL) || is_process_updatable) && !(flags_ & SVC_RESTART) &&
+        !was_last_exit_ok_) {
         bool boot_completed = GetBoolProperty("sys.boot_completed", false);
         if (now < time_crashed_ + fatal_crash_window_ || !boot_completed) {
             if (++crash_count_ > 4) {
diff --git a/init/service.h b/init/service.h
index ce7c0daf2a98..b858eeff03d6 100644
--- a/init/service.h
+++ b/init/service.h
@@ -19,6 +19,7 @@
 #include <signal.h>
 #include <sys/types.h>
 
+#include <algorithm>
 #include <chrono>
 #include <memory>
 #include <optional>
@@ -115,6 +116,7 @@ class Service {
     pid_t pid() const { return pid_; }
     android::base::boot_clock::time_point time_started() const { return time_started_; }
     int crash_count() const { return crash_count_; }
+    int was_last_exit_ok() const { return was_last_exit_ok_; }
     uid_t uid() const { return proc_attr_.uid(); }
     gid_t gid() const { return proc_attr_.gid; }
     int namespace_flags() const { return namespaces_.flags; }
@@ -130,7 +132,15 @@ class Service {
     bool process_cgroup_empty() const { return process_cgroup_empty_; }
     unsigned long start_order() const { return start_order_; }
     void set_sigstop(bool value) { sigstop_ = value; }
-    std::chrono::seconds restart_period() const { return restart_period_; }
+    std::chrono::seconds restart_period() const {
+        // If the service exited abnormally or due to timeout, late limit the restart even if
+        // restart_period is set to a very short value.
+        // If not, i.e. restart after a deliberate and successful exit, respect the period.
+        if (!was_last_exit_ok_) {
+            return std::max(restart_period_, default_restart_period_);
+        }
+        return restart_period_;
+    }
     std::optional<std::chrono::seconds> timeout_period() const { return timeout_period_; }
     const std::vector<std::string>& args() const { return args_; }
     bool is_updatable() const { return updatable_; }
@@ -172,6 +182,8 @@ class Service {
     bool upgraded_mte_ = false;           // whether we upgraded async MTE -> sync MTE before
     std::chrono::minutes fatal_crash_window_ = 4min;  // fatal() when more than 4 crashes in it
     std::optional<std::string> fatal_reboot_target_;  // reboot target of fatal handler
+    bool was_last_exit_ok_ =
+            true;  // true if the service never exited, or exited with status code 0
 
     std::optional<CapSet> capabilities_;
     ProcessAttributes proc_attr_;
@@ -214,7 +226,8 @@ class Service {
 
     bool sigstop_ = false;
 
-    std::chrono::seconds restart_period_ = 5s;
+    const std::chrono::seconds default_restart_period_ = 5s;
+    std::chrono::seconds restart_period_ = default_restart_period_;
     std::optional<std::chrono::seconds> timeout_period_;
 
     bool updatable_ = false;
diff --git a/init/service_parser.cpp b/init/service_parser.cpp
index d46e1f7544bd..a1b2cc55f472 100644
--- a/init/service_parser.cpp
+++ b/init/service_parser.cpp
@@ -370,8 +370,8 @@ Result<void> ServiceParser::ParseRebootOnFailure(std::vector<std::string>&& args
 
 Result<void> ServiceParser::ParseRestartPeriod(std::vector<std::string>&& args) {
     int period;
-    if (!ParseInt(args[1], &period, 5)) {
-        return Error() << "restart_period value must be an integer >= 5";
+    if (!ParseInt(args[1], &period, 0)) {
+        return Error() << "restart_period value must be an integer >= 0";
     }
     service_->restart_period_ = std::chrono::seconds(period);
     return {};

From 9d2fb9ca3cf50de931666dbd4783652f45cf2a5b Mon Sep 17 00:00:00 2001
From: John Stultz <jstultz@google.com>
Date: Fri, 9 Jun 2023 18:52:22 +0000
Subject: [PATCH 0105/1487] fastboot: Introduce FASTBOOT_DEVICE alias for
 ANDROID_SERIAL environment variable

The ANDROID_SERIAL env is useful for managing multiple
directly connected devices at one time.

Unfortunately for network connected devices, its harder to use.

This is because both adb and fastboot use the same ANDROID_SERIAL
environment value to identify the device to use, and while that
one value works for directly connected devices, when using
network connected devices, the fastboot and adb port numbers may
differ for the same device.

So if I set: `ANDROID_SERIAL="tcp:127.0.0.1:44403"`
fastboot will work, but when I type `adb shell`, I'll get:
 adb: device 'tcp:127.0.0.1:44403' not found

As `adb devices` outputs:
List of devices attached
localhost:36697 device

To resolve this, we need separate environment variables,
so introduce a FASTBOOT_DEVICE variable for fastboot.

If FASTBOOT_DEVICE is set, it will use that, and if not
it will fall back to the ANDROID_SERIAL if it is set.

Using an explicit -s argument will still override both.

Change-Id: Icd7db6f29e51ed2decd219e35537f6ed98d698b8
Signed-off-by: John Stultz <jstultz@google.com>
---
 fastboot/fastboot.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 799406581143..a1664a4b816b 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -2231,7 +2231,9 @@ int FastBootTool::Main(int argc, char* argv[]) {
                                       {"version", no_argument, 0, 0},
                                       {0, 0, 0, 0}};
 
-    serial = getenv("ANDROID_SERIAL");
+    serial = getenv("FASTBOOT_DEVICE");
+    if (!serial)
+        serial = getenv("ANDROID_SERIAL");
 
     int c;
     while ((c = getopt_long(argc, argv, "a::hls:S:vw", longopts, &longindex)) != -1) {

From 214f37c2493f005231ff32e9982c2b831de11d38 Mon Sep 17 00:00:00 2001
From: Biswapriyo Nath <nathbappai@gmail.com>
Date: Sat, 10 Jun 2023 20:03:31 +0530
Subject: [PATCH 0106/1487] fastboot: Add header that declares std::function
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This fixes the following compiler error with gcc
fastboot_driver.h:51:10: error: ‘function’ in namespace ‘std’ does not name a template type

Change-Id: I3a4d9b48bfdc2c76e443e2efe1761ec9503c6dc5
---
 fastboot/fastboot_driver.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fastboot/fastboot_driver.h b/fastboot/fastboot_driver.h
index 3d6c7b017c3c..6ac26ce31f13 100644
--- a/fastboot/fastboot_driver.h
+++ b/fastboot/fastboot_driver.h
@@ -28,6 +28,7 @@
 #pragma once
 #include <cstdlib>
 #include <deque>
+#include <functional>
 #include <limits>
 #include <string>
 #include <vector>

From 816480b56ec0b96c76fa9145a0c092db0ba3b37e Mon Sep 17 00:00:00 2001
From: Biswapriyo Nath <nathbappai@gmail.com>
Date: Tue, 13 Jun 2023 00:28:14 +0530
Subject: [PATCH 0107/1487] fastboot: Include header for ostream_iterator and
 istream_iterator

This fixes the following compiler errors with gcc

storage.cpp:45:20: error: 'ostream_iterator' is not a member of 'std'
storage.cpp:50:10: error: 'istream_iterator' is not a member of 'std'

Change-Id: I570e332d100bb18e445644a9d57dc14d80f104b5
---
 fastboot/storage.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/fastboot/storage.cpp b/fastboot/storage.cpp
index dc733b99464e..629ebc88eff7 100644
--- a/fastboot/storage.cpp
+++ b/fastboot/storage.cpp
@@ -18,6 +18,7 @@
 #include <android-base/logging.h>
 
 #include <fstream>
+#include <iterator>
 
 #include "storage.h"
 #include "util.h"
@@ -62,4 +63,4 @@ FileLock ConnectedDevicesStorage::Lock() const {
         LOG(FATAL) << "Cannot create directory: " << home_fastboot_path_;
     }
     return FileLock(devices_lock_path_);
-}
\ No newline at end of file
+}

From 3dc7fcc0b69b20eb6fb34fdf36908313f2cf811e Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 13 Jun 2023 14:53:32 -0700
Subject: [PATCH 0108/1487] Removing duplicate CollectImages()

images are being flashed twice, because of an additional collectImages.
This is resulting in a ~50% increase in flashing time

Test: fastboot flashall -w
Change-Id: I6c271e1e1456cd789f37ebd67cefd221cabc6e7a
---
 fastboot/fastboot.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 799406581143..fb0e18b6f36f 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1780,7 +1780,6 @@ void FlashAllTool::Flash() {
     }
 
     DetermineSlot();
-    CollectImages();
 
     CancelSnapshotIfNeeded();
 

From 32e1c70f275991ec7fe4d4a2d6e3eeba2a172540 Mon Sep 17 00:00:00 2001
From: Subrahmanya Manikanta Venkateswarlu Bhamidipati Kameswara Sri
 <subrahmanyaman@google.com>
Date: Tue, 13 Jun 2023 17:37:29 +0000
Subject: [PATCH 0109/1487] Check AServiceManager_isDeclared before
 AServiceManager_getService

Call AServiceManager_isDeclared before calling AServiceManager_getService
to avoid the waiting time when aidl service is not available.

Bug: 286969060
Test: run VtsHalGatekeeperTarget
Change-Id: I7d652a546cb810a601338a68950f01d065aea7a5
---
 gatekeeperd/gatekeeperd.cpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/gatekeeperd/gatekeeperd.cpp b/gatekeeperd/gatekeeperd.cpp
index 7987167662dc..bdfb7f6f7f1f 100644
--- a/gatekeeperd/gatekeeperd.cpp
+++ b/gatekeeperd/gatekeeperd.cpp
@@ -63,9 +63,13 @@ constexpr const char gatekeeperServiceName[] = "android.hardware.gatekeeper.IGat
 
 GateKeeperProxy::GateKeeperProxy() {
     clear_state_if_needed_done = false;
-    hw_device = IGatekeeper::getService();
-    ::ndk::SpAIBinder ks2Binder(AServiceManager_getService(gatekeeperServiceName));
-    aidl_hw_device = AidlIGatekeeper::fromBinder(ks2Binder);
+    if (AServiceManager_isDeclared(gatekeeperServiceName)) {
+        ::ndk::SpAIBinder ks2Binder(AServiceManager_waitForService(gatekeeperServiceName));
+        aidl_hw_device = AidlIGatekeeper::fromBinder(ks2Binder);
+    }
+    if (!aidl_hw_device) {
+        hw_device = IGatekeeper::getService();
+    }
     is_running_gsi = android::base::GetBoolProperty(android::gsi::kGsiBootedProp, false);
 
     if (!aidl_hw_device && !hw_device) {

From 94ef7122d663067bbdd841d0ce13054d264ec0cc Mon Sep 17 00:00:00 2001
From: Nikita Ioffe <ioffe@google.com>
Date: Wed, 7 Jun 2023 23:58:19 +0100
Subject: [PATCH 0110/1487] Treat Microdroid as OS with monolithic sepolicy

Bug: 285855150
Test: atest MicrodroidTestApp
Change-Id: Idfda3044716a021888017adef801ef67775a3eda
---
 init/selinux.cpp | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/init/selinux.cpp b/init/selinux.cpp
index 907eb80e31c0..a9365323362f 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -300,6 +300,8 @@ bool GetVendorMappingVersion(std::string* plat_vers) {
 }
 
 constexpr const char plat_policy_cil_file[] = "/system/etc/selinux/plat_sepolicy.cil";
+constexpr const char kMicrodroidPrecompiledSepolicy[] =
+        "/system/etc/selinux/microdroid_precompiled_sepolicy";
 
 bool IsSplitPolicyDevice() {
     return access(plat_policy_cil_file, R_OK) != -1;
@@ -497,14 +499,19 @@ bool OpenSplitPolicy(PolicyFile* policy_file) {
 
 bool OpenMonolithicPolicy(PolicyFile* policy_file) {
     static constexpr char kSepolicyFile[] = "/sepolicy";
-
-    LOG(VERBOSE) << "Opening SELinux policy from monolithic file";
-    policy_file->fd.reset(open(kSepolicyFile, O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
+    // In Microdroid the precompiled sepolicy is located on /system, since there is no vendor code.
+    // TODO(b/287206497): refactor once we start conditionally compiling init for Microdroid.
+    std::string monolithic_policy_file = access(kMicrodroidPrecompiledSepolicy, R_OK) == 0
+                                                 ? kMicrodroidPrecompiledSepolicy
+                                                 : kSepolicyFile;
+
+    LOG(INFO) << "Opening SELinux policy from monolithic file " << monolithic_policy_file;
+    policy_file->fd.reset(open(monolithic_policy_file.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
     if (policy_file->fd < 0) {
         PLOG(ERROR) << "Failed to open monolithic SELinux policy";
         return false;
     }
-    policy_file->path = kSepolicyFile;
+    policy_file->path = monolithic_policy_file;
     return true;
 }
 

From 1779dcca32e6c84a0b81454f5fe647cfb5295ccb Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 13 Jun 2023 10:28:40 -0700
Subject: [PATCH 0111/1487] snapuserd: Create snapuserd_readahead.h.

This moves ReadAhead out of snapuserd_core.h so it's easier to find.

Bug: N/A
Test: builds
Change-Id: I888b87921950f2f7582b94c078e9e136f8fdd09e
---
 .../user-space-merge/snapuserd_core.h         |  77 +-----------
 .../user-space-merge/snapuserd_readahead.cpp  |   2 +
 .../user-space-merge/snapuserd_readahead.h    | 112 ++++++++++++++++++
 3 files changed, 115 insertions(+), 76 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.h

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index 777aa0705b2d..79a5bc952abf 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -46,6 +46,7 @@
 #include <snapuserd/snapuserd_buffer.h>
 #include <snapuserd/snapuserd_kernel.h>
 #include <storage_literals/storage_literals.h>
+#include "snapuserd_readahead.h"
 
 namespace android {
 namespace snapshot {
@@ -96,82 +97,6 @@ struct MergeGroupState {
         : merge_state_(state), num_ios_in_progress(n_ios) {}
 };
 
-class ReadAhead {
-  public:
-    ReadAhead(const std::string& cow_device, const std::string& backing_device,
-              const std::string& misc_name, std::shared_ptr<SnapshotHandler> snapuserd);
-    bool RunThread();
-
-  private:
-    void InitializeRAIter();
-    bool RAIterDone();
-    void RAIterNext();
-    void RAResetIter(uint64_t num_blocks);
-    const CowOperation* GetRAOpIter();
-
-    void InitializeBuffer();
-    bool InitReader();
-    bool InitializeFds();
-
-    void CloseFds() { backing_store_fd_ = {}; }
-
-    bool ReadAheadIOStart();
-    int PrepareNextReadAhead(uint64_t* source_offset, int* pending_ops,
-                             std::vector<uint64_t>& blocks,
-                             std::vector<const CowOperation*>& xor_op_vec);
-    bool ReconstructDataFromCow();
-    void CheckOverlap(const CowOperation* cow_op);
-
-    bool ReadAheadAsyncIO();
-    bool ReapIoCompletions(int pending_ios_to_complete);
-    bool ReadXorData(size_t block_index, size_t xor_op_index,
-                     std::vector<const CowOperation*>& xor_op_vec);
-    void ProcessXorData(size_t& block_xor_index, size_t& xor_index,
-                        std::vector<const CowOperation*>& xor_op_vec, void* buffer,
-                        loff_t& buffer_offset);
-    void UpdateScratchMetadata();
-
-    bool ReadAheadSyncIO();
-    bool InitializeIouring();
-    void FinalizeIouring();
-
-    void* read_ahead_buffer_;
-    void* metadata_buffer_;
-
-    std::unique_ptr<ICowOpIter> cowop_iter_;
-
-    std::string cow_device_;
-    std::string backing_store_device_;
-    std::string misc_name_;
-
-    unique_fd cow_fd_;
-    unique_fd backing_store_fd_;
-
-    std::shared_ptr<SnapshotHandler> snapuserd_;
-    std::unique_ptr<CowReader> reader_;
-
-    std::unordered_set<uint64_t> dest_blocks_;
-    std::unordered_set<uint64_t> source_blocks_;
-    bool overlap_;
-    std::vector<uint64_t> blocks_;
-    int total_blocks_merged_ = 0;
-    std::unique_ptr<uint8_t[]> ra_temp_buffer_;
-    std::unique_ptr<uint8_t[]> ra_temp_meta_buffer_;
-    BufferSink bufsink_;
-
-    uint64_t total_ra_blocks_completed_ = 0;
-    bool read_ahead_async_ = false;
-    // Queue depth of 8 seems optimal. We don't want
-    // to have a huge depth as it may put more memory pressure
-    // on the kernel worker threads given that we use
-    // IOSQE_ASYNC flag - ASYNC flags can potentially
-    // result in EINTR; Since we don't restart
-    // syscalls and fallback to synchronous I/O, we
-    // don't want huge queue depth
-    int queue_depth_ = 8;
-    std::unique_ptr<struct io_uring> ring_;
-};
-
 class UpdateVerify {
   public:
     UpdateVerify(const std::string& misc_name);
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index 17f1f0e27375..af2428602962 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include "snapuserd_readahead.h"
+
 #include "snapuserd_core.h"
 
 namespace android {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.h
new file mode 100644
index 000000000000..5e94de005511
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.h
@@ -0,0 +1,112 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include <android-base/unique_fd.h>
+#include <libsnapshot/cow_reader.h>
+#include <liburing.h>
+#include <snapuserd/snapuserd_buffer.h>
+
+namespace android {
+namespace snapshot {
+
+class SnapshotHandler;
+
+class ReadAhead {
+  public:
+    ReadAhead(const std::string& cow_device, const std::string& backing_device,
+              const std::string& misc_name, std::shared_ptr<SnapshotHandler> snapuserd);
+    bool RunThread();
+
+  private:
+    void InitializeRAIter();
+    bool RAIterDone();
+    void RAIterNext();
+    void RAResetIter(uint64_t num_blocks);
+    const CowOperation* GetRAOpIter();
+
+    void InitializeBuffer();
+    bool InitReader();
+    bool InitializeFds();
+
+    void CloseFds() { backing_store_fd_ = {}; }
+
+    bool ReadAheadIOStart();
+    int PrepareNextReadAhead(uint64_t* source_offset, int* pending_ops,
+                             std::vector<uint64_t>& blocks,
+                             std::vector<const CowOperation*>& xor_op_vec);
+    bool ReconstructDataFromCow();
+    void CheckOverlap(const CowOperation* cow_op);
+
+    bool ReadAheadAsyncIO();
+    bool ReapIoCompletions(int pending_ios_to_complete);
+    bool ReadXorData(size_t block_index, size_t xor_op_index,
+                     std::vector<const CowOperation*>& xor_op_vec);
+    void ProcessXorData(size_t& block_xor_index, size_t& xor_index,
+                        std::vector<const CowOperation*>& xor_op_vec, void* buffer,
+                        loff_t& buffer_offset);
+    void UpdateScratchMetadata();
+
+    bool ReadAheadSyncIO();
+    bool InitializeIouring();
+    void FinalizeIouring();
+
+    void* read_ahead_buffer_;
+    void* metadata_buffer_;
+
+    std::unique_ptr<ICowOpIter> cowop_iter_;
+
+    std::string cow_device_;
+    std::string backing_store_device_;
+    std::string misc_name_;
+
+    android::base::unique_fd cow_fd_;
+    android::base::unique_fd backing_store_fd_;
+
+    std::shared_ptr<SnapshotHandler> snapuserd_;
+    std::unique_ptr<CowReader> reader_;
+
+    std::unordered_set<uint64_t> dest_blocks_;
+    std::unordered_set<uint64_t> source_blocks_;
+    bool overlap_;
+    std::vector<uint64_t> blocks_;
+    int total_blocks_merged_ = 0;
+    std::unique_ptr<uint8_t[]> ra_temp_buffer_;
+    std::unique_ptr<uint8_t[]> ra_temp_meta_buffer_;
+    BufferSink bufsink_;
+
+    uint64_t total_ra_blocks_completed_ = 0;
+    bool read_ahead_async_ = false;
+    // Queue depth of 8 seems optimal. We don't want
+    // to have a huge depth as it may put more memory pressure
+    // on the kernel worker threads given that we use
+    // IOSQE_ASYNC flag - ASYNC flags can potentially
+    // result in EINTR; Since we don't restart
+    // syscalls and fallback to synchronous I/O, we
+    // don't want huge queue depth
+    int queue_depth_ = 8;
+    std::unique_ptr<struct io_uring> ring_;
+};
+
+}  // namespace snapshot
+}  // namespace android

From 4ac7d0e82ebd7c0f2381ada7fa1a10dc5548c3bf Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 13 Jun 2023 10:40:17 -0700
Subject: [PATCH 0112/1487] snapuserd: Create snapuserd_verify.h.

Bug: N/A
Test: builds
Change-Id: I380bf705520858dbec8053432c0a7c3fa8bed26d
---
 .../user-space-merge/snapuserd_core.cpp       |  4 ++
 .../user-space-merge/snapuserd_core.h         | 33 +---------
 .../user-space-merge/snapuserd_verify.cpp     |  4 +-
 .../user-space-merge/snapuserd_verify.h       | 64 +++++++++++++++++++
 4 files changed, 73 insertions(+), 32 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index c3343b8c642a..8e1212b7b3ce 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -448,5 +448,9 @@ bool SnapshotHandler::IsIouringSupported() {
     return android::base::GetBoolProperty("ro.virtual_ab.io_uring.enabled", false);
 }
 
+bool SnapshotHandler::CheckPartitionVerification() {
+    return update_verify_->CheckPartitionVerification();
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index 79a5bc952abf..c16ad24a5c69 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -47,6 +47,7 @@
 #include <snapuserd/snapuserd_kernel.h>
 #include <storage_literals/storage_literals.h>
 #include "snapuserd_readahead.h"
+#include "snapuserd_verify.h"
 
 namespace android {
 namespace snapshot {
@@ -97,36 +98,6 @@ struct MergeGroupState {
         : merge_state_(state), num_ios_in_progress(n_ios) {}
 };
 
-class UpdateVerify {
-  public:
-    UpdateVerify(const std::string& misc_name);
-    void VerifyUpdatePartition();
-    bool CheckPartitionVerification();
-
-  private:
-    enum class UpdateVerifyState {
-        VERIFY_UNKNOWN,
-        VERIFY_FAILED,
-        VERIFY_SUCCESS,
-    };
-
-    std::string misc_name_;
-    UpdateVerifyState state_;
-    std::mutex m_lock_;
-    std::condition_variable m_cv_;
-
-    int kMinThreadsToVerify = 1;
-    int kMaxThreadsToVerify = 4;
-    uint64_t kThresholdSize = 512_MiB;
-    uint64_t kBlockSizeVerify = 1_MiB;
-
-    bool IsBlockAligned(uint64_t read_size) { return ((read_size & (BLOCK_SZ - 1)) == 0); }
-    void UpdatePartitionVerificationState(UpdateVerifyState state);
-    bool VerifyPartition(const std::string& partition_name, const std::string& dm_block_device);
-    bool VerifyBlocks(const std::string& partition_name, const std::string& dm_block_device,
-                      off_t offset, int skip_blocks, uint64_t dev_sz);
-};
-
 class Worker {
   public:
     Worker(const std::string& cow_device, const std::string& backing_device,
@@ -308,7 +279,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     MERGE_GROUP_STATE ProcessMergingBlock(uint64_t new_block, void* buffer);
 
     bool IsIouringSupported();
-    bool CheckPartitionVerification() { return update_verify_->CheckPartitionVerification(); }
+    bool CheckPartitionVerification();
 
   private:
     bool ReadMetadata();
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp
index 18c1dfcd9288..68173408045b 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp
@@ -14,12 +14,14 @@
  * limitations under the License.
  */
 
-#include "snapuserd_core.h"
+#include "snapuserd_verify.h"
 
 #include <android-base/chrono_utils.h>
 #include <android-base/scopeguard.h>
 #include <android-base/strings.h>
 
+#include "snapuserd_core.h"
+
 namespace android {
 namespace snapshot {
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h
new file mode 100644
index 000000000000..d07d2f836838
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h
@@ -0,0 +1,64 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#pragma once
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include <condition_variable>
+#include <mutex>
+#include <string>
+
+#include <snapuserd/snapuserd_kernel.h>
+#include <storage_literals/storage_literals.h>
+
+namespace android {
+namespace snapshot {
+
+using namespace android::storage_literals;
+
+class UpdateVerify {
+  public:
+    UpdateVerify(const std::string& misc_name);
+    void VerifyUpdatePartition();
+    bool CheckPartitionVerification();
+
+  private:
+    enum class UpdateVerifyState {
+        VERIFY_UNKNOWN,
+        VERIFY_FAILED,
+        VERIFY_SUCCESS,
+    };
+
+    std::string misc_name_;
+    UpdateVerifyState state_;
+    std::mutex m_lock_;
+    std::condition_variable m_cv_;
+
+    int kMinThreadsToVerify = 1;
+    int kMaxThreadsToVerify = 4;
+    uint64_t kThresholdSize = 512_MiB;
+    uint64_t kBlockSizeVerify = 1_MiB;
+
+    bool IsBlockAligned(uint64_t read_size) { return ((read_size & (BLOCK_SZ - 1)) == 0); }
+    void UpdatePartitionVerificationState(UpdateVerifyState state);
+    bool VerifyPartition(const std::string& partition_name, const std::string& dm_block_device);
+    bool VerifyBlocks(const std::string& partition_name, const std::string& dm_block_device,
+                      off_t offset, int skip_blocks, uint64_t dev_sz);
+};
+
+}  // namespace snapshot
+}  // namespace android

From 85f52dd1ac84567dbc817d8015896f9c00c2b671 Mon Sep 17 00:00:00 2001
From: Pawan Wagh <waghpawan@google.com>
Date: Wed, 14 Jun 2023 18:28:17 +0000
Subject: [PATCH 0113/1487] Revert "Treat Microdroid as OS with monolithic
 sepolicy"

Revert submission 2625691

Reason for revert: b/287283650

Reverted changes: /q/submissionid:2625691

Change-Id: Ie62bbb4d4f1af528f42aafde79407b151bab46f9
---
 init/selinux.cpp | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/init/selinux.cpp b/init/selinux.cpp
index a9365323362f..907eb80e31c0 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -300,8 +300,6 @@ bool GetVendorMappingVersion(std::string* plat_vers) {
 }
 
 constexpr const char plat_policy_cil_file[] = "/system/etc/selinux/plat_sepolicy.cil";
-constexpr const char kMicrodroidPrecompiledSepolicy[] =
-        "/system/etc/selinux/microdroid_precompiled_sepolicy";
 
 bool IsSplitPolicyDevice() {
     return access(plat_policy_cil_file, R_OK) != -1;
@@ -499,19 +497,14 @@ bool OpenSplitPolicy(PolicyFile* policy_file) {
 
 bool OpenMonolithicPolicy(PolicyFile* policy_file) {
     static constexpr char kSepolicyFile[] = "/sepolicy";
-    // In Microdroid the precompiled sepolicy is located on /system, since there is no vendor code.
-    // TODO(b/287206497): refactor once we start conditionally compiling init for Microdroid.
-    std::string monolithic_policy_file = access(kMicrodroidPrecompiledSepolicy, R_OK) == 0
-                                                 ? kMicrodroidPrecompiledSepolicy
-                                                 : kSepolicyFile;
-
-    LOG(INFO) << "Opening SELinux policy from monolithic file " << monolithic_policy_file;
-    policy_file->fd.reset(open(monolithic_policy_file.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
+
+    LOG(VERBOSE) << "Opening SELinux policy from monolithic file";
+    policy_file->fd.reset(open(kSepolicyFile, O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
     if (policy_file->fd < 0) {
         PLOG(ERROR) << "Failed to open monolithic SELinux policy";
         return false;
     }
-    policy_file->path = monolithic_policy_file;
+    policy_file->path = kSepolicyFile;
     return true;
 }
 

From 5eae2cb4508282b1ae8f7f376a07645c650557d0 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 9 May 2023 13:27:22 -0700
Subject: [PATCH 0114/1487] libsnapshot: Remove ISnapshotWriter.

This only added one real method to ICowWriter, so let's just fold it
into ICowWriter. CompressedSnapshotWriter goes away as well.
CompressedSnapshotReader is now part of libsnapshot_cow.

Bug: 280529365
Test: m otapackage
      apply ota
Change-Id: I55358c3c9be111d5aee1a0c22c29cb1539d05494
---
 fs_mgr/libsnapshot/Android.bp                 |   9 +-
 .../include/libsnapshot/cow_reader.h          |   9 +-
 .../include/libsnapshot/cow_writer.h          |  13 ++
 ...ck_snapshot_writer.h => mock_cow_writer.h} |  16 +-
 .../include/libsnapshot/mock_snapshot.h       |   4 +-
 .../include/libsnapshot/snapshot.h            |  28 ++-
 .../include/libsnapshot/snapshot_stub.h       |   4 +-
 .../include/libsnapshot/snapshot_writer.h     |  93 ---------
 .../include_test/libsnapshot/test_helpers.h   |   2 +-
 .../{ => libsnapshot_cow}/snapshot_reader.cpp |  86 +++------
 .../{ => libsnapshot_cow}/snapshot_reader.h   |  32 +---
 .../snapshot_reader_test.cpp                  |  19 +-
 .../libsnapshot_cow/writer_base.cpp           |  32 ++++
 .../libsnapshot/libsnapshot_cow/writer_base.h |   3 +
 fs_mgr/libsnapshot/snapshot.cpp               |  40 ++--
 fs_mgr/libsnapshot/snapshot_stub.cpp          |   4 +-
 fs_mgr/libsnapshot/snapshot_test.cpp          |  28 +--
 fs_mgr/libsnapshot/snapshot_writer.cpp        | 179 ------------------
 fs_mgr/libsnapshot/snapshot_writer_test.cpp   |  62 ------
 fs_mgr/libsnapshot/snapshotctl.cpp            |   7 +-
 fs_mgr/libsnapshot/test_helpers.cpp           |   7 +-
 21 files changed, 158 insertions(+), 519 deletions(-)
 rename fs_mgr/libsnapshot/include/libsnapshot/{mock_snapshot_writer.h => mock_cow_writer.h} (75%)
 delete mode 100644 fs_mgr/libsnapshot/include/libsnapshot/snapshot_writer.h
 rename fs_mgr/libsnapshot/{ => libsnapshot_cow}/snapshot_reader.cpp (83%)
 rename fs_mgr/libsnapshot/{ => libsnapshot_cow}/snapshot_reader.h (69%)
 rename fs_mgr/libsnapshot/{ => libsnapshot_cow}/snapshot_reader_test.cpp (92%)
 delete mode 100644 fs_mgr/libsnapshot/snapshot_writer.cpp
 delete mode 100644 fs_mgr/libsnapshot/snapshot_writer_test.cpp

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index e931bec39ff0..046d30cc9a16 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -85,11 +85,9 @@ filegroup {
         "android/snapshot/snapshot.proto",
         "device_info.cpp",
         "snapshot.cpp",
-        "snapshot_reader.cpp",
         "snapshot_stats.cpp",
         "snapshot_stub.cpp",
         "snapshot_metadata_updater.cpp",
-        "snapshot_writer.cpp",
         "partition_cow_creator.cpp",
         "return.cpp",
         "utility.cpp",
@@ -165,6 +163,9 @@ cc_defaults {
         "liblz4",
         "libzstd",
     ],
+    header_libs: [
+        "libupdate_engine_headers",
+    ],
     export_include_dirs: ["include"],
 }
 
@@ -179,6 +180,7 @@ cc_library_static {
         "libsnapshot_cow/cow_format.cpp",
         "libsnapshot_cow/cow_reader.cpp",
         "libsnapshot_cow/parser_v2.cpp",
+        "libsnapshot_cow/snapshot_reader.cpp",
         "libsnapshot_cow/writer_base.cpp",
         "libsnapshot_cow/writer_v2.cpp",
     ],
@@ -224,9 +226,7 @@ cc_defaults {
     srcs: [
         "partition_cow_creator_test.cpp",
         "snapshot_metadata_updater_test.cpp",
-        "snapshot_reader_test.cpp",
         "snapshot_test.cpp",
-        "snapshot_writer_test.cpp",
     ],
     shared_libs: [
         "libbinder",
@@ -372,6 +372,7 @@ cc_test {
         "libsnapshot_cow_defaults",
     ],
     srcs: [
+        "libsnapshot_cow/snapshot_reader_test.cpp",
         "libsnapshot_cow/test_v2.cpp",
     ],
     cflags: [
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index 95a1270f996a..3890b175434a 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -24,6 +24,10 @@
 #include <android-base/unique_fd.h>
 #include <libsnapshot/cow_format.h>
 
+namespace chromeos_update_engine {
+class FileDescriptor;
+}  // namespace chromeos_update_engine
+
 namespace android {
 namespace snapshot {
 
@@ -32,6 +36,8 @@ class ICowOpIter;
 // Interface for reading from a snapuserd COW.
 class ICowReader {
   public:
+    using FileDescriptor = chromeos_update_engine::FileDescriptor;
+
     virtual ~ICowReader() {}
 
     // Return the file header.
@@ -109,10 +115,9 @@ class CowReader final : public ICowReader {
     bool Parse(android::base::borrowed_fd fd, std::optional<uint64_t> label = {});
 
     bool InitForMerge(android::base::unique_fd&& fd);
-    bool VerifyMergeOps() override;
 
+    bool VerifyMergeOps() override;
     bool GetFooter(CowFooter* footer) override;
-
     bool GetLastLabel(uint64_t* label) override;
 
     // Create a CowOpIter object which contains footer_.num_ops
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index af2d3efc521a..d6194eb9396f 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -61,6 +61,8 @@ struct CowOptions {
 // will occur in the sequence they were added to the COW.
 class ICowWriter {
   public:
+    using FileDescriptor = chromeos_update_engine::FileDescriptor;
+
     virtual ~ICowWriter() {}
 
     // Encode an operation that copies the contents of |old_block| to the
@@ -93,6 +95,17 @@ class ICowWriter {
 
     virtual uint32_t GetBlockSize() const = 0;
     virtual std::optional<uint32_t> GetMaxBlocks() const = 0;
+
+    // Open an ICowReader for this writer. The reader will be a snapshot of the
+    // current operations in the writer; new writes after OpenReader() will not
+    // be reflected.
+    virtual std::unique_ptr<ICowReader> OpenReader() = 0;
+
+    // Open a file descriptor. This allows reading and seeing through the cow
+    // as if it were a normal file. The optional source_device must be a valid
+    // path if the CowReader contains any copy or xor operations.
+    virtual std::unique_ptr<FileDescriptor> OpenFileDescriptor(
+            const std::optional<std::string>& source_device) = 0;
 };
 
 class CompressWorker {
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/mock_cow_writer.h
similarity index 75%
rename from fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot_writer.h
rename to fs_mgr/libsnapshot/include/libsnapshot/mock_cow_writer.h
index 52e3a9c4eb34..c58c6542aa21 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/mock_cow_writer.h
@@ -15,17 +15,16 @@
 //
 
 #include <gmock/gmock.h>
-#include <libsnapshot/snapshot_writer.h>
+#include <libsnapshot/cow_writer.h>
 
 namespace android::snapshot {
 
-class MockSnapshotWriter : public ISnapshotWriter {
+class MockCowWriter : public ICowWriter {
   public:
-    using FileDescriptor = ISnapshotWriter::FileDescriptor;
+    using FileDescriptor = chromeos_update_engine::FileDescriptor;
 
     MOCK_METHOD(bool, Finalize, (), (override));
 
-    // Return number of bytes the cow image occupies on disk.
     MOCK_METHOD(uint64_t, GetCowSize, (), (override));
 
     MOCK_METHOD(bool, AddCopy, (uint64_t, uint64_t, uint64_t), (override));
@@ -35,11 +34,12 @@ class MockSnapshotWriter : public ISnapshotWriter {
     MOCK_METHOD(bool, AddZeroBlocks, (uint64_t, uint64_t), (override));
     MOCK_METHOD(bool, AddLabel, (uint64_t), (override));
     MOCK_METHOD(bool, AddSequenceData, (size_t, const uint32_t*), (override));
-    MOCK_METHOD(bool, Initialize, (), (override));
-    MOCK_METHOD(bool, InitializeAppend, (uint64_t), (override));
-    MOCK_METHOD(bool, VerifyMergeOps, (), (override, const, noexcept));
-    MOCK_METHOD(std::unique_ptr<FileDescriptor>, OpenReader, (), (override));
     MOCK_METHOD(uint32_t, GetBlockSize, (), (override, const));
     MOCK_METHOD(std::optional<uint32_t>, GetMaxBlocks, (), (override, const));
+
+    MOCK_METHOD(std::unique_ptr<ICowReader>, OpenReader, (), (override));
+    MOCK_METHOD(std::unique_ptr<FileDescriptor>, OpenFileDescriptor,
+                (const std::optional<std::string>&), (override));
 };
+
 }  // namespace android::snapshot
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot.h
index d458b8718b8d..ca45d2fad88f 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot.h
@@ -42,9 +42,9 @@ class MockSnapshotManager : public ISnapshotManager {
                 (const android::fs_mgr::CreateLogicalPartitionParams& params,
                  std::string* snapshot_path),
                 (override));
-    MOCK_METHOD(std::unique_ptr<ISnapshotWriter>, OpenSnapshotWriter,
+    MOCK_METHOD(std::unique_ptr<ICowWriter>, OpenSnapshotWriter,
                 (const android::fs_mgr::CreateLogicalPartitionParams& params,
-                 const std::optional<std::string>&),
+                 std::optional<uint64_t>),
                 (override));
     MOCK_METHOD(bool, UnmapUpdateSnapshot, (const std::string& target_partition_name), (override));
     MOCK_METHOD(bool, NeedSnapshotsInFirstStageMount, (), (override));
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index ecf1d1531710..df532ee2152a 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -33,12 +33,11 @@
 #include <libfiemap/image_manager.h>
 #include <liblp/builder.h>
 #include <liblp/liblp.h>
-#include <update_engine/update_metadata.pb.h>
-
 #include <libsnapshot/auto_device.h>
+#include <libsnapshot/cow_writer.h>
 #include <libsnapshot/return.h>
-#include <libsnapshot/snapshot_writer.h>
 #include <snapuserd/snapuserd_client.h>
+#include <update_engine/update_metadata.pb.h>
 
 #ifndef FRIEND_TEST
 #define FRIEND_TEST(test_set_name, individual_test) \
@@ -211,16 +210,13 @@ class ISnapshotManager {
     virtual bool MapUpdateSnapshot(const android::fs_mgr::CreateLogicalPartitionParams& params,
                                    std::string* snapshot_path) = 0;
 
-    // Create an ISnapshotWriter to build a snapshot against a target partition. The partition name
+    // Create an ICowWriter to build a snapshot against a target partition. The partition name
     // must be suffixed. If a source partition exists, it must be specified as well. The source
     // partition will only be used if raw bytes are needed. The source partition should be an
     // absolute path to the device, not a partition name.
-    //
-    // After calling OpenSnapshotWriter, the caller must invoke Initialize or InitializeForAppend
-    // before invoking write operations.
-    virtual std::unique_ptr<ISnapshotWriter> OpenSnapshotWriter(
+    virtual std::unique_ptr<ICowWriter> OpenSnapshotWriter(
             const android::fs_mgr::CreateLogicalPartitionParams& params,
-            const std::optional<std::string>& source_device) = 0;
+            std::optional<uint64_t> label = {}) = 0;
 
     // Unmap a snapshot device or CowWriter that was previously opened with MapUpdateSnapshot,
     // OpenSnapshotWriter. All outstanding open descriptors, writers, or
@@ -362,9 +358,9 @@ class SnapshotManager final : public ISnapshotManager {
     Return CreateUpdateSnapshots(const DeltaArchiveManifest& manifest) override;
     bool MapUpdateSnapshot(const CreateLogicalPartitionParams& params,
                            std::string* snapshot_path) override;
-    std::unique_ptr<ISnapshotWriter> OpenSnapshotWriter(
+    std::unique_ptr<ICowWriter> OpenSnapshotWriter(
             const android::fs_mgr::CreateLogicalPartitionParams& params,
-            const std::optional<std::string>& source_device) override;
+            std::optional<uint64_t> label) override;
     bool UnmapUpdateSnapshot(const std::string& target_partition_name) override;
     bool NeedSnapshotsInFirstStageMount() override;
     bool CreateLogicalAndSnapshotPartitions(
@@ -693,10 +689,10 @@ class SnapshotManager final : public ISnapshotManager {
     };
 
     // Helpers for OpenSnapshotWriter.
-    std::unique_ptr<ISnapshotWriter> OpenCompressedSnapshotWriter(
-            LockedFile* lock, const std::optional<std::string>& source_device,
-            const std::string& partition_name, const SnapshotStatus& status,
-            const SnapshotPaths& paths);
+    std::unique_ptr<ICowWriter> OpenCompressedSnapshotWriter(LockedFile* lock,
+                                                             const SnapshotStatus& status,
+                                                             const SnapshotPaths& paths,
+                                                             std::optional<uint64_t> label);
 
     // Map the base device, COW devices, and snapshot device.
     bool MapPartitionWithSnapshot(LockedFile* lock, CreateLogicalPartitionParams params,
@@ -743,7 +739,7 @@ class SnapshotManager final : public ISnapshotManager {
     // Initialize snapshots so that they can be mapped later.
     // Map the COW partition and zero-initialize the header.
     Return InitializeUpdateSnapshots(
-            LockedFile* lock, MetadataBuilder* target_metadata,
+            LockedFile* lock, uint32_t cow_version, MetadataBuilder* target_metadata,
             const LpMetadata* exported_target_metadata, const std::string& target_suffix,
             const std::map<std::string, SnapshotStatus>& all_snapshot_status);
 
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot_stub.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot_stub.h
index 171c7c6f96c9..1c9b40368eb0 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot_stub.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot_stub.h
@@ -40,9 +40,9 @@ class SnapshotManagerStub : public ISnapshotManager {
             const chromeos_update_engine::DeltaArchiveManifest& manifest) override;
     bool MapUpdateSnapshot(const android::fs_mgr::CreateLogicalPartitionParams& params,
                            std::string* snapshot_path) override;
-    std::unique_ptr<ISnapshotWriter> OpenSnapshotWriter(
+    std::unique_ptr<ICowWriter> OpenSnapshotWriter(
             const android::fs_mgr::CreateLogicalPartitionParams& params,
-            const std::optional<std::string>& source_device) override;
+            std::optional<uint64_t> label) override;
     bool UnmapUpdateSnapshot(const std::string& target_partition_name) override;
     bool NeedSnapshotsInFirstStageMount() override;
     bool CreateLogicalAndSnapshotPartitions(
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot_writer.h
deleted file mode 100644
index 2653a6053026..000000000000
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot_writer.h
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright (C) 2020 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <optional>
-
-#include <android-base/unique_fd.h>
-
-#include <libsnapshot/cow_writer.h>
-
-namespace chromeos_update_engine {
-class FileDescriptor;
-}  // namespace chromeos_update_engine
-
-namespace android {
-namespace snapshot {
-
-class ISnapshotWriter : public ICowWriter {
-  public:
-    using FileDescriptor = chromeos_update_engine::FileDescriptor;
-
-    virtual ~ISnapshotWriter() {}
-
-    // Open the writer in write mode (no append).
-    virtual bool Initialize() = 0;
-
-    // Open the writer in append mode, with the last label to resume
-    // from. See CowWriter::InitializeAppend.
-    virtual bool InitializeAppend(uint64_t label) = 0;
-
-    virtual std::unique_ptr<FileDescriptor> OpenReader() = 0;
-
-    virtual bool VerifyMergeOps() const noexcept = 0;
-};
-
-// Send writes to a COW or a raw device directly, based on a threshold.
-class CompressedSnapshotWriter final : public ISnapshotWriter {
-  public:
-    CompressedSnapshotWriter(const CowOptions& options);
-
-    void SetSourceDevice(const std::string& source_device);
-
-    // Sets the COW device; this is required.
-    bool SetCowDevice(android::base::unique_fd&& cow_device);
-
-    bool Initialize() override;
-    bool InitializeAppend(uint64_t label) override;
-    bool Finalize() override;
-    uint64_t GetCowSize() override;
-    uint32_t GetBlockSize() const override;
-    std::optional<uint32_t> GetMaxBlocks() const override;
-    std::unique_ptr<FileDescriptor> OpenReader() override;
-    bool VerifyMergeOps() const noexcept;
-
-    bool AddCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) override;
-    bool AddRawBlocks(uint64_t new_block_start, const void* data, size_t size) override;
-    bool AddXorBlocks(uint32_t new_block_start, const void* data, size_t size, uint32_t old_block,
-                      uint16_t offset) override;
-    bool AddZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) override;
-    bool AddLabel(uint64_t label) override;
-    bool AddSequenceData(size_t num_ops, const uint32_t* data) override;
-
-  private:
-    std::unique_ptr<CowReader> OpenCowReader() const;
-    android::base::borrowed_fd GetSourceFd();
-
-    CowOptions options_;
-
-    // Set the source device. This is used for AddCopy() operations, if the
-    // underlying writer needs the original bytes (for example if backed by
-    // dm-snapshot or if writing directly to an unsnapshotted region). The
-    // device is only opened on the first operation that requires it.
-    std::optional<std::string> source_device_;
-    android::base::unique_fd source_fd_;
-
-    android::base::unique_fd cow_device_;
-    std::unique_ptr<ICowWriter> cow_;
-};
-
-}  // namespace snapshot
-}  // namespace android
diff --git a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
index f45d4ed2abde..5e9f049d178a 100644
--- a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
+++ b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
@@ -198,7 +198,7 @@ void DeleteBackingImage(android::fiemap::IImageManager* manager, const std::stri
 // Expect space of |path| is multiple of 4K.
 bool WriteRandomData(const std::string& path, std::optional<size_t> expect_size = std::nullopt,
                      std::string* hash = nullptr);
-std::string HashSnapshot(ISnapshotWriter* writer);
+std::string HashSnapshot(ICowWriter::FileDescriptor* writer);
 
 std::string ToHexString(const uint8_t* buf, size_t len);
 
diff --git a/fs_mgr/libsnapshot/snapshot_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
similarity index 83%
rename from fs_mgr/libsnapshot/snapshot_reader.cpp
rename to fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
index 4e75ba75449f..f9cdbc0febf9 100644
--- a/fs_mgr/libsnapshot/snapshot_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
@@ -18,73 +18,24 @@
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
-#include <ext4_utils/ext4_utils.h>
 
 namespace android {
 namespace snapshot {
 
 using android::base::borrowed_fd;
 
-// Not supported.
-bool ReadOnlyFileDescriptor::Open(const char*, int, mode_t) {
-    errno = EINVAL;
-    return false;
-}
-
-bool ReadOnlyFileDescriptor::Open(const char*, int) {
-    errno = EINVAL;
-    return false;
-}
-
-ssize_t ReadOnlyFileDescriptor::Write(const void*, size_t) {
-    errno = EINVAL;
-    return false;
-}
-
-bool ReadOnlyFileDescriptor::BlkIoctl(int, uint64_t, uint64_t, int*) {
-    errno = EINVAL;
-    return false;
-}
-
-ReadFdFileDescriptor::ReadFdFileDescriptor(android::base::unique_fd&& fd) : fd_(std::move(fd)) {}
-
-ssize_t ReadFdFileDescriptor::Read(void* buf, size_t count) {
-    return read(fd_.get(), buf, count);
-}
-
-off64_t ReadFdFileDescriptor::Seek(off64_t offset, int whence) {
-    return lseek(fd_.get(), offset, whence);
-}
-
-uint64_t ReadFdFileDescriptor::BlockDevSize() {
-    return get_block_device_size(fd_.get());
-}
-
-bool ReadFdFileDescriptor::Close() {
-    fd_ = {};
-    return true;
-}
-
-bool ReadFdFileDescriptor::IsSettingErrno() {
-    return true;
-}
-
-bool ReadFdFileDescriptor::IsOpen() {
-    return fd_ >= 0;
-}
-
-bool ReadFdFileDescriptor::Flush() {
-    return true;
-}
-
-bool CompressedSnapshotReader::SetCow(std::unique_ptr<CowReader>&& cow) {
-    cow_ = std::move(cow);
-
+CompressedSnapshotReader::CompressedSnapshotReader(std::unique_ptr<ICowReader>&& cow,
+                                                   const std::optional<std::string>& source_device,
+                                                   std::optional<uint64_t> block_dev_size)
+    : cow_(std::move(cow)),
+      block_size_(cow_->GetHeader().block_size),
+      source_device_(source_device),
+      block_device_size_(block_dev_size.value_or(0)) {
     const auto& header = cow_->GetHeader();
     block_size_ = header.block_size;
 
     // Populate the operation map.
-    op_iter_ = cow_->GetOpIter();
+    op_iter_ = cow_->GetOpIter(false);
     while (!op_iter_->AtEnd()) {
         const CowOperation* op = op_iter_->Get();
         if (IsMetadataOp(*op)) {
@@ -97,16 +48,27 @@ bool CompressedSnapshotReader::SetCow(std::unique_ptr<CowReader>&& cow) {
         ops_[op->new_block] = op;
         op_iter_->Next();
     }
+}
 
-    return true;
+// Not supported.
+bool CompressedSnapshotReader::Open(const char*, int, mode_t) {
+    errno = EINVAL;
+    return false;
+}
+
+bool CompressedSnapshotReader::Open(const char*, int) {
+    errno = EINVAL;
+    return false;
 }
 
-void CompressedSnapshotReader::SetSourceDevice(const std::string& source_device) {
-    source_device_ = {source_device};
+ssize_t CompressedSnapshotReader::Write(const void*, size_t) {
+    errno = EINVAL;
+    return false;
 }
 
-void CompressedSnapshotReader::SetBlockDeviceSize(uint64_t block_device_size) {
-    block_device_size_ = block_device_size;
+bool CompressedSnapshotReader::BlkIoctl(int, uint64_t, uint64_t, int*) {
+    errno = EINVAL;
+    return false;
 }
 
 borrowed_fd CompressedSnapshotReader::GetSourceFd() {
diff --git a/fs_mgr/libsnapshot/snapshot_reader.h b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.h
similarity index 69%
rename from fs_mgr/libsnapshot/snapshot_reader.h
rename to fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.h
index 5e19c62ce385..3de63ed197d1 100644
--- a/fs_mgr/libsnapshot/snapshot_reader.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.h
@@ -26,36 +26,16 @@
 namespace android {
 namespace snapshot {
 
-class ReadOnlyFileDescriptor : public chromeos_update_engine::FileDescriptor {
+class CompressedSnapshotReader : public chromeos_update_engine::FileDescriptor {
   public:
+    CompressedSnapshotReader(std::unique_ptr<ICowReader>&& cow,
+                             const std::optional<std::string>& source_device,
+                             std::optional<uint64_t> block_dev_size);
+
     bool Open(const char* path, int flags, mode_t mode) override;
     bool Open(const char* path, int flags) override;
     ssize_t Write(const void* buf, size_t count) override;
     bool BlkIoctl(int request, uint64_t start, uint64_t length, int* result) override;
-};
-
-class ReadFdFileDescriptor : public ReadOnlyFileDescriptor {
-  public:
-    explicit ReadFdFileDescriptor(android::base::unique_fd&& fd);
-
-    ssize_t Read(void* buf, size_t count) override;
-    off64_t Seek(off64_t offset, int whence) override;
-    uint64_t BlockDevSize() override;
-    bool Close() override;
-    bool IsSettingErrno() override;
-    bool IsOpen() override;
-    bool Flush() override;
-
-  private:
-    android::base::unique_fd fd_;
-};
-
-class CompressedSnapshotReader : public ReadOnlyFileDescriptor {
-  public:
-    bool SetCow(std::unique_ptr<CowReader>&& cow);
-    void SetSourceDevice(const std::string& source_device);
-    void SetBlockDeviceSize(uint64_t block_device_size);
-
     ssize_t Read(void* buf, size_t count) override;
     off64_t Seek(off64_t offset, int whence) override;
     uint64_t BlockDevSize() override;
@@ -68,7 +48,7 @@ class CompressedSnapshotReader : public ReadOnlyFileDescriptor {
     ssize_t ReadBlock(uint64_t chunk, size_t start_offset, void* buffer, size_t size);
     android::base::borrowed_fd GetSourceFd();
 
-    std::unique_ptr<CowReader> cow_;
+    std::unique_ptr<ICowReader> cow_;
     std::unique_ptr<ICowOpIter> op_iter_;
     uint32_t block_size_ = 0;
 
diff --git a/fs_mgr/libsnapshot/snapshot_reader_test.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader_test.cpp
similarity index 92%
rename from fs_mgr/libsnapshot/snapshot_reader_test.cpp
rename to fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader_test.cpp
index f25023d817a6..10cb06d7eeea 100644
--- a/fs_mgr/libsnapshot/snapshot_reader_test.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader_test.cpp
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <libsnapshot/snapshot.h>
-
 #include <unordered_set>
 
 #include <android-base/file.h>
@@ -61,7 +59,7 @@ class OfflineSnapshotTest : public ::testing::Test {
         ASSERT_EQ(fsync(base_->fd), 0);
     }
 
-    void WriteCow(ISnapshotWriter* writer) {
+    void WriteCow(ICowWriter* writer) {
         std::string new_block = MakeNewBlockString();
         std::string xor_block = MakeXorBlockString();
 
@@ -72,8 +70,8 @@ class OfflineSnapshotTest : public ::testing::Test {
         ASSERT_TRUE(writer->Finalize());
     }
 
-    void TestBlockReads(ISnapshotWriter* writer) {
-        auto reader = writer->OpenReader();
+    void TestBlockReads(ICowWriter* writer) {
+        auto reader = writer->OpenFileDescriptor(base_->path);
         ASSERT_NE(reader, nullptr);
 
         // Test that unchanged blocks are not modified.
@@ -117,8 +115,8 @@ class OfflineSnapshotTest : public ::testing::Test {
         ASSERT_EQ(two_blocks, zeroes);
     }
 
-    void TestByteReads(ISnapshotWriter* writer) {
-        auto reader = writer->OpenReader();
+    void TestByteReads(ICowWriter* writer) {
+        auto reader = writer->OpenFileDescriptor(base_->path);
         ASSERT_NE(reader, nullptr);
 
         std::string blob(kBlockSize * 3, 'x');
@@ -154,7 +152,7 @@ class OfflineSnapshotTest : public ::testing::Test {
         ASSERT_EQ(got, expected);
     }
 
-    void TestReads(ISnapshotWriter* writer) {
+    void TestReads(ICowWriter* writer) {
         ASSERT_NO_FATAL_FAILURE(TestBlockReads(writer));
         ASSERT_NO_FATAL_FAILURE(TestByteReads(writer));
     }
@@ -186,10 +184,7 @@ TEST_F(OfflineSnapshotTest, CompressedSnapshot) {
     unique_fd cow_fd(dup(cow_->fd));
     ASSERT_GE(cow_fd, 0);
 
-    auto writer = std::make_unique<CompressedSnapshotWriter>(options);
-    writer->SetSourceDevice(base_->path);
-    ASSERT_TRUE(writer->SetCowDevice(std::move(cow_fd)));
-    ASSERT_TRUE(writer->Initialize());
+    auto writer = CreateCowWriter(kDefaultCowVersion, options, std::move(cow_fd));
     ASSERT_NO_FATAL_FAILURE(WriteCow(writer.get()));
     ASSERT_NO_FATAL_FAILURE(TestReads(writer.get()));
 }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.cpp
index 22e63d0a323d..ff34c597b34b 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.cpp
@@ -21,6 +21,7 @@
 #include <unistd.h>
 
 #include <android-base/logging.h>
+#include "snapshot_reader.h"
 
 // The info messages here are spammy, but as useful for update_engine. Disable
 // them when running on the host.
@@ -159,5 +160,36 @@ bool CowWriterBase::ValidateNewBlock(uint64_t new_block) {
     return true;
 }
 
+std::unique_ptr<ICowReader> CowWriterBase::OpenReader() {
+    unique_fd cow_fd(fcntl(fd_.get(), F_DUPFD | F_DUPFD_CLOEXEC, 0));
+    if (cow_fd < 0) {
+        PLOG(ERROR) << "CowWriterV2::OpenReander: dup COW device";
+        return nullptr;
+    }
+
+    auto cow = std::make_unique<CowReader>();
+    if (!cow->Parse(std::move(cow_fd))) {
+        LOG(ERROR) << "CowWriterV2::OpenReader: unable to read COW";
+        return nullptr;
+    }
+    return cow;
+}
+
+std::unique_ptr<chromeos_update_engine::FileDescriptor> CowWriterBase::OpenFileDescriptor(
+        const std::optional<std::string>& source_device) {
+    auto reader = OpenReader();
+    if (!reader) {
+        return nullptr;
+    }
+
+    std::optional<uint64_t> block_dev_size;
+    if (options_.max_blocks) {
+        block_dev_size = {*options_.max_blocks * options_.block_size};
+    }
+
+    return std::make_unique<CompressedSnapshotReader>(std::move(reader), source_device,
+                                                      block_dev_size);
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
index 8fa90656fe6b..c8b477275822 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
@@ -43,6 +43,9 @@ class CowWriterBase : public ICowWriter {
     bool AddSequenceData(size_t num_ops, const uint32_t* data) override;
     uint32_t GetBlockSize() const override { return options_.block_size; }
     std::optional<uint32_t> GetMaxBlocks() const override { return options_.max_blocks; }
+    std::unique_ptr<ICowReader> OpenReader() override;
+    std::unique_ptr<FileDescriptor> OpenFileDescriptor(
+            const std::optional<std::string>& source_device) override;
 
     const CowOptions& options() const { return options_; }
 
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 5920bc22fa8c..fbea79b4ad9b 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -45,10 +45,9 @@
 #include <android/snapshot/snapshot.pb.h>
 #include <libsnapshot/snapshot_stats.h>
 #include "device_info.h"
-#include "libsnapshot_cow/writer_v2.h"
+#include "libsnapshot_cow/parser_v2.h"
 #include "partition_cow_creator.h"
 #include "snapshot_metadata_updater.h"
-#include "snapshot_reader.h"
 #include "utility.h"
 
 namespace android {
@@ -3288,7 +3287,7 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
         return Return::Error();
     }
 
-    ret = InitializeUpdateSnapshots(lock.get(), target_metadata.get(),
+    ret = InitializeUpdateSnapshots(lock.get(), dap_metadata.cow_version(), target_metadata.get(),
                                     exported_target_metadata.get(), target_suffix,
                                     all_snapshot_status);
     if (!ret.is_ok()) return ret;
@@ -3510,7 +3509,7 @@ Return SnapshotManager::CreateUpdateSnapshotsInternal(
 }
 
 Return SnapshotManager::InitializeUpdateSnapshots(
-        LockedFile* lock, MetadataBuilder* target_metadata,
+        LockedFile* lock, uint32_t cow_version, MetadataBuilder* target_metadata,
         const LpMetadata* exported_target_metadata, const std::string& target_suffix,
         const std::map<std::string, SnapshotStatus>& all_snapshot_status) {
     CHECK(lock);
@@ -3558,8 +3557,8 @@ Return SnapshotManager::InitializeUpdateSnapshots(
             }
             options.compression = it->second.compression_algorithm();
 
-            CowWriterV2 writer(options, std::move(fd));
-            if (!writer.Initialize(std::nullopt) || !writer.Finalize()) {
+            auto writer = CreateCowWriter(cow_version, options, std::move(fd));
+            if (!writer->Finalize()) {
                 LOG(ERROR) << "Could not initialize COW device for " << target_partition->name();
                 return Return::Error();
             }
@@ -3609,12 +3608,12 @@ bool SnapshotManager::MapUpdateSnapshot(const CreateLogicalPartitionParams& para
     return true;
 }
 
-std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenSnapshotWriter(
+std::unique_ptr<ICowWriter> SnapshotManager::OpenSnapshotWriter(
         const android::fs_mgr::CreateLogicalPartitionParams& params,
-        const std::optional<std::string>& source_device) {
+        std::optional<uint64_t> label) {
 #if defined(LIBSNAPSHOT_NO_COW_WRITE)
     (void)params;
-    (void)source_device;
+    (void)label;
 
     LOG(ERROR) << "Snapshots cannot be written in first-stage init or recovery";
     return nullptr;
@@ -3653,16 +3652,14 @@ std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenSnapshotWriter(
         return nullptr;
     }
 
-    return OpenCompressedSnapshotWriter(lock.get(), source_device, params.GetPartitionName(),
-                                        status, paths);
+    return OpenCompressedSnapshotWriter(lock.get(), status, paths, label);
 #endif
 }
 
 #if !defined(LIBSNAPSHOT_NO_COW_WRITE)
-std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenCompressedSnapshotWriter(
-        LockedFile* lock, const std::optional<std::string>& source_device,
-        [[maybe_unused]] const std::string& partition_name, const SnapshotStatus& status,
-        const SnapshotPaths& paths) {
+std::unique_ptr<ICowWriter> SnapshotManager::OpenCompressedSnapshotWriter(
+        LockedFile* lock, const SnapshotStatus& status, const SnapshotPaths& paths,
+        std::optional<uint64_t> label) {
     CHECK(lock);
 
     CowOptions cow_options;
@@ -3679,11 +3676,6 @@ std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenCompressedSnapshotWriter(
     // never creates this scenario.
     CHECK(status.snapshot_size() == status.device_size());
 
-    auto writer = std::make_unique<CompressedSnapshotWriter>(cow_options);
-    if (source_device) {
-        writer->SetSourceDevice(*source_device);
-    }
-
     std::string cow_path;
     if (!GetMappedImageDevicePath(paths.cow_device_name, &cow_path)) {
         LOG(ERROR) << "Could not determine path for " << paths.cow_device_name;
@@ -3695,12 +3687,14 @@ std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenCompressedSnapshotWriter(
         PLOG(ERROR) << "OpenCompressedSnapshotWriter: open " << cow_path;
         return nullptr;
     }
-    if (!writer->SetCowDevice(std::move(cow_fd))) {
-        LOG(ERROR) << "Could not create COW writer from " << cow_path;
+
+    CowHeader header;
+    if (!ReadCowHeader(cow_fd, &header)) {
+        LOG(ERROR) << "OpenCompressedSnapshotWriter: read header failed";
         return nullptr;
     }
 
-    return writer;
+    return CreateCowWriter(header.prefix.major_version, cow_options, std::move(cow_fd), label);
 }
 #endif  // !defined(LIBSNAPSHOT_NO_COW_WRITE)
 
diff --git a/fs_mgr/libsnapshot/snapshot_stub.cpp b/fs_mgr/libsnapshot/snapshot_stub.cpp
index 84e2226fa888..93541020e51a 100644
--- a/fs_mgr/libsnapshot/snapshot_stub.cpp
+++ b/fs_mgr/libsnapshot/snapshot_stub.cpp
@@ -154,8 +154,8 @@ ISnapshotMergeStats* SnapshotManagerStub::GetSnapshotMergeStatsInstance() {
     return &snapshot_merge_stats;
 }
 
-std::unique_ptr<ISnapshotWriter> SnapshotManagerStub::OpenSnapshotWriter(
-        const CreateLogicalPartitionParams&, const std::optional<std::string>&) {
+std::unique_ptr<ICowWriter> SnapshotManagerStub::OpenSnapshotWriter(
+        const CreateLogicalPartitionParams&, std::optional<uint64_t>) {
     LOG(ERROR) << __FUNCTION__ << " should never be called.";
     return nullptr;
 }
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index dac1b771b83d..0a85489bd7eb 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -345,7 +345,7 @@ class SnapshotTest : public ::testing::Test {
     }
 
     AssertionResult MapUpdateSnapshot(const std::string& name,
-                                      std::unique_ptr<ISnapshotWriter>* writer) {
+                                      std::unique_ptr<ICowWriter>* writer) {
         TestPartitionOpener opener(fake_super);
         CreateLogicalPartitionParams params{
                 .block_device = fake_super,
@@ -355,14 +355,10 @@ class SnapshotTest : public ::testing::Test {
                 .partition_opener = &opener,
         };
 
-        auto old_partition = "/dev/block/mapper/" + GetOtherPartitionName(name);
-        auto result = sm->OpenSnapshotWriter(params, {old_partition});
+        auto result = sm->OpenSnapshotWriter(params, {});
         if (!result) {
             return AssertionFailure() << "Cannot open snapshot for writing: " << name;
         }
-        if (!result->Initialize()) {
-            return AssertionFailure() << "Cannot initialize snapshot for writing: " << name;
-        }
 
         if (writer) {
             *writer = std::move(result);
@@ -440,7 +436,7 @@ class SnapshotTest : public ::testing::Test {
 
     // Prepare A/B slot for a partition named "test_partition".
     AssertionResult PrepareOneSnapshot(uint64_t device_size,
-                                       std::unique_ptr<ISnapshotWriter>* writer = nullptr) {
+                                       std::unique_ptr<ICowWriter>* writer = nullptr) {
         lock_ = nullptr;
 
         DeltaArchiveManifest manifest;
@@ -651,7 +647,7 @@ TEST_F(SnapshotTest, Merge) {
 
     bool userspace_snapshots = false;
     if (snapuserd_required_) {
-        std::unique_ptr<ISnapshotWriter> writer;
+        std::unique_ptr<ICowWriter> writer;
         ASSERT_TRUE(PrepareOneSnapshot(kDeviceSize, &writer));
 
         userspace_snapshots = sm->UpdateUsesUserSnapshots(lock_.get());
@@ -1160,7 +1156,7 @@ class SnapshotUpdateTest : public SnapshotTest {
 
     AssertionResult MapOneUpdateSnapshot(const std::string& name) {
         if (snapuserd_required_) {
-            std::unique_ptr<ISnapshotWriter> writer;
+            std::unique_ptr<ICowWriter> writer;
             return MapUpdateSnapshot(name, &writer);
         } else {
             std::string path;
@@ -1181,7 +1177,7 @@ class SnapshotUpdateTest : public SnapshotTest {
     AssertionResult WriteSnapshotAndHash(PartitionUpdate* partition) {
         std::string name = partition->partition_name() + "_b";
         if (snapuserd_required_) {
-            std::unique_ptr<ISnapshotWriter> writer;
+            std::unique_ptr<ICowWriter> writer;
             auto res = MapUpdateSnapshot(name, &writer);
             if (!res) {
                 return res;
@@ -1250,7 +1246,7 @@ class SnapshotUpdateTest : public SnapshotTest {
     // It doesn't really matter the order, we just want copies that reference
     // blocks that won't exist if the partition shrinks.
     AssertionResult ShiftAllSnapshotBlocks(const std::string& name, uint64_t old_size) {
-        std::unique_ptr<ISnapshotWriter> writer;
+        std::unique_ptr<ICowWriter> writer;
         if (auto res = MapUpdateSnapshot(name, &writer); !res) {
             return res;
         }
@@ -1273,7 +1269,13 @@ class SnapshotUpdateTest : public SnapshotTest {
             return AssertionFailure() << "Unable to finalize writer for " << name;
         }
 
-        auto hash = HashSnapshot(writer.get());
+        auto old_partition = "/dev/block/mapper/" + GetOtherPartitionName(name);
+        auto reader = writer->OpenFileDescriptor(old_partition);
+        if (!reader) {
+            return AssertionFailure() << "Could not open file descriptor for " << name;
+        }
+
+        auto hash = HashSnapshot(reader.get());
         if (hash.empty()) {
             return AssertionFailure() << "Unable to hash snapshot writer for " << name;
         }
@@ -1428,7 +1430,7 @@ TEST_F(SnapshotUpdateTest, DuplicateOps) {
     for (auto* partition : partitions) {
         AddOperation(partition);
 
-        std::unique_ptr<ISnapshotWriter> writer;
+        std::unique_ptr<ICowWriter> writer;
         auto res = MapUpdateSnapshot(partition->partition_name() + "_b", &writer);
         ASSERT_TRUE(res);
         ASSERT_TRUE(writer->AddZeroBlocks(0, 1));
diff --git a/fs_mgr/libsnapshot/snapshot_writer.cpp b/fs_mgr/libsnapshot/snapshot_writer.cpp
deleted file mode 100644
index 0ea424c7e9d9..000000000000
--- a/fs_mgr/libsnapshot/snapshot_writer.cpp
+++ /dev/null
@@ -1,179 +0,0 @@
-//
-// Copyright (C) 2020 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include <libsnapshot/snapshot_writer.h>
-
-#include <android-base/file.h>
-#include <android-base/logging.h>
-#include <payload_consumer/file_descriptor.h>
-#include "libsnapshot_cow/writer_v2.h"
-#include "snapshot_reader.h"
-
-namespace android {
-namespace snapshot {
-
-using android::base::borrowed_fd;
-using android::base::unique_fd;
-using chromeos_update_engine::FileDescriptor;
-
-void CompressedSnapshotWriter::SetSourceDevice(const std::string& source_device) {
-    source_device_ = {source_device};
-}
-
-borrowed_fd CompressedSnapshotWriter::GetSourceFd() {
-    if (!source_device_) {
-        LOG(ERROR) << "Attempted to read from source device but none was set";
-        return borrowed_fd{-1};
-    }
-
-    if (source_fd_ < 0) {
-        source_fd_.reset(open(source_device_->c_str(), O_RDONLY | O_CLOEXEC));
-        if (source_fd_ < 0) {
-            PLOG(ERROR) << "open " << *source_device_;
-            return borrowed_fd{-1};
-        }
-    }
-    return source_fd_;
-}
-
-CompressedSnapshotWriter::CompressedSnapshotWriter(const CowOptions& options) : options_(options) {}
-
-bool CompressedSnapshotWriter::SetCowDevice(android::base::unique_fd&& cow_device) {
-    cow_device_ = std::move(cow_device);
-    return true;
-}
-
-bool CompressedSnapshotWriter::Finalize() {
-    return cow_->Finalize();
-}
-
-uint64_t CompressedSnapshotWriter::GetCowSize() {
-    return cow_->GetCowSize();
-}
-
-std::unique_ptr<CowReader> CompressedSnapshotWriter::OpenCowReader() const {
-    unique_fd cow_fd(dup(cow_device_.get()));
-    if (cow_fd < 0) {
-        PLOG(ERROR) << "dup COW device";
-        return nullptr;
-    }
-
-    auto cow = std::make_unique<CowReader>();
-    if (!cow->Parse(std::move(cow_fd))) {
-        LOG(ERROR) << "Unable to read COW";
-        return nullptr;
-    }
-    return cow;
-}
-
-bool CompressedSnapshotWriter::VerifyMergeOps() const noexcept {
-    auto cow_reader = OpenCowReader();
-    if (cow_reader == nullptr) {
-        LOG(ERROR) << "Couldn't open CowReader";
-        return false;
-    }
-    return cow_reader->VerifyMergeOps();
-}
-
-std::unique_ptr<FileDescriptor> CompressedSnapshotWriter::OpenReader() {
-    auto cow = OpenCowReader();
-    if (cow == nullptr) {
-        return nullptr;
-    }
-
-    auto reader = std::make_unique<CompressedSnapshotReader>();
-    if (!reader->SetCow(std::move(cow))) {
-        LOG(ERROR) << "Unable to initialize COW reader";
-        return nullptr;
-    }
-    if (source_device_) {
-        reader->SetSourceDevice(*source_device_);
-    }
-
-    if (options_.max_blocks) {
-        reader->SetBlockDeviceSize(*options_.max_blocks * options_.block_size);
-    }
-
-    return reader;
-}
-
-bool CompressedSnapshotWriter::AddCopy(uint64_t new_block, uint64_t old_block,
-                                       uint64_t num_blocks) {
-    return cow_->AddCopy(new_block, old_block, num_blocks);
-}
-
-bool CompressedSnapshotWriter::AddRawBlocks(uint64_t new_block_start, const void* data,
-                                            size_t size) {
-    return cow_->AddRawBlocks(new_block_start, data, size);
-}
-
-bool CompressedSnapshotWriter::AddXorBlocks(uint32_t new_block_start, const void* data, size_t size,
-                                            uint32_t old_block, uint16_t offset) {
-    return cow_->AddXorBlocks(new_block_start, data, size, old_block, offset);
-}
-
-bool CompressedSnapshotWriter::AddZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
-    return cow_->AddZeroBlocks(new_block_start, num_blocks);
-}
-
-bool CompressedSnapshotWriter::AddLabel(uint64_t label) {
-    return cow_->AddLabel(label);
-}
-
-bool CompressedSnapshotWriter::AddSequenceData(size_t num_ops, const uint32_t* data) {
-    return cow_->AddSequenceData(num_ops, data);
-}
-
-bool CompressedSnapshotWriter::Initialize() {
-    unique_fd cow_fd(dup(cow_device_.get()));
-    if (cow_fd < 0) {
-        PLOG(ERROR) << "dup COW device";
-        return false;
-    }
-
-    auto cow = std::make_unique<CowWriterV2>(options_, std::move(cow_fd));
-    if (!cow->Initialize(std::nullopt)) {
-        return false;
-    }
-    cow_ = std::move(cow);
-    return true;
-}
-
-bool CompressedSnapshotWriter::InitializeAppend(uint64_t label) {
-    unique_fd cow_fd(dup(cow_device_.get()));
-    if (cow_fd < 0) {
-        PLOG(ERROR) << "dup COW device";
-        return false;
-    }
-
-    auto cow = std::make_unique<CowWriterV2>(options_, std::move(cow_fd));
-    if (!cow->Initialize(label)) {
-        return false;
-    }
-    cow_ = std::move(cow);
-    return true;
-}
-
-uint32_t CompressedSnapshotWriter::GetBlockSize() const {
-    return cow_->GetBlockSize();
-}
-
-std::optional<uint32_t> CompressedSnapshotWriter::GetMaxBlocks() const {
-    return cow_->GetMaxBlocks();
-}
-
-}  // namespace snapshot
-}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapshot_writer_test.cpp b/fs_mgr/libsnapshot/snapshot_writer_test.cpp
deleted file mode 100644
index a03632b46c99..000000000000
--- a/fs_mgr/libsnapshot/snapshot_writer_test.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//
-// Copyright (C) 2021 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include <libsnapshot/snapshot.h>
-
-#include <unordered_set>
-
-#include <android-base/file.h>
-#include <gtest/gtest.h>
-#include <libsnapshot/snapshot_writer.h>
-#include <payload_consumer/file_descriptor.h>
-
-namespace android::snapshot {
-class CompressedSnapshotWriterTest : public ::testing::Test {
-  public:
-    static constexpr size_t BLOCK_SIZE = 4096;
-};
-
-TEST_F(CompressedSnapshotWriterTest, ReadAfterWrite) {
-    TemporaryFile cow_device_file{};
-    android::snapshot::CowOptions options{.block_size = BLOCK_SIZE};
-    android::snapshot::CompressedSnapshotWriter snapshot_writer{options};
-    ASSERT_TRUE(snapshot_writer.SetCowDevice(android::base::unique_fd{cow_device_file.fd}));
-    ASSERT_TRUE(snapshot_writer.Initialize());
-    std::vector<unsigned char> buffer;
-    buffer.resize(BLOCK_SIZE);
-    std::fill(buffer.begin(), buffer.end(), 123);
-
-    ASSERT_TRUE(snapshot_writer.AddRawBlocks(0, buffer.data(), buffer.size()));
-    ASSERT_TRUE(snapshot_writer.Finalize());
-    auto cow_reader = snapshot_writer.OpenReader();
-    ASSERT_NE(cow_reader, nullptr);
-    ASSERT_TRUE(snapshot_writer.AddRawBlocks(1, buffer.data(), buffer.size()));
-    ASSERT_TRUE(snapshot_writer.AddRawBlocks(2, buffer.data(), buffer.size()));
-    ASSERT_TRUE(snapshot_writer.Finalize());
-    // After wrigin some data, if we call OpenReader() again, writes should
-    // be visible to the newly opened reader. update_engine relies on this
-    // behavior for verity writes.
-    cow_reader = snapshot_writer.OpenReader();
-    ASSERT_NE(cow_reader, nullptr);
-    std::vector<unsigned char> read_back;
-    read_back.resize(buffer.size());
-    cow_reader->Seek(BLOCK_SIZE, SEEK_SET);
-    const auto bytes_read = cow_reader->Read(read_back.data(), read_back.size());
-    ASSERT_EQ((size_t)(bytes_read), BLOCK_SIZE);
-    ASSERT_EQ(read_back, buffer);
-}
-
-}  // namespace android::snapshot
diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index ad3f83cba89b..38eb719fd277 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -133,7 +133,6 @@ bool CreateTestUpdate(SnapshotManager* sm) {
 
     // Write the "new" system partition.
     auto system_target_name = "system" + target_slot;
-    auto source_device = "/dev/block/mapper/" + system_source_name;
     CreateLogicalPartitionParams clpp = {
             .block_device = fs_mgr_get_super_partition_name(target_slot_number),
             .metadata_slot = {target_slot_number},
@@ -141,15 +140,11 @@ bool CreateTestUpdate(SnapshotManager* sm) {
             .partition_opener = &opener,
             .timeout_ms = 10s,
     };
-    auto writer = sm->OpenSnapshotWriter(clpp, {source_device});
+    auto writer = sm->OpenSnapshotWriter(clpp, std::nullopt);
     if (!writer) {
         std::cerr << "Could not open snapshot writer.\n";
         return false;
     }
-    if (!writer->Initialize()) {
-        std::cerr << "Could not initialize snapshot for writing.\n";
-        return false;
-    }
 
     for (uint64_t block = 0; block < system_source_size / 4096; block++) {
         if (!writer->AddCopy(block, block)) {
diff --git a/fs_mgr/libsnapshot/test_helpers.cpp b/fs_mgr/libsnapshot/test_helpers.cpp
index a224f6b58284..2eac34749909 100644
--- a/fs_mgr/libsnapshot/test_helpers.cpp
+++ b/fs_mgr/libsnapshot/test_helpers.cpp
@@ -130,12 +130,7 @@ bool WriteRandomData(const std::string& path, std::optional<size_t> expect_size,
     return true;
 }
 
-std::string HashSnapshot(ISnapshotWriter* writer) {
-    auto reader = writer->OpenReader();
-    if (!reader) {
-        return {};
-    }
-
+std::string HashSnapshot(ICowWriter::FileDescriptor* reader) {
     SHA256_CTX ctx;
     SHA256_Init(&ctx);
 

From 76622d444d94b620089707528dd98337bf2671fd Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 13 Jun 2023 16:51:22 -0700
Subject: [PATCH 0115/1487] libsnapshot: Remove dependence between CowWriterV2
 and CowReader.

The plan of record for the new CowOperation layout is to automatically
translate from CowOperationV2. However, CowWriterV2 currently imports
directly from CowReader, which means we'd need two translation steps.

Luckily we now have CowParserV2, which means we can directly import into
CowWriterV2.

Bug: 280529365
Test: vts_libsnapshot_test
Test: cow_api_test
Change-Id: I11863dcb483f0448686d6c492d8eb128840ce18c
---
 .../libsnapshot/libsnapshot_cow/writer_v2.cpp | 28 ++++++++++---------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index b6603da52edf..c5499697286d 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -14,6 +14,8 @@
 // limitations under the License.
 //
 
+#include "writer_v2.h"
+
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <unistd.h>
@@ -37,7 +39,7 @@
 #include <sys/ioctl.h>
 #include <unistd.h>
 
-#include "writer_v2.h"
+#include "parser_v2.h"
 
 // The info messages here are spammy, but as useful for update_engine. Disable
 // them when running on the host.
@@ -252,14 +254,20 @@ bool CowWriterV2::OpenForWrite() {
 }
 
 bool CowWriterV2::OpenForAppend(uint64_t label) {
-    auto reader = std::make_unique<CowReader>();
-    std::queue<CowOperation> toAdd;
+    if (!ReadCowHeader(fd_, &header_)) {
+        return false;
+    }
 
-    if (!reader->Parse(fd_, {label})) {
+    CowParserV2 parser;
+    if (!parser.Parse(fd_, header_, {label})) {
+        return false;
+    }
+    if (header_.prefix.major_version > 2) {
+        LOG(ERROR) << "CowWriterV2 tried to open incompatible version "
+                   << header_.prefix.major_version;
         return false;
     }
 
-    header_ = reader->GetHeader();
     options_.block_size = header_.block_size;
     options_.cluster_ops = header_.cluster_ops;
 
@@ -267,16 +275,10 @@ bool CowWriterV2::OpenForAppend(uint64_t label) {
     footer_.op.num_ops = 0;
     InitPos();
 
-    auto iter = reader->GetOpIter();
-
-    while (!iter->AtEnd()) {
-        AddOperation(*iter->Get());
-        iter->Next();
+    for (const auto& op : *parser.ops()) {
+        AddOperation(op);
     }
 
-    // Free reader so we own the descriptor position again.
-    reader = nullptr;
-
     if (lseek(fd_.get(), next_op_pos_, SEEK_SET) < 0) {
         PLOG(ERROR) << "lseek failed";
         return false;

From fa33f85f522352be0b8766d88d1ff0abb76fd378 Mon Sep 17 00:00:00 2001
From: Nikita Ioffe <ioffe@google.com>
Date: Wed, 14 Jun 2023 20:29:37 +0000
Subject: [PATCH 0116/1487] Reland "Treat Microdroid as OS with monolithic
 sepolicy"

Bug: 285855150
Test: presubmit
Change-Id: I477e1ef7268ac8e7d0fdae7ffcc611a69bb9d4fe
---
 init/selinux.cpp | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/init/selinux.cpp b/init/selinux.cpp
index 907eb80e31c0..a9365323362f 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -300,6 +300,8 @@ bool GetVendorMappingVersion(std::string* plat_vers) {
 }
 
 constexpr const char plat_policy_cil_file[] = "/system/etc/selinux/plat_sepolicy.cil";
+constexpr const char kMicrodroidPrecompiledSepolicy[] =
+        "/system/etc/selinux/microdroid_precompiled_sepolicy";
 
 bool IsSplitPolicyDevice() {
     return access(plat_policy_cil_file, R_OK) != -1;
@@ -497,14 +499,19 @@ bool OpenSplitPolicy(PolicyFile* policy_file) {
 
 bool OpenMonolithicPolicy(PolicyFile* policy_file) {
     static constexpr char kSepolicyFile[] = "/sepolicy";
-
-    LOG(VERBOSE) << "Opening SELinux policy from monolithic file";
-    policy_file->fd.reset(open(kSepolicyFile, O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
+    // In Microdroid the precompiled sepolicy is located on /system, since there is no vendor code.
+    // TODO(b/287206497): refactor once we start conditionally compiling init for Microdroid.
+    std::string monolithic_policy_file = access(kMicrodroidPrecompiledSepolicy, R_OK) == 0
+                                                 ? kMicrodroidPrecompiledSepolicy
+                                                 : kSepolicyFile;
+
+    LOG(INFO) << "Opening SELinux policy from monolithic file " << monolithic_policy_file;
+    policy_file->fd.reset(open(monolithic_policy_file.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
     if (policy_file->fd < 0) {
         PLOG(ERROR) << "Failed to open monolithic SELinux policy";
         return false;
     }
-    policy_file->path = kSepolicyFile;
+    policy_file->path = monolithic_policy_file;
     return true;
 }
 

From 2aba0a228324b2868e62df074fac616d7cc4e609 Mon Sep 17 00:00:00 2001
From: Fabien Sanglard <sanglardf@google.com>
Date: Wed, 14 Jun 2023 23:08:02 +0000
Subject: [PATCH 0117/1487] Fix LruCache, allow std:string caching

The default initalization for mNullValue uses 0 which is in the case of
a std::string TValue will invoke the contructor with undefined behavior
parameter.

Using an empty uniform initialization {} addresses the problem.

Test: Already tested in lrucache_test.cpp
Bug: 257127748
Change-Id: I37420ce8a16c99f3014538a0208d7e113870b1c7
---
 libutils/LruCache_test.cpp        | 11 +++++++----
 libutils/include/utils/LruCache.h | 12 ++++++------
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/libutils/LruCache_test.cpp b/libutils/LruCache_test.cpp
index 8b16947bef47..5cd3cbb90cf7 100644
--- a/libutils/LruCache_test.cpp
+++ b/libutils/LruCache_test.cpp
@@ -29,6 +29,8 @@ typedef const char* StringValue;
 struct ComplexKey {
     int k;
 
+    explicit ComplexKey() : k(0) { instanceCount += 1; }
+
     explicit ComplexKey(int k) : k(k) {
         instanceCount += 1;
     }
@@ -57,6 +59,8 @@ ssize_t ComplexKey::instanceCount = 0;
 struct ComplexValue {
     int v;
 
+    explicit ComplexValue() : v(0) { instanceCount += 1; }
+
     explicit ComplexValue(int v) : v(v) {
         instanceCount += 1;
     }
@@ -83,10 +87,9 @@ struct KeyWithPointer {
 
 struct KeyFailsOnCopy : public ComplexKey {
     public:
-    KeyFailsOnCopy(const KeyFailsOnCopy& key) : ComplexKey(key) {
-        ADD_FAILURE();
-    }
-    KeyFailsOnCopy(int key) : ComplexKey(key) { }
+      KeyFailsOnCopy() : ComplexKey() {}
+      KeyFailsOnCopy(const KeyFailsOnCopy& key) : ComplexKey(key) { ADD_FAILURE(); }
+      KeyFailsOnCopy(int key) : ComplexKey(key) {}
 };
 
 } // namespace
diff --git a/libutils/include/utils/LruCache.h b/libutils/include/utils/LruCache.h
index b4243a3dbe38..70901b63b4c5 100644
--- a/libutils/include/utils/LruCache.h
+++ b/libutils/include/utils/LruCache.h
@@ -161,12 +161,12 @@ class LruCache {
 // Implementation is here, because it's fully templated
 template <typename TKey, typename TValue>
 LruCache<TKey, TValue>::LruCache(uint32_t maxCapacity)
-    : mSet(new LruCacheSet())
-    , mListener(nullptr)
-    , mOldest(nullptr)
-    , mYoungest(nullptr)
-    , mMaxCapacity(maxCapacity)
-    , mNullValue(0) {
+    : mSet(new LruCacheSet()),
+      mListener(nullptr),
+      mOldest(nullptr),
+      mYoungest(nullptr),
+      mMaxCapacity(maxCapacity),
+      mNullValue{} {
     mSet->max_load_factor(1.0);
 };
 

From 1501b0c344513b5d3dc521b91fffca71b2004054 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Wed, 14 Jun 2023 19:26:54 +0000
Subject: [PATCH 0118/1487] init_kill_services_test: binder logs on apexd fail

Print logs necessary to understand why apexd isn't shutting
down when this test fails, due to a rare flake.

Bug: 285458033
Test: init_kill_services_test (and cause this error to be hit)
Change-Id: Ic9cbf7b2b9fa89504e4a53597065e94c32233e12
---
 init/test_kill_services/init_kill_services_test.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/init/test_kill_services/init_kill_services_test.cpp b/init/test_kill_services/init_kill_services_test.cpp
index d9fcd9d45376..dd4606449621 100644
--- a/init/test_kill_services/init_kill_services_test.cpp
+++ b/init/test_kill_services/init_kill_services_test.cpp
@@ -27,10 +27,13 @@ using ::android::base::WaitForProperty;
 using std::literals::chrono_literals::operator""s;
 
 void ExpectKillingServiceRecovers(const std::string& service_name) {
+    LOG(INFO) << "before we say hi to " << service_name << ", I can't have apexd around!";
+
     // b/280514080 - servicemanager will restart apexd, and apexd will restart the
     // system when crashed. This is fine as the device recovers, but it causes
     // flakes in this test.
-    ASSERT_TRUE(WaitForProperty("init.svc.apexd", "stopped", 60s)) << "apexd won't stop";
+    ASSERT_TRUE(WaitForProperty("init.svc.apexd", "stopped", 60s))
+            << (system("cat /dev/binderfs/binder_logs/state"), "apexd won't stop");
 
     LOG(INFO) << "hello " << service_name << "!";
     const std::string status_prop = "init.svc." + service_name;

From 691b78a0fdaef1080b0315fdda91bd85df9aa626 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 15 Jun 2023 11:00:30 -0700
Subject: [PATCH 0119/1487] inspect_cow: Switch to gflags.

gflags is a lot cleaner to use than getopt, and we don't really need any
advanced argument parsing.

Test: inspect_cow
Bug: N/A
Change-Id: I19007a787a2e5cd3a67486c7949b34ba76f762e4
---
 fs_mgr/libsnapshot/Android.bp                 |   1 +
 .../libsnapshot_cow/inspect_cow.cpp           | 120 +++++-------------
 2 files changed, 35 insertions(+), 86 deletions(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 046d30cc9a16..9d1ce7db9b79 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -417,6 +417,7 @@ cc_binary {
         "libbrotli",
         "libcrypto_static",
         "liblog",
+        "libgflags",
         "libsnapshot_cow",
         "libz",
     ],
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
index c2c86eefdda3..9bb0df344e53 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
@@ -24,8 +24,19 @@
 
 #include <android-base/logging.h>
 #include <android-base/unique_fd.h>
+#include <gflags/gflags.h>
 #include <libsnapshot/cow_reader.h>
 
+DEFINE_bool(silent, false, "Run silently");
+DEFINE_bool(decompress, false, "Attempt to decompress data ops");
+DEFINE_bool(show_bad_data, false, "If an op fails to decompress, show its daw data");
+DEFINE_bool(show_ops, false, "Print all opcode information");
+DEFINE_string(order, "", "If show_ops is true, change the order (either merge or reverse-merge)");
+DEFINE_bool(show_merged, false,
+            "If show_ops is true, and order is merge or reverse-merge, include merged ops");
+DEFINE_bool(verify_merge_sequence, false, "Verify merge order sequencing");
+DEFINE_bool(show_merge_sequence, false, "Show merge order sequence");
+
 namespace android {
 namespace snapshot {
 
@@ -38,32 +49,6 @@ void MyLogger(android::base::LogId, android::base::LogSeverity severity, const c
     }
 }
 
-static void usage(void) {
-    std::cerr << "Usage: inspect_cow [-sd] <COW_FILE>\n";
-    std::cerr << "\t -s Run Silent\n";
-    std::cerr << "\t -d Attempt to decompress\n";
-    std::cerr << "\t -b Show data for failed decompress\n";
-    std::cerr << "\t -l Show ops\n";
-    std::cerr << "\t -m Show ops in reverse merge order\n";
-    std::cerr << "\t -n Show ops in merge order\n";
-    std::cerr << "\t -a Include merged ops in any merge order listing\n";
-    std::cerr << "\t -o Shows sequence op block order\n";
-    std::cerr << "\t -v Verifies merge order has no conflicts\n";
-}
-
-enum OpIter { Normal, RevMerge, Merge };
-
-struct Options {
-    bool silent;
-    bool decompress;
-    bool show_ops;
-    bool show_bad;
-    bool show_seq;
-    bool verify_sequence;
-    OpIter iter_type;
-    bool include_merged;
-};
-
 static void ShowBad(CowReader& reader, const struct CowOperation* op) {
     size_t count;
     auto buffer = std::make_unique<uint8_t[]>(op->data_length);
@@ -82,7 +67,7 @@ static void ShowBad(CowReader& reader, const struct CowOperation* op) {
     }
 }
 
-static bool Inspect(const std::string& path, Options opt) {
+static bool Inspect(const std::string& path) {
     android::base::unique_fd fd(open(path.c_str(), O_RDONLY));
     if (fd < 0) {
         PLOG(ERROR) << "open failed: " << path;
@@ -103,7 +88,7 @@ static bool Inspect(const std::string& path, Options opt) {
     bool has_footer = false;
     if (reader.GetFooter(&footer)) has_footer = true;
 
-    if (!opt.silent) {
+    if (!FLAGS_silent) {
         std::cout << "Version: " << header.prefix.major_version << "."
                   << header.prefix.minor_version << "\n";
         std::cout << "Header size: " << header.prefix.header_size << "\n";
@@ -119,11 +104,11 @@ static bool Inspect(const std::string& path, Options opt) {
         }
     }
 
-    if (!opt.silent) {
+    if (!FLAGS_silent) {
         std::cout << "Parse time: " << (parse_time.count() * 1000) << "ms\n";
     }
 
-    if (opt.verify_sequence) {
+    if (FLAGS_verify_merge_sequence) {
         std::cout << "\n";
         if (reader.VerifyMergeOps()) {
             std::cout << "\nMerge sequence is consistent.\n";
@@ -133,12 +118,12 @@ static bool Inspect(const std::string& path, Options opt) {
     }
 
     std::unique_ptr<ICowOpIter> iter;
-    if (opt.iter_type == Normal) {
+    if (FLAGS_order.empty()) {
         iter = reader.GetOpIter();
-    } else if (opt.iter_type == RevMerge) {
-        iter = reader.GetRevMergeOpIter(opt.include_merged);
-    } else if (opt.iter_type == Merge) {
-        iter = reader.GetMergeOpIter(opt.include_merged);
+    } else if (FLAGS_order == "reverse-merge") {
+        iter = reader.GetRevMergeOpIter(FLAGS_show_merged);
+    } else if (FLAGS_order == "merge") {
+        iter = reader.GetMergeOpIter(FLAGS_show_merged);
     }
 
     std::string buffer(header.block_size, '\0');
@@ -148,17 +133,17 @@ static bool Inspect(const std::string& path, Options opt) {
     while (!iter->AtEnd()) {
         const CowOperation* op = iter->Get();
 
-        if (!opt.silent && opt.show_ops) std::cout << *op << "\n";
+        if (!FLAGS_silent && FLAGS_show_ops) std::cout << *op << "\n";
 
-        if (opt.decompress && op->type == kCowReplaceOp && op->compression != kCowCompressNone) {
+        if (FLAGS_decompress && op->type == kCowReplaceOp && op->compression != kCowCompressNone) {
             if (reader.ReadData(op, buffer.data(), buffer.size()) < 0) {
                 std::cerr << "Failed to decompress for :" << *op << "\n";
                 success = false;
-                if (opt.show_bad) ShowBad(reader, op);
+                if (FLAGS_show_bad_data) ShowBad(reader, op);
             }
         }
 
-        if (op->type == kCowSequenceOp && opt.show_seq) {
+        if (op->type == kCowSequenceOp && FLAGS_show_merge_sequence) {
             size_t read;
             std::vector<uint32_t> merge_op_blocks;
             size_t seq_len = op->data_length / sizeof(uint32_t);
@@ -167,7 +152,7 @@ static bool Inspect(const std::string& path, Options opt) {
                 PLOG(ERROR) << "Failed to read sequence op!";
                 return false;
             }
-            if (!opt.silent) {
+            if (!FLAGS_silent) {
                 std::cout << "Sequence for " << *op << " is :\n";
                 for (size_t i = 0; i < seq_len; i++) {
                     std::cout << std::setfill('0') << std::setw(6) << merge_op_blocks[i] << ", ";
@@ -189,7 +174,7 @@ static bool Inspect(const std::string& path, Options opt) {
         iter->Next();
     }
 
-    if (!opt.silent) {
+    if (!FLAGS_silent) {
         auto total_ops = replace_ops + zero_ops + copy_ops + xor_ops;
         std::cout << "Data ops: " << total_ops << "\n";
         std::cout << "Replace ops: " << replace_ops << "\n";
@@ -205,57 +190,20 @@ static bool Inspect(const std::string& path, Options opt) {
 }  // namespace android
 
 int main(int argc, char** argv) {
-    int ch;
-    struct android::snapshot::Options opt;
-    opt.silent = false;
-    opt.decompress = false;
-    opt.show_bad = false;
-    opt.iter_type = android::snapshot::Normal;
-    opt.verify_sequence = false;
-    opt.include_merged = false;
-    while ((ch = getopt(argc, argv, "sdbmnolva")) != -1) {
-        switch (ch) {
-            case 's':
-                opt.silent = true;
-                break;
-            case 'd':
-                opt.decompress = true;
-                break;
-            case 'b':
-                opt.show_bad = true;
-                break;
-            case 'm':
-                opt.iter_type = android::snapshot::RevMerge;
-                break;
-            case 'n':
-                opt.iter_type = android::snapshot::Merge;
-                break;
-            case 'o':
-                opt.show_seq = true;
-                break;
-            case 'l':
-                opt.show_ops = true;
-                break;
-            case 'v':
-                opt.verify_sequence = true;
-                break;
-            case 'a':
-                opt.include_merged = true;
-                break;
-            default:
-                android::snapshot::usage();
-                return 1;
-        }
-    }
+    gflags::ParseCommandLineFlags(&argc, &argv, true);
 
-    if (argc < optind + 1) {
-        android::snapshot::usage();
+    if (argc < 2) {
+        gflags::ShowUsageWithFlags(argv[0]);
+        return 1;
+    }
+    if (FLAGS_order != "" && FLAGS_order != "merge" && FLAGS_order != "reverse-merge") {
+        std::cerr << "Order must either be \"merge\" or \"reverse-merge\".\n";
         return 1;
     }
 
     android::base::InitLogging(argv, android::snapshot::MyLogger);
 
-    if (!android::snapshot::Inspect(argv[optind], opt)) {
+    if (!android::snapshot::Inspect(argv[1])) {
         return 1;
     }
     return 0;

From 17421a93ba0c3d36fd1673bb3cd18a6f51149f4e Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 15 Jun 2023 11:18:25 -0700
Subject: [PATCH 0120/1487] inspect_cow: Add --show_raw_ops.

This bypasses CowReader and shows ops directly from CowParserV2. This
will come in handy once CowOperation is versioned and CowReader will be
translating from older versions to new versions.

Bug: 280529365
Test: inspect_cow
Change-Id: Icaeba86105c31c4dfe2812309a4028dd1d0248c0
---
 .../libsnapshot_cow/inspect_cow.cpp           | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
index 9bb0df344e53..148ecb006e5c 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
@@ -26,6 +26,7 @@
 #include <android-base/unique_fd.h>
 #include <gflags/gflags.h>
 #include <libsnapshot/cow_reader.h>
+#include "parser_v2.h"
 
 DEFINE_bool(silent, false, "Run silently");
 DEFINE_bool(decompress, false, "Attempt to decompress data ops");
@@ -36,10 +37,13 @@ DEFINE_bool(show_merged, false,
             "If show_ops is true, and order is merge or reverse-merge, include merged ops");
 DEFINE_bool(verify_merge_sequence, false, "Verify merge order sequencing");
 DEFINE_bool(show_merge_sequence, false, "Show merge order sequence");
+DEFINE_bool(show_raw_ops, false, "Show raw ops directly from the underlying parser");
 
 namespace android {
 namespace snapshot {
 
+using android::base::borrowed_fd;
+
 void MyLogger(android::base::LogId, android::base::LogSeverity severity, const char*, const char*,
               unsigned int, const char* message) {
     if (severity == android::base::ERROR) {
@@ -67,6 +71,38 @@ static void ShowBad(CowReader& reader, const struct CowOperation* op) {
     }
 }
 
+static bool ShowRawOpStreamV2(borrowed_fd fd, const CowHeader& header) {
+    CowParserV2 parser;
+    if (!parser.Parse(fd, header)) {
+        LOG(ERROR) << "v2 parser failed";
+        return false;
+    }
+    for (const auto& op : *parser.ops()) {
+        std::cout << op << "\n";
+        if (auto iter = parser.data_loc()->find(op.new_block); iter != parser.data_loc()->end()) {
+            std::cout << "    data loc: " << iter->second << "\n";
+        }
+    }
+    return true;
+}
+
+static bool ShowRawOpStream(borrowed_fd fd) {
+    CowHeader header;
+    if (!ReadCowHeader(fd, &header)) {
+        LOG(ERROR) << "parse header failed";
+        return false;
+    }
+
+    switch (header.prefix.major_version) {
+        case 1:
+        case 2:
+            return ShowRawOpStreamV2(fd, header);
+        default:
+            LOG(ERROR) << "unknown COW version: " << header.prefix.major_version;
+            return false;
+    }
+}
+
 static bool Inspect(const std::string& path) {
     android::base::unique_fd fd(open(path.c_str(), O_RDONLY));
     if (fd < 0) {
@@ -128,6 +164,21 @@ static bool Inspect(const std::string& path) {
 
     std::string buffer(header.block_size, '\0');
 
+    if (!FLAGS_silent && FLAGS_show_raw_ops) {
+        std::cout << "\n";
+        std::cout << "Listing raw op stream:\n";
+        std::cout << "----------------------\n";
+        if (!ShowRawOpStream(fd)) {
+            return false;
+        }
+    }
+
+    if (!FLAGS_silent && FLAGS_show_ops) {
+        std::cout << "\n";
+        std::cout << "Listing op stream:\n";
+        std::cout << "------------------\n";
+    }
+
     bool success = true;
     uint64_t xor_ops = 0, copy_ops = 0, replace_ops = 0, zero_ops = 0;
     while (!iter->AtEnd()) {

From d1d5f5ab6988f441780d95ddcb566a2d9030f3d9 Mon Sep 17 00:00:00 2001
From: Roy Luo <royluo@google.com>
Date: Tue, 20 Jun 2023 21:44:53 +0000
Subject: [PATCH 0121/1487] fastboot: remove retries on invalid IO iterator in
 OSX

When IOServiceGetMatchingServices returns an invalid
iterator, IOIteratorReset doesn't help. Break the loop
to prevent being stuck in the reset loop forever.
This should be fine as the open_device() call in the
upper layer is already doing retries.

Bug: 286495045
Test: fastboot update
Change-Id: Ia58fa9285640be34aa22cd77e4f58cc9092679a4
---
 fastboot/usb_osx.cpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/fastboot/usb_osx.cpp b/fastboot/usb_osx.cpp
index 5b9e5c8af0b5..8b852f567a1f 100644
--- a/fastboot/usb_osx.cpp
+++ b/fastboot/usb_osx.cpp
@@ -436,12 +436,7 @@ static int init_usb(ifc_match_func callback, std::unique_ptr<usb_handle>* handle
 
     for (;;) {
         if (! IOIteratorIsValid(iterator)) {
-            /*
-             * Apple documentation advises resetting the iterator if
-             * it should become invalid during iteration.
-             */
-            IOIteratorReset(iterator);
-            continue;
+            break;
         }
 
         io_service_t device = IOIteratorNext(iterator);

From e09de2a5ca600d1bd0d0c70f75503c44c034c0bb Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Tue, 20 Jun 2023 23:02:01 +0900
Subject: [PATCH 0122/1487] libdm: don't expect uevent for devices that have
 never been activated

Previously, libdm ensured that uevent will be generated when a dm device
is deleted. However, there actually are cases where uevent can't be
expected; for example, if an empty dm device is created, but then gets
deleted without being activated, then there should be no uevent upon
deleting because there actually is nothing to remove from /dev. (dm
device gets added to /dev only if it is activated).

Actually such a case exists in apexd. As a performance optimization, it
proactively creates empty dm devices for all APEXes it scanns. But
some of them don't ever get activated if the APEX is already in a
dm-verity protected block device (i.e. the pre-instaled APEX is the
latest one). In that cases, the empty dm devices are deleted at the end
of the boot process as a clean up.

The libdm triggered error during the clean up, because there was no
uevent generated for the empty dm devices. This has triggered a lot of
false alarms to the apex team.

This CL fixes this by ensuring uevent only for activate dm devices. If
the dm device doesn't show up in /dev, we just delete the in-kernel
object and don't expect it to generate uevent for it - which actually is
the kernel's behavior.

Bug: 286176029
Test: build and run aosp_cf_x86_64_phone. observe dmesg.

Before the change:
I apexd   : Deleting unused dm device com.android.hardware.core_permissions
E apexd   : Didn't generate uevent for [com.android.hardware.core_permissions] removal
W apexd   : Failed to delete dm-device com.android.hardware.core_permissions

After the change:
I apexd   : Deleting unused dm device com.android.hardware.core_permissions
<no error or warning logs>

Change-Id: I52042de7d4d9ab62e6a13428c32a67e13395d1b5
---
 fs_mgr/libdm/dm.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index 1e8c14fe2c01..3a9ed9b1a4de 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -106,6 +106,10 @@ bool DeviceMapper::DeleteDevice(const std::string& name,
     if (!GetDeviceUniquePath(name, &unique_path)) {
         LOG(ERROR) << "Failed to get unique path for device " << name;
     }
+    // Expect to have uevent generated if the unique path actually exists. This may not exist
+    // if the device was created but has never been activated before it gets deleted.
+    bool need_uevent = !unique_path.empty() && access(unique_path.c_str(), F_OK) == 0;
+
     struct dm_ioctl io;
     InitIo(&io, name);
 
@@ -116,7 +120,7 @@ bool DeviceMapper::DeleteDevice(const std::string& name,
 
     // Check to make sure appropriate uevent is generated so ueventd will
     // do the right thing and remove the corresponding device node and symlinks.
-    if ((io.flags & DM_UEVENT_GENERATED_FLAG) == 0) {
+    if (need_uevent && (io.flags & DM_UEVENT_GENERATED_FLAG) == 0) {
         LOG(ERROR) << "Didn't generate uevent for [" << name << "] removal";
         return false;
     }

From 55dd32538f16e498465eb7fb49407e5754ee68f3 Mon Sep 17 00:00:00 2001
From: Nikita Ioffe <ioffe@google.com>
Date: Wed, 21 Jun 2023 16:44:40 +0100
Subject: [PATCH 0123/1487] Introduce microdroid variants of init_first_stage
 and init_second_stage

These variants will compile with -DMICRODROID flag, which will allow us
to exclude init features that are not needed for Microdroid, and
introduce features that only work in Microdroid.

Bug: 287206497
Test: build com.android.virt APEX
Change-Id: Ib9af0cfcdf06c70fc39e6e6ac8ef07bb69982969
---
 init/Android.bp | 33 +++++++++++++++++++++++++++------
 1 file changed, 27 insertions(+), 6 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index 41c7a953abc2..f62d7b767dfe 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -265,8 +265,8 @@ phony {
     ],
 }
 
-cc_binary {
-    name: "init_second_stage",
+cc_defaults {
+    name: "init_second_stage_defaults",
     recovery_available: true,
     stem: "init",
     defaults: ["init_defaults"],
@@ -304,9 +304,22 @@ cc_binary {
             ],
         },
     },
+}
+
+cc_binary {
+    name: "init_second_stage",
+    defaults: ["init_second_stage_defaults"],
+}
+
+cc_binary {
+    name: "init_second_stage.microdroid",
+    defaults: ["init_second_stage_defaults"],
+    cflags: ["-DMICRODROID"],
+    installable: false,
     visibility: ["//packages/modules/Virtualization/microdroid"],
 }
 
+
 soong_config_module_type {
     name: "init_first_stage_cc_defaults",
     module_type: "cc_defaults",
@@ -324,12 +337,8 @@ init_first_stage_cc_defaults {
             installable: false,
         },
     },
-}
 
-cc_binary {
-    name: "init_first_stage",
     stem: "init",
-    defaults: ["init_first_stage_defaults"],
 
     srcs: [
         "block_dev_initializer.cpp",
@@ -443,6 +452,18 @@ cc_binary {
     install_in_root: true,
 }
 
+cc_binary {
+    name: "init_first_stage",
+    defaults: ["init_first_stage_defaults"],
+}
+
+cc_binary {
+    name: "init_first_stage.microdroid",
+    defaults: ["init_first_stage_defaults"],
+    cflags: ["-DMICRODROID"],
+    installable: false,
+}
+
 phony {
     name: "init_system",
     required: ["init_second_stage"],

From 73b983a7d41910031fc54467f39c077243a8d0a9 Mon Sep 17 00:00:00 2001
From: Subrahmanya Manikanta Venkateswarlu Bhamidipati Kameswara Sri
 <subrahmanyaman@google.com>
Date: Tue, 13 Jun 2023 17:37:29 +0000
Subject: [PATCH 0124/1487] Check AServiceManager_isDeclared before
 AServiceManager_getService

Call AServiceManager_isDeclared before calling AServiceManager_getService
to avoid the waiting time when aidl service is not available.

Bug: 286969060
Test: run VtsHalGatekeeperTarget
(cherry picked from https://android-review.googlesource.com/q/commit:32e1c70f275991ec7fe4d4a2d6e3eeba2a172540)
Merged-In: I7d652a546cb810a601338a68950f01d065aea7a5
Change-Id: I7d652a546cb810a601338a68950f01d065aea7a5
---
 gatekeeperd/gatekeeperd.cpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/gatekeeperd/gatekeeperd.cpp b/gatekeeperd/gatekeeperd.cpp
index eb43a337816b..d2fc65120d5f 100644
--- a/gatekeeperd/gatekeeperd.cpp
+++ b/gatekeeperd/gatekeeperd.cpp
@@ -74,9 +74,13 @@ class GateKeeperProxy : public BnGateKeeperService {
   public:
     GateKeeperProxy() {
         clear_state_if_needed_done = false;
-        hw_device = IGatekeeper::getService();
-        ::ndk::SpAIBinder ks2Binder(AServiceManager_getService(gatekeeperServiceName));
-        aidl_hw_device = AidlIGatekeeper::fromBinder(ks2Binder);
+        if (AServiceManager_isDeclared(gatekeeperServiceName)) {
+            ::ndk::SpAIBinder ks2Binder(AServiceManager_waitForService(gatekeeperServiceName));
+            aidl_hw_device = AidlIGatekeeper::fromBinder(ks2Binder);
+        }
+        if (!aidl_hw_device) {
+            hw_device = IGatekeeper::getService();
+        }
         is_running_gsi = android::base::GetBoolProperty(android::gsi::kGsiBootedProp, false);
 
         if (!aidl_hw_device && !hw_device) {

From 7f8fff0360233e5f8af74ba1715e8d7c07342829 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 21 Jun 2023 14:23:56 -0700
Subject: [PATCH 0125/1487] Moving source class declaration

Moving zipImageSource and localImageSource to header file to be used for
testing purposes

Test: m fastboot
Bug: 194686221
Change-Id: I689e73eb0102d3b2cdd0c4fc232b2b60b9022c47
---
 fastboot/fastboot.cpp | 16 ----------------
 fastboot/fastboot.h   | 17 +++++++++++++++++
 2 files changed, 17 insertions(+), 16 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 287285bcdf73..46786553adbe 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1902,16 +1902,6 @@ void FlashAllTool::FlashImage(const Image& image, const std::string& slot, fastb
     do_for_partitions(image.part_name, slot, flash, false);
 }
 
-class ZipImageSource final : public ImageSource {
-  public:
-    explicit ZipImageSource(ZipArchiveHandle zip) : zip_(zip) {}
-    bool ReadFile(const std::string& name, std::vector<char>* out) const override;
-    unique_fd OpenFile(const std::string& name) const override;
-
-  private:
-    ZipArchiveHandle zip_;
-};
-
 bool ZipImageSource::ReadFile(const std::string& name, std::vector<char>* out) const {
     return UnzipToMemory(zip_, name, out);
 }
@@ -1935,12 +1925,6 @@ static void do_update(const char* filename, FlashingPlan* fp) {
     CloseArchive(zip);
 }
 
-class LocalImageSource final : public ImageSource {
-  public:
-    bool ReadFile(const std::string& name, std::vector<char>* out) const override;
-    unique_fd OpenFile(const std::string& name) const override;
-};
-
 bool LocalImageSource::ReadFile(const std::string& name, std::vector<char>* out) const {
     auto path = find_item_given_name(name);
     if (path.empty()) {
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index abdf63695053..4b48d4a2d3a6 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -40,6 +40,7 @@
 #include "result.h"
 #include "socket.h"
 #include "util.h"
+#include "ziparchive/zip_archive.h"
 
 class FastBootTool {
   public:
@@ -122,6 +123,22 @@ class FlashAllTool {
     FlashingPlan* fp_;
 };
 
+class ZipImageSource final : public ImageSource {
+  public:
+    explicit ZipImageSource(ZipArchiveHandle zip) : zip_(zip) {}
+    bool ReadFile(const std::string& name, std::vector<char>* out) const override;
+    unique_fd OpenFile(const std::string& name) const override;
+
+  private:
+    ZipArchiveHandle zip_;
+};
+
+class LocalImageSource final : public ImageSource {
+  public:
+    bool ReadFile(const std::string& name, std::vector<char>* out) const override;
+    unique_fd OpenFile(const std::string& name) const override;
+};
+
 bool should_flash_in_userspace(const std::string& partition_name);
 bool is_userspace_fastboot();
 void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,

From 2127b87b706d5be964ba2ee7015cf88eed35bdea Mon Sep 17 00:00:00 2001
From: Daniel Rosenberg <drosen@google.com>
Date: Wed, 21 Jun 2023 18:45:16 -0700
Subject: [PATCH 0126/1487] Only skip checkpointing for freshly formatted ext4

"Do not reboot with commit failure when ext4 userdata is wiped" has
caused a regression in cuttlefish on f2fs. Overlay.img rapidly grows to
the full userdata size. This updates that CL to only affect partitions
marked for block based checkpointing.

Test: Boot Cuttlefish, monitor overlay.img for 5 minutes
Bug: 285019395
Change-Id: I7d8634e6535ee1531a0df9fb51c6f9c410cbfe92
---
 fs_mgr/fs_mgr.cpp       | 21 +++++++++++++--------
 fs_mgr/include/fs_mgr.h |  3 ++-
 2 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 742cdfab012a..debcb3e58e08 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -1096,8 +1096,11 @@ static bool SupportsCheckpoint(FstabEntry* entry) {
 
 class CheckpointManager {
   public:
-    CheckpointManager(int needs_checkpoint = -1, bool metadata_encrypted = false)
-        : needs_checkpoint_(needs_checkpoint), metadata_encrypted_(metadata_encrypted) {}
+    CheckpointManager(int needs_checkpoint = -1, bool metadata_encrypted = false,
+                      bool needs_encrypt = false)
+        : needs_checkpoint_(needs_checkpoint),
+          metadata_encrypted_(metadata_encrypted),
+          needs_encrypt_(needs_encrypt) {}
 
     bool NeedsCheckpoint() {
         if (needs_checkpoint_ != UNKNOWN) {
@@ -1160,7 +1163,7 @@ class CheckpointManager {
             } else {
                 LERROR << entry->fs_type << " does not implement checkpoints.";
             }
-        } else if (entry->fs_mgr_flags.checkpoint_blk) {
+        } else if (entry->fs_mgr_flags.checkpoint_blk && !needs_encrypt_) {
             auto actual_block_device = block_device.empty() ? entry->blk_device : block_device;
             if (fs_mgr_find_bow_device(actual_block_device).empty()) {
                 unique_fd fd(
@@ -1228,6 +1231,7 @@ class CheckpointManager {
     enum { UNKNOWN = -1, NO = 0, YES = 1 };
     int needs_checkpoint_;
     bool metadata_encrypted_;
+    bool needs_encrypt_;
     std::map<std::string, std::string> device_map_;
 };
 
@@ -1851,11 +1855,12 @@ int fs_mgr_do_mount_one(const FstabEntry& entry, const std::string& alt_mount_po
 // in turn, and stop on 1st success, or no more match.
 static int fs_mgr_do_mount_helper(Fstab* fstab, const std::string& n_name,
                                   const std::string& n_blk_device, const char* tmp_mount_point,
-                                  int needs_checkpoint, bool metadata_encrypted) {
+                                  int needs_checkpoint, bool metadata_encrypted,
+                                  bool needs_encrypt) {
     int mount_errors = 0;
     int first_mount_errno = 0;
     std::string mount_point;
-    CheckpointManager checkpoint_manager(needs_checkpoint, metadata_encrypted);
+    CheckpointManager checkpoint_manager(needs_checkpoint, metadata_encrypted, needs_encrypt);
     AvbUniquePtr avb_handle(nullptr);
 
     if (!fstab) {
@@ -1959,13 +1964,13 @@ static int fs_mgr_do_mount_helper(Fstab* fstab, const std::string& n_name,
 }
 
 int fs_mgr_do_mount(Fstab* fstab, const char* n_name, char* n_blk_device, char* tmp_mount_point) {
-    return fs_mgr_do_mount_helper(fstab, n_name, n_blk_device, tmp_mount_point, -1, false);
+    return fs_mgr_do_mount_helper(fstab, n_name, n_blk_device, tmp_mount_point, -1, false, false);
 }
 
 int fs_mgr_do_mount(Fstab* fstab, const char* n_name, char* n_blk_device, char* tmp_mount_point,
-                    bool needs_checkpoint, bool metadata_encrypted) {
+                    bool needs_checkpoint, bool metadata_encrypted, bool needs_encrypt) {
     return fs_mgr_do_mount_helper(fstab, n_name, n_blk_device, tmp_mount_point, needs_checkpoint,
-                                  metadata_encrypted);
+                                  metadata_encrypted, needs_encrypt);
 }
 
 /*
diff --git a/fs_mgr/include/fs_mgr.h b/fs_mgr/include/fs_mgr.h
index 43de6d84c388..37515d4653c7 100644
--- a/fs_mgr/include/fs_mgr.h
+++ b/fs_mgr/include/fs_mgr.h
@@ -88,7 +88,8 @@ MountAllResult fs_mgr_mount_all(android::fs_mgr::Fstab* fstab, int mount_mode);
 int fs_mgr_do_mount(android::fs_mgr::Fstab* fstab, const char* n_name, char* n_blk_device,
                     char* tmp_mount_point);
 int fs_mgr_do_mount(android::fs_mgr::Fstab* fstab, const char* n_name, char* n_blk_device,
-                    char* tmp_mount_point, bool need_cp, bool metadata_encrypted);
+                    char* tmp_mount_point, bool need_cp, bool metadata_encrypted,
+                    bool need_encrypted);
 int fs_mgr_do_mount_one(const android::fs_mgr::FstabEntry& entry,
                         const std::string& mount_point = "");
 int fs_mgr_do_tmpfs_mount(const char *n_name);

From 59c22c33a090f98493e3e10a0f7b334d530b54af Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 21 Jun 2023 14:30:46 -0700
Subject: [PATCH 0127/1487] Removing local image lookup from load_buf

The initial logic for adding this in was incorrect. This changed had
allowed us to do fastboot flash dts dt.img on command line. But really
we should enforce that we pass in the path to the image. This change was
added so the command line tool with resemble fastboot-info format which
will support flash dts dt.img (situation where image name and partition
name don't match).

Test: fastboot flash {partition}, fastboot flashall
Bug: 194686221
Change-Id: I62f170e14860d865453ab52793e346fe4066c6d4
---
 fastboot/fastboot.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 46786553adbe..faaca1d69466 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1076,9 +1076,7 @@ static bool load_buf(const char* fname, struct fastboot_buffer* buf) {
     unique_fd fd(TEMP_FAILURE_RETRY(open(fname, O_RDONLY | O_BINARY)));
 
     if (fd == -1) {
-        auto path = find_item_given_name(fname);
-        fd = unique_fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_BINARY)));
-        if (fd == -1) return false;
+        return false;
     }
 
     struct stat s;

From d62002cf06cd01b687d192095eb1514130095fc0 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 21 Jun 2023 14:27:35 -0700
Subject: [PATCH 0128/1487] Add flag to disable super optimization

Adding flag to turn off the super optimization. Makes for easier testing
as dynamic partitions flash tasks won't be replaced by one flash super
layout task

Test: fastboot flashall --disable-super-optimization
Bug: 194686221
Change-Id: I9142490ecfe587725872e4b734486d3db1728aa7
---
 fastboot/fastboot.cpp | 3 +++
 fastboot/fastboot.h   | 1 +
 fastboot/task.cpp     | 8 ++++++++
 3 files changed, 12 insertions(+)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index faaca1d69466..42d4f60d0fa9 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -2191,6 +2191,7 @@ int FastBootTool::Main(int argc, char* argv[]) {
                                       {"cmdline", required_argument, 0, 0},
                                       {"disable-verification", no_argument, 0, 0},
                                       {"disable-verity", no_argument, 0, 0},
+                                      {"disable-super-optimization", no_argument, 0, 0},
                                       {"force", no_argument, 0, 0},
                                       {"fs-options", required_argument, 0, 0},
                                       {"header-version", required_argument, 0, 0},
@@ -2228,6 +2229,8 @@ int FastBootTool::Main(int argc, char* argv[]) {
                 g_disable_verification = true;
             } else if (name == "disable-verity") {
                 g_disable_verity = true;
+            } else if (name == "disable-super-optimization") {
+                fp->should_optimize_flash_super = false;
             } else if (name == "force") {
                 fp->force_flash = true;
             } else if (name == "fs-options") {
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index 4b48d4a2d3a6..ae488d82d2c7 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -96,6 +96,7 @@ struct FlashingPlan {
     bool wants_set_active = false;
     bool skip_secondary = false;
     bool force_flash = false;
+    bool should_optimize_flash_super = true;
 
     std::string slot_override;
     std::string current_slot;
diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index 03f9b8942bb2..96b952c94521 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -124,6 +124,10 @@ std::string FlashSuperLayoutTask::ToString() {
 
 std::unique_ptr<FlashSuperLayoutTask> FlashSuperLayoutTask::Initialize(
         const FlashingPlan* fp, std::vector<ImageEntry>& os_images) {
+    if (!fp->should_optimize_flash_super) {
+        LOG(INFO) << "super optimization is disabled";
+        return nullptr;
+    }
     if (!supports_AB()) {
         LOG(VERBOSE) << "Cannot optimize flashing super on non-AB device";
         return nullptr;
@@ -188,6 +192,10 @@ std::unique_ptr<FlashSuperLayoutTask> FlashSuperLayoutTask::Initialize(
 
 std::unique_ptr<FlashSuperLayoutTask> FlashSuperLayoutTask::InitializeFromTasks(
         const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>& tasks) {
+    if (!fp->should_optimize_flash_super) {
+        LOG(INFO) << "super optimization is disabled";
+        return nullptr;
+    }
     if (!supports_AB()) {
         LOG(VERBOSE) << "Cannot optimize flashing super on non-AB device";
         return nullptr;

From 5769b268bf23fcbcb74d70b883339745d446847f Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 21 Jun 2023 14:41:11 -0700
Subject: [PATCH 0129/1487] use FlashingPlan sparse_limit for testing

Have get_sparse_limit() return FlashingPlan's sparse limit if set. Used
for testing to compare task lists

Test: fastboot_test
Change-Id: I7ac1eb4dc83a53b3d7aa59aa668a780b4b550664
---
 fastboot/fastboot.cpp | 36 ++++++++++++++++++------------------
 fastboot/fastboot.h   |  5 +++--
 fastboot/task.cpp     | 14 ++++++++------
 fastboot/task.h       |  3 ++-
 4 files changed, 31 insertions(+), 27 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 42d4f60d0fa9..7a036a25577e 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -104,7 +104,6 @@ static bool g_long_listing = false;
 // libsparse will support INT_MAX, but this results in large allocations, so
 // let's keep it at 1GB to avoid memory pressure on the host.
 static constexpr int64_t RESPARSE_LIMIT = 1 * 1024 * 1024 * 1024;
-static uint64_t sparse_limit = 0;
 static int64_t target_sparse_limit = -1;
 
 static unsigned g_base_addr = 0x10000000;
@@ -1016,8 +1015,8 @@ static uint64_t get_uint_var(const char* var_name) {
     return value;
 }
 
-int64_t get_sparse_limit(int64_t size) {
-    int64_t limit = sparse_limit;
+int64_t get_sparse_limit(int64_t size, const FlashingPlan* fp) {
+    int64_t limit = int64_t(fp->sparse_limit);
     if (limit == 0) {
         // Unlimited, so see what the target device's limit is.
         // TODO: shouldn't we apply this limit even if you've used -S?
@@ -1038,7 +1037,7 @@ int64_t get_sparse_limit(int64_t size) {
     return 0;
 }
 
-static bool load_buf_fd(unique_fd fd, struct fastboot_buffer* buf) {
+static bool load_buf_fd(unique_fd fd, struct fastboot_buffer* buf, const FlashingPlan* fp) {
     int64_t sz = get_file_size(fd);
     if (sz == -1) {
         return false;
@@ -1056,7 +1055,7 @@ static bool load_buf_fd(unique_fd fd, struct fastboot_buffer* buf) {
     }
 
     lseek(fd.get(), 0, SEEK_SET);
-    int64_t limit = get_sparse_limit(sz);
+    int64_t limit = get_sparse_limit(sz, fp);
     buf->fd = std::move(fd);
     if (limit) {
         buf->files = load_sparse_files(buf->fd.get(), limit);
@@ -1072,7 +1071,7 @@ static bool load_buf_fd(unique_fd fd, struct fastboot_buffer* buf) {
     return true;
 }
 
-static bool load_buf(const char* fname, struct fastboot_buffer* buf) {
+static bool load_buf(const char* fname, struct fastboot_buffer* buf, const FlashingPlan* fp) {
     unique_fd fd(TEMP_FAILURE_RETRY(open(fname, O_RDONLY | O_BINARY)));
 
     if (fd == -1) {
@@ -1088,7 +1087,7 @@ static bool load_buf(const char* fname, struct fastboot_buffer* buf) {
         return false;
     }
 
-    return load_buf_fd(std::move(fd), buf);
+    return load_buf_fd(std::move(fd), buf, fp);
 }
 
 static void rewrite_vbmeta_buffer(struct fastboot_buffer* buf, bool vbmeta_in_boot) {
@@ -1490,12 +1489,12 @@ void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,
     verbose("Do flash %s %s", pname, fname);
     struct fastboot_buffer buf;
 
-    if (fp->source) {
+    if (fp && fp->source) {
         unique_fd fd = fp->source->OpenFile(fname);
-        if (fd < 0 || !load_buf_fd(std::move(fd), &buf)) {
+        if (fd < 0 || !load_buf_fd(std::move(fd), &buf, fp)) {
             die("could not load '%s': %s", fname, strerror(errno));
         }
-    } else if (!load_buf(fname, &buf)) {
+    } else if (!load_buf(fname, &buf, fp)) {
         die("cannot load '%s': %s", fname, strerror(errno));
     }
 
@@ -1873,7 +1872,7 @@ void FlashAllTool::FlashImages(const std::vector<std::pair<const Image*, std::st
     for (const auto& [image, slot] : images) {
         fastboot_buffer buf;
         unique_fd fd = fp_->source->OpenFile(image->img_name);
-        if (fd < 0 || !load_buf_fd(std::move(fd), &buf)) {
+        if (fd < 0 || !load_buf_fd(std::move(fd), &buf, fp_)) {
             if (image->optional_if_no_image) {
                 continue;
             }
@@ -1982,7 +1981,7 @@ static unsigned fb_get_flash_block_size(std::string name) {
 
 void fb_perform_format(const std::string& partition, int skip_if_not_supported,
                        const std::string& type_override, const std::string& size_override,
-                       const unsigned fs_options) {
+                       const unsigned fs_options, const FlashingPlan* fp) {
     std::string partition_type, partition_size;
 
     struct fastboot_buffer buf;
@@ -1995,8 +1994,8 @@ void fb_perform_format(const std::string& partition, int skip_if_not_supported,
     if (target_sparse_limit > 0 && target_sparse_limit < limit) {
         limit = target_sparse_limit;
     }
-    if (sparse_limit > 0 && sparse_limit < limit) {
-        limit = sparse_limit;
+    if (fp->sparse_limit > 0 && fp->sparse_limit < limit) {
+        limit = fp->sparse_limit;
     }
 
     if (fb->GetVar("partition-type:" + partition, &partition_type) != fastboot::SUCCESS) {
@@ -2051,7 +2050,7 @@ void fb_perform_format(const std::string& partition, int skip_if_not_supported,
     if (fd == -1) {
         die("Cannot open generated image: %s", strerror(errno));
     }
-    if (!load_buf_fd(std::move(fd), &buf)) {
+    if (!load_buf_fd(std::move(fd), &buf, fp)) {
         die("Cannot read image: %s", strerror(errno));
     }
     flash_buf(partition, &buf, is_vbmeta_partition(partition));
@@ -2286,7 +2285,7 @@ int FastBootTool::Main(int argc, char* argv[]) {
                     serial = optarg;
                     break;
                 case 'S':
-                    if (!android::base::ParseByteCount(optarg, &sparse_limit)) {
+                    if (!android::base::ParseByteCount(optarg, &fp->sparse_limit)) {
                         die("invalid sparse limit %s", optarg);
                     }
                     break;
@@ -2404,7 +2403,8 @@ int FastBootTool::Main(int argc, char* argv[]) {
             std::string partition = next_arg(&args);
 
             auto format = [&](const std::string& partition) {
-                fb_perform_format(partition, 0, type_override, size_override, fp->fs_options);
+                fb_perform_format(partition, 0, type_override, size_override, fp->fs_options,
+                                  fp.get());
             };
             do_for_partitions(partition, fp->slot_override, format, true);
         } else if (command == "signature") {
@@ -2498,7 +2498,7 @@ int FastBootTool::Main(int argc, char* argv[]) {
             std::string filename = next_arg(&args);
 
             struct fastboot_buffer buf;
-            if (!load_buf(filename.c_str(), &buf) || buf.type != FB_BUFFER_FD) {
+            if (!load_buf(filename.c_str(), &buf, fp.get()) || buf.type != FB_BUFFER_FD) {
                 die("cannot load '%s'", filename.c_str());
             }
             fb->Download(filename, buf.fd.get(), buf.sz);
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index ae488d82d2c7..d4e0ae902d5c 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -97,6 +97,7 @@ struct FlashingPlan {
     bool skip_secondary = false;
     bool force_flash = false;
     bool should_optimize_flash_super = true;
+    uint64_t sparse_limit = 0;
 
     std::string slot_override;
     std::string current_slot;
@@ -176,11 +177,11 @@ Result<NetworkSerial, FastbootError> ParseNetworkSerial(const std::string& seria
 bool supports_AB();
 std::string GetPartitionName(const ImageEntry& entry, const std::string& current_slot_);
 void flash_partition_files(const std::string& partition, const std::vector<SparsePtr>& files);
-int64_t get_sparse_limit(int64_t size);
+int64_t get_sparse_limit(int64_t size, const FlashingPlan* fp);
 std::vector<SparsePtr> resparse_file(sparse_file* s, int64_t max_size);
 
 bool is_retrofit_device();
 bool is_logical(const std::string& partition);
 void fb_perform_format(const std::string& partition, int skip_if_not_supported,
                        const std::string& type_override, const std::string& size_override,
-                       const unsigned fs_options);
+                       const unsigned fs_options, const FlashingPlan* fp);
diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index 96b952c94521..c1b9a31a121d 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -98,18 +98,20 @@ std::string RebootTask::ToString() {
 
 FlashSuperLayoutTask::FlashSuperLayoutTask(const std::string& super_name,
                                            std::unique_ptr<SuperFlashHelper> helper,
-                                           SparsePtr sparse_layout, uint64_t super_size)
+                                           SparsePtr sparse_layout, uint64_t super_size,
+                                           const FlashingPlan* fp)
     : super_name_(super_name),
       helper_(std::move(helper)),
       sparse_layout_(std::move(sparse_layout)),
-      super_size_(super_size) {}
+      super_size_(super_size),
+      fp_(fp) {}
 
 void FlashSuperLayoutTask::Run() {
     // Use the reported super partition size as the upper limit, rather than
     // sparse_file_len, which (1) can fail and (2) is kind of expensive, since
     // it will map in all of the embedded fds.
     std::vector<SparsePtr> files;
-    if (int limit = get_sparse_limit(super_size_)) {
+    if (int limit = get_sparse_limit(super_size_, fp_)) {
         files = resparse_file(sparse_layout_.get(), limit);
     } else {
         files.emplace_back(std::move(sparse_layout_));
@@ -187,7 +189,7 @@ std::unique_ptr<FlashSuperLayoutTask> FlashSuperLayoutTask::Initialize(
     os_images.erase(std::remove_if(os_images.begin(), os_images.end(), remove_if_callback),
                     os_images.end());
     return std::make_unique<FlashSuperLayoutTask>(super_name, std::move(helper), std::move(s),
-                                                  partition_size);
+                                                  partition_size, fp);
 }
 
 std::unique_ptr<FlashSuperLayoutTask> FlashSuperLayoutTask::InitializeFromTasks(
@@ -260,7 +262,7 @@ std::unique_ptr<FlashSuperLayoutTask> FlashSuperLayoutTask::InitializeFromTasks(
     tasks.erase(std::remove_if(tasks.begin(), tasks.end(), remove_if_callback), tasks.end());
 
     return std::make_unique<FlashSuperLayoutTask>(super_name, std::move(helper), std::move(s),
-                                                  partition_size);
+                                                  partition_size, fp);
 }
 
 UpdateSuperTask::UpdateSuperTask(const FlashingPlan* fp) : fp_(fp) {}
@@ -330,7 +332,7 @@ void WipeTask::Run() {
         LOG(ERROR) << "wipe task erase failed with partition: " << pname_;
         return;
     }
-    fb_perform_format(pname_, 1, partition_type, "", fp_->fs_options);
+    fb_perform_format(pname_, 1, partition_type, "", fp_->fs_options, fp_);
 }
 
 std::string WipeTask::ToString() {
diff --git a/fastboot/task.h b/fastboot/task.h
index 500655dbb7c3..858f43a2e86d 100644
--- a/fastboot/task.h
+++ b/fastboot/task.h
@@ -82,7 +82,7 @@ class RebootTask : public Task {
 class FlashSuperLayoutTask : public Task {
   public:
     FlashSuperLayoutTask(const std::string& super_name, std::unique_ptr<SuperFlashHelper> helper,
-                         SparsePtr sparse_layout, uint64_t super_size);
+                         SparsePtr sparse_layout, uint64_t super_size, const FlashingPlan* fp);
     static std::unique_ptr<FlashSuperLayoutTask> Initialize(const FlashingPlan* fp,
                                                             std::vector<ImageEntry>& os_images);
     static std::unique_ptr<FlashSuperLayoutTask> InitializeFromTasks(
@@ -96,6 +96,7 @@ class FlashSuperLayoutTask : public Task {
     std::unique_ptr<SuperFlashHelper> helper_;
     SparsePtr sparse_layout_;
     uint64_t super_size_;
+    const FlashingPlan* fp_;
 };
 
 class UpdateSuperTask : public Task {

From ba07ef57329c857592c9c10da9e71a5efb4a27aa Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 21 Jun 2023 14:14:19 -0700
Subject: [PATCH 0130/1487] Change HardcodedFlash to add flashtasks

Changing Hardcoded FLash to add flash tasks, also modifying do_flash to
download signature data if a source is provided

Test: fastboot flashall
Change-Id: Ic33bc4076f269d0d48146a3de457a72eedd5e6df
---
 fastboot/fastboot.cpp | 46 ++++++++++++++++++-------------------------
 fastboot/fastboot.h   |  8 +++++---
 2 files changed, 24 insertions(+), 30 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 7a036a25577e..30eb7b5fcd5b 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1494,6 +1494,13 @@ void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,
         if (fd < 0 || !load_buf_fd(std::move(fd), &buf, fp)) {
             die("could not load '%s': %s", fname, strerror(errno));
         }
+        std::vector<char> signature_data;
+        std::string file_string(fname);
+        if (fp->source->ReadFile(file_string.substr(0, file_string.find('.')) + ".sig",
+                                 &signature_data)) {
+            fb->Download("signature", signature_data);
+            fb->RawCommand("signature", "installing signature");
+        }
     } else if (!load_buf(fname, &buf, fp)) {
         die("cannot load '%s': %s", fname, strerror(errno));
     }
@@ -1780,7 +1787,10 @@ void FlashAllTool::Flash() {
 
     CancelSnapshotIfNeeded();
 
-    HardcodedFlash();
+    tasks_ = CollectTasksFromImageList();
+    for (auto& task : tasks_) {
+        task->Run();
+    }
     return;
 }
 
@@ -1832,13 +1842,12 @@ void FlashAllTool::CollectImages() {
     }
 }
 
-void FlashAllTool::HardcodedFlash() {
+std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasksFromImageList() {
     CollectImages();
     // First flash boot partitions. We allow this to happen either in userspace
     // or in bootloader fastboot.
-    FlashImages(boot_images_);
-
     std::vector<std::unique_ptr<Task>> tasks;
+    AddFlashTasks(boot_images_, tasks);
 
     if (auto flash_super_task = FlashSuperLayoutTask::Initialize(fp_, os_images_)) {
         tasks.emplace_back(std::move(flash_super_task));
@@ -1862,13 +1871,12 @@ void FlashAllTool::HardcodedFlash() {
             tasks.emplace_back(std::make_unique<ResizeTask>(fp_, image->part_name, "0", slot));
         }
     }
-    for (auto& i : tasks) {
-        i->Run();
-    }
-    FlashImages(os_images_);
+    AddFlashTasks(os_images_, tasks);
+    return tasks;
 }
 
-void FlashAllTool::FlashImages(const std::vector<std::pair<const Image*, std::string>>& images) {
+void FlashAllTool::AddFlashTasks(const std::vector<std::pair<const Image*, std::string>>& images,
+                                 std::vector<std::unique_ptr<Task>>& tasks) {
     for (const auto& [image, slot] : images) {
         fastboot_buffer buf;
         unique_fd fd = fp_->source->OpenFile(image->img_name);
@@ -1878,27 +1886,11 @@ void FlashAllTool::FlashImages(const std::vector<std::pair<const Image*, std::st
             }
             die("could not load '%s': %s", image->img_name.c_str(), strerror(errno));
         }
-        FlashImage(*image, slot, &buf);
+        tasks.emplace_back(std::make_unique<FlashTask>(slot, image->part_name, image->img_name,
+                                                       is_vbmeta_partition(image->part_name), fp_));
     }
 }
 
-void FlashAllTool::FlashImage(const Image& image, const std::string& slot, fastboot_buffer* buf) {
-    auto flash = [&, this](const std::string& partition_name) {
-        std::vector<char> signature_data;
-        if (fp_->source->ReadFile(image.sig_name, &signature_data)) {
-            fb->Download("signature", signature_data);
-            fb->RawCommand("signature", "installing signature");
-        }
-
-        if (is_logical(partition_name)) {
-            fb->ResizePartition(partition_name, std::to_string(buf->image_size));
-        }
-
-        flash_buf(partition_name.c_str(), buf, is_vbmeta_partition(partition_name));
-    };
-    do_for_partitions(image.part_name, slot, flash, false);
-}
-
 bool ZipImageSource::ReadFile(const std::string& name, std::vector<char>* out) const {
     return UnzipToMemory(zip_, name, out);
 }
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index d4e0ae902d5c..196bd67261ca 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -116,12 +116,14 @@ class FlashAllTool {
     void CheckRequirements();
     void DetermineSlot();
     void CollectImages();
-    void FlashImages(const std::vector<std::pair<const Image*, std::string>>& images);
-    void FlashImage(const Image& image, const std::string& slot, fastboot_buffer* buf);
-    void HardcodedFlash();
+    void AddFlashTasks(const std::vector<std::pair<const Image*, std::string>>& images,
+                       std::vector<std::unique_ptr<Task>>& tasks);
+    std::vector<std::unique_ptr<Task>> CollectTasksFromImageList();
 
     std::vector<ImageEntry> boot_images_;
     std::vector<ImageEntry> os_images_;
+    std::vector<std::unique_ptr<Task>> tasks_;
+
     FlashingPlan* fp_;
 };
 

From 14e7b76dcf917041b2d2e6256c850fe9f987c35d Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Thu, 22 Jun 2023 18:56:07 +0000
Subject: [PATCH 0131/1487] init_kill_services_test: wait 120s for apexd

This is likely waiting for the Java garbage collector to run,
and due to the lockless implementation of BinderProxyNativeData
and BpBinder, it's very difficult to efficiently force this
object to be deleted.

Change-Id: I4df667b9b47327967a43d75664fb506b8704f905
Fixes: 285458033
Test: N/A
---
 init/test_kill_services/init_kill_services_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/test_kill_services/init_kill_services_test.cpp b/init/test_kill_services/init_kill_services_test.cpp
index dd4606449621..510ad8aee898 100644
--- a/init/test_kill_services/init_kill_services_test.cpp
+++ b/init/test_kill_services/init_kill_services_test.cpp
@@ -32,7 +32,7 @@ void ExpectKillingServiceRecovers(const std::string& service_name) {
     // b/280514080 - servicemanager will restart apexd, and apexd will restart the
     // system when crashed. This is fine as the device recovers, but it causes
     // flakes in this test.
-    ASSERT_TRUE(WaitForProperty("init.svc.apexd", "stopped", 60s))
+    ASSERT_TRUE(WaitForProperty("init.svc.apexd", "stopped", 120s))
             << (system("cat /dev/binderfs/binder_logs/state"), "apexd won't stop");
 
     LOG(INFO) << "hello " << service_name << "!";

From 0236af54cd25eb3e3f9c7238affc53df07e4b1a2 Mon Sep 17 00:00:00 2001
From: "A. Cody Schuffelen" <schuffelen@google.com>
Date: Thu, 22 Jun 2023 17:06:40 -0700
Subject: [PATCH 0132/1487] Build libsparse and simg2img for Mac OS X as part
 of Cuttlefish launcher tools

Bug: 288493595
Test: m libsparse simg2img
Change-Id: I9e0c5c77b9b2b5994bf52e1ca9fdb84bc1523d5d
---
 libsparse/Android.bp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/libsparse/Android.bp b/libsparse/Android.bp
index 8e83e1670ecd..5a7d0fc78f7c 100644
--- a/libsparse/Android.bp
+++ b/libsparse/Android.bp
@@ -28,6 +28,9 @@ cc_library {
         "libbase",
     ],
     target: {
+        darwin: {
+            enabled: true,
+        },
         windows: {
             enabled: true,
         },
@@ -52,6 +55,11 @@ cc_binary {
     ],
 
     cflags: ["-Werror"],
+    target: {
+        darwin: {
+            enabled: true,
+        },
+    },
 }
 
 cc_binary {

From 27fb5200aad12c597d74af696a6e94cf187b3876 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 15 Jun 2023 12:13:29 -0700
Subject: [PATCH 0133/1487] libsnapshot: Add a helper around
 CowReader::GetRawBytes.

This avoids having to use op->source which will require more work after
the new format lands.

Bug: 280529365
Test: inspect_cow
Change-Id: Iffa18974bb0152dad73d69bb03c683f1aa549031
---
 .../libsnapshot/include/libsnapshot/cow_reader.h   |  1 +
 fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp  | 14 +++++++++++++-
 fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp |  4 ++--
 3 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index 3890b175434a..f5995015a8a3 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -133,6 +133,7 @@ class CowReader final : public ICowReader {
 
     CowHeader& GetHeader() override { return header_; }
 
+    bool GetRawBytes(const CowOperation* op, void* buffer, size_t len, size_t* read);
     bool GetRawBytes(uint64_t offset, void* buffer, size_t len, size_t* read);
 
     // Returns the total number of data ops that should be merged. This is the
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index c2a7fdb39519..4ac89ae4f550 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -230,7 +230,7 @@ bool CowReader::PrepMergeOps() {
             size_t seq_len = current_op.data_length / sizeof(uint32_t);
 
             merge_op_blocks->resize(merge_op_blocks->size() + seq_len);
-            if (!GetRawBytes(current_op.source, &merge_op_blocks->data()[num_seqs],
+            if (!GetRawBytes(&current_op, &merge_op_blocks->data()[num_seqs],
                              current_op.data_length, &read)) {
                 PLOG(ERROR) << "Failed to read sequence op!";
                 return false;
@@ -516,6 +516,18 @@ std::unique_ptr<ICowOpIter> CowReader::GetMergeOpIter(bool ignore_progress) {
                                             ignore_progress ? 0 : merge_op_start_);
 }
 
+bool CowReader::GetRawBytes(const CowOperation* op, void* buffer, size_t len, size_t* read) {
+    switch (op->type) {
+        case kCowSequenceOp:
+        case kCowReplaceOp:
+        case kCowXorOp:
+            return GetRawBytes(op->source, buffer, len, read);
+        default:
+            LOG(ERROR) << "Cannot get raw bytes of non-data op: " << *op;
+            return false;
+    }
+}
+
 bool CowReader::GetRawBytes(uint64_t offset, void* buffer, size_t len, size_t* read) {
     // Validate the offset, taking care to acknowledge possible overflow of offset+len.
     if (offset < header_.prefix.header_size || offset >= fd_size_ - sizeof(CowFooter) ||
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
index 148ecb006e5c..a6dee4f43138 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
@@ -57,7 +57,7 @@ static void ShowBad(CowReader& reader, const struct CowOperation* op) {
     size_t count;
     auto buffer = std::make_unique<uint8_t[]>(op->data_length);
 
-    if (!reader.GetRawBytes(op->source, buffer.get(), op->data_length, &count)) {
+    if (!reader.GetRawBytes(op, buffer.get(), op->data_length, &count)) {
         std::cerr << "Failed to read at all!\n";
     } else {
         std::cout << "The Block data is:\n";
@@ -199,7 +199,7 @@ static bool Inspect(const std::string& path) {
             std::vector<uint32_t> merge_op_blocks;
             size_t seq_len = op->data_length / sizeof(uint32_t);
             merge_op_blocks.resize(seq_len);
-            if (!reader.GetRawBytes(op->source, merge_op_blocks.data(), op->data_length, &read)) {
+            if (!reader.GetRawBytes(op, merge_op_blocks.data(), op->data_length, &read)) {
                 PLOG(ERROR) << "Failed to read sequence op!";
                 return false;
             }

From 918971c69ea76c5638dd0e9c7334b69d7d628f03 Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Fri, 23 Jun 2023 14:16:31 +0900
Subject: [PATCH 0134/1487] No need to read ro.apex.updatable now

Bug: 288202251
Test: m
Test: device boots
Change-Id: I97a3c2fab69489cdfbb5103b148194d7e2ee4d1a
---
 init/Android.bp          |  1 -
 init/mount_namespace.cpp | 19 +------------------
 init/service.cpp         |  3 +--
 3 files changed, 2 insertions(+), 21 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index f62d7b767dfe..b4184d0bf0ea 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -228,7 +228,6 @@ cc_library_static {
     ],
     whole_static_libs: [
         "libcap",
-        "libcom.android.sysprop.apex",
         "libcom.android.sysprop.init",
     ],
     header_libs: ["bootimg_headers"],
diff --git a/init/mount_namespace.cpp b/init/mount_namespace.cpp
index fead371d1e94..5b53d5092227 100644
--- a/init/mount_namespace.cpp
+++ b/init/mount_namespace.cpp
@@ -21,7 +21,6 @@
 #include <string>
 #include <vector>
 
-#include <ApexProperties.sysprop.h>
 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/properties.h>
@@ -30,16 +29,6 @@
 
 #include "util.h"
 
-#ifndef RECOVERY
-#define ACTIVATE_FLATTENED_APEX 1
-#endif
-
-#ifdef ACTIVATE_FLATTENED_APEX
-#include <apex_manifest.pb.h>
-#include <com_android_apex.h>
-#include <selinux/android.h>
-#endif  // ACTIVATE_FLATTENED_APEX
-
 namespace android {
 namespace init {
 namespace {
@@ -77,15 +66,9 @@ static std::string GetMountNamespaceId() {
     return ret;
 }
 
-static bool IsApexUpdatable() {
-    static bool updatable = android::sysprop::ApexProperties::updatable().value_or(false);
-    return updatable;
-}
-
 // In case we have two sets of APEXes (non-updatable, updatable), we need two separate mount
 // namespaces.
 static bool NeedsTwoMountNamespaces() {
-    if (!IsApexUpdatable()) return false;
     if (IsRecoveryMode()) return false;
     // In microdroid, there's only one set of APEXes in built-in directories include block devices.
     if (IsMicrodroid()) return false;
@@ -193,7 +176,7 @@ bool SetupMountNamespaces() {
 // Switch the mount namespace of the current process from bootstrap to default OR from default to
 // bootstrap. If the current mount namespace is neither bootstrap nor default, keep it that way.
 Result<void> SwitchToMountNamespaceIfNeeded(MountNamespace target_mount_namespace) {
-    if (IsRecoveryMode() || !IsApexUpdatable()) {
+    if (IsRecoveryMode()) {
         // we don't have multiple namespaces in recovery mode or if apex is not updatable
         return {};
     }
diff --git a/init/service.cpp b/init/service.cpp
index 29457084b05f..a0b3478c0b41 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -50,7 +50,6 @@
 #endif
 
 #ifdef INIT_FULL_SOURCES
-#include <ApexProperties.sysprop.h>
 #include <android/api-level.h>
 
 #include "mount_namespace.h"
@@ -323,7 +322,7 @@ void Service::Reap(const siginfo_t& siginfo) {
     }
 
 #if INIT_FULL_SOURCES
-    static bool is_apex_updatable = android::sysprop::ApexProperties::updatable().value_or(false);
+    static bool is_apex_updatable = true;
 #else
     static bool is_apex_updatable = false;
 #endif

From c7998f2abbe67595100bb7db4711d3d991b59a45 Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Thu, 22 Jun 2023 08:44:11 -0700
Subject: [PATCH 0135/1487] Remove dead code from fs_mgr

Test: Compiles
Change-Id: I76402758396b658fc1539f81541b162723b709a2
---
 fs_mgr/fs_mgr.cpp       | 45 ++++-------------------------------------
 fs_mgr/include/fs_mgr.h |  8 ++------
 2 files changed, 6 insertions(+), 47 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index debcb3e58e08..7f4959f7f1f8 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -1849,18 +1849,14 @@ int fs_mgr_do_mount_one(const FstabEntry& entry, const std::string& alt_mount_po
     return ret;
 }
 
-// If tmp_mount_point is non-null, mount the filesystem there.  This is for the
-// tmp mount we do to check the user password
 // If multiple fstab entries are to be mounted on "n_name", it will try to mount each one
 // in turn, and stop on 1st success, or no more match.
-static int fs_mgr_do_mount_helper(Fstab* fstab, const std::string& n_name,
-                                  const std::string& n_blk_device, const char* tmp_mount_point,
-                                  int needs_checkpoint, bool metadata_encrypted,
-                                  bool needs_encrypt) {
+int fs_mgr_do_mount(Fstab* fstab, const std::string& n_name, const std::string& n_blk_device,
+                    int needs_checkpoint, bool needs_encrypt) {
     int mount_errors = 0;
     int first_mount_errno = 0;
     std::string mount_point;
-    CheckpointManager checkpoint_manager(needs_checkpoint, metadata_encrypted, needs_encrypt);
+    CheckpointManager checkpoint_manager(needs_checkpoint, true, needs_encrypt);
     AvbUniquePtr avb_handle(nullptr);
 
     if (!fstab) {
@@ -1902,11 +1898,7 @@ static int fs_mgr_do_mount_helper(Fstab* fstab, const std::string& n_name,
         }
 
         // Now mount it where requested */
-        if (tmp_mount_point) {
-            mount_point = tmp_mount_point;
-        } else {
-            mount_point = fstab_entry.mount_point;
-        }
+        mount_point = fstab_entry.mount_point;
 
         int fs_stat = prepare_fs_for_mount(n_blk_device, fstab_entry, mount_point);
 
@@ -1963,35 +1955,6 @@ static int fs_mgr_do_mount_helper(Fstab* fstab, const std::string& n_name,
     return FS_MGR_DOMNT_FAILED;
 }
 
-int fs_mgr_do_mount(Fstab* fstab, const char* n_name, char* n_blk_device, char* tmp_mount_point) {
-    return fs_mgr_do_mount_helper(fstab, n_name, n_blk_device, tmp_mount_point, -1, false, false);
-}
-
-int fs_mgr_do_mount(Fstab* fstab, const char* n_name, char* n_blk_device, char* tmp_mount_point,
-                    bool needs_checkpoint, bool metadata_encrypted, bool needs_encrypt) {
-    return fs_mgr_do_mount_helper(fstab, n_name, n_blk_device, tmp_mount_point, needs_checkpoint,
-                                  metadata_encrypted, needs_encrypt);
-}
-
-/*
- * mount a tmpfs filesystem at the given point.
- * return 0 on success, non-zero on failure.
- */
-int fs_mgr_do_tmpfs_mount(const char *n_name)
-{
-    int ret;
-
-    ret = mount("tmpfs", n_name, "tmpfs", MS_NOATIME | MS_NOSUID | MS_NODEV | MS_NOEXEC,
-                CRYPTO_TMPFS_OPTIONS);
-    if (ret < 0) {
-        LERROR << "Cannot mount tmpfs filesystem at " << n_name;
-        return -1;
-    }
-
-    /* Success */
-    return 0;
-}
-
 static bool ConfigureIoScheduler(const std::string& device_path) {
     if (!StartsWith(device_path, "/dev/")) {
         LERROR << __func__ << ": invalid argument " << device_path;
diff --git a/fs_mgr/include/fs_mgr.h b/fs_mgr/include/fs_mgr.h
index 37515d4653c7..bc4a7a6c2cf5 100644
--- a/fs_mgr/include/fs_mgr.h
+++ b/fs_mgr/include/fs_mgr.h
@@ -85,14 +85,10 @@ MountAllResult fs_mgr_mount_all(android::fs_mgr::Fstab* fstab, int mount_mode);
 #define FS_MGR_DOMNT_FAILED (-1)
 #define FS_MGR_DOMNT_BUSY (-2)
 #define FS_MGR_DOMNT_SUCCESS 0
-int fs_mgr_do_mount(android::fs_mgr::Fstab* fstab, const char* n_name, char* n_blk_device,
-                    char* tmp_mount_point);
-int fs_mgr_do_mount(android::fs_mgr::Fstab* fstab, const char* n_name, char* n_blk_device,
-                    char* tmp_mount_point, bool need_cp, bool metadata_encrypted,
-                    bool need_encrypted);
+int fs_mgr_do_mount(android::fs_mgr::Fstab* fstab, const std::string& n_name,
+                    const std::string& n_blk_device, int needs_checkpoint, bool needs_encrypt);
 int fs_mgr_do_mount_one(const android::fs_mgr::FstabEntry& entry,
                         const std::string& mount_point = "");
-int fs_mgr_do_tmpfs_mount(const char *n_name);
 bool fs_mgr_load_verity_state(int* mode);
 // Returns true if verity is enabled on this particular FstabEntry.
 bool fs_mgr_is_verity_enabled(const android::fs_mgr::FstabEntry& entry);

From 09ccef4961659a724b860a5e166024a65757c15e Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 16 Jun 2023 13:47:56 -0700
Subject: [PATCH 0136/1487] libsnapshot: Add helpers for accessing CowOperation
 offsets.

These helpers avoid manual inspection of CowOperation::source, and
fiddling with block sizes.

Bug: 280529365
Test: cow_api_test
      vts_libsnapshot_test
      apply OTA
Change-Id: I1ba276e155eb8232a3115066caaa11030c171e11
---
 .../include/libsnapshot/cow_reader.h          | 13 ++++++++
 .../libsnapshot_cow/cow_reader.cpp            | 29 ++++++++++------
 .../libsnapshot_cow/snapshot_reader.cpp       | 14 ++++++--
 .../dm-snapshot-merge/snapuserd_worker.cpp    | 13 ++++----
 .../user-space-merge/snapuserd_dm_user.cpp    | 11 ++++---
 .../user-space-merge/snapuserd_readahead.cpp  | 33 +++++++++++--------
 .../user-space-merge/snapuserd_readahead.h    |  1 +
 7 files changed, 77 insertions(+), 37 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index f5995015a8a3..d0369e5d7d1b 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -73,8 +73,20 @@ class ICowReader {
     // The operation pointer must derive from ICowOpIter::Get().
     virtual ssize_t ReadData(const CowOperation* op, void* buffer, size_t buffer_size,
                              size_t ignore_bytes = 0) = 0;
+
+    // Get the absolute source offset, in bytes, of a CowOperation. Returns
+    // false if the operation does not read from source partitions.
+    virtual bool GetSourceOffset(const CowOperation* op, uint64_t* source_offset) = 0;
 };
 
+static constexpr uint64_t GetBlockFromOffset(const CowHeader& header, uint64_t offset) {
+    return offset / header.block_size;
+}
+
+static constexpr uint64_t GetBlockRelativeOffset(const CowHeader& header, uint64_t offset) {
+    return offset % header.block_size;
+}
+
 // Iterate over a sequence of COW operations. The iterator is bidirectional.
 class ICowOpIter {
   public:
@@ -119,6 +131,7 @@ class CowReader final : public ICowReader {
     bool VerifyMergeOps() override;
     bool GetFooter(CowFooter* footer) override;
     bool GetLastLabel(uint64_t* label) override;
+    bool GetSourceOffset(const CowOperation* op, uint64_t* source_offset) override;
 
     // Create a CowOpIter object which contains footer_.num_ops
     // CowOperation objects. Get() returns a unique CowOperation object
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 4ac89ae4f550..cffc8dedbea6 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -312,19 +312,15 @@ bool CowReader::VerifyMergeOps() {
     std::unordered_map<uint64_t, const CowOperation*> overwritten_blocks;
     while (!itr->AtEnd()) {
         const auto& op = itr->Get();
-        uint64_t block;
-        bool offset;
-        if (op->type == kCowCopyOp) {
-            block = op->source;
-            offset = false;
-        } else if (op->type == kCowXorOp) {
-            block = op->source / header_.block_size;
-            offset = (op->source % header_.block_size) != 0;
-        } else {
+        uint64_t offset;
+        if (!GetSourceOffset(op, &offset)) {
             itr->Next();
             continue;
         }
 
+        uint64_t block = GetBlockFromOffset(header_, offset);
+        bool misaligned = (GetBlockRelativeOffset(header_, offset) != 0);
+
         const CowOperation* overwrite = nullptr;
         if (overwritten_blocks.count(block)) {
             overwrite = overwritten_blocks[block];
@@ -332,7 +328,7 @@ bool CowReader::VerifyMergeOps() {
                        << op << "\noverwritten by previously merged op:\n"
                        << *overwrite;
         }
-        if (offset && overwritten_blocks.count(block + 1)) {
+        if (misaligned && overwritten_blocks.count(block + 1)) {
             overwrite = overwritten_blocks[block + 1];
             LOG(ERROR) << "Invalid Sequence! Block needed for op:\n"
                        << op << "\noverwritten by previously merged op:\n"
@@ -622,5 +618,18 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
     return decompressor->Decompress(buffer, buffer_size, header_.block_size, ignore_bytes);
 }
 
+bool CowReader::GetSourceOffset(const CowOperation* op, uint64_t* source_offset) {
+    switch (op->type) {
+        case kCowCopyOp:
+            *source_offset = op->source * header_.block_size;
+            return true;
+        case kCowXorOp:
+            *source_offset = op->source;
+            return true;
+        default:
+            return false;
+    }
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
index f9cdbc0febf9..a3e40d962ce7 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
@@ -155,7 +155,12 @@ ssize_t CompressedSnapshotReader::ReadBlock(uint64_t chunk, size_t start_offset,
         }
 
         if (op) {
-            chunk = op->source;
+            uint64_t source_offset;
+            if (!cow_->GetSourceOffset(op, &source_offset)) {
+                LOG(ERROR) << "GetSourceOffset failed in CompressedSnapshotReader for op: " << *op;
+                return false;
+            }
+            chunk = GetBlockFromOffset(cow_->GetHeader(), source_offset);
         }
 
         off64_t offset = (chunk * block_size_) + start_offset;
@@ -179,7 +184,12 @@ ssize_t CompressedSnapshotReader::ReadBlock(uint64_t chunk, size_t start_offset,
             return -1;
         }
 
-        off64_t offset = op->source + start_offset;
+        uint64_t source_offset;
+        if (!cow_->GetSourceOffset(op, &source_offset)) {
+            LOG(ERROR) << "GetSourceOffset failed in CompressedSnapshotReader for op: " << *op;
+            return false;
+        }
+        off64_t offset = source_offset + start_offset;
 
         std::string data(bytes_to_read, '\0');
         if (!android::base::ReadFullyAtOffset(fd, data.data(), data.size(), offset)) {
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
index 922df34247c7..559dcc793e98 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
@@ -115,12 +115,13 @@ bool WorkerThread::ReadFromBaseDevice(const CowOperation* cow_op) {
         SNAP_LOG(ERROR) << "ReadFromBaseDevice: Failed to get payload buffer";
         return false;
     }
-    SNAP_LOG(DEBUG) << " ReadFromBaseDevice...: new-block: " << cow_op->new_block
-                    << " Source: " << cow_op->source;
-    uint64_t offset = cow_op->source;
-    if (cow_op->type == kCowCopyOp) {
-        offset *= BLOCK_SZ;
+    uint64_t offset;
+    if (!reader_->GetSourceOffset(cow_op, &offset)) {
+        SNAP_LOG(ERROR) << "ReadFromBaseDevice: Failed to get source offset";
+        return false;
     }
+    SNAP_LOG(DEBUG) << " ReadFromBaseDevice...: new-block: " << cow_op->new_block
+                    << " Source: " << offset;
     if (!android::base::ReadFullyAtOffset(backing_store_fd_, buffer, BLOCK_SZ, offset)) {
         SNAP_PLOG(ERROR) << "Copy op failed. Read from backing store: " << backing_store_device_
                          << "at block :" << offset / BLOCK_SZ << " offset:" << offset % BLOCK_SZ;
@@ -508,7 +509,7 @@ int WorkerThread::GetNumberOfMergedOps(void* merged_buffer, void* unmerged_buffe
                 if (read_ahead_buffer_map.find(cow_op->new_block) == read_ahead_buffer_map.end()) {
                     SNAP_LOG(ERROR)
                             << " Block: " << cow_op->new_block << " not found in read-ahead cache"
-                            << " Source: " << cow_op->source;
+                            << " Op: " << *cow_op;
                     return -1;
                 }
                 // If this is a final block merged in the read-ahead buffer
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
index 78582164f175..44b731912692 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
@@ -94,12 +94,13 @@ bool Worker::ReadFromSourceDevice(const CowOperation* cow_op) {
         SNAP_LOG(ERROR) << "ReadFromBaseDevice: Failed to get payload buffer";
         return false;
     }
-    SNAP_LOG(DEBUG) << " ReadFromBaseDevice...: new-block: " << cow_op->new_block
-                    << " Source: " << cow_op->source;
-    uint64_t offset = cow_op->source;
-    if (cow_op->type == kCowCopyOp) {
-        offset *= BLOCK_SZ;
+    uint64_t offset;
+    if (!reader_->GetSourceOffset(cow_op, &offset)) {
+        SNAP_LOG(ERROR) << "ReadFromSourceDevice: Failed to get source offset";
+        return false;
     }
+    SNAP_LOG(DEBUG) << " ReadFromBaseDevice...: new-block: " << cow_op->new_block
+                    << " Op: " << *cow_op;
     if (!android::base::ReadFullyAtOffset(backing_store_fd_, buffer, BLOCK_SZ, offset)) {
         std::string op;
         if (cow_op->type == kCowCopyOp)
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index af2428602962..399f7b81baf0 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -34,14 +34,17 @@ ReadAhead::ReadAhead(const std::string& cow_device, const std::string& backing_d
 }
 
 void ReadAhead::CheckOverlap(const CowOperation* cow_op) {
-    uint64_t source_block = cow_op->source;
-    uint64_t source_offset = 0;
-    if (cow_op->type == kCowXorOp) {
-        source_block /= BLOCK_SZ;
-        source_offset = cow_op->source % BLOCK_SZ;
+    uint64_t source_offset;
+    if (!reader_->GetSourceOffset(cow_op, &source_offset)) {
+        SNAP_LOG(ERROR) << "ReadAhead operation has no source offset: " << *cow_op;
+        return;
     }
+
+    uint64_t source_block = GetBlockFromOffset(header_, source_offset);
+    bool misaligned = (GetBlockRelativeOffset(header_, source_offset) != 0);
+
     if (dest_blocks_.count(cow_op->new_block) || source_blocks_.count(source_block) ||
-        (source_offset > 0 && source_blocks_.count(source_block + 1))) {
+        (misaligned && source_blocks_.count(source_block + 1))) {
         overlap_ = true;
     }
 
@@ -66,11 +69,12 @@ int ReadAhead::PrepareNextReadAhead(uint64_t* source_offset, int* pending_ops,
 
     // Get the first block with offset
     const CowOperation* cow_op = GetRAOpIter();
-    *source_offset = cow_op->source;
 
-    if (cow_op->type == kCowCopyOp) {
-        *source_offset *= BLOCK_SZ;
-    } else if (cow_op->type == kCowXorOp) {
+    if (!reader_->GetSourceOffset(cow_op, source_offset)) {
+        SNAP_LOG(ERROR) << "PrepareNextReadAhead operation has no source offset: " << *cow_op;
+        return nr_consecutive;
+    }
+    if (cow_op->type == kCowXorOp) {
         xor_op_vec.push_back(cow_op);
     }
 
@@ -88,10 +92,10 @@ int ReadAhead::PrepareNextReadAhead(uint64_t* source_offset, int* pending_ops,
      */
     while (!RAIterDone() && num_ops) {
         const CowOperation* op = GetRAOpIter();
-        uint64_t next_offset = op->source;
-
-        if (cow_op->type == kCowCopyOp) {
-            next_offset *= BLOCK_SZ;
+        uint64_t next_offset;
+        if (!reader_->GetSourceOffset(op, &next_offset)) {
+            SNAP_LOG(ERROR) << "PrepareNextReadAhead operation has no source offset: " << *cow_op;
+            break;
         }
 
         // Check for consecutive blocks
@@ -803,6 +807,7 @@ bool ReadAhead::InitReader() {
     if (!reader_->InitForMerge(std::move(cow_fd_))) {
         return false;
     }
+    header_ = reader_->GetHeader();
     return true;
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.h
index 5e94de005511..d3ba1265bb83 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.h
@@ -85,6 +85,7 @@ class ReadAhead {
 
     std::shared_ptr<SnapshotHandler> snapuserd_;
     std::unique_ptr<CowReader> reader_;
+    CowHeader header_;
 
     std::unordered_set<uint64_t> dest_blocks_;
     std::unordered_set<uint64_t> source_blocks_;

From cf311bd00f72a4a36e7857beebc29369b9bcd4a0 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 16 Jun 2023 13:59:31 -0700
Subject: [PATCH 0137/1487] libsnapshot: Remove direct accesses of
 CowOperation::source and compression.

For the remaining use cases of accessing CowOperation::source and
compression, directly, introduce helper functions, since these fields
will be removed in the v3 format.

Bug: 280529365
Test: cow_api_test
Change-Id: I07031e8968525a7c1314ca45c284e476b51d8104
---
 .../libsnapshot/include/libsnapshot/cow_format.h |  7 +++++++
 .../libsnapshot/include/libsnapshot/cow_reader.h |  1 +
 .../libsnapshot/libsnapshot_cow/cow_reader.cpp   | 16 ++++++++++------
 fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp   | 16 ++++++++--------
 .../snapuserd/dm-snapshot-merge/snapuserd.cpp    |  2 +-
 .../dm-snapshot-merge/snapuserd_readahead.cpp    |  6 +++---
 6 files changed, 30 insertions(+), 18 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index dd626bc4683a..3a81f6384e7d 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -166,6 +166,13 @@ static constexpr uint8_t kCowReadAheadNotStarted = 0;
 static constexpr uint8_t kCowReadAheadInProgress = 1;
 static constexpr uint8_t kCowReadAheadDone = 2;
 
+static inline uint64_t GetCowOpSourceInfoData(const CowOperation* op) {
+    return op->source;
+}
+static inline bool GetCowOpSourceInfoCompression(const CowOperation* op) {
+    return op->compression != kCowCompressNone;
+}
+
 struct CowFooter {
     CowFooterOperation op;
     uint8_t unused[64];
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index d0369e5d7d1b..f4ce52fa3622 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -168,6 +168,7 @@ class CowReader final : public ICowReader {
     bool ParseOps(std::optional<uint64_t> label);
     bool PrepMergeOps();
     uint64_t FindNumCopyops();
+    uint8_t GetCompressionType(const CowOperation* op);
 
     android::base::unique_fd owned_fd_;
     android::base::borrowed_fd fd_;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index cffc8dedbea6..489669ac0eae 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -517,7 +517,7 @@ bool CowReader::GetRawBytes(const CowOperation* op, void* buffer, size_t len, si
         case kCowSequenceOp:
         case kCowReplaceOp:
         case kCowXorOp:
-            return GetRawBytes(op->source, buffer, len, read);
+            return GetRawBytes(GetCowOpSourceInfoData(op), buffer, len, read);
         default:
             LOG(ERROR) << "Cannot get raw bytes of non-data op: " << *op;
             return false;
@@ -574,10 +574,14 @@ class CowDataStream final : public IByteStream {
     size_t remaining_;
 };
 
+uint8_t CowReader::GetCompressionType(const CowOperation* op) {
+    return op->compression;
+}
+
 ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_size,
                             size_t ignore_bytes) {
     std::unique_ptr<IDecompressor> decompressor;
-    switch (op->compression) {
+    switch (GetCompressionType(op)) {
         case kCowCompressNone:
             break;
         case kCowCompressGz:
@@ -597,7 +601,7 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
             }
             break;
         default:
-            LOG(ERROR) << "Unknown compression type: " << op->compression;
+            LOG(ERROR) << "Unknown compression type: " << GetCompressionType(op);
             return -1;
     }
 
@@ -605,7 +609,7 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
     if (op->type == kCowXorOp) {
         offset = data_loc_->at(op->new_block);
     } else {
-        offset = op->source;
+        offset = GetCowOpSourceInfoData(op);
     }
 
     if (!decompressor) {
@@ -621,10 +625,10 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
 bool CowReader::GetSourceOffset(const CowOperation* op, uint64_t* source_offset) {
     switch (op->type) {
         case kCowCopyOp:
-            *source_offset = op->source * header_.block_size;
+            *source_offset = GetCowOpSourceInfoData(op) * header_.block_size;
             return true;
         case kCowXorOp:
-            *source_offset = op->source;
+            *source_offset = GetCowOpSourceInfoData(op);
             return true;
         default:
             return false;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 120b2c062c83..31b9a5840934 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -145,7 +145,7 @@ TEST_F(CowTest, ReadWrite) {
     op = iter->Get();
 
     ASSERT_EQ(op->type, kCowReplaceOp);
-    ASSERT_EQ(op->compression, kCowCompressNone);
+    ASSERT_FALSE(GetCowOpSourceInfoCompression(op));
     ASSERT_EQ(op->data_length, 4096);
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -224,10 +224,10 @@ TEST_F(CowTest, ReadWriteXor) {
     op = iter->Get();
 
     ASSERT_EQ(op->type, kCowXorOp);
-    ASSERT_EQ(op->compression, kCowCompressNone);
+    ASSERT_FALSE(GetCowOpSourceInfoCompression(op));
     ASSERT_EQ(op->data_length, 4096);
     ASSERT_EQ(op->new_block, 50);
-    ASSERT_EQ(op->source, 98314);  // 4096 * 24 + 10
+    ASSERT_EQ(GetCowOpSourceInfoData(op), 98314);  // 4096 * 24 + 10
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data);
 
@@ -283,7 +283,7 @@ TEST_F(CowTest, CompressGz) {
     std::string sink(data.size(), '\0');
 
     ASSERT_EQ(op->type, kCowReplaceOp);
-    ASSERT_EQ(op->compression, kCowCompressGz);
+    ASSERT_TRUE(GetCowOpSourceInfoCompression(op));
     ASSERT_EQ(op->data_length, 56);  // compressed!
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -339,7 +339,7 @@ TEST_P(CompressionTest, ThreadedBatchWrites) {
             total_blocks += 1;
             std::string sink(xor_data.size(), '\0');
             ASSERT_EQ(op->new_block, 50);
-            ASSERT_EQ(op->source, 98314);  // 4096 * 24 + 10
+            ASSERT_EQ(GetCowOpSourceInfoData(op), 98314);  // 4096 * 24 + 10
             ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
             ASSERT_EQ(sink, xor_data);
         }
@@ -528,7 +528,7 @@ TEST_F(CowTest, ClusterCompressGz) {
     std::string sink(data.size(), '\0');
 
     ASSERT_EQ(op->type, kCowReplaceOp);
-    ASSERT_EQ(op->compression, kCowCompressGz);
+    ASSERT_TRUE(GetCowOpSourceInfoCompression(op));
     ASSERT_EQ(op->data_length, 56);  // compressed!
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -546,7 +546,7 @@ TEST_F(CowTest, ClusterCompressGz) {
 
     sink = {};
     sink.resize(data2.size(), '\0');
-    ASSERT_EQ(op->compression, kCowCompressGz);
+    ASSERT_TRUE(GetCowOpSourceInfoCompression(op));
     ASSERT_EQ(op->data_length, 41);  // compressed!
     ASSERT_EQ(op->new_block, 51);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -591,7 +591,7 @@ TEST_F(CowTest, CompressTwoBlocks) {
 
     auto op = iter->Get();
     ASSERT_EQ(op->type, kCowReplaceOp);
-    ASSERT_EQ(op->compression, kCowCompressGz);
+    ASSERT_TRUE(GetCowOpSourceInfoCompression(op));
     ASSERT_EQ(op->new_block, 51);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
 }
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
index da9bd113f6d4..978a7f25c510 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
@@ -508,7 +508,7 @@ bool Snapuserd::ReadMetadata() {
             // the merge of operations are done based on the ops present
             // in the file.
             //===========================================================
-            uint64_t block_source = cow_op->source;
+            uint64_t block_source = GetCowOpSourceInfoData(cow_op);
             if (prev_id.has_value()) {
                 if (dest_blocks.count(cow_op->new_block) || source_blocks.count(block_source)) {
                     break;
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
index a32c2bfdd2ac..d5fbe91a32f1 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
@@ -172,7 +172,7 @@ ReadAheadThread::ReadAheadThread(const std::string& cow_device, const std::strin
 }
 
 void ReadAheadThread::CheckOverlap(const CowOperation* cow_op) {
-    uint64_t source_block = cow_op->source;
+    uint64_t source_block = GetCowOpSourceInfoData(cow_op);
     if (dest_blocks_.count(cow_op->new_block) || source_blocks_.count(source_block)) {
         overlap_ = true;
     }
@@ -191,7 +191,7 @@ void ReadAheadThread::PrepareReadAhead(uint64_t* source_offset, int* pending_ops
         // Get the first block with offset
         const CowOperation* cow_op = GetRAOpIter();
         CHECK_NE(cow_op, nullptr);
-        *source_offset = cow_op->source;
+        *source_offset = GetCowOpSourceInfoData(cow_op);
         if (cow_op->type == kCowCopyOp) {
             *source_offset *= BLOCK_SZ;
         }
@@ -210,7 +210,7 @@ void ReadAheadThread::PrepareReadAhead(uint64_t* source_offset, int* pending_ops
         while (!RAIterDone() && num_ops) {
             const CowOperation* op = GetRAOpIter();
             CHECK_NE(op, nullptr);
-            uint64_t next_offset = op->source;
+            uint64_t next_offset = GetCowOpSourceInfoData(op);
             if (op->type == kCowCopyOp) {
                 next_offset *= BLOCK_SZ;
             }

From d4e035ebc3e4fbabe5065f352d7396abe4840d0d Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 21 Jun 2023 09:42:38 -0700
Subject: [PATCH 0138/1487] snapuserd: Make header_response a state variable.

header_response is meant to only be true for the first call to
WriteDmUserPayload. Codify this by making it a member variable and
resetting it on each request.

Bug: 288273605
Test: snapuserd_test
Change-Id: Ia125f86b7f22f4801be1e0796e8f85540ed5f31f
---
 .../user-space-merge/snapuserd_core.h         |  7 +--
 .../user-space-merge/snapuserd_dm_user.cpp    | 46 +++++++++----------
 2 files changed, 27 insertions(+), 26 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index c16ad24a5c69..cf38875848f7 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -120,7 +120,7 @@ class Worker {
 
     // Functions interacting with dm-user
     bool ReadDmUserHeader();
-    bool WriteDmUserPayload(size_t size, bool header_response);
+    bool WriteDmUserPayload(size_t size);
     bool DmuserReadRequest();
 
     // IO Path
@@ -130,11 +130,11 @@ class Worker {
     bool ReadDataFromBaseDevice(sector_t sector, size_t read_size);
     bool ReadFromSourceDevice(const CowOperation* cow_op);
 
-    bool ReadAlignedSector(sector_t sector, size_t sz, bool header_response);
+    bool ReadAlignedSector(sector_t sector, size_t sz);
     bool ReadUnalignedSector(sector_t sector, size_t size);
     int ReadUnalignedSector(sector_t sector, size_t size,
                             std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it);
-    bool RespondIOError(bool header_response);
+    bool RespondIOError();
 
     // Processing COW operations
     bool ProcessCowOp(const CowOperation* cow_op);
@@ -176,6 +176,7 @@ class Worker {
     unique_fd backing_store_fd_;
     unique_fd base_path_merge_fd_;
     unique_fd ctrl_fd_;
+    bool header_response_ = false;
 
     std::unique_ptr<ICowOpIter> cowop_iter_;
     size_t ra_block_index_ = 0;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
index 44b731912692..c505c32a15eb 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
@@ -306,10 +306,10 @@ bool Worker::ReadDmUserHeader() {
 }
 
 // Send the payload/data back to dm-user misc device.
-bool Worker::WriteDmUserPayload(size_t size, bool header_response) {
+bool Worker::WriteDmUserPayload(size_t size) {
     size_t payload_size = size;
     void* buf = bufsink_.GetPayloadBufPtr();
-    if (header_response) {
+    if (header_response_) {
         payload_size += sizeof(struct dm_user_header);
         buf = bufsink_.GetBufPtr();
     }
@@ -319,6 +319,9 @@ bool Worker::WriteDmUserPayload(size_t size, bool header_response) {
         return false;
     }
 
+    // After the first header is sent in response to a request, we cannot
+    // send any additional headers.
+    header_response_ = false;
     return true;
 }
 
@@ -341,7 +344,7 @@ bool Worker::ReadDataFromBaseDevice(sector_t sector, size_t read_size) {
     return true;
 }
 
-bool Worker::ReadAlignedSector(sector_t sector, size_t sz, bool header_response) {
+bool Worker::ReadAlignedSector(sector_t sector, size_t sz) {
     struct dm_user_header* header = bufsink_.GetHeaderPtr();
     size_t remaining_size = sz;
     std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
@@ -389,7 +392,7 @@ bool Worker::ReadAlignedSector(sector_t sector, size_t sz, bool header_response)
 
             // Just return the header if it is an error
             if (header->type == DM_USER_RESP_ERROR) {
-                if (!RespondIOError(header_response)) {
+                if (!RespondIOError()) {
                     return false;
                 }
 
@@ -404,14 +407,12 @@ bool Worker::ReadAlignedSector(sector_t sector, size_t sz, bool header_response)
         }
 
         if (!io_error) {
-            if (!WriteDmUserPayload(total_bytes_read, header_response)) {
+            if (!WriteDmUserPayload(total_bytes_read)) {
                 return false;
             }
 
             SNAP_LOG(DEBUG) << "WriteDmUserPayload success total_bytes_read: " << total_bytes_read
-                            << " header-response: " << header_response
                             << " remaining_size: " << remaining_size;
-            header_response = false;
             remaining_size -= total_bytes_read;
         }
     } while (remaining_size > 0 && !io_error);
@@ -484,7 +485,6 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
     // to any COW ops. In that case, we just need to read from the base
     // device.
     bool merge_complete = false;
-    bool header_response = true;
     if (it == chunk_vec.end()) {
         if (chunk_vec.size() > 0) {
             // I/O request beyond the last mapped sector
@@ -503,7 +503,7 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
             --it;
         }
     } else {
-        return ReadAlignedSector(sector, size, header_response);
+        return ReadAlignedSector(sector, size);
     }
 
     loff_t requested_offset = sector << SECTOR_SHIFT;
@@ -537,7 +537,7 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
         if (ret < 0) {
             SNAP_LOG(ERROR) << "ReadUnalignedSector failed for sector: " << sector
                             << " size: " << size << " it->sector: " << it->first;
-            return RespondIOError(header_response);
+            return RespondIOError();
         }
 
         remaining_size -= ret;
@@ -545,14 +545,13 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
         sector += (ret >> SECTOR_SHIFT);
 
         // Send the data back
-        if (!WriteDmUserPayload(total_bytes_read, header_response)) {
+        if (!WriteDmUserPayload(total_bytes_read)) {
             return false;
         }
 
-        header_response = false;
         // If we still have pending data to be processed, this will be aligned I/O
         if (remaining_size) {
-            return ReadAlignedSector(sector, remaining_size, header_response);
+            return ReadAlignedSector(sector, remaining_size);
         }
     } else {
         // This is all about handling I/O request to be routed to base device
@@ -566,21 +565,21 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
         CHECK(diff_size <= BLOCK_SZ);
         if (remaining_size < diff_size) {
             if (!ReadDataFromBaseDevice(sector, remaining_size)) {
-                return RespondIOError(header_response);
+                return RespondIOError();
             }
             total_bytes_read += remaining_size;
 
-            if (!WriteDmUserPayload(total_bytes_read, header_response)) {
+            if (!WriteDmUserPayload(total_bytes_read)) {
                 return false;
             }
         } else {
             if (!ReadDataFromBaseDevice(sector, diff_size)) {
-                return RespondIOError(header_response);
+                return RespondIOError();
             }
 
             total_bytes_read += diff_size;
 
-            if (!WriteDmUserPayload(total_bytes_read, header_response)) {
+            if (!WriteDmUserPayload(total_bytes_read)) {
                 return false;
             }
 
@@ -588,17 +587,16 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
             size_t num_sectors_read = (diff_size >> SECTOR_SHIFT);
             sector += num_sectors_read;
             CHECK(IsBlockAligned(sector << SECTOR_SHIFT));
-            header_response = false;
 
             // If we still have pending data to be processed, this will be aligned I/O
-            return ReadAlignedSector(sector, remaining_size, header_response);
+            return ReadAlignedSector(sector, remaining_size);
         }
     }
 
     return true;
 }
 
-bool Worker::RespondIOError(bool header_response) {
+bool Worker::RespondIOError() {
     struct dm_user_header* header = bufsink_.GetHeaderPtr();
     header->type = DM_USER_RESP_ERROR;
     // This is an issue with the dm-user interface. There
@@ -610,9 +608,9 @@ bool Worker::RespondIOError(bool header_response) {
     // this back to dm-user.
     //
     // TODO: Fix the interface
-    CHECK(header_response);
+    CHECK(header_response_);
 
-    if (!WriteDmUserPayload(0, header_response)) {
+    if (!WriteDmUserPayload(0)) {
         return false;
     }
 
@@ -629,7 +627,7 @@ bool Worker::DmuserReadRequest() {
         return ReadUnalignedSector(header->sector, header->len);
     }
 
-    return ReadAlignedSector(header->sector, header->len, true);
+    return ReadAlignedSector(header->sector, header->len);
 }
 
 bool Worker::ProcessIORequest() {
@@ -645,6 +643,8 @@ bool Worker::ProcessIORequest() {
     SNAP_LOG(DEBUG) << "Daemon: msg->type: " << std::dec << header->type;
     SNAP_LOG(DEBUG) << "Daemon: msg->flags: " << std::dec << header->flags;
 
+    header_response_ = true;
+
     switch (header->type) {
         case DM_USER_REQ_MAP_READ: {
             if (!DmuserReadRequest()) {

From cf16f4d794a7162e6f418d2308741c6b45806f01 Mon Sep 17 00:00:00 2001
From: Jiakai Zhang <jiakaiz@google.com>
Date: Fri, 23 Jun 2023 11:04:17 +0100
Subject: [PATCH 0139/1487] Make libfstab available to APEXes.

The ART module needs this library to determine whether to put dexopt
artifacts in dalvik-cache.

Bug: 287958783
Test: m
Change-Id: Idf338702d4f54e9c40c0692ea29e7d83e91aca38
---
 fs_mgr/Android.bp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/fs_mgr/Android.bp b/fs_mgr/Android.bp
index dd612720f26d..bbd068bacc19 100644
--- a/fs_mgr/Android.bp
+++ b/fs_mgr/Android.bp
@@ -181,6 +181,10 @@ cc_library_static {
     ramdisk_available: true,
     vendor_ramdisk_available: true,
     recovery_available: true,
+    apex_available: [
+        "//apex_available:anyapex",
+        "//apex_available:platform",
+    ],
     host_supported: true,
     defaults: ["fs_mgr_defaults"],
     srcs: [
@@ -206,6 +210,7 @@ cc_library_static {
         "libbase_headers",
         "libgsi_headers",
     ],
+    min_sdk_version: "31",
 }
 
 cc_binary {

From a66adf45aa1458884903fa11679a2996755292c4 Mon Sep 17 00:00:00 2001
From: Nikita Ioffe <ioffe@google.com>
Date: Mon, 26 Jun 2023 14:55:31 +0100
Subject: [PATCH 0140/1487] init selinux.cpp: use a better way to detect if we
 run in Microdroid

We are now conditionally compiling init binaries & libinit for
Microdroid (adding -DMICRODROID=1 cflag), so instead of checking for the
presence of the /system/etc/selinux/microdroid_precompiled_sepolicy we
can check if the code is compiled for Microdroid.

In a follow-up changes we can split the sepolicy loading logic into 2
separate headers (one for Android and one for Microdroid) and include
the necessary one depending on the target we compile for.

Bug: 287206497
Test: atest MicrodroidTestApp
Change-Id: Id9c837d03a96ff9564688d33955ec85094eee487
---
 init/Android.bp        | 26 +++++++++-----
 init/fuzzer/Android.bp |  8 ++---
 init/selinux.cpp       | 77 ++++++++++++++++++++++++++++--------------
 init/util.cpp          |  5 ---
 init/util.h            |  9 ++++-
 5 files changed, 80 insertions(+), 45 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index f62d7b767dfe..06060db5bbeb 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -214,8 +214,8 @@ cc_library_headers {
     visibility: [":__subpackages__"],
 }
 
-cc_library_static {
-    name: "libinit",
+cc_defaults {
+    name: "libinit_defaults",
     recovery_available: true,
     defaults: [
         "init_defaults",
@@ -252,10 +252,17 @@ cc_library_static {
             ],
         },
     },
-    visibility: [
-        "//system/apex/apexd",
-        "//frameworks/native/cmds/installd",
-    ],
+}
+
+cc_library_static {
+    name: "libinit",
+    defaults: ["libinit_defaults"],
+}
+
+cc_library_static {
+    name: "libinit.microdroid",
+    defaults: ["libinit_defaults"],
+    cflags: ["-DMICRODROID=1"],
 }
 
 phony {
@@ -270,7 +277,6 @@ cc_defaults {
     recovery_available: true,
     stem: "init",
     defaults: ["init_defaults"],
-    static_libs: ["libinit"],
     srcs: ["main.cpp"],
     symlinks: ["ueventd"],
     target: {
@@ -309,12 +315,14 @@ cc_defaults {
 cc_binary {
     name: "init_second_stage",
     defaults: ["init_second_stage_defaults"],
+    static_libs: ["libinit"],
 }
 
 cc_binary {
     name: "init_second_stage.microdroid",
     defaults: ["init_second_stage_defaults"],
-    cflags: ["-DMICRODROID"],
+    static_libs: ["libinit.microdroid"],
+    cflags: ["-DMICRODROID=1"],
     installable: false,
     visibility: ["//packages/modules/Virtualization/microdroid"],
 }
@@ -460,7 +468,7 @@ cc_binary {
 cc_binary {
     name: "init_first_stage.microdroid",
     defaults: ["init_first_stage_defaults"],
-    cflags: ["-DMICRODROID"],
+    cflags: ["-DMICRODROID=1"],
     installable: false,
 }
 
diff --git a/init/fuzzer/Android.bp b/init/fuzzer/Android.bp
index c21a196a97f8..856ca8cf5737 100644
--- a/init/fuzzer/Android.bp
+++ b/init/fuzzer/Android.bp
@@ -18,7 +18,7 @@ package {
 }
 
 cc_defaults {
-    name: "libinit_defaults",
+    name: "libinit_fuzzer_defaults",
     static_libs: [
         "libc++fs",
         "liblmkd_utils",
@@ -53,7 +53,7 @@ cc_fuzz {
     ],
     shared_libs: ["libhidlmetadata",],
     defaults: [
-        "libinit_defaults",
+        "libinit_fuzzer_defaults",
     ],
 }
 
@@ -62,7 +62,7 @@ cc_fuzz {
     srcs: [
         "init_property_fuzzer.cpp",
     ],
-    defaults: ["libinit_defaults"],
+    defaults: ["libinit_fuzzer_defaults"],
 }
 
 cc_fuzz {
@@ -71,6 +71,6 @@ cc_fuzz {
         "init_ueventHandler_fuzzer.cpp",
     ],
     defaults: [
-        "libinit_defaults",
+        "libinit_fuzzer_defaults",
     ],
 }
diff --git a/init/selinux.cpp b/init/selinux.cpp
index a9365323362f..e0ef4913c938 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -300,8 +300,6 @@ bool GetVendorMappingVersion(std::string* plat_vers) {
 }
 
 constexpr const char plat_policy_cil_file[] = "/system/etc/selinux/plat_sepolicy.cil";
-constexpr const char kMicrodroidPrecompiledSepolicy[] =
-        "/system/etc/selinux/microdroid_precompiled_sepolicy";
 
 bool IsSplitPolicyDevice() {
     return access(plat_policy_cil_file, R_OK) != -1;
@@ -499,19 +497,14 @@ bool OpenSplitPolicy(PolicyFile* policy_file) {
 
 bool OpenMonolithicPolicy(PolicyFile* policy_file) {
     static constexpr char kSepolicyFile[] = "/sepolicy";
-    // In Microdroid the precompiled sepolicy is located on /system, since there is no vendor code.
-    // TODO(b/287206497): refactor once we start conditionally compiling init for Microdroid.
-    std::string monolithic_policy_file = access(kMicrodroidPrecompiledSepolicy, R_OK) == 0
-                                                 ? kMicrodroidPrecompiledSepolicy
-                                                 : kSepolicyFile;
-
-    LOG(INFO) << "Opening SELinux policy from monolithic file " << monolithic_policy_file;
-    policy_file->fd.reset(open(monolithic_policy_file.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
+
+    LOG(INFO) << "Opening SELinux policy from monolithic file " << kSepolicyFile;
+    policy_file->fd.reset(open(kSepolicyFile, O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
     if (policy_file->fd < 0) {
         PLOG(ERROR) << "Failed to open monolithic SELinux policy";
         return false;
     }
-    policy_file->path = monolithic_policy_file;
+    policy_file->path = kSepolicyFile;
     return true;
 }
 
@@ -858,6 +851,10 @@ void SelinuxSetupKernelLogging() {
 }
 
 int SelinuxGetVendorAndroidVersion() {
+    if (IsMicrodroid()) {
+        // As of now Microdroid doesn't have any vendor code.
+        return __ANDROID_API_FUTURE__;
+    }
     static int vendor_android_version = [] {
         if (!IsSplitPolicyDevice()) {
             // If this device does not split sepolicy files, it's not a Treble device and therefore,
@@ -961,6 +958,26 @@ static void LoadSelinuxPolicy(std::string& policy) {
     }
 }
 
+// Encapsulates steps to load SELinux policy in Microdroid.
+// So far the process is very straightforward - just load the precompiled policy from /system.
+void LoadSelinuxPolicyMicrodroid() {
+    constexpr const char kMicrodroidPrecompiledSepolicy[] =
+            "/system/etc/selinux/microdroid_precompiled_sepolicy";
+
+    LOG(INFO) << "Opening SELinux policy from " << kMicrodroidPrecompiledSepolicy;
+    unique_fd policy_fd(open(kMicrodroidPrecompiledSepolicy, O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
+    if (policy_fd < 0) {
+        PLOG(FATAL) << "Failed to open " << kMicrodroidPrecompiledSepolicy;
+    }
+
+    std::string policy;
+    if (!android::base::ReadFdToString(policy_fd, &policy)) {
+        PLOG(FATAL) << "Failed to read policy file: " << kMicrodroidPrecompiledSepolicy;
+    }
+
+    LoadSelinuxPolicy(policy);
+}
+
 // The SELinux setup process is carefully orchestrated around snapuserd. Policy
 // must be loaded off dynamic partitions, and during an OTA, those partitions
 // cannot be read without snapuserd. But, with kernel-privileged snapuserd
@@ -976,20 +993,9 @@ static void LoadSelinuxPolicy(std::string& policy) {
 //  (5) Re-launch snapuserd and attach it to the dm-user devices from step (2).
 //
 // After this sequence, it is safe to enable enforcing mode and continue booting.
-int SetupSelinux(char** argv) {
-    SetStdioToDevNull(argv);
-    InitKernelLogging(argv);
-
-    if (REBOOT_BOOTLOADER_ON_PANIC) {
-        InstallRebootSignalHandlers();
-    }
-
-    boot_clock::time_point start_time = boot_clock::now();
-
+void LoadSelinuxPolicyAndroid() {
     MountMissingSystemPartitions();
 
-    SelinuxSetupKernelLogging();
-
     LOG(INFO) << "Opening SELinux policy";
 
     PrepareApexSepolicy();
@@ -1001,9 +1007,8 @@ int SetupSelinux(char** argv) {
 
     auto snapuserd_helper = SnapuserdSelinuxHelper::CreateIfNeeded();
     if (snapuserd_helper) {
-        // Kill the old snapused to avoid audit messages. After this we cannot
-        // read from /system (or other dynamic partitions) until we call
-        // FinishTransition().
+        // Kill the old snapused to avoid audit messages. After this we cannot read from /system
+        // (or other dynamic partitions) until we call FinishTransition().
         snapuserd_helper->StartTransition();
     }
 
@@ -1021,6 +1026,26 @@ int SetupSelinux(char** argv) {
     if (selinux_android_restorecon("/dev/selinux/", SELINUX_ANDROID_RESTORECON_RECURSE) == -1) {
         PLOG(FATAL) << "restorecon failed of /dev/selinux failed";
     }
+}
+
+int SetupSelinux(char** argv) {
+    SetStdioToDevNull(argv);
+    InitKernelLogging(argv);
+
+    if (REBOOT_BOOTLOADER_ON_PANIC) {
+        InstallRebootSignalHandlers();
+    }
+
+    boot_clock::time_point start_time = boot_clock::now();
+
+    SelinuxSetupKernelLogging();
+
+    // TODO(b/287206497): refactor into different headers to only include what we need.
+    if (IsMicrodroid()) {
+        LoadSelinuxPolicyMicrodroid();
+    } else {
+        LoadSelinuxPolicyAndroid();
+    }
 
     SelinuxSetEnforcement();
 
diff --git a/init/util.cpp b/init/util.cpp
index bc8ea6eafe3f..d0478e80d005 100644
--- a/init/util.cpp
+++ b/init/util.cpp
@@ -732,11 +732,6 @@ void SetDefaultMountNamespaceReady() {
     is_default_mount_namespace_ready = true;
 }
 
-bool IsMicrodroid() {
-    static bool is_microdroid = android::base::GetProperty("ro.hardware", "") == "microdroid";
-    return is_microdroid;
-}
-
 bool Has32BitAbi() {
     static bool has = !android::base::GetProperty("ro.product.cpu.abilist32", "").empty();
     return has;
diff --git a/init/util.h b/init/util.h
index e58e70e61788..3f0a4e023f08 100644
--- a/init/util.h
+++ b/init/util.h
@@ -105,7 +105,14 @@ bool IsRecoveryMode();
 bool IsDefaultMountNamespaceReady();
 void SetDefaultMountNamespaceReady();
 
-bool IsMicrodroid();
+inline constexpr bool IsMicrodroid() {
+#ifdef MICRODROID
+    return MICRODROID;
+#else
+    return false;
+#endif
+}
+
 bool Has32BitAbi();
 
 std::string GetApexNameFromFileName(const std::string& path);

From dee32db2491a44e8d12f9f45faefe4ec1ab29156 Mon Sep 17 00:00:00 2001
From: Matthew Maurer <mmaurer@google.com>
Date: Mon, 26 Jun 2023 22:27:09 +0000
Subject: [PATCH 0141/1487] Bindgen 0.65.1 no longer supports size_t-is-usize

The flag has been a default, and now is not accepted.

Test: Treehugger, m rust
Bug: 279198502
Bug: 276464273
Change-Id: Ifdf9968bfcdb278f73cf31ab68bc6b488b39436b
---
 libstats/pull_rust/Android.bp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/libstats/pull_rust/Android.bp b/libstats/pull_rust/Android.bp
index 85a38f8d77b5..4609e6bc4a81 100644
--- a/libstats/pull_rust/Android.bp
+++ b/libstats/pull_rust/Android.bp
@@ -28,7 +28,6 @@ rust_bindgen {
     ],
     source_stem: "bindings",
     bindgen_flags: [
-        "--size_t-is-usize",
         "--allowlist-function=AStatsEventList_addStatsEvent",
         "--allowlist-function=AStatsEvent_.*",
         "--allowlist-function=AStatsManager_.*",

From e2e8f55b81a0b92dcf3f80a6bc40158c76002eeb Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 27 Jun 2023 05:29:20 +0000
Subject: [PATCH 0142/1487] Revert "snapuserd: Make header_response a state
 variable."

This reverts commit d4e035ebc3e4fbabe5065f352d7396abe4840d0d.

Reason for revert: Breaks incremental OTAs

Change-Id: Ib9703a66b83e08114ca4d11370d669b8bcdf4789
---
 .../user-space-merge/snapuserd_core.h         |  7 ++-
 .../user-space-merge/snapuserd_dm_user.cpp    | 46 +++++++++----------
 2 files changed, 26 insertions(+), 27 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index cf38875848f7..c16ad24a5c69 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -120,7 +120,7 @@ class Worker {
 
     // Functions interacting with dm-user
     bool ReadDmUserHeader();
-    bool WriteDmUserPayload(size_t size);
+    bool WriteDmUserPayload(size_t size, bool header_response);
     bool DmuserReadRequest();
 
     // IO Path
@@ -130,11 +130,11 @@ class Worker {
     bool ReadDataFromBaseDevice(sector_t sector, size_t read_size);
     bool ReadFromSourceDevice(const CowOperation* cow_op);
 
-    bool ReadAlignedSector(sector_t sector, size_t sz);
+    bool ReadAlignedSector(sector_t sector, size_t sz, bool header_response);
     bool ReadUnalignedSector(sector_t sector, size_t size);
     int ReadUnalignedSector(sector_t sector, size_t size,
                             std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it);
-    bool RespondIOError();
+    bool RespondIOError(bool header_response);
 
     // Processing COW operations
     bool ProcessCowOp(const CowOperation* cow_op);
@@ -176,7 +176,6 @@ class Worker {
     unique_fd backing_store_fd_;
     unique_fd base_path_merge_fd_;
     unique_fd ctrl_fd_;
-    bool header_response_ = false;
 
     std::unique_ptr<ICowOpIter> cowop_iter_;
     size_t ra_block_index_ = 0;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
index c505c32a15eb..44b731912692 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
@@ -306,10 +306,10 @@ bool Worker::ReadDmUserHeader() {
 }
 
 // Send the payload/data back to dm-user misc device.
-bool Worker::WriteDmUserPayload(size_t size) {
+bool Worker::WriteDmUserPayload(size_t size, bool header_response) {
     size_t payload_size = size;
     void* buf = bufsink_.GetPayloadBufPtr();
-    if (header_response_) {
+    if (header_response) {
         payload_size += sizeof(struct dm_user_header);
         buf = bufsink_.GetBufPtr();
     }
@@ -319,9 +319,6 @@ bool Worker::WriteDmUserPayload(size_t size) {
         return false;
     }
 
-    // After the first header is sent in response to a request, we cannot
-    // send any additional headers.
-    header_response_ = false;
     return true;
 }
 
@@ -344,7 +341,7 @@ bool Worker::ReadDataFromBaseDevice(sector_t sector, size_t read_size) {
     return true;
 }
 
-bool Worker::ReadAlignedSector(sector_t sector, size_t sz) {
+bool Worker::ReadAlignedSector(sector_t sector, size_t sz, bool header_response) {
     struct dm_user_header* header = bufsink_.GetHeaderPtr();
     size_t remaining_size = sz;
     std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
@@ -392,7 +389,7 @@ bool Worker::ReadAlignedSector(sector_t sector, size_t sz) {
 
             // Just return the header if it is an error
             if (header->type == DM_USER_RESP_ERROR) {
-                if (!RespondIOError()) {
+                if (!RespondIOError(header_response)) {
                     return false;
                 }
 
@@ -407,12 +404,14 @@ bool Worker::ReadAlignedSector(sector_t sector, size_t sz) {
         }
 
         if (!io_error) {
-            if (!WriteDmUserPayload(total_bytes_read)) {
+            if (!WriteDmUserPayload(total_bytes_read, header_response)) {
                 return false;
             }
 
             SNAP_LOG(DEBUG) << "WriteDmUserPayload success total_bytes_read: " << total_bytes_read
+                            << " header-response: " << header_response
                             << " remaining_size: " << remaining_size;
+            header_response = false;
             remaining_size -= total_bytes_read;
         }
     } while (remaining_size > 0 && !io_error);
@@ -485,6 +484,7 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
     // to any COW ops. In that case, we just need to read from the base
     // device.
     bool merge_complete = false;
+    bool header_response = true;
     if (it == chunk_vec.end()) {
         if (chunk_vec.size() > 0) {
             // I/O request beyond the last mapped sector
@@ -503,7 +503,7 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
             --it;
         }
     } else {
-        return ReadAlignedSector(sector, size);
+        return ReadAlignedSector(sector, size, header_response);
     }
 
     loff_t requested_offset = sector << SECTOR_SHIFT;
@@ -537,7 +537,7 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
         if (ret < 0) {
             SNAP_LOG(ERROR) << "ReadUnalignedSector failed for sector: " << sector
                             << " size: " << size << " it->sector: " << it->first;
-            return RespondIOError();
+            return RespondIOError(header_response);
         }
 
         remaining_size -= ret;
@@ -545,13 +545,14 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
         sector += (ret >> SECTOR_SHIFT);
 
         // Send the data back
-        if (!WriteDmUserPayload(total_bytes_read)) {
+        if (!WriteDmUserPayload(total_bytes_read, header_response)) {
             return false;
         }
 
+        header_response = false;
         // If we still have pending data to be processed, this will be aligned I/O
         if (remaining_size) {
-            return ReadAlignedSector(sector, remaining_size);
+            return ReadAlignedSector(sector, remaining_size, header_response);
         }
     } else {
         // This is all about handling I/O request to be routed to base device
@@ -565,21 +566,21 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
         CHECK(diff_size <= BLOCK_SZ);
         if (remaining_size < diff_size) {
             if (!ReadDataFromBaseDevice(sector, remaining_size)) {
-                return RespondIOError();
+                return RespondIOError(header_response);
             }
             total_bytes_read += remaining_size;
 
-            if (!WriteDmUserPayload(total_bytes_read)) {
+            if (!WriteDmUserPayload(total_bytes_read, header_response)) {
                 return false;
             }
         } else {
             if (!ReadDataFromBaseDevice(sector, diff_size)) {
-                return RespondIOError();
+                return RespondIOError(header_response);
             }
 
             total_bytes_read += diff_size;
 
-            if (!WriteDmUserPayload(total_bytes_read)) {
+            if (!WriteDmUserPayload(total_bytes_read, header_response)) {
                 return false;
             }
 
@@ -587,16 +588,17 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
             size_t num_sectors_read = (diff_size >> SECTOR_SHIFT);
             sector += num_sectors_read;
             CHECK(IsBlockAligned(sector << SECTOR_SHIFT));
+            header_response = false;
 
             // If we still have pending data to be processed, this will be aligned I/O
-            return ReadAlignedSector(sector, remaining_size);
+            return ReadAlignedSector(sector, remaining_size, header_response);
         }
     }
 
     return true;
 }
 
-bool Worker::RespondIOError() {
+bool Worker::RespondIOError(bool header_response) {
     struct dm_user_header* header = bufsink_.GetHeaderPtr();
     header->type = DM_USER_RESP_ERROR;
     // This is an issue with the dm-user interface. There
@@ -608,9 +610,9 @@ bool Worker::RespondIOError() {
     // this back to dm-user.
     //
     // TODO: Fix the interface
-    CHECK(header_response_);
+    CHECK(header_response);
 
-    if (!WriteDmUserPayload(0)) {
+    if (!WriteDmUserPayload(0, header_response)) {
         return false;
     }
 
@@ -627,7 +629,7 @@ bool Worker::DmuserReadRequest() {
         return ReadUnalignedSector(header->sector, header->len);
     }
 
-    return ReadAlignedSector(header->sector, header->len);
+    return ReadAlignedSector(header->sector, header->len, true);
 }
 
 bool Worker::ProcessIORequest() {
@@ -643,8 +645,6 @@ bool Worker::ProcessIORequest() {
     SNAP_LOG(DEBUG) << "Daemon: msg->type: " << std::dec << header->type;
     SNAP_LOG(DEBUG) << "Daemon: msg->flags: " << std::dec << header->flags;
 
-    header_response_ = true;
-
     switch (header->type) {
         case DM_USER_REQ_MAP_READ: {
             if (!DmuserReadRequest()) {

From 0e01ffa6924d7eae988dbf16a2e280c9065cac85 Mon Sep 17 00:00:00 2001
From: Jiakai Zhang <jiakaiz@google.com>
Date: Fri, 23 Jun 2023 11:04:17 +0100
Subject: [PATCH 0143/1487] Make libfstab available to APEXes.

The ART module needs this library to determine whether to put dexopt
artifacts in dalvik-cache.

Bug: 287958783
Test: m
(cherry picked from https://android-review.googlesource.com/q/commit:cf16f4d794a7162e6f418d2308741c6b45806f01)
Merged-In: Idf338702d4f54e9c40c0692ea29e7d83e91aca38
Change-Id: Idf338702d4f54e9c40c0692ea29e7d83e91aca38
---
 fs_mgr/Android.bp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/fs_mgr/Android.bp b/fs_mgr/Android.bp
index dd612720f26d..bbd068bacc19 100644
--- a/fs_mgr/Android.bp
+++ b/fs_mgr/Android.bp
@@ -181,6 +181,10 @@ cc_library_static {
     ramdisk_available: true,
     vendor_ramdisk_available: true,
     recovery_available: true,
+    apex_available: [
+        "//apex_available:anyapex",
+        "//apex_available:platform",
+    ],
     host_supported: true,
     defaults: ["fs_mgr_defaults"],
     srcs: [
@@ -206,6 +210,7 @@ cc_library_static {
         "libbase_headers",
         "libgsi_headers",
     ],
+    min_sdk_version: "31",
 }
 
 cc_binary {

From 3e04857a59db6b466465350f1b3bac01b4bce040 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 21 Jun 2023 15:21:06 -0700
Subject: [PATCH 0144/1487] Changing name of flash super layout

OptimizedFlashSuper makes more sense and is more consistent with
should-optimize-super

Test: m fastboot
Change-Id: I6ceb31144dce591e0a53faec68b932112d9cd360
---
 fastboot/fastboot.cpp |  7 ++++---
 fastboot/task.cpp     | 24 ++++++++++++------------
 fastboot/task.h       | 12 ++++++------
 3 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 30eb7b5fcd5b..29980afd06f2 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1747,7 +1747,7 @@ std::vector<std::unique_ptr<Task>> ParseFastbootInfo(const FlashingPlan* fp,
         }
         tasks.emplace_back(std::move(task));
     }
-    if (auto flash_super_task = FlashSuperLayoutTask::InitializeFromTasks(fp, tasks)) {
+    if (auto flash_super_task = OptimizedFlashSuperTask::InitializeFromTasks(fp, tasks)) {
         auto it = tasks.begin();
         for (size_t i = 0; i < tasks.size(); i++) {
             if (auto flash_task = tasks[i]->AsFlashTask()) {
@@ -1849,7 +1849,7 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasksFromImageList() {
     std::vector<std::unique_ptr<Task>> tasks;
     AddFlashTasks(boot_images_, tasks);
 
-    if (auto flash_super_task = FlashSuperLayoutTask::Initialize(fp_, os_images_)) {
+    if (auto flash_super_task = OptimizedFlashSuperTask::Initialize(fp_, os_images_)) {
         tasks.emplace_back(std::move(flash_super_task));
     } else {
         // Sync the super partition. This will reboot to userspace fastboot if needed.
@@ -2205,8 +2205,9 @@ int FastBootTool::Main(int argc, char* argv[]) {
                                       {0, 0, 0, 0}};
 
     serial = getenv("FASTBOOT_DEVICE");
-    if (!serial)
+    if (!serial) {
         serial = getenv("ANDROID_SERIAL");
+    }
 
     int c;
     while ((c = getopt_long(argc, argv, "a::hls:S:vw", longopts, &longindex)) != -1) {
diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index c1b9a31a121d..bf64f0e1e42c 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -96,17 +96,17 @@ std::string RebootTask::ToString() {
     return "reboot " + reboot_target_;
 }
 
-FlashSuperLayoutTask::FlashSuperLayoutTask(const std::string& super_name,
-                                           std::unique_ptr<SuperFlashHelper> helper,
-                                           SparsePtr sparse_layout, uint64_t super_size,
-                                           const FlashingPlan* fp)
+OptimizedFlashSuperTask::OptimizedFlashSuperTask(const std::string& super_name,
+                                                 std::unique_ptr<SuperFlashHelper> helper,
+                                                 SparsePtr sparse_layout, uint64_t super_size,
+                                                 const FlashingPlan* fp)
     : super_name_(super_name),
       helper_(std::move(helper)),
       sparse_layout_(std::move(sparse_layout)),
       super_size_(super_size),
       fp_(fp) {}
 
-void FlashSuperLayoutTask::Run() {
+void OptimizedFlashSuperTask::Run() {
     // Use the reported super partition size as the upper limit, rather than
     // sparse_file_len, which (1) can fail and (2) is kind of expensive, since
     // it will map in all of the embedded fds.
@@ -120,11 +120,11 @@ void FlashSuperLayoutTask::Run() {
     // Send the data to the device.
     flash_partition_files(super_name_, files);
 }
-std::string FlashSuperLayoutTask::ToString() {
+std::string OptimizedFlashSuperTask::ToString() {
     return "optimized-flash-super";
 }
 
-std::unique_ptr<FlashSuperLayoutTask> FlashSuperLayoutTask::Initialize(
+std::unique_ptr<OptimizedFlashSuperTask> OptimizedFlashSuperTask::Initialize(
         const FlashingPlan* fp, std::vector<ImageEntry>& os_images) {
     if (!fp->should_optimize_flash_super) {
         LOG(INFO) << "super optimization is disabled";
@@ -188,11 +188,11 @@ std::unique_ptr<FlashSuperLayoutTask> FlashSuperLayoutTask::Initialize(
     };
     os_images.erase(std::remove_if(os_images.begin(), os_images.end(), remove_if_callback),
                     os_images.end());
-    return std::make_unique<FlashSuperLayoutTask>(super_name, std::move(helper), std::move(s),
-                                                  partition_size, fp);
+    return std::make_unique<OptimizedFlashSuperTask>(super_name, std::move(helper), std::move(s),
+                                                     partition_size, fp);
 }
 
-std::unique_ptr<FlashSuperLayoutTask> FlashSuperLayoutTask::InitializeFromTasks(
+std::unique_ptr<OptimizedFlashSuperTask> OptimizedFlashSuperTask::InitializeFromTasks(
         const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>& tasks) {
     if (!fp->should_optimize_flash_super) {
         LOG(INFO) << "super optimization is disabled";
@@ -261,8 +261,8 @@ std::unique_ptr<FlashSuperLayoutTask> FlashSuperLayoutTask::InitializeFromTasks(
     };
     tasks.erase(std::remove_if(tasks.begin(), tasks.end(), remove_if_callback), tasks.end());
 
-    return std::make_unique<FlashSuperLayoutTask>(super_name, std::move(helper), std::move(s),
-                                                  partition_size, fp);
+    return std::make_unique<OptimizedFlashSuperTask>(super_name, std::move(helper), std::move(s),
+                                                     partition_size, fp);
 }
 
 UpdateSuperTask::UpdateSuperTask(const FlashingPlan* fp) : fp_(fp) {}
diff --git a/fastboot/task.h b/fastboot/task.h
index 858f43a2e86d..f7c8801f9239 100644
--- a/fastboot/task.h
+++ b/fastboot/task.h
@@ -79,13 +79,13 @@ class RebootTask : public Task {
     const FlashingPlan* fp_;
 };
 
-class FlashSuperLayoutTask : public Task {
+class OptimizedFlashSuperTask : public Task {
   public:
-    FlashSuperLayoutTask(const std::string& super_name, std::unique_ptr<SuperFlashHelper> helper,
-                         SparsePtr sparse_layout, uint64_t super_size, const FlashingPlan* fp);
-    static std::unique_ptr<FlashSuperLayoutTask> Initialize(const FlashingPlan* fp,
-                                                            std::vector<ImageEntry>& os_images);
-    static std::unique_ptr<FlashSuperLayoutTask> InitializeFromTasks(
+    OptimizedFlashSuperTask(const std::string& super_name, std::unique_ptr<SuperFlashHelper> helper,
+                            SparsePtr sparse_layout, uint64_t super_size, const FlashingPlan* fp);
+    static std::unique_ptr<OptimizedFlashSuperTask> Initialize(const FlashingPlan* fp,
+                                                               std::vector<ImageEntry>& os_images);
+    static std::unique_ptr<OptimizedFlashSuperTask> InitializeFromTasks(
             const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>& tasks);
     using ImageEntry = std::pair<const Image*, std::string>;
     void Run() override;

From 786dac3d5068594735ef38f4a51bbb89e9a12003 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 15 Jun 2023 16:23:56 -0700
Subject: [PATCH 0145/1487] Update some fs_mgr/debuggerd to use getpagesize()
 instead of PAGE_SIZE

Test: th
Bug: 279808236
Change-Id: I9d30cfe19d2b1a7d624cc5425e4315dc6e3b2ad2
---
 debuggerd/crasher/crasher.cpp           |  2 +-
 debuggerd/debuggerd_test.cpp            | 19 +------------------
 debuggerd/handler/debuggerd_handler.cpp |  8 ++++----
 debuggerd/libdebuggerd/scudo.cpp        | 11 ++++++-----
 fs_mgr/fs_mgr.cpp                       |  7 ++++---
 fs_mgr/fs_mgr_format.cpp                | 10 +++++++++-
 fs_mgr/fs_mgr_overlayfs.cpp             |  4 +++-
 7 files changed, 28 insertions(+), 33 deletions(-)

diff --git a/debuggerd/crasher/crasher.cpp b/debuggerd/crasher/crasher.cpp
index 6a19878827f6..12ba502ecf8b 100644
--- a/debuggerd/crasher/crasher.cpp
+++ b/debuggerd/crasher/crasher.cpp
@@ -148,7 +148,7 @@ noinline void abuse_heap() {
 noinline void leak() {
     while (true) {
         void* mapping =
-            mmap(nullptr, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+            mmap(nullptr, getpagesize(), PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
         static_cast<volatile char*>(mapping)[0] = 'a';
     }
 }
diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 4cd619337167..52c1c255458d 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -300,24 +300,7 @@ void CrasherTest::AssertDeath(int signo) {
 }
 
 static void ConsumeFd(unique_fd fd, std::string* output) {
-  constexpr size_t read_length = PAGE_SIZE;
-  std::string result;
-
-  while (true) {
-    size_t offset = result.size();
-    result.resize(result.size() + PAGE_SIZE);
-    ssize_t rc = TEMP_FAILURE_RETRY(read(fd.get(), &result[offset], read_length));
-    if (rc == -1) {
-      FAIL() << "read failed: " << strerror(errno);
-    } else if (rc == 0) {
-      result.resize(result.size() - PAGE_SIZE);
-      break;
-    }
-
-    result.resize(result.size() - PAGE_SIZE + rc);
-  }
-
-  *output = std::move(result);
+  ASSERT_TRUE(android::base::ReadFdToString(fd, output));
 }
 
 class LogcatCollector {
diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index c6a535ad6d7f..1e5365d3cd53 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -721,19 +721,19 @@ void debuggerd_init(debuggerd_callbacks_t* callbacks) {
   }
 
   size_t thread_stack_pages = 8;
-  void* thread_stack_allocation = mmap(nullptr, PAGE_SIZE * (thread_stack_pages + 2), PROT_NONE,
+  void* thread_stack_allocation = mmap(nullptr, getpagesize() * (thread_stack_pages + 2), PROT_NONE,
                                        MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   if (thread_stack_allocation == MAP_FAILED) {
     fatal_errno("failed to allocate debuggerd thread stack");
   }
 
-  char* stack = static_cast<char*>(thread_stack_allocation) + PAGE_SIZE;
-  if (mprotect(stack, PAGE_SIZE * thread_stack_pages, PROT_READ | PROT_WRITE) != 0) {
+  char* stack = static_cast<char*>(thread_stack_allocation) + getpagesize();
+  if (mprotect(stack, getpagesize() * thread_stack_pages, PROT_READ | PROT_WRITE) != 0) {
     fatal_errno("failed to mprotect debuggerd thread stack");
   }
 
   // Stack grows negatively, set it to the last byte in the page...
-  stack = (stack + thread_stack_pages * PAGE_SIZE - 1);
+  stack = (stack + thread_stack_pages * getpagesize() - 1);
   // and align it.
   stack -= 15;
   pseudothread_stack = stack;
diff --git a/debuggerd/libdebuggerd/scudo.cpp b/debuggerd/libdebuggerd/scudo.cpp
index 5a62fe1e762c..837f40612384 100644
--- a/debuggerd/libdebuggerd/scudo.cpp
+++ b/debuggerd/libdebuggerd/scudo.cpp
@@ -22,6 +22,7 @@
 
 #include <android-base/macros.h>
 #include <bionic/macros.h>
+#include <unistd.h>
 
 #include "tombstone.pb.h"
 
@@ -54,21 +55,21 @@ ScudoCrashData::ScudoCrashData(unwindstack::Memory* process_memory,
   }
 
   untagged_fault_addr_ = process_info.untagged_fault_address;
-  uintptr_t fault_page = untagged_fault_addr_ & ~(PAGE_SIZE - 1);
+  uintptr_t fault_page = untagged_fault_addr_ & ~(getpagesize() - 1);
 
-  uintptr_t memory_begin = fault_page - PAGE_SIZE * 16;
+  uintptr_t memory_begin = fault_page - getpagesize() * 16;
   if (memory_begin > fault_page) {
     return;
   }
 
-  uintptr_t memory_end = fault_page + PAGE_SIZE * 16;
+  uintptr_t memory_end = fault_page + getpagesize() * 16;
   if (memory_end < fault_page) {
     return;
   }
 
   auto memory = std::make_unique<char[]>(memory_end - memory_begin);
-  for (auto i = memory_begin; i != memory_end; i += PAGE_SIZE) {
-    process_memory->ReadFully(i, memory.get() + i - memory_begin, PAGE_SIZE);
+  for (auto i = memory_begin; i != memory_end; i += getpagesize()) {
+    process_memory->ReadFully(i, memory.get() + i - memory_begin, getpagesize());
   }
 
   auto memory_tags = std::make_unique<char[]>((memory_end - memory_begin) / kTagGranuleSize);
diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 7f4959f7f1f8..e568a9bd6b7d 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -613,7 +613,6 @@ static void tune_metadata_csum(const std::string& blk_device, const FstabEntry&
 
 // 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
 #define F2FS_SUPER_OFFSET 1024
 static bool read_f2fs_superblock(const std::string& blk_device, int* fs_stat) {
     android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device.c_str(), O_RDONLY | O_CLOEXEC)));
@@ -628,7 +627,9 @@ static bool read_f2fs_superblock(const std::string& blk_device, int* fs_stat) {
         PERROR << "Can't read '" << blk_device << "' superblock1";
         return false;
     }
-    if (TEMP_FAILURE_RETRY(pread(fd, &sb2, sizeof(sb2), F2FS_BLKSIZE + F2FS_SUPER_OFFSET)) !=
+    // F2FS only supports block_size=page_size case. So, it is safe to call
+    // `getpagesize()` and use that as size of super block.
+    if (TEMP_FAILURE_RETRY(pread(fd, &sb2, sizeof(sb2), getpagesize() + F2FS_SUPER_OFFSET)) !=
         sizeof(sb2)) {
         PERROR << "Can't read '" << blk_device << "' superblock2";
         return false;
@@ -652,7 +653,7 @@ bool fs_mgr_is_f2fs(const std::string& blk_device) {
         return false;
     }
     if (sb == cpu_to_le32(F2FS_SUPER_MAGIC)) return true;
-    if (TEMP_FAILURE_RETRY(pread(fd, &sb, sizeof(sb), F2FS_BLKSIZE + F2FS_SUPER_OFFSET)) !=
+    if (TEMP_FAILURE_RETRY(pread(fd, &sb, sizeof(sb), getpagesize() + F2FS_SUPER_OFFSET)) !=
         sizeof(sb)) {
         return false;
     }
diff --git a/fs_mgr/fs_mgr_format.cpp b/fs_mgr/fs_mgr_format.cpp
index 7385f796161a..622f18135dcd 100644
--- a/fs_mgr/fs_mgr_format.cpp
+++ b/fs_mgr/fs_mgr_format.cpp
@@ -32,6 +32,7 @@
 #include <selinux/android.h>
 #include <selinux/label.h>
 #include <selinux/selinux.h>
+#include <string>
 
 #include "fs_mgr_priv.h"
 
@@ -68,6 +69,13 @@ static int format_ext4(const std::string& fs_blkdev, const std::string& fs_mnt_p
 
     /* Format the partition using the calculated length */
 
+    // EXT4 supports 4K block size on 16K page sizes. A 4K block
+    // size formatted EXT4 partition will mount fine on both 4K and 16K page
+    // size kernels.
+    // However, EXT4 does not support 16K block size on 4K systems.
+    // If we want the same userspace code to work on both 4k/16k kernels,
+    // using a hardcoded 4096 block size is a simple solution. Using
+    // getpagesize() here would work as well, but 4096 is simpler.
     std::string size_str = std::to_string(dev_sz / 4096);
 
     std::vector<const char*> mke2fs_args = {"/system/bin/mke2fs", "-t", "ext4", "-b", "4096"};
@@ -127,7 +135,7 @@ static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool needs
 
     /* Format the partition using the calculated length */
 
-    std::string size_str = std::to_string(dev_sz / 4096);
+    const auto size_str = std::to_string(dev_sz / getpagesize());
 
     std::vector<const char*> args = {"/system/bin/make_f2fs", "-g", "android"};
     if (needs_projid) {
diff --git a/fs_mgr/fs_mgr_overlayfs.cpp b/fs_mgr/fs_mgr_overlayfs.cpp
index f04fc8d2f1b5..01827d6cc576 100644
--- a/fs_mgr/fs_mgr_overlayfs.cpp
+++ b/fs_mgr/fs_mgr_overlayfs.cpp
@@ -939,7 +939,9 @@ bool MakeScratchFilesystem(const std::string& scratch_device) {
     auto command = ""s;
     if (!access(kMkF2fs.c_str(), X_OK) && fs_mgr_filesystem_available("f2fs")) {
         fs_type = "f2fs";
-        command = kMkF2fs + " -w 4096 -f -d1 -l" + android::base::Basename(kScratchMountPoint);
+        command = kMkF2fs + " -w ";
+        command += std::to_string(getpagesize());
+        command += " -f -d1 -l" + android::base::Basename(kScratchMountPoint);
     } else if (!access(kMkExt4.c_str(), X_OK) && fs_mgr_filesystem_available("ext4")) {
         fs_type = "ext4";
         command = kMkExt4 + " -F -b 4096 -t ext4 -m 0 -O has_journal -M " + kScratchMountPoint;

From db15b6f93d828d0c4a9705e845b41d48be22b6f2 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Wed, 3 May 2023 15:28:39 -0700
Subject: [PATCH 0146/1487] Improve error message of libmodprobe

Log path of module if that module is not found.

Bug: 273752147
Test: th
Change-Id: I428a116ee26f97455229df642acbdc1297098a32
---
 libmodprobe/libmodprobe.cpp     | 5 +++--
 libmodprobe/libmodprobe_ext.cpp | 4 ++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index 858b9555f2e4..d20b6b10a368 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -230,7 +230,7 @@ void Modprobe::ParseCfg(const std::string& cfg,
     }
 
     std::vector<std::string> lines = android::base::Split(cfg_contents, "\n");
-    for (const std::string line : lines) {
+    for (const auto& line : lines) {
         if (line.empty() || line[0] == '#') {
             continue;
         }
@@ -421,7 +421,8 @@ bool Modprobe::LoadWithAliases(const std::string& module_name, bool strict,
     }
 
     if (strict && !module_loaded) {
-        LOG(ERROR) << "LoadWithAliases was unable to load " << module_name;
+        LOG(ERROR) << "LoadWithAliases was unable to load " << module_name
+                   << ", tried: " << android::base::Join(modules_to_load, ", ");
         return false;
     }
     return true;
diff --git a/libmodprobe/libmodprobe_ext.cpp b/libmodprobe/libmodprobe_ext.cpp
index 94a1dc4e97cd..c4519e3929af 100644
--- a/libmodprobe/libmodprobe_ext.cpp
+++ b/libmodprobe/libmodprobe_ext.cpp
@@ -84,7 +84,7 @@ bool Modprobe::Rmmod(const std::string& module_name) {
 }
 
 bool Modprobe::ModuleExists(const std::string& module_name) {
-    struct stat fileStat;
+    struct stat fileStat {};
     if (blocklist_enabled && module_blocklist_.count(module_name)) {
         LOG(INFO) << "module " << module_name << " is blocklisted";
         return false;
@@ -95,7 +95,7 @@ bool Modprobe::ModuleExists(const std::string& module_name) {
         return false;
     }
     if (stat(deps.front().c_str(), &fileStat)) {
-        LOG(INFO) << "module " << module_name << " does not exist";
+        PLOG(INFO) << "module " << module_name << " can't be loaded; can't access " << deps.front();
         return false;
     }
     if (!S_ISREG(fileStat.st_mode)) {

From aab4105ef617c9bc806d14a585e59ec7546ff25d Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Tue, 27 Jun 2023 16:06:35 -0700
Subject: [PATCH 0147/1487] Drop const assignment operator.

Also, silence cert-oop54-cpp - self-assignment is already handled in
VectorImpl class.

Bug: 289151149
Test: it builds
Change-Id: I8be7714ed53d1515df7cfdf6de6f3c90b3e5cc76
---
 libutils/include/utils/Vector.h | 36 +++++++++++----------------------
 1 file changed, 12 insertions(+), 24 deletions(-)

diff --git a/libutils/include/utils/Vector.h b/libutils/include/utils/Vector.h
index be35ea2f04d2..d5db3cb482fe 100644
--- a/libutils/include/utils/Vector.h
+++ b/libutils/include/utils/Vector.h
@@ -67,13 +67,10 @@ class Vector : private VectorImpl
     virtual                 ~Vector();
 
     /*! copy operator */
-            const Vector<TYPE>&     operator = (const Vector<TYPE>& rhs) const;
-            Vector<TYPE>&           operator = (const Vector<TYPE>& rhs);
+    Vector<TYPE>& operator=(const Vector<TYPE>& rhs);        // NOLINT(cert-oop54-cpp)
+    Vector<TYPE>& operator=(const SortedVector<TYPE>& rhs);  // NOLINT(cert-oop54-cpp)
 
-            const Vector<TYPE>&     operator = (const SortedVector<TYPE>& rhs) const;
-            Vector<TYPE>&           operator = (const SortedVector<TYPE>& rhs);
-
-            /*
+    /*
      * empty the vector
      */
 
@@ -248,27 +245,18 @@ Vector<TYPE>::~Vector() {
     finish_vector();
 }
 
-template<class TYPE> inline
-Vector<TYPE>& Vector<TYPE>::operator = (const Vector<TYPE>& rhs) {
-    VectorImpl::operator = (rhs);
-    return *this;
-}
-
-template<class TYPE> inline
-const Vector<TYPE>& Vector<TYPE>::operator = (const Vector<TYPE>& rhs) const {
-    VectorImpl::operator = (static_cast<const VectorImpl&>(rhs));
-    return *this;
-}
-
-template<class TYPE> inline
-Vector<TYPE>& Vector<TYPE>::operator = (const SortedVector<TYPE>& rhs) {
-    VectorImpl::operator = (static_cast<const VectorImpl&>(rhs));
+template <class TYPE>
+inline Vector<TYPE>& Vector<TYPE>::operator=(const Vector<TYPE>& rhs)  // NOLINT(cert-oop54-cpp)
+{
+    VectorImpl::operator=(rhs);
     return *this;
 }
 
-template<class TYPE> inline
-const Vector<TYPE>& Vector<TYPE>::operator = (const SortedVector<TYPE>& rhs) const {
-    VectorImpl::operator = (rhs);
+template <class TYPE>
+inline Vector<TYPE>& Vector<TYPE>::operator=(
+        const SortedVector<TYPE>& rhs)  // NOLINT(cert-oop54-cpp)
+{
+    VectorImpl::operator=(static_cast<const VectorImpl&>(rhs));
     return *this;
 }
 

From d6d8c1f81c63ae95f4bd794060c07558e53dfd67 Mon Sep 17 00:00:00 2001
From: Daeho Jeong <daehojeong@google.com>
Date: Wed, 28 Jun 2023 14:35:30 -0700
Subject: [PATCH 0148/1487] init.rc: set f2fs seq_file_ra_mul to 128

Based on experiments, we fount out 128 (128 x global readahead window
size = 16mb) is the optimal multiple to boost up read speeds for the
sequentially accessed files with POSIX_FADV_SEQUENTIAL.

Bug: 195311558
Test: check the /sys/fs/f2fs/<userdata partition>/seq_file_ra_mul value
Change-Id: I7563ad6e47b9ab76ae7fe36978d0e5970a7490e8
Signed-off-by: Daeho Jeong <daehojeong@google.com>
---
 rootdir/init.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 53443685263a..a8b78d5d8025 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1129,7 +1129,7 @@ on boot
     write /dev/sys/fs/by-name/userdata/iostat_enable 1
 
     # set readahead multiplier for POSIX_FADV_SEQUENTIAL files
-    write /dev/sys/fs/by-name/userdata/seq_file_ra_mul 16
+    write /dev/sys/fs/by-name/userdata/seq_file_ra_mul 128
 
     # limit discard size to 128MB in order to avoid long IO latency
     # for filesystem tuning first (dm or sda)

From 0c44d8d68d56c7aecb828d8d87fba7dcb114f3d9 Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Thu, 29 Jun 2023 09:26:09 -0700
Subject: [PATCH 0149/1487] Make atrace_*_body explicitly a part of API.

Also, remove leftover atrace_set_debuggable(bool) symbol.

Bug: 289151149
Test: it builds
Change-Id: Id9fdf9451567d85b64971a6bb409336b12d3f535
---
 libcutils/include/cutils/trace.h | 40 ++++++++++++++++++++++++--------
 libcutils/trace-host.cpp         |  1 -
 2 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/libcutils/include/cutils/trace.h b/libcutils/include/cutils/trace.h
index 3867f346911d..7f57637ec116 100644
--- a/libcutils/include/cutils/trace.h
+++ b/libcutils/include/cutils/trace.h
@@ -89,6 +89,36 @@ __BEGIN_DECLS
 #error ATRACE_TAG must be defined to be one of the tags defined in cutils/trace.h
 #endif
 
+/** Internal implementation detail. Do not use. */
+void atrace_begin_body(const char*);
+
+/** Internal implementation detail. Do not use. */
+void atrace_end_body();
+
+/** Internal implementation detail. Do not use. */
+void atrace_async_begin_body(const char*, int32_t);
+
+/** Internal implementation detail. Do not use. */
+void atrace_async_end_body(const char*, int32_t);
+
+/** Internal implementation detail. Do not use. */
+void atrace_async_for_track_begin_body(const char*, const char*, int32_t);
+
+/** Internal implementation detail. Do not use. */
+void atrace_async_for_track_end_body(const char*, int32_t);
+
+/** Internal implementation detail. Do not use. */
+void atrace_instant_body(const char*);
+
+/** Internal implementation detail. Do not use. */
+void atrace_instant_for_track_body(const char*, const char*);
+
+/** Internal implementation detail. Do not use. */
+void atrace_int_body(const char*, int32_t);
+
+/** Internal implementation detail. Do not use. */
+void atrace_int64_body(const char*, int64_t);
+
 /**
  * Opens the trace file for writing and reads the property for initial tags.
  * The atrace.tags.enableflags property sets the tags to trace.
@@ -159,7 +189,6 @@ static inline uint64_t atrace_is_tag_enabled(uint64_t tag)
 static inline void atrace_begin(uint64_t tag, const char* name)
 {
     if (CC_UNLIKELY(atrace_is_tag_enabled(tag))) {
-        void atrace_begin_body(const char*);
         atrace_begin_body(name);
     }
 }
@@ -172,7 +201,6 @@ static inline void atrace_begin(uint64_t tag, const char* name)
 static inline void atrace_end(uint64_t tag)
 {
     if (CC_UNLIKELY(atrace_is_tag_enabled(tag))) {
-        void atrace_end_body();
         atrace_end_body();
     }
 }
@@ -190,7 +218,6 @@ static inline void atrace_async_begin(uint64_t tag, const char* name,
         int32_t cookie)
 {
     if (CC_UNLIKELY(atrace_is_tag_enabled(tag))) {
-        void atrace_async_begin_body(const char*, int32_t);
         atrace_async_begin_body(name, cookie);
     }
 }
@@ -203,7 +230,6 @@ static inline void atrace_async_begin(uint64_t tag, const char* name,
 static inline void atrace_async_end(uint64_t tag, const char* name, int32_t cookie)
 {
     if (CC_UNLIKELY(atrace_is_tag_enabled(tag))) {
-        void atrace_async_end_body(const char*, int32_t);
         atrace_async_end_body(name, cookie);
     }
 }
@@ -221,7 +247,6 @@ static inline void atrace_async_end(uint64_t tag, const char* name, int32_t cook
 static inline void atrace_async_for_track_begin(uint64_t tag, const char* track_name,
                                                 const char* name, int32_t cookie) {
     if (CC_UNLIKELY(atrace_is_tag_enabled(tag))) {
-        void atrace_async_for_track_begin_body(const char*, const char*, int32_t);
         atrace_async_for_track_begin_body(track_name, name, cookie);
     }
 }
@@ -235,7 +260,6 @@ static inline void atrace_async_for_track_begin(uint64_t tag, const char* track_
 static inline void atrace_async_for_track_end(uint64_t tag, const char* track_name,
                                               int32_t cookie) {
     if (CC_UNLIKELY(atrace_is_tag_enabled(tag))) {
-        void atrace_async_for_track_end_body(const char*, int32_t);
         atrace_async_for_track_end_body(track_name, cookie);
     }
 }
@@ -252,7 +276,6 @@ static inline void atrace_async_for_track_end(uint64_t tag, const char* track_na
 #define ATRACE_INSTANT(name) atrace_instant(ATRACE_TAG, name)
 static inline void atrace_instant(uint64_t tag, const char* name) {
     if (CC_UNLIKELY(atrace_is_tag_enabled(tag))) {
-        void atrace_instant_body(const char*);
         atrace_instant_body(name);
     }
 }
@@ -269,7 +292,6 @@ static inline void atrace_instant(uint64_t tag, const char* name) {
 static inline void atrace_instant_for_track(uint64_t tag, const char* track_name,
                                             const char* name) {
     if (CC_UNLIKELY(atrace_is_tag_enabled(tag))) {
-        void atrace_instant_for_track_body(const char*, const char*);
         atrace_instant_for_track_body(track_name, name);
     }
 }
@@ -282,7 +304,6 @@ static inline void atrace_instant_for_track(uint64_t tag, const char* track_name
 static inline void atrace_int(uint64_t tag, const char* name, int32_t value)
 {
     if (CC_UNLIKELY(atrace_is_tag_enabled(tag))) {
-        void atrace_int_body(const char*, int32_t);
         atrace_int_body(name, value);
     }
 }
@@ -295,7 +316,6 @@ static inline void atrace_int(uint64_t tag, const char* name, int32_t value)
 static inline void atrace_int64(uint64_t tag, const char* name, int64_t value)
 {
     if (CC_UNLIKELY(atrace_is_tag_enabled(tag))) {
-        void atrace_int64_body(const char*, int64_t);
         atrace_int64_body(name, value);
     }
 }
diff --git a/libcutils/trace-host.cpp b/libcutils/trace-host.cpp
index e9f58c356d00..2bf57ebbefb2 100644
--- a/libcutils/trace-host.cpp
+++ b/libcutils/trace-host.cpp
@@ -20,7 +20,6 @@ atomic_bool             atrace_is_ready      = ATOMIC_VAR_INIT(true);
 int                     atrace_marker_fd     = -1;
 uint64_t                atrace_enabled_tags  = 0;
 
-void atrace_set_debuggable(bool /*debuggable*/) {}
 void atrace_set_tracing_enabled(bool /*enabled*/) {}
 void atrace_update_tags() { }
 void atrace_setup() { }

From 29ad6c2aa27384fbd44fbf520528e90ae9ce0c34 Mon Sep 17 00:00:00 2001
From: Jiakai Zhang <jiakaiz@google.com>
Date: Wed, 28 Jun 2023 21:28:27 +0100
Subject: [PATCH 0150/1487] Add a variant of ReadFstabFromFile for
 /proc/mounts.

The variant excludes the code that is not for /proc/mounts, and
therefore saves code size when being called.

Also, after this change, the call to `SkipMountingPartitions` is skipped
for /proc/mounts because it is not needed.

Bug: 287958783
Test: atest CtsFsMgrTestCases
Change-Id: Ie243257fa2e87e666be7decf97ec36c806bc4524
---
 fs_mgr/fs_mgr_fstab.cpp            | 35 ++++++++++++++++++++----------
 fs_mgr/include_fstab/fstab/fstab.h |  1 +
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/fs_mgr/fs_mgr_fstab.cpp b/fs_mgr/fs_mgr_fstab.cpp
index c3c10ba62701..c85e83116bde 100644
--- a/fs_mgr/fs_mgr_fstab.cpp
+++ b/fs_mgr/fs_mgr_fstab.cpp
@@ -51,6 +51,7 @@ namespace fs_mgr {
 namespace {
 
 constexpr char kDefaultAndroidDtDir[] = "/proc/device-tree/firmware/android";
+constexpr char kProcMountsPath[] = "/proc/mounts";
 
 struct FlagList {
     const char *name;
@@ -699,9 +700,7 @@ void EnableMandatoryFlags(Fstab* fstab) {
     }
 }
 
-bool ReadFstabFromFile(const std::string& path, Fstab* fstab_out) {
-    const bool is_proc_mounts = (path == "/proc/mounts");
-
+static bool ReadFstabFromFileCommon(const std::string& path, Fstab* fstab_out) {
     std::string fstab_str;
     if (!android::base::ReadFileToString(path, &fstab_str, /* follow_symlinks = */ true)) {
         PERROR << __FUNCTION__ << "(): failed to read file: '" << path << "'";
@@ -709,11 +708,22 @@ bool ReadFstabFromFile(const std::string& path, Fstab* fstab_out) {
     }
 
     Fstab fstab;
-    if (!ParseFstabFromString(fstab_str, is_proc_mounts, &fstab)) {
+    if (!ParseFstabFromString(fstab_str, path == kProcMountsPath, &fstab)) {
         LERROR << __FUNCTION__ << "(): failed to load fstab from : '" << path << "'";
         return false;
     }
-    if (!is_proc_mounts) {
+
+    EnableMandatoryFlags(&fstab);
+
+    *fstab_out = std::move(fstab);
+    return true;
+}
+
+bool ReadFstabFromFile(const std::string& path, Fstab* fstab) {
+    if (!ReadFstabFromFileCommon(path, fstab)) {
+        return false;
+    }
+    if (path != kProcMountsPath) {
         if (!access(android::gsi::kGsiBootedIndicatorFile, F_OK)) {
             std::string dsu_slot;
             if (!android::gsi::GetActiveDsu(&dsu_slot)) {
@@ -725,20 +735,23 @@ bool ReadFstabFromFile(const std::string& path, Fstab* fstab_out) {
                 PERROR << __FUNCTION__ << "(): failed to read DSU LP names";
                 return false;
             }
-            TransformFstabForDsu(&fstab, dsu_slot, Split(lp_names, ","));
+            TransformFstabForDsu(fstab, dsu_slot, Split(lp_names, ","));
         } else if (errno != ENOENT) {
             PERROR << __FUNCTION__ << "(): failed to access() DSU booted indicator";
             return false;
         }
-    }
-
-    SkipMountingPartitions(&fstab, false /* verbose */);
-    EnableMandatoryFlags(&fstab);
 
-    *fstab_out = std::move(fstab);
+        SkipMountingPartitions(fstab, false /* verbose */);
+    }
     return true;
 }
 
+bool ReadFstabFromProcMounts(Fstab* fstab) {
+    // Don't call `ReadFstabFromFile` because the code for `path != kProcMountsPath` has an extra
+    // code size cost, even if it's never executed.
+    return ReadFstabFromFileCommon(kProcMountsPath, fstab);
+}
+
 // Returns fstab entries parsed from the device tree if they exist
 bool ReadFstabFromDt(Fstab* fstab, bool verbose) {
     std::string fstab_buf = ReadFstabFromDt();
diff --git a/fs_mgr/include_fstab/fstab/fstab.h b/fs_mgr/include_fstab/fstab/fstab.h
index a914b53bb39c..9cb1546c5aaf 100644
--- a/fs_mgr/include_fstab/fstab/fstab.h
+++ b/fs_mgr/include_fstab/fstab/fstab.h
@@ -101,6 +101,7 @@ std::string GetFstabPath();
 bool SkipMountWithConfig(const std::string& skip_config, Fstab* fstab, bool verbose);
 
 bool ReadFstabFromFile(const std::string& path, Fstab* fstab);
+bool ReadFstabFromProcMounts(Fstab* fstab);
 bool ReadFstabFromDt(Fstab* fstab, bool verbose = true);
 bool ReadDefaultFstab(Fstab* fstab);
 bool SkipMountingPartitions(Fstab* fstab, bool verbose = false);

From 25ec9c4db1345e0b338e333f661bd7ffafa36732 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= <maze@google.com>
Date: Thu, 29 Jun 2023 10:52:40 +0000
Subject: [PATCH 0151/1487] add 'nodad' support to ifc_add_address()
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Test: TreeHugger
Bug: 242067762
Signed-off-by: Maciej Żenczykowski <maze@google.com>
Change-Id: I2c022f6af45eac7631213801a89aa270709d4a57
---
 libnetutils/ifc_utils.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/libnetutils/ifc_utils.c b/libnetutils/ifc_utils.c
index 5999e39ba0fa..7cca105c2817 100644
--- a/libnetutils/ifc_utils.c
+++ b/libnetutils/ifc_utils.c
@@ -362,14 +362,19 @@ int ifc_act_on_address(int action, const char* name, const char* address, int pr
     return err->error;
 }
 
+// Pass bitwise complement of prefix length to disable DAD, ie. use ~64 instead of 64.
 // Returns zero on success and negative errno on failure.
 int ifc_add_address(const char *name, const char *address, int prefixlen) {
-    return ifc_act_on_address(RTM_NEWADDR, name, address, prefixlen, /*nodad*/ false);
+    bool nodad = (prefixlen < 0);
+    if (nodad) prefixlen = ~prefixlen;
+    return ifc_act_on_address(RTM_NEWADDR, name, address, prefixlen, nodad);
 }
 
 // Returns zero on success and negative errno on failure.
 int ifc_del_address(const char *name, const char * address, int prefixlen) {
-    return ifc_act_on_address(RTM_DELADDR, name, address, prefixlen, /*nodad*/ false);
+    bool nodad = (prefixlen < 0);
+    if (nodad) prefixlen = ~prefixlen;
+    return ifc_act_on_address(RTM_DELADDR, name, address, prefixlen, nodad);
 }
 
 /*

From 379d5c83d58fa78d4d919a26488e83b26fd6639d Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Sat, 1 Jul 2023 00:27:23 +0000
Subject: [PATCH 0152/1487] libutils: rewrite Vector fuzzer

It could never have gotten much coverage.

Bug: 288741501
Test: libutils_fuzz_vector (2,000,000 iterations)
                           (~60k-100k iterations/s)
Change-Id: I6f442642b5a3246dd08784f735db5aad5fd4d398
---
 libutils/Vector_fuzz.cpp | 250 ++++++++++++++++++++++++++++++---------
 1 file changed, 191 insertions(+), 59 deletions(-)

diff --git a/libutils/Vector_fuzz.cpp b/libutils/Vector_fuzz.cpp
index f6df05135a0b..6fd2baf17ca2 100644
--- a/libutils/Vector_fuzz.cpp
+++ b/libutils/Vector_fuzz.cpp
@@ -13,71 +13,203 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "fuzzer/FuzzedDataProvider.h"
-#include "utils/Vector.h"
-static constexpr uint16_t MAX_VEC_SIZE = 5000;
+#include <fuzzer/FuzzedDataProvider.h>
+#include <utils/Log.h>
+#include <utils/Vector.h>
 
-void runVectorFuzz(const uint8_t* data, size_t size) {
-    FuzzedDataProvider dataProvider(data, size);
-    android::Vector<uint8_t> vec = android::Vector<uint8_t>();
-    // We want to test handling of sizeof as well.
-    android::Vector<uint32_t> vec32 = android::Vector<uint32_t>();
+#include <functional>
 
-    // We're going to generate two vectors of this size
-    size_t vectorSize = dataProvider.ConsumeIntegralInRange<size_t>(0, MAX_VEC_SIZE);
-    vec.setCapacity(vectorSize);
-    vec32.setCapacity(vectorSize);
-    for (size_t i = 0; i < vectorSize; i++) {
-        uint8_t count = dataProvider.ConsumeIntegralInRange<uint8_t>(1, 5);
-        vec.insertAt((uint8_t)i, i, count);
-        vec32.insertAt((uint32_t)i, i, count);
-        vec.push_front(i);
-        vec32.push(i);
-    }
+using android::Vector;
 
-    // Now we'll perform some test operations with any remaining data
-    // Index to perform operations at
-    size_t index = dataProvider.ConsumeIntegralInRange<size_t>(0, vec.size());
-    std::vector<uint8_t> remainingVec = dataProvider.ConsumeRemainingBytes<uint8_t>();
-    // Insert an array and vector
-    vec.insertArrayAt(remainingVec.data(), index, remainingVec.size());
-    android::Vector<uint8_t> vecCopy = android::Vector<uint8_t>(vec);
-    vec.insertVectorAt(vecCopy, index);
-    // Same thing for 32 bit vector
-    android::Vector<uint32_t> vec32Copy = android::Vector<uint32_t>(vec32);
-    vec32.insertArrayAt(vec32Copy.array(), index, vec32.size());
-    vec32.insertVectorAt(vec32Copy, index);
-    // Replace single character
-    if (remainingVec.size() > 0) {
-        vec.replaceAt(remainingVec[0], index);
-        vec32.replaceAt(static_cast<uint32_t>(remainingVec[0]), index);
-    } else {
-        vec.replaceAt(0, index);
-        vec32.replaceAt(0, index);
-    }
-    // Add any remaining bytes
-    for (uint8_t i : remainingVec) {
-        vec.add(i);
-        vec32.add(static_cast<uint32_t>(i));
+static constexpr uint16_t MAX_VEC_SIZE = 100;
+static constexpr bool kLog = false;
+
+struct NonTrivialDestructor {
+    NonTrivialDestructor() : mInit(1) {}
+    ~NonTrivialDestructor() {
+        LOG_ALWAYS_FATAL_IF(mInit != 1, "mInit should be 1, but it's: %d", mInit);
+        mInit--;
+        LOG_ALWAYS_FATAL_IF(mInit != 0, "mInit should be 0, but it's: %d", mInit);
     }
-    // Shrink capactiy
-    vec.setCapacity(remainingVec.size());
-    vec32.setCapacity(remainingVec.size());
-    // Iterate through each pointer
-    size_t sum = 0;
-    for (auto& it : vec) {
-        sum += it;
+
+  private:
+    uint8_t mInit;
+};
+
+template <typename T>
+struct VectorFuzzerData {
+    Vector<T> vector;
+    const std::vector<std::function<void(FuzzedDataProvider&, Vector<T>&)>> funcs = {
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                // operator= Vector<TYPE>, still needs for SortedVector
+                if (kLog) ALOGI("operator=");
+                vector = testVector(provider);
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                if (kLog) ALOGI("clear");
+                vector.clear();
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                if (kLog) ALOGI("size");
+                vector.size();
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                if (kLog) ALOGI("isEmpty");
+                vector.isEmpty();
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                if (kLog) ALOGI("capacity");
+                vector.capacity();
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                size_t vectorSize = provider.ConsumeIntegralInRange<size_t>(0, MAX_VEC_SIZE);
+                if (kLog) ALOGI("setCapacity");
+                vector.setCapacity(vectorSize);
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                size_t vectorSize = provider.ConsumeIntegralInRange<size_t>(0, MAX_VEC_SIZE);
+                if (kLog) ALOGI("resize");
+                vector.resize(vectorSize);
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                if (kLog) ALOGI("array");
+                vector.array();
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                if (kLog) ALOGI("editArray");
+                vector.editArray();
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                if (vector.size() == 0) return;
+                size_t idx = provider.ConsumeIntegralInRange<size_t>(0, vector.size() - 1);
+                if (kLog) ALOGI("operator[]");
+                vector[idx];  // returns a const value for Vector
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                if (vector.size() == 0) return;
+                size_t idx = provider.ConsumeIntegralInRange<size_t>(0, vector.size() - 1);
+                if (kLog) ALOGI("itemAt");
+                vector.itemAt(idx);
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                if (vector.size() == 0) return;
+                if (kLog) ALOGI("top");
+                vector.top();
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                if (vector.size() == 0) return;
+                size_t idx = provider.ConsumeIntegralInRange<size_t>(0, vector.size() - 1);
+                if (kLog) ALOGI("editItemAt");
+                vector.editItemAt(idx);
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                if (vector.size() == 0) return;
+                if (kLog) ALOGI("editTop");
+                vector.editTop() = T{};
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                uint8_t idx = provider.ConsumeIntegralInRange<uint8_t>(0, vector.size());
+                Vector vec2 = testVector(provider);
+                if (vec2.size() == 0) return;  // TODO: maybe we should support this?
+                if (kLog) ALOGI("insertVectorAt %d of size %zu", idx, vec2.size());
+                vector.insertVectorAt(vec2, idx);
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                if (kLog) ALOGI("appendVector");
+                vector.appendVector(testVector(provider));
+            },
+            // TODO: insertArrayAt
+            // TODO: appendArray
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                uint8_t idx = provider.ConsumeIntegralInRange<uint8_t>(0, vector.size());
+                uint8_t numItems = provider.ConsumeIntegralInRange<uint8_t>(1, 100);
+                if (kLog) ALOGI("insertAt");
+                vector.insertAt(idx, numItems);
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                uint8_t idx = provider.ConsumeIntegralInRange<uint8_t>(0, vector.size());
+                uint8_t numItems = provider.ConsumeIntegralInRange<uint8_t>(1, 100);
+                if (kLog) ALOGI("insertAt");
+                vector.insertAt(T{}, idx, numItems);
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                if (vector.size() == 0) return;
+                if (kLog) ALOGI("pop");
+                vector.pop();
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                if (kLog) ALOGI("push");
+                vector.push();
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                if (kLog) ALOGI("add");
+                vector.add();
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                if (kLog) ALOGI("add");
+                vector.add(T{});
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                uint8_t idx = provider.ConsumeIntegralInRange<uint8_t>(0, vector.size() - 1);
+                if (kLog) ALOGI("replaceAt");
+                vector.replaceAt(idx);
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                uint8_t idx = provider.ConsumeIntegralInRange<uint8_t>(0, vector.size() - 1);
+                if (kLog) ALOGI("replaceAt");
+                vector.replaceAt(T{}, idx);
+            },
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                if (vector.size() == 0) return;
+                uint8_t idx = provider.ConsumeIntegralInRange<uint8_t>(0, vector.size() - 1);
+                if (kLog) ALOGI("remoteItemsAt");
+                vector.removeItemsAt(idx);  // TODO: different count
+            },
+            // removeAt is alias for removeItemsAt
+            // TODO: sort
+            [&](FuzzedDataProvider& provider, Vector<T>& vector) {
+                (void)provider;
+                if (kLog) ALOGI("getItemSize");
+                vector.getItemSize();
+            },
+            // TODO: iterators
+    };
+
+    Vector<T> testVector(FuzzedDataProvider& provider) {
+        Vector<T> vec;
+        size_t vectorSize = provider.ConsumeIntegralInRange<size_t>(0, MAX_VEC_SIZE);
+        return vec;
     }
-    for (auto& it : vec32) {
-        sum += it;
+
+    void fuzz(FuzzedDataProvider&& provider) {
+        while (provider.remaining_bytes()) {
+            size_t funcIdx = provider.ConsumeIntegralInRange<size_t>(0, funcs.size() - 1);
+            funcs[funcIdx](provider, vector);
+        }
     }
-    // Cleanup
-    vec.clear();
-    vecCopy.clear();
-    vec32.clear();
-    vec32Copy.clear();
-}
+};
+
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-    runVectorFuzz(data, size);
+    FuzzedDataProvider provider(data, size);
+
+    provider.PickValueInArray<std::function<void()>>({
+            [&]() { VectorFuzzerData<uint8_t>().fuzz(std::move(provider)); },
+            [&]() { VectorFuzzerData<int32_t>().fuzz(std::move(provider)); },
+            [&]() { VectorFuzzerData<NonTrivialDestructor>().fuzz(std::move(provider)); },
+    })();
+
     return 0;
 }

From 5d4c782b1fedfbf339e7e8a3b5547dd5b29a9526 Mon Sep 17 00:00:00 2001
From: Jiakai Zhang <jiakaiz@google.com>
Date: Wed, 28 Jun 2023 21:28:27 +0100
Subject: [PATCH 0153/1487] Add a variant of ReadFstabFromFile for
 /proc/mounts.

The variant excludes the code that is not for /proc/mounts, and
therefore saves code size when being called.

Also, after this change, the call to `SkipMountingPartitions` is skipped
for /proc/mounts because it is not needed.

Bug: 287958783
Test: atest CtsFsMgrTestCases
(cherry picked from https://android-review.googlesource.com/q/commit:29ad6c2aa27384fbd44fbf520528e90ae9ce0c34)
Merged-In: Ie243257fa2e87e666be7decf97ec36c806bc4524
Change-Id: Ie243257fa2e87e666be7decf97ec36c806bc4524
---
 fs_mgr/fs_mgr_fstab.cpp            | 35 ++++++++++++++++++++----------
 fs_mgr/include_fstab/fstab/fstab.h |  1 +
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/fs_mgr/fs_mgr_fstab.cpp b/fs_mgr/fs_mgr_fstab.cpp
index 598a3d2ecb4d..da9e45f4e9a2 100644
--- a/fs_mgr/fs_mgr_fstab.cpp
+++ b/fs_mgr/fs_mgr_fstab.cpp
@@ -51,6 +51,7 @@ namespace fs_mgr {
 namespace {
 
 constexpr char kDefaultAndroidDtDir[] = "/proc/device-tree/firmware/android";
+constexpr char kProcMountsPath[] = "/proc/mounts";
 
 struct FlagList {
     const char *name;
@@ -697,9 +698,7 @@ void EnableMandatoryFlags(Fstab* fstab) {
     }
 }
 
-bool ReadFstabFromFile(const std::string& path, Fstab* fstab_out) {
-    const bool is_proc_mounts = (path == "/proc/mounts");
-
+static bool ReadFstabFromFileCommon(const std::string& path, Fstab* fstab_out) {
     std::string fstab_str;
     if (!android::base::ReadFileToString(path, &fstab_str, /* follow_symlinks = */ true)) {
         PERROR << __FUNCTION__ << "(): failed to read file: '" << path << "'";
@@ -707,11 +706,22 @@ bool ReadFstabFromFile(const std::string& path, Fstab* fstab_out) {
     }
 
     Fstab fstab;
-    if (!ParseFstabFromString(fstab_str, is_proc_mounts, &fstab)) {
+    if (!ParseFstabFromString(fstab_str, path == kProcMountsPath, &fstab)) {
         LERROR << __FUNCTION__ << "(): failed to load fstab from : '" << path << "'";
         return false;
     }
-    if (!is_proc_mounts) {
+
+    EnableMandatoryFlags(&fstab);
+
+    *fstab_out = std::move(fstab);
+    return true;
+}
+
+bool ReadFstabFromFile(const std::string& path, Fstab* fstab) {
+    if (!ReadFstabFromFileCommon(path, fstab)) {
+        return false;
+    }
+    if (path != kProcMountsPath) {
         if (!access(android::gsi::kGsiBootedIndicatorFile, F_OK)) {
             std::string dsu_slot;
             if (!android::gsi::GetActiveDsu(&dsu_slot)) {
@@ -723,20 +733,23 @@ bool ReadFstabFromFile(const std::string& path, Fstab* fstab_out) {
                 PERROR << __FUNCTION__ << "(): failed to read DSU LP names";
                 return false;
             }
-            TransformFstabForDsu(&fstab, dsu_slot, Split(lp_names, ","));
+            TransformFstabForDsu(fstab, dsu_slot, Split(lp_names, ","));
         } else if (errno != ENOENT) {
             PERROR << __FUNCTION__ << "(): failed to access() DSU booted indicator";
             return false;
         }
-    }
-
-    SkipMountingPartitions(&fstab, false /* verbose */);
-    EnableMandatoryFlags(&fstab);
 
-    *fstab_out = std::move(fstab);
+        SkipMountingPartitions(fstab, false /* verbose */);
+    }
     return true;
 }
 
+bool ReadFstabFromProcMounts(Fstab* fstab) {
+    // Don't call `ReadFstabFromFile` because the code for `path != kProcMountsPath` has an extra
+    // code size cost, even if it's never executed.
+    return ReadFstabFromFileCommon(kProcMountsPath, fstab);
+}
+
 // Returns fstab entries parsed from the device tree if they exist
 bool ReadFstabFromDt(Fstab* fstab, bool verbose) {
     std::string fstab_buf = ReadFstabFromDt();
diff --git a/fs_mgr/include_fstab/fstab/fstab.h b/fs_mgr/include_fstab/fstab/fstab.h
index a914b53bb39c..9cb1546c5aaf 100644
--- a/fs_mgr/include_fstab/fstab/fstab.h
+++ b/fs_mgr/include_fstab/fstab/fstab.h
@@ -101,6 +101,7 @@ std::string GetFstabPath();
 bool SkipMountWithConfig(const std::string& skip_config, Fstab* fstab, bool verbose);
 
 bool ReadFstabFromFile(const std::string& path, Fstab* fstab);
+bool ReadFstabFromProcMounts(Fstab* fstab);
 bool ReadFstabFromDt(Fstab* fstab, bool verbose = true);
 bool ReadDefaultFstab(Fstab* fstab);
 bool SkipMountingPartitions(Fstab* fstab, bool verbose = false);

From 572692c04c618c9f0ee2ec8d2192004396ccfb89 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 21 Jun 2023 09:42:38 -0700
Subject: [PATCH 0154/1487] snapuserd: Make header_response a state variable.

header_response is meant to only be true for the first call to
WriteDmUserPayload. Codify this by making it a member variable and
resetting it on each request.

Bug: 288273605
Test: snapuserd_test
Change-Id: Ic92f5932391a607b63345d579f379d12e78e8f6c
---
 .../user-space-merge/snapuserd_core.h         |  7 +--
 .../user-space-merge/snapuserd_dm_user.cpp    | 46 +++++++++----------
 2 files changed, 27 insertions(+), 26 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index c16ad24a5c69..cf38875848f7 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -120,7 +120,7 @@ class Worker {
 
     // Functions interacting with dm-user
     bool ReadDmUserHeader();
-    bool WriteDmUserPayload(size_t size, bool header_response);
+    bool WriteDmUserPayload(size_t size);
     bool DmuserReadRequest();
 
     // IO Path
@@ -130,11 +130,11 @@ class Worker {
     bool ReadDataFromBaseDevice(sector_t sector, size_t read_size);
     bool ReadFromSourceDevice(const CowOperation* cow_op);
 
-    bool ReadAlignedSector(sector_t sector, size_t sz, bool header_response);
+    bool ReadAlignedSector(sector_t sector, size_t sz);
     bool ReadUnalignedSector(sector_t sector, size_t size);
     int ReadUnalignedSector(sector_t sector, size_t size,
                             std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it);
-    bool RespondIOError(bool header_response);
+    bool RespondIOError();
 
     // Processing COW operations
     bool ProcessCowOp(const CowOperation* cow_op);
@@ -176,6 +176,7 @@ class Worker {
     unique_fd backing_store_fd_;
     unique_fd base_path_merge_fd_;
     unique_fd ctrl_fd_;
+    bool header_response_ = false;
 
     std::unique_ptr<ICowOpIter> cowop_iter_;
     size_t ra_block_index_ = 0;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
index 44b731912692..c505c32a15eb 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
@@ -306,10 +306,10 @@ bool Worker::ReadDmUserHeader() {
 }
 
 // Send the payload/data back to dm-user misc device.
-bool Worker::WriteDmUserPayload(size_t size, bool header_response) {
+bool Worker::WriteDmUserPayload(size_t size) {
     size_t payload_size = size;
     void* buf = bufsink_.GetPayloadBufPtr();
-    if (header_response) {
+    if (header_response_) {
         payload_size += sizeof(struct dm_user_header);
         buf = bufsink_.GetBufPtr();
     }
@@ -319,6 +319,9 @@ bool Worker::WriteDmUserPayload(size_t size, bool header_response) {
         return false;
     }
 
+    // After the first header is sent in response to a request, we cannot
+    // send any additional headers.
+    header_response_ = false;
     return true;
 }
 
@@ -341,7 +344,7 @@ bool Worker::ReadDataFromBaseDevice(sector_t sector, size_t read_size) {
     return true;
 }
 
-bool Worker::ReadAlignedSector(sector_t sector, size_t sz, bool header_response) {
+bool Worker::ReadAlignedSector(sector_t sector, size_t sz) {
     struct dm_user_header* header = bufsink_.GetHeaderPtr();
     size_t remaining_size = sz;
     std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
@@ -389,7 +392,7 @@ bool Worker::ReadAlignedSector(sector_t sector, size_t sz, bool header_response)
 
             // Just return the header if it is an error
             if (header->type == DM_USER_RESP_ERROR) {
-                if (!RespondIOError(header_response)) {
+                if (!RespondIOError()) {
                     return false;
                 }
 
@@ -404,14 +407,12 @@ bool Worker::ReadAlignedSector(sector_t sector, size_t sz, bool header_response)
         }
 
         if (!io_error) {
-            if (!WriteDmUserPayload(total_bytes_read, header_response)) {
+            if (!WriteDmUserPayload(total_bytes_read)) {
                 return false;
             }
 
             SNAP_LOG(DEBUG) << "WriteDmUserPayload success total_bytes_read: " << total_bytes_read
-                            << " header-response: " << header_response
                             << " remaining_size: " << remaining_size;
-            header_response = false;
             remaining_size -= total_bytes_read;
         }
     } while (remaining_size > 0 && !io_error);
@@ -484,7 +485,6 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
     // to any COW ops. In that case, we just need to read from the base
     // device.
     bool merge_complete = false;
-    bool header_response = true;
     if (it == chunk_vec.end()) {
         if (chunk_vec.size() > 0) {
             // I/O request beyond the last mapped sector
@@ -503,7 +503,7 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
             --it;
         }
     } else {
-        return ReadAlignedSector(sector, size, header_response);
+        return ReadAlignedSector(sector, size);
     }
 
     loff_t requested_offset = sector << SECTOR_SHIFT;
@@ -537,7 +537,7 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
         if (ret < 0) {
             SNAP_LOG(ERROR) << "ReadUnalignedSector failed for sector: " << sector
                             << " size: " << size << " it->sector: " << it->first;
-            return RespondIOError(header_response);
+            return RespondIOError();
         }
 
         remaining_size -= ret;
@@ -545,14 +545,13 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
         sector += (ret >> SECTOR_SHIFT);
 
         // Send the data back
-        if (!WriteDmUserPayload(total_bytes_read, header_response)) {
+        if (!WriteDmUserPayload(total_bytes_read)) {
             return false;
         }
 
-        header_response = false;
         // If we still have pending data to be processed, this will be aligned I/O
         if (remaining_size) {
-            return ReadAlignedSector(sector, remaining_size, header_response);
+            return ReadAlignedSector(sector, remaining_size);
         }
     } else {
         // This is all about handling I/O request to be routed to base device
@@ -566,21 +565,21 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
         CHECK(diff_size <= BLOCK_SZ);
         if (remaining_size < diff_size) {
             if (!ReadDataFromBaseDevice(sector, remaining_size)) {
-                return RespondIOError(header_response);
+                return RespondIOError();
             }
             total_bytes_read += remaining_size;
 
-            if (!WriteDmUserPayload(total_bytes_read, header_response)) {
+            if (!WriteDmUserPayload(total_bytes_read)) {
                 return false;
             }
         } else {
             if (!ReadDataFromBaseDevice(sector, diff_size)) {
-                return RespondIOError(header_response);
+                return RespondIOError();
             }
 
             total_bytes_read += diff_size;
 
-            if (!WriteDmUserPayload(total_bytes_read, header_response)) {
+            if (!WriteDmUserPayload(total_bytes_read)) {
                 return false;
             }
 
@@ -588,17 +587,16 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
             size_t num_sectors_read = (diff_size >> SECTOR_SHIFT);
             sector += num_sectors_read;
             CHECK(IsBlockAligned(sector << SECTOR_SHIFT));
-            header_response = false;
 
             // If we still have pending data to be processed, this will be aligned I/O
-            return ReadAlignedSector(sector, remaining_size, header_response);
+            return ReadAlignedSector(sector, remaining_size);
         }
     }
 
     return true;
 }
 
-bool Worker::RespondIOError(bool header_response) {
+bool Worker::RespondIOError() {
     struct dm_user_header* header = bufsink_.GetHeaderPtr();
     header->type = DM_USER_RESP_ERROR;
     // This is an issue with the dm-user interface. There
@@ -610,9 +608,9 @@ bool Worker::RespondIOError(bool header_response) {
     // this back to dm-user.
     //
     // TODO: Fix the interface
-    CHECK(header_response);
+    CHECK(header_response_);
 
-    if (!WriteDmUserPayload(0, header_response)) {
+    if (!WriteDmUserPayload(0)) {
         return false;
     }
 
@@ -629,7 +627,7 @@ bool Worker::DmuserReadRequest() {
         return ReadUnalignedSector(header->sector, header->len);
     }
 
-    return ReadAlignedSector(header->sector, header->len, true);
+    return ReadAlignedSector(header->sector, header->len);
 }
 
 bool Worker::ProcessIORequest() {
@@ -645,6 +643,8 @@ bool Worker::ProcessIORequest() {
     SNAP_LOG(DEBUG) << "Daemon: msg->type: " << std::dec << header->type;
     SNAP_LOG(DEBUG) << "Daemon: msg->flags: " << std::dec << header->flags;
 
+    header_response_ = true;
+
     switch (header->type) {
         case DM_USER_REQ_MAP_READ: {
             if (!DmuserReadRequest()) {

From b6df0138e5eb6052e16d2cd63045332c68b14cf0 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 21 Jun 2023 12:40:12 -0700
Subject: [PATCH 0155/1487] snapuserd: Return void from RespondIOError.

RespondIOError could return "true" which is not the correct value for
its callers, usually. However since RespondIOError is not specifically
needed anymore, we can also avoid calling it in most places.

This also fixes a bug where ReadUnalignedSector's return value was
implicitly converted to boolean.

Bug: 288273605
Test: snapuserd_test
Change-Id: I62140b2b05d0f9f53cb669c5c0d7e0ffc7f4c9a1
---
 .../user-space-merge/snapuserd_core.h         |  2 +-
 .../user-space-merge/snapuserd_dm_user.cpp    | 23 ++++++-------------
 2 files changed, 8 insertions(+), 17 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index cf38875848f7..7cffc1c4bf47 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -134,7 +134,7 @@ class Worker {
     bool ReadUnalignedSector(sector_t sector, size_t size);
     int ReadUnalignedSector(sector_t sector, size_t size,
                             std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it);
-    bool RespondIOError();
+    void RespondIOError();
 
     // Processing COW operations
     bool ProcessCowOp(const CowOperation* cow_op);
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
index c505c32a15eb..0eb2a14fe620 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
@@ -392,10 +392,7 @@ bool Worker::ReadAlignedSector(sector_t sector, size_t sz) {
 
             // Just return the header if it is an error
             if (header->type == DM_USER_RESP_ERROR) {
-                if (!RespondIOError()) {
-                    return false;
-                }
-
+                RespondIOError();
                 io_error = true;
                 break;
             }
@@ -537,7 +534,7 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
         if (ret < 0) {
             SNAP_LOG(ERROR) << "ReadUnalignedSector failed for sector: " << sector
                             << " size: " << size << " it->sector: " << it->first;
-            return RespondIOError();
+            return false;
         }
 
         remaining_size -= ret;
@@ -565,7 +562,7 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
         CHECK(diff_size <= BLOCK_SZ);
         if (remaining_size < diff_size) {
             if (!ReadDataFromBaseDevice(sector, remaining_size)) {
-                return RespondIOError();
+                return false;
             }
             total_bytes_read += remaining_size;
 
@@ -574,7 +571,7 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
             }
         } else {
             if (!ReadDataFromBaseDevice(sector, diff_size)) {
-                return RespondIOError();
+                return false;
             }
 
             total_bytes_read += diff_size;
@@ -596,7 +593,7 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
     return true;
 }
 
-bool Worker::RespondIOError() {
+void Worker::RespondIOError() {
     struct dm_user_header* header = bufsink_.GetHeaderPtr();
     header->type = DM_USER_RESP_ERROR;
     // This is an issue with the dm-user interface. There
@@ -610,13 +607,7 @@ bool Worker::RespondIOError() {
     // TODO: Fix the interface
     CHECK(header_response_);
 
-    if (!WriteDmUserPayload(0)) {
-        return false;
-    }
-
-    // There is no need to process further as we have already seen
-    // an I/O error
-    return true;
+    WriteDmUserPayload(0);
 }
 
 bool Worker::DmuserReadRequest() {
@@ -624,7 +615,7 @@ bool Worker::DmuserReadRequest() {
 
     // Unaligned I/O request
     if (!IsBlockAligned(header->sector << SECTOR_SHIFT)) {
-        return ReadUnalignedSector(header->sector, header->len);
+        return ReadUnalignedSector(header->sector, header->len) != -1;
     }
 
     return ReadAlignedSector(header->sector, header->len);

From 80ebe8c35d7426f38fa2e951679ce2a765a6bcf2 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 21 Jun 2023 12:00:09 -0700
Subject: [PATCH 0156/1487] snapuserd: Restrict where reads/writes to
 dm_user_header happen.

Only write to dm_user_header in the functions which explicitly need to
marshal it. This avoids leakage of dm-user specifics into core logic.

This also simplifies the existing control flow by allowing us to set an
error anywhere, or nowhere, as any "return false" from ProcessIORequest
will automatically set an error header.

Bug: 288273605
Test: snapuserd_test
Change-Id: I85f67208197d7ecc49e348ab3013827a38e84761
---
 .../user-space-merge/snapuserd_core.h         |  1 -
 .../user-space-merge/snapuserd_dm_user.cpp    | 84 ++++++++-----------
 2 files changed, 34 insertions(+), 51 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index 7cffc1c4bf47..c984a61f89eb 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -119,7 +119,6 @@ class Worker {
     }
 
     // Functions interacting with dm-user
-    bool ReadDmUserHeader();
     bool WriteDmUserPayload(size_t size);
     bool DmuserReadRequest();
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
index 0eb2a14fe620..1b17698a3e1a 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
@@ -290,21 +290,6 @@ bool Worker::RunThread() {
     return true;
 }
 
-// Read Header from dm-user misc device. This gives
-// us the sector number for which IO is issued by dm-snapshot device
-bool Worker::ReadDmUserHeader() {
-    if (!android::base::ReadFully(ctrl_fd_, bufsink_.GetBufPtr(), sizeof(struct dm_user_header))) {
-        if (errno != ENOTBLK) {
-            SNAP_PLOG(ERROR) << "Control-read failed";
-        }
-
-        SNAP_PLOG(DEBUG) << "ReadDmUserHeader failed....";
-        return false;
-    }
-
-    return true;
-}
-
 // Send the payload/data back to dm-user misc device.
 bool Worker::WriteDmUserPayload(size_t size) {
     size_t payload_size = size;
@@ -345,19 +330,15 @@ bool Worker::ReadDataFromBaseDevice(sector_t sector, size_t read_size) {
 }
 
 bool Worker::ReadAlignedSector(sector_t sector, size_t sz) {
-    struct dm_user_header* header = bufsink_.GetHeaderPtr();
     size_t remaining_size = sz;
     std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
-    bool io_error = false;
     int ret = 0;
 
     do {
         // Process 1MB payload at a time
         size_t read_size = std::min(PAYLOAD_BUFFER_SZ, remaining_size);
 
-        header->type = DM_USER_RESP_SUCCESS;
         size_t total_bytes_read = 0;
-        io_error = false;
         bufsink_.ResetBufferOffset();
 
         while (read_size) {
@@ -375,7 +356,7 @@ bool Worker::ReadAlignedSector(sector_t sector, size_t sz) {
                 // device.
                 if (!ReadDataFromBaseDevice(sector, size)) {
                     SNAP_LOG(ERROR) << "ReadDataFromBaseDevice failed";
-                    header->type = DM_USER_RESP_ERROR;
+                    return false;
                 }
 
                 ret = size;
@@ -384,35 +365,26 @@ bool Worker::ReadAlignedSector(sector_t sector, size_t sz) {
                 // process it.
                 if (!ProcessCowOp(it->second)) {
                     SNAP_LOG(ERROR) << "ProcessCowOp failed";
-                    header->type = DM_USER_RESP_ERROR;
+                    return false;
                 }
 
                 ret = BLOCK_SZ;
             }
 
-            // Just return the header if it is an error
-            if (header->type == DM_USER_RESP_ERROR) {
-                RespondIOError();
-                io_error = true;
-                break;
-            }
-
             read_size -= ret;
             total_bytes_read += ret;
             sector += (ret >> SECTOR_SHIFT);
             bufsink_.UpdateBufferOffset(ret);
         }
 
-        if (!io_error) {
-            if (!WriteDmUserPayload(total_bytes_read)) {
-                return false;
-            }
-
-            SNAP_LOG(DEBUG) << "WriteDmUserPayload success total_bytes_read: " << total_bytes_read
-                            << " remaining_size: " << remaining_size;
-            remaining_size -= total_bytes_read;
+        if (!WriteDmUserPayload(total_bytes_read)) {
+            return false;
         }
-    } while (remaining_size > 0 && !io_error);
+
+        SNAP_LOG(DEBUG) << "WriteDmUserPayload success total_bytes_read: " << total_bytes_read
+                        << " remaining_size: " << remaining_size;
+        remaining_size -= total_bytes_read;
+    } while (remaining_size > 0);
 
     return true;
 }
@@ -453,8 +425,6 @@ int Worker::ReadUnalignedSector(
 }
 
 bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
-    struct dm_user_header* header = bufsink_.GetHeaderPtr();
-    header->type = DM_USER_RESP_SUCCESS;
     bufsink_.ResetBufferOffset();
     std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
 
@@ -622,9 +592,15 @@ bool Worker::DmuserReadRequest() {
 }
 
 bool Worker::ProcessIORequest() {
+    // Read Header from dm-user misc device. This gives
+    // us the sector number for which IO is issued by dm-snapshot device
     struct dm_user_header* header = bufsink_.GetHeaderPtr();
+    if (!android::base::ReadFully(ctrl_fd_, header, sizeof(*header))) {
+        if (errno != ENOTBLK) {
+            SNAP_PLOG(ERROR) << "Control-read failed";
+        }
 
-    if (!ReadDmUserHeader()) {
+        SNAP_PLOG(DEBUG) << "ReadDmUserHeader failed....";
         return false;
     }
 
@@ -634,26 +610,34 @@ bool Worker::ProcessIORequest() {
     SNAP_LOG(DEBUG) << "Daemon: msg->type: " << std::dec << header->type;
     SNAP_LOG(DEBUG) << "Daemon: msg->flags: " << std::dec << header->flags;
 
+    // Use the same header buffer as the response header.
+    int request_type = header->type;
+    header->type = DM_USER_RESP_SUCCESS;
     header_response_ = true;
 
-    switch (header->type) {
-        case DM_USER_REQ_MAP_READ: {
-            if (!DmuserReadRequest()) {
-                return false;
-            }
+    bool ok;
+    switch (request_type) {
+        case DM_USER_REQ_MAP_READ:
+            ok = DmuserReadRequest();
             break;
-        }
 
-        case DM_USER_REQ_MAP_WRITE: {
+        case DM_USER_REQ_MAP_WRITE:
             // TODO: We should not get any write request
             // to dm-user as we mount all partitions
             // as read-only. Need to verify how are TRIM commands
             // handled during mount.
-            return false;
-        }
+            ok = false;
+            break;
+
+        default:
+            ok = false;
+            break;
     }
 
-    return true;
+    if (!ok && header->type != DM_USER_RESP_ERROR) {
+        RespondIOError();
+    }
+    return ok;
 }
 
 }  // namespace snapshot

From 40e78443e93729c5f5571a4c29b25ad7c7b3cecb Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Wed, 5 Jul 2023 12:48:13 -0700
Subject: [PATCH 0157/1487] Replace usage of base::Callback with std::function

base::Callback comes from libchrome which is undermaintained. Since
C++11 there's standard library support for function objects. Migrate to
a more well knowned solution for function objects.

Test: th
Change-Id: Id19bcd7e92691f57d97520f8f1f4909ca9c25b33
---
 libbinderwrapper/Android.bp                   |  3 ---
 libbinderwrapper/binder_wrapper.cc            |  2 +-
 .../include/binderwrapper/binder_test_base.h  |  3 +--
 .../include/binderwrapper/binder_wrapper.h    |  7 +++---
 .../binderwrapper/stub_binder_wrapper.h       |  7 +++---
 libbinderwrapper/real_binder_wrapper.cc       | 24 +++++++++----------
 libbinderwrapper/real_binder_wrapper.h        |  5 ++--
 libbinderwrapper/stub_binder_wrapper.cc       | 11 ++++-----
 8 files changed, 26 insertions(+), 36 deletions(-)

diff --git a/libbinderwrapper/Android.bp b/libbinderwrapper/Android.bp
index 75f43eeaabf7..87c55faadc32 100644
--- a/libbinderwrapper/Android.bp
+++ b/libbinderwrapper/Android.bp
@@ -26,13 +26,10 @@ cc_defaults {
         "-Werror",
         "-Wno-unused-parameter",
 
-        // for libchrome
-        "-Wno-sign-promo",
     ],
     export_include_dirs: ["include"],
     shared_libs: [
         "libbinder",
-        "libchrome",
         "libutils",
     ],
 }
diff --git a/libbinderwrapper/binder_wrapper.cc b/libbinderwrapper/binder_wrapper.cc
index ca9c1dfd93cc..f5e7476f128e 100644
--- a/libbinderwrapper/binder_wrapper.cc
+++ b/libbinderwrapper/binder_wrapper.cc
@@ -16,7 +16,7 @@
 
 #include <binderwrapper/binder_wrapper.h>
 
-#include <base/logging.h>
+#include <android-base/logging.h>
 
 #include "real_binder_wrapper.h"
 
diff --git a/libbinderwrapper/include/binderwrapper/binder_test_base.h b/libbinderwrapper/include/binderwrapper/binder_test_base.h
index 06543de6fba5..46eca3f15b8e 100644
--- a/libbinderwrapper/include/binderwrapper/binder_test_base.h
+++ b/libbinderwrapper/include/binderwrapper/binder_test_base.h
@@ -17,7 +17,6 @@
 #ifndef SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_TEST_BASE_H_
 #define SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_TEST_BASE_H_
 
-#include <base/macros.h>
 #include <gtest/gtest.h>
 
 namespace android {
@@ -37,7 +36,7 @@ class BinderTestBase : public ::testing::Test {
   StubBinderWrapper* binder_wrapper_;  // Not owned.
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(BinderTestBase);
+   BinderTestBase(const BinderTestBase&) = delete;
 };
 
 }  // namespace android
diff --git a/libbinderwrapper/include/binderwrapper/binder_wrapper.h b/libbinderwrapper/include/binderwrapper/binder_wrapper.h
index a104bff32306..fc5708b62881 100644
--- a/libbinderwrapper/include/binderwrapper/binder_wrapper.h
+++ b/libbinderwrapper/include/binderwrapper/binder_wrapper.h
@@ -19,9 +19,9 @@
 
 #include <sys/types.h>
 
+#include <functional>
 #include <string>
 
-#include <base/callback.h>
 #include <utils/StrongPointer.h>
 
 namespace android {
@@ -68,9 +68,8 @@ class BinderWrapper {
 
   // Registers |callback| to be invoked when |binder| dies. If another callback
   // is currently registered for |binder|, it will be replaced.
-  virtual bool RegisterForDeathNotifications(
-      const sp<IBinder>& binder,
-      const ::base::Closure& callback) = 0;
+  virtual bool RegisterForDeathNotifications(const sp<IBinder>& binder,
+                                             const std::function<void()>&) = 0;
 
   // Unregisters the callback, if any, for |binder|.
   virtual bool UnregisterForDeathNotifications(const sp<IBinder>& binder) = 0;
diff --git a/libbinderwrapper/include/binderwrapper/stub_binder_wrapper.h b/libbinderwrapper/include/binderwrapper/stub_binder_wrapper.h
index 9d4578eb39d4..2a7f77e7a3a9 100644
--- a/libbinderwrapper/include/binderwrapper/stub_binder_wrapper.h
+++ b/libbinderwrapper/include/binderwrapper/stub_binder_wrapper.h
@@ -21,7 +21,6 @@
 #include <string>
 #include <vector>
 
-#include <base/macros.h>
 #include <binder/Binder.h>
 #include <binder/IBinder.h>
 #include <binderwrapper/binder_wrapper.h>
@@ -98,7 +97,7 @@ class StubBinderWrapper : public BinderWrapper {
                        const sp<IBinder>& binder) override;
   sp<BBinder> CreateLocalBinder() override;
   bool RegisterForDeathNotifications(const sp<IBinder>& binder,
-                                     const ::base::Closure& callback) override;
+                                     const std::function<void()>& callback) override;
   bool UnregisterForDeathNotifications(const sp<IBinder>& binder) override;
   uid_t GetCallingUid() override;
   pid_t GetCallingPid() override;
@@ -119,13 +118,13 @@ class StubBinderWrapper : public BinderWrapper {
 
   // Map from binder handle to the callback that should be invoked on binder
   // death.
-  std::map<sp<IBinder>, ::base::Closure> death_callbacks_;
+  std::map<sp<IBinder>, std::function<void()>> death_callbacks_;
 
   // Values to return from GetCallingUid() and GetCallingPid();
   uid_t calling_uid_;
   pid_t calling_pid_;
 
-  DISALLOW_COPY_AND_ASSIGN(StubBinderWrapper);
+  StubBinderWrapper(const StubBinderWrapper&) = delete;
 };
 
 }  // namespace android
diff --git a/libbinderwrapper/real_binder_wrapper.cc b/libbinderwrapper/real_binder_wrapper.cc
index f93f1837dca8..d214ce31c10f 100644
--- a/libbinderwrapper/real_binder_wrapper.cc
+++ b/libbinderwrapper/real_binder_wrapper.cc
@@ -16,7 +16,8 @@
 
 #include "real_binder_wrapper.h"
 
-#include <base/logging.h>
+#include <android-base/logging.h>
+
 #include <binder/Binder.h>
 #include <binder/IBinder.h>
 #include <binder/IPCThreadState.h>
@@ -29,20 +30,18 @@ namespace android {
 // be awkward.
 class RealBinderWrapper::DeathRecipient : public IBinder::DeathRecipient {
  public:
-  explicit DeathRecipient(const ::base::Closure& callback)
-      : callback_(callback) {}
-  ~DeathRecipient() = default;
+   explicit DeathRecipient(const std::function<void()>& callback)
+       : callback_(std::move(callback)) {}
+   ~DeathRecipient() = default;
 
-  // IBinder::DeathRecipient:
-  void binderDied(const wp<IBinder>& who) override {
-    callback_.Run();
-  }
+   // IBinder::DeathRecipient:
+   void binderDied(const wp<IBinder>& who) override { callback_(); }
 
  private:
   // Callback to run in response to binder death.
-  ::base::Closure callback_;
+   std::function<void()> callback_;
 
-  DISALLOW_COPY_AND_ASSIGN(DeathRecipient);
+   DISALLOW_COPY_AND_ASSIGN(DeathRecipient);
 };
 
 RealBinderWrapper::RealBinderWrapper() = default;
@@ -83,9 +82,8 @@ sp<BBinder> RealBinderWrapper::CreateLocalBinder() {
   return sp<BBinder>(new BBinder());
 }
 
-bool RealBinderWrapper::RegisterForDeathNotifications(
-    const sp<IBinder>& binder,
-    const ::base::Closure& callback) {
+bool RealBinderWrapper::RegisterForDeathNotifications(const sp<IBinder>& binder,
+                                                      const std::function<void()>& callback) {
   sp<DeathRecipient> recipient(new DeathRecipient(callback));
   if (binder->linkToDeath(recipient) != OK) {
     LOG(ERROR) << "Failed to register for death notifications on "
diff --git a/libbinderwrapper/real_binder_wrapper.h b/libbinderwrapper/real_binder_wrapper.h
index fa05383fbfcf..d0468f079018 100644
--- a/libbinderwrapper/real_binder_wrapper.h
+++ b/libbinderwrapper/real_binder_wrapper.h
@@ -19,7 +19,6 @@
 
 #include <map>
 
-#include <base/macros.h>
 #include <binderwrapper/binder_wrapper.h>
 
 namespace android {
@@ -38,7 +37,7 @@ class RealBinderWrapper : public BinderWrapper {
                        const sp<IBinder>& binder) override;
   sp<BBinder> CreateLocalBinder() override;
   bool RegisterForDeathNotifications(const sp<IBinder>& binder,
-                                     const ::base::Closure& callback) override;
+                                     const std::function<void()>& callback) override;
   bool UnregisterForDeathNotifications(const sp<IBinder>& binder) override;
   uid_t GetCallingUid() override;
   pid_t GetCallingPid() override;
@@ -50,7 +49,7 @@ class RealBinderWrapper : public BinderWrapper {
   // death.
   std::map<sp<IBinder>, sp<DeathRecipient>> death_recipients_;
 
-  DISALLOW_COPY_AND_ASSIGN(RealBinderWrapper);
+  RealBinderWrapper(const RealBinderWrapper&) = delete;
 };
 
 }  // namespace android
diff --git a/libbinderwrapper/stub_binder_wrapper.cc b/libbinderwrapper/stub_binder_wrapper.cc
index 8e75f6239e97..fabf1228a05c 100644
--- a/libbinderwrapper/stub_binder_wrapper.cc
+++ b/libbinderwrapper/stub_binder_wrapper.cc
@@ -16,7 +16,8 @@
 
 #include <binderwrapper/stub_binder_wrapper.h>
 
-#include <base/logging.h>
+#include <android-base/logging.h>
+
 #include <binder/Binder.h>
 #include <binder/IBinder.h>
 
@@ -41,8 +42,7 @@ sp<IBinder> StubBinderWrapper::GetRegisteredService(
 
 void StubBinderWrapper::NotifyAboutBinderDeath(const sp<IBinder>& binder) {
   const auto it = death_callbacks_.find(binder);
-  if (it != death_callbacks_.end())
-    it->second.Run();
+  if (it != death_callbacks_.end()) it->second();
 }
 
 sp<IBinder> StubBinderWrapper::GetService(const std::string& service_name) {
@@ -62,9 +62,8 @@ sp<BBinder> StubBinderWrapper::CreateLocalBinder() {
   return binder;
 }
 
-bool StubBinderWrapper::RegisterForDeathNotifications(
-    const sp<IBinder>& binder,
-    const ::base::Closure& callback) {
+bool StubBinderWrapper::RegisterForDeathNotifications(const sp<IBinder>& binder,
+                                                      const std::function<void()>& callback) {
   death_callbacks_[binder] = callback;
   return true;
 }

From c97eeed5e4fc0266bc4f028ba7e6643e5a98eabe Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 21 Jun 2023 14:49:52 -0700
Subject: [PATCH 0158/1487] Adding parsing for fastboot-info

Adding back the parsing for fastboot info

Test: m fastboot, fastboot flashall
Change-Id: I0075266bad5d45dcb99dbf91aa431008ca336216
---
 fastboot/fastboot.cpp | 30 +++++++++++++++++++++++++++---
 fastboot/fastboot.h   |  5 +++++
 2 files changed, 32 insertions(+), 3 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 29980afd06f2..6fc6f5ff742d 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -173,7 +173,7 @@ static std::vector<Image> images = {
         // clang-format on
 };
 
-static char* get_android_product_out() {
+char* get_android_product_out() {
     char* dir = getenv("ANDROID_PRODUCT_OUT");
     if (dir == nullptr || dir[0] == '\0') {
         return nullptr;
@@ -1787,13 +1787,25 @@ void FlashAllTool::Flash() {
 
     CancelSnapshotIfNeeded();
 
-    tasks_ = CollectTasksFromImageList();
+    tasks_ = CollectTasks();
     for (auto& task : tasks_) {
         task->Run();
     }
     return;
 }
 
+std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasks() {
+    std::vector<std::unique_ptr<Task>> tasks;
+    if (fp_->should_use_fastboot_info) {
+        tasks = CollectTasksFromFastbootInfo();
+
+    } else {
+        tasks = CollectTasksFromImageList();
+    }
+
+    return tasks;
+}
+
 void FlashAllTool::CheckRequirements() {
     std::vector<char> contents;
     if (!fp_->source->ReadFile("android-info.txt", &contents)) {
@@ -1848,7 +1860,6 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasksFromImageList() {
     // or in bootloader fastboot.
     std::vector<std::unique_ptr<Task>> tasks;
     AddFlashTasks(boot_images_, tasks);
-
     if (auto flash_super_task = OptimizedFlashSuperTask::Initialize(fp_, os_images_)) {
         tasks.emplace_back(std::move(flash_super_task));
     } else {
@@ -1871,10 +1882,23 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasksFromImageList() {
             tasks.emplace_back(std::make_unique<ResizeTask>(fp_, image->part_name, "0", slot));
         }
     }
+
     AddFlashTasks(os_images_, tasks);
     return tasks;
 }
 
+std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasksFromFastbootInfo() {
+    std::vector<std::unique_ptr<Task>> tasks;
+    std::vector<char> contents;
+    if (!fp_->source->ReadFile("fastboot-info.txt", &contents)) {
+        LOG(VERBOSE) << "Flashing from hardcoded images. fastboot-info.txt is empty or does not "
+                        "exist";
+        return CollectTasksFromImageList();
+    }
+    tasks = ParseFastbootInfo(fp_, Split({contents.data(), contents.size()}, "\n"));
+    return tasks;
+}
+
 void FlashAllTool::AddFlashTasks(const std::vector<std::pair<const Image*, std::string>>& images,
                                  std::vector<std::unique_ptr<Task>>& tasks) {
     for (const auto& [image, slot] : images) {
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index 196bd67261ca..77430f05ad48 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -97,6 +97,7 @@ struct FlashingPlan {
     bool skip_secondary = false;
     bool force_flash = false;
     bool should_optimize_flash_super = true;
+    bool should_use_fastboot_info = false;
     uint64_t sparse_limit = 0;
 
     std::string slot_override;
@@ -111,6 +112,7 @@ class FlashAllTool {
     FlashAllTool(FlashingPlan* fp);
 
     void Flash();
+    std::vector<std::unique_ptr<Task>> CollectTasks();
 
   private:
     void CheckRequirements();
@@ -118,6 +120,8 @@ class FlashAllTool {
     void CollectImages();
     void AddFlashTasks(const std::vector<std::pair<const Image*, std::string>>& images,
                        std::vector<std::unique_ptr<Task>>& tasks);
+
+    std::vector<std::unique_ptr<Task>> CollectTasksFromFastbootInfo();
     std::vector<std::unique_ptr<Task>> CollectTasksFromImageList();
 
     std::vector<ImageEntry> boot_images_;
@@ -143,6 +147,7 @@ class LocalImageSource final : public ImageSource {
     unique_fd OpenFile(const std::string& name) const override;
 };
 
+char* get_android_product_out();
 bool should_flash_in_userspace(const std::string& partition_name);
 bool is_userspace_fastboot();
 void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,

From 57e3c32bcc18d169d8f44615cc3cc641add7409f Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Wed, 5 Jul 2023 16:07:05 -0700
Subject: [PATCH 0159/1487] Move libbinderwrapper to update_engine

libbinderwrapper is only used by update_engine, it's better to move it
inside update_engine repo

Change-Id: Ia489f38a311b221744f7cf89c9da9c4f3682bb4c
---
 libbinderwrapper/Android.bp                   |  63 ---------
 libbinderwrapper/binder_test_base.cc          |  33 -----
 libbinderwrapper/binder_wrapper.cc            |  60 --------
 .../include/binderwrapper/binder_test_base.h  |  44 ------
 .../include/binderwrapper/binder_wrapper.h    |  87 ------------
 .../binderwrapper/stub_binder_wrapper.h       | 132 ------------------
 libbinderwrapper/real_binder_wrapper.cc       | 121 ----------------
 libbinderwrapper/real_binder_wrapper.h        |  57 --------
 libbinderwrapper/stub_binder_wrapper.cc       |  85 -----------
 9 files changed, 682 deletions(-)
 delete mode 100644 libbinderwrapper/Android.bp
 delete mode 100644 libbinderwrapper/binder_test_base.cc
 delete mode 100644 libbinderwrapper/binder_wrapper.cc
 delete mode 100644 libbinderwrapper/include/binderwrapper/binder_test_base.h
 delete mode 100644 libbinderwrapper/include/binderwrapper/binder_wrapper.h
 delete mode 100644 libbinderwrapper/include/binderwrapper/stub_binder_wrapper.h
 delete mode 100644 libbinderwrapper/real_binder_wrapper.cc
 delete mode 100644 libbinderwrapper/real_binder_wrapper.h
 delete mode 100644 libbinderwrapper/stub_binder_wrapper.cc

diff --git a/libbinderwrapper/Android.bp b/libbinderwrapper/Android.bp
deleted file mode 100644
index 87c55faadc32..000000000000
--- a/libbinderwrapper/Android.bp
+++ /dev/null
@@ -1,63 +0,0 @@
-//
-// Copyright (C) 2015 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.
-//
-
-package {
-    default_applicable_licenses: ["Android-Apache-2.0"],
-}
-
-cc_defaults {
-    name: "libbinderwrapper_defaults",
-
-    cflags: [
-        "-Wall",
-        "-Werror",
-        "-Wno-unused-parameter",
-
-    ],
-    export_include_dirs: ["include"],
-    shared_libs: [
-        "libbinder",
-        "libutils",
-    ],
-}
-
-// libbinderwrapper shared library
-// ========================================================
-cc_library_shared {
-    name: "libbinderwrapper",
-    defaults: ["libbinderwrapper_defaults"],
-    vendor_available: true,
-
-    srcs: [
-        "binder_wrapper.cc",
-        "real_binder_wrapper.cc",
-    ],
-}
-
-// libbinderwrapper_test_support static library
-// ========================================================
-cc_library_static {
-    name: "libbinderwrapper_test_support",
-    defaults: ["libbinderwrapper_defaults"],
-
-    static_libs: ["libgtest"],
-    shared_libs: ["libbinderwrapper"],
-
-    srcs: [
-        "binder_test_base.cc",
-        "stub_binder_wrapper.cc",
-    ],
-}
diff --git a/libbinderwrapper/binder_test_base.cc b/libbinderwrapper/binder_test_base.cc
deleted file mode 100644
index af93a04d9520..000000000000
--- a/libbinderwrapper/binder_test_base.cc
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (C) 2015 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 <binderwrapper/binder_test_base.h>
-
-#include <binderwrapper/binder_wrapper.h>
-#include <binderwrapper/stub_binder_wrapper.h>
-
-namespace android {
-
-BinderTestBase::BinderTestBase() : binder_wrapper_(new StubBinderWrapper()) {
-  // Pass ownership.
-  BinderWrapper::InitForTesting(binder_wrapper_);
-}
-
-BinderTestBase::~BinderTestBase() {
-  BinderWrapper::Destroy();
-}
-
-}  // namespace android
diff --git a/libbinderwrapper/binder_wrapper.cc b/libbinderwrapper/binder_wrapper.cc
deleted file mode 100644
index f5e7476f128e..000000000000
--- a/libbinderwrapper/binder_wrapper.cc
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (C) 2015 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 <binderwrapper/binder_wrapper.h>
-
-#include <android-base/logging.h>
-
-#include "real_binder_wrapper.h"
-
-namespace android {
-
-// Singleton instance.
-BinderWrapper* BinderWrapper::instance_ = nullptr;
-
-// static
-void BinderWrapper::Create() {
-  CHECK(!instance_) << "Already initialized; missing call to Destroy()?";
-  instance_ = new RealBinderWrapper();
-}
-
-// static
-void BinderWrapper::InitForTesting(BinderWrapper* wrapper) {
-  CHECK(!instance_) << "Already initialized; missing call to Destroy()?";
-  instance_ = wrapper;
-}
-
-// static
-void BinderWrapper::Destroy() {
-  CHECK(instance_) << "Not initialized; missing call to Create()?";
-  delete instance_;
-  instance_ = nullptr;
-}
-
-// static
-BinderWrapper* BinderWrapper::Get() {
-  CHECK(instance_) << "Not initialized; missing call to Create()?";
-  return instance_;
-}
-
-// static
-BinderWrapper* BinderWrapper::GetOrCreateInstance() {
-  if (!instance_)
-    instance_ = new RealBinderWrapper();
-  return instance_;
-}
-
-}  // namespace android
diff --git a/libbinderwrapper/include/binderwrapper/binder_test_base.h b/libbinderwrapper/include/binderwrapper/binder_test_base.h
deleted file mode 100644
index 46eca3f15b8e..000000000000
--- a/libbinderwrapper/include/binderwrapper/binder_test_base.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (C) 2015 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.
- */
-
-#ifndef SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_TEST_BASE_H_
-#define SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_TEST_BASE_H_
-
-#include <gtest/gtest.h>
-
-namespace android {
-
-class StubBinderWrapper;
-
-// Class that can be inherited from (or aliased via typedef/using) when writing
-// tests that use StubBinderManager.
-class BinderTestBase : public ::testing::Test {
- public:
-  BinderTestBase();
-  ~BinderTestBase() override;
-
-  StubBinderWrapper* binder_wrapper() { return binder_wrapper_; }
-
- protected:
-  StubBinderWrapper* binder_wrapper_;  // Not owned.
-
- private:
-   BinderTestBase(const BinderTestBase&) = delete;
-};
-
-}  // namespace android
-
-#endif  // SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_TEST_BASE_H_
diff --git a/libbinderwrapper/include/binderwrapper/binder_wrapper.h b/libbinderwrapper/include/binderwrapper/binder_wrapper.h
deleted file mode 100644
index fc5708b62881..000000000000
--- a/libbinderwrapper/include/binderwrapper/binder_wrapper.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (C) 2015 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.
- */
-
-#ifndef SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_WRAPPER_H_
-#define SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_WRAPPER_H_
-
-#include <sys/types.h>
-
-#include <functional>
-#include <string>
-
-#include <utils/StrongPointer.h>
-
-namespace android {
-
-class BBinder;
-class IBinder;
-
-// Wraps libbinder to make it testable.
-// NOTE: Static methods of this class are not thread-safe.
-class BinderWrapper {
- public:
-  virtual ~BinderWrapper() {}
-
-  // Creates and initializes the singleton (using a wrapper that communicates
-  // with the real binder system).
-  static void Create();
-
-  // Initializes |wrapper| as the singleton, taking ownership of it. Tests that
-  // want to inject their own wrappers should call this instead of Create().
-  static void InitForTesting(BinderWrapper* wrapper);
-
-  // Destroys the singleton. Must be called before calling Create() or
-  // InitForTesting() a second time.
-  static void Destroy();
-
-  // Returns the singleton instance previously created by Create() or set by
-  // InitForTesting().
-  static BinderWrapper* Get();
-
-  // Returns the singleton instance if it was previously created by Create() or
-  // set by InitForTesting(), or creates a new one by calling Create().
-  static BinderWrapper* GetOrCreateInstance();
-
-  // Gets the binder for communicating with the service identified by
-  // |service_name|, returning null immediately if it doesn't exist.
-  virtual sp<IBinder> GetService(const std::string& service_name) = 0;
-
-  // Registers |binder| as |service_name| with the service manager.
-  virtual bool RegisterService(const std::string& service_name,
-                               const sp<IBinder>& binder) = 0;
-
-  // Creates a local binder object.
-  virtual sp<BBinder> CreateLocalBinder() = 0;
-
-  // Registers |callback| to be invoked when |binder| dies. If another callback
-  // is currently registered for |binder|, it will be replaced.
-  virtual bool RegisterForDeathNotifications(const sp<IBinder>& binder,
-                                             const std::function<void()>&) = 0;
-
-  // Unregisters the callback, if any, for |binder|.
-  virtual bool UnregisterForDeathNotifications(const sp<IBinder>& binder) = 0;
-
-  // When called while in a transaction, returns the caller's UID or PID.
-  virtual uid_t GetCallingUid() = 0;
-  virtual pid_t GetCallingPid() = 0;
-
- private:
-  static BinderWrapper* instance_;
-};
-
-}  // namespace android
-
-#endif  // SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_WRAPPER_H_
diff --git a/libbinderwrapper/include/binderwrapper/stub_binder_wrapper.h b/libbinderwrapper/include/binderwrapper/stub_binder_wrapper.h
deleted file mode 100644
index 2a7f77e7a3a9..000000000000
--- a/libbinderwrapper/include/binderwrapper/stub_binder_wrapper.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * Copyright (C) 2015 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.
- */
-
-#ifndef SYSTEM_CORE_INCLUDE_BINDERWRAPPER_STUB_BINDER_WRAPPER_H_
-#define SYSTEM_CORE_INCLUDE_BINDERWRAPPER_STUB_BINDER_WRAPPER_H_
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include <binder/Binder.h>
-#include <binder/IBinder.h>
-#include <binderwrapper/binder_wrapper.h>
-
-namespace android {
-
-// Stub implementation of BinderWrapper for testing.
-//
-// Example usage:
-//
-// First, assuming a base IFoo binder interface, create a stub class that
-// derives from BnFoo to implement the receiver side of the communication:
-//
-//   class StubFoo : public BnFoo {
-//    public:
-//     ...
-//     status_t doSomething(int arg) override {
-//       // e.g. save passed-in value for later inspection by tests.
-//       return OK;
-//     }
-//   };
-//
-// Next, from your test code, inject a StubBinderManager either directly or by
-// inheriting from the BinderTestBase class:
-//
-//   StubBinderWrapper* wrapper = new StubBinderWrapper();
-//   BinderWrapper::InitForTesting(wrapper);  // Takes ownership.
-//
-// Also from your test, create a StubFoo and register it with the wrapper:
-//
-//   StubFoo* foo = new StubFoo();
-//   sp<IBinder> binder(foo);
-//   wrapper->SetBinderForService("foo", binder);
-//
-// The code being tested can now use the wrapper to get the stub and call it:
-//
-//   sp<IBinder> binder = BinderWrapper::Get()->GetService("foo");
-//   CHECK(binder.get());
-//   sp<IFoo> foo = interface_cast<IFoo>(binder);
-//   CHECK_EQ(foo->doSomething(3), OK);
-//
-// To create a local BBinder object, production code can call
-// CreateLocalBinder(). Then, a test can get the BBinder's address via
-// local_binders() to check that they're passed as expected in binder calls.
-//
-class StubBinderWrapper : public BinderWrapper {
- public:
-  StubBinderWrapper();
-  ~StubBinderWrapper() override;
-
-  const std::vector<sp<BBinder>>& local_binders() const {
-    return local_binders_;
-  }
-  void clear_local_binders() { local_binders_.clear(); }
-
-  void set_calling_uid(uid_t uid) { calling_uid_ = uid; }
-  void set_calling_pid(pid_t pid) { calling_pid_ = pid; }
-
-  // Sets the binder to return when |service_name| is passed to GetService() or
-  // WaitForService().
-  void SetBinderForService(const std::string& service_name,
-                           const sp<IBinder>& binder);
-
-  // Returns the binder previously registered for |service_name| via
-  // RegisterService(), or null if the service hasn't been registered.
-  sp<IBinder> GetRegisteredService(const std::string& service_name) const;
-
-  // Run the calback in |death_callbacks_| corresponding to |binder|.
-  void NotifyAboutBinderDeath(const sp<IBinder>& binder);
-
-  // BinderWrapper:
-  sp<IBinder> GetService(const std::string& service_name) override;
-  bool RegisterService(const std::string& service_name,
-                       const sp<IBinder>& binder) override;
-  sp<BBinder> CreateLocalBinder() override;
-  bool RegisterForDeathNotifications(const sp<IBinder>& binder,
-                                     const std::function<void()>& callback) override;
-  bool UnregisterForDeathNotifications(const sp<IBinder>& binder) override;
-  uid_t GetCallingUid() override;
-  pid_t GetCallingPid() override;
-
- private:
-  using ServiceMap = std::map<std::string, sp<IBinder>>;
-
-  // Map from service name to associated binder handle. Used by GetService() and
-  // WaitForService().
-  ServiceMap services_to_return_;
-
-  // Map from service name to associated binder handle. Updated by
-  // RegisterService().
-  ServiceMap registered_services_;
-
-  // Local binders returned by CreateLocalBinder().
-  std::vector<sp<BBinder>> local_binders_;
-
-  // Map from binder handle to the callback that should be invoked on binder
-  // death.
-  std::map<sp<IBinder>, std::function<void()>> death_callbacks_;
-
-  // Values to return from GetCallingUid() and GetCallingPid();
-  uid_t calling_uid_;
-  pid_t calling_pid_;
-
-  StubBinderWrapper(const StubBinderWrapper&) = delete;
-};
-
-}  // namespace android
-
-#endif  // SYSTEM_CORE_INCLUDE_BINDERWRAPPER_STUB_BINDER_WRAPPER_H_
diff --git a/libbinderwrapper/real_binder_wrapper.cc b/libbinderwrapper/real_binder_wrapper.cc
deleted file mode 100644
index d214ce31c10f..000000000000
--- a/libbinderwrapper/real_binder_wrapper.cc
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Copyright (C) 2015 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 "real_binder_wrapper.h"
-
-#include <android-base/logging.h>
-
-#include <binder/Binder.h>
-#include <binder/IBinder.h>
-#include <binder/IPCThreadState.h>
-#include <binder/IServiceManager.h>
-
-namespace android {
-
-// Class that handles binder death notifications. libbinder wants the recipient
-// to be wrapped in sp<>, so registering RealBinderWrapper as a recipient would
-// be awkward.
-class RealBinderWrapper::DeathRecipient : public IBinder::DeathRecipient {
- public:
-   explicit DeathRecipient(const std::function<void()>& callback)
-       : callback_(std::move(callback)) {}
-   ~DeathRecipient() = default;
-
-   // IBinder::DeathRecipient:
-   void binderDied(const wp<IBinder>& who) override { callback_(); }
-
- private:
-  // Callback to run in response to binder death.
-   std::function<void()> callback_;
-
-   DISALLOW_COPY_AND_ASSIGN(DeathRecipient);
-};
-
-RealBinderWrapper::RealBinderWrapper() = default;
-
-RealBinderWrapper::~RealBinderWrapper() = default;
-
-sp<IBinder> RealBinderWrapper::GetService(const std::string& service_name) {
-  sp<IServiceManager> service_manager = defaultServiceManager();
-  if (!service_manager.get()) {
-    LOG(ERROR) << "Unable to get service manager";
-    return sp<IBinder>();
-  }
-  sp<IBinder> binder =
-      service_manager->checkService(String16(service_name.c_str()));
-  if (!binder.get())
-    LOG(ERROR) << "Unable to get \"" << service_name << "\" service";
-  return binder;
-}
-
-bool RealBinderWrapper::RegisterService(const std::string& service_name,
-                                        const sp<IBinder>& binder) {
-  sp<IServiceManager> service_manager = defaultServiceManager();
-  if (!service_manager.get()) {
-    LOG(ERROR) << "Unable to get service manager";
-    return false;
-  }
-  status_t status = defaultServiceManager()->addService(
-      String16(service_name.c_str()), binder);
-  if (status != OK) {
-    LOG(ERROR) << "Failed to register \"" << service_name << "\" with service "
-               << "manager";
-    return false;
-  }
-  return true;
-}
-
-sp<BBinder> RealBinderWrapper::CreateLocalBinder() {
-  return sp<BBinder>(new BBinder());
-}
-
-bool RealBinderWrapper::RegisterForDeathNotifications(const sp<IBinder>& binder,
-                                                      const std::function<void()>& callback) {
-  sp<DeathRecipient> recipient(new DeathRecipient(callback));
-  if (binder->linkToDeath(recipient) != OK) {
-    LOG(ERROR) << "Failed to register for death notifications on "
-               << binder.get();
-    return false;
-  }
-  death_recipients_[binder] = recipient;
-  return true;
-}
-
-bool RealBinderWrapper::UnregisterForDeathNotifications(
-    const sp<IBinder>& binder) {
-  auto it = death_recipients_.find(binder);
-  if (it == death_recipients_.end()) {
-    LOG(ERROR) << "Not registered for death notifications on " << binder.get();
-    return false;
-  }
-  if (binder->unlinkToDeath(it->second) != OK) {
-    LOG(ERROR) << "Failed to unregister for death notifications on "
-               << binder.get();
-    return false;
-  }
-  death_recipients_.erase(it);
-  return true;
-}
-
-uid_t RealBinderWrapper::GetCallingUid() {
-  return IPCThreadState::self()->getCallingUid();
-}
-
-pid_t RealBinderWrapper::GetCallingPid() {
-  return IPCThreadState::self()->getCallingPid();
-}
-
-}  // namespace android
diff --git a/libbinderwrapper/real_binder_wrapper.h b/libbinderwrapper/real_binder_wrapper.h
deleted file mode 100644
index d0468f079018..000000000000
--- a/libbinderwrapper/real_binder_wrapper.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2015 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.
- */
-
-#ifndef SYSTEM_CORE_LIBBINDERWRAPPER_REAL_BINDER_WRAPPER_H_
-#define SYSTEM_CORE_LIBBINDERWRAPPER_REAL_BINDER_WRAPPER_H_
-
-#include <map>
-
-#include <binderwrapper/binder_wrapper.h>
-
-namespace android {
-
-class IBinder;
-
-// Real implementation of BinderWrapper.
-class RealBinderWrapper : public BinderWrapper {
- public:
-  RealBinderWrapper();
-  ~RealBinderWrapper() override;
-
-  // BinderWrapper:
-  sp<IBinder> GetService(const std::string& service_name) override;
-  bool RegisterService(const std::string& service_name,
-                       const sp<IBinder>& binder) override;
-  sp<BBinder> CreateLocalBinder() override;
-  bool RegisterForDeathNotifications(const sp<IBinder>& binder,
-                                     const std::function<void()>& callback) override;
-  bool UnregisterForDeathNotifications(const sp<IBinder>& binder) override;
-  uid_t GetCallingUid() override;
-  pid_t GetCallingPid() override;
-
- private:
-  class DeathRecipient;
-
-  // Map from binder handle to object that should be notified of the binder's
-  // death.
-  std::map<sp<IBinder>, sp<DeathRecipient>> death_recipients_;
-
-  RealBinderWrapper(const RealBinderWrapper&) = delete;
-};
-
-}  // namespace android
-
-#endif  // SYSTEM_CORE_LIBBINDER_WRAPPER_REAL_BINDER_WRAPPER_H_
diff --git a/libbinderwrapper/stub_binder_wrapper.cc b/libbinderwrapper/stub_binder_wrapper.cc
deleted file mode 100644
index fabf1228a05c..000000000000
--- a/libbinderwrapper/stub_binder_wrapper.cc
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright (C) 2015 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 <binderwrapper/stub_binder_wrapper.h>
-
-#include <android-base/logging.h>
-
-#include <binder/Binder.h>
-#include <binder/IBinder.h>
-
-namespace android {
-
-StubBinderWrapper::StubBinderWrapper()
-    : calling_uid_(-1),
-      calling_pid_(-1) {}
-
-StubBinderWrapper::~StubBinderWrapper() = default;
-
-void StubBinderWrapper::SetBinderForService(const std::string& service_name,
-                                            const sp<IBinder>& binder) {
-  services_to_return_[service_name] = binder;
-}
-
-sp<IBinder> StubBinderWrapper::GetRegisteredService(
-    const std::string& service_name) const {
-  const auto it = registered_services_.find(service_name);
-  return it != registered_services_.end() ? it->second : sp<IBinder>();
-}
-
-void StubBinderWrapper::NotifyAboutBinderDeath(const sp<IBinder>& binder) {
-  const auto it = death_callbacks_.find(binder);
-  if (it != death_callbacks_.end()) it->second();
-}
-
-sp<IBinder> StubBinderWrapper::GetService(const std::string& service_name) {
-  const auto it = services_to_return_.find(service_name);
-  return it != services_to_return_.end() ? it->second : sp<IBinder>();
-}
-
-bool StubBinderWrapper::RegisterService(const std::string& service_name,
-                                        const sp<IBinder>& binder) {
-  registered_services_[service_name] = binder;
-  return true;
-}
-
-sp<BBinder> StubBinderWrapper::CreateLocalBinder() {
-  sp<BBinder> binder(new BBinder());
-  local_binders_.push_back(binder);
-  return binder;
-}
-
-bool StubBinderWrapper::RegisterForDeathNotifications(const sp<IBinder>& binder,
-                                                      const std::function<void()>& callback) {
-  death_callbacks_[binder] = callback;
-  return true;
-}
-
-bool StubBinderWrapper::UnregisterForDeathNotifications(
-    const sp<IBinder>& binder) {
-  death_callbacks_.erase(binder);
-  return true;
-}
-
-uid_t StubBinderWrapper::GetCallingUid() {
-  return calling_uid_;
-}
-
-pid_t StubBinderWrapper::GetCallingPid() {
-  return calling_pid_;
-}
-
-}  // namespace android

From d7de52d72175c943667455dcc15c2d17869393d3 Mon Sep 17 00:00:00 2001
From: Daeho Jeong <daehojeong@google.com>
Date: Wed, 28 Jun 2023 14:35:30 -0700
Subject: [PATCH 0160/1487] init.rc: set f2fs seq_file_ra_mul to 128

Based on experiments, we fount out 128 (128 x global readahead window
size = 16mb) is the optimal multiple to boost up read speeds for the
sequentially accessed files with POSIX_FADV_SEQUENTIAL.

Bug: 195311558
Test: check the /sys/fs/f2fs/<userdata partition>/seq_file_ra_mul value
Merged-In: I7563ad6e47b9ab76ae7fe36978d0e5970a7490e8
Change-Id: I7563ad6e47b9ab76ae7fe36978d0e5970a7490e8
Signed-off-by: Daeho Jeong <daehojeong@google.com>
---
 rootdir/init.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 1e6918d0022c..7da264611d94 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1142,7 +1142,7 @@ on boot
     write /dev/sys/fs/by-name/userdata/iostat_enable 1
 
     # set readahead multiplier for POSIX_FADV_SEQUENTIAL files
-    write /dev/sys/fs/by-name/userdata/seq_file_ra_mul 16
+    write /dev/sys/fs/by-name/userdata/seq_file_ra_mul 128
 
     # limit discard size to 128MB in order to avoid long IO latency
     # for filesystem tuning first (dm or sda)

From 0b2c5cde1f7d380d4aa5f4f249049e6fccd5ba0e Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers@google.com>
Date: Wed, 5 Jul 2023 18:02:09 +0000
Subject: [PATCH 0161/1487] init: remove unfinished fsverity signature support
 for APEX sepolicy

The APEX sepolicy feature has unfinished support for verifying the
sepolicy file using fsverity with a builtin signature.  However, this
was never finished and doesn't really make sense, since the
already-implemented scheme that uses a full-file hash combined with a
userspace signature check is better suited to the problem.  Therefore,
remove this unfinished code.

Bug: 290064770
Test: presubmit and booting Cuttlefish
Change-Id: I3403a3303bcea32c7340642b843cd1541fe1fd2f
---
 init/Android.bp  |  2 --
 init/selinux.cpp | 46 ++--------------------------------------------
 2 files changed, 2 insertions(+), 46 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index 1af398a9a0ae..4416b9dc2637 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -166,11 +166,9 @@ libinit_cc_defaults {
         "libbootloader_message",
         "libc++fs",
         "libcgrouprc_format",
-        "libfsverity_init",
         "liblmkd_utils",
         "liblz4",
         "libzstd",
-        "libmini_keyctl_static",
         "libmodprobe",
         "libprocinfo",
         "libprotobuf-cpp-lite",
diff --git a/init/selinux.cpp b/init/selinux.cpp
index e0ef4913c938..b6d483a47d6d 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -74,10 +74,8 @@
 #include <android-base/unique_fd.h>
 #include <fs_avb/fs_avb.h>
 #include <fs_mgr.h>
-#include <fsverity_init.h>
 #include <libgsi/libgsi.h>
 #include <libsnapshot/snapshot.h>
-#include <mini_keyctl_utils.h>
 #include <selinux/android.h>
 #include <ziparchive/zip_archive.h>
 
@@ -510,7 +508,6 @@ bool OpenMonolithicPolicy(PolicyFile* policy_file) {
 
 constexpr const char* kSigningCertRelease =
         "/system/etc/selinux/com.android.sepolicy.cert-release.der";
-constexpr const char* kFsVerityProcPath = "/proc/sys/fs/verity";
 const std::string kSepolicyApexMetadataDir = "/metadata/sepolicy/";
 const std::string kSepolicyApexSystemDir = "/system/etc/selinux/apex/";
 const std::string kSepolicyZip = "SEPolicy.zip";
@@ -614,24 +611,6 @@ Result<void> GetPolicyFromApex(const std::string& dir) {
     return {};
 }
 
-Result<void> LoadSepolicyApexCerts() {
-    key_serial_t keyring_id = android::GetKeyringId(".fs-verity");
-    if (keyring_id < 0) {
-        return Error() << "Failed to find .fs-verity keyring id";
-    }
-
-    // TODO(b/199914227) the release key should always exist. Once it's checked in, start
-    // throwing an error here if it doesn't exist.
-    if (access(kSigningCertRelease, F_OK) == 0) {
-        LoadKeyFromFile(keyring_id, "fsv_sepolicy_apex_release", kSigningCertRelease);
-    }
-    return {};
-}
-
-Result<void> SepolicyFsVerityCheck() {
-    return Error() << "TODO implement support for fsverity SEPolicy.";
-}
-
 Result<void> SepolicyCheckSignature(const std::string& dir) {
     std::string signature;
     if (!android::base::ReadFileToString(dir + kSepolicySignature, &signature)) {
@@ -654,18 +633,7 @@ Result<void> SepolicyCheckSignature(const std::string& dir) {
     return verifySignature(sepolicyStr, signature, *releaseKey);
 }
 
-Result<void> SepolicyVerify(const std::string& dir, bool supportsFsVerity) {
-    if (supportsFsVerity) {
-        auto fsVerityCheck = SepolicyFsVerityCheck();
-        if (fsVerityCheck.ok()) {
-            return fsVerityCheck;
-        }
-        // TODO(b/199914227) If the device supports fsverity, but we fail here, we should fail to
-        // boot and not carry on. For now, fallback to a signature checkuntil the fsverity
-        // logic is implemented.
-        LOG(INFO) << "Falling back to standard signature check. " << fsVerityCheck.error();
-    }
-
+Result<void> SepolicyVerify(const std::string& dir) {
     auto sepolicySignature = SepolicyCheckSignature(dir);
     if (!sepolicySignature.ok()) {
         return Error() << "Apex SEPolicy failed signature check";
@@ -698,23 +666,13 @@ void CleanupApexSepolicy() {
 // 6. Sets selinux into enforcing mode and continues normal booting.
 //
 void PrepareApexSepolicy() {
-    bool supportsFsVerity = access(kFsVerityProcPath, F_OK) == 0;
-    if (supportsFsVerity) {
-        auto loadSepolicyApexCerts = LoadSepolicyApexCerts();
-        if (!loadSepolicyApexCerts.ok()) {
-            // TODO(b/199914227) If the device supports fsverity, but we fail here, we should fail
-            // to boot and not carry on. For now, fallback to a signature checkuntil the fsverity
-            // logic is implemented.
-            LOG(INFO) << loadSepolicyApexCerts.error();
-        }
-    }
     // If apex sepolicy zip exists in /metadata/sepolicy, use that, otherwise use version on
     // /system.
     auto dir = (access((kSepolicyApexMetadataDir + kSepolicyZip).c_str(), F_OK) == 0)
                        ? kSepolicyApexMetadataDir
                        : kSepolicyApexSystemDir;
 
-    auto sepolicyVerify = SepolicyVerify(dir, supportsFsVerity);
+    auto sepolicyVerify = SepolicyVerify(dir);
     if (!sepolicyVerify.ok()) {
         LOG(INFO) << "Error: " << sepolicyVerify.error();
         // If signature verification fails, fall back to version on /system.

From 79a67391bde590704c199a8567661ad130c4d90e Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers@google.com>
Date: Thu, 6 Jul 2023 17:27:46 +0000
Subject: [PATCH 0162/1487] init.rc: stop using fsverity_init --lock

Remove the code that "locked" the .fs-verity keyring at a certain point
in the boot.  It probably was thought that this achieved some useful
security property, which is a bit questionable.  Regardless, Android no
longer uses fsverity builtin signatures.  The only code that is still
being kept around is enough to access existing files on old kernels, and
for this "locking" the keyring is definitely not essential.

Bug: 290064770
Test: presubmit and booting Cuttlefish
Change-Id: Ide5729aeac5772658b2a3f0abe835988b8842b02
---
 rootdir/init.rc | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index a8b78d5d8025..3d45df249db9 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1021,13 +1021,9 @@ on post-fs-data
     # Must start after 'derive_classpath' to have *CLASSPATH variables set.
     start odsign
 
-    # Before we can lock keys and proceed to the next boot stage, wait for
-    # odsign to be done with the key
+    # Wait for odsign to be done with the key.
     wait_for_prop odsign.key.done 1
 
-    # Lock the fs-verity keyring, so no more keys can be added
-    exec -- /system/bin/fsverity_init --lock
-
     # Bump the boot level to 1000000000; this prevents further on-device signing.
     # This is a special value that shuts down the thread which listens for
     # further updates.

From f17079ff5890cfea529cb996891b2fe45a8ae63a Mon Sep 17 00:00:00 2001
From: Nikita Ioffe <ioffe@google.com>
Date: Tue, 4 Jul 2023 01:29:26 +0100
Subject: [PATCH 0163/1487] Small refactoring in first_stage_mount

The existing approach in first_stage_init/first_stage_mount makes it
harder to add conditional logic that should only be applied for
Microdroid. Additionally, it forces the FirstStageMount object to be
created twice.

This change refactors the control flow to make first_stage_init take the
ownership of the FirstStageMount object. It will help with the follow up
change (which will add logic to conditionally mount /vendor partition
while booting Microdroid). As a nice side effect, this refactoring also
fixes the problem of the FirstStageMount being created twice.

This change also merges the FirstStageMount and FirstStageMountVBootV2
in a single class, since nobody actually uses FirstStageMount.

Bug: 285855433
Test: device boots
Test: atest MicrodroidTestApp
Change-Id: I38a72c0f20e7c1ac70031498aeeca22b091fa827
---
 init/first_stage_init.cpp  |  40 +++++++++++--
 init/first_stage_mount.cpp | 116 +++++++++++--------------------------
 init/first_stage_mount.h   |  21 ++++++-
 3 files changed, 88 insertions(+), 89 deletions(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index bff80c5c731f..e1d383a0c16c 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -257,6 +257,16 @@ static BootMode GetBootMode(const std::string& cmdline, const std::string& bootc
     return BootMode::NORMAL_MODE;
 }
 
+static std::unique_ptr<FirstStageMount> CreateFirstStageMount() {
+    auto ret = FirstStageMount::Create();
+    if (ret.ok()) {
+        return std::move(*ret);
+    } else {
+        LOG(ERROR) << "Failed to create FirstStageMount : " << ret.error();
+        return nullptr;
+    }
+}
+
 int FirstStageMain(int argc, char** argv) {
     if (REBOOT_BOOTLOADER_ON_PANIC) {
         InstallRebootSignalHandlers();
@@ -381,12 +391,17 @@ int FirstStageMain(int argc, char** argv) {
                   << module_elapse_time.count() << " ms";
     }
 
+    std::unique_ptr<FirstStageMount> fsm;
+
     bool created_devices = false;
     if (want_console == FirstStageConsoleParam::CONSOLE_ON_FAILURE) {
         if (!IsRecoveryMode()) {
-            created_devices = DoCreateDevices();
-            if (!created_devices) {
-                LOG(ERROR) << "Failed to create device nodes early";
+            fsm = CreateFirstStageMount();
+            if (fsm) {
+                created_devices = fsm->DoCreateDevices();
+                if (!created_devices) {
+                    LOG(ERROR) << "Failed to create device nodes early";
+                }
             }
         }
         StartConsole(cmdline);
@@ -437,8 +452,23 @@ int FirstStageMain(int argc, char** argv) {
         SwitchRoot("/first_stage_ramdisk");
     }
 
-    if (!DoFirstStageMount(!created_devices)) {
-        LOG(FATAL) << "Failed to mount required partitions early ...";
+    if (IsRecoveryMode()) {
+        LOG(INFO) << "First stage mount skipped (recovery mode)";
+    } else {
+        if (!fsm) {
+            fsm = CreateFirstStageMount();
+        }
+        if (!fsm) {
+            LOG(FATAL) << "FirstStageMount not available";
+        }
+
+        if (!created_devices && !fsm->DoCreateDevices()) {
+            LOG(FATAL) << "Failed to create devices required for first stage mount";
+        }
+
+        if (!fsm->DoFirstStageMount()) {
+            LOG(FATAL) << "Failed to mount required partitions early ...";
+        }
     }
 
     struct stat new_root_info;
diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index 07ce4588d039..4961f6a63ed6 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -76,21 +76,21 @@ namespace init {
 
 // Class Declarations
 // ------------------
-class FirstStageMount {
+class FirstStageMountVBootV2 : public FirstStageMount {
   public:
-    FirstStageMount(Fstab fstab);
-    virtual ~FirstStageMount() = default;
+    friend void SetInitAvbVersionInRecovery();
 
-    // The factory method to create a FirstStageMountVBootV2 instance.
-    static Result<std::unique_ptr<FirstStageMount>> Create();
-    bool DoCreateDevices();    // Creates devices and logical partitions from storage devices
-    bool DoFirstStageMount();  // Mounts fstab entries read from device tree.
-    bool InitDevices();
+    FirstStageMountVBootV2(Fstab fstab);
+    virtual ~FirstStageMountVBootV2() = default;
+
+    bool DoCreateDevices() override;
+    bool DoFirstStageMount() override;
 
-  protected:
+  private:
+    bool InitDevices();
     bool InitRequiredDevices(std::set<std::string> devices);
     bool CreateLogicalPartitions();
-    bool CreateSnapshotPartitions(android::snapshot::SnapshotManager* sm);
+    bool CreateSnapshotPartitions(SnapshotManager* sm);
     bool MountPartition(const Fstab::iterator& begin, bool erase_same_mounts,
                         Fstab::iterator* end = nullptr);
 
@@ -106,9 +106,10 @@ class FirstStageMount {
     // revocation check by DSU installation service.
     void CopyDsuAvbKeys();
 
-    // Pure virtual functions.
-    virtual bool GetDmVerityDevices(std::set<std::string>* devices) = 0;
-    virtual bool SetUpDmVerity(FstabEntry* fstab_entry) = 0;
+    bool GetDmVerityDevices(std::set<std::string>* devices);
+    bool SetUpDmVerity(FstabEntry* fstab_entry);
+
+    bool InitAvbHandle();
 
     bool need_dm_verity_;
     bool dsu_not_on_userdata_ = false;
@@ -122,19 +123,6 @@ class FirstStageMount {
     // Reads all AVB keys before chroot into /system, as they might be used
     // later when mounting other partitions, e.g., /vendor and /product.
     std::map<std::string, std::vector<std::string>> preload_avb_key_blobs_;
-};
-
-class FirstStageMountVBootV2 : public FirstStageMount {
-  public:
-    friend void SetInitAvbVersionInRecovery();
-
-    FirstStageMountVBootV2(Fstab fstab);
-    ~FirstStageMountVBootV2() override = default;
-
-  protected:
-    bool GetDmVerityDevices(std::set<std::string>* devices) override;
-    bool SetUpDmVerity(FstabEntry* fstab_entry) override;
-    bool InitAvbHandle();
 
     std::vector<std::string> vbmeta_partitions_;
     AvbUniquePtr avb_handle_;
@@ -220,10 +208,6 @@ static bool IsStandaloneImageRollback(const AvbHandle& builtin_vbmeta,
 
 // Class Definitions
 // -----------------
-FirstStageMount::FirstStageMount(Fstab fstab) : need_dm_verity_(false), fstab_(std::move(fstab)) {
-    super_partition_name_ = fs_mgr_get_super_partition_name();
-}
-
 Result<std::unique_ptr<FirstStageMount>> FirstStageMount::Create() {
     auto fstab = ReadFirstStageFstab();
     if (!fstab.ok()) {
@@ -233,7 +217,7 @@ Result<std::unique_ptr<FirstStageMount>> FirstStageMount::Create() {
     return std::make_unique<FirstStageMountVBootV2>(std::move(*fstab));
 }
 
-bool FirstStageMount::DoCreateDevices() {
+bool FirstStageMountVBootV2::DoCreateDevices() {
     if (!InitDevices()) return false;
 
     // Mount /metadata before creating logical partitions, since we need to
@@ -255,7 +239,7 @@ bool FirstStageMount::DoCreateDevices() {
     return true;
 }
 
-bool FirstStageMount::DoFirstStageMount() {
+bool FirstStageMountVBootV2::DoFirstStageMount() {
     if (!IsDmLinearEnabled() && fstab_.empty()) {
         // Nothing to mount.
         LOG(INFO) << "First stage mount skipped (missing/incompatible/empty fstab in device tree)";
@@ -267,7 +251,7 @@ bool FirstStageMount::DoFirstStageMount() {
     return true;
 }
 
-bool FirstStageMount::InitDevices() {
+bool FirstStageMountVBootV2::InitDevices() {
     std::set<std::string> devices;
     GetSuperDeviceName(&devices);
 
@@ -288,14 +272,14 @@ bool FirstStageMount::InitDevices() {
     return true;
 }
 
-bool FirstStageMount::IsDmLinearEnabled() {
+bool FirstStageMountVBootV2::IsDmLinearEnabled() {
     for (const auto& entry : fstab_) {
         if (entry.fs_mgr_flags.logical) return true;
     }
     return false;
 }
 
-void FirstStageMount::GetSuperDeviceName(std::set<std::string>* devices) {
+void FirstStageMountVBootV2::GetSuperDeviceName(std::set<std::string>* devices) {
     // Add any additional devices required for dm-linear mappings.
     if (!IsDmLinearEnabled()) {
         return;
@@ -307,7 +291,7 @@ void FirstStageMount::GetSuperDeviceName(std::set<std::string>* devices) {
 // Creates devices with uevent->partition_name matching ones in the given set.
 // Found partitions will then be removed from it for the subsequent member
 // function to check which devices are NOT created.
-bool FirstStageMount::InitRequiredDevices(std::set<std::string> devices) {
+bool FirstStageMountVBootV2::InitRequiredDevices(std::set<std::string> devices) {
     if (!block_dev_init_.InitDeviceMapper()) {
         return false;
     }
@@ -317,7 +301,8 @@ bool FirstStageMount::InitRequiredDevices(std::set<std::string> devices) {
     return block_dev_init_.InitDevices(std::move(devices));
 }
 
-bool FirstStageMount::InitDmLinearBackingDevices(const android::fs_mgr::LpMetadata& metadata) {
+bool FirstStageMountVBootV2::InitDmLinearBackingDevices(
+        const android::fs_mgr::LpMetadata& metadata) {
     std::set<std::string> devices;
 
     auto partition_names = android::fs_mgr::GetBlockDevicePartitionNames(metadata);
@@ -334,7 +319,7 @@ bool FirstStageMount::InitDmLinearBackingDevices(const android::fs_mgr::LpMetada
     return InitRequiredDevices(std::move(devices));
 }
 
-bool FirstStageMount::CreateLogicalPartitions() {
+bool FirstStageMountVBootV2::CreateLogicalPartitions() {
     if (!IsDmLinearEnabled()) {
         return true;
     }
@@ -365,7 +350,7 @@ bool FirstStageMount::CreateLogicalPartitions() {
     return android::fs_mgr::CreateLogicalPartitions(*metadata.get(), super_path_);
 }
 
-bool FirstStageMount::CreateSnapshotPartitions(SnapshotManager* sm) {
+bool FirstStageMountVBootV2::CreateSnapshotPartitions(SnapshotManager* sm) {
     // When COW images are present for snapshots, they are stored on
     // the data partition.
     if (!InitRequiredDevices({"userdata"})) {
@@ -400,8 +385,8 @@ bool FirstStageMount::CreateSnapshotPartitions(SnapshotManager* sm) {
     return true;
 }
 
-bool FirstStageMount::MountPartition(const Fstab::iterator& begin, bool erase_same_mounts,
-                                     Fstab::iterator* end) {
+bool FirstStageMountVBootV2::MountPartition(const Fstab::iterator& begin, bool erase_same_mounts,
+                                            Fstab::iterator* end) {
     // Sets end to begin + 1, so we can just return on failure below.
     if (end) {
         *end = begin + 1;
@@ -445,7 +430,7 @@ bool FirstStageMount::MountPartition(const Fstab::iterator& begin, bool erase_sa
     return mounted;
 }
 
-void FirstStageMount::PreloadAvbKeys() {
+void FirstStageMountVBootV2::PreloadAvbKeys() {
     for (const auto& entry : fstab_) {
         // No need to cache the key content if it's empty, or is already cached.
         if (entry.avb_keys.empty() || preload_avb_key_blobs_.count(entry.avb_keys)) {
@@ -492,7 +477,7 @@ void FirstStageMount::PreloadAvbKeys() {
 // If system is in the fstab then we're not a system-as-root device, and in
 // this case, we mount system first then pivot to it.  From that point on,
 // we are effectively identical to a system-as-root device.
-bool FirstStageMount::TrySwitchSystemAsRoot() {
+bool FirstStageMountVBootV2::TrySwitchSystemAsRoot() {
     UseDsuIfPresent();
     // Preloading all AVB keys from the ramdisk before switching root to /system.
     PreloadAvbKeys();
@@ -521,7 +506,7 @@ bool FirstStageMount::TrySwitchSystemAsRoot() {
     return true;
 }
 
-bool FirstStageMount::MountPartitions() {
+bool FirstStageMountVBootV2::MountPartitions() {
     if (!TrySwitchSystemAsRoot()) return false;
 
     if (!SkipMountingPartitions(&fstab_, true /* verbose */)) return false;
@@ -604,7 +589,7 @@ bool FirstStageMount::MountPartitions() {
 // copy files to /metadata is NOT fatal, because it is auxiliary to perform
 // public key matching before booting into DSU images on next boot. The actual
 // public key matching will still be done on next boot to DSU.
-void FirstStageMount::CopyDsuAvbKeys() {
+void FirstStageMountVBootV2::CopyDsuAvbKeys() {
     std::error_code ec;
     // Removing existing keys in gsi::kDsuAvbKeyDir as they might be stale.
     std::filesystem::remove_all(gsi::kDsuAvbKeyDir, ec);
@@ -620,7 +605,7 @@ void FirstStageMount::CopyDsuAvbKeys() {
     }
 }
 
-void FirstStageMount::UseDsuIfPresent() {
+void FirstStageMountVBootV2::UseDsuIfPresent() {
     std::string error;
 
     if (!android::gsi::CanBootIntoGsi(&error)) {
@@ -657,10 +642,10 @@ void FirstStageMount::UseDsuIfPresent() {
     TransformFstabForDsu(&fstab_, active_dsu, dsu_partitions);
 }
 
-// First retrieve any vbmeta partitions from device tree (legacy) then read through the fstab
-// for any further vbmeta partitions.
 FirstStageMountVBootV2::FirstStageMountVBootV2(Fstab fstab)
-    : FirstStageMount(std::move(fstab)), avb_handle_(nullptr) {
+    : need_dm_verity_(false), fstab_(std::move(fstab)), avb_handle_(nullptr) {
+    super_partition_name_ = fs_mgr_get_super_partition_name();
+
     std::string device_tree_vbmeta_parts;
     read_android_dt_file("vbmeta/parts", &device_tree_vbmeta_parts);
 
@@ -793,39 +778,6 @@ bool FirstStageMountVBootV2::InitAvbHandle() {
     return true;
 }
 
-// Public functions
-// ----------------
-// Creates devices and logical partitions from storage devices
-bool DoCreateDevices() {
-    auto fsm = FirstStageMount::Create();
-    if (!fsm.ok()) {
-        LOG(ERROR) << "Failed to create FirstStageMount: " << fsm.error();
-        return false;
-    }
-    return (*fsm)->DoCreateDevices();
-}
-
-// Mounts partitions specified by fstab in device tree.
-bool DoFirstStageMount(bool create_devices) {
-    // Skips first stage mount if we're in recovery mode.
-    if (IsRecoveryMode()) {
-        LOG(INFO) << "First stage mount skipped (recovery mode)";
-        return true;
-    }
-
-    auto fsm = FirstStageMount::Create();
-    if (!fsm.ok()) {
-        LOG(ERROR) << "Failed to create FirstStageMount " << fsm.error();
-        return false;
-    }
-
-    if (create_devices) {
-        if (!(*fsm)->DoCreateDevices()) return false;
-    }
-
-    return (*fsm)->DoFirstStageMount();
-}
-
 void SetInitAvbVersionInRecovery() {
     if (!IsRecoveryMode()) {
         LOG(INFO) << "Skipped setting INIT_AVB_VERSION (not in recovery mode)";
diff --git a/init/first_stage_mount.h b/init/first_stage_mount.h
index 2f4e663825bf..ab14966c67b5 100644
--- a/init/first_stage_mount.h
+++ b/init/first_stage_mount.h
@@ -16,11 +16,28 @@
 
 #pragma once
 
+#include <memory>
+
+#include "result.h"
+
 namespace android {
 namespace init {
 
-bool DoCreateDevices();
-bool DoFirstStageMount(bool create_devices);
+class FirstStageMount {
+  public:
+    virtual ~FirstStageMount() = default;
+
+    // The factory method to create a FirstStageMount instance.
+    static Result<std::unique_ptr<FirstStageMount>> Create();
+    // Creates devices and logical partitions from storage devices
+    virtual bool DoCreateDevices() = 0;
+    // Mounts fstab entries read from device tree.
+    virtual bool DoFirstStageMount() = 0;
+
+  protected:
+    FirstStageMount() = default;
+};
+
 void SetInitAvbVersionInRecovery();
 
 }  // namespace init

From 440354afa08a60d396d24024cf8f87774cab88ee Mon Sep 17 00:00:00 2001
From: Nikita Ioffe <ioffe@google.com>
Date: Tue, 4 Jul 2023 15:17:36 +0100
Subject: [PATCH 0164/1487] Support for conditionally mounting /vendor
 partition in Microdroid

first_stage_init will only mount the /vendor partition in Microdroid if
the androidboot.microdroid.mount_vendor=1 is provided in the kernel
cmdline.

Bug: 285855433
Test: atest MicrodroidTestApp
Change-Id: I5b840b5474bc52ec2696a0ba6ead0476acddfb1a
---
 init/first_stage_init.cpp  |  8 ++++----
 init/first_stage_mount.cpp | 33 +++++++++++++++++++++++++++------
 init/first_stage_mount.h   |  2 +-
 3 files changed, 32 insertions(+), 11 deletions(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index e1d383a0c16c..e871da20b824 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -257,8 +257,8 @@ static BootMode GetBootMode(const std::string& cmdline, const std::string& bootc
     return BootMode::NORMAL_MODE;
 }
 
-static std::unique_ptr<FirstStageMount> CreateFirstStageMount() {
-    auto ret = FirstStageMount::Create();
+static std::unique_ptr<FirstStageMount> CreateFirstStageMount(const std::string& cmdline) {
+    auto ret = FirstStageMount::Create(cmdline);
     if (ret.ok()) {
         return std::move(*ret);
     } else {
@@ -396,7 +396,7 @@ int FirstStageMain(int argc, char** argv) {
     bool created_devices = false;
     if (want_console == FirstStageConsoleParam::CONSOLE_ON_FAILURE) {
         if (!IsRecoveryMode()) {
-            fsm = CreateFirstStageMount();
+            fsm = CreateFirstStageMount(cmdline);
             if (fsm) {
                 created_devices = fsm->DoCreateDevices();
                 if (!created_devices) {
@@ -456,7 +456,7 @@ int FirstStageMain(int argc, char** argv) {
         LOG(INFO) << "First stage mount skipped (recovery mode)";
     } else {
         if (!fsm) {
-            fsm = CreateFirstStageMount();
+            fsm = CreateFirstStageMount(cmdline);
         }
         if (!fsm) {
             LOG(FATAL) << "FirstStageMount not available";
diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index 4961f6a63ed6..d0f68a80c26b 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -138,7 +138,7 @@ static inline bool IsDtVbmetaCompatible(const Fstab& fstab) {
     return is_android_dt_value_expected("vbmeta/compatible", "android,vbmeta");
 }
 
-static Result<Fstab> ReadFirstStageFstab() {
+static Result<Fstab> ReadFirstStageFstabAndroid() {
     Fstab fstab;
     if (!ReadFstabFromDt(&fstab)) {
         if (ReadDefaultFstab(&fstab)) {
@@ -154,6 +154,24 @@ static Result<Fstab> ReadFirstStageFstab() {
     return fstab;
 }
 
+// Note: this is a temporary solution to avoid blocking devs that depend on /vendor partition in
+// Microdroid. For the proper solution the /vendor fstab should probably be defined in the DT.
+// TODO(b/285855430): refactor this
+// TODO(b/285855436): verify key microdroid-vendor was signed with.
+// TODO(b/285855436): should be mounted on top of dm-verity device.
+static Result<Fstab> ReadFirstStageFstabMicrodroid(const std::string& cmdline) {
+    Fstab fstab;
+    if (!ReadDefaultFstab(&fstab)) {
+        return Error() << "failed to read fstab";
+    }
+    if (cmdline.find("androidboot.microdroid.mount_vendor=1") == std::string::npos) {
+        // We weren't asked to mount /vendor partition, filter it out from the fstab.
+        auto predicate = [](const auto& entry) { return entry.mount_point == "/vendor"; };
+        fstab.erase(std::remove_if(fstab.begin(), fstab.end(), predicate), fstab.end());
+    }
+    return fstab;
+}
+
 static bool GetRootEntry(FstabEntry* root_entry) {
     Fstab proc_mounts;
     if (!ReadFstabFromFile("/proc/mounts", &proc_mounts)) {
@@ -206,10 +224,13 @@ static bool IsStandaloneImageRollback(const AvbHandle& builtin_vbmeta,
     return rollbacked;
 }
 
-// Class Definitions
-// -----------------
-Result<std::unique_ptr<FirstStageMount>> FirstStageMount::Create() {
-    auto fstab = ReadFirstStageFstab();
+Result<std::unique_ptr<FirstStageMount>> FirstStageMount::Create(const std::string& cmdline) {
+    Result<Fstab> fstab;
+    if (IsMicrodroid()) {
+        fstab = ReadFirstStageFstabMicrodroid(cmdline);
+    } else {
+        fstab = ReadFirstStageFstabAndroid();
+    }
     if (!fstab.ok()) {
         return fstab.error();
     }
@@ -784,7 +805,7 @@ void SetInitAvbVersionInRecovery() {
         return;
     }
 
-    auto fstab = ReadFirstStageFstab();
+    auto fstab = ReadFirstStageFstabAndroid();
     if (!fstab.ok()) {
         LOG(ERROR) << fstab.error();
         return;
diff --git a/init/first_stage_mount.h b/init/first_stage_mount.h
index ab14966c67b5..54501d8df6f5 100644
--- a/init/first_stage_mount.h
+++ b/init/first_stage_mount.h
@@ -28,7 +28,7 @@ class FirstStageMount {
     virtual ~FirstStageMount() = default;
 
     // The factory method to create a FirstStageMount instance.
-    static Result<std::unique_ptr<FirstStageMount>> Create();
+    static Result<std::unique_ptr<FirstStageMount>> Create(const std::string& cmdline);
     // Creates devices and logical partitions from storage devices
     virtual bool DoCreateDevices() = 0;
     // Mounts fstab entries read from device tree.

From df0e96e962af40df7d6a89f61642e75ff0b6284c Mon Sep 17 00:00:00 2001
From: Nikita Ioffe <ioffe@google.com>
Date: Tue, 4 Jul 2023 17:18:02 +0100
Subject: [PATCH 0165/1487] Only allow debuggable Microdroid VMs to mount
 /vendor

Until the verification of the /vendor partition we restrict the usage of
the feature to only debuggable VMs. If a non-debuggable Microdroid VM
is requested to mount /vendor, first_stage_init will crash and the VM
won't boot.

Bug: 285855436
Test: vm run-microdroid --debug none --vendor test_vendor.img
Change-Id: I9d44ad5c1d971bac1a9173c291ce61b628f2f8e9
---
 init/first_stage_init.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index e871da20b824..7fabbac517a2 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -357,6 +357,18 @@ int FirstStageMain(int argc, char** argv) {
 
     LOG(INFO) << "init first stage started!";
 
+    // We only allow /vendor partition in debuggable Microdrod until it is verified during boot.
+    // TODO(b/285855436): remove this check.
+    if (IsMicrodroid()) {
+        bool mount_vendor =
+                cmdline.find("androidboot.microdroid.mount_vendor=1") != std::string::npos;
+        bool debuggable =
+                bootconfig.find("androidboot.microdroid.debuggable = \"1\"") != std::string::npos;
+        if (mount_vendor && !debuggable) {
+            LOG(FATAL) << "Attempted to mount /vendor partition for non-debuggable Microdroid VM";
+        }
+    }
+
     auto old_root_dir = std::unique_ptr<DIR, decltype(&closedir)>{opendir("/"), closedir};
     if (!old_root_dir) {
         PLOG(ERROR) << "Could not opendir(\"/\"), not freeing ramdisk";

From 9fbd1683d4d64a250d379df75ca151eb5c37b257 Mon Sep 17 00:00:00 2001
From: Andrew Walbran <qwandor@google.com>
Date: Mon, 10 Jul 2023 14:56:20 +0100
Subject: [PATCH 0166/1487] Add safety comments.

These will soon be required by a lint.

Bug: 290018030
Test: m vm virtmgr
Change-Id: Id628b2a88f1cb0235fbccc748c52514e64561fe5
---
 debuggerd/rust/tombstoned_client/src/lib.rs | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/debuggerd/rust/tombstoned_client/src/lib.rs b/debuggerd/rust/tombstoned_client/src/lib.rs
index 5c8abef2cdb8..d1b5e696e481 100644
--- a/debuggerd/rust/tombstoned_client/src/lib.rs
+++ b/debuggerd/rust/tombstoned_client/src/lib.rs
@@ -39,20 +39,26 @@ pub struct TombstonedConnection {
 }
 
 impl TombstonedConnection {
+    /// # Safety
+    ///
+    /// The file descriptors must be valid and open.
     unsafe fn from_raw_fds(
         tombstoned_socket: RawFd,
         text_output_fd: RawFd,
         proto_output_fd: RawFd,
     ) -> Self {
         Self {
-            tombstoned_socket: File::from_raw_fd(tombstoned_socket),
+            // SAFETY: The caller guarantees that the file descriptor is valid and open.
+            tombstoned_socket: unsafe { File::from_raw_fd(tombstoned_socket) },
             text_output: if text_output_fd >= 0 {
-                Some(File::from_raw_fd(text_output_fd))
+                // SAFETY: The caller guarantees that the file descriptor is valid and open.
+                Some(unsafe { File::from_raw_fd(text_output_fd) })
             } else {
                 None
             },
             proto_output: if proto_output_fd >= 0 {
-                Some(File::from_raw_fd(proto_output_fd))
+                // SAFETY: The caller guarantees that the file descriptor is valid and open.
+                Some(unsafe { File::from_raw_fd(proto_output_fd) })
             } else {
                 None
             },
@@ -71,6 +77,8 @@ impl TombstonedConnection {
             &mut proto_output_fd,
             dump_type,
         ) {
+            // SAFETY: If tombstoned_connect_files returns successfully then they file descriptors
+            // are valid and open.
             Ok(unsafe { Self::from_raw_fds(tombstoned_socket, text_output_fd, proto_output_fd) })
         } else {
             Err(Error)
@@ -146,8 +154,6 @@ mod tests {
             .write_all(b"test data")
             .expect("Failed to write to text output FD.");
 
-        connection
-            .notify_completion()
-            .expect("Failed to notify completion.");
+        connection.notify_completion().expect("Failed to notify completion.");
     }
 }

From ab74dbb197df58609babd43b3acfb11a58fd9992 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers@google.com>
Date: Mon, 10 Jul 2023 17:58:33 +0000
Subject: [PATCH 0167/1487] init: simplify queue_fs_event()

Combine some cases that are handled identically, and remove the
'userdata_remount' parameter which is unused.  No change in behavior.

Test: presubmit
Change-Id: I0567e47d02942af7865c155dab76e6d0e9d71a1f
---
 init/builtins.cpp | 30 ++++++------------------------
 1 file changed, 6 insertions(+), 24 deletions(-)

diff --git a/init/builtins.cpp b/init/builtins.cpp
index 585eca25da88..2176233aab96 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -577,7 +577,7 @@ static void import_late(const std::vector<std::string>& rc_paths) {
  *
  * return code is processed based on input code
  */
-static Result<void> queue_fs_event(int code, bool userdata_remount) {
+static Result<void> queue_fs_event(int code) {
     if (code == FS_MGR_MNTALL_DEV_NOT_ENCRYPTABLE) {
         SetProperty("ro.crypto.state", "unsupported");
         ActionManager::GetInstance().QueueEventTrigger("nonencrypted");
@@ -591,27 +591,9 @@ static Result<void> queue_fs_event(int code, bool userdata_remount) {
         const std::vector<std::string> options = {"--wipe_data", "--reason=fs_mgr_mount_all" };
         return reboot_into_recovery(options);
         /* If reboot worked, there is no return. */
-    } else if (code == FS_MGR_MNTALL_DEV_FILE_ENCRYPTED) {
-        if (!FscryptInstallKeyring()) {
-            return Error() << "FscryptInstallKeyring() failed";
-        }
-        SetProperty("ro.crypto.state", "encrypted");
-
-        // Although encrypted, we have device key, so we do not need to
-        // do anything different from the nonencrypted case.
-        ActionManager::GetInstance().QueueEventTrigger("nonencrypted");
-        return {};
-    } else if (code == FS_MGR_MNTALL_DEV_IS_METADATA_ENCRYPTED) {
-        if (!FscryptInstallKeyring()) {
-            return Error() << "FscryptInstallKeyring() failed";
-        }
-        SetProperty("ro.crypto.state", "encrypted");
-
-        // Although encrypted, vold has already set the device up, so we do not need to
-        // do anything different from the nonencrypted case.
-        ActionManager::GetInstance().QueueEventTrigger("nonencrypted");
-        return {};
-    } else if (code == FS_MGR_MNTALL_DEV_NEEDS_METADATA_ENCRYPTION) {
+    } else if (code == FS_MGR_MNTALL_DEV_FILE_ENCRYPTED ||
+               code == FS_MGR_MNTALL_DEV_IS_METADATA_ENCRYPTED ||
+               code == FS_MGR_MNTALL_DEV_NEEDS_METADATA_ENCRYPTION) {
         if (!FscryptInstallKeyring()) {
             return Error() << "FscryptInstallKeyring() failed";
         }
@@ -683,7 +665,7 @@ static Result<void> do_mount_all(const BuiltinArguments& args) {
     if (queue_event) {
         /* queue_fs_event will queue event based on mount_fstab return code
          * and return processed return code*/
-        auto queue_fs_result = queue_fs_event(mount_fstab_result.code, false);
+        auto queue_fs_result = queue_fs_event(mount_fstab_result.code);
         if (!queue_fs_result.ok()) {
             return Error() << "queue_fs_event() failed: " << queue_fs_result.error();
         }
@@ -1217,7 +1199,7 @@ static Result<void> do_remount_userdata(const BuiltinArguments& args) {
                                          "/metadata/userspacereboot/mount_info.txt");
         trigger_shutdown("reboot,mount_userdata_failed");
     }
-    if (auto result = queue_fs_event(initial_mount_fstab_return_code, true); !result.ok()) {
+    if (auto result = queue_fs_event(initial_mount_fstab_return_code); !result.ok()) {
         return Error() << "queue_fs_event() failed: " << result.error();
     }
     return {};

From 8bb751dc8a1499f24add9e0831ab347feb2c3878 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 17 Feb 2023 01:20:52 -0800
Subject: [PATCH 0168/1487] snapuserd: Split the server into two classes.

This splits server into two classes: one that handles the IPC requests,
and one that managers snapshot handlers. This will allow embedding of
the snapshot handling code, without booting up a server. It'll also make
testing much easier.

The handler code has been further placed behind a virtual interface,
though this is likely unnecessary unless we start testing the server
logic itself (or attempt to unify the S and T+ versions of snapuserd).

Bug: 269361087
Test: ota
Ignore-AOSP-First: cherry-pick from aosp
Change-Id: I3ca3ad9c8c1fb910a1c7bf9f44165e2f44c930c9
Merged-In: I3ca3ad9c8c1fb910a1c7bf9f44165e2f44c930c9
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   1 +
 .../snapuserd/snapuserd_daemon.cpp            |   2 +-
 .../user-space-merge/handler_manager.cpp      | 371 ++++++++++++++++++
 .../user-space-merge/handler_manager.h        | 131 +++++++
 .../user-space-merge/snapuserd_server.cpp     | 338 +---------------
 .../user-space-merge/snapuserd_server.h       |  58 +--
 6 files changed, 526 insertions(+), 375 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index dd11a33daf28..65f3d6d297ed 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -62,6 +62,7 @@ cc_library_static {
         "dm-snapshot-merge/snapuserd_worker.cpp",
         "dm-snapshot-merge/snapuserd_readahead.cpp",
         "snapuserd_buffer.cpp",
+        "user-space-merge/handler_manager.cpp",
         "user-space-merge/snapuserd_core.cpp",
         "user-space-merge/snapuserd_dm_user.cpp",
         "user-space-merge/snapuserd_merge.cpp",
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
index ae20e1fa479e..36dad3343d3e 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
@@ -114,7 +114,7 @@ bool Daemon::StartServerForUserspaceSnapshots(int arg_start, int argc, char** ar
             return false;
         }
         auto handler = user_server_.AddHandler(parts[0], parts[1], parts[2], parts[3]);
-        if (!handler || !user_server_.StartHandler(handler)) {
+        if (!handler || !user_server_.StartHandler(parts[0])) {
             return false;
         }
     }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
new file mode 100644
index 000000000000..c5150c411d02
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -0,0 +1,371 @@
+// Copyright (C) 2023 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 "handler_manager.h"
+
+#include <sys/eventfd.h>
+
+#include <android-base/logging.h>
+
+#include "snapuserd_core.h"
+
+namespace android {
+namespace snapshot {
+
+static constexpr uint8_t kMaxMergeThreads = 2;
+
+void HandlerThread::FreeResources() {
+    // Each worker thread holds a reference to snapuserd.
+    // Clear them so that all the resources
+    // held by snapuserd is released
+    if (snapuserd_) {
+        snapuserd_->FreeResources();
+        snapuserd_ = nullptr;
+    }
+}
+
+SnapshotHandlerManager::SnapshotHandlerManager() {
+    monitor_merge_event_fd_.reset(eventfd(0, EFD_CLOEXEC));
+    if (monitor_merge_event_fd_ == -1) {
+        PLOG(FATAL) << "monitor_merge_event_fd_: failed to create eventfd";
+    }
+}
+
+std::shared_ptr<HandlerThread> SnapshotHandlerManager::AddHandler(
+        const std::string& misc_name, const std::string& cow_device_path,
+        const std::string& backing_device, const std::string& base_path_merge,
+        int num_worker_threads, bool use_iouring, bool perform_verification) {
+    auto snapuserd = std::make_shared<SnapshotHandler>(misc_name, cow_device_path, backing_device,
+                                                       base_path_merge, num_worker_threads,
+                                                       use_iouring, perform_verification);
+    if (!snapuserd->InitCowDevice()) {
+        LOG(ERROR) << "Failed to initialize Snapuserd";
+        return nullptr;
+    }
+
+    if (!snapuserd->InitializeWorkers()) {
+        LOG(ERROR) << "Failed to initialize workers";
+        return nullptr;
+    }
+
+    auto handler = std::make_shared<HandlerThread>(snapuserd);
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+        if (FindHandler(&lock, misc_name) != dm_users_.end()) {
+            LOG(ERROR) << "Handler already exists: " << misc_name;
+            return nullptr;
+        }
+        dm_users_.push_back(handler);
+    }
+    return handler;
+}
+
+bool SnapshotHandlerManager::StartHandler(const std::string& misc_name) {
+    std::lock_guard<std::mutex> lock(lock_);
+    auto iter = FindHandler(&lock, misc_name);
+    if (iter == dm_users_.end()) {
+        LOG(ERROR) << "Could not find handler: " << misc_name;
+        return false;
+    }
+    if (!(*iter)->snapuserd() || (*iter)->snapuserd()->IsAttached()) {
+        LOG(ERROR) << "Tried to re-attach control device: " << misc_name;
+        return false;
+    }
+    if (!StartHandler(*iter)) {
+        return false;
+    }
+    return true;
+}
+
+bool SnapshotHandlerManager::StartHandler(const std::shared_ptr<HandlerThread>& handler) {
+    if (handler->snapuserd()->IsAttached()) {
+        LOG(ERROR) << "Handler already attached";
+        return false;
+    }
+
+    handler->snapuserd()->AttachControlDevice();
+
+    handler->thread() = std::thread(std::bind(&SnapshotHandlerManager::RunThread, this, handler));
+    return true;
+}
+
+bool SnapshotHandlerManager::DeleteHandler(const std::string& misc_name) {
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+        auto iter = FindHandler(&lock, misc_name);
+        if (iter == dm_users_.end()) {
+            // After merge is completed, we swap dm-user table with
+            // the underlying dm-linear base device. Hence, worker
+            // threads would have terminted and was removed from
+            // the list.
+            LOG(DEBUG) << "Could not find handler: " << misc_name;
+            return true;
+        }
+
+        if (!(*iter)->ThreadTerminated()) {
+            (*iter)->snapuserd()->NotifyIOTerminated();
+        }
+    }
+    if (!RemoveAndJoinHandler(misc_name)) {
+        return false;
+    }
+    return true;
+}
+
+void SnapshotHandlerManager::RunThread(std::shared_ptr<HandlerThread> handler) {
+    LOG(INFO) << "Entering thread for handler: " << handler->misc_name();
+
+    if (!handler->snapuserd()->Start()) {
+        LOG(ERROR) << " Failed to launch all worker threads";
+    }
+
+    handler->snapuserd()->CloseFds();
+    bool merge_completed = handler->snapuserd()->CheckMergeCompletionStatus();
+    handler->snapuserd()->UnmapBufferRegion();
+
+    auto misc_name = handler->misc_name();
+    LOG(INFO) << "Handler thread about to exit: " << misc_name;
+
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+        if (merge_completed) {
+            num_partitions_merge_complete_ += 1;
+            active_merge_threads_ -= 1;
+            WakeupMonitorMergeThread();
+        }
+        handler->SetThreadTerminated();
+        auto iter = FindHandler(&lock, handler->misc_name());
+        if (iter == dm_users_.end()) {
+            // RemoveAndJoinHandler() already removed us from the list, and is
+            // now waiting on a join(), so just return. Additionally, release
+            // all the resources held by snapuserd object which are shared
+            // by worker threads. This should be done when the last reference
+            // of "handler" is released; but we will explicitly release here
+            // to make sure snapuserd object is freed as it is the biggest
+            // consumer of memory in the daemon.
+            handler->FreeResources();
+            LOG(INFO) << "Exiting handler thread to allow for join: " << misc_name;
+            return;
+        }
+
+        LOG(INFO) << "Exiting handler thread and freeing resources: " << misc_name;
+
+        if (handler->snapuserd()->IsAttached()) {
+            handler->thread().detach();
+        }
+
+        // Important: free resources within the lock. This ensures that if
+        // WaitForDelete() is called, the handler is either in the list, or
+        // it's not and its resources are guaranteed to be freed.
+        handler->FreeResources();
+        dm_users_.erase(iter);
+    }
+}
+
+bool SnapshotHandlerManager::InitiateMerge(const std::string& misc_name) {
+    std::lock_guard<std::mutex> lock(lock_);
+    auto iter = FindHandler(&lock, misc_name);
+    if (iter == dm_users_.end()) {
+        LOG(ERROR) << "Could not find handler: " << misc_name;
+        return false;
+    }
+
+    return StartMerge(&lock, *iter);
+}
+
+bool SnapshotHandlerManager::StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
+                                        const std::shared_ptr<HandlerThread>& handler) {
+    CHECK(proof_of_lock);
+
+    if (!handler->snapuserd()->IsAttached()) {
+        LOG(ERROR) << "Handler not attached to dm-user - Merge thread cannot be started";
+        return false;
+    }
+
+    handler->snapuserd()->MonitorMerge();
+
+    if (!is_merge_monitor_started_) {
+        std::thread(&SnapshotHandlerManager::MonitorMerge, this).detach();
+        is_merge_monitor_started_ = true;
+    }
+
+    merge_handlers_.push(handler);
+    WakeupMonitorMergeThread();
+    return true;
+}
+
+void SnapshotHandlerManager::WakeupMonitorMergeThread() {
+    uint64_t notify = 1;
+    ssize_t rc = TEMP_FAILURE_RETRY(write(monitor_merge_event_fd_.get(), &notify, sizeof(notify)));
+    if (rc < 0) {
+        PLOG(FATAL) << "failed to notify monitor merge thread";
+    }
+}
+
+void SnapshotHandlerManager::MonitorMerge() {
+    while (!stop_monitor_merge_thread_) {
+        uint64_t testVal;
+        ssize_t ret =
+                TEMP_FAILURE_RETRY(read(monitor_merge_event_fd_.get(), &testVal, sizeof(testVal)));
+        if (ret == -1) {
+            PLOG(FATAL) << "Failed to read from eventfd";
+        } else if (ret == 0) {
+            LOG(FATAL) << "Hit EOF on eventfd";
+        }
+
+        LOG(INFO) << "MonitorMerge: active-merge-threads: " << active_merge_threads_;
+        {
+            std::lock_guard<std::mutex> lock(lock_);
+            while (active_merge_threads_ < kMaxMergeThreads && merge_handlers_.size() > 0) {
+                auto handler = merge_handlers_.front();
+                merge_handlers_.pop();
+
+                if (!handler->snapuserd()) {
+                    LOG(INFO) << "MonitorMerge: skipping deleted handler: " << handler->misc_name();
+                    continue;
+                }
+
+                LOG(INFO) << "Starting merge for partition: "
+                          << handler->snapuserd()->GetMiscName();
+                handler->snapuserd()->InitiateMerge();
+                active_merge_threads_ += 1;
+            }
+        }
+    }
+
+    LOG(INFO) << "Exiting MonitorMerge: size: " << merge_handlers_.size();
+}
+
+std::string SnapshotHandlerManager::GetMergeStatus(const std::string& misc_name) {
+    std::lock_guard<std::mutex> lock(lock_);
+    auto iter = FindHandler(&lock, misc_name);
+    if (iter == dm_users_.end()) {
+        LOG(ERROR) << "Could not find handler: " << misc_name;
+        return {};
+    }
+
+    return (*iter)->snapuserd()->GetMergeStatus();
+}
+
+double SnapshotHandlerManager::GetMergePercentage() {
+    std::lock_guard<std::mutex> lock(lock_);
+
+    double percentage = 0.0;
+    int n = 0;
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        auto& th = (*iter)->thread();
+        if (th.joinable()) {
+            // Merge percentage by individual partitions wherein merge is still
+            // in-progress
+            percentage += (*iter)->snapuserd()->GetMergePercentage();
+            n += 1;
+        }
+    }
+
+    // Calculate final merge including those partitions where merge was already
+    // completed - num_partitions_merge_complete_ will track them when each
+    // thread exists in RunThread.
+    int total_partitions = n + num_partitions_merge_complete_;
+
+    if (total_partitions) {
+        percentage = ((num_partitions_merge_complete_ * 100.0) + percentage) / total_partitions;
+    }
+
+    LOG(DEBUG) << "Merge %: " << percentage
+               << " num_partitions_merge_complete_: " << num_partitions_merge_complete_
+               << " total_partitions: " << total_partitions << " n: " << n;
+    return percentage;
+}
+
+bool SnapshotHandlerManager::GetVerificationStatus() {
+    std::lock_guard<std::mutex> lock(lock_);
+
+    bool status = true;
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        auto& th = (*iter)->thread();
+        if (th.joinable() && status) {
+            status = (*iter)->snapuserd()->CheckPartitionVerification() && status;
+        } else {
+            // return immediately if there is a failure
+            return false;
+        }
+    }
+
+    return status;
+}
+
+bool SnapshotHandlerManager::RemoveAndJoinHandler(const std::string& misc_name) {
+    std::shared_ptr<HandlerThread> handler;
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+
+        auto iter = FindHandler(&lock, misc_name);
+        if (iter == dm_users_.end()) {
+            // Client already deleted.
+            return true;
+        }
+        handler = std::move(*iter);
+        dm_users_.erase(iter);
+    }
+
+    auto& th = handler->thread();
+    if (th.joinable()) {
+        th.join();
+    }
+    return true;
+}
+
+void SnapshotHandlerManager::TerminateMergeThreads() {
+    std::lock_guard<std::mutex> guard(lock_);
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        if (!(*iter)->ThreadTerminated()) {
+            (*iter)->snapuserd()->NotifyIOTerminated();
+        }
+    }
+}
+
+void SnapshotHandlerManager::JoinAllThreads() {
+    // Acquire the thread list within the lock.
+    std::vector<std::shared_ptr<HandlerThread>> dm_users;
+    {
+        std::lock_guard<std::mutex> guard(lock_);
+        dm_users = std::move(dm_users_);
+    }
+
+    for (auto& client : dm_users) {
+        auto& th = client->thread();
+
+        if (th.joinable()) th.join();
+    }
+
+    stop_monitor_merge_thread_ = true;
+    WakeupMonitorMergeThread();
+}
+
+auto SnapshotHandlerManager::FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
+                                         const std::string& misc_name) -> HandlerList::iterator {
+    CHECK(proof_of_lock);
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        if ((*iter)->misc_name() == misc_name) {
+            return iter;
+        }
+    }
+    return dm_users_.end();
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
new file mode 100644
index 000000000000..b7ddac19f28a
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
@@ -0,0 +1,131 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <memory>
+#include <queue>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include <android-base/unique_fd.h>
+
+namespace android {
+namespace snapshot {
+
+class SnapshotHandler;
+
+class HandlerThread {
+  public:
+    explicit HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd);
+
+    void FreeResources();
+    const std::shared_ptr<SnapshotHandler>& snapuserd() const { return snapuserd_; }
+    std::thread& thread() { return thread_; }
+
+    const std::string& misc_name() const { return misc_name_; }
+    bool ThreadTerminated() { return thread_terminated_; }
+    void SetThreadTerminated() { thread_terminated_ = true; }
+
+  private:
+    std::thread thread_;
+    std::shared_ptr<SnapshotHandler> snapuserd_;
+    std::string misc_name_;
+    bool thread_terminated_ = false;
+};
+
+class ISnapshotHandlerManager {
+  public:
+    virtual ~ISnapshotHandlerManager() {}
+
+    // Add a new snapshot handler but do not start serving requests yet.
+    virtual std::shared_ptr<HandlerThread> AddHandler(const std::string& misc_name,
+                                                      const std::string& cow_device_path,
+                                                      const std::string& backing_device,
+                                                      const std::string& base_path_merge,
+                                                      int num_worker_threads, bool use_iouring,
+                                                      bool perform_verification) = 0;
+
+    // Start serving requests on a snapshot handler.
+    virtual bool StartHandler(const std::string& misc_name) = 0;
+
+    // Stop serving requests on a snapshot handler and remove it.
+    virtual bool DeleteHandler(const std::string& misc_name) = 0;
+
+    // Begin merging blocks on the given snapshot handler.
+    virtual bool InitiateMerge(const std::string& misc_name) = 0;
+
+    // Return a string containing a status code indicating the merge status
+    // on the handler. Returns empty on error.
+    virtual std::string GetMergeStatus(const std::string& misc_name) = 0;
+
+    // Wait until all handlers have terminated.
+    virtual void JoinAllThreads() = 0;
+
+    // Stop any in-progress merge threads.
+    virtual void TerminateMergeThreads() = 0;
+
+    // Returns the merge progress across all merging snapshot handlers.
+    virtual double GetMergePercentage() = 0;
+
+    // Returns whether all snapshots have verified.
+    virtual bool GetVerificationStatus() = 0;
+};
+
+class SnapshotHandlerManager final : public ISnapshotHandlerManager {
+  public:
+    SnapshotHandlerManager();
+    std::shared_ptr<HandlerThread> AddHandler(const std::string& misc_name,
+                                              const std::string& cow_device_path,
+                                              const std::string& backing_device,
+                                              const std::string& base_path_merge,
+                                              int num_worker_threads, bool use_iouring,
+                                              bool perform_verification) override;
+    bool StartHandler(const std::string& misc_name) override;
+    bool DeleteHandler(const std::string& misc_name) override;
+    bool InitiateMerge(const std::string& misc_name) override;
+    std::string GetMergeStatus(const std::string& misc_name) override;
+    void JoinAllThreads() override;
+    void TerminateMergeThreads() override;
+    double GetMergePercentage() override;
+    bool GetVerificationStatus() override;
+
+  private:
+    bool StartHandler(const std::shared_ptr<HandlerThread>& handler);
+    void RunThread(std::shared_ptr<HandlerThread> handler);
+    bool StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
+                    const std::shared_ptr<HandlerThread>& handler);
+    void MonitorMerge();
+    void WakeupMonitorMergeThread();
+    bool RemoveAndJoinHandler(const std::string& misc_name);
+
+    // Find a HandlerThread within a lock.
+    using HandlerList = std::vector<std::shared_ptr<HandlerThread>>;
+    HandlerList::iterator FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
+                                      const std::string& misc_name);
+
+    std::mutex lock_;
+    HandlerList dm_users_;
+
+    bool is_merge_monitor_started_ = false;
+    bool stop_monitor_merge_thread_ = false;
+    int active_merge_threads_ = 0;
+    int num_partitions_merge_complete_ = 0;
+    std::queue<std::shared_ptr<HandlerThread>> merge_handlers_;
+    android::base::unique_fd monitor_merge_event_fd_;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index b7ce2109adfe..cc8115f5f800 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -62,11 +62,8 @@ DaemonOps UserSnapshotServer::Resolveop(std::string& input) {
 }
 
 UserSnapshotServer::UserSnapshotServer() {
-    monitor_merge_event_fd_.reset(eventfd(0, EFD_CLOEXEC));
-    if (monitor_merge_event_fd_ == -1) {
-        PLOG(FATAL) << "monitor_merge_event_fd_: failed to create eventfd";
-    }
     terminating_ = false;
+    handlers_ = std::make_unique<SnapshotHandlerManager>();
 }
 
 UserSnapshotServer::~UserSnapshotServer() {
@@ -99,7 +96,7 @@ void UserSnapshotServer::Parsemsg(std::string const& msg, const char delim,
 
 void UserSnapshotServer::ShutdownThreads() {
     terminating_ = true;
-    JoinAllThreads();
+    handlers_->JoinAllThreads();
 }
 
 HandlerThread::HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd)
@@ -166,17 +163,7 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 return Sendmsg(fd, "fail");
             }
 
-            std::lock_guard<std::mutex> lock(lock_);
-            auto iter = FindHandler(&lock, out[1]);
-            if (iter == dm_users_.end()) {
-                LOG(ERROR) << "Could not find handler: " << out[1];
-                return Sendmsg(fd, "fail");
-            }
-            if (!(*iter)->snapuserd() || (*iter)->snapuserd()->IsAttached()) {
-                LOG(ERROR) << "Tried to re-attach control device: " << out[1];
-                return Sendmsg(fd, "fail");
-            }
-            if (!StartHandler(*iter)) {
+            if (!handlers_->StartHandler(out[1])) {
                 return Sendmsg(fd, "fail");
             }
             return Sendmsg(fd, "success");
@@ -209,30 +196,13 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
                 return Sendmsg(fd, "fail");
             }
-            {
-                std::lock_guard<std::mutex> lock(lock_);
-                auto iter = FindHandler(&lock, out[1]);
-                if (iter == dm_users_.end()) {
-                    // After merge is completed, we swap dm-user table with
-                    // the underlying dm-linear base device. Hence, worker
-                    // threads would have terminted and was removed from
-                    // the list.
-                    LOG(DEBUG) << "Could not find handler: " << out[1];
-                    return Sendmsg(fd, "success");
-                }
-
-                if (!(*iter)->ThreadTerminated()) {
-                    (*iter)->snapuserd()->NotifyIOTerminated();
-                }
-            }
-            if (!RemoveAndJoinHandler(out[1])) {
+            if (!handlers_->DeleteHandler(out[1])) {
                 return Sendmsg(fd, "fail");
             }
             return Sendmsg(fd, "success");
         }
         case DaemonOps::DETACH: {
-            std::lock_guard<std::mutex> lock(lock_);
-            TerminateMergeThreads(&lock);
+            handlers_->TerminateMergeThreads();
             terminating_ = true;
             return true;
         }
@@ -252,24 +222,15 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 return Sendmsg(fd, "fail");
             }
             if (out[0] == "initiate_merge") {
-                std::lock_guard<std::mutex> lock(lock_);
-                auto iter = FindHandler(&lock, out[1]);
-                if (iter == dm_users_.end()) {
-                    LOG(ERROR) << "Could not find handler: " << out[1];
+                if (!handlers_->InitiateMerge(out[1])) {
                     return Sendmsg(fd, "fail");
                 }
-
-                if (!StartMerge(&lock, *iter)) {
-                    return Sendmsg(fd, "fail");
-                }
-
                 return Sendmsg(fd, "success");
             }
             return Sendmsg(fd, "fail");
         }
         case DaemonOps::PERCENTAGE: {
-            std::lock_guard<std::mutex> lock(lock_);
-            double percentage = GetMergePercentage(&lock);
+            double percentage = handlers_->GetMergePercentage();
 
             return Sendmsg(fd, std::to_string(percentage));
         }
@@ -280,24 +241,16 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
                 return Sendmsg(fd, "snapshot-merge-failed");
             }
-            {
-                std::lock_guard<std::mutex> lock(lock_);
-                auto iter = FindHandler(&lock, out[1]);
-                if (iter == dm_users_.end()) {
-                    LOG(ERROR) << "Could not find handler: " << out[1];
-                    return Sendmsg(fd, "snapshot-merge-failed");
-                }
-
-                std::string merge_status = GetMergeStatus(*iter);
-                return Sendmsg(fd, merge_status);
+            auto status = handlers_->GetMergeStatus(out[1]);
+            if (status.empty()) {
+                return Sendmsg(fd, "snapshot-merge-failed");
             }
+            return Sendmsg(fd, status);
         }
         case DaemonOps::UPDATE_VERIFY: {
-            std::lock_guard<std::mutex> lock(lock_);
-            if (!UpdateVerification(&lock)) {
+            if (!handlers_->GetVerificationStatus()) {
                 return Sendmsg(fd, "fail");
             }
-
             return Sendmsg(fd, "success");
         }
         default: {
@@ -308,56 +261,6 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
     }
 }
 
-void UserSnapshotServer::RunThread(std::shared_ptr<HandlerThread> handler) {
-    LOG(INFO) << "Entering thread for handler: " << handler->misc_name();
-
-    if (!handler->snapuserd()->Start()) {
-        LOG(ERROR) << " Failed to launch all worker threads";
-    }
-
-    handler->snapuserd()->CloseFds();
-    bool merge_completed = handler->snapuserd()->CheckMergeCompletionStatus();
-    handler->snapuserd()->UnmapBufferRegion();
-
-    auto misc_name = handler->misc_name();
-    LOG(INFO) << "Handler thread about to exit: " << misc_name;
-
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        if (merge_completed) {
-            num_partitions_merge_complete_ += 1;
-            active_merge_threads_ -= 1;
-            WakeupMonitorMergeThread();
-        }
-        handler->SetThreadTerminated();
-        auto iter = FindHandler(&lock, handler->misc_name());
-        if (iter == dm_users_.end()) {
-            // RemoveAndJoinHandler() already removed us from the list, and is
-            // now waiting on a join(), so just return. Additionally, release
-            // all the resources held by snapuserd object which are shared
-            // by worker threads. This should be done when the last reference
-            // of "handler" is released; but we will explicitly release here
-            // to make sure snapuserd object is freed as it is the biggest
-            // consumer of memory in the daemon.
-            handler->FreeResources();
-            LOG(INFO) << "Exiting handler thread to allow for join: " << misc_name;
-            return;
-        }
-
-        LOG(INFO) << "Exiting handler thread and freeing resources: " << misc_name;
-
-        if (handler->snapuserd()->IsAttached()) {
-            handler->thread().detach();
-        }
-
-        // Important: free resources within the lock. This ensures that if
-        // WaitForDelete() is called, the handler is either in the list, or
-        // it's not and its resources are guaranteed to be freed.
-        handler->FreeResources();
-        dm_users_.erase(iter);
-    }
-}
-
 bool UserSnapshotServer::Start(const std::string& socketname) {
     bool start_listening = true;
 
@@ -423,28 +326,10 @@ bool UserSnapshotServer::Run() {
         }
     }
 
-    JoinAllThreads();
+    handlers_->JoinAllThreads();
     return true;
 }
 
-void UserSnapshotServer::JoinAllThreads() {
-    // Acquire the thread list within the lock.
-    std::vector<std::shared_ptr<HandlerThread>> dm_users;
-    {
-        std::lock_guard<std::mutex> guard(lock_);
-        dm_users = std::move(dm_users_);
-    }
-
-    for (auto& client : dm_users) {
-        auto& th = client->thread();
-
-        if (th.joinable()) th.join();
-    }
-
-    stop_monitor_merge_thread_ = true;
-    WakeupMonitorMergeThread();
-}
-
 void UserSnapshotServer::AddWatchedFd(android::base::borrowed_fd fd, int events) {
     struct pollfd p = {};
     p.fd = fd.get();
@@ -506,185 +391,13 @@ std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string&
         perform_verification = false;
     }
 
-    auto snapuserd = std::make_shared<SnapshotHandler>(misc_name, cow_device_path, backing_device,
-                                                       base_path_merge, num_worker_threads,
-                                                       io_uring_enabled_, perform_verification);
-    if (!snapuserd->InitCowDevice()) {
-        LOG(ERROR) << "Failed to initialize Snapuserd";
-        return nullptr;
-    }
-
-    if (!snapuserd->InitializeWorkers()) {
-        LOG(ERROR) << "Failed to initialize workers";
-        return nullptr;
-    }
-
-    auto handler = std::make_shared<HandlerThread>(snapuserd);
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        if (FindHandler(&lock, misc_name) != dm_users_.end()) {
-            LOG(ERROR) << "Handler already exists: " << misc_name;
-            return nullptr;
-        }
-        dm_users_.push_back(handler);
-    }
-    return handler;
-}
-
-bool UserSnapshotServer::StartHandler(const std::shared_ptr<HandlerThread>& handler) {
-    if (handler->snapuserd()->IsAttached()) {
-        LOG(ERROR) << "Handler already attached";
-        return false;
-    }
-
-    handler->snapuserd()->AttachControlDevice();
-
-    handler->thread() = std::thread(std::bind(&UserSnapshotServer::RunThread, this, handler));
-    return true;
-}
-
-bool UserSnapshotServer::StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
-                                    const std::shared_ptr<HandlerThread>& handler) {
-    CHECK(proof_of_lock);
-
-    if (!handler->snapuserd()->IsAttached()) {
-        LOG(ERROR) << "Handler not attached to dm-user - Merge thread cannot be started";
-        return false;
-    }
-
-    handler->snapuserd()->MonitorMerge();
-
-    if (!is_merge_monitor_started_.has_value()) {
-        std::thread(&UserSnapshotServer::MonitorMerge, this).detach();
-        is_merge_monitor_started_ = true;
-    }
-
-    merge_handlers_.push(handler);
-    WakeupMonitorMergeThread();
-    return true;
-}
-
-auto UserSnapshotServer::FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
-                                     const std::string& misc_name) -> HandlerList::iterator {
-    CHECK(proof_of_lock);
-
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        if ((*iter)->misc_name() == misc_name) {
-            return iter;
-        }
-    }
-    return dm_users_.end();
-}
-
-void UserSnapshotServer::TerminateMergeThreads(std::lock_guard<std::mutex>* proof_of_lock) {
-    CHECK(proof_of_lock);
-
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        if (!(*iter)->ThreadTerminated()) {
-            (*iter)->snapuserd()->NotifyIOTerminated();
-        }
-    }
-}
-
-std::string UserSnapshotServer::GetMergeStatus(const std::shared_ptr<HandlerThread>& handler) {
-    return handler->snapuserd()->GetMergeStatus();
-}
-
-double UserSnapshotServer::GetMergePercentage(std::lock_guard<std::mutex>* proof_of_lock) {
-    CHECK(proof_of_lock);
-    double percentage = 0.0;
-    int n = 0;
-
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        auto& th = (*iter)->thread();
-        if (th.joinable()) {
-            // Merge percentage by individual partitions wherein merge is still
-            // in-progress
-            percentage += (*iter)->snapuserd()->GetMergePercentage();
-            n += 1;
-        }
-    }
-
-    // Calculate final merge including those partitions where merge was already
-    // completed - num_partitions_merge_complete_ will track them when each
-    // thread exists in RunThread.
-    int total_partitions = n + num_partitions_merge_complete_;
-
-    if (total_partitions) {
-        percentage = ((num_partitions_merge_complete_ * 100.0) + percentage) / total_partitions;
-    }
-
-    LOG(DEBUG) << "Merge %: " << percentage
-               << " num_partitions_merge_complete_: " << num_partitions_merge_complete_
-               << " total_partitions: " << total_partitions << " n: " << n;
-    return percentage;
-}
-
-bool UserSnapshotServer::RemoveAndJoinHandler(const std::string& misc_name) {
-    std::shared_ptr<HandlerThread> handler;
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-
-        auto iter = FindHandler(&lock, misc_name);
-        if (iter == dm_users_.end()) {
-            // Client already deleted.
-            return true;
-        }
-        handler = std::move(*iter);
-        dm_users_.erase(iter);
-    }
-
-    auto& th = handler->thread();
-    if (th.joinable()) {
-        th.join();
-    }
-    return true;
-}
-
-void UserSnapshotServer::WakeupMonitorMergeThread() {
-    uint64_t notify = 1;
-    ssize_t rc = TEMP_FAILURE_RETRY(write(monitor_merge_event_fd_.get(), &notify, sizeof(notify)));
-    if (rc < 0) {
-        PLOG(FATAL) << "failed to notify monitor merge thread";
-    }
-}
-
-void UserSnapshotServer::MonitorMerge() {
-    while (!stop_monitor_merge_thread_) {
-        uint64_t testVal;
-        ssize_t ret =
-                TEMP_FAILURE_RETRY(read(monitor_merge_event_fd_.get(), &testVal, sizeof(testVal)));
-        if (ret == -1) {
-            PLOG(FATAL) << "Failed to read from eventfd";
-        } else if (ret == 0) {
-            LOG(FATAL) << "Hit EOF on eventfd";
-        }
-
-        LOG(INFO) << "MonitorMerge: active-merge-threads: " << active_merge_threads_;
-        {
-            std::lock_guard<std::mutex> lock(lock_);
-            while (active_merge_threads_ < kMaxMergeThreads && merge_handlers_.size() > 0) {
-                auto handler = merge_handlers_.front();
-                merge_handlers_.pop();
-
-                if (!handler->snapuserd()) {
-                    LOG(INFO) << "MonitorMerge: skipping deleted handler: " << handler->misc_name();
-                    continue;
-                }
-
-                LOG(INFO) << "Starting merge for partition: "
-                          << handler->snapuserd()->GetMiscName();
-                handler->snapuserd()->InitiateMerge();
-                active_merge_threads_ += 1;
-            }
-        }
-    }
-
-    LOG(INFO) << "Exiting MonitorMerge: size: " << merge_handlers_.size();
+    return handlers_->AddHandler(misc_name, cow_device_path, backing_device, base_path_merge,
+                                 num_worker_threads, io_uring_enabled_, perform_verification);
 }
 
 bool UserSnapshotServer::WaitForSocket() {
-    auto scope_guard = android::base::make_scope_guard([this]() -> void { JoinAllThreads(); });
+    auto scope_guard =
+            android::base::make_scope_guard([this]() -> void { handlers_->JoinAllThreads(); });
 
     auto socket_path = ANDROID_SOCKET_DIR "/"s + kSnapuserdSocketProxy;
 
@@ -781,21 +494,8 @@ bool UserSnapshotServer::RunForSocketHandoff() {
     return true;
 }
 
-bool UserSnapshotServer::UpdateVerification(std::lock_guard<std::mutex>* proof_of_lock) {
-    CHECK(proof_of_lock);
-
-    bool status = true;
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        auto& th = (*iter)->thread();
-        if (th.joinable() && status) {
-            status = (*iter)->snapuserd()->CheckPartitionVerification() && status;
-        } else {
-            // return immediately if there is a failure
-            return false;
-        }
-    }
-
-    return status;
+bool UserSnapshotServer::StartHandler(const std::string& misc_name) {
+    return handlers_->StartHandler(misc_name);
 }
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index 12c3903c495c..ae5190391dfa 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -31,6 +31,7 @@
 #include <vector>
 
 #include <android-base/unique_fd.h>
+#include "handler_manager.h"
 #include "snapuserd_core.h"
 
 namespace android {
@@ -54,33 +55,6 @@ enum class DaemonOps {
     INVALID,
 };
 
-class HandlerThread {
-  public:
-    explicit HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd);
-
-    void FreeResources() {
-        // Each worker thread holds a reference to snapuserd.
-        // Clear them so that all the resources
-        // held by snapuserd is released
-        if (snapuserd_) {
-            snapuserd_->FreeResources();
-            snapuserd_ = nullptr;
-        }
-    }
-    const std::shared_ptr<SnapshotHandler>& snapuserd() const { return snapuserd_; }
-    std::thread& thread() { return thread_; }
-
-    const std::string& misc_name() const { return misc_name_; }
-    bool ThreadTerminated() { return thread_terminated_; }
-    void SetThreadTerminated() { thread_terminated_ = true; }
-
-  private:
-    std::thread thread_;
-    std::shared_ptr<SnapshotHandler> snapuserd_;
-    std::string misc_name_;
-    bool thread_terminated_ = false;
-};
-
 class UserSnapshotServer {
   private:
     android::base::unique_fd sockfd_;
@@ -88,21 +62,12 @@ class UserSnapshotServer {
     volatile bool received_socket_signal_ = false;
     std::vector<struct pollfd> watched_fds_;
     bool is_socket_present_ = false;
-    int num_partitions_merge_complete_ = 0;
-    int active_merge_threads_ = 0;
-    bool stop_monitor_merge_thread_ = false;
     bool is_server_running_ = false;
     bool io_uring_enabled_ = false;
-    std::optional<bool> is_merge_monitor_started_;
-
-    android::base::unique_fd monitor_merge_event_fd_;
+    std::unique_ptr<ISnapshotHandlerManager> handlers_;
 
     std::mutex lock_;
 
-    using HandlerList = std::vector<std::shared_ptr<HandlerThread>>;
-    HandlerList dm_users_;
-    std::queue<std::shared_ptr<HandlerThread>> merge_handlers_;
-
     void AddWatchedFd(android::base::borrowed_fd fd, int events);
     void AcceptClient();
     bool HandleClient(android::base::borrowed_fd fd, int revents);
@@ -111,28 +76,15 @@ class UserSnapshotServer {
     bool Receivemsg(android::base::borrowed_fd fd, const std::string& str);
 
     void ShutdownThreads();
-    bool RemoveAndJoinHandler(const std::string& control_device);
     DaemonOps Resolveop(std::string& input);
     std::string GetDaemonStatus();
     void Parsemsg(std::string const& msg, const char delim, std::vector<std::string>& out);
 
     bool IsTerminating() { return terminating_; }
 
-    void RunThread(std::shared_ptr<HandlerThread> handler);
-    void MonitorMerge();
-
     void JoinAllThreads();
     bool StartWithSocket(bool start_listening);
 
-    // Find a HandlerThread within a lock.
-    HandlerList::iterator FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
-                                      const std::string& misc_name);
-
-    double GetMergePercentage(std::lock_guard<std::mutex>* proof_of_lock);
-    void TerminateMergeThreads(std::lock_guard<std::mutex>* proof_of_lock);
-
-    bool UpdateVerification(std::lock_guard<std::mutex>* proof_of_lock);
-
   public:
     UserSnapshotServer();
     ~UserSnapshotServer();
@@ -147,12 +99,8 @@ class UserSnapshotServer {
                                               const std::string& cow_device_path,
                                               const std::string& backing_device,
                                               const std::string& base_path_merge);
-    bool StartHandler(const std::shared_ptr<HandlerThread>& handler);
-    bool StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
-                    const std::shared_ptr<HandlerThread>& handler);
-    std::string GetMergeStatus(const std::shared_ptr<HandlerThread>& handler);
+    bool StartHandler(const std::string& misc_name);
 
-    void WakeupMonitorMergeThread();
     void SetTerminating() { terminating_ = true; }
     void ReceivedSocketSignal() { received_socket_signal_ = true; }
     void SetServerRunning() { is_server_running_ = true; }

From f84f9c319e5a05fa6bfed9730ea6b9d28407a84b Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 14 Mar 2023 09:09:48 -0700
Subject: [PATCH 0169/1487] snapuserd: Remove DaemonOps.

These are only used for a single switch statement. Just compare the
input strings instead.

Bug: 269361087
Test: builds, ota applies
Ignore-AOSP-First: cherry-pick from aosp
Change-Id: Ib90ae55309ea99c181585c64ed2ac814e5ed6c72
Merged-In: Ib90ae55309ea99c181585c64ed2ac814e5ed6c72
---
 .../user-space-merge/snapuserd_server.cpp     | 218 ++++++++----------
 .../user-space-merge/snapuserd_server.h       |  16 --
 2 files changed, 94 insertions(+), 140 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index cc8115f5f800..d87990aca2a8 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -45,22 +45,6 @@ using namespace std::string_literals;
 using android::base::borrowed_fd;
 using android::base::unique_fd;
 
-DaemonOps UserSnapshotServer::Resolveop(std::string& input) {
-    if (input == "init") return DaemonOps::INIT;
-    if (input == "start") return DaemonOps::START;
-    if (input == "stop") return DaemonOps::STOP;
-    if (input == "query") return DaemonOps::QUERY;
-    if (input == "delete") return DaemonOps::DELETE;
-    if (input == "detach") return DaemonOps::DETACH;
-    if (input == "supports") return DaemonOps::SUPPORTS;
-    if (input == "initiate_merge") return DaemonOps::INITIATE;
-    if (input == "merge_percent") return DaemonOps::PERCENTAGE;
-    if (input == "getstatus") return DaemonOps::GETSTATUS;
-    if (input == "update-verify") return DaemonOps::UPDATE_VERIFY;
-
-    return DaemonOps::INVALID;
-}
-
 UserSnapshotServer::UserSnapshotServer() {
     terminating_ = false;
     handlers_ = std::make_unique<SnapshotHandlerManager>();
@@ -132,132 +116,118 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
 
     std::vector<std::string> out;
     Parsemsg(str, delim, out);
-    DaemonOps op = Resolveop(out[0]);
-
-    switch (op) {
-        case DaemonOps::INIT: {
-            // Message format:
-            // init,<misc_name>,<cow_device_path>,<backing_device>,<base_path_merge>
-            //
-            // Reads the metadata and send the number of sectors
-            if (out.size() != 5) {
-                LOG(ERROR) << "Malformed init message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
 
-            auto handler = AddHandler(out[1], out[2], out[3], out[4]);
-            if (!handler) {
-                return Sendmsg(fd, "fail");
-            }
-
-            auto retval = "success," + std::to_string(handler->snapuserd()->GetNumSectors());
-            return Sendmsg(fd, retval);
+    const auto& cmd = out[0];
+    if (cmd == "init") {
+        // Message format:
+        // init,<misc_name>,<cow_device_path>,<backing_device>,<base_path_merge>
+        //
+        // Reads the metadata and send the number of sectors
+        if (out.size() != 5) {
+            LOG(ERROR) << "Malformed init message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::START: {
-            // Message format:
-            // start,<misc_name>
-            //
-            // Start the new thread which binds to dm-user misc device
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed start message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
 
-            if (!handlers_->StartHandler(out[1])) {
-                return Sendmsg(fd, "fail");
-            }
-            return Sendmsg(fd, "success");
-        }
-        case DaemonOps::STOP: {
-            // Message format: stop
-            //
-            // Stop all the threads gracefully and then shutdown the
-            // main thread
-            SetTerminating();
-            ShutdownThreads();
-            return true;
+        auto handler = AddHandler(out[1], out[2], out[3], out[4]);
+        if (!handler) {
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::QUERY: {
-            // Message format: query
-            //
-            // As part of transition, Second stage daemon will be
-            // created before terminating the first stage daemon. Hence,
-            // for a brief period client may have to distiguish between
-            // first stage daemon and second stage daemon.
-            //
-            // Second stage daemon is marked as active and hence will
-            // be ready to receive control message.
-            return Sendmsg(fd, GetDaemonStatus());
+
+        auto retval = "success," + std::to_string(handler->snapuserd()->GetNumSectors());
+        return Sendmsg(fd, retval);
+    } else if (cmd == "start") {
+        // Message format:
+        // start,<misc_name>
+        //
+        // Start the new thread which binds to dm-user misc device
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed start message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::DELETE: {
-            // Message format:
-            // delete,<misc_name>
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (!handlers_->DeleteHandler(out[1])) {
-                return Sendmsg(fd, "fail");
-            }
-            return Sendmsg(fd, "success");
+
+        if (!handlers_->StartHandler(out[1])) {
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::DETACH: {
-            handlers_->TerminateMergeThreads();
-            terminating_ = true;
-            return true;
+        return Sendmsg(fd, "success");
+    } else if (cmd == "stop") {
+        // Message format: stop
+        //
+        // Stop all the threads gracefully and then shutdown the
+        // main thread
+        SetTerminating();
+        ShutdownThreads();
+        return true;
+    } else if (cmd == "query") {
+        // Message format: query
+        //
+        // As part of transition, Second stage daemon will be
+        // created before terminating the first stage daemon. Hence,
+        // for a brief period client may have to distiguish between
+        // first stage daemon and second stage daemon.
+        //
+        // Second stage daemon is marked as active and hence will
+        // be ready to receive control message.
+        return Sendmsg(fd, GetDaemonStatus());
+    } else if (cmd == "delete") {
+        // Message format:
+        // delete,<misc_name>
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::SUPPORTS: {
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed supports message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (out[1] == "second_stage_socket_handoff") {
-                return Sendmsg(fd, "success");
-            }
+        if (!handlers_->DeleteHandler(out[1])) {
             return Sendmsg(fd, "fail");
         }
-        case DaemonOps::INITIATE: {
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed initiate-merge message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (out[0] == "initiate_merge") {
-                if (!handlers_->InitiateMerge(out[1])) {
-                    return Sendmsg(fd, "fail");
-                }
-                return Sendmsg(fd, "success");
-            }
+        return Sendmsg(fd, "success");
+    } else if (cmd == "detach") {
+        handlers_->TerminateMergeThreads();
+        terminating_ = true;
+        return true;
+    } else if (cmd == "supports") {
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed supports message, " << out.size() << " parts";
             return Sendmsg(fd, "fail");
         }
-        case DaemonOps::PERCENTAGE: {
-            double percentage = handlers_->GetMergePercentage();
-
-            return Sendmsg(fd, std::to_string(percentage));
+        if (out[1] == "second_stage_socket_handoff") {
+            return Sendmsg(fd, "success");
         }
-        case DaemonOps::GETSTATUS: {
-            // Message format:
-            // getstatus,<misc_name>
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
-                return Sendmsg(fd, "snapshot-merge-failed");
-            }
-            auto status = handlers_->GetMergeStatus(out[1]);
-            if (status.empty()) {
-                return Sendmsg(fd, "snapshot-merge-failed");
-            }
-            return Sendmsg(fd, status);
+        return Sendmsg(fd, "fail");
+    } else if (cmd == "initiate_merge") {
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed initiate-merge message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::UPDATE_VERIFY: {
-            if (!handlers_->GetVerificationStatus()) {
+        if (out[0] == "initiate_merge") {
+            if (!handlers_->InitiateMerge(out[1])) {
                 return Sendmsg(fd, "fail");
             }
             return Sendmsg(fd, "success");
         }
-        default: {
-            LOG(ERROR) << "Received unknown message type from client";
-            Sendmsg(fd, "fail");
-            return false;
+        return Sendmsg(fd, "fail");
+    } else if (cmd == "merge_percent") {
+        double percentage = handlers_->GetMergePercentage();
+        return Sendmsg(fd, std::to_string(percentage));
+    } else if (cmd == "getstatus") {
+        // Message format:
+        // getstatus,<misc_name>
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
+            return Sendmsg(fd, "snapshot-merge-failed");
+        }
+        auto status = handlers_->GetMergeStatus(out[1]);
+        if (status.empty()) {
+            return Sendmsg(fd, "snapshot-merge-failed");
         }
+        return Sendmsg(fd, status);
+    } else if (cmd == "update-verify") {
+        if (!handlers_->GetVerificationStatus()) {
+            return Sendmsg(fd, "fail");
+        }
+        return Sendmsg(fd, "success");
+    } else {
+        LOG(ERROR) << "Received unknown message type from client";
+        Sendmsg(fd, "fail");
+        return false;
     }
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index ae5190391dfa..988c01a99ba3 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -40,21 +40,6 @@ namespace snapshot {
 static constexpr uint32_t kMaxPacketSize = 512;
 static constexpr uint8_t kMaxMergeThreads = 2;
 
-enum class DaemonOps {
-    INIT,
-    START,
-    QUERY,
-    STOP,
-    DELETE,
-    DETACH,
-    SUPPORTS,
-    INITIATE,
-    PERCENTAGE,
-    GETSTATUS,
-    UPDATE_VERIFY,
-    INVALID,
-};
-
 class UserSnapshotServer {
   private:
     android::base::unique_fd sockfd_;
@@ -76,7 +61,6 @@ class UserSnapshotServer {
     bool Receivemsg(android::base::borrowed_fd fd, const std::string& str);
 
     void ShutdownThreads();
-    DaemonOps Resolveop(std::string& input);
     std::string GetDaemonStatus();
     void Parsemsg(std::string const& msg, const char delim, std::vector<std::string>& out);
 

From 269e99f9558ae332e10329451fc51dc6698375a0 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 14 Mar 2023 10:57:47 -0700
Subject: [PATCH 0170/1487] snapuserd: Run snapuserd threads in-process.

This removes the temporary daemon and socket and instead directly embeds
SnapshotHandlerManager. We can also remove the test flags for io_uring
as with this they're no longer necessary.

Bug: 269361087
Test: snapuserd_test
Ignore-AOSP-First: cherry-pick from aosp
Change-Id: I728186d9bc90c98fabd76d3f86569840488ada96
Merged-In: I728186d9bc90c98fabd76d3f86569840488ada96
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       | 15 ++--
 .../user-space-merge/handler_manager.cpp      |  3 +
 .../user-space-merge/snapuserd_core.cpp       |  5 --
 .../user-space-merge/snapuserd_server.cpp     |  3 -
 .../user-space-merge/snapuserd_test.cpp       | 75 ++++++-------------
 5 files changed, 33 insertions(+), 68 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 65f3d6d297ed..9fe567acbc7e 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -165,7 +165,7 @@ cc_binary {
 }
 
 cc_test {
-    name: "cow_snapuserd_test",
+    name: "snapuserd_test_legacy",
     defaults: [
         "fs_mgr_defaults",
         "libsnapshot_cow_defaults",
@@ -217,16 +217,17 @@ cc_test {
     ],
     static_libs: [
         "libbrotli",
-        "libgtest",
-        "libsnapshot_cow",
-        "libsnapshot_snapuserd",
         "libcutils_sockets",
-        "libz",
-        "libfs_mgr",
         "libdm",
         "libext4_utils",
-        "liburing",
+        "libfs_mgr",
         "libgflags",
+        "libgtest",
+        "libsnapshot_cow",
+        "libsnapshot_snapuserd",
+        "libsnapuserd",
+        "liburing",
+        "libz",
     ],
     include_dirs: ["bionic/libc/kernel"],
     header_libs: [
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index c5150c411d02..bdba5c0cc3ab 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -25,6 +25,9 @@ namespace snapshot {
 
 static constexpr uint8_t kMaxMergeThreads = 2;
 
+HandlerThread::HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd)
+    : snapuserd_(snapuserd), misc_name_(snapuserd_->GetMiscName()) {}
+
 void HandlerThread::FreeResources() {
     // Each worker thread holds a reference to snapuserd.
     // Clear them so that all the resources
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index c8a5cc584a28..8e1212b7b3ce 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -421,11 +421,6 @@ bool SnapshotHandler::IsIouringSupported() {
     struct utsname uts;
     unsigned int major, minor;
 
-    if (android::base::GetBoolProperty("snapuserd.test.io_uring.force_disable", false)) {
-        SNAP_LOG(INFO) << "io_uring disabled for testing";
-        return false;
-    }
-
     if ((uname(&uts) != 0) || (sscanf(uts.release, "%u.%u", &major, &minor) != 2)) {
         SNAP_LOG(ERROR) << "Could not parse the kernel version from uname. "
                         << " io_uring not supported";
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index d87990aca2a8..c953f1a053bd 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -83,9 +83,6 @@ void UserSnapshotServer::ShutdownThreads() {
     handlers_->JoinAllThreads();
 }
 
-HandlerThread::HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd)
-    : snapuserd_(snapuserd), misc_name_(snapuserd_->GetMiscName()) {}
-
 bool UserSnapshotServer::Sendmsg(android::base::borrowed_fd fd, const std::string& msg) {
     ssize_t ret = TEMP_FAILURE_RETRY(send(fd.get(), msg.data(), msg.size(), MSG_NOSIGNAL));
     if (ret < 0) {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index ef3689f61f6b..efe0c1443215 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -37,9 +37,9 @@
 #include <libdm/dm.h>
 #include <libdm/loop_control.h>
 #include <libsnapshot/cow_writer.h>
-#include <snapuserd/snapuserd_client.h>
 #include <storage_literals/storage_literals.h>
 
+#include "handler_manager.h"
 #include "snapuserd_core.h"
 
 DEFINE_string(force_config, "", "Force testing mode with iouring disabled");
@@ -54,8 +54,6 @@ using namespace std::chrono_literals;
 using namespace android::dm;
 using namespace std;
 
-static constexpr char kSnapuserdSocketTest[] = "snapuserdTest";
-
 class Tempdevice {
   public:
     Tempdevice(const std::string& name, const DmTable& table)
@@ -68,15 +66,15 @@ class Tempdevice {
     }
     ~Tempdevice() {
         if (valid_) {
-            dm_.DeleteDevice(name_);
+            dm_.DeleteDeviceIfExists(name_);
         }
     }
     bool Destroy() {
         if (!valid_) {
-            return false;
+            return true;
         }
         valid_ = false;
-        return dm_.DeleteDevice(name_);
+        return dm_.DeleteDeviceIfExists(name_);
     }
     const std::string& path() const { return path_; }
     const std::string& name() const { return name_; }
@@ -139,7 +137,6 @@ class SnapuserdTest : public ::testing::Test {
     void SetDeviceControlName();
     void InitDaemon();
     void CreateDmUserDevice();
-    void StartSnapuserdDaemon();
 
     unique_ptr<LoopDevice> base_loop_;
     unique_ptr<Tempdevice> dmuser_dev_;
@@ -149,9 +146,9 @@ class SnapuserdTest : public ::testing::Test {
 
     unique_fd base_fd_;
     std::unique_ptr<TemporaryFile> cow_system_;
-    std::unique_ptr<SnapuserdClient> client_;
     std::unique_ptr<uint8_t[]> orig_buffer_;
     std::unique_ptr<uint8_t[]> merged_buffer_;
+    SnapshotHandlerManager handlers_;
     bool setup_ok_ = false;
     bool merge_ok_ = false;
     size_t size_ = 100_MiB;
@@ -181,9 +178,9 @@ void SnapuserdTest::Shutdown() {
     ASSERT_TRUE(dmuser_dev_->Destroy());
 
     auto misc_device = "/dev/dm-user/" + system_device_ctrl_name_;
-    ASSERT_TRUE(client_->WaitForDeviceDelete(system_device_ctrl_name_));
+    ASSERT_TRUE(handlers_.DeleteHandler(system_device_ctrl_name_));
     ASSERT_TRUE(android::fs_mgr::WaitForFileDeleted(misc_device, 10s));
-    ASSERT_TRUE(client_->DetachSnapuserd());
+    handlers_.TerminateMergeThreads();
 }
 
 bool SnapuserdTest::SetupDefault() {
@@ -218,8 +215,6 @@ bool SnapuserdTest::SetupCopyOverlap_2() {
 bool SnapuserdTest::SetupDaemon() {
     SetDeviceControlName();
 
-    StartSnapuserdDaemon();
-
     CreateDmUserDevice();
     InitCowDevice();
     InitDaemon();
@@ -229,20 +224,6 @@ bool SnapuserdTest::SetupDaemon() {
     return setup_ok_;
 }
 
-void SnapuserdTest::StartSnapuserdDaemon() {
-    pid_t pid = fork();
-    ASSERT_GE(pid, 0);
-    if (pid == 0) {
-        std::string arg0 = "/system/bin/snapuserd";
-        std::string arg1 = "-socket="s + kSnapuserdSocketTest;
-        char* const argv[] = {arg0.data(), arg1.data(), nullptr};
-        ASSERT_GE(execv(arg0.c_str(), argv), 0);
-    } else {
-        client_ = SnapuserdClient::Connect(kSnapuserdSocketTest, 10s);
-        ASSERT_NE(client_, nullptr);
-    }
-}
-
 void SnapuserdTest::CreateBaseDevice() {
     unique_fd rnd_fd;
 
@@ -591,9 +572,17 @@ void SnapuserdTest::CreateCowDevice() {
 }
 
 void SnapuserdTest::InitCowDevice() {
-    uint64_t num_sectors = client_->InitDmUserCow(system_device_ctrl_name_, cow_system_->path,
-                                                  base_loop_->device(), base_loop_->device());
-    ASSERT_NE(num_sectors, 0);
+    bool use_iouring = true;
+    if (FLAGS_force_config == "iouring_disabled") {
+        use_iouring = false;
+    }
+
+    auto handler =
+            handlers_.AddHandler(system_device_ctrl_name_, cow_system_->path, base_loop_->device(),
+                                 base_loop_->device(), 1, use_iouring, false);
+    ASSERT_NE(handler, nullptr);
+    ASSERT_NE(handler->snapuserd(), nullptr);
+    ASSERT_NE(handler->snapuserd()->GetNumSectors(), 0);
 }
 
 void SnapuserdTest::SetDeviceControlName() {
@@ -631,13 +620,12 @@ void SnapuserdTest::CreateDmUserDevice() {
 }
 
 void SnapuserdTest::InitDaemon() {
-    bool ok = client_->AttachDmUser(system_device_ctrl_name_);
-    ASSERT_TRUE(ok);
+    ASSERT_TRUE(handlers_.StartHandler(system_device_ctrl_name_));
 }
 
 void SnapuserdTest::CheckMergeCompletion() {
     while (true) {
-        double percentage = client_->GetMergePercent();
+        double percentage = handlers_.GetMergePercentage();
         if ((int)percentage == 100) {
             break;
         }
@@ -652,8 +640,6 @@ void SnapuserdTest::SetupImpl() {
 
     SetDeviceControlName();
 
-    StartSnapuserdDaemon();
-
     CreateDmUserDevice();
     InitCowDevice();
     InitDaemon();
@@ -669,8 +655,7 @@ bool SnapuserdTest::Merge() {
 }
 
 void SnapuserdTest::StartMerge() {
-    bool ok = client_->InitiateMerge(system_device_ctrl_name_);
-    ASSERT_TRUE(ok);
+    ASSERT_TRUE(handlers_.InitiateMerge(system_device_ctrl_name_));
 }
 
 void SnapuserdTest::ValidateMerge() {
@@ -684,7 +669,6 @@ void SnapuserdTest::SimulateDaemonRestart() {
     Shutdown();
     std::this_thread::sleep_for(500ms);
     SetDeviceControlName();
-    StartSnapuserdDaemon();
     CreateDmUserDevice();
     InitCowDevice();
     InitDaemon();
@@ -844,20 +828,5 @@ int main(int argc, char** argv) {
 
     gflags::ParseCommandLineFlags(&argc, &argv, false);
 
-    android::base::SetProperty("ctl.stop", "snapuserd");
-
-    if (FLAGS_force_config == "iouring_disabled") {
-        if (!android::base::SetProperty("snapuserd.test.io_uring.force_disable", "1")) {
-            return testing::AssertionFailure()
-                   << "Failed to disable property: snapuserd.test.io_uring.disabled";
-        }
-    }
-
-    int ret = RUN_ALL_TESTS();
-
-    if (FLAGS_force_config == "iouring_disabled") {
-        android::base::SetProperty("snapuserd.test.io_uring.force_disable", "0");
-    }
-
-    return ret;
+    return RUN_ALL_TESTS();
 }

From 15632504107b40e0c15c1c9efb0f1d19e991a02a Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 10 Jul 2023 22:03:11 +0000
Subject: [PATCH 0171/1487] NetlinkEvent: trivial simplification.

free(NULL) is defined as a no-op. Don't overcomplicate things.

Bug: http://b/287138549
Test: treehugger
Change-Id: I9ae532a71f986d9468f191972a9b7acf6e709d13
---
 libsysutils/src/NetlinkEvent.cpp | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/libsysutils/src/NetlinkEvent.cpp b/libsysutils/src/NetlinkEvent.cpp
index cd9db54fa6f4..55bbe46e1a85 100644
--- a/libsysutils/src/NetlinkEvent.cpp
+++ b/libsysutils/src/NetlinkEvent.cpp
@@ -150,15 +150,10 @@ NetlinkEvent::NetlinkEvent() {
 }
 
 NetlinkEvent::~NetlinkEvent() {
-    int i;
-    if (mPath)
-        free(mPath);
-    if (mSubsystem)
-        free(mSubsystem);
-    for (i = 0; i < NL_PARAMS_MAX; i++) {
-        if (!mParams[i])
-            break;
-        free(mParams[i]);
+    free(mPath);
+    free(mSubsystem);
+    for (auto param : mParams) {
+        free(param);
     }
 }
 

From fac2b18fffee638018b6175c98e99f78dac8f183 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers@google.com>
Date: Mon, 10 Jul 2023 23:13:44 +0000
Subject: [PATCH 0172/1487] init.rc: merge the zygote-start actions

The three actions for "zygote-start" are identical except for their
property triggers.  This seems to have been left over from when Android
supported both File Based Encryption (FBE) and Full Disk Encryption
(FDE), causing there to be four possible encryption states:

- ro.crypto.state=unsupported (No encryption configured)
- ro.crypto.state=encrypted && ro.crypto.type=file (FBE enabled)
- ro.crypto.state=unencrypted (FDE supported but disabled)
- ro.crypto.state=encrypted && ro.crypto.type=block (FDE enabled)

It seems that the reason the zygote-start action was duplicated three
times was to exclude the "FDE enabled" case, which could only be done by
explicitly listing the other three cases.

However, now that FDE is no longer supported, only the first two cases
are possible.  Therefore, zygote-start can just be the whole trigger.

Bug: 208476087
Test: presubmit
Change-Id: Icd6e4b0d2fb3f9f20595c0af4e2e35350564da8d
---
 rootdir/init.rc | 22 ++--------------------
 1 file changed, 2 insertions(+), 20 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index a8b78d5d8025..4f3959f7cdca 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -533,7 +533,7 @@ on late-init
     # Should be before netd, but after apex, properties and logging is available.
     trigger load_bpf_programs
 
-    # Now we can start zygote for devices with file based encryption
+    # Now we can start zygote.
     trigger zygote-start
 
     # Remove a file to wake up anything waiting for firmware.
@@ -1056,25 +1056,7 @@ on post-fs-data
 
 # It is recommended to put unnecessary data/ initialization from post-fs-data
 # to start-zygote in device's init.rc to unblock zygote start.
-on zygote-start && property:ro.crypto.state=unencrypted
-    wait_for_prop odsign.verification.done 1
-    # A/B update verifier that marks a successful boot.
-    exec_start update_verifier_nonencrypted
-    start statsd
-    start netd
-    start zygote
-    start zygote_secondary
-
-on zygote-start && property:ro.crypto.state=unsupported
-    wait_for_prop odsign.verification.done 1
-    # A/B update verifier that marks a successful boot.
-    exec_start update_verifier_nonencrypted
-    start statsd
-    start netd
-    start zygote
-    start zygote_secondary
-
-on zygote-start && property:ro.crypto.state=encrypted && property:ro.crypto.type=file
+on zygote-start
     wait_for_prop odsign.verification.done 1
     # A/B update verifier that marks a successful boot.
     exec_start update_verifier_nonencrypted

From 6e8e8ac71fbc3bf09289bbf2aaee0bc12634578e Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers@google.com>
Date: Mon, 10 Jul 2023 23:48:38 +0000
Subject: [PATCH 0173/1487] init.rc: start update_verifier instead of
 update_verifier_nonencrypted

The "update_verifier_nonencrypted" service is being replaced with simply
"update_verifier", so update init.rc accordingly.

Bug: 208476087
Test: presubmit
Change-Id: I58f3fb25167ff7d3679c72e5e9c012f02fa5b516
---
 rootdir/init.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 4f3959f7cdca..cdf67b9c06d6 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1059,7 +1059,7 @@ on post-fs-data
 on zygote-start
     wait_for_prop odsign.verification.done 1
     # A/B update verifier that marks a successful boot.
-    exec_start update_verifier_nonencrypted
+    exec_start update_verifier
     start statsd
     start netd
     start zygote

From a0d2401d23b231d4b48e9ec6ee0e58fded421e13 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 10 Jul 2023 16:45:54 -0700
Subject: [PATCH 0174/1487] Mocking get_uint_var()

Changing implementation to have mock fastboot driver return a the
sparse_limit rather than modifying the variable inside of flashing plan

Test: fastboot_test
Change-Id: I850ccd5bd09b6a8479ccc8cf7bf1d227abb87e3a
---
 fastboot/fastboot.cpp                | 23 +++++++++++++----------
 fastboot/fastboot_driver.h           |  2 +-
 fastboot/fastboot_driver_interface.h |  4 ++++
 fastboot/fastboot_driver_mock.h      |  7 ++++---
 4 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 6fc6f5ff742d..eee0e93d031e 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -76,6 +76,7 @@
 #include "constants.h"
 #include "diagnose_usb.h"
 #include "fastboot_driver.h"
+#include "fastboot_driver_interface.h"
 #include "fs.h"
 #include "storage.h"
 #include "super_flash_helper.h"
@@ -996,7 +997,7 @@ static std::vector<SparsePtr> load_sparse_files(int fd, int64_t max_size) {
     return resparse_file(s.get(), max_size);
 }
 
-static uint64_t get_uint_var(const char* var_name) {
+static uint64_t get_uint_var(const char* var_name, fastboot::IFastBootDriver* fb) {
     std::string value_str;
     if (fb->GetVar(var_name, &value_str) != fastboot::SUCCESS || value_str.empty()) {
         verbose("target didn't report %s", var_name);
@@ -1021,7 +1022,7 @@ int64_t get_sparse_limit(int64_t size, const FlashingPlan* fp) {
         // Unlimited, so see what the target device's limit is.
         // TODO: shouldn't we apply this limit even if you've used -S?
         if (target_sparse_limit == -1) {
-            target_sparse_limit = static_cast<int64_t>(get_uint_var("max-download-size"));
+            target_sparse_limit = static_cast<int64_t>(get_uint_var("max-download-size", fp->fb));
         }
         if (target_sparse_limit > 0) {
             limit = target_sparse_limit;
@@ -1420,8 +1421,9 @@ bool is_retrofit_device() {
 
 // Fetch a partition from the device to a given fd. This is a wrapper over FetchToFd to fetch
 // the full image.
-static uint64_t fetch_partition(const std::string& partition, borrowed_fd fd) {
-    uint64_t fetch_size = get_uint_var(FB_VAR_MAX_FETCH_SIZE);
+static uint64_t fetch_partition(const std::string& partition, borrowed_fd fd,
+                                fastboot::IFastBootDriver* fb) {
+    uint64_t fetch_size = get_uint_var(FB_VAR_MAX_FETCH_SIZE, fb);
     if (fetch_size == 0) {
         die("Unable to get %s. Device does not support fetch command.", FB_VAR_MAX_FETCH_SIZE);
     }
@@ -1443,17 +1445,18 @@ static uint64_t fetch_partition(const std::string& partition, borrowed_fd fd) {
 }
 
 static void do_fetch(const std::string& partition, const std::string& slot_override,
-                     const std::string& outfile) {
+                     const std::string& outfile, fastboot::IFastBootDriver* fb) {
     unique_fd fd(TEMP_FAILURE_RETRY(
             open(outfile.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_BINARY, 0644)));
-    auto fetch = std::bind(fetch_partition, _1, borrowed_fd(fd));
+    auto fetch = std::bind(fetch_partition, _1, borrowed_fd(fd), fb);
     do_for_partitions(partition, slot_override, fetch, false /* force slot */);
 }
 
 // Return immediately if not flashing a vendor boot image. If flashing a vendor boot image,
 // repack vendor_boot image with an updated ramdisk. After execution, buf is set
 // to the new image to flash, and return value is the real partition name to flash.
-static std::string repack_ramdisk(const char* pname, struct fastboot_buffer* buf) {
+static std::string repack_ramdisk(const char* pname, struct fastboot_buffer* buf,
+                                  fastboot::IFastBootDriver* fb) {
     std::string_view pname_sv{pname};
 
     if (!android::base::StartsWith(pname_sv, "vendor_boot:") &&
@@ -1471,7 +1474,7 @@ static std::string repack_ramdisk(const char* pname, struct fastboot_buffer* buf
     std::string ramdisk(pname_sv.substr(pname_sv.find(':') + 1));
 
     unique_fd vendor_boot(make_temporary_fd("vendor boot repack"));
-    uint64_t vendor_boot_size = fetch_partition(partition, vendor_boot);
+    uint64_t vendor_boot_size = fetch_partition(partition, vendor_boot, fb);
     auto repack_res = replace_vendor_ramdisk(vendor_boot, vendor_boot_size, ramdisk, buf->fd,
                                              static_cast<uint64_t>(buf->sz));
     if (!repack_res.ok()) {
@@ -1508,7 +1511,7 @@ void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,
     if (is_logical(pname)) {
         fb->ResizePartition(pname, std::to_string(buf.image_size));
     }
-    std::string flash_pname = repack_ramdisk(pname, &buf);
+    std::string flash_pname = repack_ramdisk(pname, &buf, fp->fb);
     flash_buf(flash_pname, &buf, apply_vbmeta);
 }
 
@@ -2576,7 +2579,7 @@ int FastBootTool::Main(int argc, char* argv[]) {
         } else if (command == FB_CMD_FETCH) {
             std::string partition = next_arg(&args);
             std::string outfile = next_arg(&args);
-            do_fetch(partition, fp->slot_override, outfile);
+            do_fetch(partition, fp->slot_override, outfile, fp->fb);
         } else {
             syntax_error("unknown command %s", command.c_str());
         }
diff --git a/fastboot/fastboot_driver.h b/fastboot/fastboot_driver.h
index 6ac26ce31f13..8774eadc6a6f 100644
--- a/fastboot/fastboot_driver.h
+++ b/fastboot/fastboot_driver.h
@@ -105,7 +105,7 @@ class FastBootDriver : public IFastBootDriver {
                                   std::vector<std::string>* info = nullptr);
     RetCode FetchToFd(const std::string& partition, android::base::borrowed_fd fd,
                       int64_t offset = -1, int64_t size = -1, std::string* response = nullptr,
-                      std::vector<std::string>* info = nullptr);
+                      std::vector<std::string>* info = nullptr) override;
 
     /* HIGHER LEVEL COMMANDS -- Composed of the commands above */
     RetCode FlashPartition(const std::string& partition, const std::vector<char>& data);
diff --git a/fastboot/fastboot_driver_interface.h b/fastboot/fastboot_driver_interface.h
index 795938fb41f7..7cb8a6b6acdf 100644
--- a/fastboot/fastboot_driver_interface.h
+++ b/fastboot/fastboot_driver_interface.h
@@ -45,6 +45,10 @@ class IFastBootDriver {
                              std::vector<std::string>* info = nullptr) = 0;
     RetCode virtual GetVar(const std::string& key, std::string* val,
                            std::vector<std::string>* info = nullptr) = 0;
+    RetCode virtual FetchToFd(const std::string& partition, android::base::borrowed_fd fd,
+                              int64_t offset = -1, int64_t size = -1,
+                              std::string* response = nullptr,
+                              std::vector<std::string>* info = nullptr) = 0;
     RetCode virtual Download(const std::string& name, android::base::borrowed_fd fd, size_t size,
                              std::string* response = nullptr,
                              std::vector<std::string>* info = nullptr) = 0;
diff --git a/fastboot/fastboot_driver_mock.h b/fastboot/fastboot_driver_mock.h
index d2a123b199c5..7c41d78a1839 100644
--- a/fastboot/fastboot_driver_mock.h
+++ b/fastboot/fastboot_driver_mock.h
@@ -28,15 +28,16 @@ class MockFastbootDriver : public IFastBootDriver {
     MOCK_METHOD(RetCode, Reboot, (std::string*, std::vector<std::string>*), (override));
     MOCK_METHOD(RetCode, RebootTo, (std::string, std::string*, std::vector<std::string>*),
                 (override));
-
     MOCK_METHOD(RetCode, GetVar, (const std::string&, std::string*, std::vector<std::string>*),
                 (override));
-
+    MOCK_METHOD(RetCode, FetchToFd,
+                (const std::string&, android::base::borrowed_fd, int64_t offset, int64_t size,
+                 std::string*, std::vector<std::string>*),
+                (override));
     MOCK_METHOD(RetCode, Download,
                 (const std::string&, android::base::borrowed_fd, size_t, std::string*,
                  std::vector<std::string>*),
                 (override));
-
     MOCK_METHOD(RetCode, RawCommand,
                 (const std::string&, const std::string&, std::string*, std::vector<std::string>*,
                  int*),

From 59589d47dbdd3a648f2d9496c13206e795115c54 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 10 Jul 2023 16:51:30 -0700
Subject: [PATCH 0175/1487] Asserting flashing plan is used in do_flash

Adding check to ensure flashing plan is used in do_flash. FlashingPlan
should never be null

Test: fastboot flashall -w
Change-Id: I8e69326c59b31c7b54d6d2e04c8ce5c0f12693a7
---
 fastboot/fastboot.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index eee0e93d031e..79c71692a8bb 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1489,10 +1489,13 @@ static std::string repack_ramdisk(const char* pname, struct fastboot_buffer* buf
 
 void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,
               const FlashingPlan* fp) {
+    if (!fp) {
+        die("do flash was called without a valid flashing plan");
+    }
     verbose("Do flash %s %s", pname, fname);
     struct fastboot_buffer buf;
 
-    if (fp && fp->source) {
+    if (fp->source) {
         unique_fd fd = fp->source->OpenFile(fname);
         if (fd < 0 || !load_buf_fd(std::move(fd), &buf, fp)) {
             die("could not load '%s': %s", fname, strerror(errno));

From eabfe272c3829cc1b0cd26dbc1aea800e7325901 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 21 Jun 2023 14:51:54 -0700
Subject: [PATCH 0176/1487] Fastboot-info testing

adding test to compare task list formed from fastboot-info vs list
formed from image list. To test, we need to set sparse_limit in flashing
plan and turn off update-super-optimization. The list of partitions to
be flashed by parsing fastboot-info should be a superset of the
partitions flashed by the hardcoded list. Changing is_retrofit_device()
to also take in a fastboot driver so we can pass in a mock

Test: fastboot_test
Bug: 194686221
Change-Id: Ib860c24c85779de1fbaa6bec8778e1f5ebb9475a
---
 fastboot/fastboot.cpp  |  4 +--
 fastboot/fastboot.h    |  2 +-
 fastboot/task_test.cpp | 76 ++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 79 insertions(+), 3 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 79c71692a8bb..294121696c64 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1411,7 +1411,7 @@ void do_for_partitions(const std::string& part, const std::string& slot,
     }
 }
 
-bool is_retrofit_device() {
+bool is_retrofit_device(fastboot::IFastBootDriver* fb) {
     std::string value;
     if (fb->GetVar("super-partition-name", &value) != fastboot::SUCCESS) {
         return false;
@@ -1878,7 +1878,7 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasksFromImageList() {
             // On these devices, secondary slots must be flashed as physical
             // partitions (otherwise they would not mount on first boot). To enforce
             // this, we delete any logical partitions for the "other" slot.
-            if (is_retrofit_device()) {
+            if (is_retrofit_device(fp_->fb)) {
                 std::string partition_name = image->part_name + "_"s + slot;
                 if (image->IsSecondary() && should_flash_in_userspace(partition_name)) {
                     fp_->fb->DeletePartition(partition_name);
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index 77430f05ad48..50db25db027e 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -187,7 +187,7 @@ void flash_partition_files(const std::string& partition, const std::vector<Spars
 int64_t get_sparse_limit(int64_t size, const FlashingPlan* fp);
 std::vector<SparsePtr> resparse_file(sparse_file* s, int64_t max_size);
 
-bool is_retrofit_device();
+bool is_retrofit_device(fastboot::IFastBootDriver* fb);
 bool is_logical(const std::string& partition);
 void fb_perform_format(const std::string& partition, int skip_if_not_supported,
                        const std::string& type_override, const std::string& size_override,
diff --git a/fastboot/task_test.cpp b/fastboot/task_test.cpp
index b4e139b8dd03..1ba3f4ae426e 100644
--- a/fastboot/task_test.cpp
+++ b/fastboot/task_test.cpp
@@ -24,6 +24,7 @@
 #include <memory>
 #include <unordered_map>
 #include "android-base/strings.h"
+
 using android::base::Split;
 using testing::_;
 
@@ -60,6 +61,33 @@ std::unique_ptr<Task> ParseCommand(FlashingPlan* fp, std::string command) {
     return ParseFastbootInfoLine(fp, vec_command);
 }
 
+// tests if tasks_a is a superset of tasks_b. Used for checking to ensure all partitions flashed
+// from hardcoded image list is also flashed in new fastboot-info.txt
+static bool compareTaskList(std::vector<std::unique_ptr<Task>>& tasks_a,
+                            std::vector<std::unique_ptr<Task>>& tasks_b) {
+    std::set<std::string> list;
+    for (auto& task : tasks_a) {
+        list.insert(task->ToString());
+    }
+    for (auto& task : tasks_b) {
+        if (list.find(task->ToString()) == list.end()) {
+            std::cout << "ERROR: " << task->ToString()
+                      << " not found in task list created by fastboot-info.txt";
+            return false;
+        }
+    }
+    return true;
+}
+
+static std::string tasksToString(std::vector<std::unique_ptr<Task>>& tasks) {
+    std::string output;
+    for (auto& task : tasks) {
+        output.append(task->ToString());
+        output.append("\n");
+    }
+    return output;
+}
+
 TEST_F(ParseTest, CorrectFlashTaskFormed) {
     std::vector<std::string> commands = {"flash dtbo", "flash --slot-other system system_other.img",
                                          "flash system", "flash --apply-vbmeta vbmeta"};
@@ -159,3 +187,51 @@ TEST_F(ParseTest, CorrectDriverCalls) {
         task->Run();
     }
 }
+
+TEST_F(ParseTest, CorrectTaskLists) {
+    if (!get_android_product_out()) {
+        GTEST_SKIP();
+    }
+
+    LocalImageSource s;
+    fp->source = &s;
+    fp->sparse_limit = std::numeric_limits<int64_t>::max();
+
+    fastboot::MockFastbootDriver fb;
+    fp->fb = &fb;
+    fp->should_optimize_flash_super = false;
+
+    ON_CALL(fb, GetVar("super-partition-name", _, _))
+            .WillByDefault(testing::Return(fastboot::BAD_ARG));
+
+    FlashAllTool tool(fp.get());
+
+    fp->should_use_fastboot_info = false;
+    auto hardcoded_tasks = tool.CollectTasks();
+    fp->should_use_fastboot_info = true;
+    auto fastboot_info_tasks = tool.CollectTasks();
+
+    auto is_non_flash_task = [](const auto& task) -> bool {
+        return task->AsFlashTask() == nullptr;
+    };
+
+    // remove non flash tasks for testing purposes
+    hardcoded_tasks.erase(
+            std::remove_if(hardcoded_tasks.begin(), hardcoded_tasks.end(), is_non_flash_task),
+            hardcoded_tasks.end());
+    fastboot_info_tasks.erase(std::remove_if(fastboot_info_tasks.begin(), fastboot_info_tasks.end(),
+                                             is_non_flash_task),
+                              fastboot_info_tasks.end());
+
+    if (!compareTaskList(fastboot_info_tasks, hardcoded_tasks)) {
+        std::cout << "\n\n---Hardcoded Task List---\n"
+                  << tasksToString(hardcoded_tasks) << "\n---Fastboot-Info Task List---\n"
+                  << tasksToString(fastboot_info_tasks);
+    }
+
+    ASSERT_TRUE(compareTaskList(fastboot_info_tasks, hardcoded_tasks));
+
+    ASSERT_TRUE(fastboot_info_tasks.size() >= hardcoded_tasks.size())
+            << "size of fastboot-info task list: " << fastboot_info_tasks.size()
+            << " size of hardcoded task list: " << hardcoded_tasks.size();
+}

From 63dfeaae7acc9fcefdab93b71f1c691cb09887ae Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 3 Jul 2023 14:01:57 -0700
Subject: [PATCH 0177/1487] Adding flag to disable fastboot_info

Adding flag to override fastboot_info for a quick fix in case
fastboot_info format is wrong

Test: fastboot flashall
Change-Id: I1f41646f14d747ce7ac7636ca9ced7279e13f7b0
---
 fastboot/fastboot.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 294121696c64..61c7204daacd 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -2213,6 +2213,7 @@ int FastBootTool::Main(int argc, char* argv[]) {
                                       {"disable-verification", no_argument, 0, 0},
                                       {"disable-verity", no_argument, 0, 0},
                                       {"disable-super-optimization", no_argument, 0, 0},
+                                      {"disable-fastboot-info", no_argument, 0, 0},
                                       {"force", no_argument, 0, 0},
                                       {"fs-options", required_argument, 0, 0},
                                       {"header-version", required_argument, 0, 0},
@@ -2253,6 +2254,8 @@ int FastBootTool::Main(int argc, char* argv[]) {
                 g_disable_verity = true;
             } else if (name == "disable-super-optimization") {
                 fp->should_optimize_flash_super = false;
+            } else if (name == "disable-fastboot-info") {
+                fp->should_use_fastboot_info = false;
             } else if (name == "force") {
                 fp->force_flash = true;
             } else if (name == "fs-options") {

From 6acfe9bcd01fa51b45726a306cbb2ae1c91ebac7 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 5 Jul 2023 10:23:37 -0700
Subject: [PATCH 0178/1487] Turning on fastboot-info

turning on fastboot-info by default again

Test: fastboot flashall
Change-Id: I6b8bb0d145af37d437419a5e6cee70158ed553ae
---
 fastboot/fastboot.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index 50db25db027e..f6ffb641fc69 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -97,7 +97,7 @@ struct FlashingPlan {
     bool skip_secondary = false;
     bool force_flash = false;
     bool should_optimize_flash_super = true;
-    bool should_use_fastboot_info = false;
+    bool should_use_fastboot_info = true;
     uint64_t sparse_limit = 0;
 
     std::string slot_override;

From 3196be61fcf0e0303cf819630876b9c812b9474e Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Tue, 11 Jul 2023 09:05:11 -0700
Subject: [PATCH 0179/1487] Revert "Fix deadlock caused by two-threaded
 property controls"

This reverts commit 606afc7b7451aba90e3634076d9b59a5ef08186b.

These fixes for b/262208935 introduced a race condition. We believe the
race is fixed by ag/23879563, but at this point in the release feel that
reverting the fixes and refixing in main is the better solution

Test: Builds, boots
Bug: 283202477
Bug: 288991737
Ignore-AOSP-First: Reverting CL only in internal
Change-Id: I9ae6863b0ea5e064c59d9d34c03d33fa1da12fdc
---
 init/property_service.cpp | 50 ++++++++++++++++++---------------------
 1 file changed, 23 insertions(+), 27 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index 4242912ed0af..2d084db46d2a 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -117,6 +117,7 @@ static bool accept_messages = false;
 static std::mutex accept_messages_lock;
 static std::thread property_service_thread;
 static std::thread property_service_for_system_thread;
+static std::mutex set_property_lock;
 
 static std::unique_ptr<PersistWriteThread> persist_write_thread;
 
@@ -394,37 +395,32 @@ static std::optional<uint32_t> PropertySet(const std::string& name, const std::s
         return {PROP_ERROR_INVALID_VALUE};
     }
 
-    if (name == "sys.powerctl") {
-        // No action here - NotifyPropertyChange will trigger the appropriate action, and since this
-        // can come to the second thread, we mustn't call out to the __system_property_* functions
-        // which support multiple readers but only one mutator.
-    } else {
-        prop_info* pi = (prop_info*)__system_property_find(name.c_str());
-        if (pi != nullptr) {
-            // ro.* properties are actually "write-once".
-            if (StartsWith(name, "ro.")) {
-                *error = "Read-only property was already set";
-                return {PROP_ERROR_READ_ONLY_PROPERTY};
-            }
+    auto lock = std::lock_guard{set_property_lock};
+    prop_info* pi = (prop_info*)__system_property_find(name.c_str());
+    if (pi != nullptr) {
+        // ro.* properties are actually "write-once".
+        if (StartsWith(name, "ro.")) {
+            *error = "Read-only property was already set";
+            return {PROP_ERROR_READ_ONLY_PROPERTY};
+        }
 
-            __system_property_update(pi, value.c_str(), valuelen);
-        } else {
-            int rc = __system_property_add(name.c_str(), name.size(), value.c_str(), valuelen);
-            if (rc < 0) {
-                *error = "__system_property_add failed";
-                return {PROP_ERROR_SET_FAILED};
-            }
+        __system_property_update(pi, value.c_str(), valuelen);
+    } else {
+        int rc = __system_property_add(name.c_str(), name.size(), value.c_str(), valuelen);
+        if (rc < 0) {
+            *error = "__system_property_add failed";
+            return {PROP_ERROR_SET_FAILED};
         }
+    }
 
-        // Don't write properties to disk until after we have read all default
-        // properties to prevent them from being overwritten by default values.
-        if (socket && persistent_properties_loaded && StartsWith(name, "persist.")) {
-            if (persist_write_thread) {
-                persist_write_thread->Write(name, value, std::move(*socket));
-                return {};
-            }
-            WritePersistentProperty(name, value);
+    // Don't write properties to disk until after we have read all default
+    // properties to prevent them from being overwritten by default values.
+    if (socket && persistent_properties_loaded && StartsWith(name, "persist.")) {
+        if (persist_write_thread) {
+            persist_write_thread->Write(name, value, std::move(*socket));
+            return {};
         }
+        WritePersistentProperty(name, value);
     }
 
     NotifyPropertyChange(name, value);

From be392fc69318d376f18eed7c8ef5ded0d1dc8648 Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Tue, 11 Jul 2023 09:05:27 -0700
Subject: [PATCH 0180/1487] Revert "Listen on property_service_for_system
 socket"

This reverts commit 90879edeea0b2fd1e766428693d736163f39c511.

These fixes for b/262208935 introduced a race condition. We believe the
race is fixed by ag/23879563, but at this point in the release feel that
reverting the fixes and refixing in main is the better solution

Test: Builds, boots
Bug: 283202477
Bug: 288991737
Ignore-AOSP-First: Reverting CL only in internal
Change-Id: I28491e90847f6aa0c9767b27e1d99190637048b9
---
 init/property_service.cpp | 53 ++++++++++++++++-----------------------
 1 file changed, 21 insertions(+), 32 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index 2d084db46d2a..8da69822ccb9 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -57,12 +57,12 @@
 #include <android-base/result.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
-#include <private/android_filesystem_config.h>
 #include <property_info_parser/property_info_parser.h>
 #include <property_info_serializer/property_info_serializer.h>
 #include <selinux/android.h>
 #include <selinux/label.h>
 #include <selinux/selinux.h>
+
 #include "debug_ramdisk.h"
 #include "epoll.h"
 #include "init.h"
@@ -111,13 +111,12 @@ constexpr auto API_LEVEL_CURRENT = 10000;
 
 static bool persistent_properties_loaded = false;
 
+static int property_set_fd = -1;
 static int from_init_socket = -1;
 static int init_socket = -1;
 static bool accept_messages = false;
 static std::mutex accept_messages_lock;
 static std::thread property_service_thread;
-static std::thread property_service_for_system_thread;
-static std::mutex set_property_lock;
 
 static std::unique_ptr<PersistWriteThread> persist_write_thread;
 
@@ -395,7 +394,6 @@ static std::optional<uint32_t> PropertySet(const std::string& name, const std::s
         return {PROP_ERROR_INVALID_VALUE};
     }
 
-    auto lock = std::lock_guard{set_property_lock};
     prop_info* pi = (prop_info*)__system_property_find(name.c_str());
     if (pi != nullptr) {
         // ro.* properties are actually "write-once".
@@ -581,10 +579,10 @@ uint32_t HandlePropertySetNoSocket(const std::string& name, const std::string& v
     return *ret;
 }
 
-static void handle_property_set_fd(int fd) {
+static void handle_property_set_fd() {
     static constexpr uint32_t kDefaultSocketTimeout = 2000; /* ms */
 
-    int s = accept4(fd, nullptr, nullptr, SOCK_CLOEXEC);
+    int s = accept4(property_set_fd, nullptr, nullptr, SOCK_CLOEXEC);
     if (s == -1) {
         return;
     }
@@ -1421,21 +1419,19 @@ static void HandleInitSocket() {
     }
 }
 
-static void PropertyServiceThread(int fd, bool listen_init) {
+static void PropertyServiceThread() {
     Epoll epoll;
     if (auto result = epoll.Open(); !result.ok()) {
         LOG(FATAL) << result.error();
     }
 
-    if (auto result = epoll.RegisterHandler(fd, std::bind(handle_property_set_fd, fd));
+    if (auto result = epoll.RegisterHandler(property_set_fd, handle_property_set_fd);
         !result.ok()) {
         LOG(FATAL) << result.error();
     }
 
-    if (listen_init) {
-        if (auto result = epoll.RegisterHandler(init_socket, HandleInitSocket); !result.ok()) {
-            LOG(FATAL) << result.error();
-        }
+    if (auto result = epoll.RegisterHandler(init_socket, HandleInitSocket); !result.ok()) {
+        LOG(FATAL) << result.error();
     }
 
     while (true) {
@@ -1486,23 +1482,6 @@ void PersistWriteThread::Write(std::string name, std::string value, SocketConnec
     cv_.notify_all();
 }
 
-void StartThread(const char* name, int mode, int gid, std::thread& t, bool listen_init) {
-    int fd = -1;
-    if (auto result = CreateSocket(name, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
-                                   /*passcred=*/false, /*should_listen=*/false, mode, /*uid=*/0,
-                                   /*gid=*/gid, /*socketcon=*/{});
-        result.ok()) {
-        fd = *result;
-    } else {
-        LOG(FATAL) << "start_property_service socket creation failed: " << result.error();
-    }
-
-    listen(fd, 8);
-
-    auto new_thread = std::thread(PropertyServiceThread, fd, listen_init);
-    t.swap(new_thread);
-}
-
 void StartPropertyService(int* epoll_socket) {
     InitPropertySet("ro.property_service.version", "2");
 
@@ -1514,9 +1493,19 @@ void StartPropertyService(int* epoll_socket) {
     init_socket = sockets[1];
     StartSendingMessages();
 
-    StartThread(PROP_SERVICE_FOR_SYSTEM_NAME, 0660, AID_SYSTEM, property_service_for_system_thread,
-                true);
-    StartThread(PROP_SERVICE_NAME, 0666, 0, property_service_thread, false);
+    if (auto result = CreateSocket(PROP_SERVICE_NAME, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
+                                   /*passcred=*/false, /*should_listen=*/false, 0666, /*uid=*/0,
+                                   /*gid=*/0, /*socketcon=*/{});
+        result.ok()) {
+        property_set_fd = *result;
+    } else {
+        LOG(FATAL) << "start_property_service socket creation failed: " << result.error();
+    }
+
+    listen(property_set_fd, 8);
+
+    auto new_thread = std::thread{PropertyServiceThread};
+    property_service_thread.swap(new_thread);
 
     auto async_persist_writes =
             android::base::GetBoolProperty("ro.property_service.async_persist_writes", false);

From 0de2195738cf608c2e051c7912ca4c97d4400734 Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Thu, 29 Jun 2023 15:05:44 -0700
Subject: [PATCH 0181/1487] Migrate gettid to GetThreadId

Bug: 289414897
Test: it builds
Change-Id: If1214a181d4e9a193adf1bac0d35e7e3ac6c27db
---
 libstats/push_compat/Android.bp                           | 2 +-
 .../push_compat/{statsd_writer.c => statsd_writer.cpp}    | 8 ++++----
 libstats/push_compat/statsd_writer.h                      | 4 ++++
 3 files changed, 9 insertions(+), 5 deletions(-)
 rename libstats/push_compat/{statsd_writer.c => statsd_writer.cpp} (98%)

diff --git a/libstats/push_compat/Android.bp b/libstats/push_compat/Android.bp
index 819066eb4f1e..c5c1934956c4 100644
--- a/libstats/push_compat/Android.bp
+++ b/libstats/push_compat/Android.bp
@@ -26,7 +26,7 @@ package {
 cc_defaults {
     name: "libstatspush_compat_defaults",
     srcs: [
-        "statsd_writer.c",
+        "statsd_writer.cpp",
         "stats_event_list.c",
         "StatsEventCompat.cpp"
     ],
diff --git a/libstats/push_compat/statsd_writer.c b/libstats/push_compat/statsd_writer.cpp
similarity index 98%
rename from libstats/push_compat/statsd_writer.c
rename to libstats/push_compat/statsd_writer.cpp
index 4818d1112ec1..a3600f322fce 100644
--- a/libstats/push_compat/statsd_writer.c
+++ b/libstats/push_compat/statsd_writer.cpp
@@ -15,9 +15,9 @@
  */
 #include "statsd_writer.h"
 
+#include <android-base/threads.h>
 #include <cutils/fs.h>
 #include <cutils/sockets.h>
-#include <cutils/threads.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
@@ -108,7 +108,7 @@ static int statsdOpen() {
                     case -ECONNREFUSED:
                     case -ENOENT:
                         i = atomic_exchange(&statsdLoggerWrite.sock, ret);
-                    /* FALLTHRU */
+                        break;
                     default:
                         break;
                 }
@@ -188,7 +188,7 @@ static int statsdWrite(struct timespec* ts, struct iovec* vec, size_t nr) {
      *  };
      */
 
-    header.tid = gettid();
+    header.tid = android::base::GetThreadId();
     header.realtime.tv_sec = ts->tv_sec;
     header.realtime.tv_nsec = ts->tv_nsec;
 
@@ -272,7 +272,7 @@ static int statsdWrite(struct timespec* ts, struct iovec* vec, size_t nr) {
             if (ret < 0) {
                 ret = -errno;
             }
-        /* FALLTHRU */
+            break;
         default:
             break;
     }
diff --git a/libstats/push_compat/statsd_writer.h b/libstats/push_compat/statsd_writer.h
index fe2d37cbc7d8..f030b96c7b5a 100644
--- a/libstats/push_compat/statsd_writer.h
+++ b/libstats/push_compat/statsd_writer.h
@@ -21,6 +21,8 @@
 #include <stdatomic.h>
 #include <sys/socket.h>
 
+__BEGIN_DECLS
+
 /**
  * Internal lock should not be exposed. This is bad design.
  * TODO: rewrite it in c++ code and encapsulate the functionality in a
@@ -42,4 +44,6 @@ struct android_log_transport_write {
     void (*noteDrop)(int error, int tag);
 };
 
+__END_DECLS
+
 #endif  // ANDROID_STATS_LOG_STATS_WRITER_H

From 9c8c748c1161ffdb213336425dc1e99632fce03c Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Wed, 12 Jul 2023 18:18:42 +0000
Subject: [PATCH 0182/1487] libprocessgroup: Remove isolated UID cgroup
 directories

Global UID level cgroup removal was eliminated because of a race
between app launch and app killing using the same directory name. [1]

However isolated app UIDs are assigned sequentially, and are
basically never reused until we wrap around the large range of
isolated UIDs. This leaves thousands of isolated cgroup directories
unused, which consumes kernel memory and increases memory reclaim
overhead. Remove this subset of UID level cgroup directories when
killing process groups.

[1] https://android.googlesource.com/platform/system/core/+/d0464b0c0180b8b98fe6a65b7188d45612b2d546

Test: 50 cycle ACT leaves 1000 fewer empty isolated cgroups
Bug: 290953668
Change-Id: If7d2a7b8eec14561a72208049b74ff785ca961bd
---
 libprocessgroup/processgroup.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 1f2904000866..06d386f363e7 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -223,6 +223,13 @@ static int RemoveProcessGroup(const char* cgroup, uid_t uid, int pid, unsigned i
         std::this_thread::sleep_for(5ms);
     }
 
+    if (!ret && uid >= AID_ISOLATED_START && uid <= AID_ISOLATED_END) {
+        // Isolated UIDs are unlikely to be reused soon after removal,
+        // so free up the kernel resources for the UID level cgroup.
+        const auto uid_path = ConvertUidToPath(cgroup, uid);
+        ret = rmdir(uid_path.c_str());
+    }
+
     return ret;
 }
 

From cb199b47955623746a021bdb91a04478b3bd3a7e Mon Sep 17 00:00:00 2001
From: Eric Miao <ericymiao@google.com>
Date: Wed, 30 Nov 2022 16:05:49 -0800
Subject: [PATCH 0183/1487] libutils: Improve performance of
 utf8_to_utf16/utf16_to_utf8

This CL improves the performance of below functions in helping with conversion
between utf8/utf16 with libutils:

  - utf8_to_utf16_length
  - utf8_to_utf16
  - utf16_to_utf8_length
  - utf16_to_utf

The basic idea is to keep the loop as tight as possible for the most
common cases, e.g. in UTF16-->UTF8 case, the most common case is
when the character is < 0x80 (ASCII), next is when it's < 0x0800 (
most Latin), and so on.

This version of implementation reduces the number of instructions
needed for every incoming utf-8 bytes in the original implementation
where:

  1) calculating how many bytes needed given a leading UTF-8 byte
     in utf8_codepoint_len(), it's a very clever way but involves
     multiple instructions to calculate regardless

  2) and an intermediate conversion to utf32, and then to utf16
     utf8_to_utf32_codepoint()

The end result is about ~1.5x throughput improvement.

Benchmark results on redfin (64bit) before the change:

utf8_to_utf16_length: bytes_per_second=307.556M/s
utf8_to_utf16:        bytes_per_second=246.664M/s
utf16_to_utf8_length: bytes_per_second=482.241M/s
utf16_to_utf8:        bytes_per_second=351.376M/s

After the change:

utf8_to_utf16_length: bytes_per_second=544.022M/s
utf8_to_utf16:        bytes_per_second=471.135M/s
utf16_to_utf8_length: bytes_per_second=685.381M/s
utf16_to_utf8:        bytes_per_second=580.004M/s

Ideas for future improvement could include alignment handling and loop
unrolling to increase throughput more.

This CL also fixes issues below:

  1. utf16_to_utf8_length() should return 0 when the source string has
     length of 0, the original code returns -1 as below:

    ssize_t utf16_to_utf8_length(const char16_t *src, size_t src_len)
    {
        if (src == nullptr || src_len == 0) {
            return -1;
        }
	...

  2. utf8_to_utf16() should check whether input string is valid.

Change-Id: I546138a7a8050681a524eabce9864219fc44f48e
---
 libutils/Unicode.cpp | 358 +++++++++++++++++++++++++------------------
 1 file changed, 209 insertions(+), 149 deletions(-)

diff --git a/libutils/Unicode.cpp b/libutils/Unicode.cpp
index 3ffcf7e34c57..364a1778c632 100644
--- a/libutils/Unicode.cpp
+++ b/libutils/Unicode.cpp
@@ -280,158 +280,181 @@ int strzcmp16(const char16_t *s1, size_t n1, const char16_t *s2, size_t n2)
            : 0);
 }
 
-void utf16_to_utf8(const char16_t* src, size_t src_len, char* dst, size_t dst_len)
-{
-    if (src == nullptr || src_len == 0 || dst == nullptr) {
-        return;
-    }
-
-    const char16_t* cur_utf16 = src;
-    const char16_t* const end_utf16 = src + src_len;
-    char *cur = dst;
-    while (cur_utf16 < end_utf16) {
-        char32_t utf32;
-        // surrogate pairs
-        if((*cur_utf16 & 0xFC00) == 0xD800 && (cur_utf16 + 1) < end_utf16
-                && (*(cur_utf16 + 1) & 0xFC00) == 0xDC00) {
-            utf32 = (*cur_utf16++ - 0xD800) << 10;
-            utf32 |= *cur_utf16++ - 0xDC00;
-            utf32 += 0x10000;
-        } else {
-            utf32 = (char32_t) *cur_utf16++;
-        }
-        const size_t len = utf32_codepoint_utf8_length(utf32);
-        LOG_ALWAYS_FATAL_IF(dst_len < len, "%zu < %zu", dst_len, len);
-        utf32_codepoint_to_utf8((uint8_t*)cur, utf32, len);
-        cur += len;
-        dst_len -= len;
-    }
-    LOG_ALWAYS_FATAL_IF(dst_len < 1, "%zu < 1", dst_len);
-    *cur = '\0';
+// is_any_surrogate() returns true if w is either a high or low surrogate
+static constexpr bool is_any_surrogate(char16_t w) {
+    return (w & 0xf800) == 0xd800;
 }
 
-// --------------------------------------------------------------------------
-// UTF-8
-// --------------------------------------------------------------------------
+// is_surrogate_pair() returns true if w1 and w2 form a valid surrogate pair
+static constexpr bool is_surrogate_pair(char16_t w1, char16_t w2) {
+    return ((w1 & 0xfc00) == 0xd800) && ((w2 & 0xfc00) == 0xdc00);
+}
 
+// TODO: currently utf16_to_utf8_length() returns -1 if src_len == 0,
+// which is inconsistent with utf8_to_utf16_length(), here we keep the
+// current behavior as intended not to break compatibility
 ssize_t utf16_to_utf8_length(const char16_t *src, size_t src_len)
 {
-    if (src == nullptr || src_len == 0) {
+    if (src == nullptr || src_len == 0)
         return -1;
-    }
 
-    size_t ret = 0;
     const char16_t* const end = src + src_len;
-    while (src < end) {
-        size_t char_len;
-        if ((*src & 0xFC00) == 0xD800 && (src + 1) < end
-                && (*(src + 1) & 0xFC00) == 0xDC00) {
-            // surrogate pairs are always 4 bytes.
-            char_len = 4;
-            src += 2;
-        } else {
-            char_len = utf32_codepoint_utf8_length((char32_t)*src++);
+    const char16_t* in = src;
+    size_t utf8_len = 0;
+
+    while (in < end) {
+        char16_t w = *in++;
+        if (LIKELY(w < 0x0080)) {
+            utf8_len += 1;
+            continue;
         }
-        if (SSIZE_MAX - char_len < ret) {
-            // If this happens, we would overflow the ssize_t type when
-            // returning from this function, so we cannot express how
-            // long this string is in an ssize_t.
-            android_errorWriteLog(0x534e4554, "37723026");
-            return -1;
+        if (LIKELY(w < 0x0800)) {
+            utf8_len += 2;
+            continue;
         }
-        ret += char_len;
+        if (LIKELY(!is_any_surrogate(w))) {
+            utf8_len += 3;
+            continue;
+        }
+        if (in < end && is_surrogate_pair(w, *in)) {
+            utf8_len += 4;
+            in++;
+            continue;
+        }
+        /* skip if at the end of the string or invalid surrogate pair */
     }
-    return ret;
+    return (in == end && utf8_len < SSIZE_MAX) ? utf8_len : -1;
 }
 
-/**
- * Returns 1-4 based on the number of leading bits.
- *
- * 1111 -> 4
- * 1110 -> 3
- * 110x -> 2
- * 10xx -> 1
- * 0xxx -> 1
- */
-static inline size_t utf8_codepoint_len(uint8_t ch)
+void utf16_to_utf8(const char16_t* src, size_t src_len, char* dst, size_t dst_len)
 {
-    return ((0xe5000000 >> ((ch >> 3) & 0x1e)) & 3) + 1;
-}
+    if (src == nullptr || src_len == 0 || dst == nullptr) {
+        return;
+    }
 
-static inline void utf8_shift_and_mask(uint32_t* codePoint, const uint8_t byte)
-{
-    *codePoint <<= 6;
-    *codePoint |= 0x3F & byte;
+    const char16_t* in = src;
+    const char16_t* const in_end = src + src_len;
+    char* out = dst;
+    const char* const out_end = dst + dst_len;
+    char16_t w2;
+
+    auto err_out = [&out, &out_end, &dst_len]() {
+        LOG_ALWAYS_FATAL_IF(out >= out_end,
+                "target utf8 string size %zu too short", dst_len);
+    };
+
+    while (in < in_end) {
+        char16_t w = *in++;
+        if (LIKELY(w < 0x0080)) {
+            if (out + 1 > out_end)
+                return err_out();
+            *out++ = (char)(w & 0xff);
+            continue;
+        }
+        if (LIKELY(w < 0x0800)) {
+            if (out + 2 > out_end)
+                return err_out();
+            *out++ = (char)(0xc0 | ((w >> 6) & 0x1f));
+            *out++ = (char)(0x80 | ((w >> 0) & 0x3f));
+            continue;
+        }
+        if (LIKELY(!is_any_surrogate(w))) {
+            if (out + 3 > out_end)
+                return err_out();
+            *out++ = (char)(0xe0 | ((w >> 12) & 0xf));
+            *out++ = (char)(0x80 | ((w >> 6) & 0x3f));
+            *out++ = (char)(0x80 | ((w >> 0) & 0x3f));
+            continue;
+        }
+        /* surrogate pair */
+        if (in < in_end && (w2 = *in, is_surrogate_pair(w, w2))) {
+            if (out + 4 > out_end)
+                return err_out();
+            char32_t dw = (char32_t)(0x10000 + ((w - 0xd800) << 10) + (w2 - 0xdc00));
+            *out++ = (char)(0xf0 | ((dw >> 18) & 0x07));
+            *out++ = (char)(0x80 | ((dw >> 12) & 0x3f));
+            *out++ = (char)(0x80 | ((dw >> 6)  & 0x3f));
+            *out++ = (char)(0x80 | ((dw >> 0)  & 0x3f));
+            in++;
+        }
+        /* We reach here in two cases:
+         *  1) (in == in_end), which means end of the input string
+         *  2) (w2 & 0xfc00) != 0xdc00, which means invalid surrogate pair
+         * In either case, we intentionally do nothing and skip
+         */
+    }
+    *out = '\0';
+    return;
 }
 
-static inline uint32_t utf8_to_utf32_codepoint(const uint8_t *src, size_t length)
-{
-    uint32_t unicode;
-
-    switch (length)
-    {
-        case 1:
-            return src[0];
-        case 2:
-            unicode = src[0] & 0x1f;
-            utf8_shift_and_mask(&unicode, src[1]);
-            return unicode;
-        case 3:
-            unicode = src[0] & 0x0f;
-            utf8_shift_and_mask(&unicode, src[1]);
-            utf8_shift_and_mask(&unicode, src[2]);
-            return unicode;
-        case 4:
-            unicode = src[0] & 0x07;
-            utf8_shift_and_mask(&unicode, src[1]);
-            utf8_shift_and_mask(&unicode, src[2]);
-            utf8_shift_and_mask(&unicode, src[3]);
-            return unicode;
-        default:
-            return 0xffff;
-    }
+// --------------------------------------------------------------------------
+// UTF-8
+// --------------------------------------------------------------------------
 
-    //printf("Char at %p: len=%d, utf-16=%p\n", src, length, (void*)result);
+static char32_t utf8_4b_to_utf32(uint8_t c1, uint8_t c2, uint8_t c3, uint8_t c4) {
+    return ((c1 & 0x07) << 18) | ((c2 & 0x3f) << 12) | ((c3 & 0x3f) << 6) | (c4 & 0x3f);
 }
 
+// TODO: current behavior of converting UTF8 to UTF-16 has a few issues below
+//
+// 1. invalid trailing bytes (i.e. not b'10xxxxxx) are treated as valid trailing
+//    bytes and follows normal conversion rules
+// 2. invalid leading byte (b'10xxxxxx) is treated as a valid single UTF-8 byte
+// 3. invalid leading byte (b'11111xxx) is treated as a valid leading byte
+//    (same as b'11110xxx) for a 4-byte UTF-8 sequence
+// 4. an invalid 4-byte UTF-8 sequence that translates to a codepoint < U+10000
+//    will be converted as a valid UTF-16 character
+//
+// We keep the current behavior as is but with warnings logged, so as not to
+// break compatibility.  However, this needs to be addressed later.
+
 ssize_t utf8_to_utf16_length(const uint8_t* u8str, size_t u8len, bool overreadIsFatal)
 {
-    const uint8_t* const u8end = u8str + u8len;
-    const uint8_t* u8cur = u8str;
-
-    /* Validate that the UTF-8 is the correct len */
-    size_t u16measuredLen = 0;
-    while (u8cur < u8end) {
-        u16measuredLen++;
-        int u8charLen = utf8_codepoint_len(*u8cur);
-        // Malformed utf8, some characters are beyond the end.
-        // Cases:
-        // If u8charLen == 1, this becomes u8cur >= u8end, which cannot happen as u8cur < u8end,
-        // then this condition fail and we continue, as expected.
-        // If u8charLen == 2, this becomes u8cur + 1 >= u8end, which fails only if
-        // u8cur == u8end - 1, that is, there was only one remaining character to read but we need
-        // 2 of them. This condition holds and we return -1, as expected.
-        if (u8cur + u8charLen - 1 >= u8end) {
-            if (overreadIsFatal) {
-                LOG_ALWAYS_FATAL("Attempt to overread computing length of utf8 string");
-            } else {
-                return -1;
+    if (u8str == nullptr)
+        return -1;
+
+    const uint8_t* const in_end = u8str + u8len;
+    const uint8_t* in = u8str;
+    size_t utf16_len = 0;
+
+    while (in < in_end) {
+        uint8_t c = *in;
+        utf16_len++;
+        if (LIKELY((c & 0x80) == 0)) {
+            in++;
+            continue;
+        }
+        if (UNLIKELY(c < 0xc0)) {
+            ALOGW("Invalid UTF-8 leading byte: 0x%02x", c);
+            in++;
+            continue;
+        }
+        if (LIKELY(c < 0xe0)) {
+            in += 2;
+            continue;
+        }
+        if (LIKELY(c < 0xf0)) {
+            in += 3;
+            continue;
+        } else {
+            uint8_t c2, c3, c4;
+            if (UNLIKELY(c >= 0xf8)) {
+                ALOGW("Invalid UTF-8 leading byte: 0x%02x", c);
+            }
+            c2 = in[1]; c3 = in[2]; c4 = in[3];
+            if (utf8_4b_to_utf32(c, c2, c3, c4) >= 0x10000) {
+                utf16_len++;
             }
+            in += 4;
+            continue;
         }
-        uint32_t codepoint = utf8_to_utf32_codepoint(u8cur, u8charLen);
-        if (codepoint > 0xFFFF) u16measuredLen++; // this will be a surrogate pair in utf16
-        u8cur += u8charLen;
     }
-
-    /**
-     * Make sure that we ended where we thought we would and the output UTF-16
-     * will be exactly how long we were told it would be.
-     */
-    if (u8cur != u8end) {
-        return -1;
+    if (in == in_end) {
+        return utf16_len < SSIZE_MAX ? utf16_len : -1;
     }
-
-    return u16measuredLen;
+    if (overreadIsFatal)
+        LOG_ALWAYS_FATAL("Attempt to overread computing length of utf8 string");
+    return -1;
 }
 
 char16_t* utf8_to_utf16(const uint8_t* u8str, size_t u8len, char16_t* u16str, size_t u16len) {
@@ -444,38 +467,75 @@ char16_t* utf8_to_utf16(const uint8_t* u8str, size_t u8len, char16_t* u16str, si
 
 char16_t* utf8_to_utf16_no_null_terminator(
         const uint8_t* src, size_t srcLen, char16_t* dst, size_t dstLen) {
-    if (dstLen == 0) {
+    if (src == nullptr || srcLen == 0 || dstLen == 0) {
         return dst;
     }
     // A value > SSIZE_MAX is probably a negative value returned as an error and casted.
     LOG_ALWAYS_FATAL_IF(dstLen > SSIZE_MAX, "dstLen is %zu", dstLen);
-    const uint8_t* const u8end = src + srcLen;
-    const uint8_t* u8cur = src;
-    const char16_t* const u16end = dst + dstLen;
-    char16_t* u16cur = dst;
-
-    while (u8cur < u8end && u16cur < u16end) {
-        size_t u8len = utf8_codepoint_len(*u8cur);
-        uint32_t codepoint = utf8_to_utf32_codepoint(u8cur, u8len);
-
-        // Convert the UTF32 codepoint to one or more UTF16 codepoints
-        if (codepoint <= 0xFFFF) {
-            // Single UTF16 character
-            *u16cur++ = (char16_t) codepoint;
+
+    const uint8_t* const in_end = src + srcLen;
+    const uint8_t* in = src;
+    const char16_t* const out_end = dst + dstLen;
+    char16_t* out = dst;
+    uint8_t c, c2, c3, c4;
+    char32_t w;
+
+    auto err_in = [&c, &out]() {
+        ALOGW("Unended UTF-8 byte: 0x%02x", c);
+        return out;
+    };
+
+    while (in < in_end && out < out_end) {
+        c = *in++;
+        if (LIKELY((c & 0x80) == 0)) {
+            *out++ = (char16_t)(c);
+            continue;
+        }
+        if (UNLIKELY(c < 0xc0)) {
+            ALOGW("Invalid UTF-8 leading byte: 0x%02x", c);
+            *out++ = (char16_t)(c);
+            continue;
+        }
+        if (LIKELY(c < 0xe0)) {
+            if (UNLIKELY(in + 1 > in_end)) {
+                return err_in();
+            }
+            c2 = *in++;
+            *out++ = (char16_t)(((c & 0x1f) << 6) | (c2 & 0x3f));
+            continue;
+        }
+        if (LIKELY(c < 0xf0)) {
+            if (UNLIKELY(in + 2 > in_end)) {
+                return err_in();
+            }
+            c2 = *in++; c3 = *in++;
+            *out++ = (char16_t)(((c & 0x0f) << 12) |
+                                ((c2 & 0x3f) << 6) | (c3 & 0x3f));
+            continue;
         } else {
+            if (UNLIKELY(in + 3 > in_end)) {
+                return err_in();
+            }
+            if (UNLIKELY(c >= 0xf8)) {
+                ALOGW("Invalid UTF-8 leading byte: 0x%02x", c);
+            }
             // Multiple UTF16 characters with surrogates
-            codepoint = codepoint - 0x10000;
-            *u16cur++ = (char16_t) ((codepoint >> 10) + 0xD800);
-            if (u16cur >= u16end) {
-                // Ooops...  not enough room for this surrogate pair.
-                return u16cur-1;
+            c2 = *in++; c3 = *in++; c4 = *in++;
+            w = utf8_4b_to_utf32(c, c2, c3, c4);
+            if (UNLIKELY(w < 0x10000)) {
+                *out++ = (char16_t)(w);
+            } else {
+                if (UNLIKELY(out + 2 > out_end)) {
+                    // Ooops.... not enough room for this surrogate pair.
+                    return out;
+                }
+                *out++ = (char16_t)(((w - 0x10000) >> 10) + 0xd800);
+                *out++ = (char16_t)(((w - 0x10000) & 0x3ff) + 0xdc00);
             }
-            *u16cur++ = (char16_t) ((codepoint & 0x3FF) + 0xDC00);
+            continue;
         }
-
-        u8cur += u8len;
     }
-    return u16cur;
+    return out;
 }
 
 }

From a4648c2be0f8cc58474c426f850ac02745154c35 Mon Sep 17 00:00:00 2001
From: Kiyoung Kim <kiyoungkim@google.com>
Date: Fri, 23 Jun 2023 11:12:38 +0900
Subject: [PATCH 0184/1487] Enable ABI dump for libcutils

Enable ABI dump for libcutils, so ABI can be stabilized from any update
after official release.

Bug: 254141417
Test: abidiff intermediates found from libcutils.vendor build
Change-Id: Ic27c82b908b7836c7bc538a24202ed8adba4d048
---
 libcutils/Android.bp                          |    8 +
 .../arm64/source-based/libcutils.so.lsdump    | 2690 ++++++++++++++++
 .../source-based/libcutils.so.lsdump          | 2700 +++++++++++++++++
 3 files changed, 5398 insertions(+)
 create mode 100644 libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
 create mode 100644 libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump

diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index 0b5c1254ea2a..92486e3357a8 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -219,11 +219,19 @@ cc_library {
             exclude_srcs: [
                 "qtaguid.cpp",
             ],
+            header_abi_checker: {
+                enabled: true,
+                ref_dump_dirs: ["abi-dumps"],
+            },
         },
         product: {
             exclude_srcs: [
                 "qtaguid.cpp",
             ],
+            header_abi_checker: {
+                enabled: true,
+                ref_dump_dirs: ["abi-dumps"],
+            },
         },
     },
 
diff --git a/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump b/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
new file mode 100644
index 000000000000..333e61c181fa
--- /dev/null
+++ b/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
@@ -0,0 +1,2690 @@
+{
+ "array_types" :
+ [
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIA0_i",
+   "name" : "int[0]",
+   "referenced_type" : "_ZTIi",
+   "self_type" : "_ZTIA0_i",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  }
+ ],
+ "builtin_types" :
+ [
+  {
+   "alignment" : 1,
+   "is_integral" : true,
+   "linker_set_key" : "_ZTIa",
+   "name" : "signed char",
+   "referenced_type" : "_ZTIa",
+   "self_type" : "_ZTIa",
+   "size" : 1
+  },
+  {
+   "alignment" : 1,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIb",
+   "name" : "bool",
+   "referenced_type" : "_ZTIb",
+   "self_type" : "_ZTIb",
+   "size" : 1
+  },
+  {
+   "alignment" : 1,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIc",
+   "name" : "char",
+   "referenced_type" : "_ZTIc",
+   "self_type" : "_ZTIc",
+   "size" : 1
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIf",
+   "name" : "float",
+   "referenced_type" : "_ZTIf",
+   "self_type" : "_ZTIf",
+   "size" : 4
+  },
+  {
+   "alignment" : 4,
+   "is_integral" : true,
+   "linker_set_key" : "_ZTIi",
+   "name" : "int",
+   "referenced_type" : "_ZTIi",
+   "self_type" : "_ZTIi",
+   "size" : 4
+  },
+  {
+   "alignment" : 4,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIj",
+   "name" : "unsigned int",
+   "referenced_type" : "_ZTIj",
+   "self_type" : "_ZTIj",
+   "size" : 4
+  },
+  {
+   "alignment" : 8,
+   "is_integral" : true,
+   "linker_set_key" : "_ZTIl",
+   "name" : "long",
+   "referenced_type" : "_ZTIl",
+   "self_type" : "_ZTIl",
+   "size" : 8
+  },
+  {
+   "alignment" : 8,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIm",
+   "name" : "unsigned long",
+   "referenced_type" : "_ZTIm",
+   "self_type" : "_ZTIm",
+   "size" : 8
+  },
+  {
+   "linker_set_key" : "_ZTIv",
+   "name" : "void",
+   "referenced_type" : "_ZTIv",
+   "self_type" : "_ZTIv"
+  }
+ ],
+ "elf_functions" :
+ [
+  {
+   "name" : "_Z23socket_make_sockaddr_unPKciP11sockaddr_unPj"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZN7android4base4TrimIRNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES8_OT_"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE4syncEv"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE6setbufEPcl"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE7seekposENS_4fposI9mbstate_tEEj"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE8overflowEi"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE9pbackfailEi"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE9underflowEv"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEEC2Ev"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEED0Ev"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEED2Ev"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__124__put_character_sequenceIcNS_11char_traitsIcEEEERNS_13basic_ostreamIT_T0_EES7_PKS4_m"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__16vectorI5EntryNS_9allocatorIS1_EEE24__emplace_back_slow_pathIJS1_EEEvDpOT_"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__17getlineIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS_13basic_istreamIT_T0_EES9_RNS_12basic_stringIS6_S7_T1_EES6_"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__1lsINS_11char_traitsIcEEEERNS_13basic_ostreamIcT_EES6_PKc"
+  },
+  {
+   "name" : "android_get_control_file"
+  },
+  {
+   "name" : "android_get_control_socket"
+  },
+  {
+   "name" : "android_get_ioprio"
+  },
+  {
+   "name" : "android_reboot"
+  },
+  {
+   "name" : "android_set_ioprio"
+  },
+  {
+   "name" : "ashmem_create_region"
+  },
+  {
+   "name" : "ashmem_get_size_region"
+  },
+  {
+   "name" : "ashmem_pin_region"
+  },
+  {
+   "name" : "ashmem_set_prot_region"
+  },
+  {
+   "name" : "ashmem_unpin_region"
+  },
+  {
+   "name" : "ashmem_valid"
+  },
+  {
+   "name" : "atrace_async_begin_body"
+  },
+  {
+   "name" : "atrace_async_end_body"
+  },
+  {
+   "name" : "atrace_async_for_track_begin_body"
+  },
+  {
+   "name" : "atrace_async_for_track_end_body"
+  },
+  {
+   "name" : "atrace_begin_body"
+  },
+  {
+   "name" : "atrace_end_body"
+  },
+  {
+   "name" : "atrace_get_enabled_tags"
+  },
+  {
+   "name" : "atrace_init"
+  },
+  {
+   "name" : "atrace_instant_body"
+  },
+  {
+   "name" : "atrace_instant_for_track_body"
+  },
+  {
+   "name" : "atrace_int64_body"
+  },
+  {
+   "name" : "atrace_int_body"
+  },
+  {
+   "name" : "atrace_set_tracing_enabled"
+  },
+  {
+   "name" : "atrace_setup"
+  },
+  {
+   "name" : "atrace_update_tags"
+  },
+  {
+   "name" : "canned_fs_config"
+  },
+  {
+   "name" : "config_bool"
+  },
+  {
+   "name" : "config_find"
+  },
+  {
+   "name" : "config_free"
+  },
+  {
+   "name" : "config_load"
+  },
+  {
+   "name" : "config_load_file"
+  },
+  {
+   "name" : "config_node"
+  },
+  {
+   "name" : "config_set"
+  },
+  {
+   "name" : "config_str"
+  },
+  {
+   "name" : "fs_config"
+  },
+  {
+   "name" : "fs_mkdirs"
+  },
+  {
+   "name" : "fs_prepare_dir"
+  },
+  {
+   "name" : "fs_prepare_dir_strict"
+  },
+  {
+   "name" : "fs_prepare_file_strict"
+  },
+  {
+   "name" : "fs_read_atomic_int"
+  },
+  {
+   "name" : "fs_write_atomic_int"
+  },
+  {
+   "name" : "hashmapCreate"
+  },
+  {
+   "name" : "hashmapForEach"
+  },
+  {
+   "name" : "hashmapFree"
+  },
+  {
+   "name" : "hashmapGet"
+  },
+  {
+   "name" : "hashmapHash"
+  },
+  {
+   "name" : "hashmapLock"
+  },
+  {
+   "name" : "hashmapPut"
+  },
+  {
+   "name" : "hashmapRemove"
+  },
+  {
+   "name" : "hashmapUnlock"
+  },
+  {
+   "name" : "klog_set_level"
+  },
+  {
+   "name" : "klog_write"
+  },
+  {
+   "name" : "klog_writev"
+  },
+  {
+   "name" : "load_canned_fs_config"
+  },
+  {
+   "name" : "load_file"
+  },
+  {
+   "name" : "multiuser_convert_sdk_sandbox_to_app_uid"
+  },
+  {
+   "name" : "multiuser_get_app_id"
+  },
+  {
+   "name" : "multiuser_get_cache_gid"
+  },
+  {
+   "name" : "multiuser_get_ext_cache_gid"
+  },
+  {
+   "name" : "multiuser_get_ext_gid"
+  },
+  {
+   "name" : "multiuser_get_sdk_sandbox_uid"
+  },
+  {
+   "name" : "multiuser_get_shared_app_gid"
+  },
+  {
+   "name" : "multiuser_get_shared_gid"
+  },
+  {
+   "name" : "multiuser_get_uid"
+  },
+  {
+   "name" : "multiuser_get_user_id"
+  },
+  {
+   "name" : "native_handle_clone"
+  },
+  {
+   "name" : "native_handle_close"
+  },
+  {
+   "name" : "native_handle_close_with_tag"
+  },
+  {
+   "name" : "native_handle_create"
+  },
+  {
+   "name" : "native_handle_delete"
+  },
+  {
+   "name" : "native_handle_init"
+  },
+  {
+   "name" : "native_handle_set_fdsan_tag"
+  },
+  {
+   "name" : "native_handle_unset_fdsan_tag"
+  },
+  {
+   "name" : "partition_wiped"
+  },
+  {
+   "name" : "property_get"
+  },
+  {
+   "name" : "property_get_bool"
+  },
+  {
+   "name" : "property_get_int32"
+  },
+  {
+   "name" : "property_get_int64"
+  },
+  {
+   "name" : "property_list"
+  },
+  {
+   "name" : "property_set"
+  },
+  {
+   "name" : "record_stream_free"
+  },
+  {
+   "name" : "record_stream_get_next"
+  },
+  {
+   "name" : "record_stream_new"
+  },
+  {
+   "name" : "socket_close"
+  },
+  {
+   "name" : "socket_get_local_port"
+  },
+  {
+   "name" : "socket_inaddr_any_server"
+  },
+  {
+   "name" : "socket_local_client"
+  },
+  {
+   "name" : "socket_local_client_connect"
+  },
+  {
+   "name" : "socket_local_server"
+  },
+  {
+   "name" : "socket_local_server_bind"
+  },
+  {
+   "name" : "socket_network_client"
+  },
+  {
+   "name" : "socket_network_client_timeout"
+  },
+  {
+   "name" : "socket_send_buffers"
+  },
+  {
+   "name" : "str_parms_add_float"
+  },
+  {
+   "name" : "str_parms_add_int"
+  },
+  {
+   "name" : "str_parms_add_str"
+  },
+  {
+   "name" : "str_parms_create"
+  },
+  {
+   "name" : "str_parms_create_str"
+  },
+  {
+   "name" : "str_parms_del"
+  },
+  {
+   "name" : "str_parms_destroy"
+  },
+  {
+   "name" : "str_parms_dump"
+  },
+  {
+   "name" : "str_parms_get_float"
+  },
+  {
+   "name" : "str_parms_get_int"
+  },
+  {
+   "name" : "str_parms_get_str"
+  },
+  {
+   "name" : "str_parms_has_key"
+  },
+  {
+   "name" : "str_parms_to_str"
+  },
+  {
+   "name" : "uevent_kernel_multicast_recv"
+  },
+  {
+   "name" : "uevent_kernel_multicast_uid_recv"
+  },
+  {
+   "name" : "uevent_kernel_recv"
+  },
+  {
+   "name" : "uevent_open_socket"
+  }
+ ],
+ "elf_objects" :
+ [
+  {
+   "binding" : "weak",
+   "name" : "_ZTCNSt3__114basic_ifstreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZTTNSt3__114basic_ifstreamIcNS_11char_traitsIcEEEE"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZTVNSt3__113basic_filebufIcNS_11char_traitsIcEEEE"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZTVNSt3__114basic_ifstreamIcNS_11char_traitsIcEEEE"
+  },
+  {
+   "name" : "atrace_enabled_tags"
+  },
+  {
+   "name" : "atrace_is_ready"
+  },
+  {
+   "name" : "atrace_marker_fd"
+  }
+ ],
+ "enum_types" :
+ [
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 0,
+     "name" : "IoSchedClass_NONE"
+    },
+    {
+     "enum_field_value" : 1,
+     "name" : "IoSchedClass_RT"
+    },
+    {
+     "enum_field_value" : 2,
+     "name" : "IoSchedClass_BE"
+    },
+    {
+     "enum_field_value" : 3,
+     "name" : "IoSchedClass_IDLE"
+    }
+   ],
+   "linker_set_key" : "_ZTI12IoSchedClass",
+   "name" : "IoSchedClass",
+   "referenced_type" : "_ZTI12IoSchedClass",
+   "self_type" : "_ZTI12IoSchedClass",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h",
+   "underlying_type" : "_ZTIj"
+  }
+ ],
+ "function_types" :
+ [
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIFbPvS_E",
+   "name" : "bool (void *, void *)",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "referenced_type" : "_ZTIFbPvS_E",
+   "return_type" : "_ZTIb",
+   "self_type" : "_ZTIFbPvS_E",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIFbPvS_S_E",
+   "name" : "bool (void *, void *, void *)",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "referenced_type" : "_ZTIFbPvS_S_E",
+   "return_type" : "_ZTIb",
+   "self_type" : "_ZTIFbPvS_S_E",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIFiPvE",
+   "name" : "int (void *)",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "referenced_type" : "_ZTIFiPvE",
+   "return_type" : "_ZTIi",
+   "self_type" : "_ZTIFiPvE",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIFvPKcS0_PvE",
+   "name" : "void (const char *, const char *, void *)",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "referenced_type" : "_ZTIFvPKcS0_PvE",
+   "return_type" : "_ZTIv",
+   "self_type" : "_ZTIFvPKcS0_PvE",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  }
+ ],
+ "functions" :
+ [
+  {
+   "function_name" : "android_get_control_file",
+   "linker_set_key" : "android_get_control_file",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/android_get_control_file.h"
+  },
+  {
+   "function_name" : "android_get_control_socket",
+   "linker_set_key" : "android_get_control_socket",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "android_get_ioprio",
+   "linker_set_key" : "android_get_ioprio",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIP12IoSchedClass"
+    },
+    {
+     "referenced_type" : "_ZTIPi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h"
+  },
+  {
+   "function_name" : "android_reboot",
+   "linker_set_key" : "android_reboot",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/android_reboot.h"
+  },
+  {
+   "function_name" : "android_set_ioprio",
+   "linker_set_key" : "android_set_ioprio",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTI12IoSchedClass"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h"
+  },
+  {
+   "function_name" : "ashmem_create_region",
+   "linker_set_key" : "ashmem_create_region",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIm"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/ashmem.h"
+  },
+  {
+   "function_name" : "ashmem_get_size_region",
+   "linker_set_key" : "ashmem_get_size_region",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/ashmem.h"
+  },
+  {
+   "function_name" : "ashmem_pin_region",
+   "linker_set_key" : "ashmem_pin_region",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIm"
+    },
+    {
+     "referenced_type" : "_ZTIm"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/ashmem.h"
+  },
+  {
+   "function_name" : "ashmem_set_prot_region",
+   "linker_set_key" : "ashmem_set_prot_region",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/ashmem.h"
+  },
+  {
+   "function_name" : "ashmem_unpin_region",
+   "linker_set_key" : "ashmem_unpin_region",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIm"
+    },
+    {
+     "referenced_type" : "_ZTIm"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/ashmem.h"
+  },
+  {
+   "function_name" : "ashmem_valid",
+   "linker_set_key" : "ashmem_valid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/ashmem.h"
+  },
+  {
+   "function_name" : "atrace_async_begin_body",
+   "linker_set_key" : "atrace_async_begin_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_async_end_body",
+   "linker_set_key" : "atrace_async_end_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_async_for_track_begin_body",
+   "linker_set_key" : "atrace_async_for_track_begin_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_async_for_track_end_body",
+   "linker_set_key" : "atrace_async_for_track_end_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_begin_body",
+   "linker_set_key" : "atrace_begin_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_end_body",
+   "linker_set_key" : "atrace_end_body",
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_get_enabled_tags",
+   "linker_set_key" : "atrace_get_enabled_tags",
+   "return_type" : "_ZTIm",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_init",
+   "linker_set_key" : "atrace_init",
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_instant_body",
+   "linker_set_key" : "atrace_instant_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_instant_for_track_body",
+   "linker_set_key" : "atrace_instant_for_track_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_int64_body",
+   "linker_set_key" : "atrace_int64_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIl"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_int_body",
+   "linker_set_key" : "atrace_int_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_set_tracing_enabled",
+   "linker_set_key" : "atrace_set_tracing_enabled",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIb"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_setup",
+   "linker_set_key" : "atrace_setup",
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_update_tags",
+   "linker_set_key" : "atrace_update_tags",
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "canned_fs_config",
+   "linker_set_key" : "canned_fs_config",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    },
+    {
+     "referenced_type" : "_ZTIPm"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/private/canned_fs_config.h"
+  },
+  {
+   "function_name" : "config_bool",
+   "linker_set_key" : "config_bool",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_find",
+   "linker_set_key" : "config_find",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIP5cnode",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_free",
+   "linker_set_key" : "config_free",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_load",
+   "linker_set_key" : "config_load",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "referenced_type" : "_ZTIPc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_load_file",
+   "linker_set_key" : "config_load_file",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_node",
+   "linker_set_key" : "config_node",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIP5cnode",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_set",
+   "linker_set_key" : "config_set",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_str",
+   "linker_set_key" : "config_str",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIPKc",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "fs_config",
+   "linker_set_key" : "fs_config",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    },
+    {
+     "referenced_type" : "_ZTIPm"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
+  },
+  {
+   "function_name" : "fs_mkdirs",
+   "linker_set_key" : "fs_mkdirs",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/fs.h"
+  },
+  {
+   "function_name" : "fs_prepare_dir",
+   "linker_set_key" : "fs_prepare_dir",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/fs.h"
+  },
+  {
+   "function_name" : "fs_prepare_dir_strict",
+   "linker_set_key" : "fs_prepare_dir_strict",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/fs.h"
+  },
+  {
+   "function_name" : "fs_prepare_file_strict",
+   "linker_set_key" : "fs_prepare_file_strict",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/fs.h"
+  },
+  {
+   "function_name" : "fs_read_atomic_int",
+   "linker_set_key" : "fs_read_atomic_int",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/fs.h"
+  },
+  {
+   "function_name" : "fs_write_atomic_int",
+   "linker_set_key" : "fs_write_atomic_int",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/fs.h"
+  },
+  {
+   "function_name" : "hashmapCreate",
+   "linker_set_key" : "hashmapCreate",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIm"
+    },
+    {
+     "referenced_type" : "_ZTIPFiPvE"
+    },
+    {
+     "referenced_type" : "_ZTIPFbPvS_E"
+    }
+   ],
+   "return_type" : "_ZTIP7Hashmap",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapForEach",
+   "linker_set_key" : "hashmapForEach",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    },
+    {
+     "referenced_type" : "_ZTIPFbPvS_S_E"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapFree",
+   "linker_set_key" : "hashmapFree",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapGet",
+   "linker_set_key" : "hashmapGet",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "return_type" : "_ZTIPv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapHash",
+   "linker_set_key" : "hashmapHash",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIm"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapLock",
+   "linker_set_key" : "hashmapLock",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapPut",
+   "linker_set_key" : "hashmapPut",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "return_type" : "_ZTIPv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapRemove",
+   "linker_set_key" : "hashmapRemove",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "return_type" : "_ZTIPv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapUnlock",
+   "linker_set_key" : "hashmapUnlock",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "klog_set_level",
+   "linker_set_key" : "klog_set_level",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/klog.h"
+  },
+  {
+   "function_name" : "klog_write",
+   "linker_set_key" : "klog_write",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/klog.h"
+  },
+  {
+   "function_name" : "klog_writev",
+   "linker_set_key" : "klog_writev",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPK5iovec"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/klog.h"
+  },
+  {
+   "function_name" : "load_canned_fs_config",
+   "linker_set_key" : "load_canned_fs_config",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/private/canned_fs_config.h"
+  },
+  {
+   "function_name" : "load_file",
+   "linker_set_key" : "load_file",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    }
+   ],
+   "return_type" : "_ZTIPv",
+   "source_file" : "system/core/libcutils/include/cutils/misc.h"
+  },
+  {
+   "function_name" : "multiuser_convert_sdk_sandbox_to_app_uid",
+   "linker_set_key" : "multiuser_convert_sdk_sandbox_to_app_uid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_app_id",
+   "linker_set_key" : "multiuser_get_app_id",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_cache_gid",
+   "linker_set_key" : "multiuser_get_cache_gid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_ext_cache_gid",
+   "linker_set_key" : "multiuser_get_ext_cache_gid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_ext_gid",
+   "linker_set_key" : "multiuser_get_ext_gid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_sdk_sandbox_uid",
+   "linker_set_key" : "multiuser_get_sdk_sandbox_uid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_shared_app_gid",
+   "linker_set_key" : "multiuser_get_shared_app_gid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_shared_gid",
+   "linker_set_key" : "multiuser_get_shared_gid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_uid",
+   "linker_set_key" : "multiuser_get_uid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_user_id",
+   "linker_set_key" : "multiuser_get_user_id",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "native_handle_clone",
+   "linker_set_key" : "native_handle_clone",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPK13native_handle"
+    }
+   ],
+   "return_type" : "_ZTIP13native_handle",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_close",
+   "linker_set_key" : "native_handle_close",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPK13native_handle"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_close_with_tag",
+   "linker_set_key" : "native_handle_close_with_tag",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPK13native_handle"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_create",
+   "linker_set_key" : "native_handle_create",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIP13native_handle",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_delete",
+   "linker_set_key" : "native_handle_delete",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP13native_handle"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_init",
+   "linker_set_key" : "native_handle_init",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIP13native_handle",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_set_fdsan_tag",
+   "linker_set_key" : "native_handle_set_fdsan_tag",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPK13native_handle"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_unset_fdsan_tag",
+   "linker_set_key" : "native_handle_unset_fdsan_tag",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPK13native_handle"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "partition_wiped",
+   "linker_set_key" : "partition_wiped",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/partition_utils.h"
+  },
+  {
+   "function_name" : "property_get",
+   "linker_set_key" : "property_get",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "function_name" : "property_get_bool",
+   "linker_set_key" : "property_get_bool",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIa"
+    }
+   ],
+   "return_type" : "_ZTIa",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "function_name" : "property_get_int32",
+   "linker_set_key" : "property_get_int32",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "function_name" : "property_get_int64",
+   "linker_set_key" : "property_get_int64",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIl"
+    }
+   ],
+   "return_type" : "_ZTIl",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "function_name" : "property_list",
+   "linker_set_key" : "property_list",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPFvPKcS0_PvE"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "function_name" : "property_set",
+   "linker_set_key" : "property_set",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "function_name" : "record_stream_free",
+   "linker_set_key" : "record_stream_free",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP12RecordStream"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
+  },
+  {
+   "function_name" : "record_stream_get_next",
+   "linker_set_key" : "record_stream_get_next",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP12RecordStream"
+    },
+    {
+     "referenced_type" : "_ZTIPPv"
+    },
+    {
+     "referenced_type" : "_ZTIPm"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
+  },
+  {
+   "function_name" : "record_stream_new",
+   "linker_set_key" : "record_stream_new",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIm"
+    }
+   ],
+   "return_type" : "_ZTIP12RecordStream",
+   "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
+  },
+  {
+   "function_name" : "socket_close",
+   "linker_set_key" : "socket_close",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_get_local_port",
+   "linker_set_key" : "socket_get_local_port",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_inaddr_any_server",
+   "linker_set_key" : "socket_inaddr_any_server",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_local_client",
+   "linker_set_key" : "socket_local_client",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_local_client_connect",
+   "linker_set_key" : "socket_local_client_connect",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_local_server",
+   "linker_set_key" : "socket_local_server",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_local_server_bind",
+   "linker_set_key" : "socket_local_server_bind",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_network_client",
+   "linker_set_key" : "socket_network_client",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_network_client_timeout",
+   "linker_set_key" : "socket_network_client_timeout",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_send_buffers",
+   "linker_set_key" : "socket_send_buffers",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPK22cutils_socket_buffer_t"
+    },
+    {
+     "referenced_type" : "_ZTIm"
+    }
+   ],
+   "return_type" : "_ZTIl",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "str_parms_add_float",
+   "linker_set_key" : "str_parms_add_float",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIf"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_add_int",
+   "linker_set_key" : "str_parms_add_int",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_add_str",
+   "linker_set_key" : "str_parms_add_str",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_create",
+   "linker_set_key" : "str_parms_create",
+   "return_type" : "_ZTIP9str_parms",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_create_str",
+   "linker_set_key" : "str_parms_create_str",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIP9str_parms",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_del",
+   "linker_set_key" : "str_parms_del",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_destroy",
+   "linker_set_key" : "str_parms_destroy",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_dump",
+   "linker_set_key" : "str_parms_dump",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_get_float",
+   "linker_set_key" : "str_parms_get_float",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPf"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_get_int",
+   "linker_set_key" : "str_parms_get_int",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_get_str",
+   "linker_set_key" : "str_parms_get_str",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_has_key",
+   "linker_set_key" : "str_parms_has_key",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_to_str",
+   "linker_set_key" : "str_parms_to_str",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    }
+   ],
+   "return_type" : "_ZTIPc",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "uevent_kernel_multicast_recv",
+   "linker_set_key" : "uevent_kernel_multicast_recv",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIm"
+    }
+   ],
+   "return_type" : "_ZTIl",
+   "source_file" : "system/core/libcutils/include/cutils/uevent.h"
+  },
+  {
+   "function_name" : "uevent_kernel_multicast_uid_recv",
+   "linker_set_key" : "uevent_kernel_multicast_uid_recv",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIm"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    }
+   ],
+   "return_type" : "_ZTIl",
+   "source_file" : "system/core/libcutils/include/cutils/uevent.h"
+  },
+  {
+   "function_name" : "uevent_kernel_recv",
+   "linker_set_key" : "uevent_kernel_recv",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIm"
+    },
+    {
+     "referenced_type" : "_ZTIb"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    }
+   ],
+   "return_type" : "_ZTIl",
+   "source_file" : "system/core/libcutils/include/cutils/uevent.h"
+  },
+  {
+   "function_name" : "uevent_open_socket",
+   "linker_set_key" : "uevent_open_socket",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIb"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/uevent.h"
+  }
+ ],
+ "global_vars" :
+ [
+  {
+   "linker_set_key" : "atrace_enabled_tags",
+   "name" : "atrace_enabled_tags",
+   "referenced_type" : "_ZTIm",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "linker_set_key" : "atrace_is_ready",
+   "name" : "atrace_is_ready",
+   "referenced_type" : "_ZTINSt3__16atomicIbEE",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "linker_set_key" : "atrace_marker_fd",
+   "name" : "atrace_marker_fd",
+   "referenced_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  }
+ ],
+ "lvalue_reference_types" : [],
+ "pointer_types" :
+ [
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIP12IoSchedClass",
+   "name" : "IoSchedClass *",
+   "referenced_type" : "_ZTI12IoSchedClass",
+   "self_type" : "_ZTIP12IoSchedClass",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIP12RecordStream",
+   "name" : "RecordStream *",
+   "referenced_type" : "_ZTI12RecordStream",
+   "self_type" : "_ZTIP12RecordStream",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIP13native_handle",
+   "name" : "native_handle *",
+   "referenced_type" : "_ZTI13native_handle",
+   "self_type" : "_ZTIP13native_handle",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIP5cnode",
+   "name" : "cnode *",
+   "referenced_type" : "_ZTI5cnode",
+   "self_type" : "_ZTIP5cnode",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIP7Hashmap",
+   "name" : "Hashmap *",
+   "referenced_type" : "_ZTI7Hashmap",
+   "self_type" : "_ZTIP7Hashmap",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIP9str_parms",
+   "name" : "str_parms *",
+   "referenced_type" : "_ZTI9str_parms",
+   "self_type" : "_ZTIP9str_parms",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPFbPvS_E",
+   "name" : "bool (*)(void *, void *)",
+   "referenced_type" : "_ZTIFbPvS_E",
+   "self_type" : "_ZTIPFbPvS_E",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPFbPvS_S_E",
+   "name" : "bool (*)(void *, void *, void *)",
+   "referenced_type" : "_ZTIFbPvS_S_E",
+   "self_type" : "_ZTIPFbPvS_S_E",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPFiPvE",
+   "name" : "int (*)(void *)",
+   "referenced_type" : "_ZTIFiPvE",
+   "self_type" : "_ZTIPFiPvE",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPFvPKcS0_PvE",
+   "name" : "void (*)(const char *, const char *, void *)",
+   "referenced_type" : "_ZTIFvPKcS0_PvE",
+   "self_type" : "_ZTIPFvPKcS0_PvE",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPK13native_handle",
+   "name" : "const native_handle *",
+   "referenced_type" : "_ZTIK13native_handle",
+   "self_type" : "_ZTIPK13native_handle",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPK22cutils_socket_buffer_t",
+   "name" : "const cutils_socket_buffer_t *",
+   "referenced_type" : "_ZTIK22cutils_socket_buffer_t",
+   "self_type" : "_ZTIPK22cutils_socket_buffer_t",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPK5iovec",
+   "name" : "const iovec *",
+   "referenced_type" : "_ZTIK5iovec",
+   "self_type" : "_ZTIPK5iovec",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/klog.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPKc",
+   "name" : "const char *",
+   "referenced_type" : "_ZTIKc",
+   "self_type" : "_ZTIPKc",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPKv",
+   "name" : "const void *",
+   "referenced_type" : "_ZTIKv",
+   "self_type" : "_ZTIPKv",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPPv",
+   "name" : "void **",
+   "referenced_type" : "_ZTIPv",
+   "self_type" : "_ZTIPPv",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPc",
+   "name" : "char *",
+   "referenced_type" : "_ZTIc",
+   "self_type" : "_ZTIPc",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPf",
+   "name" : "float *",
+   "referenced_type" : "_ZTIf",
+   "self_type" : "_ZTIPf",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPi",
+   "name" : "int *",
+   "referenced_type" : "_ZTIi",
+   "self_type" : "_ZTIPi",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPj",
+   "name" : "unsigned int *",
+   "referenced_type" : "_ZTIj",
+   "self_type" : "_ZTIPj",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/misc.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPm",
+   "name" : "unsigned long *",
+   "referenced_type" : "_ZTIm",
+   "self_type" : "_ZTIPm",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPv",
+   "name" : "void *",
+   "referenced_type" : "_ZTIv",
+   "self_type" : "_ZTIPv",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/misc.h"
+  }
+ ],
+ "qualified_types" :
+ [
+  {
+   "alignment" : 4,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIK13native_handle",
+   "name" : "const native_handle",
+   "referenced_type" : "_ZTI13native_handle",
+   "self_type" : "_ZTIK13native_handle",
+   "size" : 12,
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "alignment" : 8,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIK22cutils_socket_buffer_t",
+   "name" : "const cutils_socket_buffer_t",
+   "referenced_type" : "_ZTI22cutils_socket_buffer_t",
+   "self_type" : "_ZTIK22cutils_socket_buffer_t",
+   "size" : 16,
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "alignment" : 8,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIK5iovec",
+   "name" : "const iovec",
+   "referenced_type" : "_ZTI5iovec",
+   "self_type" : "_ZTIK5iovec",
+   "size" : 16,
+   "source_file" : "system/core/libcutils/include/cutils/klog.h"
+  },
+  {
+   "alignment" : 1,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIKc",
+   "name" : "const char",
+   "referenced_type" : "_ZTIc",
+   "self_type" : "_ZTIKc",
+   "size" : 1,
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "is_const" : true,
+   "linker_set_key" : "_ZTIKv",
+   "name" : "const void",
+   "referenced_type" : "_ZTIv",
+   "self_type" : "_ZTIKv",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  }
+ ],
+ "record_types" :
+ [
+  {
+   "alignment" : 4,
+   "fields" :
+   [
+    {
+     "field_name" : "version",
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "field_name" : "numFds",
+     "field_offset" : 32,
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "field_name" : "numInts",
+     "field_offset" : 64,
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "field_name" : "data",
+     "field_offset" : 96,
+     "referenced_type" : "_ZTIA0_i"
+    }
+   ],
+   "linker_set_key" : "_ZTI13native_handle",
+   "name" : "native_handle",
+   "referenced_type" : "_ZTI13native_handle",
+   "self_type" : "_ZTI13native_handle",
+   "size" : 12,
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "alignment" : 8,
+   "fields" :
+   [
+    {
+     "field_name" : "data",
+     "referenced_type" : "_ZTIPKv"
+    },
+    {
+     "field_name" : "length",
+     "field_offset" : 64,
+     "referenced_type" : "_ZTIm"
+    }
+   ],
+   "linker_set_key" : "_ZTI22cutils_socket_buffer_t",
+   "name" : "cutils_socket_buffer_t",
+   "referenced_type" : "_ZTI22cutils_socket_buffer_t",
+   "self_type" : "_ZTI22cutils_socket_buffer_t",
+   "size" : 16,
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "alignment" : 8,
+   "fields" :
+   [
+    {
+     "field_name" : "next",
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "field_name" : "first_child",
+     "field_offset" : 64,
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "field_name" : "last_child",
+     "field_offset" : 128,
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "field_name" : "name",
+     "field_offset" : 192,
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "field_name" : "value",
+     "field_offset" : 256,
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "linker_set_key" : "_ZTI5cnode",
+   "name" : "cnode",
+   "referenced_type" : "_ZTI5cnode",
+   "self_type" : "_ZTI5cnode",
+   "size" : 40,
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  }
+ ],
+ "rvalue_reference_types" : []
+}
diff --git a/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump b/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
new file mode 100644
index 000000000000..f612fb9420a4
--- /dev/null
+++ b/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
@@ -0,0 +1,2700 @@
+{
+ "array_types" :
+ [
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIA0_i",
+   "name" : "int[0]",
+   "referenced_type" : "_ZTIi",
+   "self_type" : "_ZTIA0_i",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  }
+ ],
+ "builtin_types" :
+ [
+  {
+   "alignment" : 1,
+   "is_integral" : true,
+   "linker_set_key" : "_ZTIa",
+   "name" : "signed char",
+   "referenced_type" : "_ZTIa",
+   "self_type" : "_ZTIa",
+   "size" : 1
+  },
+  {
+   "alignment" : 1,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIb",
+   "name" : "bool",
+   "referenced_type" : "_ZTIb",
+   "self_type" : "_ZTIb",
+   "size" : 1
+  },
+  {
+   "alignment" : 1,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIc",
+   "name" : "char",
+   "referenced_type" : "_ZTIc",
+   "self_type" : "_ZTIc",
+   "size" : 1
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIf",
+   "name" : "float",
+   "referenced_type" : "_ZTIf",
+   "self_type" : "_ZTIf",
+   "size" : 4
+  },
+  {
+   "alignment" : 4,
+   "is_integral" : true,
+   "linker_set_key" : "_ZTIi",
+   "name" : "int",
+   "referenced_type" : "_ZTIi",
+   "self_type" : "_ZTIi",
+   "size" : 4
+  },
+  {
+   "alignment" : 4,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIj",
+   "name" : "unsigned int",
+   "referenced_type" : "_ZTIj",
+   "self_type" : "_ZTIj",
+   "size" : 4
+  },
+  {
+   "alignment" : 2,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIt",
+   "name" : "unsigned short",
+   "referenced_type" : "_ZTIt",
+   "self_type" : "_ZTIt",
+   "size" : 2
+  },
+  {
+   "linker_set_key" : "_ZTIv",
+   "name" : "void",
+   "referenced_type" : "_ZTIv",
+   "self_type" : "_ZTIv"
+  },
+  {
+   "alignment" : 8,
+   "is_integral" : true,
+   "linker_set_key" : "_ZTIx",
+   "name" : "long long",
+   "referenced_type" : "_ZTIx",
+   "self_type" : "_ZTIx",
+   "size" : 8
+  },
+  {
+   "alignment" : 8,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIy",
+   "name" : "unsigned long long",
+   "referenced_type" : "_ZTIy",
+   "self_type" : "_ZTIy",
+   "size" : 8
+  }
+ ],
+ "elf_functions" :
+ [
+  {
+   "name" : "_Z23socket_make_sockaddr_unPKciP11sockaddr_unPi"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZN7android4base4TrimIRNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES8_OT_"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE4syncEv"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE6setbufEPci"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE7seekposENS_4fposI9mbstate_tEEj"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE8overflowEi"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE9pbackfailEi"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE9underflowEv"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEEC2Ev"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEED0Ev"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEED2Ev"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__124__put_character_sequenceIcNS_11char_traitsIcEEEERNS_13basic_ostreamIT_T0_EES7_PKS4_j"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__16vectorI5EntryNS_9allocatorIS1_EEE24__emplace_back_slow_pathIJS1_EEEvDpOT_"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__17getlineIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS_13basic_istreamIT_T0_EES9_RNS_12basic_stringIS6_S7_T1_EES6_"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__1lsINS_11char_traitsIcEEEERNS_13basic_ostreamIcT_EES6_PKc"
+  },
+  {
+   "name" : "android_get_control_file"
+  },
+  {
+   "name" : "android_get_control_socket"
+  },
+  {
+   "name" : "android_get_ioprio"
+  },
+  {
+   "name" : "android_reboot"
+  },
+  {
+   "name" : "android_set_ioprio"
+  },
+  {
+   "name" : "ashmem_create_region"
+  },
+  {
+   "name" : "ashmem_get_size_region"
+  },
+  {
+   "name" : "ashmem_pin_region"
+  },
+  {
+   "name" : "ashmem_set_prot_region"
+  },
+  {
+   "name" : "ashmem_unpin_region"
+  },
+  {
+   "name" : "ashmem_valid"
+  },
+  {
+   "name" : "atrace_async_begin_body"
+  },
+  {
+   "name" : "atrace_async_end_body"
+  },
+  {
+   "name" : "atrace_async_for_track_begin_body"
+  },
+  {
+   "name" : "atrace_async_for_track_end_body"
+  },
+  {
+   "name" : "atrace_begin_body"
+  },
+  {
+   "name" : "atrace_end_body"
+  },
+  {
+   "name" : "atrace_get_enabled_tags"
+  },
+  {
+   "name" : "atrace_init"
+  },
+  {
+   "name" : "atrace_instant_body"
+  },
+  {
+   "name" : "atrace_instant_for_track_body"
+  },
+  {
+   "name" : "atrace_int64_body"
+  },
+  {
+   "name" : "atrace_int_body"
+  },
+  {
+   "name" : "atrace_set_tracing_enabled"
+  },
+  {
+   "name" : "atrace_setup"
+  },
+  {
+   "name" : "atrace_update_tags"
+  },
+  {
+   "name" : "canned_fs_config"
+  },
+  {
+   "name" : "config_bool"
+  },
+  {
+   "name" : "config_find"
+  },
+  {
+   "name" : "config_free"
+  },
+  {
+   "name" : "config_load"
+  },
+  {
+   "name" : "config_load_file"
+  },
+  {
+   "name" : "config_node"
+  },
+  {
+   "name" : "config_set"
+  },
+  {
+   "name" : "config_str"
+  },
+  {
+   "name" : "fs_config"
+  },
+  {
+   "name" : "fs_mkdirs"
+  },
+  {
+   "name" : "fs_prepare_dir"
+  },
+  {
+   "name" : "fs_prepare_dir_strict"
+  },
+  {
+   "name" : "fs_prepare_file_strict"
+  },
+  {
+   "name" : "fs_read_atomic_int"
+  },
+  {
+   "name" : "fs_write_atomic_int"
+  },
+  {
+   "name" : "hashmapCreate"
+  },
+  {
+   "name" : "hashmapForEach"
+  },
+  {
+   "name" : "hashmapFree"
+  },
+  {
+   "name" : "hashmapGet"
+  },
+  {
+   "name" : "hashmapHash"
+  },
+  {
+   "name" : "hashmapLock"
+  },
+  {
+   "name" : "hashmapPut"
+  },
+  {
+   "name" : "hashmapRemove"
+  },
+  {
+   "name" : "hashmapUnlock"
+  },
+  {
+   "name" : "klog_set_level"
+  },
+  {
+   "name" : "klog_write"
+  },
+  {
+   "name" : "klog_writev"
+  },
+  {
+   "name" : "load_canned_fs_config"
+  },
+  {
+   "name" : "load_file"
+  },
+  {
+   "name" : "multiuser_convert_sdk_sandbox_to_app_uid"
+  },
+  {
+   "name" : "multiuser_get_app_id"
+  },
+  {
+   "name" : "multiuser_get_cache_gid"
+  },
+  {
+   "name" : "multiuser_get_ext_cache_gid"
+  },
+  {
+   "name" : "multiuser_get_ext_gid"
+  },
+  {
+   "name" : "multiuser_get_sdk_sandbox_uid"
+  },
+  {
+   "name" : "multiuser_get_shared_app_gid"
+  },
+  {
+   "name" : "multiuser_get_shared_gid"
+  },
+  {
+   "name" : "multiuser_get_uid"
+  },
+  {
+   "name" : "multiuser_get_user_id"
+  },
+  {
+   "name" : "native_handle_clone"
+  },
+  {
+   "name" : "native_handle_close"
+  },
+  {
+   "name" : "native_handle_close_with_tag"
+  },
+  {
+   "name" : "native_handle_create"
+  },
+  {
+   "name" : "native_handle_delete"
+  },
+  {
+   "name" : "native_handle_init"
+  },
+  {
+   "name" : "native_handle_set_fdsan_tag"
+  },
+  {
+   "name" : "native_handle_unset_fdsan_tag"
+  },
+  {
+   "name" : "partition_wiped"
+  },
+  {
+   "name" : "property_get"
+  },
+  {
+   "name" : "property_get_bool"
+  },
+  {
+   "name" : "property_get_int32"
+  },
+  {
+   "name" : "property_get_int64"
+  },
+  {
+   "name" : "property_list"
+  },
+  {
+   "name" : "property_set"
+  },
+  {
+   "name" : "record_stream_free"
+  },
+  {
+   "name" : "record_stream_get_next"
+  },
+  {
+   "name" : "record_stream_new"
+  },
+  {
+   "name" : "socket_close"
+  },
+  {
+   "name" : "socket_get_local_port"
+  },
+  {
+   "name" : "socket_inaddr_any_server"
+  },
+  {
+   "name" : "socket_local_client"
+  },
+  {
+   "name" : "socket_local_client_connect"
+  },
+  {
+   "name" : "socket_local_server"
+  },
+  {
+   "name" : "socket_local_server_bind"
+  },
+  {
+   "name" : "socket_network_client"
+  },
+  {
+   "name" : "socket_network_client_timeout"
+  },
+  {
+   "name" : "socket_send_buffers"
+  },
+  {
+   "name" : "str_parms_add_float"
+  },
+  {
+   "name" : "str_parms_add_int"
+  },
+  {
+   "name" : "str_parms_add_str"
+  },
+  {
+   "name" : "str_parms_create"
+  },
+  {
+   "name" : "str_parms_create_str"
+  },
+  {
+   "name" : "str_parms_del"
+  },
+  {
+   "name" : "str_parms_destroy"
+  },
+  {
+   "name" : "str_parms_dump"
+  },
+  {
+   "name" : "str_parms_get_float"
+  },
+  {
+   "name" : "str_parms_get_int"
+  },
+  {
+   "name" : "str_parms_get_str"
+  },
+  {
+   "name" : "str_parms_has_key"
+  },
+  {
+   "name" : "str_parms_to_str"
+  },
+  {
+   "name" : "uevent_kernel_multicast_recv"
+  },
+  {
+   "name" : "uevent_kernel_multicast_uid_recv"
+  },
+  {
+   "name" : "uevent_kernel_recv"
+  },
+  {
+   "name" : "uevent_open_socket"
+  }
+ ],
+ "elf_objects" :
+ [
+  {
+   "binding" : "weak",
+   "name" : "_ZTCNSt3__114basic_ifstreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZTTNSt3__114basic_ifstreamIcNS_11char_traitsIcEEEE"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZTVNSt3__113basic_filebufIcNS_11char_traitsIcEEEE"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZTVNSt3__114basic_ifstreamIcNS_11char_traitsIcEEEE"
+  },
+  {
+   "name" : "atrace_enabled_tags"
+  },
+  {
+   "name" : "atrace_is_ready"
+  },
+  {
+   "name" : "atrace_marker_fd"
+  }
+ ],
+ "enum_types" :
+ [
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 0,
+     "name" : "IoSchedClass_NONE"
+    },
+    {
+     "enum_field_value" : 1,
+     "name" : "IoSchedClass_RT"
+    },
+    {
+     "enum_field_value" : 2,
+     "name" : "IoSchedClass_BE"
+    },
+    {
+     "enum_field_value" : 3,
+     "name" : "IoSchedClass_IDLE"
+    }
+   ],
+   "linker_set_key" : "_ZTI12IoSchedClass",
+   "name" : "IoSchedClass",
+   "referenced_type" : "_ZTI12IoSchedClass",
+   "self_type" : "_ZTI12IoSchedClass",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h",
+   "underlying_type" : "_ZTIj"
+  }
+ ],
+ "function_types" :
+ [
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIFbPvS_E",
+   "name" : "bool (void *, void *)",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "referenced_type" : "_ZTIFbPvS_E",
+   "return_type" : "_ZTIb",
+   "self_type" : "_ZTIFbPvS_E",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIFbPvS_S_E",
+   "name" : "bool (void *, void *, void *)",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "referenced_type" : "_ZTIFbPvS_S_E",
+   "return_type" : "_ZTIb",
+   "self_type" : "_ZTIFbPvS_S_E",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIFiPvE",
+   "name" : "int (void *)",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "referenced_type" : "_ZTIFiPvE",
+   "return_type" : "_ZTIi",
+   "self_type" : "_ZTIFiPvE",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIFvPKcS0_PvE",
+   "name" : "void (const char *, const char *, void *)",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "referenced_type" : "_ZTIFvPKcS0_PvE",
+   "return_type" : "_ZTIv",
+   "self_type" : "_ZTIFvPKcS0_PvE",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  }
+ ],
+ "functions" :
+ [
+  {
+   "function_name" : "android_get_control_file",
+   "linker_set_key" : "android_get_control_file",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/android_get_control_file.h"
+  },
+  {
+   "function_name" : "android_get_control_socket",
+   "linker_set_key" : "android_get_control_socket",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "android_get_ioprio",
+   "linker_set_key" : "android_get_ioprio",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIP12IoSchedClass"
+    },
+    {
+     "referenced_type" : "_ZTIPi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h"
+  },
+  {
+   "function_name" : "android_reboot",
+   "linker_set_key" : "android_reboot",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/android_reboot.h"
+  },
+  {
+   "function_name" : "android_set_ioprio",
+   "linker_set_key" : "android_set_ioprio",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTI12IoSchedClass"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h"
+  },
+  {
+   "function_name" : "ashmem_create_region",
+   "linker_set_key" : "ashmem_create_region",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/ashmem.h"
+  },
+  {
+   "function_name" : "ashmem_get_size_region",
+   "linker_set_key" : "ashmem_get_size_region",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/ashmem.h"
+  },
+  {
+   "function_name" : "ashmem_pin_region",
+   "linker_set_key" : "ashmem_pin_region",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/ashmem.h"
+  },
+  {
+   "function_name" : "ashmem_set_prot_region",
+   "linker_set_key" : "ashmem_set_prot_region",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/ashmem.h"
+  },
+  {
+   "function_name" : "ashmem_unpin_region",
+   "linker_set_key" : "ashmem_unpin_region",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/ashmem.h"
+  },
+  {
+   "function_name" : "ashmem_valid",
+   "linker_set_key" : "ashmem_valid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/ashmem.h"
+  },
+  {
+   "function_name" : "atrace_async_begin_body",
+   "linker_set_key" : "atrace_async_begin_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_async_end_body",
+   "linker_set_key" : "atrace_async_end_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_async_for_track_begin_body",
+   "linker_set_key" : "atrace_async_for_track_begin_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_async_for_track_end_body",
+   "linker_set_key" : "atrace_async_for_track_end_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_begin_body",
+   "linker_set_key" : "atrace_begin_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_end_body",
+   "linker_set_key" : "atrace_end_body",
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_get_enabled_tags",
+   "linker_set_key" : "atrace_get_enabled_tags",
+   "return_type" : "_ZTIy",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_init",
+   "linker_set_key" : "atrace_init",
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_instant_body",
+   "linker_set_key" : "atrace_instant_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_instant_for_track_body",
+   "linker_set_key" : "atrace_instant_for_track_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_int64_body",
+   "linker_set_key" : "atrace_int64_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIx"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_int_body",
+   "linker_set_key" : "atrace_int_body",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_set_tracing_enabled",
+   "linker_set_key" : "atrace_set_tracing_enabled",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIb"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_setup",
+   "linker_set_key" : "atrace_setup",
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "atrace_update_tags",
+   "linker_set_key" : "atrace_update_tags",
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "function_name" : "canned_fs_config",
+   "linker_set_key" : "canned_fs_config",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    },
+    {
+     "referenced_type" : "_ZTIPy"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/private/canned_fs_config.h"
+  },
+  {
+   "function_name" : "config_bool",
+   "linker_set_key" : "config_bool",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_find",
+   "linker_set_key" : "config_find",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIP5cnode",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_free",
+   "linker_set_key" : "config_free",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_load",
+   "linker_set_key" : "config_load",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "referenced_type" : "_ZTIPc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_load_file",
+   "linker_set_key" : "config_load_file",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_node",
+   "linker_set_key" : "config_node",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIP5cnode",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_set",
+   "linker_set_key" : "config_set",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "config_str",
+   "linker_set_key" : "config_str",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIPKc",
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "function_name" : "fs_config",
+   "linker_set_key" : "fs_config",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    },
+    {
+     "referenced_type" : "_ZTIPy"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
+  },
+  {
+   "function_name" : "fs_mkdirs",
+   "linker_set_key" : "fs_mkdirs",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIt"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/fs.h"
+  },
+  {
+   "function_name" : "fs_prepare_dir",
+   "linker_set_key" : "fs_prepare_dir",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIt"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/fs.h"
+  },
+  {
+   "function_name" : "fs_prepare_dir_strict",
+   "linker_set_key" : "fs_prepare_dir_strict",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIt"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/fs.h"
+  },
+  {
+   "function_name" : "fs_prepare_file_strict",
+   "linker_set_key" : "fs_prepare_file_strict",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIt"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/fs.h"
+  },
+  {
+   "function_name" : "fs_read_atomic_int",
+   "linker_set_key" : "fs_read_atomic_int",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/fs.h"
+  },
+  {
+   "function_name" : "fs_write_atomic_int",
+   "linker_set_key" : "fs_write_atomic_int",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/fs.h"
+  },
+  {
+   "function_name" : "hashmapCreate",
+   "linker_set_key" : "hashmapCreate",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIPFiPvE"
+    },
+    {
+     "referenced_type" : "_ZTIPFbPvS_E"
+    }
+   ],
+   "return_type" : "_ZTIP7Hashmap",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapForEach",
+   "linker_set_key" : "hashmapForEach",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    },
+    {
+     "referenced_type" : "_ZTIPFbPvS_S_E"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapFree",
+   "linker_set_key" : "hashmapFree",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapGet",
+   "linker_set_key" : "hashmapGet",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "return_type" : "_ZTIPv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapHash",
+   "linker_set_key" : "hashmapHash",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapLock",
+   "linker_set_key" : "hashmapLock",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapPut",
+   "linker_set_key" : "hashmapPut",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "return_type" : "_ZTIPv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapRemove",
+   "linker_set_key" : "hashmapRemove",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "return_type" : "_ZTIPv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "hashmapUnlock",
+   "linker_set_key" : "hashmapUnlock",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP7Hashmap"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "function_name" : "klog_set_level",
+   "linker_set_key" : "klog_set_level",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/klog.h"
+  },
+  {
+   "function_name" : "klog_write",
+   "linker_set_key" : "klog_write",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/klog.h"
+  },
+  {
+   "function_name" : "klog_writev",
+   "linker_set_key" : "klog_writev",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPK5iovec"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/klog.h"
+  },
+  {
+   "function_name" : "load_canned_fs_config",
+   "linker_set_key" : "load_canned_fs_config",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/private/canned_fs_config.h"
+  },
+  {
+   "function_name" : "load_file",
+   "linker_set_key" : "load_file",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    }
+   ],
+   "return_type" : "_ZTIPv",
+   "source_file" : "system/core/libcutils/include/cutils/misc.h"
+  },
+  {
+   "function_name" : "multiuser_convert_sdk_sandbox_to_app_uid",
+   "linker_set_key" : "multiuser_convert_sdk_sandbox_to_app_uid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_app_id",
+   "linker_set_key" : "multiuser_get_app_id",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_cache_gid",
+   "linker_set_key" : "multiuser_get_cache_gid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_ext_cache_gid",
+   "linker_set_key" : "multiuser_get_ext_cache_gid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_ext_gid",
+   "linker_set_key" : "multiuser_get_ext_gid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_sdk_sandbox_uid",
+   "linker_set_key" : "multiuser_get_sdk_sandbox_uid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_shared_app_gid",
+   "linker_set_key" : "multiuser_get_shared_app_gid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_shared_gid",
+   "linker_set_key" : "multiuser_get_shared_gid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_uid",
+   "linker_set_key" : "multiuser_get_uid",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "multiuser_get_user_id",
+   "linker_set_key" : "multiuser_get_user_id",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIj",
+   "source_file" : "system/core/libcutils/include/cutils/multiuser.h"
+  },
+  {
+   "function_name" : "native_handle_clone",
+   "linker_set_key" : "native_handle_clone",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPK13native_handle"
+    }
+   ],
+   "return_type" : "_ZTIP13native_handle",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_close",
+   "linker_set_key" : "native_handle_close",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPK13native_handle"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_close_with_tag",
+   "linker_set_key" : "native_handle_close_with_tag",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPK13native_handle"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_create",
+   "linker_set_key" : "native_handle_create",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIP13native_handle",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_delete",
+   "linker_set_key" : "native_handle_delete",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP13native_handle"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_init",
+   "linker_set_key" : "native_handle_init",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIP13native_handle",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_set_fdsan_tag",
+   "linker_set_key" : "native_handle_set_fdsan_tag",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPK13native_handle"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "native_handle_unset_fdsan_tag",
+   "linker_set_key" : "native_handle_unset_fdsan_tag",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPK13native_handle"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "function_name" : "partition_wiped",
+   "linker_set_key" : "partition_wiped",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/partition_utils.h"
+  },
+  {
+   "function_name" : "property_get",
+   "linker_set_key" : "property_get",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "function_name" : "property_get_bool",
+   "linker_set_key" : "property_get_bool",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIa"
+    }
+   ],
+   "return_type" : "_ZTIa",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "function_name" : "property_get_int32",
+   "linker_set_key" : "property_get_int32",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "function_name" : "property_get_int64",
+   "linker_set_key" : "property_get_int64",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIx"
+    }
+   ],
+   "return_type" : "_ZTIx",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "function_name" : "property_list",
+   "linker_set_key" : "property_list",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPFvPKcS0_PvE"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "function_name" : "property_set",
+   "linker_set_key" : "property_set",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "function_name" : "record_stream_free",
+   "linker_set_key" : "record_stream_free",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP12RecordStream"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
+  },
+  {
+   "function_name" : "record_stream_get_next",
+   "linker_set_key" : "record_stream_get_next",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP12RecordStream"
+    },
+    {
+     "referenced_type" : "_ZTIPPv"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
+  },
+  {
+   "function_name" : "record_stream_new",
+   "linker_set_key" : "record_stream_new",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIP12RecordStream",
+   "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
+  },
+  {
+   "function_name" : "socket_close",
+   "linker_set_key" : "socket_close",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_get_local_port",
+   "linker_set_key" : "socket_get_local_port",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_inaddr_any_server",
+   "linker_set_key" : "socket_inaddr_any_server",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_local_client",
+   "linker_set_key" : "socket_local_client",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_local_client_connect",
+   "linker_set_key" : "socket_local_client_connect",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_local_server",
+   "linker_set_key" : "socket_local_server",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_local_server_bind",
+   "linker_set_key" : "socket_local_server_bind",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_network_client",
+   "linker_set_key" : "socket_network_client",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_network_client_timeout",
+   "linker_set_key" : "socket_network_client_timeout",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "socket_send_buffers",
+   "linker_set_key" : "socket_send_buffers",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPK22cutils_socket_buffer_t"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "function_name" : "str_parms_add_float",
+   "linker_set_key" : "str_parms_add_float",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIf"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_add_int",
+   "linker_set_key" : "str_parms_add_int",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_add_str",
+   "linker_set_key" : "str_parms_add_str",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_create",
+   "linker_set_key" : "str_parms_create",
+   "return_type" : "_ZTIP9str_parms",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_create_str",
+   "linker_set_key" : "str_parms_create_str",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIP9str_parms",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_del",
+   "linker_set_key" : "str_parms_del",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_destroy",
+   "linker_set_key" : "str_parms_destroy",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_dump",
+   "linker_set_key" : "str_parms_dump",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_get_float",
+   "linker_set_key" : "str_parms_get_float",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPf"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_get_int",
+   "linker_set_key" : "str_parms_get_int",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_get_str",
+   "linker_set_key" : "str_parms_get_str",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIPc"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_has_key",
+   "linker_set_key" : "str_parms_has_key",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "str_parms_to_str",
+   "linker_set_key" : "str_parms_to_str",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIP9str_parms"
+    }
+   ],
+   "return_type" : "_ZTIPc",
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "function_name" : "uevent_kernel_multicast_recv",
+   "linker_set_key" : "uevent_kernel_multicast_recv",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/uevent.h"
+  },
+  {
+   "function_name" : "uevent_kernel_multicast_uid_recv",
+   "linker_set_key" : "uevent_kernel_multicast_uid_recv",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/uevent.h"
+  },
+  {
+   "function_name" : "uevent_kernel_recv",
+   "linker_set_key" : "uevent_kernel_recv",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "referenced_type" : "_ZTIb"
+    },
+    {
+     "referenced_type" : "_ZTIPj"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/uevent.h"
+  },
+  {
+   "function_name" : "uevent_open_socket",
+   "linker_set_key" : "uevent_open_socket",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIb"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/uevent.h"
+  }
+ ],
+ "global_vars" :
+ [
+  {
+   "linker_set_key" : "atrace_enabled_tags",
+   "name" : "atrace_enabled_tags",
+   "referenced_type" : "_ZTIy",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "linker_set_key" : "atrace_is_ready",
+   "name" : "atrace_is_ready",
+   "referenced_type" : "_ZTINSt3__16atomicIbEE",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  },
+  {
+   "linker_set_key" : "atrace_marker_fd",
+   "name" : "atrace_marker_fd",
+   "referenced_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/trace.h"
+  }
+ ],
+ "lvalue_reference_types" : [],
+ "pointer_types" :
+ [
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIP12IoSchedClass",
+   "name" : "IoSchedClass *",
+   "referenced_type" : "_ZTI12IoSchedClass",
+   "self_type" : "_ZTIP12IoSchedClass",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIP12RecordStream",
+   "name" : "RecordStream *",
+   "referenced_type" : "_ZTI12RecordStream",
+   "self_type" : "_ZTIP12RecordStream",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIP13native_handle",
+   "name" : "native_handle *",
+   "referenced_type" : "_ZTI13native_handle",
+   "self_type" : "_ZTIP13native_handle",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIP5cnode",
+   "name" : "cnode *",
+   "referenced_type" : "_ZTI5cnode",
+   "self_type" : "_ZTIP5cnode",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIP7Hashmap",
+   "name" : "Hashmap *",
+   "referenced_type" : "_ZTI7Hashmap",
+   "self_type" : "_ZTIP7Hashmap",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIP9str_parms",
+   "name" : "str_parms *",
+   "referenced_type" : "_ZTI9str_parms",
+   "self_type" : "_ZTIP9str_parms",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPFbPvS_E",
+   "name" : "bool (*)(void *, void *)",
+   "referenced_type" : "_ZTIFbPvS_E",
+   "self_type" : "_ZTIPFbPvS_E",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPFbPvS_S_E",
+   "name" : "bool (*)(void *, void *, void *)",
+   "referenced_type" : "_ZTIFbPvS_S_E",
+   "self_type" : "_ZTIPFbPvS_S_E",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPFiPvE",
+   "name" : "int (*)(void *)",
+   "referenced_type" : "_ZTIFiPvE",
+   "self_type" : "_ZTIPFiPvE",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPFvPKcS0_PvE",
+   "name" : "void (*)(const char *, const char *, void *)",
+   "referenced_type" : "_ZTIFvPKcS0_PvE",
+   "self_type" : "_ZTIPFvPKcS0_PvE",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/properties.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPK13native_handle",
+   "name" : "const native_handle *",
+   "referenced_type" : "_ZTIK13native_handle",
+   "self_type" : "_ZTIPK13native_handle",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPK22cutils_socket_buffer_t",
+   "name" : "const cutils_socket_buffer_t *",
+   "referenced_type" : "_ZTIK22cutils_socket_buffer_t",
+   "self_type" : "_ZTIPK22cutils_socket_buffer_t",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPK5iovec",
+   "name" : "const iovec *",
+   "referenced_type" : "_ZTIK5iovec",
+   "self_type" : "_ZTIPK5iovec",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/klog.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPKc",
+   "name" : "const char *",
+   "referenced_type" : "_ZTIKc",
+   "self_type" : "_ZTIPKc",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPKv",
+   "name" : "const void *",
+   "referenced_type" : "_ZTIKv",
+   "self_type" : "_ZTIPKv",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPPv",
+   "name" : "void **",
+   "referenced_type" : "_ZTIPv",
+   "self_type" : "_ZTIPPv",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPc",
+   "name" : "char *",
+   "referenced_type" : "_ZTIc",
+   "self_type" : "_ZTIPc",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPf",
+   "name" : "float *",
+   "referenced_type" : "_ZTIf",
+   "self_type" : "_ZTIPf",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPi",
+   "name" : "int *",
+   "referenced_type" : "_ZTIi",
+   "self_type" : "_ZTIPi",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPj",
+   "name" : "unsigned int *",
+   "referenced_type" : "_ZTIj",
+   "self_type" : "_ZTIPj",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/misc.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPv",
+   "name" : "void *",
+   "referenced_type" : "_ZTIv",
+   "self_type" : "_ZTIPv",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/cutils/misc.h"
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPy",
+   "name" : "unsigned long long *",
+   "referenced_type" : "_ZTIy",
+   "self_type" : "_ZTIPy",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/private/canned_fs_config.h"
+  }
+ ],
+ "qualified_types" :
+ [
+  {
+   "alignment" : 4,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIK13native_handle",
+   "name" : "const native_handle",
+   "referenced_type" : "_ZTI13native_handle",
+   "self_type" : "_ZTIK13native_handle",
+   "size" : 12,
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "alignment" : 4,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIK22cutils_socket_buffer_t",
+   "name" : "const cutils_socket_buffer_t",
+   "referenced_type" : "_ZTI22cutils_socket_buffer_t",
+   "self_type" : "_ZTIK22cutils_socket_buffer_t",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "alignment" : 4,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIK5iovec",
+   "name" : "const iovec",
+   "referenced_type" : "_ZTI5iovec",
+   "self_type" : "_ZTIK5iovec",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/klog.h"
+  },
+  {
+   "alignment" : 1,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIKc",
+   "name" : "const char",
+   "referenced_type" : "_ZTIc",
+   "self_type" : "_ZTIKc",
+   "size" : 1,
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "is_const" : true,
+   "linker_set_key" : "_ZTIKv",
+   "name" : "const void",
+   "referenced_type" : "_ZTIv",
+   "self_type" : "_ZTIKv",
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  }
+ ],
+ "record_types" :
+ [
+  {
+   "alignment" : 4,
+   "fields" :
+   [
+    {
+     "field_name" : "version",
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "field_name" : "numFds",
+     "field_offset" : 32,
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "field_name" : "numInts",
+     "field_offset" : 64,
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "field_name" : "data",
+     "field_offset" : 96,
+     "referenced_type" : "_ZTIA0_i"
+    }
+   ],
+   "linker_set_key" : "_ZTI13native_handle",
+   "name" : "native_handle",
+   "referenced_type" : "_ZTI13native_handle",
+   "self_type" : "_ZTI13native_handle",
+   "size" : 12,
+   "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
+  },
+  {
+   "alignment" : 4,
+   "fields" :
+   [
+    {
+     "field_name" : "data",
+     "referenced_type" : "_ZTIPKv"
+    },
+    {
+     "field_name" : "length",
+     "field_offset" : 32,
+     "referenced_type" : "_ZTIj"
+    }
+   ],
+   "linker_set_key" : "_ZTI22cutils_socket_buffer_t",
+   "name" : "cutils_socket_buffer_t",
+   "referenced_type" : "_ZTI22cutils_socket_buffer_t",
+   "self_type" : "_ZTI22cutils_socket_buffer_t",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/cutils/sockets.h"
+  },
+  {
+   "alignment" : 4,
+   "fields" :
+   [
+    {
+     "field_name" : "next",
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "field_name" : "first_child",
+     "field_offset" : 32,
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "field_name" : "last_child",
+     "field_offset" : 64,
+     "referenced_type" : "_ZTIP5cnode"
+    },
+    {
+     "field_name" : "name",
+     "field_offset" : 96,
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "field_name" : "value",
+     "field_offset" : 128,
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "linker_set_key" : "_ZTI5cnode",
+   "name" : "cnode",
+   "referenced_type" : "_ZTI5cnode",
+   "self_type" : "_ZTI5cnode",
+   "size" : 20,
+   "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  }
+ ],
+ "rvalue_reference_types" : []
+}

From 54b86e7b7a3645cc7de6fef642ba76a805beff37 Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Thu, 13 Jul 2023 17:33:50 +0900
Subject: [PATCH 0185/1487] Workaround for Global ThinLTO

Global string literals are not initialized correctly with the new
config.

This change is a workaround by changing them into plain C literals until
we have a better solution.

Bug: 291033685
Test: adb-remount-test.sh
Change-Id: I178286133f55ff5dc11030fa132a9e6db0747ae7
---
 fs_mgr/fs_mgr_overlayfs.cpp | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/fs_mgr/fs_mgr_overlayfs.cpp b/fs_mgr/fs_mgr_overlayfs.cpp
index 01827d6cc576..82a8b8b233c9 100644
--- a/fs_mgr/fs_mgr_overlayfs.cpp
+++ b/fs_mgr/fs_mgr_overlayfs.cpp
@@ -75,8 +75,8 @@ bool fs_mgr_access(const std::string& path) {
     return access(path.c_str(), F_OK) == 0;
 }
 
-const auto kLowerdirOption = "lowerdir="s;
-const auto kUpperdirOption = "upperdir="s;
+const auto kLowerdirOption = "lowerdir=";
+const auto kUpperdirOption = "upperdir=";
 
 bool fs_mgr_in_recovery() {
     // Check the existence of recovery binary instead of using the compile time
@@ -99,8 +99,8 @@ bool fs_mgr_is_dsu_running() {
 }
 
 // list of acceptable overlayfs backing storage
-const auto kScratchMountPoint = "/mnt/scratch"s;
-const auto kCacheMountPoint = "/cache"s;
+const auto kScratchMountPoint = "/mnt/scratch";
+const auto kCacheMountPoint = "/cache";
 
 bool IsABDevice() {
     return !android::base::GetProperty("ro.boot.slot_suffix", "").empty();
@@ -158,7 +158,7 @@ bool fs_mgr_filesystem_has_space(const std::string& mount_point) {
            (static_cast<uint64_t>(vst.f_bfree) * vst.f_frsize) >= kSizeThreshold;
 }
 
-const auto kPhysicalDevice = "/dev/block/by-name/"s;
+const auto kPhysicalDevice = "/dev/block/by-name/";
 constexpr char kScratchImageMetadata[] = "/metadata/gsi/remount/lp_metadata";
 
 // Note: this is meant only for recovery/first-stage init.
@@ -182,7 +182,7 @@ bool fs_mgr_update_blk_device(FstabEntry* entry) {
     }
 
     // special case for system-as-root (taimen and others)
-    auto blk_device = kPhysicalDevice + "system";
+    auto blk_device = std::string(kPhysicalDevice) + "system";
     if (!fs_mgr_access(blk_device)) {
         blk_device += fs_mgr_get_slot_suffix();
         if (!fs_mgr_access(blk_device)) {
@@ -301,9 +301,9 @@ bool fs_mgr_rm_all(const std::string& path, bool* change = nullptr, int level =
     return ret;
 }
 
-const auto kUpperName = "upper"s;
-const auto kWorkName = "work"s;
-const auto kOverlayTopDir = "/overlay"s;
+const auto kUpperName = "upper";
+const auto kWorkName = "work";
+const auto kOverlayTopDir = "/overlay";
 
 std::string fs_mgr_get_overlayfs_candidate(const std::string& mount_point) {
     if (!fs_mgr_is_dir(mount_point)) return "";
@@ -472,10 +472,10 @@ bool fs_mgr_overlayfs_has_logical(const Fstab& fstab) {
 // Returns true if immediate unmount succeeded and the scratch mount point was
 // removed.
 bool fs_mgr_overlayfs_umount_scratch() {
-    if (umount(kScratchMountPoint.c_str()) != 0) {
+    if (umount(kScratchMountPoint) != 0) {
         return false;
     }
-    if (rmdir(kScratchMountPoint.c_str()) != 0 && errno != ENOENT) {
+    if (rmdir(kScratchMountPoint) != 0 && errno != ENOENT) {
         PLOG(ERROR) << "rmdir " << kScratchMountPoint;
     }
     return true;
@@ -573,7 +573,7 @@ bool fs_mgr_overlayfs_teardown_one(const std::string& overlay, const std::string
     auto cleanup_all = mount_point.empty();
     const auto partition_name = android::base::Basename(mount_point);
     const auto oldpath = top + (cleanup_all ? "" : ("/" + partition_name));
-    const auto newpath = cleanup_all ? overlay + "/." + kOverlayTopDir.substr(1) + ".teardown"
+    const auto newpath = cleanup_all ? overlay + "/." + (kOverlayTopDir + 1) + ".teardown"
                                      : top + "/." + partition_name + ".teardown";
     auto ret = fs_mgr_rm_all(newpath);
     if (!rename(oldpath.c_str(), newpath.c_str())) {
@@ -853,7 +853,7 @@ bool MountScratch(const std::string& device_path, bool readonly = false) {
     if (!createcon.Ok()) {
         return false;
     }
-    if (mkdir(kScratchMountPoint.c_str(), 0755) && (errno != EEXIST)) {
+    if (mkdir(kScratchMountPoint, 0755) && (errno != EEXIST)) {
         PERROR << "create " << kScratchMountPoint;
         return false;
     }
@@ -884,7 +884,7 @@ bool MountScratch(const std::string& device_path, bool readonly = false) {
         return false;
     }
     if (!mounted) {
-        rmdir(kScratchMountPoint.c_str());
+        rmdir(kScratchMountPoint);
         return false;
     }
     return true;
@@ -1192,7 +1192,7 @@ bool fs_mgr_overlayfs_setup_scratch(const Fstab& fstab) {
     // If the partition exists, assume first that it can be mounted.
     if (partition_exists) {
         if (MountScratch(scratch_device)) {
-            if (fs_mgr_access(kScratchMountPoint + kOverlayTopDir) ||
+            if (fs_mgr_access(std::string(kScratchMountPoint) + kOverlayTopDir) ||
                 fs_mgr_filesystem_has_space(kScratchMountPoint)) {
                 return true;
             }
@@ -1331,7 +1331,7 @@ static void TryMountScratch() {
     if (!MountScratch(scratch_device, true /* readonly */)) {
         return;
     }
-    auto has_overlayfs_dir = fs_mgr_access(kScratchMountPoint + kOverlayTopDir);
+    auto has_overlayfs_dir = fs_mgr_access(std::string(kScratchMountPoint) + kOverlayTopDir);
     fs_mgr_overlayfs_umount_scratch();
     if (has_overlayfs_dir) {
         MountScratch(scratch_device);

From c28150f56f47d79e4b4802e082a51318af04f524 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 23 Jun 2023 12:19:57 -0700
Subject: [PATCH 0186/1487] snapuserd: Create a MergeWorker class.

Merge threads and read threads share some common state but not much.
Splitting into separate classes will help isolate dm-user specific code.

Bug: 288273605
Test: snapuserd_test
Change-Id: I612374bb0072b1eedf32c30270913dbe907cc6ab
---
 .../user-space-merge/handler_manager.cpp      |  1 +
 .../user-space-merge/snapuserd_core.cpp       | 15 ++++-
 .../user-space-merge/snapuserd_core.h         | 37 ++----------
 .../user-space-merge/snapuserd_merge.cpp      | 31 ++++++----
 .../user-space-merge/snapuserd_merge.h        | 56 +++++++++++++++++++
 5 files changed, 92 insertions(+), 48 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index bdba5c0cc3ab..734e84f3c1a9 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -19,6 +19,7 @@
 #include <android-base/logging.h>
 
 #include "snapuserd_core.h"
+#include "snapuserd_merge.h"
 
 namespace android {
 namespace snapshot {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 8e1212b7b3ce..4f7495c0a3f9 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -23,6 +23,8 @@
 #include <android-base/scopeguard.h>
 #include <android-base/strings.h>
 
+#include "snapuserd_merge.h"
+
 namespace android {
 namespace snapshot {
 
@@ -57,8 +59,9 @@ bool SnapshotHandler::InitializeWorkers() {
         worker_threads_.push_back(std::move(wt));
     }
 
-    merge_thread_ = std::make_unique<Worker>(cow_device_, backing_store_device_, control_device_,
-                                             misc_name_, base_path_merge_, GetSharedPtr());
+    merge_thread_ =
+            std::make_unique<MergeWorker>(cow_device_, backing_store_device_, control_device_,
+                                          misc_name_, base_path_merge_, GetSharedPtr());
 
     read_ahead_thread_ = std::make_unique<ReadAhead>(cow_device_, backing_store_device_, misc_name_,
                                                      GetSharedPtr());
@@ -316,7 +319,7 @@ bool SnapshotHandler::Start() {
     }
 
     std::future<bool> merge_thread =
-            std::async(std::launch::async, &Worker::RunMergeThread, merge_thread_.get());
+            std::async(std::launch::async, &MergeWorker::Run, merge_thread_.get());
 
     // Now that the worker threads are up, scan the partitions.
     if (perform_verification_) {
@@ -452,5 +455,11 @@ bool SnapshotHandler::CheckPartitionVerification() {
     return update_verify_->CheckPartitionVerification();
 }
 
+void SnapshotHandler::FreeResources() {
+    worker_threads_.clear();
+    read_ahead_thread_ = nullptr;
+    merge_thread_ = nullptr;
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index c984a61f89eb..fe10edfeeb8a 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -75,6 +75,7 @@ enum class MERGE_IO_TRANSITION {
     READ_AHEAD_FAILURE,
 };
 
+class MergeWorker;
 class SnapshotHandler;
 
 enum class MERGE_GROUP_STATE {
@@ -104,10 +105,9 @@ class Worker {
            const std::string& control_device, const std::string& misc_name,
            const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd);
     bool RunThread();
-    bool RunMergeThread();
     bool Init();
 
-  private:
+  protected:
     // Initialization
     void InitializeBufsink();
     bool InitializeFds();
@@ -145,22 +145,9 @@ class Worker {
     bool ProcessXorOp(const CowOperation* cow_op);
     bool ProcessOrderedOp(const CowOperation* cow_op);
 
-    // Merge related ops
-    bool Merge();
-    bool AsyncMerge();
-    bool SyncMerge();
-    bool MergeOrderedOps();
-    bool MergeOrderedOpsAsync();
-    bool MergeReplaceZeroOps();
-    int PrepareMerge(uint64_t* source_offset, int* pending_ops,
-                     std::vector<const CowOperation*>* replace_zero_vec = nullptr);
-
     sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
     chunk_t SectorToChunk(sector_t sector) { return sector >> CHUNK_SHIFT; }
 
-    bool InitializeIouring();
-    void FinalizeIouring();
-
     std::unique_ptr<CowReader> reader_;
     BufferSink bufsink_;
     XorSink xorsink_;
@@ -178,18 +165,6 @@ class Worker {
     bool header_response_ = false;
 
     std::unique_ptr<ICowOpIter> cowop_iter_;
-    size_t ra_block_index_ = 0;
-    uint64_t blocks_merged_in_group_ = 0;
-    bool merge_async_ = false;
-    // Queue depth of 8 seems optimal. We don't want
-    // to have a huge depth as it may put more memory pressure
-    // on the kernel worker threads given that we use
-    // IOSQE_ASYNC flag - ASYNC flags can potentially
-    // result in EINTR; Since we don't restart
-    // syscalls and fallback to synchronous I/O, we
-    // don't want huge queue depth
-    int queue_depth_ = 8;
-    std::unique_ptr<struct io_uring> ring_;
 
     std::shared_ptr<SnapshotHandler> snapuserd_;
 };
@@ -212,11 +187,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     bool CommitMerge(int num_merge_ops);
 
     void CloseFds() { cow_fd_ = {}; }
-    void FreeResources() {
-        worker_threads_.clear();
-        read_ahead_thread_ = nullptr;
-        merge_thread_ = nullptr;
-    }
+    void FreeResources();
 
     bool InitializeWorkers();
     std::unique_ptr<CowReader> CloneReaderForWorker();
@@ -330,7 +301,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     // Merge Block state
     std::vector<std::unique_ptr<MergeGroupState>> merge_blk_state_;
 
-    std::unique_ptr<Worker> merge_thread_;
+    std::unique_ptr<MergeWorker> merge_thread_;
     double merge_completion_percentage_;
 
     bool merge_initiated_ = false;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
index ce95b7659d9d..ee7101129dbc 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "snapuserd_merge.h"
 
 #include "snapuserd_core.h"
 
@@ -23,8 +24,14 @@ using namespace android;
 using namespace android::dm;
 using android::base::unique_fd;
 
-int Worker::PrepareMerge(uint64_t* source_offset, int* pending_ops,
-                         std::vector<const CowOperation*>* replace_zero_vec) {
+MergeWorker::MergeWorker(const std::string& cow_device, const std::string& backing_device,
+                         const std::string& control_device, const std::string& misc_name,
+                         const std::string& base_path_merge,
+                         std::shared_ptr<SnapshotHandler> snapuserd)
+    : Worker(cow_device, backing_device, control_device, misc_name, base_path_merge, snapuserd) {}
+
+int MergeWorker::PrepareMerge(uint64_t* source_offset, int* pending_ops,
+                              std::vector<const CowOperation*>* replace_zero_vec) {
     int num_ops = *pending_ops;
     int nr_consecutive = 0;
     bool checkOrderedOp = (replace_zero_vec == nullptr);
@@ -70,7 +77,7 @@ int Worker::PrepareMerge(uint64_t* source_offset, int* pending_ops,
     return nr_consecutive;
 }
 
-bool Worker::MergeReplaceZeroOps() {
+bool MergeWorker::MergeReplaceZeroOps() {
     // Flush after merging 2MB. Since all ops are independent and there is no
     // dependency between COW ops, we will flush the data and the number
     // of ops merged in COW block device. If there is a crash, we will
@@ -149,7 +156,7 @@ bool Worker::MergeReplaceZeroOps() {
 
         if (snapuserd_->IsIOTerminated()) {
             SNAP_LOG(ERROR)
-                    << "MergeReplaceZeroOps: Worker threads terminated - shutting down merge";
+                    << "MergeReplaceZeroOps: MergeWorker threads terminated - shutting down merge";
             return false;
         }
     }
@@ -173,7 +180,7 @@ bool Worker::MergeReplaceZeroOps() {
     return true;
 }
 
-bool Worker::MergeOrderedOpsAsync() {
+bool MergeWorker::MergeOrderedOpsAsync() {
     void* mapped_addr = snapuserd_->GetMappedAddr();
     void* read_ahead_buffer =
             static_cast<void*>((char*)mapped_addr + snapuserd_->GetBufferDataOffset());
@@ -354,7 +361,7 @@ bool Worker::MergeOrderedOpsAsync() {
     return true;
 }
 
-bool Worker::MergeOrderedOps() {
+bool MergeWorker::MergeOrderedOps() {
     void* mapped_addr = snapuserd_->GetMappedAddr();
     void* read_ahead_buffer =
             static_cast<void*>((char*)mapped_addr + snapuserd_->GetBufferDataOffset());
@@ -439,7 +446,7 @@ bool Worker::MergeOrderedOps() {
     return true;
 }
 
-bool Worker::AsyncMerge() {
+bool MergeWorker::AsyncMerge() {
     if (!MergeOrderedOpsAsync()) {
         SNAP_LOG(ERROR) << "MergeOrderedOpsAsync failed - Falling back to synchronous I/O";
         // Reset the iter so that we retry the merge
@@ -455,7 +462,7 @@ bool Worker::AsyncMerge() {
     return true;
 }
 
-bool Worker::SyncMerge() {
+bool MergeWorker::SyncMerge() {
     if (!MergeOrderedOps()) {
         SNAP_LOG(ERROR) << "Merge failed for ordered ops";
         return false;
@@ -465,7 +472,7 @@ bool Worker::SyncMerge() {
     return true;
 }
 
-bool Worker::Merge() {
+bool MergeWorker::Merge() {
     cowop_iter_ = reader_->GetOpIter(true);
 
     bool retry = false;
@@ -511,7 +518,7 @@ bool Worker::Merge() {
     return true;
 }
 
-bool Worker::InitializeIouring() {
+bool MergeWorker::InitializeIouring() {
     if (!snapuserd_->IsIouringSupported()) {
         return false;
     }
@@ -530,13 +537,13 @@ bool Worker::InitializeIouring() {
     return true;
 }
 
-void Worker::FinalizeIouring() {
+void MergeWorker::FinalizeIouring() {
     if (merge_async_) {
         io_uring_queue_exit(ring_.get());
     }
 }
 
-bool Worker::RunMergeThread() {
+bool MergeWorker::Run() {
     SNAP_LOG(DEBUG) << "Waiting for merge begin...";
     if (!snapuserd_->WaitForMergeBegin()) {
         SNAP_LOG(ERROR) << "Merge terminated early...";
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h
new file mode 100644
index 000000000000..08192a0ef3b7
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h
@@ -0,0 +1,56 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include "snapuserd_core.h"
+
+namespace android {
+namespace snapshot {
+
+class MergeWorker : public Worker {
+  public:
+    MergeWorker(const std::string& cow_device, const std::string& backing_device,
+                const std::string& control_device, const std::string& misc_name,
+                const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd);
+    bool Run();
+
+  private:
+    int PrepareMerge(uint64_t* source_offset, int* pending_ops,
+                     std::vector<const CowOperation*>* replace_zero_vec = nullptr);
+    bool MergeReplaceZeroOps();
+    bool MergeOrderedOps();
+    bool MergeOrderedOpsAsync();
+    bool Merge();
+    bool AsyncMerge();
+    bool SyncMerge();
+    bool InitializeIouring();
+    void FinalizeIouring();
+
+  private:
+    std::unique_ptr<struct io_uring> ring_;
+    size_t ra_block_index_ = 0;
+    uint64_t blocks_merged_in_group_ = 0;
+    bool merge_async_ = false;
+    // Queue depth of 8 seems optimal. We don't want
+    // to have a huge depth as it may put more memory pressure
+    // on the kernel worker threads given that we use
+    // IOSQE_ASYNC flag - ASYNC flags can potentially
+    // result in EINTR; Since we don't restart
+    // syscalls and fallback to synchronous I/O, we
+    // don't want huge queue depth
+    int queue_depth_ = 8;
+};
+
+}  // namespace snapshot
+}  // namespace android

From d967591434f4e8467fce590286a7c18c1c06c64d Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 23 Jun 2023 12:39:19 -0700
Subject: [PATCH 0187/1487] snapuserd: Create a ReadWorker class.

This splits the dm-user specific parts of Worker into a derived class.

Bug: 288273605
Test: snapuserd_test
Change-Id: Ic0ed1a8dff30018fa8466e7dc6e92469f1c87579
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |  2 +-
 .../user-space-merge/handler_manager.cpp      |  1 +
 ...{snapuserd_dm_user.cpp => read_worker.cpp} | 41 +++++++++-----
 .../snapuserd/user-space-merge/read_worker.h  | 53 +++++++++++++++++++
 .../user-space-merge/snapuserd_core.cpp       |  8 +--
 .../user-space-merge/snapuserd_core.h         | 27 ++--------
 6 files changed, 92 insertions(+), 40 deletions(-)
 rename fs_mgr/libsnapshot/snapuserd/user-space-merge/{snapuserd_dm_user.cpp => read_worker.cpp} (94%)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 9fe567acbc7e..38ec23fc6d63 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -63,8 +63,8 @@ cc_library_static {
         "dm-snapshot-merge/snapuserd_readahead.cpp",
         "snapuserd_buffer.cpp",
         "user-space-merge/handler_manager.cpp",
+        "user-space-merge/read_worker.cpp",
         "user-space-merge/snapuserd_core.cpp",
-        "user-space-merge/snapuserd_dm_user.cpp",
         "user-space-merge/snapuserd_merge.cpp",
         "user-space-merge/snapuserd_readahead.cpp",
         "user-space-merge/snapuserd_transitions.cpp",
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index 734e84f3c1a9..4105b4b4836a 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -18,6 +18,7 @@
 
 #include <android-base/logging.h>
 
+#include "read_worker.h"
 #include "snapuserd_core.h"
 #include "snapuserd_merge.h"
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
similarity index 94%
rename from fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
rename to fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index 2b9d14e9c19c..49a83608e290 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include "read_worker.h"
+
 #include "snapuserd_core.h"
 
 namespace android {
@@ -34,6 +36,12 @@ Worker::Worker(const std::string& cow_device, const std::string& backing_device,
     snapuserd_ = snapuserd;
 }
 
+ReadWorker::ReadWorker(const std::string& cow_device, const std::string& backing_device,
+                       const std::string& control_device, const std::string& misc_name,
+                       const std::string& base_path_merge,
+                       std::shared_ptr<SnapshotHandler> snapuserd)
+    : Worker(cow_device, backing_device, control_device, misc_name, base_path_merge, snapuserd) {}
+
 bool Worker::InitializeFds() {
     backing_store_fd_.reset(open(backing_store_device_.c_str(), O_RDONLY));
     if (backing_store_fd_ < 0) {
@@ -118,7 +126,7 @@ bool Worker::ReadFromSourceDevice(const CowOperation* cow_op) {
 
 // Start the copy operation. This will read the backing
 // block device which is represented by cow_op->source.
-bool Worker::ProcessCopyOp(const CowOperation* cow_op) {
+bool ReadWorker::ProcessCopyOp(const CowOperation* cow_op) {
     if (!ReadFromSourceDevice(cow_op)) {
         return false;
     }
@@ -126,7 +134,7 @@ bool Worker::ProcessCopyOp(const CowOperation* cow_op) {
     return true;
 }
 
-bool Worker::ProcessXorOp(const CowOperation* cow_op) {
+bool ReadWorker::ProcessXorOp(const CowOperation* cow_op) {
     if (!ReadFromSourceDevice(cow_op)) {
         return false;
     }
@@ -165,7 +173,7 @@ bool Worker::ProcessZeroOp() {
     return true;
 }
 
-bool Worker::ProcessOrderedOp(const CowOperation* cow_op) {
+bool ReadWorker::ProcessOrderedOp(const CowOperation* cow_op) {
     void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
     if (buffer == nullptr) {
         SNAP_LOG(ERROR) << "ProcessOrderedOp: Failed to get payload buffer";
@@ -218,7 +226,7 @@ bool Worker::ProcessOrderedOp(const CowOperation* cow_op) {
     return false;
 }
 
-bool Worker::ProcessCowOp(const CowOperation* cow_op) {
+bool ReadWorker::ProcessCowOp(const CowOperation* cow_op) {
     if (cow_op == nullptr) {
         SNAP_LOG(ERROR) << "ProcessCowOp: Invalid cow_op";
         return false;
@@ -257,7 +265,6 @@ void Worker::InitializeBufsink() {
 
 bool Worker::Init() {
     InitializeBufsink();
-    xorsink_.Initialize(&bufsink_, BLOCK_SZ);
 
     if (!InitializeFds()) {
         return false;
@@ -270,7 +277,15 @@ bool Worker::Init() {
     return true;
 }
 
-bool Worker::RunThread() {
+bool ReadWorker::Init() {
+    if (!Worker::Init()) {
+        return false;
+    }
+    xorsink_.Initialize(&bufsink_, BLOCK_SZ);
+    return true;
+}
+
+bool ReadWorker::Run() {
     SNAP_LOG(INFO) << "Processing snapshot I/O requests....";
 
     if (setpriority(PRIO_PROCESS, gettid(), kNiceValueForMergeThreads)) {
@@ -291,7 +306,7 @@ bool Worker::RunThread() {
 }
 
 // Send the payload/data back to dm-user misc device.
-bool Worker::WriteDmUserPayload(size_t size) {
+bool ReadWorker::WriteDmUserPayload(size_t size) {
     size_t payload_size = size;
     void* buf = bufsink_.GetPayloadBufPtr();
     if (header_response_) {
@@ -329,7 +344,7 @@ bool Worker::ReadDataFromBaseDevice(sector_t sector, size_t read_size) {
     return true;
 }
 
-bool Worker::ReadAlignedSector(sector_t sector, size_t sz) {
+bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
     size_t remaining_size = sz;
     std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
     int ret = 0;
@@ -389,7 +404,7 @@ bool Worker::ReadAlignedSector(sector_t sector, size_t sz) {
     return true;
 }
 
-int Worker::ReadUnalignedSector(
+int ReadWorker::ReadUnalignedSector(
         sector_t sector, size_t size,
         std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it) {
     size_t skip_sector_size = 0;
@@ -424,7 +439,7 @@ int Worker::ReadUnalignedSector(
     return std::min(size, (BLOCK_SZ - skip_sector_size));
 }
 
-bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
+bool ReadWorker::ReadUnalignedSector(sector_t sector, size_t size) {
     bufsink_.ResetBufferOffset();
     std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
 
@@ -563,7 +578,7 @@ bool Worker::ReadUnalignedSector(sector_t sector, size_t size) {
     return true;
 }
 
-void Worker::RespondIOError() {
+void ReadWorker::RespondIOError() {
     struct dm_user_header* header = bufsink_.GetHeaderPtr();
     header->type = DM_USER_RESP_ERROR;
     // This is an issue with the dm-user interface. There
@@ -580,7 +595,7 @@ void Worker::RespondIOError() {
     WriteDmUserPayload(0);
 }
 
-bool Worker::DmuserReadRequest() {
+bool ReadWorker::DmuserReadRequest() {
     struct dm_user_header* header = bufsink_.GetHeaderPtr();
 
     // Unaligned I/O request
@@ -591,7 +606,7 @@ bool Worker::DmuserReadRequest() {
     return ReadAlignedSector(header->sector, header->len);
 }
 
-bool Worker::ProcessIORequest() {
+bool ReadWorker::ProcessIORequest() {
     // Read Header from dm-user misc device. This gives
     // us the sector number for which IO is issued by dm-snapshot device
     struct dm_user_header* header = bufsink_.GetHeaderPtr();
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
new file mode 100644
index 000000000000..262f8adfe26f
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
@@ -0,0 +1,53 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "snapuserd_core.h"
+
+namespace android {
+namespace snapshot {
+
+class ReadWorker : public Worker {
+  public:
+    ReadWorker(const std::string& cow_device, const std::string& backing_device,
+               const std::string& control_device, const std::string& misc_name,
+               const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd);
+
+    bool Run();
+    bool Init() override;
+
+  private:
+    // Functions interacting with dm-user
+    bool ProcessIORequest();
+    bool WriteDmUserPayload(size_t size);
+    bool DmuserReadRequest();
+    void RespondIOError();
+
+    bool ProcessCowOp(const CowOperation* cow_op);
+    bool ProcessXorOp(const CowOperation* cow_op);
+    bool ProcessOrderedOp(const CowOperation* cow_op);
+    bool ProcessCopyOp(const CowOperation* cow_op);
+
+    bool ReadAlignedSector(sector_t sector, size_t sz);
+    bool ReadUnalignedSector(sector_t sector, size_t size);
+    int ReadUnalignedSector(sector_t sector, size_t size,
+                            std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it);
+
+    XorSink xorsink_;
+    bool header_response_ = false;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 4f7495c0a3f9..baf06b393c05 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -23,6 +23,7 @@
 #include <android-base/scopeguard.h>
 #include <android-base/strings.h>
 
+#include "read_worker.h"
 #include "snapuserd_merge.h"
 
 namespace android {
@@ -48,9 +49,8 @@ SnapshotHandler::SnapshotHandler(std::string misc_name, std::string cow_device,
 
 bool SnapshotHandler::InitializeWorkers() {
     for (int i = 0; i < num_worker_threads_; i++) {
-        std::unique_ptr<Worker> wt =
-                std::make_unique<Worker>(cow_device_, backing_store_device_, control_device_,
-                                         misc_name_, base_path_merge_, GetSharedPtr());
+        auto wt = std::make_unique<ReadWorker>(cow_device_, backing_store_device_, control_device_,
+                                               misc_name_, base_path_merge_, GetSharedPtr());
         if (!wt->Init()) {
             SNAP_LOG(ERROR) << "Thread initialization failed";
             return false;
@@ -315,7 +315,7 @@ bool SnapshotHandler::Start() {
     // Launch worker threads
     for (int i = 0; i < worker_threads_.size(); i++) {
         threads.emplace_back(
-                std::async(std::launch::async, &Worker::RunThread, worker_threads_[i].get()));
+                std::async(std::launch::async, &ReadWorker::Run, worker_threads_[i].get()));
     }
 
     std::future<bool> merge_thread =
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index fe10edfeeb8a..0c30eac75821 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -76,6 +76,7 @@ enum class MERGE_IO_TRANSITION {
 };
 
 class MergeWorker;
+class ReadWorker;
 class SnapshotHandler;
 
 enum class MERGE_GROUP_STATE {
@@ -104,8 +105,9 @@ class Worker {
     Worker(const std::string& cow_device, const std::string& backing_device,
            const std::string& control_device, const std::string& misc_name,
            const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd);
-    bool RunThread();
-    bool Init();
+    virtual ~Worker() = default;
+
+    virtual bool Init();
 
   protected:
     // Initialization
@@ -118,39 +120,21 @@ class Worker {
         base_path_merge_fd_ = {};
     }
 
-    // Functions interacting with dm-user
-    bool WriteDmUserPayload(size_t size);
-    bool DmuserReadRequest();
-
     // IO Path
-    bool ProcessIORequest();
     bool IsBlockAligned(size_t size) { return ((size & (BLOCK_SZ - 1)) == 0); }
 
     bool ReadDataFromBaseDevice(sector_t sector, size_t read_size);
     bool ReadFromSourceDevice(const CowOperation* cow_op);
 
-    bool ReadAlignedSector(sector_t sector, size_t sz);
-    bool ReadUnalignedSector(sector_t sector, size_t size);
-    int ReadUnalignedSector(sector_t sector, size_t size,
-                            std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it);
-    void RespondIOError();
-
     // Processing COW operations
-    bool ProcessCowOp(const CowOperation* cow_op);
     bool ProcessReplaceOp(const CowOperation* cow_op);
     bool ProcessZeroOp();
 
-    // Handles Copy and Xor
-    bool ProcessCopyOp(const CowOperation* cow_op);
-    bool ProcessXorOp(const CowOperation* cow_op);
-    bool ProcessOrderedOp(const CowOperation* cow_op);
-
     sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
     chunk_t SectorToChunk(sector_t sector) { return sector >> CHUNK_SHIFT; }
 
     std::unique_ptr<CowReader> reader_;
     BufferSink bufsink_;
-    XorSink xorsink_;
 
     std::string cow_device_;
     std::string backing_store_device_;
@@ -162,7 +146,6 @@ class Worker {
     unique_fd backing_store_fd_;
     unique_fd base_path_merge_fd_;
     unique_fd ctrl_fd_;
-    bool header_response_ = false;
 
     std::unique_ptr<ICowOpIter> cowop_iter_;
 
@@ -286,7 +269,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     void* mapped_addr_;
     size_t total_mapped_addr_length_;
 
-    std::vector<std::unique_ptr<Worker>> worker_threads_;
+    std::vector<std::unique_ptr<ReadWorker>> worker_threads_;
     // Read-ahead related
     bool populate_data_from_cow_ = false;
     bool ra_thread_ = false;

From ab57c8a5774a5ba59e6144e06ecb33d9df690ea3 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 23 Jun 2023 13:00:34 -0700
Subject: [PATCH 0188/1487] snapuserd: Split more methods out of Worker.

This moves ReadWorker-specific methods out of Worker, and moves
remaining Worker methods into a separate worker.cpp file.

Bug: 288273605
Test: snapuserd_test
Change-Id: I59c31318e127db61a5f3a673956865dac97a6e5f
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |  1 +
 .../user-space-merge/read_worker.cpp          | 76 +--------------
 .../snapuserd/user-space-merge/read_worker.h  |  7 +-
 .../user-space-merge/snapuserd_core.h         | 53 -----------
 .../user-space-merge/snapuserd_merge.h        |  4 +-
 .../snapuserd/user-space-merge/worker.cpp     | 95 +++++++++++++++++++
 .../snapuserd/user-space-merge/worker.h       | 86 +++++++++++++++++
 7 files changed, 193 insertions(+), 129 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.cpp
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 38ec23fc6d63..78a3b9bf28ea 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -69,6 +69,7 @@ cc_library_static {
         "user-space-merge/snapuserd_readahead.cpp",
         "user-space-merge/snapuserd_transitions.cpp",
         "user-space-merge/snapuserd_verify.cpp",
+        "user-space-merge/worker.cpp",
     ],
     static_libs: [
         "libbase",
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index 49a83608e290..c47abe3fd57a 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -25,61 +25,12 @@ using namespace android;
 using namespace android::dm;
 using android::base::unique_fd;
 
-Worker::Worker(const std::string& cow_device, const std::string& backing_device,
-               const std::string& control_device, const std::string& misc_name,
-               const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd) {
-    cow_device_ = cow_device;
-    backing_store_device_ = backing_device;
-    control_device_ = control_device;
-    misc_name_ = misc_name;
-    base_path_merge_ = base_path_merge;
-    snapuserd_ = snapuserd;
-}
-
 ReadWorker::ReadWorker(const std::string& cow_device, const std::string& backing_device,
                        const std::string& control_device, const std::string& misc_name,
                        const std::string& base_path_merge,
                        std::shared_ptr<SnapshotHandler> snapuserd)
     : Worker(cow_device, backing_device, control_device, misc_name, base_path_merge, snapuserd) {}
 
-bool Worker::InitializeFds() {
-    backing_store_fd_.reset(open(backing_store_device_.c_str(), O_RDONLY));
-    if (backing_store_fd_ < 0) {
-        SNAP_PLOG(ERROR) << "Open Failed: " << backing_store_device_;
-        return false;
-    }
-
-    cow_fd_.reset(open(cow_device_.c_str(), O_RDWR));
-    if (cow_fd_ < 0) {
-        SNAP_PLOG(ERROR) << "Open Failed: " << cow_device_;
-        return false;
-    }
-
-    ctrl_fd_.reset(open(control_device_.c_str(), O_RDWR));
-    if (ctrl_fd_ < 0) {
-        SNAP_PLOG(ERROR) << "Unable to open " << control_device_;
-        return false;
-    }
-
-    // Base device used by merge thread
-    base_path_merge_fd_.reset(open(base_path_merge_.c_str(), O_RDWR));
-    if (base_path_merge_fd_ < 0) {
-        SNAP_PLOG(ERROR) << "Open Failed: " << base_path_merge_;
-        return false;
-    }
-
-    return true;
-}
-
-bool Worker::InitReader() {
-    reader_ = snapuserd_->CloneReaderForWorker();
-
-    if (!reader_->InitForMerge(std::move(cow_fd_))) {
-        return false;
-    }
-    return true;
-}
-
 // Start the replace operation. This will read the
 // internal COW format and if the block is compressed,
 // it will be de-compressed.
@@ -96,7 +47,7 @@ bool Worker::ProcessReplaceOp(const CowOperation* cow_op) {
     return true;
 }
 
-bool Worker::ReadFromSourceDevice(const CowOperation* cow_op) {
+bool ReadWorker::ReadFromSourceDevice(const CowOperation* cow_op) {
     void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
     if (buffer == nullptr) {
         SNAP_LOG(ERROR) << "ReadFromBaseDevice: Failed to get payload buffer";
@@ -254,29 +205,6 @@ bool ReadWorker::ProcessCowOp(const CowOperation* cow_op) {
     return false;
 }
 
-void Worker::InitializeBufsink() {
-    // Allocate the buffer which is used to communicate between
-    // daemon and dm-user. The buffer comprises of header and a fixed payload.
-    // If the dm-user requests a big IO, the IO will be broken into chunks
-    // of PAYLOAD_BUFFER_SZ.
-    size_t buf_size = sizeof(struct dm_user_header) + PAYLOAD_BUFFER_SZ;
-    bufsink_.Initialize(buf_size);
-}
-
-bool Worker::Init() {
-    InitializeBufsink();
-
-    if (!InitializeFds()) {
-        return false;
-    }
-
-    if (!InitReader()) {
-        return false;
-    }
-
-    return true;
-}
-
 bool ReadWorker::Init() {
     if (!Worker::Init()) {
         return false;
@@ -325,7 +253,7 @@ bool ReadWorker::WriteDmUserPayload(size_t size) {
     return true;
 }
 
-bool Worker::ReadDataFromBaseDevice(sector_t sector, size_t read_size) {
+bool ReadWorker::ReadDataFromBaseDevice(sector_t sector, size_t read_size) {
     CHECK(read_size <= BLOCK_SZ);
 
     void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
index 262f8adfe26f..b12dab24ca77 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
@@ -14,7 +14,10 @@
 
 #pragma once
 
-#include "snapuserd_core.h"
+#include <utility>
+#include <vector>
+
+#include "worker.h"
 
 namespace android {
 namespace snapshot {
@@ -44,6 +47,8 @@ class ReadWorker : public Worker {
     bool ReadUnalignedSector(sector_t sector, size_t size);
     int ReadUnalignedSector(sector_t sector, size_t size,
                             std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it);
+    bool ReadFromSourceDevice(const CowOperation* cow_op);
+    bool ReadDataFromBaseDevice(sector_t sector, size_t read_size);
 
     XorSink xorsink_;
     bool header_response_ = false;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index 0c30eac75821..cdc38c01665e 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -77,7 +77,6 @@ enum class MERGE_IO_TRANSITION {
 
 class MergeWorker;
 class ReadWorker;
-class SnapshotHandler;
 
 enum class MERGE_GROUP_STATE {
     GROUP_MERGE_PENDING,
@@ -100,58 +99,6 @@ struct MergeGroupState {
         : merge_state_(state), num_ios_in_progress(n_ios) {}
 };
 
-class Worker {
-  public:
-    Worker(const std::string& cow_device, const std::string& backing_device,
-           const std::string& control_device, const std::string& misc_name,
-           const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd);
-    virtual ~Worker() = default;
-
-    virtual bool Init();
-
-  protected:
-    // Initialization
-    void InitializeBufsink();
-    bool InitializeFds();
-    bool InitReader();
-    void CloseFds() {
-        ctrl_fd_ = {};
-        backing_store_fd_ = {};
-        base_path_merge_fd_ = {};
-    }
-
-    // IO Path
-    bool IsBlockAligned(size_t size) { return ((size & (BLOCK_SZ - 1)) == 0); }
-
-    bool ReadDataFromBaseDevice(sector_t sector, size_t read_size);
-    bool ReadFromSourceDevice(const CowOperation* cow_op);
-
-    // Processing COW operations
-    bool ProcessReplaceOp(const CowOperation* cow_op);
-    bool ProcessZeroOp();
-
-    sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
-    chunk_t SectorToChunk(sector_t sector) { return sector >> CHUNK_SHIFT; }
-
-    std::unique_ptr<CowReader> reader_;
-    BufferSink bufsink_;
-
-    std::string cow_device_;
-    std::string backing_store_device_;
-    std::string control_device_;
-    std::string misc_name_;
-    std::string base_path_merge_;
-
-    unique_fd cow_fd_;
-    unique_fd backing_store_fd_;
-    unique_fd base_path_merge_fd_;
-    unique_fd ctrl_fd_;
-
-    std::unique_ptr<ICowOpIter> cowop_iter_;
-
-    std::shared_ptr<SnapshotHandler> snapuserd_;
-};
-
 class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
   public:
     SnapshotHandler(std::string misc_name, std::string cow_device, std::string backing_device,
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h
index 08192a0ef3b7..3da73c24d001 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h
@@ -13,7 +13,9 @@
 // limitations under the License.
 #pragma once
 
-#include "snapuserd_core.h"
+#include "worker.h"
+
+#include <liburing.h>
 
 namespace android {
 namespace snapshot {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.cpp
new file mode 100644
index 000000000000..ef6781a61feb
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.cpp
@@ -0,0 +1,95 @@
+// Copyright (C) 2023 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 "worker.h"
+
+#include "snapuserd_core.h"
+
+namespace android {
+namespace snapshot {
+
+Worker::Worker(const std::string& cow_device, const std::string& backing_device,
+               const std::string& control_device, const std::string& misc_name,
+               const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd) {
+    cow_device_ = cow_device;
+    backing_store_device_ = backing_device;
+    control_device_ = control_device;
+    misc_name_ = misc_name;
+    base_path_merge_ = base_path_merge;
+    snapuserd_ = snapuserd;
+}
+
+void Worker::InitializeBufsink() {
+    // Allocate the buffer which is used to communicate between
+    // daemon and dm-user. The buffer comprises of header and a fixed payload.
+    // If the dm-user requests a big IO, the IO will be broken into chunks
+    // of PAYLOAD_BUFFER_SZ.
+    size_t buf_size = sizeof(struct dm_user_header) + PAYLOAD_BUFFER_SZ;
+    bufsink_.Initialize(buf_size);
+}
+
+bool Worker::Init() {
+    InitializeBufsink();
+
+    if (!InitializeFds()) {
+        return false;
+    }
+
+    if (!InitReader()) {
+        return false;
+    }
+
+    return true;
+}
+
+bool Worker::InitReader() {
+    reader_ = snapuserd_->CloneReaderForWorker();
+
+    if (!reader_->InitForMerge(std::move(cow_fd_))) {
+        return false;
+    }
+    return true;
+}
+
+bool Worker::InitializeFds() {
+    backing_store_fd_.reset(open(backing_store_device_.c_str(), O_RDONLY));
+    if (backing_store_fd_ < 0) {
+        SNAP_PLOG(ERROR) << "Open Failed: " << backing_store_device_;
+        return false;
+    }
+
+    cow_fd_.reset(open(cow_device_.c_str(), O_RDWR));
+    if (cow_fd_ < 0) {
+        SNAP_PLOG(ERROR) << "Open Failed: " << cow_device_;
+        return false;
+    }
+
+    ctrl_fd_.reset(open(control_device_.c_str(), O_RDWR));
+    if (ctrl_fd_ < 0) {
+        SNAP_PLOG(ERROR) << "Unable to open " << control_device_;
+        return false;
+    }
+
+    // Base device used by merge thread
+    base_path_merge_fd_.reset(open(base_path_merge_.c_str(), O_RDWR));
+    if (base_path_merge_fd_ < 0) {
+        SNAP_PLOG(ERROR) << "Open Failed: " << base_path_merge_;
+        return false;
+    }
+
+    return true;
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h
new file mode 100644
index 000000000000..d38ce5d1895c
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h
@@ -0,0 +1,86 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <stddef.h>
+
+#include <memory>
+#include <string>
+
+#include <android-base/unique_fd.h>
+#include <libsnapshot/cow_reader.h>
+#include <snapuserd/snapuserd_buffer.h>
+#include <snapuserd/snapuserd_kernel.h>
+
+namespace android {
+namespace snapshot {
+
+using android::base::unique_fd;
+
+class SnapshotHandler;
+
+class Worker {
+  public:
+    Worker(const std::string& cow_device, const std::string& backing_device,
+           const std::string& control_device, const std::string& misc_name,
+           const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd);
+    virtual ~Worker() = default;
+
+    virtual bool Init();
+
+  protected:
+    // Initialization
+    void InitializeBufsink();
+    bool InitializeFds();
+    bool InitReader();
+    void CloseFds() {
+        ctrl_fd_ = {};
+        backing_store_fd_ = {};
+        base_path_merge_fd_ = {};
+    }
+
+    // IO Path
+    bool IsBlockAligned(size_t size) { return ((size & (BLOCK_SZ - 1)) == 0); }
+
+    bool ReadDataFromBaseDevice(sector_t sector, size_t read_size);
+
+    // Processing COW operations
+    bool ProcessReplaceOp(const CowOperation* cow_op);
+    bool ProcessZeroOp();
+
+    sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
+    chunk_t SectorToChunk(sector_t sector) { return sector >> CHUNK_SHIFT; }
+
+    std::unique_ptr<CowReader> reader_;
+    BufferSink bufsink_;
+
+    std::string cow_device_;
+    std::string backing_store_device_;
+    std::string control_device_;
+    std::string misc_name_;
+    std::string base_path_merge_;
+
+    unique_fd cow_fd_;
+    unique_fd backing_store_fd_;
+    unique_fd base_path_merge_fd_;
+    unique_fd ctrl_fd_;
+
+    std::unique_ptr<ICowOpIter> cowop_iter_;
+
+    std::shared_ptr<SnapshotHandler> snapuserd_;
+};
+
+}  // namespace snapshot
+}  // namespace android

From c2d5a19d269bfcde34f4e4ea5db9733f437305f6 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 23 Jun 2023 13:30:00 -0700
Subject: [PATCH 0189/1487] snapuserd: Move more fields out of Worker.

These fields are specific to either ReadWorker or MergeWorker, but not
both.

Bug: 288273605
Test: snapuserd_test
Change-Id: I2db9cfa2a8f034249879517bd90a40babe97bc64
---
 .../user-space-merge/read_worker.cpp          | 23 +++++++++++++-
 .../snapuserd/user-space-merge/read_worker.h  | 10 ++++++
 .../user-space-merge/snapuserd_core.cpp       |  5 ++-
 .../user-space-merge/snapuserd_merge.cpp      |  5 ++-
 .../user-space-merge/snapuserd_merge.h        |  4 +--
 .../snapuserd/user-space-merge/worker.cpp     | 17 +---------
 .../snapuserd/user-space-merge/worker.h       | 31 +++++--------------
 7 files changed, 47 insertions(+), 48 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index c47abe3fd57a..4c8223f1e913 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -25,11 +25,19 @@ using namespace android;
 using namespace android::dm;
 using android::base::unique_fd;
 
+void ReadWorker::CloseFds() {
+    ctrl_fd_ = {};
+    backing_store_fd_ = {};
+    Worker::CloseFds();
+}
+
 ReadWorker::ReadWorker(const std::string& cow_device, const std::string& backing_device,
                        const std::string& control_device, const std::string& misc_name,
                        const std::string& base_path_merge,
                        std::shared_ptr<SnapshotHandler> snapuserd)
-    : Worker(cow_device, backing_device, control_device, misc_name, base_path_merge, snapuserd) {}
+    : Worker(cow_device, misc_name, base_path_merge, snapuserd),
+      backing_store_device_(backing_device),
+      control_device_(control_device) {}
 
 // Start the replace operation. This will read the
 // internal COW format and if the block is compressed,
@@ -209,6 +217,19 @@ bool ReadWorker::Init() {
     if (!Worker::Init()) {
         return false;
     }
+
+    backing_store_fd_.reset(open(backing_store_device_.c_str(), O_RDONLY));
+    if (backing_store_fd_ < 0) {
+        SNAP_PLOG(ERROR) << "Open Failed: " << backing_store_device_;
+        return false;
+    }
+
+    ctrl_fd_.reset(open(control_device_.c_str(), O_RDWR));
+    if (ctrl_fd_ < 0) {
+        SNAP_PLOG(ERROR) << "Unable to open " << control_device_;
+        return false;
+    }
+
     xorsink_.Initialize(&bufsink_, BLOCK_SZ);
     return true;
 }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
index b12dab24ca77..bc0474f4bba7 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
@@ -30,6 +30,7 @@ class ReadWorker : public Worker {
 
     bool Run();
     bool Init() override;
+    void CloseFds() override;
 
   private:
     // Functions interacting with dm-user
@@ -50,6 +51,15 @@ class ReadWorker : public Worker {
     bool ReadFromSourceDevice(const CowOperation* cow_op);
     bool ReadDataFromBaseDevice(sector_t sector, size_t read_size);
 
+    constexpr bool IsBlockAligned(size_t size) { return ((size & (BLOCK_SZ - 1)) == 0); }
+    constexpr sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
+
+    std::string backing_store_device_;
+    unique_fd backing_store_fd_;
+
+    std::string control_device_;
+    unique_fd ctrl_fd_;
+
     XorSink xorsink_;
     bool header_response_ = false;
 };
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index baf06b393c05..e52d752a0eb9 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -59,9 +59,8 @@ bool SnapshotHandler::InitializeWorkers() {
         worker_threads_.push_back(std::move(wt));
     }
 
-    merge_thread_ =
-            std::make_unique<MergeWorker>(cow_device_, backing_store_device_, control_device_,
-                                          misc_name_, base_path_merge_, GetSharedPtr());
+    merge_thread_ = std::make_unique<MergeWorker>(cow_device_, misc_name_, base_path_merge_,
+                                                  GetSharedPtr());
 
     read_ahead_thread_ = std::make_unique<ReadAhead>(cow_device_, backing_store_device_, misc_name_,
                                                      GetSharedPtr());
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
index ee7101129dbc..510e27d29eea 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
@@ -24,11 +24,10 @@ using namespace android;
 using namespace android::dm;
 using android::base::unique_fd;
 
-MergeWorker::MergeWorker(const std::string& cow_device, const std::string& backing_device,
-                         const std::string& control_device, const std::string& misc_name,
+MergeWorker::MergeWorker(const std::string& cow_device, const std::string& misc_name,
                          const std::string& base_path_merge,
                          std::shared_ptr<SnapshotHandler> snapuserd)
-    : Worker(cow_device, backing_device, control_device, misc_name, base_path_merge, snapuserd) {}
+    : Worker(cow_device, misc_name, base_path_merge, snapuserd) {}
 
 int MergeWorker::PrepareMerge(uint64_t* source_offset, int* pending_ops,
                               std::vector<const CowOperation*>* replace_zero_vec) {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h
index 3da73c24d001..f35147f2beb6 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h
@@ -22,8 +22,7 @@ namespace snapshot {
 
 class MergeWorker : public Worker {
   public:
-    MergeWorker(const std::string& cow_device, const std::string& backing_device,
-                const std::string& control_device, const std::string& misc_name,
+    MergeWorker(const std::string& cow_device, const std::string& misc_name,
                 const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd);
     bool Run();
 
@@ -40,6 +39,7 @@ class MergeWorker : public Worker {
     void FinalizeIouring();
 
   private:
+    std::unique_ptr<ICowOpIter> cowop_iter_;
     std::unique_ptr<struct io_uring> ring_;
     size_t ra_block_index_ = 0;
     uint64_t blocks_merged_in_group_ = 0;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.cpp
index ef6781a61feb..aa156301fa3b 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.cpp
@@ -19,12 +19,9 @@
 namespace android {
 namespace snapshot {
 
-Worker::Worker(const std::string& cow_device, const std::string& backing_device,
-               const std::string& control_device, const std::string& misc_name,
+Worker::Worker(const std::string& cow_device, const std::string& misc_name,
                const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd) {
     cow_device_ = cow_device;
-    backing_store_device_ = backing_device;
-    control_device_ = control_device;
     misc_name_ = misc_name;
     base_path_merge_ = base_path_merge;
     snapuserd_ = snapuserd;
@@ -63,24 +60,12 @@ bool Worker::InitReader() {
 }
 
 bool Worker::InitializeFds() {
-    backing_store_fd_.reset(open(backing_store_device_.c_str(), O_RDONLY));
-    if (backing_store_fd_ < 0) {
-        SNAP_PLOG(ERROR) << "Open Failed: " << backing_store_device_;
-        return false;
-    }
-
     cow_fd_.reset(open(cow_device_.c_str(), O_RDWR));
     if (cow_fd_ < 0) {
         SNAP_PLOG(ERROR) << "Open Failed: " << cow_device_;
         return false;
     }
 
-    ctrl_fd_.reset(open(control_device_.c_str(), O_RDWR));
-    if (ctrl_fd_ < 0) {
-        SNAP_PLOG(ERROR) << "Unable to open " << control_device_;
-        return false;
-    }
-
     // Base device used by merge thread
     base_path_merge_fd_.reset(open(base_path_merge_.c_str(), O_RDWR));
     if (base_path_merge_fd_ < 0) {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h
index d38ce5d1895c..1175ab714b7e 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h
@@ -33,8 +33,7 @@ class SnapshotHandler;
 
 class Worker {
   public:
-    Worker(const std::string& cow_device, const std::string& backing_device,
-           const std::string& control_device, const std::string& misc_name,
+    Worker(const std::string& cow_device, const std::string& misc_name,
            const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd);
     virtual ~Worker() = default;
 
@@ -45,14 +44,7 @@ class Worker {
     void InitializeBufsink();
     bool InitializeFds();
     bool InitReader();
-    void CloseFds() {
-        ctrl_fd_ = {};
-        backing_store_fd_ = {};
-        base_path_merge_fd_ = {};
-    }
-
-    // IO Path
-    bool IsBlockAligned(size_t size) { return ((size & (BLOCK_SZ - 1)) == 0); }
+    virtual void CloseFds() { base_path_merge_fd_ = {}; }
 
     bool ReadDataFromBaseDevice(sector_t sector, size_t read_size);
 
@@ -60,26 +52,19 @@ class Worker {
     bool ProcessReplaceOp(const CowOperation* cow_op);
     bool ProcessZeroOp();
 
-    sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
-    chunk_t SectorToChunk(sector_t sector) { return sector >> CHUNK_SHIFT; }
-
     std::unique_ptr<CowReader> reader_;
     BufferSink bufsink_;
 
-    std::string cow_device_;
-    std::string backing_store_device_;
-    std::string control_device_;
-    std::string misc_name_;
-    std::string base_path_merge_;
+    std::string misc_name_;  // Needed for SNAP_LOG.
 
-    unique_fd cow_fd_;
-    unique_fd backing_store_fd_;
     unique_fd base_path_merge_fd_;
-    unique_fd ctrl_fd_;
-
-    std::unique_ptr<ICowOpIter> cowop_iter_;
 
     std::shared_ptr<SnapshotHandler> snapuserd_;
+
+  private:
+    std::string cow_device_;
+    std::string base_path_merge_;
+    unique_fd cow_fd_;
 };
 
 }  // namespace snapshot

From 77280caed16ecc3b2744fa1b38e08765c852e08d Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 12 Jul 2023 11:49:40 -0700
Subject: [PATCH 0190/1487] snapuserd: Fix bool/int return value mismatches.

Bug: 288273605
Test: snapuserd_test, ota
Change-Id: I06d641d3255711dd51583ea9bd9fd6a1acdc7bb2
---
 .../snapuserd/user-space-merge/snapuserd_dm_user.cpp            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
index 1b17698a3e1a..2b9d14e9c19c 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_dm_user.cpp
@@ -585,7 +585,7 @@ bool Worker::DmuserReadRequest() {
 
     // Unaligned I/O request
     if (!IsBlockAligned(header->sector << SECTOR_SHIFT)) {
-        return ReadUnalignedSector(header->sector, header->len) != -1;
+        return ReadUnalignedSector(header->sector, header->len);
     }
 
     return ReadAlignedSector(header->sector, header->len);

From 8bc625e9cae82c798e0d2ef8233902663a638744 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 23 Jun 2023 13:52:44 -0700
Subject: [PATCH 0191/1487] snapuserd: Move Process ops out of Worker.

These are so small they can be inlined into MergeWorker. Sharing these
methods will be difficult after decoupling from dm-user, since
acquisition of buffers will change.

Bug: 288273605
Test: snapuserd_test
Change-Id: I1625d1a6e55bcb2041f73453ca15a01f98263e8a
---
 .../snapuserd/user-space-merge/read_worker.cpp    |  4 ++--
 .../snapuserd/user-space-merge/read_worker.h      |  2 ++
 .../user-space-merge/snapuserd_merge.cpp          | 15 +++++++++------
 .../snapuserd/user-space-merge/worker.h           |  6 ------
 4 files changed, 13 insertions(+), 14 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index 4c8223f1e913..dd2996b783a0 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -42,7 +42,7 @@ ReadWorker::ReadWorker(const std::string& cow_device, const std::string& backing
 // Start the replace operation. This will read the
 // internal COW format and if the block is compressed,
 // it will be de-compressed.
-bool Worker::ProcessReplaceOp(const CowOperation* cow_op) {
+bool ReadWorker::ProcessReplaceOp(const CowOperation* cow_op) {
     void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
     if (!buffer) {
         SNAP_LOG(ERROR) << "ProcessReplaceOp failed to allocate buffer";
@@ -120,7 +120,7 @@ bool ReadWorker::ProcessXorOp(const CowOperation* cow_op) {
     return true;
 }
 
-bool Worker::ProcessZeroOp() {
+bool ReadWorker::ProcessZeroOp() {
     // Zero out the entire block
     void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
     if (buffer == nullptr) {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
index bc0474f4bba7..c3a4c346ebfd 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
@@ -43,6 +43,8 @@ class ReadWorker : public Worker {
     bool ProcessXorOp(const CowOperation* cow_op);
     bool ProcessOrderedOp(const CowOperation* cow_op);
     bool ProcessCopyOp(const CowOperation* cow_op);
+    bool ProcessReplaceOp(const CowOperation* cow_op);
+    bool ProcessZeroOp();
 
     bool ReadAlignedSector(sector_t sector, size_t sz);
     bool ReadUnalignedSector(sector_t sector, size_t size);
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
index 510e27d29eea..563f6ad427cc 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
@@ -105,17 +105,20 @@ bool MergeWorker::MergeReplaceZeroOps() {
 
         for (size_t i = 0; i < replace_zero_vec.size(); i++) {
             const CowOperation* cow_op = replace_zero_vec[i];
+
+            void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
+            if (!buffer) {
+                SNAP_LOG(ERROR) << "Failed to acquire buffer in merge";
+                return false;
+            }
             if (cow_op->type == kCowReplaceOp) {
-                if (!ProcessReplaceOp(cow_op)) {
-                    SNAP_LOG(ERROR) << "Merge - ReplaceOp failed for block: " << cow_op->new_block;
+                if (!reader_->ReadData(cow_op, buffer, BLOCK_SZ)) {
+                    SNAP_LOG(ERROR) << "Failed to read COW in merge";
                     return false;
                 }
             } else {
                 CHECK(cow_op->type == kCowZeroOp);
-                if (!ProcessZeroOp()) {
-                    SNAP_LOG(ERROR) << "Merge ZeroOp failed.";
-                    return false;
-                }
+                memset(buffer, 0, BLOCK_SZ);
             }
 
             bufsink_.UpdateBufferOffset(BLOCK_SZ);
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h
index 1175ab714b7e..813b159eaee3 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h
@@ -46,12 +46,6 @@ class Worker {
     bool InitReader();
     virtual void CloseFds() { base_path_merge_fd_ = {}; }
 
-    bool ReadDataFromBaseDevice(sector_t sector, size_t read_size);
-
-    // Processing COW operations
-    bool ProcessReplaceOp(const CowOperation* cow_op);
-    bool ProcessZeroOp();
-
     std::unique_ptr<CowReader> reader_;
     BufferSink bufsink_;
 

From f8f3b627aed47167b2a5d557601c8fa06367eaee Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 13 Jul 2023 09:25:11 -0700
Subject: [PATCH 0192/1487] fs_mgr: Split fs_mgr_overlayfs into two separate
 files.

One of the paint points for fs_mgr_overlayfs is that mounting and
scratch management code are somewhat unrelated but very intertwined in
the same file.

Split it into two files: fs_mgr_overlayfs_mount, which is only for
mount-related code, and fs_mgr_overlayfs_control, which is only for
setup/teardown code.

The code removed from fs_mgr_overlayfs_control.cpp is code that moved
to fs_mgr_overlayfs_mount.cpp.

This converts a bunch of functions to "static", and splits
fs_mgr_priv_overlayfs.h into two new files (fs_mgr_overlayfs_mount.h and
fs_mgr_overlayfs_control.h).

Bug: N/A
Test: remount
Change-Id: I83da43652b4787f344da75a1d30177df1d7f63b2
---
 fs_mgr/Android.bp                             |   3 +-
 ...layfs.cpp => fs_mgr_overlayfs_control.cpp} | 669 +--------------
 ...overlayfs.h => fs_mgr_overlayfs_control.h} |  33 +-
 fs_mgr/fs_mgr_overlayfs_mount.cpp             | 802 ++++++++++++++++++
 fs_mgr/fs_mgr_overlayfs_mount.h               |  62 ++
 fs_mgr/fs_mgr_remount.cpp                     |   3 +-
 6 files changed, 894 insertions(+), 678 deletions(-)
 rename fs_mgr/{fs_mgr_overlayfs.cpp => fs_mgr_overlayfs_control.cpp} (61%)
 rename fs_mgr/{fs_mgr_priv_overlayfs.h => fs_mgr_overlayfs_control.h} (53%)
 create mode 100644 fs_mgr/fs_mgr_overlayfs_mount.cpp
 create mode 100644 fs_mgr/fs_mgr_overlayfs_mount.h

diff --git a/fs_mgr/Android.bp b/fs_mgr/Android.bp
index bbd068bacc19..15600fd403eb 100644
--- a/fs_mgr/Android.bp
+++ b/fs_mgr/Android.bp
@@ -70,8 +70,9 @@ cc_defaults {
         "fs_mgr.cpp",
         "fs_mgr_format.cpp",
         "fs_mgr_dm_linear.cpp",
-        "fs_mgr_overlayfs.cpp",
         "fs_mgr_roots.cpp",
+        "fs_mgr_overlayfs_control.cpp",
+        "fs_mgr_overlayfs_mount.cpp",
         "fs_mgr_vendor_overlay.cpp",
         ":libfiemap_srcs",
     ],
diff --git a/fs_mgr/fs_mgr_overlayfs.cpp b/fs_mgr/fs_mgr_overlayfs_control.cpp
similarity index 61%
rename from fs_mgr/fs_mgr_overlayfs.cpp
rename to fs_mgr/fs_mgr_overlayfs_control.cpp
index 82a8b8b233c9..69a2ac028c6c 100644
--- a/fs_mgr/fs_mgr_overlayfs.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_control.cpp
@@ -55,8 +55,9 @@
 #include <liblp/liblp.h>
 #include <storage_literals/storage_literals.h>
 
+#include "fs_mgr_overlayfs_control.h"
+#include "fs_mgr_overlayfs_mount.h"
 #include "fs_mgr_priv.h"
-#include "fs_mgr_priv_overlayfs.h"
 #include "libfiemap/utility.h"
 
 using namespace std::literals;
@@ -69,100 +70,18 @@ using android::fiemap::IImageManager;
 namespace {
 
 constexpr char kDataScratchSizeMbProp[] = "fs_mgr.overlayfs.data_scratch_size_mb";
-constexpr char kPreferCacheBackingStorageProp[] = "fs_mgr.overlayfs.prefer_cache_backing_storage";
-
-bool fs_mgr_access(const std::string& path) {
-    return access(path.c_str(), F_OK) == 0;
-}
-
-const auto kLowerdirOption = "lowerdir=";
-const auto kUpperdirOption = "upperdir=";
-
-bool fs_mgr_in_recovery() {
-    // Check the existence of recovery binary instead of using the compile time
-    // __ANDROID_RECOVERY__ macro.
-    // If BOARD_USES_RECOVERY_AS_BOOT is true, both normal and recovery boot
-    // mode would use the same init binary, which would mean during normal boot
-    // the '/init' binary is actually a symlink pointing to
-    // init_second_stage.recovery, which would be compiled with
-    // __ANDROID_RECOVERY__ defined.
-    return fs_mgr_access("/system/bin/recovery");
-}
-
-bool fs_mgr_is_dsu_running() {
-    // Since android::gsi::CanBootIntoGsi() or android::gsi::MarkSystemAsGsi() is
-    // never called in recovery, the return value of android::gsi::IsGsiRunning()
-    // is not well-defined. In this case, just return false as being in recovery
-    // implies not running a DSU system.
-    if (fs_mgr_in_recovery()) return false;
-    return android::gsi::IsGsiRunning();
-}
-
-// list of acceptable overlayfs backing storage
-const auto kScratchMountPoint = "/mnt/scratch";
-const auto kCacheMountPoint = "/cache";
-
-bool IsABDevice() {
-    return !android::base::GetProperty("ro.boot.slot_suffix", "").empty();
-}
-
-std::vector<const std::string> OverlayMountPoints() {
-    // Never fallback to legacy cache mount point if within a DSU system,
-    // because running a DSU system implies the device supports dynamic
-    // partitions, which means legacy cache mustn't be used.
-    if (fs_mgr_is_dsu_running()) {
-        return {kScratchMountPoint};
-    }
-
-    // For non-A/B devices prefer cache backing storage if
-    // kPreferCacheBackingStorageProp property set.
-    if (!IsABDevice() && android::base::GetBoolProperty(kPreferCacheBackingStorageProp, false) &&
-        android::base::GetIntProperty("ro.vendor.api_level", -1) < __ANDROID_API_T__) {
-        return {kCacheMountPoint, kScratchMountPoint};
-    }
-
-    return {kScratchMountPoint, kCacheMountPoint};
-}
 
 // Return true if everything is mounted, but before adb is started.  Right
 // after 'trigger load_persist_props_action' is done.
-bool fs_mgr_boot_completed() {
+static bool fs_mgr_boot_completed() {
     return android::base::GetBoolProperty("ro.persistent_properties.ready", false);
 }
 
-bool fs_mgr_is_dir(const std::string& path) {
-    struct stat st;
-    return !stat(path.c_str(), &st) && S_ISDIR(st.st_mode);
-}
-
-bool fs_mgr_rw_access(const std::string& path) {
-    if (path.empty()) return false;
-    return access(path.c_str(), R_OK | W_OK) == 0;
-}
-
-// At less than 1% or 8MB of free space return value of false,
-// means we will try to wrap with overlayfs.
-bool fs_mgr_filesystem_has_space(const std::string& mount_point) {
-    // If we have access issues to find out space remaining, return true
-    // to prevent us trying to override with overlayfs.
-    struct statvfs vst;
-    if (statvfs(mount_point.c_str(), &vst)) {
-        PLOG(ERROR) << "statvfs " << mount_point;
-        return true;
-    }
-
-    static constexpr int kPercentThreshold = 1;                       // 1%
-    static constexpr unsigned long kSizeThreshold = 8 * 1024 * 1024;  // 8MB
-
-    return (vst.f_bfree >= (vst.f_blocks * kPercentThreshold / 100)) &&
-           (static_cast<uint64_t>(vst.f_bfree) * vst.f_frsize) >= kSizeThreshold;
-}
-
-const auto kPhysicalDevice = "/dev/block/by-name/";
+constexpr auto kPhysicalDevice = "/dev/block/by-name/";
 constexpr char kScratchImageMetadata[] = "/metadata/gsi/remount/lp_metadata";
 
 // Note: this is meant only for recovery/first-stage init.
-bool ScratchIsOnData() {
+static bool ScratchIsOnData() {
     // The scratch partition of DSU is managed by gsid.
     if (fs_mgr_is_dsu_running()) {
         return false;
@@ -170,97 +89,7 @@ bool ScratchIsOnData() {
     return fs_mgr_access(kScratchImageMetadata);
 }
 
-bool fs_mgr_update_blk_device(FstabEntry* entry) {
-    if (entry->fs_mgr_flags.logical) {
-        fs_mgr_update_logical_partition(entry);
-    }
-    if (fs_mgr_access(entry->blk_device)) {
-        return true;
-    }
-    if (entry->blk_device != "/dev/root") {
-        return false;
-    }
-
-    // special case for system-as-root (taimen and others)
-    auto blk_device = std::string(kPhysicalDevice) + "system";
-    if (!fs_mgr_access(blk_device)) {
-        blk_device += fs_mgr_get_slot_suffix();
-        if (!fs_mgr_access(blk_device)) {
-            return false;
-        }
-    }
-    entry->blk_device = blk_device;
-    return true;
-}
-
-bool fs_mgr_has_shared_blocks(const std::string& mount_point, const std::string& dev) {
-    struct statfs fs;
-    if ((statfs((mount_point + "/lost+found").c_str(), &fs) == -1) ||
-        (fs.f_type != EXT4_SUPER_MAGIC)) {
-        return false;
-    }
-
-    android::base::unique_fd fd(open(dev.c_str(), O_RDONLY | O_CLOEXEC));
-    if (fd < 0) return false;
-
-    struct ext4_super_block sb;
-    if ((TEMP_FAILURE_RETRY(lseek64(fd, 1024, SEEK_SET)) < 0) ||
-        (TEMP_FAILURE_RETRY(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;
-}
-
-#define F2FS_SUPER_OFFSET 1024
-#define F2FS_FEATURE_OFFSET 2180
-#define F2FS_FEATURE_RO 0x4000
-bool fs_mgr_is_read_only_f2fs(const std::string& dev) {
-    if (!fs_mgr_is_f2fs(dev)) return false;
-
-    android::base::unique_fd fd(open(dev.c_str(), O_RDONLY | O_CLOEXEC));
-    if (fd < 0) return false;
-
-    __le32 feat;
-    if ((TEMP_FAILURE_RETRY(lseek64(fd, F2FS_SUPER_OFFSET + F2FS_FEATURE_OFFSET, SEEK_SET)) < 0) ||
-        (TEMP_FAILURE_RETRY(read(fd, &feat, sizeof(feat))) < 0)) {
-        return false;
-    }
-
-    return (feat & cpu_to_le32(F2FS_FEATURE_RO)) != 0;
-}
-
-bool fs_mgr_overlayfs_enabled(FstabEntry* entry) {
-    // readonly filesystem, can not be mount -o remount,rw
-    // for squashfs, erofs or if free space is (near) zero making such a remount
-    // virtually useless, or if there are shared blocks that prevent remount,rw
-    if (!fs_mgr_filesystem_has_space(entry->mount_point)) {
-        return true;
-    }
-
-    // blk_device needs to be setup so we can check superblock.
-    // If we fail here, because during init first stage and have doubts.
-    if (!fs_mgr_update_blk_device(entry)) {
-        return true;
-    }
-
-    // f2fs read-only mode doesn't support remount,rw
-    if (fs_mgr_is_read_only_f2fs(entry->blk_device)) {
-        return true;
-    }
-
-    // check if ext4 de-dupe
-    auto has_shared_blocks = fs_mgr_has_shared_blocks(entry->mount_point, entry->blk_device);
-    if (!has_shared_blocks && (entry->mount_point == "/system")) {
-        has_shared_blocks = fs_mgr_has_shared_blocks("/", entry->blk_device);
-    }
-    return has_shared_blocks;
-}
-
-bool fs_mgr_rm_all(const std::string& path, bool* change = nullptr, int level = 0) {
+static bool fs_mgr_rm_all(const std::string& path, bool* change = nullptr, int level = 0) {
     std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(path.c_str()), closedir);
     if (!dir) {
         if (errno == ENOENT) {
@@ -301,96 +130,6 @@ bool fs_mgr_rm_all(const std::string& path, bool* change = nullptr, int level =
     return ret;
 }
 
-const auto kUpperName = "upper";
-const auto kWorkName = "work";
-const auto kOverlayTopDir = "/overlay";
-
-std::string fs_mgr_get_overlayfs_candidate(const std::string& mount_point) {
-    if (!fs_mgr_is_dir(mount_point)) return "";
-    const auto base = android::base::Basename(mount_point) + "/";
-    for (const auto& overlay_mount_point : OverlayMountPoints()) {
-        auto dir = overlay_mount_point + kOverlayTopDir + "/" + base;
-        auto upper = dir + kUpperName;
-        if (!fs_mgr_is_dir(upper)) continue;
-        auto work = dir + kWorkName;
-        if (!fs_mgr_is_dir(work)) continue;
-        if (!fs_mgr_rw_access(work)) continue;
-        return dir;
-    }
-    return "";
-}
-
-static inline bool KernelSupportsUserXattrs() {
-    struct utsname uts;
-    uname(&uts);
-
-    int major, minor;
-    if (sscanf(uts.release, "%d.%d", &major, &minor) != 2) {
-        return false;
-    }
-    return major > 5 || (major == 5 && minor >= 15);
-}
-
-const std::string fs_mgr_mount_point(const std::string& mount_point) {
-    if ("/"s != mount_point) return mount_point;
-    return "/system";
-}
-
-// default options for mount_point, returns empty string for none available.
-std::string fs_mgr_get_overlayfs_options(const FstabEntry& entry) {
-    const auto mount_point = fs_mgr_mount_point(entry.mount_point);
-    auto candidate = fs_mgr_get_overlayfs_candidate(mount_point);
-    if (candidate.empty()) return "";
-    auto ret = kLowerdirOption + mount_point + "," + kUpperdirOption + candidate + kUpperName +
-               ",workdir=" + candidate + kWorkName;
-    if (fs_mgr_overlayfs_valid() == OverlayfsValidResult::kOverrideCredsRequired) {
-        ret += ",override_creds=off";
-    }
-    if (KernelSupportsUserXattrs()) {
-        ret += ",userxattr";
-    }
-    for (const auto& flag : android::base::Split(entry.fs_options, ",")) {
-        if (android::base::StartsWith(flag, "context=")) {
-            ret += "," + flag;
-        }
-    }
-    return ret;
-}
-
-constexpr char kOverlayfsFileContext[] = "u:object_r:overlayfs_file:s0";
-
-class AutoSetFsCreateCon final {
-  public:
-    AutoSetFsCreateCon() {}
-    AutoSetFsCreateCon(const std::string& context) { Set(context); }
-    ~AutoSetFsCreateCon() { Restore(); }
-
-    bool Ok() const { return ok_; }
-    bool Set(const std::string& context) {
-        if (setfscreatecon(context.c_str())) {
-            PLOG(ERROR) << "setfscreatecon " << context;
-            return false;
-        }
-        ok_ = true;
-        return true;
-    }
-    bool Restore() {
-        if (restored_ || !ok_) {
-            return true;
-        }
-        if (setfscreatecon(nullptr)) {
-            PLOG(ERROR) << "setfscreatecon null";
-            return false;
-        }
-        restored_ = true;
-        return true;
-    }
-
-  private:
-    bool ok_ = false;
-    bool restored_ = false;
-};
-
 std::string fs_mgr_overlayfs_setup_dir(const std::string& dir) {
     auto top = dir + kOverlayTopDir;
 
@@ -452,15 +191,15 @@ bool fs_mgr_overlayfs_setup_one(const std::string& overlay, const std::string& m
     return true;
 }
 
-uint32_t fs_mgr_overlayfs_slot_number() {
+static uint32_t fs_mgr_overlayfs_slot_number() {
     return SlotNumberForSlotSuffix(fs_mgr_get_slot_suffix());
 }
 
-std::string fs_mgr_overlayfs_super_device(uint32_t slot_number) {
+static std::string fs_mgr_overlayfs_super_device(uint32_t slot_number) {
     return kPhysicalDevice + fs_mgr_get_super_partition_name(slot_number);
 }
 
-bool fs_mgr_overlayfs_has_logical(const Fstab& fstab) {
+static bool fs_mgr_overlayfs_has_logical(const Fstab& fstab) {
     for (const auto& entry : fstab) {
         if (entry.fs_mgr_flags.logical) {
             return true;
@@ -469,18 +208,6 @@ bool fs_mgr_overlayfs_has_logical(const Fstab& fstab) {
     return false;
 }
 
-// Returns true if immediate unmount succeeded and the scratch mount point was
-// removed.
-bool fs_mgr_overlayfs_umount_scratch() {
-    if (umount(kScratchMountPoint) != 0) {
-        return false;
-    }
-    if (rmdir(kScratchMountPoint) != 0 && errno != ENOENT) {
-        PLOG(ERROR) << "rmdir " << kScratchMountPoint;
-    }
-    return true;
-}
-
 OverlayfsTeardownResult TeardownDataScratch(IImageManager* images,
                                             const std::string& partition_name, bool was_mounted) {
     if (!images) {
@@ -619,214 +346,6 @@ bool fs_mgr_overlayfs_teardown_one(const std::string& overlay, const std::string
     return ret;
 }
 
-bool fs_mgr_overlayfs_set_shared_mount(const std::string& mount_point, bool shared_flag) {
-    auto ret = mount(nullptr, mount_point.c_str(), nullptr, shared_flag ? MS_SHARED : MS_PRIVATE,
-                     nullptr);
-    if (ret) {
-        PERROR << "__mount(target=" << mount_point
-               << ",flag=" << (shared_flag ? "MS_SHARED" : "MS_PRIVATE") << ")=" << ret;
-        // If "/system" doesn't look like a mountpoint, retry with "/".
-        if (errno == EINVAL && mount_point == "/system") {
-            return fs_mgr_overlayfs_set_shared_mount("/", shared_flag);
-        }
-        return false;
-    }
-    return true;
-}
-
-bool fs_mgr_overlayfs_move_mount(const std::string& source, const std::string& target) {
-    auto ret = mount(source.c_str(), target.c_str(), nullptr, MS_MOVE, nullptr);
-    if (ret) {
-        PERROR << "__mount(source=" << source << ",target=" << target << ",flag=MS_MOVE)=" << ret;
-        return false;
-    }
-    return true;
-}
-
-struct mount_info {
-    std::string mount_point;
-    bool shared_flag;
-};
-
-std::vector<mount_info> ReadMountinfoFromFile(const std::string& path) {
-    std::vector<mount_info> info;
-
-    auto file = std::unique_ptr<FILE, decltype(&fclose)>{fopen(path.c_str(), "re"), fclose};
-    if (!file) {
-        PERROR << __FUNCTION__ << "(): cannot open file: '" << path << "'";
-        return info;
-    }
-
-    ssize_t len;
-    size_t alloc_len = 0;
-    char* line = nullptr;
-    while ((len = getline(&line, &alloc_len, file.get())) != -1) {
-        /* if the last character is a newline, shorten the string by 1 byte */
-        if (line[len - 1] == '\n') {
-            line[len - 1] = '\0';
-        }
-
-        static constexpr char delim[] = " \t";
-        char* save_ptr;
-        if (!strtok_r(line, delim, &save_ptr)) {
-            LERROR << "Error parsing mount ID";
-            break;
-        }
-        if (!strtok_r(nullptr, delim, &save_ptr)) {
-            LERROR << "Error parsing parent ID";
-            break;
-        }
-        if (!strtok_r(nullptr, delim, &save_ptr)) {
-            LERROR << "Error parsing mount source";
-            break;
-        }
-        if (!strtok_r(nullptr, delim, &save_ptr)) {
-            LERROR << "Error parsing root";
-            break;
-        }
-
-        char* p;
-        if (!(p = strtok_r(nullptr, delim, &save_ptr))) {
-            LERROR << "Error parsing mount_point";
-            break;
-        }
-        mount_info entry = {p, false};
-
-        if (!strtok_r(nullptr, delim, &save_ptr)) {
-            LERROR << "Error parsing mount_flags";
-            break;
-        }
-
-        while ((p = strtok_r(nullptr, delim, &save_ptr))) {
-            if ((p[0] == '-') && (p[1] == '\0')) break;
-            if (android::base::StartsWith(p, "shared:")) entry.shared_flag = true;
-        }
-        if (!p) {
-            LERROR << "Error parsing fields";
-            break;
-        }
-        info.emplace_back(std::move(entry));
-    }
-
-    free(line);
-    if (info.empty()) {
-        LERROR << __FUNCTION__ << "(): failed to load mountinfo from : '" << path << "'";
-    }
-    return info;
-}
-
-bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
-    const auto mount_point = fs_mgr_mount_point(entry.mount_point);
-    const auto options = fs_mgr_get_overlayfs_options(entry);
-    if (options.empty()) return false;
-
-    auto retval = true;
-
-    struct move_entry {
-        std::string mount_point;
-        std::string dir;
-        bool shared_flag;
-    };
-    std::vector<move_entry> move;
-    auto parent_private = false;
-    auto parent_made_private = false;
-    auto dev_private = false;
-    auto dev_made_private = false;
-    for (auto& entry : ReadMountinfoFromFile("/proc/self/mountinfo")) {
-        if ((entry.mount_point == mount_point) && !entry.shared_flag) {
-            parent_private = true;
-        }
-        if ((entry.mount_point == "/dev") && !entry.shared_flag) {
-            dev_private = true;
-        }
-
-        if (!android::base::StartsWith(entry.mount_point, mount_point + "/")) {
-            continue;
-        }
-        if (std::find_if(move.begin(), move.end(), [&entry](const auto& it) {
-                return android::base::StartsWith(entry.mount_point, it.mount_point + "/");
-            }) != move.end()) {
-            continue;
-        }
-
-        // use as the bound directory in /dev.
-        AutoSetFsCreateCon createcon;
-        auto new_context = fs_mgr_get_context(entry.mount_point);
-        if (new_context.empty() || !createcon.Set(new_context)) {
-            continue;
-        }
-        move_entry new_entry = {std::move(entry.mount_point), "/dev/TemporaryDir-XXXXXX",
-                                entry.shared_flag};
-        const auto target = mkdtemp(new_entry.dir.data());
-        if (!createcon.Restore()) {
-            return false;
-        }
-        if (!target) {
-            retval = false;
-            PERROR << "temporary directory for MS_BIND";
-            continue;
-        }
-
-        if (!parent_private && !parent_made_private) {
-            parent_made_private = fs_mgr_overlayfs_set_shared_mount(mount_point, false);
-        }
-        if (new_entry.shared_flag) {
-            new_entry.shared_flag = fs_mgr_overlayfs_set_shared_mount(new_entry.mount_point, false);
-        }
-        if (!fs_mgr_overlayfs_move_mount(new_entry.mount_point, new_entry.dir)) {
-            retval = false;
-            if (new_entry.shared_flag) {
-                fs_mgr_overlayfs_set_shared_mount(new_entry.mount_point, true);
-            }
-            continue;
-        }
-        move.emplace_back(std::move(new_entry));
-    }
-
-    // hijack __mount() report format to help triage
-    auto report = "__mount(source=overlay,target="s + mount_point + ",type=overlay";
-    const auto opt_list = android::base::Split(options, ",");
-    for (const auto& opt : opt_list) {
-        if (android::base::StartsWith(opt, kUpperdirOption)) {
-            report = report + "," + opt;
-            break;
-        }
-    }
-    report = report + ")=";
-
-    auto ret = mount("overlay", mount_point.c_str(), "overlay", MS_RDONLY | MS_NOATIME,
-                     options.c_str());
-    if (ret) {
-        retval = false;
-        PERROR << report << ret;
-    } else {
-        LINFO << report << ret;
-    }
-
-    // Move submounts back.
-    for (const auto& entry : move) {
-        if (!dev_private && !dev_made_private) {
-            dev_made_private = fs_mgr_overlayfs_set_shared_mount("/dev", false);
-        }
-
-        if (!fs_mgr_overlayfs_move_mount(entry.dir, entry.mount_point)) {
-            retval = false;
-        } else if (entry.shared_flag &&
-                   !fs_mgr_overlayfs_set_shared_mount(entry.mount_point, true)) {
-            retval = false;
-        }
-        rmdir(entry.dir.c_str());
-    }
-    if (dev_made_private) {
-        fs_mgr_overlayfs_set_shared_mount("/dev", true);
-    }
-    if (parent_made_private) {
-        fs_mgr_overlayfs_set_shared_mount(mount_point, true);
-    }
-
-    return retval;
-}
-
 // Mount kScratchMountPoint
 bool MountScratch(const std::string& device_path, bool readonly = false) {
     if (readonly) {
@@ -1010,21 +529,7 @@ static bool CreateDynamicScratch(std::string* scratch_device, bool* partition_ex
         auto partition_size =
                 builder->AllocatableSpace() - builder->UsedSpace() + partition->size();
         if ((partition_size > kMinimumSize) || !partition->size()) {
-            // Leave some space for free space jitter of a few erase
-            // blocks, in case they are needed for any individual updates
-            // to any other partition that needs to be flashed while
-            // overlayfs is in force.  Of course if margin_size is not
-            // enough could normally get a flash failure, so
-            // ResizePartition() will delete the scratch partition in
-            // order to fulfill.  Deleting scratch will destroy all of
-            // the adb remount overrides :-( .
-            auto margin_size = uint64_t(3 * 256 * 1024);
-            BlockDeviceInfo info;
-            if (builder->GetBlockDeviceInfo(fs_mgr_get_super_partition_name(slot_number), &info)) {
-                margin_size = 3 * info.logical_block_size;
-            }
-            partition_size = std::max(std::min(kMinimumSize, partition_size - margin_size),
-                                      partition_size / 2);
+            partition_size = std::max(std::min(kMinimumSize, partition_size), partition_size / 2);
             if (partition_size > partition->size()) {
                 if (!builder->ResizePartition(partition, partition_size)) {
                     // Try to free up space by deallocating partitions in the other slot.
@@ -1032,8 +537,8 @@ static bool CreateDynamicScratch(std::string* scratch_device, bool* partition_ex
 
                     partition_size =
                             builder->AllocatableSpace() - builder->UsedSpace() + partition->size();
-                    partition_size = std::max(std::min(kMinimumSize, partition_size - margin_size),
-                                              partition_size / 2);
+                    partition_size =
+                            std::max(std::min(kMinimumSize, partition_size), partition_size / 2);
                     if (!builder->ResizePartition(partition, partition_size)) {
                         LERROR << "resize " << partition_name;
                         return false;
@@ -1212,12 +717,6 @@ bool fs_mgr_overlayfs_setup_scratch(const Fstab& fstab) {
     return MountScratch(scratch_device);
 }
 
-#if ALLOW_ADBD_DISABLE_VERITY
-constexpr bool kAllowOverlayfs = true;
-#else
-constexpr bool kAllowOverlayfs = false;
-#endif
-
 // NOTE: OverlayfsSetupAllowed() must be "stricter" than OverlayfsTeardownAllowed().
 // Setup is allowed only if teardown is also allowed.
 bool OverlayfsSetupAllowed(bool verbose = false) {
@@ -1251,114 +750,6 @@ constexpr bool OverlayfsTeardownAllowed() {
 
 }  // namespace
 
-bool fs_mgr_wants_overlayfs(FstabEntry* entry) {
-    // Don't check entries that are managed by vold.
-    if (entry->fs_mgr_flags.vold_managed || entry->fs_mgr_flags.recovery_only) return false;
-
-    // *_other doesn't want overlayfs.
-    if (entry->fs_mgr_flags.slot_select_other) return false;
-
-    // Only concerned with readonly partitions.
-    if (!(entry->flags & MS_RDONLY)) return false;
-
-    // If unbindable, do not allow overlayfs as this could expose us to
-    // security issues.  On Android, this could also be used to turn off
-    // the ability to overlay an otherwise acceptable filesystem since
-    // /system and /vendor are never bound(sic) to.
-    if (entry->flags & MS_UNBINDABLE) return false;
-
-    if (!fs_mgr_overlayfs_enabled(entry)) return false;
-
-    return true;
-}
-
-Fstab fs_mgr_overlayfs_candidate_list(const Fstab& fstab) {
-    android::fs_mgr::Fstab mounts;
-    if (!android::fs_mgr::ReadFstabFromFile("/proc/mounts", &mounts)) {
-        PLOG(ERROR) << "Failed to read /proc/mounts";
-        return {};
-    }
-
-    Fstab candidates;
-    for (const auto& entry : fstab) {
-        // Filter out partitions whose type doesn't match what's mounted.
-        // This avoids spammy behavior on devices which can mount different
-        // filesystems for each partition.
-        auto proc_mount_point = (entry.mount_point == "/system") ? "/" : entry.mount_point;
-        auto mounted = GetEntryForMountPoint(&mounts, proc_mount_point);
-        if (!mounted || mounted->fs_type != entry.fs_type) {
-            continue;
-        }
-
-        FstabEntry new_entry = entry;
-        if (!fs_mgr_overlayfs_already_mounted(entry.mount_point) &&
-            !fs_mgr_wants_overlayfs(&new_entry)) {
-            continue;
-        }
-        auto new_mount_point = fs_mgr_mount_point(entry.mount_point);
-        auto duplicate_or_more_specific = false;
-        for (auto it = candidates.begin(); it != candidates.end();) {
-            auto it_mount_point = fs_mgr_mount_point(it->mount_point);
-            if ((it_mount_point == new_mount_point) ||
-                (android::base::StartsWith(new_mount_point, it_mount_point + "/"))) {
-                duplicate_or_more_specific = true;
-                break;
-            }
-            if (android::base::StartsWith(it_mount_point, new_mount_point + "/")) {
-                it = candidates.erase(it);
-            } else {
-                ++it;
-            }
-        }
-        if (!duplicate_or_more_specific) candidates.emplace_back(std::move(new_entry));
-    }
-    return candidates;
-}
-
-static void TryMountScratch() {
-    // Note we get the boot scratch device here, which means if scratch was
-    // just created through ImageManager, this could fail. In practice this
-    // should not happen because "remount" detects this scenario (by checking
-    // if verity is still disabled, i.e. no reboot occurred), and skips calling
-    // fs_mgr_overlayfs_mount_all().
-    auto scratch_device = GetBootScratchDevice();
-    if (!fs_mgr_rw_access(scratch_device)) {
-        return;
-    }
-    if (!WaitForFile(scratch_device, 10s)) {
-        return;
-    }
-    if (!MountScratch(scratch_device, true /* readonly */)) {
-        return;
-    }
-    auto has_overlayfs_dir = fs_mgr_access(std::string(kScratchMountPoint) + kOverlayTopDir);
-    fs_mgr_overlayfs_umount_scratch();
-    if (has_overlayfs_dir) {
-        MountScratch(scratch_device);
-    }
-}
-
-bool fs_mgr_overlayfs_mount_all(Fstab* fstab) {
-    if (!OverlayfsSetupAllowed()) {
-        return false;
-    }
-    auto ret = true;
-    auto scratch_can_be_mounted = true;
-    for (const auto& entry : fs_mgr_overlayfs_candidate_list(*fstab)) {
-        if (fs_mgr_is_verity_enabled(entry)) continue;
-        auto mount_point = fs_mgr_mount_point(entry.mount_point);
-        if (fs_mgr_overlayfs_already_mounted(mount_point)) {
-            continue;
-        }
-        if (scratch_can_be_mounted) {
-            scratch_can_be_mounted = false;
-            TryMountScratch();
-        }
-        ret &= fs_mgr_overlayfs_mount(entry);
-    }
-    return ret;
-}
-
 bool fs_mgr_overlayfs_setup(const Fstab& fstab, const char* mount_point, bool* want_reboot,
                             bool just_disabled_verity) {
     if (!OverlayfsSetupAllowed(/*verbose=*/true)) {
@@ -1582,22 +973,6 @@ OverlayfsTeardownResult fs_mgr_overlayfs_teardown(const char* mount_point, bool*
     return rv;
 }
 
-bool fs_mgr_overlayfs_is_setup() {
-    if (!OverlayfsSetupAllowed()) {
-        return false;
-    }
-    if (fs_mgr_overlayfs_already_mounted(kScratchMountPoint, false)) return true;
-    Fstab fstab;
-    if (!ReadDefaultFstab(&fstab)) {
-        return false;
-    }
-    for (const auto& entry : fs_mgr_overlayfs_candidate_list(fstab)) {
-        if (fs_mgr_is_verity_enabled(entry)) continue;
-        if (fs_mgr_overlayfs_already_mounted(fs_mgr_mount_point(entry.mount_point))) return true;
-    }
-    return false;
-}
-
 namespace android {
 namespace fs_mgr {
 
@@ -1714,23 +1089,3 @@ void TeardownAllOverlayForMountPoint(const std::string& mount_point) {
 
 }  // namespace fs_mgr
 }  // namespace android
-
-bool fs_mgr_overlayfs_already_mounted(const std::string& mount_point, bool overlay_only) {
-    Fstab fstab;
-    if (!ReadFstabFromFile("/proc/mounts", &fstab)) {
-        return false;
-    }
-    const auto lowerdir = kLowerdirOption + mount_point;
-    for (const auto& entry : fstab) {
-        if (overlay_only && "overlay" != entry.fs_type && "overlayfs" != entry.fs_type) continue;
-        if (mount_point != entry.mount_point) continue;
-        if (!overlay_only) return true;
-        const auto options = android::base::Split(entry.fs_options, ",");
-        for (const auto& opt : options) {
-            if (opt == lowerdir) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
diff --git a/fs_mgr/fs_mgr_priv_overlayfs.h b/fs_mgr/fs_mgr_overlayfs_control.h
similarity index 53%
rename from fs_mgr/fs_mgr_priv_overlayfs.h
rename to fs_mgr/fs_mgr_overlayfs_control.h
index 2033701d9a58..50e83e8a30ef 100644
--- a/fs_mgr/fs_mgr_priv_overlayfs.h
+++ b/fs_mgr/fs_mgr_overlayfs_control.h
@@ -1,18 +1,16 @@
-/*
- * Copyright (C) 2022 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.
- */
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #pragma once
 
@@ -20,11 +18,8 @@
 
 #include <fstab/fstab.h>
 
-bool fs_mgr_overlayfs_already_mounted(const std::string& mount_point, bool overlay_only = true);
-bool fs_mgr_wants_overlayfs(android::fs_mgr::FstabEntry* entry);
-android::fs_mgr::Fstab fs_mgr_overlayfs_candidate_list(const android::fs_mgr::Fstab& fstab);
-
 // If "mount_point" is non-null, set up exactly one overlay.
+//
 // If "mount_point" is null, setup any overlays.
 //
 // If |want_reboot| is non-null, and a reboot is needed to apply overlays, then
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
new file mode 100644
index 000000000000..c057c2bc1369
--- /dev/null
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -0,0 +1,802 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/fs.h>
+#include <selinux/selinux.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mount.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <sys/types.h>
+#include <sys/utsname.h>
+#include <sys/vfs.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <android-base/file.h>
+#include <android-base/macros.h>
+#include <android-base/properties.h>
+#include <android-base/strings.h>
+#include <android-base/unique_fd.h>
+#include <ext4_utils/ext4_utils.h>
+#include <fs_mgr.h>
+#include <fs_mgr/file_wait.h>
+#include <fs_mgr_dm_linear.h>
+#include <fs_mgr_overlayfs.h>
+#include <fstab/fstab.h>
+#include <libdm/dm.h>
+#include <libgsi/libgsi.h>
+#include <storage_literals/storage_literals.h>
+
+#include "fs_mgr_overlayfs_mount.h"
+#include "fs_mgr_priv.h"
+
+using namespace std::literals;
+using namespace android::dm;
+using namespace android::fs_mgr;
+using namespace android::storage_literals;
+
+constexpr char kPreferCacheBackingStorageProp[] = "fs_mgr.overlayfs.prefer_cache_backing_storage";
+
+bool fs_mgr_access(const std::string& path) {
+    return access(path.c_str(), F_OK) == 0;
+}
+
+const auto kLowerdirOption = "lowerdir=";
+const auto kUpperdirOption = "upperdir=";
+
+bool fs_mgr_in_recovery() {
+    // Check the existence of recovery binary instead of using the compile time
+    // __ANDROID_RECOVERY__ macro.
+    // If BOARD_USES_RECOVERY_AS_BOOT is true, both normal and recovery boot
+    // mode would use the same init binary, which would mean during normal boot
+    // the '/init' binary is actually a symlink pointing to
+    // init_second_stage.recovery, which would be compiled with
+    // __ANDROID_RECOVERY__ defined.
+    return fs_mgr_access("/system/bin/recovery");
+}
+
+bool fs_mgr_is_dsu_running() {
+    // Since android::gsi::CanBootIntoGsi() or android::gsi::MarkSystemAsGsi() is
+    // never called in recovery, the return value of android::gsi::IsGsiRunning()
+    // is not well-defined. In this case, just return false as being in recovery
+    // implies not running a DSU system.
+    if (fs_mgr_in_recovery()) return false;
+    return android::gsi::IsGsiRunning();
+}
+
+const auto kCacheMountPoint = "/cache";
+
+static bool IsABDevice() {
+    return !android::base::GetProperty("ro.boot.slot_suffix", "").empty();
+}
+
+std::vector<const std::string> OverlayMountPoints() {
+    // Never fallback to legacy cache mount point if within a DSU system,
+    // because running a DSU system implies the device supports dynamic
+    // partitions, which means legacy cache mustn't be used.
+    if (fs_mgr_is_dsu_running()) {
+        return {kScratchMountPoint};
+    }
+
+    // For non-A/B devices prefer cache backing storage if
+    // kPreferCacheBackingStorageProp property set.
+    if (!IsABDevice() && android::base::GetBoolProperty(kPreferCacheBackingStorageProp, false) &&
+        android::base::GetIntProperty("ro.vendor.api_level", -1) < __ANDROID_API_T__) {
+        return {kCacheMountPoint, kScratchMountPoint};
+    }
+
+    return {kScratchMountPoint, kCacheMountPoint};
+}
+
+static bool fs_mgr_is_dir(const std::string& path) {
+    struct stat st;
+    return !stat(path.c_str(), &st) && S_ISDIR(st.st_mode);
+}
+
+bool fs_mgr_rw_access(const std::string& path) {
+    if (path.empty()) return false;
+    return access(path.c_str(), R_OK | W_OK) == 0;
+}
+
+// At less than 1% or 8MB of free space return value of false,
+// means we will try to wrap with overlayfs.
+bool fs_mgr_filesystem_has_space(const std::string& mount_point) {
+    // If we have access issues to find out space remaining, return true
+    // to prevent us trying to override with overlayfs.
+    struct statvfs vst;
+    if (statvfs(mount_point.c_str(), &vst)) {
+        PLOG(ERROR) << "statvfs " << mount_point;
+        return true;
+    }
+
+    static constexpr int kPercentThreshold = 1;                       // 1%
+    static constexpr unsigned long kSizeThreshold = 8 * 1024 * 1024;  // 8MB
+
+    return (vst.f_bfree >= (vst.f_blocks * kPercentThreshold / 100)) &&
+           (static_cast<uint64_t>(vst.f_bfree) * vst.f_frsize) >= kSizeThreshold;
+}
+
+const auto kPhysicalDevice = "/dev/block/by-name/";
+
+static bool fs_mgr_update_blk_device(FstabEntry* entry) {
+    if (entry->fs_mgr_flags.logical) {
+        fs_mgr_update_logical_partition(entry);
+    }
+    if (fs_mgr_access(entry->blk_device)) {
+        return true;
+    }
+    if (entry->blk_device != "/dev/root") {
+        return false;
+    }
+
+    // special case for system-as-root (taimen and others)
+    auto blk_device = std::string(kPhysicalDevice) + "system";
+    if (!fs_mgr_access(blk_device)) {
+        blk_device += fs_mgr_get_slot_suffix();
+        if (!fs_mgr_access(blk_device)) {
+            return false;
+        }
+    }
+    entry->blk_device = blk_device;
+    return true;
+}
+
+static bool fs_mgr_has_shared_blocks(const std::string& mount_point, const std::string& dev) {
+    struct statfs fs;
+    if ((statfs((mount_point + "/lost+found").c_str(), &fs) == -1) ||
+        (fs.f_type != EXT4_SUPER_MAGIC)) {
+        return false;
+    }
+
+    android::base::unique_fd fd(open(dev.c_str(), O_RDONLY | O_CLOEXEC));
+    if (fd < 0) return false;
+
+    struct ext4_super_block sb;
+    if ((TEMP_FAILURE_RETRY(lseek64(fd, 1024, SEEK_SET)) < 0) ||
+        (TEMP_FAILURE_RETRY(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;
+}
+
+#define F2FS_SUPER_OFFSET 1024
+#define F2FS_FEATURE_OFFSET 2180
+#define F2FS_FEATURE_RO 0x4000
+static bool fs_mgr_is_read_only_f2fs(const std::string& dev) {
+    if (!fs_mgr_is_f2fs(dev)) return false;
+
+    android::base::unique_fd fd(open(dev.c_str(), O_RDONLY | O_CLOEXEC));
+    if (fd < 0) return false;
+
+    __le32 feat;
+    if ((TEMP_FAILURE_RETRY(lseek64(fd, F2FS_SUPER_OFFSET + F2FS_FEATURE_OFFSET, SEEK_SET)) < 0) ||
+        (TEMP_FAILURE_RETRY(read(fd, &feat, sizeof(feat))) < 0)) {
+        return false;
+    }
+
+    return (feat & cpu_to_le32(F2FS_FEATURE_RO)) != 0;
+}
+
+static bool fs_mgr_overlayfs_enabled(FstabEntry* entry) {
+    // readonly filesystem, can not be mount -o remount,rw
+    // for squashfs, erofs or if free space is (near) zero making such a remount
+    // virtually useless, or if there are shared blocks that prevent remount,rw
+    if (!fs_mgr_filesystem_has_space(entry->mount_point)) {
+        return true;
+    }
+
+    // blk_device needs to be setup so we can check superblock.
+    // If we fail here, because during init first stage and have doubts.
+    if (!fs_mgr_update_blk_device(entry)) {
+        return true;
+    }
+
+    // f2fs read-only mode doesn't support remount,rw
+    if (fs_mgr_is_read_only_f2fs(entry->blk_device)) {
+        return true;
+    }
+
+    // check if ext4 de-dupe
+    auto has_shared_blocks = fs_mgr_has_shared_blocks(entry->mount_point, entry->blk_device);
+    if (!has_shared_blocks && (entry->mount_point == "/system")) {
+        has_shared_blocks = fs_mgr_has_shared_blocks("/", entry->blk_device);
+    }
+    return has_shared_blocks;
+}
+
+static std::string fs_mgr_get_overlayfs_candidate(const std::string& mount_point) {
+    if (!fs_mgr_is_dir(mount_point)) return "";
+    const auto base = android::base::Basename(mount_point) + "/";
+    for (const auto& overlay_mount_point : OverlayMountPoints()) {
+        auto dir = overlay_mount_point + kOverlayTopDir + "/" + base;
+        auto upper = dir + kUpperName;
+        if (!fs_mgr_is_dir(upper)) continue;
+        auto work = dir + kWorkName;
+        if (!fs_mgr_is_dir(work)) continue;
+        if (!fs_mgr_rw_access(work)) continue;
+        return dir;
+    }
+    return "";
+}
+
+static inline bool KernelSupportsUserXattrs() {
+    struct utsname uts;
+    uname(&uts);
+
+    int major, minor;
+    if (sscanf(uts.release, "%d.%d", &major, &minor) != 2) {
+        return false;
+    }
+    return major > 5 || (major == 5 && minor >= 15);
+}
+
+const std::string fs_mgr_mount_point(const std::string& mount_point) {
+    if ("/"s != mount_point) return mount_point;
+    return "/system";
+}
+
+// default options for mount_point, returns empty string for none available.
+static std::string fs_mgr_get_overlayfs_options(const FstabEntry& entry) {
+    const auto mount_point = fs_mgr_mount_point(entry.mount_point);
+    auto candidate = fs_mgr_get_overlayfs_candidate(mount_point);
+    if (candidate.empty()) return "";
+    auto ret = kLowerdirOption + mount_point + "," + kUpperdirOption + candidate + kUpperName +
+               ",workdir=" + candidate + kWorkName;
+    if (fs_mgr_overlayfs_valid() == OverlayfsValidResult::kOverrideCredsRequired) {
+        ret += ",override_creds=off";
+    }
+    if (KernelSupportsUserXattrs()) {
+        ret += ",userxattr";
+    }
+    for (const auto& flag : android::base::Split(entry.fs_options, ",")) {
+        if (android::base::StartsWith(flag, "context=")) {
+            ret += "," + flag;
+        }
+    }
+    return ret;
+}
+
+bool AutoSetFsCreateCon::Set(const std::string& context) {
+    if (setfscreatecon(context.c_str())) {
+        PLOG(ERROR) << "setfscreatecon " << context;
+        return false;
+    }
+    ok_ = true;
+    return true;
+}
+
+bool AutoSetFsCreateCon::Restore() {
+    if (restored_ || !ok_) {
+        return true;
+    }
+    if (setfscreatecon(nullptr)) {
+        PLOG(ERROR) << "setfscreatecon null";
+        return false;
+    }
+    restored_ = true;
+    return true;
+}
+
+// Returns true if immediate unmount succeeded and the scratch mount point was
+// removed.
+bool fs_mgr_overlayfs_umount_scratch() {
+    if (umount(kScratchMountPoint) != 0) {
+        return false;
+    }
+    if (rmdir(kScratchMountPoint) != 0 && errno != ENOENT) {
+        PLOG(ERROR) << "rmdir " << kScratchMountPoint;
+    }
+    return true;
+}
+
+static bool fs_mgr_overlayfs_set_shared_mount(const std::string& mount_point, bool shared_flag) {
+    auto ret = mount(nullptr, mount_point.c_str(), nullptr, shared_flag ? MS_SHARED : MS_PRIVATE,
+                     nullptr);
+    if (ret) {
+        PERROR << "__mount(target=" << mount_point
+               << ",flag=" << (shared_flag ? "MS_SHARED" : "MS_PRIVATE") << ")=" << ret;
+        // If "/system" doesn't look like a mountpoint, retry with "/".
+        if (errno == EINVAL && mount_point == "/system") {
+            return fs_mgr_overlayfs_set_shared_mount("/", shared_flag);
+        }
+        return false;
+    }
+    return true;
+}
+
+static bool fs_mgr_overlayfs_move_mount(const std::string& source, const std::string& target) {
+    auto ret = mount(source.c_str(), target.c_str(), nullptr, MS_MOVE, nullptr);
+    if (ret) {
+        PERROR << "__mount(source=" << source << ",target=" << target << ",flag=MS_MOVE)=" << ret;
+        return false;
+    }
+    return true;
+}
+
+struct mount_info {
+    std::string mount_point;
+    bool shared_flag;
+};
+
+static std::vector<mount_info> ReadMountinfoFromFile(const std::string& path) {
+    std::vector<mount_info> info;
+
+    auto file = std::unique_ptr<FILE, decltype(&fclose)>{fopen(path.c_str(), "re"), fclose};
+    if (!file) {
+        PERROR << __FUNCTION__ << "(): cannot open file: '" << path << "'";
+        return info;
+    }
+
+    ssize_t len;
+    size_t alloc_len = 0;
+    char* line = nullptr;
+    while ((len = getline(&line, &alloc_len, file.get())) != -1) {
+        /* if the last character is a newline, shorten the string by 1 byte */
+        if (line[len - 1] == '\n') {
+            line[len - 1] = '\0';
+        }
+
+        static constexpr char delim[] = " \t";
+        char* save_ptr;
+        if (!strtok_r(line, delim, &save_ptr)) {
+            LERROR << "Error parsing mount ID";
+            break;
+        }
+        if (!strtok_r(nullptr, delim, &save_ptr)) {
+            LERROR << "Error parsing parent ID";
+            break;
+        }
+        if (!strtok_r(nullptr, delim, &save_ptr)) {
+            LERROR << "Error parsing mount source";
+            break;
+        }
+        if (!strtok_r(nullptr, delim, &save_ptr)) {
+            LERROR << "Error parsing root";
+            break;
+        }
+
+        char* p;
+        if (!(p = strtok_r(nullptr, delim, &save_ptr))) {
+            LERROR << "Error parsing mount_point";
+            break;
+        }
+        mount_info entry = {p, false};
+
+        if (!strtok_r(nullptr, delim, &save_ptr)) {
+            LERROR << "Error parsing mount_flags";
+            break;
+        }
+
+        while ((p = strtok_r(nullptr, delim, &save_ptr))) {
+            if ((p[0] == '-') && (p[1] == '\0')) break;
+            if (android::base::StartsWith(p, "shared:")) entry.shared_flag = true;
+        }
+        if (!p) {
+            LERROR << "Error parsing fields";
+            break;
+        }
+        info.emplace_back(std::move(entry));
+    }
+
+    free(line);
+    if (info.empty()) {
+        LERROR << __FUNCTION__ << "(): failed to load mountinfo from : '" << path << "'";
+    }
+    return info;
+}
+
+static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
+    const auto mount_point = fs_mgr_mount_point(entry.mount_point);
+    const auto options = fs_mgr_get_overlayfs_options(entry);
+    if (options.empty()) return false;
+
+    auto retval = true;
+
+    struct move_entry {
+        std::string mount_point;
+        std::string dir;
+        bool shared_flag;
+    };
+    std::vector<move_entry> move;
+    auto parent_private = false;
+    auto parent_made_private = false;
+    auto dev_private = false;
+    auto dev_made_private = false;
+    for (auto& entry : ReadMountinfoFromFile("/proc/self/mountinfo")) {
+        if ((entry.mount_point == mount_point) && !entry.shared_flag) {
+            parent_private = true;
+        }
+        if ((entry.mount_point == "/dev") && !entry.shared_flag) {
+            dev_private = true;
+        }
+
+        if (!android::base::StartsWith(entry.mount_point, mount_point + "/")) {
+            continue;
+        }
+        if (std::find_if(move.begin(), move.end(), [&entry](const auto& it) {
+                return android::base::StartsWith(entry.mount_point, it.mount_point + "/");
+            }) != move.end()) {
+            continue;
+        }
+
+        // use as the bound directory in /dev.
+        AutoSetFsCreateCon createcon;
+        auto new_context = fs_mgr_get_context(entry.mount_point);
+        if (new_context.empty() || !createcon.Set(new_context)) {
+            continue;
+        }
+        move_entry new_entry = {std::move(entry.mount_point), "/dev/TemporaryDir-XXXXXX",
+                                entry.shared_flag};
+        const auto target = mkdtemp(new_entry.dir.data());
+        if (!createcon.Restore()) {
+            return false;
+        }
+        if (!target) {
+            retval = false;
+            PERROR << "temporary directory for MS_BIND";
+            continue;
+        }
+
+        if (!parent_private && !parent_made_private) {
+            parent_made_private = fs_mgr_overlayfs_set_shared_mount(mount_point, false);
+        }
+        if (new_entry.shared_flag) {
+            new_entry.shared_flag = fs_mgr_overlayfs_set_shared_mount(new_entry.mount_point, false);
+        }
+        if (!fs_mgr_overlayfs_move_mount(new_entry.mount_point, new_entry.dir)) {
+            retval = false;
+            if (new_entry.shared_flag) {
+                fs_mgr_overlayfs_set_shared_mount(new_entry.mount_point, true);
+            }
+            continue;
+        }
+        move.emplace_back(std::move(new_entry));
+    }
+
+    // hijack __mount() report format to help triage
+    auto report = "__mount(source=overlay,target="s + mount_point + ",type=overlay";
+    const auto opt_list = android::base::Split(options, ",");
+    for (const auto& opt : opt_list) {
+        if (android::base::StartsWith(opt, kUpperdirOption)) {
+            report = report + "," + opt;
+            break;
+        }
+    }
+    report = report + ")=";
+
+    auto ret = mount("overlay", mount_point.c_str(), "overlay", MS_RDONLY | MS_NOATIME,
+                     options.c_str());
+    if (ret) {
+        retval = false;
+        PERROR << report << ret;
+    } else {
+        LINFO << report << ret;
+    }
+
+    // Move submounts back.
+    for (const auto& entry : move) {
+        if (!dev_private && !dev_made_private) {
+            dev_made_private = fs_mgr_overlayfs_set_shared_mount("/dev", false);
+        }
+
+        if (!fs_mgr_overlayfs_move_mount(entry.dir, entry.mount_point)) {
+            retval = false;
+        } else if (entry.shared_flag &&
+                   !fs_mgr_overlayfs_set_shared_mount(entry.mount_point, true)) {
+            retval = false;
+        }
+        rmdir(entry.dir.c_str());
+    }
+    if (dev_made_private) {
+        fs_mgr_overlayfs_set_shared_mount("/dev", true);
+    }
+    if (parent_made_private) {
+        fs_mgr_overlayfs_set_shared_mount(mount_point, true);
+    }
+
+    return retval;
+}
+
+// Mount kScratchMountPoint
+static bool MountScratch(const std::string& device_path, bool readonly = false) {
+    if (readonly) {
+        if (!fs_mgr_access(device_path)) {
+            LOG(ERROR) << "Path does not exist: " << device_path;
+            return false;
+        }
+    } else if (!fs_mgr_rw_access(device_path)) {
+        LOG(ERROR) << "Path does not exist or is not readwrite: " << device_path;
+        return false;
+    }
+
+    std::vector<const char*> filesystem_candidates;
+    if (fs_mgr_is_f2fs(device_path)) {
+        filesystem_candidates = {"f2fs", "ext4"};
+    } else if (fs_mgr_is_ext4(device_path)) {
+        filesystem_candidates = {"ext4", "f2fs"};
+    } else {
+        LOG(ERROR) << "Scratch partition is not f2fs or ext4";
+        return false;
+    }
+
+    AutoSetFsCreateCon createcon(kOverlayfsFileContext);
+    if (!createcon.Ok()) {
+        return false;
+    }
+    if (mkdir(kScratchMountPoint, 0755) && (errno != EEXIST)) {
+        PERROR << "create " << kScratchMountPoint;
+        return false;
+    }
+
+    FstabEntry entry;
+    entry.blk_device = device_path;
+    entry.mount_point = kScratchMountPoint;
+    entry.flags = MS_NOATIME | MS_RDONLY;
+    if (!readonly) {
+        entry.flags &= ~MS_RDONLY;
+        entry.flags |= MS_SYNCHRONOUS;
+        entry.fs_options = "nodiscard";
+        fs_mgr_set_blk_ro(device_path, false);
+    }
+    // check_fs requires apex runtime library
+    if (fs_mgr_overlayfs_already_mounted("/data", false)) {
+        entry.fs_mgr_flags.check = true;
+    }
+    bool mounted = false;
+    for (auto fs_type : filesystem_candidates) {
+        entry.fs_type = fs_type;
+        if (fs_mgr_do_mount_one(entry) == 0) {
+            mounted = true;
+            break;
+        }
+    }
+    if (!createcon.Restore()) {
+        return false;
+    }
+    if (!mounted) {
+        rmdir(kScratchMountPoint);
+        return false;
+    }
+    return true;
+}
+
+const std::string kMkF2fs("/system/bin/make_f2fs");
+const std::string kMkExt4("/system/bin/mke2fs");
+
+// Note: The scratch partition of DSU is managed by gsid, and should be initialized during
+// first-stage-mount. Just check if the DM device for DSU scratch partition is created or not.
+static std::string GetDsuScratchDevice() {
+    auto& dm = DeviceMapper::Instance();
+    std::string device;
+    if (dm.GetState(android::gsi::kDsuScratch) != DmDeviceState::INVALID &&
+        dm.GetDmDevicePathByName(android::gsi::kDsuScratch, &device)) {
+        return device;
+    }
+    return "";
+}
+
+// This returns the scratch device that was detected during early boot (first-
+// stage init). If the device was created later, for example during setup for
+// the adb remount command, it can return an empty string since it does not
+// query ImageManager. (Note that ImageManager in first-stage init will always
+// use device-mapper, since /data is not available to use loop devices.)
+static std::string GetBootScratchDevice() {
+    // Note: fs_mgr_is_dsu_running() always returns false in recovery or fastbootd.
+    if (fs_mgr_is_dsu_running()) {
+        return GetDsuScratchDevice();
+    }
+
+    auto& dm = DeviceMapper::Instance();
+
+    // If there is a scratch partition allocated in /data or on super, we
+    // automatically prioritize that over super_other or system_other.
+    // Some devices, for example, have a write-protected eMMC and the
+    // super partition cannot be used even if it exists.
+    std::string device;
+    auto partition_name = android::base::Basename(kScratchMountPoint);
+    if (dm.GetState(partition_name) != DmDeviceState::INVALID &&
+        dm.GetDmDevicePathByName(partition_name, &device)) {
+        return device;
+    }
+
+    return "";
+}
+
+// NOTE: OverlayfsSetupAllowed() must be "stricter" than OverlayfsTeardownAllowed().
+// Setup is allowed only if teardown is also allowed.
+bool OverlayfsSetupAllowed(bool verbose = false) {
+    if (!kAllowOverlayfs) {
+        if (verbose) {
+            LOG(ERROR) << "Overlayfs remounts can only be used in debuggable builds";
+        }
+        return false;
+    }
+    // Check mandatory kernel patches.
+    if (fs_mgr_overlayfs_valid() == OverlayfsValidResult::kNotSupported) {
+        if (verbose) {
+            LOG(ERROR) << "Kernel does not support overlayfs";
+        }
+        return false;
+    }
+    // in recovery or fastbootd, not allowed!
+    if (fs_mgr_in_recovery()) {
+        if (verbose) {
+            LOG(ERROR) << "Unsupported overlayfs setup from recovery";
+        }
+        return false;
+    }
+    return true;
+}
+
+bool fs_mgr_wants_overlayfs(FstabEntry* entry) {
+    // Don't check entries that are managed by vold.
+    if (entry->fs_mgr_flags.vold_managed || entry->fs_mgr_flags.recovery_only) return false;
+
+    // *_other doesn't want overlayfs.
+    if (entry->fs_mgr_flags.slot_select_other) return false;
+
+    // Only concerned with readonly partitions.
+    if (!(entry->flags & MS_RDONLY)) return false;
+
+    // If unbindable, do not allow overlayfs as this could expose us to
+    // security issues.  On Android, this could also be used to turn off
+    // the ability to overlay an otherwise acceptable filesystem since
+    // /system and /vendor are never bound(sic) to.
+    if (entry->flags & MS_UNBINDABLE) return false;
+
+    if (!fs_mgr_overlayfs_enabled(entry)) return false;
+
+    return true;
+}
+
+Fstab fs_mgr_overlayfs_candidate_list(const Fstab& fstab) {
+    android::fs_mgr::Fstab mounts;
+    if (!android::fs_mgr::ReadFstabFromFile("/proc/mounts", &mounts)) {
+        PLOG(ERROR) << "Failed to read /proc/mounts";
+        return {};
+    }
+
+    Fstab candidates;
+    for (const auto& entry : fstab) {
+        // Filter out partitions whose type doesn't match what's mounted.
+        // This avoids spammy behavior on devices which can mount different
+        // filesystems for each partition.
+        auto proc_mount_point = (entry.mount_point == "/system") ? "/" : entry.mount_point;
+        auto mounted = GetEntryForMountPoint(&mounts, proc_mount_point);
+        if (!mounted || mounted->fs_type != entry.fs_type) {
+            continue;
+        }
+
+        FstabEntry new_entry = entry;
+        if (!fs_mgr_overlayfs_already_mounted(entry.mount_point) &&
+            !fs_mgr_wants_overlayfs(&new_entry)) {
+            continue;
+        }
+        auto new_mount_point = fs_mgr_mount_point(entry.mount_point);
+        auto duplicate_or_more_specific = false;
+        for (auto it = candidates.begin(); it != candidates.end();) {
+            auto it_mount_point = fs_mgr_mount_point(it->mount_point);
+            if ((it_mount_point == new_mount_point) ||
+                (android::base::StartsWith(new_mount_point, it_mount_point + "/"))) {
+                duplicate_or_more_specific = true;
+                break;
+            }
+            if (android::base::StartsWith(it_mount_point, new_mount_point + "/")) {
+                it = candidates.erase(it);
+            } else {
+                ++it;
+            }
+        }
+        if (!duplicate_or_more_specific) candidates.emplace_back(std::move(new_entry));
+    }
+    return candidates;
+}
+
+static void TryMountScratch() {
+    // Note we get the boot scratch device here, which means if scratch was
+    // just created through ImageManager, this could fail. In practice this
+    // should not happen because "remount" detects this scenario (by checking
+    // if verity is still disabled, i.e. no reboot occurred), and skips calling
+    // fs_mgr_overlayfs_mount_all().
+    auto scratch_device = GetBootScratchDevice();
+    if (!fs_mgr_rw_access(scratch_device)) {
+        return;
+    }
+    if (!WaitForFile(scratch_device, 10s)) {
+        return;
+    }
+    if (!MountScratch(scratch_device, true /* readonly */)) {
+        return;
+    }
+    auto has_overlayfs_dir = fs_mgr_access(std::string(kScratchMountPoint) + kOverlayTopDir);
+    fs_mgr_overlayfs_umount_scratch();
+    if (has_overlayfs_dir) {
+        MountScratch(scratch_device);
+    }
+}
+
+bool fs_mgr_overlayfs_mount_all(Fstab* fstab) {
+    if (!OverlayfsSetupAllowed()) {
+        return false;
+    }
+    auto ret = true;
+    auto scratch_can_be_mounted = true;
+    for (const auto& entry : fs_mgr_overlayfs_candidate_list(*fstab)) {
+        if (fs_mgr_is_verity_enabled(entry)) continue;
+        auto mount_point = fs_mgr_mount_point(entry.mount_point);
+        if (fs_mgr_overlayfs_already_mounted(mount_point)) {
+            continue;
+        }
+        if (scratch_can_be_mounted) {
+            scratch_can_be_mounted = false;
+            TryMountScratch();
+        }
+        ret &= fs_mgr_overlayfs_mount(entry);
+    }
+    return ret;
+}
+
+bool fs_mgr_overlayfs_is_setup() {
+    if (!OverlayfsSetupAllowed()) {
+        return false;
+    }
+    if (fs_mgr_overlayfs_already_mounted(kScratchMountPoint, false)) return true;
+    Fstab fstab;
+    if (!ReadDefaultFstab(&fstab)) {
+        return false;
+    }
+    for (const auto& entry : fs_mgr_overlayfs_candidate_list(fstab)) {
+        if (fs_mgr_is_verity_enabled(entry)) continue;
+        if (fs_mgr_overlayfs_already_mounted(fs_mgr_mount_point(entry.mount_point))) return true;
+    }
+    return false;
+}
+
+bool fs_mgr_overlayfs_already_mounted(const std::string& mount_point, bool overlay_only) {
+    Fstab fstab;
+    if (!ReadFstabFromFile("/proc/mounts", &fstab)) {
+        return false;
+    }
+    const auto lowerdir = kLowerdirOption + mount_point;
+    for (const auto& entry : fstab) {
+        if (overlay_only && "overlay" != entry.fs_type && "overlayfs" != entry.fs_type) continue;
+        if (mount_point != entry.mount_point) continue;
+        if (!overlay_only) return true;
+        const auto options = android::base::Split(entry.fs_options, ",");
+        for (const auto& opt : options) {
+            if (opt == lowerdir) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.h b/fs_mgr/fs_mgr_overlayfs_mount.h
new file mode 100644
index 000000000000..ae3ea84edab6
--- /dev/null
+++ b/fs_mgr/fs_mgr_overlayfs_mount.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+#include <fstab/fstab.h>
+
+bool fs_mgr_overlayfs_already_mounted(const std::string& mount_point, bool overlay_only = true);
+bool fs_mgr_wants_overlayfs(android::fs_mgr::FstabEntry* entry);
+android::fs_mgr::Fstab fs_mgr_overlayfs_candidate_list(const android::fs_mgr::Fstab& fstab);
+
+#if ALLOW_ADBD_DISABLE_VERITY
+constexpr bool kAllowOverlayfs = true;
+#else
+constexpr bool kAllowOverlayfs = false;
+#endif
+
+class AutoSetFsCreateCon final {
+  public:
+    AutoSetFsCreateCon() {}
+    AutoSetFsCreateCon(const std::string& context) { Set(context); }
+    ~AutoSetFsCreateCon() { Restore(); }
+
+    bool Ok() const { return ok_; }
+    bool Set(const std::string& context);
+    bool Restore();
+
+  private:
+    bool ok_ = false;
+    bool restored_ = false;
+};
+
+constexpr auto kScratchMountPoint = "/mnt/scratch";
+constexpr char kOverlayfsFileContext[] = "u:object_r:overlayfs_file:s0";
+
+constexpr auto kUpperName = "upper";
+constexpr auto kWorkName = "work";
+constexpr auto kOverlayTopDir = "/overlay";
+
+bool fs_mgr_is_dsu_running();
+bool fs_mgr_in_recovery();
+bool fs_mgr_access(const std::string& path);
+bool fs_mgr_rw_access(const std::string& path);
+bool fs_mgr_filesystem_has_space(const std::string& mount_point);
+const std::string fs_mgr_mount_point(const std::string& mount_point);
+bool fs_mgr_overlayfs_umount_scratch();
+std::vector<const std::string> OverlayMountPoints();
diff --git a/fs_mgr/fs_mgr_remount.cpp b/fs_mgr/fs_mgr_remount.cpp
index 5a9f391a4ade..4c458283a537 100644
--- a/fs_mgr/fs_mgr_remount.cpp
+++ b/fs_mgr/fs_mgr_remount.cpp
@@ -43,7 +43,8 @@
 #include <libavb_user/libavb_user.h>
 #include <libgsi/libgsid.h>
 
-#include "fs_mgr_priv_overlayfs.h"
+#include "fs_mgr_overlayfs_control.h"
+#include "fs_mgr_overlayfs_mount.h"
 
 using namespace std::literals;
 using android::fs_mgr::Fstab;

From edeae250c9f9f73212529b8717f440dc7b6dea94 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 14 Jul 2023 08:56:46 -0700
Subject: [PATCH 0193/1487] libsnapshot: Move export_include_dirs to correct
 location.

Bug: 291083311
Test: builds
Change-Id: I7a547bb0b2c06f312f83a6b8659a4e30e97c8438
---
 fs_mgr/libsnapshot/Android.bp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 9d1ce7db9b79..8f353818ce08 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -166,7 +166,6 @@ cc_defaults {
     header_libs: [
         "libupdate_engine_headers",
     ],
-    export_include_dirs: ["include"],
 }
 
 cc_library_static {
@@ -184,6 +183,7 @@ cc_library_static {
         "libsnapshot_cow/writer_base.cpp",
         "libsnapshot_cow/writer_v2.cpp",
     ],
+    export_include_dirs: ["include"],
     host_supported: true,
     recovery_available: true,
     ramdisk_available: true,

From a71faae86f3ff23c4400f0b1d0452b2d6d7fbe10 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 14 Jul 2023 08:57:30 -0700
Subject: [PATCH 0194/1487] Allow processes in the "system" group to read
 /metadata/ota.

lpdumpd runs as "system", not "root". Adjust the DAC permissions of
/metadata/ota so it can call SnapshotManager::Dump.

Bug: 291083311
Test: lpdump
Change-Id: I97fd7eb2055cf6d31fd42f1021e2f99edbdb838a
---
 rootdir/init.rc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 4f3959f7cdca..be03489a6d0e 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -604,8 +604,8 @@ on post-fs
     chmod 0700 /metadata/vold
     mkdir /metadata/password_slots 0771 root system
     mkdir /metadata/bootstat 0750 system log
-    mkdir /metadata/ota 0700 root system
-    mkdir /metadata/ota/snapshots 0700 root system
+    mkdir /metadata/ota 0750 root system
+    mkdir /metadata/ota/snapshots 0750 root system
     mkdir /metadata/userspacereboot 0770 root system
     mkdir /metadata/watchdog 0770 root system
 

From 01cd7285ee9c6baa9954cade128e9d334e3084f2 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 17 Feb 2023 01:20:52 -0800
Subject: [PATCH 0195/1487] snapuserd: Split the server into two classes.

This splits server into two classes: one that handles the IPC requests,
and one that managers snapshot handlers. This will allow embedding of
the snapshot handling code, without booting up a server. It'll also make
testing much easier.

The handler code has been further placed behind a virtual interface,
though this is likely unnecessary unless we start testing the server
logic itself (or attempt to unify the S and T+ versions of snapuserd).

Bug: 269361087
Test: ota
Ignore-AOSP-First: cherry-pick from aosp
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:8bb751dc8a1499f24add9e0831ab347feb2c3878)
Merged-In: I3ca3ad9c8c1fb910a1c7bf9f44165e2f44c930c9
Change-Id: I3ca3ad9c8c1fb910a1c7bf9f44165e2f44c930c9
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   1 +
 .../snapuserd/snapuserd_daemon.cpp            |   2 +-
 .../user-space-merge/handler_manager.cpp      | 371 ++++++++++++++++++
 .../user-space-merge/handler_manager.h        | 131 +++++++
 .../user-space-merge/snapuserd_server.cpp     | 338 +---------------
 .../user-space-merge/snapuserd_server.h       |  58 +--
 6 files changed, 526 insertions(+), 375 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index dd11a33daf28..65f3d6d297ed 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -62,6 +62,7 @@ cc_library_static {
         "dm-snapshot-merge/snapuserd_worker.cpp",
         "dm-snapshot-merge/snapuserd_readahead.cpp",
         "snapuserd_buffer.cpp",
+        "user-space-merge/handler_manager.cpp",
         "user-space-merge/snapuserd_core.cpp",
         "user-space-merge/snapuserd_dm_user.cpp",
         "user-space-merge/snapuserd_merge.cpp",
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
index ae20e1fa479e..36dad3343d3e 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
@@ -114,7 +114,7 @@ bool Daemon::StartServerForUserspaceSnapshots(int arg_start, int argc, char** ar
             return false;
         }
         auto handler = user_server_.AddHandler(parts[0], parts[1], parts[2], parts[3]);
-        if (!handler || !user_server_.StartHandler(handler)) {
+        if (!handler || !user_server_.StartHandler(parts[0])) {
             return false;
         }
     }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
new file mode 100644
index 000000000000..c5150c411d02
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -0,0 +1,371 @@
+// Copyright (C) 2023 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 "handler_manager.h"
+
+#include <sys/eventfd.h>
+
+#include <android-base/logging.h>
+
+#include "snapuserd_core.h"
+
+namespace android {
+namespace snapshot {
+
+static constexpr uint8_t kMaxMergeThreads = 2;
+
+void HandlerThread::FreeResources() {
+    // Each worker thread holds a reference to snapuserd.
+    // Clear them so that all the resources
+    // held by snapuserd is released
+    if (snapuserd_) {
+        snapuserd_->FreeResources();
+        snapuserd_ = nullptr;
+    }
+}
+
+SnapshotHandlerManager::SnapshotHandlerManager() {
+    monitor_merge_event_fd_.reset(eventfd(0, EFD_CLOEXEC));
+    if (monitor_merge_event_fd_ == -1) {
+        PLOG(FATAL) << "monitor_merge_event_fd_: failed to create eventfd";
+    }
+}
+
+std::shared_ptr<HandlerThread> SnapshotHandlerManager::AddHandler(
+        const std::string& misc_name, const std::string& cow_device_path,
+        const std::string& backing_device, const std::string& base_path_merge,
+        int num_worker_threads, bool use_iouring, bool perform_verification) {
+    auto snapuserd = std::make_shared<SnapshotHandler>(misc_name, cow_device_path, backing_device,
+                                                       base_path_merge, num_worker_threads,
+                                                       use_iouring, perform_verification);
+    if (!snapuserd->InitCowDevice()) {
+        LOG(ERROR) << "Failed to initialize Snapuserd";
+        return nullptr;
+    }
+
+    if (!snapuserd->InitializeWorkers()) {
+        LOG(ERROR) << "Failed to initialize workers";
+        return nullptr;
+    }
+
+    auto handler = std::make_shared<HandlerThread>(snapuserd);
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+        if (FindHandler(&lock, misc_name) != dm_users_.end()) {
+            LOG(ERROR) << "Handler already exists: " << misc_name;
+            return nullptr;
+        }
+        dm_users_.push_back(handler);
+    }
+    return handler;
+}
+
+bool SnapshotHandlerManager::StartHandler(const std::string& misc_name) {
+    std::lock_guard<std::mutex> lock(lock_);
+    auto iter = FindHandler(&lock, misc_name);
+    if (iter == dm_users_.end()) {
+        LOG(ERROR) << "Could not find handler: " << misc_name;
+        return false;
+    }
+    if (!(*iter)->snapuserd() || (*iter)->snapuserd()->IsAttached()) {
+        LOG(ERROR) << "Tried to re-attach control device: " << misc_name;
+        return false;
+    }
+    if (!StartHandler(*iter)) {
+        return false;
+    }
+    return true;
+}
+
+bool SnapshotHandlerManager::StartHandler(const std::shared_ptr<HandlerThread>& handler) {
+    if (handler->snapuserd()->IsAttached()) {
+        LOG(ERROR) << "Handler already attached";
+        return false;
+    }
+
+    handler->snapuserd()->AttachControlDevice();
+
+    handler->thread() = std::thread(std::bind(&SnapshotHandlerManager::RunThread, this, handler));
+    return true;
+}
+
+bool SnapshotHandlerManager::DeleteHandler(const std::string& misc_name) {
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+        auto iter = FindHandler(&lock, misc_name);
+        if (iter == dm_users_.end()) {
+            // After merge is completed, we swap dm-user table with
+            // the underlying dm-linear base device. Hence, worker
+            // threads would have terminted and was removed from
+            // the list.
+            LOG(DEBUG) << "Could not find handler: " << misc_name;
+            return true;
+        }
+
+        if (!(*iter)->ThreadTerminated()) {
+            (*iter)->snapuserd()->NotifyIOTerminated();
+        }
+    }
+    if (!RemoveAndJoinHandler(misc_name)) {
+        return false;
+    }
+    return true;
+}
+
+void SnapshotHandlerManager::RunThread(std::shared_ptr<HandlerThread> handler) {
+    LOG(INFO) << "Entering thread for handler: " << handler->misc_name();
+
+    if (!handler->snapuserd()->Start()) {
+        LOG(ERROR) << " Failed to launch all worker threads";
+    }
+
+    handler->snapuserd()->CloseFds();
+    bool merge_completed = handler->snapuserd()->CheckMergeCompletionStatus();
+    handler->snapuserd()->UnmapBufferRegion();
+
+    auto misc_name = handler->misc_name();
+    LOG(INFO) << "Handler thread about to exit: " << misc_name;
+
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+        if (merge_completed) {
+            num_partitions_merge_complete_ += 1;
+            active_merge_threads_ -= 1;
+            WakeupMonitorMergeThread();
+        }
+        handler->SetThreadTerminated();
+        auto iter = FindHandler(&lock, handler->misc_name());
+        if (iter == dm_users_.end()) {
+            // RemoveAndJoinHandler() already removed us from the list, and is
+            // now waiting on a join(), so just return. Additionally, release
+            // all the resources held by snapuserd object which are shared
+            // by worker threads. This should be done when the last reference
+            // of "handler" is released; but we will explicitly release here
+            // to make sure snapuserd object is freed as it is the biggest
+            // consumer of memory in the daemon.
+            handler->FreeResources();
+            LOG(INFO) << "Exiting handler thread to allow for join: " << misc_name;
+            return;
+        }
+
+        LOG(INFO) << "Exiting handler thread and freeing resources: " << misc_name;
+
+        if (handler->snapuserd()->IsAttached()) {
+            handler->thread().detach();
+        }
+
+        // Important: free resources within the lock. This ensures that if
+        // WaitForDelete() is called, the handler is either in the list, or
+        // it's not and its resources are guaranteed to be freed.
+        handler->FreeResources();
+        dm_users_.erase(iter);
+    }
+}
+
+bool SnapshotHandlerManager::InitiateMerge(const std::string& misc_name) {
+    std::lock_guard<std::mutex> lock(lock_);
+    auto iter = FindHandler(&lock, misc_name);
+    if (iter == dm_users_.end()) {
+        LOG(ERROR) << "Could not find handler: " << misc_name;
+        return false;
+    }
+
+    return StartMerge(&lock, *iter);
+}
+
+bool SnapshotHandlerManager::StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
+                                        const std::shared_ptr<HandlerThread>& handler) {
+    CHECK(proof_of_lock);
+
+    if (!handler->snapuserd()->IsAttached()) {
+        LOG(ERROR) << "Handler not attached to dm-user - Merge thread cannot be started";
+        return false;
+    }
+
+    handler->snapuserd()->MonitorMerge();
+
+    if (!is_merge_monitor_started_) {
+        std::thread(&SnapshotHandlerManager::MonitorMerge, this).detach();
+        is_merge_monitor_started_ = true;
+    }
+
+    merge_handlers_.push(handler);
+    WakeupMonitorMergeThread();
+    return true;
+}
+
+void SnapshotHandlerManager::WakeupMonitorMergeThread() {
+    uint64_t notify = 1;
+    ssize_t rc = TEMP_FAILURE_RETRY(write(monitor_merge_event_fd_.get(), &notify, sizeof(notify)));
+    if (rc < 0) {
+        PLOG(FATAL) << "failed to notify monitor merge thread";
+    }
+}
+
+void SnapshotHandlerManager::MonitorMerge() {
+    while (!stop_monitor_merge_thread_) {
+        uint64_t testVal;
+        ssize_t ret =
+                TEMP_FAILURE_RETRY(read(monitor_merge_event_fd_.get(), &testVal, sizeof(testVal)));
+        if (ret == -1) {
+            PLOG(FATAL) << "Failed to read from eventfd";
+        } else if (ret == 0) {
+            LOG(FATAL) << "Hit EOF on eventfd";
+        }
+
+        LOG(INFO) << "MonitorMerge: active-merge-threads: " << active_merge_threads_;
+        {
+            std::lock_guard<std::mutex> lock(lock_);
+            while (active_merge_threads_ < kMaxMergeThreads && merge_handlers_.size() > 0) {
+                auto handler = merge_handlers_.front();
+                merge_handlers_.pop();
+
+                if (!handler->snapuserd()) {
+                    LOG(INFO) << "MonitorMerge: skipping deleted handler: " << handler->misc_name();
+                    continue;
+                }
+
+                LOG(INFO) << "Starting merge for partition: "
+                          << handler->snapuserd()->GetMiscName();
+                handler->snapuserd()->InitiateMerge();
+                active_merge_threads_ += 1;
+            }
+        }
+    }
+
+    LOG(INFO) << "Exiting MonitorMerge: size: " << merge_handlers_.size();
+}
+
+std::string SnapshotHandlerManager::GetMergeStatus(const std::string& misc_name) {
+    std::lock_guard<std::mutex> lock(lock_);
+    auto iter = FindHandler(&lock, misc_name);
+    if (iter == dm_users_.end()) {
+        LOG(ERROR) << "Could not find handler: " << misc_name;
+        return {};
+    }
+
+    return (*iter)->snapuserd()->GetMergeStatus();
+}
+
+double SnapshotHandlerManager::GetMergePercentage() {
+    std::lock_guard<std::mutex> lock(lock_);
+
+    double percentage = 0.0;
+    int n = 0;
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        auto& th = (*iter)->thread();
+        if (th.joinable()) {
+            // Merge percentage by individual partitions wherein merge is still
+            // in-progress
+            percentage += (*iter)->snapuserd()->GetMergePercentage();
+            n += 1;
+        }
+    }
+
+    // Calculate final merge including those partitions where merge was already
+    // completed - num_partitions_merge_complete_ will track them when each
+    // thread exists in RunThread.
+    int total_partitions = n + num_partitions_merge_complete_;
+
+    if (total_partitions) {
+        percentage = ((num_partitions_merge_complete_ * 100.0) + percentage) / total_partitions;
+    }
+
+    LOG(DEBUG) << "Merge %: " << percentage
+               << " num_partitions_merge_complete_: " << num_partitions_merge_complete_
+               << " total_partitions: " << total_partitions << " n: " << n;
+    return percentage;
+}
+
+bool SnapshotHandlerManager::GetVerificationStatus() {
+    std::lock_guard<std::mutex> lock(lock_);
+
+    bool status = true;
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        auto& th = (*iter)->thread();
+        if (th.joinable() && status) {
+            status = (*iter)->snapuserd()->CheckPartitionVerification() && status;
+        } else {
+            // return immediately if there is a failure
+            return false;
+        }
+    }
+
+    return status;
+}
+
+bool SnapshotHandlerManager::RemoveAndJoinHandler(const std::string& misc_name) {
+    std::shared_ptr<HandlerThread> handler;
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+
+        auto iter = FindHandler(&lock, misc_name);
+        if (iter == dm_users_.end()) {
+            // Client already deleted.
+            return true;
+        }
+        handler = std::move(*iter);
+        dm_users_.erase(iter);
+    }
+
+    auto& th = handler->thread();
+    if (th.joinable()) {
+        th.join();
+    }
+    return true;
+}
+
+void SnapshotHandlerManager::TerminateMergeThreads() {
+    std::lock_guard<std::mutex> guard(lock_);
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        if (!(*iter)->ThreadTerminated()) {
+            (*iter)->snapuserd()->NotifyIOTerminated();
+        }
+    }
+}
+
+void SnapshotHandlerManager::JoinAllThreads() {
+    // Acquire the thread list within the lock.
+    std::vector<std::shared_ptr<HandlerThread>> dm_users;
+    {
+        std::lock_guard<std::mutex> guard(lock_);
+        dm_users = std::move(dm_users_);
+    }
+
+    for (auto& client : dm_users) {
+        auto& th = client->thread();
+
+        if (th.joinable()) th.join();
+    }
+
+    stop_monitor_merge_thread_ = true;
+    WakeupMonitorMergeThread();
+}
+
+auto SnapshotHandlerManager::FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
+                                         const std::string& misc_name) -> HandlerList::iterator {
+    CHECK(proof_of_lock);
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        if ((*iter)->misc_name() == misc_name) {
+            return iter;
+        }
+    }
+    return dm_users_.end();
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
new file mode 100644
index 000000000000..b7ddac19f28a
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
@@ -0,0 +1,131 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <memory>
+#include <queue>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include <android-base/unique_fd.h>
+
+namespace android {
+namespace snapshot {
+
+class SnapshotHandler;
+
+class HandlerThread {
+  public:
+    explicit HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd);
+
+    void FreeResources();
+    const std::shared_ptr<SnapshotHandler>& snapuserd() const { return snapuserd_; }
+    std::thread& thread() { return thread_; }
+
+    const std::string& misc_name() const { return misc_name_; }
+    bool ThreadTerminated() { return thread_terminated_; }
+    void SetThreadTerminated() { thread_terminated_ = true; }
+
+  private:
+    std::thread thread_;
+    std::shared_ptr<SnapshotHandler> snapuserd_;
+    std::string misc_name_;
+    bool thread_terminated_ = false;
+};
+
+class ISnapshotHandlerManager {
+  public:
+    virtual ~ISnapshotHandlerManager() {}
+
+    // Add a new snapshot handler but do not start serving requests yet.
+    virtual std::shared_ptr<HandlerThread> AddHandler(const std::string& misc_name,
+                                                      const std::string& cow_device_path,
+                                                      const std::string& backing_device,
+                                                      const std::string& base_path_merge,
+                                                      int num_worker_threads, bool use_iouring,
+                                                      bool perform_verification) = 0;
+
+    // Start serving requests on a snapshot handler.
+    virtual bool StartHandler(const std::string& misc_name) = 0;
+
+    // Stop serving requests on a snapshot handler and remove it.
+    virtual bool DeleteHandler(const std::string& misc_name) = 0;
+
+    // Begin merging blocks on the given snapshot handler.
+    virtual bool InitiateMerge(const std::string& misc_name) = 0;
+
+    // Return a string containing a status code indicating the merge status
+    // on the handler. Returns empty on error.
+    virtual std::string GetMergeStatus(const std::string& misc_name) = 0;
+
+    // Wait until all handlers have terminated.
+    virtual void JoinAllThreads() = 0;
+
+    // Stop any in-progress merge threads.
+    virtual void TerminateMergeThreads() = 0;
+
+    // Returns the merge progress across all merging snapshot handlers.
+    virtual double GetMergePercentage() = 0;
+
+    // Returns whether all snapshots have verified.
+    virtual bool GetVerificationStatus() = 0;
+};
+
+class SnapshotHandlerManager final : public ISnapshotHandlerManager {
+  public:
+    SnapshotHandlerManager();
+    std::shared_ptr<HandlerThread> AddHandler(const std::string& misc_name,
+                                              const std::string& cow_device_path,
+                                              const std::string& backing_device,
+                                              const std::string& base_path_merge,
+                                              int num_worker_threads, bool use_iouring,
+                                              bool perform_verification) override;
+    bool StartHandler(const std::string& misc_name) override;
+    bool DeleteHandler(const std::string& misc_name) override;
+    bool InitiateMerge(const std::string& misc_name) override;
+    std::string GetMergeStatus(const std::string& misc_name) override;
+    void JoinAllThreads() override;
+    void TerminateMergeThreads() override;
+    double GetMergePercentage() override;
+    bool GetVerificationStatus() override;
+
+  private:
+    bool StartHandler(const std::shared_ptr<HandlerThread>& handler);
+    void RunThread(std::shared_ptr<HandlerThread> handler);
+    bool StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
+                    const std::shared_ptr<HandlerThread>& handler);
+    void MonitorMerge();
+    void WakeupMonitorMergeThread();
+    bool RemoveAndJoinHandler(const std::string& misc_name);
+
+    // Find a HandlerThread within a lock.
+    using HandlerList = std::vector<std::shared_ptr<HandlerThread>>;
+    HandlerList::iterator FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
+                                      const std::string& misc_name);
+
+    std::mutex lock_;
+    HandlerList dm_users_;
+
+    bool is_merge_monitor_started_ = false;
+    bool stop_monitor_merge_thread_ = false;
+    int active_merge_threads_ = 0;
+    int num_partitions_merge_complete_ = 0;
+    std::queue<std::shared_ptr<HandlerThread>> merge_handlers_;
+    android::base::unique_fd monitor_merge_event_fd_;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index b7ce2109adfe..cc8115f5f800 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -62,11 +62,8 @@ DaemonOps UserSnapshotServer::Resolveop(std::string& input) {
 }
 
 UserSnapshotServer::UserSnapshotServer() {
-    monitor_merge_event_fd_.reset(eventfd(0, EFD_CLOEXEC));
-    if (monitor_merge_event_fd_ == -1) {
-        PLOG(FATAL) << "monitor_merge_event_fd_: failed to create eventfd";
-    }
     terminating_ = false;
+    handlers_ = std::make_unique<SnapshotHandlerManager>();
 }
 
 UserSnapshotServer::~UserSnapshotServer() {
@@ -99,7 +96,7 @@ void UserSnapshotServer::Parsemsg(std::string const& msg, const char delim,
 
 void UserSnapshotServer::ShutdownThreads() {
     terminating_ = true;
-    JoinAllThreads();
+    handlers_->JoinAllThreads();
 }
 
 HandlerThread::HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd)
@@ -166,17 +163,7 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 return Sendmsg(fd, "fail");
             }
 
-            std::lock_guard<std::mutex> lock(lock_);
-            auto iter = FindHandler(&lock, out[1]);
-            if (iter == dm_users_.end()) {
-                LOG(ERROR) << "Could not find handler: " << out[1];
-                return Sendmsg(fd, "fail");
-            }
-            if (!(*iter)->snapuserd() || (*iter)->snapuserd()->IsAttached()) {
-                LOG(ERROR) << "Tried to re-attach control device: " << out[1];
-                return Sendmsg(fd, "fail");
-            }
-            if (!StartHandler(*iter)) {
+            if (!handlers_->StartHandler(out[1])) {
                 return Sendmsg(fd, "fail");
             }
             return Sendmsg(fd, "success");
@@ -209,30 +196,13 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
                 return Sendmsg(fd, "fail");
             }
-            {
-                std::lock_guard<std::mutex> lock(lock_);
-                auto iter = FindHandler(&lock, out[1]);
-                if (iter == dm_users_.end()) {
-                    // After merge is completed, we swap dm-user table with
-                    // the underlying dm-linear base device. Hence, worker
-                    // threads would have terminted and was removed from
-                    // the list.
-                    LOG(DEBUG) << "Could not find handler: " << out[1];
-                    return Sendmsg(fd, "success");
-                }
-
-                if (!(*iter)->ThreadTerminated()) {
-                    (*iter)->snapuserd()->NotifyIOTerminated();
-                }
-            }
-            if (!RemoveAndJoinHandler(out[1])) {
+            if (!handlers_->DeleteHandler(out[1])) {
                 return Sendmsg(fd, "fail");
             }
             return Sendmsg(fd, "success");
         }
         case DaemonOps::DETACH: {
-            std::lock_guard<std::mutex> lock(lock_);
-            TerminateMergeThreads(&lock);
+            handlers_->TerminateMergeThreads();
             terminating_ = true;
             return true;
         }
@@ -252,24 +222,15 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 return Sendmsg(fd, "fail");
             }
             if (out[0] == "initiate_merge") {
-                std::lock_guard<std::mutex> lock(lock_);
-                auto iter = FindHandler(&lock, out[1]);
-                if (iter == dm_users_.end()) {
-                    LOG(ERROR) << "Could not find handler: " << out[1];
+                if (!handlers_->InitiateMerge(out[1])) {
                     return Sendmsg(fd, "fail");
                 }
-
-                if (!StartMerge(&lock, *iter)) {
-                    return Sendmsg(fd, "fail");
-                }
-
                 return Sendmsg(fd, "success");
             }
             return Sendmsg(fd, "fail");
         }
         case DaemonOps::PERCENTAGE: {
-            std::lock_guard<std::mutex> lock(lock_);
-            double percentage = GetMergePercentage(&lock);
+            double percentage = handlers_->GetMergePercentage();
 
             return Sendmsg(fd, std::to_string(percentage));
         }
@@ -280,24 +241,16 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
                 return Sendmsg(fd, "snapshot-merge-failed");
             }
-            {
-                std::lock_guard<std::mutex> lock(lock_);
-                auto iter = FindHandler(&lock, out[1]);
-                if (iter == dm_users_.end()) {
-                    LOG(ERROR) << "Could not find handler: " << out[1];
-                    return Sendmsg(fd, "snapshot-merge-failed");
-                }
-
-                std::string merge_status = GetMergeStatus(*iter);
-                return Sendmsg(fd, merge_status);
+            auto status = handlers_->GetMergeStatus(out[1]);
+            if (status.empty()) {
+                return Sendmsg(fd, "snapshot-merge-failed");
             }
+            return Sendmsg(fd, status);
         }
         case DaemonOps::UPDATE_VERIFY: {
-            std::lock_guard<std::mutex> lock(lock_);
-            if (!UpdateVerification(&lock)) {
+            if (!handlers_->GetVerificationStatus()) {
                 return Sendmsg(fd, "fail");
             }
-
             return Sendmsg(fd, "success");
         }
         default: {
@@ -308,56 +261,6 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
     }
 }
 
-void UserSnapshotServer::RunThread(std::shared_ptr<HandlerThread> handler) {
-    LOG(INFO) << "Entering thread for handler: " << handler->misc_name();
-
-    if (!handler->snapuserd()->Start()) {
-        LOG(ERROR) << " Failed to launch all worker threads";
-    }
-
-    handler->snapuserd()->CloseFds();
-    bool merge_completed = handler->snapuserd()->CheckMergeCompletionStatus();
-    handler->snapuserd()->UnmapBufferRegion();
-
-    auto misc_name = handler->misc_name();
-    LOG(INFO) << "Handler thread about to exit: " << misc_name;
-
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        if (merge_completed) {
-            num_partitions_merge_complete_ += 1;
-            active_merge_threads_ -= 1;
-            WakeupMonitorMergeThread();
-        }
-        handler->SetThreadTerminated();
-        auto iter = FindHandler(&lock, handler->misc_name());
-        if (iter == dm_users_.end()) {
-            // RemoveAndJoinHandler() already removed us from the list, and is
-            // now waiting on a join(), so just return. Additionally, release
-            // all the resources held by snapuserd object which are shared
-            // by worker threads. This should be done when the last reference
-            // of "handler" is released; but we will explicitly release here
-            // to make sure snapuserd object is freed as it is the biggest
-            // consumer of memory in the daemon.
-            handler->FreeResources();
-            LOG(INFO) << "Exiting handler thread to allow for join: " << misc_name;
-            return;
-        }
-
-        LOG(INFO) << "Exiting handler thread and freeing resources: " << misc_name;
-
-        if (handler->snapuserd()->IsAttached()) {
-            handler->thread().detach();
-        }
-
-        // Important: free resources within the lock. This ensures that if
-        // WaitForDelete() is called, the handler is either in the list, or
-        // it's not and its resources are guaranteed to be freed.
-        handler->FreeResources();
-        dm_users_.erase(iter);
-    }
-}
-
 bool UserSnapshotServer::Start(const std::string& socketname) {
     bool start_listening = true;
 
@@ -423,28 +326,10 @@ bool UserSnapshotServer::Run() {
         }
     }
 
-    JoinAllThreads();
+    handlers_->JoinAllThreads();
     return true;
 }
 
-void UserSnapshotServer::JoinAllThreads() {
-    // Acquire the thread list within the lock.
-    std::vector<std::shared_ptr<HandlerThread>> dm_users;
-    {
-        std::lock_guard<std::mutex> guard(lock_);
-        dm_users = std::move(dm_users_);
-    }
-
-    for (auto& client : dm_users) {
-        auto& th = client->thread();
-
-        if (th.joinable()) th.join();
-    }
-
-    stop_monitor_merge_thread_ = true;
-    WakeupMonitorMergeThread();
-}
-
 void UserSnapshotServer::AddWatchedFd(android::base::borrowed_fd fd, int events) {
     struct pollfd p = {};
     p.fd = fd.get();
@@ -506,185 +391,13 @@ std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string&
         perform_verification = false;
     }
 
-    auto snapuserd = std::make_shared<SnapshotHandler>(misc_name, cow_device_path, backing_device,
-                                                       base_path_merge, num_worker_threads,
-                                                       io_uring_enabled_, perform_verification);
-    if (!snapuserd->InitCowDevice()) {
-        LOG(ERROR) << "Failed to initialize Snapuserd";
-        return nullptr;
-    }
-
-    if (!snapuserd->InitializeWorkers()) {
-        LOG(ERROR) << "Failed to initialize workers";
-        return nullptr;
-    }
-
-    auto handler = std::make_shared<HandlerThread>(snapuserd);
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        if (FindHandler(&lock, misc_name) != dm_users_.end()) {
-            LOG(ERROR) << "Handler already exists: " << misc_name;
-            return nullptr;
-        }
-        dm_users_.push_back(handler);
-    }
-    return handler;
-}
-
-bool UserSnapshotServer::StartHandler(const std::shared_ptr<HandlerThread>& handler) {
-    if (handler->snapuserd()->IsAttached()) {
-        LOG(ERROR) << "Handler already attached";
-        return false;
-    }
-
-    handler->snapuserd()->AttachControlDevice();
-
-    handler->thread() = std::thread(std::bind(&UserSnapshotServer::RunThread, this, handler));
-    return true;
-}
-
-bool UserSnapshotServer::StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
-                                    const std::shared_ptr<HandlerThread>& handler) {
-    CHECK(proof_of_lock);
-
-    if (!handler->snapuserd()->IsAttached()) {
-        LOG(ERROR) << "Handler not attached to dm-user - Merge thread cannot be started";
-        return false;
-    }
-
-    handler->snapuserd()->MonitorMerge();
-
-    if (!is_merge_monitor_started_.has_value()) {
-        std::thread(&UserSnapshotServer::MonitorMerge, this).detach();
-        is_merge_monitor_started_ = true;
-    }
-
-    merge_handlers_.push(handler);
-    WakeupMonitorMergeThread();
-    return true;
-}
-
-auto UserSnapshotServer::FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
-                                     const std::string& misc_name) -> HandlerList::iterator {
-    CHECK(proof_of_lock);
-
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        if ((*iter)->misc_name() == misc_name) {
-            return iter;
-        }
-    }
-    return dm_users_.end();
-}
-
-void UserSnapshotServer::TerminateMergeThreads(std::lock_guard<std::mutex>* proof_of_lock) {
-    CHECK(proof_of_lock);
-
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        if (!(*iter)->ThreadTerminated()) {
-            (*iter)->snapuserd()->NotifyIOTerminated();
-        }
-    }
-}
-
-std::string UserSnapshotServer::GetMergeStatus(const std::shared_ptr<HandlerThread>& handler) {
-    return handler->snapuserd()->GetMergeStatus();
-}
-
-double UserSnapshotServer::GetMergePercentage(std::lock_guard<std::mutex>* proof_of_lock) {
-    CHECK(proof_of_lock);
-    double percentage = 0.0;
-    int n = 0;
-
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        auto& th = (*iter)->thread();
-        if (th.joinable()) {
-            // Merge percentage by individual partitions wherein merge is still
-            // in-progress
-            percentage += (*iter)->snapuserd()->GetMergePercentage();
-            n += 1;
-        }
-    }
-
-    // Calculate final merge including those partitions where merge was already
-    // completed - num_partitions_merge_complete_ will track them when each
-    // thread exists in RunThread.
-    int total_partitions = n + num_partitions_merge_complete_;
-
-    if (total_partitions) {
-        percentage = ((num_partitions_merge_complete_ * 100.0) + percentage) / total_partitions;
-    }
-
-    LOG(DEBUG) << "Merge %: " << percentage
-               << " num_partitions_merge_complete_: " << num_partitions_merge_complete_
-               << " total_partitions: " << total_partitions << " n: " << n;
-    return percentage;
-}
-
-bool UserSnapshotServer::RemoveAndJoinHandler(const std::string& misc_name) {
-    std::shared_ptr<HandlerThread> handler;
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-
-        auto iter = FindHandler(&lock, misc_name);
-        if (iter == dm_users_.end()) {
-            // Client already deleted.
-            return true;
-        }
-        handler = std::move(*iter);
-        dm_users_.erase(iter);
-    }
-
-    auto& th = handler->thread();
-    if (th.joinable()) {
-        th.join();
-    }
-    return true;
-}
-
-void UserSnapshotServer::WakeupMonitorMergeThread() {
-    uint64_t notify = 1;
-    ssize_t rc = TEMP_FAILURE_RETRY(write(monitor_merge_event_fd_.get(), &notify, sizeof(notify)));
-    if (rc < 0) {
-        PLOG(FATAL) << "failed to notify monitor merge thread";
-    }
-}
-
-void UserSnapshotServer::MonitorMerge() {
-    while (!stop_monitor_merge_thread_) {
-        uint64_t testVal;
-        ssize_t ret =
-                TEMP_FAILURE_RETRY(read(monitor_merge_event_fd_.get(), &testVal, sizeof(testVal)));
-        if (ret == -1) {
-            PLOG(FATAL) << "Failed to read from eventfd";
-        } else if (ret == 0) {
-            LOG(FATAL) << "Hit EOF on eventfd";
-        }
-
-        LOG(INFO) << "MonitorMerge: active-merge-threads: " << active_merge_threads_;
-        {
-            std::lock_guard<std::mutex> lock(lock_);
-            while (active_merge_threads_ < kMaxMergeThreads && merge_handlers_.size() > 0) {
-                auto handler = merge_handlers_.front();
-                merge_handlers_.pop();
-
-                if (!handler->snapuserd()) {
-                    LOG(INFO) << "MonitorMerge: skipping deleted handler: " << handler->misc_name();
-                    continue;
-                }
-
-                LOG(INFO) << "Starting merge for partition: "
-                          << handler->snapuserd()->GetMiscName();
-                handler->snapuserd()->InitiateMerge();
-                active_merge_threads_ += 1;
-            }
-        }
-    }
-
-    LOG(INFO) << "Exiting MonitorMerge: size: " << merge_handlers_.size();
+    return handlers_->AddHandler(misc_name, cow_device_path, backing_device, base_path_merge,
+                                 num_worker_threads, io_uring_enabled_, perform_verification);
 }
 
 bool UserSnapshotServer::WaitForSocket() {
-    auto scope_guard = android::base::make_scope_guard([this]() -> void { JoinAllThreads(); });
+    auto scope_guard =
+            android::base::make_scope_guard([this]() -> void { handlers_->JoinAllThreads(); });
 
     auto socket_path = ANDROID_SOCKET_DIR "/"s + kSnapuserdSocketProxy;
 
@@ -781,21 +494,8 @@ bool UserSnapshotServer::RunForSocketHandoff() {
     return true;
 }
 
-bool UserSnapshotServer::UpdateVerification(std::lock_guard<std::mutex>* proof_of_lock) {
-    CHECK(proof_of_lock);
-
-    bool status = true;
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        auto& th = (*iter)->thread();
-        if (th.joinable() && status) {
-            status = (*iter)->snapuserd()->CheckPartitionVerification() && status;
-        } else {
-            // return immediately if there is a failure
-            return false;
-        }
-    }
-
-    return status;
+bool UserSnapshotServer::StartHandler(const std::string& misc_name) {
+    return handlers_->StartHandler(misc_name);
 }
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index 12c3903c495c..ae5190391dfa 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -31,6 +31,7 @@
 #include <vector>
 
 #include <android-base/unique_fd.h>
+#include "handler_manager.h"
 #include "snapuserd_core.h"
 
 namespace android {
@@ -54,33 +55,6 @@ enum class DaemonOps {
     INVALID,
 };
 
-class HandlerThread {
-  public:
-    explicit HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd);
-
-    void FreeResources() {
-        // Each worker thread holds a reference to snapuserd.
-        // Clear them so that all the resources
-        // held by snapuserd is released
-        if (snapuserd_) {
-            snapuserd_->FreeResources();
-            snapuserd_ = nullptr;
-        }
-    }
-    const std::shared_ptr<SnapshotHandler>& snapuserd() const { return snapuserd_; }
-    std::thread& thread() { return thread_; }
-
-    const std::string& misc_name() const { return misc_name_; }
-    bool ThreadTerminated() { return thread_terminated_; }
-    void SetThreadTerminated() { thread_terminated_ = true; }
-
-  private:
-    std::thread thread_;
-    std::shared_ptr<SnapshotHandler> snapuserd_;
-    std::string misc_name_;
-    bool thread_terminated_ = false;
-};
-
 class UserSnapshotServer {
   private:
     android::base::unique_fd sockfd_;
@@ -88,21 +62,12 @@ class UserSnapshotServer {
     volatile bool received_socket_signal_ = false;
     std::vector<struct pollfd> watched_fds_;
     bool is_socket_present_ = false;
-    int num_partitions_merge_complete_ = 0;
-    int active_merge_threads_ = 0;
-    bool stop_monitor_merge_thread_ = false;
     bool is_server_running_ = false;
     bool io_uring_enabled_ = false;
-    std::optional<bool> is_merge_monitor_started_;
-
-    android::base::unique_fd monitor_merge_event_fd_;
+    std::unique_ptr<ISnapshotHandlerManager> handlers_;
 
     std::mutex lock_;
 
-    using HandlerList = std::vector<std::shared_ptr<HandlerThread>>;
-    HandlerList dm_users_;
-    std::queue<std::shared_ptr<HandlerThread>> merge_handlers_;
-
     void AddWatchedFd(android::base::borrowed_fd fd, int events);
     void AcceptClient();
     bool HandleClient(android::base::borrowed_fd fd, int revents);
@@ -111,28 +76,15 @@ class UserSnapshotServer {
     bool Receivemsg(android::base::borrowed_fd fd, const std::string& str);
 
     void ShutdownThreads();
-    bool RemoveAndJoinHandler(const std::string& control_device);
     DaemonOps Resolveop(std::string& input);
     std::string GetDaemonStatus();
     void Parsemsg(std::string const& msg, const char delim, std::vector<std::string>& out);
 
     bool IsTerminating() { return terminating_; }
 
-    void RunThread(std::shared_ptr<HandlerThread> handler);
-    void MonitorMerge();
-
     void JoinAllThreads();
     bool StartWithSocket(bool start_listening);
 
-    // Find a HandlerThread within a lock.
-    HandlerList::iterator FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
-                                      const std::string& misc_name);
-
-    double GetMergePercentage(std::lock_guard<std::mutex>* proof_of_lock);
-    void TerminateMergeThreads(std::lock_guard<std::mutex>* proof_of_lock);
-
-    bool UpdateVerification(std::lock_guard<std::mutex>* proof_of_lock);
-
   public:
     UserSnapshotServer();
     ~UserSnapshotServer();
@@ -147,12 +99,8 @@ class UserSnapshotServer {
                                               const std::string& cow_device_path,
                                               const std::string& backing_device,
                                               const std::string& base_path_merge);
-    bool StartHandler(const std::shared_ptr<HandlerThread>& handler);
-    bool StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
-                    const std::shared_ptr<HandlerThread>& handler);
-    std::string GetMergeStatus(const std::shared_ptr<HandlerThread>& handler);
+    bool StartHandler(const std::string& misc_name);
 
-    void WakeupMonitorMergeThread();
     void SetTerminating() { terminating_ = true; }
     void ReceivedSocketSignal() { received_socket_signal_ = true; }
     void SetServerRunning() { is_server_running_ = true; }

From 395edf8460ca6c6079ea4f73136c902c0de6fc71 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 17 Feb 2023 01:20:52 -0800
Subject: [PATCH 0196/1487] snapuserd: Split the server into two classes.

This splits server into two classes: one that handles the IPC requests,
and one that managers snapshot handlers. This will allow embedding of
the snapshot handling code, without booting up a server. It'll also make
testing much easier.

The handler code has been further placed behind a virtual interface,
though this is likely unnecessary unless we start testing the server
logic itself (or attempt to unify the S and T+ versions of snapuserd).

Bug: 269361087
Test: ota
Ignore-AOSP-First: cherry-pick from aosp
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:8bb751dc8a1499f24add9e0831ab347feb2c3878)
Merged-In: I3ca3ad9c8c1fb910a1c7bf9f44165e2f44c930c9
Change-Id: I3ca3ad9c8c1fb910a1c7bf9f44165e2f44c930c9
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   1 +
 .../snapuserd/snapuserd_daemon.cpp            |   2 +-
 .../user-space-merge/handler_manager.cpp      | 371 ++++++++++++++++++
 .../user-space-merge/handler_manager.h        | 131 +++++++
 .../user-space-merge/snapuserd_server.cpp     | 338 +---------------
 .../user-space-merge/snapuserd_server.h       |  58 +--
 6 files changed, 526 insertions(+), 375 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index dd11a33daf28..65f3d6d297ed 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -62,6 +62,7 @@ cc_library_static {
         "dm-snapshot-merge/snapuserd_worker.cpp",
         "dm-snapshot-merge/snapuserd_readahead.cpp",
         "snapuserd_buffer.cpp",
+        "user-space-merge/handler_manager.cpp",
         "user-space-merge/snapuserd_core.cpp",
         "user-space-merge/snapuserd_dm_user.cpp",
         "user-space-merge/snapuserd_merge.cpp",
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
index ae20e1fa479e..36dad3343d3e 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
@@ -114,7 +114,7 @@ bool Daemon::StartServerForUserspaceSnapshots(int arg_start, int argc, char** ar
             return false;
         }
         auto handler = user_server_.AddHandler(parts[0], parts[1], parts[2], parts[3]);
-        if (!handler || !user_server_.StartHandler(handler)) {
+        if (!handler || !user_server_.StartHandler(parts[0])) {
             return false;
         }
     }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
new file mode 100644
index 000000000000..c5150c411d02
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -0,0 +1,371 @@
+// Copyright (C) 2023 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 "handler_manager.h"
+
+#include <sys/eventfd.h>
+
+#include <android-base/logging.h>
+
+#include "snapuserd_core.h"
+
+namespace android {
+namespace snapshot {
+
+static constexpr uint8_t kMaxMergeThreads = 2;
+
+void HandlerThread::FreeResources() {
+    // Each worker thread holds a reference to snapuserd.
+    // Clear them so that all the resources
+    // held by snapuserd is released
+    if (snapuserd_) {
+        snapuserd_->FreeResources();
+        snapuserd_ = nullptr;
+    }
+}
+
+SnapshotHandlerManager::SnapshotHandlerManager() {
+    monitor_merge_event_fd_.reset(eventfd(0, EFD_CLOEXEC));
+    if (monitor_merge_event_fd_ == -1) {
+        PLOG(FATAL) << "monitor_merge_event_fd_: failed to create eventfd";
+    }
+}
+
+std::shared_ptr<HandlerThread> SnapshotHandlerManager::AddHandler(
+        const std::string& misc_name, const std::string& cow_device_path,
+        const std::string& backing_device, const std::string& base_path_merge,
+        int num_worker_threads, bool use_iouring, bool perform_verification) {
+    auto snapuserd = std::make_shared<SnapshotHandler>(misc_name, cow_device_path, backing_device,
+                                                       base_path_merge, num_worker_threads,
+                                                       use_iouring, perform_verification);
+    if (!snapuserd->InitCowDevice()) {
+        LOG(ERROR) << "Failed to initialize Snapuserd";
+        return nullptr;
+    }
+
+    if (!snapuserd->InitializeWorkers()) {
+        LOG(ERROR) << "Failed to initialize workers";
+        return nullptr;
+    }
+
+    auto handler = std::make_shared<HandlerThread>(snapuserd);
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+        if (FindHandler(&lock, misc_name) != dm_users_.end()) {
+            LOG(ERROR) << "Handler already exists: " << misc_name;
+            return nullptr;
+        }
+        dm_users_.push_back(handler);
+    }
+    return handler;
+}
+
+bool SnapshotHandlerManager::StartHandler(const std::string& misc_name) {
+    std::lock_guard<std::mutex> lock(lock_);
+    auto iter = FindHandler(&lock, misc_name);
+    if (iter == dm_users_.end()) {
+        LOG(ERROR) << "Could not find handler: " << misc_name;
+        return false;
+    }
+    if (!(*iter)->snapuserd() || (*iter)->snapuserd()->IsAttached()) {
+        LOG(ERROR) << "Tried to re-attach control device: " << misc_name;
+        return false;
+    }
+    if (!StartHandler(*iter)) {
+        return false;
+    }
+    return true;
+}
+
+bool SnapshotHandlerManager::StartHandler(const std::shared_ptr<HandlerThread>& handler) {
+    if (handler->snapuserd()->IsAttached()) {
+        LOG(ERROR) << "Handler already attached";
+        return false;
+    }
+
+    handler->snapuserd()->AttachControlDevice();
+
+    handler->thread() = std::thread(std::bind(&SnapshotHandlerManager::RunThread, this, handler));
+    return true;
+}
+
+bool SnapshotHandlerManager::DeleteHandler(const std::string& misc_name) {
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+        auto iter = FindHandler(&lock, misc_name);
+        if (iter == dm_users_.end()) {
+            // After merge is completed, we swap dm-user table with
+            // the underlying dm-linear base device. Hence, worker
+            // threads would have terminted and was removed from
+            // the list.
+            LOG(DEBUG) << "Could not find handler: " << misc_name;
+            return true;
+        }
+
+        if (!(*iter)->ThreadTerminated()) {
+            (*iter)->snapuserd()->NotifyIOTerminated();
+        }
+    }
+    if (!RemoveAndJoinHandler(misc_name)) {
+        return false;
+    }
+    return true;
+}
+
+void SnapshotHandlerManager::RunThread(std::shared_ptr<HandlerThread> handler) {
+    LOG(INFO) << "Entering thread for handler: " << handler->misc_name();
+
+    if (!handler->snapuserd()->Start()) {
+        LOG(ERROR) << " Failed to launch all worker threads";
+    }
+
+    handler->snapuserd()->CloseFds();
+    bool merge_completed = handler->snapuserd()->CheckMergeCompletionStatus();
+    handler->snapuserd()->UnmapBufferRegion();
+
+    auto misc_name = handler->misc_name();
+    LOG(INFO) << "Handler thread about to exit: " << misc_name;
+
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+        if (merge_completed) {
+            num_partitions_merge_complete_ += 1;
+            active_merge_threads_ -= 1;
+            WakeupMonitorMergeThread();
+        }
+        handler->SetThreadTerminated();
+        auto iter = FindHandler(&lock, handler->misc_name());
+        if (iter == dm_users_.end()) {
+            // RemoveAndJoinHandler() already removed us from the list, and is
+            // now waiting on a join(), so just return. Additionally, release
+            // all the resources held by snapuserd object which are shared
+            // by worker threads. This should be done when the last reference
+            // of "handler" is released; but we will explicitly release here
+            // to make sure snapuserd object is freed as it is the biggest
+            // consumer of memory in the daemon.
+            handler->FreeResources();
+            LOG(INFO) << "Exiting handler thread to allow for join: " << misc_name;
+            return;
+        }
+
+        LOG(INFO) << "Exiting handler thread and freeing resources: " << misc_name;
+
+        if (handler->snapuserd()->IsAttached()) {
+            handler->thread().detach();
+        }
+
+        // Important: free resources within the lock. This ensures that if
+        // WaitForDelete() is called, the handler is either in the list, or
+        // it's not and its resources are guaranteed to be freed.
+        handler->FreeResources();
+        dm_users_.erase(iter);
+    }
+}
+
+bool SnapshotHandlerManager::InitiateMerge(const std::string& misc_name) {
+    std::lock_guard<std::mutex> lock(lock_);
+    auto iter = FindHandler(&lock, misc_name);
+    if (iter == dm_users_.end()) {
+        LOG(ERROR) << "Could not find handler: " << misc_name;
+        return false;
+    }
+
+    return StartMerge(&lock, *iter);
+}
+
+bool SnapshotHandlerManager::StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
+                                        const std::shared_ptr<HandlerThread>& handler) {
+    CHECK(proof_of_lock);
+
+    if (!handler->snapuserd()->IsAttached()) {
+        LOG(ERROR) << "Handler not attached to dm-user - Merge thread cannot be started";
+        return false;
+    }
+
+    handler->snapuserd()->MonitorMerge();
+
+    if (!is_merge_monitor_started_) {
+        std::thread(&SnapshotHandlerManager::MonitorMerge, this).detach();
+        is_merge_monitor_started_ = true;
+    }
+
+    merge_handlers_.push(handler);
+    WakeupMonitorMergeThread();
+    return true;
+}
+
+void SnapshotHandlerManager::WakeupMonitorMergeThread() {
+    uint64_t notify = 1;
+    ssize_t rc = TEMP_FAILURE_RETRY(write(monitor_merge_event_fd_.get(), &notify, sizeof(notify)));
+    if (rc < 0) {
+        PLOG(FATAL) << "failed to notify monitor merge thread";
+    }
+}
+
+void SnapshotHandlerManager::MonitorMerge() {
+    while (!stop_monitor_merge_thread_) {
+        uint64_t testVal;
+        ssize_t ret =
+                TEMP_FAILURE_RETRY(read(monitor_merge_event_fd_.get(), &testVal, sizeof(testVal)));
+        if (ret == -1) {
+            PLOG(FATAL) << "Failed to read from eventfd";
+        } else if (ret == 0) {
+            LOG(FATAL) << "Hit EOF on eventfd";
+        }
+
+        LOG(INFO) << "MonitorMerge: active-merge-threads: " << active_merge_threads_;
+        {
+            std::lock_guard<std::mutex> lock(lock_);
+            while (active_merge_threads_ < kMaxMergeThreads && merge_handlers_.size() > 0) {
+                auto handler = merge_handlers_.front();
+                merge_handlers_.pop();
+
+                if (!handler->snapuserd()) {
+                    LOG(INFO) << "MonitorMerge: skipping deleted handler: " << handler->misc_name();
+                    continue;
+                }
+
+                LOG(INFO) << "Starting merge for partition: "
+                          << handler->snapuserd()->GetMiscName();
+                handler->snapuserd()->InitiateMerge();
+                active_merge_threads_ += 1;
+            }
+        }
+    }
+
+    LOG(INFO) << "Exiting MonitorMerge: size: " << merge_handlers_.size();
+}
+
+std::string SnapshotHandlerManager::GetMergeStatus(const std::string& misc_name) {
+    std::lock_guard<std::mutex> lock(lock_);
+    auto iter = FindHandler(&lock, misc_name);
+    if (iter == dm_users_.end()) {
+        LOG(ERROR) << "Could not find handler: " << misc_name;
+        return {};
+    }
+
+    return (*iter)->snapuserd()->GetMergeStatus();
+}
+
+double SnapshotHandlerManager::GetMergePercentage() {
+    std::lock_guard<std::mutex> lock(lock_);
+
+    double percentage = 0.0;
+    int n = 0;
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        auto& th = (*iter)->thread();
+        if (th.joinable()) {
+            // Merge percentage by individual partitions wherein merge is still
+            // in-progress
+            percentage += (*iter)->snapuserd()->GetMergePercentage();
+            n += 1;
+        }
+    }
+
+    // Calculate final merge including those partitions where merge was already
+    // completed - num_partitions_merge_complete_ will track them when each
+    // thread exists in RunThread.
+    int total_partitions = n + num_partitions_merge_complete_;
+
+    if (total_partitions) {
+        percentage = ((num_partitions_merge_complete_ * 100.0) + percentage) / total_partitions;
+    }
+
+    LOG(DEBUG) << "Merge %: " << percentage
+               << " num_partitions_merge_complete_: " << num_partitions_merge_complete_
+               << " total_partitions: " << total_partitions << " n: " << n;
+    return percentage;
+}
+
+bool SnapshotHandlerManager::GetVerificationStatus() {
+    std::lock_guard<std::mutex> lock(lock_);
+
+    bool status = true;
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        auto& th = (*iter)->thread();
+        if (th.joinable() && status) {
+            status = (*iter)->snapuserd()->CheckPartitionVerification() && status;
+        } else {
+            // return immediately if there is a failure
+            return false;
+        }
+    }
+
+    return status;
+}
+
+bool SnapshotHandlerManager::RemoveAndJoinHandler(const std::string& misc_name) {
+    std::shared_ptr<HandlerThread> handler;
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+
+        auto iter = FindHandler(&lock, misc_name);
+        if (iter == dm_users_.end()) {
+            // Client already deleted.
+            return true;
+        }
+        handler = std::move(*iter);
+        dm_users_.erase(iter);
+    }
+
+    auto& th = handler->thread();
+    if (th.joinable()) {
+        th.join();
+    }
+    return true;
+}
+
+void SnapshotHandlerManager::TerminateMergeThreads() {
+    std::lock_guard<std::mutex> guard(lock_);
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        if (!(*iter)->ThreadTerminated()) {
+            (*iter)->snapuserd()->NotifyIOTerminated();
+        }
+    }
+}
+
+void SnapshotHandlerManager::JoinAllThreads() {
+    // Acquire the thread list within the lock.
+    std::vector<std::shared_ptr<HandlerThread>> dm_users;
+    {
+        std::lock_guard<std::mutex> guard(lock_);
+        dm_users = std::move(dm_users_);
+    }
+
+    for (auto& client : dm_users) {
+        auto& th = client->thread();
+
+        if (th.joinable()) th.join();
+    }
+
+    stop_monitor_merge_thread_ = true;
+    WakeupMonitorMergeThread();
+}
+
+auto SnapshotHandlerManager::FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
+                                         const std::string& misc_name) -> HandlerList::iterator {
+    CHECK(proof_of_lock);
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        if ((*iter)->misc_name() == misc_name) {
+            return iter;
+        }
+    }
+    return dm_users_.end();
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
new file mode 100644
index 000000000000..b7ddac19f28a
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
@@ -0,0 +1,131 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <memory>
+#include <queue>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include <android-base/unique_fd.h>
+
+namespace android {
+namespace snapshot {
+
+class SnapshotHandler;
+
+class HandlerThread {
+  public:
+    explicit HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd);
+
+    void FreeResources();
+    const std::shared_ptr<SnapshotHandler>& snapuserd() const { return snapuserd_; }
+    std::thread& thread() { return thread_; }
+
+    const std::string& misc_name() const { return misc_name_; }
+    bool ThreadTerminated() { return thread_terminated_; }
+    void SetThreadTerminated() { thread_terminated_ = true; }
+
+  private:
+    std::thread thread_;
+    std::shared_ptr<SnapshotHandler> snapuserd_;
+    std::string misc_name_;
+    bool thread_terminated_ = false;
+};
+
+class ISnapshotHandlerManager {
+  public:
+    virtual ~ISnapshotHandlerManager() {}
+
+    // Add a new snapshot handler but do not start serving requests yet.
+    virtual std::shared_ptr<HandlerThread> AddHandler(const std::string& misc_name,
+                                                      const std::string& cow_device_path,
+                                                      const std::string& backing_device,
+                                                      const std::string& base_path_merge,
+                                                      int num_worker_threads, bool use_iouring,
+                                                      bool perform_verification) = 0;
+
+    // Start serving requests on a snapshot handler.
+    virtual bool StartHandler(const std::string& misc_name) = 0;
+
+    // Stop serving requests on a snapshot handler and remove it.
+    virtual bool DeleteHandler(const std::string& misc_name) = 0;
+
+    // Begin merging blocks on the given snapshot handler.
+    virtual bool InitiateMerge(const std::string& misc_name) = 0;
+
+    // Return a string containing a status code indicating the merge status
+    // on the handler. Returns empty on error.
+    virtual std::string GetMergeStatus(const std::string& misc_name) = 0;
+
+    // Wait until all handlers have terminated.
+    virtual void JoinAllThreads() = 0;
+
+    // Stop any in-progress merge threads.
+    virtual void TerminateMergeThreads() = 0;
+
+    // Returns the merge progress across all merging snapshot handlers.
+    virtual double GetMergePercentage() = 0;
+
+    // Returns whether all snapshots have verified.
+    virtual bool GetVerificationStatus() = 0;
+};
+
+class SnapshotHandlerManager final : public ISnapshotHandlerManager {
+  public:
+    SnapshotHandlerManager();
+    std::shared_ptr<HandlerThread> AddHandler(const std::string& misc_name,
+                                              const std::string& cow_device_path,
+                                              const std::string& backing_device,
+                                              const std::string& base_path_merge,
+                                              int num_worker_threads, bool use_iouring,
+                                              bool perform_verification) override;
+    bool StartHandler(const std::string& misc_name) override;
+    bool DeleteHandler(const std::string& misc_name) override;
+    bool InitiateMerge(const std::string& misc_name) override;
+    std::string GetMergeStatus(const std::string& misc_name) override;
+    void JoinAllThreads() override;
+    void TerminateMergeThreads() override;
+    double GetMergePercentage() override;
+    bool GetVerificationStatus() override;
+
+  private:
+    bool StartHandler(const std::shared_ptr<HandlerThread>& handler);
+    void RunThread(std::shared_ptr<HandlerThread> handler);
+    bool StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
+                    const std::shared_ptr<HandlerThread>& handler);
+    void MonitorMerge();
+    void WakeupMonitorMergeThread();
+    bool RemoveAndJoinHandler(const std::string& misc_name);
+
+    // Find a HandlerThread within a lock.
+    using HandlerList = std::vector<std::shared_ptr<HandlerThread>>;
+    HandlerList::iterator FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
+                                      const std::string& misc_name);
+
+    std::mutex lock_;
+    HandlerList dm_users_;
+
+    bool is_merge_monitor_started_ = false;
+    bool stop_monitor_merge_thread_ = false;
+    int active_merge_threads_ = 0;
+    int num_partitions_merge_complete_ = 0;
+    std::queue<std::shared_ptr<HandlerThread>> merge_handlers_;
+    android::base::unique_fd monitor_merge_event_fd_;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index b7ce2109adfe..cc8115f5f800 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -62,11 +62,8 @@ DaemonOps UserSnapshotServer::Resolveop(std::string& input) {
 }
 
 UserSnapshotServer::UserSnapshotServer() {
-    monitor_merge_event_fd_.reset(eventfd(0, EFD_CLOEXEC));
-    if (monitor_merge_event_fd_ == -1) {
-        PLOG(FATAL) << "monitor_merge_event_fd_: failed to create eventfd";
-    }
     terminating_ = false;
+    handlers_ = std::make_unique<SnapshotHandlerManager>();
 }
 
 UserSnapshotServer::~UserSnapshotServer() {
@@ -99,7 +96,7 @@ void UserSnapshotServer::Parsemsg(std::string const& msg, const char delim,
 
 void UserSnapshotServer::ShutdownThreads() {
     terminating_ = true;
-    JoinAllThreads();
+    handlers_->JoinAllThreads();
 }
 
 HandlerThread::HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd)
@@ -166,17 +163,7 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 return Sendmsg(fd, "fail");
             }
 
-            std::lock_guard<std::mutex> lock(lock_);
-            auto iter = FindHandler(&lock, out[1]);
-            if (iter == dm_users_.end()) {
-                LOG(ERROR) << "Could not find handler: " << out[1];
-                return Sendmsg(fd, "fail");
-            }
-            if (!(*iter)->snapuserd() || (*iter)->snapuserd()->IsAttached()) {
-                LOG(ERROR) << "Tried to re-attach control device: " << out[1];
-                return Sendmsg(fd, "fail");
-            }
-            if (!StartHandler(*iter)) {
+            if (!handlers_->StartHandler(out[1])) {
                 return Sendmsg(fd, "fail");
             }
             return Sendmsg(fd, "success");
@@ -209,30 +196,13 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
                 return Sendmsg(fd, "fail");
             }
-            {
-                std::lock_guard<std::mutex> lock(lock_);
-                auto iter = FindHandler(&lock, out[1]);
-                if (iter == dm_users_.end()) {
-                    // After merge is completed, we swap dm-user table with
-                    // the underlying dm-linear base device. Hence, worker
-                    // threads would have terminted and was removed from
-                    // the list.
-                    LOG(DEBUG) << "Could not find handler: " << out[1];
-                    return Sendmsg(fd, "success");
-                }
-
-                if (!(*iter)->ThreadTerminated()) {
-                    (*iter)->snapuserd()->NotifyIOTerminated();
-                }
-            }
-            if (!RemoveAndJoinHandler(out[1])) {
+            if (!handlers_->DeleteHandler(out[1])) {
                 return Sendmsg(fd, "fail");
             }
             return Sendmsg(fd, "success");
         }
         case DaemonOps::DETACH: {
-            std::lock_guard<std::mutex> lock(lock_);
-            TerminateMergeThreads(&lock);
+            handlers_->TerminateMergeThreads();
             terminating_ = true;
             return true;
         }
@@ -252,24 +222,15 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 return Sendmsg(fd, "fail");
             }
             if (out[0] == "initiate_merge") {
-                std::lock_guard<std::mutex> lock(lock_);
-                auto iter = FindHandler(&lock, out[1]);
-                if (iter == dm_users_.end()) {
-                    LOG(ERROR) << "Could not find handler: " << out[1];
+                if (!handlers_->InitiateMerge(out[1])) {
                     return Sendmsg(fd, "fail");
                 }
-
-                if (!StartMerge(&lock, *iter)) {
-                    return Sendmsg(fd, "fail");
-                }
-
                 return Sendmsg(fd, "success");
             }
             return Sendmsg(fd, "fail");
         }
         case DaemonOps::PERCENTAGE: {
-            std::lock_guard<std::mutex> lock(lock_);
-            double percentage = GetMergePercentage(&lock);
+            double percentage = handlers_->GetMergePercentage();
 
             return Sendmsg(fd, std::to_string(percentage));
         }
@@ -280,24 +241,16 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
                 return Sendmsg(fd, "snapshot-merge-failed");
             }
-            {
-                std::lock_guard<std::mutex> lock(lock_);
-                auto iter = FindHandler(&lock, out[1]);
-                if (iter == dm_users_.end()) {
-                    LOG(ERROR) << "Could not find handler: " << out[1];
-                    return Sendmsg(fd, "snapshot-merge-failed");
-                }
-
-                std::string merge_status = GetMergeStatus(*iter);
-                return Sendmsg(fd, merge_status);
+            auto status = handlers_->GetMergeStatus(out[1]);
+            if (status.empty()) {
+                return Sendmsg(fd, "snapshot-merge-failed");
             }
+            return Sendmsg(fd, status);
         }
         case DaemonOps::UPDATE_VERIFY: {
-            std::lock_guard<std::mutex> lock(lock_);
-            if (!UpdateVerification(&lock)) {
+            if (!handlers_->GetVerificationStatus()) {
                 return Sendmsg(fd, "fail");
             }
-
             return Sendmsg(fd, "success");
         }
         default: {
@@ -308,56 +261,6 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
     }
 }
 
-void UserSnapshotServer::RunThread(std::shared_ptr<HandlerThread> handler) {
-    LOG(INFO) << "Entering thread for handler: " << handler->misc_name();
-
-    if (!handler->snapuserd()->Start()) {
-        LOG(ERROR) << " Failed to launch all worker threads";
-    }
-
-    handler->snapuserd()->CloseFds();
-    bool merge_completed = handler->snapuserd()->CheckMergeCompletionStatus();
-    handler->snapuserd()->UnmapBufferRegion();
-
-    auto misc_name = handler->misc_name();
-    LOG(INFO) << "Handler thread about to exit: " << misc_name;
-
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        if (merge_completed) {
-            num_partitions_merge_complete_ += 1;
-            active_merge_threads_ -= 1;
-            WakeupMonitorMergeThread();
-        }
-        handler->SetThreadTerminated();
-        auto iter = FindHandler(&lock, handler->misc_name());
-        if (iter == dm_users_.end()) {
-            // RemoveAndJoinHandler() already removed us from the list, and is
-            // now waiting on a join(), so just return. Additionally, release
-            // all the resources held by snapuserd object which are shared
-            // by worker threads. This should be done when the last reference
-            // of "handler" is released; but we will explicitly release here
-            // to make sure snapuserd object is freed as it is the biggest
-            // consumer of memory in the daemon.
-            handler->FreeResources();
-            LOG(INFO) << "Exiting handler thread to allow for join: " << misc_name;
-            return;
-        }
-
-        LOG(INFO) << "Exiting handler thread and freeing resources: " << misc_name;
-
-        if (handler->snapuserd()->IsAttached()) {
-            handler->thread().detach();
-        }
-
-        // Important: free resources within the lock. This ensures that if
-        // WaitForDelete() is called, the handler is either in the list, or
-        // it's not and its resources are guaranteed to be freed.
-        handler->FreeResources();
-        dm_users_.erase(iter);
-    }
-}
-
 bool UserSnapshotServer::Start(const std::string& socketname) {
     bool start_listening = true;
 
@@ -423,28 +326,10 @@ bool UserSnapshotServer::Run() {
         }
     }
 
-    JoinAllThreads();
+    handlers_->JoinAllThreads();
     return true;
 }
 
-void UserSnapshotServer::JoinAllThreads() {
-    // Acquire the thread list within the lock.
-    std::vector<std::shared_ptr<HandlerThread>> dm_users;
-    {
-        std::lock_guard<std::mutex> guard(lock_);
-        dm_users = std::move(dm_users_);
-    }
-
-    for (auto& client : dm_users) {
-        auto& th = client->thread();
-
-        if (th.joinable()) th.join();
-    }
-
-    stop_monitor_merge_thread_ = true;
-    WakeupMonitorMergeThread();
-}
-
 void UserSnapshotServer::AddWatchedFd(android::base::borrowed_fd fd, int events) {
     struct pollfd p = {};
     p.fd = fd.get();
@@ -506,185 +391,13 @@ std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string&
         perform_verification = false;
     }
 
-    auto snapuserd = std::make_shared<SnapshotHandler>(misc_name, cow_device_path, backing_device,
-                                                       base_path_merge, num_worker_threads,
-                                                       io_uring_enabled_, perform_verification);
-    if (!snapuserd->InitCowDevice()) {
-        LOG(ERROR) << "Failed to initialize Snapuserd";
-        return nullptr;
-    }
-
-    if (!snapuserd->InitializeWorkers()) {
-        LOG(ERROR) << "Failed to initialize workers";
-        return nullptr;
-    }
-
-    auto handler = std::make_shared<HandlerThread>(snapuserd);
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        if (FindHandler(&lock, misc_name) != dm_users_.end()) {
-            LOG(ERROR) << "Handler already exists: " << misc_name;
-            return nullptr;
-        }
-        dm_users_.push_back(handler);
-    }
-    return handler;
-}
-
-bool UserSnapshotServer::StartHandler(const std::shared_ptr<HandlerThread>& handler) {
-    if (handler->snapuserd()->IsAttached()) {
-        LOG(ERROR) << "Handler already attached";
-        return false;
-    }
-
-    handler->snapuserd()->AttachControlDevice();
-
-    handler->thread() = std::thread(std::bind(&UserSnapshotServer::RunThread, this, handler));
-    return true;
-}
-
-bool UserSnapshotServer::StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
-                                    const std::shared_ptr<HandlerThread>& handler) {
-    CHECK(proof_of_lock);
-
-    if (!handler->snapuserd()->IsAttached()) {
-        LOG(ERROR) << "Handler not attached to dm-user - Merge thread cannot be started";
-        return false;
-    }
-
-    handler->snapuserd()->MonitorMerge();
-
-    if (!is_merge_monitor_started_.has_value()) {
-        std::thread(&UserSnapshotServer::MonitorMerge, this).detach();
-        is_merge_monitor_started_ = true;
-    }
-
-    merge_handlers_.push(handler);
-    WakeupMonitorMergeThread();
-    return true;
-}
-
-auto UserSnapshotServer::FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
-                                     const std::string& misc_name) -> HandlerList::iterator {
-    CHECK(proof_of_lock);
-
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        if ((*iter)->misc_name() == misc_name) {
-            return iter;
-        }
-    }
-    return dm_users_.end();
-}
-
-void UserSnapshotServer::TerminateMergeThreads(std::lock_guard<std::mutex>* proof_of_lock) {
-    CHECK(proof_of_lock);
-
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        if (!(*iter)->ThreadTerminated()) {
-            (*iter)->snapuserd()->NotifyIOTerminated();
-        }
-    }
-}
-
-std::string UserSnapshotServer::GetMergeStatus(const std::shared_ptr<HandlerThread>& handler) {
-    return handler->snapuserd()->GetMergeStatus();
-}
-
-double UserSnapshotServer::GetMergePercentage(std::lock_guard<std::mutex>* proof_of_lock) {
-    CHECK(proof_of_lock);
-    double percentage = 0.0;
-    int n = 0;
-
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        auto& th = (*iter)->thread();
-        if (th.joinable()) {
-            // Merge percentage by individual partitions wherein merge is still
-            // in-progress
-            percentage += (*iter)->snapuserd()->GetMergePercentage();
-            n += 1;
-        }
-    }
-
-    // Calculate final merge including those partitions where merge was already
-    // completed - num_partitions_merge_complete_ will track them when each
-    // thread exists in RunThread.
-    int total_partitions = n + num_partitions_merge_complete_;
-
-    if (total_partitions) {
-        percentage = ((num_partitions_merge_complete_ * 100.0) + percentage) / total_partitions;
-    }
-
-    LOG(DEBUG) << "Merge %: " << percentage
-               << " num_partitions_merge_complete_: " << num_partitions_merge_complete_
-               << " total_partitions: " << total_partitions << " n: " << n;
-    return percentage;
-}
-
-bool UserSnapshotServer::RemoveAndJoinHandler(const std::string& misc_name) {
-    std::shared_ptr<HandlerThread> handler;
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-
-        auto iter = FindHandler(&lock, misc_name);
-        if (iter == dm_users_.end()) {
-            // Client already deleted.
-            return true;
-        }
-        handler = std::move(*iter);
-        dm_users_.erase(iter);
-    }
-
-    auto& th = handler->thread();
-    if (th.joinable()) {
-        th.join();
-    }
-    return true;
-}
-
-void UserSnapshotServer::WakeupMonitorMergeThread() {
-    uint64_t notify = 1;
-    ssize_t rc = TEMP_FAILURE_RETRY(write(monitor_merge_event_fd_.get(), &notify, sizeof(notify)));
-    if (rc < 0) {
-        PLOG(FATAL) << "failed to notify monitor merge thread";
-    }
-}
-
-void UserSnapshotServer::MonitorMerge() {
-    while (!stop_monitor_merge_thread_) {
-        uint64_t testVal;
-        ssize_t ret =
-                TEMP_FAILURE_RETRY(read(monitor_merge_event_fd_.get(), &testVal, sizeof(testVal)));
-        if (ret == -1) {
-            PLOG(FATAL) << "Failed to read from eventfd";
-        } else if (ret == 0) {
-            LOG(FATAL) << "Hit EOF on eventfd";
-        }
-
-        LOG(INFO) << "MonitorMerge: active-merge-threads: " << active_merge_threads_;
-        {
-            std::lock_guard<std::mutex> lock(lock_);
-            while (active_merge_threads_ < kMaxMergeThreads && merge_handlers_.size() > 0) {
-                auto handler = merge_handlers_.front();
-                merge_handlers_.pop();
-
-                if (!handler->snapuserd()) {
-                    LOG(INFO) << "MonitorMerge: skipping deleted handler: " << handler->misc_name();
-                    continue;
-                }
-
-                LOG(INFO) << "Starting merge for partition: "
-                          << handler->snapuserd()->GetMiscName();
-                handler->snapuserd()->InitiateMerge();
-                active_merge_threads_ += 1;
-            }
-        }
-    }
-
-    LOG(INFO) << "Exiting MonitorMerge: size: " << merge_handlers_.size();
+    return handlers_->AddHandler(misc_name, cow_device_path, backing_device, base_path_merge,
+                                 num_worker_threads, io_uring_enabled_, perform_verification);
 }
 
 bool UserSnapshotServer::WaitForSocket() {
-    auto scope_guard = android::base::make_scope_guard([this]() -> void { JoinAllThreads(); });
+    auto scope_guard =
+            android::base::make_scope_guard([this]() -> void { handlers_->JoinAllThreads(); });
 
     auto socket_path = ANDROID_SOCKET_DIR "/"s + kSnapuserdSocketProxy;
 
@@ -781,21 +494,8 @@ bool UserSnapshotServer::RunForSocketHandoff() {
     return true;
 }
 
-bool UserSnapshotServer::UpdateVerification(std::lock_guard<std::mutex>* proof_of_lock) {
-    CHECK(proof_of_lock);
-
-    bool status = true;
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        auto& th = (*iter)->thread();
-        if (th.joinable() && status) {
-            status = (*iter)->snapuserd()->CheckPartitionVerification() && status;
-        } else {
-            // return immediately if there is a failure
-            return false;
-        }
-    }
-
-    return status;
+bool UserSnapshotServer::StartHandler(const std::string& misc_name) {
+    return handlers_->StartHandler(misc_name);
 }
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index 12c3903c495c..ae5190391dfa 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -31,6 +31,7 @@
 #include <vector>
 
 #include <android-base/unique_fd.h>
+#include "handler_manager.h"
 #include "snapuserd_core.h"
 
 namespace android {
@@ -54,33 +55,6 @@ enum class DaemonOps {
     INVALID,
 };
 
-class HandlerThread {
-  public:
-    explicit HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd);
-
-    void FreeResources() {
-        // Each worker thread holds a reference to snapuserd.
-        // Clear them so that all the resources
-        // held by snapuserd is released
-        if (snapuserd_) {
-            snapuserd_->FreeResources();
-            snapuserd_ = nullptr;
-        }
-    }
-    const std::shared_ptr<SnapshotHandler>& snapuserd() const { return snapuserd_; }
-    std::thread& thread() { return thread_; }
-
-    const std::string& misc_name() const { return misc_name_; }
-    bool ThreadTerminated() { return thread_terminated_; }
-    void SetThreadTerminated() { thread_terminated_ = true; }
-
-  private:
-    std::thread thread_;
-    std::shared_ptr<SnapshotHandler> snapuserd_;
-    std::string misc_name_;
-    bool thread_terminated_ = false;
-};
-
 class UserSnapshotServer {
   private:
     android::base::unique_fd sockfd_;
@@ -88,21 +62,12 @@ class UserSnapshotServer {
     volatile bool received_socket_signal_ = false;
     std::vector<struct pollfd> watched_fds_;
     bool is_socket_present_ = false;
-    int num_partitions_merge_complete_ = 0;
-    int active_merge_threads_ = 0;
-    bool stop_monitor_merge_thread_ = false;
     bool is_server_running_ = false;
     bool io_uring_enabled_ = false;
-    std::optional<bool> is_merge_monitor_started_;
-
-    android::base::unique_fd monitor_merge_event_fd_;
+    std::unique_ptr<ISnapshotHandlerManager> handlers_;
 
     std::mutex lock_;
 
-    using HandlerList = std::vector<std::shared_ptr<HandlerThread>>;
-    HandlerList dm_users_;
-    std::queue<std::shared_ptr<HandlerThread>> merge_handlers_;
-
     void AddWatchedFd(android::base::borrowed_fd fd, int events);
     void AcceptClient();
     bool HandleClient(android::base::borrowed_fd fd, int revents);
@@ -111,28 +76,15 @@ class UserSnapshotServer {
     bool Receivemsg(android::base::borrowed_fd fd, const std::string& str);
 
     void ShutdownThreads();
-    bool RemoveAndJoinHandler(const std::string& control_device);
     DaemonOps Resolveop(std::string& input);
     std::string GetDaemonStatus();
     void Parsemsg(std::string const& msg, const char delim, std::vector<std::string>& out);
 
     bool IsTerminating() { return terminating_; }
 
-    void RunThread(std::shared_ptr<HandlerThread> handler);
-    void MonitorMerge();
-
     void JoinAllThreads();
     bool StartWithSocket(bool start_listening);
 
-    // Find a HandlerThread within a lock.
-    HandlerList::iterator FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
-                                      const std::string& misc_name);
-
-    double GetMergePercentage(std::lock_guard<std::mutex>* proof_of_lock);
-    void TerminateMergeThreads(std::lock_guard<std::mutex>* proof_of_lock);
-
-    bool UpdateVerification(std::lock_guard<std::mutex>* proof_of_lock);
-
   public:
     UserSnapshotServer();
     ~UserSnapshotServer();
@@ -147,12 +99,8 @@ class UserSnapshotServer {
                                               const std::string& cow_device_path,
                                               const std::string& backing_device,
                                               const std::string& base_path_merge);
-    bool StartHandler(const std::shared_ptr<HandlerThread>& handler);
-    bool StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
-                    const std::shared_ptr<HandlerThread>& handler);
-    std::string GetMergeStatus(const std::shared_ptr<HandlerThread>& handler);
+    bool StartHandler(const std::string& misc_name);
 
-    void WakeupMonitorMergeThread();
     void SetTerminating() { terminating_ = true; }
     void ReceivedSocketSignal() { received_socket_signal_ = true; }
     void SetServerRunning() { is_server_running_ = true; }

From 1c29014458a0b47c92b46e39c99db6c3482054d7 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 14 Mar 2023 09:09:48 -0700
Subject: [PATCH 0197/1487] snapuserd: Remove DaemonOps.

These are only used for a single switch statement. Just compare the
input strings instead.

Bug: 269361087
Test: builds, ota applies
Ignore-AOSP-First: cherry-pick from aosp
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:f84f9c319e5a05fa6bfed9730ea6b9d28407a84b)
Merged-In: Ib90ae55309ea99c181585c64ed2ac814e5ed6c72
Change-Id: Ib90ae55309ea99c181585c64ed2ac814e5ed6c72
---
 .../user-space-merge/snapuserd_server.cpp     | 218 ++++++++----------
 .../user-space-merge/snapuserd_server.h       |  16 --
 2 files changed, 94 insertions(+), 140 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index cc8115f5f800..d87990aca2a8 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -45,22 +45,6 @@ using namespace std::string_literals;
 using android::base::borrowed_fd;
 using android::base::unique_fd;
 
-DaemonOps UserSnapshotServer::Resolveop(std::string& input) {
-    if (input == "init") return DaemonOps::INIT;
-    if (input == "start") return DaemonOps::START;
-    if (input == "stop") return DaemonOps::STOP;
-    if (input == "query") return DaemonOps::QUERY;
-    if (input == "delete") return DaemonOps::DELETE;
-    if (input == "detach") return DaemonOps::DETACH;
-    if (input == "supports") return DaemonOps::SUPPORTS;
-    if (input == "initiate_merge") return DaemonOps::INITIATE;
-    if (input == "merge_percent") return DaemonOps::PERCENTAGE;
-    if (input == "getstatus") return DaemonOps::GETSTATUS;
-    if (input == "update-verify") return DaemonOps::UPDATE_VERIFY;
-
-    return DaemonOps::INVALID;
-}
-
 UserSnapshotServer::UserSnapshotServer() {
     terminating_ = false;
     handlers_ = std::make_unique<SnapshotHandlerManager>();
@@ -132,132 +116,118 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
 
     std::vector<std::string> out;
     Parsemsg(str, delim, out);
-    DaemonOps op = Resolveop(out[0]);
-
-    switch (op) {
-        case DaemonOps::INIT: {
-            // Message format:
-            // init,<misc_name>,<cow_device_path>,<backing_device>,<base_path_merge>
-            //
-            // Reads the metadata and send the number of sectors
-            if (out.size() != 5) {
-                LOG(ERROR) << "Malformed init message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
 
-            auto handler = AddHandler(out[1], out[2], out[3], out[4]);
-            if (!handler) {
-                return Sendmsg(fd, "fail");
-            }
-
-            auto retval = "success," + std::to_string(handler->snapuserd()->GetNumSectors());
-            return Sendmsg(fd, retval);
+    const auto& cmd = out[0];
+    if (cmd == "init") {
+        // Message format:
+        // init,<misc_name>,<cow_device_path>,<backing_device>,<base_path_merge>
+        //
+        // Reads the metadata and send the number of sectors
+        if (out.size() != 5) {
+            LOG(ERROR) << "Malformed init message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::START: {
-            // Message format:
-            // start,<misc_name>
-            //
-            // Start the new thread which binds to dm-user misc device
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed start message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
 
-            if (!handlers_->StartHandler(out[1])) {
-                return Sendmsg(fd, "fail");
-            }
-            return Sendmsg(fd, "success");
-        }
-        case DaemonOps::STOP: {
-            // Message format: stop
-            //
-            // Stop all the threads gracefully and then shutdown the
-            // main thread
-            SetTerminating();
-            ShutdownThreads();
-            return true;
+        auto handler = AddHandler(out[1], out[2], out[3], out[4]);
+        if (!handler) {
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::QUERY: {
-            // Message format: query
-            //
-            // As part of transition, Second stage daemon will be
-            // created before terminating the first stage daemon. Hence,
-            // for a brief period client may have to distiguish between
-            // first stage daemon and second stage daemon.
-            //
-            // Second stage daemon is marked as active and hence will
-            // be ready to receive control message.
-            return Sendmsg(fd, GetDaemonStatus());
+
+        auto retval = "success," + std::to_string(handler->snapuserd()->GetNumSectors());
+        return Sendmsg(fd, retval);
+    } else if (cmd == "start") {
+        // Message format:
+        // start,<misc_name>
+        //
+        // Start the new thread which binds to dm-user misc device
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed start message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::DELETE: {
-            // Message format:
-            // delete,<misc_name>
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (!handlers_->DeleteHandler(out[1])) {
-                return Sendmsg(fd, "fail");
-            }
-            return Sendmsg(fd, "success");
+
+        if (!handlers_->StartHandler(out[1])) {
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::DETACH: {
-            handlers_->TerminateMergeThreads();
-            terminating_ = true;
-            return true;
+        return Sendmsg(fd, "success");
+    } else if (cmd == "stop") {
+        // Message format: stop
+        //
+        // Stop all the threads gracefully and then shutdown the
+        // main thread
+        SetTerminating();
+        ShutdownThreads();
+        return true;
+    } else if (cmd == "query") {
+        // Message format: query
+        //
+        // As part of transition, Second stage daemon will be
+        // created before terminating the first stage daemon. Hence,
+        // for a brief period client may have to distiguish between
+        // first stage daemon and second stage daemon.
+        //
+        // Second stage daemon is marked as active and hence will
+        // be ready to receive control message.
+        return Sendmsg(fd, GetDaemonStatus());
+    } else if (cmd == "delete") {
+        // Message format:
+        // delete,<misc_name>
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::SUPPORTS: {
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed supports message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (out[1] == "second_stage_socket_handoff") {
-                return Sendmsg(fd, "success");
-            }
+        if (!handlers_->DeleteHandler(out[1])) {
             return Sendmsg(fd, "fail");
         }
-        case DaemonOps::INITIATE: {
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed initiate-merge message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (out[0] == "initiate_merge") {
-                if (!handlers_->InitiateMerge(out[1])) {
-                    return Sendmsg(fd, "fail");
-                }
-                return Sendmsg(fd, "success");
-            }
+        return Sendmsg(fd, "success");
+    } else if (cmd == "detach") {
+        handlers_->TerminateMergeThreads();
+        terminating_ = true;
+        return true;
+    } else if (cmd == "supports") {
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed supports message, " << out.size() << " parts";
             return Sendmsg(fd, "fail");
         }
-        case DaemonOps::PERCENTAGE: {
-            double percentage = handlers_->GetMergePercentage();
-
-            return Sendmsg(fd, std::to_string(percentage));
+        if (out[1] == "second_stage_socket_handoff") {
+            return Sendmsg(fd, "success");
         }
-        case DaemonOps::GETSTATUS: {
-            // Message format:
-            // getstatus,<misc_name>
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
-                return Sendmsg(fd, "snapshot-merge-failed");
-            }
-            auto status = handlers_->GetMergeStatus(out[1]);
-            if (status.empty()) {
-                return Sendmsg(fd, "snapshot-merge-failed");
-            }
-            return Sendmsg(fd, status);
+        return Sendmsg(fd, "fail");
+    } else if (cmd == "initiate_merge") {
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed initiate-merge message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::UPDATE_VERIFY: {
-            if (!handlers_->GetVerificationStatus()) {
+        if (out[0] == "initiate_merge") {
+            if (!handlers_->InitiateMerge(out[1])) {
                 return Sendmsg(fd, "fail");
             }
             return Sendmsg(fd, "success");
         }
-        default: {
-            LOG(ERROR) << "Received unknown message type from client";
-            Sendmsg(fd, "fail");
-            return false;
+        return Sendmsg(fd, "fail");
+    } else if (cmd == "merge_percent") {
+        double percentage = handlers_->GetMergePercentage();
+        return Sendmsg(fd, std::to_string(percentage));
+    } else if (cmd == "getstatus") {
+        // Message format:
+        // getstatus,<misc_name>
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
+            return Sendmsg(fd, "snapshot-merge-failed");
+        }
+        auto status = handlers_->GetMergeStatus(out[1]);
+        if (status.empty()) {
+            return Sendmsg(fd, "snapshot-merge-failed");
         }
+        return Sendmsg(fd, status);
+    } else if (cmd == "update-verify") {
+        if (!handlers_->GetVerificationStatus()) {
+            return Sendmsg(fd, "fail");
+        }
+        return Sendmsg(fd, "success");
+    } else {
+        LOG(ERROR) << "Received unknown message type from client";
+        Sendmsg(fd, "fail");
+        return false;
     }
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index ae5190391dfa..988c01a99ba3 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -40,21 +40,6 @@ namespace snapshot {
 static constexpr uint32_t kMaxPacketSize = 512;
 static constexpr uint8_t kMaxMergeThreads = 2;
 
-enum class DaemonOps {
-    INIT,
-    START,
-    QUERY,
-    STOP,
-    DELETE,
-    DETACH,
-    SUPPORTS,
-    INITIATE,
-    PERCENTAGE,
-    GETSTATUS,
-    UPDATE_VERIFY,
-    INVALID,
-};
-
 class UserSnapshotServer {
   private:
     android::base::unique_fd sockfd_;
@@ -76,7 +61,6 @@ class UserSnapshotServer {
     bool Receivemsg(android::base::borrowed_fd fd, const std::string& str);
 
     void ShutdownThreads();
-    DaemonOps Resolveop(std::string& input);
     std::string GetDaemonStatus();
     void Parsemsg(std::string const& msg, const char delim, std::vector<std::string>& out);
 

From 06d9d8745407256f47e51415b26cd77dcb7f9752 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 14 Mar 2023 10:57:47 -0700
Subject: [PATCH 0198/1487] snapuserd: Run snapuserd threads in-process.

This removes the temporary daemon and socket and instead directly embeds
SnapshotHandlerManager. We can also remove the test flags for io_uring
as with this they're no longer necessary.

Bug: 269361087
Test: snapuserd_test
Ignore-AOSP-First: cherry-pick from aosp
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:269e99f9558ae332e10329451fc51dc6698375a0)
Merged-In: I728186d9bc90c98fabd76d3f86569840488ada96
Change-Id: I728186d9bc90c98fabd76d3f86569840488ada96
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       | 15 ++--
 .../user-space-merge/handler_manager.cpp      |  3 +
 .../user-space-merge/snapuserd_core.cpp       |  5 --
 .../user-space-merge/snapuserd_server.cpp     |  3 -
 .../user-space-merge/snapuserd_test.cpp       | 75 ++++++-------------
 5 files changed, 33 insertions(+), 68 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 65f3d6d297ed..9fe567acbc7e 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -165,7 +165,7 @@ cc_binary {
 }
 
 cc_test {
-    name: "cow_snapuserd_test",
+    name: "snapuserd_test_legacy",
     defaults: [
         "fs_mgr_defaults",
         "libsnapshot_cow_defaults",
@@ -217,16 +217,17 @@ cc_test {
     ],
     static_libs: [
         "libbrotli",
-        "libgtest",
-        "libsnapshot_cow",
-        "libsnapshot_snapuserd",
         "libcutils_sockets",
-        "libz",
-        "libfs_mgr",
         "libdm",
         "libext4_utils",
-        "liburing",
+        "libfs_mgr",
         "libgflags",
+        "libgtest",
+        "libsnapshot_cow",
+        "libsnapshot_snapuserd",
+        "libsnapuserd",
+        "liburing",
+        "libz",
     ],
     include_dirs: ["bionic/libc/kernel"],
     header_libs: [
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index c5150c411d02..bdba5c0cc3ab 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -25,6 +25,9 @@ namespace snapshot {
 
 static constexpr uint8_t kMaxMergeThreads = 2;
 
+HandlerThread::HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd)
+    : snapuserd_(snapuserd), misc_name_(snapuserd_->GetMiscName()) {}
+
 void HandlerThread::FreeResources() {
     // Each worker thread holds a reference to snapuserd.
     // Clear them so that all the resources
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index c8a5cc584a28..8e1212b7b3ce 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -421,11 +421,6 @@ bool SnapshotHandler::IsIouringSupported() {
     struct utsname uts;
     unsigned int major, minor;
 
-    if (android::base::GetBoolProperty("snapuserd.test.io_uring.force_disable", false)) {
-        SNAP_LOG(INFO) << "io_uring disabled for testing";
-        return false;
-    }
-
     if ((uname(&uts) != 0) || (sscanf(uts.release, "%u.%u", &major, &minor) != 2)) {
         SNAP_LOG(ERROR) << "Could not parse the kernel version from uname. "
                         << " io_uring not supported";
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index d87990aca2a8..c953f1a053bd 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -83,9 +83,6 @@ void UserSnapshotServer::ShutdownThreads() {
     handlers_->JoinAllThreads();
 }
 
-HandlerThread::HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd)
-    : snapuserd_(snapuserd), misc_name_(snapuserd_->GetMiscName()) {}
-
 bool UserSnapshotServer::Sendmsg(android::base::borrowed_fd fd, const std::string& msg) {
     ssize_t ret = TEMP_FAILURE_RETRY(send(fd.get(), msg.data(), msg.size(), MSG_NOSIGNAL));
     if (ret < 0) {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index ef3689f61f6b..efe0c1443215 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -37,9 +37,9 @@
 #include <libdm/dm.h>
 #include <libdm/loop_control.h>
 #include <libsnapshot/cow_writer.h>
-#include <snapuserd/snapuserd_client.h>
 #include <storage_literals/storage_literals.h>
 
+#include "handler_manager.h"
 #include "snapuserd_core.h"
 
 DEFINE_string(force_config, "", "Force testing mode with iouring disabled");
@@ -54,8 +54,6 @@ using namespace std::chrono_literals;
 using namespace android::dm;
 using namespace std;
 
-static constexpr char kSnapuserdSocketTest[] = "snapuserdTest";
-
 class Tempdevice {
   public:
     Tempdevice(const std::string& name, const DmTable& table)
@@ -68,15 +66,15 @@ class Tempdevice {
     }
     ~Tempdevice() {
         if (valid_) {
-            dm_.DeleteDevice(name_);
+            dm_.DeleteDeviceIfExists(name_);
         }
     }
     bool Destroy() {
         if (!valid_) {
-            return false;
+            return true;
         }
         valid_ = false;
-        return dm_.DeleteDevice(name_);
+        return dm_.DeleteDeviceIfExists(name_);
     }
     const std::string& path() const { return path_; }
     const std::string& name() const { return name_; }
@@ -139,7 +137,6 @@ class SnapuserdTest : public ::testing::Test {
     void SetDeviceControlName();
     void InitDaemon();
     void CreateDmUserDevice();
-    void StartSnapuserdDaemon();
 
     unique_ptr<LoopDevice> base_loop_;
     unique_ptr<Tempdevice> dmuser_dev_;
@@ -149,9 +146,9 @@ class SnapuserdTest : public ::testing::Test {
 
     unique_fd base_fd_;
     std::unique_ptr<TemporaryFile> cow_system_;
-    std::unique_ptr<SnapuserdClient> client_;
     std::unique_ptr<uint8_t[]> orig_buffer_;
     std::unique_ptr<uint8_t[]> merged_buffer_;
+    SnapshotHandlerManager handlers_;
     bool setup_ok_ = false;
     bool merge_ok_ = false;
     size_t size_ = 100_MiB;
@@ -181,9 +178,9 @@ void SnapuserdTest::Shutdown() {
     ASSERT_TRUE(dmuser_dev_->Destroy());
 
     auto misc_device = "/dev/dm-user/" + system_device_ctrl_name_;
-    ASSERT_TRUE(client_->WaitForDeviceDelete(system_device_ctrl_name_));
+    ASSERT_TRUE(handlers_.DeleteHandler(system_device_ctrl_name_));
     ASSERT_TRUE(android::fs_mgr::WaitForFileDeleted(misc_device, 10s));
-    ASSERT_TRUE(client_->DetachSnapuserd());
+    handlers_.TerminateMergeThreads();
 }
 
 bool SnapuserdTest::SetupDefault() {
@@ -218,8 +215,6 @@ bool SnapuserdTest::SetupCopyOverlap_2() {
 bool SnapuserdTest::SetupDaemon() {
     SetDeviceControlName();
 
-    StartSnapuserdDaemon();
-
     CreateDmUserDevice();
     InitCowDevice();
     InitDaemon();
@@ -229,20 +224,6 @@ bool SnapuserdTest::SetupDaemon() {
     return setup_ok_;
 }
 
-void SnapuserdTest::StartSnapuserdDaemon() {
-    pid_t pid = fork();
-    ASSERT_GE(pid, 0);
-    if (pid == 0) {
-        std::string arg0 = "/system/bin/snapuserd";
-        std::string arg1 = "-socket="s + kSnapuserdSocketTest;
-        char* const argv[] = {arg0.data(), arg1.data(), nullptr};
-        ASSERT_GE(execv(arg0.c_str(), argv), 0);
-    } else {
-        client_ = SnapuserdClient::Connect(kSnapuserdSocketTest, 10s);
-        ASSERT_NE(client_, nullptr);
-    }
-}
-
 void SnapuserdTest::CreateBaseDevice() {
     unique_fd rnd_fd;
 
@@ -591,9 +572,17 @@ void SnapuserdTest::CreateCowDevice() {
 }
 
 void SnapuserdTest::InitCowDevice() {
-    uint64_t num_sectors = client_->InitDmUserCow(system_device_ctrl_name_, cow_system_->path,
-                                                  base_loop_->device(), base_loop_->device());
-    ASSERT_NE(num_sectors, 0);
+    bool use_iouring = true;
+    if (FLAGS_force_config == "iouring_disabled") {
+        use_iouring = false;
+    }
+
+    auto handler =
+            handlers_.AddHandler(system_device_ctrl_name_, cow_system_->path, base_loop_->device(),
+                                 base_loop_->device(), 1, use_iouring, false);
+    ASSERT_NE(handler, nullptr);
+    ASSERT_NE(handler->snapuserd(), nullptr);
+    ASSERT_NE(handler->snapuserd()->GetNumSectors(), 0);
 }
 
 void SnapuserdTest::SetDeviceControlName() {
@@ -631,13 +620,12 @@ void SnapuserdTest::CreateDmUserDevice() {
 }
 
 void SnapuserdTest::InitDaemon() {
-    bool ok = client_->AttachDmUser(system_device_ctrl_name_);
-    ASSERT_TRUE(ok);
+    ASSERT_TRUE(handlers_.StartHandler(system_device_ctrl_name_));
 }
 
 void SnapuserdTest::CheckMergeCompletion() {
     while (true) {
-        double percentage = client_->GetMergePercent();
+        double percentage = handlers_.GetMergePercentage();
         if ((int)percentage == 100) {
             break;
         }
@@ -652,8 +640,6 @@ void SnapuserdTest::SetupImpl() {
 
     SetDeviceControlName();
 
-    StartSnapuserdDaemon();
-
     CreateDmUserDevice();
     InitCowDevice();
     InitDaemon();
@@ -669,8 +655,7 @@ bool SnapuserdTest::Merge() {
 }
 
 void SnapuserdTest::StartMerge() {
-    bool ok = client_->InitiateMerge(system_device_ctrl_name_);
-    ASSERT_TRUE(ok);
+    ASSERT_TRUE(handlers_.InitiateMerge(system_device_ctrl_name_));
 }
 
 void SnapuserdTest::ValidateMerge() {
@@ -684,7 +669,6 @@ void SnapuserdTest::SimulateDaemonRestart() {
     Shutdown();
     std::this_thread::sleep_for(500ms);
     SetDeviceControlName();
-    StartSnapuserdDaemon();
     CreateDmUserDevice();
     InitCowDevice();
     InitDaemon();
@@ -844,20 +828,5 @@ int main(int argc, char** argv) {
 
     gflags::ParseCommandLineFlags(&argc, &argv, false);
 
-    android::base::SetProperty("ctl.stop", "snapuserd");
-
-    if (FLAGS_force_config == "iouring_disabled") {
-        if (!android::base::SetProperty("snapuserd.test.io_uring.force_disable", "1")) {
-            return testing::AssertionFailure()
-                   << "Failed to disable property: snapuserd.test.io_uring.disabled";
-        }
-    }
-
-    int ret = RUN_ALL_TESTS();
-
-    if (FLAGS_force_config == "iouring_disabled") {
-        android::base::SetProperty("snapuserd.test.io_uring.force_disable", "0");
-    }
-
-    return ret;
+    return RUN_ALL_TESTS();
 }

From 7445be510f4e782a1519116f60d0ddbce613e33c Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 14 Mar 2023 09:09:48 -0700
Subject: [PATCH 0199/1487] snapuserd: Remove DaemonOps.

These are only used for a single switch statement. Just compare the
input strings instead.

Bug: 269361087
Test: builds, ota applies
Ignore-AOSP-First: cherry-pick from aosp
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:f84f9c319e5a05fa6bfed9730ea6b9d28407a84b)
Merged-In: Ib90ae55309ea99c181585c64ed2ac814e5ed6c72
Change-Id: Ib90ae55309ea99c181585c64ed2ac814e5ed6c72
---
 .../user-space-merge/snapuserd_server.cpp     | 218 ++++++++----------
 .../user-space-merge/snapuserd_server.h       |  16 --
 2 files changed, 94 insertions(+), 140 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index cc8115f5f800..d87990aca2a8 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -45,22 +45,6 @@ using namespace std::string_literals;
 using android::base::borrowed_fd;
 using android::base::unique_fd;
 
-DaemonOps UserSnapshotServer::Resolveop(std::string& input) {
-    if (input == "init") return DaemonOps::INIT;
-    if (input == "start") return DaemonOps::START;
-    if (input == "stop") return DaemonOps::STOP;
-    if (input == "query") return DaemonOps::QUERY;
-    if (input == "delete") return DaemonOps::DELETE;
-    if (input == "detach") return DaemonOps::DETACH;
-    if (input == "supports") return DaemonOps::SUPPORTS;
-    if (input == "initiate_merge") return DaemonOps::INITIATE;
-    if (input == "merge_percent") return DaemonOps::PERCENTAGE;
-    if (input == "getstatus") return DaemonOps::GETSTATUS;
-    if (input == "update-verify") return DaemonOps::UPDATE_VERIFY;
-
-    return DaemonOps::INVALID;
-}
-
 UserSnapshotServer::UserSnapshotServer() {
     terminating_ = false;
     handlers_ = std::make_unique<SnapshotHandlerManager>();
@@ -132,132 +116,118 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
 
     std::vector<std::string> out;
     Parsemsg(str, delim, out);
-    DaemonOps op = Resolveop(out[0]);
-
-    switch (op) {
-        case DaemonOps::INIT: {
-            // Message format:
-            // init,<misc_name>,<cow_device_path>,<backing_device>,<base_path_merge>
-            //
-            // Reads the metadata and send the number of sectors
-            if (out.size() != 5) {
-                LOG(ERROR) << "Malformed init message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
 
-            auto handler = AddHandler(out[1], out[2], out[3], out[4]);
-            if (!handler) {
-                return Sendmsg(fd, "fail");
-            }
-
-            auto retval = "success," + std::to_string(handler->snapuserd()->GetNumSectors());
-            return Sendmsg(fd, retval);
+    const auto& cmd = out[0];
+    if (cmd == "init") {
+        // Message format:
+        // init,<misc_name>,<cow_device_path>,<backing_device>,<base_path_merge>
+        //
+        // Reads the metadata and send the number of sectors
+        if (out.size() != 5) {
+            LOG(ERROR) << "Malformed init message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::START: {
-            // Message format:
-            // start,<misc_name>
-            //
-            // Start the new thread which binds to dm-user misc device
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed start message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
 
-            if (!handlers_->StartHandler(out[1])) {
-                return Sendmsg(fd, "fail");
-            }
-            return Sendmsg(fd, "success");
-        }
-        case DaemonOps::STOP: {
-            // Message format: stop
-            //
-            // Stop all the threads gracefully and then shutdown the
-            // main thread
-            SetTerminating();
-            ShutdownThreads();
-            return true;
+        auto handler = AddHandler(out[1], out[2], out[3], out[4]);
+        if (!handler) {
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::QUERY: {
-            // Message format: query
-            //
-            // As part of transition, Second stage daemon will be
-            // created before terminating the first stage daemon. Hence,
-            // for a brief period client may have to distiguish between
-            // first stage daemon and second stage daemon.
-            //
-            // Second stage daemon is marked as active and hence will
-            // be ready to receive control message.
-            return Sendmsg(fd, GetDaemonStatus());
+
+        auto retval = "success," + std::to_string(handler->snapuserd()->GetNumSectors());
+        return Sendmsg(fd, retval);
+    } else if (cmd == "start") {
+        // Message format:
+        // start,<misc_name>
+        //
+        // Start the new thread which binds to dm-user misc device
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed start message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::DELETE: {
-            // Message format:
-            // delete,<misc_name>
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (!handlers_->DeleteHandler(out[1])) {
-                return Sendmsg(fd, "fail");
-            }
-            return Sendmsg(fd, "success");
+
+        if (!handlers_->StartHandler(out[1])) {
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::DETACH: {
-            handlers_->TerminateMergeThreads();
-            terminating_ = true;
-            return true;
+        return Sendmsg(fd, "success");
+    } else if (cmd == "stop") {
+        // Message format: stop
+        //
+        // Stop all the threads gracefully and then shutdown the
+        // main thread
+        SetTerminating();
+        ShutdownThreads();
+        return true;
+    } else if (cmd == "query") {
+        // Message format: query
+        //
+        // As part of transition, Second stage daemon will be
+        // created before terminating the first stage daemon. Hence,
+        // for a brief period client may have to distiguish between
+        // first stage daemon and second stage daemon.
+        //
+        // Second stage daemon is marked as active and hence will
+        // be ready to receive control message.
+        return Sendmsg(fd, GetDaemonStatus());
+    } else if (cmd == "delete") {
+        // Message format:
+        // delete,<misc_name>
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::SUPPORTS: {
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed supports message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (out[1] == "second_stage_socket_handoff") {
-                return Sendmsg(fd, "success");
-            }
+        if (!handlers_->DeleteHandler(out[1])) {
             return Sendmsg(fd, "fail");
         }
-        case DaemonOps::INITIATE: {
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed initiate-merge message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (out[0] == "initiate_merge") {
-                if (!handlers_->InitiateMerge(out[1])) {
-                    return Sendmsg(fd, "fail");
-                }
-                return Sendmsg(fd, "success");
-            }
+        return Sendmsg(fd, "success");
+    } else if (cmd == "detach") {
+        handlers_->TerminateMergeThreads();
+        terminating_ = true;
+        return true;
+    } else if (cmd == "supports") {
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed supports message, " << out.size() << " parts";
             return Sendmsg(fd, "fail");
         }
-        case DaemonOps::PERCENTAGE: {
-            double percentage = handlers_->GetMergePercentage();
-
-            return Sendmsg(fd, std::to_string(percentage));
+        if (out[1] == "second_stage_socket_handoff") {
+            return Sendmsg(fd, "success");
         }
-        case DaemonOps::GETSTATUS: {
-            // Message format:
-            // getstatus,<misc_name>
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
-                return Sendmsg(fd, "snapshot-merge-failed");
-            }
-            auto status = handlers_->GetMergeStatus(out[1]);
-            if (status.empty()) {
-                return Sendmsg(fd, "snapshot-merge-failed");
-            }
-            return Sendmsg(fd, status);
+        return Sendmsg(fd, "fail");
+    } else if (cmd == "initiate_merge") {
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed initiate-merge message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::UPDATE_VERIFY: {
-            if (!handlers_->GetVerificationStatus()) {
+        if (out[0] == "initiate_merge") {
+            if (!handlers_->InitiateMerge(out[1])) {
                 return Sendmsg(fd, "fail");
             }
             return Sendmsg(fd, "success");
         }
-        default: {
-            LOG(ERROR) << "Received unknown message type from client";
-            Sendmsg(fd, "fail");
-            return false;
+        return Sendmsg(fd, "fail");
+    } else if (cmd == "merge_percent") {
+        double percentage = handlers_->GetMergePercentage();
+        return Sendmsg(fd, std::to_string(percentage));
+    } else if (cmd == "getstatus") {
+        // Message format:
+        // getstatus,<misc_name>
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
+            return Sendmsg(fd, "snapshot-merge-failed");
+        }
+        auto status = handlers_->GetMergeStatus(out[1]);
+        if (status.empty()) {
+            return Sendmsg(fd, "snapshot-merge-failed");
         }
+        return Sendmsg(fd, status);
+    } else if (cmd == "update-verify") {
+        if (!handlers_->GetVerificationStatus()) {
+            return Sendmsg(fd, "fail");
+        }
+        return Sendmsg(fd, "success");
+    } else {
+        LOG(ERROR) << "Received unknown message type from client";
+        Sendmsg(fd, "fail");
+        return false;
     }
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index ae5190391dfa..988c01a99ba3 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -40,21 +40,6 @@ namespace snapshot {
 static constexpr uint32_t kMaxPacketSize = 512;
 static constexpr uint8_t kMaxMergeThreads = 2;
 
-enum class DaemonOps {
-    INIT,
-    START,
-    QUERY,
-    STOP,
-    DELETE,
-    DETACH,
-    SUPPORTS,
-    INITIATE,
-    PERCENTAGE,
-    GETSTATUS,
-    UPDATE_VERIFY,
-    INVALID,
-};
-
 class UserSnapshotServer {
   private:
     android::base::unique_fd sockfd_;
@@ -76,7 +61,6 @@ class UserSnapshotServer {
     bool Receivemsg(android::base::borrowed_fd fd, const std::string& str);
 
     void ShutdownThreads();
-    DaemonOps Resolveop(std::string& input);
     std::string GetDaemonStatus();
     void Parsemsg(std::string const& msg, const char delim, std::vector<std::string>& out);
 

From 54d326c5e090df2b5739bb09e2ebb37bf281f0ce Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 14 Mar 2023 10:57:47 -0700
Subject: [PATCH 0200/1487] snapuserd: Run snapuserd threads in-process.

This removes the temporary daemon and socket and instead directly embeds
SnapshotHandlerManager. We can also remove the test flags for io_uring
as with this they're no longer necessary.

Bug: 269361087
Test: snapuserd_test
Ignore-AOSP-First: cherry-pick from aosp
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:269e99f9558ae332e10329451fc51dc6698375a0)
Merged-In: I728186d9bc90c98fabd76d3f86569840488ada96
Change-Id: I728186d9bc90c98fabd76d3f86569840488ada96
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       | 15 ++--
 .../user-space-merge/handler_manager.cpp      |  3 +
 .../user-space-merge/snapuserd_core.cpp       |  5 --
 .../user-space-merge/snapuserd_server.cpp     |  3 -
 .../user-space-merge/snapuserd_test.cpp       | 75 ++++++-------------
 5 files changed, 33 insertions(+), 68 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 65f3d6d297ed..9fe567acbc7e 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -165,7 +165,7 @@ cc_binary {
 }
 
 cc_test {
-    name: "cow_snapuserd_test",
+    name: "snapuserd_test_legacy",
     defaults: [
         "fs_mgr_defaults",
         "libsnapshot_cow_defaults",
@@ -217,16 +217,17 @@ cc_test {
     ],
     static_libs: [
         "libbrotli",
-        "libgtest",
-        "libsnapshot_cow",
-        "libsnapshot_snapuserd",
         "libcutils_sockets",
-        "libz",
-        "libfs_mgr",
         "libdm",
         "libext4_utils",
-        "liburing",
+        "libfs_mgr",
         "libgflags",
+        "libgtest",
+        "libsnapshot_cow",
+        "libsnapshot_snapuserd",
+        "libsnapuserd",
+        "liburing",
+        "libz",
     ],
     include_dirs: ["bionic/libc/kernel"],
     header_libs: [
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index c5150c411d02..bdba5c0cc3ab 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -25,6 +25,9 @@ namespace snapshot {
 
 static constexpr uint8_t kMaxMergeThreads = 2;
 
+HandlerThread::HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd)
+    : snapuserd_(snapuserd), misc_name_(snapuserd_->GetMiscName()) {}
+
 void HandlerThread::FreeResources() {
     // Each worker thread holds a reference to snapuserd.
     // Clear them so that all the resources
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index c8a5cc584a28..8e1212b7b3ce 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -421,11 +421,6 @@ bool SnapshotHandler::IsIouringSupported() {
     struct utsname uts;
     unsigned int major, minor;
 
-    if (android::base::GetBoolProperty("snapuserd.test.io_uring.force_disable", false)) {
-        SNAP_LOG(INFO) << "io_uring disabled for testing";
-        return false;
-    }
-
     if ((uname(&uts) != 0) || (sscanf(uts.release, "%u.%u", &major, &minor) != 2)) {
         SNAP_LOG(ERROR) << "Could not parse the kernel version from uname. "
                         << " io_uring not supported";
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index d87990aca2a8..c953f1a053bd 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -83,9 +83,6 @@ void UserSnapshotServer::ShutdownThreads() {
     handlers_->JoinAllThreads();
 }
 
-HandlerThread::HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd)
-    : snapuserd_(snapuserd), misc_name_(snapuserd_->GetMiscName()) {}
-
 bool UserSnapshotServer::Sendmsg(android::base::borrowed_fd fd, const std::string& msg) {
     ssize_t ret = TEMP_FAILURE_RETRY(send(fd.get(), msg.data(), msg.size(), MSG_NOSIGNAL));
     if (ret < 0) {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index ef3689f61f6b..efe0c1443215 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -37,9 +37,9 @@
 #include <libdm/dm.h>
 #include <libdm/loop_control.h>
 #include <libsnapshot/cow_writer.h>
-#include <snapuserd/snapuserd_client.h>
 #include <storage_literals/storage_literals.h>
 
+#include "handler_manager.h"
 #include "snapuserd_core.h"
 
 DEFINE_string(force_config, "", "Force testing mode with iouring disabled");
@@ -54,8 +54,6 @@ using namespace std::chrono_literals;
 using namespace android::dm;
 using namespace std;
 
-static constexpr char kSnapuserdSocketTest[] = "snapuserdTest";
-
 class Tempdevice {
   public:
     Tempdevice(const std::string& name, const DmTable& table)
@@ -68,15 +66,15 @@ class Tempdevice {
     }
     ~Tempdevice() {
         if (valid_) {
-            dm_.DeleteDevice(name_);
+            dm_.DeleteDeviceIfExists(name_);
         }
     }
     bool Destroy() {
         if (!valid_) {
-            return false;
+            return true;
         }
         valid_ = false;
-        return dm_.DeleteDevice(name_);
+        return dm_.DeleteDeviceIfExists(name_);
     }
     const std::string& path() const { return path_; }
     const std::string& name() const { return name_; }
@@ -139,7 +137,6 @@ class SnapuserdTest : public ::testing::Test {
     void SetDeviceControlName();
     void InitDaemon();
     void CreateDmUserDevice();
-    void StartSnapuserdDaemon();
 
     unique_ptr<LoopDevice> base_loop_;
     unique_ptr<Tempdevice> dmuser_dev_;
@@ -149,9 +146,9 @@ class SnapuserdTest : public ::testing::Test {
 
     unique_fd base_fd_;
     std::unique_ptr<TemporaryFile> cow_system_;
-    std::unique_ptr<SnapuserdClient> client_;
     std::unique_ptr<uint8_t[]> orig_buffer_;
     std::unique_ptr<uint8_t[]> merged_buffer_;
+    SnapshotHandlerManager handlers_;
     bool setup_ok_ = false;
     bool merge_ok_ = false;
     size_t size_ = 100_MiB;
@@ -181,9 +178,9 @@ void SnapuserdTest::Shutdown() {
     ASSERT_TRUE(dmuser_dev_->Destroy());
 
     auto misc_device = "/dev/dm-user/" + system_device_ctrl_name_;
-    ASSERT_TRUE(client_->WaitForDeviceDelete(system_device_ctrl_name_));
+    ASSERT_TRUE(handlers_.DeleteHandler(system_device_ctrl_name_));
     ASSERT_TRUE(android::fs_mgr::WaitForFileDeleted(misc_device, 10s));
-    ASSERT_TRUE(client_->DetachSnapuserd());
+    handlers_.TerminateMergeThreads();
 }
 
 bool SnapuserdTest::SetupDefault() {
@@ -218,8 +215,6 @@ bool SnapuserdTest::SetupCopyOverlap_2() {
 bool SnapuserdTest::SetupDaemon() {
     SetDeviceControlName();
 
-    StartSnapuserdDaemon();
-
     CreateDmUserDevice();
     InitCowDevice();
     InitDaemon();
@@ -229,20 +224,6 @@ bool SnapuserdTest::SetupDaemon() {
     return setup_ok_;
 }
 
-void SnapuserdTest::StartSnapuserdDaemon() {
-    pid_t pid = fork();
-    ASSERT_GE(pid, 0);
-    if (pid == 0) {
-        std::string arg0 = "/system/bin/snapuserd";
-        std::string arg1 = "-socket="s + kSnapuserdSocketTest;
-        char* const argv[] = {arg0.data(), arg1.data(), nullptr};
-        ASSERT_GE(execv(arg0.c_str(), argv), 0);
-    } else {
-        client_ = SnapuserdClient::Connect(kSnapuserdSocketTest, 10s);
-        ASSERT_NE(client_, nullptr);
-    }
-}
-
 void SnapuserdTest::CreateBaseDevice() {
     unique_fd rnd_fd;
 
@@ -591,9 +572,17 @@ void SnapuserdTest::CreateCowDevice() {
 }
 
 void SnapuserdTest::InitCowDevice() {
-    uint64_t num_sectors = client_->InitDmUserCow(system_device_ctrl_name_, cow_system_->path,
-                                                  base_loop_->device(), base_loop_->device());
-    ASSERT_NE(num_sectors, 0);
+    bool use_iouring = true;
+    if (FLAGS_force_config == "iouring_disabled") {
+        use_iouring = false;
+    }
+
+    auto handler =
+            handlers_.AddHandler(system_device_ctrl_name_, cow_system_->path, base_loop_->device(),
+                                 base_loop_->device(), 1, use_iouring, false);
+    ASSERT_NE(handler, nullptr);
+    ASSERT_NE(handler->snapuserd(), nullptr);
+    ASSERT_NE(handler->snapuserd()->GetNumSectors(), 0);
 }
 
 void SnapuserdTest::SetDeviceControlName() {
@@ -631,13 +620,12 @@ void SnapuserdTest::CreateDmUserDevice() {
 }
 
 void SnapuserdTest::InitDaemon() {
-    bool ok = client_->AttachDmUser(system_device_ctrl_name_);
-    ASSERT_TRUE(ok);
+    ASSERT_TRUE(handlers_.StartHandler(system_device_ctrl_name_));
 }
 
 void SnapuserdTest::CheckMergeCompletion() {
     while (true) {
-        double percentage = client_->GetMergePercent();
+        double percentage = handlers_.GetMergePercentage();
         if ((int)percentage == 100) {
             break;
         }
@@ -652,8 +640,6 @@ void SnapuserdTest::SetupImpl() {
 
     SetDeviceControlName();
 
-    StartSnapuserdDaemon();
-
     CreateDmUserDevice();
     InitCowDevice();
     InitDaemon();
@@ -669,8 +655,7 @@ bool SnapuserdTest::Merge() {
 }
 
 void SnapuserdTest::StartMerge() {
-    bool ok = client_->InitiateMerge(system_device_ctrl_name_);
-    ASSERT_TRUE(ok);
+    ASSERT_TRUE(handlers_.InitiateMerge(system_device_ctrl_name_));
 }
 
 void SnapuserdTest::ValidateMerge() {
@@ -684,7 +669,6 @@ void SnapuserdTest::SimulateDaemonRestart() {
     Shutdown();
     std::this_thread::sleep_for(500ms);
     SetDeviceControlName();
-    StartSnapuserdDaemon();
     CreateDmUserDevice();
     InitCowDevice();
     InitDaemon();
@@ -844,20 +828,5 @@ int main(int argc, char** argv) {
 
     gflags::ParseCommandLineFlags(&argc, &argv, false);
 
-    android::base::SetProperty("ctl.stop", "snapuserd");
-
-    if (FLAGS_force_config == "iouring_disabled") {
-        if (!android::base::SetProperty("snapuserd.test.io_uring.force_disable", "1")) {
-            return testing::AssertionFailure()
-                   << "Failed to disable property: snapuserd.test.io_uring.disabled";
-        }
-    }
-
-    int ret = RUN_ALL_TESTS();
-
-    if (FLAGS_force_config == "iouring_disabled") {
-        android::base::SetProperty("snapuserd.test.io_uring.force_disable", "0");
-    }
-
-    return ret;
+    return RUN_ALL_TESTS();
 }

From 21089f8b46f5f415fb3944bf8e774f4d09cb3f5c Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 17 Feb 2023 01:20:52 -0800
Subject: [PATCH 0201/1487] snapuserd: Split the server into two classes.

This splits server into two classes: one that handles the IPC requests,
and one that managers snapshot handlers. This will allow embedding of
the snapshot handling code, without booting up a server. It'll also make
testing much easier.

The handler code has been further placed behind a virtual interface,
though this is likely unnecessary unless we start testing the server
logic itself (or attempt to unify the S and T+ versions of snapuserd).

Bug: 269361087
Test: ota
Ignore-AOSP-First: cherry-pick from aosp
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:8bb751dc8a1499f24add9e0831ab347feb2c3878)
Merged-In: I3ca3ad9c8c1fb910a1c7bf9f44165e2f44c930c9
Change-Id: I3ca3ad9c8c1fb910a1c7bf9f44165e2f44c930c9
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   1 +
 .../snapuserd/snapuserd_daemon.cpp            |   2 +-
 .../user-space-merge/handler_manager.cpp      | 371 ++++++++++++++++++
 .../user-space-merge/handler_manager.h        | 131 +++++++
 .../user-space-merge/snapuserd_server.cpp     | 338 +---------------
 .../user-space-merge/snapuserd_server.h       |  58 +--
 6 files changed, 526 insertions(+), 375 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index dd11a33daf28..65f3d6d297ed 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -62,6 +62,7 @@ cc_library_static {
         "dm-snapshot-merge/snapuserd_worker.cpp",
         "dm-snapshot-merge/snapuserd_readahead.cpp",
         "snapuserd_buffer.cpp",
+        "user-space-merge/handler_manager.cpp",
         "user-space-merge/snapuserd_core.cpp",
         "user-space-merge/snapuserd_dm_user.cpp",
         "user-space-merge/snapuserd_merge.cpp",
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
index ae20e1fa479e..36dad3343d3e 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
@@ -114,7 +114,7 @@ bool Daemon::StartServerForUserspaceSnapshots(int arg_start, int argc, char** ar
             return false;
         }
         auto handler = user_server_.AddHandler(parts[0], parts[1], parts[2], parts[3]);
-        if (!handler || !user_server_.StartHandler(handler)) {
+        if (!handler || !user_server_.StartHandler(parts[0])) {
             return false;
         }
     }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
new file mode 100644
index 000000000000..c5150c411d02
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -0,0 +1,371 @@
+// Copyright (C) 2023 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 "handler_manager.h"
+
+#include <sys/eventfd.h>
+
+#include <android-base/logging.h>
+
+#include "snapuserd_core.h"
+
+namespace android {
+namespace snapshot {
+
+static constexpr uint8_t kMaxMergeThreads = 2;
+
+void HandlerThread::FreeResources() {
+    // Each worker thread holds a reference to snapuserd.
+    // Clear them so that all the resources
+    // held by snapuserd is released
+    if (snapuserd_) {
+        snapuserd_->FreeResources();
+        snapuserd_ = nullptr;
+    }
+}
+
+SnapshotHandlerManager::SnapshotHandlerManager() {
+    monitor_merge_event_fd_.reset(eventfd(0, EFD_CLOEXEC));
+    if (monitor_merge_event_fd_ == -1) {
+        PLOG(FATAL) << "monitor_merge_event_fd_: failed to create eventfd";
+    }
+}
+
+std::shared_ptr<HandlerThread> SnapshotHandlerManager::AddHandler(
+        const std::string& misc_name, const std::string& cow_device_path,
+        const std::string& backing_device, const std::string& base_path_merge,
+        int num_worker_threads, bool use_iouring, bool perform_verification) {
+    auto snapuserd = std::make_shared<SnapshotHandler>(misc_name, cow_device_path, backing_device,
+                                                       base_path_merge, num_worker_threads,
+                                                       use_iouring, perform_verification);
+    if (!snapuserd->InitCowDevice()) {
+        LOG(ERROR) << "Failed to initialize Snapuserd";
+        return nullptr;
+    }
+
+    if (!snapuserd->InitializeWorkers()) {
+        LOG(ERROR) << "Failed to initialize workers";
+        return nullptr;
+    }
+
+    auto handler = std::make_shared<HandlerThread>(snapuserd);
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+        if (FindHandler(&lock, misc_name) != dm_users_.end()) {
+            LOG(ERROR) << "Handler already exists: " << misc_name;
+            return nullptr;
+        }
+        dm_users_.push_back(handler);
+    }
+    return handler;
+}
+
+bool SnapshotHandlerManager::StartHandler(const std::string& misc_name) {
+    std::lock_guard<std::mutex> lock(lock_);
+    auto iter = FindHandler(&lock, misc_name);
+    if (iter == dm_users_.end()) {
+        LOG(ERROR) << "Could not find handler: " << misc_name;
+        return false;
+    }
+    if (!(*iter)->snapuserd() || (*iter)->snapuserd()->IsAttached()) {
+        LOG(ERROR) << "Tried to re-attach control device: " << misc_name;
+        return false;
+    }
+    if (!StartHandler(*iter)) {
+        return false;
+    }
+    return true;
+}
+
+bool SnapshotHandlerManager::StartHandler(const std::shared_ptr<HandlerThread>& handler) {
+    if (handler->snapuserd()->IsAttached()) {
+        LOG(ERROR) << "Handler already attached";
+        return false;
+    }
+
+    handler->snapuserd()->AttachControlDevice();
+
+    handler->thread() = std::thread(std::bind(&SnapshotHandlerManager::RunThread, this, handler));
+    return true;
+}
+
+bool SnapshotHandlerManager::DeleteHandler(const std::string& misc_name) {
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+        auto iter = FindHandler(&lock, misc_name);
+        if (iter == dm_users_.end()) {
+            // After merge is completed, we swap dm-user table with
+            // the underlying dm-linear base device. Hence, worker
+            // threads would have terminted and was removed from
+            // the list.
+            LOG(DEBUG) << "Could not find handler: " << misc_name;
+            return true;
+        }
+
+        if (!(*iter)->ThreadTerminated()) {
+            (*iter)->snapuserd()->NotifyIOTerminated();
+        }
+    }
+    if (!RemoveAndJoinHandler(misc_name)) {
+        return false;
+    }
+    return true;
+}
+
+void SnapshotHandlerManager::RunThread(std::shared_ptr<HandlerThread> handler) {
+    LOG(INFO) << "Entering thread for handler: " << handler->misc_name();
+
+    if (!handler->snapuserd()->Start()) {
+        LOG(ERROR) << " Failed to launch all worker threads";
+    }
+
+    handler->snapuserd()->CloseFds();
+    bool merge_completed = handler->snapuserd()->CheckMergeCompletionStatus();
+    handler->snapuserd()->UnmapBufferRegion();
+
+    auto misc_name = handler->misc_name();
+    LOG(INFO) << "Handler thread about to exit: " << misc_name;
+
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+        if (merge_completed) {
+            num_partitions_merge_complete_ += 1;
+            active_merge_threads_ -= 1;
+            WakeupMonitorMergeThread();
+        }
+        handler->SetThreadTerminated();
+        auto iter = FindHandler(&lock, handler->misc_name());
+        if (iter == dm_users_.end()) {
+            // RemoveAndJoinHandler() already removed us from the list, and is
+            // now waiting on a join(), so just return. Additionally, release
+            // all the resources held by snapuserd object which are shared
+            // by worker threads. This should be done when the last reference
+            // of "handler" is released; but we will explicitly release here
+            // to make sure snapuserd object is freed as it is the biggest
+            // consumer of memory in the daemon.
+            handler->FreeResources();
+            LOG(INFO) << "Exiting handler thread to allow for join: " << misc_name;
+            return;
+        }
+
+        LOG(INFO) << "Exiting handler thread and freeing resources: " << misc_name;
+
+        if (handler->snapuserd()->IsAttached()) {
+            handler->thread().detach();
+        }
+
+        // Important: free resources within the lock. This ensures that if
+        // WaitForDelete() is called, the handler is either in the list, or
+        // it's not and its resources are guaranteed to be freed.
+        handler->FreeResources();
+        dm_users_.erase(iter);
+    }
+}
+
+bool SnapshotHandlerManager::InitiateMerge(const std::string& misc_name) {
+    std::lock_guard<std::mutex> lock(lock_);
+    auto iter = FindHandler(&lock, misc_name);
+    if (iter == dm_users_.end()) {
+        LOG(ERROR) << "Could not find handler: " << misc_name;
+        return false;
+    }
+
+    return StartMerge(&lock, *iter);
+}
+
+bool SnapshotHandlerManager::StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
+                                        const std::shared_ptr<HandlerThread>& handler) {
+    CHECK(proof_of_lock);
+
+    if (!handler->snapuserd()->IsAttached()) {
+        LOG(ERROR) << "Handler not attached to dm-user - Merge thread cannot be started";
+        return false;
+    }
+
+    handler->snapuserd()->MonitorMerge();
+
+    if (!is_merge_monitor_started_) {
+        std::thread(&SnapshotHandlerManager::MonitorMerge, this).detach();
+        is_merge_monitor_started_ = true;
+    }
+
+    merge_handlers_.push(handler);
+    WakeupMonitorMergeThread();
+    return true;
+}
+
+void SnapshotHandlerManager::WakeupMonitorMergeThread() {
+    uint64_t notify = 1;
+    ssize_t rc = TEMP_FAILURE_RETRY(write(monitor_merge_event_fd_.get(), &notify, sizeof(notify)));
+    if (rc < 0) {
+        PLOG(FATAL) << "failed to notify monitor merge thread";
+    }
+}
+
+void SnapshotHandlerManager::MonitorMerge() {
+    while (!stop_monitor_merge_thread_) {
+        uint64_t testVal;
+        ssize_t ret =
+                TEMP_FAILURE_RETRY(read(monitor_merge_event_fd_.get(), &testVal, sizeof(testVal)));
+        if (ret == -1) {
+            PLOG(FATAL) << "Failed to read from eventfd";
+        } else if (ret == 0) {
+            LOG(FATAL) << "Hit EOF on eventfd";
+        }
+
+        LOG(INFO) << "MonitorMerge: active-merge-threads: " << active_merge_threads_;
+        {
+            std::lock_guard<std::mutex> lock(lock_);
+            while (active_merge_threads_ < kMaxMergeThreads && merge_handlers_.size() > 0) {
+                auto handler = merge_handlers_.front();
+                merge_handlers_.pop();
+
+                if (!handler->snapuserd()) {
+                    LOG(INFO) << "MonitorMerge: skipping deleted handler: " << handler->misc_name();
+                    continue;
+                }
+
+                LOG(INFO) << "Starting merge for partition: "
+                          << handler->snapuserd()->GetMiscName();
+                handler->snapuserd()->InitiateMerge();
+                active_merge_threads_ += 1;
+            }
+        }
+    }
+
+    LOG(INFO) << "Exiting MonitorMerge: size: " << merge_handlers_.size();
+}
+
+std::string SnapshotHandlerManager::GetMergeStatus(const std::string& misc_name) {
+    std::lock_guard<std::mutex> lock(lock_);
+    auto iter = FindHandler(&lock, misc_name);
+    if (iter == dm_users_.end()) {
+        LOG(ERROR) << "Could not find handler: " << misc_name;
+        return {};
+    }
+
+    return (*iter)->snapuserd()->GetMergeStatus();
+}
+
+double SnapshotHandlerManager::GetMergePercentage() {
+    std::lock_guard<std::mutex> lock(lock_);
+
+    double percentage = 0.0;
+    int n = 0;
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        auto& th = (*iter)->thread();
+        if (th.joinable()) {
+            // Merge percentage by individual partitions wherein merge is still
+            // in-progress
+            percentage += (*iter)->snapuserd()->GetMergePercentage();
+            n += 1;
+        }
+    }
+
+    // Calculate final merge including those partitions where merge was already
+    // completed - num_partitions_merge_complete_ will track them when each
+    // thread exists in RunThread.
+    int total_partitions = n + num_partitions_merge_complete_;
+
+    if (total_partitions) {
+        percentage = ((num_partitions_merge_complete_ * 100.0) + percentage) / total_partitions;
+    }
+
+    LOG(DEBUG) << "Merge %: " << percentage
+               << " num_partitions_merge_complete_: " << num_partitions_merge_complete_
+               << " total_partitions: " << total_partitions << " n: " << n;
+    return percentage;
+}
+
+bool SnapshotHandlerManager::GetVerificationStatus() {
+    std::lock_guard<std::mutex> lock(lock_);
+
+    bool status = true;
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        auto& th = (*iter)->thread();
+        if (th.joinable() && status) {
+            status = (*iter)->snapuserd()->CheckPartitionVerification() && status;
+        } else {
+            // return immediately if there is a failure
+            return false;
+        }
+    }
+
+    return status;
+}
+
+bool SnapshotHandlerManager::RemoveAndJoinHandler(const std::string& misc_name) {
+    std::shared_ptr<HandlerThread> handler;
+    {
+        std::lock_guard<std::mutex> lock(lock_);
+
+        auto iter = FindHandler(&lock, misc_name);
+        if (iter == dm_users_.end()) {
+            // Client already deleted.
+            return true;
+        }
+        handler = std::move(*iter);
+        dm_users_.erase(iter);
+    }
+
+    auto& th = handler->thread();
+    if (th.joinable()) {
+        th.join();
+    }
+    return true;
+}
+
+void SnapshotHandlerManager::TerminateMergeThreads() {
+    std::lock_guard<std::mutex> guard(lock_);
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        if (!(*iter)->ThreadTerminated()) {
+            (*iter)->snapuserd()->NotifyIOTerminated();
+        }
+    }
+}
+
+void SnapshotHandlerManager::JoinAllThreads() {
+    // Acquire the thread list within the lock.
+    std::vector<std::shared_ptr<HandlerThread>> dm_users;
+    {
+        std::lock_guard<std::mutex> guard(lock_);
+        dm_users = std::move(dm_users_);
+    }
+
+    for (auto& client : dm_users) {
+        auto& th = client->thread();
+
+        if (th.joinable()) th.join();
+    }
+
+    stop_monitor_merge_thread_ = true;
+    WakeupMonitorMergeThread();
+}
+
+auto SnapshotHandlerManager::FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
+                                         const std::string& misc_name) -> HandlerList::iterator {
+    CHECK(proof_of_lock);
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        if ((*iter)->misc_name() == misc_name) {
+            return iter;
+        }
+    }
+    return dm_users_.end();
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
new file mode 100644
index 000000000000..b7ddac19f28a
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
@@ -0,0 +1,131 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <memory>
+#include <queue>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include <android-base/unique_fd.h>
+
+namespace android {
+namespace snapshot {
+
+class SnapshotHandler;
+
+class HandlerThread {
+  public:
+    explicit HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd);
+
+    void FreeResources();
+    const std::shared_ptr<SnapshotHandler>& snapuserd() const { return snapuserd_; }
+    std::thread& thread() { return thread_; }
+
+    const std::string& misc_name() const { return misc_name_; }
+    bool ThreadTerminated() { return thread_terminated_; }
+    void SetThreadTerminated() { thread_terminated_ = true; }
+
+  private:
+    std::thread thread_;
+    std::shared_ptr<SnapshotHandler> snapuserd_;
+    std::string misc_name_;
+    bool thread_terminated_ = false;
+};
+
+class ISnapshotHandlerManager {
+  public:
+    virtual ~ISnapshotHandlerManager() {}
+
+    // Add a new snapshot handler but do not start serving requests yet.
+    virtual std::shared_ptr<HandlerThread> AddHandler(const std::string& misc_name,
+                                                      const std::string& cow_device_path,
+                                                      const std::string& backing_device,
+                                                      const std::string& base_path_merge,
+                                                      int num_worker_threads, bool use_iouring,
+                                                      bool perform_verification) = 0;
+
+    // Start serving requests on a snapshot handler.
+    virtual bool StartHandler(const std::string& misc_name) = 0;
+
+    // Stop serving requests on a snapshot handler and remove it.
+    virtual bool DeleteHandler(const std::string& misc_name) = 0;
+
+    // Begin merging blocks on the given snapshot handler.
+    virtual bool InitiateMerge(const std::string& misc_name) = 0;
+
+    // Return a string containing a status code indicating the merge status
+    // on the handler. Returns empty on error.
+    virtual std::string GetMergeStatus(const std::string& misc_name) = 0;
+
+    // Wait until all handlers have terminated.
+    virtual void JoinAllThreads() = 0;
+
+    // Stop any in-progress merge threads.
+    virtual void TerminateMergeThreads() = 0;
+
+    // Returns the merge progress across all merging snapshot handlers.
+    virtual double GetMergePercentage() = 0;
+
+    // Returns whether all snapshots have verified.
+    virtual bool GetVerificationStatus() = 0;
+};
+
+class SnapshotHandlerManager final : public ISnapshotHandlerManager {
+  public:
+    SnapshotHandlerManager();
+    std::shared_ptr<HandlerThread> AddHandler(const std::string& misc_name,
+                                              const std::string& cow_device_path,
+                                              const std::string& backing_device,
+                                              const std::string& base_path_merge,
+                                              int num_worker_threads, bool use_iouring,
+                                              bool perform_verification) override;
+    bool StartHandler(const std::string& misc_name) override;
+    bool DeleteHandler(const std::string& misc_name) override;
+    bool InitiateMerge(const std::string& misc_name) override;
+    std::string GetMergeStatus(const std::string& misc_name) override;
+    void JoinAllThreads() override;
+    void TerminateMergeThreads() override;
+    double GetMergePercentage() override;
+    bool GetVerificationStatus() override;
+
+  private:
+    bool StartHandler(const std::shared_ptr<HandlerThread>& handler);
+    void RunThread(std::shared_ptr<HandlerThread> handler);
+    bool StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
+                    const std::shared_ptr<HandlerThread>& handler);
+    void MonitorMerge();
+    void WakeupMonitorMergeThread();
+    bool RemoveAndJoinHandler(const std::string& misc_name);
+
+    // Find a HandlerThread within a lock.
+    using HandlerList = std::vector<std::shared_ptr<HandlerThread>>;
+    HandlerList::iterator FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
+                                      const std::string& misc_name);
+
+    std::mutex lock_;
+    HandlerList dm_users_;
+
+    bool is_merge_monitor_started_ = false;
+    bool stop_monitor_merge_thread_ = false;
+    int active_merge_threads_ = 0;
+    int num_partitions_merge_complete_ = 0;
+    std::queue<std::shared_ptr<HandlerThread>> merge_handlers_;
+    android::base::unique_fd monitor_merge_event_fd_;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index b7ce2109adfe..cc8115f5f800 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -62,11 +62,8 @@ DaemonOps UserSnapshotServer::Resolveop(std::string& input) {
 }
 
 UserSnapshotServer::UserSnapshotServer() {
-    monitor_merge_event_fd_.reset(eventfd(0, EFD_CLOEXEC));
-    if (monitor_merge_event_fd_ == -1) {
-        PLOG(FATAL) << "monitor_merge_event_fd_: failed to create eventfd";
-    }
     terminating_ = false;
+    handlers_ = std::make_unique<SnapshotHandlerManager>();
 }
 
 UserSnapshotServer::~UserSnapshotServer() {
@@ -99,7 +96,7 @@ void UserSnapshotServer::Parsemsg(std::string const& msg, const char delim,
 
 void UserSnapshotServer::ShutdownThreads() {
     terminating_ = true;
-    JoinAllThreads();
+    handlers_->JoinAllThreads();
 }
 
 HandlerThread::HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd)
@@ -166,17 +163,7 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 return Sendmsg(fd, "fail");
             }
 
-            std::lock_guard<std::mutex> lock(lock_);
-            auto iter = FindHandler(&lock, out[1]);
-            if (iter == dm_users_.end()) {
-                LOG(ERROR) << "Could not find handler: " << out[1];
-                return Sendmsg(fd, "fail");
-            }
-            if (!(*iter)->snapuserd() || (*iter)->snapuserd()->IsAttached()) {
-                LOG(ERROR) << "Tried to re-attach control device: " << out[1];
-                return Sendmsg(fd, "fail");
-            }
-            if (!StartHandler(*iter)) {
+            if (!handlers_->StartHandler(out[1])) {
                 return Sendmsg(fd, "fail");
             }
             return Sendmsg(fd, "success");
@@ -209,30 +196,13 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
                 return Sendmsg(fd, "fail");
             }
-            {
-                std::lock_guard<std::mutex> lock(lock_);
-                auto iter = FindHandler(&lock, out[1]);
-                if (iter == dm_users_.end()) {
-                    // After merge is completed, we swap dm-user table with
-                    // the underlying dm-linear base device. Hence, worker
-                    // threads would have terminted and was removed from
-                    // the list.
-                    LOG(DEBUG) << "Could not find handler: " << out[1];
-                    return Sendmsg(fd, "success");
-                }
-
-                if (!(*iter)->ThreadTerminated()) {
-                    (*iter)->snapuserd()->NotifyIOTerminated();
-                }
-            }
-            if (!RemoveAndJoinHandler(out[1])) {
+            if (!handlers_->DeleteHandler(out[1])) {
                 return Sendmsg(fd, "fail");
             }
             return Sendmsg(fd, "success");
         }
         case DaemonOps::DETACH: {
-            std::lock_guard<std::mutex> lock(lock_);
-            TerminateMergeThreads(&lock);
+            handlers_->TerminateMergeThreads();
             terminating_ = true;
             return true;
         }
@@ -252,24 +222,15 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 return Sendmsg(fd, "fail");
             }
             if (out[0] == "initiate_merge") {
-                std::lock_guard<std::mutex> lock(lock_);
-                auto iter = FindHandler(&lock, out[1]);
-                if (iter == dm_users_.end()) {
-                    LOG(ERROR) << "Could not find handler: " << out[1];
+                if (!handlers_->InitiateMerge(out[1])) {
                     return Sendmsg(fd, "fail");
                 }
-
-                if (!StartMerge(&lock, *iter)) {
-                    return Sendmsg(fd, "fail");
-                }
-
                 return Sendmsg(fd, "success");
             }
             return Sendmsg(fd, "fail");
         }
         case DaemonOps::PERCENTAGE: {
-            std::lock_guard<std::mutex> lock(lock_);
-            double percentage = GetMergePercentage(&lock);
+            double percentage = handlers_->GetMergePercentage();
 
             return Sendmsg(fd, std::to_string(percentage));
         }
@@ -280,24 +241,16 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
                 LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
                 return Sendmsg(fd, "snapshot-merge-failed");
             }
-            {
-                std::lock_guard<std::mutex> lock(lock_);
-                auto iter = FindHandler(&lock, out[1]);
-                if (iter == dm_users_.end()) {
-                    LOG(ERROR) << "Could not find handler: " << out[1];
-                    return Sendmsg(fd, "snapshot-merge-failed");
-                }
-
-                std::string merge_status = GetMergeStatus(*iter);
-                return Sendmsg(fd, merge_status);
+            auto status = handlers_->GetMergeStatus(out[1]);
+            if (status.empty()) {
+                return Sendmsg(fd, "snapshot-merge-failed");
             }
+            return Sendmsg(fd, status);
         }
         case DaemonOps::UPDATE_VERIFY: {
-            std::lock_guard<std::mutex> lock(lock_);
-            if (!UpdateVerification(&lock)) {
+            if (!handlers_->GetVerificationStatus()) {
                 return Sendmsg(fd, "fail");
             }
-
             return Sendmsg(fd, "success");
         }
         default: {
@@ -308,56 +261,6 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
     }
 }
 
-void UserSnapshotServer::RunThread(std::shared_ptr<HandlerThread> handler) {
-    LOG(INFO) << "Entering thread for handler: " << handler->misc_name();
-
-    if (!handler->snapuserd()->Start()) {
-        LOG(ERROR) << " Failed to launch all worker threads";
-    }
-
-    handler->snapuserd()->CloseFds();
-    bool merge_completed = handler->snapuserd()->CheckMergeCompletionStatus();
-    handler->snapuserd()->UnmapBufferRegion();
-
-    auto misc_name = handler->misc_name();
-    LOG(INFO) << "Handler thread about to exit: " << misc_name;
-
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        if (merge_completed) {
-            num_partitions_merge_complete_ += 1;
-            active_merge_threads_ -= 1;
-            WakeupMonitorMergeThread();
-        }
-        handler->SetThreadTerminated();
-        auto iter = FindHandler(&lock, handler->misc_name());
-        if (iter == dm_users_.end()) {
-            // RemoveAndJoinHandler() already removed us from the list, and is
-            // now waiting on a join(), so just return. Additionally, release
-            // all the resources held by snapuserd object which are shared
-            // by worker threads. This should be done when the last reference
-            // of "handler" is released; but we will explicitly release here
-            // to make sure snapuserd object is freed as it is the biggest
-            // consumer of memory in the daemon.
-            handler->FreeResources();
-            LOG(INFO) << "Exiting handler thread to allow for join: " << misc_name;
-            return;
-        }
-
-        LOG(INFO) << "Exiting handler thread and freeing resources: " << misc_name;
-
-        if (handler->snapuserd()->IsAttached()) {
-            handler->thread().detach();
-        }
-
-        // Important: free resources within the lock. This ensures that if
-        // WaitForDelete() is called, the handler is either in the list, or
-        // it's not and its resources are guaranteed to be freed.
-        handler->FreeResources();
-        dm_users_.erase(iter);
-    }
-}
-
 bool UserSnapshotServer::Start(const std::string& socketname) {
     bool start_listening = true;
 
@@ -423,28 +326,10 @@ bool UserSnapshotServer::Run() {
         }
     }
 
-    JoinAllThreads();
+    handlers_->JoinAllThreads();
     return true;
 }
 
-void UserSnapshotServer::JoinAllThreads() {
-    // Acquire the thread list within the lock.
-    std::vector<std::shared_ptr<HandlerThread>> dm_users;
-    {
-        std::lock_guard<std::mutex> guard(lock_);
-        dm_users = std::move(dm_users_);
-    }
-
-    for (auto& client : dm_users) {
-        auto& th = client->thread();
-
-        if (th.joinable()) th.join();
-    }
-
-    stop_monitor_merge_thread_ = true;
-    WakeupMonitorMergeThread();
-}
-
 void UserSnapshotServer::AddWatchedFd(android::base::borrowed_fd fd, int events) {
     struct pollfd p = {};
     p.fd = fd.get();
@@ -506,185 +391,13 @@ std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string&
         perform_verification = false;
     }
 
-    auto snapuserd = std::make_shared<SnapshotHandler>(misc_name, cow_device_path, backing_device,
-                                                       base_path_merge, num_worker_threads,
-                                                       io_uring_enabled_, perform_verification);
-    if (!snapuserd->InitCowDevice()) {
-        LOG(ERROR) << "Failed to initialize Snapuserd";
-        return nullptr;
-    }
-
-    if (!snapuserd->InitializeWorkers()) {
-        LOG(ERROR) << "Failed to initialize workers";
-        return nullptr;
-    }
-
-    auto handler = std::make_shared<HandlerThread>(snapuserd);
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        if (FindHandler(&lock, misc_name) != dm_users_.end()) {
-            LOG(ERROR) << "Handler already exists: " << misc_name;
-            return nullptr;
-        }
-        dm_users_.push_back(handler);
-    }
-    return handler;
-}
-
-bool UserSnapshotServer::StartHandler(const std::shared_ptr<HandlerThread>& handler) {
-    if (handler->snapuserd()->IsAttached()) {
-        LOG(ERROR) << "Handler already attached";
-        return false;
-    }
-
-    handler->snapuserd()->AttachControlDevice();
-
-    handler->thread() = std::thread(std::bind(&UserSnapshotServer::RunThread, this, handler));
-    return true;
-}
-
-bool UserSnapshotServer::StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
-                                    const std::shared_ptr<HandlerThread>& handler) {
-    CHECK(proof_of_lock);
-
-    if (!handler->snapuserd()->IsAttached()) {
-        LOG(ERROR) << "Handler not attached to dm-user - Merge thread cannot be started";
-        return false;
-    }
-
-    handler->snapuserd()->MonitorMerge();
-
-    if (!is_merge_monitor_started_.has_value()) {
-        std::thread(&UserSnapshotServer::MonitorMerge, this).detach();
-        is_merge_monitor_started_ = true;
-    }
-
-    merge_handlers_.push(handler);
-    WakeupMonitorMergeThread();
-    return true;
-}
-
-auto UserSnapshotServer::FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
-                                     const std::string& misc_name) -> HandlerList::iterator {
-    CHECK(proof_of_lock);
-
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        if ((*iter)->misc_name() == misc_name) {
-            return iter;
-        }
-    }
-    return dm_users_.end();
-}
-
-void UserSnapshotServer::TerminateMergeThreads(std::lock_guard<std::mutex>* proof_of_lock) {
-    CHECK(proof_of_lock);
-
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        if (!(*iter)->ThreadTerminated()) {
-            (*iter)->snapuserd()->NotifyIOTerminated();
-        }
-    }
-}
-
-std::string UserSnapshotServer::GetMergeStatus(const std::shared_ptr<HandlerThread>& handler) {
-    return handler->snapuserd()->GetMergeStatus();
-}
-
-double UserSnapshotServer::GetMergePercentage(std::lock_guard<std::mutex>* proof_of_lock) {
-    CHECK(proof_of_lock);
-    double percentage = 0.0;
-    int n = 0;
-
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        auto& th = (*iter)->thread();
-        if (th.joinable()) {
-            // Merge percentage by individual partitions wherein merge is still
-            // in-progress
-            percentage += (*iter)->snapuserd()->GetMergePercentage();
-            n += 1;
-        }
-    }
-
-    // Calculate final merge including those partitions where merge was already
-    // completed - num_partitions_merge_complete_ will track them when each
-    // thread exists in RunThread.
-    int total_partitions = n + num_partitions_merge_complete_;
-
-    if (total_partitions) {
-        percentage = ((num_partitions_merge_complete_ * 100.0) + percentage) / total_partitions;
-    }
-
-    LOG(DEBUG) << "Merge %: " << percentage
-               << " num_partitions_merge_complete_: " << num_partitions_merge_complete_
-               << " total_partitions: " << total_partitions << " n: " << n;
-    return percentage;
-}
-
-bool UserSnapshotServer::RemoveAndJoinHandler(const std::string& misc_name) {
-    std::shared_ptr<HandlerThread> handler;
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-
-        auto iter = FindHandler(&lock, misc_name);
-        if (iter == dm_users_.end()) {
-            // Client already deleted.
-            return true;
-        }
-        handler = std::move(*iter);
-        dm_users_.erase(iter);
-    }
-
-    auto& th = handler->thread();
-    if (th.joinable()) {
-        th.join();
-    }
-    return true;
-}
-
-void UserSnapshotServer::WakeupMonitorMergeThread() {
-    uint64_t notify = 1;
-    ssize_t rc = TEMP_FAILURE_RETRY(write(monitor_merge_event_fd_.get(), &notify, sizeof(notify)));
-    if (rc < 0) {
-        PLOG(FATAL) << "failed to notify monitor merge thread";
-    }
-}
-
-void UserSnapshotServer::MonitorMerge() {
-    while (!stop_monitor_merge_thread_) {
-        uint64_t testVal;
-        ssize_t ret =
-                TEMP_FAILURE_RETRY(read(monitor_merge_event_fd_.get(), &testVal, sizeof(testVal)));
-        if (ret == -1) {
-            PLOG(FATAL) << "Failed to read from eventfd";
-        } else if (ret == 0) {
-            LOG(FATAL) << "Hit EOF on eventfd";
-        }
-
-        LOG(INFO) << "MonitorMerge: active-merge-threads: " << active_merge_threads_;
-        {
-            std::lock_guard<std::mutex> lock(lock_);
-            while (active_merge_threads_ < kMaxMergeThreads && merge_handlers_.size() > 0) {
-                auto handler = merge_handlers_.front();
-                merge_handlers_.pop();
-
-                if (!handler->snapuserd()) {
-                    LOG(INFO) << "MonitorMerge: skipping deleted handler: " << handler->misc_name();
-                    continue;
-                }
-
-                LOG(INFO) << "Starting merge for partition: "
-                          << handler->snapuserd()->GetMiscName();
-                handler->snapuserd()->InitiateMerge();
-                active_merge_threads_ += 1;
-            }
-        }
-    }
-
-    LOG(INFO) << "Exiting MonitorMerge: size: " << merge_handlers_.size();
+    return handlers_->AddHandler(misc_name, cow_device_path, backing_device, base_path_merge,
+                                 num_worker_threads, io_uring_enabled_, perform_verification);
 }
 
 bool UserSnapshotServer::WaitForSocket() {
-    auto scope_guard = android::base::make_scope_guard([this]() -> void { JoinAllThreads(); });
+    auto scope_guard =
+            android::base::make_scope_guard([this]() -> void { handlers_->JoinAllThreads(); });
 
     auto socket_path = ANDROID_SOCKET_DIR "/"s + kSnapuserdSocketProxy;
 
@@ -781,21 +494,8 @@ bool UserSnapshotServer::RunForSocketHandoff() {
     return true;
 }
 
-bool UserSnapshotServer::UpdateVerification(std::lock_guard<std::mutex>* proof_of_lock) {
-    CHECK(proof_of_lock);
-
-    bool status = true;
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        auto& th = (*iter)->thread();
-        if (th.joinable() && status) {
-            status = (*iter)->snapuserd()->CheckPartitionVerification() && status;
-        } else {
-            // return immediately if there is a failure
-            return false;
-        }
-    }
-
-    return status;
+bool UserSnapshotServer::StartHandler(const std::string& misc_name) {
+    return handlers_->StartHandler(misc_name);
 }
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index 12c3903c495c..ae5190391dfa 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -31,6 +31,7 @@
 #include <vector>
 
 #include <android-base/unique_fd.h>
+#include "handler_manager.h"
 #include "snapuserd_core.h"
 
 namespace android {
@@ -54,33 +55,6 @@ enum class DaemonOps {
     INVALID,
 };
 
-class HandlerThread {
-  public:
-    explicit HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd);
-
-    void FreeResources() {
-        // Each worker thread holds a reference to snapuserd.
-        // Clear them so that all the resources
-        // held by snapuserd is released
-        if (snapuserd_) {
-            snapuserd_->FreeResources();
-            snapuserd_ = nullptr;
-        }
-    }
-    const std::shared_ptr<SnapshotHandler>& snapuserd() const { return snapuserd_; }
-    std::thread& thread() { return thread_; }
-
-    const std::string& misc_name() const { return misc_name_; }
-    bool ThreadTerminated() { return thread_terminated_; }
-    void SetThreadTerminated() { thread_terminated_ = true; }
-
-  private:
-    std::thread thread_;
-    std::shared_ptr<SnapshotHandler> snapuserd_;
-    std::string misc_name_;
-    bool thread_terminated_ = false;
-};
-
 class UserSnapshotServer {
   private:
     android::base::unique_fd sockfd_;
@@ -88,21 +62,12 @@ class UserSnapshotServer {
     volatile bool received_socket_signal_ = false;
     std::vector<struct pollfd> watched_fds_;
     bool is_socket_present_ = false;
-    int num_partitions_merge_complete_ = 0;
-    int active_merge_threads_ = 0;
-    bool stop_monitor_merge_thread_ = false;
     bool is_server_running_ = false;
     bool io_uring_enabled_ = false;
-    std::optional<bool> is_merge_monitor_started_;
-
-    android::base::unique_fd monitor_merge_event_fd_;
+    std::unique_ptr<ISnapshotHandlerManager> handlers_;
 
     std::mutex lock_;
 
-    using HandlerList = std::vector<std::shared_ptr<HandlerThread>>;
-    HandlerList dm_users_;
-    std::queue<std::shared_ptr<HandlerThread>> merge_handlers_;
-
     void AddWatchedFd(android::base::borrowed_fd fd, int events);
     void AcceptClient();
     bool HandleClient(android::base::borrowed_fd fd, int revents);
@@ -111,28 +76,15 @@ class UserSnapshotServer {
     bool Receivemsg(android::base::borrowed_fd fd, const std::string& str);
 
     void ShutdownThreads();
-    bool RemoveAndJoinHandler(const std::string& control_device);
     DaemonOps Resolveop(std::string& input);
     std::string GetDaemonStatus();
     void Parsemsg(std::string const& msg, const char delim, std::vector<std::string>& out);
 
     bool IsTerminating() { return terminating_; }
 
-    void RunThread(std::shared_ptr<HandlerThread> handler);
-    void MonitorMerge();
-
     void JoinAllThreads();
     bool StartWithSocket(bool start_listening);
 
-    // Find a HandlerThread within a lock.
-    HandlerList::iterator FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
-                                      const std::string& misc_name);
-
-    double GetMergePercentage(std::lock_guard<std::mutex>* proof_of_lock);
-    void TerminateMergeThreads(std::lock_guard<std::mutex>* proof_of_lock);
-
-    bool UpdateVerification(std::lock_guard<std::mutex>* proof_of_lock);
-
   public:
     UserSnapshotServer();
     ~UserSnapshotServer();
@@ -147,12 +99,8 @@ class UserSnapshotServer {
                                               const std::string& cow_device_path,
                                               const std::string& backing_device,
                                               const std::string& base_path_merge);
-    bool StartHandler(const std::shared_ptr<HandlerThread>& handler);
-    bool StartMerge(std::lock_guard<std::mutex>* proof_of_lock,
-                    const std::shared_ptr<HandlerThread>& handler);
-    std::string GetMergeStatus(const std::shared_ptr<HandlerThread>& handler);
+    bool StartHandler(const std::string& misc_name);
 
-    void WakeupMonitorMergeThread();
     void SetTerminating() { terminating_ = true; }
     void ReceivedSocketSignal() { received_socket_signal_ = true; }
     void SetServerRunning() { is_server_running_ = true; }

From 338c3ae0712be50a66e3beb2c142921434d0d509 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 14 Mar 2023 09:09:48 -0700
Subject: [PATCH 0202/1487] snapuserd: Remove DaemonOps.

These are only used for a single switch statement. Just compare the
input strings instead.

Bug: 269361087
Test: builds, ota applies
Ignore-AOSP-First: cherry-pick from aosp
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:f84f9c319e5a05fa6bfed9730ea6b9d28407a84b)
Merged-In: Ib90ae55309ea99c181585c64ed2ac814e5ed6c72
Change-Id: Ib90ae55309ea99c181585c64ed2ac814e5ed6c72
---
 .../user-space-merge/snapuserd_server.cpp     | 218 ++++++++----------
 .../user-space-merge/snapuserd_server.h       |  16 --
 2 files changed, 94 insertions(+), 140 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index cc8115f5f800..d87990aca2a8 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -45,22 +45,6 @@ using namespace std::string_literals;
 using android::base::borrowed_fd;
 using android::base::unique_fd;
 
-DaemonOps UserSnapshotServer::Resolveop(std::string& input) {
-    if (input == "init") return DaemonOps::INIT;
-    if (input == "start") return DaemonOps::START;
-    if (input == "stop") return DaemonOps::STOP;
-    if (input == "query") return DaemonOps::QUERY;
-    if (input == "delete") return DaemonOps::DELETE;
-    if (input == "detach") return DaemonOps::DETACH;
-    if (input == "supports") return DaemonOps::SUPPORTS;
-    if (input == "initiate_merge") return DaemonOps::INITIATE;
-    if (input == "merge_percent") return DaemonOps::PERCENTAGE;
-    if (input == "getstatus") return DaemonOps::GETSTATUS;
-    if (input == "update-verify") return DaemonOps::UPDATE_VERIFY;
-
-    return DaemonOps::INVALID;
-}
-
 UserSnapshotServer::UserSnapshotServer() {
     terminating_ = false;
     handlers_ = std::make_unique<SnapshotHandlerManager>();
@@ -132,132 +116,118 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
 
     std::vector<std::string> out;
     Parsemsg(str, delim, out);
-    DaemonOps op = Resolveop(out[0]);
-
-    switch (op) {
-        case DaemonOps::INIT: {
-            // Message format:
-            // init,<misc_name>,<cow_device_path>,<backing_device>,<base_path_merge>
-            //
-            // Reads the metadata and send the number of sectors
-            if (out.size() != 5) {
-                LOG(ERROR) << "Malformed init message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
 
-            auto handler = AddHandler(out[1], out[2], out[3], out[4]);
-            if (!handler) {
-                return Sendmsg(fd, "fail");
-            }
-
-            auto retval = "success," + std::to_string(handler->snapuserd()->GetNumSectors());
-            return Sendmsg(fd, retval);
+    const auto& cmd = out[0];
+    if (cmd == "init") {
+        // Message format:
+        // init,<misc_name>,<cow_device_path>,<backing_device>,<base_path_merge>
+        //
+        // Reads the metadata and send the number of sectors
+        if (out.size() != 5) {
+            LOG(ERROR) << "Malformed init message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::START: {
-            // Message format:
-            // start,<misc_name>
-            //
-            // Start the new thread which binds to dm-user misc device
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed start message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
 
-            if (!handlers_->StartHandler(out[1])) {
-                return Sendmsg(fd, "fail");
-            }
-            return Sendmsg(fd, "success");
-        }
-        case DaemonOps::STOP: {
-            // Message format: stop
-            //
-            // Stop all the threads gracefully and then shutdown the
-            // main thread
-            SetTerminating();
-            ShutdownThreads();
-            return true;
+        auto handler = AddHandler(out[1], out[2], out[3], out[4]);
+        if (!handler) {
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::QUERY: {
-            // Message format: query
-            //
-            // As part of transition, Second stage daemon will be
-            // created before terminating the first stage daemon. Hence,
-            // for a brief period client may have to distiguish between
-            // first stage daemon and second stage daemon.
-            //
-            // Second stage daemon is marked as active and hence will
-            // be ready to receive control message.
-            return Sendmsg(fd, GetDaemonStatus());
+
+        auto retval = "success," + std::to_string(handler->snapuserd()->GetNumSectors());
+        return Sendmsg(fd, retval);
+    } else if (cmd == "start") {
+        // Message format:
+        // start,<misc_name>
+        //
+        // Start the new thread which binds to dm-user misc device
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed start message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::DELETE: {
-            // Message format:
-            // delete,<misc_name>
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (!handlers_->DeleteHandler(out[1])) {
-                return Sendmsg(fd, "fail");
-            }
-            return Sendmsg(fd, "success");
+
+        if (!handlers_->StartHandler(out[1])) {
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::DETACH: {
-            handlers_->TerminateMergeThreads();
-            terminating_ = true;
-            return true;
+        return Sendmsg(fd, "success");
+    } else if (cmd == "stop") {
+        // Message format: stop
+        //
+        // Stop all the threads gracefully and then shutdown the
+        // main thread
+        SetTerminating();
+        ShutdownThreads();
+        return true;
+    } else if (cmd == "query") {
+        // Message format: query
+        //
+        // As part of transition, Second stage daemon will be
+        // created before terminating the first stage daemon. Hence,
+        // for a brief period client may have to distiguish between
+        // first stage daemon and second stage daemon.
+        //
+        // Second stage daemon is marked as active and hence will
+        // be ready to receive control message.
+        return Sendmsg(fd, GetDaemonStatus());
+    } else if (cmd == "delete") {
+        // Message format:
+        // delete,<misc_name>
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::SUPPORTS: {
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed supports message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (out[1] == "second_stage_socket_handoff") {
-                return Sendmsg(fd, "success");
-            }
+        if (!handlers_->DeleteHandler(out[1])) {
             return Sendmsg(fd, "fail");
         }
-        case DaemonOps::INITIATE: {
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed initiate-merge message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (out[0] == "initiate_merge") {
-                if (!handlers_->InitiateMerge(out[1])) {
-                    return Sendmsg(fd, "fail");
-                }
-                return Sendmsg(fd, "success");
-            }
+        return Sendmsg(fd, "success");
+    } else if (cmd == "detach") {
+        handlers_->TerminateMergeThreads();
+        terminating_ = true;
+        return true;
+    } else if (cmd == "supports") {
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed supports message, " << out.size() << " parts";
             return Sendmsg(fd, "fail");
         }
-        case DaemonOps::PERCENTAGE: {
-            double percentage = handlers_->GetMergePercentage();
-
-            return Sendmsg(fd, std::to_string(percentage));
+        if (out[1] == "second_stage_socket_handoff") {
+            return Sendmsg(fd, "success");
         }
-        case DaemonOps::GETSTATUS: {
-            // Message format:
-            // getstatus,<misc_name>
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
-                return Sendmsg(fd, "snapshot-merge-failed");
-            }
-            auto status = handlers_->GetMergeStatus(out[1]);
-            if (status.empty()) {
-                return Sendmsg(fd, "snapshot-merge-failed");
-            }
-            return Sendmsg(fd, status);
+        return Sendmsg(fd, "fail");
+    } else if (cmd == "initiate_merge") {
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed initiate-merge message, " << out.size() << " parts";
+            return Sendmsg(fd, "fail");
         }
-        case DaemonOps::UPDATE_VERIFY: {
-            if (!handlers_->GetVerificationStatus()) {
+        if (out[0] == "initiate_merge") {
+            if (!handlers_->InitiateMerge(out[1])) {
                 return Sendmsg(fd, "fail");
             }
             return Sendmsg(fd, "success");
         }
-        default: {
-            LOG(ERROR) << "Received unknown message type from client";
-            Sendmsg(fd, "fail");
-            return false;
+        return Sendmsg(fd, "fail");
+    } else if (cmd == "merge_percent") {
+        double percentage = handlers_->GetMergePercentage();
+        return Sendmsg(fd, std::to_string(percentage));
+    } else if (cmd == "getstatus") {
+        // Message format:
+        // getstatus,<misc_name>
+        if (out.size() != 2) {
+            LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
+            return Sendmsg(fd, "snapshot-merge-failed");
+        }
+        auto status = handlers_->GetMergeStatus(out[1]);
+        if (status.empty()) {
+            return Sendmsg(fd, "snapshot-merge-failed");
         }
+        return Sendmsg(fd, status);
+    } else if (cmd == "update-verify") {
+        if (!handlers_->GetVerificationStatus()) {
+            return Sendmsg(fd, "fail");
+        }
+        return Sendmsg(fd, "success");
+    } else {
+        LOG(ERROR) << "Received unknown message type from client";
+        Sendmsg(fd, "fail");
+        return false;
     }
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index ae5190391dfa..988c01a99ba3 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -40,21 +40,6 @@ namespace snapshot {
 static constexpr uint32_t kMaxPacketSize = 512;
 static constexpr uint8_t kMaxMergeThreads = 2;
 
-enum class DaemonOps {
-    INIT,
-    START,
-    QUERY,
-    STOP,
-    DELETE,
-    DETACH,
-    SUPPORTS,
-    INITIATE,
-    PERCENTAGE,
-    GETSTATUS,
-    UPDATE_VERIFY,
-    INVALID,
-};
-
 class UserSnapshotServer {
   private:
     android::base::unique_fd sockfd_;
@@ -76,7 +61,6 @@ class UserSnapshotServer {
     bool Receivemsg(android::base::borrowed_fd fd, const std::string& str);
 
     void ShutdownThreads();
-    DaemonOps Resolveop(std::string& input);
     std::string GetDaemonStatus();
     void Parsemsg(std::string const& msg, const char delim, std::vector<std::string>& out);
 

From 329fef34a546f0ea2da869c75e3eb750a1aed486 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 14 Mar 2023 10:57:47 -0700
Subject: [PATCH 0203/1487] snapuserd: Run snapuserd threads in-process.

This removes the temporary daemon and socket and instead directly embeds
SnapshotHandlerManager. We can also remove the test flags for io_uring
as with this they're no longer necessary.

Bug: 269361087
Test: snapuserd_test
Ignore-AOSP-First: cherry-pick from aosp
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:269e99f9558ae332e10329451fc51dc6698375a0)
Merged-In: I728186d9bc90c98fabd76d3f86569840488ada96
Change-Id: I728186d9bc90c98fabd76d3f86569840488ada96
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       | 15 ++--
 .../user-space-merge/handler_manager.cpp      |  3 +
 .../user-space-merge/snapuserd_core.cpp       |  5 --
 .../user-space-merge/snapuserd_server.cpp     |  3 -
 .../user-space-merge/snapuserd_test.cpp       | 75 ++++++-------------
 5 files changed, 33 insertions(+), 68 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 65f3d6d297ed..9fe567acbc7e 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -165,7 +165,7 @@ cc_binary {
 }
 
 cc_test {
-    name: "cow_snapuserd_test",
+    name: "snapuserd_test_legacy",
     defaults: [
         "fs_mgr_defaults",
         "libsnapshot_cow_defaults",
@@ -217,16 +217,17 @@ cc_test {
     ],
     static_libs: [
         "libbrotli",
-        "libgtest",
-        "libsnapshot_cow",
-        "libsnapshot_snapuserd",
         "libcutils_sockets",
-        "libz",
-        "libfs_mgr",
         "libdm",
         "libext4_utils",
-        "liburing",
+        "libfs_mgr",
         "libgflags",
+        "libgtest",
+        "libsnapshot_cow",
+        "libsnapshot_snapuserd",
+        "libsnapuserd",
+        "liburing",
+        "libz",
     ],
     include_dirs: ["bionic/libc/kernel"],
     header_libs: [
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index c5150c411d02..bdba5c0cc3ab 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -25,6 +25,9 @@ namespace snapshot {
 
 static constexpr uint8_t kMaxMergeThreads = 2;
 
+HandlerThread::HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd)
+    : snapuserd_(snapuserd), misc_name_(snapuserd_->GetMiscName()) {}
+
 void HandlerThread::FreeResources() {
     // Each worker thread holds a reference to snapuserd.
     // Clear them so that all the resources
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index c8a5cc584a28..8e1212b7b3ce 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -421,11 +421,6 @@ bool SnapshotHandler::IsIouringSupported() {
     struct utsname uts;
     unsigned int major, minor;
 
-    if (android::base::GetBoolProperty("snapuserd.test.io_uring.force_disable", false)) {
-        SNAP_LOG(INFO) << "io_uring disabled for testing";
-        return false;
-    }
-
     if ((uname(&uts) != 0) || (sscanf(uts.release, "%u.%u", &major, &minor) != 2)) {
         SNAP_LOG(ERROR) << "Could not parse the kernel version from uname. "
                         << " io_uring not supported";
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index d87990aca2a8..c953f1a053bd 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -83,9 +83,6 @@ void UserSnapshotServer::ShutdownThreads() {
     handlers_->JoinAllThreads();
 }
 
-HandlerThread::HandlerThread(std::shared_ptr<SnapshotHandler> snapuserd)
-    : snapuserd_(snapuserd), misc_name_(snapuserd_->GetMiscName()) {}
-
 bool UserSnapshotServer::Sendmsg(android::base::borrowed_fd fd, const std::string& msg) {
     ssize_t ret = TEMP_FAILURE_RETRY(send(fd.get(), msg.data(), msg.size(), MSG_NOSIGNAL));
     if (ret < 0) {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index ef3689f61f6b..efe0c1443215 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -37,9 +37,9 @@
 #include <libdm/dm.h>
 #include <libdm/loop_control.h>
 #include <libsnapshot/cow_writer.h>
-#include <snapuserd/snapuserd_client.h>
 #include <storage_literals/storage_literals.h>
 
+#include "handler_manager.h"
 #include "snapuserd_core.h"
 
 DEFINE_string(force_config, "", "Force testing mode with iouring disabled");
@@ -54,8 +54,6 @@ using namespace std::chrono_literals;
 using namespace android::dm;
 using namespace std;
 
-static constexpr char kSnapuserdSocketTest[] = "snapuserdTest";
-
 class Tempdevice {
   public:
     Tempdevice(const std::string& name, const DmTable& table)
@@ -68,15 +66,15 @@ class Tempdevice {
     }
     ~Tempdevice() {
         if (valid_) {
-            dm_.DeleteDevice(name_);
+            dm_.DeleteDeviceIfExists(name_);
         }
     }
     bool Destroy() {
         if (!valid_) {
-            return false;
+            return true;
         }
         valid_ = false;
-        return dm_.DeleteDevice(name_);
+        return dm_.DeleteDeviceIfExists(name_);
     }
     const std::string& path() const { return path_; }
     const std::string& name() const { return name_; }
@@ -139,7 +137,6 @@ class SnapuserdTest : public ::testing::Test {
     void SetDeviceControlName();
     void InitDaemon();
     void CreateDmUserDevice();
-    void StartSnapuserdDaemon();
 
     unique_ptr<LoopDevice> base_loop_;
     unique_ptr<Tempdevice> dmuser_dev_;
@@ -149,9 +146,9 @@ class SnapuserdTest : public ::testing::Test {
 
     unique_fd base_fd_;
     std::unique_ptr<TemporaryFile> cow_system_;
-    std::unique_ptr<SnapuserdClient> client_;
     std::unique_ptr<uint8_t[]> orig_buffer_;
     std::unique_ptr<uint8_t[]> merged_buffer_;
+    SnapshotHandlerManager handlers_;
     bool setup_ok_ = false;
     bool merge_ok_ = false;
     size_t size_ = 100_MiB;
@@ -181,9 +178,9 @@ void SnapuserdTest::Shutdown() {
     ASSERT_TRUE(dmuser_dev_->Destroy());
 
     auto misc_device = "/dev/dm-user/" + system_device_ctrl_name_;
-    ASSERT_TRUE(client_->WaitForDeviceDelete(system_device_ctrl_name_));
+    ASSERT_TRUE(handlers_.DeleteHandler(system_device_ctrl_name_));
     ASSERT_TRUE(android::fs_mgr::WaitForFileDeleted(misc_device, 10s));
-    ASSERT_TRUE(client_->DetachSnapuserd());
+    handlers_.TerminateMergeThreads();
 }
 
 bool SnapuserdTest::SetupDefault() {
@@ -218,8 +215,6 @@ bool SnapuserdTest::SetupCopyOverlap_2() {
 bool SnapuserdTest::SetupDaemon() {
     SetDeviceControlName();
 
-    StartSnapuserdDaemon();
-
     CreateDmUserDevice();
     InitCowDevice();
     InitDaemon();
@@ -229,20 +224,6 @@ bool SnapuserdTest::SetupDaemon() {
     return setup_ok_;
 }
 
-void SnapuserdTest::StartSnapuserdDaemon() {
-    pid_t pid = fork();
-    ASSERT_GE(pid, 0);
-    if (pid == 0) {
-        std::string arg0 = "/system/bin/snapuserd";
-        std::string arg1 = "-socket="s + kSnapuserdSocketTest;
-        char* const argv[] = {arg0.data(), arg1.data(), nullptr};
-        ASSERT_GE(execv(arg0.c_str(), argv), 0);
-    } else {
-        client_ = SnapuserdClient::Connect(kSnapuserdSocketTest, 10s);
-        ASSERT_NE(client_, nullptr);
-    }
-}
-
 void SnapuserdTest::CreateBaseDevice() {
     unique_fd rnd_fd;
 
@@ -591,9 +572,17 @@ void SnapuserdTest::CreateCowDevice() {
 }
 
 void SnapuserdTest::InitCowDevice() {
-    uint64_t num_sectors = client_->InitDmUserCow(system_device_ctrl_name_, cow_system_->path,
-                                                  base_loop_->device(), base_loop_->device());
-    ASSERT_NE(num_sectors, 0);
+    bool use_iouring = true;
+    if (FLAGS_force_config == "iouring_disabled") {
+        use_iouring = false;
+    }
+
+    auto handler =
+            handlers_.AddHandler(system_device_ctrl_name_, cow_system_->path, base_loop_->device(),
+                                 base_loop_->device(), 1, use_iouring, false);
+    ASSERT_NE(handler, nullptr);
+    ASSERT_NE(handler->snapuserd(), nullptr);
+    ASSERT_NE(handler->snapuserd()->GetNumSectors(), 0);
 }
 
 void SnapuserdTest::SetDeviceControlName() {
@@ -631,13 +620,12 @@ void SnapuserdTest::CreateDmUserDevice() {
 }
 
 void SnapuserdTest::InitDaemon() {
-    bool ok = client_->AttachDmUser(system_device_ctrl_name_);
-    ASSERT_TRUE(ok);
+    ASSERT_TRUE(handlers_.StartHandler(system_device_ctrl_name_));
 }
 
 void SnapuserdTest::CheckMergeCompletion() {
     while (true) {
-        double percentage = client_->GetMergePercent();
+        double percentage = handlers_.GetMergePercentage();
         if ((int)percentage == 100) {
             break;
         }
@@ -652,8 +640,6 @@ void SnapuserdTest::SetupImpl() {
 
     SetDeviceControlName();
 
-    StartSnapuserdDaemon();
-
     CreateDmUserDevice();
     InitCowDevice();
     InitDaemon();
@@ -669,8 +655,7 @@ bool SnapuserdTest::Merge() {
 }
 
 void SnapuserdTest::StartMerge() {
-    bool ok = client_->InitiateMerge(system_device_ctrl_name_);
-    ASSERT_TRUE(ok);
+    ASSERT_TRUE(handlers_.InitiateMerge(system_device_ctrl_name_));
 }
 
 void SnapuserdTest::ValidateMerge() {
@@ -684,7 +669,6 @@ void SnapuserdTest::SimulateDaemonRestart() {
     Shutdown();
     std::this_thread::sleep_for(500ms);
     SetDeviceControlName();
-    StartSnapuserdDaemon();
     CreateDmUserDevice();
     InitCowDevice();
     InitDaemon();
@@ -844,20 +828,5 @@ int main(int argc, char** argv) {
 
     gflags::ParseCommandLineFlags(&argc, &argv, false);
 
-    android::base::SetProperty("ctl.stop", "snapuserd");
-
-    if (FLAGS_force_config == "iouring_disabled") {
-        if (!android::base::SetProperty("snapuserd.test.io_uring.force_disable", "1")) {
-            return testing::AssertionFailure()
-                   << "Failed to disable property: snapuserd.test.io_uring.disabled";
-        }
-    }
-
-    int ret = RUN_ALL_TESTS();
-
-    if (FLAGS_force_config == "iouring_disabled") {
-        android::base::SetProperty("snapuserd.test.io_uring.force_disable", "0");
-    }
-
-    return ret;
+    return RUN_ALL_TESTS();
 }

From 07339000d4e9d12c2f29d062c0e71395cde4ea1a Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 14 Jul 2023 12:30:35 -0700
Subject: [PATCH 0204/1487] Remove local_include_dirs from fs_mgr_defaults.

fs_mgr_defaults gets used in lots of places, propagate
local_include_dirs to where it's needed so it doesn't cause problems on
modules that don't have an "includes" directory.

Bug: 291083311
Test: builds
Change-Id: Ief2f6362f584b99d3e2dc7dc1b46450609ad189d
---
 fs_mgr/Android.bp                       | 3 ++-
 fs_mgr/libsnapshot/snapuserd/Android.bp | 1 +
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/Android.bp b/fs_mgr/Android.bp
index 15600fd403eb..0a836e43295f 100644
--- a/fs_mgr/Android.bp
+++ b/fs_mgr/Android.bp
@@ -49,7 +49,6 @@ cc_defaults {
     sanitize: {
         misc_undefined: ["integer"],
     },
-    local_include_dirs: ["include/"],
     cflags: [
         "-Wall",
         "-Werror",
@@ -60,6 +59,7 @@ cc_defaults {
     name: "libfs_mgr_defaults",
     defaults: ["fs_mgr_defaults"],
     export_include_dirs: ["include"],
+    local_include_dirs: ["include/"],
     include_dirs: ["system/vold"],
     cflags: [
         "-D_FILE_OFFSET_BITS=64",
@@ -188,6 +188,7 @@ cc_library_static {
     ],
     host_supported: true,
     defaults: ["fs_mgr_defaults"],
+    local_include_dirs: ["include/"],
     srcs: [
         "fs_mgr_fstab.cpp",
         "fs_mgr_boot_config.cpp",
diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 9fe567acbc7e..e5b561b682b3 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -57,6 +57,7 @@ cc_library_static {
     defaults: [
         "fs_mgr_defaults",
     ],
+    local_include_dirs: ["include/"],
     srcs: [
         "dm-snapshot-merge/snapuserd.cpp",
         "dm-snapshot-merge/snapuserd_worker.cpp",

From 74c55e94c9a0dc794747294bd06ea9034072f1f9 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Fri, 14 Jul 2023 21:44:57 -0700
Subject: [PATCH 0205/1487] libsnapshot: GetReminingTime not required after
 mapping dm-user

After MapDmUserCow, there is no further calls in this function. Snapshot
is mapped; Hence, checking remaining time is not required as
it may return false if the time was exceeded. This would mean function returning false even though snapshots were successfully mapped.

Bug: 291288998
Test: OTA

Change-Id: I4fd8fa6ef90a48885392297f217361507268ba51
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshot.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index fbea79b4ad9b..09d35cff104d 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -2490,9 +2490,6 @@ bool SnapshotManager::MapPartitionWithSnapshot(LockedFile* lock,
         }
         created_devices.EmplaceBack<AutoUnmapDevice>(&dm_, name);
 
-        remaining_time = GetRemainingTime(params.timeout_ms, begin);
-        if (remaining_time.count() < 0) return false;
-
         cow_device = new_cow_device;
     }
 
@@ -2507,6 +2504,9 @@ bool SnapshotManager::MapPartitionWithSnapshot(LockedFile* lock,
     // the user-space will not start the merge. We have to explicitly inform the
     // daemon to resume the merge. Check ProcessUpdateState() call stack.
     if (!UpdateUsesUserSnapshots(lock)) {
+        remaining_time = GetRemainingTime(params.timeout_ms, begin);
+        if (remaining_time.count() < 0) return false;
+
         std::string path;
         if (!MapSnapshot(lock, params.GetPartitionName(), base_device, cow_device, remaining_time,
                          &path)) {

From 53ed745e3ffda084d96d11766bb44bc5bef264d8 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers@google.com>
Date: Mon, 17 Jul 2023 20:45:44 +0000
Subject: [PATCH 0206/1487] init: avoid ERROR log due to missing SEPolicy.zip

One of the first ERROR messages in logcat of a normal boot of Cuttlefish
is from failure to open SEPolicy.zip.  This condition is expected.
Therefore don't try to load SEPolicy.zip when it doesn't exist.  This
replaces the following log messages:

0     0 I init    : Error: Apex SEPolicy failed signature check
0     0 I init    : Loading APEX Sepolicy from /system/etc/selinux/apex/SEPolicy.zip
0     0 E init    : Failed to open package /system/etc/selinux/apex/SEPolicy.zip: No such file or directory

... with just:

0     0 I init    : No APEX Sepolicy found

Change-Id: If3a77407c35130165df5782b9ef91912e8374dbf
---
 init/selinux.cpp | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/init/selinux.cpp b/init/selinux.cpp
index b6d483a47d6d..51093d898e8b 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -667,10 +667,16 @@ void CleanupApexSepolicy() {
 //
 void PrepareApexSepolicy() {
     // If apex sepolicy zip exists in /metadata/sepolicy, use that, otherwise use version on
-    // /system.
-    auto dir = (access((kSepolicyApexMetadataDir + kSepolicyZip).c_str(), F_OK) == 0)
-                       ? kSepolicyApexMetadataDir
-                       : kSepolicyApexSystemDir;
+    // /system. If neither exists, do nothing.
+    std::string dir;
+    if (access((kSepolicyApexMetadataDir + kSepolicyZip).c_str(), F_OK) == 0) {
+        dir = kSepolicyApexMetadataDir;
+    } else if (access((kSepolicyApexSystemDir + kSepolicyZip).c_str(), F_OK) == 0) {
+        dir = kSepolicyApexSystemDir;
+    } else {
+        LOG(INFO) << "APEX Sepolicy not found";
+        return;
+    }
 
     auto sepolicyVerify = SepolicyVerify(dir);
     if (!sepolicyVerify.ok()) {

From 556c46bfb9f79955b6f66c55c2581cfd38d2c7ee Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Mon, 17 Jul 2023 13:41:38 -0700
Subject: [PATCH 0207/1487] Look for radio.img and bootloader.img in
 ANDROID_PRODUCT_OUT

Test: fastboot flash bootloader and fastboot flash radio both work
Change-Id: I79674469c0df3dd592e5fcf840fef0dcc3f11d33
---
 fastboot/fastboot.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 30eb7b5fcd5b..1ce4e8b2b5c6 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -119,6 +119,9 @@ fastboot::FastBootDriver* fb = nullptr;
 static std::vector<Image> images = {
         // clang-format off
     { "boot",     "boot.img",         "boot.sig",     "boot",     false, ImageType::BootCritical },
+    { "bootloader",
+                  "bootloader.img",   "",             "bootloader",
+                                                                  true,  ImageType::Extra },
     { "init_boot",
                   "init_boot.img",    "init_boot.sig",
                                                       "init_boot",
@@ -131,6 +134,7 @@ static std::vector<Image> images = {
     { "odm_dlkm", "odm_dlkm.img",     "odm_dlkm.sig", "odm_dlkm", true,  ImageType::Normal },
     { "product",  "product.img",      "product.sig",  "product",  true,  ImageType::Normal },
     { "pvmfw",    "pvmfw.img",        "pvmfw.sig",    "pvmfw",    true,  ImageType::BootCritical },
+    { "radio",    "radio.img",        "",             "radio",    true,  ImageType::Extra },
     { "recovery", "recovery.img",     "recovery.sig", "recovery", true,  ImageType::BootCritical },
     { "super",    "super.img",        "super.sig",    "super",    true,  ImageType::Extra },
     { "system",   "system.img",       "system.sig",   "system",   false, ImageType::Normal },

From 3930625074323af9bade13775bd28c3a0ccfcc7c Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 21 Jun 2023 12:13:15 -0700
Subject: [PATCH 0208/1487] snapuserd: Refactor how buffers are managed.

Currently all I/O is processed through BufferSink. However, the
allocation of buffers is implicit in low-level helper functions, which
have no knowledge of how much data will actually be sent. As a result,
"allocation of buffers" and "tracking of how many bytes were written" is
disjoint. This will make it very difficult to break dependence on
dm-user, without a much more complex API.

This patch refactors how BufferSink is used. First, GetPayloadBuffer has
been deprecated in favor of AcquireBuffer. AcquireBuffer performs both
allocation and write tracking. The number of bytes written is not
necessarily the number of bytes allocated, and the new API allows for
this.

The "Process" helpers now take in an explicit buffer, and their callers
are responsible for allocating a buffer. This allows for
ReadUnalignedSector to have proper buffer offset tracking.

Because write tracking is now accurate, no explicit size needs to be
passed to WriteDmUserPayload. It can simply read the current watermark
in BufferSink.

This patch also removes XorSink, since its dependence on BufferSink made
this change more difficult.

Bug: 288273605
Test: snapuserd_test
Change-Id: Id9ca5044f9c0386f351b250349793b6b276b01b7
---
 .../include/snapuserd/snapuserd_buffer.h      |  29 +--
 .../snapuserd/snapuserd_buffer.cpp            |  51 ++---
 .../user-space-merge/read_worker.cpp          | 178 +++++++-----------
 .../snapuserd/user-space-merge/read_worker.h  |  19 +-
 .../user-space-merge/snapuserd_merge.cpp      |   6 +-
 .../user-space-merge/snapuserd_readahead.cpp  |   3 +-
 6 files changed, 117 insertions(+), 169 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_buffer.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_buffer.h
index a6b6a7f2d9e8..c5ca2b120184 100644
--- a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_buffer.h
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_buffer.h
@@ -36,6 +36,21 @@ class BufferSink final {
     struct dm_user_header* GetHeaderPtr();
     void ResetBufferOffset() { buffer_offset_ = 0; }
     void* GetPayloadBufPtr();
+    loff_t GetPayloadBytesWritten() { return buffer_offset_; }
+
+    // Same as calling GetPayloadBuffer and then UpdateBufferOffset.
+    //
+    // This is preferred over GetPayloadBuffer as it does not require a
+    // separate call to UpdateBufferOffset.
+    void* AcquireBuffer(size_t size) { return AcquireBuffer(size, size); }
+
+    // Same as AcquireBuffer, but separates the requested size from the buffer
+    // offset. This is useful for a situation where a full run of data will be
+    // read, but only a partial amount will be returned.
+    //
+    // If size != to_write, the excess bytes may be reallocated by the next
+    // call to AcquireBuffer.
+    void* AcquireBuffer(size_t size, size_t to_write);
 
   private:
     std::unique_ptr<uint8_t[]> buffer_;
@@ -43,19 +58,5 @@ class BufferSink final {
     size_t buffer_size_;
 };
 
-class XorSink final {
-  public:
-    void Initialize(BufferSink* sink, size_t size);
-    void Reset();
-    void* GetBuffer(size_t requested, size_t* actual);
-    bool ReturnData(void* buffer, size_t len);
-
-  private:
-    BufferSink* bufsink_;
-    std::unique_ptr<uint8_t[]> buffer_;
-    size_t buffer_size_;
-    size_t returned_;
-};
-
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_buffer.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_buffer.cpp
index ab763ab7e4bc..35065e61ef86 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_buffer.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_buffer.cpp
@@ -15,6 +15,8 @@
  */
 
 #include <snapuserd/snapuserd_buffer.h>
+
+#include <android-base/logging.h>
 #include <snapuserd/snapuserd_kernel.h>
 
 namespace android {
@@ -26,11 +28,23 @@ void BufferSink::Initialize(size_t size) {
     buffer_ = std::make_unique<uint8_t[]>(size);
 }
 
-void* BufferSink::GetPayloadBuffer(size_t size) {
-    if ((buffer_size_ - buffer_offset_) < size) return nullptr;
+void* BufferSink::AcquireBuffer(size_t size, size_t to_write) {
+    CHECK(to_write <= size);
+
+    void* ptr = GetPayloadBuffer(size);
+    if (!ptr) {
+        return nullptr;
+    }
+    UpdateBufferOffset(to_write);
+    return ptr;
+}
 
+void* BufferSink::GetPayloadBuffer(size_t size) {
     char* buffer = reinterpret_cast<char*>(GetBufPtr());
     struct dm_user_message* msg = (struct dm_user_message*)(&(buffer[0]));
+    if ((buffer_size_ - buffer_offset_ - sizeof(msg->header)) < size) {
+        return nullptr;
+    }
     return (char*)msg->payload.buf + buffer_offset_;
 }
 
@@ -59,38 +73,5 @@ void* BufferSink::GetPayloadBufPtr() {
     return msg->payload.buf;
 }
 
-void XorSink::Initialize(BufferSink* sink, size_t size) {
-    bufsink_ = sink;
-    buffer_size_ = size;
-    returned_ = 0;
-    buffer_ = std::make_unique<uint8_t[]>(size);
-}
-
-void XorSink::Reset() {
-    returned_ = 0;
-}
-
-void* XorSink::GetBuffer(size_t requested, size_t* actual) {
-    if (requested > buffer_size_) {
-        *actual = buffer_size_;
-    } else {
-        *actual = requested;
-    }
-    return buffer_.get();
-}
-
-bool XorSink::ReturnData(void* buffer, size_t len) {
-    uint8_t* xor_data = reinterpret_cast<uint8_t*>(buffer);
-    uint8_t* buff = reinterpret_cast<uint8_t*>(bufsink_->GetPayloadBuffer(len + returned_));
-    if (buff == nullptr) {
-        return false;
-    }
-    for (size_t i = 0; i < len; i++) {
-        buff[returned_ + i] ^= xor_data[i];
-    }
-    returned_ += len;
-    return true;
-}
-
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index dd2996b783a0..7268fca1e1cc 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -42,12 +42,7 @@ ReadWorker::ReadWorker(const std::string& cow_device, const std::string& backing
 // Start the replace operation. This will read the
 // internal COW format and if the block is compressed,
 // it will be de-compressed.
-bool ReadWorker::ProcessReplaceOp(const CowOperation* cow_op) {
-    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
-    if (!buffer) {
-        SNAP_LOG(ERROR) << "ProcessReplaceOp failed to allocate buffer";
-        return false;
-    }
+bool ReadWorker::ProcessReplaceOp(const CowOperation* cow_op, void* buffer) {
     if (!reader_->ReadData(cow_op, buffer, BLOCK_SZ)) {
         SNAP_LOG(ERROR) << "ProcessReplaceOp failed for block " << cow_op->new_block;
         return false;
@@ -55,12 +50,7 @@ bool ReadWorker::ProcessReplaceOp(const CowOperation* cow_op) {
     return true;
 }
 
-bool ReadWorker::ReadFromSourceDevice(const CowOperation* cow_op) {
-    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
-    if (buffer == nullptr) {
-        SNAP_LOG(ERROR) << "ReadFromBaseDevice: Failed to get payload buffer";
-        return false;
-    }
+bool ReadWorker::ReadFromSourceDevice(const CowOperation* cow_op, void* buffer) {
     uint64_t offset;
     if (!reader_->GetSourceOffset(cow_op, &offset)) {
         SNAP_LOG(ERROR) << "ReadFromSourceDevice: Failed to get source offset";
@@ -85,60 +75,43 @@ bool ReadWorker::ReadFromSourceDevice(const CowOperation* cow_op) {
 
 // Start the copy operation. This will read the backing
 // block device which is represented by cow_op->source.
-bool ReadWorker::ProcessCopyOp(const CowOperation* cow_op) {
-    if (!ReadFromSourceDevice(cow_op)) {
+bool ReadWorker::ProcessCopyOp(const CowOperation* cow_op, void* buffer) {
+    if (!ReadFromSourceDevice(cow_op, buffer)) {
         return false;
     }
-
     return true;
 }
 
-bool ReadWorker::ProcessXorOp(const CowOperation* cow_op) {
-    if (!ReadFromSourceDevice(cow_op)) {
+bool ReadWorker::ProcessXorOp(const CowOperation* cow_op, void* buffer) {
+    if (!ReadFromSourceDevice(cow_op, buffer)) {
         return false;
     }
 
-    xorsink_.Reset();
-
-    size_t actual = 0;
-    void* buffer = xorsink_.GetBuffer(BLOCK_SZ, &actual);
-    if (!buffer || actual < BLOCK_SZ) {
-        SNAP_LOG(ERROR) << "ProcessXorOp failed to get buffer of " << BLOCK_SZ << " size, got "
-                        << actual;
-        return false;
+    if (xor_buffer_.empty()) {
+        xor_buffer_.resize(BLOCK_SZ);
     }
-    ssize_t size = reader_->ReadData(cow_op, buffer, BLOCK_SZ);
+    CHECK(xor_buffer_.size() == BLOCK_SZ);
+
+    ssize_t size = reader_->ReadData(cow_op, xor_buffer_.data(), xor_buffer_.size());
     if (size != BLOCK_SZ) {
         SNAP_LOG(ERROR) << "ProcessXorOp failed for block " << cow_op->new_block
                         << ", return value: " << size;
         return false;
     }
-    if (!xorsink_.ReturnData(buffer, size)) {
-        SNAP_LOG(ERROR) << "ProcessXorOp failed to return data";
-        return false;
+
+    auto xor_out = reinterpret_cast<uint8_t*>(buffer);
+    for (size_t i = 0; i < BLOCK_SZ; i++) {
+        xor_out[i] ^= xor_buffer_[i];
     }
     return true;
 }
 
-bool ReadWorker::ProcessZeroOp() {
-    // Zero out the entire block
-    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
-    if (buffer == nullptr) {
-        SNAP_LOG(ERROR) << "ProcessZeroOp: Failed to get payload buffer";
-        return false;
-    }
-
+bool ReadWorker::ProcessZeroOp(void* buffer) {
     memset(buffer, 0, BLOCK_SZ);
     return true;
 }
 
-bool ReadWorker::ProcessOrderedOp(const CowOperation* cow_op) {
-    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
-    if (buffer == nullptr) {
-        SNAP_LOG(ERROR) << "ProcessOrderedOp: Failed to get payload buffer";
-        return false;
-    }
-
+bool ReadWorker::ProcessOrderedOp(const CowOperation* cow_op, void* buffer) {
     MERGE_GROUP_STATE state = snapuserd_->ProcessMergingBlock(cow_op->new_block, buffer);
 
     switch (state) {
@@ -148,7 +121,7 @@ bool ReadWorker::ProcessOrderedOp(const CowOperation* cow_op) {
             SNAP_LOG(DEBUG) << "Merge-completed: Reading from base device sector: "
                             << (cow_op->new_block >> SECTOR_SHIFT)
                             << " Block-number: " << cow_op->new_block;
-            if (!ReadDataFromBaseDevice(ChunkToSector(cow_op->new_block), BLOCK_SZ)) {
+            if (!ReadDataFromBaseDevice(ChunkToSector(cow_op->new_block), buffer, BLOCK_SZ)) {
                 SNAP_LOG(ERROR) << "ReadDataFromBaseDevice at sector: "
                                 << (cow_op->new_block >> SECTOR_SHIFT) << " after merge-complete.";
                 return false;
@@ -158,9 +131,9 @@ bool ReadWorker::ProcessOrderedOp(const CowOperation* cow_op) {
         case MERGE_GROUP_STATE::GROUP_MERGE_PENDING: {
             bool ret;
             if (cow_op->type == kCowCopyOp) {
-                ret = ProcessCopyOp(cow_op);
+                ret = ProcessCopyOp(cow_op, buffer);
             } else {
-                ret = ProcessXorOp(cow_op);
+                ret = ProcessXorOp(cow_op, buffer);
             }
 
             // I/O is complete - decrement the refcount irrespective of the return
@@ -185,7 +158,7 @@ bool ReadWorker::ProcessOrderedOp(const CowOperation* cow_op) {
     return false;
 }
 
-bool ReadWorker::ProcessCowOp(const CowOperation* cow_op) {
+bool ReadWorker::ProcessCowOp(const CowOperation* cow_op, void* buffer) {
     if (cow_op == nullptr) {
         SNAP_LOG(ERROR) << "ProcessCowOp: Invalid cow_op";
         return false;
@@ -193,17 +166,17 @@ bool ReadWorker::ProcessCowOp(const CowOperation* cow_op) {
 
     switch (cow_op->type) {
         case kCowReplaceOp: {
-            return ProcessReplaceOp(cow_op);
+            return ProcessReplaceOp(cow_op, buffer);
         }
 
         case kCowZeroOp: {
-            return ProcessZeroOp();
+            return ProcessZeroOp(buffer);
         }
 
         case kCowCopyOp:
             [[fallthrough]];
         case kCowXorOp: {
-            return ProcessOrderedOp(cow_op);
+            return ProcessOrderedOp(cow_op, buffer);
         }
 
         default: {
@@ -229,8 +202,6 @@ bool ReadWorker::Init() {
         SNAP_PLOG(ERROR) << "Unable to open " << control_device_;
         return false;
     }
-
-    xorsink_.Initialize(&bufsink_, BLOCK_SZ);
     return true;
 }
 
@@ -271,18 +242,15 @@ bool ReadWorker::WriteDmUserPayload(size_t size) {
     // After the first header is sent in response to a request, we cannot
     // send any additional headers.
     header_response_ = false;
+
+    // Reset the buffer for use by the next request.
+    bufsink_.ResetBufferOffset();
     return true;
 }
 
-bool ReadWorker::ReadDataFromBaseDevice(sector_t sector, size_t read_size) {
+bool ReadWorker::ReadDataFromBaseDevice(sector_t sector, void* buffer, size_t read_size) {
     CHECK(read_size <= BLOCK_SZ);
 
-    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
-    if (buffer == nullptr) {
-        SNAP_LOG(ERROR) << "ReadFromBaseDevice: Failed to get payload buffer";
-        return false;
-    }
-
     loff_t offset = sector << SECTOR_SHIFT;
     if (!android::base::ReadFullyAtOffset(base_path_merge_fd_, buffer, read_size, offset)) {
         SNAP_PLOG(ERROR) << "ReadDataFromBaseDevice failed. fd: " << base_path_merge_fd_
@@ -303,7 +271,6 @@ bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
         size_t read_size = std::min(PAYLOAD_BUFFER_SZ, remaining_size);
 
         size_t total_bytes_read = 0;
-        bufsink_.ResetBufferOffset();
 
         while (read_size) {
             // We need to check every 4k block to verify if it is
@@ -314,11 +281,17 @@ bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
                                        std::make_pair(sector, nullptr), SnapshotHandler::compare);
             bool not_found = (it == chunk_vec.end() || it->first != sector);
 
+            void* buffer = bufsink_.AcquireBuffer(BLOCK_SZ, size);
+            if (!buffer) {
+                SNAP_LOG(ERROR) << "AcquireBuffer failed in ReadAlignedSector";
+                return false;
+            }
+
             if (not_found) {
                 // Block not found in map - which means this block was not
                 // changed as per the OTA. Just route the I/O to the base
                 // device.
-                if (!ReadDataFromBaseDevice(sector, size)) {
+                if (!ReadDataFromBaseDevice(sector, buffer, size)) {
                     SNAP_LOG(ERROR) << "ReadDataFromBaseDevice failed";
                     return false;
                 }
@@ -327,7 +300,7 @@ bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
             } else {
                 // We found the sector in mapping. Check the type of COW OP and
                 // process it.
-                if (!ProcessCowOp(it->second)) {
+                if (!ProcessCowOp(it->second, buffer)) {
                     SNAP_LOG(ERROR) << "ProcessCowOp failed";
                     return false;
                 }
@@ -338,14 +311,13 @@ bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
             read_size -= ret;
             total_bytes_read += ret;
             sector += (ret >> SECTOR_SHIFT);
-            bufsink_.UpdateBufferOffset(ret);
         }
 
-        if (!WriteDmUserPayload(total_bytes_read)) {
+        if (!SendBufferedIo()) {
             return false;
         }
 
-        SNAP_LOG(DEBUG) << "WriteDmUserPayload success total_bytes_read: " << total_bytes_read
+        SNAP_LOG(DEBUG) << "SendBufferedIo success total_bytes_read: " << total_bytes_read
                         << " remaining_size: " << remaining_size;
         remaining_size -= total_bytes_read;
     } while (remaining_size > 0);
@@ -356,40 +328,36 @@ bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
 int ReadWorker::ReadUnalignedSector(
         sector_t sector, size_t size,
         std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it) {
-    size_t skip_sector_size = 0;
-
     SNAP_LOG(DEBUG) << "ReadUnalignedSector: sector " << sector << " size: " << size
                     << " Aligned sector: " << it->first;
 
-    if (!ProcessCowOp(it->second)) {
+    int num_sectors_skip = sector - it->first;
+    size_t skip_size = num_sectors_skip << SECTOR_SHIFT;
+    size_t write_size = std::min(size, BLOCK_SZ - skip_size);
+    auto buffer = reinterpret_cast<uint8_t*>(bufsink_.AcquireBuffer(BLOCK_SZ, write_size));
+    if (!buffer) {
+        SNAP_LOG(ERROR) << "ProcessCowOp failed to allocate buffer";
+        return -1;
+    }
+
+    if (!ProcessCowOp(it->second, buffer)) {
         SNAP_LOG(ERROR) << "ReadUnalignedSector: " << sector << " failed of size: " << size
                         << " Aligned sector: " << it->first;
         return -1;
     }
 
-    int num_sectors_skip = sector - it->first;
-
-    if (num_sectors_skip > 0) {
-        skip_sector_size = num_sectors_skip << SECTOR_SHIFT;
-        char* buffer = reinterpret_cast<char*>(bufsink_.GetBufPtr());
-        struct dm_user_message* msg = (struct dm_user_message*)(&(buffer[0]));
-
-        if (skip_sector_size == BLOCK_SZ) {
+    if (skip_size) {
+        if (skip_size == BLOCK_SZ) {
             SNAP_LOG(ERROR) << "Invalid un-aligned IO request at sector: " << sector
                             << " Base-sector: " << it->first;
             return -1;
         }
-
-        memmove(msg->payload.buf, (char*)msg->payload.buf + skip_sector_size,
-                (BLOCK_SZ - skip_sector_size));
+        memmove(buffer, buffer + skip_size, write_size);
     }
-
-    bufsink_.ResetBufferOffset();
-    return std::min(size, (BLOCK_SZ - skip_sector_size));
+    return write_size;
 }
 
 bool ReadWorker::ReadUnalignedSector(sector_t sector, size_t size) {
-    bufsink_.ResetBufferOffset();
     std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
 
     auto it = std::lower_bound(chunk_vec.begin(), chunk_vec.end(), std::make_pair(sector, nullptr),
@@ -458,7 +426,6 @@ bool ReadWorker::ReadUnalignedSector(sector_t sector, size_t size) {
     // requested offset in this case is beyond the last mapped COW op size (which
     // is block 1 in this case).
 
-    size_t total_bytes_read = 0;
     size_t remaining_size = size;
     int ret = 0;
     if (!merge_complete && (requested_offset >= final_offset) &&
@@ -472,11 +439,10 @@ bool ReadWorker::ReadUnalignedSector(sector_t sector, size_t size) {
         }
 
         remaining_size -= ret;
-        total_bytes_read += ret;
         sector += (ret >> SECTOR_SHIFT);
 
         // Send the data back
-        if (!WriteDmUserPayload(total_bytes_read)) {
+        if (!SendBufferedIo()) {
             return false;
         }
 
@@ -494,26 +460,21 @@ bool ReadWorker::ReadUnalignedSector(sector_t sector, size_t size) {
         // Find the diff of the aligned offset
         size_t diff_size = aligned_offset - requested_offset;
         CHECK(diff_size <= BLOCK_SZ);
-        if (remaining_size < diff_size) {
-            if (!ReadDataFromBaseDevice(sector, remaining_size)) {
-                return false;
-            }
-            total_bytes_read += remaining_size;
-
-            if (!WriteDmUserPayload(total_bytes_read)) {
-                return false;
-            }
-        } else {
-            if (!ReadDataFromBaseDevice(sector, diff_size)) {
-                return false;
-            }
 
-            total_bytes_read += diff_size;
-
-            if (!WriteDmUserPayload(total_bytes_read)) {
-                return false;
-            }
+        size_t read_size = std::min(remaining_size, diff_size);
+        void* buffer = bufsink_.AcquireBuffer(BLOCK_SZ, read_size);
+        if (!buffer) {
+            SNAP_LOG(ERROR) << "AcquireBuffer failed in ReadUnalignedSector";
+            return false;
+        }
+        if (!ReadDataFromBaseDevice(sector, buffer, read_size)) {
+            return false;
+        }
+        if (!SendBufferedIo()) {
+            return false;
+        }
 
+        if (remaining_size >= diff_size) {
             remaining_size -= diff_size;
             size_t num_sectors_read = (diff_size >> SECTOR_SHIFT);
             sector += num_sectors_read;
@@ -555,6 +516,10 @@ bool ReadWorker::DmuserReadRequest() {
     return ReadAlignedSector(header->sector, header->len);
 }
 
+bool ReadWorker::SendBufferedIo() {
+    return WriteDmUserPayload(bufsink_.GetPayloadBytesWritten());
+}
+
 bool ReadWorker::ProcessIORequest() {
     // Read Header from dm-user misc device. This gives
     // us the sector number for which IO is issued by dm-snapshot device
@@ -579,6 +544,9 @@ bool ReadWorker::ProcessIORequest() {
     header->type = DM_USER_RESP_SUCCESS;
     header_response_ = true;
 
+    // Reset the output buffer.
+    bufsink_.ResetBufferOffset();
+
     bool ok;
     switch (request_type) {
         case DM_USER_REQ_MAP_READ:
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
index c3a4c346ebfd..8d6f66379359 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
@@ -37,21 +37,22 @@ class ReadWorker : public Worker {
     bool ProcessIORequest();
     bool WriteDmUserPayload(size_t size);
     bool DmuserReadRequest();
+    bool SendBufferedIo();
     void RespondIOError();
 
-    bool ProcessCowOp(const CowOperation* cow_op);
-    bool ProcessXorOp(const CowOperation* cow_op);
-    bool ProcessOrderedOp(const CowOperation* cow_op);
-    bool ProcessCopyOp(const CowOperation* cow_op);
-    bool ProcessReplaceOp(const CowOperation* cow_op);
-    bool ProcessZeroOp();
+    bool ProcessCowOp(const CowOperation* cow_op, void* buffer);
+    bool ProcessXorOp(const CowOperation* cow_op, void* buffer);
+    bool ProcessOrderedOp(const CowOperation* cow_op, void* buffer);
+    bool ProcessCopyOp(const CowOperation* cow_op, void* buffer);
+    bool ProcessReplaceOp(const CowOperation* cow_op, void* buffer);
+    bool ProcessZeroOp(void* buffer);
 
     bool ReadAlignedSector(sector_t sector, size_t sz);
     bool ReadUnalignedSector(sector_t sector, size_t size);
     int ReadUnalignedSector(sector_t sector, size_t size,
                             std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it);
-    bool ReadFromSourceDevice(const CowOperation* cow_op);
-    bool ReadDataFromBaseDevice(sector_t sector, size_t read_size);
+    bool ReadFromSourceDevice(const CowOperation* cow_op, void* buffer);
+    bool ReadDataFromBaseDevice(sector_t sector, void* buffer, size_t read_size);
 
     constexpr bool IsBlockAligned(size_t size) { return ((size & (BLOCK_SZ - 1)) == 0); }
     constexpr sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
@@ -62,8 +63,8 @@ class ReadWorker : public Worker {
     std::string control_device_;
     unique_fd ctrl_fd_;
 
-    XorSink xorsink_;
     bool header_response_ = false;
+    std::basic_string<uint8_t> xor_buffer_;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
index 563f6ad427cc..517148d36730 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
@@ -106,9 +106,9 @@ bool MergeWorker::MergeReplaceZeroOps() {
         for (size_t i = 0; i < replace_zero_vec.size(); i++) {
             const CowOperation* cow_op = replace_zero_vec[i];
 
-            void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
+            void* buffer = bufsink_.AcquireBuffer(BLOCK_SZ);
             if (!buffer) {
-                SNAP_LOG(ERROR) << "Failed to acquire buffer in merge";
+                SNAP_LOG(ERROR) << "AcquireBuffer failed in MergeReplaceOps";
                 return false;
             }
             if (cow_op->type == kCowReplaceOp) {
@@ -120,8 +120,6 @@ bool MergeWorker::MergeReplaceZeroOps() {
                 CHECK(cow_op->type == kCowZeroOp);
                 memset(buffer, 0, BLOCK_SZ);
             }
-
-            bufsink_.UpdateBufferOffset(BLOCK_SZ);
         }
 
         size_t io_size = linear_blocks * BLOCK_SZ;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index 399f7b81baf0..3e9588b53d5b 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -492,7 +492,7 @@ bool ReadAhead::ReadXorData(size_t block_index, size_t xor_op_index,
         if (xor_op_index < xor_op_vec.size()) {
             const CowOperation* xor_op = xor_op_vec[xor_op_index];
             if (xor_op->new_block == new_block) {
-                void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
+                void* buffer = bufsink_.AcquireBuffer(BLOCK_SZ);
                 if (!buffer) {
                     SNAP_LOG(ERROR) << "ReadAhead - failed to allocate buffer for block: "
                                     << xor_op->new_block;
@@ -506,7 +506,6 @@ bool ReadAhead::ReadXorData(size_t block_index, size_t xor_op_index,
                 }
 
                 xor_op_index += 1;
-                bufsink_.UpdateBufferOffset(BLOCK_SZ);
             }
         }
         block_index += 1;

From ad6ca1451d034cb381d99f9b170a1024bb1d5014 Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Tue, 11 Jul 2023 09:05:11 -0700
Subject: [PATCH 0209/1487] Revert "Fix deadlock caused by two-threaded
 property controls"

This reverts commit 606afc7b7451aba90e3634076d9b59a5ef08186b.

These fixes for b/262208935 introduced a race condition. We believe the
race is fixed by ag/23879563, but at this point in the release feel that
reverting the fixes and refixing in main is the better solution

Test: Builds, boots
Bug: 283202477
Bug: 288991737
Ignore-AOSP-First: Reverting CL only in internal
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:3196be61fcf0e0303cf819630876b9c812b9474e)
Merged-In: I9ae6863b0ea5e064c59d9d34c03d33fa1da12fdc
Change-Id: I9ae6863b0ea5e064c59d9d34c03d33fa1da12fdc
---
 init/property_service.cpp | 50 ++++++++++++++++++---------------------
 1 file changed, 23 insertions(+), 27 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index 4242912ed0af..2d084db46d2a 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -117,6 +117,7 @@ static bool accept_messages = false;
 static std::mutex accept_messages_lock;
 static std::thread property_service_thread;
 static std::thread property_service_for_system_thread;
+static std::mutex set_property_lock;
 
 static std::unique_ptr<PersistWriteThread> persist_write_thread;
 
@@ -394,37 +395,32 @@ static std::optional<uint32_t> PropertySet(const std::string& name, const std::s
         return {PROP_ERROR_INVALID_VALUE};
     }
 
-    if (name == "sys.powerctl") {
-        // No action here - NotifyPropertyChange will trigger the appropriate action, and since this
-        // can come to the second thread, we mustn't call out to the __system_property_* functions
-        // which support multiple readers but only one mutator.
-    } else {
-        prop_info* pi = (prop_info*)__system_property_find(name.c_str());
-        if (pi != nullptr) {
-            // ro.* properties are actually "write-once".
-            if (StartsWith(name, "ro.")) {
-                *error = "Read-only property was already set";
-                return {PROP_ERROR_READ_ONLY_PROPERTY};
-            }
+    auto lock = std::lock_guard{set_property_lock};
+    prop_info* pi = (prop_info*)__system_property_find(name.c_str());
+    if (pi != nullptr) {
+        // ro.* properties are actually "write-once".
+        if (StartsWith(name, "ro.")) {
+            *error = "Read-only property was already set";
+            return {PROP_ERROR_READ_ONLY_PROPERTY};
+        }
 
-            __system_property_update(pi, value.c_str(), valuelen);
-        } else {
-            int rc = __system_property_add(name.c_str(), name.size(), value.c_str(), valuelen);
-            if (rc < 0) {
-                *error = "__system_property_add failed";
-                return {PROP_ERROR_SET_FAILED};
-            }
+        __system_property_update(pi, value.c_str(), valuelen);
+    } else {
+        int rc = __system_property_add(name.c_str(), name.size(), value.c_str(), valuelen);
+        if (rc < 0) {
+            *error = "__system_property_add failed";
+            return {PROP_ERROR_SET_FAILED};
         }
+    }
 
-        // Don't write properties to disk until after we have read all default
-        // properties to prevent them from being overwritten by default values.
-        if (socket && persistent_properties_loaded && StartsWith(name, "persist.")) {
-            if (persist_write_thread) {
-                persist_write_thread->Write(name, value, std::move(*socket));
-                return {};
-            }
-            WritePersistentProperty(name, value);
+    // Don't write properties to disk until after we have read all default
+    // properties to prevent them from being overwritten by default values.
+    if (socket && persistent_properties_loaded && StartsWith(name, "persist.")) {
+        if (persist_write_thread) {
+            persist_write_thread->Write(name, value, std::move(*socket));
+            return {};
         }
+        WritePersistentProperty(name, value);
     }
 
     NotifyPropertyChange(name, value);

From de5f915991bb445ddadd4a3889874ee97dc7913d Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Tue, 11 Jul 2023 09:05:27 -0700
Subject: [PATCH 0210/1487] Revert "Listen on property_service_for_system
 socket"

This reverts commit 90879edeea0b2fd1e766428693d736163f39c511.

These fixes for b/262208935 introduced a race condition. We believe the
race is fixed by ag/23879563, but at this point in the release feel that
reverting the fixes and refixing in main is the better solution

Test: Builds, boots
Bug: 283202477
Bug: 288991737
Ignore-AOSP-First: Reverting CL only in internal
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:be392fc69318d376f18eed7c8ef5ded0d1dc8648)
Merged-In: I28491e90847f6aa0c9767b27e1d99190637048b9
Change-Id: I28491e90847f6aa0c9767b27e1d99190637048b9
---
 init/property_service.cpp | 53 ++++++++++++++++-----------------------
 1 file changed, 21 insertions(+), 32 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index 2d084db46d2a..8da69822ccb9 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -57,12 +57,12 @@
 #include <android-base/result.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
-#include <private/android_filesystem_config.h>
 #include <property_info_parser/property_info_parser.h>
 #include <property_info_serializer/property_info_serializer.h>
 #include <selinux/android.h>
 #include <selinux/label.h>
 #include <selinux/selinux.h>
+
 #include "debug_ramdisk.h"
 #include "epoll.h"
 #include "init.h"
@@ -111,13 +111,12 @@ constexpr auto API_LEVEL_CURRENT = 10000;
 
 static bool persistent_properties_loaded = false;
 
+static int property_set_fd = -1;
 static int from_init_socket = -1;
 static int init_socket = -1;
 static bool accept_messages = false;
 static std::mutex accept_messages_lock;
 static std::thread property_service_thread;
-static std::thread property_service_for_system_thread;
-static std::mutex set_property_lock;
 
 static std::unique_ptr<PersistWriteThread> persist_write_thread;
 
@@ -395,7 +394,6 @@ static std::optional<uint32_t> PropertySet(const std::string& name, const std::s
         return {PROP_ERROR_INVALID_VALUE};
     }
 
-    auto lock = std::lock_guard{set_property_lock};
     prop_info* pi = (prop_info*)__system_property_find(name.c_str());
     if (pi != nullptr) {
         // ro.* properties are actually "write-once".
@@ -581,10 +579,10 @@ uint32_t HandlePropertySetNoSocket(const std::string& name, const std::string& v
     return *ret;
 }
 
-static void handle_property_set_fd(int fd) {
+static void handle_property_set_fd() {
     static constexpr uint32_t kDefaultSocketTimeout = 2000; /* ms */
 
-    int s = accept4(fd, nullptr, nullptr, SOCK_CLOEXEC);
+    int s = accept4(property_set_fd, nullptr, nullptr, SOCK_CLOEXEC);
     if (s == -1) {
         return;
     }
@@ -1421,21 +1419,19 @@ static void HandleInitSocket() {
     }
 }
 
-static void PropertyServiceThread(int fd, bool listen_init) {
+static void PropertyServiceThread() {
     Epoll epoll;
     if (auto result = epoll.Open(); !result.ok()) {
         LOG(FATAL) << result.error();
     }
 
-    if (auto result = epoll.RegisterHandler(fd, std::bind(handle_property_set_fd, fd));
+    if (auto result = epoll.RegisterHandler(property_set_fd, handle_property_set_fd);
         !result.ok()) {
         LOG(FATAL) << result.error();
     }
 
-    if (listen_init) {
-        if (auto result = epoll.RegisterHandler(init_socket, HandleInitSocket); !result.ok()) {
-            LOG(FATAL) << result.error();
-        }
+    if (auto result = epoll.RegisterHandler(init_socket, HandleInitSocket); !result.ok()) {
+        LOG(FATAL) << result.error();
     }
 
     while (true) {
@@ -1486,23 +1482,6 @@ void PersistWriteThread::Write(std::string name, std::string value, SocketConnec
     cv_.notify_all();
 }
 
-void StartThread(const char* name, int mode, int gid, std::thread& t, bool listen_init) {
-    int fd = -1;
-    if (auto result = CreateSocket(name, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
-                                   /*passcred=*/false, /*should_listen=*/false, mode, /*uid=*/0,
-                                   /*gid=*/gid, /*socketcon=*/{});
-        result.ok()) {
-        fd = *result;
-    } else {
-        LOG(FATAL) << "start_property_service socket creation failed: " << result.error();
-    }
-
-    listen(fd, 8);
-
-    auto new_thread = std::thread(PropertyServiceThread, fd, listen_init);
-    t.swap(new_thread);
-}
-
 void StartPropertyService(int* epoll_socket) {
     InitPropertySet("ro.property_service.version", "2");
 
@@ -1514,9 +1493,19 @@ void StartPropertyService(int* epoll_socket) {
     init_socket = sockets[1];
     StartSendingMessages();
 
-    StartThread(PROP_SERVICE_FOR_SYSTEM_NAME, 0660, AID_SYSTEM, property_service_for_system_thread,
-                true);
-    StartThread(PROP_SERVICE_NAME, 0666, 0, property_service_thread, false);
+    if (auto result = CreateSocket(PROP_SERVICE_NAME, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
+                                   /*passcred=*/false, /*should_listen=*/false, 0666, /*uid=*/0,
+                                   /*gid=*/0, /*socketcon=*/{});
+        result.ok()) {
+        property_set_fd = *result;
+    } else {
+        LOG(FATAL) << "start_property_service socket creation failed: " << result.error();
+    }
+
+    listen(property_set_fd, 8);
+
+    auto new_thread = std::thread{PropertyServiceThread};
+    property_service_thread.swap(new_thread);
 
     auto async_persist_writes =
             android::base::GetBoolProperty("ro.property_service.async_persist_writes", false);

From 689adfad37bb2fc98fd9b687c3e087901255328e Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Tue, 18 Jul 2023 08:39:10 -0700
Subject: [PATCH 0211/1487] Listen on property_service_for_system socket for
 powerctl messages

It is easy to dos the property_service socket, since it will wait for a
complete data packet from one command before moving on to the next one.

To prevent low privilege apps interfering with system and root apps,
add a second property_service socket that only they can use.

However, since writes to properties are not thread-safe, limit use of
this second socket to just sys.powerctl messages. These are the messages
that this security issue is concerned about, and they do not actually
write to the properties, rather they are acted upon immediately.

Bug: 262208935
Test: Builds, boots
Ignore-AOSP-First: Security fix
Change-Id: I32835de31bb42c91b6479051ddf4b26b5c0b163f
---
 init/property_service.cpp | 108 ++++++++++++++++++++++----------------
 1 file changed, 62 insertions(+), 46 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index 8da69822ccb9..3e9a6d9f342e 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -57,12 +57,12 @@
 #include <android-base/result.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
+#include <private/android_filesystem_config.h>
 #include <property_info_parser/property_info_parser.h>
 #include <property_info_serializer/property_info_serializer.h>
 #include <selinux/android.h>
 #include <selinux/label.h>
 #include <selinux/selinux.h>
-
 #include "debug_ramdisk.h"
 #include "epoll.h"
 #include "init.h"
@@ -111,12 +111,13 @@ constexpr auto API_LEVEL_CURRENT = 10000;
 
 static bool persistent_properties_loaded = false;
 
-static int property_set_fd = -1;
 static int from_init_socket = -1;
 static int init_socket = -1;
 static bool accept_messages = false;
 static std::mutex accept_messages_lock;
+static std::mutex selinux_check_access_lock;
 static std::thread property_service_thread;
+static std::thread property_service_for_system_thread;
 
 static std::unique_ptr<PersistWriteThread> persist_write_thread;
 
@@ -161,6 +162,7 @@ bool CanReadProperty(const std::string& source_context, const std::string& name)
     ucred cr = {.pid = 0, .uid = 0, .gid = 0};
     audit_data.cr = &cr;
 
+    auto lock = std::lock_guard{selinux_check_access_lock};
     return selinux_check_access(source_context.c_str(), target_context, "file", "read",
                                 &audit_data) == 0;
 }
@@ -176,10 +178,9 @@ static bool CheckMacPerms(const std::string& name, const char* target_context,
     audit_data.name = name.c_str();
     audit_data.cr = &cr;
 
-    bool has_access = (selinux_check_access(source_context, target_context, "property_service",
-                                            "set", &audit_data) == 0);
-
-    return has_access;
+    auto lock = std::lock_guard{selinux_check_access_lock};
+    return selinux_check_access(source_context, target_context, "property_service", "set",
+                                &audit_data) == 0;
 }
 
 void NotifyPropertyChange(const std::string& name, const std::string& value) {
@@ -394,31 +395,37 @@ static std::optional<uint32_t> PropertySet(const std::string& name, const std::s
         return {PROP_ERROR_INVALID_VALUE};
     }
 
-    prop_info* pi = (prop_info*)__system_property_find(name.c_str());
-    if (pi != nullptr) {
-        // ro.* properties are actually "write-once".
-        if (StartsWith(name, "ro.")) {
-            *error = "Read-only property was already set";
-            return {PROP_ERROR_READ_ONLY_PROPERTY};
-        }
-
-        __system_property_update(pi, value.c_str(), valuelen);
+    if (name == "sys.powerctl") {
+        // No action here - NotifyPropertyChange will trigger the appropriate action, and since this
+        // can come to the second thread, we mustn't call out to the __system_property_* functions
+        // which support multiple readers but only one mutator.
     } else {
-        int rc = __system_property_add(name.c_str(), name.size(), value.c_str(), valuelen);
-        if (rc < 0) {
-            *error = "__system_property_add failed";
-            return {PROP_ERROR_SET_FAILED};
+        prop_info* pi = (prop_info*)__system_property_find(name.c_str());
+        if (pi != nullptr) {
+            // ro.* properties are actually "write-once".
+            if (StartsWith(name, "ro.")) {
+                *error = "Read-only property was already set";
+                return {PROP_ERROR_READ_ONLY_PROPERTY};
+            }
+
+            __system_property_update(pi, value.c_str(), valuelen);
+        } else {
+            int rc = __system_property_add(name.c_str(), name.size(), value.c_str(), valuelen);
+            if (rc < 0) {
+                *error = "__system_property_add failed";
+                return {PROP_ERROR_SET_FAILED};
+            }
         }
-    }
 
-    // Don't write properties to disk until after we have read all default
-    // properties to prevent them from being overwritten by default values.
-    if (socket && persistent_properties_loaded && StartsWith(name, "persist.")) {
-        if (persist_write_thread) {
-            persist_write_thread->Write(name, value, std::move(*socket));
-            return {};
+        // Don't write properties to disk until after we have read all default
+        // properties to prevent them from being overwritten by default values.
+        if (socket && persistent_properties_loaded && StartsWith(name, "persist.")) {
+            if (persist_write_thread) {
+                persist_write_thread->Write(name, value, std::move(*socket));
+                return {};
+            }
+            WritePersistentProperty(name, value);
         }
-        WritePersistentProperty(name, value);
     }
 
     NotifyPropertyChange(name, value);
@@ -579,10 +586,10 @@ uint32_t HandlePropertySetNoSocket(const std::string& name, const std::string& v
     return *ret;
 }
 
-static void handle_property_set_fd() {
+static void handle_property_set_fd(int fd) {
     static constexpr uint32_t kDefaultSocketTimeout = 2000; /* ms */
 
-    int s = accept4(property_set_fd, nullptr, nullptr, SOCK_CLOEXEC);
+    int s = accept4(fd, nullptr, nullptr, SOCK_CLOEXEC);
     if (s == -1) {
         return;
     }
@@ -1419,19 +1426,21 @@ static void HandleInitSocket() {
     }
 }
 
-static void PropertyServiceThread() {
+static void PropertyServiceThread(int fd, bool listen_init) {
     Epoll epoll;
     if (auto result = epoll.Open(); !result.ok()) {
         LOG(FATAL) << result.error();
     }
 
-    if (auto result = epoll.RegisterHandler(property_set_fd, handle_property_set_fd);
+    if (auto result = epoll.RegisterHandler(fd, std::bind(handle_property_set_fd, fd));
         !result.ok()) {
         LOG(FATAL) << result.error();
     }
 
-    if (auto result = epoll.RegisterHandler(init_socket, HandleInitSocket); !result.ok()) {
-        LOG(FATAL) << result.error();
+    if (listen_init) {
+        if (auto result = epoll.RegisterHandler(init_socket, HandleInitSocket); !result.ok()) {
+            LOG(FATAL) << result.error();
+        }
     }
 
     while (true) {
@@ -1482,6 +1491,23 @@ void PersistWriteThread::Write(std::string name, std::string value, SocketConnec
     cv_.notify_all();
 }
 
+void StartThread(const char* name, int mode, int gid, std::thread& t, bool listen_init) {
+    int fd = -1;
+    if (auto result = CreateSocket(name, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
+                                   /*passcred=*/false, /*should_listen=*/false, mode, /*uid=*/0,
+                                   /*gid=*/gid, /*socketcon=*/{});
+        result.ok()) {
+        fd = *result;
+    } else {
+        LOG(FATAL) << "start_property_service socket creation failed: " << result.error();
+    }
+
+    listen(fd, 8);
+
+    auto new_thread = std::thread(PropertyServiceThread, fd, listen_init);
+    t.swap(new_thread);
+}
+
 void StartPropertyService(int* epoll_socket) {
     InitPropertySet("ro.property_service.version", "2");
 
@@ -1493,19 +1519,9 @@ void StartPropertyService(int* epoll_socket) {
     init_socket = sockets[1];
     StartSendingMessages();
 
-    if (auto result = CreateSocket(PROP_SERVICE_NAME, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
-                                   /*passcred=*/false, /*should_listen=*/false, 0666, /*uid=*/0,
-                                   /*gid=*/0, /*socketcon=*/{});
-        result.ok()) {
-        property_set_fd = *result;
-    } else {
-        LOG(FATAL) << "start_property_service socket creation failed: " << result.error();
-    }
-
-    listen(property_set_fd, 8);
-
-    auto new_thread = std::thread{PropertyServiceThread};
-    property_service_thread.swap(new_thread);
+    StartThread(PROP_SERVICE_FOR_SYSTEM_NAME, 0660, AID_SYSTEM, property_service_for_system_thread,
+                true);
+    StartThread(PROP_SERVICE_NAME, 0666, 0, property_service_thread, false);
 
     auto async_persist_writes =
             android::base::GetBoolProperty("ro.property_service.async_persist_writes", false);

From 3adb2a63bed9e97a5a179316b4f14a3196df81e3 Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Tue, 11 Jul 2023 09:05:11 -0700
Subject: [PATCH 0212/1487] Revert "Fix deadlock caused by two-threaded
 property controls"

This reverts commit 606afc7b7451aba90e3634076d9b59a5ef08186b.

These fixes for b/262208935 introduced a race condition. We believe the
race is fixed by ag/23879563, but at this point in the release feel that
reverting the fixes and refixing in main is the better solution

Test: Builds, boots
Bug: 283202477
Bug: 288991737
Ignore-AOSP-First: Reverting CL only in internal
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:3196be61fcf0e0303cf819630876b9c812b9474e)
Merged-In: I9ae6863b0ea5e064c59d9d34c03d33fa1da12fdc
Change-Id: I9ae6863b0ea5e064c59d9d34c03d33fa1da12fdc
---
 init/property_service.cpp | 50 ++++++++++++++++++---------------------
 1 file changed, 23 insertions(+), 27 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index 4242912ed0af..2d084db46d2a 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -117,6 +117,7 @@ static bool accept_messages = false;
 static std::mutex accept_messages_lock;
 static std::thread property_service_thread;
 static std::thread property_service_for_system_thread;
+static std::mutex set_property_lock;
 
 static std::unique_ptr<PersistWriteThread> persist_write_thread;
 
@@ -394,37 +395,32 @@ static std::optional<uint32_t> PropertySet(const std::string& name, const std::s
         return {PROP_ERROR_INVALID_VALUE};
     }
 
-    if (name == "sys.powerctl") {
-        // No action here - NotifyPropertyChange will trigger the appropriate action, and since this
-        // can come to the second thread, we mustn't call out to the __system_property_* functions
-        // which support multiple readers but only one mutator.
-    } else {
-        prop_info* pi = (prop_info*)__system_property_find(name.c_str());
-        if (pi != nullptr) {
-            // ro.* properties are actually "write-once".
-            if (StartsWith(name, "ro.")) {
-                *error = "Read-only property was already set";
-                return {PROP_ERROR_READ_ONLY_PROPERTY};
-            }
+    auto lock = std::lock_guard{set_property_lock};
+    prop_info* pi = (prop_info*)__system_property_find(name.c_str());
+    if (pi != nullptr) {
+        // ro.* properties are actually "write-once".
+        if (StartsWith(name, "ro.")) {
+            *error = "Read-only property was already set";
+            return {PROP_ERROR_READ_ONLY_PROPERTY};
+        }
 
-            __system_property_update(pi, value.c_str(), valuelen);
-        } else {
-            int rc = __system_property_add(name.c_str(), name.size(), value.c_str(), valuelen);
-            if (rc < 0) {
-                *error = "__system_property_add failed";
-                return {PROP_ERROR_SET_FAILED};
-            }
+        __system_property_update(pi, value.c_str(), valuelen);
+    } else {
+        int rc = __system_property_add(name.c_str(), name.size(), value.c_str(), valuelen);
+        if (rc < 0) {
+            *error = "__system_property_add failed";
+            return {PROP_ERROR_SET_FAILED};
         }
+    }
 
-        // Don't write properties to disk until after we have read all default
-        // properties to prevent them from being overwritten by default values.
-        if (socket && persistent_properties_loaded && StartsWith(name, "persist.")) {
-            if (persist_write_thread) {
-                persist_write_thread->Write(name, value, std::move(*socket));
-                return {};
-            }
-            WritePersistentProperty(name, value);
+    // Don't write properties to disk until after we have read all default
+    // properties to prevent them from being overwritten by default values.
+    if (socket && persistent_properties_loaded && StartsWith(name, "persist.")) {
+        if (persist_write_thread) {
+            persist_write_thread->Write(name, value, std::move(*socket));
+            return {};
         }
+        WritePersistentProperty(name, value);
     }
 
     NotifyPropertyChange(name, value);

From 8543f7dcd4fa94c7aeba938ad78679915ea8b1cd Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Tue, 11 Jul 2023 09:05:27 -0700
Subject: [PATCH 0213/1487] Revert "Listen on property_service_for_system
 socket"

This reverts commit 90879edeea0b2fd1e766428693d736163f39c511.

These fixes for b/262208935 introduced a race condition. We believe the
race is fixed by ag/23879563, but at this point in the release feel that
reverting the fixes and refixing in main is the better solution

Test: Builds, boots
Bug: 283202477
Bug: 288991737
Ignore-AOSP-First: Reverting CL only in internal
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:be392fc69318d376f18eed7c8ef5ded0d1dc8648)
Merged-In: I28491e90847f6aa0c9767b27e1d99190637048b9
Change-Id: I28491e90847f6aa0c9767b27e1d99190637048b9
---
 init/property_service.cpp | 53 ++++++++++++++++-----------------------
 1 file changed, 21 insertions(+), 32 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index 2d084db46d2a..8da69822ccb9 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -57,12 +57,12 @@
 #include <android-base/result.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
-#include <private/android_filesystem_config.h>
 #include <property_info_parser/property_info_parser.h>
 #include <property_info_serializer/property_info_serializer.h>
 #include <selinux/android.h>
 #include <selinux/label.h>
 #include <selinux/selinux.h>
+
 #include "debug_ramdisk.h"
 #include "epoll.h"
 #include "init.h"
@@ -111,13 +111,12 @@ constexpr auto API_LEVEL_CURRENT = 10000;
 
 static bool persistent_properties_loaded = false;
 
+static int property_set_fd = -1;
 static int from_init_socket = -1;
 static int init_socket = -1;
 static bool accept_messages = false;
 static std::mutex accept_messages_lock;
 static std::thread property_service_thread;
-static std::thread property_service_for_system_thread;
-static std::mutex set_property_lock;
 
 static std::unique_ptr<PersistWriteThread> persist_write_thread;
 
@@ -395,7 +394,6 @@ static std::optional<uint32_t> PropertySet(const std::string& name, const std::s
         return {PROP_ERROR_INVALID_VALUE};
     }
 
-    auto lock = std::lock_guard{set_property_lock};
     prop_info* pi = (prop_info*)__system_property_find(name.c_str());
     if (pi != nullptr) {
         // ro.* properties are actually "write-once".
@@ -581,10 +579,10 @@ uint32_t HandlePropertySetNoSocket(const std::string& name, const std::string& v
     return *ret;
 }
 
-static void handle_property_set_fd(int fd) {
+static void handle_property_set_fd() {
     static constexpr uint32_t kDefaultSocketTimeout = 2000; /* ms */
 
-    int s = accept4(fd, nullptr, nullptr, SOCK_CLOEXEC);
+    int s = accept4(property_set_fd, nullptr, nullptr, SOCK_CLOEXEC);
     if (s == -1) {
         return;
     }
@@ -1421,21 +1419,19 @@ static void HandleInitSocket() {
     }
 }
 
-static void PropertyServiceThread(int fd, bool listen_init) {
+static void PropertyServiceThread() {
     Epoll epoll;
     if (auto result = epoll.Open(); !result.ok()) {
         LOG(FATAL) << result.error();
     }
 
-    if (auto result = epoll.RegisterHandler(fd, std::bind(handle_property_set_fd, fd));
+    if (auto result = epoll.RegisterHandler(property_set_fd, handle_property_set_fd);
         !result.ok()) {
         LOG(FATAL) << result.error();
     }
 
-    if (listen_init) {
-        if (auto result = epoll.RegisterHandler(init_socket, HandleInitSocket); !result.ok()) {
-            LOG(FATAL) << result.error();
-        }
+    if (auto result = epoll.RegisterHandler(init_socket, HandleInitSocket); !result.ok()) {
+        LOG(FATAL) << result.error();
     }
 
     while (true) {
@@ -1486,23 +1482,6 @@ void PersistWriteThread::Write(std::string name, std::string value, SocketConnec
     cv_.notify_all();
 }
 
-void StartThread(const char* name, int mode, int gid, std::thread& t, bool listen_init) {
-    int fd = -1;
-    if (auto result = CreateSocket(name, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
-                                   /*passcred=*/false, /*should_listen=*/false, mode, /*uid=*/0,
-                                   /*gid=*/gid, /*socketcon=*/{});
-        result.ok()) {
-        fd = *result;
-    } else {
-        LOG(FATAL) << "start_property_service socket creation failed: " << result.error();
-    }
-
-    listen(fd, 8);
-
-    auto new_thread = std::thread(PropertyServiceThread, fd, listen_init);
-    t.swap(new_thread);
-}
-
 void StartPropertyService(int* epoll_socket) {
     InitPropertySet("ro.property_service.version", "2");
 
@@ -1514,9 +1493,19 @@ void StartPropertyService(int* epoll_socket) {
     init_socket = sockets[1];
     StartSendingMessages();
 
-    StartThread(PROP_SERVICE_FOR_SYSTEM_NAME, 0660, AID_SYSTEM, property_service_for_system_thread,
-                true);
-    StartThread(PROP_SERVICE_NAME, 0666, 0, property_service_thread, false);
+    if (auto result = CreateSocket(PROP_SERVICE_NAME, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
+                                   /*passcred=*/false, /*should_listen=*/false, 0666, /*uid=*/0,
+                                   /*gid=*/0, /*socketcon=*/{});
+        result.ok()) {
+        property_set_fd = *result;
+    } else {
+        LOG(FATAL) << "start_property_service socket creation failed: " << result.error();
+    }
+
+    listen(property_set_fd, 8);
+
+    auto new_thread = std::thread{PropertyServiceThread};
+    property_service_thread.swap(new_thread);
 
     auto async_persist_writes =
             android::base::GetBoolProperty("ro.property_service.async_persist_writes", false);

From 253445ce3ad507f41c61ebf0f829f75ee2c37509 Mon Sep 17 00:00:00 2001
From: Hao Chen <chenhaosjtuacm@google.com>
Date: Tue, 18 Jul 2023 18:46:34 +0000
Subject: [PATCH 0214/1487] threads.h: avoid defining gettid on glibc >= 2.30

The issue in https://bugs.chromium.org/p/chromium/issues/detail?id=1182060 also
exists on glibc 2.30 and 2.31 since `gettid` was Introduced in glibc 2.30.

See https://man7.org/linux/man-pages/man2/gettid.2.html

Bug: 285204695
Test: Build
Change-Id: I7e534edf8c0a20c415232bcfffabbf2c1d6eec98
---
 libcutils/include/cutils/threads.h | 2 +-
 libcutils/threads.cpp              | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/libcutils/include/cutils/threads.h b/libcutils/include/cutils/threads.h
index 0082c6c63445..18861840e28d 100644
--- a/libcutils/include/cutils/threads.h
+++ b/libcutils/include/cutils/threads.h
@@ -31,7 +31,7 @@ extern "C" {
 //
 // Deprecated: use android::base::GetThreadId instead, which doesn't truncate on Mac/Windows.
 //
-#if !defined(__GLIBC__) || __GLIBC__ >= 2 && __GLIBC_MINOR__ < 32
+#if !defined(__GLIBC__) || __GLIBC__ >= 2 && __GLIBC_MINOR__ < 30
 extern pid_t gettid();
 #endif
 
diff --git a/libcutils/threads.cpp b/libcutils/threads.cpp
index 6ece7a3afc93..2638720847d8 100644
--- a/libcutils/threads.cpp
+++ b/libcutils/threads.cpp
@@ -25,9 +25,9 @@
 #include <windows.h>
 #endif
 
-#if defined(__BIONIC__) || defined(__GLIBC__) && __GLIBC_MINOR__ >= 32
+#if defined(__BIONIC__) || defined(__GLIBC__) && __GLIBC_MINOR__ >= 30
 // No definition needed for Android because we'll just pick up bionic's copy.
-// No definition needed for Glibc >= 2.32 because it exposes its own copy.
+// No definition needed for Glibc >= 2.30 because it exposes its own copy.
 #else
 pid_t gettid() {
 #if defined(__APPLE__)

From 749becfa689186a6ab5cc6d83f9f470cced9b05c Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Thu, 13 Jul 2023 21:19:50 +0000
Subject: [PATCH 0215/1487] Fix libutils_fuzz_string8 deadlock.

Bug: 290835996
Test: libutils_fuzz_string8 for several minutes
Change-Id: I9b312dd968c380f4fa2a837d38121d0a7a7ac7b1
---
 libutils/String8_fuzz.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libutils/String8_fuzz.cpp b/libutils/String8_fuzz.cpp
index faf49b66b5ce..e5dcd316ecb0 100644
--- a/libutils/String8_fuzz.cpp
+++ b/libutils/String8_fuzz.cpp
@@ -45,6 +45,8 @@ std::vector<std::function<void(FuzzedDataProvider*, android::String8*, android::
                     str1->toLower();
                 },
                 [](FuzzedDataProvider*, android::String8* str1, android::String8* str2) -> void {
+                    if (str2->size() == 0) return;
+
                     str1->removeAll(str2->c_str());
                 },
                 [](FuzzedDataProvider*, android::String8* str1, android::String8* str2) -> void {

From 658182b8e7ce29c1e14ea0b96b147cd6a21f1144 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 18 Jul 2023 15:36:26 -0700
Subject: [PATCH 0216/1487] Adding documentation

adding --help documentation to fastboot for --disable-super-optimization
and --disable-fastboot-info

Test: fastboot -h
Change-Id: Ia8993b3894d302a63cc97796d66e0af3fb004eef
---
 fastboot/fastboot.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 61c7204daacd..b64888ace83a 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -630,6 +630,9 @@ static int show_help() {
             " --skip-reboot              Don't reboot device after flashing.\n"
             " --disable-verity           Sets disable-verity when flashing vbmeta.\n"
             " --disable-verification     Sets disable-verification when flashing vbmeta.\n"
+            " --disable-super-optimization\n"
+            "                            Disables optimizations on flashing super partition.\n"
+            " --disable-fastboot-info    Will collects tasks from image list rather than $OUT/fastboot-info.txt.\n"
             " --fs-options=OPTION[,OPTION]\n"
             "                            Enable filesystem features. OPTION supports casefold, projid, compress\n"
             // TODO: remove --unbuffered?

From c6ce48ef190d74b11c265076518dcc69f6fe4665 Mon Sep 17 00:00:00 2001
From: Eric Miao <ericymiao@google.com>
Date: Fri, 14 Jul 2023 16:35:09 -0700
Subject: [PATCH 0217/1487] String8: fix infinite loop and segmentation fault
 in removeAll()

Bug: 290835996
Test: libutils_fuzz_string8 for several minutes

String8::removeAll() has 2 serious problems:

1. When `other` is an empty string, `removeAll()` will loop infinitely
   due to below process:

   a) with `other` being empty string `""`, find() will call strstr()
      on an empty string, which always returns `mString`, and thus
      find() always return 0 in this case
   b) with find() returns 0 for empty string, the next while loop in
      String8::removeAll() will keep loop infinitely as `index` will
      always be 0

   This CL fixes this problem by returning true if `other` is an empty
   string (i.e. `strlen(other) == 0`), this follows the logic that an
   empty string will always be found and no actual remove needs to be
   done.

2. When `other` is a NULL string, strstr() has undefined behavior. See
   https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf.

   This undefined behavior on Android unfortunately causes immediate
   segmentation fault as the current `strstr` implementation in bionic
   libc doesn't check `needle` being NULL, and an access to a NULL
   location is performed to check if the `needle` string is an empty
   string, and thus causes segmentation fault.

   This CL gives an error message and aborts instead of having a
   segfault, and to keep some backward compatibility.

   This CL also adds test for String8::removeAll()

Change-Id: Ie2ccee6767efe0fed476db4ec6072717198279e9
---
 libutils/String8.cpp      |  5 +++++
 libutils/String8_test.cpp | 18 ++++++++++++++++++
 2 files changed, 23 insertions(+)

diff --git a/libutils/String8.cpp b/libutils/String8.cpp
index 82f5cb682b47..8d312b57ce2b 100644
--- a/libutils/String8.cpp
+++ b/libutils/String8.cpp
@@ -393,6 +393,11 @@ ssize_t String8::find(const char* other, size_t start) const
 }
 
 bool String8::removeAll(const char* other) {
+    ALOG_ASSERT(other, "String8::removeAll() requires a non-NULL string");
+
+    if (*other == '\0')
+        return true;
+
     ssize_t index = find(other);
     if (index < 0) return false;
 
diff --git a/libutils/String8_test.cpp b/libutils/String8_test.cpp
index 1356cd08f53b..35fd512f442d 100644
--- a/libutils/String8_test.cpp
+++ b/libutils/String8_test.cpp
@@ -114,3 +114,21 @@ TEST_F(String8Test, append) {
     EXPECT_EQ(NO_MEMORY, s.append("baz", SIZE_MAX));
     EXPECT_STREQ("foobar", s);
 }
+
+TEST_F(String8Test, removeAll) {
+    String8 s("Hello, world!");
+
+    // NULL input should cause an assertion failure and error message in logcat
+    EXPECT_DEATH(s.removeAll(NULL), "");
+
+    // expect to return true and string content should remain unchanged
+    EXPECT_TRUE(s.removeAll(""));
+    EXPECT_STREQ("Hello, world!", s);
+
+    // expect to return false
+    EXPECT_FALSE(s.removeAll("x"));
+    EXPECT_STREQ("Hello, world!", s);
+
+    EXPECT_TRUE(s.removeAll("o"));
+    EXPECT_STREQ("Hell, wrld!", s);
+}

From 7acaea6770021889d1745b8fb54b57b7cf10585a Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers@google.com>
Date: Wed, 19 Jul 2023 01:13:15 +0000
Subject: [PATCH 0218/1487] init.rc: stop calling 'fsverity_init
 --load-verified-keys'

Since Android 14, Android does not use fsverity builtin signatures.
(fsverity remains supported, but signatures are verified in userspace,
or fsverity is used for integrity-only use cases.)  Therefore, the only
reason to still run 'fsverity_init --load-verified-keys' at boot time is
to ensure that old files can still be opened, if:

- They were created by Android 13 or earlier, with an fsverity builtin
  signature by a key in /{system,product}/etc/security/fsverity/.

- *And*, the kernel still has CONFIG_FS_VERITY_BUILTIN_SIGNATURES=y.

However, it appears that this isn't actually needed anymore.  Only two
features could potentially be affected: APK verity and updatable fonts.
APK verity wasn't widely rolled out before being disabled, and updatable
fonts have recovery logic in place for when the files cannot be opened.
And in any case, disabling CONFIG_FS_VERITY_BUILTIN_SIGNATURES in the
kernel is recommended and would avoid any problem.

Bug: 290064770
Test: presubmit
Change-Id: I3376c3f0b4b9bd4ba2fd614259522be0c1daafb6
---
 rootdir/Android.bp | 5 +----
 rootdir/init.rc    | 3 ---
 2 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index e98733ada721..65865a65b4ea 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -20,10 +20,7 @@ prebuilt_etc {
     name: "init.rc",
     src: "init.rc",
     sub_dir: "init/hw",
-    required: [
-        "fsverity_init",
-        "platform-bootclasspath",
-    ],
+    required: ["platform-bootclasspath"],
 }
 
 prebuilt_etc {
diff --git a/rootdir/init.rc b/rootdir/init.rc
index d2499ef3816e..dec763ac1df9 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -629,9 +629,6 @@ on late-fs
     # HALs required before storage encryption can get unlocked (FBE)
     class_start early_hal
 
-    # Load trusted keys from dm-verity protected partitions
-    exec -- /system/bin/fsverity_init --load-verified-keys
-
 # Only enable the bootreceiver tracing instance for kernels 5.10 and above.
 on late-fs && property:ro.kernel.version=4.9
     setprop bootreceiver.enable 0

From e37743292464cd8ae4f3d198c318bbe4ab3e71a8 Mon Sep 17 00:00:00 2001
From: Jakob Vukalovic <jakobvukalovic@google.com>
Date: Tue, 11 Jul 2023 10:28:53 +0100
Subject: [PATCH 0219/1487] ueventd: Fix creation of VFIO dev nodes

VFIO nodes, both the container (`vfio`) node and group (numbered)
nodes, should be located in `/dev/vfio`. This change prevents
ueventd from flattening that structure.

Test: Bind a device to VFIO driver to create a VFIO group
Change-Id: I635e9febe6bb52718df263e735479f361eacad4c
---
 init/devices.cpp   | 2 ++
 rootdir/ueventd.rc | 6 ++++++
 2 files changed, 8 insertions(+)

diff --git a/init/devices.cpp b/init/devices.cpp
index d29ffd604f4e..7c234924b450 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -568,6 +568,8 @@ void DeviceHandler::HandleUevent(const Uevent& uevent) {
         return;
     } else if (uevent.subsystem == "misc" && StartsWith(uevent.device_name, "dm-user/")) {
         devpath = "/dev/dm-user/" + uevent.device_name.substr(8);
+    } else if (uevent.subsystem == "misc" && uevent.device_name == "vfio/vfio") {
+        devpath = "/dev/" + uevent.device_name;
     } else {
         devpath = "/dev/" + Basename(uevent.path);
     }
diff --git a/rootdir/ueventd.rc b/rootdir/ueventd.rc
index 0b7ffb8ea684..60dcc2a95c9f 100644
--- a/rootdir/ueventd.rc
+++ b/rootdir/ueventd.rc
@@ -23,6 +23,11 @@ subsystem sound
 subsystem dma_heap
    devname uevent_devpath
    dirname /dev/dma_heap
+
+subsystem vfio
+    devname uevent_devpath
+    dirname /dev/vfio
+
 # ueventd can only set permissions on device nodes and their associated
 # sysfs attributes, not on arbitrary paths.
 #
@@ -43,6 +48,7 @@ subsystem dma_heap
 /dev/binder               0666   root       root
 /dev/hwbinder             0666   root       root
 /dev/vndbinder            0666   root       root
+/dev/vfio/*               0666   root       root
 
 /dev/pmsg0                0222   root       log
 /dev/dma_heap/system      0444   system     system

From fb92cd3c22980e6ee6574be193f8ec993d19b2bf Mon Sep 17 00:00:00 2001
From: Stephen Crane <cranes@google.com>
Date: Mon, 17 Jul 2023 20:29:46 +0000
Subject: [PATCH 0220/1487] storageproxyd: Start binder thread pool

The Trusty storage proxy requires that the suspend service is started to
acquire a wakelock for UFS RPMB operations. Without the binder thread
pool running, starting this service results in at least a 1s polling
delay. This change ensures that we start the thread pool before handling
any RPMB operations, so acquiring the wakelock will complete as soon as
the service is ready without needing to poll once per second.

Test: m storageproxyd
Test: Artificially delay suspend_service to check if we poll
Bug: 281951047
Change-Id: I1a4cdd48d57201b0cf9c24523d22e5bdbcea376a
---
 trusty/storage/proxy/Android.bp |  1 +
 trusty/storage/proxy/proxy.c    | 10 ++++++++++
 trusty/storage/proxy/rpmb.c     |  8 ++++++++
 3 files changed, 19 insertions(+)

diff --git a/trusty/storage/proxy/Android.bp b/trusty/storage/proxy/Android.bp
index 2e97ee0fe568..e362b8b97e21 100644
--- a/trusty/storage/proxy/Android.bp
+++ b/trusty/storage/proxy/Android.bp
@@ -33,6 +33,7 @@ cc_binary {
 
     shared_libs: [
         "libbase",
+        "libbinder_ndk",
         "libcutils",
         "liblog",
         "libhardware_legacy",
diff --git a/trusty/storage/proxy/proxy.c b/trusty/storage/proxy/proxy.c
index c89c5b6fd21b..3b744ec9422f 100644
--- a/trusty/storage/proxy/proxy.c
+++ b/trusty/storage/proxy/proxy.c
@@ -24,6 +24,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
+#include <android/binder_process.h>
 #include <cutils/android_filesystem_config.h>
 
 #include "checkpoint_handling.h"
@@ -238,6 +239,15 @@ int main(int argc, char* argv[]) {
     /* parse arguments */
     parse_args(argc, argv);
 
+    /*
+     * Start binder threadpool. At least one extra binder thread is needed to
+     * connect to the wakelock service without relying on polling. If we poll on
+     * the main thread we end up pausing for at least 1s even if the service
+     * starts faster.
+     */
+    ABinderProcess_setThreadPoolMaxThreadCount(1);
+    ABinderProcess_startThreadPool();
+
     /* initialize secure storage directory */
     rc = storage_init(ss_data_root);
     if (rc < 0) return EXIT_FAILURE;
diff --git a/trusty/storage/proxy/rpmb.c b/trusty/storage/proxy/rpmb.c
index 22a85a72b717..1f5d1079699d 100644
--- a/trusty/storage/proxy/rpmb.c
+++ b/trusty/storage/proxy/rpmb.c
@@ -399,6 +399,14 @@ static int send_ufs_rpmb_req(int sg_fd, const struct storage_rpmb_send_req* req,
 
     bool is_request_write = req->reliable_write_size > 0;
 
+    /*
+     * Internally this call connects to the suspend service, which will cause
+     * this service to start if not already running. If the binder thread pool
+     * has not been started at this point, this call will block and poll for the
+     * service every 1s. We need to make sure the thread pool is started to
+     * receive an async notification that the service is started to avoid
+     * blocking (see main).
+     */
     wl_rc = acquire_wake_lock(PARTIAL_WAKE_LOCK, UFS_WAKE_LOCK_NAME);
     if (wl_rc < 0) {
         ALOGE("%s: failed to acquire wakelock: %d, %s\n", __func__, wl_rc, strerror(errno));

From e1132a9c2ff5a039fcdd33694fe42bd245d2fca8 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 19 Jul 2023 23:03:54 -0700
Subject: [PATCH 0221/1487] snapuserd: Fix ubsan when reading a single aligned
 sector.

When a read request is for a single sector, and the sector is
block-aligned, it falls into the ReadAlignedSector path, which assumes
block-sized reads. Fix this by clamping the expected size.

Bug: 291862304
Test: manual test of ReadWorker::ReadAlignedSector
      full OTA
Change-Id: I00e460c333e8a9a4dc2433443e3633f3d794da1d
---
 fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index 7268fca1e1cc..7d2e3a613746 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -305,7 +305,7 @@ bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
                     return false;
                 }
 
-                ret = BLOCK_SZ;
+                ret = std::min(BLOCK_SZ, read_size);
             }
 
             read_size -= ret;

From 908056efeb612c57eee789aef43229487bce6b27 Mon Sep 17 00:00:00 2001
From: Mitchell Wills <mwills@google.com>
Date: Thu, 20 Jul 2023 05:32:03 +0000
Subject: [PATCH 0222/1487] Add logs in SuperLayoutBuilder::Open when the
 metadata isn't supported

Change-Id: Ic9733775616b642f669ceb7459cccd33631ae12b
---
 fs_mgr/liblp/super_layout_builder.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/fs_mgr/liblp/super_layout_builder.cpp b/fs_mgr/liblp/super_layout_builder.cpp
index 37f28e124102..5349e41a9a69 100644
--- a/fs_mgr/liblp/super_layout_builder.cpp
+++ b/fs_mgr/liblp/super_layout_builder.cpp
@@ -46,21 +46,21 @@ bool SuperLayoutBuilder::Open(const void* data, size_t size) {
 bool SuperLayoutBuilder::Open(const LpMetadata& metadata) {
     for (const auto& partition : metadata.partitions) {
         if (partition.attributes & LP_PARTITION_ATTR_SLOT_SUFFIXED) {
-            // Retrofit devices are not supported.
+            LOG(ERROR) << "Retrofit devices are not supported";
             return false;
         }
         if (!(partition.attributes & LP_PARTITION_ATTR_READONLY)) {
-            // Writable partitions are not supported.
+            LOG(ERROR) << "Writable partitions are not supported";
             return false;
         }
     }
     if (!metadata.extents.empty()) {
-        // Partitions that already have extents are not supported (should
-        // never be true of super_empty.img).
+        LOG(ERROR) << "Partitions that already have extents are not supported";
+        // should never be true of super_empty.img.
         return false;
     }
     if (metadata.block_devices.size() != 1) {
-        // Only one "super" is supported.
+        LOG(ERROR) << "Only one 'super' is supported";
         return false;
     }
 

From 4d6fa8ccaf37f5ba5b501036cd187a184f119438 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Thu, 20 Jul 2023 18:41:15 +0800
Subject: [PATCH 0223/1487] init_first_stage: Disable ThinLTO

Static executables + x86 target build + ThinLTO produces bug behavior.
Global variables are not constructor initialized, resulting in faulty
runtime behavior.

Bug: 169004486
Bug: 291033685
Test: Treehugger
Change-Id: I777016cceb4851f2b432a37bc4d29aed56c23804
---
 init/Android.bp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/init/Android.bp b/init/Android.bp
index 1af398a9a0ae..0b8c7dc0971d 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -394,6 +394,10 @@ init_first_stage_cc_defaults {
     ],
 
     static_executable: true,
+    lto: {
+        // b/169004486 ThinLTO breaks x86 static executables.
+        never: true,
+    },
     system_shared_libs: [],
 
     cflags: [

From 1310d7a6d6d665299f4aa8b485809a78eba0ad9b Mon Sep 17 00:00:00 2001
From: Stephen Crane <cranes@google.com>
Date: Mon, 17 Jul 2023 20:29:46 +0000
Subject: [PATCH 0224/1487] storageproxyd: Start binder thread pool

The Trusty storage proxy requires that the suspend service is started to
acquire a wakelock for UFS RPMB operations. Without the binder thread
pool running, starting this service results in at least a 1s polling
delay. This change ensures that we start the thread pool before handling
any RPMB operations, so acquiring the wakelock will complete as soon as
the service is ready without needing to poll once per second.

Test: m storageproxyd
Test: Artificially delay suspend_service to check if we poll
Bug: 281951047
(cherry picked from https://android-review.googlesource.com/q/commit:fb92cd3c22980e6ee6574be193f8ec993d19b2bf)
Merged-In: I1a4cdd48d57201b0cf9c24523d22e5bdbcea376a
Change-Id: I1a4cdd48d57201b0cf9c24523d22e5bdbcea376a
---
 trusty/storage/proxy/Android.bp |  1 +
 trusty/storage/proxy/proxy.c    | 10 ++++++++++
 trusty/storage/proxy/rpmb.c     |  8 ++++++++
 3 files changed, 19 insertions(+)

diff --git a/trusty/storage/proxy/Android.bp b/trusty/storage/proxy/Android.bp
index 2e97ee0fe568..e362b8b97e21 100644
--- a/trusty/storage/proxy/Android.bp
+++ b/trusty/storage/proxy/Android.bp
@@ -33,6 +33,7 @@ cc_binary {
 
     shared_libs: [
         "libbase",
+        "libbinder_ndk",
         "libcutils",
         "liblog",
         "libhardware_legacy",
diff --git a/trusty/storage/proxy/proxy.c b/trusty/storage/proxy/proxy.c
index c89c5b6fd21b..3b744ec9422f 100644
--- a/trusty/storage/proxy/proxy.c
+++ b/trusty/storage/proxy/proxy.c
@@ -24,6 +24,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
+#include <android/binder_process.h>
 #include <cutils/android_filesystem_config.h>
 
 #include "checkpoint_handling.h"
@@ -238,6 +239,15 @@ int main(int argc, char* argv[]) {
     /* parse arguments */
     parse_args(argc, argv);
 
+    /*
+     * Start binder threadpool. At least one extra binder thread is needed to
+     * connect to the wakelock service without relying on polling. If we poll on
+     * the main thread we end up pausing for at least 1s even if the service
+     * starts faster.
+     */
+    ABinderProcess_setThreadPoolMaxThreadCount(1);
+    ABinderProcess_startThreadPool();
+
     /* initialize secure storage directory */
     rc = storage_init(ss_data_root);
     if (rc < 0) return EXIT_FAILURE;
diff --git a/trusty/storage/proxy/rpmb.c b/trusty/storage/proxy/rpmb.c
index 22a85a72b717..1f5d1079699d 100644
--- a/trusty/storage/proxy/rpmb.c
+++ b/trusty/storage/proxy/rpmb.c
@@ -399,6 +399,14 @@ static int send_ufs_rpmb_req(int sg_fd, const struct storage_rpmb_send_req* req,
 
     bool is_request_write = req->reliable_write_size > 0;
 
+    /*
+     * Internally this call connects to the suspend service, which will cause
+     * this service to start if not already running. If the binder thread pool
+     * has not been started at this point, this call will block and poll for the
+     * service every 1s. We need to make sure the thread pool is started to
+     * receive an async notification that the service is started to avoid
+     * blocking (see main).
+     */
     wl_rc = acquire_wake_lock(PARTIAL_WAKE_LOCK, UFS_WAKE_LOCK_NAME);
     if (wl_rc < 0) {
         ALOGE("%s: failed to acquire wakelock: %d, %s\n", __func__, wl_rc, strerror(errno));

From bf2bebd8e74908317a76c11f1951c67c0910eefb Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 21 Jul 2023 00:31:06 +0000
Subject: [PATCH 0225/1487] libprocessgroup: UIDs in linux are unsigned

We use the %d format specificier for uid_t, which maps to
__kernel_uid32_t, which is unsigned. [1] This is undefined behavior
which can lead to paths with negative UIDs when erroneously large
values are passed for uid:

E libprocessgroup: No such cgroup attribute: /sys/fs/cgroup/uid_-89846/cgroup.freeze

Fix it with %u.

[1] https://cs.android.com/search?q=typedef.*__kernel_uid32_t&ss=android%2Fplatform%2Fsuperproject%2Fmain

Change-Id: Ibb52ba2503e30e2f20770b7d23629167e38d076a
---
 libprocessgroup/task_profiles.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 44dba2a16694..1276a72a6ad0 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -146,7 +146,7 @@ bool ProfileAttribute::GetPathForUID(uid_t uid, std::string* path) const {
 
     const std::string& file_name =
             controller()->version() == 2 && !file_v2_name_.empty() ? file_v2_name_ : file_name_;
-    *path = StringPrintf("%s/uid_%d/%s", controller()->path(), uid, file_name.c_str());
+    *path = StringPrintf("%s/uid_%u/%s", controller()->path(), uid, file_name.c_str());
     return true;
 }
 

From b2e0edcaae52804484278340813a1556db8f95ac Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Fri, 21 Jul 2023 16:19:13 +0800
Subject: [PATCH 0226/1487] fs_mgr_overlayfs: Make all string constants
 constexpr

According to https://abseil.io/tips/140, string constants should be
constexpr char array or string_view object. This avoids subtle bugs due
to the toolchain shuffling object initialization order between/within
compilation units.

string_view has bad interoperability between C APIs as many of those
functions require string values to be null-terminated. Thus we can only
rely on good old c-string constants.

This change groups all string constants together and change them all to
constexpr char array for consistent style.
Also remove some duplicated method definition.

Test: adb-remount-test
Change-Id: I1ed57e6dc24ce3750e72c5538c388a6872cd2b40
---
 fs_mgr/fs_mgr_overlayfs_control.cpp | 117 ++++------------------------
 fs_mgr/fs_mgr_overlayfs_mount.cpp   |  26 +++----
 fs_mgr/fs_mgr_overlayfs_mount.h     |  21 ++---
 3 files changed, 36 insertions(+), 128 deletions(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_control.cpp b/fs_mgr/fs_mgr_overlayfs_control.cpp
index 69a2ac028c6c..c9a8997f6cb1 100644
--- a/fs_mgr/fs_mgr_overlayfs_control.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_control.cpp
@@ -71,15 +71,18 @@ namespace {
 
 constexpr char kDataScratchSizeMbProp[] = "fs_mgr.overlayfs.data_scratch_size_mb";
 
+constexpr char kPhysicalDevice[] = "/dev/block/by-name/";
+constexpr char kScratchImageMetadata[] = "/metadata/gsi/remount/lp_metadata";
+
+constexpr char kMkF2fs[] = "/system/bin/make_f2fs";
+constexpr char kMkExt4[] = "/system/bin/mke2fs";
+
 // Return true if everything is mounted, but before adb is started.  Right
 // after 'trigger load_persist_props_action' is done.
 static bool fs_mgr_boot_completed() {
     return android::base::GetBoolProperty("ro.persistent_properties.ready", false);
 }
 
-constexpr auto kPhysicalDevice = "/dev/block/by-name/";
-constexpr char kScratchImageMetadata[] = "/metadata/gsi/remount/lp_metadata";
-
 // Note: this is meant only for recovery/first-stage init.
 static bool ScratchIsOnData() {
     // The scratch partition of DSU is managed by gsid.
@@ -131,7 +134,7 @@ static bool fs_mgr_rm_all(const std::string& path, bool* change = nullptr, int l
 }
 
 std::string fs_mgr_overlayfs_setup_dir(const std::string& dir) {
-    auto top = dir + kOverlayTopDir;
+    auto top = dir + "/" + kOverlayTopDir;
 
     AutoSetFsCreateCon createcon(kOverlayfsFileContext);
     if (!createcon.Ok()) {
@@ -290,7 +293,7 @@ OverlayfsTeardownResult fs_mgr_overlayfs_teardown_scratch(const std::string& ove
 
 bool fs_mgr_overlayfs_teardown_one(const std::string& overlay, const std::string& mount_point,
                                    bool* change, bool* should_destroy_scratch = nullptr) {
-    const auto top = overlay + kOverlayTopDir;
+    const auto top = overlay + "/" + kOverlayTopDir;
 
     if (!fs_mgr_access(top)) {
         if (should_destroy_scratch) *should_destroy_scratch = true;
@@ -300,7 +303,7 @@ bool fs_mgr_overlayfs_teardown_one(const std::string& overlay, const std::string
     auto cleanup_all = mount_point.empty();
     const auto partition_name = android::base::Basename(mount_point);
     const auto oldpath = top + (cleanup_all ? "" : ("/" + partition_name));
-    const auto newpath = cleanup_all ? overlay + "/." + (kOverlayTopDir + 1) + ".teardown"
+    const auto newpath = cleanup_all ? overlay + "/." + kOverlayTopDir + ".teardown"
                                      : top + "/." + partition_name + ".teardown";
     auto ret = fs_mgr_rm_all(newpath);
     if (!rename(oldpath.c_str(), newpath.c_str())) {
@@ -346,72 +349,6 @@ bool fs_mgr_overlayfs_teardown_one(const std::string& overlay, const std::string
     return ret;
 }
 
-// Mount kScratchMountPoint
-bool MountScratch(const std::string& device_path, bool readonly = false) {
-    if (readonly) {
-        if (!fs_mgr_access(device_path)) {
-            LOG(ERROR) << "Path does not exist: " << device_path;
-            return false;
-        }
-    } else if (!fs_mgr_rw_access(device_path)) {
-        LOG(ERROR) << "Path does not exist or is not readwrite: " << device_path;
-        return false;
-    }
-
-    std::vector<const char*> filesystem_candidates;
-    if (fs_mgr_is_f2fs(device_path)) {
-        filesystem_candidates = {"f2fs", "ext4"};
-    } else if (fs_mgr_is_ext4(device_path)) {
-        filesystem_candidates = {"ext4", "f2fs"};
-    } else {
-        LOG(ERROR) << "Scratch partition is not f2fs or ext4";
-        return false;
-    }
-
-    AutoSetFsCreateCon createcon(kOverlayfsFileContext);
-    if (!createcon.Ok()) {
-        return false;
-    }
-    if (mkdir(kScratchMountPoint, 0755) && (errno != EEXIST)) {
-        PERROR << "create " << kScratchMountPoint;
-        return false;
-    }
-
-    FstabEntry entry;
-    entry.blk_device = device_path;
-    entry.mount_point = kScratchMountPoint;
-    entry.flags = MS_NOATIME | MS_RDONLY;
-    if (!readonly) {
-        entry.flags &= ~MS_RDONLY;
-        entry.flags |= MS_SYNCHRONOUS;
-        entry.fs_options = "nodiscard";
-        fs_mgr_set_blk_ro(device_path, false);
-    }
-    // check_fs requires apex runtime library
-    if (fs_mgr_overlayfs_already_mounted("/data", false)) {
-        entry.fs_mgr_flags.check = true;
-    }
-    bool mounted = false;
-    for (auto fs_type : filesystem_candidates) {
-        entry.fs_type = fs_type;
-        if (fs_mgr_do_mount_one(entry) == 0) {
-            mounted = true;
-            break;
-        }
-    }
-    if (!createcon.Restore()) {
-        return false;
-    }
-    if (!mounted) {
-        rmdir(kScratchMountPoint);
-        return false;
-    }
-    return true;
-}
-
-const std::string kMkF2fs("/system/bin/make_f2fs");
-const std::string kMkExt4("/system/bin/mke2fs");
-
 // Note: The scratch partition of DSU is managed by gsid, and should be initialized during
 // first-stage-mount. Just check if the DM device for DSU scratch partition is created or not.
 static std::string GetDsuScratchDevice() {
@@ -456,14 +393,14 @@ bool MakeScratchFilesystem(const std::string& scratch_device) {
     // thus do not rely on fsck to correct problems that could creep in.
     auto fs_type = ""s;
     auto command = ""s;
-    if (!access(kMkF2fs.c_str(), X_OK) && fs_mgr_filesystem_available("f2fs")) {
+    if (!access(kMkF2fs, X_OK) && fs_mgr_filesystem_available("f2fs")) {
         fs_type = "f2fs";
-        command = kMkF2fs + " -w ";
+        command = kMkF2fs + " -w "s;
         command += std::to_string(getpagesize());
         command += " -f -d1 -l" + android::base::Basename(kScratchMountPoint);
-    } else if (!access(kMkExt4.c_str(), X_OK) && fs_mgr_filesystem_available("ext4")) {
+    } else if (!access(kMkExt4, X_OK) && fs_mgr_filesystem_available("ext4")) {
         fs_type = "ext4";
-        command = kMkExt4 + " -F -b 4096 -t ext4 -m 0 -O has_journal -M " + kScratchMountPoint;
+        command = kMkExt4 + " -F -b 4096 -t ext4 -m 0 -O has_journal -M "s + kScratchMountPoint;
     } else {
         LERROR << "No supported mkfs command or filesystem driver available, supported filesystems "
                   "are: f2fs, ext4";
@@ -697,7 +634,7 @@ bool fs_mgr_overlayfs_setup_scratch(const Fstab& fstab) {
     // If the partition exists, assume first that it can be mounted.
     if (partition_exists) {
         if (MountScratch(scratch_device)) {
-            if (fs_mgr_access(std::string(kScratchMountPoint) + kOverlayTopDir) ||
+            if (fs_mgr_access(kScratchMountPoint + "/"s + kOverlayTopDir) ||
                 fs_mgr_filesystem_has_space(kScratchMountPoint)) {
                 return true;
             }
@@ -717,32 +654,6 @@ bool fs_mgr_overlayfs_setup_scratch(const Fstab& fstab) {
     return MountScratch(scratch_device);
 }
 
-// NOTE: OverlayfsSetupAllowed() must be "stricter" than OverlayfsTeardownAllowed().
-// Setup is allowed only if teardown is also allowed.
-bool OverlayfsSetupAllowed(bool verbose = false) {
-    if (!kAllowOverlayfs) {
-        if (verbose) {
-            LOG(ERROR) << "Overlayfs remounts can only be used in debuggable builds";
-        }
-        return false;
-    }
-    // Check mandatory kernel patches.
-    if (fs_mgr_overlayfs_valid() == OverlayfsValidResult::kNotSupported) {
-        if (verbose) {
-            LOG(ERROR) << "Kernel does not support overlayfs";
-        }
-        return false;
-    }
-    // in recovery or fastbootd, not allowed!
-    if (fs_mgr_in_recovery()) {
-        if (verbose) {
-            LOG(ERROR) << "Unsupported overlayfs setup from recovery";
-        }
-        return false;
-    }
-    return true;
-}
-
 constexpr bool OverlayfsTeardownAllowed() {
     // Never allow on non-debuggable build.
     return kAllowOverlayfs;
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index c057c2bc1369..e380f8401112 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -62,13 +62,16 @@ using namespace android::storage_literals;
 
 constexpr char kPreferCacheBackingStorageProp[] = "fs_mgr.overlayfs.prefer_cache_backing_storage";
 
+constexpr char kCacheMountPoint[] = "/cache";
+constexpr char kPhysicalDevice[] = "/dev/block/by-name/";
+
+constexpr char kLowerdirOption[] = "lowerdir=";
+constexpr char kUpperdirOption[] = "upperdir=";
+
 bool fs_mgr_access(const std::string& path) {
     return access(path.c_str(), F_OK) == 0;
 }
 
-const auto kLowerdirOption = "lowerdir=";
-const auto kUpperdirOption = "upperdir=";
-
 bool fs_mgr_in_recovery() {
     // Check the existence of recovery binary instead of using the compile time
     // __ANDROID_RECOVERY__ macro.
@@ -89,8 +92,6 @@ bool fs_mgr_is_dsu_running() {
     return android::gsi::IsGsiRunning();
 }
 
-const auto kCacheMountPoint = "/cache";
-
 static bool IsABDevice() {
     return !android::base::GetProperty("ro.boot.slot_suffix", "").empty();
 }
@@ -141,8 +142,6 @@ bool fs_mgr_filesystem_has_space(const std::string& mount_point) {
            (static_cast<uint64_t>(vst.f_bfree) * vst.f_frsize) >= kSizeThreshold;
 }
 
-const auto kPhysicalDevice = "/dev/block/by-name/";
-
 static bool fs_mgr_update_blk_device(FstabEntry* entry) {
     if (entry->fs_mgr_flags.logical) {
         fs_mgr_update_logical_partition(entry);
@@ -155,7 +154,7 @@ static bool fs_mgr_update_blk_device(FstabEntry* entry) {
     }
 
     // special case for system-as-root (taimen and others)
-    auto blk_device = std::string(kPhysicalDevice) + "system";
+    auto blk_device = kPhysicalDevice + "system"s;
     if (!fs_mgr_access(blk_device)) {
         blk_device += fs_mgr_get_slot_suffix();
         if (!fs_mgr_access(blk_device)) {
@@ -237,7 +236,7 @@ static std::string fs_mgr_get_overlayfs_candidate(const std::string& mount_point
     if (!fs_mgr_is_dir(mount_point)) return "";
     const auto base = android::base::Basename(mount_point) + "/";
     for (const auto& overlay_mount_point : OverlayMountPoints()) {
-        auto dir = overlay_mount_point + kOverlayTopDir + "/" + base;
+        auto dir = overlay_mount_point + "/" + kOverlayTopDir + "/" + base;
         auto upper = dir + kUpperName;
         if (!fs_mgr_is_dir(upper)) continue;
         auto work = dir + kWorkName;
@@ -527,7 +526,7 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
 }
 
 // Mount kScratchMountPoint
-static bool MountScratch(const std::string& device_path, bool readonly = false) {
+bool MountScratch(const std::string& device_path, bool readonly) {
     if (readonly) {
         if (!fs_mgr_access(device_path)) {
             LOG(ERROR) << "Path does not exist: " << device_path;
@@ -589,9 +588,6 @@ static bool MountScratch(const std::string& device_path, bool readonly = false)
     return true;
 }
 
-const std::string kMkF2fs("/system/bin/make_f2fs");
-const std::string kMkExt4("/system/bin/mke2fs");
-
 // Note: The scratch partition of DSU is managed by gsid, and should be initialized during
 // first-stage-mount. Just check if the DM device for DSU scratch partition is created or not.
 static std::string GetDsuScratchDevice() {
@@ -633,7 +629,7 @@ static std::string GetBootScratchDevice() {
 
 // NOTE: OverlayfsSetupAllowed() must be "stricter" than OverlayfsTeardownAllowed().
 // Setup is allowed only if teardown is also allowed.
-bool OverlayfsSetupAllowed(bool verbose = false) {
+bool OverlayfsSetupAllowed(bool verbose) {
     if (!kAllowOverlayfs) {
         if (verbose) {
             LOG(ERROR) << "Overlayfs remounts can only be used in debuggable builds";
@@ -737,7 +733,7 @@ static void TryMountScratch() {
     if (!MountScratch(scratch_device, true /* readonly */)) {
         return;
     }
-    auto has_overlayfs_dir = fs_mgr_access(std::string(kScratchMountPoint) + kOverlayTopDir);
+    auto has_overlayfs_dir = fs_mgr_access(kScratchMountPoint + "/"s + kOverlayTopDir);
     fs_mgr_overlayfs_umount_scratch();
     if (has_overlayfs_dir) {
         MountScratch(scratch_device);
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.h b/fs_mgr/fs_mgr_overlayfs_mount.h
index ae3ea84edab6..d9a93d4ac50a 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.h
+++ b/fs_mgr/fs_mgr_overlayfs_mount.h
@@ -20,9 +20,12 @@
 
 #include <fstab/fstab.h>
 
-bool fs_mgr_overlayfs_already_mounted(const std::string& mount_point, bool overlay_only = true);
-bool fs_mgr_wants_overlayfs(android::fs_mgr::FstabEntry* entry);
-android::fs_mgr::Fstab fs_mgr_overlayfs_candidate_list(const android::fs_mgr::Fstab& fstab);
+constexpr char kOverlayfsFileContext[] = "u:object_r:overlayfs_file:s0";
+
+constexpr char kScratchMountPoint[] = "/mnt/scratch";
+constexpr char kOverlayTopDir[] = "overlay";
+constexpr char kUpperName[] = "upper";
+constexpr char kWorkName[] = "work";
 
 #if ALLOW_ADBD_DISABLE_VERITY
 constexpr bool kAllowOverlayfs = true;
@@ -45,18 +48,16 @@ class AutoSetFsCreateCon final {
     bool restored_ = false;
 };
 
-constexpr auto kScratchMountPoint = "/mnt/scratch";
-constexpr char kOverlayfsFileContext[] = "u:object_r:overlayfs_file:s0";
-
-constexpr auto kUpperName = "upper";
-constexpr auto kWorkName = "work";
-constexpr auto kOverlayTopDir = "/overlay";
-
 bool fs_mgr_is_dsu_running();
 bool fs_mgr_in_recovery();
 bool fs_mgr_access(const std::string& path);
 bool fs_mgr_rw_access(const std::string& path);
 bool fs_mgr_filesystem_has_space(const std::string& mount_point);
 const std::string fs_mgr_mount_point(const std::string& mount_point);
+bool OverlayfsSetupAllowed(bool verbose = false);
+bool MountScratch(const std::string& device_path, bool readonly = false);
 bool fs_mgr_overlayfs_umount_scratch();
 std::vector<const std::string> OverlayMountPoints();
+bool fs_mgr_overlayfs_already_mounted(const std::string& mount_point, bool overlay_only = true);
+bool fs_mgr_wants_overlayfs(android::fs_mgr::FstabEntry* entry);
+android::fs_mgr::Fstab fs_mgr_overlayfs_candidate_list(const android::fs_mgr::Fstab& fstab);

From 98e3522762797ecadca62a5732372c51b60dfc59 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Fri, 21 Jul 2023 22:31:59 +0800
Subject: [PATCH 0227/1487] fs_mgr: Refactor by inlining trivial helpers

Inline some trivial helpers and remove unused header declarations.

Remove fs_mgr_*access() as it is really just access().
Remove fs_mgr_overlayfs_super_device() as we always want the primary
slot and having this wrapper isn't particularly helpful.

Test: adb-remount-test
Change-Id: I2581fd7c7d5071cbb97778535b7811dbcb80d76e
---
 fs_mgr/fs_mgr_fstab.cpp             | 26 ++++++++------
 fs_mgr/fs_mgr_overlayfs_control.cpp | 40 +++++++--------------
 fs_mgr/fs_mgr_overlayfs_control.h   |  2 --
 fs_mgr/fs_mgr_overlayfs_mount.cpp   | 54 +++++++----------------------
 fs_mgr/fs_mgr_overlayfs_mount.h     |  3 --
 fs_mgr/fs_mgr_priv.h                |  2 --
 fs_mgr/include_fstab/fstab/fstab.h  |  2 ++
 7 files changed, 43 insertions(+), 86 deletions(-)

diff --git a/fs_mgr/fs_mgr_fstab.cpp b/fs_mgr/fs_mgr_fstab.cpp
index c85e83116bde..ca27034f4451 100644
--- a/fs_mgr/fs_mgr_fstab.cpp
+++ b/fs_mgr/fs_mgr_fstab.cpp
@@ -328,8 +328,7 @@ bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
     // some recovery fstabs still contain the FDE options since they didn't do
     // anything in recovery mode anyway (except possibly to cause the
     // reservation of a crypto footer) and thus never got removed.
-    if (entry->fs_mgr_flags.crypt && !entry->fs_mgr_flags.vold_managed &&
-        access("/system/bin/recovery", F_OK) != 0) {
+    if (entry->fs_mgr_flags.crypt && !entry->fs_mgr_flags.vold_managed && !InRecovery()) {
         LERROR << "FDE is no longer supported; 'encryptable' can only be used for adoptable "
                   "storage";
         return false;
@@ -520,6 +519,9 @@ std::vector<FstabPtrEntryType*> GetEntriesByPred(FstabPtr fstab, const Pred& pre
 // ramdisk's copy of the fstab had to be located in the root directory, but now
 // the system/etc directory is supported too and is the preferred location.
 std::string GetFstabPath() {
+    if (InRecovery()) {
+        return "/etc/recovery.fstab";
+    }
     for (const char* prop : {"fstab_suffix", "hardware", "hardware.platform"}) {
         std::string suffix;
 
@@ -835,15 +837,8 @@ bool ReadDefaultFstab(Fstab* fstab) {
     fstab->clear();
     ReadFstabFromDt(fstab, false /* verbose */);
 
-    std::string default_fstab_path;
-    // Use different fstab paths for normal boot and recovery boot, respectively
-    if ((access("/sbin/recovery", F_OK) == 0) || (access("/system/bin/recovery", F_OK) == 0)) {
-        default_fstab_path = "/etc/recovery.fstab";
-    } else {  // normal boot
-        default_fstab_path = GetFstabPath();
-    }
-
     Fstab default_fstab;
+    const std::string default_fstab_path = GetFstabPath();
     if (!default_fstab_path.empty() && ReadFstabFromFile(default_fstab_path, &default_fstab)) {
         for (auto&& entry : default_fstab) {
             fstab->emplace_back(std::move(entry));
@@ -936,6 +931,17 @@ std::string GetVerityDeviceName(const FstabEntry& entry) {
     return base_device + "-verity";
 }
 
+bool InRecovery() {
+    // Check the existence of recovery binary instead of using the compile time
+    // __ANDROID_RECOVERY__ macro.
+    // If BOARD_USES_RECOVERY_AS_BOOT is true, both normal and recovery boot
+    // mode would use the same init binary, which would mean during normal boot
+    // the '/init' binary is actually a symlink pointing to
+    // init_second_stage.recovery, which would be compiled with
+    // __ANDROID_RECOVERY__ defined.
+    return access("/system/bin/recovery", F_OK) == 0 || access("/sbin/recovery", F_OK) == 0;
+}
+
 }  // namespace fs_mgr
 }  // namespace android
 
diff --git a/fs_mgr/fs_mgr_overlayfs_control.cpp b/fs_mgr/fs_mgr_overlayfs_control.cpp
index c9a8997f6cb1..68576f22086d 100644
--- a/fs_mgr/fs_mgr_overlayfs_control.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_control.cpp
@@ -18,17 +18,10 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/fs.h>
-#include <selinux/selinux.h>
-#include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
-#include <sys/mount.h>
-#include <sys/param.h>
 #include <sys/stat.h>
 #include <sys/statvfs.h>
 #include <sys/types.h>
-#include <sys/utsname.h>
-#include <sys/vfs.h>
 #include <unistd.h>
 
 #include <algorithm>
@@ -38,13 +31,9 @@
 #include <vector>
 
 #include <android-base/file.h>
-#include <android-base/macros.h>
 #include <android-base/properties.h>
 #include <android-base/strings.h>
-#include <android-base/unique_fd.h>
-#include <ext4_utils/ext4_utils.h>
 #include <fs_mgr.h>
-#include <fs_mgr/file_wait.h>
 #include <fs_mgr_dm_linear.h>
 #include <fs_mgr_overlayfs.h>
 #include <fstab/fstab.h>
@@ -89,7 +78,7 @@ static bool ScratchIsOnData() {
     if (fs_mgr_is_dsu_running()) {
         return false;
     }
-    return fs_mgr_access(kScratchImageMetadata);
+    return access(kScratchImageMetadata, F_OK) == 0;
 }
 
 static bool fs_mgr_rm_all(const std::string& path, bool* change = nullptr, int level = 0) {
@@ -198,10 +187,6 @@ static uint32_t fs_mgr_overlayfs_slot_number() {
     return SlotNumberForSlotSuffix(fs_mgr_get_slot_suffix());
 }
 
-static std::string fs_mgr_overlayfs_super_device(uint32_t slot_number) {
-    return kPhysicalDevice + fs_mgr_get_super_partition_name(slot_number);
-}
-
 static bool fs_mgr_overlayfs_has_logical(const Fstab& fstab) {
     for (const auto& entry : fstab) {
         if (entry.fs_mgr_flags.logical) {
@@ -261,8 +246,8 @@ OverlayfsTeardownResult fs_mgr_overlayfs_teardown_scratch(const std::string& ove
     }
 
     auto slot_number = fs_mgr_overlayfs_slot_number();
-    auto super_device = fs_mgr_overlayfs_super_device(slot_number);
-    if (!fs_mgr_rw_access(super_device)) {
+    const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();
+    if (access(super_device.c_str(), R_OK | W_OK)) {
         return OverlayfsTeardownResult::Ok;
     }
 
@@ -295,7 +280,7 @@ bool fs_mgr_overlayfs_teardown_one(const std::string& overlay, const std::string
                                    bool* change, bool* should_destroy_scratch = nullptr) {
     const auto top = overlay + "/" + kOverlayTopDir;
 
-    if (!fs_mgr_access(top)) {
+    if (access(top.c_str(), F_OK)) {
         if (should_destroy_scratch) *should_destroy_scratch = true;
         return true;
     }
@@ -443,7 +428,7 @@ static bool CreateDynamicScratch(std::string* scratch_device, bool* partition_ex
 
     auto partition_create = !*partition_exists;
     auto slot_number = fs_mgr_overlayfs_slot_number();
-    auto super_device = fs_mgr_overlayfs_super_device(slot_number);
+    const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();
     auto builder = MetadataBuilder::New(super_device, slot_number);
     if (!builder) {
         LERROR << "open " << super_device << " metadata";
@@ -583,8 +568,8 @@ static bool CreateScratchOnData(std::string* scratch_device, bool* partition_exi
 
 static bool CanUseSuperPartition(const Fstab& fstab) {
     auto slot_number = fs_mgr_overlayfs_slot_number();
-    auto super_device = fs_mgr_overlayfs_super_device(slot_number);
-    if (!fs_mgr_rw_access(super_device) || !fs_mgr_overlayfs_has_logical(fstab)) {
+    const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();
+    if (access(super_device.c_str(), R_OK | W_OK) || !fs_mgr_overlayfs_has_logical(fstab)) {
         return false;
     }
     auto metadata = ReadMetadata(super_device, slot_number);
@@ -634,8 +619,8 @@ bool fs_mgr_overlayfs_setup_scratch(const Fstab& fstab) {
     // If the partition exists, assume first that it can be mounted.
     if (partition_exists) {
         if (MountScratch(scratch_device)) {
-            if (fs_mgr_access(kScratchMountPoint + "/"s + kOverlayTopDir) ||
-                fs_mgr_filesystem_has_space(kScratchMountPoint)) {
+            const auto top = kScratchMountPoint + "/"s + kOverlayTopDir;
+            if (access(top.c_str(), F_OK) == 0 || fs_mgr_filesystem_has_space(kScratchMountPoint)) {
                 return true;
             }
             // declare it useless, no overrides and no free space
@@ -755,7 +740,7 @@ static std::optional<MapInfo> EnsureScratchMapped() {
     if (!info.device.empty()) {
         return {std::move(info)};
     }
-    if (!fs_mgr_in_recovery()) {
+    if (!InRecovery()) {
         return {};
     }
 
@@ -778,8 +763,7 @@ static std::optional<MapInfo> EnsureScratchMapped() {
     }
 
     // Avoid uart spam by first checking for a scratch partition.
-    auto metadata_slot = fs_mgr_overlayfs_slot_number();
-    auto super_device = fs_mgr_overlayfs_super_device(metadata_slot);
+    const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();
     auto metadata = ReadCurrentMetadata(super_device);
     if (!metadata) {
         return {};
@@ -941,7 +925,7 @@ void TeardownAllOverlayForMountPoint(const std::string& mount_point) {
     if (!OverlayfsTeardownAllowed()) {
         return;
     }
-    if (!fs_mgr_in_recovery()) {
+    if (!InRecovery()) {
         LERROR << __FUNCTION__ << "(): must be called within recovery.";
         return;
     }
diff --git a/fs_mgr/fs_mgr_overlayfs_control.h b/fs_mgr/fs_mgr_overlayfs_control.h
index 50e83e8a30ef..b1751015844f 100644
--- a/fs_mgr/fs_mgr_overlayfs_control.h
+++ b/fs_mgr/fs_mgr_overlayfs_control.h
@@ -14,8 +14,6 @@
 
 #pragma once
 
-#include <string>
-
 #include <fstab/fstab.h>
 
 // If "mount_point" is non-null, set up exactly one overlay.
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index e380f8401112..37e30585a040 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -14,16 +14,12 @@
  * limitations under the License.
  */
 
-#include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/fs.h>
 #include <selinux/selinux.h>
-#include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include <sys/mount.h>
-#include <sys/param.h>
 #include <sys/stat.h>
 #include <sys/statvfs.h>
 #include <sys/types.h>
@@ -33,7 +29,6 @@
 
 #include <algorithm>
 #include <memory>
-#include <optional>
 #include <string>
 #include <vector>
 
@@ -45,7 +40,6 @@
 #include <ext4_utils/ext4_utils.h>
 #include <fs_mgr.h>
 #include <fs_mgr/file_wait.h>
-#include <fs_mgr_dm_linear.h>
 #include <fs_mgr_overlayfs.h>
 #include <fstab/fstab.h>
 #include <libdm/dm.h>
@@ -68,34 +62,15 @@ constexpr char kPhysicalDevice[] = "/dev/block/by-name/";
 constexpr char kLowerdirOption[] = "lowerdir=";
 constexpr char kUpperdirOption[] = "upperdir=";
 
-bool fs_mgr_access(const std::string& path) {
-    return access(path.c_str(), F_OK) == 0;
-}
-
-bool fs_mgr_in_recovery() {
-    // Check the existence of recovery binary instead of using the compile time
-    // __ANDROID_RECOVERY__ macro.
-    // If BOARD_USES_RECOVERY_AS_BOOT is true, both normal and recovery boot
-    // mode would use the same init binary, which would mean during normal boot
-    // the '/init' binary is actually a symlink pointing to
-    // init_second_stage.recovery, which would be compiled with
-    // __ANDROID_RECOVERY__ defined.
-    return fs_mgr_access("/system/bin/recovery");
-}
-
 bool fs_mgr_is_dsu_running() {
     // Since android::gsi::CanBootIntoGsi() or android::gsi::MarkSystemAsGsi() is
     // never called in recovery, the return value of android::gsi::IsGsiRunning()
     // is not well-defined. In this case, just return false as being in recovery
     // implies not running a DSU system.
-    if (fs_mgr_in_recovery()) return false;
+    if (InRecovery()) return false;
     return android::gsi::IsGsiRunning();
 }
 
-static bool IsABDevice() {
-    return !android::base::GetProperty("ro.boot.slot_suffix", "").empty();
-}
-
 std::vector<const std::string> OverlayMountPoints() {
     // Never fallback to legacy cache mount point if within a DSU system,
     // because running a DSU system implies the device supports dynamic
@@ -106,7 +81,8 @@ std::vector<const std::string> OverlayMountPoints() {
 
     // For non-A/B devices prefer cache backing storage if
     // kPreferCacheBackingStorageProp property set.
-    if (!IsABDevice() && android::base::GetBoolProperty(kPreferCacheBackingStorageProp, false) &&
+    if (fs_mgr_get_slot_suffix().empty() &&
+        android::base::GetBoolProperty(kPreferCacheBackingStorageProp, false) &&
         android::base::GetIntProperty("ro.vendor.api_level", -1) < __ANDROID_API_T__) {
         return {kCacheMountPoint, kScratchMountPoint};
     }
@@ -119,11 +95,6 @@ static bool fs_mgr_is_dir(const std::string& path) {
     return !stat(path.c_str(), &st) && S_ISDIR(st.st_mode);
 }
 
-bool fs_mgr_rw_access(const std::string& path) {
-    if (path.empty()) return false;
-    return access(path.c_str(), R_OK | W_OK) == 0;
-}
-
 // At less than 1% or 8MB of free space return value of false,
 // means we will try to wrap with overlayfs.
 bool fs_mgr_filesystem_has_space(const std::string& mount_point) {
@@ -146,7 +117,7 @@ static bool fs_mgr_update_blk_device(FstabEntry* entry) {
     if (entry->fs_mgr_flags.logical) {
         fs_mgr_update_logical_partition(entry);
     }
-    if (fs_mgr_access(entry->blk_device)) {
+    if (access(entry->blk_device.c_str(), F_OK) == 0) {
         return true;
     }
     if (entry->blk_device != "/dev/root") {
@@ -155,9 +126,9 @@ static bool fs_mgr_update_blk_device(FstabEntry* entry) {
 
     // special case for system-as-root (taimen and others)
     auto blk_device = kPhysicalDevice + "system"s;
-    if (!fs_mgr_access(blk_device)) {
+    if (access(blk_device.c_str(), F_OK)) {
         blk_device += fs_mgr_get_slot_suffix();
-        if (!fs_mgr_access(blk_device)) {
+        if (access(blk_device.c_str(), F_OK)) {
             return false;
         }
     }
@@ -241,7 +212,7 @@ static std::string fs_mgr_get_overlayfs_candidate(const std::string& mount_point
         if (!fs_mgr_is_dir(upper)) continue;
         auto work = dir + kWorkName;
         if (!fs_mgr_is_dir(work)) continue;
-        if (!fs_mgr_rw_access(work)) continue;
+        if (access(work.c_str(), R_OK | W_OK)) continue;
         return dir;
     }
     return "";
@@ -528,11 +499,11 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
 // Mount kScratchMountPoint
 bool MountScratch(const std::string& device_path, bool readonly) {
     if (readonly) {
-        if (!fs_mgr_access(device_path)) {
+        if (access(device_path.c_str(), F_OK)) {
             LOG(ERROR) << "Path does not exist: " << device_path;
             return false;
         }
-    } else if (!fs_mgr_rw_access(device_path)) {
+    } else if (access(device_path.c_str(), R_OK | W_OK)) {
         LOG(ERROR) << "Path does not exist or is not readwrite: " << device_path;
         return false;
     }
@@ -644,7 +615,7 @@ bool OverlayfsSetupAllowed(bool verbose) {
         return false;
     }
     // in recovery or fastbootd, not allowed!
-    if (fs_mgr_in_recovery()) {
+    if (InRecovery()) {
         if (verbose) {
             LOG(ERROR) << "Unsupported overlayfs setup from recovery";
         }
@@ -724,7 +695,7 @@ static void TryMountScratch() {
     // if verity is still disabled, i.e. no reboot occurred), and skips calling
     // fs_mgr_overlayfs_mount_all().
     auto scratch_device = GetBootScratchDevice();
-    if (!fs_mgr_rw_access(scratch_device)) {
+    if (access(scratch_device.c_str(), R_OK | W_OK)) {
         return;
     }
     if (!WaitForFile(scratch_device, 10s)) {
@@ -733,7 +704,8 @@ static void TryMountScratch() {
     if (!MountScratch(scratch_device, true /* readonly */)) {
         return;
     }
-    auto has_overlayfs_dir = fs_mgr_access(kScratchMountPoint + "/"s + kOverlayTopDir);
+    const auto top = kScratchMountPoint + "/"s + kOverlayTopDir;
+    const bool has_overlayfs_dir = access(top.c_str(), F_OK) == 0;
     fs_mgr_overlayfs_umount_scratch();
     if (has_overlayfs_dir) {
         MountScratch(scratch_device);
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.h b/fs_mgr/fs_mgr_overlayfs_mount.h
index d9a93d4ac50a..f0afac1edfe9 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.h
+++ b/fs_mgr/fs_mgr_overlayfs_mount.h
@@ -49,9 +49,6 @@ class AutoSetFsCreateCon final {
 };
 
 bool fs_mgr_is_dsu_running();
-bool fs_mgr_in_recovery();
-bool fs_mgr_access(const std::string& path);
-bool fs_mgr_rw_access(const std::string& path);
 bool fs_mgr_filesystem_has_space(const std::string& mount_point);
 const std::string fs_mgr_mount_point(const std::string& mount_point);
 bool OverlayfsSetupAllowed(bool verbose = false);
diff --git a/fs_mgr/fs_mgr_priv.h b/fs_mgr/fs_mgr_priv.h
index 46cdb62cfcc1..c3b18c85c78f 100644
--- a/fs_mgr/fs_mgr_priv.h
+++ b/fs_mgr/fs_mgr_priv.h
@@ -97,8 +97,6 @@ bool is_dt_compatible();
 bool fs_mgr_is_ext4(const std::string& blk_device);
 bool fs_mgr_is_f2fs(const std::string& blk_device);
 
-bool fs_mgr_teardown_verity(android::fs_mgr::FstabEntry* fstab);
-
 bool fs_mgr_filesystem_available(const std::string& filesystem);
 std::string fs_mgr_get_context(const std::string& mount_point);
 
diff --git a/fs_mgr/include_fstab/fstab/fstab.h b/fs_mgr/include_fstab/fstab/fstab.h
index 9cb1546c5aaf..80b45ba93dc6 100644
--- a/fs_mgr/include_fstab/fstab/fstab.h
+++ b/fs_mgr/include_fstab/fstab/fstab.h
@@ -131,5 +131,7 @@ std::set<std::string> GetBootDevices();
 // expected name.
 std::string GetVerityDeviceName(const FstabEntry& entry);
 
+bool InRecovery();
+
 }  // namespace fs_mgr
 }  // namespace android

From f580fe57991f0fef9ac058040e813eeb16876af2 Mon Sep 17 00:00:00 2001
From: Andrew Walbran <qwandor@google.com>
Date: Fri, 21 Jul 2023 19:13:48 +0100
Subject: [PATCH 0228/1487] Add safety comments.

These will soon be required by a lint.

Bug: 290018030
Test: m rust
Change-Id: I0b25bcaa18d167fb9c2d63e637833d4935dc8ff4
---
 libstats/pull_rust/stats_pull.rs | 7 +++++--
 trusty/libtrusty-rs/src/lib.rs   | 2 ++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/libstats/pull_rust/stats_pull.rs b/libstats/pull_rust/stats_pull.rs
index 09b26232f8b8..d188b5fb5838 100644
--- a/libstats/pull_rust/stats_pull.rs
+++ b/libstats/pull_rust/stats_pull.rs
@@ -111,7 +111,9 @@ lazy_static! {
     static ref COOKIES: Mutex<HashMap<i32, fn() -> StatsPullResult>> = Mutex::new(HashMap::new());
 }
 
-// Safety: We store our callbacks in the global so they are valid.
+/// # Safety
+///
+/// `data` must be a valid pointer with no aliases.
 unsafe extern "C" fn callback_wrapper(
     atom_tag: i32,
     data: *mut AStatsEventList,
@@ -126,7 +128,8 @@ unsafe extern "C" fn callback_wrapper(
                 let stats = cb();
                 let result = stats
                     .iter()
-                    .map(|stat| stat.add_astats_event(&mut *data))
+                    // Safety: The caller promises that `data` is valid and unaliased.
+                    .map(|stat| stat.add_astats_event(unsafe { &mut *data }))
                     .collect::<Result<Vec<()>, StatsError>>();
                 match result {
                     Ok(_) => {
diff --git a/trusty/libtrusty-rs/src/lib.rs b/trusty/libtrusty-rs/src/lib.rs
index 28ea07505b0f..22b894a47afb 100644
--- a/trusty/libtrusty-rs/src/lib.rs
+++ b/trusty/libtrusty-rs/src/lib.rs
@@ -102,6 +102,8 @@ impl TipcChannel {
         let file = File::options().read(true).write(true).open(device)?;
 
         let srv_name = CString::new(service).expect("Service name contained null bytes");
+        // SAFETY: The file descriptor is valid because it came from a `File`, and the name is a
+        // valid C string because it came from a `CString`.
         unsafe {
             tipc_connect(file.as_raw_fd(), srv_name.as_ptr())?;
         }

From b05b8706714a6e7eb64890e0bee012dbc69f72be Mon Sep 17 00:00:00 2001
From: Stephen Crane <cranes@google.com>
Date: Fri, 21 Jul 2023 19:10:40 +0000
Subject: [PATCH 0229/1487] storageproxyd: Start only a single binder thread

We only need a single binder thread to receive notifications, so we
should set the thread pool max to 0 rather than 1. startThreadPool()
starts one thread + the max count.

Test: m storageproxyd
Bug: 281951047
Fixes: 292030372
Change-Id: I53a90eaa2aa69469fd3a00b6da0d7061318c8ba9
---
 trusty/storage/proxy/proxy.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/trusty/storage/proxy/proxy.c b/trusty/storage/proxy/proxy.c
index 3b744ec9422f..67e935e39324 100644
--- a/trusty/storage/proxy/proxy.c
+++ b/trusty/storage/proxy/proxy.c
@@ -243,9 +243,12 @@ int main(int argc, char* argv[]) {
      * Start binder threadpool. At least one extra binder thread is needed to
      * connect to the wakelock service without relying on polling. If we poll on
      * the main thread we end up pausing for at least 1s even if the service
-     * starts faster.
+     * starts faster. We set the max thread count to 0 because startThreadPool
+     * "Starts one thread, PLUS those requested in setThreadPoolMaxThreadCount,
+     * PLUS those manually requested in joinThreadPool." We only need a single
+     * binder thread to receive notifications on.
      */
-    ABinderProcess_setThreadPoolMaxThreadCount(1);
+    ABinderProcess_setThreadPoolMaxThreadCount(0);
     ABinderProcess_startThreadPool();
 
     /* initialize secure storage directory */

From 37c18b30cb8e19db4e4d55050aed67863831b5c5 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 20 Jul 2023 22:00:53 -0700
Subject: [PATCH 0230/1487] snapuserd: use local buffers for xor processing
 during sync I/O

Bug: 291862304
Test: Incremental OTA on Pixel - Verify first stage boot logs
Change-Id: Ifc4f1ec912ccc1d24673f7bb03b05129ce504fa1
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp   | 2 +-
 .../snapuserd/user-space-merge/snapuserd_readahead.cpp          | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index e52d752a0eb9..2dd2ec09d6ce 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -308,7 +308,7 @@ bool SnapshotHandler::Start() {
         ra_thread_status =
                 std::async(std::launch::async, &ReadAhead::RunThread, read_ahead_thread_.get());
 
-        SNAP_LOG(INFO) << "Read-ahead thread started...";
+        SNAP_LOG(INFO) << "Read-ahead thread started";
     }
 
     // Launch worker threads
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index 3e9588b53d5b..8755820e1ed2 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -592,7 +592,7 @@ bool ReadAhead::ReadAheadSyncIO() {
             // Check if this block is an XOR op
             if (xor_op->new_block == new_block) {
                 // Read the xor'ed data from COW
-                void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
+                void* buffer = bufsink.GetPayloadBuffer(BLOCK_SZ);
                 if (!buffer) {
                     SNAP_LOG(ERROR) << "ReadAhead - failed to allocate buffer";
                     return false;

From c5184f79eed2efbe793a8869671c0868547f6b36 Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Fri, 21 Jul 2023 15:21:28 -0700
Subject: [PATCH 0231/1487] Explicitly ignore the result of std::async

The newer libc++ marks std::async with [[nodiscard]] in C++20 mode.

Bug: b/175635923
Test: treehugger
Change-Id: Ib63259983d952b97cf1b1c6c243c831cb72f9724
---
 fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
index 978a7f25c510..71664bfa91b6 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
@@ -734,8 +734,8 @@ void Snapuserd::ReadBlocks(const std::string& partition_name, const std::string&
     off_t offset = 0;
 
     for (int i = 0; i < num_threads; i++) {
-        std::async(std::launch::async, &Snapuserd::ReadBlocksToCache, this, dm_block_device,
-                   partition_name, offset, read_sz_per_thread);
+        (void)std::async(std::launch::async, &Snapuserd::ReadBlocksToCache, this, dm_block_device,
+                         partition_name, offset, read_sz_per_thread);
 
         offset += read_sz_per_thread;
     }

From 209890c07d40651e5c44eb8677c6c4e555b35488 Mon Sep 17 00:00:00 2001
From: Stephen Crane <cranes@google.com>
Date: Fri, 21 Jul 2023 22:21:31 +0000
Subject: [PATCH 0232/1487] storageproxyd: Start only a single binder thread

We only need a single binder thread to receive notifications, so we
should set the thread pool max to 0 rather than 1. startThreadPool()
starts one thread + the max count.

Test: m storageproxyd
Bug: 281951047
Fixes: 292030372
(cherry picked from https://android-review.googlesource.com/q/commit:b05b8706714a6e7eb64890e0bee012dbc69f72be)
Merged-In: I53a90eaa2aa69469fd3a00b6da0d7061318c8ba9

Change-Id: I53a90eaa2aa69469fd3a00b6da0d7061318c8ba9
---
 trusty/storage/proxy/proxy.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/trusty/storage/proxy/proxy.c b/trusty/storage/proxy/proxy.c
index 3b744ec9422f..67e935e39324 100644
--- a/trusty/storage/proxy/proxy.c
+++ b/trusty/storage/proxy/proxy.c
@@ -243,9 +243,12 @@ int main(int argc, char* argv[]) {
      * Start binder threadpool. At least one extra binder thread is needed to
      * connect to the wakelock service without relying on polling. If we poll on
      * the main thread we end up pausing for at least 1s even if the service
-     * starts faster.
+     * starts faster. We set the max thread count to 0 because startThreadPool
+     * "Starts one thread, PLUS those requested in setThreadPoolMaxThreadCount,
+     * PLUS those manually requested in joinThreadPool." We only need a single
+     * binder thread to receive notifications on.
      */
-    ABinderProcess_setThreadPoolMaxThreadCount(1);
+    ABinderProcess_setThreadPoolMaxThreadCount(0);
     ABinderProcess_startThreadPool();
 
     /* initialize secure storage directory */

From cbda2c038b742915eb96e2cd469df6f804f2693a Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 18 Jul 2023 15:04:43 -0700
Subject: [PATCH 0233/1487] Adding flag to flash only static partitions

adding in --exclude-dynamic-partitions to flash only bootloader
partitions and skip the rest. Super optimization will be turned off as
well when this flag is enabled

Test: fastboot flashall --exclude-dynamic-partitions

Change-Id: I4b9d70b7f6179bf079991bf3a20aade64cfe9935
---
 fastboot/fastboot.cpp | 18 +++++++++++++++++-
 fastboot/fastboot.h   |  1 +
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 61c7204daacd..faee5e25dad0 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1794,6 +1794,7 @@ void FlashAllTool::Flash() {
     CancelSnapshotIfNeeded();
 
     tasks_ = CollectTasks();
+
     for (auto& task : tasks_) {
         task->Run();
     }
@@ -1808,7 +1809,18 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasks() {
     } else {
         tasks = CollectTasksFromImageList();
     }
-
+    if (fp_->exclude_dynamic_partitions) {
+        auto is_non_static_flash_task = [](const auto& task) -> bool {
+            if (auto flash_task = task->AsFlashTask()) {
+                if (!should_flash_in_userspace(flash_task->GetPartitionAndSlot())) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        tasks.erase(std::remove_if(tasks.begin(), tasks.end(), is_non_static_flash_task),
+                    tasks.end());
+    }
     return tasks;
 }
 
@@ -2213,6 +2225,7 @@ int FastBootTool::Main(int argc, char* argv[]) {
                                       {"disable-verification", no_argument, 0, 0},
                                       {"disable-verity", no_argument, 0, 0},
                                       {"disable-super-optimization", no_argument, 0, 0},
+                                      {"exclude-dynamic-partitions", no_argument, 0, 0},
                                       {"disable-fastboot-info", no_argument, 0, 0},
                                       {"force", no_argument, 0, 0},
                                       {"fs-options", required_argument, 0, 0},
@@ -2254,6 +2267,9 @@ int FastBootTool::Main(int argc, char* argv[]) {
                 g_disable_verity = true;
             } else if (name == "disable-super-optimization") {
                 fp->should_optimize_flash_super = false;
+            } else if (name == "exclude-dynamic-partitions") {
+                fp->exclude_dynamic_partitions = true;
+                fp->should_optimize_flash_super = false;
             } else if (name == "disable-fastboot-info") {
                 fp->should_use_fastboot_info = false;
             } else if (name == "force") {
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index f6ffb641fc69..3fb00e0fda5d 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -98,6 +98,7 @@ struct FlashingPlan {
     bool force_flash = false;
     bool should_optimize_flash_super = true;
     bool should_use_fastboot_info = true;
+    bool exclude_dynamic_partitions = false;
     uint64_t sparse_limit = 0;
 
     std::string slot_override;

From 2493d50328a99c725e7e690fcfd3efde88f86541 Mon Sep 17 00:00:00 2001
From: Lee George Thomas <lgthomas@google.com>
Date: Tue, 25 Jul 2023 15:07:17 -0700
Subject: [PATCH 0234/1487] Create /data/misc/bootanim folder in init.rc.

This folder is used to host bootanim data files.

Bug: 210757252
Test: /data/misc/bootanim is correctly created.
Change-Id: I9c9949316d073ad7ebac503f097c5fee6c0b2a22
---
 rootdir/init.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index d2499ef3816e..8f01d932b851 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -997,7 +997,7 @@ on post-fs-data
     perform_apex_config
 
     # Create directories for boot animation.
-    mkdir /data/bootanim 0755 system system encryption=DeleteIfNecessary
+    mkdir /data/misc/bootanim 0755 system system encryption=DeleteIfNecessary
 
     exec_start derive_sdk
 

From 9292f74fc1b20275e29246a12ce4913599645cd9 Mon Sep 17 00:00:00 2001
From: Yunkai Lim <yunkai@google.com>
Date: Wed, 26 Jul 2023 06:21:30 +0000
Subject: [PATCH 0235/1487] Revert "init.rc: stop calling 'fsverity_init
 --load-verified-keys'"

Revert submission 2662658-fsverity-init-cleanup

Reason for revert: Culprit for test breakage b/293232766

Reverted changes: /q/submissionid:2662658-fsverity-init-cleanup

Change-Id: I77086f955a53eec274166b7395a88b7dc0e1ad53
---
 rootdir/Android.bp | 5 ++++-
 rootdir/init.rc    | 3 +++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 65865a65b4ea..e98733ada721 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -20,7 +20,10 @@ prebuilt_etc {
     name: "init.rc",
     src: "init.rc",
     sub_dir: "init/hw",
-    required: ["platform-bootclasspath"],
+    required: [
+        "fsverity_init",
+        "platform-bootclasspath",
+    ],
 }
 
 prebuilt_etc {
diff --git a/rootdir/init.rc b/rootdir/init.rc
index dec763ac1df9..d2499ef3816e 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -629,6 +629,9 @@ on late-fs
     # HALs required before storage encryption can get unlocked (FBE)
     class_start early_hal
 
+    # Load trusted keys from dm-verity protected partitions
+    exec -- /system/bin/fsverity_init --load-verified-keys
+
 # Only enable the bootreceiver tracing instance for kernels 5.10 and above.
 on late-fs && property:ro.kernel.version=4.9
     setprop bootreceiver.enable 0

From a895aac5e0b3f4b715c9062860b0242a64ef487e Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Wed, 26 Jul 2023 07:50:44 -0700
Subject: [PATCH 0236/1487] Add bug component to system/core

Bug: 289414897
Test: N/A
Change-Id: I9709b2483988f8d7a4204d5398cc559d167f14bf
---
 OWNERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/OWNERS b/OWNERS
index 682a067b3a98..96b4f54ec0b5 100644
--- a/OWNERS
+++ b/OWNERS
@@ -1 +1,2 @@
+# Bug component: 128577
 enh@google.com

From aa6158b410ca65566bcd23d30bf32bc522d9d6dc Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Wed, 26 Jul 2023 22:12:44 +0000
Subject: [PATCH 0237/1487] libprocessgroup: UIDs in linux are unsigned

We missed two incorrect specifiers in the previous commit with this same
title.

We use the %d format specificier for uid_t, which maps to
__kernel_uid32_t, which is unsigned. [1] This is undefined behavior
which can lead to paths with negative UIDs when erroneously large
values are passed for uid:

E libprocessgroup: No such cgroup attribute: /sys/fs/cgroup/uid_-89846/cgroup.freeze

Fix it with %u.

[1] https://cs.android.com/search?q=typedef.*__kernel_uid32_t&ss=android%2Fplatform%2Fsuperproject%2Fmain

Change-Id: Ica04b03526bd2e156f026a2797fe9912b259cd9f
---
 libprocessgroup/processgroup.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 06d386f363e7..450643912e09 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -206,11 +206,11 @@ bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles) {
 }
 
 static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
-    return StringPrintf("%s/uid_%d", cgroup, uid);
+    return StringPrintf("%s/uid_%u", cgroup, uid);
 }
 
 static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, int pid) {
-    return StringPrintf("%s/uid_%d/pid_%d", cgroup, uid, pid);
+    return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
 }
 
 static int RemoveProcessGroup(const char* cgroup, uid_t uid, int pid, unsigned int retries) {

From 8fe4f073c210b012330863ba3beda11062d3a7ed Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Thu, 27 Jul 2023 10:16:05 -0700
Subject: [PATCH 0238/1487] Add bug component to cutils

Bug: 289414897
Test: N/A
Change-Id: Ic7122e52c3847beba3891b121b723d19bf2076de
---
 libcutils/OWNERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libcutils/OWNERS b/libcutils/OWNERS
index 7529cb920940..e1cbe4aaf975 100644
--- a/libcutils/OWNERS
+++ b/libcutils/OWNERS
@@ -1 +1,2 @@
+# Bug component: 128577
 include platform/system/core:/janitors/OWNERS

From 35078468722cdee94fe17e57fe5f300d3ee156f4 Mon Sep 17 00:00:00 2001
From: Suren Baghdasaryan <surenb@google.com>
Date: Tue, 25 Jul 2023 14:50:18 -0700
Subject: [PATCH 0239/1487] libprocessgroup: fix reset of file_v2_name

ProfileAttribute::Reset does not reset file_v2_name, fix that. Also
provide ProfileAttribute::file_name() to consolidate the code.

Bug: 292636609
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Change-Id: I5b33ca47b4fa5cabf582c8804bd13f72f6e58411
---
 libprocessgroup/task_profiles.cpp      | 22 +++++++++++++---------
 libprocessgroup/task_profiles.h        |  8 +++++---
 libprocessgroup/task_profiles_test.cpp |  7 +++----
 3 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 1276a72a6ad0..59b135013326 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -114,9 +114,16 @@ bool FdCacheHelper::IsAppDependentPath(const std::string& path) {
 
 IProfileAttribute::~IProfileAttribute() = default;
 
-void ProfileAttribute::Reset(const CgroupController& controller, const std::string& file_name) {
+const std::string& ProfileAttribute::file_name() const {
+    if (controller()->version() == 2 && !file_v2_name_.empty()) return file_v2_name_;
+    return file_name_;
+}
+
+void ProfileAttribute::Reset(const CgroupController& controller, const std::string& file_name,
+                             const std::string& file_v2_name) {
     controller_ = controller;
     file_name_ = file_name;
+    file_v2_name_ = file_v2_name;
 }
 
 bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
@@ -129,12 +136,11 @@ bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
         return true;
     }
 
-    const std::string& file_name =
-            controller()->version() == 2 && !file_v2_name_.empty() ? file_v2_name_ : file_name_;
     if (subgroup.empty()) {
-        *path = StringPrintf("%s/%s", controller()->path(), file_name.c_str());
+        *path = StringPrintf("%s/%s", controller()->path(), file_name().c_str());
     } else {
-        *path = StringPrintf("%s/%s/%s", controller()->path(), subgroup.c_str(), file_name.c_str());
+        *path = StringPrintf("%s/%s/%s", controller()->path(), subgroup.c_str(),
+                             file_name().c_str());
     }
     return true;
 }
@@ -144,9 +150,7 @@ bool ProfileAttribute::GetPathForUID(uid_t uid, std::string* path) const {
         return true;
     }
 
-    const std::string& file_name =
-            controller()->version() == 2 && !file_v2_name_.empty() ? file_v2_name_ : file_name_;
-    *path = StringPrintf("%s/uid_%u/%s", controller()->path(), uid, file_name.c_str());
+    *path = StringPrintf("%s/uid_%u/%s", controller()->path(), uid, file_name().c_str());
     return true;
 }
 
@@ -816,7 +820,7 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                 attributes_[name] =
                         std::make_unique<ProfileAttribute>(controller, file_attr, file_v2_attr);
             } else {
-                iter->second->Reset(controller, file_attr);
+                iter->second->Reset(controller, file_attr, file_v2_attr);
             }
         } else {
             LOG(WARNING) << "Controller " << controller_name << " is not found";
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index a62c5b0a9e8c..ac8918e650fc 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -32,7 +32,8 @@
 class IProfileAttribute {
   public:
     virtual ~IProfileAttribute() = 0;
-    virtual void Reset(const CgroupController& controller, const std::string& file_name) = 0;
+    virtual void Reset(const CgroupController& controller, const std::string& file_name,
+                       const std::string& file_v2_name) = 0;
     virtual const CgroupController* controller() const = 0;
     virtual const std::string& file_name() const = 0;
     virtual bool GetPathForTask(int tid, std::string* path) const = 0;
@@ -50,8 +51,9 @@ class ProfileAttribute : public IProfileAttribute {
     ~ProfileAttribute() = default;
 
     const CgroupController* controller() const override { return &controller_; }
-    const std::string& file_name() const override { return file_name_; }
-    void Reset(const CgroupController& controller, const std::string& file_name) override;
+    const std::string& file_name() const override;
+    void Reset(const CgroupController& controller, const std::string& file_name,
+               const std::string& file_v2_name) override;
 
     bool GetPathForTask(int tid, std::string* path) const override;
     bool GetPathForUID(uid_t uid, std::string* path) const override;
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index eadbe7697b07..da74bb012f8f 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -102,7 +102,8 @@ class ProfileAttributeMock : public IProfileAttribute {
   public:
     ProfileAttributeMock(const std::string& file_name) : file_name_(file_name) {}
     ~ProfileAttributeMock() override = default;
-    void Reset(const CgroupController& controller, const std::string& file_name) override {
+    void Reset(const CgroupController& controller, const std::string& file_name,
+               const std::string& file_v2_name) override {
         CHECK(false);
     }
     const CgroupController* controller() const override {
@@ -125,9 +126,7 @@ class ProfileAttributeMock : public IProfileAttribute {
         return true;
     };
 
-    bool GetPathForUID(uid_t, std::string*) const override {
-        return false;
-    }
+    bool GetPathForUID(uid_t, std::string*) const override { return false; }
 
   private:
     const std::string file_name_;

From 3483798fd9045f93e9095e5b09ffe4f59054c535 Mon Sep 17 00:00:00 2001
From: Suren Baghdasaryan <surenb@google.com>
Date: Tue, 25 Jul 2023 15:45:45 -0700
Subject: [PATCH 0240/1487] libprocessgroup: optimize
 SetAttributeAction::ExecuteForProcess performance

Current implementation of SetAttributeAction::ExecuteForProcess reuses
SetAttributeAction::ExecuteForTask while not utilizing available uid/pid
information. This results in a call to GetPathForTask() which is an
expensive function due to it reading and parsing /proc/$pid/cgroups.
This can be avoided if we utilize available uid/pid info and the fact
that cgroup v2 attributes share the cgroup v2 hierarchy as process
groups, which use a known path template.

Bug: 292636609
Change-Id: I02e3046bd85d0dfebc68ab444f1796bb54cc69c7
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
---
 libprocessgroup/task_profiles.cpp      | 45 +++++++++++++++++++-------
 libprocessgroup/task_profiles.h        |  4 +++
 libprocessgroup/task_profiles_test.cpp |  3 ++
 3 files changed, 40 insertions(+), 12 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 59b135013326..f51b07671bf1 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -126,6 +126,16 @@ void ProfileAttribute::Reset(const CgroupController& controller, const std::stri
     file_v2_name_ = file_v2_name;
 }
 
+bool ProfileAttribute::GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const {
+    if (controller()->version() == 2) {
+        // all cgroup v2 attributes use the same process group hierarchy
+        *path = StringPrintf("%s/uid_%u/pid_%d/%s", controller()->path(), uid, pid,
+                             file_name().c_str());
+        return true;
+    }
+    return GetPathForTask(pid, path);
+}
+
 bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
     std::string subgroup;
     if (!controller()->GetTaskGroup(tid, &subgroup)) {
@@ -209,18 +219,7 @@ bool SetTimerSlackAction::ExecuteForTask(int) const {
 
 #endif
 
-bool SetAttributeAction::ExecuteForProcess(uid_t, pid_t pid) const {
-    return ExecuteForTask(pid);
-}
-
-bool SetAttributeAction::ExecuteForTask(int tid) const {
-    std::string path;
-
-    if (!attribute_->GetPathForTask(tid, &path)) {
-        LOG(ERROR) << "Failed to find cgroup for tid " << tid;
-        return false;
-    }
-
+bool SetAttributeAction::WriteValueToFile(const std::string& path) const {
     if (!WriteStringToFile(value_, path)) {
         if (access(path.c_str(), F_OK) < 0) {
             if (optional_) {
@@ -240,6 +239,28 @@ bool SetAttributeAction::ExecuteForTask(int tid) const {
     return true;
 }
 
+bool SetAttributeAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
+    std::string path;
+
+    if (!attribute_->GetPathForProcess(uid, pid, &path)) {
+        LOG(ERROR) << "Failed to find cgroup for uid " << uid << " pid " << pid;
+        return false;
+    }
+
+    return WriteValueToFile(path);
+}
+
+bool SetAttributeAction::ExecuteForTask(int tid) const {
+    std::string path;
+
+    if (!attribute_->GetPathForTask(tid, &path)) {
+        LOG(ERROR) << "Failed to find cgroup for tid " << tid;
+        return false;
+    }
+
+    return WriteValueToFile(path);
+}
+
 bool SetAttributeAction::ExecuteForUID(uid_t uid) const {
     std::string path;
 
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index ac8918e650fc..4663f64e2a7e 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -36,6 +36,7 @@ class IProfileAttribute {
                        const std::string& file_v2_name) = 0;
     virtual const CgroupController* controller() const = 0;
     virtual const std::string& file_name() const = 0;
+    virtual bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const = 0;
     virtual bool GetPathForTask(int tid, std::string* path) const = 0;
     virtual bool GetPathForUID(uid_t uid, std::string* path) const = 0;
 };
@@ -55,6 +56,7 @@ class ProfileAttribute : public IProfileAttribute {
     void Reset(const CgroupController& controller, const std::string& file_name,
                const std::string& file_v2_name) override;
 
+    bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const override;
     bool GetPathForTask(int tid, std::string* path) const override;
     bool GetPathForUID(uid_t uid, std::string* path) const override;
 
@@ -133,6 +135,8 @@ class SetAttributeAction : public ProfileAction {
     const IProfileAttribute* attribute_;
     std::string value_;
     bool optional_;
+
+    bool WriteValueToFile(const std::string& path) const;
 };
 
 // Set cgroup profile element
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index da74bb012f8f..99d819a7cc4c 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -111,6 +111,9 @@ class ProfileAttributeMock : public IProfileAttribute {
         return {};
     }
     const std::string& file_name() const override { return file_name_; }
+    bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const override {
+        return GetPathForTask(pid, path);
+    }
     bool GetPathForTask(int tid, std::string* path) const override {
 #ifdef __ANDROID__
         CHECK(CgroupGetControllerPath(CGROUPV2_CONTROLLER_NAME, path));

From 2ffbeaef3a926b0b5fd873136588deb3ec61ef96 Mon Sep 17 00:00:00 2001
From: Suren Baghdasaryan <surenb@google.com>
Date: Tue, 25 Jul 2023 14:50:18 -0700
Subject: [PATCH 0241/1487] libprocessgroup: fix reset of file_v2_name

ProfileAttribute::Reset does not reset file_v2_name, fix that. Also
provide ProfileAttribute::file_name() to consolidate the code.

Bug: 292636609
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Change-Id: I5b33ca47b4fa5cabf582c8804bd13f72f6e58411
Merged-In: I5b33ca47b4fa5cabf582c8804bd13f72f6e58411
---
 libprocessgroup/task_profiles.cpp      | 22 +++++++++++++---------
 libprocessgroup/task_profiles.h        |  8 +++++---
 libprocessgroup/task_profiles_test.cpp |  7 +++----
 3 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 44dba2a16694..59b135013326 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -114,9 +114,16 @@ bool FdCacheHelper::IsAppDependentPath(const std::string& path) {
 
 IProfileAttribute::~IProfileAttribute() = default;
 
-void ProfileAttribute::Reset(const CgroupController& controller, const std::string& file_name) {
+const std::string& ProfileAttribute::file_name() const {
+    if (controller()->version() == 2 && !file_v2_name_.empty()) return file_v2_name_;
+    return file_name_;
+}
+
+void ProfileAttribute::Reset(const CgroupController& controller, const std::string& file_name,
+                             const std::string& file_v2_name) {
     controller_ = controller;
     file_name_ = file_name;
+    file_v2_name_ = file_v2_name;
 }
 
 bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
@@ -129,12 +136,11 @@ bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
         return true;
     }
 
-    const std::string& file_name =
-            controller()->version() == 2 && !file_v2_name_.empty() ? file_v2_name_ : file_name_;
     if (subgroup.empty()) {
-        *path = StringPrintf("%s/%s", controller()->path(), file_name.c_str());
+        *path = StringPrintf("%s/%s", controller()->path(), file_name().c_str());
     } else {
-        *path = StringPrintf("%s/%s/%s", controller()->path(), subgroup.c_str(), file_name.c_str());
+        *path = StringPrintf("%s/%s/%s", controller()->path(), subgroup.c_str(),
+                             file_name().c_str());
     }
     return true;
 }
@@ -144,9 +150,7 @@ bool ProfileAttribute::GetPathForUID(uid_t uid, std::string* path) const {
         return true;
     }
 
-    const std::string& file_name =
-            controller()->version() == 2 && !file_v2_name_.empty() ? file_v2_name_ : file_name_;
-    *path = StringPrintf("%s/uid_%d/%s", controller()->path(), uid, file_name.c_str());
+    *path = StringPrintf("%s/uid_%u/%s", controller()->path(), uid, file_name().c_str());
     return true;
 }
 
@@ -816,7 +820,7 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                 attributes_[name] =
                         std::make_unique<ProfileAttribute>(controller, file_attr, file_v2_attr);
             } else {
-                iter->second->Reset(controller, file_attr);
+                iter->second->Reset(controller, file_attr, file_v2_attr);
             }
         } else {
             LOG(WARNING) << "Controller " << controller_name << " is not found";
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index a62c5b0a9e8c..ac8918e650fc 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -32,7 +32,8 @@
 class IProfileAttribute {
   public:
     virtual ~IProfileAttribute() = 0;
-    virtual void Reset(const CgroupController& controller, const std::string& file_name) = 0;
+    virtual void Reset(const CgroupController& controller, const std::string& file_name,
+                       const std::string& file_v2_name) = 0;
     virtual const CgroupController* controller() const = 0;
     virtual const std::string& file_name() const = 0;
     virtual bool GetPathForTask(int tid, std::string* path) const = 0;
@@ -50,8 +51,9 @@ class ProfileAttribute : public IProfileAttribute {
     ~ProfileAttribute() = default;
 
     const CgroupController* controller() const override { return &controller_; }
-    const std::string& file_name() const override { return file_name_; }
-    void Reset(const CgroupController& controller, const std::string& file_name) override;
+    const std::string& file_name() const override;
+    void Reset(const CgroupController& controller, const std::string& file_name,
+               const std::string& file_v2_name) override;
 
     bool GetPathForTask(int tid, std::string* path) const override;
     bool GetPathForUID(uid_t uid, std::string* path) const override;
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index eadbe7697b07..da74bb012f8f 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -102,7 +102,8 @@ class ProfileAttributeMock : public IProfileAttribute {
   public:
     ProfileAttributeMock(const std::string& file_name) : file_name_(file_name) {}
     ~ProfileAttributeMock() override = default;
-    void Reset(const CgroupController& controller, const std::string& file_name) override {
+    void Reset(const CgroupController& controller, const std::string& file_name,
+               const std::string& file_v2_name) override {
         CHECK(false);
     }
     const CgroupController* controller() const override {
@@ -125,9 +126,7 @@ class ProfileAttributeMock : public IProfileAttribute {
         return true;
     };
 
-    bool GetPathForUID(uid_t, std::string*) const override {
-        return false;
-    }
+    bool GetPathForUID(uid_t, std::string*) const override { return false; }
 
   private:
     const std::string file_name_;

From 961c01ce23bb886583ca8cac1640806346c09a7f Mon Sep 17 00:00:00 2001
From: Suren Baghdasaryan <surenb@google.com>
Date: Tue, 25 Jul 2023 15:45:45 -0700
Subject: [PATCH 0242/1487] libprocessgroup: optimize
 SetAttributeAction::ExecuteForProcess performance

Current implementation of SetAttributeAction::ExecuteForProcess reuses
SetAttributeAction::ExecuteForTask while not utilizing available uid/pid
information. This results in a call to GetPathForTask() which is an
expensive function due to it reading and parsing /proc/$pid/cgroups.
This can be avoided if we utilize available uid/pid info and the fact
that cgroup v2 attributes share the cgroup v2 hierarchy as process
groups, which use a known path template.

Bug: 292636609
Change-Id: I02e3046bd85d0dfebc68ab444f1796bb54cc69c7
Merged-In: I02e3046bd85d0dfebc68ab444f1796bb54cc69c7
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
---
 libprocessgroup/task_profiles.cpp      | 45 +++++++++++++++++++-------
 libprocessgroup/task_profiles.h        |  4 +++
 libprocessgroup/task_profiles_test.cpp |  3 ++
 3 files changed, 40 insertions(+), 12 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 59b135013326..f51b07671bf1 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -126,6 +126,16 @@ void ProfileAttribute::Reset(const CgroupController& controller, const std::stri
     file_v2_name_ = file_v2_name;
 }
 
+bool ProfileAttribute::GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const {
+    if (controller()->version() == 2) {
+        // all cgroup v2 attributes use the same process group hierarchy
+        *path = StringPrintf("%s/uid_%u/pid_%d/%s", controller()->path(), uid, pid,
+                             file_name().c_str());
+        return true;
+    }
+    return GetPathForTask(pid, path);
+}
+
 bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
     std::string subgroup;
     if (!controller()->GetTaskGroup(tid, &subgroup)) {
@@ -209,18 +219,7 @@ bool SetTimerSlackAction::ExecuteForTask(int) const {
 
 #endif
 
-bool SetAttributeAction::ExecuteForProcess(uid_t, pid_t pid) const {
-    return ExecuteForTask(pid);
-}
-
-bool SetAttributeAction::ExecuteForTask(int tid) const {
-    std::string path;
-
-    if (!attribute_->GetPathForTask(tid, &path)) {
-        LOG(ERROR) << "Failed to find cgroup for tid " << tid;
-        return false;
-    }
-
+bool SetAttributeAction::WriteValueToFile(const std::string& path) const {
     if (!WriteStringToFile(value_, path)) {
         if (access(path.c_str(), F_OK) < 0) {
             if (optional_) {
@@ -240,6 +239,28 @@ bool SetAttributeAction::ExecuteForTask(int tid) const {
     return true;
 }
 
+bool SetAttributeAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
+    std::string path;
+
+    if (!attribute_->GetPathForProcess(uid, pid, &path)) {
+        LOG(ERROR) << "Failed to find cgroup for uid " << uid << " pid " << pid;
+        return false;
+    }
+
+    return WriteValueToFile(path);
+}
+
+bool SetAttributeAction::ExecuteForTask(int tid) const {
+    std::string path;
+
+    if (!attribute_->GetPathForTask(tid, &path)) {
+        LOG(ERROR) << "Failed to find cgroup for tid " << tid;
+        return false;
+    }
+
+    return WriteValueToFile(path);
+}
+
 bool SetAttributeAction::ExecuteForUID(uid_t uid) const {
     std::string path;
 
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index ac8918e650fc..4663f64e2a7e 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -36,6 +36,7 @@ class IProfileAttribute {
                        const std::string& file_v2_name) = 0;
     virtual const CgroupController* controller() const = 0;
     virtual const std::string& file_name() const = 0;
+    virtual bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const = 0;
     virtual bool GetPathForTask(int tid, std::string* path) const = 0;
     virtual bool GetPathForUID(uid_t uid, std::string* path) const = 0;
 };
@@ -55,6 +56,7 @@ class ProfileAttribute : public IProfileAttribute {
     void Reset(const CgroupController& controller, const std::string& file_name,
                const std::string& file_v2_name) override;
 
+    bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const override;
     bool GetPathForTask(int tid, std::string* path) const override;
     bool GetPathForUID(uid_t uid, std::string* path) const override;
 
@@ -133,6 +135,8 @@ class SetAttributeAction : public ProfileAction {
     const IProfileAttribute* attribute_;
     std::string value_;
     bool optional_;
+
+    bool WriteValueToFile(const std::string& path) const;
 };
 
 // Set cgroup profile element
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index da74bb012f8f..99d819a7cc4c 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -111,6 +111,9 @@ class ProfileAttributeMock : public IProfileAttribute {
         return {};
     }
     const std::string& file_name() const override { return file_name_; }
+    bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const override {
+        return GetPathForTask(pid, path);
+    }
     bool GetPathForTask(int tid, std::string* path) const override {
 #ifdef __ANDROID__
         CHECK(CgroupGetControllerPath(CGROUPV2_CONTROLLER_NAME, path));

From cac69b6cb83c2322942876db4029ab070add6f35 Mon Sep 17 00:00:00 2001
From: Matthew Maurer <mmaurer@google.com>
Date: Thu, 27 Jul 2023 22:15:46 +0000
Subject: [PATCH 0243/1487] trusty: keymint: Statically link Rust deps

Vendor libraries can be linked dynamically now, but until more Rust
components are using it, static is more efficient.

Bug: 292062611
Test: TH
Change-Id: I3708f5fac1ace797b6233811adf3ec71218d5738
---
 trusty/keymint/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/trusty/keymint/Android.bp b/trusty/keymint/Android.bp
index c19ebbd2663f..19dcc98753f4 100644
--- a/trusty/keymint/Android.bp
+++ b/trusty/keymint/Android.bp
@@ -35,6 +35,7 @@ rust_binary {
         "liblibc",
         "liblog_rust",
     ],
+    prefer_rlib: true,
     required: [
         "android.hardware.hardware_keystore.xml",
     ],

From 5ffd88f26f0bb8fe7bfa0058f70c7e40bf7e8f9f Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Fri, 28 Jul 2023 17:28:27 +0900
Subject: [PATCH 0244/1487] init: move `MarkServicesUpdate` later

MarkServicesUpdate() starts delayed services which are mostly for
APEXes. (e.g. start a service from APEX). But before
"DefaultNamespaceReady", services are started in "bootstrap" mount
namespace, which makes services from non-bootstrap APEXes fail to start.

This is a quick fix for the problem before coming up with better
solution in the future.

Bug: 293535323
Test: add 'start adbd' before 'perform_apex_config' in init.rc
      adbd starts successfully.
Change-Id: I846689f7c38cdca83c1f7faec0106b8174527e09
---
 init/builtins.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/init/builtins.cpp b/init/builtins.cpp
index 2176233aab96..fa5e36d52220 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -1297,7 +1297,6 @@ static Result<void> do_perform_apex_config(const BuiltinArguments& args) {
         return create_dirs.error();
     }
     auto parse_configs = ParseApexConfigs(/*apex_name=*/"");
-    ServiceList::GetInstance().MarkServicesUpdate();
     if (!parse_configs.ok()) {
         return parse_configs.error();
     }
@@ -1307,6 +1306,8 @@ static Result<void> do_perform_apex_config(const BuiltinArguments& args) {
         return update_linker_config.error();
     }
 
+    // Now start delayed services
+    ServiceList::GetInstance().MarkServicesUpdate();
     return {};
 }
 

From 63ec4c6180f98457bbb309d05514f2d76b91a09c Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 20 Jul 2023 10:40:00 -0700
Subject: [PATCH 0245/1487] libsnapshot: Verify the ordering of COW operations.

Sequence op should contain all ordered ops followed
by Replace and Zero ops. There shouldn't be any non-ordered
ops embedded between ordered ops in the sequence ordering.

Bug: 290159346
Test: inspect_cow <cow_file>, OTA
Change-Id: Ia840340b0e4be07525f216838043bf0265f690c3
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../libsnapshot_cow/cow_reader.cpp            | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 489669ac0eae..f37aed1afe63 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -310,9 +310,34 @@ bool CowReader::PrepMergeOps() {
 bool CowReader::VerifyMergeOps() {
     auto itr = GetMergeOpIter(true);
     std::unordered_map<uint64_t, const CowOperation*> overwritten_blocks;
+    bool non_ordered_op_found = false;
+
     while (!itr->AtEnd()) {
         const auto& op = itr->Get();
         uint64_t offset;
+
+        // Op should not be a metadata
+        if (IsMetadataOp(*op)) {
+            LOG(ERROR) << "Metadata op: " << op << " found during merge sequence";
+            return false;
+        }
+
+        // Sequence ops should contain all the ordered ops followed
+        // by Replace and Zero ops. If we find the first op which
+        // is not ordered, that means all ordered ops processing
+        // has been completed.
+        if (!IsOrderedOp(*op)) {
+            non_ordered_op_found = true;
+        }
+
+        // Since, all ordered ops processing has been completed,
+        // check that the subsequent ops are not ordered.
+        if (non_ordered_op_found && IsOrderedOp(*op)) {
+            LOG(ERROR) << "Invalid sequence - non-ordered and ordered ops"
+                       << " cannot be mixed during sequence generation";
+            return false;
+        }
+
         if (!GetSourceOffset(op, &offset)) {
             itr->Next();
             continue;

From 750fe6a37b2ff0fcb7f54721cd92f7e2686bb807 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Fri, 28 Jul 2023 10:58:56 -0700
Subject: [PATCH 0246/1487] Adding include to functional

adding include to functional since we use it in this file. Some users
are reporting build issues due to missing this include

Test: m fastboot
Change-Id: I9ba11bdaf7dcedf5f9ebfb6fa50013be50738f48
---
 fastboot/fastboot.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index f6ffb641fc69..dc57149761e9 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -27,6 +27,7 @@
  */
 #pragma once
 
+#include <functional>
 #include <string>
 #include "fastboot_driver.h"
 #include "fastboot_driver_interface.h"

From 201801ce8eb5e001de9e669e55ee507e18bcae66 Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Thu, 20 Jul 2023 17:25:47 +0900
Subject: [PATCH 0247/1487] Use /bootstrap-apex for bootstrap APEXes

This new directory is bind-mounted to /apex in the bootstrap mount
namespace so that apexd-bootstrap mounts bootstrap APEXes there via
/apex.

The directory is detached from /apex in the default mount namespace but
still visible in case bootstrap APEXes are needed.

However, there are (mostly, virtual) devices which don't need two mount
namespaces. Those devices don't need to make /bootstrap-apex directory
at all.

Bug: 290148078
Test: atest VendorApexHostTestCases
Test: atest MicrodroidTests
Change-Id: I541cec71d9970b14971d46e01e4808b23590dbed
---
 init/builtins.cpp        | 50 ++++++++++++++++++++++++++++++++++++++++
 init/init.cpp            |  6 +++++
 init/mount_namespace.cpp | 39 +++++++++++++++++++++++--------
 init/mount_namespace.h   |  3 +++
 init/selinux.cpp         |  2 +-
 rootdir/Android.mk       |  2 +-
 6 files changed, 91 insertions(+), 11 deletions(-)

diff --git a/init/builtins.cpp b/init/builtins.cpp
index 2176233aab96..e4f0bd040ed6 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -1262,6 +1262,51 @@ static Result<void> MountLinkerConfigForDefaultNamespace() {
 
     return {};
 }
+
+static Result<void> MountApexRootForDefaultNamespace() {
+    auto mount_namespace_id = GetCurrentMountNamespace();
+    if (!mount_namespace_id.ok()) {
+        return mount_namespace_id.error();
+    }
+    // There's nothing to do if it's still in the bootstrap mount namespace.
+    // This happens when we don't need to update APEXes (e.g. Microdroid)
+    // where bootstrap mount namespace == default mount namespace.
+    if (mount_namespace_id.value() == NS_BOOTSTRAP) {
+        return {};
+    }
+
+    // Now, we're in the "default" mount namespace and need a fresh /apex for
+    // the default mount namespace.
+    //
+    // At this point, there are two mounts at the same mount point: /apex
+    // - to tmpfs (private)
+    // - to /bootstrap-apex (shared)
+    //
+    // We need unmount the second mount so that /apex in the default mount
+    // namespace becomes RW/empty and "private" (we don't want mount events to
+    // propagate to the bootstrap mount namespace).
+    //
+    // Likewise, we don't want the unmount event itself to propagate to the
+    // bootstrap mount namespace. Otherwise, /apex in the bootstrap mount
+    // namespace would become empty due to the unmount.
+    //
+    // Hence, before unmounting, we make /apex (the second one) "private" first.
+    // so that the unmouting below doesn't affect to the bootstrap mount namespace.
+    if (mount(nullptr, "/apex", nullptr, MS_PRIVATE | MS_REC, nullptr) == -1) {
+        return ErrnoError() << "Failed to remount /apex as private";
+    }
+
+    // Now we can unmount /apex (bind-mount to /bootstrap-apex). This only affects
+    // in the default mount namespace and /apex is now seen as tmpfs mount.
+    // Note that /apex in the bootstrap mount namespace is still a bind-mount to
+    // /bootstrap-apex and holds the APEX mounts.
+    if (umount2("/apex", MNT_DETACH) == -1) {
+        return ErrnoError() << "Failed to umount /apex";
+    }
+
+    return {};
+}
+
 static Result<void> do_update_linker_config(const BuiltinArguments&) {
     return GenerateLinkerConfiguration();
 }
@@ -1314,6 +1359,11 @@ static Result<void> do_enter_default_mount_ns(const BuiltinArguments& args) {
     if (auto result = SwitchToMountNamespaceIfNeeded(NS_DEFAULT); !result.ok()) {
         return result.error();
     }
+
+    if (auto result = MountApexRootForDefaultNamespace(); !result.ok()) {
+        return result.error();
+    }
+
     if (auto result = MountLinkerConfigForDefaultNamespace(); !result.ok()) {
         return result.error();
     }
diff --git a/init/init.cpp b/init/init.cpp
index da63fdc3bda5..4bb8eecb981a 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -832,6 +832,12 @@ static void MountExtraFilesystems() {
     CHECKCALL(mount("tmpfs", "/apex", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
                     "mode=0755,uid=0,gid=0"));
 
+    if (NeedsTwoMountNamespaces()) {
+        // /bootstrap-apex is used to mount "bootstrap" APEXes.
+        CHECKCALL(mount("tmpfs", "/bootstrap-apex", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
+                        "mode=0755,uid=0,gid=0"));
+    }
+
     // /linkerconfig is used to keep generated linker configuration
     CHECKCALL(mount("tmpfs", "/linkerconfig", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
                     "mode=0755,uid=0,gid=0"));
diff --git a/init/mount_namespace.cpp b/init/mount_namespace.cpp
index 5b53d5092227..e069a5d3e3db 100644
--- a/init/mount_namespace.cpp
+++ b/init/mount_namespace.cpp
@@ -66,15 +66,6 @@ static std::string GetMountNamespaceId() {
     return ret;
 }
 
-// In case we have two sets of APEXes (non-updatable, updatable), we need two separate mount
-// namespaces.
-static bool NeedsTwoMountNamespaces() {
-    if (IsRecoveryMode()) return false;
-    // In microdroid, there's only one set of APEXes in built-in directories include block devices.
-    if (IsMicrodroid()) return false;
-    return true;
-}
-
 static android::base::unique_fd bootstrap_ns_fd;
 static android::base::unique_fd default_ns_fd;
 
@@ -83,6 +74,15 @@ static std::string default_ns_id;
 
 }  // namespace
 
+// In case we have two sets of APEXes (non-updatable, updatable), we need two separate mount
+// namespaces.
+bool NeedsTwoMountNamespaces() {
+    if (IsRecoveryMode()) return false;
+    // In microdroid, there's only one set of APEXes in built-in directories include block devices.
+    if (IsMicrodroid()) return false;
+    return true;
+}
+
 bool SetupMountNamespaces() {
     // Set the propagation type of / as shared so that any mounting event (e.g.
     // /data) is by default visible to all processes. When private mounting is
@@ -96,6 +96,27 @@ bool SetupMountNamespaces() {
     // the bootstrap namespace get APEXes from the read-only partition.
     if (!(ChangeMount("/apex", MS_PRIVATE))) return false;
 
+    // However, some components (e.g. servicemanager) need to access bootstrap
+    // APEXes from the default mount namespace. To achieve that, we bind-mount
+    // /apex with /bootstrap-apex (not private) in the bootstrap mount namespace.
+    // Bootstrap APEXes are mounted in /apex and also visible in /bootstrap-apex.
+    // In the default mount namespace, we detach /bootstrap-apex from /apex and
+    // bootstrap APEXes are still be visible in /bootstrap-apex.
+    //
+    // The end result will look like:
+    //   in the bootstrap mount namespace:
+    //     /apex  (== /bootstrap-apex)
+    //       {bootstrap APEXes from the read-only partition}
+    //
+    //   in the default mount namespace:
+    //     /bootstrap-apex
+    //       {bootstrap APEXes from the read-only partition}
+    //     /apex
+    //       {APEXes, can be from /data partition}
+    if (NeedsTwoMountNamespaces()) {
+        if (!(BindMount("/bootstrap-apex", "/apex"))) return false;
+    }
+
     // /linkerconfig is a private mountpoint to give a different linker configuration
     // based on the mount namespace. Subdirectory will be bind-mounted based on current mount
     // namespace
diff --git a/init/mount_namespace.h b/init/mount_namespace.h
index 5e3dab241290..43c5476a6ab8 100644
--- a/init/mount_namespace.h
+++ b/init/mount_namespace.h
@@ -24,9 +24,12 @@ namespace init {
 enum MountNamespace { NS_BOOTSTRAP, NS_DEFAULT };
 
 bool SetupMountNamespaces();
+
 base::Result<void> SwitchToMountNamespaceIfNeeded(MountNamespace target_mount_namespace);
 
 base::Result<MountNamespace> GetCurrentMountNamespace();
 
+bool NeedsTwoMountNamespaces();
+
 }  // namespace init
 }  // namespace android
diff --git a/init/selinux.cpp b/init/selinux.cpp
index 51093d898e8b..8532c44c1c70 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -766,7 +766,7 @@ void SelinuxRestoreContext() {
     selinux_android_restorecon("/dev/device-mapper", 0);
 
     selinux_android_restorecon("/apex", 0);
-
+    selinux_android_restorecon("/bootstrap-apex", 0);
     selinux_android_restorecon("/linkerconfig", 0);
 
     // adb remount, snapshot-based updates, and DSUs all create files during
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 3362872c070d..52187536f3fe 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -91,7 +91,7 @@ endif
 #
 # create some directories (some are mount points) and symlinks
 LOCAL_POST_INSTALL_CMD := mkdir -p $(addprefix $(TARGET_ROOT_OUT)/, \
-    dev proc sys system data data_mirror odm oem acct config storage mnt apex debug_ramdisk \
+    dev proc sys system data data_mirror odm oem acct config storage mnt apex bootstrap-apex debug_ramdisk \
     linkerconfig second_stage_resources postinstall $(BOARD_ROOT_EXTRA_FOLDERS)); \
     ln -sf /system/bin $(TARGET_ROOT_OUT)/bin; \
     ln -sf /system/etc $(TARGET_ROOT_OUT)/etc; \

From 48d6e0452e1564f3a2b49e327e9f750fc50ed3d8 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Mon, 31 Jul 2023 14:24:01 -0700
Subject: [PATCH 0248/1487] Make libdebuggerd ramdisk available.

Test: Builds and debuggerd unit tests pass.
Change-Id: I2a5bd96e349f81ae0bec8dbffc49646c1f58bfea
---
 debuggerd/Android.bp       | 17 ++++++++++++++---
 debuggerd/proto/Android.bp |  1 +
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index d20de6bbf724..5393e25e5098 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -188,6 +188,7 @@ cc_library {
 cc_library_static {
     name: "libdebuggerd",
     defaults: ["debuggerd_defaults"],
+    ramdisk_available: true,
     recovery_available: true,
     vendor_ramdisk_available: true,
 
@@ -221,9 +222,6 @@ cc_library_static {
         "libbase",
         "libcutils",
     ],
-    runtime_libs: [
-        "libdexfile",           // libdexfile_support dependency
-    ],
 
     whole_static_libs: [
         "libasync_safe",
@@ -250,6 +248,19 @@ cc_library_static {
                 "libdexfile",
             ],
         },
+        ramdisk: {
+            exclude_static_libs: [
+                "libdexfile_support",
+            ],
+            exclude_runtime_libs: [
+                "libdexfile",
+            ],
+        },
+        android: {
+            runtime_libs: [
+                "libdexfile",           // libdexfile_support dependency
+            ],
+        },
     },
 
     product_variables: {
diff --git a/debuggerd/proto/Android.bp b/debuggerd/proto/Android.bp
index 73cf5737d12e..804f8055ba60 100644
--- a/debuggerd/proto/Android.bp
+++ b/debuggerd/proto/Android.bp
@@ -35,6 +35,7 @@ cc_library_static {
         "com.android.runtime",
     ],
 
+    ramdisk_available: true,
     recovery_available: true,
     vendor_ramdisk_available: true,
 }

From 72254810d9d63f8267d32d251456a78cd4891698 Mon Sep 17 00:00:00 2001
From: Suren Baghdasaryan <surenb@google.com>
Date: Tue, 25 Jul 2023 14:50:18 -0700
Subject: [PATCH 0249/1487] libprocessgroup: fix reset of file_v2_name

ProfileAttribute::Reset does not reset file_v2_name, fix that. Also
provide ProfileAttribute::file_name() to consolidate the code.

Bug: 292636609
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Change-Id: I5b33ca47b4fa5cabf582c8804bd13f72f6e58411
Merged-In: I5b33ca47b4fa5cabf582c8804bd13f72f6e58411
(cherry picked from commit 2ffbeaef3a926b0b5fd873136588deb3ec61ef96)
---
 libprocessgroup/task_profiles.cpp      | 22 +++++++++++++---------
 libprocessgroup/task_profiles.h        |  8 +++++---
 libprocessgroup/task_profiles_test.cpp |  7 +++----
 3 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 44dba2a16694..59b135013326 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -114,9 +114,16 @@ bool FdCacheHelper::IsAppDependentPath(const std::string& path) {
 
 IProfileAttribute::~IProfileAttribute() = default;
 
-void ProfileAttribute::Reset(const CgroupController& controller, const std::string& file_name) {
+const std::string& ProfileAttribute::file_name() const {
+    if (controller()->version() == 2 && !file_v2_name_.empty()) return file_v2_name_;
+    return file_name_;
+}
+
+void ProfileAttribute::Reset(const CgroupController& controller, const std::string& file_name,
+                             const std::string& file_v2_name) {
     controller_ = controller;
     file_name_ = file_name;
+    file_v2_name_ = file_v2_name;
 }
 
 bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
@@ -129,12 +136,11 @@ bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
         return true;
     }
 
-    const std::string& file_name =
-            controller()->version() == 2 && !file_v2_name_.empty() ? file_v2_name_ : file_name_;
     if (subgroup.empty()) {
-        *path = StringPrintf("%s/%s", controller()->path(), file_name.c_str());
+        *path = StringPrintf("%s/%s", controller()->path(), file_name().c_str());
     } else {
-        *path = StringPrintf("%s/%s/%s", controller()->path(), subgroup.c_str(), file_name.c_str());
+        *path = StringPrintf("%s/%s/%s", controller()->path(), subgroup.c_str(),
+                             file_name().c_str());
     }
     return true;
 }
@@ -144,9 +150,7 @@ bool ProfileAttribute::GetPathForUID(uid_t uid, std::string* path) const {
         return true;
     }
 
-    const std::string& file_name =
-            controller()->version() == 2 && !file_v2_name_.empty() ? file_v2_name_ : file_name_;
-    *path = StringPrintf("%s/uid_%d/%s", controller()->path(), uid, file_name.c_str());
+    *path = StringPrintf("%s/uid_%u/%s", controller()->path(), uid, file_name().c_str());
     return true;
 }
 
@@ -816,7 +820,7 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                 attributes_[name] =
                         std::make_unique<ProfileAttribute>(controller, file_attr, file_v2_attr);
             } else {
-                iter->second->Reset(controller, file_attr);
+                iter->second->Reset(controller, file_attr, file_v2_attr);
             }
         } else {
             LOG(WARNING) << "Controller " << controller_name << " is not found";
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index a62c5b0a9e8c..ac8918e650fc 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -32,7 +32,8 @@
 class IProfileAttribute {
   public:
     virtual ~IProfileAttribute() = 0;
-    virtual void Reset(const CgroupController& controller, const std::string& file_name) = 0;
+    virtual void Reset(const CgroupController& controller, const std::string& file_name,
+                       const std::string& file_v2_name) = 0;
     virtual const CgroupController* controller() const = 0;
     virtual const std::string& file_name() const = 0;
     virtual bool GetPathForTask(int tid, std::string* path) const = 0;
@@ -50,8 +51,9 @@ class ProfileAttribute : public IProfileAttribute {
     ~ProfileAttribute() = default;
 
     const CgroupController* controller() const override { return &controller_; }
-    const std::string& file_name() const override { return file_name_; }
-    void Reset(const CgroupController& controller, const std::string& file_name) override;
+    const std::string& file_name() const override;
+    void Reset(const CgroupController& controller, const std::string& file_name,
+               const std::string& file_v2_name) override;
 
     bool GetPathForTask(int tid, std::string* path) const override;
     bool GetPathForUID(uid_t uid, std::string* path) const override;
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index eadbe7697b07..da74bb012f8f 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -102,7 +102,8 @@ class ProfileAttributeMock : public IProfileAttribute {
   public:
     ProfileAttributeMock(const std::string& file_name) : file_name_(file_name) {}
     ~ProfileAttributeMock() override = default;
-    void Reset(const CgroupController& controller, const std::string& file_name) override {
+    void Reset(const CgroupController& controller, const std::string& file_name,
+               const std::string& file_v2_name) override {
         CHECK(false);
     }
     const CgroupController* controller() const override {
@@ -125,9 +126,7 @@ class ProfileAttributeMock : public IProfileAttribute {
         return true;
     };
 
-    bool GetPathForUID(uid_t, std::string*) const override {
-        return false;
-    }
+    bool GetPathForUID(uid_t, std::string*) const override { return false; }
 
   private:
     const std::string file_name_;

From 1e81ee13638c5ca03157db674009d4cf7c2a1263 Mon Sep 17 00:00:00 2001
From: Suren Baghdasaryan <surenb@google.com>
Date: Tue, 25 Jul 2023 15:45:45 -0700
Subject: [PATCH 0250/1487] libprocessgroup: optimize
 SetAttributeAction::ExecuteForProcess performance

Current implementation of SetAttributeAction::ExecuteForProcess reuses
SetAttributeAction::ExecuteForTask while not utilizing available uid/pid
information. This results in a call to GetPathForTask() which is an
expensive function due to it reading and parsing /proc/$pid/cgroups.
This can be avoided if we utilize available uid/pid info and the fact
that cgroup v2 attributes share the cgroup v2 hierarchy as process
groups, which use a known path template.

Bug: 292636609
Change-Id: I02e3046bd85d0dfebc68ab444f1796bb54cc69c7
Merged-In: I02e3046bd85d0dfebc68ab444f1796bb54cc69c7
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
(cherry picked from commit 961c01ce23bb886583ca8cac1640806346c09a7f)
---
 libprocessgroup/task_profiles.cpp      | 45 +++++++++++++++++++-------
 libprocessgroup/task_profiles.h        |  4 +++
 libprocessgroup/task_profiles_test.cpp |  3 ++
 3 files changed, 40 insertions(+), 12 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 59b135013326..f51b07671bf1 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -126,6 +126,16 @@ void ProfileAttribute::Reset(const CgroupController& controller, const std::stri
     file_v2_name_ = file_v2_name;
 }
 
+bool ProfileAttribute::GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const {
+    if (controller()->version() == 2) {
+        // all cgroup v2 attributes use the same process group hierarchy
+        *path = StringPrintf("%s/uid_%u/pid_%d/%s", controller()->path(), uid, pid,
+                             file_name().c_str());
+        return true;
+    }
+    return GetPathForTask(pid, path);
+}
+
 bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
     std::string subgroup;
     if (!controller()->GetTaskGroup(tid, &subgroup)) {
@@ -209,18 +219,7 @@ bool SetTimerSlackAction::ExecuteForTask(int) const {
 
 #endif
 
-bool SetAttributeAction::ExecuteForProcess(uid_t, pid_t pid) const {
-    return ExecuteForTask(pid);
-}
-
-bool SetAttributeAction::ExecuteForTask(int tid) const {
-    std::string path;
-
-    if (!attribute_->GetPathForTask(tid, &path)) {
-        LOG(ERROR) << "Failed to find cgroup for tid " << tid;
-        return false;
-    }
-
+bool SetAttributeAction::WriteValueToFile(const std::string& path) const {
     if (!WriteStringToFile(value_, path)) {
         if (access(path.c_str(), F_OK) < 0) {
             if (optional_) {
@@ -240,6 +239,28 @@ bool SetAttributeAction::ExecuteForTask(int tid) const {
     return true;
 }
 
+bool SetAttributeAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
+    std::string path;
+
+    if (!attribute_->GetPathForProcess(uid, pid, &path)) {
+        LOG(ERROR) << "Failed to find cgroup for uid " << uid << " pid " << pid;
+        return false;
+    }
+
+    return WriteValueToFile(path);
+}
+
+bool SetAttributeAction::ExecuteForTask(int tid) const {
+    std::string path;
+
+    if (!attribute_->GetPathForTask(tid, &path)) {
+        LOG(ERROR) << "Failed to find cgroup for tid " << tid;
+        return false;
+    }
+
+    return WriteValueToFile(path);
+}
+
 bool SetAttributeAction::ExecuteForUID(uid_t uid) const {
     std::string path;
 
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index ac8918e650fc..4663f64e2a7e 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -36,6 +36,7 @@ class IProfileAttribute {
                        const std::string& file_v2_name) = 0;
     virtual const CgroupController* controller() const = 0;
     virtual const std::string& file_name() const = 0;
+    virtual bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const = 0;
     virtual bool GetPathForTask(int tid, std::string* path) const = 0;
     virtual bool GetPathForUID(uid_t uid, std::string* path) const = 0;
 };
@@ -55,6 +56,7 @@ class ProfileAttribute : public IProfileAttribute {
     void Reset(const CgroupController& controller, const std::string& file_name,
                const std::string& file_v2_name) override;
 
+    bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const override;
     bool GetPathForTask(int tid, std::string* path) const override;
     bool GetPathForUID(uid_t uid, std::string* path) const override;
 
@@ -133,6 +135,8 @@ class SetAttributeAction : public ProfileAction {
     const IProfileAttribute* attribute_;
     std::string value_;
     bool optional_;
+
+    bool WriteValueToFile(const std::string& path) const;
 };
 
 // Set cgroup profile element
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index da74bb012f8f..99d819a7cc4c 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -111,6 +111,9 @@ class ProfileAttributeMock : public IProfileAttribute {
         return {};
     }
     const std::string& file_name() const override { return file_name_; }
+    bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const override {
+        return GetPathForTask(pid, path);
+    }
     bool GetPathForTask(int tid, std::string* path) const override {
 #ifdef __ANDROID__
         CHECK(CgroupGetControllerPath(CGROUPV2_CONTROLLER_NAME, path));

From 7b5c38f8eb7fc83006e1cc7366397a2441c88604 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Sat, 29 Jul 2023 17:46:32 +0800
Subject: [PATCH 0251/1487] libfstab: Unexport InRecovery()

It was accidentally moved to the public header when I was previously
refactoring the code. It hasn't caused any harm yet, but we probably
don't want to export this, too.

Bug: 293695109
Test: build
Change-Id: Id81c802cc6cc697c5a4204638aa467966bea1562
---
 fs_mgr/fs_mgr_priv.h               | 3 +++
 fs_mgr/include_fstab/fstab/fstab.h | 2 --
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/fs_mgr_priv.h b/fs_mgr/fs_mgr_priv.h
index c3b18c85c78f..678dd69cb3d7 100644
--- a/fs_mgr/fs_mgr_priv.h
+++ b/fs_mgr/fs_mgr_priv.h
@@ -109,6 +109,9 @@ OverlayfsValidResult fs_mgr_overlayfs_valid();
 
 namespace android {
 namespace fs_mgr {
+
 bool UnmapDevice(const std::string& name);
+bool InRecovery();
+
 }  // namespace fs_mgr
 }  // namespace android
diff --git a/fs_mgr/include_fstab/fstab/fstab.h b/fs_mgr/include_fstab/fstab/fstab.h
index 80b45ba93dc6..9cb1546c5aaf 100644
--- a/fs_mgr/include_fstab/fstab/fstab.h
+++ b/fs_mgr/include_fstab/fstab/fstab.h
@@ -131,7 +131,5 @@ std::set<std::string> GetBootDevices();
 // expected name.
 std::string GetVerityDeviceName(const FstabEntry& entry);
 
-bool InRecovery();
-
 }  // namespace fs_mgr
 }  // namespace android

From d838dde6aa27bc137855313798988d70f4305adf Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Sat, 22 Jul 2023 01:41:10 +0800
Subject: [PATCH 0252/1487] fs_mgr: Refactor mandatory overlayfs kernel patch
 checks

The check result can just return the exact mount flags to use, this
reduces code duplication at the caller's side.

Bug: 293695109
Test: adb-remount-test
Change-Id: I9b5c918968f2494c0c1be3cb8d8e6b527a9c4eb2
---
 fs_mgr/fs_mgr.cpp                 | 45 ++++++++++++++++---------------
 fs_mgr/fs_mgr_overlayfs_mount.cpp | 22 ++-------------
 fs_mgr/fs_mgr_priv.h              | 14 +++++-----
 fs_mgr/fs_mgr_vendor_overlay.cpp  |  8 +++---
 4 files changed, 35 insertions(+), 54 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index e568a9bd6b7d..d55f8d3bfd59 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -2227,8 +2227,8 @@ bool fs_mgr_create_canonical_mount_point(const std::string& mount_point) {
 }
 
 bool fs_mgr_mount_overlayfs_fstab_entry(const FstabEntry& entry) {
-    auto overlayfs_valid_result = fs_mgr_overlayfs_valid();
-    if (overlayfs_valid_result == OverlayfsValidResult::kNotSupported) {
+    const auto overlayfs_check_result = android::fs_mgr::CheckOverlayfs();
+    if (!overlayfs_check_result.supported) {
         LERROR << __FUNCTION__ << "(): kernel does not support overlayfs";
         return false;
     }
@@ -2280,10 +2280,7 @@ bool fs_mgr_mount_overlayfs_fstab_entry(const FstabEntry& entry) {
         }
     }
 
-    auto options = "lowerdir=" + lowerdir;
-    if (overlayfs_valid_result == OverlayfsValidResult::kOverrideCredsRequired) {
-        options += ",override_creds=off";
-    }
+    const auto options = "lowerdir=" + lowerdir + overlayfs_check_result.mount_flags;
 
     // Use "overlay-" + entry.blk_device as the mount() source, so that adb-remout-test don't
     // confuse this with adb remount overlay, whose device name is "overlay".
@@ -2339,30 +2336,34 @@ std::string fs_mgr_get_context(const std::string& mount_point) {
     return context;
 }
 
-OverlayfsValidResult fs_mgr_overlayfs_valid() {
-    // Overlayfs available in the kernel, and patched for override_creds?
-    if (access("/sys/module/overlay/parameters/override_creds", F_OK) == 0) {
-        return OverlayfsValidResult::kOverrideCredsRequired;
-    }
+namespace android {
+namespace fs_mgr {
+
+OverlayfsCheckResult CheckOverlayfs() {
     if (!fs_mgr_filesystem_available("overlay")) {
-        return OverlayfsValidResult::kNotSupported;
+        return {.supported = false};
     }
     struct utsname uts;
     if (uname(&uts) == -1) {
-        return OverlayfsValidResult::kNotSupported;
+        return {.supported = false};
     }
     int major, minor;
     if (sscanf(uts.release, "%d.%d", &major, &minor) != 2) {
-        return OverlayfsValidResult::kNotSupported;
+        return {.supported = false};
     }
-    if (major < 4) {
-        return OverlayfsValidResult::kOk;
-    }
-    if (major > 4) {
-        return OverlayfsValidResult::kNotSupported;
+    // Overlayfs available in the kernel, and patched for override_creds?
+    if (access("/sys/module/overlay/parameters/override_creds", F_OK) == 0) {
+        auto mount_flags = ",override_creds=off"s;
+        if (major > 5 || (major == 5 && minor >= 15)) {
+            mount_flags += ",userxattr"s;
+        }
+        return {.supported = true, .mount_flags = mount_flags};
     }
-    if (minor > 3) {
-        return OverlayfsValidResult::kNotSupported;
+    if (major < 4 || (major == 4 && minor <= 3)) {
+        return {.supported = true};
     }
-    return OverlayfsValidResult::kOk;
+    return {.supported = false};
 }
+
+}  // namespace fs_mgr
+}  // namespace android
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index 37e30585a040..8fb63b17435a 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -23,7 +23,6 @@
 #include <sys/stat.h>
 #include <sys/statvfs.h>
 #include <sys/types.h>
-#include <sys/utsname.h>
 #include <sys/vfs.h>
 #include <unistd.h>
 
@@ -218,17 +217,6 @@ static std::string fs_mgr_get_overlayfs_candidate(const std::string& mount_point
     return "";
 }
 
-static inline bool KernelSupportsUserXattrs() {
-    struct utsname uts;
-    uname(&uts);
-
-    int major, minor;
-    if (sscanf(uts.release, "%d.%d", &major, &minor) != 2) {
-        return false;
-    }
-    return major > 5 || (major == 5 && minor >= 15);
-}
-
 const std::string fs_mgr_mount_point(const std::string& mount_point) {
     if ("/"s != mount_point) return mount_point;
     return "/system";
@@ -240,13 +228,7 @@ static std::string fs_mgr_get_overlayfs_options(const FstabEntry& entry) {
     auto candidate = fs_mgr_get_overlayfs_candidate(mount_point);
     if (candidate.empty()) return "";
     auto ret = kLowerdirOption + mount_point + "," + kUpperdirOption + candidate + kUpperName +
-               ",workdir=" + candidate + kWorkName;
-    if (fs_mgr_overlayfs_valid() == OverlayfsValidResult::kOverrideCredsRequired) {
-        ret += ",override_creds=off";
-    }
-    if (KernelSupportsUserXattrs()) {
-        ret += ",userxattr";
-    }
+               ",workdir=" + candidate + kWorkName + android::fs_mgr::CheckOverlayfs().mount_flags;
     for (const auto& flag : android::base::Split(entry.fs_options, ",")) {
         if (android::base::StartsWith(flag, "context=")) {
             ret += "," + flag;
@@ -608,7 +590,7 @@ bool OverlayfsSetupAllowed(bool verbose) {
         return false;
     }
     // Check mandatory kernel patches.
-    if (fs_mgr_overlayfs_valid() == OverlayfsValidResult::kNotSupported) {
+    if (!android::fs_mgr::CheckOverlayfs().supported) {
         if (verbose) {
             LOG(ERROR) << "Kernel does not support overlayfs";
         }
diff --git a/fs_mgr/fs_mgr_priv.h b/fs_mgr/fs_mgr_priv.h
index 678dd69cb3d7..12a4a6d7f3dd 100644
--- a/fs_mgr/fs_mgr_priv.h
+++ b/fs_mgr/fs_mgr_priv.h
@@ -100,18 +100,18 @@ bool fs_mgr_is_f2fs(const std::string& blk_device);
 bool fs_mgr_filesystem_available(const std::string& filesystem);
 std::string fs_mgr_get_context(const std::string& mount_point);
 
-enum class OverlayfsValidResult {
-    kNotSupported = 0,
-    kOk,
-    kOverrideCredsRequired,
-};
-OverlayfsValidResult fs_mgr_overlayfs_valid();
-
 namespace android {
 namespace fs_mgr {
 
 bool UnmapDevice(const std::string& name);
 bool InRecovery();
 
+struct OverlayfsCheckResult {
+    bool supported;
+    std::string mount_flags;
+};
+
+OverlayfsCheckResult CheckOverlayfs();
+
 }  // namespace fs_mgr
 }  // namespace android
diff --git a/fs_mgr/fs_mgr_vendor_overlay.cpp b/fs_mgr/fs_mgr_vendor_overlay.cpp
index 6b32b4d6fcd4..bacfa4b59bfe 100644
--- a/fs_mgr/fs_mgr_vendor_overlay.cpp
+++ b/fs_mgr/fs_mgr_vendor_overlay.cpp
@@ -85,10 +85,8 @@ bool fs_mgr_vendor_overlay_mount(const std::pair<std::string, std::string>& moun
         return false;
     }
 
-    auto options = kLowerdirOption + source_directory + ":" + vendor_mount_point;
-    if (fs_mgr_overlayfs_valid() == OverlayfsValidResult::kOverrideCredsRequired) {
-        options += ",override_creds=off";
-    }
+    const auto options = kLowerdirOption + source_directory + ":" + vendor_mount_point +
+                         android::fs_mgr::CheckOverlayfs().mount_flags;
     auto report = "__mount(source=overlay,target="s + vendor_mount_point + ",type=overlay," +
                   options + ")=";
     auto ret = mount("overlay", vendor_mount_point.c_str(), "overlay", MS_RDONLY | MS_NOATIME,
@@ -120,7 +118,7 @@ bool fs_mgr_vendor_overlay_mount_all() {
 
     const auto vendor_overlay_dirs = fs_mgr_get_vendor_overlay_dirs(vndk_version);
     if (vendor_overlay_dirs.empty()) return true;
-    if (fs_mgr_overlayfs_valid() == OverlayfsValidResult::kNotSupported) {
+    if (!android::fs_mgr::CheckOverlayfs().supported) {
         LINFO << "vendor overlay: kernel does not support overlayfs";
         return false;
     }

From c30f033b4e8d5f288114f2037be1813e29c09049 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Tue, 25 Jul 2023 01:32:05 +0800
Subject: [PATCH 0253/1487] fs_mgr: Remove `include_dirs` declaration

We aren't using anything through the removed path.
We also shouldn't use `include_dirs` to begin with, as it bypasses any
build system checks.

Bug: 293695109
Test: build
Change-Id: I06f7450c3ce545aa2583f8c3f8db18c45073f69e
---
 fs_mgr/Android.bp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/fs_mgr/Android.bp b/fs_mgr/Android.bp
index 0a836e43295f..7721ebf7aad3 100644
--- a/fs_mgr/Android.bp
+++ b/fs_mgr/Android.bp
@@ -60,7 +60,6 @@ cc_defaults {
     defaults: ["fs_mgr_defaults"],
     export_include_dirs: ["include"],
     local_include_dirs: ["include/"],
-    include_dirs: ["system/vold"],
     cflags: [
         "-D_FILE_OFFSET_BITS=64",
     ],

From 96126069c290b7daa408b14e1fc526c9a8e3b451 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Mon, 24 Jul 2023 20:03:01 +0800
Subject: [PATCH 0254/1487] fs_mgr: Split libfs_mgr and libfstab

The goal is to make the header definitions of the two curiously
intertwined libraries less chaotic.

After this change, libfstab's header would be self contained. In the
sense that all symbols exported by its headers are defined in its
compilation units.
libfs_mgr would still embed libfstab like before, it can use internal
symbols (symbols not exported by public headers) of libfstab through
the libfstab/fstab_priv.h private header.

Keep include_fstab/ as a symbolic link pointing to its new location.
This is a temporary workaround as there are still some bad build rules
(incorrectly) depending on the old include path with Android.bp
`include_dirs` directive.

Bug: 293695109
Test: build
Change-Id: Ib70a84984ac2cbfca5f5b27fadebf6a16e58146a
---
 fs_mgr/Android.bp                             | 43 -------------
 fs_mgr/fs_mgr_priv.h                          | 14 +----
 fs_mgr/include_fstab                          |  1 +
 fs_mgr/libfstab/Android.bp                    | 62 +++++++++++++++++++
 .../boot_config.cpp}                          | 11 ++--
 .../{fs_mgr_fstab.cpp => libfstab/fstab.cpp}  | 15 +++--
 .../fstab_priv.h}                             | 26 ++++++--
 fs_mgr/{ => libfstab}/fuzz/Android.bp         |  0
 .../fuzz/fs_mgr_fstab_fuzzer.cpp              |  2 +
 fs_mgr/{ => libfstab}/fuzz/fstab.dict         |  0
 .../include}/fstab/fstab.h                    |  7 ---
 fs_mgr/libfstab/logging_macros.h              | 40 ++++++++++++
 .../slotselect.cpp}                           |  4 +-
 fs_mgr/tests/Android.bp                       |  2 -
 fs_mgr/tests/fs_mgr_test.cpp                  |  2 +-
 fs_mgr/tests/vts_fs_test.cpp                  |  2 +
 16 files changed, 146 insertions(+), 85 deletions(-)
 create mode 120000 fs_mgr/include_fstab
 create mode 100644 fs_mgr/libfstab/Android.bp
 rename fs_mgr/{fs_mgr_boot_config.cpp => libfstab/boot_config.cpp} (97%)
 rename fs_mgr/{fs_mgr_fstab.cpp => libfstab/fstab.cpp} (98%)
 rename fs_mgr/{fs_mgr_priv_boot_config.h => libfstab/fstab_priv.h} (69%)
 rename fs_mgr/{ => libfstab}/fuzz/Android.bp (100%)
 rename fs_mgr/{ => libfstab}/fuzz/fs_mgr_fstab_fuzzer.cpp (98%)
 rename fs_mgr/{ => libfstab}/fuzz/fstab.dict (100%)
 rename fs_mgr/{include_fstab => libfstab/include}/fstab/fstab.h (91%)
 create mode 100644 fs_mgr/libfstab/logging_macros.h
 rename fs_mgr/{fs_mgr_slotselect.cpp => libfstab/slotselect.cpp} (98%)

diff --git a/fs_mgr/Android.bp b/fs_mgr/Android.bp
index 7721ebf7aad3..4e4d20edc516 100644
--- a/fs_mgr/Android.bp
+++ b/fs_mgr/Android.bp
@@ -89,8 +89,6 @@ cc_defaults {
     static_libs: [
         "libavb",
         "libfs_avb",
-        "libfstab",
-        "libdm",
         "libgsi",
     ],
     export_static_lib_headers: [
@@ -173,47 +171,6 @@ cc_library {
     ],
 }
 
-cc_library_static {
-    // Do not ever make this a shared library as long as it is vendor_available.
-    // It does not have a stable interface.
-    name: "libfstab",
-    vendor_available: true,
-    ramdisk_available: true,
-    vendor_ramdisk_available: true,
-    recovery_available: true,
-    apex_available: [
-        "//apex_available:anyapex",
-        "//apex_available:platform",
-    ],
-    host_supported: true,
-    defaults: ["fs_mgr_defaults"],
-    local_include_dirs: ["include/"],
-    srcs: [
-        "fs_mgr_fstab.cpp",
-        "fs_mgr_boot_config.cpp",
-        "fs_mgr_slotselect.cpp",
-    ],
-    target: {
-        darwin: {
-            enabled: false,
-        },
-        vendor: {
-            cflags: [
-                // Skipping entries in fstab should only be done in a system
-                // process as the config file is in /system_ext.
-                // Remove the op from the vendor variant.
-                "-DNO_SKIP_MOUNT",
-            ],
-        },
-    },
-    export_include_dirs: ["include_fstab"],
-    header_libs: [
-        "libbase_headers",
-        "libgsi_headers",
-    ],
-    min_sdk_version: "31",
-}
-
 cc_binary {
     name: "remount",
     defaults: ["fs_mgr_defaults"],
diff --git a/fs_mgr/fs_mgr_priv.h b/fs_mgr/fs_mgr_priv.h
index 12a4a6d7f3dd..7e4d5e54db4c 100644
--- a/fs_mgr/fs_mgr_priv.h
+++ b/fs_mgr/fs_mgr_priv.h
@@ -23,15 +23,7 @@
 #include <fs_mgr.h>
 #include <fstab/fstab.h>
 
-#include "fs_mgr_priv_boot_config.h"
-
-/* The CHECK() in logging.h will use program invocation name as the tag.
- * Thus, the log will have prefix "init: " when libfs_mgr is statically
- * linked in the init process. This might be opaque when debugging.
- * Appends "in libfs_mgr" at the end of the abort message to explicitly
- * indicate the check happens in fs_mgr.
- */
-#define FS_MGR_CHECK(x) CHECK(x) << "in libfs_mgr "
+#include "libfstab/fstab_priv.h"
 
 #define FS_MGR_TAG "[libfs_mgr] "
 
@@ -89,10 +81,7 @@
 using namespace std::chrono_literals;
 
 bool fs_mgr_set_blk_ro(const std::string& blockdev, bool readonly = true);
-bool fs_mgr_update_for_slotselect(android::fs_mgr::Fstab* fstab);
 bool fs_mgr_is_device_unlocked();
-const std::string& get_android_dt_dir();
-bool is_dt_compatible();
 
 bool fs_mgr_is_ext4(const std::string& blk_device);
 bool fs_mgr_is_f2fs(const std::string& blk_device);
@@ -104,7 +93,6 @@ namespace android {
 namespace fs_mgr {
 
 bool UnmapDevice(const std::string& name);
-bool InRecovery();
 
 struct OverlayfsCheckResult {
     bool supported;
diff --git a/fs_mgr/include_fstab b/fs_mgr/include_fstab
new file mode 120000
index 000000000000..728737fe589c
--- /dev/null
+++ b/fs_mgr/include_fstab
@@ -0,0 +1 @@
+libfstab/include
\ No newline at end of file
diff --git a/fs_mgr/libfstab/Android.bp b/fs_mgr/libfstab/Android.bp
new file mode 100644
index 000000000000..df0269c3a6af
--- /dev/null
+++ b/fs_mgr/libfstab/Android.bp
@@ -0,0 +1,62 @@
+//
+// Copyright (C) 2023 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.
+//
+
+package {
+    default_applicable_licenses: [
+        "Android-Apache-2.0",
+        "system_core_fs_mgr_license",
+    ],
+}
+
+cc_library_static {
+    // Do not ever make this a shared library as long as it is vendor_available.
+    // It does not have a stable interface.
+    name: "libfstab",
+    vendor_available: true,
+    ramdisk_available: true,
+    vendor_ramdisk_available: true,
+    recovery_available: true,
+    host_supported: true,
+    defaults: ["fs_mgr_defaults"],
+    export_include_dirs: ["include"],
+    header_libs: [
+        "libbase_headers",
+        "libgsi_headers",
+    ],
+    srcs: [
+        "fstab.cpp",
+        "boot_config.cpp",
+        "slotselect.cpp",
+    ],
+    target: {
+        darwin: {
+            enabled: false,
+        },
+        vendor: {
+            cflags: [
+                // Skipping entries in fstab should only be done in a system
+                // process as the config file is in /system_ext.
+                // Remove the op from the vendor variant.
+                "-DNO_SKIP_MOUNT",
+            ],
+        },
+    },
+    apex_available: [
+        "//apex_available:anyapex",
+        "//apex_available:platform",
+    ],
+    min_sdk_version: "31",
+}
diff --git a/fs_mgr/fs_mgr_boot_config.cpp b/fs_mgr/libfstab/boot_config.cpp
similarity index 97%
rename from fs_mgr/fs_mgr_boot_config.cpp
rename to fs_mgr/libfstab/boot_config.cpp
index 75d1e0db69d4..8fb28c607cb9 100644
--- a/fs_mgr/fs_mgr_boot_config.cpp
+++ b/fs_mgr/libfstab/boot_config.cpp
@@ -20,11 +20,12 @@
 #include <vector>
 
 #include <android-base/file.h>
+#include <android-base/properties.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
-#include <android-base/properties.h>
 
-#include "fs_mgr_priv.h"
+#include "fstab_priv.h"
+#include "logging_macros.h"
 
 std::vector<std::pair<std::string, std::string>> fs_mgr_parse_cmdline(const std::string& cmdline) {
     static constexpr char quote = '"';
@@ -84,7 +85,7 @@ std::vector<std::pair<std::string, std::string>> fs_mgr_parse_proc_bootconfig(
 
 bool fs_mgr_get_boot_config_from_bootconfig(const std::string& bootconfig,
                                             const std::string& android_key, std::string* out_val) {
-    FS_MGR_CHECK(out_val != nullptr);
+    FSTAB_CHECK(out_val != nullptr);
 
     const std::string bootconfig_key("androidboot." + android_key);
     for (const auto& [key, value] : fs_mgr_parse_proc_bootconfig(bootconfig)) {
@@ -100,7 +101,7 @@ bool fs_mgr_get_boot_config_from_bootconfig(const std::string& bootconfig,
 
 bool fs_mgr_get_boot_config_from_kernel(const std::string& cmdline, const std::string& android_key,
                                         std::string* out_val) {
-    FS_MGR_CHECK(out_val != nullptr);
+    FSTAB_CHECK(out_val != nullptr);
 
     const std::string cmdline_key("androidboot." + android_key);
     for (const auto& [key, value] : fs_mgr_parse_cmdline(cmdline)) {
@@ -140,7 +141,7 @@ bool fs_mgr_get_boot_config_from_kernel_cmdline(const std::string& key, std::str
 // kernel cmdline (in that order).  Returns 'true' if successfully
 // found, 'false' otherwise.
 bool fs_mgr_get_boot_config(const std::string& key, std::string* out_val) {
-    FS_MGR_CHECK(out_val != nullptr);
+    FSTAB_CHECK(out_val != nullptr);
 
     // firstly, check the device tree
     if (is_dt_compatible()) {
diff --git a/fs_mgr/fs_mgr_fstab.cpp b/fs_mgr/libfstab/fstab.cpp
similarity index 98%
rename from fs_mgr/fs_mgr_fstab.cpp
rename to fs_mgr/libfstab/fstab.cpp
index ca27034f4451..5b5c3d26c450 100644
--- a/fs_mgr/fs_mgr_fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -36,7 +36,8 @@
 #include <android-base/strings.h>
 #include <libgsi/libgsi.h>
 
-#include "fs_mgr_priv.h"
+#include "fstab_priv.h"
+#include "logging_macros.h"
 
 using android::base::EndsWith;
 using android::base::ParseByteCount;
@@ -54,7 +55,7 @@ constexpr char kDefaultAndroidDtDir[] = "/proc/device-tree/firmware/android";
 constexpr char kProcMountsPath[] = "/proc/mounts";
 
 struct FlagList {
-    const char *name;
+    const char* name;
     uint64_t flag;
 };
 
@@ -80,7 +81,7 @@ FlagList kMountFlagsList[] = {
 off64_t CalculateZramSize(int percentage) {
     off64_t total;
 
-    total  = sysconf(_SC_PHYS_PAGES);
+    total = sysconf(_SC_PHYS_PAGES);
     total *= percentage;
     total /= 100;
 
@@ -400,7 +401,7 @@ std::string ReadFstabFromDt() {
 
         std::string mount_point;
         file_name =
-            android::base::StringPrintf("%s/%s/mnt_point", fstabdir_name.c_str(), dp->d_name);
+                android::base::StringPrintf("%s/%s/mnt_point", fstabdir_name.c_str(), dp->d_name);
         if (ReadDtFile(file_name, &value)) {
             LINFO << "dt_fstab: Using a specified mount point " << value << " for " << dp->d_name;
             mount_point = value;
@@ -416,14 +417,16 @@ std::string ReadFstabFromDt() {
         }
         fstab_entry.push_back(value);
 
-        file_name = android::base::StringPrintf("%s/%s/mnt_flags", fstabdir_name.c_str(), dp->d_name);
+        file_name =
+                android::base::StringPrintf("%s/%s/mnt_flags", fstabdir_name.c_str(), dp->d_name);
         if (!ReadDtFile(file_name, &value)) {
             LERROR << "dt_fstab: Failed to find type for partition " << dp->d_name;
             return {};
         }
         fstab_entry.push_back(value);
 
-        file_name = android::base::StringPrintf("%s/%s/fsmgr_flags", fstabdir_name.c_str(), dp->d_name);
+        file_name =
+                android::base::StringPrintf("%s/%s/fsmgr_flags", fstabdir_name.c_str(), dp->d_name);
         if (!ReadDtFile(file_name, &value)) {
             LERROR << "dt_fstab: Failed to find type for partition " << dp->d_name;
             return {};
diff --git a/fs_mgr/fs_mgr_priv_boot_config.h b/fs_mgr/libfstab/fstab_priv.h
similarity index 69%
rename from fs_mgr/fs_mgr_priv_boot_config.h
rename to fs_mgr/libfstab/fstab_priv.h
index 6a38401319b4..fb12b9fb1d1c 100644
--- a/fs_mgr/fs_mgr_priv_boot_config.h
+++ b/fs_mgr/libfstab/fstab_priv.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2023 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.
@@ -14,16 +14,17 @@
  * limitations under the License.
  */
 
-#ifndef __CORE_FS_MGR_PRIV_BOOTCONFIG_H
-#define __CORE_FS_MGR_PRIV_BOOTCONFIG_H
+#pragma once
 
-#include <sys/cdefs.h>
 #include <string>
 #include <utility>
 #include <vector>
 
-std::vector<std::pair<std::string, std::string>> fs_mgr_parse_cmdline(const std::string& cmdline);
+#include <fstab/fstab.h>
+
+// Do not include logging_macros.h here as this header is used by fs_mgr, too.
 
+std::vector<std::pair<std::string, std::string>> fs_mgr_parse_cmdline(const std::string& cmdline);
 bool fs_mgr_get_boot_config_from_kernel(const std::string& cmdline, const std::string& key,
                                         std::string* out_val);
 bool fs_mgr_get_boot_config_from_kernel_cmdline(const std::string& key, std::string* out_val);
@@ -34,4 +35,17 @@ bool fs_mgr_get_boot_config_from_bootconfig(const std::string& bootconfig, const
                                             std::string* out_val);
 bool fs_mgr_get_boot_config_from_bootconfig_source(const std::string& key, std::string* out_val);
 
-#endif /* __CORE_FS_MGR_PRIV_BOOTCONFIG_H */
+bool fs_mgr_update_for_slotselect(android::fs_mgr::Fstab* fstab);
+const std::string& get_android_dt_dir();
+bool is_dt_compatible();
+
+namespace android {
+namespace fs_mgr {
+
+bool InRecovery();
+bool ParseFstabFromString(const std::string& fstab_str, bool proc_mounts, Fstab* fstab_out);
+bool SkipMountWithConfig(const std::string& skip_config, Fstab* fstab, bool verbose);
+std::string GetFstabPath();
+
+}  // namespace fs_mgr
+}  // namespace android
diff --git a/fs_mgr/fuzz/Android.bp b/fs_mgr/libfstab/fuzz/Android.bp
similarity index 100%
rename from fs_mgr/fuzz/Android.bp
rename to fs_mgr/libfstab/fuzz/Android.bp
diff --git a/fs_mgr/fuzz/fs_mgr_fstab_fuzzer.cpp b/fs_mgr/libfstab/fuzz/fs_mgr_fstab_fuzzer.cpp
similarity index 98%
rename from fs_mgr/fuzz/fs_mgr_fstab_fuzzer.cpp
rename to fs_mgr/libfstab/fuzz/fs_mgr_fstab_fuzzer.cpp
index b5fdad4d54b6..b09b273df584 100644
--- a/fs_mgr/fuzz/fs_mgr_fstab_fuzzer.cpp
+++ b/fs_mgr/libfstab/fuzz/fs_mgr_fstab_fuzzer.cpp
@@ -20,6 +20,8 @@
 #include <fstab/fstab.h>
 #include <fuzzer/FuzzedDataProvider.h>
 
+#include "../fstab_priv.h"
+
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
     FuzzedDataProvider fdp(data, size);
 
diff --git a/fs_mgr/fuzz/fstab.dict b/fs_mgr/libfstab/fuzz/fstab.dict
similarity index 100%
rename from fs_mgr/fuzz/fstab.dict
rename to fs_mgr/libfstab/fuzz/fstab.dict
diff --git a/fs_mgr/include_fstab/fstab/fstab.h b/fs_mgr/libfstab/include/fstab/fstab.h
similarity index 91%
rename from fs_mgr/include_fstab/fstab/fstab.h
rename to fs_mgr/libfstab/include/fstab/fstab.h
index 9cb1546c5aaf..e0683ac284cb 100644
--- a/fs_mgr/include_fstab/fstab/fstab.h
+++ b/fs_mgr/libfstab/include/fstab/fstab.h
@@ -93,13 +93,6 @@ struct FstabEntry {
 // Unless explicitly requested, a lookup on mount point should always return the 1st one.
 using Fstab = std::vector<FstabEntry>;
 
-// Exported for testability. Regular users should use ReadFstabFromFile().
-bool ParseFstabFromString(const std::string& fstab_str, bool proc_mounts, Fstab* fstab_out);
-// Exported for testability. Regular users should use ReadDefaultFstab().
-std::string GetFstabPath();
-// Exported for testability.
-bool SkipMountWithConfig(const std::string& skip_config, Fstab* fstab, bool verbose);
-
 bool ReadFstabFromFile(const std::string& path, Fstab* fstab);
 bool ReadFstabFromProcMounts(Fstab* fstab);
 bool ReadFstabFromDt(Fstab* fstab, bool verbose = true);
diff --git a/fs_mgr/libfstab/logging_macros.h b/fs_mgr/libfstab/logging_macros.h
new file mode 100644
index 000000000000..7ea1b7720a54
--- /dev/null
+++ b/fs_mgr/libfstab/logging_macros.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <android-base/logging.h>
+
+#define FSTAB_TAG "[libfstab] "
+
+/* The CHECK() in logging.h will use program invocation name as the tag.
+ * Thus, the log will have prefix "init: " when libfs_mgr is statically
+ * linked in the init process. This might be opaque when debugging.
+ * Append a library name tag at the end of the abort message to aid debugging.
+ */
+#define FSTAB_CHECK(x) CHECK(x) << "in " << FSTAB_TAG
+
+// Logs a message to kernel
+#define LINFO LOG(INFO) << FSTAB_TAG
+#define LWARNING LOG(WARNING) << FSTAB_TAG
+#define LERROR LOG(ERROR) << FSTAB_TAG
+#define LFATAL LOG(FATAL) << FSTAB_TAG
+
+// Logs a message with strerror(errno) at the end
+#define PINFO PLOG(INFO) << FSTAB_TAG
+#define PWARNING PLOG(WARNING) << FSTAB_TAG
+#define PERROR PLOG(ERROR) << FSTAB_TAG
+#define PFATAL PLOG(FATAL) << FSTAB_TAG
diff --git a/fs_mgr/fs_mgr_slotselect.cpp b/fs_mgr/libfstab/slotselect.cpp
similarity index 98%
rename from fs_mgr/fs_mgr_slotselect.cpp
rename to fs_mgr/libfstab/slotselect.cpp
index 09c1b7e20e97..97b2ba1f575f 100644
--- a/fs_mgr/fs_mgr_slotselect.cpp
+++ b/fs_mgr/libfstab/slotselect.cpp
@@ -18,8 +18,8 @@
 
 #include <string>
 
-#include "fs_mgr.h"
-#include "fs_mgr_priv.h"
+#include "fstab_priv.h"
+#include "logging_macros.h"
 
 // Realistically, this file should be part of the android::fs_mgr namespace;
 using namespace android::fs_mgr;
diff --git a/fs_mgr/tests/Android.bp b/fs_mgr/tests/Android.bp
index b9bae2513e70..b7f792fe6235 100644
--- a/fs_mgr/tests/Android.bp
+++ b/fs_mgr/tests/Android.bp
@@ -38,7 +38,6 @@ cc_test {
     ],
     static_libs: [
         "libfs_mgr",
-        "libfstab",
     ],
     srcs: [
         "file_wait_test.cpp",
@@ -109,7 +108,6 @@ cc_test {
     ],
     static_libs: [
         "libfs_mgr",
-        "libfstab",
         "libgmock",
         "libgtest",
     ],
diff --git a/fs_mgr/tests/fs_mgr_test.cpp b/fs_mgr/tests/fs_mgr_test.cpp
index 5f889caee5e7..c51df2a7ef1a 100644
--- a/fs_mgr/tests/fs_mgr_test.cpp
+++ b/fs_mgr/tests/fs_mgr_test.cpp
@@ -31,7 +31,7 @@
 #include <fstab/fstab.h>
 #include <gtest/gtest.h>
 
-#include "../fs_mgr_priv_boot_config.h"
+#include "../fs_mgr_priv.h"
 
 using namespace android::fs_mgr;
 
diff --git a/fs_mgr/tests/vts_fs_test.cpp b/fs_mgr/tests/vts_fs_test.cpp
index 4d771fa046d6..32947b53a6d1 100644
--- a/fs_mgr/tests/vts_fs_test.cpp
+++ b/fs_mgr/tests/vts_fs_test.cpp
@@ -23,6 +23,8 @@
 #include <gtest/gtest.h>
 #include <libdm/dm.h>
 
+#include "../fs_mgr_priv.h"
+
 using testing::Contains;
 using testing::Not;
 

From 840691be716bfd95f4d7b536c13a0a6a5204471a Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Tue, 1 Aug 2023 09:06:42 +0000
Subject: [PATCH 0255/1487] Revert "Use /bootstrap-apex for bootstrap APEXes"

Revert submission 2666915-share-bootstrap

Reason for revert: b/293949266 vold_prepare_subdirs fails to create apexdata directories.

Reverted changes: /q/submissionid:2666915-share-bootstrap

Change-Id: I3e97e8511755844de4b54f51ff20afc154bd8e74
---
 init/builtins.cpp        | 50 ----------------------------------------
 init/init.cpp            |  6 -----
 init/mount_namespace.cpp | 39 ++++++++-----------------------
 init/mount_namespace.h   |  3 ---
 init/selinux.cpp         |  2 +-
 rootdir/Android.mk       |  2 +-
 6 files changed, 11 insertions(+), 91 deletions(-)

diff --git a/init/builtins.cpp b/init/builtins.cpp
index e4f0bd040ed6..2176233aab96 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -1262,51 +1262,6 @@ static Result<void> MountLinkerConfigForDefaultNamespace() {
 
     return {};
 }
-
-static Result<void> MountApexRootForDefaultNamespace() {
-    auto mount_namespace_id = GetCurrentMountNamespace();
-    if (!mount_namespace_id.ok()) {
-        return mount_namespace_id.error();
-    }
-    // There's nothing to do if it's still in the bootstrap mount namespace.
-    // This happens when we don't need to update APEXes (e.g. Microdroid)
-    // where bootstrap mount namespace == default mount namespace.
-    if (mount_namespace_id.value() == NS_BOOTSTRAP) {
-        return {};
-    }
-
-    // Now, we're in the "default" mount namespace and need a fresh /apex for
-    // the default mount namespace.
-    //
-    // At this point, there are two mounts at the same mount point: /apex
-    // - to tmpfs (private)
-    // - to /bootstrap-apex (shared)
-    //
-    // We need unmount the second mount so that /apex in the default mount
-    // namespace becomes RW/empty and "private" (we don't want mount events to
-    // propagate to the bootstrap mount namespace).
-    //
-    // Likewise, we don't want the unmount event itself to propagate to the
-    // bootstrap mount namespace. Otherwise, /apex in the bootstrap mount
-    // namespace would become empty due to the unmount.
-    //
-    // Hence, before unmounting, we make /apex (the second one) "private" first.
-    // so that the unmouting below doesn't affect to the bootstrap mount namespace.
-    if (mount(nullptr, "/apex", nullptr, MS_PRIVATE | MS_REC, nullptr) == -1) {
-        return ErrnoError() << "Failed to remount /apex as private";
-    }
-
-    // Now we can unmount /apex (bind-mount to /bootstrap-apex). This only affects
-    // in the default mount namespace and /apex is now seen as tmpfs mount.
-    // Note that /apex in the bootstrap mount namespace is still a bind-mount to
-    // /bootstrap-apex and holds the APEX mounts.
-    if (umount2("/apex", MNT_DETACH) == -1) {
-        return ErrnoError() << "Failed to umount /apex";
-    }
-
-    return {};
-}
-
 static Result<void> do_update_linker_config(const BuiltinArguments&) {
     return GenerateLinkerConfiguration();
 }
@@ -1359,11 +1314,6 @@ static Result<void> do_enter_default_mount_ns(const BuiltinArguments& args) {
     if (auto result = SwitchToMountNamespaceIfNeeded(NS_DEFAULT); !result.ok()) {
         return result.error();
     }
-
-    if (auto result = MountApexRootForDefaultNamespace(); !result.ok()) {
-        return result.error();
-    }
-
     if (auto result = MountLinkerConfigForDefaultNamespace(); !result.ok()) {
         return result.error();
     }
diff --git a/init/init.cpp b/init/init.cpp
index 4bb8eecb981a..da63fdc3bda5 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -832,12 +832,6 @@ static void MountExtraFilesystems() {
     CHECKCALL(mount("tmpfs", "/apex", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
                     "mode=0755,uid=0,gid=0"));
 
-    if (NeedsTwoMountNamespaces()) {
-        // /bootstrap-apex is used to mount "bootstrap" APEXes.
-        CHECKCALL(mount("tmpfs", "/bootstrap-apex", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
-                        "mode=0755,uid=0,gid=0"));
-    }
-
     // /linkerconfig is used to keep generated linker configuration
     CHECKCALL(mount("tmpfs", "/linkerconfig", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
                     "mode=0755,uid=0,gid=0"));
diff --git a/init/mount_namespace.cpp b/init/mount_namespace.cpp
index e069a5d3e3db..5b53d5092227 100644
--- a/init/mount_namespace.cpp
+++ b/init/mount_namespace.cpp
@@ -66,23 +66,23 @@ static std::string GetMountNamespaceId() {
     return ret;
 }
 
-static android::base::unique_fd bootstrap_ns_fd;
-static android::base::unique_fd default_ns_fd;
-
-static std::string bootstrap_ns_id;
-static std::string default_ns_id;
-
-}  // namespace
-
 // In case we have two sets of APEXes (non-updatable, updatable), we need two separate mount
 // namespaces.
-bool NeedsTwoMountNamespaces() {
+static bool NeedsTwoMountNamespaces() {
     if (IsRecoveryMode()) return false;
     // In microdroid, there's only one set of APEXes in built-in directories include block devices.
     if (IsMicrodroid()) return false;
     return true;
 }
 
+static android::base::unique_fd bootstrap_ns_fd;
+static android::base::unique_fd default_ns_fd;
+
+static std::string bootstrap_ns_id;
+static std::string default_ns_id;
+
+}  // namespace
+
 bool SetupMountNamespaces() {
     // Set the propagation type of / as shared so that any mounting event (e.g.
     // /data) is by default visible to all processes. When private mounting is
@@ -96,27 +96,6 @@ bool SetupMountNamespaces() {
     // the bootstrap namespace get APEXes from the read-only partition.
     if (!(ChangeMount("/apex", MS_PRIVATE))) return false;
 
-    // However, some components (e.g. servicemanager) need to access bootstrap
-    // APEXes from the default mount namespace. To achieve that, we bind-mount
-    // /apex with /bootstrap-apex (not private) in the bootstrap mount namespace.
-    // Bootstrap APEXes are mounted in /apex and also visible in /bootstrap-apex.
-    // In the default mount namespace, we detach /bootstrap-apex from /apex and
-    // bootstrap APEXes are still be visible in /bootstrap-apex.
-    //
-    // The end result will look like:
-    //   in the bootstrap mount namespace:
-    //     /apex  (== /bootstrap-apex)
-    //       {bootstrap APEXes from the read-only partition}
-    //
-    //   in the default mount namespace:
-    //     /bootstrap-apex
-    //       {bootstrap APEXes from the read-only partition}
-    //     /apex
-    //       {APEXes, can be from /data partition}
-    if (NeedsTwoMountNamespaces()) {
-        if (!(BindMount("/bootstrap-apex", "/apex"))) return false;
-    }
-
     // /linkerconfig is a private mountpoint to give a different linker configuration
     // based on the mount namespace. Subdirectory will be bind-mounted based on current mount
     // namespace
diff --git a/init/mount_namespace.h b/init/mount_namespace.h
index 43c5476a6ab8..5e3dab241290 100644
--- a/init/mount_namespace.h
+++ b/init/mount_namespace.h
@@ -24,12 +24,9 @@ namespace init {
 enum MountNamespace { NS_BOOTSTRAP, NS_DEFAULT };
 
 bool SetupMountNamespaces();
-
 base::Result<void> SwitchToMountNamespaceIfNeeded(MountNamespace target_mount_namespace);
 
 base::Result<MountNamespace> GetCurrentMountNamespace();
 
-bool NeedsTwoMountNamespaces();
-
 }  // namespace init
 }  // namespace android
diff --git a/init/selinux.cpp b/init/selinux.cpp
index 8532c44c1c70..51093d898e8b 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -766,7 +766,7 @@ void SelinuxRestoreContext() {
     selinux_android_restorecon("/dev/device-mapper", 0);
 
     selinux_android_restorecon("/apex", 0);
-    selinux_android_restorecon("/bootstrap-apex", 0);
+
     selinux_android_restorecon("/linkerconfig", 0);
 
     // adb remount, snapshot-based updates, and DSUs all create files during
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 52187536f3fe..3362872c070d 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -91,7 +91,7 @@ endif
 #
 # create some directories (some are mount points) and symlinks
 LOCAL_POST_INSTALL_CMD := mkdir -p $(addprefix $(TARGET_ROOT_OUT)/, \
-    dev proc sys system data data_mirror odm oem acct config storage mnt apex bootstrap-apex debug_ramdisk \
+    dev proc sys system data data_mirror odm oem acct config storage mnt apex debug_ramdisk \
     linkerconfig second_stage_resources postinstall $(BOARD_ROOT_EXTRA_FOLDERS)); \
     ln -sf /system/bin $(TARGET_ROOT_OUT)/bin; \
     ln -sf /system/etc $(TARGET_ROOT_OUT)/etc; \

From f4b1d698b1d3fd4592c68464923912d902460509 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Tue, 25 Jul 2023 22:08:55 +0800
Subject: [PATCH 0256/1487] init: Unify duplicated get_android_dt_dir with
 libfs_mgr

init and libfs_mgr both defines get_android_dt_dir() with subtle
differences. Merge the two implementations into libfs_mgr to reduce code
duplication (in terms of source code and code gen)

Note:
init's implementation checks the kernel cmdline first and then the
kernel bootconfig, while libfs_mgr's order is the opposite.
Realistically I don't think this order matter much though. If any, we
should prioritize bootconfig over kernel cmdline most of the time.

Bug: 293695109
Test: Presubmit
Change-Id: Ic8d2c965c62f9e873ccdaf77d67c7708f25a7b56
(cherry picked from https://android-review.googlesource.com/q/commit:d7c67b40a9b6a5e72d54adf37da22238381182f7)
Ignore-AOSP-First: Fix merge conflict
---
 fs_mgr/libfstab/boot_config.cpp       | 29 +++++++++++++++++++-
 fs_mgr/libfstab/fstab.cpp             | 29 ++++----------------
 fs_mgr/libfstab/fstab_priv.h          |  1 -
 fs_mgr/libfstab/include/fstab/fstab.h |  4 +++
 init/Android.bp                       |  1 +
 init/property_service.cpp             |  6 +++--
 init/util.cpp                         | 39 +++++----------------------
 init/util.h                           |  3 ---
 8 files changed, 49 insertions(+), 63 deletions(-)

diff --git a/fs_mgr/libfstab/boot_config.cpp b/fs_mgr/libfstab/boot_config.cpp
index 8fb28c607cb9..fee40158b709 100644
--- a/fs_mgr/libfstab/boot_config.cpp
+++ b/fs_mgr/libfstab/boot_config.cpp
@@ -27,6 +27,33 @@
 #include "fstab_priv.h"
 #include "logging_macros.h"
 
+namespace android {
+namespace fs_mgr {
+
+const std::string& GetAndroidDtDir() {
+    // Set once and saves time for subsequent calls to this function
+    static const std::string kAndroidDtDir = [] {
+        std::string android_dt_dir;
+        if ((fs_mgr_get_boot_config_from_bootconfig_source("android_dt_dir", &android_dt_dir) ||
+             fs_mgr_get_boot_config_from_kernel_cmdline("android_dt_dir", &android_dt_dir)) &&
+            !android_dt_dir.empty()) {
+            // Ensure the returned path ends with a /
+            if (android_dt_dir.back() != '/') {
+                android_dt_dir.push_back('/');
+            }
+        } else {
+            // Fall back to the standard procfs-based path
+            android_dt_dir = "/proc/device-tree/firmware/android/";
+        }
+        LINFO << "Using Android DT directory " << android_dt_dir;
+        return android_dt_dir;
+    }();
+    return kAndroidDtDir;
+}
+
+}  // namespace fs_mgr
+}  // namespace android
+
 std::vector<std::pair<std::string, std::string>> fs_mgr_parse_cmdline(const std::string& cmdline) {
     static constexpr char quote = '"';
 
@@ -145,7 +172,7 @@ bool fs_mgr_get_boot_config(const std::string& key, std::string* out_val) {
 
     // firstly, check the device tree
     if (is_dt_compatible()) {
-        std::string file_name = get_android_dt_dir() + "/" + key;
+        std::string file_name = android::fs_mgr::GetAndroidDtDir() + key;
         if (android::base::ReadFileToString(file_name, out_val)) {
             if (!out_val->empty()) {
                 out_val->pop_back();  // Trims the trailing '\0' out.
diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index 5b5c3d26c450..86ba03148838 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -51,7 +51,6 @@ namespace android {
 namespace fs_mgr {
 namespace {
 
-constexpr char kDefaultAndroidDtDir[] = "/proc/device-tree/firmware/android";
 constexpr char kProcMountsPath[] = "/proc/mounts";
 
 struct FlagList {
@@ -337,25 +336,14 @@ bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
     return true;
 }
 
-std::string InitAndroidDtDir() {
-    std::string android_dt_dir;
-    // The platform may specify a custom Android DT path in kernel cmdline
-    if (!fs_mgr_get_boot_config_from_bootconfig_source("android_dt_dir", &android_dt_dir) &&
-        !fs_mgr_get_boot_config_from_kernel_cmdline("android_dt_dir", &android_dt_dir)) {
-        // Fall back to the standard procfs-based path
-        android_dt_dir = kDefaultAndroidDtDir;
-    }
-    return android_dt_dir;
-}
-
 bool IsDtFstabCompatible() {
     std::string dt_value;
-    std::string file_name = get_android_dt_dir() + "/fstab/compatible";
+    std::string file_name = GetAndroidDtDir() + "fstab/compatible";
 
     if (ReadDtFile(file_name, &dt_value) && dt_value == "android,fstab") {
         // If there's no status property or its set to "ok" or "okay", then we use the DT fstab.
         std::string status_value;
-        std::string status_file_name = get_android_dt_dir() + "/fstab/status";
+        std::string status_file_name = GetAndroidDtDir() + "fstab/status";
         return !ReadDtFile(status_file_name, &status_value) || status_value == "ok" ||
                status_value == "okay";
     }
@@ -368,7 +356,7 @@ std::string ReadFstabFromDt() {
         return {};
     }
 
-    std::string fstabdir_name = get_android_dt_dir() + "/fstab";
+    std::string fstabdir_name = GetAndroidDtDir() + "fstab";
     std::unique_ptr<DIR, int (*)(DIR*)> fstabdir(opendir(fstabdir_name.c_str()), closedir);
     if (!fstabdir) return {};
 
@@ -876,7 +864,7 @@ const FstabEntry* GetEntryForMountPoint(const Fstab* fstab, const std::string& p
 
 std::set<std::string> GetBootDevices() {
     // First check bootconfig, then kernel commandline, then the device tree
-    std::string dt_file_name = get_android_dt_dir() + "/boot_devices";
+    std::string dt_file_name = GetAndroidDtDir() + "boot_devices";
     std::string value;
     if (fs_mgr_get_boot_config_from_bootconfig_source("boot_devices", &value) ||
         fs_mgr_get_boot_config_from_bootconfig_source("boot_device", &value)) {
@@ -948,15 +936,8 @@ bool InRecovery() {
 }  // namespace fs_mgr
 }  // namespace android
 
-// FIXME: The same logic is duplicated in system/core/init/
-const std::string& get_android_dt_dir() {
-    // Set once and saves time for subsequent calls to this function
-    static const std::string kAndroidDtDir = android::fs_mgr::InitAndroidDtDir();
-    return kAndroidDtDir;
-}
-
 bool is_dt_compatible() {
-    std::string file_name = get_android_dt_dir() + "/compatible";
+    std::string file_name = android::fs_mgr::GetAndroidDtDir() + "compatible";
     std::string dt_value;
     if (android::fs_mgr::ReadDtFile(file_name, &dt_value)) {
         if (dt_value == "android,firmware") {
diff --git a/fs_mgr/libfstab/fstab_priv.h b/fs_mgr/libfstab/fstab_priv.h
index fb12b9fb1d1c..5d226f8798f6 100644
--- a/fs_mgr/libfstab/fstab_priv.h
+++ b/fs_mgr/libfstab/fstab_priv.h
@@ -36,7 +36,6 @@ bool fs_mgr_get_boot_config_from_bootconfig(const std::string& bootconfig, const
 bool fs_mgr_get_boot_config_from_bootconfig_source(const std::string& key, std::string* out_val);
 
 bool fs_mgr_update_for_slotselect(android::fs_mgr::Fstab* fstab);
-const std::string& get_android_dt_dir();
 bool is_dt_compatible();
 
 namespace android {
diff --git a/fs_mgr/libfstab/include/fstab/fstab.h b/fs_mgr/libfstab/include/fstab/fstab.h
index e0683ac284cb..0a45fe87ad3e 100644
--- a/fs_mgr/libfstab/include/fstab/fstab.h
+++ b/fs_mgr/libfstab/include/fstab/fstab.h
@@ -124,5 +124,9 @@ std::set<std::string> GetBootDevices();
 // expected name.
 std::string GetVerityDeviceName(const FstabEntry& entry);
 
+// Returns the Android Device Tree directory as specified in the kernel bootconfig or cmdline.
+// If the platform does not configure a custom DT path, returns the standard one (based in procfs).
+const std::string& GetAndroidDtDir();
+
 }  // namespace fs_mgr
 }  // namespace android
diff --git a/init/Android.bp b/init/Android.bp
index ee34215d750e..d4852d6483be 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -539,6 +539,7 @@ cc_defaults {
         "libprotobuf-cpp-lite",
     ],
     static_libs: [
+        "libfs_mgr",
         "libhidl-gen-utils",
     ],
 }
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 3e9a6d9f342e..87ab13b3c3c5 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -57,6 +57,7 @@
 #include <android-base/result.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
+#include <fs_mgr.h>
 #include <private/android_filesystem_config.h>
 #include <property_info_parser/property_info_parser.h>
 #include <property_info_serializer/property_info_serializer.h>
@@ -1324,7 +1325,8 @@ static void ProcessKernelDt() {
         return;
     }
 
-    std::unique_ptr<DIR, int (*)(DIR*)> dir(opendir(get_android_dt_dir().c_str()), closedir);
+    std::unique_ptr<DIR, int (*)(DIR*)> dir(opendir(android::fs_mgr::GetAndroidDtDir().c_str()),
+                                            closedir);
     if (!dir) return;
 
     std::string dt_file;
@@ -1335,7 +1337,7 @@ static void ProcessKernelDt() {
             continue;
         }
 
-        std::string file_name = get_android_dt_dir() + dp->d_name;
+        std::string file_name = android::fs_mgr::GetAndroidDtDir() + dp->d_name;
 
         android::base::ReadFileToString(file_name, &dt_file);
         std::replace(dt_file.begin(), dt_file.end(), ',', '.');
diff --git a/init/util.cpp b/init/util.cpp
index d0478e80d005..61d59a4801d0 100644
--- a/init/util.cpp
+++ b/init/util.cpp
@@ -42,6 +42,10 @@
 #include <cutils/sockets.h>
 #include <selinux/android.h>
 
+#if defined(__ANDROID__)
+#include <fs_mgr.h>
+#endif
+
 #ifdef INIT_FULL_SOURCES
 #include <android/api-level.h>
 #include <sys/system_properties.h>
@@ -60,8 +64,6 @@ using namespace std::literals::string_literals;
 namespace android {
 namespace init {
 
-const std::string kDefaultAndroidDtDir("/proc/device-tree/firmware/android/");
-
 const std::string kDataDirPrefix("/data/");
 
 void (*trigger_shutdown)(const std::string& command) = nullptr;
@@ -375,45 +377,18 @@ Result<std::string> ExpandProps(const std::string& src) {
     return dst;
 }
 
-static std::string init_android_dt_dir() {
-    // Use the standard procfs-based path by default
-    std::string android_dt_dir = kDefaultAndroidDtDir;
-    // The platform may specify a custom Android DT path in kernel cmdline
-    ImportKernelCmdline([&](const std::string& key, const std::string& value) {
-        if (key == "androidboot.android_dt_dir") {
-            android_dt_dir = value;
-        }
-    });
-    // ..Or bootconfig
-    if (android_dt_dir == kDefaultAndroidDtDir) {
-        ImportBootconfig([&](const std::string& key, const std::string& value) {
-            if (key == "androidboot.android_dt_dir") {
-                android_dt_dir = value;
-            }
-        });
-    }
-
-    LOG(INFO) << "Using Android DT directory " << android_dt_dir;
-    return android_dt_dir;
-}
-
-// FIXME: The same logic is duplicated in system/core/fs_mgr/
-const std::string& get_android_dt_dir() {
-    // Set once and saves time for subsequent calls to this function
-    static const std::string kAndroidDtDir = init_android_dt_dir();
-    return kAndroidDtDir;
-}
-
 // Reads the content of device tree file under the platform's Android DT directory.
 // Returns true if the read is success, false otherwise.
 bool read_android_dt_file(const std::string& sub_path, std::string* dt_content) {
-    const std::string file_name = get_android_dt_dir() + sub_path;
+#if defined(__ANDROID__)
+    const std::string file_name = android::fs_mgr::GetAndroidDtDir() + sub_path;
     if (android::base::ReadFileToString(file_name, dt_content)) {
         if (!dt_content->empty()) {
             dt_content->pop_back();  // Trims the trailing '\0' out.
             return true;
         }
     }
+#endif
     return false;
 }
 
diff --git a/init/util.h b/init/util.h
index 3f0a4e023f08..1c00a3efc0b1 100644
--- a/init/util.h
+++ b/init/util.h
@@ -60,9 +60,6 @@ bool make_dir(const std::string& path, mode_t mode);
 bool is_dir(const char* pathname);
 Result<std::string> ExpandProps(const std::string& src);
 
-// Returns the platform's Android DT directory as specified in the kernel cmdline.
-// If the platform does not configure a custom DT path, returns the standard one (based in procfs).
-const std::string& get_android_dt_dir();
 // Reads or compares the content of device tree file under the platform's Android DT directory.
 bool read_android_dt_file(const std::string& sub_path, std::string* dt_content);
 bool is_android_dt_value_expected(const std::string& sub_path, const std::string& expected_content);

From b8c23259b15b85feec119e4e770e232c5cc74fcd Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Tue, 25 Jul 2023 22:08:55 +0800
Subject: [PATCH 0257/1487] init: Unify duplicated get_android_dt_dir with
 libfs_mgr

init and libfs_mgr both defines get_android_dt_dir() with subtle
differences. Merge the two implementations into libfs_mgr to reduce code
duplication (in terms of source code and code gen)

Note:
init's implementation checks the kernel cmdline first and then the
kernel bootconfig, while libfs_mgr's order is the opposite.
Realistically I don't think this order matter much though. If any, we
should prioritize bootconfig over kernel cmdline most of the time.

Bug: 293695109
Test: Presubmit
Merged-In: Ic8d2c965c62f9e873ccdaf77d67c7708f25a7b56
Change-Id: Ic8d2c965c62f9e873ccdaf77d67c7708f25a7b56
---
 fs_mgr/libfstab/boot_config.cpp       | 29 +++++++++++++++++++-
 fs_mgr/libfstab/fstab.cpp             | 29 ++++----------------
 fs_mgr/libfstab/fstab_priv.h          |  1 -
 fs_mgr/libfstab/include/fstab/fstab.h |  4 +++
 init/Android.bp                       |  1 +
 init/property_service.cpp             |  6 +++--
 init/util.cpp                         | 39 +++++----------------------
 init/util.h                           |  3 ---
 8 files changed, 49 insertions(+), 63 deletions(-)

diff --git a/fs_mgr/libfstab/boot_config.cpp b/fs_mgr/libfstab/boot_config.cpp
index 8fb28c607cb9..fee40158b709 100644
--- a/fs_mgr/libfstab/boot_config.cpp
+++ b/fs_mgr/libfstab/boot_config.cpp
@@ -27,6 +27,33 @@
 #include "fstab_priv.h"
 #include "logging_macros.h"
 
+namespace android {
+namespace fs_mgr {
+
+const std::string& GetAndroidDtDir() {
+    // Set once and saves time for subsequent calls to this function
+    static const std::string kAndroidDtDir = [] {
+        std::string android_dt_dir;
+        if ((fs_mgr_get_boot_config_from_bootconfig_source("android_dt_dir", &android_dt_dir) ||
+             fs_mgr_get_boot_config_from_kernel_cmdline("android_dt_dir", &android_dt_dir)) &&
+            !android_dt_dir.empty()) {
+            // Ensure the returned path ends with a /
+            if (android_dt_dir.back() != '/') {
+                android_dt_dir.push_back('/');
+            }
+        } else {
+            // Fall back to the standard procfs-based path
+            android_dt_dir = "/proc/device-tree/firmware/android/";
+        }
+        LINFO << "Using Android DT directory " << android_dt_dir;
+        return android_dt_dir;
+    }();
+    return kAndroidDtDir;
+}
+
+}  // namespace fs_mgr
+}  // namespace android
+
 std::vector<std::pair<std::string, std::string>> fs_mgr_parse_cmdline(const std::string& cmdline) {
     static constexpr char quote = '"';
 
@@ -145,7 +172,7 @@ bool fs_mgr_get_boot_config(const std::string& key, std::string* out_val) {
 
     // firstly, check the device tree
     if (is_dt_compatible()) {
-        std::string file_name = get_android_dt_dir() + "/" + key;
+        std::string file_name = android::fs_mgr::GetAndroidDtDir() + key;
         if (android::base::ReadFileToString(file_name, out_val)) {
             if (!out_val->empty()) {
                 out_val->pop_back();  // Trims the trailing '\0' out.
diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index 5b5c3d26c450..86ba03148838 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -51,7 +51,6 @@ namespace android {
 namespace fs_mgr {
 namespace {
 
-constexpr char kDefaultAndroidDtDir[] = "/proc/device-tree/firmware/android";
 constexpr char kProcMountsPath[] = "/proc/mounts";
 
 struct FlagList {
@@ -337,25 +336,14 @@ bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
     return true;
 }
 
-std::string InitAndroidDtDir() {
-    std::string android_dt_dir;
-    // The platform may specify a custom Android DT path in kernel cmdline
-    if (!fs_mgr_get_boot_config_from_bootconfig_source("android_dt_dir", &android_dt_dir) &&
-        !fs_mgr_get_boot_config_from_kernel_cmdline("android_dt_dir", &android_dt_dir)) {
-        // Fall back to the standard procfs-based path
-        android_dt_dir = kDefaultAndroidDtDir;
-    }
-    return android_dt_dir;
-}
-
 bool IsDtFstabCompatible() {
     std::string dt_value;
-    std::string file_name = get_android_dt_dir() + "/fstab/compatible";
+    std::string file_name = GetAndroidDtDir() + "fstab/compatible";
 
     if (ReadDtFile(file_name, &dt_value) && dt_value == "android,fstab") {
         // If there's no status property or its set to "ok" or "okay", then we use the DT fstab.
         std::string status_value;
-        std::string status_file_name = get_android_dt_dir() + "/fstab/status";
+        std::string status_file_name = GetAndroidDtDir() + "fstab/status";
         return !ReadDtFile(status_file_name, &status_value) || status_value == "ok" ||
                status_value == "okay";
     }
@@ -368,7 +356,7 @@ std::string ReadFstabFromDt() {
         return {};
     }
 
-    std::string fstabdir_name = get_android_dt_dir() + "/fstab";
+    std::string fstabdir_name = GetAndroidDtDir() + "fstab";
     std::unique_ptr<DIR, int (*)(DIR*)> fstabdir(opendir(fstabdir_name.c_str()), closedir);
     if (!fstabdir) return {};
 
@@ -876,7 +864,7 @@ const FstabEntry* GetEntryForMountPoint(const Fstab* fstab, const std::string& p
 
 std::set<std::string> GetBootDevices() {
     // First check bootconfig, then kernel commandline, then the device tree
-    std::string dt_file_name = get_android_dt_dir() + "/boot_devices";
+    std::string dt_file_name = GetAndroidDtDir() + "boot_devices";
     std::string value;
     if (fs_mgr_get_boot_config_from_bootconfig_source("boot_devices", &value) ||
         fs_mgr_get_boot_config_from_bootconfig_source("boot_device", &value)) {
@@ -948,15 +936,8 @@ bool InRecovery() {
 }  // namespace fs_mgr
 }  // namespace android
 
-// FIXME: The same logic is duplicated in system/core/init/
-const std::string& get_android_dt_dir() {
-    // Set once and saves time for subsequent calls to this function
-    static const std::string kAndroidDtDir = android::fs_mgr::InitAndroidDtDir();
-    return kAndroidDtDir;
-}
-
 bool is_dt_compatible() {
-    std::string file_name = get_android_dt_dir() + "/compatible";
+    std::string file_name = android::fs_mgr::GetAndroidDtDir() + "compatible";
     std::string dt_value;
     if (android::fs_mgr::ReadDtFile(file_name, &dt_value)) {
         if (dt_value == "android,firmware") {
diff --git a/fs_mgr/libfstab/fstab_priv.h b/fs_mgr/libfstab/fstab_priv.h
index fb12b9fb1d1c..5d226f8798f6 100644
--- a/fs_mgr/libfstab/fstab_priv.h
+++ b/fs_mgr/libfstab/fstab_priv.h
@@ -36,7 +36,6 @@ bool fs_mgr_get_boot_config_from_bootconfig(const std::string& bootconfig, const
 bool fs_mgr_get_boot_config_from_bootconfig_source(const std::string& key, std::string* out_val);
 
 bool fs_mgr_update_for_slotselect(android::fs_mgr::Fstab* fstab);
-const std::string& get_android_dt_dir();
 bool is_dt_compatible();
 
 namespace android {
diff --git a/fs_mgr/libfstab/include/fstab/fstab.h b/fs_mgr/libfstab/include/fstab/fstab.h
index e0683ac284cb..0a45fe87ad3e 100644
--- a/fs_mgr/libfstab/include/fstab/fstab.h
+++ b/fs_mgr/libfstab/include/fstab/fstab.h
@@ -124,5 +124,9 @@ std::set<std::string> GetBootDevices();
 // expected name.
 std::string GetVerityDeviceName(const FstabEntry& entry);
 
+// Returns the Android Device Tree directory as specified in the kernel bootconfig or cmdline.
+// If the platform does not configure a custom DT path, returns the standard one (based in procfs).
+const std::string& GetAndroidDtDir();
+
 }  // namespace fs_mgr
 }  // namespace android
diff --git a/init/Android.bp b/init/Android.bp
index ee34215d750e..d4852d6483be 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -539,6 +539,7 @@ cc_defaults {
         "libprotobuf-cpp-lite",
     ],
     static_libs: [
+        "libfs_mgr",
         "libhidl-gen-utils",
     ],
 }
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 8da69822ccb9..0e82022a0e83 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -57,6 +57,7 @@
 #include <android-base/result.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
+#include <fs_mgr.h>
 #include <property_info_parser/property_info_parser.h>
 #include <property_info_serializer/property_info_serializer.h>
 #include <selinux/android.h>
@@ -1317,7 +1318,8 @@ static void ProcessKernelDt() {
         return;
     }
 
-    std::unique_ptr<DIR, int (*)(DIR*)> dir(opendir(get_android_dt_dir().c_str()), closedir);
+    std::unique_ptr<DIR, int (*)(DIR*)> dir(opendir(android::fs_mgr::GetAndroidDtDir().c_str()),
+                                            closedir);
     if (!dir) return;
 
     std::string dt_file;
@@ -1328,7 +1330,7 @@ static void ProcessKernelDt() {
             continue;
         }
 
-        std::string file_name = get_android_dt_dir() + dp->d_name;
+        std::string file_name = android::fs_mgr::GetAndroidDtDir() + dp->d_name;
 
         android::base::ReadFileToString(file_name, &dt_file);
         std::replace(dt_file.begin(), dt_file.end(), ',', '.');
diff --git a/init/util.cpp b/init/util.cpp
index d0478e80d005..61d59a4801d0 100644
--- a/init/util.cpp
+++ b/init/util.cpp
@@ -42,6 +42,10 @@
 #include <cutils/sockets.h>
 #include <selinux/android.h>
 
+#if defined(__ANDROID__)
+#include <fs_mgr.h>
+#endif
+
 #ifdef INIT_FULL_SOURCES
 #include <android/api-level.h>
 #include <sys/system_properties.h>
@@ -60,8 +64,6 @@ using namespace std::literals::string_literals;
 namespace android {
 namespace init {
 
-const std::string kDefaultAndroidDtDir("/proc/device-tree/firmware/android/");
-
 const std::string kDataDirPrefix("/data/");
 
 void (*trigger_shutdown)(const std::string& command) = nullptr;
@@ -375,45 +377,18 @@ Result<std::string> ExpandProps(const std::string& src) {
     return dst;
 }
 
-static std::string init_android_dt_dir() {
-    // Use the standard procfs-based path by default
-    std::string android_dt_dir = kDefaultAndroidDtDir;
-    // The platform may specify a custom Android DT path in kernel cmdline
-    ImportKernelCmdline([&](const std::string& key, const std::string& value) {
-        if (key == "androidboot.android_dt_dir") {
-            android_dt_dir = value;
-        }
-    });
-    // ..Or bootconfig
-    if (android_dt_dir == kDefaultAndroidDtDir) {
-        ImportBootconfig([&](const std::string& key, const std::string& value) {
-            if (key == "androidboot.android_dt_dir") {
-                android_dt_dir = value;
-            }
-        });
-    }
-
-    LOG(INFO) << "Using Android DT directory " << android_dt_dir;
-    return android_dt_dir;
-}
-
-// FIXME: The same logic is duplicated in system/core/fs_mgr/
-const std::string& get_android_dt_dir() {
-    // Set once and saves time for subsequent calls to this function
-    static const std::string kAndroidDtDir = init_android_dt_dir();
-    return kAndroidDtDir;
-}
-
 // Reads the content of device tree file under the platform's Android DT directory.
 // Returns true if the read is success, false otherwise.
 bool read_android_dt_file(const std::string& sub_path, std::string* dt_content) {
-    const std::string file_name = get_android_dt_dir() + sub_path;
+#if defined(__ANDROID__)
+    const std::string file_name = android::fs_mgr::GetAndroidDtDir() + sub_path;
     if (android::base::ReadFileToString(file_name, dt_content)) {
         if (!dt_content->empty()) {
             dt_content->pop_back();  // Trims the trailing '\0' out.
             return true;
         }
     }
+#endif
     return false;
 }
 
diff --git a/init/util.h b/init/util.h
index 3f0a4e023f08..1c00a3efc0b1 100644
--- a/init/util.h
+++ b/init/util.h
@@ -60,9 +60,6 @@ bool make_dir(const std::string& path, mode_t mode);
 bool is_dir(const char* pathname);
 Result<std::string> ExpandProps(const std::string& src);
 
-// Returns the platform's Android DT directory as specified in the kernel cmdline.
-// If the platform does not configure a custom DT path, returns the standard one (based in procfs).
-const std::string& get_android_dt_dir();
 // Reads or compares the content of device tree file under the platform's Android DT directory.
 bool read_android_dt_file(const std::string& sub_path, std::string* dt_content);
 bool is_android_dt_value_expected(const std::string& sub_path, const std::string& expected_content);

From a637416a87c0ac5444bd0fa33d484790deb94294 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Sun, 23 Jul 2023 10:00:40 -0700
Subject: [PATCH 0258/1487] libsnapshot: Introduce a dynamically linked version
 of libsnapshot.

This will cut down on the binary sizes of update_engine, snapshotctl,
and lpdumpd.

Bug: 291688516
Test: treehugger
Change-Id: Idae5ea075ab21c2bd4fdb839eb065d865cb07d58
---
 fs_mgr/libfiemap/fiemap_writer_test.cpp |  4 +++-
 fs_mgr/libsnapshot/Android.bp           | 26 +++++++++++++++++++++----
 2 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/fs_mgr/libfiemap/fiemap_writer_test.cpp b/fs_mgr/libfiemap/fiemap_writer_test.cpp
index bd97a78ae8f7..c37329c36e40 100644
--- a/fs_mgr/libfiemap/fiemap_writer_test.cpp
+++ b/fs_mgr/libfiemap/fiemap_writer_test.cpp
@@ -27,6 +27,7 @@
 #include <sys/vfs.h>
 #include <unistd.h>
 
+#include <cstring>
 #include <string>
 #include <utility>
 
@@ -518,7 +519,8 @@ class FsTest : public ::testing::Test {
         ASSERT_EQ(ret, 0);
 
         // mount the file system
-        ASSERT_EQ(mount(loop_dev.device().c_str(), mntpoint_.c_str(), "f2fs", 0, nullptr), 0);
+        ASSERT_EQ(mount(loop_dev.device().c_str(), mntpoint_.c_str(), "f2fs", 0, nullptr), 0)
+                << strerror(errno);
     }
 
     void TearDown() override {
diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 8f353818ce08..bd017ff10bfa 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -101,7 +101,7 @@ cc_library_headers {
 }
 
 cc_library_static {
-    name: "libsnapshot",
+    name: "libsnapshot_static",
     defaults: [
         "libsnapshot_defaults",
         "libsnapshot_hal_deps",
@@ -112,6 +112,25 @@ cc_library_static {
     ],
 }
 
+cc_library {
+    name: "libsnapshot",
+    defaults: [
+        "libsnapshot_defaults",
+        "libsnapshot_cow_defaults",
+        "libsnapshot_hal_deps",
+    ],
+    srcs: [":libsnapshot_sources"],
+    shared_libs: [
+        "libfs_mgr_binder",
+        "liblp",
+        "libprotobuf-cpp-lite",
+    ],
+    static_libs: [
+        "libc++fs",
+        "libsnapshot_cow",
+    ]
+}
+
 cc_library_static {
     name: "libsnapshot_init",
     native_coverage : true,
@@ -247,7 +266,7 @@ cc_defaults {
         "libgsi",
         "libgmock",
         "liblp",
-        "libsnapshot",
+        "libsnapshot_static",
         "libsnapshot_cow",
         "libsnapshot_test_helpers",
         "libsparse",
@@ -330,8 +349,6 @@ cc_binary {
         "libbrotli",
         "libc++fs",
         "libfstab",
-        "libsnapshot",
-        "libsnapshot_cow",
         "libz",
         "update_metadata-protos",
     ],
@@ -344,6 +361,7 @@ cc_binary {
         "liblog",
         "liblp",
         "libprotobuf-cpp-lite",
+        "libsnapshot",
         "libstatslog",
         "libutils",
     ],

From 79ad1e2e9bf1628c141c8cd2fbb4f3df61a6ba75 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Sat, 29 Jul 2023 17:37:23 +0800
Subject: [PATCH 0259/1487] init: Unify kernel bootconfig parser with libfs_mgr

Right now there are two bootconfig parsers that gets linked into `init`.
One is from libinit itself and the other is from libfs_mgr.

The one in libinit removes all space characters between list elements,
so `key = "val1", "val2"` gets unquoted and squeezed into:
  `key=val1,val2`
The one in libfs_mgr doesn't remove spaces, it only unquotes:
  `key=val1, val2`

The libinit behavior is due to existing systems (such as sysprop)
expect the config value to be in the same format as kernel cmdline.
(aosp/1757971)
THe libfs_mgr behavior is due to the `androidboot.boot_device[s]`
format explicitly allows quoted comma appear in its list value, thus
relies on space, not comma, as the list value delimeter.

This commit merges the two parsers into libfs_mgr. Since all usages in
libfs_mgr besides `boot_device[s]` do not care about how list value are
delimited, and most usages in init expects the bootconfig value format
to be the same format as cmdline. We just special case the
`boot_device` scenario.

Also harden the test cases to cover all the different config value
format and expected result.

Note:
The format of kernel bootconfig is described here
https://docs.kernel.org/admin-guide/bootconfig.html

Bug: 293695109
Test: CtsFsMgrTestCases
Change-Id: I42b9bf626e8de38a60e8e09fac0693126b7efd91
---
 fs_mgr/libfstab/boot_config.cpp       | 113 ++++++++++++++------------
 fs_mgr/libfstab/fstab.cpp             |  12 ++-
 fs_mgr/libfstab/fstab_priv.h          |  12 +--
 fs_mgr/libfstab/include/fstab/fstab.h |   9 ++
 fs_mgr/tests/Android.bp               |   2 +
 fs_mgr/tests/fs_mgr_test.cpp          | 112 +++++++++++++++----------
 init/devices.cpp                      |   3 +-
 init/property_service.cpp             |   2 +-
 init/reboot_utils.cpp                 |  17 ++--
 init/selinux.cpp                      |  10 +--
 init/util.cpp                         |  15 ----
 init/util.h                           |   1 -
 12 files changed, 165 insertions(+), 143 deletions(-)

diff --git a/fs_mgr/libfstab/boot_config.cpp b/fs_mgr/libfstab/boot_config.cpp
index fee40158b709..53c843e9338e 100644
--- a/fs_mgr/libfstab/boot_config.cpp
+++ b/fs_mgr/libfstab/boot_config.cpp
@@ -34,7 +34,7 @@ const std::string& GetAndroidDtDir() {
     // Set once and saves time for subsequent calls to this function
     static const std::string kAndroidDtDir = [] {
         std::string android_dt_dir;
-        if ((fs_mgr_get_boot_config_from_bootconfig_source("android_dt_dir", &android_dt_dir) ||
+        if ((GetBootconfig("androidboot.android_dt_dir", &android_dt_dir) ||
              fs_mgr_get_boot_config_from_kernel_cmdline("android_dt_dir", &android_dt_dir)) &&
             !android_dt_dir.empty()) {
             // Ensure the returned path ends with a /
@@ -51,6 +51,65 @@ const std::string& GetAndroidDtDir() {
     return kAndroidDtDir;
 }
 
+void ImportBootconfigFromString(const std::string& bootconfig,
+                                const std::function<void(std::string, std::string)>& fn) {
+    for (std::string_view line : android::base::Split(bootconfig, "\n")) {
+        const auto equal_pos = line.find('=');
+        std::string key = android::base::Trim(line.substr(0, equal_pos));
+        if (key.empty()) {
+            continue;
+        }
+        std::string value;
+        if (equal_pos != line.npos) {
+            value = android::base::Trim(line.substr(equal_pos + 1));
+            // If the value is a comma-delimited list, the kernel would insert a space between the
+            // list elements when read from /proc/bootconfig.
+            // BoardConfig.mk:
+            //      BOARD_BOOTCONFIG := key=value1,value2,value3
+            // /proc/bootconfig:
+            //      key = "value1", "value2", "value3"
+            if (key == "androidboot.boot_device" || key == "androidboot.boot_devices") {
+                // boot_device[s] is a special case where a list element can contain comma and the
+                // caller expects a space-delimited list, so don't remove space here.
+                value.erase(std::remove(value.begin(), value.end(), '"'), value.end());
+            } else {
+                // In order to not break the expectations of existing code, we modify the value to
+                // keep the format consistent with the kernel cmdline by removing quote and space.
+                std::string_view sv(value);
+                android::base::ConsumePrefix(&sv, "\"");
+                android::base::ConsumeSuffix(&sv, "\"");
+                value = android::base::StringReplace(sv, R"(", ")", ",", true);
+            }
+        }
+        // "key" and "key =" means empty value.
+        fn(std::move(key), std::move(value));
+    }
+}
+
+bool GetBootconfigFromString(const std::string& bootconfig, const std::string& key,
+                             std::string* out) {
+    bool found = false;
+    ImportBootconfigFromString(bootconfig, [&](std::string config_key, std::string value) {
+        if (!found && config_key == key) {
+            *out = std::move(value);
+            found = true;
+        }
+    });
+    return found;
+}
+
+void ImportBootconfig(const std::function<void(std::string, std::string)>& fn) {
+    std::string bootconfig;
+    android::base::ReadFileToString("/proc/bootconfig", &bootconfig);
+    ImportBootconfigFromString(bootconfig, fn);
+}
+
+bool GetBootconfig(const std::string& key, std::string* out) {
+    std::string bootconfig;
+    android::base::ReadFileToString("/proc/bootconfig", &bootconfig);
+    return GetBootconfigFromString(bootconfig, key, out);
+}
+
 }  // namespace fs_mgr
 }  // namespace android
 
@@ -88,44 +147,6 @@ std::vector<std::pair<std::string, std::string>> fs_mgr_parse_cmdline(const std:
     return result;
 }
 
-std::vector<std::pair<std::string, std::string>> fs_mgr_parse_proc_bootconfig(
-        const std::string& cmdline) {
-    static constexpr char quote = '"';
-
-    std::vector<std::pair<std::string, std::string>> result;
-    for (auto& line : android::base::Split(cmdline, "\n")) {
-        line.erase(std::remove(line.begin(), line.end(), quote), line.end());
-        auto equal_sign = line.find('=');
-        if (equal_sign == line.npos) {
-            if (!line.empty()) {
-                // no difference between <key> and <key>=
-                result.emplace_back(std::move(line), "");
-            }
-        } else {
-            result.emplace_back(android::base::Trim(line.substr(0, equal_sign)),
-                                android::base::Trim(line.substr(equal_sign + 1)));
-        }
-    }
-
-    return result;
-}
-
-bool fs_mgr_get_boot_config_from_bootconfig(const std::string& bootconfig,
-                                            const std::string& android_key, std::string* out_val) {
-    FSTAB_CHECK(out_val != nullptr);
-
-    const std::string bootconfig_key("androidboot." + android_key);
-    for (const auto& [key, value] : fs_mgr_parse_proc_bootconfig(bootconfig)) {
-        if (key == bootconfig_key) {
-            *out_val = value;
-            return true;
-        }
-    }
-
-    *out_val = "";
-    return false;
-}
-
 bool fs_mgr_get_boot_config_from_kernel(const std::string& cmdline, const std::string& android_key,
                                         std::string* out_val) {
     FSTAB_CHECK(out_val != nullptr);
@@ -142,17 +163,6 @@ bool fs_mgr_get_boot_config_from_kernel(const std::string& cmdline, const std::s
     return false;
 }
 
-// Tries to get the given boot config value from bootconfig.
-// Returns true if successfully found, false otherwise.
-bool fs_mgr_get_boot_config_from_bootconfig_source(const std::string& key, std::string* out_val) {
-    std::string bootconfig;
-    if (!android::base::ReadFileToString("/proc/bootconfig", &bootconfig)) return false;
-    if (!bootconfig.empty() && bootconfig.back() == '\n') {
-        bootconfig.pop_back();
-    }
-    return fs_mgr_get_boot_config_from_bootconfig(bootconfig, key, out_val);
-}
-
 // Tries to get the given boot config value from kernel cmdline.
 // Returns true if successfully found, false otherwise.
 bool fs_mgr_get_boot_config_from_kernel_cmdline(const std::string& key, std::string* out_val) {
@@ -188,7 +198,8 @@ bool fs_mgr_get_boot_config(const std::string& key, std::string* out_val) {
     }
 
     // next, check if we have the property in bootconfig
-    if (fs_mgr_get_boot_config_from_bootconfig_source(key, out_val)) {
+    const std::string config_key = "androidboot." + key;
+    if (android::fs_mgr::GetBootconfig(config_key, out_val)) {
         return true;
     }
 
diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index 86ba03148838..3cbd8c819e9e 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -864,21 +864,19 @@ const FstabEntry* GetEntryForMountPoint(const Fstab* fstab, const std::string& p
 
 std::set<std::string> GetBootDevices() {
     // First check bootconfig, then kernel commandline, then the device tree
-    std::string dt_file_name = GetAndroidDtDir() + "boot_devices";
     std::string value;
-    if (fs_mgr_get_boot_config_from_bootconfig_source("boot_devices", &value) ||
-        fs_mgr_get_boot_config_from_bootconfig_source("boot_device", &value)) {
+    if (GetBootconfig("androidboot.boot_devices", &value) ||
+        GetBootconfig("androidboot.boot_device", &value)) {
         std::set<std::string> boot_devices;
-        // remove quotes and split by spaces
-        auto boot_device_strings = base::Split(base::StringReplace(value, "\"", "", true), " ");
-        for (std::string_view device : boot_device_strings) {
-            // trim the trailing comma, keep the rest.
+        // split by spaces and trim the trailing comma.
+        for (std::string_view device : android::base::Split(value, " ")) {
             base::ConsumeSuffix(&device, ",");
             boot_devices.emplace(device);
         }
         return boot_devices;
     }
 
+    std::string dt_file_name = GetAndroidDtDir() + "boot_devices";
     if (fs_mgr_get_boot_config_from_kernel_cmdline("boot_devices", &value) ||
         ReadDtFile(dt_file_name, &value)) {
         auto boot_devices = Split(value, ",");
diff --git a/fs_mgr/libfstab/fstab_priv.h b/fs_mgr/libfstab/fstab_priv.h
index 5d226f8798f6..cc5682567548 100644
--- a/fs_mgr/libfstab/fstab_priv.h
+++ b/fs_mgr/libfstab/fstab_priv.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <functional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -29,11 +30,6 @@ bool fs_mgr_get_boot_config_from_kernel(const std::string& cmdline, const std::s
                                         std::string* out_val);
 bool fs_mgr_get_boot_config_from_kernel_cmdline(const std::string& key, std::string* out_val);
 bool fs_mgr_get_boot_config(const std::string& key, std::string* out_val);
-std::vector<std::pair<std::string, std::string>> fs_mgr_parse_proc_bootconfig(
-        const std::string& bootconfig);
-bool fs_mgr_get_boot_config_from_bootconfig(const std::string& bootconfig, const std::string& key,
-                                            std::string* out_val);
-bool fs_mgr_get_boot_config_from_bootconfig_source(const std::string& key, std::string* out_val);
 
 bool fs_mgr_update_for_slotselect(android::fs_mgr::Fstab* fstab);
 bool is_dt_compatible();
@@ -46,5 +42,11 @@ bool ParseFstabFromString(const std::string& fstab_str, bool proc_mounts, Fstab*
 bool SkipMountWithConfig(const std::string& skip_config, Fstab* fstab, bool verbose);
 std::string GetFstabPath();
 
+void ImportBootconfigFromString(const std::string& bootconfig,
+                                const std::function<void(std::string, std::string)>& fn);
+
+bool GetBootconfigFromString(const std::string& bootconfig, const std::string& key,
+                             std::string* out);
+
 }  // namespace fs_mgr
 }  // namespace android
diff --git a/fs_mgr/libfstab/include/fstab/fstab.h b/fs_mgr/libfstab/include/fstab/fstab.h
index 0a45fe87ad3e..79a07eef2a14 100644
--- a/fs_mgr/libfstab/include/fstab/fstab.h
+++ b/fs_mgr/libfstab/include/fstab/fstab.h
@@ -19,6 +19,7 @@
 #include <stdint.h>
 #include <sys/types.h>
 
+#include <functional>
 #include <set>
 #include <string>
 #include <vector>
@@ -128,5 +129,13 @@ std::string GetVerityDeviceName(const FstabEntry& entry);
 // If the platform does not configure a custom DT path, returns the standard one (based in procfs).
 const std::string& GetAndroidDtDir();
 
+// Import the kernel bootconfig by calling the callback |fn| with each key-value pair.
+void ImportBootconfig(const std::function<void(std::string, std::string)>& fn);
+
+// Get the kernel bootconfig value for |key|.
+// Returns true if |key| is found in bootconfig.
+// Otherwise returns false and |*out| is not modified.
+bool GetBootconfig(const std::string& key, std::string* out);
+
 }  // namespace fs_mgr
 }  // namespace android
diff --git a/fs_mgr/tests/Android.bp b/fs_mgr/tests/Android.bp
index b7f792fe6235..2aeba0acd6a1 100644
--- a/fs_mgr/tests/Android.bp
+++ b/fs_mgr/tests/Android.bp
@@ -38,6 +38,8 @@ cc_test {
     ],
     static_libs: [
         "libfs_mgr",
+        "libgmock",
+        "libgtest",
     ],
     srcs: [
         "file_wait_test.cpp",
diff --git a/fs_mgr/tests/fs_mgr_test.cpp b/fs_mgr/tests/fs_mgr_test.cpp
index c51df2a7ef1a..fbed3716074a 100644
--- a/fs_mgr/tests/fs_mgr_test.cpp
+++ b/fs_mgr/tests/fs_mgr_test.cpp
@@ -29,11 +29,13 @@
 #include <android-base/strings.h>
 #include <fs_mgr.h>
 #include <fstab/fstab.h>
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 #include "../fs_mgr_priv.h"
 
 using namespace android::fs_mgr;
+using namespace testing;
 
 namespace {
 
@@ -119,37 +121,42 @@ const std::vector<std::pair<std::string, std::string>> result_space = {
         {"terminator", "truncated"},
 };
 
-const std::string bootconfig =
-        "androidboot.bootdevice = \"1d84000.ufshc\"\n"
-        "androidboot.boot_devices = \"dev1\", \"dev2,withcomma\", \"dev3\"\n"
-        "androidboot.baseband = \"sdy\"\n"
-        "androidboot.keymaster = \"1\"\n"
-        "androidboot.serialno = \"BLAHBLAHBLAH\"\n"
-        "androidboot.slot_suffix = \"_a\"\n"
-        "androidboot.hardware.platform = \"sdw813\"\n"
-        "androidboot.hardware = \"foo\"\n"
-        "androidboot.revision = \"EVT1.0\"\n"
-        "androidboot.bootloader = \"burp-0.1-7521\"\n"
-        "androidboot.hardware.sku = \"mary\"\n"
-        "androidboot.hardware.radio.subtype = \"0\"\n"
-        "androidboot.dtbo_idx = \"2\"\n"
-        "androidboot.mode = \"normal\"\n"
-        "androidboot.hardware.ddr = \"1GB,combuchi,LPDDR4X\"\n"
-        "androidboot.ddr_info = \"combuchiandroidboot.ddr_size=2GB\"\n"
-        "androidboot.hardware.ufs = \"2GB,combushi\"\n"
-        "androidboot.boottime = \"0BLE:58,1BLL:22,1BLE:571,2BLL:105,ODT:0,AVB:123\"\n"
-        "androidboot.ramdump = \"disabled\"\n"
-        "androidboot.vbmeta.device = \"PARTUUID=aa08f1a4-c7c9-402e-9a66-9707cafa9ceb\"\n"
-        "androidboot.vbmeta.avb_version = \"1.1\"\n"
-        "androidboot.vbmeta.device_state = \"unlocked\"\n"
-        "androidboot.vbmeta.hash_alg = \"sha256\"\n"
-        "androidboot.vbmeta.size = \"5248\"\n"
-        "androidboot.vbmeta.digest = \""
-        "ac13147e959861c20f2a6da97d25fe79e60e902c022a371c5c039d31e7c68860\"\n"
-        "androidboot.vbmeta.invalidate_on_error = \"yes\"\n"
-        "androidboot.veritymode = \"enforcing\"\n"
-        "androidboot.verifiedbootstate = \"orange\"\n"
-        "androidboot.space = \"sha256 5248 androidboot.nospace = nope\"\n";
+const std::string bootconfig = R"(
+androidboot.bootdevice = "1d84000.ufshc"
+androidboot.boot_devices = "dev1", "dev2,withcomma", "dev3"
+androidboot.baseband = "sdy"
+androidboot.keymaster = "1"
+androidboot.serialno = "BLAHBLAHBLAH"
+androidboot.slot_suffix = "_a"
+androidboot.hardware.platform = "sdw813"
+androidboot.hardware = "foo"
+androidboot.revision = "EVT1.0"
+androidboot.bootloader = "burp-0.1-7521"
+androidboot.hardware.sku = "mary"
+androidboot.hardware.radio.subtype = "0"
+androidboot.dtbo_idx = "2"
+androidboot.mode = "normal"
+androidboot.hardware.ddr = "1GB,combuchi,LPDDR4X"
+androidboot.ddr_info = "combuchiandroidboot.ddr_size=2GB"
+androidboot.hardware.ufs = "2GB,combushi"
+androidboot.boottime = "0BLE:58,1BLL:22,1BLE:571,2BLL:105,ODT:0,AVB:123"
+androidboot.ramdump = "disabled"
+androidboot.vbmeta.device = "PARTUUID=aa08f1a4-c7c9-402e-9a66-9707cafa9ceb"
+androidboot.vbmeta.avb_version = "1.1"
+androidboot.vbmeta.device_state = "unlocked"
+androidboot.vbmeta.hash_alg = "sha256"
+androidboot.vbmeta.size = "5248"
+androidboot.vbmeta.digest = "ac13147e959861c20f2a6da97d25fe79e60e902c022a371c5c039d31e7c68860"
+androidboot.vbmeta.invalidate_on_error = "yes"
+androidboot.veritymode = "enforcing"
+androidboot.verifiedbootstate = "orange"
+androidboot.space = "sha256 5248 androidboot.nospace = nope"
+just.key
+key.empty.value =
+dessert.value = "ice, cream"
+dessert.list = "ice", "cream"
+ambiguous.list = ", ", ", "
+)";
 
 const std::vector<std::pair<std::string, std::string>> bootconfig_result_space = {
         {"androidboot.bootdevice", "1d84000.ufshc"},
@@ -182,6 +189,11 @@ const std::vector<std::pair<std::string, std::string>> bootconfig_result_space =
         {"androidboot.veritymode", "enforcing"},
         {"androidboot.verifiedbootstate", "orange"},
         {"androidboot.space", "sha256 5248 androidboot.nospace = nope"},
+        {"just.key", ""},
+        {"key.empty.value", ""},
+        {"dessert.value", "ice, cream"},
+        {"dessert.list", "ice,cream"},
+        {"ambiguous.list", ", ,, "},
 };
 
 bool CompareFlags(FstabEntry::FsMgrFlags& lhs, FstabEntry::FsMgrFlags& rhs) {
@@ -231,25 +243,35 @@ TEST(fs_mgr, fs_mgr_get_boot_config_from_kernel_cmdline) {
     EXPECT_TRUE(content.empty()) << content;
 }
 
-TEST(fs_mgr, fs_mgr_parse_bootconfig) {
-    EXPECT_EQ(bootconfig_result_space, fs_mgr_parse_proc_bootconfig(bootconfig));
+TEST(fs_mgr, ImportBootconfig) {
+    std::vector<std::pair<std::string, std::string>> result;
+    ImportBootconfigFromString(bootconfig, [&](std::string key, std::string value) {
+        result.emplace_back(key, value);
+    });
+    EXPECT_THAT(result, ContainerEq(bootconfig_result_space));
 }
 
-TEST(fs_mgr, fs_mgr_get_boot_config_from_bootconfig) {
+TEST(fs_mgr, GetBootconfig) {
     std::string content;
-    for (const auto& entry : bootconfig_result_space) {
-        static constexpr char androidboot[] = "androidboot.";
-        if (!android::base::StartsWith(entry.first, androidboot)) continue;
-        auto key = entry.first.substr(strlen(androidboot));
-        EXPECT_TRUE(fs_mgr_get_boot_config_from_bootconfig(bootconfig, key, &content))
-                << " for " << key;
-        EXPECT_EQ(entry.second, content);
+    for (const auto& [key, value] : bootconfig_result_space) {
+        EXPECT_TRUE(GetBootconfigFromString(bootconfig, key, &content)) << " for " << key;
+        EXPECT_EQ(content, value);
     }
 
-    EXPECT_FALSE(fs_mgr_get_boot_config_from_bootconfig(bootconfig, "vbmeta.avb_versio", &content));
-    EXPECT_TRUE(content.empty()) << content;
-    EXPECT_FALSE(fs_mgr_get_boot_config_from_bootconfig(bootconfig, "nospace", &content));
-    EXPECT_TRUE(content.empty()) << content;
+    const std::string kUnmodifiedToken = "<UNMODIFIED>";
+    content = kUnmodifiedToken;
+    EXPECT_FALSE(android::fs_mgr::GetBootconfigFromString(bootconfig, "", &content));
+    EXPECT_EQ(content, kUnmodifiedToken) << "output parameter shouldn't be overridden";
+
+    content = kUnmodifiedToken;
+    EXPECT_FALSE(android::fs_mgr::GetBootconfigFromString(
+            bootconfig, "androidboot.vbmeta.avb_versio", &content));
+    EXPECT_EQ(content, kUnmodifiedToken) << "output parameter shouldn't be overridden";
+
+    content = kUnmodifiedToken;
+    EXPECT_FALSE(
+            android::fs_mgr::GetBootconfigFromString(bootconfig, "androidboot.nospace", &content));
+    EXPECT_EQ(content, kUnmodifiedToken) << "output parameter shouldn't be overridden";
 }
 
 TEST(fs_mgr, fs_mgr_read_fstab_file_proc_mounts) {
diff --git a/init/devices.cpp b/init/devices.cpp
index 7c234924b450..6b8474eaa302 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -32,6 +32,7 @@
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
+#include <fs_mgr.h>
 #include <libdm/dm.h>
 #include <private/android_filesystem_config.h>
 #include <selinux/android.h>
@@ -204,7 +205,7 @@ std::string DeviceHandler::GetPartitionNameForDevice(const std::string& query_de
             }
         };
         ImportKernelCmdline(parser);
-        ImportBootconfig(parser);
+        android::fs_mgr::ImportBootconfig(parser);
         return partition_map;
     }();
 
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 0e82022a0e83..35577874f6da 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1351,7 +1351,7 @@ static void ProcessKernelCmdline() {
 
 
 static void ProcessBootconfig() {
-    ImportBootconfig([&](const std::string& key, const std::string& value) {
+    android::fs_mgr::ImportBootconfig([&](const std::string& key, const std::string& value) {
         if (StartsWith(key, ANDROIDBOOT_PREFIX)) {
             InitPropertySet("ro.boot." + key.substr(ANDROIDBOOT_PREFIX.size()), value);
         }
diff --git a/init/reboot_utils.cpp b/init/reboot_utils.cpp
index e6b868e797ae..547b1869f3c4 100644
--- a/init/reboot_utils.cpp
+++ b/init/reboot_utils.cpp
@@ -27,6 +27,7 @@
 #include <android-base/properties.h>
 #include <android-base/strings.h>
 #include <cutils/android_reboot.h>
+#include <fs_mgr.h>
 #include <unwindstack/AndroidUnwinder.h>
 
 #include "capabilities.h"
@@ -48,13 +49,9 @@ void SetFatalRebootTarget(const std::optional<std::string>& reboot_target) {
 
     const std::string kInitFatalPanicParamString = "androidboot.init_fatal_panic";
     if (cmdline.find(kInitFatalPanicParamString) == std::string::npos) {
-        init_fatal_panic = false;
-        ImportBootconfig(
-                [kInitFatalPanicParamString](const std::string& key, const std::string& value) {
-                    if (key == kInitFatalPanicParamString && value == "true") {
-                        init_fatal_panic = true;
-                    }
-                });
+        std::string value;
+        init_fatal_panic = (android::fs_mgr::GetBootconfig(kInitFatalPanicParamString, &value) &&
+                            value == "true");
     } else {
         const std::string kInitFatalPanicString = kInitFatalPanicParamString + "=true";
         init_fatal_panic = cmdline.find(kInitFatalPanicString) != std::string::npos;
@@ -68,11 +65,7 @@ void SetFatalRebootTarget(const std::optional<std::string>& reboot_target) {
     const std::string kRebootTargetString = "androidboot.init_fatal_reboot_target";
     auto start_pos = cmdline.find(kRebootTargetString);
     if (start_pos == std::string::npos) {
-        ImportBootconfig([kRebootTargetString](const std::string& key, const std::string& value) {
-            if (key == kRebootTargetString) {
-                init_fatal_reboot_target = value;
-            }
-        });
+        android::fs_mgr::GetBootconfig(kRebootTargetString, &init_fatal_reboot_target);
         // We already default to bootloader if no setting is provided.
     } else {
         const std::string kRebootTargetStringPattern = kRebootTargetString + "=";
diff --git a/init/selinux.cpp b/init/selinux.cpp
index 51093d898e8b..6fb028b169fe 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -110,11 +110,11 @@ EnforcingStatus StatusFromProperty() {
     });
 
     if (status == SELINUX_ENFORCING) {
-        ImportBootconfig([&](const std::string& key, const std::string& value) {
-            if (key == "androidboot.selinux" && value == "permissive") {
-                status = SELINUX_PERMISSIVE;
-            }
-        });
+        std::string value;
+        if (android::fs_mgr::GetBootconfig("androidboot.selinux", &value) &&
+            value == "permissive") {
+            status = SELINUX_PERMISSIVE;
+        }
     }
 
     return status;
diff --git a/init/util.cpp b/init/util.cpp
index 61d59a4801d0..b34d45d70f42 100644
--- a/init/util.cpp
+++ b/init/util.cpp
@@ -254,21 +254,6 @@ void ImportKernelCmdline(const std::function<void(const std::string&, const std:
     }
 }
 
-void ImportBootconfig(const std::function<void(const std::string&, const std::string&)>& fn) {
-    std::string bootconfig;
-    android::base::ReadFileToString("/proc/bootconfig", &bootconfig);
-
-    for (const auto& entry : android::base::Split(bootconfig, "\n")) {
-        std::vector<std::string> pieces = android::base::Split(entry, "=");
-        if (pieces.size() == 2) {
-            // get rid of the extra space between a list of values and remove the quotes.
-            std::string value = android::base::StringReplace(pieces[1], "\", \"", ",", true);
-            value.erase(std::remove(value.begin(), value.end(), '"'), value.end());
-            fn(android::base::Trim(pieces[0]), android::base::Trim(value));
-        }
-    }
-}
-
 bool make_dir(const std::string& path, mode_t mode) {
     std::string secontext;
     if (SelabelLookupFileContext(path, mode, &secontext) && !secontext.empty()) {
diff --git a/init/util.h b/init/util.h
index 1c00a3efc0b1..0b0ef632b109 100644
--- a/init/util.h
+++ b/init/util.h
@@ -55,7 +55,6 @@ Result<uid_t> DecodeUid(const std::string& name);
 bool mkdir_recursive(const std::string& pathname, mode_t mode);
 int wait_for_file(const char *filename, std::chrono::nanoseconds timeout);
 void ImportKernelCmdline(const std::function<void(const std::string&, const std::string&)>&);
-void ImportBootconfig(const std::function<void(const std::string&, const std::string&)>&);
 bool make_dir(const std::string& path, mode_t mode);
 bool is_dir(const char* pathname);
 Result<std::string> ExpandProps(const std::string& src);

From da5323e2d6be16470b7ce2be118d41a497c7d9a6 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Wed, 2 Aug 2023 01:08:23 +0800
Subject: [PATCH 0260/1487] init: Use libfs_mgr kernel cmdline parser

Bug: 293695109
Test: CtsFsMgrTestCases
Change-Id: Ie2567d84cb80c392ad68aef0c438d8acc03a311e
---
 fs_mgr/libfstab/boot_config.cpp       | 65 ++++++++++++---------------
 fs_mgr/libfstab/fstab.cpp             | 28 +++++-------
 fs_mgr/libfstab/fstab_priv.h          | 12 ++---
 fs_mgr/libfstab/include/fstab/fstab.h |  8 ++++
 fs_mgr/tests/fs_mgr_test.cpp          | 43 ++++++++++--------
 init/devices.cpp                      |  2 +-
 init/property_service.cpp             |  2 +-
 init/selinux.cpp                      | 23 +++-------
 init/util.cpp                         | 12 -----
 init/util.h                           |  3 +-
 10 files changed, 89 insertions(+), 109 deletions(-)

diff --git a/fs_mgr/libfstab/boot_config.cpp b/fs_mgr/libfstab/boot_config.cpp
index 53c843e9338e..ae537b5d2560 100644
--- a/fs_mgr/libfstab/boot_config.cpp
+++ b/fs_mgr/libfstab/boot_config.cpp
@@ -17,11 +17,9 @@
 #include <algorithm>
 #include <iterator>
 #include <string>
-#include <vector>
 
 #include <android-base/file.h>
 #include <android-base/properties.h>
-#include <android-base/stringprintf.h>
 #include <android-base/strings.h>
 
 #include "fstab_priv.h"
@@ -35,7 +33,7 @@ const std::string& GetAndroidDtDir() {
     static const std::string kAndroidDtDir = [] {
         std::string android_dt_dir;
         if ((GetBootconfig("androidboot.android_dt_dir", &android_dt_dir) ||
-             fs_mgr_get_boot_config_from_kernel_cmdline("android_dt_dir", &android_dt_dir)) &&
+             GetKernelCmdline("androidboot.android_dt_dir", &android_dt_dir)) &&
             !android_dt_dir.empty()) {
             // Ensure the returned path ends with a /
             if (android_dt_dir.back() != '/') {
@@ -110,13 +108,10 @@ bool GetBootconfig(const std::string& key, std::string* out) {
     return GetBootconfigFromString(bootconfig, key, out);
 }
 
-}  // namespace fs_mgr
-}  // namespace android
-
-std::vector<std::pair<std::string, std::string>> fs_mgr_parse_cmdline(const std::string& cmdline) {
+void ImportKernelCmdlineFromString(const std::string& cmdline,
+                                   const std::function<void(std::string, std::string)>& fn) {
     static constexpr char quote = '"';
 
-    std::vector<std::pair<std::string, std::string>> result;
     size_t base = 0;
     while (true) {
         // skip quoted spans
@@ -135,48 +130,46 @@ std::vector<std::pair<std::string, std::string>> fs_mgr_parse_cmdline(const std:
         if (equal_sign == piece.npos) {
             if (!piece.empty()) {
                 // no difference between <key> and <key>=
-                result.emplace_back(std::move(piece), "");
+                fn(std::move(piece), "");
             }
         } else {
-            result.emplace_back(piece.substr(0, equal_sign), piece.substr(equal_sign + 1));
+            fn(piece.substr(0, equal_sign), piece.substr(equal_sign + 1));
         }
         if (found == cmdline.npos) break;
         base = found + 1;
     }
-
-    return result;
 }
 
-bool fs_mgr_get_boot_config_from_kernel(const std::string& cmdline, const std::string& android_key,
-                                        std::string* out_val) {
-    FSTAB_CHECK(out_val != nullptr);
-
-    const std::string cmdline_key("androidboot." + android_key);
-    for (const auto& [key, value] : fs_mgr_parse_cmdline(cmdline)) {
-        if (key == cmdline_key) {
-            *out_val = value;
-            return true;
+bool GetKernelCmdlineFromString(const std::string& cmdline, const std::string& key,
+                                std::string* out) {
+    bool found = false;
+    ImportKernelCmdlineFromString(cmdline, [&](std::string config_key, std::string value) {
+        if (!found && config_key == key) {
+            *out = std::move(value);
+            found = true;
         }
-    }
+    });
+    return found;
+}
 
-    *out_val = "";
-    return false;
+void ImportKernelCmdline(const std::function<void(std::string, std::string)>& fn) {
+    std::string cmdline;
+    android::base::ReadFileToString("/proc/cmdline", &cmdline);
+    ImportKernelCmdlineFromString(android::base::Trim(cmdline), fn);
 }
 
-// Tries to get the given boot config value from kernel cmdline.
-// Returns true if successfully found, false otherwise.
-bool fs_mgr_get_boot_config_from_kernel_cmdline(const std::string& key, std::string* out_val) {
+bool GetKernelCmdline(const std::string& key, std::string* out) {
     std::string cmdline;
-    if (!android::base::ReadFileToString("/proc/cmdline", &cmdline)) return false;
-    if (!cmdline.empty() && cmdline.back() == '\n') {
-        cmdline.pop_back();
-    }
-    return fs_mgr_get_boot_config_from_kernel(cmdline, key, out_val);
+    android::base::ReadFileToString("/proc/cmdline", &cmdline);
+    return GetKernelCmdlineFromString(android::base::Trim(cmdline), key, out);
 }
 
-// Tries to get the boot config value in device tree, properties and
-// kernel cmdline (in that order).  Returns 'true' if successfully
-// found, 'false' otherwise.
+}  // namespace fs_mgr
+}  // namespace android
+
+// Tries to get the boot config value in device tree, properties, kernel bootconfig and kernel
+// cmdline (in that order).
+// Returns 'true' if successfully found, 'false' otherwise.
 bool fs_mgr_get_boot_config(const std::string& key, std::string* out_val) {
     FSTAB_CHECK(out_val != nullptr);
 
@@ -204,7 +197,7 @@ bool fs_mgr_get_boot_config(const std::string& key, std::string* out_val) {
     }
 
     // finally, fallback to kernel cmdline, properties may not be ready yet
-    if (fs_mgr_get_boot_config_from_kernel_cmdline(key, out_val)) {
+    if (android::fs_mgr::GetKernelCmdline(config_key, out_val)) {
         return true;
     }
 
diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index 3cbd8c819e9e..21b002434391 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -863,11 +863,11 @@ const FstabEntry* GetEntryForMountPoint(const Fstab* fstab, const std::string& p
 }
 
 std::set<std::string> GetBootDevices() {
+    std::set<std::string> boot_devices;
     // First check bootconfig, then kernel commandline, then the device tree
     std::string value;
     if (GetBootconfig("androidboot.boot_devices", &value) ||
         GetBootconfig("androidboot.boot_device", &value)) {
-        std::set<std::string> boot_devices;
         // split by spaces and trim the trailing comma.
         for (std::string_view device : android::base::Split(value, " ")) {
             base::ConsumeSuffix(&device, ",");
@@ -876,25 +876,19 @@ std::set<std::string> GetBootDevices() {
         return boot_devices;
     }
 
-    std::string dt_file_name = GetAndroidDtDir() + "boot_devices";
-    if (fs_mgr_get_boot_config_from_kernel_cmdline("boot_devices", &value) ||
-        ReadDtFile(dt_file_name, &value)) {
-        auto boot_devices = Split(value, ",");
-        return std::set<std::string>(boot_devices.begin(), boot_devices.end());
+    const std::string dt_file_name = GetAndroidDtDir() + "boot_devices";
+    if (GetKernelCmdline("androidboot.boot_devices", &value) || ReadDtFile(dt_file_name, &value)) {
+        auto boot_devices_list = Split(value, ",");
+        return {boot_devices_list.begin(), boot_devices_list.end()};
     }
 
-    std::string cmdline;
-    if (android::base::ReadFileToString("/proc/cmdline", &cmdline)) {
-        std::set<std::string> boot_devices;
-        const std::string cmdline_key = "androidboot.boot_device";
-        for (const auto& [key, value] : fs_mgr_parse_cmdline(cmdline)) {
-            if (key == cmdline_key) {
-                boot_devices.emplace(value);
-            }
-        }
-        if (!boot_devices.empty()) {
-            return boot_devices;
+    ImportKernelCmdline([&](std::string key, std::string value) {
+        if (key == "androidboot.boot_device") {
+            boot_devices.emplace(std::move(value));
         }
+    });
+    if (!boot_devices.empty()) {
+        return boot_devices;
     }
 
     // Fallback to extract boot devices from fstab.
diff --git a/fs_mgr/libfstab/fstab_priv.h b/fs_mgr/libfstab/fstab_priv.h
index cc5682567548..5105da001031 100644
--- a/fs_mgr/libfstab/fstab_priv.h
+++ b/fs_mgr/libfstab/fstab_priv.h
@@ -18,17 +18,11 @@
 
 #include <functional>
 #include <string>
-#include <utility>
-#include <vector>
 
 #include <fstab/fstab.h>
 
 // Do not include logging_macros.h here as this header is used by fs_mgr, too.
 
-std::vector<std::pair<std::string, std::string>> fs_mgr_parse_cmdline(const std::string& cmdline);
-bool fs_mgr_get_boot_config_from_kernel(const std::string& cmdline, const std::string& key,
-                                        std::string* out_val);
-bool fs_mgr_get_boot_config_from_kernel_cmdline(const std::string& key, std::string* out_val);
 bool fs_mgr_get_boot_config(const std::string& key, std::string* out_val);
 
 bool fs_mgr_update_for_slotselect(android::fs_mgr::Fstab* fstab);
@@ -48,5 +42,11 @@ void ImportBootconfigFromString(const std::string& bootconfig,
 bool GetBootconfigFromString(const std::string& bootconfig, const std::string& key,
                              std::string* out);
 
+void ImportKernelCmdlineFromString(const std::string& cmdline,
+                                   const std::function<void(std::string, std::string)>& fn);
+
+bool GetKernelCmdlineFromString(const std::string& cmdline, const std::string& key,
+                                std::string* out);
+
 }  // namespace fs_mgr
 }  // namespace android
diff --git a/fs_mgr/libfstab/include/fstab/fstab.h b/fs_mgr/libfstab/include/fstab/fstab.h
index 79a07eef2a14..150a47da350c 100644
--- a/fs_mgr/libfstab/include/fstab/fstab.h
+++ b/fs_mgr/libfstab/include/fstab/fstab.h
@@ -137,5 +137,13 @@ void ImportBootconfig(const std::function<void(std::string, std::string)>& fn);
 // Otherwise returns false and |*out| is not modified.
 bool GetBootconfig(const std::string& key, std::string* out);
 
+// Import the kernel cmdline by calling the callback |fn| with each key-value pair.
+void ImportKernelCmdline(const std::function<void(std::string, std::string)>& fn);
+
+// Get the kernel cmdline value for |key|.
+// Returns true if |key| is found in the kernel cmdline.
+// Otherwise returns false and |*out| is not modified.
+bool GetKernelCmdline(const std::string& key, std::string* out);
+
 }  // namespace fs_mgr
 }  // namespace android
diff --git a/fs_mgr/tests/fs_mgr_test.cpp b/fs_mgr/tests/fs_mgr_test.cpp
index fbed3716074a..322bf1b08930 100644
--- a/fs_mgr/tests/fs_mgr_test.cpp
+++ b/fs_mgr/tests/fs_mgr_test.cpp
@@ -224,23 +224,32 @@ bool CompareFlags(FstabEntry::FsMgrFlags& lhs, FstabEntry::FsMgrFlags& rhs) {
 
 }  // namespace
 
-TEST(fs_mgr, fs_mgr_parse_cmdline) {
-    EXPECT_EQ(result_space, fs_mgr_parse_cmdline(cmdline));
+TEST(fs_mgr, ImportKernelCmdline) {
+    std::vector<std::pair<std::string, std::string>> result;
+    ImportKernelCmdlineFromString(
+            cmdline, [&](std::string key, std::string value) { result.emplace_back(key, value); });
+    EXPECT_THAT(result, ContainerEq(result_space));
 }
 
-TEST(fs_mgr, fs_mgr_get_boot_config_from_kernel_cmdline) {
+TEST(fs_mgr, GetKernelCmdline) {
     std::string content;
-    for (const auto& entry : result_space) {
-        static constexpr char androidboot[] = "androidboot.";
-        if (!android::base::StartsWith(entry.first, androidboot)) continue;
-        auto key = entry.first.substr(strlen(androidboot));
-        EXPECT_TRUE(fs_mgr_get_boot_config_from_kernel(cmdline, key, &content)) << " for " << key;
-        EXPECT_EQ(entry.second, content);
+    for (const auto& [key, value] : result_space) {
+        EXPECT_TRUE(GetKernelCmdlineFromString(cmdline, key, &content)) << " for " << key;
+        EXPECT_EQ(content, value);
     }
-    EXPECT_FALSE(fs_mgr_get_boot_config_from_kernel(cmdline, "vbmeta.avb_versio", &content));
-    EXPECT_TRUE(content.empty()) << content;
-    EXPECT_FALSE(fs_mgr_get_boot_config_from_kernel(cmdline, "nospace", &content));
-    EXPECT_TRUE(content.empty()) << content;
+
+    const std::string kUnmodifiedToken = "<UNMODIFIED>";
+    content = kUnmodifiedToken;
+    EXPECT_FALSE(GetKernelCmdlineFromString(cmdline, "", &content));
+    EXPECT_EQ(content, kUnmodifiedToken) << "output parameter shouldn't be overridden";
+
+    content = kUnmodifiedToken;
+    EXPECT_FALSE(GetKernelCmdlineFromString(cmdline, "androidboot.vbmeta.avb_versio", &content));
+    EXPECT_EQ(content, kUnmodifiedToken) << "output parameter shouldn't be overridden";
+
+    content = kUnmodifiedToken;
+    EXPECT_FALSE(GetKernelCmdlineFromString(bootconfig, "androidboot.nospace", &content));
+    EXPECT_EQ(content, kUnmodifiedToken) << "output parameter shouldn't be overridden";
 }
 
 TEST(fs_mgr, ImportBootconfig) {
@@ -260,17 +269,15 @@ TEST(fs_mgr, GetBootconfig) {
 
     const std::string kUnmodifiedToken = "<UNMODIFIED>";
     content = kUnmodifiedToken;
-    EXPECT_FALSE(android::fs_mgr::GetBootconfigFromString(bootconfig, "", &content));
+    EXPECT_FALSE(GetBootconfigFromString(bootconfig, "", &content));
     EXPECT_EQ(content, kUnmodifiedToken) << "output parameter shouldn't be overridden";
 
     content = kUnmodifiedToken;
-    EXPECT_FALSE(android::fs_mgr::GetBootconfigFromString(
-            bootconfig, "androidboot.vbmeta.avb_versio", &content));
+    EXPECT_FALSE(GetBootconfigFromString(bootconfig, "androidboot.vbmeta.avb_versio", &content));
     EXPECT_EQ(content, kUnmodifiedToken) << "output parameter shouldn't be overridden";
 
     content = kUnmodifiedToken;
-    EXPECT_FALSE(
-            android::fs_mgr::GetBootconfigFromString(bootconfig, "androidboot.nospace", &content));
+    EXPECT_FALSE(GetBootconfigFromString(bootconfig, "androidboot.nospace", &content));
     EXPECT_EQ(content, kUnmodifiedToken) << "output parameter shouldn't be overridden";
 }
 
diff --git a/init/devices.cpp b/init/devices.cpp
index 6b8474eaa302..e76786a6d495 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -204,7 +204,7 @@ std::string DeviceHandler::GetPartitionNameForDevice(const std::string& query_de
                 partition_map.emplace_back(map_pieces[0], map_pieces[1]);
             }
         };
-        ImportKernelCmdline(parser);
+        android::fs_mgr::ImportKernelCmdline(parser);
         android::fs_mgr::ImportBootconfig(parser);
         return partition_map;
     }();
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 35577874f6da..f5de17d82bf1 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1342,7 +1342,7 @@ static void ProcessKernelDt() {
 constexpr auto ANDROIDBOOT_PREFIX = "androidboot."sv;
 
 static void ProcessKernelCmdline() {
-    ImportKernelCmdline([&](const std::string& key, const std::string& value) {
+    android::fs_mgr::ImportKernelCmdline([&](const std::string& key, const std::string& value) {
         if (StartsWith(key, ANDROIDBOOT_PREFIX)) {
             InitPropertySet("ro.boot." + key.substr(ANDROIDBOOT_PREFIX.size()), value);
         }
diff --git a/init/selinux.cpp b/init/selinux.cpp
index 6fb028b169fe..f34474f85093 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -101,23 +101,14 @@ namespace {
 enum EnforcingStatus { SELINUX_PERMISSIVE, SELINUX_ENFORCING };
 
 EnforcingStatus StatusFromProperty() {
-    EnforcingStatus status = SELINUX_ENFORCING;
-
-    ImportKernelCmdline([&](const std::string& key, const std::string& value) {
-        if (key == "androidboot.selinux" && value == "permissive") {
-            status = SELINUX_PERMISSIVE;
-        }
-    });
-
-    if (status == SELINUX_ENFORCING) {
-        std::string value;
-        if (android::fs_mgr::GetBootconfig("androidboot.selinux", &value) &&
-            value == "permissive") {
-            status = SELINUX_PERMISSIVE;
-        }
+    std::string value;
+    if (android::fs_mgr::GetKernelCmdline("androidboot.selinux", &value) && value == "permissive") {
+        return SELINUX_PERMISSIVE;
     }
-
-    return status;
+    if (android::fs_mgr::GetBootconfig("androidboot.selinux", &value) && value == "permissive") {
+        return SELINUX_PERMISSIVE;
+    }
+    return SELINUX_ENFORCING;
 }
 
 bool IsEnforcing() {
diff --git a/init/util.cpp b/init/util.cpp
index b34d45d70f42..e760a5969f5a 100644
--- a/init/util.cpp
+++ b/init/util.cpp
@@ -242,18 +242,6 @@ int wait_for_file(const char* filename, std::chrono::nanoseconds timeout) {
     return -1;
 }
 
-void ImportKernelCmdline(const std::function<void(const std::string&, const std::string&)>& fn) {
-    std::string cmdline;
-    android::base::ReadFileToString("/proc/cmdline", &cmdline);
-
-    for (const auto& entry : android::base::Split(android::base::Trim(cmdline), " ")) {
-        std::vector<std::string> pieces = android::base::Split(entry, "=");
-        if (pieces.size() == 2) {
-            fn(pieces[0], pieces[1]);
-        }
-    }
-}
-
 bool make_dir(const std::string& path, mode_t mode) {
     std::string secontext;
     if (SelabelLookupFileContext(path, mode, &secontext) && !secontext.empty()) {
diff --git a/init/util.h b/init/util.h
index 0b0ef632b109..2d021827165f 100644
--- a/init/util.h
+++ b/init/util.h
@@ -53,8 +53,7 @@ Result<void> WriteFile(const std::string& path, const std::string& content);
 Result<uid_t> DecodeUid(const std::string& name);
 
 bool mkdir_recursive(const std::string& pathname, mode_t mode);
-int wait_for_file(const char *filename, std::chrono::nanoseconds timeout);
-void ImportKernelCmdline(const std::function<void(const std::string&, const std::string&)>&);
+int wait_for_file(const char* filename, std::chrono::nanoseconds timeout);
 bool make_dir(const std::string& path, mode_t mode);
 bool is_dir(const char* pathname);
 Result<std::string> ExpandProps(const std::string& src);

From d865493814bb172d7100920b1cbce0b6ccfa17e7 Mon Sep 17 00:00:00 2001
From: "Ray-cy.lee" <ray-cy.lee@mediatek.com>
Date: Mon, 31 Jul 2023 20:00:43 +0800
Subject: [PATCH 0261/1487] Add snapuserd_ramdisk execute permission

Bug: 294192189
Test: th
Change-Id: I42ff176ffb7eae0ac05e7f9cc54090c82df982b5
---
 libcutils/fs_config.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libcutils/fs_config.cpp b/libcutils/fs_config.cpp
index f90a1bc3ca98..26ac576070fc 100644
--- a/libcutils/fs_config.cpp
+++ b/libcutils/fs_config.cpp
@@ -214,6 +214,7 @@ static const struct fs_path_config android_files[] = {
 #endif
     { 00755, AID_ROOT,      AID_ROOT,      0, "first_stage_ramdisk/system/bin/resize2fs" },
     { 00755, AID_ROOT,      AID_ROOT,      0, "first_stage_ramdisk/system/bin/snapuserd" },
+    { 00755, AID_ROOT,      AID_ROOT,      0, "first_stage_ramdisk/system/bin/snapuserd_ramdisk" },
     { 00755, AID_ROOT,      AID_ROOT,      0, "first_stage_ramdisk/system/bin/tune2fs" },
     { 00755, AID_ROOT,      AID_ROOT,      0, "first_stage_ramdisk/system/bin/fsck.f2fs" },
     // generic defaults

From e54c0be60f5aa32ce06f4366a3c55db45c41093c Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Wed, 2 Aug 2023 15:18:35 +0800
Subject: [PATCH 0262/1487] libfstab: Optimize out C++ object copy

* Edit / truncate string objects in-place, don't copy a temporary string
  object just for storing intermeidate results.
* Replace copy construct semantics with move semantics.
* Use range-based std::vector::insert() to move whole range.

Bug: 293695109
Test: CtsFsMgrTestCases
Change-Id: I5437303ba9900dbad3276a981413cba138f17157
---
 fs_mgr/libfstab/boot_config.cpp | 10 +++++-----
 fs_mgr/libfstab/fstab.cpp       |  8 ++++----
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/fs_mgr/libfstab/boot_config.cpp b/fs_mgr/libfstab/boot_config.cpp
index ae537b5d2560..b21495ecd9e7 100644
--- a/fs_mgr/libfstab/boot_config.cpp
+++ b/fs_mgr/libfstab/boot_config.cpp
@@ -122,10 +122,8 @@ void ImportKernelCmdlineFromString(const std::string& cmdline,
             if ((found = cmdline.find(quote, found + 1)) == cmdline.npos) break;
             ++found;
         }
-        std::string piece;
-        auto source = cmdline.substr(base, found - base);
-        std::remove_copy(source.begin(), source.end(),
-                         std::back_insert_iterator<std::string>(piece), quote);
+        std::string piece = cmdline.substr(base, found - base);
+        piece.erase(std::remove(piece.begin(), piece.end(), quote), piece.end());
         auto equal_sign = piece.find('=');
         if (equal_sign == piece.npos) {
             if (!piece.empty()) {
@@ -133,7 +131,9 @@ void ImportKernelCmdlineFromString(const std::string& cmdline,
                 fn(std::move(piece), "");
             }
         } else {
-            fn(piece.substr(0, equal_sign), piece.substr(equal_sign + 1));
+            std::string value = piece.substr(equal_sign + 1);
+            piece.resize(equal_sign);
+            fn(std::move(piece), std::move(value));
         }
         if (found == cmdline.npos) break;
         base = found + 1;
diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index 21b002434391..32460b17b5e1 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -831,9 +831,8 @@ bool ReadDefaultFstab(Fstab* fstab) {
     Fstab default_fstab;
     const std::string default_fstab_path = GetFstabPath();
     if (!default_fstab_path.empty() && ReadFstabFromFile(default_fstab_path, &default_fstab)) {
-        for (auto&& entry : default_fstab) {
-            fstab->emplace_back(std::move(entry));
-        }
+        fstab->insert(fstab->end(), std::make_move_iterator(default_fstab.begin()),
+                      std::make_move_iterator(default_fstab.end()));
     } else {
         LINFO << __FUNCTION__ << "(): failed to find device default fstab";
     }
@@ -879,7 +878,8 @@ std::set<std::string> GetBootDevices() {
     const std::string dt_file_name = GetAndroidDtDir() + "boot_devices";
     if (GetKernelCmdline("androidboot.boot_devices", &value) || ReadDtFile(dt_file_name, &value)) {
         auto boot_devices_list = Split(value, ",");
-        return {boot_devices_list.begin(), boot_devices_list.end()};
+        return {std::make_move_iterator(boot_devices_list.begin()),
+                std::make_move_iterator(boot_devices_list.end())};
     }
 
     ImportKernelCmdline([&](std::string key, std::string value) {

From 59442132d1c16b0350aa70ec56684d4605a06bd0 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Thu, 3 Aug 2023 01:51:57 +0800
Subject: [PATCH 0263/1487] remount: Replace ServiceManager::getService with
 checkService

Address this build log message:
```
[ 18% 2/11] //system/core/fs_mgr:remount clang++ fs_mgr_remount.cpp
system/core/fs_mgr/fs_mgr_remount.cpp:133:31: warning: 'getService' is deprecated: this polls for 5s, prefer waitForService or checkService [-Wdeprecated-declarations]
        if (auto binder = sm->getService(android::String16("vold"))) {
                              ^
```

Bug: 293695109
Test: adb-remount-test
Change-Id: I3b5c7d338e9307dee58edeb0f6a00ba9a73d46f6
---
 fs_mgr/fs_mgr_remount.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/fs_mgr/fs_mgr_remount.cpp b/fs_mgr/fs_mgr_remount.cpp
index 4c458283a537..4b3a5d3ea0fe 100644
--- a/fs_mgr/fs_mgr_remount.cpp
+++ b/fs_mgr/fs_mgr_remount.cpp
@@ -128,12 +128,11 @@ class MyLogger {
 }
 
 static android::sp<android::os::IVold> GetVold() {
+    auto sm = android::defaultServiceManager();
     while (true) {
-        if (auto sm = android::defaultServiceManager()) {
-            if (auto binder = sm->getService(android::String16("vold"))) {
-                if (auto vold = android::interface_cast<android::os::IVold>(binder)) {
-                    return vold;
-                }
+        if (auto binder = sm->checkService(android::String16("vold"))) {
+            if (auto vold = android::interface_cast<android::os::IVold>(binder)) {
+                return vold;
             }
         }
         std::this_thread::sleep_for(2s);

From fbc5f597377ef2955fa8a801aac040d3ff1b595d Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 2 Aug 2023 19:53:25 -0700
Subject: [PATCH 0264/1487] libsnapshot: Fix missing return keyword in error
 path.

Bug: 288273605
Test: vts_libsnapshot_test
Change-Id: I0bee5ee1ebfb61f17d2a495440048d02e2c347b1
---
 fs_mgr/libsnapshot/include/libsnapshot/snapshot.h |  2 +-
 fs_mgr/libsnapshot/snapshot.cpp                   | 10 ++++------
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index df532ee2152a..c056a19f83a1 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -624,7 +624,7 @@ class SnapshotManager final : public ISnapshotManager {
     bool CollapseSnapshotDevice(LockedFile* lock, const std::string& name,
                                 const SnapshotStatus& status);
 
-    struct MergeResult {
+    struct [[nodiscard]] MergeResult {
         explicit MergeResult(UpdateState state,
                              MergeFailureCode failure_code = MergeFailureCode::Ok)
             : state(state), failure_code(failure_code) {}
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 09d35cff104d..86ff5f710da7 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -1248,14 +1248,12 @@ auto SnapshotManager::CheckTargetMergeState(LockedFile* lock, const std::string&
            GetMetadataPartitionState(*current_metadata, name) == MetadataPartitionState::Updated);
 
     if (UpdateUsesUserSnapshots(lock)) {
-        std::string merge_status;
-        if (EnsureSnapuserdConnected()) {
-            // Query the snapshot status from the daemon
-            merge_status = snapuserd_client_->QuerySnapshotStatus(name);
-        } else {
-            MergeResult(UpdateState::MergeFailed, MergeFailureCode::QuerySnapshotStatus);
+        if (!EnsureSnapuserdConnected()) {
+            return MergeResult(UpdateState::MergeFailed, MergeFailureCode::QuerySnapshotStatus);
         }
 
+        // Query the snapshot status from the daemon
+        const auto merge_status = snapuserd_client_->QuerySnapshotStatus(name);
         if (merge_status == "snapshot-merge-failed") {
             return MergeResult(UpdateState::MergeFailed, MergeFailureCode::UnknownTargetType);
         }

From 355ae4154efa87bc791a83ceb8fe90998165ad2b Mon Sep 17 00:00:00 2001
From: Cole Faust <colefaust@google.com>
Date: Thu, 3 Aug 2023 10:54:59 -0700
Subject: [PATCH 0265/1487] Remove references to the pdk product variable

pdk is deprecated and has no effect as of aosp/1319667.

Test: Presubmits
Change-Id: I78d7afaaa71b93e575dcd5c20716ffb295b9f522
---
 bootstat/Android.bp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/bootstat/Android.bp b/bootstat/Android.bp
index ca59ef39bb95..0c8760c2d1b4 100644
--- a/bootstat/Android.bp
+++ b/bootstat/Android.bp
@@ -72,9 +72,6 @@ cc_binary {
     ],
     init_rc: ["bootstat.rc"],
     product_variables: {
-        pdk: {
-            enabled: false,
-        },
         debuggable: {
             init_rc: ["bootstat-debug.rc"],
         },

From 21a071661320806bd521f4d5e6259601627fd531 Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Tue, 25 Jul 2023 12:57:45 -0700
Subject: [PATCH 0266/1487] Remove gettid declaration from cutils

Bug: 289414897
Test: it builds
Change-Id: I22d93406cf065c0e3c7d94e800763974d228ee21
---
 libcutils/include/cutils/threads.h | 15 ---------------
 libcutils/threads.cpp              |  6 ++++--
 2 files changed, 4 insertions(+), 17 deletions(-)

diff --git a/libcutils/include/cutils/threads.h b/libcutils/include/cutils/threads.h
index 18861840e28d..92564b8db9a7 100644
--- a/libcutils/include/cutils/threads.h
+++ b/libcutils/include/cutils/threads.h
@@ -23,18 +23,3 @@
 #else
 #include <pthread.h>
 #endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-//
-// Deprecated: use android::base::GetThreadId instead, which doesn't truncate on Mac/Windows.
-//
-#if !defined(__GLIBC__) || __GLIBC__ >= 2 && __GLIBC_MINOR__ < 30
-extern pid_t gettid();
-#endif
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/libcutils/threads.cpp b/libcutils/threads.cpp
index 2638720847d8..cca50c191c14 100644
--- a/libcutils/threads.cpp
+++ b/libcutils/threads.cpp
@@ -14,11 +14,13 @@
 ** limitations under the License.
 */
 
-#include <cutils/threads.h>
+#include <sys/types.h>
 
 #if defined(__APPLE__)
+#include <pthread.h>
 #include <stdint.h>
 #elif defined(__linux__)
+#include <pthread.h>
 #include <syscall.h>
 #include <unistd.h>
 #elif defined(_WIN32)
@@ -29,7 +31,7 @@
 // No definition needed for Android because we'll just pick up bionic's copy.
 // No definition needed for Glibc >= 2.30 because it exposes its own copy.
 #else
-pid_t gettid() {
+extern "C" pid_t gettid() {
 #if defined(__APPLE__)
   uint64_t tid;
   pthread_threadid_np(NULL, &tid);

From d22098f65d93a394f22139459eef717058f285f3 Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Tue, 25 Jul 2023 13:16:06 -0700
Subject: [PATCH 0267/1487] Remove sub-includes from libcutils/threads.h

This will drop any incentive to use this header

Bug: 289414897
Test: it builds
Change-Id: I3d7f56ac027f59794cb4cf533847c5fda5529906
---
 libcutils/include/cutils/threads.h | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/libcutils/include/cutils/threads.h b/libcutils/include/cutils/threads.h
index 92564b8db9a7..9bc3429bec29 100644
--- a/libcutils/include/cutils/threads.h
+++ b/libcutils/include/cutils/threads.h
@@ -13,13 +13,3 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-#pragma once
-
-#include  <sys/types.h>
-
-#if defined(_WIN32)
-#include <windows.h>
-#else
-#include <pthread.h>
-#endif

From 8b0160868eefc2997155906aa361470fb9a6c9ab Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Fri, 28 Jul 2023 12:37:10 -0700
Subject: [PATCH 0268/1487] Remove gettid symbol from cutils

Bug: 289414897
Test: it builds
Change-Id: I3b4c8b35dbf47e41d1fb0912fedc05e6545bd3d7
---
 libcutils/Android.bp  |  1 -
 libcutils/threads.cpp | 45 -------------------------------------------
 2 files changed, 46 deletions(-)
 delete mode 100644 libcutils/threads.cpp

diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index 92486e3357a8..55a8694ffc31 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -162,7 +162,6 @@ cc_library {
         "properties.cpp",
         "record_stream.cpp",
         "strlcpy.c",
-        "threads.cpp",
     ],
 
     target: {
diff --git a/libcutils/threads.cpp b/libcutils/threads.cpp
deleted file mode 100644
index cca50c191c14..000000000000
--- a/libcutils/threads.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
-** Copyright (C) 2007, 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 <sys/types.h>
-
-#if defined(__APPLE__)
-#include <pthread.h>
-#include <stdint.h>
-#elif defined(__linux__)
-#include <pthread.h>
-#include <syscall.h>
-#include <unistd.h>
-#elif defined(_WIN32)
-#include <windows.h>
-#endif
-
-#if defined(__BIONIC__) || defined(__GLIBC__) && __GLIBC_MINOR__ >= 30
-// No definition needed for Android because we'll just pick up bionic's copy.
-// No definition needed for Glibc >= 2.30 because it exposes its own copy.
-#else
-extern "C" pid_t gettid() {
-#if defined(__APPLE__)
-  uint64_t tid;
-  pthread_threadid_np(NULL, &tid);
-  return tid;
-#elif defined(__linux__)
-  return syscall(__NR_gettid);
-#elif defined(_WIN32)
-  return GetCurrentThreadId();
-#endif
-}
-#endif

From 75c5deed5264fed76ef57efa1ad9e25e3b8ce944 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 30 Jun 2023 10:22:34 -0700
Subject: [PATCH 0269/1487] snapuserd: Rename libsnapshot_snapuserd to
 libsnapuserd_client.

We don't need this on the host, since the host will not be running
snapuserd as a server. Rename it for clarity and remove it where we can.

Bug: 288273605
Test: snapuserd_test
Change-Id: I679ef668a89411c670fea8d3b758bde589623548
---
 fs_mgr/libfiemap/Android.bp             |  1 +
 fs_mgr/libsnapshot/Android.bp           |  2 +-
 fs_mgr/libsnapshot/snapuserd/Android.bp | 15 +++++++++------
 3 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/fs_mgr/libfiemap/Android.bp b/fs_mgr/libfiemap/Android.bp
index ddda648d8e88..c8d575630262 100644
--- a/fs_mgr/libfiemap/Android.bp
+++ b/fs_mgr/libfiemap/Android.bp
@@ -24,6 +24,7 @@ cc_library_headers {
     vendor_ramdisk_available: true,
     recovery_available: true,
     export_include_dirs: ["include"],
+    host_supported: true,
 }
 
 filegroup {
diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index bd017ff10bfa..04b5a021ad5f 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -44,7 +44,7 @@ cc_defaults {
         "libext2_uuid",
         "libext4_utils",
         "libfstab",
-        "libsnapshot_snapuserd",
+        "libsnapuserd_client",
         "libz",
     ],
     header_libs: [
diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index a9b96e2efc7f..20eef71af51d 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -19,7 +19,7 @@ package {
 }
 
 cc_defaults {
-    name: "libsnapshot_snapuserd_defaults",
+    name: "libsnapuserd_client_defaults",
     defaults: [
         "fs_mgr_defaults",
     ],
@@ -33,10 +33,10 @@ cc_defaults {
 }
 
 cc_library_static {
-    name: "libsnapshot_snapuserd",
+    name: "libsnapuserd_client",
     defaults: [
         "fs_mgr_defaults",
-        "libsnapshot_snapuserd_defaults",
+        "libsnapuserd_client_defaults",
     ],
     recovery_available: true,
     static_libs: [
@@ -80,6 +80,7 @@ cc_library_static {
         "liburing",
     ],
     include_dirs: ["bionic/libc/kernel"],
+    export_include_dirs: ["include"],
     header_libs: [
         "libstorage_literals_headers",
     ],
@@ -108,8 +109,8 @@ cc_defaults {
         "libgflags",
         "liblog",
         "libsnapshot_cow",
-        "libsnapshot_snapuserd",
         "libsnapuserd",
+        "libsnapuserd_client",
         "libz",
         "liblz4",
         "libext4_utils",
@@ -144,6 +145,9 @@ cc_binary {
     init_rc: [
         "snapuserd.rc",
     ],
+    static_libs: [
+        "libsnapuserd_client",
+    ],
     ramdisk_available: false,
     vendor_ramdisk_available: true,
 }
@@ -186,7 +190,7 @@ cc_test {
         "libbrotli",
         "libgtest",
         "libsnapshot_cow",
-        "libsnapshot_snapuserd",
+        "libsnapuserd_client",
         "libcutils_sockets",
         "libz",
         "libfs_mgr",
@@ -226,7 +230,6 @@ cc_test {
         "libgflags",
         "libgtest",
         "libsnapshot_cow",
-        "libsnapshot_snapuserd",
         "libsnapuserd",
         "liburing",
         "libz",

From c132bf80aec74e362826e895c25d9eaf69a08cb9 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 30 Jun 2023 10:24:37 -0700
Subject: [PATCH 0270/1487] snapuserd: Remove dependence on libfs_mgr.

The only function we use from libfs_mgr is WaitForFile, so factor that
out into libfs_mgr_file_wait. libfs_mgr has too much dependence on AOSP
internals to build on the host.

Bug: 288273605
Test: builds
Change-Id: I8e5eb4075ae01b9ca64074422171a487179e7943
---
 fs_mgr/Android.bp                       | 19 +++++++++++++++++++
 fs_mgr/libsnapshot/snapuserd/Android.bp | 12 ++++++++----
 2 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/Android.bp b/fs_mgr/Android.bp
index 4e4d20edc516..87db98b0877d 100644
--- a/fs_mgr/Android.bp
+++ b/fs_mgr/Android.bp
@@ -171,6 +171,25 @@ cc_library {
     ],
 }
 
+cc_library_static {
+    name: "libfs_mgr_file_wait",
+    defaults: ["fs_mgr_defaults"],
+    export_include_dirs: ["include"],
+    cflags: [
+        "-D_FILE_OFFSET_BITS=64",
+    ],
+    srcs: [
+        "file_wait.cpp",
+    ],
+    shared_libs: [
+        "libbase",
+    ],
+    host_supported: true,
+    ramdisk_available: true,
+    vendor_ramdisk_available: true,
+    recovery_available: true,
+}
+
 cc_binary {
     name: "remount",
     defaults: ["fs_mgr_defaults"],
diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 20eef71af51d..dddc9075771d 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -41,7 +41,7 @@ cc_library_static {
     recovery_available: true,
     static_libs: [
         "libcutils_sockets",
-        "libfs_mgr",
+        "libfs_mgr_file_wait",
     ],
     shared_libs: [
         "libbase",
@@ -75,6 +75,7 @@ cc_library_static {
     static_libs: [
         "libbase",
         "libdm",
+        "libext2_uuid",
         "libext4_utils",
         "libsnapshot_cow",
         "liburing",
@@ -105,7 +106,8 @@ cc_defaults {
         "libbrotli",
         "libcutils_sockets",
         "libdm",
-        "libfs_mgr",
+        "libext2_uuid",
+        "libfs_mgr_file_wait",
         "libgflags",
         "liblog",
         "libsnapshot_cow",
@@ -193,9 +195,10 @@ cc_test {
         "libsnapuserd_client",
         "libcutils_sockets",
         "libz",
-        "libfs_mgr",
         "libdm",
+        "libext2_uuid",
         "libext4_utils",
+        "libfs_mgr_file_wait",
     ],
     header_libs: [
         "libstorage_literals_headers",
@@ -225,8 +228,9 @@ cc_test {
         "libbrotli",
         "libcutils_sockets",
         "libdm",
+        "libext2_uuid",
         "libext4_utils",
-        "libfs_mgr",
+        "libfs_mgr_file_wait",
         "libgflags",
         "libgtest",
         "libsnapshot_cow",

From 95f46b07580e484d8c7b091c162e1fc6322b6957 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 28 Jun 2023 10:34:30 -0700
Subject: [PATCH 0271/1487] snapuserd: Split Tempdevice into a separate file.

Bug: 288273605
Test: snapuserd_test
Change-Id: I3f1b01de8986d22de03bb31355ec09fe48c9204b
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |  5 +-
 .../snapuserd/testing/temp_device.h           | 72 +++++++++++++++++++
 .../user-space-merge/snapuserd_test.cpp       | 44 +-----------
 3 files changed, 77 insertions(+), 44 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/testing/temp_device.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index dddc9075771d..f63579b9b372 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -238,7 +238,10 @@ cc_test {
         "liburing",
         "libz",
     ],
-    include_dirs: ["bionic/libc/kernel"],
+    include_dirs: [
+        "bionic/libc/kernel",
+        ".",
+    ],
     header_libs: [
         "libstorage_literals_headers",
         "libfiemap_headers",
diff --git a/fs_mgr/libsnapshot/snapuserd/testing/temp_device.h b/fs_mgr/libsnapshot/snapuserd/testing/temp_device.h
new file mode 100644
index 000000000000..2a6d3eaac5e4
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/testing/temp_device.h
@@ -0,0 +1,72 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <chrono>
+#include <string>
+
+#include <libdm/dm.h>
+
+namespace android {
+namespace snapshot {
+
+using android::dm::DeviceMapper;
+using android::dm::DmTable;
+
+class Tempdevice {
+  public:
+    Tempdevice(const std::string& name, const DmTable& table)
+        : dm_(DeviceMapper::Instance()), name_(name), valid_(false) {
+        valid_ = dm_.CreateDevice(name, table, &path_, std::chrono::seconds(5));
+    }
+    Tempdevice(Tempdevice&& other) noexcept
+        : dm_(other.dm_), name_(other.name_), path_(other.path_), valid_(other.valid_) {
+        other.valid_ = false;
+    }
+    ~Tempdevice() {
+        if (valid_) {
+            dm_.DeleteDeviceIfExists(name_);
+        }
+    }
+    bool Destroy() {
+        if (!valid_) {
+            return true;
+        }
+        valid_ = false;
+        return dm_.DeleteDeviceIfExists(name_);
+    }
+    const std::string& path() const { return path_; }
+    const std::string& name() const { return name_; }
+    bool valid() const { return valid_; }
+
+    Tempdevice(const Tempdevice&) = delete;
+    Tempdevice& operator=(const Tempdevice&) = delete;
+
+    Tempdevice& operator=(Tempdevice&& other) noexcept {
+        name_ = other.name_;
+        valid_ = other.valid_;
+        other.valid_ = false;
+        return *this;
+    }
+
+  private:
+    DeviceMapper& dm_;
+    std::string name_;
+    std::string path_;
+    bool valid_;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index efe0c1443215..f3c3f671199d 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -41,6 +41,7 @@
 
 #include "handler_manager.h"
 #include "snapuserd_core.h"
+#include "testing/temp_device.h"
 
 DEFINE_string(force_config, "", "Force testing mode with iouring disabled");
 
@@ -54,49 +55,6 @@ using namespace std::chrono_literals;
 using namespace android::dm;
 using namespace std;
 
-class Tempdevice {
-  public:
-    Tempdevice(const std::string& name, const DmTable& table)
-        : dm_(DeviceMapper::Instance()), name_(name), valid_(false) {
-        valid_ = dm_.CreateDevice(name, table, &path_, std::chrono::seconds(5));
-    }
-    Tempdevice(Tempdevice&& other) noexcept
-        : dm_(other.dm_), name_(other.name_), path_(other.path_), valid_(other.valid_) {
-        other.valid_ = false;
-    }
-    ~Tempdevice() {
-        if (valid_) {
-            dm_.DeleteDeviceIfExists(name_);
-        }
-    }
-    bool Destroy() {
-        if (!valid_) {
-            return true;
-        }
-        valid_ = false;
-        return dm_.DeleteDeviceIfExists(name_);
-    }
-    const std::string& path() const { return path_; }
-    const std::string& name() const { return name_; }
-    bool valid() const { return valid_; }
-
-    Tempdevice(const Tempdevice&) = delete;
-    Tempdevice& operator=(const Tempdevice&) = delete;
-
-    Tempdevice& operator=(Tempdevice&& other) noexcept {
-        name_ = other.name_;
-        valid_ = other.valid_;
-        other.valid_ = false;
-        return *this;
-    }
-
-  private:
-    DeviceMapper& dm_;
-    std::string name_;
-    std::string path_;
-    bool valid_;
-};
-
 class SnapuserdTest : public ::testing::Test {
   public:
     bool SetupDefault();

From 48d1c39da7663561b54d8244e2b967fc984d41ea Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 5 Jul 2023 13:35:12 -0700
Subject: [PATCH 0272/1487] snapuserd: Move GetNumSectors call to
 snapuserd_server.

Calling this in snapuserd_core fails when the base path is a regular
file. Since the value is only read once, just call it from
snapuserd_server instead, which also means we don't have to add an
S_ISBLK check here.

Bug: 288273605
Test: snapuserd_test
Change-Id: Ic26bf807b24611f2d97829d1b4eb1d0ede2feb6a
---
 .../include/snapuserd/snapuserd_kernel.h      |  1 +
 .../user-space-merge/snapuserd_core.cpp       | 30 ++++++++++---------
 .../user-space-merge/snapuserd_core.h         |  4 +--
 .../user-space-merge/snapuserd_server.cpp     |  7 ++++-
 .../user-space-merge/snapuserd_test.cpp       |  2 ++
 5 files changed, 26 insertions(+), 18 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_kernel.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_kernel.h
index 46952c4ed98e..0d83f4789625 100644
--- a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_kernel.h
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_kernel.h
@@ -40,6 +40,7 @@ static constexpr uint32_t SNAPSHOT_VALID = 1;
  * multiple of 512 bytes. Hence these two constants.
  */
 static constexpr uint32_t SECTOR_SHIFT = 9;
+static constexpr uint64_t SECTOR_SIZE = (1ULL << SECTOR_SHIFT);
 
 static constexpr size_t BLOCK_SZ = 4096;
 static constexpr size_t BLOCK_SHIFT = (__builtin_ffs(BLOCK_SZ) - 1);
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 2dd2ec09d6ce..12d095afec05 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -280,20 +280,6 @@ bool SnapshotHandler::InitCowDevice() {
         return false;
     }
 
-    unique_fd fd(TEMP_FAILURE_RETRY(open(base_path_merge_.c_str(), O_RDONLY | O_CLOEXEC)));
-    if (fd < 0) {
-        SNAP_LOG(ERROR) << "Cannot open block device";
-        return false;
-    }
-
-    uint64_t dev_sz = get_block_device_size(fd.get());
-    if (!dev_sz) {
-        SNAP_LOG(ERROR) << "Failed to find block device size: " << base_path_merge_;
-        return false;
-    }
-
-    num_sectors_ = dev_sz >> SECTOR_SHIFT;
-
     return ReadMetadata();
 }
 
@@ -460,5 +446,21 @@ void SnapshotHandler::FreeResources() {
     merge_thread_ = nullptr;
 }
 
+uint64_t SnapshotHandler::GetNumSectors() const {
+    unique_fd fd(TEMP_FAILURE_RETRY(open(base_path_merge_.c_str(), O_RDONLY | O_CLOEXEC)));
+    if (fd < 0) {
+        SNAP_LOG(ERROR) << "Cannot open base path: " << base_path_merge_;
+        return false;
+    }
+
+    uint64_t dev_sz = get_block_device_size(fd.get());
+    if (!dev_sz) {
+        SNAP_LOG(ERROR) << "Failed to find block device size: " << base_path_merge_;
+        return false;
+    }
+
+    return dev_sz / SECTOR_SIZE;
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index cdc38c01665e..5fe0a709af8e 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -109,7 +109,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
 
     const std::string& GetControlDevicePath() { return control_device_; }
     const std::string& GetMiscName() { return misc_name_; }
-    const uint64_t& GetNumSectors() { return num_sectors_; }
+    uint64_t GetNumSectors() const;
     const bool& IsAttached() const { return attached_; }
     void AttachControlDevice() { attached_ = true; }
 
@@ -202,8 +202,6 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
 
     unique_fd cow_fd_;
 
-    uint64_t num_sectors_;
-
     std::unique_ptr<CowReader> reader_;
 
     // chunk_vec stores the pseudo mapping of sector
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index c953f1a053bd..f2585eab1d81 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -130,7 +130,12 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
             return Sendmsg(fd, "fail");
         }
 
-        auto retval = "success," + std::to_string(handler->snapuserd()->GetNumSectors());
+        auto num_sectors = handler->snapuserd()->GetNumSectors();
+        if (!num_sectors) {
+            return Sendmsg(fd, "fail");
+        }
+
+        auto retval = "success," + std::to_string(num_sectors);
         return Sendmsg(fd, retval);
     } else if (cmd == "start") {
         // Message format:
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index f3c3f671199d..16f9ed87f7ac 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -540,7 +540,9 @@ void SnapuserdTest::InitCowDevice() {
                                  base_loop_->device(), 1, use_iouring, false);
     ASSERT_NE(handler, nullptr);
     ASSERT_NE(handler->snapuserd(), nullptr);
+#ifdef __ANDROID__
     ASSERT_NE(handler->snapuserd()->GetNumSectors(), 0);
+#endif
 }
 
 void SnapuserdTest::SetDeviceControlName() {

From ed34b6e2324122f5fe02f4d3b873ac9888b8ef47 Mon Sep 17 00:00:00 2001
From: Snehal <snehalreddy@google.com>
Date: Fri, 30 Jun 2023 14:49:48 +0000
Subject: [PATCH 0273/1487] Coverage library on the NS side for the coverage
 controller

Bug: 289520358

Change-Id: I6c2c0e5db9e8d9a0edec93d2fb123d185c7c4416
---
 trusty/line-coverage/Android.bp               |  36 ++++
 trusty/line-coverage/coverage.cpp             | 191 ++++++++++++++++++
 .../include/trusty/line-coverage/coverage.h   |  61 ++++++
 .../include/trusty/line-coverage/tipc.h       | 140 +++++++++++++
 .../include/trusty/line-coverage/uuid.h       |  37 ++++
 5 files changed, 465 insertions(+)
 create mode 100644 trusty/line-coverage/Android.bp
 create mode 100644 trusty/line-coverage/coverage.cpp
 create mode 100644 trusty/line-coverage/include/trusty/line-coverage/coverage.h
 create mode 100644 trusty/line-coverage/include/trusty/line-coverage/tipc.h
 create mode 100644 trusty/line-coverage/include/trusty/line-coverage/uuid.h

diff --git a/trusty/line-coverage/Android.bp b/trusty/line-coverage/Android.bp
new file mode 100644
index 000000000000..36a73aada8cc
--- /dev/null
+++ b/trusty/line-coverage/Android.bp
@@ -0,0 +1,36 @@
+// Copyright (C) 2023 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.
+
+package {
+    default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+cc_library {
+    name: "libtrusty_line_coverage",
+    vendor_available: true,
+    srcs: [
+        "coverage.cpp",
+    ],
+    export_include_dirs: [
+        "include",
+    ],
+    shared_libs: [
+        "libbase",
+        "libext2_uuid",
+        "liblog",
+        "libdmabufheap",
+        "libtrusty",
+    ],
+}
+
diff --git a/trusty/line-coverage/coverage.cpp b/trusty/line-coverage/coverage.cpp
new file mode 100644
index 000000000000..57b702510da7
--- /dev/null
+++ b/trusty/line-coverage/coverage.cpp
@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2023 The Android Open Sourete 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.
+ */
+
+#define LOG_TAG "line-coverage"
+
+#include <BufferAllocator/BufferAllocator.h>
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <assert.h>
+#include <log/log.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/uio.h>
+#include <trusty/line-coverage/coverage.h>
+#include <trusty/line-coverage/tipc.h>
+#include <trusty/tipc.h>
+#include <iostream>
+
+#define LINE_COVERAGE_CLIENT_PORT "com.android.trusty.linecoverage.client"
+
+struct control {
+    /* Written by controller, read by instrumented TA */
+    uint64_t        cntrl_flags;
+
+    /* Written by instrumented TA, read by controller */
+    uint64_t        oper_flags;
+    uint64_t        write_buffer_start_count;
+    uint64_t        write_buffer_complete_count;
+};
+
+namespace android {
+namespace trusty {
+namespace line_coverage {
+
+using ::android::base::ErrnoError;
+using ::android::base::Error;
+using ::std::string;
+
+static inline uintptr_t RoundPageUp(uintptr_t val) {
+    return (val + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
+}
+
+CoverageRecord::CoverageRecord(string tipc_dev, struct uuid* uuid)
+    : tipc_dev_(std::move(tipc_dev)),
+      coverage_srv_fd_(-1),
+      uuid_(*uuid),
+      record_len_(0),
+      shm_(NULL),
+      shm_len_(0) {}
+
+CoverageRecord::~CoverageRecord() {
+    if (shm_) {
+        munmap((void*)shm_, shm_len_);
+    }
+}
+
+volatile void *CoverageRecord::getShm() {
+    if(!IsOpen()) {
+        fprintf(stderr, "Warning! SHM is NULL!\n");
+    }
+    return shm_;
+}
+
+Result<void> CoverageRecord::Rpc(struct line_coverage_client_req* req, \
+                                  int req_fd, \
+                                  struct line_coverage_client_resp* resp) {
+    int rc;
+
+    if (req_fd < 0) {
+        rc = write(coverage_srv_fd_, req, sizeof(*req));
+    } else {
+        iovec iov = {
+                .iov_base = req,
+                .iov_len = sizeof(*req),
+        };
+
+        trusty_shm shm = {
+                .fd = req_fd,
+                .transfer = TRUSTY_SHARE,
+        };
+
+        rc = tipc_send(coverage_srv_fd_, &iov, 1, &shm, 1);
+    }
+
+    if (rc != (int)sizeof(*req)) {
+        return ErrnoError() << "failed to send request to coverage server: ";
+    }
+
+    rc = read(coverage_srv_fd_, resp, sizeof(*resp));
+    if (rc != (int)sizeof(*resp)) {
+        return ErrnoError() << "failed to read reply from coverage server: ";
+    }
+
+    if (resp->hdr.cmd != (req->hdr.cmd | LINE_COVERAGE_CLIENT_CMD_RESP_BIT)) {
+        return ErrnoError() << "unknown response cmd: " << resp->hdr.cmd;
+    }
+
+    return {};
+}
+
+Result<void> CoverageRecord::Open(int fd) {
+    struct line_coverage_client_req req;
+    struct line_coverage_client_resp resp;
+
+    if (shm_) {
+        return {}; /* already initialized */
+    }
+
+    coverage_srv_fd_= fd;
+
+    req.hdr.cmd = LINE_COVERAGE_CLIENT_CMD_OPEN;
+    req.open_args.uuid = uuid_;
+    auto ret = Rpc(&req, -1, &resp);
+    if (!ret.ok()) {
+        return Error() << "failed to open coverage client: " << ret.error();
+    }
+    record_len_ = resp.open_args.record_len;
+    shm_len_ = RoundPageUp(record_len_);
+
+    BufferAllocator allocator;
+
+    fd = allocator.Alloc("system", shm_len_);
+    if (fd < 0) {
+        return ErrnoError() << "failed to create dmabuf of size " << shm_len_
+                            << " err code: " << fd;
+    }
+    unique_fd dma_buf(fd);
+
+    void* shm = mmap(0, shm_len_, PROT_READ | PROT_WRITE, MAP_SHARED, dma_buf, 0);
+    if (shm == MAP_FAILED) {
+        return ErrnoError() << "failed to map memfd: ";
+    }
+
+    req.hdr.cmd = LINE_COVERAGE_CLIENT_CMD_SHARE_RECORD;
+    req.share_record_args.shm_len = shm_len_;
+    ret = Rpc(&req, dma_buf, &resp);
+    if (!ret.ok()) {
+        return Error() << "failed to send shared memory: " << ret.error();
+    }
+
+    shm_ = shm;
+
+    req.hdr.cmd = LINE_COVERAGE_CLIENT_CMD_OPEN;
+    req.open_args.uuid = uuid_;
+    ret = Rpc(&req, -1, &resp);
+    if (!ret.ok()) {
+        return Error() << "failed to open coverage client: " << ret.error();
+    }
+
+    return {};
+}
+
+bool CoverageRecord::IsOpen() {
+    return shm_;
+}
+
+Result<void> CoverageRecord::SaveFile(const std::string& filename) {
+    if(!IsOpen()) {
+        return ErrnoError() << "Warning! SHM is NULL!";
+    }
+    android::base::unique_fd output_fd(TEMP_FAILURE_RETRY(creat(filename.c_str(), 00644)));
+    if (!output_fd.ok()) {
+        return ErrnoError() << "Could not open output file";
+    }
+
+    uintptr_t* begin = (uintptr_t*)((char *)shm_ + sizeof(struct control));
+    bool ret = WriteFully(output_fd, begin, record_len_);
+    if(!ret) {
+        fprintf(stderr, "Coverage write to file failed\n");
+    }
+
+    return {};
+}
+
+}  // namespace line_coverage
+}  // namespace trusty
+}  // namespace android
diff --git a/trusty/line-coverage/include/trusty/line-coverage/coverage.h b/trusty/line-coverage/include/trusty/line-coverage/coverage.h
new file mode 100644
index 000000000000..53901beb74bf
--- /dev/null
+++ b/trusty/line-coverage/include/trusty/line-coverage/coverage.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <optional>
+#include <string>
+
+#include <android-base/result.h>
+#include <android-base/unique_fd.h>
+#include <stdint.h>
+#include <trusty/line-coverage/tipc.h>
+
+namespace android {
+namespace trusty {
+namespace line_coverage {
+
+using android::base::Result;
+using android::base::unique_fd;
+
+class CoverageRecord {
+  public:
+    CoverageRecord(std::string tipc_dev, struct uuid* uuid);
+
+    ~CoverageRecord();
+    Result<void> Open(int fd);
+    bool IsOpen();
+    Result<void> SaveFile(const std::string& filename);
+    volatile void* getShm();
+
+  private:
+    Result<void> Rpc(struct line_coverage_client_req* req, \
+                      int req_fd, \
+                      struct line_coverage_client_resp* resp);
+
+    Result<std::pair<size_t, size_t>> GetRegionBounds(uint32_t region_type);
+
+    std::string tipc_dev_;
+    int coverage_srv_fd_;
+    struct uuid uuid_;
+    size_t record_len_;
+    volatile void* shm_;
+    size_t shm_len_;
+};
+
+}  // namespace line_coverage
+}  // namespace trusty
+}  // namespace android
diff --git a/trusty/line-coverage/include/trusty/line-coverage/tipc.h b/trusty/line-coverage/include/trusty/line-coverage/tipc.h
new file mode 100644
index 000000000000..20e855cbfdb6
--- /dev/null
+++ b/trusty/line-coverage/include/trusty/line-coverage/tipc.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+/* This file needs to be kept in-sync with its counterpart on Trusty side */
+
+#pragma once
+
+#include <stdint.h>
+#include <trusty/line-coverage/uuid.h>
+
+
+#define LINE_COVERAGE_CLIENT_PORT "com.android.trusty.linecoverage.client"
+
+/**
+ * enum line_coverage_client_cmd - command identifiers for coverage client interface
+ * @LINE_COVERAGE_CLIENT_CMD_RESP_BIT:     response bit set as part of response
+ * @LINE_COVERAGE_CLIENT_CMD_SHIFT:        number of bits used by response bit
+ * @LINE_COVERAGE_CLIENT_CMD_OPEN:         command to open coverage record
+ * @LINE_COVERAGE_CLIENT_CMD_SHARE_RECORD: command to register a shared memory region
+ *                                    where coverage record will be written to
+ */
+enum line_coverage_client_cmd {
+    LINE_COVERAGE_CLIENT_CMD_RESP_BIT = 1U,
+    LINE_COVERAGE_CLIENT_CMD_SHIFT = 1U,
+    LINE_COVERAGE_CLIENT_CMD_OPEN = (1U << LINE_COVERAGE_CLIENT_CMD_SHIFT),
+    LINE_COVERAGE_CLIENT_CMD_SHARE_RECORD = (2U << LINE_COVERAGE_CLIENT_CMD_SHIFT),
+    LINE_COVERAGE_CLIENT_CMD_SEND_LIST = (3U << LINE_COVERAGE_CLIENT_CMD_SHIFT),
+};
+
+/**
+ * struct line_coverage_client_hdr - header for coverage client messages
+ * @cmd: command identifier
+ *
+ * Note that no messages return a status code. Any error on the server side
+ * results in the connection being closed. So, operations can be assumed to be
+ * successful if they return a response.
+ */
+struct line_coverage_client_hdr {
+    uint32_t cmd;
+};
+
+/**
+ * struct line_coverage_client_open_req - arguments for request to open coverage
+ *                                   record
+ * @uuid: UUID of target TA
+ *
+ * There is one coverage record per TA. @uuid is used to identify both the TA
+ * and corresponding coverage record.
+ */
+struct line_coverage_client_open_req {
+    struct uuid uuid;
+};
+
+/**
+ * struct line_coverage_client_open_resp - arguments for response to open coverage
+ *                                    record
+ * @record_len: length of coverage record that will be emitted by target TA
+ *
+ * Shared memory allocated for this coverage record must larger than
+ * @record_len.
+ */
+struct line_coverage_client_open_resp {
+    uint32_t record_len;
+};
+
+/**
+ * struct line_coverage_client_send_list_resp - arguments for response to send list
+ *                                   record
+ * @uuid: UUID of TA that connected to aggregator
+ */
+struct line_coverage_client_send_list_resp {
+    struct uuid uuid;
+};
+
+/**
+ * struct line_coverage_client_send_list_resp - arguments for response to send list
+ *                                   record
+ * @index: index of the list being requested
+ */
+struct line_coverage_client_send_list_req {
+    uint32_t index;
+};
+
+/**
+ * struct line_coverage_client_share_record_req - arguments for request to share
+ *                                           memory for coverage record
+ * @shm_len: length of memory region being shared
+ *
+ * A handle to a memory region must be sent along with this message. This memory
+ * is used to store coverage record.
+ *
+ * Upon success, this memory region can be assumed to be shared between the
+ * client and target TA.
+ */
+struct line_coverage_client_share_record_req {
+    uint32_t shm_len;
+};
+
+/**
+ * struct line_coverage_client_req - structure for a coverage client request
+ * @hdr:               message header
+ * @open_args:         arguments for %COVERAGE_CLIENT_CMD_OPEN request
+ * @share_record_args: arguments for %COVERAGE_CLIENT_CMD_SHARE_RECORD request
+ * @index: arguments for %COVERAGE_CLIENT_CMD_SHARE_RECORD request
+ */
+struct line_coverage_client_req {
+    struct line_coverage_client_hdr hdr;
+    union {
+        struct line_coverage_client_open_req open_args;
+        struct line_coverage_client_share_record_req share_record_args;
+        struct line_coverage_client_send_list_req send_list_args;
+    };
+};
+
+/**
+ * struct line_coverage_client_resp - structure for a coverage client response
+ * @hdr:       message header
+ * @open_args: arguments for %COVERAGE_CLIENT_CMD_OPEN response
+ * @send_list_args: arguments for %COVERAGE_CLIENT_CMD_SHARE_RECORD response
+ */
+struct line_coverage_client_resp {
+    struct line_coverage_client_hdr hdr;
+    union {
+        struct line_coverage_client_open_resp open_args;
+        struct line_coverage_client_send_list_resp send_list_args;
+    };
+};
diff --git a/trusty/line-coverage/include/trusty/line-coverage/uuid.h b/trusty/line-coverage/include/trusty/line-coverage/uuid.h
new file mode 100644
index 000000000000..187398014767
--- /dev/null
+++ b/trusty/line-coverage/include/trusty/line-coverage/uuid.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <string.h>
+
+#define UUCMP(u1, u2) if (u1 != u2) return u1 < u2
+
+struct uuid {
+    uint32_t time_low;
+    uint16_t time_mid;
+    uint16_t time_hi_and_version;
+    uint8_t clock_seq_and_node[8];
+
+    bool operator<(const struct uuid& rhs) const
+    {
+        UUCMP(time_low, rhs.time_low);
+        UUCMP(time_mid, rhs.time_mid);
+        UUCMP(time_hi_and_version, rhs.time_hi_and_version);
+        return memcmp(clock_seq_and_node, rhs.clock_seq_and_node, 8);
+    }
+};

From 806e70bb941acc590d9bd9c1f29a77d648d5f928 Mon Sep 17 00:00:00 2001
From: Snehal <snehalreddy@google.com>
Date: Fri, 30 Jun 2023 15:23:14 +0000
Subject: [PATCH 0274/1487] Add Coverage controller

Bug: 289523068

Change-Id: I5b36c274acc7da4e2d6b9cf91409a7b1af5f0d34
---
 trusty/utils/coverage-controller/Android.bp   |  34 ++++
 .../utils/coverage-controller/controller.cpp  | 164 ++++++++++++++++++
 trusty/utils/coverage-controller/controller.h |  64 +++++++
 3 files changed, 262 insertions(+)
 create mode 100644 trusty/utils/coverage-controller/Android.bp
 create mode 100644 trusty/utils/coverage-controller/controller.cpp
 create mode 100644 trusty/utils/coverage-controller/controller.h

diff --git a/trusty/utils/coverage-controller/Android.bp b/trusty/utils/coverage-controller/Android.bp
new file mode 100644
index 000000000000..1aa88cc12086
--- /dev/null
+++ b/trusty/utils/coverage-controller/Android.bp
@@ -0,0 +1,34 @@
+// Copyright (C) 2023 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.
+
+package {
+    default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+cc_binary {
+    name: "coverage-controller",
+    vendor: true,
+
+    srcs: ["controller.cpp"],
+    shared_libs: [
+        "libc",
+        "liblog",
+        "libbase",
+        "libdmabufheap",
+    ],
+    static_libs: [
+        "libtrusty",
+        "libtrusty_line_coverage",
+    ],
+}
diff --git a/trusty/utils/coverage-controller/controller.cpp b/trusty/utils/coverage-controller/controller.cpp
new file mode 100644
index 000000000000..730c0109b0ca
--- /dev/null
+++ b/trusty/utils/coverage-controller/controller.cpp
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2023 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 <getopt.h>
+#include <trusty/line-coverage/coverage.h>
+#include <trusty/tipc.h>
+#include <array>
+#include <memory>
+#include <vector>
+
+#include "controller.h"
+
+#define READ_ONCE(x) (*((volatile __typeof__(x) *) &(x)))
+#define WRITE_ONCE(x, val) (*((volatile __typeof__(val) *) &(x)) = (val))
+
+namespace android {
+namespace trusty {
+namespace controller {
+
+using ::android::trusty::line_coverage::CoverageRecord;
+
+void Controller::run(std::string output_dir) {
+    connectCoverageServer();
+    struct control *control;
+    uint64_t complete_cnt = 0, start_cnt = 0, flags;
+
+    while(1) {
+        setUpShm();
+
+        for (int index = 0; index < record_list_.size(); index++) {
+            control = (struct control *)record_list_[index]->getShm();
+            start_cnt = READ_ONCE((control->write_buffer_start_count));
+            complete_cnt = READ_ONCE(control->write_buffer_complete_count);
+            flags = READ_ONCE(control->cntrl_flags);
+
+            if (complete_cnt != counters[index] && start_cnt == complete_cnt) {
+                WRITE_ONCE(control->cntrl_flags, FLAG_NONE);
+                std::string fmt = "/%d.%lu.profraw";
+                int sz = std::snprintf(nullptr, 0, fmt.c_str(), index, counters[index]);
+                std::string filename(sz+1, '.');
+                std::sprintf(filename.data(), fmt.c_str(), index, counters[index]);
+                filename.insert(0, output_dir);
+                android::base::Result<void> res = record_list_[index]->SaveFile(filename);
+                counters[index]++;
+            }
+            if(complete_cnt == counters[index] &&
+                !(flags & FLAG_RUN)) {
+                flags |= FLAG_RUN;
+                WRITE_ONCE(control->cntrl_flags, flags);
+            }
+        }
+    }
+}
+
+void Controller::connectCoverageServer() {
+    coverage_srv_fd = tipc_connect(TIPC_DEV, LINE_COVERAGE_CLIENT_PORT);
+    if (coverage_srv_fd < 0) {
+        fprintf(stderr, \
+                "Error: Failed to connect to Trusty coverage server: %d\n", coverage_srv_fd);
+        return;
+    }
+}
+
+void Controller::setUpShm() {
+    struct line_coverage_client_req req;
+    struct line_coverage_client_resp resp;
+    uint32_t cur_index = record_list_.size();
+    struct uuid zero_uuid = {0, 0, 0, { 0 }};
+    req.hdr.cmd = LINE_COVERAGE_CLIENT_CMD_SEND_LIST;
+    int rc = write(coverage_srv_fd, &req, sizeof(req));
+        if (rc != (int)sizeof(req)) {
+            fprintf(stderr, "failed to send request to coverage server: %d\n", rc);
+            return;
+    }
+
+    while(1) {
+        rc = read(coverage_srv_fd, &resp, sizeof(resp));
+        if (rc != (int)sizeof(resp)) {
+            fprintf(stderr, "failed to read reply from coverage server:: %d\n", rc);
+        }
+
+        if (resp.hdr.cmd == (req.hdr.cmd | LINE_COVERAGE_CLIENT_CMD_RESP_BIT)) {
+            if (!memcmp(&resp.send_list_args.uuid, &zero_uuid, sizeof(struct uuid))) {
+                break;
+            }
+            if(uuid_set_.find(resp.send_list_args.uuid) == uuid_set_.end()) {
+                uuid_set_.insert(resp.send_list_args.uuid);
+                record_list_.push_back(std::make_unique<CoverageRecord>(TIPC_DEV,
+                                                                    &resp.send_list_args.uuid));
+                counters.push_back(0);
+            }
+        }
+        else {
+            fprintf(stderr, "Unknown response header\n");
+        }
+        cur_index++;
+        req.hdr.cmd = LINE_COVERAGE_CLIENT_CMD_SEND_LIST;
+        req.send_list_args.index = cur_index;
+        int rc = write(coverage_srv_fd, &req, sizeof(req));
+        if (rc != (int)sizeof(req)) {
+            fprintf(stderr, "failed to send request to coverage server: %d\n", rc);
+        }
+    }
+
+    for(int ind = 0 ; ind < record_list_.size() ; ind++) {
+        record_list_[ind]->Open(coverage_srv_fd);
+    }
+}
+
+
+}  // namespace controller
+}  // namespace trusty
+}  // namespace android
+
+int main(int argc, char* argv[]) {
+
+    std::string optarg = "";
+    do {
+        int c;
+        c = getopt(argc, argv, "o");
+
+        if (c == -1) {
+            break;
+        }
+
+        switch (c) {
+        case 'o':
+            break;
+        default:
+            fprintf(stderr, "usage: %s -o [output_directory]\n", argv[0]);
+            exit(EXIT_FAILURE);
+        }
+    } while (1);
+
+    if (argc > optind + 1) {
+        fprintf(stderr, "%s: too many arguments\n", argv[0]);
+        exit(EXIT_FAILURE);
+    }
+
+    if (argc > optind) {
+        optarg = argv[optind];
+    }
+    if (optarg.size()==0) {
+        optarg = "data/local/tmp";
+    }
+
+    android::trusty::controller::Controller cur;
+    cur.run(optarg);
+
+    return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/trusty/utils/coverage-controller/controller.h b/trusty/utils/coverage-controller/controller.h
new file mode 100644
index 000000000000..b771c16150d8
--- /dev/null
+++ b/trusty/utils/coverage-controller/controller.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <trusty/line-coverage/coverage.h>
+#include <array>
+#include <memory>
+#include <vector>
+#include <set>
+
+#define TIPC_DEV "/dev/trusty-ipc-dev0"
+#define TEST_SRV_PORT "com.android.trusty.sancov.test.srv"
+#define TEST_SRV_MODULE "srv.syms.elf"
+
+#define FLAG_NONE               0x0
+#define FLAG_RUN                0x1
+#define FLAG_TOGGLE_CLEAR       0x2
+
+struct control {
+    /* Written by controller, read by instrumented TA */
+    uint64_t        cntrl_flags;
+
+    /* Written by instrumented TA, read by controller */
+    uint64_t        oper_flags;
+    uint64_t        write_buffer_start_count;
+    uint64_t        write_buffer_complete_count;
+};
+
+namespace android {
+namespace trusty {
+namespace controller {
+
+class Controller {
+  public:
+    public:
+        void run(std::string output_dir);
+
+    private:
+        std::vector<std::unique_ptr<line_coverage::CoverageRecord>>record_list_;
+        std::set<struct uuid>uuid_set_;
+        std::vector<uint64_t> counters;
+        int coverage_srv_fd;
+
+        void connectCoverageServer();
+        void setUpShm();
+};
+
+}  // namespace controller
+}  // namespace trusty
+}  // namespace android

From 6367e8953aaace4967643a7f2f78d36ae84b1a9c Mon Sep 17 00:00:00 2001
From: Alexander Koskovich <akoskovich@pm.me>
Date: Sat, 5 Aug 2023 00:38:29 -0400
Subject: [PATCH 0275/1487] core: fastboot: Fix data not being wiped on
 do_update

 * With platform-tools-34.0.4 if you try to wipe data
   as apart of the fastboot update command it will not
   work, will just reboot to userspace without running
   the wipe task.

Test: fastboot -w update image.zip, observe that data
      gets wiped. Also verified 'fastboot update image.zip'
      does *not* wipe data.
Change-Id: I57a2c64029fd4f78968324bdf60251e1e962b3fd
---
 fastboot/fastboot.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 0bd07ed8054a..3644d9537d77 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1944,7 +1944,6 @@ static void do_update(const char* filename, FlashingPlan* fp) {
     }
     ZipImageSource zp = ZipImageSource(zip);
     fp->source = &zp;
-    fp->wants_wipe = false;
     FlashAllTool tool(fp);
     tool.Flash();
 

From 76094b499cf630fa55f2dec6aa595abeb6545e92 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 7 Aug 2023 10:12:05 -0700
Subject: [PATCH 0276/1487] snapuserd: Rename snapuserd_merge to merge_worker.

This follows the recently added names read_worker and worker.

Bug: 288273605
Test: builds
Change-Id: Ie75e94405a018dd0068aa24aefd268adb1aee17e
---
 fs_mgr/libsnapshot/snapuserd/Android.bp                         | 2 +-
 .../libsnapshot/snapuserd/user-space-merge/handler_manager.cpp  | 2 +-
 .../user-space-merge/{snapuserd_merge.cpp => merge_worker.cpp}  | 2 +-
 .../user-space-merge/{snapuserd_merge.h => merge_worker.h}      | 0
 .../libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp   | 2 +-
 5 files changed, 4 insertions(+), 4 deletions(-)
 rename fs_mgr/libsnapshot/snapuserd/user-space-merge/{snapuserd_merge.cpp => merge_worker.cpp} (99%)
 rename fs_mgr/libsnapshot/snapuserd/user-space-merge/{snapuserd_merge.h => merge_worker.h} (100%)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index f63579b9b372..3d76aceadc2f 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -64,9 +64,9 @@ cc_library_static {
         "dm-snapshot-merge/snapuserd_readahead.cpp",
         "snapuserd_buffer.cpp",
         "user-space-merge/handler_manager.cpp",
+        "user-space-merge/merge_worker.cpp",
         "user-space-merge/read_worker.cpp",
         "user-space-merge/snapuserd_core.cpp",
-        "user-space-merge/snapuserd_merge.cpp",
         "user-space-merge/snapuserd_readahead.cpp",
         "user-space-merge/snapuserd_transitions.cpp",
         "user-space-merge/snapuserd_verify.cpp",
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index 4105b4b4836a..041e5169918e 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -18,9 +18,9 @@
 
 #include <android-base/logging.h>
 
+#include "merge_worker.h"
 #include "read_worker.h"
 #include "snapuserd_core.h"
-#include "snapuserd_merge.h"
 
 namespace android {
 namespace snapshot {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
similarity index 99%
rename from fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
rename to fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index 517148d36730..2305a1c485a6 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "snapuserd_merge.h"
+#include "merge_worker.h"
 
 #include "snapuserd_core.h"
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.h
similarity index 100%
rename from fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_merge.h
rename to fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.h
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 12d095afec05..6d09bc9b3d5b 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -23,8 +23,8 @@
 #include <android-base/scopeguard.h>
 #include <android-base/strings.h>
 
+#include "merge_worker.h"
 #include "read_worker.h"
-#include "snapuserd_merge.h"
 
 namespace android {
 namespace snapshot {

From e9277f91f85f1371b1eb6efa67d9b58542ee1c8c Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 27 Jun 2023 13:26:43 -0700
Subject: [PATCH 0277/1487] snapuserd: Add an IBlockServer abstraction around
 dm-user.

This adds the planned interface that will abstract around dm-user (for
now), and later ublk at which point it can be adjusted as needed.

This declares the interface and implements it, but does not yet switch
snapuserd to use it. The implementation is copied from read_worker.cpp.

Bug: 288273605
Test: snapuserd_test
Change-Id: I060788c91dba78e52d315b5616b84b37eaf4040f
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   3 +-
 .../snapuserd/dm_user_block_server.cpp        | 146 ++++++++++++++++++
 .../include/snapuserd/block_server.h          |  87 +++++++++++
 .../include/snapuserd/dm_user_block_server.h  |  63 ++++++++
 .../libsnapshot/snapuserd/snapuserd_logging.h |  20 +++
 5 files changed, 318 insertions(+), 1 deletion(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp
 create mode 100644 fs_mgr/libsnapshot/snapuserd/include/snapuserd/block_server.h
 create mode 100644 fs_mgr/libsnapshot/snapuserd/include/snapuserd/dm_user_block_server.h
 create mode 100644 fs_mgr/libsnapshot/snapuserd/snapuserd_logging.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 3d76aceadc2f..40dcc2a8e5b3 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -60,8 +60,9 @@ cc_library_static {
     local_include_dirs: ["include/"],
     srcs: [
         "dm-snapshot-merge/snapuserd.cpp",
-        "dm-snapshot-merge/snapuserd_worker.cpp",
         "dm-snapshot-merge/snapuserd_readahead.cpp",
+        "dm-snapshot-merge/snapuserd_worker.cpp",
+        "dm_user_block_server.cpp",
         "snapuserd_buffer.cpp",
         "user-space-merge/handler_manager.cpp",
         "user-space-merge/merge_worker.cpp",
diff --git a/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp b/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp
new file mode 100644
index 000000000000..ae62bc6ba077
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp
@@ -0,0 +1,146 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <snapuserd/dm_user_block_server.h>
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <snapuserd/snapuserd_kernel.h>
+#include "snapuserd_logging.h"
+
+namespace android {
+namespace snapshot {
+
+using android::base::unique_fd;
+
+DmUserBlockServer::DmUserBlockServer(const std::string& misc_name, unique_fd&& ctrl_fd,
+                                     Delegate* delegate, size_t buffer_size)
+    : misc_name_(misc_name), ctrl_fd_(std::move(ctrl_fd)), delegate_(delegate) {
+    buffer_.Initialize(sizeof(struct dm_user_header) + buffer_size);
+}
+
+bool DmUserBlockServer::ProcessRequests() {
+    struct dm_user_header* header = buffer_.GetHeaderPtr();
+    if (!android::base::ReadFully(ctrl_fd_, header, sizeof(*header))) {
+        if (errno != ENOTBLK) {
+            SNAP_PLOG(ERROR) << "Control-read failed";
+        }
+
+        SNAP_PLOG(DEBUG) << "ReadDmUserHeader failed....";
+        return false;
+    }
+
+    SNAP_LOG(DEBUG) << "Daemon: msg->seq: " << std::dec << header->seq;
+    SNAP_LOG(DEBUG) << "Daemon: msg->len: " << std::dec << header->len;
+    SNAP_LOG(DEBUG) << "Daemon: msg->sector: " << std::dec << header->sector;
+    SNAP_LOG(DEBUG) << "Daemon: msg->type: " << std::dec << header->type;
+    SNAP_LOG(DEBUG) << "Daemon: msg->flags: " << std::dec << header->flags;
+
+    if (!ProcessRequest(header)) {
+        if (header->type != DM_USER_RESP_ERROR) {
+            SendError();
+        }
+        return false;
+    }
+    return true;
+}
+
+bool DmUserBlockServer::ProcessRequest(dm_user_header* header) {
+    // Use the same header buffer as the response header.
+    int request_type = header->type;
+    header->type = DM_USER_RESP_SUCCESS;
+    header_response_ = true;
+
+    // Reset the output buffer.
+    buffer_.ResetBufferOffset();
+
+    switch (request_type) {
+        case DM_USER_REQ_MAP_READ:
+            return delegate_->RequestSectors(header->sector, header->len);
+
+        case DM_USER_REQ_MAP_WRITE:
+            // We should not get any write request to dm-user as we mount all
+            // partitions as read-only.
+            SNAP_LOG(ERROR) << "Unexpected write request from dm-user";
+            return false;
+
+        default:
+            SNAP_LOG(ERROR) << "Unexpected request from dm-user: " << request_type;
+            return false;
+    }
+}
+
+void* DmUserBlockServer::GetResponseBuffer(size_t size, size_t to_write) {
+    return buffer_.AcquireBuffer(size, to_write);
+}
+
+bool DmUserBlockServer::SendBufferedIo() {
+    return WriteDmUserPayload(buffer_.GetPayloadBytesWritten());
+}
+
+void DmUserBlockServer::SendError() {
+    struct dm_user_header* header = buffer_.GetHeaderPtr();
+    header->type = DM_USER_RESP_ERROR;
+    // This is an issue with the dm-user interface. There
+    // is no way to propagate the I/O error back to dm-user
+    // if we have already communicated the header back. Header
+    // is responded once at the beginning; however I/O can
+    // be processed in chunks. If we encounter an I/O error
+    // somewhere in the middle of the processing, we can't communicate
+    // this back to dm-user.
+    //
+    // TODO: Fix the interface
+    CHECK(header_response_);
+
+    WriteDmUserPayload(0);
+}
+
+bool DmUserBlockServer::WriteDmUserPayload(size_t size) {
+    size_t payload_size = size;
+    void* buf = buffer_.GetPayloadBufPtr();
+    if (header_response_) {
+        payload_size += sizeof(struct dm_user_header);
+        buf = buffer_.GetBufPtr();
+    }
+
+    if (!android::base::WriteFully(ctrl_fd_, buf, payload_size)) {
+        SNAP_PLOG(ERROR) << "Write to dm-user failed size: " << payload_size;
+        return false;
+    }
+
+    // After the first header is sent in response to a request, we cannot
+    // send any additional headers.
+    header_response_ = false;
+
+    // Reset the buffer for use by the next request.
+    buffer_.ResetBufferOffset();
+    return true;
+}
+
+DmUserBlockServerOpener::DmUserBlockServerOpener(const std::string& misc_name,
+                                                 const std::string& dm_user_path)
+    : misc_name_(misc_name), dm_user_path_(dm_user_path) {}
+
+std::unique_ptr<IBlockServer> DmUserBlockServerOpener::Open(IBlockServer::Delegate* delegate,
+                                                            size_t buffer_size) {
+    unique_fd fd(open(dm_user_path_.c_str(), O_RDWR | O_CLOEXEC));
+    if (fd < 0) {
+        SNAP_PLOG(ERROR) << "Could not open dm-user path: " << dm_user_path_;
+        return nullptr;
+    }
+    return std::make_unique<DmUserBlockServer>(misc_name_, std::move(fd), delegate, buffer_size);
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/block_server.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/block_server.h
new file mode 100644
index 000000000000..3be6d1c3e844
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/block_server.h
@@ -0,0 +1,87 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+
+namespace android {
+namespace snapshot {
+
+// These interfaces model the block device driver component of snapuserd (eg,
+// dm-user).
+
+// An open connection to a userspace block device control
+class IBlockServer {
+  public:
+    class Delegate {
+      public:
+        virtual ~Delegate() {}
+
+        // Respond to a request for reading a contiguous run of sectors. This
+        // call should be followed by calls to GetResponseBuffer/CommitBuffer
+        // until the |size| is fulfilled.
+        //
+        // If false is returned, an error will be automatically reported unless
+        // SendError was called.
+        virtual bool RequestSectors(uint64_t sector, size_t size) = 0;
+    };
+
+    virtual ~IBlockServer() {}
+
+    // Process I/O requests. This can block the worker thread until either a
+    // request is available or the underlying connection has been destroyed.
+    //
+    // True indicates that one or more requests was processed. False indicates
+    // an unrecoverable condition and processing should stop.
+    virtual bool ProcessRequests() = 0;
+
+    // Return a buffer for fulfilling a RequestSectors request. This buffer
+    // is valid until calling SendBufferedIo. This cannot be called outside
+    // of RequestSectors().
+    //
+    // "to_write" must be <= "size". If it is < size, the excess bytes are
+    // available for writing, but will not be send via SendBufferedIo, and
+    // may be reallocated in the next call to GetResponseBuffer.
+    //
+    // All buffers returned are invalidated after SendBufferedIo or returning
+    // control from RequestSectors.
+    virtual void* GetResponseBuffer(size_t size, size_t to_write) = 0;
+
+    // Send all outstanding buffers to the driver, in order. This should
+    // be called at least once in response to RequestSectors. This returns
+    // ownership of any buffers returned by GetResponseBuffer.
+    //
+    // If false is returned, an error is automatically reported to the driver.
+    virtual bool SendBufferedIo() = 0;
+
+    void* GetResponseBuffer(size_t size) { return GetResponseBuffer(size, size); }
+};
+
+class IBlockServerOpener {
+  public:
+    virtual ~IBlockServerOpener() = default;
+
+    // Open a connection to the service. This is called on the daemon thread.
+    //
+    // buffer_size is the maximum amount of buffered I/O to use.
+    virtual std::unique_ptr<IBlockServer> Open(IBlockServer::Delegate* delegate,
+                                               size_t buffer_size) = 0;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/dm_user_block_server.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/dm_user_block_server.h
new file mode 100644
index 000000000000..6aecf500d4a2
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/dm_user_block_server.h
@@ -0,0 +1,63 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <android-base/unique_fd.h>
+
+#include <string>
+
+#include <snapuserd/block_server.h>
+#include <snapuserd/snapuserd_buffer.h>
+
+namespace android {
+namespace snapshot {
+
+class DmUserBlockServer : public IBlockServer {
+  public:
+    DmUserBlockServer(const std::string& misc_name, android::base::unique_fd&& ctrl_fd,
+                      Delegate* delegate, size_t buffer_size);
+
+    bool ProcessRequests() override;
+    void* GetResponseBuffer(size_t size, size_t to_write) override;
+    bool SendBufferedIo() override;
+    void SendError();
+
+  private:
+    bool ProcessRequest(dm_user_header* header);
+    bool WriteDmUserPayload(size_t size);
+
+    std::string misc_name_;
+    android::base::unique_fd ctrl_fd_;
+    Delegate* delegate_;
+
+    // Per-request state.
+    BufferSink buffer_;
+    bool header_response_ = false;
+};
+
+class DmUserBlockServerOpener : public IBlockServerOpener {
+  public:
+    DmUserBlockServerOpener(const std::string& misc_name, const std::string& dm_user_path);
+
+    std::unique_ptr<IBlockServer> Open(IBlockServer::Delegate* delegate,
+                                       size_t buffer_size) override;
+
+  private:
+    std::string misc_name_;
+    std::string dm_user_path_;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_logging.h b/fs_mgr/libsnapshot/snapuserd/snapuserd_logging.h
new file mode 100644
index 000000000000..bc470ce1076c
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_logging.h
@@ -0,0 +1,20 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <android-base/logging.h>
+
+#define SNAP_LOG(level) LOG(level) << misc_name_ << ": "
+#define SNAP_PLOG(level) PLOG(level) << misc_name_ << ": "

From a392fa3c7823d59d0c2e5dae1695969a1ca0e486 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 27 Jun 2023 16:31:20 -0700
Subject: [PATCH 0278/1487] snapuserd: Remove dm-user specific code from
 ReadWorker.

This uses the new IBlockServer abstraction layer instead.

Bug: 288273605
Test: snapuserd_test
Change-Id: Ie9a781e44da7447426706d4874644aabf1be1946
---
 .../include/snapuserd/block_server.h          |   2 +-
 .../user-space-merge/read_worker.cpp          | 129 +++---------------
 .../snapuserd/user-space-merge/read_worker.h  |  19 ++-
 .../user-space-merge/snapuserd_core.cpp       |   6 +-
 4 files changed, 31 insertions(+), 125 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/block_server.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/block_server.h
index 3be6d1c3e844..72b73fc0b5f0 100644
--- a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/block_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/block_server.h
@@ -38,7 +38,7 @@ class IBlockServer {
         //
         // If false is returned, an error will be automatically reported unless
         // SendError was called.
-        virtual bool RequestSectors(uint64_t sector, size_t size) = 0;
+        virtual bool RequestSectors(uint64_t sector, uint64_t size) = 0;
     };
 
     virtual ~IBlockServer() {}
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index 7d2e3a613746..ce4be4348f8b 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -26,18 +26,18 @@ using namespace android::dm;
 using android::base::unique_fd;
 
 void ReadWorker::CloseFds() {
-    ctrl_fd_ = {};
+    block_server_ = {};
     backing_store_fd_ = {};
     Worker::CloseFds();
 }
 
 ReadWorker::ReadWorker(const std::string& cow_device, const std::string& backing_device,
-                       const std::string& control_device, const std::string& misc_name,
-                       const std::string& base_path_merge,
-                       std::shared_ptr<SnapshotHandler> snapuserd)
+                       const std::string& misc_name, const std::string& base_path_merge,
+                       std::shared_ptr<SnapshotHandler> snapuserd,
+                       std::shared_ptr<IBlockServerOpener> opener)
     : Worker(cow_device, misc_name, base_path_merge, snapuserd),
       backing_store_device_(backing_device),
-      control_device_(control_device) {}
+      block_server_opener_(opener) {}
 
 // Start the replace operation. This will read the
 // internal COW format and if the block is compressed,
@@ -197,9 +197,9 @@ bool ReadWorker::Init() {
         return false;
     }
 
-    ctrl_fd_.reset(open(control_device_.c_str(), O_RDWR));
-    if (ctrl_fd_ < 0) {
-        SNAP_PLOG(ERROR) << "Unable to open " << control_device_;
+    block_server_ = block_server_opener_->Open(this, PAYLOAD_BUFFER_SZ);
+    if (!block_server_) {
+        SNAP_PLOG(ERROR) << "Unable to open block server";
         return false;
     }
     return true;
@@ -214,7 +214,7 @@ bool ReadWorker::Run() {
 
     // Start serving IO
     while (true) {
-        if (!ProcessIORequest()) {
+        if (!block_server_->ProcessRequests()) {
             break;
         }
     }
@@ -225,29 +225,6 @@ bool ReadWorker::Run() {
     return true;
 }
 
-// Send the payload/data back to dm-user misc device.
-bool ReadWorker::WriteDmUserPayload(size_t size) {
-    size_t payload_size = size;
-    void* buf = bufsink_.GetPayloadBufPtr();
-    if (header_response_) {
-        payload_size += sizeof(struct dm_user_header);
-        buf = bufsink_.GetBufPtr();
-    }
-
-    if (!android::base::WriteFully(ctrl_fd_, buf, payload_size)) {
-        SNAP_PLOG(ERROR) << "Write to dm-user failed size: " << payload_size;
-        return false;
-    }
-
-    // After the first header is sent in response to a request, we cannot
-    // send any additional headers.
-    header_response_ = false;
-
-    // Reset the buffer for use by the next request.
-    bufsink_.ResetBufferOffset();
-    return true;
-}
-
 bool ReadWorker::ReadDataFromBaseDevice(sector_t sector, void* buffer, size_t read_size) {
     CHECK(read_size <= BLOCK_SZ);
 
@@ -281,7 +258,7 @@ bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
                                        std::make_pair(sector, nullptr), SnapshotHandler::compare);
             bool not_found = (it == chunk_vec.end() || it->first != sector);
 
-            void* buffer = bufsink_.AcquireBuffer(BLOCK_SZ, size);
+            void* buffer = block_server_->GetResponseBuffer(BLOCK_SZ, size);
             if (!buffer) {
                 SNAP_LOG(ERROR) << "AcquireBuffer failed in ReadAlignedSector";
                 return false;
@@ -334,7 +311,8 @@ int ReadWorker::ReadUnalignedSector(
     int num_sectors_skip = sector - it->first;
     size_t skip_size = num_sectors_skip << SECTOR_SHIFT;
     size_t write_size = std::min(size, BLOCK_SZ - skip_size);
-    auto buffer = reinterpret_cast<uint8_t*>(bufsink_.AcquireBuffer(BLOCK_SZ, write_size));
+    auto buffer =
+            reinterpret_cast<uint8_t*>(block_server_->GetResponseBuffer(BLOCK_SZ, write_size));
     if (!buffer) {
         SNAP_LOG(ERROR) << "ProcessCowOp failed to allocate buffer";
         return -1;
@@ -462,7 +440,7 @@ bool ReadWorker::ReadUnalignedSector(sector_t sector, size_t size) {
         CHECK(diff_size <= BLOCK_SZ);
 
         size_t read_size = std::min(remaining_size, diff_size);
-        void* buffer = bufsink_.AcquireBuffer(BLOCK_SZ, read_size);
+        void* buffer = block_server_->GetResponseBuffer(BLOCK_SZ, read_size);
         if (!buffer) {
             SNAP_LOG(ERROR) << "AcquireBuffer failed in ReadUnalignedSector";
             return false;
@@ -488,88 +466,17 @@ bool ReadWorker::ReadUnalignedSector(sector_t sector, size_t size) {
     return true;
 }
 
-void ReadWorker::RespondIOError() {
-    struct dm_user_header* header = bufsink_.GetHeaderPtr();
-    header->type = DM_USER_RESP_ERROR;
-    // This is an issue with the dm-user interface. There
-    // is no way to propagate the I/O error back to dm-user
-    // if we have already communicated the header back. Header
-    // is responded once at the beginning; however I/O can
-    // be processed in chunks. If we encounter an I/O error
-    // somewhere in the middle of the processing, we can't communicate
-    // this back to dm-user.
-    //
-    // TODO: Fix the interface
-    CHECK(header_response_);
-
-    WriteDmUserPayload(0);
-}
-
-bool ReadWorker::DmuserReadRequest() {
-    struct dm_user_header* header = bufsink_.GetHeaderPtr();
-
+bool ReadWorker::RequestSectors(uint64_t sector, uint64_t len) {
     // Unaligned I/O request
-    if (!IsBlockAligned(header->sector << SECTOR_SHIFT)) {
-        return ReadUnalignedSector(header->sector, header->len);
+    if (!IsBlockAligned(sector << SECTOR_SHIFT)) {
+        return ReadUnalignedSector(sector, len);
     }
 
-    return ReadAlignedSector(header->sector, header->len);
+    return ReadAlignedSector(sector, len);
 }
 
 bool ReadWorker::SendBufferedIo() {
-    return WriteDmUserPayload(bufsink_.GetPayloadBytesWritten());
-}
-
-bool ReadWorker::ProcessIORequest() {
-    // Read Header from dm-user misc device. This gives
-    // us the sector number for which IO is issued by dm-snapshot device
-    struct dm_user_header* header = bufsink_.GetHeaderPtr();
-    if (!android::base::ReadFully(ctrl_fd_, header, sizeof(*header))) {
-        if (errno != ENOTBLK) {
-            SNAP_PLOG(ERROR) << "Control-read failed";
-        }
-
-        SNAP_PLOG(DEBUG) << "ReadDmUserHeader failed....";
-        return false;
-    }
-
-    SNAP_LOG(DEBUG) << "Daemon: msg->seq: " << std::dec << header->seq;
-    SNAP_LOG(DEBUG) << "Daemon: msg->len: " << std::dec << header->len;
-    SNAP_LOG(DEBUG) << "Daemon: msg->sector: " << std::dec << header->sector;
-    SNAP_LOG(DEBUG) << "Daemon: msg->type: " << std::dec << header->type;
-    SNAP_LOG(DEBUG) << "Daemon: msg->flags: " << std::dec << header->flags;
-
-    // Use the same header buffer as the response header.
-    int request_type = header->type;
-    header->type = DM_USER_RESP_SUCCESS;
-    header_response_ = true;
-
-    // Reset the output buffer.
-    bufsink_.ResetBufferOffset();
-
-    bool ok;
-    switch (request_type) {
-        case DM_USER_REQ_MAP_READ:
-            ok = DmuserReadRequest();
-            break;
-
-        case DM_USER_REQ_MAP_WRITE:
-            // TODO: We should not get any write request
-            // to dm-user as we mount all partitions
-            // as read-only. Need to verify how are TRIM commands
-            // handled during mount.
-            ok = false;
-            break;
-
-        default:
-            ok = false;
-            break;
-    }
-
-    if (!ok && header->type != DM_USER_RESP_ERROR) {
-        RespondIOError();
-    }
-    return ok;
+    return block_server_->SendBufferedIo();
 }
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
index 8d6f66379359..a6a3eb8ca54d 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
@@ -17,28 +17,26 @@
 #include <utility>
 #include <vector>
 
+#include <snapuserd/block_server.h>
 #include "worker.h"
 
 namespace android {
 namespace snapshot {
 
-class ReadWorker : public Worker {
+class ReadWorker : public Worker, public IBlockServer::Delegate {
   public:
     ReadWorker(const std::string& cow_device, const std::string& backing_device,
-               const std::string& control_device, const std::string& misc_name,
-               const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd);
+               const std::string& misc_name, const std::string& base_path_merge,
+               std::shared_ptr<SnapshotHandler> snapuserd,
+               std::shared_ptr<IBlockServerOpener> opener);
 
     bool Run();
     bool Init() override;
     void CloseFds() override;
 
   private:
-    // Functions interacting with dm-user
-    bool ProcessIORequest();
-    bool WriteDmUserPayload(size_t size);
-    bool DmuserReadRequest();
+    bool RequestSectors(uint64_t sector, uint64_t size) override;
     bool SendBufferedIo();
-    void RespondIOError();
 
     bool ProcessCowOp(const CowOperation* cow_op, void* buffer);
     bool ProcessXorOp(const CowOperation* cow_op, void* buffer);
@@ -60,10 +58,9 @@ class ReadWorker : public Worker {
     std::string backing_store_device_;
     unique_fd backing_store_fd_;
 
-    std::string control_device_;
-    unique_fd ctrl_fd_;
+    std::shared_ptr<IBlockServerOpener> block_server_opener_;
+    std::unique_ptr<IBlockServer> block_server_;
 
-    bool header_response_ = false;
     std::basic_string<uint8_t> xor_buffer_;
 };
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 6d09bc9b3d5b..6d3d5c7ad639 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -22,6 +22,7 @@
 #include <android-base/properties.h>
 #include <android-base/scopeguard.h>
 #include <android-base/strings.h>
+#include <snapuserd/dm_user_block_server.h>
 
 #include "merge_worker.h"
 #include "read_worker.h"
@@ -48,9 +49,10 @@ SnapshotHandler::SnapshotHandler(std::string misc_name, std::string cow_device,
 }
 
 bool SnapshotHandler::InitializeWorkers() {
+    auto opener = std::make_shared<DmUserBlockServerOpener>(misc_name_, control_device_);
     for (int i = 0; i < num_worker_threads_; i++) {
-        auto wt = std::make_unique<ReadWorker>(cow_device_, backing_store_device_, control_device_,
-                                               misc_name_, base_path_merge_, GetSharedPtr());
+        auto wt = std::make_unique<ReadWorker>(cow_device_, backing_store_device_, misc_name_,
+                                               base_path_merge_, GetSharedPtr(), opener);
         if (!wt->Init()) {
             SNAP_LOG(ERROR) << "Thread initialization failed";
             return false;

From 7728c6c998abcec2461b80cd6aea56e38c568725 Mon Sep 17 00:00:00 2001
From: Snehal <snehalreddy@google.com>
Date: Thu, 3 Aug 2023 16:51:20 +0000
Subject: [PATCH 0279/1487] Add mikemcternan@ to OWNERS

Change-Id: Ia414e191eab2b2e3139b94fa8c94ea54f4fbf308
---
 trusty/OWNERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/trusty/OWNERS b/trusty/OWNERS
index 61b97c6410fd..bf1691275b67 100644
--- a/trusty/OWNERS
+++ b/trusty/OWNERS
@@ -3,6 +3,7 @@ arve@android.com
 danielangell@google.com
 gmar@google.com
 marcone@google.com
+mikemcternan@google.com
 mmaurer@google.com
 ncbray@google.com
 swillden@google.com

From 2cffe186ada6ddc3e474a0be97c9d74e12c4b880 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 7 Aug 2023 10:09:10 -0700
Subject: [PATCH 0280/1487] snapuserd: Remove ambiguous BufferSink in workers.

BufferSink is not needed/used in all worker types, so move it explicitly
to MergeWorker. This also moves the sizeof(dm_user_header) computation
to BufferSink::Initialize.

Bug: 288273605
Test: snapuserd_test
Change-Id: I8fcea6f0e587ca6d8672df5ec58c4d4d14d4b72e
---
 fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp |  2 +-
 fs_mgr/libsnapshot/snapuserd/snapuserd_buffer.cpp     |  4 ++--
 .../snapuserd/user-space-merge/merge_worker.cpp       |  2 ++
 .../snapuserd/user-space-merge/merge_worker.h         |  1 +
 .../libsnapshot/snapuserd/user-space-merge/worker.cpp | 11 -----------
 .../libsnapshot/snapuserd/user-space-merge/worker.h   |  3 ---
 6 files changed, 6 insertions(+), 17 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp b/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp
index ae62bc6ba077..b5fef4787f19 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp
@@ -27,7 +27,7 @@ using android::base::unique_fd;
 DmUserBlockServer::DmUserBlockServer(const std::string& misc_name, unique_fd&& ctrl_fd,
                                      Delegate* delegate, size_t buffer_size)
     : misc_name_(misc_name), ctrl_fd_(std::move(ctrl_fd)), delegate_(delegate) {
-    buffer_.Initialize(sizeof(struct dm_user_header) + buffer_size);
+    buffer_.Initialize(buffer_size);
 }
 
 bool DmUserBlockServer::ProcessRequests() {
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_buffer.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_buffer.cpp
index 35065e61ef86..490c0e63a1bc 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_buffer.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_buffer.cpp
@@ -23,9 +23,9 @@ namespace android {
 namespace snapshot {
 
 void BufferSink::Initialize(size_t size) {
-    buffer_size_ = size;
+    buffer_size_ = size + sizeof(struct dm_user_header);
     buffer_offset_ = 0;
-    buffer_ = std::make_unique<uint8_t[]>(size);
+    buffer_ = std::make_unique<uint8_t[]>(buffer_size_);
 }
 
 void* BufferSink::AcquireBuffer(size_t size, size_t to_write) {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index 2305a1c485a6..a83cab8d8b4c 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -556,6 +556,8 @@ bool MergeWorker::Run() {
 
     SNAP_LOG(INFO) << "Merge starting..";
 
+    bufsink_.Initialize(PAYLOAD_BUFFER_SZ);
+
     if (!Init()) {
         SNAP_LOG(ERROR) << "Merge thread initialization failed...";
         snapuserd_->MergeFailed();
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.h
index f35147f2beb6..478d4c8a270c 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.h
@@ -39,6 +39,7 @@ class MergeWorker : public Worker {
     void FinalizeIouring();
 
   private:
+    BufferSink bufsink_;
     std::unique_ptr<ICowOpIter> cowop_iter_;
     std::unique_ptr<struct io_uring> ring_;
     size_t ra_block_index_ = 0;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.cpp
index aa156301fa3b..65208fb8bac9 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.cpp
@@ -27,18 +27,7 @@ Worker::Worker(const std::string& cow_device, const std::string& misc_name,
     snapuserd_ = snapuserd;
 }
 
-void Worker::InitializeBufsink() {
-    // Allocate the buffer which is used to communicate between
-    // daemon and dm-user. The buffer comprises of header and a fixed payload.
-    // If the dm-user requests a big IO, the IO will be broken into chunks
-    // of PAYLOAD_BUFFER_SZ.
-    size_t buf_size = sizeof(struct dm_user_header) + PAYLOAD_BUFFER_SZ;
-    bufsink_.Initialize(buf_size);
-}
-
 bool Worker::Init() {
-    InitializeBufsink();
-
     if (!InitializeFds()) {
         return false;
     }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h
index 813b159eaee3..c89d1b4fd558 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/worker.h
@@ -40,14 +40,11 @@ class Worker {
     virtual bool Init();
 
   protected:
-    // Initialization
-    void InitializeBufsink();
     bool InitializeFds();
     bool InitReader();
     virtual void CloseFds() { base_path_merge_fd_ = {}; }
 
     std::unique_ptr<CowReader> reader_;
-    BufferSink bufsink_;
 
     std::string misc_name_;  // Needed for SNAP_LOG.
 

From 384b22ce587766fb985dffaafee4c804b18c0109 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 28 Jun 2023 11:22:00 -0700
Subject: [PATCH 0281/1487] snapuserd: Add an IBlockServerFactory abstraction.

To avoid SnapshotHandler hardcoding specifics about dm-user, this patch
adds a factory interface, responsible for providing IBlockServerOpener
objects.

The test harness will use this to facilitate dm-user-less testing on
host devices.

Bug: 288273605
Test: snapuserd_test
Change-Id: Ifd33c28ee7076f30a8a90f745353893188f97a08
---
 fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp  |  6 ++++++
 .../snapuserd/include/snapuserd/block_server.h         |  8 ++++++++
 .../snapuserd/include/snapuserd/dm_user_block_server.h |  5 +++++
 .../snapuserd/user-space-merge/handler_manager.cpp     |  5 +++--
 .../snapuserd/user-space-merge/handler_manager.h       |  3 +++
 .../snapuserd/user-space-merge/snapuserd_core.cpp      | 10 +++++-----
 .../snapuserd/user-space-merge/snapuserd_core.h        |  6 ++++--
 .../snapuserd/user-space-merge/snapuserd_server.cpp    |  7 ++++++-
 .../snapuserd/user-space-merge/snapuserd_server.h      |  2 ++
 .../snapuserd/user-space-merge/snapuserd_test.cpp      |  7 +++++--
 10 files changed, 47 insertions(+), 12 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp b/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp
index b5fef4787f19..e98833502554 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp
@@ -142,5 +142,11 @@ std::unique_ptr<IBlockServer> DmUserBlockServerOpener::Open(IBlockServer::Delega
     return std::make_unique<DmUserBlockServer>(misc_name_, std::move(fd), delegate, buffer_size);
 }
 
+std::shared_ptr<IBlockServerOpener> DmUserBlockServerFactory::CreateOpener(
+        const std::string& misc_name) {
+    auto dm_path = "/dev/dm-user/" + misc_name;
+    return std::make_shared<DmUserBlockServerOpener>(misc_name, dm_path);
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/block_server.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/block_server.h
index 72b73fc0b5f0..406bf11c34ca 100644
--- a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/block_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/block_server.h
@@ -83,5 +83,13 @@ class IBlockServerOpener {
                                                size_t buffer_size) = 0;
 };
 
+class IBlockServerFactory {
+  public:
+    virtual ~IBlockServerFactory() {}
+
+    // Return a new IBlockServerOpener given a unique device name.
+    virtual std::shared_ptr<IBlockServerOpener> CreateOpener(const std::string& misc_name) = 0;
+};
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/dm_user_block_server.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/dm_user_block_server.h
index 6aecf500d4a2..f1f8da1430e2 100644
--- a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/dm_user_block_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/dm_user_block_server.h
@@ -59,5 +59,10 @@ class DmUserBlockServerOpener : public IBlockServerOpener {
     std::string dm_user_path_;
 };
 
+class DmUserBlockServerFactory : public IBlockServerFactory {
+  public:
+    std::shared_ptr<IBlockServerOpener> CreateOpener(const std::string& misc_name) override;
+};
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index 041e5169918e..fd41cd419b3c 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -50,9 +50,10 @@ SnapshotHandlerManager::SnapshotHandlerManager() {
 std::shared_ptr<HandlerThread> SnapshotHandlerManager::AddHandler(
         const std::string& misc_name, const std::string& cow_device_path,
         const std::string& backing_device, const std::string& base_path_merge,
-        int num_worker_threads, bool use_iouring, bool perform_verification) {
+        std::shared_ptr<IBlockServerOpener> opener, int num_worker_threads, bool use_iouring,
+        bool perform_verification) {
     auto snapuserd = std::make_shared<SnapshotHandler>(misc_name, cow_device_path, backing_device,
-                                                       base_path_merge, num_worker_threads,
+                                                       base_path_merge, opener, num_worker_threads,
                                                        use_iouring, perform_verification);
     if (!snapuserd->InitCowDevice()) {
         LOG(ERROR) << "Failed to initialize Snapuserd";
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
index b7ddac19f28a..2a6da964e02c 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
@@ -21,6 +21,7 @@
 #include <vector>
 
 #include <android-base/unique_fd.h>
+#include <snapuserd/block_server.h>
 
 namespace android {
 namespace snapshot {
@@ -55,6 +56,7 @@ class ISnapshotHandlerManager {
                                                       const std::string& cow_device_path,
                                                       const std::string& backing_device,
                                                       const std::string& base_path_merge,
+                                                      std::shared_ptr<IBlockServerOpener> opener,
                                                       int num_worker_threads, bool use_iouring,
                                                       bool perform_verification) = 0;
 
@@ -91,6 +93,7 @@ class SnapshotHandlerManager final : public ISnapshotHandlerManager {
                                               const std::string& cow_device_path,
                                               const std::string& backing_device,
                                               const std::string& base_path_merge,
+                                              std::shared_ptr<IBlockServerOpener> opener,
                                               int num_worker_threads, bool use_iouring,
                                               bool perform_verification) override;
     bool StartHandler(const std::string& misc_name) override;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 6d3d5c7ad639..5a82ca1f4d92 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -36,12 +36,12 @@ using android::base::unique_fd;
 
 SnapshotHandler::SnapshotHandler(std::string misc_name, std::string cow_device,
                                  std::string backing_device, std::string base_path_merge,
-                                 int num_worker_threads, bool use_iouring,
-                                 bool perform_verification) {
+                                 std::shared_ptr<IBlockServerOpener> opener, int num_worker_threads,
+                                 bool use_iouring, bool perform_verification) {
     misc_name_ = std::move(misc_name);
     cow_device_ = std::move(cow_device);
     backing_store_device_ = std::move(backing_device);
-    control_device_ = "/dev/dm-user/" + misc_name_;
+    block_server_opener_ = std::move(opener);
     base_path_merge_ = std::move(base_path_merge);
     num_worker_threads_ = num_worker_threads;
     is_io_uring_enabled_ = use_iouring;
@@ -49,10 +49,10 @@ SnapshotHandler::SnapshotHandler(std::string misc_name, std::string cow_device,
 }
 
 bool SnapshotHandler::InitializeWorkers() {
-    auto opener = std::make_shared<DmUserBlockServerOpener>(misc_name_, control_device_);
     for (int i = 0; i < num_worker_threads_; i++) {
         auto wt = std::make_unique<ReadWorker>(cow_device_, backing_store_device_, misc_name_,
-                                               base_path_merge_, GetSharedPtr(), opener);
+                                               base_path_merge_, GetSharedPtr(),
+                                               block_server_opener_);
         if (!wt->Init()) {
             SNAP_LOG(ERROR) << "Thread initialization failed";
             return false;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index 5fe0a709af8e..a45e0bcc76e7 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -43,6 +43,7 @@
 #include <libsnapshot/cow_reader.h>
 #include <libsnapshot/cow_writer.h>
 #include <liburing.h>
+#include <snapuserd/block_server.h>
 #include <snapuserd/snapuserd_buffer.h>
 #include <snapuserd/snapuserd_kernel.h>
 #include <storage_literals/storage_literals.h>
@@ -102,8 +103,8 @@ struct MergeGroupState {
 class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
   public:
     SnapshotHandler(std::string misc_name, std::string cow_device, std::string backing_device,
-                    std::string base_path_merge, int num_workers, bool use_iouring,
-                    bool perform_verification);
+                    std::string base_path_merge, std::shared_ptr<IBlockServerOpener> opener,
+                    int num_workers, bool use_iouring, bool perform_verification);
     bool InitCowDevice();
     bool Start();
 
@@ -242,6 +243,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
 
     std::unique_ptr<struct io_uring> ring_;
     std::unique_ptr<UpdateVerify> update_verify_;
+    std::shared_ptr<IBlockServerOpener> block_server_opener_;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index f2585eab1d81..13b9a00b8a4b 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -31,6 +31,7 @@
 #include <android-base/scopeguard.h>
 #include <android-base/strings.h>
 #include <fs_mgr/file_wait.h>
+#include <snapuserd/dm_user_block_server.h>
 #include <snapuserd/snapuserd_client.h>
 #include "snapuserd_server.h"
 
@@ -48,6 +49,7 @@ using android::base::unique_fd;
 UserSnapshotServer::UserSnapshotServer() {
     terminating_ = false;
     handlers_ = std::make_unique<SnapshotHandlerManager>();
+    block_server_factory_ = std::make_unique<DmUserBlockServerFactory>();
 }
 
 UserSnapshotServer::~UserSnapshotServer() {
@@ -363,8 +365,11 @@ std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string&
         perform_verification = false;
     }
 
+    auto opener = block_server_factory_->CreateOpener(misc_name);
+
     return handlers_->AddHandler(misc_name, cow_device_path, backing_device, base_path_merge,
-                                 num_worker_threads, io_uring_enabled_, perform_verification);
+                                 opener, num_worker_threads, io_uring_enabled_,
+                                 perform_verification);
 }
 
 bool UserSnapshotServer::WaitForSocket() {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index 988c01a99ba3..be285412f903 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -31,6 +31,7 @@
 #include <vector>
 
 #include <android-base/unique_fd.h>
+#include <snapuserd/block_server.h>
 #include "handler_manager.h"
 #include "snapuserd_core.h"
 
@@ -50,6 +51,7 @@ class UserSnapshotServer {
     bool is_server_running_ = false;
     bool io_uring_enabled_ = false;
     std::unique_ptr<ISnapshotHandlerManager> handlers_;
+    std::unique_ptr<IBlockServerFactory> block_server_factory_;
 
     std::mutex lock_;
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 16f9ed87f7ac..157925d63d59 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -37,8 +37,8 @@
 #include <libdm/dm.h>
 #include <libdm/loop_control.h>
 #include <libsnapshot/cow_writer.h>
+#include <snapuserd/dm_user_block_server.h>
 #include <storage_literals/storage_literals.h>
-
 #include "handler_manager.h"
 #include "snapuserd_core.h"
 #include "testing/temp_device.h"
@@ -535,9 +535,12 @@ void SnapuserdTest::InitCowDevice() {
         use_iouring = false;
     }
 
+    DmUserBlockServerFactory factory;
+
+    auto opener = factory.CreateOpener(system_device_ctrl_name_);
     auto handler =
             handlers_.AddHandler(system_device_ctrl_name_, cow_system_->path, base_loop_->device(),
-                                 base_loop_->device(), 1, use_iouring, false);
+                                 base_loop_->device(), opener, 1, use_iouring, false);
     ASSERT_NE(handler, nullptr);
     ASSERT_NE(handler->snapuserd(), nullptr);
 #ifdef __ANDROID__

From fe032d03914bf04e413927b89ba0b349bb5adb94 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 3 Aug 2023 16:44:27 -0700
Subject: [PATCH 0282/1487] snapuserd: Add a harness to run tests without
 dm-user specific code.

This patch adds an abstraction layer around Tempdevice (which wraps
device-mapper), and a layer to replace hardcoding of DmUserBlockServer.

The only implementation of the new layer, currently, is for dm-user.
However this will allow the harness to run with a backend chosen at
runtime, making testing on the host or of ublk much easier.

Bug: 288273605
Test: snapuserd_test
Change-Id: I8735ef6c373f3e5c5cdf3df461668ddd8e551f63
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |  1 +
 .../snapuserd/testing/dm_user_harness.cpp     | 67 +++++++++++++++++++
 .../snapuserd/testing/dm_user_harness.h       | 54 +++++++++++++++
 .../libsnapshot/snapuserd/testing/harness.h   | 47 +++++++++++++
 .../user-space-merge/snapuserd_test.cpp       | 51 +++++++-------
 5 files changed, 197 insertions(+), 23 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/testing/dm_user_harness.cpp
 create mode 100644 fs_mgr/libsnapshot/snapuserd/testing/dm_user_harness.h
 create mode 100644 fs_mgr/libsnapshot/snapuserd/testing/harness.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 40dcc2a8e5b3..2368f8f360a0 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -219,6 +219,7 @@ cc_test {
         "libsnapshot_cow_defaults",
     ],
     srcs: [
+        "testing/dm_user_harness.cpp",
         "user-space-merge/snapuserd_test.cpp",
     ],
     shared_libs: [
diff --git a/fs_mgr/libsnapshot/snapuserd/testing/dm_user_harness.cpp b/fs_mgr/libsnapshot/snapuserd/testing/dm_user_harness.cpp
new file mode 100644
index 000000000000..7cadf250c267
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/testing/dm_user_harness.cpp
@@ -0,0 +1,67 @@
+// Copyright (C) 2023 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 "dm_user_harness.h"
+
+#include <fcntl.h>
+
+#include <android-base/file.h>
+#include <fs_mgr/file_wait.h>
+#include <libdm/dm.h>
+#include <snapuserd/dm_user_block_server.h>
+
+namespace android {
+namespace snapshot {
+
+using namespace std::chrono_literals;
+using android::base::unique_fd;
+
+DmUserDevice::DmUserDevice(std::unique_ptr<Tempdevice>&& dev) : dev_(std::move(dev)) {}
+
+const std::string& DmUserDevice::GetPath() {
+    return dev_->path();
+}
+
+bool DmUserDevice::Destroy() {
+    return dev_->Destroy();
+}
+
+DmUserTestHarness::DmUserTestHarness() {
+    block_server_factory_ = std::make_unique<DmUserBlockServerFactory>();
+}
+
+std::unique_ptr<IUserDevice> DmUserTestHarness::CreateUserDevice(const std::string& dev_name,
+                                                                 const std::string& misc_name,
+                                                                 uint64_t num_sectors) {
+    android::dm::DmTable dmuser_table;
+    dmuser_table.Emplace<android::dm::DmTargetUser>(0, num_sectors, misc_name);
+    auto dev = std::make_unique<Tempdevice>(dev_name, dmuser_table);
+    if (!dev->valid()) {
+        return nullptr;
+    }
+
+    auto misc_device = "/dev/dm-user/" + misc_name;
+    if (!android::fs_mgr::WaitForFile(misc_device, 10s)) {
+        return nullptr;
+    }
+
+    return std::make_unique<DmUserDevice>(std::move(dev));
+}
+
+IBlockServerFactory* DmUserTestHarness::GetBlockServerFactory() {
+    return block_server_factory_.get();
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/testing/dm_user_harness.h b/fs_mgr/libsnapshot/snapuserd/testing/dm_user_harness.h
new file mode 100644
index 000000000000..cf26bed037c1
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/testing/dm_user_harness.h
@@ -0,0 +1,54 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <android-base/unique_fd.h>
+
+#include "harness.h"
+#include "temp_device.h"
+
+namespace android {
+namespace snapshot {
+
+using android::base::unique_fd;
+
+class DmUserBlockServerFactory;
+
+class DmUserDevice final : public IUserDevice {
+  public:
+    explicit DmUserDevice(std::unique_ptr<Tempdevice>&& dev);
+    const std::string& GetPath() override;
+    bool Destroy() override;
+
+  private:
+    std::unique_ptr<Tempdevice> dev_;
+};
+
+class DmUserTestHarness final : public ITestHarness {
+  public:
+    DmUserTestHarness();
+
+    std::unique_ptr<IUserDevice> CreateUserDevice(const std::string& dev_name,
+                                                  const std::string& misc_name,
+                                                  uint64_t num_sectors) override;
+    IBlockServerFactory* GetBlockServerFactory() override;
+    bool HasUserDevice() override { return true; }
+
+  private:
+    std::unique_ptr<DmUserBlockServerFactory> block_server_factory_;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/testing/harness.h b/fs_mgr/libsnapshot/snapuserd/testing/harness.h
new file mode 100644
index 000000000000..c0d528f8ba78
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/testing/harness.h
@@ -0,0 +1,47 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <stddef.h>
+#include <sys/types.h>
+
+#include <memory>
+
+#include <android-base/unique_fd.h>
+#include <snapuserd/block_server.h>
+
+namespace android {
+namespace snapshot {
+
+// Interface for a "block driver in userspace" device.
+class IUserDevice {
+  public:
+    virtual ~IUserDevice() {}
+    virtual const std::string& GetPath() = 0;
+    virtual bool Destroy() = 0;
+};
+
+class ITestHarness {
+  public:
+    virtual ~ITestHarness() {}
+    virtual std::unique_ptr<IUserDevice> CreateUserDevice(const std::string& dev_name,
+                                                          const std::string& misc_name,
+                                                          uint64_t num_sectors) = 0;
+    virtual IBlockServerFactory* GetBlockServerFactory() = 0;
+    virtual bool HasUserDevice() = 0;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 157925d63d59..4ea1d5d08ead 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -41,6 +41,7 @@
 #include <storage_literals/storage_literals.h>
 #include "handler_manager.h"
 #include "snapuserd_core.h"
+#include "testing/dm_user_harness.h"
 #include "testing/temp_device.h"
 
 DEFINE_string(force_config, "", "Force testing mode with iouring disabled");
@@ -75,10 +76,9 @@ class SnapuserdTest : public ::testing::Test {
     static const uint64_t kSectorSize = 512;
 
   protected:
-    void SetUp() override {}
+    void SetUp() override;
     void TearDown() override { Shutdown(); }
 
-  private:
     void SetupImpl();
 
     void SimulateDaemonRestart();
@@ -94,10 +94,10 @@ class SnapuserdTest : public ::testing::Test {
     void InitCowDevice();
     void SetDeviceControlName();
     void InitDaemon();
-    void CreateDmUserDevice();
+    void CreateUserDevice();
 
     unique_ptr<LoopDevice> base_loop_;
-    unique_ptr<Tempdevice> dmuser_dev_;
+    unique_ptr<IUserDevice> dmuser_dev_;
 
     std::string system_device_ctrl_name_;
     std::string system_device_name_;
@@ -112,6 +112,7 @@ class SnapuserdTest : public ::testing::Test {
     size_t size_ = 100_MiB;
     int cow_num_sectors_;
     int total_base_size_;
+    std::unique_ptr<ITestHarness> harness_;
 };
 
 static unique_fd CreateTempFile(const std::string& name, size_t size) {
@@ -132,6 +133,10 @@ static unique_fd CreateTempFile(const std::string& name, size_t size) {
     return fd;
 }
 
+void SnapuserdTest::SetUp() {
+    harness_ = std::make_unique<DmUserTestHarness>();
+}
+
 void SnapuserdTest::Shutdown() {
     ASSERT_TRUE(dmuser_dev_->Destroy());
 
@@ -173,7 +178,7 @@ bool SnapuserdTest::SetupCopyOverlap_2() {
 bool SnapuserdTest::SetupDaemon() {
     SetDeviceControlName();
 
-    CreateDmUserDevice();
+    CreateUserDevice();
     InitCowDevice();
     InitDaemon();
 
@@ -206,7 +211,7 @@ void SnapuserdTest::CreateBaseDevice() {
 }
 
 void SnapuserdTest::ReadSnapshotDeviceAndValidate() {
-    unique_fd fd(open(dmuser_dev_->path().c_str(), O_RDONLY));
+    unique_fd fd(open(dmuser_dev_->GetPath().c_str(), O_RDONLY));
     ASSERT_GE(fd, 0);
     std::unique_ptr<uint8_t[]> snapuserd_buffer = std::make_unique<uint8_t[]>(size_);
 
@@ -535,9 +540,8 @@ void SnapuserdTest::InitCowDevice() {
         use_iouring = false;
     }
 
-    DmUserBlockServerFactory factory;
-
-    auto opener = factory.CreateOpener(system_device_ctrl_name_);
+    auto factory = harness_->GetBlockServerFactory();
+    auto opener = factory->CreateOpener(system_device_ctrl_name_);
     auto handler =
             handlers_.AddHandler(system_device_ctrl_name_, cow_system_->path, base_loop_->device(),
                                  base_loop_->device(), opener, 1, use_iouring, false);
@@ -560,7 +564,7 @@ void SnapuserdTest::SetDeviceControlName() {
     system_device_ctrl_name_ = system_device_name_ + "-ctrl";
 }
 
-void SnapuserdTest::CreateDmUserDevice() {
+void SnapuserdTest::CreateUserDevice() {
     unique_fd fd(TEMP_FAILURE_RETRY(open(base_loop_->device().c_str(), O_RDONLY | O_CLOEXEC)));
     ASSERT_TRUE(fd > 0);
 
@@ -569,17 +573,9 @@ void SnapuserdTest::CreateDmUserDevice() {
 
     cow_num_sectors_ = dev_sz >> 9;
 
-    DmTable dmuser_table;
-    ASSERT_TRUE(dmuser_table.AddTarget(
-            std::make_unique<DmTargetUser>(0, cow_num_sectors_, system_device_ctrl_name_)));
-    ASSERT_TRUE(dmuser_table.valid());
-
-    dmuser_dev_ = std::make_unique<Tempdevice>(system_device_name_, dmuser_table);
-    ASSERT_TRUE(dmuser_dev_->valid());
-    ASSERT_FALSE(dmuser_dev_->path().empty());
-
-    auto misc_device = "/dev/dm-user/" + system_device_ctrl_name_;
-    ASSERT_TRUE(android::fs_mgr::WaitForFile(misc_device, 10s));
+    dmuser_dev_ = harness_->CreateUserDevice(system_device_name_, system_device_ctrl_name_,
+                                             cow_num_sectors_);
+    ASSERT_NE(dmuser_dev_, nullptr);
 }
 
 void SnapuserdTest::InitDaemon() {
@@ -603,7 +599,7 @@ void SnapuserdTest::SetupImpl() {
 
     SetDeviceControlName();
 
-    CreateDmUserDevice();
+    CreateUserDevice();
     InitCowDevice();
     InitDaemon();
 
@@ -632,7 +628,7 @@ void SnapuserdTest::SimulateDaemonRestart() {
     Shutdown();
     std::this_thread::sleep_for(500ms);
     SetDeviceControlName();
-    CreateDmUserDevice();
+    CreateUserDevice();
     InitCowDevice();
     InitDaemon();
 }
@@ -695,6 +691,9 @@ void SnapuserdTest::MergeInterrupt() {
 }
 
 TEST_F(SnapuserdTest, Snapshot_IO_TEST) {
+    if (!harness_->HasUserDevice()) {
+        GTEST_SKIP() << "Skipping snapshot read; not supported";
+    }
     ASSERT_TRUE(SetupDefault());
     // I/O before merge
     ReadSnapshotDeviceAndValidate();
@@ -707,6 +706,9 @@ TEST_F(SnapuserdTest, Snapshot_IO_TEST) {
 }
 
 TEST_F(SnapuserdTest, Snapshot_MERGE_IO_TEST) {
+    if (!harness_->HasUserDevice()) {
+        GTEST_SKIP() << "Skipping snapshot read; not supported";
+    }
     ASSERT_TRUE(SetupDefault());
     // Issue I/O before merge begins
     std::async(std::launch::async, &SnapuserdTest::ReadSnapshotDeviceAndValidate, this);
@@ -717,6 +719,9 @@ TEST_F(SnapuserdTest, Snapshot_MERGE_IO_TEST) {
 }
 
 TEST_F(SnapuserdTest, Snapshot_MERGE_IO_TEST_1) {
+    if (!harness_->HasUserDevice()) {
+        GTEST_SKIP() << "Skipping snapshot read; not supported";
+    }
     ASSERT_TRUE(SetupDefault());
     // Start the merge
     StartMerge();

From dba77ad7377d18eefeaa2cdb661660e39e02e595 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 3 Aug 2023 16:53:55 -0700
Subject: [PATCH 0283/1487] snapuserd: Factor setpriority/settid calls into a
 helper.

This allows disabling the code in host builds, since settid() isn't
available in the glibc prebuilt.

Bug: 288273605
Test: snapuserd_test
Change-Id: Ifddb5cb8b04484a1ab0a29794d65c9839759a919
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |  1 +
 .../user-space-merge/merge_worker.cpp         |  5 +--
 .../user-space-merge/read_worker.cpp          |  5 +--
 .../user-space-merge/snapuserd_readahead.cpp  |  5 +--
 .../user-space-merge/snapuserd_test.cpp       |  1 +
 fs_mgr/libsnapshot/snapuserd/utility.cpp      | 36 +++++++++++++++++++
 fs_mgr/libsnapshot/snapuserd/utility.h        | 23 ++++++++++++
 7 files changed, 70 insertions(+), 6 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/utility.cpp
 create mode 100644 fs_mgr/libsnapshot/snapuserd/utility.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 2368f8f360a0..6251e5aeafb3 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -72,6 +72,7 @@ cc_library_static {
         "user-space-merge/snapuserd_transitions.cpp",
         "user-space-merge/snapuserd_verify.cpp",
         "user-space-merge/worker.cpp",
+        "utility.cpp",
     ],
     static_libs: [
         "libbase",
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index a83cab8d8b4c..2d6972171ea7 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -16,6 +16,7 @@
 #include "merge_worker.h"
 
 #include "snapuserd_core.h"
+#include "utility.h"
 
 namespace android {
 namespace snapshot {
@@ -550,8 +551,8 @@ bool MergeWorker::Run() {
         return true;
     }
 
-    if (setpriority(PRIO_PROCESS, gettid(), kNiceValueForMergeThreads)) {
-        SNAP_PLOG(ERROR) << "Failed to set priority for TID: " << gettid();
+    if (!SetThreadPriority(kNiceValueForMergeThreads)) {
+        SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
     SNAP_LOG(INFO) << "Merge starting..";
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index ce4be4348f8b..e2c292bd85bb 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -17,6 +17,7 @@
 #include "read_worker.h"
 
 #include "snapuserd_core.h"
+#include "utility.h"
 
 namespace android {
 namespace snapshot {
@@ -208,8 +209,8 @@ bool ReadWorker::Init() {
 bool ReadWorker::Run() {
     SNAP_LOG(INFO) << "Processing snapshot I/O requests....";
 
-    if (setpriority(PRIO_PROCESS, gettid(), kNiceValueForMergeThreads)) {
-        SNAP_PLOG(ERROR) << "Failed to set priority for TID: " << gettid();
+    if (!SetThreadPriority(kNiceValueForMergeThreads)) {
+        SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
     // Start serving IO
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index 8755820e1ed2..8b799ea93a7c 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -17,6 +17,7 @@
 #include "snapuserd_readahead.h"
 
 #include "snapuserd_core.h"
+#include "utility.h"
 
 namespace android {
 namespace snapshot {
@@ -765,8 +766,8 @@ bool ReadAhead::RunThread() {
 
     InitializeIouring();
 
-    if (setpriority(PRIO_PROCESS, gettid(), kNiceValueForMergeThreads)) {
-        SNAP_PLOG(ERROR) << "Failed to set priority for TID: " << gettid();
+    if (!SetThreadPriority(kNiceValueForMergeThreads)) {
+        SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
     while (!RAIterDone()) {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 4ea1d5d08ead..c40783499bb0 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -43,6 +43,7 @@
 #include "snapuserd_core.h"
 #include "testing/dm_user_harness.h"
 #include "testing/temp_device.h"
+#include "utility.h"
 
 DEFINE_string(force_config, "", "Force testing mode with iouring disabled");
 
diff --git a/fs_mgr/libsnapshot/snapuserd/utility.cpp b/fs_mgr/libsnapshot/snapuserd/utility.cpp
new file mode 100644
index 000000000000..a84a7c14fc5e
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/utility.cpp
@@ -0,0 +1,36 @@
+// Copyright (C) 2023 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 "utility.h"
+
+#include <sys/resource.h>
+#include <unistd.h>
+
+#include <android-base/file.h>
+
+namespace android {
+namespace snapshot {
+
+using android::base::unique_fd;
+
+bool SetThreadPriority([[maybe_unused]] int priority) {
+#ifdef __ANDROID__
+    return setpriority(PRIO_PROCESS, gettid(), priority) != -1;
+#else
+    return true;
+#endif
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/utility.h b/fs_mgr/libsnapshot/snapuserd/utility.h
new file mode 100644
index 000000000000..58ec3e63a3b3
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/utility.h
@@ -0,0 +1,23 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+namespace android {
+namespace snapshot {
+
+bool SetThreadPriority(int priority);
+
+}  // namespace snapshot
+}  // namespace android

From 1cb36d300e3366d000086a0b2cac06c8187d34cb Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 8 Aug 2023 08:51:48 -0700
Subject: [PATCH 0284/1487] Adding struct to hold compresion parameters

Since we're adding compression levels should consolidate this
information into one structure.  Adding in CowCompression struct
to hold this information and refactoring code to work off this struct

Test: ota
Change-Id: I969a3ae19ec80fd964bcfb76b39f42f8dd31a56d
---
 .../include/libsnapshot/cow_format.h           |  4 ++++
 fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp |  3 ++-
 .../libsnapshot/libsnapshot_cow/writer_v2.cpp  | 18 +++++++++---------
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h |  2 +-
 4 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 3a81f6384e7d..c9a4dee3af41 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -161,6 +161,10 @@ enum CowCompressionAlgorithm : uint8_t {
     kCowCompressLz4 = 3,
     kCowCompressZstd = 4,
 };
+struct CowCompression {
+    CowCompressionAlgorithm algorithm = kCowCompressNone;
+    uint32_t compression_level = 0;
+};
 
 static constexpr uint8_t kCowReadAheadNotStarted = 0;
 static constexpr uint8_t kCowReadAheadInProgress = 1;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 31b9a5840934..ab275d4eba0f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -472,9 +472,10 @@ TEST_P(CompressionTest, HorribleStream) {
     if (strcmp(GetParam(), "none") == 0) {
         GTEST_SKIP();
     }
-
+    CowCompression compression;
     auto algorithm = CompressionAlgorithmFromString(GetParam());
     ASSERT_TRUE(algorithm.has_value());
+    compression.algorithm = algorithm.value();
 
     std::string expected = "The quick brown fox jumps over the lazy dog.";
     expected.resize(4096, '\0');
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index c5499697286d..cbd7569d210f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -124,7 +124,7 @@ bool CowWriterV2::ParseOptions() {
         LOG(ERROR) << "unrecognized compression: " << options_.compression;
         return false;
     }
-    compression_ = *algorithm;
+    compression_.algorithm = *algorithm;
 
     if (options_.cluster_ops == 1) {
         LOG(ERROR) << "Clusters must contain at least two operations to function.";
@@ -165,7 +165,7 @@ void CowWriterV2::InitWorkers() {
         return;
     }
     for (int i = 0; i < num_compress_threads_; i++) {
-        auto wt = std::make_unique<CompressWorker>(compression_, header_.block_size);
+        auto wt = std::make_unique<CompressWorker>(compression_.algorithm, header_.block_size);
         threads_.emplace_back(std::async(std::launch::async, &CompressWorker::RunThread, wt.get()));
         compress_threads_.push_back(std::move(wt));
     }
@@ -320,8 +320,8 @@ bool CowWriterV2::CompressBlocks(size_t num_blocks, const void* data) {
     const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
     compressed_buf_.clear();
     if (num_threads <= 1) {
-        return CompressWorker::CompressBlocks(compression_, options_.block_size, data, num_blocks,
-                                              &compressed_buf_);
+        return CompressWorker::CompressBlocks(compression_.algorithm, options_.block_size, data,
+                                              num_blocks, &compressed_buf_);
     }
 
     // Submit the blocks per thread. The retrieval of
@@ -366,7 +366,7 @@ bool CowWriterV2::EmitBlocks(uint64_t new_block_start, const void* data, size_t
     while (num_blocks) {
         size_t pending_blocks = (std::min(kProcessingBlocks, num_blocks));
 
-        if (compression_ && num_compress_threads_ > 1) {
+        if (compression_.algorithm && num_compress_threads_ > 1) {
             if (!CompressBlocks(pending_blocks, iter)) {
                 return false;
             }
@@ -386,19 +386,19 @@ bool CowWriterV2::EmitBlocks(uint64_t new_block_start, const void* data, size_t
                 op.source = next_data_pos_;
             }
 
-            if (compression_) {
+            if (compression_.algorithm) {
                 auto data = [&, this]() {
                     if (num_compress_threads_ > 1) {
                         auto data = std::move(*buf_iter_);
                         buf_iter_++;
                         return data;
                     } else {
-                        auto data =
-                                CompressWorker::Compress(compression_, iter, header_.block_size);
+                        auto data = CompressWorker::Compress(compression_.algorithm, iter,
+                                                             header_.block_size);
                         return data;
                     }
                 }();
-                op.compression = compression_;
+                op.compression = compression_.algorithm;
                 op.data_length = static_cast<uint16_t>(data.size());
 
                 if (!WriteOperation(op, data.data(), data.size())) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
index 809ae5747935..1aa851872f42 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
@@ -63,7 +63,7 @@ class CowWriterV2 : public CowWriterBase {
 
   private:
     CowFooter footer_{};
-    CowCompressionAlgorithm compression_ = kCowCompressNone;
+    CowCompression compression_;
     uint64_t current_op_pos_ = 0;
     uint64_t next_op_pos_ = 0;
     uint64_t next_data_pos_ = 0;

From db70cbf78a874cbb679f92cdf8f395cbc7483c25 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 3 Aug 2023 16:57:12 -0700
Subject: [PATCH 0285/1487] snapuserd: Remove test dependence on LoopDevice.

LoopDevice requires root, which is an obstacle to running this test in
automation. The test also requires memfd which is not available in our
included glibc. Create an IBackingDevice layer so we can use temporary
files instead on host tests, while keeping the block-device code for
on-device tests, which more closely matches how snapuserd runs.

Bug: 288273605
Test: snapuserd_test
Change-Id: I89b154921b6bbcf8fe213ef7f5c4da4d48322909
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   1 +
 .../libsnapshot/snapuserd/testing/harness.cpp | 116 ++++++++++++++++++
 .../libsnapshot/snapuserd/testing/harness.h   |   9 ++
 .../user-space-merge/snapuserd_test.cpp       |  47 ++-----
 4 files changed, 138 insertions(+), 35 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/testing/harness.cpp

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 6251e5aeafb3..fc260b6921c4 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -221,6 +221,7 @@ cc_test {
     ],
     srcs: [
         "testing/dm_user_harness.cpp",
+        "testing/harness.cpp",
         "user-space-merge/snapuserd_test.cpp",
     ],
     shared_libs: [
diff --git a/fs_mgr/libsnapshot/snapuserd/testing/harness.cpp b/fs_mgr/libsnapshot/snapuserd/testing/harness.cpp
new file mode 100644
index 000000000000..02ae549d1cc0
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/testing/harness.cpp
@@ -0,0 +1,116 @@
+// Copyright (C) 2023 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 "harness.h"
+
+#ifdef __ANDROID__
+#include <linux/memfd.h>
+#endif
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <unistd.h>
+
+#include <android-base/file.h>
+#include <ext4_utils/ext4_utils.h>
+#include <libdm/loop_control.h>
+#include "snapuserd_logging.h"
+
+namespace android {
+namespace snapshot {
+
+using namespace std::chrono_literals;
+using android::base::unique_fd;
+using android::dm::LoopDevice;
+
+#ifdef __ANDROID__
+// Prefer this on device since it is a real block device, which is more similar
+// to how we use snapuserd.
+class MemoryBackedDevice final : public IBackingDevice {
+  public:
+    bool Init(uint64_t size) {
+        memfd_.reset(memfd_create("snapuserd_test", MFD_ALLOW_SEALING));
+        if (memfd_ < 0) {
+            PLOG(ERROR) << "memfd_create failed";
+            return false;
+        }
+        if (ftruncate(memfd_.get(), size) < 0) {
+            PLOG(ERROR) << "ftruncate failed";
+            return false;
+        }
+        if (fcntl(memfd_.get(), F_ADD_SEALS, F_SEAL_GROW | F_SEAL_SHRINK) < 0) {
+            PLOG(ERROR) << "fcntl seal failed";
+            return false;
+        }
+        dev_ = std::make_unique<LoopDevice>(memfd_, 10s);
+        return dev_->valid();
+    }
+    const std::string& GetPath() override { return dev_->device(); }
+    uint64_t GetSize() override {
+        unique_fd fd(open(GetPath().c_str(), O_RDONLY | O_CLOEXEC));
+        if (fd < 0) {
+            PLOG(ERROR) << "open failed: " << GetPath();
+            return 0;
+        }
+        return get_block_device_size(fd.get());
+    }
+
+  private:
+    unique_fd memfd_;
+    std::unique_ptr<LoopDevice> dev_;
+};
+#endif
+
+class FileBackedDevice final : public IBackingDevice {
+  public:
+    bool Init(uint64_t size) {
+        if (temp_.fd < 0) {
+            return false;
+        }
+        if (ftruncate(temp_.fd, size) < 0) {
+            PLOG(ERROR) << "ftruncate failed: " << temp_.path;
+            return false;
+        }
+        path_ = temp_.path;
+        return true;
+    }
+
+    const std::string& GetPath() override { return path_; }
+    uint64_t GetSize() override {
+        off_t off = lseek(temp_.fd, 0, SEEK_END);
+        if (off < 0) {
+            PLOG(ERROR) << "lseek failed: " << temp_.path;
+            return 0;
+        }
+        return off;
+    }
+
+  private:
+    TemporaryFile temp_;
+    std::string path_;
+};
+
+std::unique_ptr<IBackingDevice> ITestHarness::CreateBackingDevice(uint64_t size) {
+#ifdef __ANDROID__
+    auto dev = std::make_unique<MemoryBackedDevice>();
+#else
+    auto dev = std::make_unique<FileBackedDevice>();
+#endif
+    if (!dev->Init(size)) {
+        return nullptr;
+    }
+    return dev;
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/testing/harness.h b/fs_mgr/libsnapshot/snapuserd/testing/harness.h
index c0d528f8ba78..ffe9f7bc72e2 100644
--- a/fs_mgr/libsnapshot/snapuserd/testing/harness.h
+++ b/fs_mgr/libsnapshot/snapuserd/testing/harness.h
@@ -33,6 +33,14 @@ class IUserDevice {
     virtual bool Destroy() = 0;
 };
 
+// Interface for an fd/temp file that is a block device when possible.
+class IBackingDevice {
+  public:
+    virtual ~IBackingDevice() {}
+    virtual const std::string& GetPath() = 0;
+    virtual uint64_t GetSize() = 0;
+};
+
 class ITestHarness {
   public:
     virtual ~ITestHarness() {}
@@ -41,6 +49,7 @@ class ITestHarness {
                                                           uint64_t num_sectors) = 0;
     virtual IBlockServerFactory* GetBlockServerFactory() = 0;
     virtual bool HasUserDevice() = 0;
+    virtual std::unique_ptr<IBackingDevice> CreateBackingDevice(uint64_t size);
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index c40783499bb0..7e1b2c40f3f7 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -17,7 +17,6 @@
 
 #include <fcntl.h>
 #include <linux/fs.h>
-#include <linux/memfd.h>
 #include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <sys/syscall.h>
@@ -97,7 +96,7 @@ class SnapuserdTest : public ::testing::Test {
     void InitDaemon();
     void CreateUserDevice();
 
-    unique_ptr<LoopDevice> base_loop_;
+    unique_ptr<IBackingDevice> base_dev_;
     unique_ptr<IUserDevice> dmuser_dev_;
 
     std::string system_device_ctrl_name_;
@@ -116,24 +115,6 @@ class SnapuserdTest : public ::testing::Test {
     std::unique_ptr<ITestHarness> harness_;
 };
 
-static unique_fd CreateTempFile(const std::string& name, size_t size) {
-    unique_fd fd(syscall(__NR_memfd_create, name.c_str(), MFD_ALLOW_SEALING));
-    if (fd < 0) {
-        return {};
-    }
-    if (size) {
-        if (ftruncate(fd, size) < 0) {
-            perror("ftruncate");
-            return {};
-        }
-        if (fcntl(fd, F_ADD_SEALS, F_SEAL_GROW | F_SEAL_SHRINK) < 0) {
-            perror("fcntl");
-            return {};
-        }
-    }
-    return fd;
-}
-
 void SnapuserdTest::SetUp() {
     harness_ = std::make_unique<DmUserTestHarness>();
 }
@@ -189,14 +170,16 @@ bool SnapuserdTest::SetupDaemon() {
 }
 
 void SnapuserdTest::CreateBaseDevice() {
-    unique_fd rnd_fd;
-
     total_base_size_ = (size_ * 5);
-    base_fd_ = CreateTempFile("base_device", total_base_size_);
+
+    base_dev_ = harness_->CreateBackingDevice(total_base_size_);
+    ASSERT_NE(base_dev_, nullptr);
+
+    base_fd_.reset(open(base_dev_->GetPath().c_str(), O_RDWR | O_CLOEXEC));
     ASSERT_GE(base_fd_, 0);
 
-    rnd_fd.reset(open("/dev/random", O_RDONLY));
-    ASSERT_TRUE(rnd_fd > 0);
+    unique_fd rnd_fd(open("/dev/random", O_RDONLY));
+    ASSERT_GE(rnd_fd, 0);
 
     std::unique_ptr<uint8_t[]> random_buffer = std::make_unique<uint8_t[]>(1_MiB);
 
@@ -206,9 +189,6 @@ void SnapuserdTest::CreateBaseDevice() {
     }
 
     ASSERT_EQ(lseek(base_fd_, 0, SEEK_SET), 0);
-
-    base_loop_ = std::make_unique<LoopDevice>(base_fd_, 10s);
-    ASSERT_TRUE(base_loop_->valid());
 }
 
 void SnapuserdTest::ReadSnapshotDeviceAndValidate() {
@@ -544,8 +524,8 @@ void SnapuserdTest::InitCowDevice() {
     auto factory = harness_->GetBlockServerFactory();
     auto opener = factory->CreateOpener(system_device_ctrl_name_);
     auto handler =
-            handlers_.AddHandler(system_device_ctrl_name_, cow_system_->path, base_loop_->device(),
-                                 base_loop_->device(), opener, 1, use_iouring, false);
+            handlers_.AddHandler(system_device_ctrl_name_, cow_system_->path, base_dev_->GetPath(),
+                                 base_dev_->GetPath(), opener, 1, use_iouring, false);
     ASSERT_NE(handler, nullptr);
     ASSERT_NE(handler->snapuserd(), nullptr);
 #ifdef __ANDROID__
@@ -566,11 +546,8 @@ void SnapuserdTest::SetDeviceControlName() {
 }
 
 void SnapuserdTest::CreateUserDevice() {
-    unique_fd fd(TEMP_FAILURE_RETRY(open(base_loop_->device().c_str(), O_RDONLY | O_CLOEXEC)));
-    ASSERT_TRUE(fd > 0);
-
-    uint64_t dev_sz = get_block_device_size(fd.get());
-    ASSERT_TRUE(dev_sz > 0);
+    auto dev_sz = base_dev_->GetSize();
+    ASSERT_NE(dev_sz, 0);
 
     cow_num_sectors_ = dev_sz >> 9;
 

From 02191dbfac2c7a555d9d154ec9b2aa23a8313ebc Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 5 Jul 2023 16:54:42 -0700
Subject: [PATCH 0286/1487] snapuserd: Fix race condition in HandleManager
 shutdown.

When HandlerManager shuts down, the monitor thread is left detached. The
monitor thread does not hold a shared_ptr reference to the
HandlerManager, so the pointer can be left dangling.

Fix this by not detaching the monitor merge thread.

This patch also changes the test harness to destroy
SnapshotHandlerManager on "shutdown", to avoid state leaking into the
next instance of snapuserd.

Bug: 288273605
Test: snapuserd_test
Change-Id: Iaaf96a37657c85cff4d2a8b15ccfde4aa03d3220
---
 .../user-space-merge/handler_manager.cpp      | 13 ++++++++-----
 .../user-space-merge/handler_manager.h        |  2 +-
 .../user-space-merge/snapuserd_test.cpp       | 19 +++++++++++--------
 3 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index fd41cd419b3c..50b9d4331482 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -201,9 +201,8 @@ bool SnapshotHandlerManager::StartMerge(std::lock_guard<std::mutex>* proof_of_lo
 
     handler->snapuserd()->MonitorMerge();
 
-    if (!is_merge_monitor_started_) {
-        std::thread(&SnapshotHandlerManager::MonitorMerge, this).detach();
-        is_merge_monitor_started_ = true;
+    if (!merge_monitor_.joinable()) {
+        merge_monitor_ = std::thread(&SnapshotHandlerManager::MonitorMerge, this);
     }
 
     merge_handlers_.push(handler);
@@ -357,8 +356,12 @@ void SnapshotHandlerManager::JoinAllThreads() {
         if (th.joinable()) th.join();
     }
 
-    stop_monitor_merge_thread_ = true;
-    WakeupMonitorMergeThread();
+    if (merge_monitor_.joinable()) {
+        stop_monitor_merge_thread_ = true;
+        WakeupMonitorMergeThread();
+
+        merge_monitor_.join();
+    }
 }
 
 auto SnapshotHandlerManager::FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
index 2a6da964e02c..b1605f0989fe 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
@@ -122,9 +122,9 @@ class SnapshotHandlerManager final : public ISnapshotHandlerManager {
     std::mutex lock_;
     HandlerList dm_users_;
 
-    bool is_merge_monitor_started_ = false;
     bool stop_monitor_merge_thread_ = false;
     int active_merge_threads_ = 0;
+    std::thread merge_monitor_;
     int num_partitions_merge_complete_ = 0;
     std::queue<std::shared_ptr<HandlerThread>> merge_handlers_;
     android::base::unique_fd monitor_merge_event_fd_;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 7e1b2c40f3f7..0e02f0b853cf 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -106,7 +106,7 @@ class SnapuserdTest : public ::testing::Test {
     std::unique_ptr<TemporaryFile> cow_system_;
     std::unique_ptr<uint8_t[]> orig_buffer_;
     std::unique_ptr<uint8_t[]> merged_buffer_;
-    SnapshotHandlerManager handlers_;
+    std::unique_ptr<SnapshotHandlerManager> handlers_;
     bool setup_ok_ = false;
     bool merge_ok_ = false;
     size_t size_ = 100_MiB;
@@ -117,15 +117,18 @@ class SnapuserdTest : public ::testing::Test {
 
 void SnapuserdTest::SetUp() {
     harness_ = std::make_unique<DmUserTestHarness>();
+    handlers_ = std::make_unique<SnapshotHandlerManager>();
 }
 
 void SnapuserdTest::Shutdown() {
     ASSERT_TRUE(dmuser_dev_->Destroy());
 
     auto misc_device = "/dev/dm-user/" + system_device_ctrl_name_;
-    ASSERT_TRUE(handlers_.DeleteHandler(system_device_ctrl_name_));
+    ASSERT_TRUE(handlers_->DeleteHandler(system_device_ctrl_name_));
     ASSERT_TRUE(android::fs_mgr::WaitForFileDeleted(misc_device, 10s));
-    handlers_.TerminateMergeThreads();
+    handlers_->TerminateMergeThreads();
+    handlers_->JoinAllThreads();
+    handlers_ = std::make_unique<SnapshotHandlerManager>();
 }
 
 bool SnapuserdTest::SetupDefault() {
@@ -524,8 +527,8 @@ void SnapuserdTest::InitCowDevice() {
     auto factory = harness_->GetBlockServerFactory();
     auto opener = factory->CreateOpener(system_device_ctrl_name_);
     auto handler =
-            handlers_.AddHandler(system_device_ctrl_name_, cow_system_->path, base_dev_->GetPath(),
-                                 base_dev_->GetPath(), opener, 1, use_iouring, false);
+            handlers_->AddHandler(system_device_ctrl_name_, cow_system_->path, base_dev_->GetPath(),
+                                  base_dev_->GetPath(), opener, 1, use_iouring, false);
     ASSERT_NE(handler, nullptr);
     ASSERT_NE(handler->snapuserd(), nullptr);
 #ifdef __ANDROID__
@@ -557,12 +560,12 @@ void SnapuserdTest::CreateUserDevice() {
 }
 
 void SnapuserdTest::InitDaemon() {
-    ASSERT_TRUE(handlers_.StartHandler(system_device_ctrl_name_));
+    ASSERT_TRUE(handlers_->StartHandler(system_device_ctrl_name_));
 }
 
 void SnapuserdTest::CheckMergeCompletion() {
     while (true) {
-        double percentage = handlers_.GetMergePercentage();
+        double percentage = handlers_->GetMergePercentage();
         if ((int)percentage == 100) {
             break;
         }
@@ -592,7 +595,7 @@ bool SnapuserdTest::Merge() {
 }
 
 void SnapuserdTest::StartMerge() {
-    ASSERT_TRUE(handlers_.InitiateMerge(system_device_ctrl_name_));
+    ASSERT_TRUE(handlers_->InitiateMerge(system_device_ctrl_name_));
 }
 
 void SnapuserdTest::ValidateMerge() {

From 9aa421824686f102276a5578db2e9366bc4d2060 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 5 Jul 2023 16:57:28 -0700
Subject: [PATCH 0287/1487] snapuserd: Add diagnostics for debugging races.

Adds calls to pthread_setname_np for each thread.

Clarify error messages from io_uring calls that return -errno.

Add log messages for some failure paths that didn't have any.

Add an ostream overload for MERGE_IO_TRANSITION, and add an INVALID
state for initialization.

Bug: 288273605
Test: builds
Change-Id: Ic0681cbf0017af67bcf52b98db184a9b48752faf
---
 .../user-space-merge/handler_manager.cpp      |  4 ++++
 .../user-space-merge/merge_worker.cpp         |  8 ++++++-
 .../user-space-merge/read_worker.cpp          |  4 ++++
 .../user-space-merge/snapuserd_core.cpp       |  2 --
 .../user-space-merge/snapuserd_core.h         |  8 +++++--
 .../user-space-merge/snapuserd_readahead.cpp  | 12 ++++++++--
 .../snapuserd_transitions.cpp                 | 24 +++++++++++++++++++
 7 files changed, 55 insertions(+), 7 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index 50b9d4331482..d979e20c0c0a 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -14,6 +14,7 @@
 
 #include "handler_manager.h"
 
+#include <pthread.h>
 #include <sys/eventfd.h>
 
 #include <android-base/logging.h>
@@ -132,6 +133,8 @@ bool SnapshotHandlerManager::DeleteHandler(const std::string& misc_name) {
 void SnapshotHandlerManager::RunThread(std::shared_ptr<HandlerThread> handler) {
     LOG(INFO) << "Entering thread for handler: " << handler->misc_name();
 
+    pthread_setname_np(pthread_self(), "Handler");
+
     if (!handler->snapuserd()->Start()) {
         LOG(ERROR) << " Failed to launch all worker threads";
     }
@@ -219,6 +222,7 @@ void SnapshotHandlerManager::WakeupMonitorMergeThread() {
 }
 
 void SnapshotHandlerManager::MonitorMerge() {
+    pthread_setname_np(pthread_self(), "Merge Monitor");
     while (!stop_monitor_merge_thread_) {
         uint64_t testVal;
         ssize_t ret =
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index 2d6972171ea7..11b8d7c92f0e 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -15,6 +15,8 @@
  */
 #include "merge_worker.h"
 
+#include <pthread.h>
+
 #include "snapuserd_core.h"
 #include "utility.h"
 
@@ -198,6 +200,7 @@ bool MergeWorker::MergeOrderedOpsAsync() {
         // Wait for RA thread to notify that the merge window
         // is ready for merging.
         if (!snapuserd_->WaitForMergeBegin()) {
+            SNAP_LOG(ERROR) << "Failed waiting for merge to begin";
             return false;
         }
 
@@ -303,7 +306,7 @@ bool MergeWorker::MergeOrderedOpsAsync() {
                     // will fallback to synchronous I/O.
                     ret = io_uring_wait_cqe(ring_.get(), &cqe);
                     if (ret) {
-                        SNAP_LOG(ERROR) << "Merge: io_uring_wait_cqe failed: " << ret;
+                        SNAP_LOG(ERROR) << "Merge: io_uring_wait_cqe failed: " << strerror(-ret);
                         status = false;
                         break;
                     }
@@ -546,6 +549,9 @@ void MergeWorker::FinalizeIouring() {
 
 bool MergeWorker::Run() {
     SNAP_LOG(DEBUG) << "Waiting for merge begin...";
+
+    pthread_setname_np(pthread_self(), "MergeWorker");
+
     if (!snapuserd_->WaitForMergeBegin()) {
         SNAP_LOG(ERROR) << "Merge terminated early...";
         return true;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index e2c292bd85bb..b9ecfa5b3235 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -16,6 +16,8 @@
 
 #include "read_worker.h"
 
+#include <pthread.h>
+
 #include "snapuserd_core.h"
 #include "utility.h"
 
@@ -209,6 +211,8 @@ bool ReadWorker::Init() {
 bool ReadWorker::Run() {
     SNAP_LOG(INFO) << "Processing snapshot I/O requests....";
 
+    pthread_setname_np(pthread_self(), "ReadWorker");
+
     if (!SetThreadPriority(kNiceValueForMergeThreads)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 5a82ca1f4d92..c2958512d1c1 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -295,8 +295,6 @@ bool SnapshotHandler::Start() {
     if (ra_thread_) {
         ra_thread_status =
                 std::async(std::launch::async, &ReadAhead::RunThread, read_ahead_thread_.get());
-
-        SNAP_LOG(INFO) << "Read-ahead thread started";
     }
 
     // Launch worker threads
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index a45e0bcc76e7..622fc5028dbe 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -28,6 +28,7 @@
 #include <iostream>
 #include <limits>
 #include <mutex>
+#include <ostream>
 #include <string>
 #include <thread>
 #include <unordered_map>
@@ -68,12 +69,13 @@ static constexpr int kNiceValueForMergeThreads = -5;
 #define SNAP_PLOG(level) PLOG(level) << misc_name_ << ": "
 
 enum class MERGE_IO_TRANSITION {
+    INVALID,
     MERGE_READY,
     MERGE_BEGIN,
     MERGE_FAILED,
     MERGE_COMPLETE,
     IO_TERMINATED,
-    READ_AHEAD_FAILURE,
+    READ_AHEAD_FAILURE
 };
 
 class MergeWorker;
@@ -220,7 +222,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     bool populate_data_from_cow_ = false;
     bool ra_thread_ = false;
     int total_ra_blocks_merged_ = 0;
-    MERGE_IO_TRANSITION io_state_;
+    MERGE_IO_TRANSITION io_state_ = MERGE_IO_TRANSITION::INVALID;
     std::unique_ptr<ReadAhead> read_ahead_thread_;
     std::unordered_map<uint64_t, void*> read_ahead_buffer_map_;
 
@@ -246,5 +248,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     std::shared_ptr<IBlockServerOpener> block_server_opener_;
 };
 
+std::ostream& operator<<(std::ostream& os, MERGE_IO_TRANSITION value);
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index 8b799ea93a7c..d2128c5d02fa 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -16,6 +16,8 @@
 
 #include "snapuserd_readahead.h"
 
+#include <pthread.h>
+
 #include "snapuserd_core.h"
 #include "utility.h"
 
@@ -428,7 +430,7 @@ bool ReadAhead::ReapIoCompletions(int pending_ios_to_complete) {
         // will fallback to synchronous I/O.
         int ret = io_uring_wait_cqe(ring_.get(), &cqe);
         if (ret) {
-            SNAP_LOG(ERROR) << "Read-ahead - io_uring_wait_cqe failed: " << ret;
+            SNAP_LOG(ERROR) << "Read-ahead - io_uring_wait_cqe failed: " << strerror(-ret);
             status = false;
             break;
         }
@@ -691,6 +693,7 @@ bool ReadAhead::ReadAheadIOStart() {
     // window. If there is a crash during this time frame, merge should resume
     // based on the contents of the scratch space.
     if (!snapuserd_->WaitForMergeReady()) {
+        SNAP_LOG(ERROR) << "ReadAhead failed to wait for merge ready";
         return false;
     }
 
@@ -752,6 +755,10 @@ void ReadAhead::FinalizeIouring() {
 }
 
 bool ReadAhead::RunThread() {
+    SNAP_LOG(INFO) << "ReadAhead thread started.";
+
+    pthread_setname_np(pthread_self(), "ReadAhead");
+
     if (!InitializeFds()) {
         return false;
     }
@@ -770,6 +777,7 @@ bool ReadAhead::RunThread() {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
+    SNAP_LOG(INFO) << "ReadAhead processing.";
     while (!RAIterDone()) {
         if (!ReadAheadIOStart()) {
             break;
@@ -780,7 +788,7 @@ bool ReadAhead::RunThread() {
     CloseFds();
     reader_->CloseCowFd();
 
-    SNAP_LOG(INFO) << " ReadAhead thread terminating....";
+    SNAP_LOG(INFO) << " ReadAhead thread terminating.";
     return true;
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
index 28c9f688a8cc..52e4f89cd124 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
@@ -199,6 +199,7 @@ bool SnapshotHandler::WaitForMergeBegin() {
 
             if (io_state_ == MERGE_IO_TRANSITION::READ_AHEAD_FAILURE ||
                 io_state_ == MERGE_IO_TRANSITION::IO_TERMINATED) {
+                SNAP_LOG(ERROR) << "WaitForMergeBegin failed with state: " << io_state_;
                 return false;
             }
         }
@@ -211,6 +212,7 @@ bool SnapshotHandler::WaitForMergeBegin() {
 
         if (io_state_ == MERGE_IO_TRANSITION::READ_AHEAD_FAILURE ||
             io_state_ == MERGE_IO_TRANSITION::IO_TERMINATED) {
+            SNAP_LOG(ERROR) << "WaitForMergeBegin failed with state: " << io_state_;
             return false;
         }
 
@@ -277,6 +279,7 @@ bool SnapshotHandler::WaitForMergeReady() {
         if (io_state_ == MERGE_IO_TRANSITION::MERGE_FAILED ||
             io_state_ == MERGE_IO_TRANSITION::MERGE_COMPLETE ||
             io_state_ == MERGE_IO_TRANSITION::IO_TERMINATED) {
+            SNAP_LOG(ERROR) << "Wait for merge ready failed: " << io_state_;
             return false;
         }
         return true;
@@ -668,5 +671,26 @@ MERGE_GROUP_STATE SnapshotHandler::ProcessMergingBlock(uint64_t new_block, void*
     }
 }
 
+std::ostream& operator<<(std::ostream& os, MERGE_IO_TRANSITION value) {
+    switch (value) {
+        case MERGE_IO_TRANSITION::INVALID:
+            return os << "INVALID";
+        case MERGE_IO_TRANSITION::MERGE_READY:
+            return os << "MERGE_READY";
+        case MERGE_IO_TRANSITION::MERGE_BEGIN:
+            return os << "MERGE_BEGIN";
+        case MERGE_IO_TRANSITION::MERGE_FAILED:
+            return os << "MERGE_FAILED";
+        case MERGE_IO_TRANSITION::MERGE_COMPLETE:
+            return os << "MERGE_COMPLETE";
+        case MERGE_IO_TRANSITION::IO_TERMINATED:
+            return os << "IO_TERMINATED";
+        case MERGE_IO_TRANSITION::READ_AHEAD_FAILURE:
+            return os << "READ_AHEAD_FAILURE";
+        default:
+            return os << "unknown";
+    }
+}
+
 }  // namespace snapshot
 }  // namespace android

From 4e0d58c9e57e0838fa2a902291700eb54848b976 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 7 Aug 2023 14:59:07 -0700
Subject: [PATCH 0288/1487] snapuserd: Don't specify a path to TemporaryFile.

Placing temporary files in the executable dir creates unexpected files
in the build dir when running on the host, which linger if snapuserd
crashes.

Bug: 288273605
Test: snapuserd_test
Change-Id: Ia1ea4ba70b645a9d2f49419b91003bc62fb03cb2
---
 .../libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp  | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 9f7a91dae277..0f1374cd1038 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -108,8 +108,7 @@ void SnapuserdTestBase::CreateBaseDevice() {
 }
 
 std::unique_ptr<ICowWriter> SnapuserdTestBase::CreateCowDeviceInternal() {
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
+    cow_system_ = std::make_unique<TemporaryFile>();
 
     CowOptions options;
     options.compression = "gz";

From 27add511522e09350fb64ac744c970c11285b21f Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 3 Aug 2023 20:42:38 -0700
Subject: [PATCH 0289/1487] snapuserd: Add an ITestHarness implementation for
 hosts.

This adds an implementation of ITestHarness suitable for running tests
on the host. IUserDevice and ProcessRequests are implemented just enough
for shutdown of ReadWorker to work. Most snapuserd tests are focused on
merging, and do not need a ReadWorker accepting requests.

Bug: 288273605
Test: snapuserd_test
Change-Id: I00cf6ec941fb6423290f7a299e5321adea7d8919
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   1 +
 .../snapuserd/testing/host_harness.cpp        | 107 ++++++++++++++++++
 .../snapuserd/testing/host_harness.h          | 104 +++++++++++++++++
 3 files changed, 212 insertions(+)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/testing/host_harness.cpp
 create mode 100644 fs_mgr/libsnapshot/snapuserd/testing/host_harness.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index fc260b6921c4..f5b87e04fd3b 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -222,6 +222,7 @@ cc_test {
     srcs: [
         "testing/dm_user_harness.cpp",
         "testing/harness.cpp",
+        "testing/host_harness.cpp",
         "user-space-merge/snapuserd_test.cpp",
     ],
     shared_libs: [
diff --git a/fs_mgr/libsnapshot/snapuserd/testing/host_harness.cpp b/fs_mgr/libsnapshot/snapuserd/testing/host_harness.cpp
new file mode 100644
index 000000000000..bb90e6d29cc6
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/testing/host_harness.cpp
@@ -0,0 +1,107 @@
+// Copyright (C) 2023 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 "host_harness.h"
+
+#include "snapuserd_logging.h"
+
+namespace android {
+namespace snapshot {
+
+void TestBlockServerQueue::WaitForShutdown() {
+    std::unique_lock lock(m_);
+    if (shutdown_) {
+        return;
+    }
+    cv_.wait(lock, [this]() -> bool { return shutdown_; });
+}
+
+void TestBlockServerQueue::Shutdown() {
+    std::unique_lock lock(m_);
+    shutdown_ = true;
+    cv_.notify_all();
+}
+
+TestBlockServer::TestBlockServer(std::shared_ptr<TestBlockServerQueue> queue,
+                                 const std::string& misc_name)
+    : queue_(queue), misc_name_(misc_name) {}
+
+bool TestBlockServer::ProcessRequests() {
+    queue_->WaitForShutdown();
+    return false;
+}
+
+void* TestBlockServer::GetResponseBuffer(size_t size, size_t to_write) {
+    std::string buffer(size, '\0');
+    buffered_.emplace_back(std::move(buffer), to_write);
+    return buffered_.back().first.data();
+}
+
+bool TestBlockServer::SendBufferedIo() {
+    for (const auto& [data, to_write] : buffered_) {
+        sent_io_ += data.substr(0, to_write);
+    }
+    buffered_.clear();
+    return true;
+}
+
+TestBlockServerOpener::TestBlockServerOpener(std::shared_ptr<TestBlockServerQueue> queue,
+                                             const std::string& misc_name)
+    : queue_(queue), misc_name_(misc_name) {}
+
+std::unique_ptr<IBlockServer> TestBlockServerOpener::Open(IBlockServer::Delegate*, size_t) {
+    return std::make_unique<TestBlockServer>(queue_, misc_name_);
+}
+
+std::shared_ptr<IBlockServerOpener> TestBlockServerFactory::CreateOpener(
+        const std::string& misc_name) {
+    if (queues_.count(misc_name)) {
+        LOG(ERROR) << "Cannot create opener for " << misc_name << ", already exists";
+        return nullptr;
+    }
+    auto queue = std::make_shared<TestBlockServerQueue>();
+    queues_.emplace(misc_name, queue);
+    return std::make_shared<TestBlockServerOpener>(queue, misc_name);
+}
+
+bool TestBlockServerFactory::DeleteQueue(const std::string& misc_name) {
+    auto iter = queues_.find(misc_name);
+    if (iter == queues_.end()) {
+        LOG(ERROR) << "Cannot delete queue " << misc_name << ", not found";
+        return false;
+    }
+    iter->second->Shutdown();
+    queues_.erase(iter);
+    return true;
+}
+
+HostUserDevice::HostUserDevice(TestBlockServerFactory* factory, const std::string& misc_name)
+    : factory_(factory), misc_name_(misc_name) {}
+
+bool HostUserDevice::Destroy() {
+    return factory_->DeleteQueue(misc_name_);
+}
+
+std::unique_ptr<IUserDevice> HostTestHarness::CreateUserDevice(const std::string&,
+                                                               const std::string& misc_name,
+                                                               uint64_t) {
+    return std::make_unique<HostUserDevice>(&factory_, misc_name);
+}
+
+IBlockServerFactory* HostTestHarness::GetBlockServerFactory() {
+    return &factory_;
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/testing/host_harness.h b/fs_mgr/libsnapshot/snapuserd/testing/host_harness.h
new file mode 100644
index 000000000000..e5c698514e7a
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/testing/host_harness.h
@@ -0,0 +1,104 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <condition_variable>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "harness.h"
+
+namespace android {
+namespace snapshot {
+
+class TestBlockServerQueue final {
+  public:
+    void WaitForShutdown();
+    void Shutdown();
+
+  private:
+    std::mutex m_;
+    std::condition_variable cv_;
+    bool shutdown_ = false;
+};
+
+class TestBlockServer final : public IBlockServer {
+  public:
+    TestBlockServer(std::shared_ptr<TestBlockServerQueue> queue, const std::string& misc_name);
+    bool ProcessRequests() override;
+    void* GetResponseBuffer(size_t size, size_t to_write) override;
+    bool SendBufferedIo() override;
+
+    std::string&& sent_io() { return std::move(sent_io_); }
+
+  private:
+    std::shared_ptr<TestBlockServerQueue> queue_;
+    std::string misc_name_;
+    std::string sent_io_;
+    std::vector<std::pair<std::string, size_t>> buffered_;
+};
+
+class TestBlockServerOpener final : public IBlockServerOpener {
+  public:
+    TestBlockServerOpener(std::shared_ptr<TestBlockServerQueue> queue,
+                          const std::string& misc_name);
+    std::unique_ptr<IBlockServer> Open(IBlockServer::Delegate* delegate,
+                                       size_t buffer_size) override;
+
+  private:
+    std::shared_ptr<TestBlockServerQueue> queue_;
+    std::string misc_name_;
+};
+
+class TestBlockServerFactory final : public IBlockServerFactory {
+  public:
+    std::shared_ptr<IBlockServerOpener> CreateOpener(const std::string& misc_name) override;
+    bool DeleteQueue(const std::string& misc_name);
+
+  private:
+    std::unordered_map<std::string, std::shared_ptr<TestBlockServerQueue>> queues_;
+};
+
+class TestBlockServerFactory;
+
+class HostUserDevice final : public IUserDevice {
+  public:
+    HostUserDevice(TestBlockServerFactory* factory, const std::string& misc_name);
+    const std::string& GetPath() override { return empty_path_; }
+    bool Destroy();
+
+  private:
+    TestBlockServerFactory* factory_;
+    std::string misc_name_;
+    std::string empty_path_;
+};
+
+class HostTestHarness final : public ITestHarness {
+  public:
+    std::unique_ptr<IUserDevice> CreateUserDevice(const std::string& dev_name,
+                                                  const std::string& misc_name,
+                                                  uint64_t num_sectors) override;
+    IBlockServerFactory* GetBlockServerFactory() override;
+    bool HasUserDevice() override { return false; }
+
+  private:
+    TestBlockServerFactory factory_;
+};
+
+}  // namespace snapshot
+}  // namespace android

From 0ec9b0eb9226828a2fa7a67b3e9d7400015acbef Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 7 Aug 2023 15:25:07 -0700
Subject: [PATCH 0290/1487] snapuesrd: Build snapuserd_test on host.

Bug: 288273605
Test: snapuserd_test
Change-Id: I10e099feff30f09b8c9f0b9dcca64336cb0861b9
---
 fs_mgr/libsnapshot/snapuserd/Android.bp                  | 2 ++
 .../snapuserd/include/snapuserd/snapuserd_kernel.h       | 6 ++++--
 .../snapuserd/user-space-merge/snapuserd_test.cpp        | 9 ++++++++-
 3 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index f5b87e04fd3b..fe7f99c675d7 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -90,6 +90,7 @@ cc_library_static {
     ramdisk_available: true,
     vendor_ramdisk_available: true,
     recovery_available: true,
+    host_supported: true,
 }
 
 cc_defaults {
@@ -256,4 +257,5 @@ cc_test {
     },
     auto_gen_config: true,
     require_root: false,
+    host_supported: true,
 }
diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_kernel.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_kernel.h
index 0d83f4789625..7ab75dc7966c 100644
--- a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_kernel.h
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_kernel.h
@@ -14,6 +14,8 @@
 
 #pragma once
 
+#include <linux/types.h>
+
 namespace android {
 namespace snapshot {
 
@@ -70,7 +72,7 @@ struct disk_header {
 
     /* In sectors */
     uint32_t chunk_size;
-} __packed;
+} __attribute__((packed));
 
 // A disk exception is a mapping of old_chunk to new_chunk
 // old_chunk is the chunk ID of a dm-snapshot device.
@@ -78,7 +80,7 @@ struct disk_header {
 struct disk_exception {
     uint64_t old_chunk;
     uint64_t new_chunk;
-} __packed;
+} __attribute__((packed));
 
 // Control structures to communicate with dm-user
 // It comprises of header and a payload
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 0f1374cd1038..9c923847daed 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -41,6 +41,7 @@
 #include "handler_manager.h"
 #include "snapuserd_core.h"
 #include "testing/dm_user_harness.h"
+#include "testing/host_harness.h"
 #include "testing/temp_device.h"
 #include "utility.h"
 
@@ -80,7 +81,11 @@ class SnapuserdTestBase : public ::testing::Test {
 };
 
 void SnapuserdTestBase::SetUp() {
+#if __ANDROID__
     harness_ = std::make_unique<DmUserTestHarness>();
+#else
+    harness_ = std::make_unique<HostTestHarness>();
+#endif
 }
 
 void SnapuserdTestBase::TearDown() {}
@@ -269,7 +274,9 @@ void SnapuserdTest::TearDown() {
 }
 
 void SnapuserdTest::Shutdown() {
-    ASSERT_TRUE(dmuser_dev_->Destroy());
+    if (dmuser_dev_) {
+        ASSERT_TRUE(dmuser_dev_->Destroy());
+    }
 
     auto misc_device = "/dev/dm-user/" + system_device_ctrl_name_;
     ASSERT_TRUE(handlers_->DeleteHandler(system_device_ctrl_name_));

From 9fb4fc307c5e950a8eeb8c03d9b884eff137b8f0 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 7 Aug 2023 14:18:46 -0700
Subject: [PATCH 0291/1487] snapuserd: Add error propagation to tests.

snapuserd_test in general doesn't propagate errors, which means the
first failure will cascade into many failures. This can make it harder
to figure out what's going on.

Unfortunately error propagation is difficult with gtest, since bool
returns don't work with ASSERT_EQ and Android doesn't use exceptions.

Use ASSERT_NO_FATAL_FAILURE for now, since that is the least invasive
change.

Bug: 288273605
Test: snapuserd_test
Change-Id: I6550682fd63602bc15649f705def2915f6329357
---
 .../user-space-merge/snapuserd_test.cpp       | 187 ++++++++----------
 1 file changed, 84 insertions(+), 103 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 0e02f0b853cf..ae921fd35bfe 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -58,11 +58,11 @@ using namespace std;
 
 class SnapuserdTest : public ::testing::Test {
   public:
-    bool SetupDefault();
-    bool SetupOrderedOps();
-    bool SetupOrderedOpsInverted();
-    bool SetupCopyOverlap_1();
-    bool SetupCopyOverlap_2();
+    void SetupDefault();
+    void SetupOrderedOps();
+    void SetupOrderedOpsInverted();
+    void SetupCopyOverlap_1();
+    void SetupCopyOverlap_2();
     bool Merge();
     void ValidateMerge();
     void ReadSnapshotDeviceAndValidate();
@@ -70,7 +70,7 @@ class SnapuserdTest : public ::testing::Test {
     void MergeInterrupt();
     void MergeInterruptFixed(int duration);
     void MergeInterruptRandomly(int max_duration);
-    void StartMerge();
+    bool StartMerge();
     void CheckMergeCompletion();
 
     static const uint64_t kSectorSize = 512;
@@ -89,7 +89,7 @@ class SnapuserdTest : public ::testing::Test {
     void CreateCowDeviceOrderedOpsInverted();
     void CreateCowDeviceWithCopyOverlap_1();
     void CreateCowDeviceWithCopyOverlap_2();
-    bool SetupDaemon();
+    void SetupDaemon();
     void CreateBaseDevice();
     void InitCowDevice();
     void SetDeviceControlName();
@@ -107,8 +107,6 @@ class SnapuserdTest : public ::testing::Test {
     std::unique_ptr<uint8_t[]> orig_buffer_;
     std::unique_ptr<uint8_t[]> merged_buffer_;
     std::unique_ptr<SnapshotHandlerManager> handlers_;
-    bool setup_ok_ = false;
-    bool merge_ok_ = false;
     size_t size_ = 100_MiB;
     int cow_num_sectors_;
     int total_base_size_;
@@ -131,45 +129,40 @@ void SnapuserdTest::Shutdown() {
     handlers_ = std::make_unique<SnapshotHandlerManager>();
 }
 
-bool SnapuserdTest::SetupDefault() {
-    SetupImpl();
-    return setup_ok_;
+void SnapuserdTest::SetupDefault() {
+    ASSERT_NO_FATAL_FAILURE(SetupImpl());
 }
 
-bool SnapuserdTest::SetupOrderedOps() {
-    CreateBaseDevice();
-    CreateCowDeviceOrderedOps();
-    return SetupDaemon();
+void SnapuserdTest::SetupOrderedOps() {
+    ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
+    ASSERT_NO_FATAL_FAILURE(CreateCowDeviceOrderedOps());
+    ASSERT_NO_FATAL_FAILURE(SetupDaemon());
 }
 
-bool SnapuserdTest::SetupOrderedOpsInverted() {
-    CreateBaseDevice();
-    CreateCowDeviceOrderedOpsInverted();
-    return SetupDaemon();
+void SnapuserdTest::SetupOrderedOpsInverted() {
+    ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
+    ASSERT_NO_FATAL_FAILURE(CreateCowDeviceOrderedOpsInverted());
+    ASSERT_NO_FATAL_FAILURE(SetupDaemon());
 }
 
-bool SnapuserdTest::SetupCopyOverlap_1() {
-    CreateBaseDevice();
-    CreateCowDeviceWithCopyOverlap_1();
-    return SetupDaemon();
+void SnapuserdTest::SetupCopyOverlap_1() {
+    ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
+    ASSERT_NO_FATAL_FAILURE(CreateCowDeviceWithCopyOverlap_1());
+    ASSERT_NO_FATAL_FAILURE(SetupDaemon());
 }
 
-bool SnapuserdTest::SetupCopyOverlap_2() {
-    CreateBaseDevice();
-    CreateCowDeviceWithCopyOverlap_2();
-    return SetupDaemon();
+void SnapuserdTest::SetupCopyOverlap_2() {
+    ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
+    ASSERT_NO_FATAL_FAILURE(CreateCowDeviceWithCopyOverlap_2());
+    ASSERT_NO_FATAL_FAILURE(SetupDaemon());
 }
 
-bool SnapuserdTest::SetupDaemon() {
+void SnapuserdTest::SetupDaemon() {
     SetDeviceControlName();
 
-    CreateUserDevice();
-    InitCowDevice();
-    InitDaemon();
-
-    setup_ok_ = true;
-
-    return setup_ok_;
+    ASSERT_NO_FATAL_FAILURE(CreateUserDevice());
+    ASSERT_NO_FATAL_FAILURE(InitCowDevice());
+    ASSERT_NO_FATAL_FAILURE(InitDaemon());
 }
 
 void SnapuserdTest::CreateBaseDevice() {
@@ -575,27 +568,26 @@ void SnapuserdTest::CheckMergeCompletion() {
 }
 
 void SnapuserdTest::SetupImpl() {
-    CreateBaseDevice();
-    CreateCowDevice();
+    ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
+    ASSERT_NO_FATAL_FAILURE(CreateCowDevice());
 
     SetDeviceControlName();
 
-    CreateUserDevice();
-    InitCowDevice();
-    InitDaemon();
-
-    setup_ok_ = true;
+    ASSERT_NO_FATAL_FAILURE(CreateUserDevice());
+    ASSERT_NO_FATAL_FAILURE(InitCowDevice());
+    ASSERT_NO_FATAL_FAILURE(InitDaemon());
 }
 
 bool SnapuserdTest::Merge() {
-    StartMerge();
+    if (!StartMerge()) {
+        return false;
+    }
     CheckMergeCompletion();
-    merge_ok_ = true;
-    return merge_ok_;
+    return true;
 }
 
-void SnapuserdTest::StartMerge() {
-    ASSERT_TRUE(handlers_->InitiateMerge(system_device_ctrl_name_));
+bool SnapuserdTest::StartMerge() {
+    return handlers_->InitiateMerge(system_device_ctrl_name_);
 }
 
 void SnapuserdTest::ValidateMerge() {
@@ -606,67 +598,67 @@ void SnapuserdTest::ValidateMerge() {
 }
 
 void SnapuserdTest::SimulateDaemonRestart() {
-    Shutdown();
+    ASSERT_NO_FATAL_FAILURE(Shutdown());
     std::this_thread::sleep_for(500ms);
     SetDeviceControlName();
-    CreateUserDevice();
-    InitCowDevice();
-    InitDaemon();
+    ASSERT_NO_FATAL_FAILURE(CreateUserDevice());
+    ASSERT_NO_FATAL_FAILURE(InitCowDevice());
+    ASSERT_NO_FATAL_FAILURE(InitDaemon());
 }
 
 void SnapuserdTest::MergeInterruptRandomly(int max_duration) {
     std::srand(std::time(nullptr));
-    StartMerge();
+    ASSERT_TRUE(StartMerge());
 
     for (int i = 0; i < 20; i++) {
         int duration = std::rand() % max_duration;
         std::this_thread::sleep_for(std::chrono::milliseconds(duration));
-        SimulateDaemonRestart();
-        StartMerge();
+        ASSERT_NO_FATAL_FAILURE(SimulateDaemonRestart());
+        ASSERT_TRUE(StartMerge());
     }
 
-    SimulateDaemonRestart();
+    ASSERT_NO_FATAL_FAILURE(SimulateDaemonRestart());
     ASSERT_TRUE(Merge());
 }
 
 void SnapuserdTest::MergeInterruptFixed(int duration) {
-    StartMerge();
+    ASSERT_TRUE(StartMerge());
 
     for (int i = 0; i < 25; i++) {
         std::this_thread::sleep_for(std::chrono::milliseconds(duration));
-        SimulateDaemonRestart();
-        StartMerge();
+        ASSERT_NO_FATAL_FAILURE(SimulateDaemonRestart());
+        ASSERT_TRUE(StartMerge());
     }
 
-    SimulateDaemonRestart();
+    ASSERT_NO_FATAL_FAILURE(SimulateDaemonRestart());
     ASSERT_TRUE(Merge());
 }
 
 void SnapuserdTest::MergeInterrupt() {
     // Interrupt merge at various intervals
-    StartMerge();
+    ASSERT_TRUE(StartMerge());
     std::this_thread::sleep_for(250ms);
-    SimulateDaemonRestart();
+    ASSERT_NO_FATAL_FAILURE(SimulateDaemonRestart());
 
-    StartMerge();
+    ASSERT_TRUE(StartMerge());
     std::this_thread::sleep_for(250ms);
-    SimulateDaemonRestart();
+    ASSERT_NO_FATAL_FAILURE(SimulateDaemonRestart());
 
-    StartMerge();
+    ASSERT_TRUE(StartMerge());
     std::this_thread::sleep_for(150ms);
-    SimulateDaemonRestart();
+    ASSERT_NO_FATAL_FAILURE(SimulateDaemonRestart());
 
-    StartMerge();
+    ASSERT_TRUE(StartMerge());
     std::this_thread::sleep_for(100ms);
-    SimulateDaemonRestart();
+    ASSERT_NO_FATAL_FAILURE(SimulateDaemonRestart());
 
-    StartMerge();
+    ASSERT_TRUE(StartMerge());
     std::this_thread::sleep_for(800ms);
-    SimulateDaemonRestart();
+    ASSERT_NO_FATAL_FAILURE(SimulateDaemonRestart());
 
-    StartMerge();
+    ASSERT_TRUE(StartMerge());
     std::this_thread::sleep_for(600ms);
-    SimulateDaemonRestart();
+    ASSERT_NO_FATAL_FAILURE(SimulateDaemonRestart());
 
     ASSERT_TRUE(Merge());
 }
@@ -675,98 +667,87 @@ TEST_F(SnapuserdTest, Snapshot_IO_TEST) {
     if (!harness_->HasUserDevice()) {
         GTEST_SKIP() << "Skipping snapshot read; not supported";
     }
-    ASSERT_TRUE(SetupDefault());
+    ASSERT_NO_FATAL_FAILURE(SetupDefault());
     // I/O before merge
-    ReadSnapshotDeviceAndValidate();
+    ASSERT_NO_FATAL_FAILURE(ReadSnapshotDeviceAndValidate());
     ASSERT_TRUE(Merge());
     ValidateMerge();
     // I/O after merge - daemon should read directly
     // from base device
-    ReadSnapshotDeviceAndValidate();
-    Shutdown();
+    ASSERT_NO_FATAL_FAILURE(ReadSnapshotDeviceAndValidate());
 }
 
 TEST_F(SnapuserdTest, Snapshot_MERGE_IO_TEST) {
     if (!harness_->HasUserDevice()) {
         GTEST_SKIP() << "Skipping snapshot read; not supported";
     }
-    ASSERT_TRUE(SetupDefault());
+    ASSERT_NO_FATAL_FAILURE(SetupDefault());
     // Issue I/O before merge begins
     std::async(std::launch::async, &SnapuserdTest::ReadSnapshotDeviceAndValidate, this);
     // Start the merge
     ASSERT_TRUE(Merge());
     ValidateMerge();
-    Shutdown();
 }
 
 TEST_F(SnapuserdTest, Snapshot_MERGE_IO_TEST_1) {
     if (!harness_->HasUserDevice()) {
         GTEST_SKIP() << "Skipping snapshot read; not supported";
     }
-    ASSERT_TRUE(SetupDefault());
+    ASSERT_NO_FATAL_FAILURE(SetupDefault());
     // Start the merge
-    StartMerge();
+    ASSERT_TRUE(StartMerge());
     // Issue I/O in parallel when merge is in-progress
     std::async(std::launch::async, &SnapuserdTest::ReadSnapshotDeviceAndValidate, this);
     CheckMergeCompletion();
     ValidateMerge();
-    Shutdown();
 }
 
 TEST_F(SnapuserdTest, Snapshot_Merge_Resume) {
-    ASSERT_TRUE(SetupDefault());
-    MergeInterrupt();
+    ASSERT_NO_FATAL_FAILURE(SetupDefault());
+    ASSERT_NO_FATAL_FAILURE(MergeInterrupt());
     ValidateMerge();
-    Shutdown();
 }
 
 TEST_F(SnapuserdTest, Snapshot_COPY_Overlap_TEST_1) {
-    ASSERT_TRUE(SetupCopyOverlap_1());
+    ASSERT_NO_FATAL_FAILURE(SetupCopyOverlap_1());
     ASSERT_TRUE(Merge());
     ValidateMerge();
-    Shutdown();
 }
 
 TEST_F(SnapuserdTest, Snapshot_COPY_Overlap_TEST_2) {
-    ASSERT_TRUE(SetupCopyOverlap_2());
+    ASSERT_NO_FATAL_FAILURE(SetupCopyOverlap_2());
     ASSERT_TRUE(Merge());
     ValidateMerge();
-    Shutdown();
 }
 
 TEST_F(SnapuserdTest, Snapshot_COPY_Overlap_Merge_Resume_TEST) {
-    ASSERT_TRUE(SetupCopyOverlap_1());
-    MergeInterrupt();
+    ASSERT_NO_FATAL_FAILURE(SetupCopyOverlap_1());
+    ASSERT_NO_FATAL_FAILURE(MergeInterrupt());
     ValidateMerge();
-    Shutdown();
 }
 
 TEST_F(SnapuserdTest, Snapshot_Merge_Crash_Fixed_Ordered) {
-    ASSERT_TRUE(SetupOrderedOps());
-    MergeInterruptFixed(300);
+    ASSERT_NO_FATAL_FAILURE(SetupOrderedOps());
+    ASSERT_NO_FATAL_FAILURE(MergeInterruptFixed(300));
     ValidateMerge();
-    Shutdown();
 }
 
 TEST_F(SnapuserdTest, Snapshot_Merge_Crash_Random_Ordered) {
-    ASSERT_TRUE(SetupOrderedOps());
-    MergeInterruptRandomly(500);
+    ASSERT_NO_FATAL_FAILURE(SetupOrderedOps());
+    ASSERT_NO_FATAL_FAILURE(MergeInterruptRandomly(500));
     ValidateMerge();
-    Shutdown();
 }
 
 TEST_F(SnapuserdTest, Snapshot_Merge_Crash_Fixed_Inverted) {
-    ASSERT_TRUE(SetupOrderedOpsInverted());
-    MergeInterruptFixed(50);
+    ASSERT_NO_FATAL_FAILURE(SetupOrderedOpsInverted());
+    ASSERT_NO_FATAL_FAILURE(MergeInterruptFixed(50));
     ValidateMerge();
-    Shutdown();
 }
 
 TEST_F(SnapuserdTest, Snapshot_Merge_Crash_Random_Inverted) {
-    ASSERT_TRUE(SetupOrderedOpsInverted());
-    MergeInterruptRandomly(50);
+    ASSERT_NO_FATAL_FAILURE(SetupOrderedOpsInverted());
+    ASSERT_NO_FATAL_FAILURE(MergeInterruptRandomly(50));
     ValidateMerge();
-    Shutdown();
 }
 
 }  // namespace snapshot

From 6aec095d6872b93d8c18076a7b0b45c494b95a1c Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 7 Aug 2023 19:46:20 -0700
Subject: [PATCH 0292/1487] snapuserd: Add unit tests for
 ReadWorker::ReadAlignedSector.

These tests are for real bugs that were previously not testable.

Bug: 288273605
Test: snapuserd_test
Change-Id: I9e9af999e4f5f988f4538750eba109f6b2fe448c
---
 .../snapuserd/testing/host_harness.cpp        |   7 +-
 .../snapuserd/testing/host_harness.h          |   1 +
 .../snapuserd/user-space-merge/read_worker.h  |   4 +-
 .../user-space-merge/snapuserd_test.cpp       | 109 ++++++++++++++++++
 4 files changed, 119 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/testing/host_harness.cpp b/fs_mgr/libsnapshot/snapuserd/testing/host_harness.cpp
index bb90e6d29cc6..0d230ad84726 100644
--- a/fs_mgr/libsnapshot/snapuserd/testing/host_harness.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/testing/host_harness.cpp
@@ -64,7 +64,7 @@ std::unique_ptr<IBlockServer> TestBlockServerOpener::Open(IBlockServer::Delegate
     return std::make_unique<TestBlockServer>(queue_, misc_name_);
 }
 
-std::shared_ptr<IBlockServerOpener> TestBlockServerFactory::CreateOpener(
+std::shared_ptr<TestBlockServerOpener> TestBlockServerFactory::CreateTestOpener(
         const std::string& misc_name) {
     if (queues_.count(misc_name)) {
         LOG(ERROR) << "Cannot create opener for " << misc_name << ", already exists";
@@ -75,6 +75,11 @@ std::shared_ptr<IBlockServerOpener> TestBlockServerFactory::CreateOpener(
     return std::make_shared<TestBlockServerOpener>(queue, misc_name);
 }
 
+std::shared_ptr<IBlockServerOpener> TestBlockServerFactory::CreateOpener(
+        const std::string& misc_name) {
+    return CreateTestOpener(misc_name);
+}
+
 bool TestBlockServerFactory::DeleteQueue(const std::string& misc_name) {
     auto iter = queues_.find(misc_name);
     if (iter == queues_.end()) {
diff --git a/fs_mgr/libsnapshot/snapuserd/testing/host_harness.h b/fs_mgr/libsnapshot/snapuserd/testing/host_harness.h
index e5c698514e7a..ec0bd29ad474 100644
--- a/fs_mgr/libsnapshot/snapuserd/testing/host_harness.h
+++ b/fs_mgr/libsnapshot/snapuserd/testing/host_harness.h
@@ -68,6 +68,7 @@ class TestBlockServerOpener final : public IBlockServerOpener {
 class TestBlockServerFactory final : public IBlockServerFactory {
   public:
     std::shared_ptr<IBlockServerOpener> CreateOpener(const std::string& misc_name) override;
+    std::shared_ptr<TestBlockServerOpener> CreateTestOpener(const std::string& misc_name);
     bool DeleteQueue(const std::string& misc_name);
 
   private:
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
index a6a3eb8ca54d..6dbae812f812 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
@@ -33,9 +33,11 @@ class ReadWorker : public Worker, public IBlockServer::Delegate {
     bool Run();
     bool Init() override;
     void CloseFds() override;
+    bool RequestSectors(uint64_t sector, uint64_t size) override;
+
+    IBlockServer* block_server() const { return block_server_.get(); }
 
   private:
-    bool RequestSectors(uint64_t sector, uint64_t size) override;
     bool SendBufferedIo();
 
     bool ProcessCowOp(const CowOperation* cow_op, void* buffer);
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 9c923847daed..c5ccb0d22f16 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -39,6 +39,8 @@
 #include <snapuserd/dm_user_block_server.h>
 #include <storage_literals/storage_literals.h>
 #include "handler_manager.h"
+#include "merge_worker.h"
+#include "read_worker.h"
 #include "snapuserd_core.h"
 #include "testing/dm_user_harness.h"
 #include "testing/host_harness.h"
@@ -56,6 +58,9 @@ using LoopDevice = android::dm::LoopDevice;
 using namespace std::chrono_literals;
 using namespace android::dm;
 using namespace std;
+using testing::AssertionFailure;
+using testing::AssertionResult;
+using testing::AssertionSuccess;
 
 class SnapuserdTestBase : public ::testing::Test {
   protected:
@@ -776,6 +781,110 @@ TEST_F(SnapuserdTest, Snapshot_Merge_Crash_Random_Inverted) {
     ValidateMerge();
 }
 
+class HandlerTest : public SnapuserdTestBase {
+  protected:
+    void SetUp() override;
+    void TearDown() override;
+
+    AssertionResult ReadSectors(sector_t sector, uint64_t size, void* buffer);
+
+    TestBlockServerFactory factory_;
+    std::shared_ptr<TestBlockServerOpener> opener_;
+    std::shared_ptr<SnapshotHandler> handler_;
+    std::unique_ptr<ReadWorker> read_worker_;
+    TestBlockServer* block_server_;
+    std::future<bool> handler_thread_;
+};
+
+void HandlerTest::SetUp() {
+    ASSERT_NO_FATAL_FAILURE(SnapuserdTestBase::SetUp());
+    ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
+    ASSERT_NO_FATAL_FAILURE(CreateCowDevice());
+    ASSERT_NO_FATAL_FAILURE(SetDeviceControlName());
+
+    opener_ = factory_.CreateTestOpener(system_device_ctrl_name_);
+    ASSERT_NE(opener_, nullptr);
+
+    handler_ = std::make_shared<SnapshotHandler>(system_device_ctrl_name_, cow_system_->path,
+                                                 base_dev_->GetPath(), base_dev_->GetPath(),
+                                                 opener_, 1, false, false);
+    ASSERT_TRUE(handler_->InitCowDevice());
+    ASSERT_TRUE(handler_->InitializeWorkers());
+
+    read_worker_ = std::make_unique<ReadWorker>(cow_system_->path, base_dev_->GetPath(),
+                                                system_device_ctrl_name_, base_dev_->GetPath(),
+                                                handler_->GetSharedPtr(), opener_);
+    ASSERT_TRUE(read_worker_->Init());
+    block_server_ = static_cast<TestBlockServer*>(read_worker_->block_server());
+
+    handler_thread_ = std::async(std::launch::async, &SnapshotHandler::Start, handler_.get());
+}
+
+void HandlerTest::TearDown() {
+    ASSERT_TRUE(factory_.DeleteQueue(system_device_ctrl_name_));
+    ASSERT_TRUE(handler_thread_.get());
+    SnapuserdTestBase::TearDown();
+}
+
+AssertionResult HandlerTest::ReadSectors(sector_t sector, uint64_t size, void* buffer) {
+    if (!read_worker_->RequestSectors(sector, size)) {
+        return AssertionFailure() << "request sectors failed";
+    }
+
+    std::string result = std::move(block_server_->sent_io());
+    if (result.size() != size) {
+        return AssertionFailure() << "size mismatch in result, got " << result.size()
+                                  << ", expected " << size;
+    }
+
+    memcpy(buffer, result.data(), size);
+    return AssertionSuccess();
+}
+
+// This test mirrors ReadSnapshotDeviceAndValidate.
+TEST_F(HandlerTest, Read) {
+    std::unique_ptr<uint8_t[]> snapuserd_buffer = std::make_unique<uint8_t[]>(size_);
+
+    // COPY
+    loff_t offset = 0;
+    ASSERT_TRUE(ReadSectors(offset / SECTOR_SIZE, size_, snapuserd_buffer.get()));
+    ASSERT_EQ(memcmp(snapuserd_buffer.get(), orig_buffer_.get(), size_), 0);
+
+    // REPLACE
+    offset += size_;
+    ASSERT_TRUE(ReadSectors(offset / SECTOR_SIZE, size_, snapuserd_buffer.get()));
+    ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + size_, size_), 0);
+
+    // ZERO
+    offset += size_;
+    ASSERT_TRUE(ReadSectors(offset / SECTOR_SIZE, size_, snapuserd_buffer.get()));
+    ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + (size_ * 2), size_), 0);
+
+    // REPLACE
+    offset += size_;
+    ASSERT_TRUE(ReadSectors(offset / SECTOR_SIZE, size_, snapuserd_buffer.get()));
+    ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + (size_ * 3), size_), 0);
+
+    // XOR
+    offset += size_;
+    ASSERT_TRUE(ReadSectors(offset / SECTOR_SIZE, size_, snapuserd_buffer.get()));
+    ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + (size_ * 4), size_), 0);
+}
+
+TEST_F(HandlerTest, ReadUnalignedSector) {
+    std::unique_ptr<uint8_t[]> snapuserd_buffer = std::make_unique<uint8_t[]>(BLOCK_SZ);
+
+    ASSERT_TRUE(ReadSectors(1, BLOCK_SZ, snapuserd_buffer.get()));
+    ASSERT_EQ(memcmp(snapuserd_buffer.get(), orig_buffer_.get() + SECTOR_SIZE, BLOCK_SZ), 0);
+}
+
+TEST_F(HandlerTest, ReadUnalignedSize) {
+    std::unique_ptr<uint8_t[]> snapuserd_buffer = std::make_unique<uint8_t[]>(SECTOR_SIZE);
+
+    ASSERT_TRUE(ReadSectors(0, SECTOR_SIZE, snapuserd_buffer.get()));
+    ASSERT_EQ(memcmp(snapuserd_buffer.get(), orig_buffer_.get(), SECTOR_SIZE), 0);
+}
+
 }  // namespace snapshot
 }  // namespace android
 

From dbda1300aee31850ea89c4f76573dda225fed220 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 7 Aug 2023 14:54:38 -0700
Subject: [PATCH 0293/1487] snapuserd: Factor a base class out of tests.

This factors a lighter weight class out of SnapuserdTest, so we can
construct tests without needing a HandlerManager/daemon.

Bug: 288273605
Test: snapuserd_test
Change-Id: Ib33dc593a5b3d3df86853e73f245918ef36fd9fa
---
 .../user-space-merge/snapuserd_test.cpp       | 316 ++++++++++--------
 1 file changed, 168 insertions(+), 148 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index ae921fd35bfe..9f7a91dae277 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -56,7 +56,167 @@ using namespace std::chrono_literals;
 using namespace android::dm;
 using namespace std;
 
-class SnapuserdTest : public ::testing::Test {
+class SnapuserdTestBase : public ::testing::Test {
+  protected:
+    void SetUp() override;
+    void TearDown() override;
+    void CreateBaseDevice();
+    void CreateCowDevice();
+    void SetDeviceControlName();
+    std::unique_ptr<ICowWriter> CreateCowDeviceInternal();
+
+    std::unique_ptr<ITestHarness> harness_;
+    size_t size_ = 100_MiB;
+    int total_base_size_ = 0;
+    std::string system_device_ctrl_name_;
+    std::string system_device_name_;
+
+    unique_ptr<IBackingDevice> base_dev_;
+    unique_fd base_fd_;
+
+    std::unique_ptr<TemporaryFile> cow_system_;
+
+    std::unique_ptr<uint8_t[]> orig_buffer_;
+};
+
+void SnapuserdTestBase::SetUp() {
+    harness_ = std::make_unique<DmUserTestHarness>();
+}
+
+void SnapuserdTestBase::TearDown() {}
+
+void SnapuserdTestBase::CreateBaseDevice() {
+    total_base_size_ = (size_ * 5);
+
+    base_dev_ = harness_->CreateBackingDevice(total_base_size_);
+    ASSERT_NE(base_dev_, nullptr);
+
+    base_fd_.reset(open(base_dev_->GetPath().c_str(), O_RDWR | O_CLOEXEC));
+    ASSERT_GE(base_fd_, 0);
+
+    unique_fd rnd_fd(open("/dev/random", O_RDONLY));
+    ASSERT_GE(rnd_fd, 0);
+
+    std::unique_ptr<uint8_t[]> random_buffer = std::make_unique<uint8_t[]>(1_MiB);
+
+    for (size_t j = 0; j < ((total_base_size_) / 1_MiB); j++) {
+        ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer.get(), 1_MiB, 0), true);
+        ASSERT_EQ(android::base::WriteFully(base_fd_, random_buffer.get(), 1_MiB), true);
+    }
+
+    ASSERT_EQ(lseek(base_fd_, 0, SEEK_SET), 0);
+}
+
+std::unique_ptr<ICowWriter> SnapuserdTestBase::CreateCowDeviceInternal() {
+    std::string path = android::base::GetExecutableDirectory();
+    cow_system_ = std::make_unique<TemporaryFile>(path);
+
+    CowOptions options;
+    options.compression = "gz";
+
+    unique_fd fd(cow_system_->fd);
+    cow_system_->fd = -1;
+
+    return CreateCowWriter(kDefaultCowVersion, options, std::move(fd));
+}
+
+void SnapuserdTestBase::CreateCowDevice() {
+    unique_fd rnd_fd;
+    loff_t offset = 0;
+
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
+
+    rnd_fd.reset(open("/dev/random", O_RDONLY));
+    ASSERT_TRUE(rnd_fd > 0);
+
+    std::unique_ptr<uint8_t[]> random_buffer_1_ = std::make_unique<uint8_t[]>(size_);
+
+    // Fill random data
+    for (size_t j = 0; j < (size_ / 1_MiB); j++) {
+        ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer_1_.get() + offset, 1_MiB, 0),
+                  true);
+
+        offset += 1_MiB;
+    }
+
+    size_t num_blocks = size_ / writer->GetBlockSize();
+    size_t blk_end_copy = num_blocks * 2;
+    size_t source_blk = num_blocks - 1;
+    size_t blk_src_copy = blk_end_copy - 1;
+
+    uint32_t sequence[num_blocks * 2];
+    // Sequence for Copy ops
+    for (int i = 0; i < num_blocks; i++) {
+        sequence[i] = num_blocks - 1 - i;
+    }
+    // Sequence for Xor ops
+    for (int i = 0; i < num_blocks; i++) {
+        sequence[num_blocks + i] = 5 * num_blocks - 1 - i;
+    }
+    ASSERT_TRUE(writer->AddSequenceData(2 * num_blocks, sequence));
+
+    size_t x = num_blocks;
+    while (1) {
+        ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
+        x -= 1;
+        if (x == 0) {
+            break;
+        }
+        source_blk -= 1;
+        blk_src_copy -= 1;
+    }
+
+    source_blk = num_blocks;
+    blk_src_copy = blk_end_copy;
+
+    ASSERT_TRUE(writer->AddRawBlocks(source_blk, random_buffer_1_.get(), size_));
+
+    size_t blk_zero_copy_start = source_blk + num_blocks;
+    size_t blk_zero_copy_end = blk_zero_copy_start + num_blocks;
+
+    ASSERT_TRUE(writer->AddZeroBlocks(blk_zero_copy_start, num_blocks));
+
+    size_t blk_random2_replace_start = blk_zero_copy_end;
+
+    ASSERT_TRUE(writer->AddRawBlocks(blk_random2_replace_start, random_buffer_1_.get(), size_));
+
+    size_t blk_xor_start = blk_random2_replace_start + num_blocks;
+    size_t xor_offset = BLOCK_SZ / 2;
+    ASSERT_TRUE(writer->AddXorBlocks(blk_xor_start, random_buffer_1_.get(), size_, num_blocks,
+                                     xor_offset));
+
+    // Flush operations
+    ASSERT_TRUE(writer->Finalize());
+    // Construct the buffer required for validation
+    orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
+    std::string zero_buffer(size_, 0);
+    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), size_, size_), true);
+    memcpy((char*)orig_buffer_.get() + size_, random_buffer_1_.get(), size_);
+    memcpy((char*)orig_buffer_.get() + (size_ * 2), (void*)zero_buffer.c_str(), size_);
+    memcpy((char*)orig_buffer_.get() + (size_ * 3), random_buffer_1_.get(), size_);
+    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, &orig_buffer_.get()[size_ * 4], size_,
+                                               size_ + xor_offset),
+              true);
+    for (int i = 0; i < size_; i++) {
+        orig_buffer_.get()[(size_ * 4) + i] =
+                (uint8_t)(orig_buffer_.get()[(size_ * 4) + i] ^ random_buffer_1_.get()[i]);
+    }
+}
+
+void SnapuserdTestBase::SetDeviceControlName() {
+    system_device_name_.clear();
+    system_device_ctrl_name_.clear();
+
+    std::string str(cow_system_->path);
+    std::size_t found = str.find_last_of("/\\");
+    ASSERT_NE(found, std::string::npos);
+    system_device_name_ = str.substr(found + 1);
+
+    system_device_ctrl_name_ = system_device_name_ + "-ctrl";
+}
+
+class SnapuserdTest : public SnapuserdTestBase {
   public:
     void SetupDefault();
     void SetupOrderedOps();
@@ -77,47 +237,38 @@ class SnapuserdTest : public ::testing::Test {
 
   protected:
     void SetUp() override;
-    void TearDown() override { Shutdown(); }
+    void TearDown() override;
 
     void SetupImpl();
 
     void SimulateDaemonRestart();
 
-    std::unique_ptr<ICowWriter> CreateCowDeviceInternal();
-    void CreateCowDevice();
     void CreateCowDeviceOrderedOps();
     void CreateCowDeviceOrderedOpsInverted();
     void CreateCowDeviceWithCopyOverlap_1();
     void CreateCowDeviceWithCopyOverlap_2();
     void SetupDaemon();
-    void CreateBaseDevice();
     void InitCowDevice();
-    void SetDeviceControlName();
     void InitDaemon();
     void CreateUserDevice();
 
-    unique_ptr<IBackingDevice> base_dev_;
     unique_ptr<IUserDevice> dmuser_dev_;
 
-    std::string system_device_ctrl_name_;
-    std::string system_device_name_;
-
-    unique_fd base_fd_;
-    std::unique_ptr<TemporaryFile> cow_system_;
-    std::unique_ptr<uint8_t[]> orig_buffer_;
     std::unique_ptr<uint8_t[]> merged_buffer_;
     std::unique_ptr<SnapshotHandlerManager> handlers_;
-    size_t size_ = 100_MiB;
     int cow_num_sectors_;
-    int total_base_size_;
-    std::unique_ptr<ITestHarness> harness_;
 };
 
 void SnapuserdTest::SetUp() {
-    harness_ = std::make_unique<DmUserTestHarness>();
+    ASSERT_NO_FATAL_FAILURE(SnapuserdTestBase::SetUp());
     handlers_ = std::make_unique<SnapshotHandlerManager>();
 }
 
+void SnapuserdTest::TearDown() {
+    SnapuserdTestBase::TearDown();
+    Shutdown();
+}
+
 void SnapuserdTest::Shutdown() {
     ASSERT_TRUE(dmuser_dev_->Destroy());
 
@@ -165,28 +316,6 @@ void SnapuserdTest::SetupDaemon() {
     ASSERT_NO_FATAL_FAILURE(InitDaemon());
 }
 
-void SnapuserdTest::CreateBaseDevice() {
-    total_base_size_ = (size_ * 5);
-
-    base_dev_ = harness_->CreateBackingDevice(total_base_size_);
-    ASSERT_NE(base_dev_, nullptr);
-
-    base_fd_.reset(open(base_dev_->GetPath().c_str(), O_RDWR | O_CLOEXEC));
-    ASSERT_GE(base_fd_, 0);
-
-    unique_fd rnd_fd(open("/dev/random", O_RDONLY));
-    ASSERT_GE(rnd_fd, 0);
-
-    std::unique_ptr<uint8_t[]> random_buffer = std::make_unique<uint8_t[]>(1_MiB);
-
-    for (size_t j = 0; j < ((total_base_size_) / 1_MiB); j++) {
-        ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer.get(), 1_MiB, 0), true);
-        ASSERT_EQ(android::base::WriteFully(base_fd_, random_buffer.get(), 1_MiB), true);
-    }
-
-    ASSERT_EQ(lseek(base_fd_, 0, SEEK_SET), 0);
-}
-
 void SnapuserdTest::ReadSnapshotDeviceAndValidate() {
     unique_fd fd(open(dmuser_dev_->GetPath().c_str(), O_RDONLY));
     ASSERT_GE(fd, 0);
@@ -218,19 +347,6 @@ void SnapuserdTest::ReadSnapshotDeviceAndValidate() {
     ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + (size_ * 4), size_), 0);
 }
 
-std::unique_ptr<ICowWriter> SnapuserdTest::CreateCowDeviceInternal() {
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
-
-    CowOptions options;
-    options.compression = "gz";
-
-    unique_fd fd(cow_system_->fd);
-    cow_system_->fd = -1;
-
-    return CreateCowWriter(kDefaultCowVersion, options, std::move(fd));
-}
-
 void SnapuserdTest::CreateCowDeviceWithCopyOverlap_2() {
     auto writer = CreateCowDeviceInternal();
     ASSERT_NE(writer, nullptr);
@@ -427,90 +543,6 @@ void SnapuserdTest::CreateCowDeviceOrderedOps() {
     }
 }
 
-void SnapuserdTest::CreateCowDevice() {
-    unique_fd rnd_fd;
-    loff_t offset = 0;
-
-    auto writer = CreateCowDeviceInternal();
-    ASSERT_NE(writer, nullptr);
-
-    rnd_fd.reset(open("/dev/random", O_RDONLY));
-    ASSERT_TRUE(rnd_fd > 0);
-
-    std::unique_ptr<uint8_t[]> random_buffer_1_ = std::make_unique<uint8_t[]>(size_);
-
-    // Fill random data
-    for (size_t j = 0; j < (size_ / 1_MiB); j++) {
-        ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer_1_.get() + offset, 1_MiB, 0),
-                  true);
-
-        offset += 1_MiB;
-    }
-
-    size_t num_blocks = size_ / writer->GetBlockSize();
-    size_t blk_end_copy = num_blocks * 2;
-    size_t source_blk = num_blocks - 1;
-    size_t blk_src_copy = blk_end_copy - 1;
-
-    uint32_t sequence[num_blocks * 2];
-    // Sequence for Copy ops
-    for (int i = 0; i < num_blocks; i++) {
-        sequence[i] = num_blocks - 1 - i;
-    }
-    // Sequence for Xor ops
-    for (int i = 0; i < num_blocks; i++) {
-        sequence[num_blocks + i] = 5 * num_blocks - 1 - i;
-    }
-    ASSERT_TRUE(writer->AddSequenceData(2 * num_blocks, sequence));
-
-    size_t x = num_blocks;
-    while (1) {
-        ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
-        x -= 1;
-        if (x == 0) {
-            break;
-        }
-        source_blk -= 1;
-        blk_src_copy -= 1;
-    }
-
-    source_blk = num_blocks;
-    blk_src_copy = blk_end_copy;
-
-    ASSERT_TRUE(writer->AddRawBlocks(source_blk, random_buffer_1_.get(), size_));
-
-    size_t blk_zero_copy_start = source_blk + num_blocks;
-    size_t blk_zero_copy_end = blk_zero_copy_start + num_blocks;
-
-    ASSERT_TRUE(writer->AddZeroBlocks(blk_zero_copy_start, num_blocks));
-
-    size_t blk_random2_replace_start = blk_zero_copy_end;
-
-    ASSERT_TRUE(writer->AddRawBlocks(blk_random2_replace_start, random_buffer_1_.get(), size_));
-
-    size_t blk_xor_start = blk_random2_replace_start + num_blocks;
-    size_t xor_offset = BLOCK_SZ / 2;
-    ASSERT_TRUE(writer->AddXorBlocks(blk_xor_start, random_buffer_1_.get(), size_, num_blocks,
-                                     xor_offset));
-
-    // Flush operations
-    ASSERT_TRUE(writer->Finalize());
-    // Construct the buffer required for validation
-    orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
-    std::string zero_buffer(size_, 0);
-    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), size_, size_), true);
-    memcpy((char*)orig_buffer_.get() + size_, random_buffer_1_.get(), size_);
-    memcpy((char*)orig_buffer_.get() + (size_ * 2), (void*)zero_buffer.c_str(), size_);
-    memcpy((char*)orig_buffer_.get() + (size_ * 3), random_buffer_1_.get(), size_);
-    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, &orig_buffer_.get()[size_ * 4], size_,
-                                               size_ + xor_offset),
-              true);
-    for (int i = 0; i < size_; i++) {
-        orig_buffer_.get()[(size_ * 4) + i] =
-                (uint8_t)(orig_buffer_.get()[(size_ * 4) + i] ^ random_buffer_1_.get()[i]);
-    }
-}
-
 void SnapuserdTest::InitCowDevice() {
     bool use_iouring = true;
     if (FLAGS_force_config == "iouring_disabled") {
@@ -529,18 +561,6 @@ void SnapuserdTest::InitCowDevice() {
 #endif
 }
 
-void SnapuserdTest::SetDeviceControlName() {
-    system_device_name_.clear();
-    system_device_ctrl_name_.clear();
-
-    std::string str(cow_system_->path);
-    std::size_t found = str.find_last_of("/\\");
-    ASSERT_NE(found, std::string::npos);
-    system_device_name_ = str.substr(found + 1);
-
-    system_device_ctrl_name_ = system_device_name_ + "-ctrl";
-}
-
 void SnapuserdTest::CreateUserDevice() {
     auto dev_sz = base_dev_->GetSize();
     ASSERT_NE(dev_sz, 0);

From 1333d87bfe60623b8db8eb6b38b94957cf165e79 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 7 Aug 2023 19:58:55 -0700
Subject: [PATCH 0294/1487] snapuserd: Reduce size of COWs in tests.

This greatly reduces the runtime of snapuserd_test, from 4 minutes to
about 1.5 minutes.

Bug: 269361087
Test: snapuserd_test
Change-Id: Ic18443d4e4318f6ef6adadeabd47ccceeeb19b6f
---
 .../libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index c5ccb0d22f16..01fe06fe79bf 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -72,7 +72,7 @@ class SnapuserdTestBase : public ::testing::Test {
     std::unique_ptr<ICowWriter> CreateCowDeviceInternal();
 
     std::unique_ptr<ITestHarness> harness_;
-    size_t size_ = 100_MiB;
+    size_t size_ = 10_MiB;
     int total_base_size_ = 0;
     std::string system_device_ctrl_name_;
     std::string system_device_name_;

From 50460fa3acde3b8e663e51a56b3d27561c09878e Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 3 Aug 2023 16:39:36 -0700
Subject: [PATCH 0295/1487] libsnapshot: take in compression_level

Changing libsnapshot to have configurable compression_level

Test: ota_from_target_files
Change-Id: I4c050a2c83cc0fa9079f94dd2d9009f291358740
---
 .../include/libsnapshot/cow_writer.h          | 14 +++---
 .../libsnapshot_cow/cow_compress.cpp          | 49 ++++++++++++++-----
 .../libsnapshot/libsnapshot_cow/test_v2.cpp   | 14 +++++-
 .../libsnapshot/libsnapshot_cow/writer_v2.cpp | 35 ++++++++++---
 4 files changed, 83 insertions(+), 29 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index d6194eb9396f..755050fa1d4f 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -110,16 +110,17 @@ class ICowWriter {
 
 class CompressWorker {
   public:
-    CompressWorker(CowCompressionAlgorithm compression, uint32_t block_size);
+    CompressWorker(CowCompression compression, uint32_t block_size);
     bool RunThread();
     void EnqueueCompressBlocks(const void* buffer, size_t num_blocks);
     bool GetCompressedBuffers(std::vector<std::basic_string<uint8_t>>* compressed_buf);
     void Finalize();
-    static std::basic_string<uint8_t> Compress(CowCompressionAlgorithm compression,
-                                               const void* data, size_t length);
+    static uint32_t GetDefaultCompressionLevel(CowCompressionAlgorithm compression);
+    static std::basic_string<uint8_t> Compress(CowCompression compression, const void* data,
+                                               size_t length);
 
-    static bool CompressBlocks(CowCompressionAlgorithm compression, size_t block_size,
-                               const void* buffer, size_t num_blocks,
+    static bool CompressBlocks(CowCompression compression, size_t block_size, const void* buffer,
+                               size_t num_blocks,
                                std::vector<std::basic_string<uint8_t>>* compressed_data);
 
   private:
@@ -130,7 +131,7 @@ class CompressWorker {
         std::vector<std::basic_string<uint8_t>> compressed_data;
     };
 
-    CowCompressionAlgorithm compression_;
+    CowCompression compression_;
     uint32_t block_size_;
 
     std::queue<CompressWork> work_queue_;
@@ -139,7 +140,6 @@ class CompressWorker {
     std::condition_variable cv_;
     bool stopped_ = false;
 
-    std::basic_string<uint8_t> Compress(const void* data, size_t length);
     bool CompressBlocks(const void* buffer, size_t num_blocks,
                         std::vector<std::basic_string<uint8_t>>* compressed_data);
 };
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
index a4a0ad661823..96d60161218d 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
@@ -46,24 +46,47 @@ std::optional<CowCompressionAlgorithm> CompressionAlgorithmFromString(std::strin
     } else if (name == "none" || name.empty()) {
         return {kCowCompressNone};
     } else {
+        LOG(ERROR) << "unable to determine default compression algorithm for: " << name;
         return {};
     }
 }
 
-std::basic_string<uint8_t> CompressWorker::Compress(const void* data, size_t length) {
-    return Compress(compression_, data, length);
+// 1. Default compression level is determined by compression algorithm
+// 2. There might be compatibility issues if a value is changed here, as  some older versions of
+// Android will assume a different compression level, causing cow_size estimation differences that
+// will lead to OTA failure. Ensure that the device and OTA package use the same compression level
+// for OTA to succeed.
+uint32_t CompressWorker::GetDefaultCompressionLevel(CowCompressionAlgorithm compression) {
+    switch (compression) {
+        case kCowCompressGz: {
+            return Z_BEST_COMPRESSION;
+        }
+        case kCowCompressBrotli: {
+            return BROTLI_DEFAULT_QUALITY;
+        }
+        case kCowCompressLz4: {
+            break;
+        }
+        case kCowCompressZstd: {
+            return ZSTD_defaultCLevel();
+        }
+        case kCowCompressNone: {
+            break;
+        }
+    }
+    return 0;
 }
 
-std::basic_string<uint8_t> CompressWorker::Compress(CowCompressionAlgorithm compression,
-                                                    const void* data, size_t length) {
-    switch (compression) {
+std::basic_string<uint8_t> CompressWorker::Compress(CowCompression compression, const void* data,
+                                                    size_t length) {
+    switch (compression.algorithm) {
         case kCowCompressGz: {
             const auto bound = compressBound(length);
             std::basic_string<uint8_t> buffer(bound, '\0');
 
             uLongf dest_len = bound;
             auto rv = compress2(buffer.data(), &dest_len, reinterpret_cast<const Bytef*>(data),
-                                length, Z_BEST_COMPRESSION);
+                                length, compression.compression_level);
             if (rv != Z_OK) {
                 LOG(ERROR) << "compress2 returned: " << rv;
                 return {};
@@ -81,8 +104,8 @@ std::basic_string<uint8_t> CompressWorker::Compress(CowCompressionAlgorithm comp
 
             size_t encoded_size = bound;
             auto rv = BrotliEncoderCompress(
-                    BROTLI_DEFAULT_QUALITY, BROTLI_DEFAULT_WINDOW, BROTLI_DEFAULT_MODE, length,
-                    reinterpret_cast<const uint8_t*>(data), &encoded_size, buffer.data());
+                    compression.compression_level, BROTLI_DEFAULT_WINDOW, BROTLI_DEFAULT_MODE,
+                    length, reinterpret_cast<const uint8_t*>(data), &encoded_size, buffer.data());
             if (!rv) {
                 LOG(ERROR) << "BrotliEncoderCompress failed";
                 return {};
@@ -117,8 +140,8 @@ std::basic_string<uint8_t> CompressWorker::Compress(CowCompressionAlgorithm comp
         }
         case kCowCompressZstd: {
             std::basic_string<uint8_t> buffer(ZSTD_compressBound(length), '\0');
-            const auto compressed_size =
-                    ZSTD_compress(buffer.data(), buffer.size(), data, length, 0);
+            const auto compressed_size = ZSTD_compress(buffer.data(), buffer.size(), data, length,
+                                                       compression.compression_level);
             if (compressed_size <= 0) {
                 LOG(ERROR) << "ZSTD compression failed " << compressed_size;
                 return {};
@@ -133,7 +156,7 @@ std::basic_string<uint8_t> CompressWorker::Compress(CowCompressionAlgorithm comp
             return buffer;
         }
         default:
-            LOG(ERROR) << "unhandled compression type: " << compression;
+            LOG(ERROR) << "unhandled compression type: " << compression.algorithm;
             break;
     }
     return {};
@@ -143,7 +166,7 @@ bool CompressWorker::CompressBlocks(const void* buffer, size_t num_blocks,
     return CompressBlocks(compression_, block_size_, buffer, num_blocks, compressed_data);
 }
 
-bool CompressWorker::CompressBlocks(CowCompressionAlgorithm compression, size_t block_size,
+bool CompressWorker::CompressBlocks(CowCompression compression, size_t block_size,
                                     const void* buffer, size_t num_blocks,
                                     std::vector<std::basic_string<uint8_t>>* compressed_data) {
     const uint8_t* iter = reinterpret_cast<const uint8_t*>(buffer);
@@ -255,7 +278,7 @@ void CompressWorker::Finalize() {
     cv_.notify_all();
 }
 
-CompressWorker::CompressWorker(CowCompressionAlgorithm compression, uint32_t block_size)
+CompressWorker::CompressWorker(CowCompression compression, uint32_t block_size)
     : compression_(compression), block_size_(block_size) {}
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index ab275d4eba0f..2258d9fb75cb 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -480,7 +480,7 @@ TEST_P(CompressionTest, HorribleStream) {
     std::string expected = "The quick brown fox jumps over the lazy dog.";
     expected.resize(4096, '\0');
 
-    auto result = CompressWorker::Compress(*algorithm, expected.data(), expected.size());
+    auto result = CompressWorker::Compress(compression, expected.data(), expected.size());
     ASSERT_FALSE(result.empty());
 
     HorribleStream<uint8_t> stream(result);
@@ -1409,6 +1409,18 @@ TEST_F(CowTest, RevMergeOpItrTest) {
     ASSERT_TRUE(iter->AtEnd());
 }
 
+TEST_F(CowTest, ParseOptionsTest) {
+    CowOptions options;
+    std::vector<std::pair<std::string, bool>> testcases = {
+            {"gz,4", true},   {"gz,4,4", false}, {"lz4,4", true}, {"brotli,4", true},
+            {"zstd,4", true}, {"zstd,x", false}, {"zs,4", false}, {"zstd.4", false}};
+    for (size_t i = 0; i < testcases.size(); i++) {
+        options.compression = testcases[i].first;
+        CowWriterV2 writer(options, GetCowFd());
+        ASSERT_EQ(writer.Initialize(), testcases[i].second);
+    }
+}
+
 TEST_F(CowTest, LegacyRevMergeOpItrTest) {
     CowOptions options;
     options.cluster_ops = 5;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index cbd7569d210f..4ab5713b476a 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -39,6 +39,8 @@
 #include <sys/ioctl.h>
 #include <unistd.h>
 
+#include "android-base/parseint.h"
+#include "android-base/strings.h"
 #include "parser_v2.h"
 
 // The info messages here are spammy, but as useful for update_engine. Disable
@@ -119,11 +121,28 @@ void CowWriterV2::SetupHeaders() {
 }
 
 bool CowWriterV2::ParseOptions() {
-    auto algorithm = CompressionAlgorithmFromString(options_.compression);
+    auto parts = android::base::Split(options_.compression, ",");
+
+    if (parts.size() > 2) {
+        LOG(ERROR) << "failed to parse compression parameters: invalid argument count: "
+                   << parts.size() << " " << options_.compression;
+        return false;
+    }
+    auto algorithm = CompressionAlgorithmFromString(parts[0]);
     if (!algorithm) {
         LOG(ERROR) << "unrecognized compression: " << options_.compression;
         return false;
     }
+    if (parts.size() > 1) {
+        if (!android::base::ParseUint(parts[1], &compression_.compression_level)) {
+            LOG(ERROR) << "failed to parse compression level invalid type: " << parts[1];
+            return false;
+        }
+    } else {
+        compression_.compression_level =
+                CompressWorker::GetDefaultCompressionLevel(algorithm.value());
+    }
+
     compression_.algorithm = *algorithm;
 
     if (options_.cluster_ops == 1) {
@@ -165,7 +184,7 @@ void CowWriterV2::InitWorkers() {
         return;
     }
     for (int i = 0; i < num_compress_threads_; i++) {
-        auto wt = std::make_unique<CompressWorker>(compression_.algorithm, header_.block_size);
+        auto wt = std::make_unique<CompressWorker>(compression_, header_.block_size);
         threads_.emplace_back(std::async(std::launch::async, &CompressWorker::RunThread, wt.get()));
         compress_threads_.push_back(std::move(wt));
     }
@@ -320,8 +339,8 @@ bool CowWriterV2::CompressBlocks(size_t num_blocks, const void* data) {
     const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
     compressed_buf_.clear();
     if (num_threads <= 1) {
-        return CompressWorker::CompressBlocks(compression_.algorithm, options_.block_size, data,
-                                              num_blocks, &compressed_buf_);
+        return CompressWorker::CompressBlocks(compression_, options_.block_size, data, num_blocks,
+                                              &compressed_buf_);
     }
 
     // Submit the blocks per thread. The retrieval of
@@ -393,8 +412,8 @@ bool CowWriterV2::EmitBlocks(uint64_t new_block_start, const void* data, size_t
                         buf_iter_++;
                         return data;
                     } else {
-                        auto data = CompressWorker::Compress(compression_.algorithm, iter,
-                                                             header_.block_size);
+                        auto data =
+                                CompressWorker::Compress(compression_, iter, header_.block_size);
                         return data;
                     }
                 }();
@@ -507,8 +526,8 @@ bool CowWriterV2::Finalize() {
         }
     }
 
-    // Footer should be at the end of a file, so if there is data after the current block, end it
-    // and start a new cluster.
+    // Footer should be at the end of a file, so if there is data after the current block, end
+    // it and start a new cluster.
     if (cluster_size_ && current_data_size_ > 0) {
         EmitCluster();
         extra_cluster = true;

From fe6c1d55f72da9429fcae161cd582125e59b027c Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 8 Aug 2023 08:46:43 -0700
Subject: [PATCH 0296/1487] Moving includes

Removing unused includes + moving includes to file that uses them

Test: m libsnapshot
Change-Id: Iacb1d1d0d17cf9059583443e9a17fdc1007bc399
---
 fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h | 3 ---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp    | 2 +-
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h      | 1 +
 3 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 755050fa1d4f..74b8bb845533 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -18,14 +18,11 @@
 
 #include <condition_variable>
 #include <cstdint>
-#include <future>
 #include <memory>
 #include <mutex>
 #include <optional>
 #include <queue>
 #include <string>
-#include <thread>
-#include <utility>
 #include <vector>
 
 #include <android-base/unique_fd.h>
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index 4ab5713b476a..6d04c6a0c380 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -20,8 +20,8 @@
 #include <sys/uio.h>
 #include <unistd.h>
 
+#include <future>
 #include <limits>
-#include <queue>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
index 1aa851872f42..3f357e024cf0 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
@@ -14,6 +14,7 @@
 
 #pragma once
 
+#include <future>
 #include "writer_base.h"
 
 namespace android {

From 0ff0eeed775142048c4f22021310d6a7b3084e53 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 12 May 2023 10:09:23 -0700
Subject: [PATCH 0297/1487] libfs_avb: Allow overriding the slot suffix.

There is no easy way to override fs_mgr_get_slot_suffix for testing or
for simulating slot switches. It relies on global properties, and
since fstab is usually a static library, linked multiple times, we can't
just stick a global variable in fs_mgr_slotselect.

libfs_avb already takes slot suffix arguments in various places. This CL
extends that by adding arguments to AvbHandle and FsManagerAvbOps.

Bug: N/A
Test: snapshotctl
Change-Id: Ide7f052b38249d6bc79a6a2c124baf8ca08bcc3b
---
 fs_mgr/libfs_avb/avb_ops.cpp             | 13 ++++++++----
 fs_mgr/libfs_avb/avb_ops.h               |  3 ++-
 fs_mgr/libfs_avb/fs_avb.cpp              | 25 ++++++++++++++++++------
 fs_mgr/libfs_avb/include/fs_avb/fs_avb.h |  8 +++++---
 fs_mgr/libfstab/include/fstab/fstab.h    |  3 +++
 fs_mgr/libfstab/slotselect.cpp           | 10 ++++++++++
 6 files changed, 48 insertions(+), 14 deletions(-)

diff --git a/fs_mgr/libfs_avb/avb_ops.cpp b/fs_mgr/libfs_avb/avb_ops.cpp
index a119bfcde274..cc197761984d 100644
--- a/fs_mgr/libfs_avb/avb_ops.cpp
+++ b/fs_mgr/libfs_avb/avb_ops.cpp
@@ -108,8 +108,8 @@ static AvbIOResult get_size_of_partition(AvbOps* ops ATTRIBUTE_UNUSED,
 // Converts a partition name (with ab_suffix) to the corresponding mount point.
 // e.g., "system_a" => "/system",
 // e.g., "vendor_a" => "/vendor",
-static std::string DeriveMountPoint(const std::string& partition_name) {
-    const std::string ab_suffix = fs_mgr_get_slot_suffix();
+static std::string DeriveMountPoint(const std::string& partition_name,
+                                    const std::string& ab_suffix) {
     std::string mount_point(partition_name);
     auto found = partition_name.rfind(ab_suffix);
     if (found != std::string::npos) {
@@ -119,7 +119,7 @@ static std::string DeriveMountPoint(const std::string& partition_name) {
     return "/" + mount_point;
 }
 
-FsManagerAvbOps::FsManagerAvbOps() {
+FsManagerAvbOps::FsManagerAvbOps(const std::string& slot_suffix) {
     // We only need to provide the implementation of read_from_partition()
     // operation since that's all what is being used by the avb_slot_verify().
     // Other I/O operations are only required in bootloader but not in
@@ -135,6 +135,11 @@ FsManagerAvbOps::FsManagerAvbOps() {
 
     // Sets user_data for GetInstanceFromAvbOps() to convert it back to FsManagerAvbOps.
     avb_ops_.user_data = this;
+
+    slot_suffix_ = slot_suffix;
+    if (slot_suffix_.empty()) {
+        slot_suffix_ = fs_mgr_get_slot_suffix();
+    }
 }
 
 // Given a partition name (with ab_suffix), e.g., system_a, returns the corresponding
@@ -149,7 +154,7 @@ std::string FsManagerAvbOps::GetLogicalPath(const std::string& partition_name) {
         return "";
     }
 
-    const auto mount_point = DeriveMountPoint(partition_name);
+    const auto mount_point = DeriveMountPoint(partition_name, slot_suffix_);
     if (mount_point.empty()) return "";
 
     auto fstab_entry = GetEntryForMountPoint(&fstab_, mount_point);
diff --git a/fs_mgr/libfs_avb/avb_ops.h b/fs_mgr/libfs_avb/avb_ops.h
index 12686a61df5b..709091e3832e 100644
--- a/fs_mgr/libfs_avb/avb_ops.h
+++ b/fs_mgr/libfs_avb/avb_ops.h
@@ -48,7 +48,7 @@ namespace fs_mgr {
 //
 class FsManagerAvbOps {
   public:
-    FsManagerAvbOps();
+    explicit FsManagerAvbOps(const std::string& slot_suffix = {});
 
     static FsManagerAvbOps* GetInstanceFromAvbOps(AvbOps* ops) {
         return reinterpret_cast<FsManagerAvbOps*>(ops->user_data);
@@ -66,6 +66,7 @@ class FsManagerAvbOps {
     std::string GetPartitionPath(const char* partition_name);
     AvbOps avb_ops_;
     Fstab fstab_;
+    std::string slot_suffix_;
 };
 
 }  // namespace fs_mgr
diff --git a/fs_mgr/libfs_avb/fs_avb.cpp b/fs_mgr/libfs_avb/fs_avb.cpp
index a28887627673..fb224230fe4c 100644
--- a/fs_mgr/libfs_avb/fs_avb.cpp
+++ b/fs_mgr/libfs_avb/fs_avb.cpp
@@ -182,6 +182,11 @@ bool AvbVerifier::VerifyVbmetaImages(const std::vector<VBMetaData>& vbmeta_image
 
 // class AvbHandle
 // ---------------
+AvbHandle::AvbHandle() : status_(AvbHandleStatus::kUninitialized) {
+    slot_suffix_ = fs_mgr_get_slot_suffix();
+    other_slot_suffix_ = fs_mgr_get_other_slot_suffix();
+}
+
 AvbUniquePtr AvbHandle::LoadAndVerifyVbmeta(
         const std::string& partition_name, const std::string& ab_suffix,
         const std::string& ab_other_suffix, const std::string& expected_public_key_path,
@@ -194,6 +199,9 @@ AvbUniquePtr AvbHandle::LoadAndVerifyVbmeta(
         return nullptr;
     }
 
+    avb_handle->slot_suffix_ = ab_suffix;
+    avb_handle->other_slot_suffix_ = ab_other_suffix;
+
     std::string expected_key_blob;
     if (!expected_public_key_path.empty()) {
         if (access(expected_public_key_path.c_str(), F_OK) != 0) {
@@ -373,9 +381,14 @@ AvbUniquePtr AvbHandle::LoadAndVerifyVbmeta(const FstabEntry& fstab_entry,
     return avb_handle;
 }
 
-AvbUniquePtr AvbHandle::LoadAndVerifyVbmeta() {
+AvbUniquePtr AvbHandle::LoadAndVerifyVbmeta(const std::string& slot_suffix) {
     // Loads inline vbmeta images, starting from /vbmeta.
-    return LoadAndVerifyVbmeta("vbmeta", fs_mgr_get_slot_suffix(), fs_mgr_get_other_slot_suffix(),
+    auto suffix = slot_suffix;
+    if (suffix.empty()) {
+        suffix = fs_mgr_get_slot_suffix();
+    }
+    auto other_suffix = android::fs_mgr::OtherSlotSuffix(suffix);
+    return LoadAndVerifyVbmeta("vbmeta", suffix, other_suffix,
                                {} /* expected_public_key, already checked by bootloader */,
                                HashAlgorithm::kSHA256,
                                IsAvbPermissive(), /* allow_verification_error */
@@ -399,7 +412,7 @@ AvbUniquePtr AvbHandle::Open() {
                                        ? AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR
                                        : AVB_SLOT_VERIFY_FLAGS_NONE;
     AvbSlotVerifyResult verify_result =
-            avb_ops.AvbSlotVerify(fs_mgr_get_slot_suffix(), flags, &avb_handle->vbmeta_images_);
+            avb_ops.AvbSlotVerify(avb_handle->slot_suffix_, flags, &avb_handle->vbmeta_images_);
 
     // Only allow the following verify results:
     //   - AVB_SLOT_VERIFY_RESULT_OK.
@@ -492,7 +505,7 @@ AvbHashtreeResult AvbHandle::SetUpAvbHashtree(FstabEntry* fstab_entry, bool wait
     }
 
     if (!LoadAvbHashtreeToEnableVerity(fstab_entry, wait_for_verity_dev, vbmeta_images_,
-                                       fs_mgr_get_slot_suffix(), fs_mgr_get_other_slot_suffix())) {
+                                       slot_suffix_, other_slot_suffix_)) {
         return AvbHashtreeResult::kFail;
     }
 
@@ -526,8 +539,8 @@ std::string AvbHandle::GetSecurityPatchLevel(const FstabEntry& fstab_entry) cons
     if (vbmeta_images_.size() < 1) {
         return "";
     }
-    std::string avb_partition_name = DeriveAvbPartitionName(fstab_entry, fs_mgr_get_slot_suffix(),
-                                                            fs_mgr_get_other_slot_suffix());
+    std::string avb_partition_name =
+            DeriveAvbPartitionName(fstab_entry, slot_suffix_, other_slot_suffix_);
     auto avb_prop_name = "com.android.build." + avb_partition_name + ".security_patch";
     return GetAvbPropertyDescriptor(avb_prop_name, vbmeta_images_);
 }
diff --git a/fs_mgr/libfs_avb/include/fs_avb/fs_avb.h b/fs_mgr/libfs_avb/include/fs_avb/fs_avb.h
index 4702e6807914..924ab247384f 100644
--- a/fs_mgr/libfs_avb/include/fs_avb/fs_avb.h
+++ b/fs_mgr/libfs_avb/include/fs_avb/fs_avb.h
@@ -83,8 +83,8 @@ class AvbHandle {
     //     is verified and can be trusted.
     //
     // TODO(bowgotsai): remove Open() and switch to LoadAndVerifyVbmeta().
-    static AvbUniquePtr Open();                 // loads inline vbmeta, via libavb.
-    static AvbUniquePtr LoadAndVerifyVbmeta();  // loads inline vbmeta.
+    static AvbUniquePtr Open();  // loads inline vbmeta, via libavb.
+    static AvbUniquePtr LoadAndVerifyVbmeta(const std::string& slot_suffix = {});
 
     // The caller can specify optional preload_avb_key_blobs for public key matching.
     // This is mostly for init to preload AVB keys before chroot into /system.
@@ -137,12 +137,14 @@ class AvbHandle {
     AvbHandle& operator=(AvbHandle&&) noexcept = delete;  // no move assignment
 
   private:
-    AvbHandle() : status_(AvbHandleStatus::kUninitialized) {}
+    AvbHandle();
 
     std::vector<VBMetaData> vbmeta_images_;
     VBMetaInfo vbmeta_info_;  // A summary info for vbmeta_images_.
     AvbHandleStatus status_;
     std::string avb_version_;
+    std::string slot_suffix_;
+    std::string other_slot_suffix_;
 };
 
 }  // namespace fs_mgr
diff --git a/fs_mgr/libfstab/include/fstab/fstab.h b/fs_mgr/libfstab/include/fstab/fstab.h
index 150a47da350c..09471f087f6c 100644
--- a/fs_mgr/libfstab/include/fstab/fstab.h
+++ b/fs_mgr/libfstab/include/fstab/fstab.h
@@ -145,5 +145,8 @@ void ImportKernelCmdline(const std::function<void(std::string, std::string)>& fn
 // Otherwise returns false and |*out| is not modified.
 bool GetKernelCmdline(const std::string& key, std::string* out);
 
+// Return the "other" slot for the given slot suffix.
+std::string OtherSlotSuffix(const std::string& suffix);
+
 }  // namespace fs_mgr
 }  // namespace android
diff --git a/fs_mgr/libfstab/slotselect.cpp b/fs_mgr/libfstab/slotselect.cpp
index 97b2ba1f575f..db3f8da64254 100644
--- a/fs_mgr/libfstab/slotselect.cpp
+++ b/fs_mgr/libfstab/slotselect.cpp
@@ -74,3 +74,13 @@ bool fs_mgr_update_for_slotselect(Fstab* fstab) {
     }
     return true;
 }
+
+namespace android {
+namespace fs_mgr {
+
+std::string OtherSlotSuffix(const std::string& suffix) {
+    return other_suffix(suffix);
+}
+
+}  // namespace fs_mgr
+}  // namespace android

From ad5df3256061b2afeddc05c30200fe3f9df2543f Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 8 Aug 2023 13:49:27 -0700
Subject: [PATCH 0298/1487] decompressor maintenence

cleaning up a bit of code for consistency + adding in zstd to
FromString() function

Test: m libsnapshot
Change-Id: Ic8b7243c5a5ee25326a46e944c13578136f27078
---
 .../libsnapshot_cow/cow_decompress.cpp        | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp
index da90cc048169..3692c1a8aa9c 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp
@@ -18,6 +18,7 @@
 
 #include <array>
 #include <cstring>
+#include <memory>
 #include <utility>
 #include <vector>
 
@@ -62,6 +63,8 @@ std::unique_ptr<IDecompressor> IDecompressor::FromString(std::string_view compre
         return IDecompressor::Brotli();
     } else if (compressor == "gz") {
         return IDecompressor::Gz();
+    } else if (compressor == "zstd") {
+        return IDecompressor::Zstd();
     } else {
         return nullptr;
     }
@@ -211,10 +214,6 @@ bool GzDecompressor::PartialDecompress(const uint8_t* data, size_t length) {
     return true;
 }
 
-std::unique_ptr<IDecompressor> IDecompressor::Gz() {
-    return std::unique_ptr<IDecompressor>(new GzDecompressor());
-}
-
 class BrotliDecompressor final : public StreamDecompressor {
   public:
     ~BrotliDecompressor();
@@ -275,10 +274,6 @@ bool BrotliDecompressor::PartialDecompress(const uint8_t* data, size_t length) {
     return true;
 }
 
-std::unique_ptr<IDecompressor> IDecompressor::Brotli() {
-    return std::unique_ptr<IDecompressor>(new BrotliDecompressor());
-}
-
 class Lz4Decompressor final : public IDecompressor {
   public:
     ~Lz4Decompressor() override = default;
@@ -382,6 +377,14 @@ class ZstdDecompressor final : public IDecompressor {
     }
 };
 
+std::unique_ptr<IDecompressor> IDecompressor::Brotli() {
+    return std::make_unique<BrotliDecompressor>();
+}
+
+std::unique_ptr<IDecompressor> IDecompressor::Gz() {
+    return std::make_unique<GzDecompressor>();
+}
+
 std::unique_ptr<IDecompressor> IDecompressor::Lz4() {
     return std::make_unique<Lz4Decompressor>();
 }

From 1b13b14758257350cb76381b52c906685ed58c74 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 8 Aug 2023 16:00:30 -0700
Subject: [PATCH 0299/1487] crasher: add pac and bti crashes.

Also add the missing `.size` directives to all the assembler functions
for slightly improved backtraces.

Test: crasher64 pac; crasher64 bti
Change-Id: I8e0c127cbff56c33637e6ca8f1d927b971951807
---
 debuggerd/crasher/arm/crashglue.S     |  8 ++--
 debuggerd/crasher/arm64/crashglue.S   | 45 +++++++++++++++++++--
 debuggerd/crasher/crasher.cpp         | 56 ++++++++++++++++++++++-----
 debuggerd/crasher/riscv64/crashglue.S |  6 ++-
 debuggerd/crasher/x86/crashglue.S     |  6 ++-
 debuggerd/crasher/x86_64/crashglue.S  |  6 ++-
 6 files changed, 105 insertions(+), 22 deletions(-)

diff --git a/debuggerd/crasher/arm/crashglue.S b/debuggerd/crasher/arm/crashglue.S
index e4adf403cd85..0def8aee3f7b 100644
--- a/debuggerd/crasher/arm/crashglue.S
+++ b/debuggerd/crasher/arm/crashglue.S
@@ -23,10 +23,11 @@ crash1:
 	ldr lr, [lr]
 	b .
 	.cfi_endproc
+	.size crash1, .-crash1
 
-.globl crashnostack
-.type crashnostack, %function
-crashnostack:
+.globl crash_no_stack
+.type crash_no_stack, %function
+crash_no_stack:
 	.cfi_startproc
 	mov r1, sp
 	.cfi_def_cfa_register r1
@@ -35,3 +36,4 @@ crashnostack:
 	ldr r0, [r0]
 	b .
 	.cfi_endproc
+	.size crash_no_stack, .-crash_no_stack
diff --git a/debuggerd/crasher/arm64/crashglue.S b/debuggerd/crasher/arm64/crashglue.S
index 97c824efb2d2..c56e19a388c7 100644
--- a/debuggerd/crasher/arm64/crashglue.S
+++ b/debuggerd/crasher/arm64/crashglue.S
@@ -41,11 +41,12 @@ crash1:
 	ldr x30, [x30]
 	b .
 	.cfi_endproc
+	.size crash1, .-crash1
 
 
-.globl crashnostack
-.type crashnostack, %function
-crashnostack:
+.globl crash_no_stack
+.type crash_no_stack, %function
+crash_no_stack:
 	.cfi_startproc
 	mov x1, sp
 	.cfi_def_cfa_register x1
@@ -54,3 +55,41 @@ crashnostack:
 	ldr x0, [x0]
 	b .
 	.cfi_endproc
+	.size crash_no_stack, .-crash_no_stack
+
+
+.globl crash_bti
+.type crash_bti, %function
+crash_bti:
+	.cfi_startproc
+	adr x16, 1f
+	br x16
+1:	// Deliberatly not a bti instruction so we crash here.
+	b .
+	.cfi_endproc
+	.size crash_bti, .-crash_bti
+
+
+.globl crash_pac
+.type crash_pac, %function
+crash_pac:
+	.cfi_startproc
+	paciasp
+	// Since sp is a pac input, this ensures a mismatch.
+	sub sp, sp, #16
+	autiasp
+	b .
+	.cfi_endproc
+	.size crash_pac, .-crash_pac
+
+// Set the PAC and BTI bits for this object file.
+.section .note.gnu.property, "a"
+.balign 8
+.long 4
+.long 0x10
+.long 0x5
+.asciz "GNU"
+.long 0xc0000000
+.long 4
+.long 0x3
+.long 0
diff --git a/debuggerd/crasher/crasher.cpp b/debuggerd/crasher/crasher.cpp
index 12ba502ecf8b..3b52776d7b32 100644
--- a/debuggerd/crasher/crasher.cpp
+++ b/debuggerd/crasher/crasher.cpp
@@ -19,6 +19,7 @@
 #include <assert.h>
 #include <dirent.h>
 #include <errno.h>
+#include <error.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <signal.h>
@@ -29,6 +30,9 @@
 #include <sys/prctl.h>
 #include <unistd.h>
 
+#include <android-base/file.h>
+#include <android-base/strings.h>
+
 // We test both kinds of logging.
 #include <android-base/logging.h>
 #include <log/log.h>
@@ -59,8 +63,10 @@ typedef int (__kuser_cmpxchg64_t)(const int64_t*, const int64_t*, volatile int64
 // Avoid name mangling so that stacks are more readable.
 extern "C" {
 
-void crash1(void);
-void crashnostack(void);
+void crash1();
+void crash_no_stack();
+void crash_bti();
+void crash_pac();
 
 int do_action(const char* arg);
 
@@ -196,13 +202,6 @@ static int usage() {
     fprintf(stderr, "  fdsan_file            close a file descriptor that's owned by a FILE*\n");
     fprintf(stderr, "  fdsan_dir             close a file descriptor that's owned by a DIR*\n");
     fprintf(stderr, "  seccomp               fail a seccomp check\n");
-#if defined(__arm__)
-    fprintf(stderr, "  kuser_helper_version  call kuser_helper_version\n");
-    fprintf(stderr, "  kuser_get_tls         call kuser_get_tls\n");
-    fprintf(stderr, "  kuser_cmpxchg         call kuser_cmpxchg\n");
-    fprintf(stderr, "  kuser_memory_barrier  call kuser_memory_barrier\n");
-    fprintf(stderr, "  kuser_cmpxchg64       call kuser_cmpxchg64\n");
-#endif
     fprintf(stderr, "  xom                   read execute-only memory\n");
     fprintf(stderr, "\n");
     fprintf(stderr, "  LOG_ALWAYS_FATAL      call liblog LOG_ALWAYS_FATAL\n");
@@ -223,6 +222,20 @@ static int usage() {
     fprintf(stderr, "\n");
     fprintf(stderr, "  no_new_privs          set PR_SET_NO_NEW_PRIVS and then abort\n");
     fprintf(stderr, "\n");
+#if defined(__arm__)
+    fprintf(stderr, "Also, since this is an arm32 binary:\n");
+    fprintf(stderr, "  kuser_helper_version  call kuser_helper_version\n");
+    fprintf(stderr, "  kuser_get_tls         call kuser_get_tls\n");
+    fprintf(stderr, "  kuser_cmpxchg         call kuser_cmpxchg\n");
+    fprintf(stderr, "  kuser_memory_barrier  call kuser_memory_barrier\n");
+    fprintf(stderr, "  kuser_cmpxchg64       call kuser_cmpxchg64\n");
+#endif
+#if defined(__aarch64__)
+    fprintf(stderr, "Also, since this is an arm64 binary:\n");
+    fprintf(stderr, "  bti                   fail a branch target identification (BTI) check\n");
+    fprintf(stderr, "  pac                   fail a pointer authentication (PAC) check\n");
+#endif
+    fprintf(stderr, "\n");
     fprintf(stderr, "prefix any of the above with 'thread-' to run on a new thread\n");
     fprintf(stderr, "prefix any of the above with 'exhaustfd-' to exhaust\n");
     fprintf(stderr, "all available file descriptors before crashing.\n");
@@ -231,6 +244,21 @@ static int usage() {
     return EXIT_FAILURE;
 }
 
+[[maybe_unused]] static void CheckCpuFeature(const std::string& name) {
+    std::string cpuinfo;
+    if (!android::base::ReadFileToString("/proc/cpuinfo", &cpuinfo)) {
+        error(1, errno, "couldn't read /proc/cpuinfo");
+    }
+    std::vector<std::string> lines = android::base::Split(cpuinfo, "\n");
+    for (std::string_view line : lines) {
+        if (!android::base::ConsumePrefix(&line, "Features\t:")) continue;
+        std::vector<std::string> features = android::base::Split(std::string(line), " ");
+        if (std::find(features.begin(), features.end(), name) == features.end()) {
+          error(1, 0, "/proc/cpuinfo does not report feature '%s'", name.c_str());
+        }
+    }
+}
+
 noinline int do_action(const char* arg) {
     // Prefixes.
     if (!strncmp(arg, "wait-", strlen("wait-"))) {
@@ -256,7 +284,7 @@ noinline int do_action(const char* arg) {
     } else if (!strcasecmp(arg, "stack-overflow")) {
       overflow_stack(nullptr);
     } else if (!strcasecmp(arg, "nostack")) {
-      crashnostack();
+      crash_no_stack();
     } else if (!strcasecmp(arg, "exit")) {
       exit(1);
     } else if (!strcasecmp(arg, "call-null")) {
@@ -349,6 +377,14 @@ noinline int do_action(const char* arg) {
         __kuser_dmb();
     } else if (!strcasecmp(arg, "kuser_cmpxchg64")) {
         return __kuser_cmpxchg64(0, 0, 0);
+#endif
+#if defined(__aarch64__)
+    } else if (!strcasecmp(arg, "bti")) {
+        CheckCpuFeature("bti");
+        crash_bti();
+    } else if (!strcasecmp(arg, "pac")) {
+        CheckCpuFeature("paca");
+        crash_pac();
 #endif
     } else if (!strcasecmp(arg, "no_new_privs")) {
         if (prctl(PR_SET_NO_NEW_PRIVS, 1) != 0) {
diff --git a/debuggerd/crasher/riscv64/crashglue.S b/debuggerd/crasher/riscv64/crashglue.S
index 42f59b345723..f179e336810f 100644
--- a/debuggerd/crasher/riscv64/crashglue.S
+++ b/debuggerd/crasher/riscv64/crashglue.S
@@ -43,10 +43,11 @@ crash1:
 	ld t2, 0(zero)
 	j .
 	.cfi_endproc
+	.size crash1, .-crash1
 
 
-.globl crashnostack
-crashnostack:
+.globl crash_no_stack
+crash_no_stack:
 	.cfi_startproc
 	mv t1, sp
 	.cfi_def_cfa_register t1
@@ -54,3 +55,4 @@ crashnostack:
 	ld t2, 0(zero)
 	j .
 	.cfi_endproc
+	.size crash_no_stack, .-crash_no_stack
diff --git a/debuggerd/crasher/x86/crashglue.S b/debuggerd/crasher/x86/crashglue.S
index e8eb3a7cab5c..453035bf81ab 100644
--- a/debuggerd/crasher/x86/crashglue.S
+++ b/debuggerd/crasher/x86/crashglue.S
@@ -6,13 +6,15 @@ crash1:
 
 	movl $0, %edx
 	jmp *%edx
+	.size crash1, .-crash1
 
 
-.globl crashnostack
-crashnostack:
+.globl crash_no_stack
+crash_no_stack:
 	.cfi_startproc
 	movl %esp, %eax
 	.cfi_def_cfa_register %eax
 	movl $0, %esp
 	movl (%esp), %ebx
 	.cfi_endproc
+	.size crash_no_stack, .-crash_no_stack
diff --git a/debuggerd/crasher/x86_64/crashglue.S b/debuggerd/crasher/x86_64/crashglue.S
index 8f6721478a0b..c3d39c483f3c 100644
--- a/debuggerd/crasher/x86_64/crashglue.S
+++ b/debuggerd/crasher/x86_64/crashglue.S
@@ -6,13 +6,15 @@ crash1:
 
 	movl $0, %edx
 	jmp *%rdx
+	.size crash1, .-crash1
 
 
-.globl crashnostack
-crashnostack:
+.globl crash_no_stack
+crash_no_stack:
 	.cfi_startproc
 	movq %rsp, %rax
 	.cfi_def_cfa_register %rax
 	movq $0, %rsp
 	movq (%rsp), %rbx
 	.cfi_endproc
+	.size crash_no_stack, .-crash_no_stack

From 8665b5f9df3141db35c6b3ddc36286ab1c69a611 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 8 Aug 2023 16:34:19 -0700
Subject: [PATCH 0300/1487] snapuserd: Remove host_supported from
 snapuserd_test until it passes.

Bug: 295074841
Test: snapuserd_test
Change-Id: Ie51263ec6971f9806bcfa2b522e5ed24da5d65cf
---
 fs_mgr/libsnapshot/snapuserd/Android.bp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index fe7f99c675d7..6548cc8a75b0 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -257,5 +257,4 @@ cc_test {
     },
     auto_gen_config: true,
     require_root: false,
-    host_supported: true,
 }

From 566c65239f1cf3fcb0d8745715e5ef1083d4bd3a Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Wed, 9 Aug 2023 07:05:31 +0000
Subject: [PATCH 0301/1487] Use /bootstrap-apex for bootstrap APEXes

This new directory is bind-mounted to /apex in the bootstrap mount
namespace so that apexd-bootstrap mounts bootstrap APEXes there via
/apex.

The directory is shared between two mount namespaces, hence visible
in the default mount namespace.

Bug: 290148078
Test: VendorApexHostTestCases
Change-Id: I841480e41be8def5a4c6a4aa874c4e21465a71d3
---
 init/init.cpp            |  6 ++++++
 init/mount_namespace.cpp | 35 ++++++++++++++++++++++++++---------
 init/mount_namespace.h   |  3 +++
 init/selinux.cpp         |  2 +-
 rootdir/Android.mk       |  2 +-
 5 files changed, 37 insertions(+), 11 deletions(-)

diff --git a/init/init.cpp b/init/init.cpp
index da63fdc3bda5..4bb8eecb981a 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -832,6 +832,12 @@ static void MountExtraFilesystems() {
     CHECKCALL(mount("tmpfs", "/apex", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
                     "mode=0755,uid=0,gid=0"));
 
+    if (NeedsTwoMountNamespaces()) {
+        // /bootstrap-apex is used to mount "bootstrap" APEXes.
+        CHECKCALL(mount("tmpfs", "/bootstrap-apex", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
+                        "mode=0755,uid=0,gid=0"));
+    }
+
     // /linkerconfig is used to keep generated linker configuration
     CHECKCALL(mount("tmpfs", "/linkerconfig", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
                     "mode=0755,uid=0,gid=0"));
diff --git a/init/mount_namespace.cpp b/init/mount_namespace.cpp
index 5b53d5092227..7918f23e9e82 100644
--- a/init/mount_namespace.cpp
+++ b/init/mount_namespace.cpp
@@ -66,15 +66,6 @@ static std::string GetMountNamespaceId() {
     return ret;
 }
 
-// In case we have two sets of APEXes (non-updatable, updatable), we need two separate mount
-// namespaces.
-static bool NeedsTwoMountNamespaces() {
-    if (IsRecoveryMode()) return false;
-    // In microdroid, there's only one set of APEXes in built-in directories include block devices.
-    if (IsMicrodroid()) return false;
-    return true;
-}
-
 static android::base::unique_fd bootstrap_ns_fd;
 static android::base::unique_fd default_ns_fd;
 
@@ -83,6 +74,15 @@ static std::string default_ns_id;
 
 }  // namespace
 
+// In case we have two sets of APEXes (non-updatable, updatable), we need two separate mount
+// namespaces.
+bool NeedsTwoMountNamespaces() {
+    if (IsRecoveryMode()) return false;
+    // In microdroid, there's only one set of APEXes in built-in directories include block devices.
+    if (IsMicrodroid()) return false;
+    return true;
+}
+
 bool SetupMountNamespaces() {
     // Set the propagation type of / as shared so that any mounting event (e.g.
     // /data) is by default visible to all processes. When private mounting is
@@ -163,6 +163,23 @@ bool SetupMountNamespaces() {
             PLOG(ERROR) << "Cannot switch back to bootstrap mount namespace";
             return false;
         }
+
+        // Some components (e.g. servicemanager) need to access bootstrap
+        // APEXes from the default mount namespace. To achieve that, we bind-mount
+        // /apex to /bootstrap-apex in the bootstrap mount namespace. Since /bootstrap-apex
+        // is "shared", the mounts are visible in the default mount namespace as well.
+        //
+        // The end result will look like:
+        //   in the bootstrap mount namespace:
+        //     /apex  (== /bootstrap-apex)
+        //       {bootstrap APEXes from the read-only partition}
+        //
+        //   in the default mount namespace:
+        //     /bootstrap-apex
+        //       {bootstrap APEXes from the read-only partition}
+        //     /apex
+        //       {APEXes, can be from /data partition}
+        if (!(BindMount("/bootstrap-apex", "/apex"))) return false;
     } else {
         // Otherwise, default == bootstrap
         default_ns_fd.reset(OpenMountNamespace());
diff --git a/init/mount_namespace.h b/init/mount_namespace.h
index 5e3dab241290..43c5476a6ab8 100644
--- a/init/mount_namespace.h
+++ b/init/mount_namespace.h
@@ -24,9 +24,12 @@ namespace init {
 enum MountNamespace { NS_BOOTSTRAP, NS_DEFAULT };
 
 bool SetupMountNamespaces();
+
 base::Result<void> SwitchToMountNamespaceIfNeeded(MountNamespace target_mount_namespace);
 
 base::Result<MountNamespace> GetCurrentMountNamespace();
 
+bool NeedsTwoMountNamespaces();
+
 }  // namespace init
 }  // namespace android
diff --git a/init/selinux.cpp b/init/selinux.cpp
index f34474f85093..ebdcaa62db38 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -757,7 +757,7 @@ void SelinuxRestoreContext() {
     selinux_android_restorecon("/dev/device-mapper", 0);
 
     selinux_android_restorecon("/apex", 0);
-
+    selinux_android_restorecon("/bootstrap-apex", 0);
     selinux_android_restorecon("/linkerconfig", 0);
 
     // adb remount, snapshot-based updates, and DSUs all create files during
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 3362872c070d..52187536f3fe 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -91,7 +91,7 @@ endif
 #
 # create some directories (some are mount points) and symlinks
 LOCAL_POST_INSTALL_CMD := mkdir -p $(addprefix $(TARGET_ROOT_OUT)/, \
-    dev proc sys system data data_mirror odm oem acct config storage mnt apex debug_ramdisk \
+    dev proc sys system data data_mirror odm oem acct config storage mnt apex bootstrap-apex debug_ramdisk \
     linkerconfig second_stage_resources postinstall $(BOARD_ROOT_EXTRA_FOLDERS)); \
     ln -sf /system/bin $(TARGET_ROOT_OUT)/bin; \
     ln -sf /system/etc $(TARGET_ROOT_OUT)/etc; \

From cedcb4cd92d0d677d62ec97998ef8b1d467caac5 Mon Sep 17 00:00:00 2001
From: David Drysdale <drysdale@google.com>
Date: Wed, 9 Aug 2023 11:32:48 +0100
Subject: [PATCH 0302/1487] KeyMint HAL: process destroyAttestationIds

Bugs: 283049310
Test: VtsAidlKeyMintTargetTest using disabled test
Change-Id: I545511a7a701faf8e82dff9c169c3738f2c30e6d
---
 trusty/keymaster/TrustyKeymaster.cpp                        | 5 +++++
 trusty/keymaster/include/trusty_keymaster/TrustyKeymaster.h | 2 ++
 trusty/keymaster/keymint/TrustyKeyMintDevice.cpp            | 6 +++++-
 3 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/trusty/keymaster/TrustyKeymaster.cpp b/trusty/keymaster/TrustyKeymaster.cpp
index ac986951da56..b118a2001ca2 100644
--- a/trusty/keymaster/TrustyKeymaster.cpp
+++ b/trusty/keymaster/TrustyKeymaster.cpp
@@ -218,6 +218,11 @@ void TrustyKeymaster::DeleteAllKeys(const DeleteAllKeysRequest& request,
     ForwardCommand(KM_DELETE_ALL_KEYS, request, response);
 }
 
+void TrustyKeymaster::DestroyAttestationIds(const DestroyAttestationIdsRequest& request,
+                                            DestroyAttestationIdsResponse* response) {
+    ForwardCommand(KM_DESTROY_ATTESTATION_IDS, request, response);
+}
+
 void TrustyKeymaster::BeginOperation(const BeginOperationRequest& request,
                                      BeginOperationResponse* response) {
     ForwardCommand(KM_BEGIN_OPERATION, request, response);
diff --git a/trusty/keymaster/include/trusty_keymaster/TrustyKeymaster.h b/trusty/keymaster/include/trusty_keymaster/TrustyKeymaster.h
index 60d3f87ae6e5..c50178bcfa2e 100644
--- a/trusty/keymaster/include/trusty_keymaster/TrustyKeymaster.h
+++ b/trusty/keymaster/include/trusty_keymaster/TrustyKeymaster.h
@@ -55,6 +55,8 @@ class TrustyKeymaster {
     void UpgradeKey(const UpgradeKeyRequest& request, UpgradeKeyResponse* response);
     void DeleteKey(const DeleteKeyRequest& request, DeleteKeyResponse* response);
     void DeleteAllKeys(const DeleteAllKeysRequest& request, DeleteAllKeysResponse* response);
+    void DestroyAttestationIds(const DestroyAttestationIdsRequest& request,
+                               DestroyAttestationIdsResponse* response);
     void BeginOperation(const BeginOperationRequest& request, BeginOperationResponse* response);
     void UpdateOperation(const UpdateOperationRequest& request, UpdateOperationResponse* response);
     void FinishOperation(const FinishOperationRequest& request, FinishOperationResponse* response);
diff --git a/trusty/keymaster/keymint/TrustyKeyMintDevice.cpp b/trusty/keymaster/keymint/TrustyKeyMintDevice.cpp
index b696ff9316be..fec4c60fe19d 100644
--- a/trusty/keymaster/keymint/TrustyKeyMintDevice.cpp
+++ b/trusty/keymaster/keymint/TrustyKeyMintDevice.cpp
@@ -258,7 +258,11 @@ ScopedAStatus TrustyKeyMintDevice::deleteAllKeys() {
 }
 
 ScopedAStatus TrustyKeyMintDevice::destroyAttestationIds() {
-    return kmError2ScopedAStatus(KM_ERROR_UNIMPLEMENTED);
+    keymaster::DestroyAttestationIdsRequest request(impl_->message_version());
+    keymaster::DestroyAttestationIdsResponse response(impl_->message_version());
+    impl_->DestroyAttestationIds(request, &response);
+
+    return kmError2ScopedAStatus(response.error);
 }
 
 ScopedAStatus TrustyKeyMintDevice::begin(KeyPurpose purpose, const vector<uint8_t>& keyBlob,

From 376b70423d3e0ffdb3d032231a7e41d51b0ff746 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 9 Aug 2023 10:52:38 -0700
Subject: [PATCH 0303/1487] Adding force_flash functionality

aosp/2452605 might've accidentally omitted force flash functionality
from fastboot. Some users need to flash dynamic partitions from
bootloader, so we are readding this feature back into fastboot

Test: adb reboot bootloader, fastboot flash system --force

Change-Id: I37a51ebbe38b27ed428c38068d30c0febd7db09c
---
 fastboot/task.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index bf64f0e1e42c..146064cc5b3f 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -32,7 +32,7 @@ FlashTask::FlashTask(const std::string& slot, const std::string& pname, const st
 
 void FlashTask::Run() {
     auto flash = [&](const std::string& partition) {
-        if (should_flash_in_userspace(partition) && !is_userspace_fastboot()) {
+        if (should_flash_in_userspace(partition) && !is_userspace_fastboot() && !fp_->force_flash) {
             die("The partition you are trying to flash is dynamic, and "
                 "should be flashed via fastbootd. Please run:\n"
                 "\n"

From 24a7df5d38c638489cc4e1b3a8034a3b1ad2cf36 Mon Sep 17 00:00:00 2001
From: Tomislav Novak <tnovak@meta.com>
Date: Wed, 9 Aug 2023 15:19:51 -0700
Subject: [PATCH 0304/1487] debuggerd: fix passing of fdsan_table to crash_dump

Commit aosp/1259140 moved fdsan_table into debugger_process_info, which
is populated conditionally. This introduced a bug where the process that
receives BIONIC_SIGNAL_DEBUGGER (35) does not propagate the fdsan_table
pointer to crash_dump:

  $ adb shell kill -SIG35 <pid>
  $ adb logcat -s DEBUG
  E DEBUG   : failed to read fdsan table entry 0: I/O error

Fdsan in warn-only mode uses BIONIC_SIGNAL_DEBUGGER[1], so the generated
tombstones don't have any fd ownership info.

Fix it by calling get_process_info() irrespective of the signal being
handled, taking care to preserve the previous behavior of not showing
abort messages set by applications in non-fatal dumps.

Test: debuggerd_test
Test: send SIG35 to arbitrary process and inspect the log and tombstone
Test: crasher fdsan_file

[1] https://android.googlesource.com/platform/bionic/+/20ad9129e7115417fcd1da922693947580b7f0a6/libc/bionic/fdsan.cpp#166

Change-Id: I76931ca4825e846fc99f26fa590c045130abb850
---
 debuggerd/handler/debuggerd_handler.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index 1e5365d3cd53..01365f22fc10 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -552,8 +552,14 @@ static void debuggerd_signal_handler(int signal_number, siginfo_t* info, void* c
   }
 
   debugger_process_info process_info = {};
+  if (g_callbacks.get_process_info) {
+    process_info = g_callbacks.get_process_info();
+  }
   uintptr_t si_val = reinterpret_cast<uintptr_t>(info->si_ptr);
   if (signal_number == BIONIC_SIGNAL_DEBUGGER) {
+    // Applications can set abort messages via android_set_abort_message without
+    // actually aborting; ignore those messages in non-fatal dumps.
+    process_info.abort_msg = nullptr;
     if (info->si_code == SI_QUEUE && info->si_pid == __getpid()) {
       // Allow for the abort message to be explicitly specified via the sigqueue value.
       // Keep the bottom bit intact for representing whether we want a backtrace or a tombstone.
@@ -562,8 +568,6 @@ static void debuggerd_signal_handler(int signal_number, siginfo_t* info, void* c
         info->si_ptr = reinterpret_cast<void*>(si_val & 1);
       }
     }
-  } else if (g_callbacks.get_process_info) {
-    process_info = g_callbacks.get_process_info();
   }
 
   gwp_asan_callbacks_t gwp_asan_callbacks = {};

From 3a0833c9cdf3b8c09a41bf5cadd9ffe8dd135c84 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Fri, 28 Jul 2023 13:07:53 -0700
Subject: [PATCH 0305/1487] Fix potential miscellaneous debuggerd issues.

Check for the log opening failing.

Add the ability to put error messages in the log and tombstone so
that it's clear if the log reading failed in some way.

Adjust test so that if there is a log or if no log exists, the test
will still pass.

Print an <unknown> if the command line is unreadable instead of nothing.

Test: Ran unit tests.
Test: Induced error and verified error message is save in tombstone.
Change-Id: I2fce8078573b40b9fed3cd453235f3824cadb5e3
---
 debuggerd/debuggerd_test.cpp                  | 10 ++++--
 debuggerd/libdebuggerd/tombstone_proto.cpp    | 35 +++++++++++++++----
 .../libdebuggerd/tombstone_proto_to_text.cpp  |  2 ++
 3 files changed, 37 insertions(+), 10 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 52c1c255458d..19ff7ebf0b44 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -2264,10 +2264,14 @@ TEST_F(CrasherTest, fault_address_after_last_map) {
 
   ASSERT_MATCH(result, R"(\nmemory map \(.*\): \(fault address prefixed with --->)\n)");
 
-  // Assumes that the open files section comes after the map section.
-  // If that assumption changes, the regex below needs to change.
+  // Verifies that the fault address error message is at the end of the
+  // maps section. To do this, the check below looks for the start of the
+  // open files section or the start of the log file section. It's possible
+  // for either of these sections to be present after the maps section right
+  // now.
+  // If the sections move around, this check might need to be modified.
   match_str = android::base::StringPrintf(
-      R"(\n--->Fault address falls at %s after any mapped regions\n\nopen files:)",
+      R"(\n--->Fault address falls at %s after any mapped regions\n(---------|\nopen files:))",
       format_pointer(crash_uptr).c_str());
   ASSERT_MATCH(result, match_str);
 }
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index 7b2e0689e440..744bfabf5afb 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -493,27 +493,48 @@ static void dump_mappings(Tombstone* tombstone, unwindstack::Maps* maps,
   }
 }
 
+// This creates a fake log message that indicates an error occurred when
+// reading the log.
+static void add_error_log_msg(Tombstone* tombstone, const std::string&& error_msg) {
+  LogBuffer buffer;
+  buffer.set_name("ERROR");
+
+  LogMessage* log_msg = buffer.add_logs();
+  log_msg->set_timestamp("00-00 00:00:00.000");
+  log_msg->set_pid(0);
+  log_msg->set_tid(0);
+  log_msg->set_priority(ANDROID_LOG_ERROR);
+  log_msg->set_tag("");
+  log_msg->set_message(error_msg);
+
+  *tombstone->add_log_buffers() = std::move(buffer);
+
+  async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG, "%s", error_msg.c_str());
+}
+
 static void dump_log_file(Tombstone* tombstone, const char* logger, pid_t pid) {
   logger_list* logger_list = android_logger_list_open(android_name_to_log_id(logger),
                                                       ANDROID_LOG_NONBLOCK, kMaxLogMessages, pid);
+  if (logger_list == nullptr) {
+    add_error_log_msg(tombstone, android::base::StringPrintf("Cannot open log file %s", logger));
+    return;
+  }
 
   LogBuffer buffer;
-
   while (true) {
     log_msg log_entry;
     ssize_t actual = android_logger_list_read(logger_list, &log_entry);
-
     if (actual < 0) {
       if (actual == -EINTR) {
         // interrupted by signal, retry
         continue;
       }
-      if (actual == -EAGAIN) {
-        // non-blocking EOF; we're done
-        break;
-      } else {
-        break;
+      // Don't consider EAGAIN an error since this is a non-blocking call.
+      if (actual != -EAGAIN) {
+        add_error_log_msg(tombstone, android::base::StringPrintf("reading log %s failed (%s)",
+                                                                 logger, strerror(-actual)));
       }
+      break;
     } else if (actual == 0) {
       break;
     }
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index 8e6abdfa117e..eed81fc1533a 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -81,6 +81,8 @@ static void print_thread_header(CallbackType callback, const Tombstone& tombston
   if (!tombstone.command_line().empty()) {
     process_name = tombstone.command_line()[0].c_str();
     CB(should_log, "Cmdline: %s", android::base::Join(tombstone.command_line(), " ").c_str());
+  } else {
+    CB(should_log, "Cmdline: <unknown>");
   }
   CB(should_log, "pid: %d, tid: %d, name: %s  >>> %s <<<", tombstone.pid(), thread.id(),
      thread.name().c_str(), process_name);

From 5c4217cf6eb0686fcab73cd55d216859549b6250 Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Thu, 10 Aug 2023 13:12:53 +0900
Subject: [PATCH 0306/1487] Read .rc files from bootstrap apexes

To start an early_hal service from a bootstrap vendor apex, init now
reads .rc files from bootstrap apexes as well.

In this change, perform_apex_config command is re-purposed to support
bootstrap mode. Now we have some similarity between two apexd calls:

- for bootstrap apexes (in the bootstrap mount namespace):

  exec_start apexd-bootstrap
  perform_apex_config --bootstrap

- for normal apexes (in the default mount namespace):

  restart apexd
  ...
  wait_for_prop apexd.status activated
  perform_apex_config

Note that some tasks in perform_apex_config are not needed in the
bootstrap.  For example, we don't need to create apexdata directories
for bootstrap apexes.

Bug: 290148081
Test: VendorApexHostTestCases
Change-Id: I8f683a4dcd7cd9a2466a4b1b417d84c025c37761
---
 init/README.md    |  3 ++-
 init/builtins.cpp | 25 +++++++++++++++++++------
 rootdir/init.rc   |  4 +---
 3 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/init/README.md b/init/README.md
index 5fced19b076f..11c4e1cf3770 100644
--- a/init/README.md
+++ b/init/README.md
@@ -674,11 +674,12 @@ provides the `aidl_lazy_test_1` interface.
   _options_ include "barrier=1", "noauto\_da\_alloc", "discard", ... as
   a comma separated string, e.g. barrier=1,noauto\_da\_alloc
 
-`perform_apex_config`
+`perform_apex_config [--bootstrap]`
 > Performs tasks after APEXes are mounted. For example, creates data directories
   for the mounted APEXes, parses config file(s) from them, and updates linker
   configurations. Intended to be used only once when apexd notifies the mount
   event by setting `apexd.status` to ready.
+  Use --bootstrap when invoking in the bootstrap mount namespace.
 
 `restart [--only-if-running] <service>`
 > Stops and restarts a running service, does nothing if the service is currently
diff --git a/init/builtins.cpp b/init/builtins.cpp
index fa5e36d52220..e40b831d1427 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -1292,10 +1292,21 @@ static Result<void> create_apex_data_dirs() {
 }
 
 static Result<void> do_perform_apex_config(const BuiltinArguments& args) {
-    auto create_dirs = create_apex_data_dirs();
-    if (!create_dirs.ok()) {
-        return create_dirs.error();
+    bool bootstrap = false;
+    if (args.size() == 2) {
+        if (args[1] != "--bootstrap") {
+            return Error() << "Unexpected argument: " << args[1];
+        }
+        bootstrap = true;
     }
+
+    if (!bootstrap) {
+        auto create_dirs = create_apex_data_dirs();
+        if (!create_dirs.ok()) {
+            return create_dirs.error();
+        }
+    }
+
     auto parse_configs = ParseApexConfigs(/*apex_name=*/"");
     if (!parse_configs.ok()) {
         return parse_configs.error();
@@ -1306,8 +1317,10 @@ static Result<void> do_perform_apex_config(const BuiltinArguments& args) {
         return update_linker_config.error();
     }
 
-    // Now start delayed services
-    ServiceList::GetInstance().MarkServicesUpdate();
+    if (!bootstrap) {
+        // Now start delayed services
+        ServiceList::GetInstance().MarkServicesUpdate();
+    }
     return {};
 }
 
@@ -1362,7 +1375,7 @@ const BuiltinFunctionMap& GetBuiltinFunctionMap() {
         // mount and umount are run in the same context as mount_all for symmetry.
         {"mount_all",               {0,     kMax, {false,  do_mount_all}}},
         {"mount",                   {3,     kMax, {false,  do_mount}}},
-        {"perform_apex_config",     {0,     0,    {false,  do_perform_apex_config}}},
+        {"perform_apex_config",     {0,     1,    {false,  do_perform_apex_config}}},
         {"umount",                  {1,     1,    {false,  do_umount}}},
         {"umount_all",              {0,     1,    {false,  do_umount_all}}},
         {"update_linker_config",    {0,     0,    {false,  do_update_linker_config}}},
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 8f01d932b851..0d31cdce788b 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -74,9 +74,7 @@ on early-init
     # become available. Note that this is executed as exec_start to ensure that
     # the libraries are available to the processes started after this statement.
     exec_start apexd-bootstrap
-
-    # Generate linker config based on apex mounted in bootstrap namespace
-    update_linker_config
+    perform_apex_config --bootstrap
 
     # These must already exist by the time boringssl_self_test32 / boringssl_self_test64 run.
     mkdir /dev/boringssl 0755 root root

From 6fe9367f7bb636d63a856d29944b4f229c3d01e2 Mon Sep 17 00:00:00 2001
From: Po-yao Chang <Po-yao.Chang@mediatek.com>
Date: Thu, 10 Aug 2023 17:03:34 +0800
Subject: [PATCH 0307/1487] Run boringssl tests according to ro.zygote

If ro.zygote is zygote64, don't bother running 32-bit test.
Otherwise abilist{32,64} decides what tests to run.

Bug: 291874369
Test: make gsi_arm64-user; Check /system/etc/init/hw
Change-Id: Id10b2242606d6400acc29c3174f713581d6cce2e
---
 rootdir/Android.bp                    | 18 ++++++++++++++++++
 rootdir/init.boringssl.zygote64.rc    |  4 ++++
 rootdir/init.boringssl.zygote64_32.rc |  8 ++++++++
 rootdir/init.rc                       |  9 +--------
 4 files changed, 31 insertions(+), 8 deletions(-)
 create mode 100644 rootdir/init.boringssl.zygote64.rc
 create mode 100644 rootdir/init.boringssl.zygote64_32.rc

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index e98733ada721..c8a3cd61cf28 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -16,6 +16,22 @@ package {
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
+prebuilt_etc {
+    name: "init.boringssl.zygote64_32.rc",
+    src: "init.boringssl.zygote64_32.rc",
+    sub_dir: "init/hw",
+    symlinks: [
+        "init.boringssl.zygote32.rc",
+        "init.boringssl.no_zygote.rc",
+    ],
+}
+
+prebuilt_etc {
+    name: "init.boringssl.zygote64.rc",
+    src: "init.boringssl.zygote64.rc",
+    sub_dir: "init/hw",
+}
+
 prebuilt_etc {
     name: "init.rc",
     src: "init.rc",
@@ -23,6 +39,8 @@ prebuilt_etc {
     required: [
         "fsverity_init",
         "platform-bootclasspath",
+        "init.boringssl.zygote64.rc",
+        "init.boringssl.zygote64_32.rc",
     ],
 }
 
diff --git a/rootdir/init.boringssl.zygote64.rc b/rootdir/init.boringssl.zygote64.rc
new file mode 100644
index 000000000000..3f49fea8b01c
--- /dev/null
+++ b/rootdir/init.boringssl.zygote64.rc
@@ -0,0 +1,4 @@
+on init && property:ro.product.cpu.abilist64=*
+    exec_start boringssl_self_test64
+on property:apexd.status=ready && property:ro.product.cpu.abilist64=*
+    exec_start boringssl_self_test_apex64
diff --git a/rootdir/init.boringssl.zygote64_32.rc b/rootdir/init.boringssl.zygote64_32.rc
new file mode 100644
index 000000000000..c0be42dbb098
--- /dev/null
+++ b/rootdir/init.boringssl.zygote64_32.rc
@@ -0,0 +1,8 @@
+on init && property:ro.product.cpu.abilist32=*
+    exec_start boringssl_self_test32
+on init && property:ro.product.cpu.abilist64=*
+    exec_start boringssl_self_test64
+on property:apexd.status=ready && property:ro.product.cpu.abilist32=*
+    exec_start boringssl_self_test_apex32
+on property:apexd.status=ready && property:ro.product.cpu.abilist64=*
+    exec_start boringssl_self_test_apex64
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 8f01d932b851..56bcedfbe530 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -461,14 +461,7 @@ on init
     start vndservicemanager
 
 # Run boringssl self test for each ABI.  Any failures trigger reboot to firmware.
-on init && property:ro.product.cpu.abilist32=*
-    exec_start boringssl_self_test32
-on init && property:ro.product.cpu.abilist64=*
-    exec_start boringssl_self_test64
-on property:apexd.status=ready && property:ro.product.cpu.abilist32=*
-    exec_start boringssl_self_test_apex32
-on property:apexd.status=ready && property:ro.product.cpu.abilist64=*
-    exec_start boringssl_self_test_apex64
+import /system/etc/init/hw/init.boringssl.${ro.zygote}.rc
 
 service boringssl_self_test32 /system/bin/boringssl_self_test32
     reboot_on_failure reboot,boringssl-self-check-failed

From d3550e33148c48c4accdccb7f822701e5bea025d Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Thu, 10 Aug 2023 06:28:58 +0000
Subject: [PATCH 0308/1487] Remove cutils threads.h header completely.

Bug: 289414897
Test: it builds
Change-Id: Ifcde5849923f19f1c898a6a95811eea55be0d276
---
 libcutils/include/cutils/threads.h                | 15 ---------------
 libcutils/include_outside_system/cutils/threads.h |  1 -
 2 files changed, 16 deletions(-)
 delete mode 100644 libcutils/include/cutils/threads.h
 delete mode 120000 libcutils/include_outside_system/cutils/threads.h

diff --git a/libcutils/include/cutils/threads.h b/libcutils/include/cutils/threads.h
deleted file mode 100644
index 9bc3429bec29..000000000000
--- a/libcutils/include/cutils/threads.h
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
- * Copyright (C) 2007 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.
- */
diff --git a/libcutils/include_outside_system/cutils/threads.h b/libcutils/include_outside_system/cutils/threads.h
deleted file mode 120000
index 99330ffadfe3..000000000000
--- a/libcutils/include_outside_system/cutils/threads.h
+++ /dev/null
@@ -1 +0,0 @@
-../../include/cutils/threads.h
\ No newline at end of file

From 3983f9aa6ec3961a7581f95f817f189a8ca5c492 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 9 Aug 2023 23:08:21 -0700
Subject: [PATCH 0309/1487] libsnapshot: Check for valid snapshots based on
 current slot

We may have snapshot files in /metadata/ota/snapshot/ which ends with
.tmp such as system_a.tmp - This happens if the device
reboots just before `rename` in `WriteStringToFileAtomic`. This
can lead to spurious merge failures.

Log the error and skip these snapshot files. It is ok to skip
as we will still have original snapshot status files since
we are already in the merge path. Additionally, try to remove
these files when snapshot is deleted.

Bug: 292198189
Test: OTA
Change-Id: I5db3dbd5a919b263ae577185de3e7f79a5e9b89a
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshot.cpp      | 18 +++++++++++++-----
 fs_mgr/libsnapshot/snapshot_test.cpp | 23 ++++++++++++++++++++++-
 2 files changed, 35 insertions(+), 6 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 86ff5f710da7..51389a0dbf27 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -729,6 +729,14 @@ bool SnapshotManager::DeleteSnapshot(LockedFile* lock, const std::string& name)
         LOG(ERROR) << "Failed to remove status file " << file_path << ": " << error;
         return false;
     }
+
+    // This path may never exist. If it is present, then it's a stale
+    // snapshot status file. Just remove the file and log the message.
+    const std::string tmp_path = file_path + ".tmp";
+    if (!android::base::RemoveFileIfExists(tmp_path, &error)) {
+        LOG(ERROR) << "Failed to remove stale snapshot file " << tmp_path;
+    }
+
     return true;
 }
 
@@ -754,10 +762,10 @@ bool SnapshotManager::InitiateMerge() {
         return false;
     }
 
-    auto other_suffix = device_->GetOtherSlotSuffix();
+    auto current_slot_suffix = device_->GetSlotSuffix();
 
     for (const auto& snapshot : snapshots) {
-        if (android::base::EndsWith(snapshot, other_suffix)) {
+        if (!android::base::EndsWith(snapshot, current_slot_suffix)) {
             // Allow the merge to continue, but log this unexpected case.
             LOG(ERROR) << "Unexpected snapshot found during merge: " << snapshot;
             continue;
@@ -1123,7 +1131,7 @@ auto SnapshotManager::CheckMergeState(LockedFile* lock, const std::function<bool
         return MergeResult(UpdateState::MergeFailed, MergeFailureCode::ListSnapshots);
     }
 
-    auto other_suffix = device_->GetOtherSlotSuffix();
+    auto current_slot_suffix = device_->GetSlotSuffix();
 
     bool cancelled = false;
     bool merging = false;
@@ -1131,9 +1139,9 @@ auto SnapshotManager::CheckMergeState(LockedFile* lock, const std::function<bool
     bool wrong_phase = false;
     MergeFailureCode failure_code = MergeFailureCode::Ok;
     for (const auto& snapshot : snapshots) {
-        if (android::base::EndsWith(snapshot, other_suffix)) {
+        if (!android::base::EndsWith(snapshot, current_slot_suffix)) {
             // This will have triggered an error message in InitiateMerge already.
-            LOG(INFO) << "Skipping merge validation of unexpected snapshot: " << snapshot;
+            LOG(ERROR) << "Skipping merge validation of unexpected snapshot: " << snapshot;
             continue;
         }
 
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 0a85489bd7eb..3b6d26aa11ff 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -685,6 +685,17 @@ TEST_F(SnapshotTest, Merge) {
     }
     ASSERT_TRUE(sm->InitiateMerge());
 
+    // Create stale files in snapshot directory. Merge should skip these files
+    // as the suffix doesn't match the current slot.
+    auto tmp_path = test_device->GetMetadataDir() + "/snapshots/test_partition_b.tmp";
+    auto other_slot = test_device->GetMetadataDir() + "/snapshots/test_partition_a";
+
+    unique_fd fd(open(tmp_path.c_str(), O_RDWR | O_CLOEXEC | O_CREAT, 0644));
+    ASSERT_GE(fd, 0);
+
+    fd.reset(open(other_slot.c_str(), O_RDWR | O_CLOEXEC | O_CREAT, 0644));
+    ASSERT_GE(fd, 0);
+
     // The device should have been switched to a snapshot-merge target.
     DeviceMapper::TargetInfo target;
     ASSERT_TRUE(sm->IsSnapshotDevice("test_partition_b", &target));
@@ -700,13 +711,23 @@ TEST_F(SnapshotTest, Merge) {
     ASSERT_EQ(sm->ProcessUpdateState(), UpdateState::MergeCompleted);
     ASSERT_EQ(sm->GetUpdateState(), UpdateState::None);
 
+    // Make sure that snapshot states are cleared and all stale files
+    // are deleted
+    {
+        ASSERT_TRUE(AcquireLock());
+        auto local_lock = std::move(lock_);
+        std::vector<std::string> snapshots;
+        ASSERT_TRUE(sm->ListSnapshots(local_lock.get(), &snapshots));
+        ASSERT_TRUE(snapshots.empty());
+    }
+
     // The device should no longer be a snapshot or snapshot-merge.
     ASSERT_FALSE(sm->IsSnapshotDevice("test_partition_b"));
 
     // Test that we can read back the string we wrote to the snapshot. Note
     // that the base device is gone now. |snap_device| contains the correct
     // partition.
-    unique_fd fd(open("/dev/block/mapper/test_partition_b", O_RDONLY | O_CLOEXEC));
+    fd.reset(open("/dev/block/mapper/test_partition_b", O_RDONLY | O_CLOEXEC));
     ASSERT_GE(fd, 0);
 
     std::string buffer(test_string.size(), '\0');

From 55ef3d6104032dcaa773e486405cb9f8978fd5ce Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Thu, 10 Aug 2023 18:27:22 +0900
Subject: [PATCH 0310/1487] Skip bootstrap APEX RC files for the second round

Reading .rc files from bootstrap APEXes causes "double loading".
This works for services because init just ignores duplicates. But it
emits error logs, which can mislead even though there's no actual
errors. Besides, for actions, duplicates can cause a problem when
commands are not idempotent.

So, when loading RC files from APEXes for the second time, we'd better
skip those bootstrap APEXes.

Bug: 290148081
Test: VendorApexHostTestCases
Change-Id: Ia630dbd14046064b5e5c612c01ebacf57091c8d4
---
 init/apex_init_util.cpp | 91 ++++++++++++++++++++++++++++++++---------
 init/apex_init_util.h   |  8 ++--
 init/builtins.cpp       |  6 +--
 init/init.cpp           |  2 +-
 4 files changed, 81 insertions(+), 26 deletions(-)

diff --git a/init/apex_init_util.cpp b/init/apex_init_util.cpp
index c818f8fe9e3a..d88da390eff6 100644
--- a/init/apex_init_util.cpp
+++ b/init/apex_init_util.cpp
@@ -16,13 +16,15 @@
 
 #include "apex_init_util.h"
 
+#include <dirent.h>
 #include <glob.h>
 
+#include <set>
 #include <vector>
 
 #include <android-base/logging.h>
-#include <android-base/result.h>
 #include <android-base/properties.h>
+#include <android-base/result.h>
 #include <android-base/strings.h>
 
 #include "action_manager.h"
@@ -34,10 +36,13 @@
 namespace android {
 namespace init {
 
-static Result<std::vector<std::string>> CollectApexConfigs(const std::string& apex_name) {
+static Result<std::vector<std::string>> CollectRcScriptsFromApex(
+        const std::string& apex_name, const std::set<std::string>& skip_apexes) {
     glob_t glob_result;
-    std::string glob_pattern = apex_name.empty() ?
-            "/apex/*/etc/*rc" : "/apex/" + apex_name + "/etc/*rc";
+    // Pattern uses "*rc" instead of ".rc" because APEXes can have versioned RC files
+    // like foo.34rc.
+    std::string glob_pattern =
+            apex_name.empty() ? "/apex/*/etc/*rc" : "/apex/" + apex_name + "/etc/*rc";
 
     const int ret = glob(glob_pattern.c_str(), GLOB_MARK, nullptr, &glob_result);
     if (ret != 0 && ret != GLOB_NOMATCH) {
@@ -47,15 +52,28 @@ static Result<std::vector<std::string>> CollectApexConfigs(const std::string& ap
     std::vector<std::string> configs;
     for (size_t i = 0; i < glob_result.gl_pathc; i++) {
         std::string path = glob_result.gl_pathv[i];
-        // Filter-out /apex/<name>@<ver> paths. The paths are bind-mounted to
+
+        // Filter out directories
+        if (path.back() == '/') {
+            continue;
+        }
+
+        // Get apex name from path.
+        std::vector<std::string> paths = android::base::Split(path, "/");
+        if (paths.size() < 3) {
+            continue;
+        }
+        const std::string& apex_name = paths[2];
+
+        // Filter out /apex/<name>@<ver> paths. The paths are bind-mounted to
         // /apex/<name> paths, so unless we filter them out, we will parse the
         // same file twice.
-        std::vector<std::string> paths = android::base::Split(path, "/");
-        if (paths.size() >= 3 && paths[2].find('@') != std::string::npos) {
+        if (apex_name.find('@') != std::string::npos) {
             continue;
         }
-        // Filter directories
-        if (path.back() == '/') {
+
+        // Filter out skip_set apexes
+        if (skip_apexes.count(apex_name) > 0) {
             continue;
         }
         configs.push_back(path);
@@ -64,11 +82,41 @@ static Result<std::vector<std::string>> CollectApexConfigs(const std::string& ap
     return configs;
 }
 
-static Result<void> ParseConfigs(const std::vector<std::string>& configs) {
+static std::set<std::string> GetApexListFrom(const std::string& apex_dir) {
+    std::set<std::string> apex_list;
+    auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir(apex_dir.c_str()), closedir);
+    if (!dirp) {
+        return apex_list;
+    }
+    struct dirent* entry;
+    while ((entry = readdir(dirp.get())) != nullptr) {
+        if (entry->d_type != DT_DIR) continue;
+
+        const char* name = entry->d_name;
+        if (name[0] == '.') continue;
+        if (strchr(name, '@') != nullptr) continue;
+        if (strcmp(name, "sharedlibs") == 0) continue;
+        apex_list.insert(name);
+    }
+    return apex_list;
+}
+
+static Result<void> ParseRcScripts(const std::vector<std::string>& files) {
+    if (files.empty()) {
+        return {};
+    }
+    // APEXes can have versioned RC files. These should be filtered based on
+    // SDK version.
+    auto filtered = FilterVersionedConfigs(
+            files, android::base::GetIntProperty("ro.build.version.sdk", INT_MAX));
+    if (filtered.empty()) {
+        return {};
+    }
+
     Parser parser =
             CreateApexConfigParser(ActionManager::GetInstance(), ServiceList::GetInstance());
     std::vector<std::string> errors;
-    for (const auto& c : configs) {
+    for (const auto& c : filtered) {
         auto result = parser.ParseConfigFile(c);
         // We should handle other config files even when there's an error.
         if (!result.ok()) {
@@ -81,16 +129,21 @@ static Result<void> ParseConfigs(const std::vector<std::string>& configs) {
     return {};
 }
 
-Result<void> ParseApexConfigs(const std::string& apex_name) {
-    auto configs = OR_RETURN(CollectApexConfigs(apex_name));
+Result<void> ParseRcScriptsFromApex(const std::string& apex_name) {
+    auto configs = OR_RETURN(CollectRcScriptsFromApex(apex_name, /*skip_apexes=*/{}));
+    return ParseRcScripts(configs);
+}
 
-    if (configs.empty()) {
-        return {};
+Result<void> ParseRcScriptsFromAllApexes(bool bootstrap) {
+    std::set<std::string> skip_apexes;
+    if (!bootstrap) {
+        // In case we already loaded config files from bootstrap APEXes, we need to avoid loading
+        // them again. We can get the list of bootstrap APEXes by scanning /bootstrap-apex and
+        // skip them in CollectRcScriptsFromApex.
+        skip_apexes = GetApexListFrom("/bootstrap-apex");
     }
-
-    auto filtered_configs = FilterVersionedConfigs(configs,
-                                    android::base::GetIntProperty("ro.build.version.sdk", INT_MAX));
-    return ParseConfigs(filtered_configs);
+    auto configs = OR_RETURN(CollectRcScriptsFromApex(/*apex_name=*/"", skip_apexes));
+    return ParseRcScripts(configs);
 }
 
 }  // namespace init
diff --git a/init/apex_init_util.h b/init/apex_init_util.h
index 43f8ad5eb64d..e55b3c0c9976 100644
--- a/init/apex_init_util.h
+++ b/init/apex_init_util.h
@@ -24,9 +24,11 @@
 namespace android {
 namespace init {
 
-// Parse all config files for a given apex.
-// If apex name is empty(""), config files for all apexes will be parsed.
-Result<void> ParseApexConfigs(const std::string& apex_name);
+// Parse all RC scripts for a given apex.
+Result<void> ParseRcScriptsFromApex(const std::string& apex_name);
+
+// Parse all RC scripts for all apexes under /apex.
+Result<void> ParseRcScriptsFromAllApexes(bool bootstrap);
 
 }  // namespace init
 }  // namespace android
diff --git a/init/builtins.cpp b/init/builtins.cpp
index e40b831d1427..2ced66d113f2 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -1307,9 +1307,9 @@ static Result<void> do_perform_apex_config(const BuiltinArguments& args) {
         }
     }
 
-    auto parse_configs = ParseApexConfigs(/*apex_name=*/"");
-    if (!parse_configs.ok()) {
-        return parse_configs.error();
+    auto parse_result = ParseRcScriptsFromAllApexes(bootstrap);
+    if (!parse_result.ok()) {
+        return parse_result.error();
     }
 
     auto update_linker_config = do_update_linker_config(args);
diff --git a/init/init.cpp b/init/init.cpp
index 4bb8eecb981a..40e21696fbdf 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -487,7 +487,7 @@ static Result<void> UpdateApexLinkerConfig(const std::string& apex_name) {
 }
 
 static Result<void> DoLoadApex(const std::string& apex_name) {
-    if (auto result = ParseApexConfigs(apex_name); !result.ok()) {
+    if (auto result = ParseRcScriptsFromApex(apex_name); !result.ok()) {
         return result.error();
     }
 

From d8a270698d3f12c659b9f8e3ec7fec631bf2058a Mon Sep 17 00:00:00 2001
From: Wei Li <weiwli@google.com>
Date: Thu, 10 Aug 2023 18:18:36 -0700
Subject: [PATCH 0311/1487] Track root directory symlinks created by
 LOCAL_POST_INSTALL_CMD in ALL_ROOTDIR_SYMLINKS and add them to
 ALL_DEFAULT_INSTALLED_MODULES, so they can be included in product SBOMs
 properly.

Bug: 272358980
Test: CIs and build/soong/tests/sbom_test.sh
Change-Id: I73dfb34156d681786c013912e59a0d0c0c48ecc7
---
 rootdir/Android.mk | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 3362872c070d..ebed44ea15a2 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -98,20 +98,31 @@ LOCAL_POST_INSTALL_CMD := mkdir -p $(addprefix $(TARGET_ROOT_OUT)/, \
     ln -sf /data/user_de/0/com.android.shell/files/bugreports $(TARGET_ROOT_OUT)/bugreports; \
     ln -sfn /sys/kernel/debug $(TARGET_ROOT_OUT)/d; \
     ln -sf /storage/self/primary $(TARGET_ROOT_OUT)/sdcard
+
+ALL_ROOTDIR_SYMLINKS := \
+  $(TARGET_ROOT_OUT)/bin \
+  $(TARGET_ROOT_OUT)/etc \
+  $(TARGET_ROOT_OUT)/bugreports \
+  $(TARGET_ROOT_OUT)/d \
+  $(TARGET_ROOT_OUT)/sdcard
+
 ifdef BOARD_USES_VENDORIMAGE
   LOCAL_POST_INSTALL_CMD += ; mkdir -p $(TARGET_ROOT_OUT)/vendor
 else
   LOCAL_POST_INSTALL_CMD += ; ln -sf /system/vendor $(TARGET_ROOT_OUT)/vendor
+  ALL_ROOTDIR_SYMLINKS += $(TARGET_ROOT_OUT)/vendor
 endif
 ifdef BOARD_USES_PRODUCTIMAGE
   LOCAL_POST_INSTALL_CMD += ; mkdir -p $(TARGET_ROOT_OUT)/product
 else
   LOCAL_POST_INSTALL_CMD += ; ln -sf /system/product $(TARGET_ROOT_OUT)/product
+  ALL_ROOTDIR_SYMLINKS += $(TARGET_ROOT_OUT)/product
 endif
 ifdef BOARD_USES_SYSTEM_EXTIMAGE
   LOCAL_POST_INSTALL_CMD += ; mkdir -p $(TARGET_ROOT_OUT)/system_ext
 else
   LOCAL_POST_INSTALL_CMD += ; ln -sf /system/system_ext $(TARGET_ROOT_OUT)/system_ext
+  ALL_ROOTDIR_SYMLINKS += $(TARGET_ROOT_OUT)/system_ext
 endif
 ifdef BOARD_USES_METADATA_PARTITION
   LOCAL_POST_INSTALL_CMD += ; mkdir -p $(TARGET_ROOT_OUT)/metadata
@@ -134,6 +145,18 @@ LOCAL_POST_INSTALL_CMD += ; ln -sf /vendor/odm/overlay $(TARGET_ROOT_OUT)/odm/ov
 LOCAL_POST_INSTALL_CMD += ; ln -sf /vendor/odm/priv-app $(TARGET_ROOT_OUT)/odm/priv-app
 LOCAL_POST_INSTALL_CMD += ; ln -sf /vendor/odm/usr $(TARGET_ROOT_OUT)/odm/usr
 
+ALL_ROOTDIR_SYMLINKS += \
+  $(TARGET_ROOT_OUT)/odm/app \
+  $(TARGET_ROOT_OUT)/odm/bin \
+  $(TARGET_ROOT_OUT)/odm/etc \
+  $(TARGET_ROOT_OUT)/odm/firmware \
+  $(TARGET_ROOT_OUT)/odm/framework \
+  $(TARGET_ROOT_OUT)/odm/lib \
+  $(TARGET_ROOT_OUT)/odm/lib64 \
+  $(TARGET_ROOT_OUT)/odm/overlay \
+  $(TARGET_ROOT_OUT)/odm/priv-app \
+  $(TARGET_ROOT_OUT)/odm/usr
+
 
 # For /vendor_dlkm partition.
 LOCAL_POST_INSTALL_CMD += ; mkdir -p $(TARGET_ROOT_OUT)/vendor_dlkm
@@ -144,6 +167,7 @@ LOCAL_POST_INSTALL_CMD += ; mkdir -p $(TARGET_ROOT_OUT)/vendor_dlkm
 # Note that /vendor_dlkm/lib is omitted because vendor DLKMs should be accessed
 # via /vendor/lib/modules directly.
 LOCAL_POST_INSTALL_CMD += ; ln -sf /vendor/vendor_dlkm/etc $(TARGET_ROOT_OUT)/vendor_dlkm/etc
+ALL_ROOTDIR_SYMLINKS += $(TARGET_ROOT_OUT)/vendor_dlkm/etc
 
 # For /odm_dlkm partition.
 LOCAL_POST_INSTALL_CMD += ; mkdir -p $(TARGET_ROOT_OUT)/odm_dlkm
@@ -154,6 +178,7 @@ LOCAL_POST_INSTALL_CMD += ; mkdir -p $(TARGET_ROOT_OUT)/odm_dlkm
 # Note that /odm_dlkm/lib is omitted because odm DLKMs should be accessed
 # via /odm/lib/modules directly.
 LOCAL_POST_INSTALL_CMD += ; ln -sf /odm/odm_dlkm/etc $(TARGET_ROOT_OUT)/odm_dlkm/etc
+ALL_ROOTDIR_SYMLINKS += $(TARGET_ROOT_OUT)/odm_dlkm/etc
 
 # For /system_dlkm partition
 LOCAL_POST_INSTALL_CMD += ; mkdir -p $(TARGET_ROOT_OUT)/system_dlkm
@@ -162,6 +187,7 @@ ifdef BOARD_CACHEIMAGE_FILE_SYSTEM_TYPE
   LOCAL_POST_INSTALL_CMD += ; mkdir -p $(TARGET_ROOT_OUT)/cache
 else
   LOCAL_POST_INSTALL_CMD += ; ln -sf /data/cache $(TARGET_ROOT_OUT)/cache
+  ALL_ROOTDIR_SYMLINKS += $(TARGET_ROOT_OUT)/cache
 endif
 ifdef BOARD_ROOT_EXTRA_SYMLINKS
 # BOARD_ROOT_EXTRA_SYMLINKS is a list of <target>:<link_name>.
@@ -169,14 +195,19 @@ ifdef BOARD_ROOT_EXTRA_SYMLINKS
     $(eval p := $(subst :,$(space),$(s)))\
     ; mkdir -p $(dir $(TARGET_ROOT_OUT)/$(word 2,$(p))) \
     ; ln -sf $(word 1,$(p)) $(TARGET_ROOT_OUT)/$(word 2,$(p)))
+  ALL_ROOTDIR_SYMLINKS += $(foreach s,$(BOARD_ROOT_EXTRA_SYMLINKS),$(TARGET_ROOT_OUT)/$(call word-colon,2,$s))
 endif
 
 # The init symlink must be a post install command of a file that is to TARGET_ROOT_OUT.
 # Since init.environ.rc is required for init and satisfies that requirement, we hijack it to create the symlink.
 LOCAL_POST_INSTALL_CMD += ; ln -sf /system/bin/init $(TARGET_ROOT_OUT)/init
+ALL_ROOTDIR_SYMLINKS += $(TARGET_ROOT_OUT)/init
+
+ALL_DEFAULT_INSTALLED_MODULES += $(ALL_ROOTDIR_SYMLINKS)
 
 include $(BUILD_SYSTEM)/base_rules.mk
 
+$(ALL_ROOTDIR_SYMLINKS): $(LOCAL_BUILT_MODULE)
 $(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/init.environ.rc.in
 	@echo "Generate: $< -> $@"
 	@mkdir -p $(dir $@)

From 2982f09d57fdf1ad3fb7aa10c4aa62243b50fd0d Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Fri, 11 Aug 2023 14:14:37 +0900
Subject: [PATCH 0312/1487] Dedup apex-scanning

create_apex_data_dirs() now uses GetApexListFrom(dir) in
apex_init_util.cpp.

This is essentially a refactoring, but there are a few behavioral
changes, which I think make more sense.
- Emits no error when opendir(/apex) fails.
- Emits errors when mkdir fails for each apex.
- Does not abort `perform_apex_config` even though create_apex_data_dirs
  fails.

Bug: 293546778
Test: check /data/misc/apexdata/ after boot
Change-Id: I9d1a9710a6a626eec087c8c0fb1768667ffb036e
---
 init/apex_init_util.cpp |  2 +-
 init/apex_init_util.h   |  4 ++++
 init/builtins.cpp       | 30 ++++++++----------------------
 3 files changed, 13 insertions(+), 23 deletions(-)

diff --git a/init/apex_init_util.cpp b/init/apex_init_util.cpp
index d88da390eff6..6d17f36e2201 100644
--- a/init/apex_init_util.cpp
+++ b/init/apex_init_util.cpp
@@ -82,7 +82,7 @@ static Result<std::vector<std::string>> CollectRcScriptsFromApex(
     return configs;
 }
 
-static std::set<std::string> GetApexListFrom(const std::string& apex_dir) {
+std::set<std::string> GetApexListFrom(const std::string& apex_dir) {
     std::set<std::string> apex_list;
     auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir(apex_dir.c_str()), closedir);
     if (!dirp) {
diff --git a/init/apex_init_util.h b/init/apex_init_util.h
index e55b3c0c9976..75dfee1ae4a4 100644
--- a/init/apex_init_util.h
+++ b/init/apex_init_util.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <set>
 #include <string>
 #include <vector>
 
@@ -24,6 +25,9 @@
 namespace android {
 namespace init {
 
+// Scans apex_dir (/apex) to get the list of active APEXes.
+std::set<std::string> GetApexListFrom(const std::string& apex_dir);
+
 // Parse all RC scripts for a given apex.
 Result<void> ParseRcScriptsFromApex(const std::string& apex_name);
 
diff --git a/init/builtins.cpp b/init/builtins.cpp
index 2ced66d113f2..a5b762cbb834 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -1269,26 +1269,15 @@ static Result<void> do_update_linker_config(const BuiltinArguments&) {
 /*
  * Creates a directory under /data/misc/apexdata/ for each APEX.
  */
-static Result<void> create_apex_data_dirs() {
-    auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir("/apex"), closedir);
-    if (!dirp) {
-        return ErrnoError() << "Unable to open apex directory";
-    }
-    struct dirent* entry;
-    while ((entry = readdir(dirp.get())) != nullptr) {
-        if (entry->d_type != DT_DIR) continue;
-
-        const char* name = entry->d_name;
-        // skip any starting with "."
-        if (name[0] == '.') continue;
-
-        if (strchr(name, '@') != nullptr) continue;
-
-        auto path = "/data/misc/apexdata/" + std::string(name);
+static void create_apex_data_dirs() {
+    for (const auto& name : GetApexListFrom("/apex")) {
+        auto path = "/data/misc/apexdata/" + name;
         auto options = MkdirOptions{path, 0771, AID_ROOT, AID_SYSTEM, FscryptAction::kNone, "ref"};
-        make_dir_with_options(options);
+        auto result = make_dir_with_options(options);
+        if (!result.ok()) {
+            LOG(ERROR) << result.error();
+        }
     }
-    return {};
 }
 
 static Result<void> do_perform_apex_config(const BuiltinArguments& args) {
@@ -1301,10 +1290,7 @@ static Result<void> do_perform_apex_config(const BuiltinArguments& args) {
     }
 
     if (!bootstrap) {
-        auto create_dirs = create_apex_data_dirs();
-        if (!create_dirs.ok()) {
-            return create_dirs.error();
-        }
+        create_apex_data_dirs();
     }
 
     auto parse_result = ParseRcScriptsFromAllApexes(bootstrap);

From 90af4157c57de30ea0c3ab5ce2ab79c2ba36ef3b Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Fri, 11 Aug 2023 02:12:16 +0000
Subject: [PATCH 0313/1487] Add String16::c_str and start using it.

This is for parity with String8::c_str and in general the first step
in transition from String8|16.string() - to make it more similar to
std::string.

Bug: 295394788
Test: mma -j
Change-Id: I6c1411bef07c761fb2fb3fb38c27801ac4cffc57
---
 libutils/String16.cpp             | 13 +++++--------
 libutils/String8.cpp              |  7 ++-----
 libutils/include/utils/String16.h |  8 +++++++-
 libutils/include/utils/String8.h  |  6 +++---
 4 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/libutils/String16.cpp b/libutils/String16.cpp
index 68642d84f7ea..38d483e9495e 100644
--- a/libutils/String16.cpp
+++ b/libutils/String16.cpp
@@ -26,7 +26,7 @@ namespace android {
 
 static const StaticString16 emptyString(u"");
 static inline char16_t* getEmptyString() {
-    return const_cast<char16_t*>(emptyString.string());
+    return const_cast<char16_t*>(emptyString.c_str());
 }
 
 // ---------------------------------------------------------------------------
@@ -112,10 +112,7 @@ String16::String16(const char16_t* o) : mString(allocFromUTF16(o, strlen16(o)))
 
 String16::String16(const char16_t* o, size_t len) : mString(allocFromUTF16(o, len)) {}
 
-String16::String16(const String8& o)
-    : mString(allocFromUTF8(o.string(), o.size()))
-{
-}
+String16::String16(const String8& o) : mString(allocFromUTF8(o.c_str(), o.size())) {}
 
 String16::String16(const char* o)
     : mString(allocFromUTF8(o, strlen(o)))
@@ -173,7 +170,7 @@ status_t String16::setTo(const String16& other, size_t len, size_t begin)
         LOG_ALWAYS_FATAL("Not implemented");
     }
 
-    return setTo(other.string()+begin, len);
+    return setTo(other.c_str() + begin, len);
 }
 
 status_t String16::setTo(const char16_t* other)
@@ -200,7 +197,7 @@ status_t String16::setTo(const char16_t* other, size_t len)
 }
 
 status_t String16::append(const String16& other) {
-    return append(other.string(), other.size());
+    return append(other.c_str(), other.size());
 }
 
 status_t String16::append(const char16_t* chrs, size_t otherLen) {
@@ -286,7 +283,7 @@ bool String16::startsWith(const String16& prefix) const
 {
     const size_t ps = prefix.size();
     if (ps > size()) return false;
-    return strzcmp16(mString, ps, prefix.string(), ps) == 0;
+    return strzcmp16(mString, ps, prefix.c_str(), ps) == 0;
 }
 
 bool String16::startsWith(const char16_t* prefix) const
diff --git a/libutils/String8.cpp b/libutils/String8.cpp
index 8d312b57ce2b..79b7edfe9a12 100644
--- a/libutils/String8.cpp
+++ b/libutils/String8.cpp
@@ -150,10 +150,7 @@ String8::String8(const char* o, size_t len)
     }
 }
 
-String8::String8(const String16& o)
-    : mString(allocFromUTF16(o.string(), o.size()))
-{
-}
+String8::String8(const String16& o) : mString(allocFromUTF16(o.c_str(), o.size())) {}
 
 String8::String8(const char16_t* o)
     : mString(allocFromUTF16(o, strlen16(o)))
@@ -267,7 +264,7 @@ status_t String8::append(const String8& other)
         return OK;
     }
 
-    return real_append(other.string(), otherLen);
+    return real_append(other.c_str(), otherLen);
 }
 
 status_t String8::append(const char* other)
diff --git a/libutils/include/utils/String16.h b/libutils/include/utils/String16.h
index 3ef56a3cfa8f..d719aeaaa28e 100644
--- a/libutils/include/utils/String16.h
+++ b/libutils/include/utils/String16.h
@@ -53,6 +53,7 @@ class String16
 
                                 ~String16();
 
+    inline  const char16_t*     c_str() const;
     inline  const char16_t*     string() const;
 
 private:
@@ -234,6 +235,11 @@ inline int strictly_order_type(const String16& lhs, const String16& rhs)
     return compare_type(lhs, rhs) < 0;
 }
 
+inline const char16_t* String16::c_str() const
+{
+    return mString;
+}
+
 inline const char16_t* String16::string() const
 {
     return mString;
@@ -241,7 +247,7 @@ inline const char16_t* String16::string() const
 
 inline std::string String16::std_string(const String16& str)
 {
-    return std::string(String8(str).string());
+    return std::string(String8(str).c_str());
 }
 
 inline String16& String16::operator=(const String16& other)
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index 8b2dcf9a0a3a..e58f1a5d1992 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -193,14 +193,14 @@ class String8
      * replaces whatever was there before.
      */
     String8& appendPath(const char* leaf);
-    String8& appendPath(const String8& leaf)  { return appendPath(leaf.string()); }
+    String8& appendPath(const String8& leaf) { return appendPath(leaf.c_str()); }
 
     /*
      * Like appendPath(), but does not affect this string.  Returns a new one instead.
      */
     String8 appendPathCopy(const char* leaf) const
                                              { String8 p(*this); p.appendPath(leaf); return p; }
-    String8 appendPathCopy(const String8& leaf) const { return appendPathCopy(leaf.string()); }
+    String8 appendPathCopy(const String8& leaf) const { return appendPathCopy(leaf.c_str()); }
 
     /*
      * Converts all separators in this string to /, the default path separator.
@@ -255,7 +255,7 @@ inline const char* String8::string() const
 
 inline std::string String8::std_string(const String8& str)
 {
-    return std::string(str.string());
+    return std::string(str.c_str());
 }
 
 inline size_t String8::size() const

From 18b746188c73a83ad57b99558914ba9421e8a20a Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Thu, 10 Aug 2023 23:29:50 +0000
Subject: [PATCH 0314/1487] Migrate String8/16 from .string() to c_str()

This will align usage with std::string.

Bug: 295394788
Test: make checkbuild
Change-Id: Ic5c215b011197950dcbcb0339f44cc68fefc65a1
---
 fs_mgr/libfiemap/binder.cpp   | 26 +++++++++++++-------------
 healthd/BatteryMonitor.cpp    | 31 ++++++++++++-------------------
 healthd/BatteryMonitor_v1.cpp | 31 ++++++++++++-------------------
 libutils/ProcessCallStack.cpp |  5 ++---
 libutils/RefBase.cpp          |  2 +-
 libutils/String16_fuzz.cpp    |  6 +++---
 libutils/String8_test.cpp     | 20 ++++++++++----------
 libutils/Tokenizer.cpp        | 10 +++++-----
 8 files changed, 58 insertions(+), 73 deletions(-)

diff --git a/fs_mgr/libfiemap/binder.cpp b/fs_mgr/libfiemap/binder.cpp
index 41e534af4a8d..439aac9695aa 100644
--- a/fs_mgr/libfiemap/binder.cpp
+++ b/fs_mgr/libfiemap/binder.cpp
@@ -77,7 +77,7 @@ class ImageManagerBinder final : public IImageManager {
 
 static FiemapStatus ToFiemapStatus(const char* func, const binder::Status& status) {
     if (!status.isOk()) {
-        LOG(ERROR) << func << " binder returned: " << status.toString8().string();
+        LOG(ERROR) << func << " binder returned: " << status.toString8().c_str();
         if (status.serviceSpecificErrorCode() != 0) {
             return FiemapStatus::FromErrorCode(status.serviceSpecificErrorCode());
         } else {
@@ -106,7 +106,7 @@ bool ImageManagerBinder::DeleteBackingImage(const std::string& name) {
     auto status = manager_->deleteBackingImage(name);
     if (!status.isOk()) {
         LOG(ERROR) << __PRETTY_FUNCTION__
-                   << " binder returned: " << status.exceptionMessage().string();
+                   << " binder returned: " << status.exceptionMessage().c_str();
         return false;
     }
     return true;
@@ -122,7 +122,7 @@ bool ImageManagerBinder::MapImageDevice(const std::string& name,
     auto status = manager_->mapImageDevice(name, timeout_ms_count, &map);
     if (!status.isOk()) {
         LOG(ERROR) << __PRETTY_FUNCTION__
-                   << " binder returned: " << status.exceptionMessage().string();
+                   << " binder returned: " << status.exceptionMessage().c_str();
         return false;
     }
     *path = map.path;
@@ -133,7 +133,7 @@ bool ImageManagerBinder::UnmapImageDevice(const std::string& name) {
     auto status = manager_->unmapImageDevice(name);
     if (!status.isOk()) {
         LOG(ERROR) << __PRETTY_FUNCTION__
-                   << " binder returned: " << status.exceptionMessage().string();
+                   << " binder returned: " << status.exceptionMessage().c_str();
         return false;
     }
     return true;
@@ -144,7 +144,7 @@ bool ImageManagerBinder::BackingImageExists(const std::string& name) {
     auto status = manager_->backingImageExists(name, &retval);
     if (!status.isOk()) {
         LOG(ERROR) << __PRETTY_FUNCTION__
-                   << " binder returned: " << status.exceptionMessage().string();
+                   << " binder returned: " << status.exceptionMessage().c_str();
         return false;
     }
     return retval;
@@ -155,7 +155,7 @@ bool ImageManagerBinder::IsImageMapped(const std::string& name) {
     auto status = manager_->isImageMapped(name, &retval);
     if (!status.isOk()) {
         LOG(ERROR) << __PRETTY_FUNCTION__
-                   << " binder returned: " << status.exceptionMessage().string();
+                   << " binder returned: " << status.exceptionMessage().c_str();
         return false;
     }
     return retval;
@@ -175,7 +175,7 @@ std::vector<std::string> ImageManagerBinder::GetAllBackingImages() {
     auto status = manager_->getAllBackingImages(&retval);
     if (!status.isOk()) {
         LOG(ERROR) << __PRETTY_FUNCTION__
-                   << " binder returned: " << status.exceptionMessage().string();
+                   << " binder returned: " << status.exceptionMessage().c_str();
     }
     return retval;
 }
@@ -189,7 +189,7 @@ bool ImageManagerBinder::RemoveAllImages() {
     auto status = manager_->removeAllImages();
     if (!status.isOk()) {
         LOG(ERROR) << __PRETTY_FUNCTION__
-                   << " binder returned: " << status.exceptionMessage().string();
+                   << " binder returned: " << status.exceptionMessage().c_str();
         return false;
     }
     return true;
@@ -199,7 +199,7 @@ bool ImageManagerBinder::DisableImage(const std::string& name) {
     auto status = manager_->disableImage(name);
     if (!status.isOk()) {
         LOG(ERROR) << __PRETTY_FUNCTION__
-                   << " binder returned: " << status.exceptionMessage().string();
+                   << " binder returned: " << status.exceptionMessage().c_str();
         return false;
     }
     return true;
@@ -209,7 +209,7 @@ bool ImageManagerBinder::RemoveDisabledImages() {
     auto status = manager_->removeDisabledImages();
     if (!status.isOk()) {
         LOG(ERROR) << __PRETTY_FUNCTION__
-                   << " binder returned: " << status.exceptionMessage().string();
+                   << " binder returned: " << status.exceptionMessage().c_str();
         return false;
     }
     return true;
@@ -219,7 +219,7 @@ bool ImageManagerBinder::GetMappedImageDevice(const std::string& name, std::stri
     auto status = manager_->getMappedImageDevice(name, device);
     if (!status.isOk()) {
         LOG(ERROR) << __PRETTY_FUNCTION__
-                   << " binder returned: " << status.exceptionMessage().string();
+                   << " binder returned: " << status.exceptionMessage().c_str();
         return false;
     }
     return !device->empty();
@@ -230,7 +230,7 @@ bool ImageManagerBinder::IsImageDisabled(const std::string& name) {
     auto status = manager_->isImageDisabled(name, &retval);
     if (!status.isOk()) {
         LOG(ERROR) << __PRETTY_FUNCTION__
-                   << " binder returned: " << status.exceptionMessage().string();
+                   << " binder returned: " << status.exceptionMessage().c_str();
         return false;
     }
     return retval;
@@ -249,7 +249,7 @@ std::unique_ptr<IImageManager> IImageManager::Open(const std::string& dir,
 
     auto status = service->openImageService(dir, &manager);
     if (!status.isOk() || !manager) {
-        LOG(ERROR) << "Could not acquire IImageManager: " << status.exceptionMessage().string();
+        LOG(ERROR) << "Could not acquire IImageManager: " << status.exceptionMessage().c_str();
         return nullptr;
     }
     return std::make_unique<ImageManagerBinder>(std::move(service), std::move(manager));
diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index bd7955a7f8b4..15c30be412f8 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -444,12 +444,10 @@ void BatteryMonitor::updateValues(void) {
 
     for (size_t i = 0; i < mChargerNames.size(); i++) {
         String8 path;
-        path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH,
-                          mChargerNames[i].string());
+        path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, mChargerNames[i].c_str());
         if (getIntField(path)) {
             path.clear();
-            path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH,
-                              mChargerNames[i].string());
+            path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH, mChargerNames[i].c_str());
             switch(readPowerSupplyType(path)) {
             case ANDROID_POWER_SUPPLY_TYPE_AC:
                 mHealthInfo->chargerAcOnline = true;
@@ -466,26 +464,24 @@ void BatteryMonitor::updateValues(void) {
             default:
                 path.clear();
                 path.appendFormat("%s/%s/is_dock", POWER_SUPPLY_SYSFS_PATH,
-                                  mChargerNames[i].string());
-                if (access(path.string(), R_OK) == 0)
+                                  mChargerNames[i].c_str());
+                if (access(path.c_str(), R_OK) == 0)
                     mHealthInfo->chargerDockOnline = true;
                 else
                     KLOG_WARNING(LOG_TAG, "%s: Unknown power supply type\n",
-                                 mChargerNames[i].string());
+                                 mChargerNames[i].c_str());
             }
             path.clear();
             path.appendFormat("%s/%s/current_max", POWER_SUPPLY_SYSFS_PATH,
-                              mChargerNames[i].string());
-            int ChargingCurrent =
-                    (access(path.string(), R_OK) == 0) ? getIntField(path) : 0;
+                              mChargerNames[i].c_str());
+            int ChargingCurrent = (access(path.c_str(), R_OK) == 0) ? getIntField(path) : 0;
 
             path.clear();
             path.appendFormat("%s/%s/voltage_max", POWER_SUPPLY_SYSFS_PATH,
-                              mChargerNames[i].string());
+                              mChargerNames[i].c_str());
 
             int ChargingVoltage =
-                (access(path.string(), R_OK) == 0) ? getIntField(path) :
-                DEFAULT_VBUS_VOLTAGE;
+                    (access(path.c_str(), R_OK) == 0) ? getIntField(path) : DEFAULT_VBUS_VOLTAGE;
 
             double power = ((double)ChargingCurrent / MILLION) *
                            ((double)ChargingVoltage / MILLION);
@@ -775,8 +771,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
             case ANDROID_POWER_SUPPLY_TYPE_DOCK:
                 path.clear();
                 path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, name);
-                if (access(path.string(), R_OK) == 0)
-                    mChargerNames.add(String8(name));
+                if (access(path.c_str(), R_OK) == 0) mChargerNames.add(String8(name));
                 break;
 
             case ANDROID_POWER_SUPPLY_TYPE_BATTERY:
@@ -958,12 +953,10 @@ void BatteryMonitor::init(struct healthd_config *hc) {
             // Look for "is_dock" file
             path.clear();
             path.appendFormat("%s/%s/is_dock", POWER_SUPPLY_SYSFS_PATH, name);
-            if (access(path.string(), R_OK) == 0) {
+            if (access(path.c_str(), R_OK) == 0) {
                 path.clear();
                 path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, name);
-                if (access(path.string(), R_OK) == 0)
-                    mChargerNames.add(String8(name));
-
+                if (access(path.c_str(), R_OK) == 0) mChargerNames.add(String8(name));
             }
         }
     }
diff --git a/healthd/BatteryMonitor_v1.cpp b/healthd/BatteryMonitor_v1.cpp
index b87c493b2579..b2d6518f7a29 100644
--- a/healthd/BatteryMonitor_v1.cpp
+++ b/healthd/BatteryMonitor_v1.cpp
@@ -358,12 +358,10 @@ void BatteryMonitor::updateValues(void) {
 
     for (size_t i = 0; i < mChargerNames.size(); i++) {
         String8 path;
-        path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH,
-                          mChargerNames[i].string());
+        path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, mChargerNames[i].c_str());
         if (getIntField(path)) {
             path.clear();
-            path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH,
-                              mChargerNames[i].string());
+            path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH, mChargerNames[i].c_str());
             switch(readPowerSupplyType(path)) {
             case ANDROID_POWER_SUPPLY_TYPE_AC:
                 mHealthInfo->chargerAcOnline = true;
@@ -380,26 +378,24 @@ void BatteryMonitor::updateValues(void) {
             default:
                 path.clear();
                 path.appendFormat("%s/%s/is_dock", POWER_SUPPLY_SYSFS_PATH,
-                                  mChargerNames[i].string());
-                if (access(path.string(), R_OK) == 0)
+                                  mChargerNames[i].c_str());
+                if (access(path.c_str(), R_OK) == 0)
                     mHealthInfo->chargerDockOnline = true;
                 else
                     KLOG_WARNING(LOG_TAG, "%s: Unknown power supply type\n",
-                                 mChargerNames[i].string());
+                                 mChargerNames[i].c_str());
             }
             path.clear();
             path.appendFormat("%s/%s/current_max", POWER_SUPPLY_SYSFS_PATH,
-                              mChargerNames[i].string());
-            int ChargingCurrent =
-                    (access(path.string(), R_OK) == 0) ? getIntField(path) : 0;
+                              mChargerNames[i].c_str());
+            int ChargingCurrent = (access(path.c_str(), R_OK) == 0) ? getIntField(path) : 0;
 
             path.clear();
             path.appendFormat("%s/%s/voltage_max", POWER_SUPPLY_SYSFS_PATH,
-                              mChargerNames[i].string());
+                              mChargerNames[i].c_str());
 
             int ChargingVoltage =
-                (access(path.string(), R_OK) == 0) ? getIntField(path) :
-                DEFAULT_VBUS_VOLTAGE;
+                    (access(path.c_str(), R_OK) == 0) ? getIntField(path) : DEFAULT_VBUS_VOLTAGE;
 
             double power = ((double)ChargingCurrent / MILLION) *
                            ((double)ChargingVoltage / MILLION);
@@ -628,8 +624,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
             case ANDROID_POWER_SUPPLY_TYPE_DOCK:
                 path.clear();
                 path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, name);
-                if (access(path.string(), R_OK) == 0)
-                    mChargerNames.add(String8(name));
+                if (access(path.c_str(), R_OK) == 0) mChargerNames.add(String8(name));
                 break;
 
             case ANDROID_POWER_SUPPLY_TYPE_BATTERY:
@@ -767,12 +762,10 @@ void BatteryMonitor::init(struct healthd_config *hc) {
             // Look for "is_dock" file
             path.clear();
             path.appendFormat("%s/%s/is_dock", POWER_SUPPLY_SYSFS_PATH, name);
-            if (access(path.string(), R_OK) == 0) {
+            if (access(path.c_str(), R_OK) == 0) {
                 path.clear();
                 path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH, name);
-                if (access(path.string(), R_OK) == 0)
-                    mChargerNames.add(String8(name));
-
+                if (access(path.c_str(), R_OK) == 0) mChargerNames.add(String8(name));
             }
         }
     }
diff --git a/libutils/ProcessCallStack.cpp b/libutils/ProcessCallStack.cpp
index f054de98b393..4b27bdddd64a 100644
--- a/libutils/ProcessCallStack.cpp
+++ b/libutils/ProcessCallStack.cpp
@@ -205,8 +205,7 @@ void ProcessCallStack::print(Printer& printer) const {
 }
 
 void ProcessCallStack::printInternal(Printer& printer, Printer& csPrinter) const {
-    dumpProcessHeader(printer, getpid(),
-                      getTimeString(mTimeUpdated).string());
+    dumpProcessHeader(printer, getpid(), getTimeString(mTimeUpdated).c_str());
 
     for (size_t i = 0; i < mThreadMap.size(); ++i) {
         pid_t tid = mThreadMap.keyAt(i);
@@ -214,7 +213,7 @@ void ProcessCallStack::printInternal(Printer& printer, Printer& csPrinter) const
         const String8& threadName = threadInfo.threadName;
 
         printer.printLine("");
-        printer.printFormatLine("\"%s\" sysTid=%d", threadName.string(), tid);
+        printer.printFormatLine("\"%s\" sysTid=%d", threadName.c_str(), tid);
 
         threadInfo.callStack.print(csPrinter);
     }
diff --git a/libutils/RefBase.cpp b/libutils/RefBase.cpp
index ab122c73213e..e0a2846d4a7a 100644
--- a/libutils/RefBase.cpp
+++ b/libutils/RefBase.cpp
@@ -330,7 +330,7 @@ class RefBase::weakref_impl : public RefBase::weakref_type
                      this);
             int rc = open(name, O_RDWR | O_CREAT | O_APPEND, 0644);
             if (rc >= 0) {
-                (void)write(rc, text.string(), text.length());
+                (void)write(rc, text.c_str(), text.length());
                 close(rc);
                 ALOGI("STACK TRACE for %p saved in %s", this, name);
             }
diff --git a/libutils/String16_fuzz.cpp b/libutils/String16_fuzz.cpp
index d7e5ec783690..a271aeebd897 100644
--- a/libutils/String16_fuzz.cpp
+++ b/libutils/String16_fuzz.cpp
@@ -25,7 +25,7 @@ std::vector<std::function<void(FuzzedDataProvider&, android::String16, android::
 
                 // Bytes and size
                 ([](FuzzedDataProvider&, android::String16 str1, android::String16) -> void {
-                    str1.string();
+                    str1.c_str();
                 }),
                 ([](FuzzedDataProvider&, android::String16 str1, android::String16) -> void {
                     str1.isStaticString();
@@ -39,7 +39,7 @@ std::vector<std::function<void(FuzzedDataProvider&, android::String16, android::
                     str1.startsWith(str2);
                 }),
                 ([](FuzzedDataProvider&, android::String16 str1, android::String16 str2) -> void {
-                    str1.contains(str2.string());
+                    str1.contains(str2.c_str());
                 }),
                 ([](FuzzedDataProvider&, android::String16 str1, android::String16 str2) -> void {
                     str1.compare(str2);
@@ -52,7 +52,7 @@ std::vector<std::function<void(FuzzedDataProvider&, android::String16, android::
                 ([](FuzzedDataProvider& dataProvider, android::String16 str1,
                     android::String16 str2) -> void {
                     int pos = dataProvider.ConsumeIntegralInRange<int>(0, str1.size());
-                    str1.insert(pos, str2.string());
+                    str1.insert(pos, str2.c_str());
                 }),
 
                 // Find and replace operations
diff --git a/libutils/String8_test.cpp b/libutils/String8_test.cpp
index 35fd512f442d..9c12cb12df84 100644
--- a/libutils/String8_test.cpp
+++ b/libutils/String8_test.cpp
@@ -36,7 +36,7 @@ class String8Test : public testing::Test {
 TEST_F(String8Test, Cstr) {
     String8 tmp("Hello, world!");
 
-    EXPECT_STREQ(tmp.string(), "Hello, world!");
+    EXPECT_STREQ(tmp.c_str(), "Hello, world!");
 }
 
 TEST_F(String8Test, OperatorPlus) {
@@ -45,16 +45,16 @@ TEST_F(String8Test, OperatorPlus) {
     // Test adding String8 + const char*
     const char* ccsrc2 = "world!";
     String8 dst1 = src1 + ccsrc2;
-    EXPECT_STREQ(dst1.string(), "Hello, world!");
-    EXPECT_STREQ(src1.string(), "Hello, ");
+    EXPECT_STREQ(dst1.c_str(), "Hello, world!");
+    EXPECT_STREQ(src1.c_str(), "Hello, ");
     EXPECT_STREQ(ccsrc2, "world!");
 
     // Test adding String8 + String8
     String8 ssrc2("world!");
     String8 dst2 = src1 + ssrc2;
-    EXPECT_STREQ(dst2.string(), "Hello, world!");
-    EXPECT_STREQ(src1.string(), "Hello, ");
-    EXPECT_STREQ(ssrc2.string(), "world!");
+    EXPECT_STREQ(dst2.c_str(), "Hello, world!");
+    EXPECT_STREQ(src1.c_str(), "Hello, ");
+    EXPECT_STREQ(ssrc2.c_str(), "world!");
 }
 
 TEST_F(String8Test, OperatorPlusEquals) {
@@ -63,14 +63,14 @@ TEST_F(String8Test, OperatorPlusEquals) {
     // Testing String8 += String8
     String8 src2(" is my passport.");
     src1 += src2;
-    EXPECT_STREQ(src1.string(), "My voice is my passport.");
-    EXPECT_STREQ(src2.string(), " is my passport.");
+    EXPECT_STREQ(src1.c_str(), "My voice is my passport.");
+    EXPECT_STREQ(src2.c_str(), " is my passport.");
 
     // Adding const char* to the previous string.
     const char* src3 = " Verify me.";
     src1 += src3;
-    EXPECT_STREQ(src1.string(), "My voice is my passport. Verify me.");
-    EXPECT_STREQ(src2.string(), " is my passport.");
+    EXPECT_STREQ(src1.c_str(), "My voice is my passport. Verify me.");
+    EXPECT_STREQ(src2.c_str(), " is my passport.");
     EXPECT_STREQ(src3, " Verify me.");
 }
 
diff --git a/libutils/Tokenizer.cpp b/libutils/Tokenizer.cpp
index c3ec1652b292..9fc955c1a37d 100644
--- a/libutils/Tokenizer.cpp
+++ b/libutils/Tokenizer.cpp
@@ -50,15 +50,15 @@ status_t Tokenizer::open(const String8& filename, Tokenizer** outTokenizer) {
     *outTokenizer = nullptr;
 
     int result = OK;
-    int fd = ::open(filename.string(), O_RDONLY);
+    int fd = ::open(filename.c_str(), O_RDONLY);
     if (fd < 0) {
         result = -errno;
-        ALOGE("Error opening file '%s': %s", filename.string(), strerror(errno));
+        ALOGE("Error opening file '%s': %s", filename.c_str(), strerror(errno));
     } else {
         struct stat stat;
         if (fstat(fd, &stat)) {
             result = -errno;
-            ALOGE("Error getting size of file '%s': %s", filename.string(), strerror(errno));
+            ALOGE("Error getting size of file '%s': %s", filename.c_str(), strerror(errno));
         } else {
             size_t length = size_t(stat.st_size);
 
@@ -80,7 +80,7 @@ status_t Tokenizer::open(const String8& filename, Tokenizer** outTokenizer) {
                 ssize_t nrd = read(fd, buffer, length);
                 if (nrd < 0) {
                     result = -errno;
-                    ALOGE("Error reading file '%s': %s", filename.string(), strerror(errno));
+                    ALOGE("Error reading file '%s': %s", filename.c_str(), strerror(errno));
                     delete[] buffer;
                     buffer = nullptr;
                 } else {
@@ -106,7 +106,7 @@ status_t Tokenizer::fromContents(const String8& filename,
 
 String8 Tokenizer::getLocation() const {
     String8 result;
-    result.appendFormat("%s:%d", mFilename.string(), mLineNumber);
+    result.appendFormat("%s:%d", mFilename.c_str(), mLineNumber);
     return result;
 }
 

From 141c6a886c47a043ee6d1572ec634e2f79a47089 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers@google.com>
Date: Fri, 11 Aug 2023 21:05:14 +0000
Subject: [PATCH 0315/1487] Avoid two SELinux related error messages at boot
 time

It is expected that /metadata/ota/rollback-indicator and /metadata/gsi
don't always exist, so don't call selinux_android_restorecon() on them
when they don't exist.  This eliminates the following error messages:

0     0 E selinux : SELinux: Could not get canonical path for /metadata/ota/rollback-indicator restorecon: No such file or directory.
0     0 E selinux : SELinux:  Could not stat /metadata/gsi: No such file or directory.

Test: Booted Cuttlefish and verified the error messages are gone
Change-Id: I94c998556c85adde5f11f134178219ba7880c2be
---
 init/selinux.cpp | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/init/selinux.cpp b/init/selinux.cpp
index ebdcaa62db38..ac102eb4e4ce 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -735,6 +735,14 @@ void SelinuxAvcLog(char* buf) {
     TEMP_FAILURE_RETRY(send(fd.get(), &request, sizeof(request), 0));
 }
 
+int RestoreconIfExists(const char* path, unsigned int flags) {
+    if (access(path, F_OK) != 0 && errno == ENOENT) {
+        // Avoid error message for path that is expected to not always exist.
+        return 0;
+    }
+    return selinux_android_restorecon(path, flags);
+}
+
 }  // namespace
 
 void SelinuxRestoreContext() {
@@ -762,9 +770,9 @@ void SelinuxRestoreContext() {
 
     // adb remount, snapshot-based updates, and DSUs all create files during
     // first-stage init.
-    selinux_android_restorecon(SnapshotManager::GetGlobalRollbackIndicatorPath().c_str(), 0);
-    selinux_android_restorecon("/metadata/gsi", SELINUX_ANDROID_RESTORECON_RECURSE |
-                                                        SELINUX_ANDROID_RESTORECON_SKIP_SEHASH);
+    RestoreconIfExists(SnapshotManager::GetGlobalRollbackIndicatorPath().c_str(), 0);
+    RestoreconIfExists("/metadata/gsi",
+                       SELINUX_ANDROID_RESTORECON_RECURSE | SELINUX_ANDROID_RESTORECON_SKIP_SEHASH);
 }
 
 int SelinuxKlogCallback(int type, const char* fmt, ...) {

From 90d4f89e8bbe2fd5c4719d4d62b099bfe0ce9fc9 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 14 Aug 2023 15:07:15 -0700
Subject: [PATCH 0316/1487] Removing extra string creation for log

Removin unneccessary string from being created in logging

Test: m libsnapshot
Change-Id: I123b6a10f349dfb0c275e630b5f02d1cec8c2687
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index 6d04c6a0c380..1dd63731a270 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -174,8 +174,7 @@ void CowWriterV2::InitBatchWrites() {
         current_data_pos_ = next_data_pos_;
     }
 
-    std::string batch_write = batch_write_ ? "enabled" : "disabled";
-    LOG_INFO << "Batch writes: " << batch_write;
+    LOG_INFO << "Batch writes: " << batch_write_ ? "enabled" : "disabled";
 }
 
 void CowWriterV2::InitWorkers() {

From de6e446efa45477ddcc7051a4e8f711e5220f0fc Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 8 Aug 2023 13:58:46 -0700
Subject: [PATCH 0317/1487] Adding compressor class

Adding in compressor class to clean up code for cow_compress.cpp.
Since we are making some api changes (to zstd) that are unique to each
compression methods, these should be implementation details should be
hidden to the parent class

Test: m libsnapshot

Change-Id: I9194e2c615aefed078458f525382253228bc1b69
---
 .../include/libsnapshot/cow_compress.h        |  48 ++++
 .../include/libsnapshot/cow_writer.h          |  10 +-
 .../libsnapshot_cow/cow_compress.cpp          | 222 +++++++++++-------
 .../libsnapshot/libsnapshot_cow/test_v2.cpp   |   3 +-
 .../libsnapshot/libsnapshot_cow/writer_v2.cpp |  18 +-
 .../libsnapshot/libsnapshot_cow/writer_v2.h   |   3 +
 6 files changed, 206 insertions(+), 98 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
new file mode 100644
index 000000000000..8add041cd874
--- /dev/null
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
@@ -0,0 +1,48 @@
+//
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#pragma once
+
+#include <memory>
+#include <string_view>
+#include "libsnapshot/cow_format.h"
+
+namespace android {
+namespace snapshot {
+
+class ICompressor {
+  public:
+    explicit ICompressor(uint32_t compression_level) : compression_level_(compression_level) {}
+
+    virtual ~ICompressor() {}
+    // Factory methods for compression methods.
+    static std::unique_ptr<ICompressor> Gz(uint32_t compression_level);
+    static std::unique_ptr<ICompressor> Brotli(uint32_t compression_level);
+    static std::unique_ptr<ICompressor> Lz4(uint32_t compression_level);
+    static std::unique_ptr<ICompressor> Zstd(uint32_t compression_level);
+
+    static std::unique_ptr<ICompressor> Create(CowCompression compression);
+
+    uint32_t GetCompressionLevel() const { return compression_level_; }
+
+    [[nodiscard]] virtual std::basic_string<uint8_t> Compress(const void* data,
+                                                              size_t length) const = 0;
+
+  private:
+    uint32_t compression_level_;
+};
+}  // namespace snapshot
+}  // namespace android
\ No newline at end of file
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 74b8bb845533..3016e933b798 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -14,6 +14,8 @@
 
 #pragma once
 
+#include <libsnapshot/cow_compress.h>
+
 #include <stdint.h>
 
 #include <condition_variable>
@@ -107,16 +109,14 @@ class ICowWriter {
 
 class CompressWorker {
   public:
-    CompressWorker(CowCompression compression, uint32_t block_size);
+    CompressWorker(std::unique_ptr<ICompressor>&& compressor, uint32_t block_size);
     bool RunThread();
     void EnqueueCompressBlocks(const void* buffer, size_t num_blocks);
     bool GetCompressedBuffers(std::vector<std::basic_string<uint8_t>>* compressed_buf);
     void Finalize();
     static uint32_t GetDefaultCompressionLevel(CowCompressionAlgorithm compression);
-    static std::basic_string<uint8_t> Compress(CowCompression compression, const void* data,
-                                               size_t length);
 
-    static bool CompressBlocks(CowCompression compression, size_t block_size, const void* buffer,
+    static bool CompressBlocks(ICompressor* compressor, size_t block_size, const void* buffer,
                                size_t num_blocks,
                                std::vector<std::basic_string<uint8_t>>* compressed_data);
 
@@ -128,7 +128,7 @@ class CompressWorker {
         std::vector<std::basic_string<uint8_t>> compressed_data;
     };
 
-    CowCompression compression_;
+    std::unique_ptr<ICompressor> compressor_;
     uint32_t block_size_;
 
     std::queue<CompressWork> work_queue_;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
index 96d60161218d..d023f19e3a49 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
@@ -22,8 +22,11 @@
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include <android-base/parseint.h>
+#include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 #include <brotli/encode.h>
+#include <libsnapshot/cow_compress.h>
 #include <libsnapshot/cow_format.h>
 #include <libsnapshot/cow_reader.h>
 #include <libsnapshot/cow_writer.h>
@@ -51,6 +54,22 @@ std::optional<CowCompressionAlgorithm> CompressionAlgorithmFromString(std::strin
     }
 }
 
+std::unique_ptr<ICompressor> ICompressor::Create(CowCompression compression) {
+    switch (compression.algorithm) {
+        case kCowCompressLz4:
+            return ICompressor::Lz4(compression.compression_level);
+        case kCowCompressBrotli:
+            return ICompressor::Brotli(compression.compression_level);
+        case kCowCompressGz:
+            return ICompressor::Gz(compression.compression_level);
+        case kCowCompressZstd:
+            return ICompressor::Zstd(compression.compression_level);
+        case kCowCompressNone:
+            return nullptr;
+    }
+    return nullptr;
+}
+
 // 1. Default compression level is determined by compression algorithm
 // 2. There might be compatibility issues if a value is changed here, as  some older versions of
 // Android will assume a different compression level, causing cow_size estimation differences that
@@ -77,101 +96,116 @@ uint32_t CompressWorker::GetDefaultCompressionLevel(CowCompressionAlgorithm comp
     return 0;
 }
 
-std::basic_string<uint8_t> CompressWorker::Compress(CowCompression compression, const void* data,
-                                                    size_t length) {
-    switch (compression.algorithm) {
-        case kCowCompressGz: {
-            const auto bound = compressBound(length);
-            std::basic_string<uint8_t> buffer(bound, '\0');
-
-            uLongf dest_len = bound;
-            auto rv = compress2(buffer.data(), &dest_len, reinterpret_cast<const Bytef*>(data),
-                                length, compression.compression_level);
-            if (rv != Z_OK) {
-                LOG(ERROR) << "compress2 returned: " << rv;
-                return {};
-            }
-            buffer.resize(dest_len);
-            return buffer;
+class GzCompressor final : public ICompressor {
+  public:
+    GzCompressor(uint32_t compression_level) : ICompressor(compression_level){};
+
+    std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
+        const auto bound = compressBound(length);
+        std::basic_string<uint8_t> buffer(bound, '\0');
+
+        uLongf dest_len = bound;
+        auto rv = compress2(buffer.data(), &dest_len, reinterpret_cast<const Bytef*>(data), length,
+                            GetCompressionLevel());
+        if (rv != Z_OK) {
+            LOG(ERROR) << "compress2 returned: " << rv;
+            return {};
         }
-        case kCowCompressBrotli: {
-            const auto bound = BrotliEncoderMaxCompressedSize(length);
-            if (!bound) {
-                LOG(ERROR) << "BrotliEncoderMaxCompressedSize returned 0";
-                return {};
-            }
-            std::basic_string<uint8_t> buffer(bound, '\0');
-
-            size_t encoded_size = bound;
-            auto rv = BrotliEncoderCompress(
-                    compression.compression_level, BROTLI_DEFAULT_WINDOW, BROTLI_DEFAULT_MODE,
-                    length, reinterpret_cast<const uint8_t*>(data), &encoded_size, buffer.data());
-            if (!rv) {
-                LOG(ERROR) << "BrotliEncoderCompress failed";
-                return {};
-            }
-            buffer.resize(encoded_size);
-            return buffer;
+        buffer.resize(dest_len);
+        return buffer;
+    };
+};
+
+class Lz4Compressor final : public ICompressor {
+  public:
+    Lz4Compressor(uint32_t compression_level) : ICompressor(compression_level){};
+
+    std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
+        const auto bound = LZ4_compressBound(length);
+        if (!bound) {
+            LOG(ERROR) << "LZ4_compressBound returned 0";
+            return {};
         }
-        case kCowCompressLz4: {
-            const auto bound = LZ4_compressBound(length);
-            if (!bound) {
-                LOG(ERROR) << "LZ4_compressBound returned 0";
-                return {};
-            }
-            std::basic_string<uint8_t> buffer(bound, '\0');
-
-            const auto compressed_size = LZ4_compress_default(
-                    static_cast<const char*>(data), reinterpret_cast<char*>(buffer.data()), length,
-                    buffer.size());
-            if (compressed_size <= 0) {
-                LOG(ERROR) << "LZ4_compress_default failed, input size: " << length
-                           << ", compression bound: " << bound << ", ret: " << compressed_size;
-                return {};
-            }
-            // Don't run compression if the compressed output is larger
-            if (compressed_size >= length) {
-                buffer.resize(length);
-                memcpy(buffer.data(), data, length);
-            } else {
-                buffer.resize(compressed_size);
-            }
-            return buffer;
+        std::basic_string<uint8_t> buffer(bound, '\0');
+
+        const auto compressed_size =
+                LZ4_compress_default(static_cast<const char*>(data),
+                                     reinterpret_cast<char*>(buffer.data()), length, buffer.size());
+        if (compressed_size <= 0) {
+            LOG(ERROR) << "LZ4_compress_default failed, input size: " << length
+                       << ", compression bound: " << bound << ", ret: " << compressed_size;
+            return {};
         }
-        case kCowCompressZstd: {
-            std::basic_string<uint8_t> buffer(ZSTD_compressBound(length), '\0');
-            const auto compressed_size = ZSTD_compress(buffer.data(), buffer.size(), data, length,
-                                                       compression.compression_level);
-            if (compressed_size <= 0) {
-                LOG(ERROR) << "ZSTD compression failed " << compressed_size;
-                return {};
-            }
-            // Don't run compression if the compressed output is larger
-            if (compressed_size >= length) {
-                buffer.resize(length);
-                memcpy(buffer.data(), data, length);
-            } else {
-                buffer.resize(compressed_size);
-            }
-            return buffer;
+        // Don't run compression if the compressed output is larger
+        if (compressed_size >= length) {
+            buffer.resize(length);
+            memcpy(buffer.data(), data, length);
+        } else {
+            buffer.resize(compressed_size);
         }
-        default:
-            LOG(ERROR) << "unhandled compression type: " << compression.algorithm;
-            break;
-    }
-    return {};
-}
+        return buffer;
+    };
+};
+
+class BrotliCompressor final : public ICompressor {
+  public:
+    BrotliCompressor(uint32_t compression_level) : ICompressor(compression_level){};
+
+    std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
+        const auto bound = BrotliEncoderMaxCompressedSize(length);
+        if (!bound) {
+            LOG(ERROR) << "BrotliEncoderMaxCompressedSize returned 0";
+            return {};
+        }
+        std::basic_string<uint8_t> buffer(bound, '\0');
+
+        size_t encoded_size = bound;
+        auto rv = BrotliEncoderCompress(
+                GetCompressionLevel(), BROTLI_DEFAULT_WINDOW, BROTLI_DEFAULT_MODE, length,
+                reinterpret_cast<const uint8_t*>(data), &encoded_size, buffer.data());
+        if (!rv) {
+            LOG(ERROR) << "BrotliEncoderCompress failed";
+            return {};
+        }
+        buffer.resize(encoded_size);
+        return buffer;
+    };
+};
+
+class ZstdCompressor final : public ICompressor {
+  public:
+    ZstdCompressor(uint32_t compression_level) : ICompressor(compression_level){};
+
+    std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
+        std::basic_string<uint8_t> buffer(ZSTD_compressBound(length), '\0');
+        const auto compressed_size =
+                ZSTD_compress(buffer.data(), buffer.size(), data, length, GetCompressionLevel());
+        if (compressed_size <= 0) {
+            LOG(ERROR) << "ZSTD compression failed " << compressed_size;
+            return {};
+        }
+        // Don't run compression if the compressed output is larger
+        if (compressed_size >= length) {
+            buffer.resize(length);
+            memcpy(buffer.data(), data, length);
+        } else {
+            buffer.resize(compressed_size);
+        }
+        return buffer;
+    };
+};
+
 bool CompressWorker::CompressBlocks(const void* buffer, size_t num_blocks,
                                     std::vector<std::basic_string<uint8_t>>* compressed_data) {
-    return CompressBlocks(compression_, block_size_, buffer, num_blocks, compressed_data);
+    return CompressBlocks(compressor_.get(), block_size_, buffer, num_blocks, compressed_data);
 }
 
-bool CompressWorker::CompressBlocks(CowCompression compression, size_t block_size,
-                                    const void* buffer, size_t num_blocks,
+bool CompressWorker::CompressBlocks(ICompressor* compressor, size_t block_size, const void* buffer,
+                                    size_t num_blocks,
                                     std::vector<std::basic_string<uint8_t>>* compressed_data) {
     const uint8_t* iter = reinterpret_cast<const uint8_t*>(buffer);
     while (num_blocks) {
-        auto data = Compress(compression, iter, block_size);
+        auto data = compressor->Compress(iter, block_size);
         if (data.empty()) {
             PLOG(ERROR) << "CompressBlocks: Compression failed";
             return false;
@@ -270,6 +304,22 @@ bool CompressWorker::GetCompressedBuffers(std::vector<std::basic_string<uint8_t>
     return true;
 }
 
+std::unique_ptr<ICompressor> ICompressor::Brotli(uint32_t compression_level) {
+    return std::make_unique<BrotliCompressor>(compression_level);
+}
+
+std::unique_ptr<ICompressor> ICompressor::Gz(uint32_t compression_level) {
+    return std::make_unique<GzCompressor>(compression_level);
+}
+
+std::unique_ptr<ICompressor> ICompressor::Lz4(uint32_t compression_level) {
+    return std::make_unique<Lz4Compressor>(compression_level);
+}
+
+std::unique_ptr<ICompressor> ICompressor::Zstd(uint32_t compression_level) {
+    return std::make_unique<ZstdCompressor>(compression_level);
+}
+
 void CompressWorker::Finalize() {
     {
         std::unique_lock<std::mutex> lock(lock_);
@@ -278,8 +328,8 @@ void CompressWorker::Finalize() {
     cv_.notify_all();
 }
 
-CompressWorker::CompressWorker(CowCompression compression, uint32_t block_size)
-    : compression_(compression), block_size_(block_size) {}
+CompressWorker::CompressWorker(std::unique_ptr<ICompressor>&& compressor, uint32_t block_size)
+    : compressor_(std::move(compressor)), block_size_(block_size) {}
 
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 2258d9fb75cb..0ecad9d2c7a7 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -480,7 +480,8 @@ TEST_P(CompressionTest, HorribleStream) {
     std::string expected = "The quick brown fox jumps over the lazy dog.";
     expected.resize(4096, '\0');
 
-    auto result = CompressWorker::Compress(compression, expected.data(), expected.size());
+    std::unique_ptr<ICompressor> compressor = ICompressor::Create(compression);
+    auto result = compressor->Compress(expected.data(), expected.size());
     ASSERT_FALSE(result.empty());
 
     HorribleStream<uint8_t> stream(result);
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index 6d04c6a0c380..7115821b63fb 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -184,7 +184,8 @@ void CowWriterV2::InitWorkers() {
         return;
     }
     for (int i = 0; i < num_compress_threads_; i++) {
-        auto wt = std::make_unique<CompressWorker>(compression_, header_.block_size);
+        std::unique_ptr<ICompressor> compressor = ICompressor::Create(compression_);
+        auto wt = std::make_unique<CompressWorker>(std::move(compressor), header_.block_size);
         threads_.emplace_back(std::async(std::launch::async, &CompressWorker::RunThread, wt.get()));
         compress_threads_.push_back(std::move(wt));
     }
@@ -339,10 +340,12 @@ bool CowWriterV2::CompressBlocks(size_t num_blocks, const void* data) {
     const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
     compressed_buf_.clear();
     if (num_threads <= 1) {
-        return CompressWorker::CompressBlocks(compression_, options_.block_size, data, num_blocks,
-                                              &compressed_buf_);
+        if (!compressor_) {
+            compressor_ = ICompressor::Create(compression_);
+        }
+        return CompressWorker::CompressBlocks(compressor_.get(), options_.block_size, data,
+                                              num_blocks, &compressed_buf_);
     }
-
     // Submit the blocks per thread. The retrieval of
     // compressed buffers has to be done in the same order.
     // We should not poll for completed buffers in a different order as the
@@ -412,8 +415,11 @@ bool CowWriterV2::EmitBlocks(uint64_t new_block_start, const void* data, size_t
                         buf_iter_++;
                         return data;
                     } else {
-                        auto data =
-                                CompressWorker::Compress(compression_, iter, header_.block_size);
+                        if (!compressor_) {
+                            compressor_ = ICompressor::Create(compression_);
+                        }
+
+                        auto data = compressor_->Compress(iter, header_.block_size);
                         return data;
                     }
                 }();
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
index 3f357e024cf0..131a068455ba 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
@@ -65,6 +65,9 @@ class CowWriterV2 : public CowWriterBase {
   private:
     CowFooter footer_{};
     CowCompression compression_;
+    // in the case that we are using one thread for compression, we can store and re-use the same
+    // compressor
+    std::unique_ptr<ICompressor> compressor_;
     uint64_t current_op_pos_ = 0;
     uint64_t next_op_pos_ = 0;
     uint64_t next_data_pos_ = 0;

From 03acfdbeb6dcf6ffb32b1823a91d8b29bbce03b5 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 9 Aug 2023 13:48:08 -0700
Subject: [PATCH 0318/1487] Optimize zstd compression

reuse the same context for zstd compression. One context should be used
per compression thread for optimal performance. Discussion and
reccomendations can be found at go/android-hw-compression-vendor

Results (level 3 compression)
full ota on raven with optimizations:  1191.304 seconds
without optimizations:  1461.854 seconds

compression ratio remains unchanged and merge time difference are
negligible ~1% delta (probably just noise)

Test: ota_from_target_files, update_device.py
Change-Id: I3feede9f1f119874e369c54b29c594475fbf7376
---
 .../libsnapshot/libsnapshot_cow/cow_compress.cpp   | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
index d023f19e3a49..466b93c25b27 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
@@ -18,6 +18,7 @@
 #include <unistd.h>
 
 #include <limits>
+#include <memory>
 #include <queue>
 
 #include <android-base/file.h>
@@ -174,12 +175,18 @@ class BrotliCompressor final : public ICompressor {
 
 class ZstdCompressor final : public ICompressor {
   public:
-    ZstdCompressor(uint32_t compression_level) : ICompressor(compression_level){};
+    ZstdCompressor(uint32_t compression_level)
+        : ICompressor(compression_level), zstd_context_(ZSTD_createCCtx(), ZSTD_freeCCtx) {
+        ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_compressionLevel, compression_level);
+        // FIXME: hardcoding a value of 12 here for 4k blocks, should change to be either set by
+        // user, or optimized depending on block size
+        ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_windowLog, 12);
+    };
 
     std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
         std::basic_string<uint8_t> buffer(ZSTD_compressBound(length), '\0');
         const auto compressed_size =
-                ZSTD_compress(buffer.data(), buffer.size(), data, length, GetCompressionLevel());
+                ZSTD_compress2(zstd_context_.get(), buffer.data(), buffer.size(), data, length);
         if (compressed_size <= 0) {
             LOG(ERROR) << "ZSTD compression failed " << compressed_size;
             return {};
@@ -193,6 +200,9 @@ class ZstdCompressor final : public ICompressor {
         }
         return buffer;
     };
+
+  private:
+    std::unique_ptr<ZSTD_CCtx, decltype(&ZSTD_freeCCtx)> zstd_context_;
 };
 
 bool CompressWorker::CompressBlocks(const void* buffer, size_t num_blocks,

From 8d9940bdaf637fcefaf6d1f91212de7a0d0d8da7 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 15 Aug 2023 15:13:52 -0700
Subject: [PATCH 0319/1487] Update OWNERS.

Change-Id: Ib069b181fd48d73e5320f44c435b8814f269d291
---
 fs_mgr/libsnapshot/OWNERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs_mgr/libsnapshot/OWNERS b/fs_mgr/libsnapshot/OWNERS
index 9d2b877aca56..1ee4175cffca 100644
--- a/fs_mgr/libsnapshot/OWNERS
+++ b/fs_mgr/libsnapshot/OWNERS
@@ -3,3 +3,4 @@ balsini@google.com
 dvander@google.com
 elsk@google.com
 akailash@google.com
+zhangkelvin@google.com

From fb7e268552867da13229eb8d8aee77dee4f6d2bc Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 9 Aug 2023 10:31:56 -0700
Subject: [PATCH 0320/1487] snapuserd: Fix race condition in
 MergeWorker::WaitForMergeBegin.

The pre-conditions and post-conditions to cv.wait() in this function are
different, which leads to a race. If the merge is never initiated, but
I/O is terminated, the wait() will hang.

This is easy to hit in tests where I/O terminates quickly, but should
not affect actual OTA flow in practice.

Bug: 269361087
Test: snapuserd_test
Change-Id: I85ed9c357031ec6fd74d6a3f49d85e6cbb037eee
---
 .../snapuserd_transitions.cpp                 | 39 +++++++++----------
 1 file changed, 18 insertions(+), 21 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
index 52e4f89cd124..f3e00195266a 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
@@ -189,35 +189,32 @@ void SnapshotHandler::InitiateMerge() {
     cv.notify_all();
 }
 
+static inline bool IsMergeBeginError(MERGE_IO_TRANSITION io_state) {
+    return io_state == MERGE_IO_TRANSITION::READ_AHEAD_FAILURE ||
+           io_state == MERGE_IO_TRANSITION::IO_TERMINATED;
+}
+
 // Invoked by Merge thread - Waits on RA thread to resume merging. Will
 // be waken up RA thread.
 bool SnapshotHandler::WaitForMergeBegin() {
-    {
-        std::unique_lock<std::mutex> lock(lock_);
-        while (!MergeInitiated()) {
-            cv.wait(lock);
+    std::unique_lock<std::mutex> lock(lock_);
 
-            if (io_state_ == MERGE_IO_TRANSITION::READ_AHEAD_FAILURE ||
-                io_state_ == MERGE_IO_TRANSITION::IO_TERMINATED) {
-                SNAP_LOG(ERROR) << "WaitForMergeBegin failed with state: " << io_state_;
-                return false;
-            }
-        }
+    cv.wait(lock, [this]() -> bool { return MergeInitiated() || IsMergeBeginError(io_state_); });
 
-        while (!(io_state_ == MERGE_IO_TRANSITION::MERGE_BEGIN ||
-                 io_state_ == MERGE_IO_TRANSITION::READ_AHEAD_FAILURE ||
-                 io_state_ == MERGE_IO_TRANSITION::IO_TERMINATED)) {
-            cv.wait(lock);
-        }
+    if (IsMergeBeginError(io_state_)) {
+        SNAP_LOG(ERROR) << "WaitForMergeBegin failed with state: " << io_state_;
+        return false;
+    }
 
-        if (io_state_ == MERGE_IO_TRANSITION::READ_AHEAD_FAILURE ||
-            io_state_ == MERGE_IO_TRANSITION::IO_TERMINATED) {
-            SNAP_LOG(ERROR) << "WaitForMergeBegin failed with state: " << io_state_;
-            return false;
-        }
+    cv.wait(lock, [this]() -> bool {
+        return io_state_ == MERGE_IO_TRANSITION::MERGE_BEGIN || IsMergeBeginError(io_state_);
+    });
 
-        return true;
+    if (IsMergeBeginError(io_state_)) {
+        SNAP_LOG(ERROR) << "WaitForMergeBegin failed with state: " << io_state_;
+        return false;
     }
+    return true;
 }
 
 // Invoked by RA thread - Flushes the RA block to scratch space if necessary

From ed7716f2c46eaf846f16791bec21a2836c1bcc99 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 8 Aug 2023 12:47:28 -0700
Subject: [PATCH 0321/1487] snapuserd: Add snapuserd_test to presubmit and VTS.

Bug: 269361087
Test: presubmit
Change-Id: Ic80025b1e75f049abdc7fdbcfdd5a142f56d702e
---
 fs_mgr/TEST_MAPPING                     |  8 +++++++-
 fs_mgr/libsnapshot/snapuserd/Android.bp | 25 ++++++++++++++++++++++---
 2 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index d357e4571dcf..169496929bdd 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -28,6 +28,9 @@
     //{"name": "vabc_legacy_tests"},
     {
       "name": "cow_api_test"
+    },
+    {
+      "name": "snapuserd_test"
     }
   ],
   "kernel-presubmit": [
@@ -42,8 +45,11 @@
     },
     {
       "name": "vab_legacy_tests"
-    }
+    },
     // TODO: b/279009697
     //{"name": "vabc_legacy_tests"}
+    {
+      "name": "snapuserd_test"
+    }
   ]
 }
diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 6548cc8a75b0..e56ffbe63d47 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -214,8 +214,8 @@ cc_test {
     require_root: false,
 }
 
-cc_test {
-    name: "snapuserd_test",
+cc_defaults {
+    name: "snapuserd_test_defaults",
     defaults: [
         "fs_mgr_defaults",
         "libsnapshot_cow_defaults",
@@ -256,5 +256,24 @@ cc_test {
         min_shipping_api_level: 30,
     },
     auto_gen_config: true,
-    require_root: false,
+    require_root: true,
+    compile_multilib: "first",
+}
+
+cc_test {
+    name: "snapuserd_test",
+    defaults: ["snapuserd_test_defaults"],
+    host_supported: true,
+    test_suites: [
+        "device-tests",
+    ],
+}
+
+// vts tests cannot be host_supported.
+cc_test {
+    name: "vts_snapuserd_test",
+    defaults: ["snapuserd_test_defaults"],
+    test_suites: [
+        "vts",
+    ],
 }

From b702fddd2e0907740f0656550016ea9fcda5e72b Mon Sep 17 00:00:00 2001
From: Snehal <snehalreddy@google.com>
Date: Fri, 11 Aug 2023 09:48:22 +0000
Subject: [PATCH 0322/1487] Change name to trusty-coverage-controller

Test: builds and passes tests

Bug: None

Change-Id: I89eec23312f79f4da43c491ce58aa4f246c7ab34
---
 trusty/utils/coverage-controller/Android.bp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/utils/coverage-controller/Android.bp b/trusty/utils/coverage-controller/Android.bp
index 1aa88cc12086..e6d30d912d12 100644
--- a/trusty/utils/coverage-controller/Android.bp
+++ b/trusty/utils/coverage-controller/Android.bp
@@ -17,7 +17,7 @@ package {
 }
 
 cc_binary {
-    name: "coverage-controller",
+    name: "trusty-coverage-controller",
     vendor: true,
 
     srcs: ["controller.cpp"],

From c37838eec8d7b5bcec74e8293a0bdb655991a4e7 Mon Sep 17 00:00:00 2001
From: Bruce Po <brucepo@google.com>
Date: Wed, 16 Aug 2023 17:36:55 +0000
Subject: [PATCH 0323/1487] Revert "Remove cutils threads.h header completely."

This reverts commit d3550e33148c48c4accdccb7f822701e5bea025d.

Reason for revert: DroidMonitor-triggered revert due to breakage https://android-build.googleplex.com/builds/quarterdeck?branch=git_tm-qpr-dev-plus-aosp&target=aosp_sunfish-userdebug&lkgb=10667572&lkbb=10667604&fkbb=10667601, bug http://b/296247274

Change-Id: I3f3864dc21fcb34cbb2ff524c43c3d92bd260ff6
BUG: 296247274
---
 libcutils/include/cutils/threads.h                | 15 +++++++++++++++
 libcutils/include_outside_system/cutils/threads.h |  1 +
 2 files changed, 16 insertions(+)
 create mode 100644 libcutils/include/cutils/threads.h
 create mode 120000 libcutils/include_outside_system/cutils/threads.h

diff --git a/libcutils/include/cutils/threads.h b/libcutils/include/cutils/threads.h
new file mode 100644
index 000000000000..9bc3429bec29
--- /dev/null
+++ b/libcutils/include/cutils/threads.h
@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2007 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.
+ */
diff --git a/libcutils/include_outside_system/cutils/threads.h b/libcutils/include_outside_system/cutils/threads.h
new file mode 120000
index 000000000000..99330ffadfe3
--- /dev/null
+++ b/libcutils/include_outside_system/cutils/threads.h
@@ -0,0 +1 @@
+../../include/cutils/threads.h
\ No newline at end of file

From 6cf9cd0123016879454fe0eff15ba78223a68527 Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Wed, 16 Aug 2023 22:37:14 +0000
Subject: [PATCH 0324/1487] Revert "Revert "Remove cutils threads.h header
 completely.""

This reverts commit c37838eec8d7b5bcec74e8293a0bdb655991a4e7.

Reason for revert: b/296247274 root-cause fixed

Change-Id: I859e7500a1dd09e3a66986cda9e62adf5d7a524a
---
 libcutils/include/cutils/threads.h                | 15 ---------------
 libcutils/include_outside_system/cutils/threads.h |  1 -
 2 files changed, 16 deletions(-)
 delete mode 100644 libcutils/include/cutils/threads.h
 delete mode 120000 libcutils/include_outside_system/cutils/threads.h

diff --git a/libcutils/include/cutils/threads.h b/libcutils/include/cutils/threads.h
deleted file mode 100644
index 9bc3429bec29..000000000000
--- a/libcutils/include/cutils/threads.h
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
- * Copyright (C) 2007 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.
- */
diff --git a/libcutils/include_outside_system/cutils/threads.h b/libcutils/include_outside_system/cutils/threads.h
deleted file mode 120000
index 99330ffadfe3..000000000000
--- a/libcutils/include_outside_system/cutils/threads.h
+++ /dev/null
@@ -1 +0,0 @@
-../../include/cutils/threads.h
\ No newline at end of file

From 96b78feec1f326fbfcfee9714a0dcaaa1a3683e1 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 15 Aug 2023 14:34:39 -0700
Subject: [PATCH 0325/1487] Fix zstd optimization api usage

ZSTD_c_windowLog should be set as log base 2 of max block size. Changing
hardcoded value to be determined by this variable.

Test: m libsnapshot
Change-Id: I09be447b7f1e95cb72a6a42eddb4035f61a43aad
---
 .../include/libsnapshot/cow_compress.h            |  4 ++--
 .../libsnapshot/libsnapshot_cow/cow_compress.cpp  | 15 +++++++--------
 fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp    |  2 +-
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp  |  7 ++++---
 4 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
index 8add041cd874..97974c414524 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
@@ -32,9 +32,9 @@ class ICompressor {
     static std::unique_ptr<ICompressor> Gz(uint32_t compression_level);
     static std::unique_ptr<ICompressor> Brotli(uint32_t compression_level);
     static std::unique_ptr<ICompressor> Lz4(uint32_t compression_level);
-    static std::unique_ptr<ICompressor> Zstd(uint32_t compression_level);
+    static std::unique_ptr<ICompressor> Zstd(uint32_t compression_level, const int32_t BLOCK_SZ);
 
-    static std::unique_ptr<ICompressor> Create(CowCompression compression);
+    static std::unique_ptr<ICompressor> Create(CowCompression compression, const int32_t BLOCK_SZ);
 
     uint32_t GetCompressionLevel() const { return compression_level_; }
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
index 466b93c25b27..71ac59f20d20 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
@@ -55,7 +55,8 @@ std::optional<CowCompressionAlgorithm> CompressionAlgorithmFromString(std::strin
     }
 }
 
-std::unique_ptr<ICompressor> ICompressor::Create(CowCompression compression) {
+std::unique_ptr<ICompressor> ICompressor::Create(CowCompression compression,
+                                                 const int32_t BLOCK_SZ) {
     switch (compression.algorithm) {
         case kCowCompressLz4:
             return ICompressor::Lz4(compression.compression_level);
@@ -64,7 +65,7 @@ std::unique_ptr<ICompressor> ICompressor::Create(CowCompression compression) {
         case kCowCompressGz:
             return ICompressor::Gz(compression.compression_level);
         case kCowCompressZstd:
-            return ICompressor::Zstd(compression.compression_level);
+            return ICompressor::Zstd(compression.compression_level, BLOCK_SZ);
         case kCowCompressNone:
             return nullptr;
     }
@@ -175,12 +176,10 @@ class BrotliCompressor final : public ICompressor {
 
 class ZstdCompressor final : public ICompressor {
   public:
-    ZstdCompressor(uint32_t compression_level)
+    ZstdCompressor(uint32_t compression_level, const uint32_t MAX_BLOCK_SIZE)
         : ICompressor(compression_level), zstd_context_(ZSTD_createCCtx(), ZSTD_freeCCtx) {
         ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_compressionLevel, compression_level);
-        // FIXME: hardcoding a value of 12 here for 4k blocks, should change to be either set by
-        // user, or optimized depending on block size
-        ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_windowLog, 12);
+        ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_windowLog, log2(MAX_BLOCK_SIZE));
     };
 
     std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
@@ -326,8 +325,8 @@ std::unique_ptr<ICompressor> ICompressor::Lz4(uint32_t compression_level) {
     return std::make_unique<Lz4Compressor>(compression_level);
 }
 
-std::unique_ptr<ICompressor> ICompressor::Zstd(uint32_t compression_level) {
-    return std::make_unique<ZstdCompressor>(compression_level);
+std::unique_ptr<ICompressor> ICompressor::Zstd(uint32_t compression_level, const int32_t BLOCK_SZ) {
+    return std::make_unique<ZstdCompressor>(compression_level, BLOCK_SZ);
 }
 
 void CompressWorker::Finalize() {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 0ecad9d2c7a7..e59bd927fe08 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -480,7 +480,7 @@ TEST_P(CompressionTest, HorribleStream) {
     std::string expected = "The quick brown fox jumps over the lazy dog.";
     expected.resize(4096, '\0');
 
-    std::unique_ptr<ICompressor> compressor = ICompressor::Create(compression);
+    std::unique_ptr<ICompressor> compressor = ICompressor::Create(compression, 4096);
     auto result = compressor->Compress(expected.data(), expected.size());
     ASSERT_FALSE(result.empty());
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index 7115821b63fb..4172fc9c34a5 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -184,7 +184,8 @@ void CowWriterV2::InitWorkers() {
         return;
     }
     for (int i = 0; i < num_compress_threads_; i++) {
-        std::unique_ptr<ICompressor> compressor = ICompressor::Create(compression_);
+        std::unique_ptr<ICompressor> compressor =
+                ICompressor::Create(compression_, header_.block_size);
         auto wt = std::make_unique<CompressWorker>(std::move(compressor), header_.block_size);
         threads_.emplace_back(std::async(std::launch::async, &CompressWorker::RunThread, wt.get()));
         compress_threads_.push_back(std::move(wt));
@@ -341,7 +342,7 @@ bool CowWriterV2::CompressBlocks(size_t num_blocks, const void* data) {
     compressed_buf_.clear();
     if (num_threads <= 1) {
         if (!compressor_) {
-            compressor_ = ICompressor::Create(compression_);
+            compressor_ = ICompressor::Create(compression_, header_.block_size);
         }
         return CompressWorker::CompressBlocks(compressor_.get(), options_.block_size, data,
                                               num_blocks, &compressed_buf_);
@@ -416,7 +417,7 @@ bool CowWriterV2::EmitBlocks(uint64_t new_block_start, const void* data, size_t
                         return data;
                     } else {
                         if (!compressor_) {
-                            compressor_ = ICompressor::Create(compression_);
+                            compressor_ = ICompressor::Create(compression_, header_.block_size);
                         }
 
                         auto data = compressor_->Compress(iter, header_.block_size);

From 21aab6cb8384c3e7d53118c9684b450c7604b4b7 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 16 Aug 2023 15:19:57 -0700
Subject: [PATCH 0326/1487] Fix warning

remove some unused headers and fix warning: Moving a temporary object prevents copy elision

Test: m libsnapshot
Change-Id: Idec3e051837dab5f1b95e677d1cdb09e9a57e73e
---
 fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index f37aed1afe63..1b5d72484a5a 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -17,9 +17,7 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-#include <limits>
 #include <optional>
-#include <set>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
@@ -103,7 +101,7 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
     footer_ = parser.footer();
     fd_size_ = parser.fd_size();
     last_label_ = parser.last_label();
-    ops_ = std::move(parser.ops());
+    ops_ = parser.ops();
     data_loc_ = parser.data_loc();
 
     // If we're resuming a write, we're not ready to merge

From 36882e98b4b33d48949cfcc3700f39f24489bebd Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 15 Aug 2023 13:32:48 -0700
Subject: [PATCH 0327/1487] ZSTD read from wrong buf

Fix zstd to read from ignore_buf rather than buf since that is where we
are first copying the date

Test: zstd ota
Change-Id: I5032300e4628ecd7e49f1fa9f76dc9a828fb58e6
---
 fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp
index 3692c1a8aa9c..2aaf3883f638 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp
@@ -351,7 +351,7 @@ class ZstdDecompressor final : public IDecompressor {
             return decompressed_size;
         }
         std::vector<unsigned char> ignore_buf(decompressed_size);
-        if (!Decompress(buffer, decompressed_size)) {
+        if (!Decompress(ignore_buf.data(), decompressed_size)) {
             return -1;
         }
         memcpy(buffer, ignore_buf.data() + ignore_bytes, buffer_size);

From 4b503b968cc9822a39588c2d198280aff85efbc6 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 17 Aug 2023 15:12:49 -0700
Subject: [PATCH 0328/1487] Fix uninitialized var compiler warnings

Test: th
Bug: 293313353
Change-Id: I87420a21a9c2ce1987179bf70767ea15b26cd5a5
---
 init/first_stage_init.cpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index 7fabbac517a2..88300cb29c36 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -67,7 +67,7 @@ enum class BootMode {
 void FreeRamdisk(DIR* dir, dev_t dev) {
     int dfd = dirfd(dir);
 
-    dirent* de;
+    dirent* de = nullptr;
     while ((de = readdir(dir)) != nullptr) {
         if (de->d_name == "."s || de->d_name == ".."s) {
             continue;
@@ -76,7 +76,7 @@ void FreeRamdisk(DIR* dir, dev_t dev) {
         bool is_dir = false;
 
         if (de->d_type == DT_DIR || de->d_type == DT_UNKNOWN) {
-            struct stat info;
+            struct stat info {};
             if (fstatat(dfd, de->d_name, &info, AT_SYMLINK_NOFOLLOW) != 0) {
                 continue;
             }
@@ -171,7 +171,7 @@ std::string GetModuleLoadList(BootMode boot_mode, const std::string& dir_path) {
     }
 
     if (module_load_file != "modules.load") {
-        struct stat fileStat;
+        struct stat fileStat {};
         std::string load_path = dir_path + "/" + module_load_file;
         // Fall back to modules.load if the other files aren't accessible
         if (stat(load_path.c_str(), &fileStat)) {
@@ -185,11 +185,11 @@ std::string GetModuleLoadList(BootMode boot_mode, const std::string& dir_path) {
 #define MODULE_BASE_DIR "/lib/modules"
 bool LoadKernelModules(BootMode boot_mode, bool want_console, bool want_parallel,
                        int& modules_loaded) {
-    struct utsname uts;
+    struct utsname uts {};
     if (uname(&uts)) {
         LOG(FATAL) << "Failed to get kernel version.";
     }
-    int major, minor;
+    int major = 0, minor = 0;
     if (sscanf(uts.release, "%d.%d", &major, &minor) != 2) {
         LOG(FATAL) << "Failed to parse kernel version " << uts.release;
     }
@@ -199,13 +199,13 @@ bool LoadKernelModules(BootMode boot_mode, bool want_console, bool want_parallel
         LOG(INFO) << "Unable to open /lib/modules, skipping module loading.";
         return true;
     }
-    dirent* entry;
+    dirent* entry = nullptr;
     std::vector<std::string> module_dirs;
     while ((entry = readdir(base_dir.get()))) {
         if (entry->d_type != DT_DIR) {
             continue;
         }
-        int dir_major, dir_minor;
+        int dir_major = 0, dir_minor = 0;
         if (sscanf(entry->d_name, "%d.%d", &dir_major, &dir_minor) != 2 || dir_major != major ||
             dir_minor != minor) {
             continue;
@@ -374,7 +374,7 @@ int FirstStageMain(int argc, char** argv) {
         PLOG(ERROR) << "Could not opendir(\"/\"), not freeing ramdisk";
     }
 
-    struct stat old_root_info;
+    struct stat old_root_info {};
     if (stat("/", &old_root_info) != 0) {
         PLOG(ERROR) << "Could not stat(\"/\"), not freeing ramdisk";
         old_root_dir.reset();
@@ -483,7 +483,7 @@ int FirstStageMain(int argc, char** argv) {
         }
     }
 
-    struct stat new_root_info;
+    struct stat new_root_info {};
     if (stat("/", &new_root_info) != 0) {
         PLOG(ERROR) << "Could not stat(\"/\"), not freeing ramdisk";
         old_root_dir.reset();

From 6e074fc31ee0a58eaa8f3c35affbe54918165747 Mon Sep 17 00:00:00 2001
From: Snehal <snehalreddy@google.com>
Date: Mon, 14 Aug 2023 14:31:14 +0000
Subject: [PATCH 0329/1487] Add UUIDs to profraw filenames

Bug: 295866435

Change-Id: Ie9390f412c70202d1583e29ac83c30778ae02f70
---
 .../utils/coverage-controller/controller.cpp  | 33 +++++++++++++++----
 trusty/utils/coverage-controller/controller.h |  3 ++
 2 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/trusty/utils/coverage-controller/controller.cpp b/trusty/utils/coverage-controller/controller.cpp
index 730c0109b0ca..0047046d7566 100644
--- a/trusty/utils/coverage-controller/controller.cpp
+++ b/trusty/utils/coverage-controller/controller.cpp
@@ -14,11 +14,16 @@
  * limitations under the License.
  */
 
+#include <android-base/stringprintf.h>
+#include <array>
 #include <getopt.h>
+#include <inttypes.h>
+#include <memory>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
 #include <trusty/line-coverage/coverage.h>
 #include <trusty/tipc.h>
-#include <array>
-#include <memory>
 #include <vector>
 
 #include "controller.h"
@@ -48,10 +53,10 @@ void Controller::run(std::string output_dir) {
 
             if (complete_cnt != counters[index] && start_cnt == complete_cnt) {
                 WRITE_ONCE(control->cntrl_flags, FLAG_NONE);
-                std::string fmt = "/%d.%lu.profraw";
-                int sz = std::snprintf(nullptr, 0, fmt.c_str(), index, counters[index]);
-                std::string filename(sz+1, '.');
-                std::sprintf(filename.data(), fmt.c_str(), index, counters[index]);
+                std::string filename;
+                filename = android::base::StringPrintf("/%s.%lu.profraw",
+                                                    uuid_list_[index].c_str(),
+                                                    counters[index]);
                 filename.insert(0, output_dir);
                 android::base::Result<void> res = record_list_[index]->SaveFile(filename);
                 counters[index]++;
@@ -79,6 +84,7 @@ void Controller::setUpShm() {
     struct line_coverage_client_resp resp;
     uint32_t cur_index = record_list_.size();
     struct uuid zero_uuid = {0, 0, 0, { 0 }};
+    char uuid_str[UUID_STR_SIZE];
     req.hdr.cmd = LINE_COVERAGE_CLIENT_CMD_SEND_LIST;
     int rc = write(coverage_srv_fd, &req, sizeof(req));
         if (rc != (int)sizeof(req)) {
@@ -98,6 +104,21 @@ void Controller::setUpShm() {
             }
             if(uuid_set_.find(resp.send_list_args.uuid) == uuid_set_.end()) {
                 uuid_set_.insert(resp.send_list_args.uuid);
+                sprintf(uuid_str,
+                    "%08" PRIx32 "-%04" PRIx16 "-%04" PRIx16 "-%02" PRIx8 "%02" PRIx8
+                    "-%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "%02" PRIx8,
+                    resp.send_list_args.uuid.time_low,
+                    resp.send_list_args.uuid.time_mid,
+                    resp.send_list_args.uuid.time_hi_and_version,
+                    resp.send_list_args.uuid.clock_seq_and_node[0],
+                    resp.send_list_args.uuid.clock_seq_and_node[1],
+                    resp.send_list_args.uuid.clock_seq_and_node[2],
+                    resp.send_list_args.uuid.clock_seq_and_node[3],
+                    resp.send_list_args.uuid.clock_seq_and_node[4],
+                    resp.send_list_args.uuid.clock_seq_and_node[5],
+                    resp.send_list_args.uuid.clock_seq_and_node[6],
+                    resp.send_list_args.uuid.clock_seq_and_node[7]);
+                uuid_list_.push_back(uuid_str);
                 record_list_.push_back(std::make_unique<CoverageRecord>(TIPC_DEV,
                                                                     &resp.send_list_args.uuid));
                 counters.push_back(0);
diff --git a/trusty/utils/coverage-controller/controller.h b/trusty/utils/coverage-controller/controller.h
index b771c16150d8..f7789bfed076 100644
--- a/trusty/utils/coverage-controller/controller.h
+++ b/trusty/utils/coverage-controller/controller.h
@@ -26,6 +26,8 @@
 #define TEST_SRV_PORT "com.android.trusty.sancov.test.srv"
 #define TEST_SRV_MODULE "srv.syms.elf"
 
+#define UUID_STR_SIZE (37)
+
 #define FLAG_NONE               0x0
 #define FLAG_RUN                0x1
 #define FLAG_TOGGLE_CLEAR       0x2
@@ -52,6 +54,7 @@ class Controller {
     private:
         std::vector<std::unique_ptr<line_coverage::CoverageRecord>>record_list_;
         std::set<struct uuid>uuid_set_;
+        std::vector<std::string>uuid_list_;
         std::vector<uint64_t> counters;
         int coverage_srv_fd;
 

From 6d1b644930d2c89ce967bcecc7fa4af0290e8fcd Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Mon, 14 Aug 2023 15:47:29 +0000
Subject: [PATCH 0330/1487] Drop String::empty()

This method causes confuction and bugs by having the same name, but
different meaning versus std::string::empty().

Bug: 295394788
Test: make checkbuild
Change-Id: I15aadc023b20559930e4ec79f43f7032e8cd90d0
---
 libutils/include/utils/String8.h | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index e58f1a5d1992..ace0243f3314 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -52,8 +52,6 @@ class String8
     explicit                    String8(const char32_t* o, size_t numChars);
                                 ~String8();
 
-    static inline const String8 empty();
-
     static String8              format(const char* fmt, ...) __attribute__((format (printf, 1, 2)));
     static String8              formatV(const char* fmt, va_list args);
 
@@ -240,10 +238,6 @@ inline int strictly_order_type(const String8& lhs, const String8& rhs)
     return compare_type(lhs, rhs) < 0;
 }
 
-inline const String8 String8::empty() {
-    return String8();
-}
-
 inline const char* String8::c_str() const
 {
     return mString;

From 2676893dd89fd7127c34a2f211dd02b5a8d7a647 Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Mon, 14 Aug 2023 17:05:51 +0000
Subject: [PATCH 0331/1487] Implement String8|16::empty and String16::length

This time following std::string::empty meaning.

String16::length is for parity with String8::length and to
follow std::string::length/size duo.

Bug: 295394788
Test: mma
Change-Id: I43df2cbb9ca6f980a4cf6d971064d594d661f884
---
 libutils/include/utils/String16.h | 14 ++++++++++++++
 libutils/include/utils/String8.h  |  6 ++++++
 2 files changed, 20 insertions(+)

diff --git a/libutils/include/utils/String16.h b/libutils/include/utils/String16.h
index d719aeaaa28e..b48b90765612 100644
--- a/libutils/include/utils/String16.h
+++ b/libutils/include/utils/String16.h
@@ -60,6 +60,10 @@ class String16
     static inline std::string   std_string(const String16& str);
 public:
             size_t              size() const;
+    inline  bool                empty() const;
+
+    inline  size_t              length() const;
+
             void                setTo(const String16& other);
             status_t            setTo(const char16_t* other);
             status_t            setTo(const char16_t* other, size_t len);
@@ -250,6 +254,16 @@ inline std::string String16::std_string(const String16& str)
     return std::string(String8(str).c_str());
 }
 
+inline bool String16::empty() const
+{
+    return length() == 0;
+}
+
+inline size_t String16::length() const
+{
+    return size();
+}
+
 inline String16& String16::operator=(const String16& other)
 {
     setTo(other);
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index ace0243f3314..10eef06cd020 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -64,6 +64,7 @@ class String8
 
     inline  size_t              size() const;
     inline  size_t              bytes() const;
+    inline  bool                empty() const;
     inline  bool                isEmpty() const;
 
             size_t              length() const;
@@ -257,6 +258,11 @@ inline size_t String8::size() const
     return length();
 }
 
+inline bool String8::empty() const
+{
+    return length() == 0;
+}
+
 inline bool String8::isEmpty() const
 {
     return length() == 0;

From f59712928233f6abadd888e7d014b6fa4a20e932 Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Mon, 14 Aug 2023 18:18:26 +0000
Subject: [PATCH 0332/1487] Migrate from android::String isEmpty to empty

This empty method is different from the old one - it aligns with
std::string definition.

Bug: 295394788
Test: make checkbuild
Change-Id: Id6baed8cde01a75a8839ad6b4475a31ba1f49c8a
---
 healthd/BatteryMonitor.cpp    | 142 +++++++++++++++++-----------------
 healthd/BatteryMonitor_v1.cpp | 100 ++++++++++++------------
 libutils/String8_fuzz.cpp     |   2 +-
 3 files changed, 122 insertions(+), 122 deletions(-)

diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index 15c30be412f8..e4cf582fbdcf 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -361,7 +361,7 @@ static bool isScopedPowerSupply(const char* name) {
 void BatteryMonitor::updateValues(void) {
     initHealthInfo(mHealthInfo.get());
 
-    if (!mHealthdConfig->batteryPresentPath.isEmpty())
+    if (!mHealthdConfig->batteryPresentPath.empty())
         mHealthInfo->batteryPresent = getBooleanField(mHealthdConfig->batteryPresentPath);
     else
         mHealthInfo->batteryPresent = mBatteryDevicePresent;
@@ -371,43 +371,43 @@ void BatteryMonitor::updateValues(void) {
                                         : getIntField(mHealthdConfig->batteryCapacityPath);
     mHealthInfo->batteryVoltageMillivolts = getIntField(mHealthdConfig->batteryVoltagePath) / 1000;
 
-    if (!mHealthdConfig->batteryCurrentNowPath.isEmpty())
+    if (!mHealthdConfig->batteryCurrentNowPath.empty())
         mHealthInfo->batteryCurrentMicroamps = getIntField(mHealthdConfig->batteryCurrentNowPath);
 
-    if (!mHealthdConfig->batteryFullChargePath.isEmpty())
+    if (!mHealthdConfig->batteryFullChargePath.empty())
         mHealthInfo->batteryFullChargeUah = getIntField(mHealthdConfig->batteryFullChargePath);
 
-    if (!mHealthdConfig->batteryCycleCountPath.isEmpty())
+    if (!mHealthdConfig->batteryCycleCountPath.empty())
         mHealthInfo->batteryCycleCount = getIntField(mHealthdConfig->batteryCycleCountPath);
 
-    if (!mHealthdConfig->batteryChargeCounterPath.isEmpty())
+    if (!mHealthdConfig->batteryChargeCounterPath.empty())
         mHealthInfo->batteryChargeCounterUah =
                 getIntField(mHealthdConfig->batteryChargeCounterPath);
 
-    if (!mHealthdConfig->batteryCurrentAvgPath.isEmpty())
+    if (!mHealthdConfig->batteryCurrentAvgPath.empty())
         mHealthInfo->batteryCurrentAverageMicroamps =
                 getIntField(mHealthdConfig->batteryCurrentAvgPath);
 
-    if (!mHealthdConfig->batteryChargeTimeToFullNowPath.isEmpty())
+    if (!mHealthdConfig->batteryChargeTimeToFullNowPath.empty())
         mHealthInfo->batteryChargeTimeToFullNowSeconds =
                 getIntField(mHealthdConfig->batteryChargeTimeToFullNowPath);
 
-    if (!mHealthdConfig->batteryFullChargeDesignCapacityUahPath.isEmpty())
+    if (!mHealthdConfig->batteryFullChargeDesignCapacityUahPath.empty())
         mHealthInfo->batteryFullChargeDesignCapacityUah =
                 getIntField(mHealthdConfig->batteryFullChargeDesignCapacityUahPath);
 
-    if (!mHealthdConfig->batteryHealthStatusPath.isEmpty())
+    if (!mHealthdConfig->batteryHealthStatusPath.empty())
         mBatteryHealthStatus = getIntField(mHealthdConfig->batteryHealthStatusPath);
 
-    if (!mHealthdConfig->batteryStateOfHealthPath.isEmpty())
+    if (!mHealthdConfig->batteryStateOfHealthPath.empty())
         mHealthInfo->batteryHealthData->batteryStateOfHealth =
                 getIntField(mHealthdConfig->batteryStateOfHealthPath);
 
-    if (!mHealthdConfig->batteryManufacturingDatePath.isEmpty())
+    if (!mHealthdConfig->batteryManufacturingDatePath.empty())
         mHealthInfo->batteryHealthData->batteryManufacturingDateSeconds =
                 getIntField(mHealthdConfig->batteryManufacturingDatePath);
 
-    if (!mHealthdConfig->batteryFirstUsageDatePath.isEmpty())
+    if (!mHealthdConfig->batteryFirstUsageDatePath.empty())
         mHealthInfo->batteryHealthData->batteryFirstUsageSeconds =
                 getIntField(mHealthdConfig->batteryFirstUsageDatePath);
 
@@ -506,17 +506,17 @@ static void doLogValues(const HealthInfo& props, const struct healthd_config& he
                  props.batteryStatus);
 
         len = strlen(dmesgline);
-        if (!healthd_config.batteryCurrentNowPath.isEmpty()) {
+        if (!healthd_config.batteryCurrentNowPath.empty()) {
             len += snprintf(dmesgline + len, sizeof(dmesgline) - len, " c=%d",
                             props.batteryCurrentMicroamps);
         }
 
-        if (!healthd_config.batteryFullChargePath.isEmpty()) {
+        if (!healthd_config.batteryFullChargePath.empty()) {
             len += snprintf(dmesgline + len, sizeof(dmesgline) - len, " fc=%d",
                             props.batteryFullChargeUah);
         }
 
-        if (!healthd_config.batteryCycleCountPath.isEmpty()) {
+        if (!healthd_config.batteryCycleCountPath.empty()) {
             len += snprintf(dmesgline + len, sizeof(dmesgline) - len, " cc=%d",
                             props.batteryCycleCount);
         }
@@ -550,7 +550,7 @@ bool BatteryMonitor::isChargerOnline() {
 
 int BatteryMonitor::getChargeStatus() {
     BatteryStatus result = BatteryStatus::UNKNOWN;
-    if (!mHealthdConfig->batteryStatusPath.isEmpty()) {
+    if (!mHealthdConfig->batteryStatusPath.empty()) {
         std::string buf;
         if (readFromFile(mHealthdConfig->batteryStatusPath, &buf) > 0)
             result = getBatteryStatus(buf.c_str());
@@ -561,7 +561,7 @@ int BatteryMonitor::getChargeStatus() {
 status_t BatteryMonitor::setChargingPolicy(int value) {
     status_t ret = NAME_NOT_FOUND;
     bool result;
-    if (!mHealthdConfig->chargingPolicyPath.isEmpty()) {
+    if (!mHealthdConfig->chargingPolicyPath.empty()) {
         result = writeToFile(mHealthdConfig->chargingPolicyPath, value);
         if (!result) {
             KLOG_WARNING(LOG_TAG, "setChargingPolicy fail\n");
@@ -575,7 +575,7 @@ status_t BatteryMonitor::setChargingPolicy(int value) {
 
 int BatteryMonitor::getChargingPolicy() {
     BatteryChargingPolicy result = BatteryChargingPolicy::DEFAULT;
-    if (!mHealthdConfig->chargingPolicyPath.isEmpty()) {
+    if (!mHealthdConfig->chargingPolicyPath.empty()) {
         std::string buf;
         if (readFromFile(mHealthdConfig->chargingPolicyPath, &buf) > 0)
             result = getBatteryChargingPolicy(buf.c_str());
@@ -585,15 +585,15 @@ int BatteryMonitor::getChargingPolicy() {
 
 int BatteryMonitor::getBatteryHealthData(int id) {
     if (id == BATTERY_PROP_MANUFACTURING_DATE) {
-        if (!mHealthdConfig->batteryManufacturingDatePath.isEmpty())
+        if (!mHealthdConfig->batteryManufacturingDatePath.empty())
             return getIntField(mHealthdConfig->batteryManufacturingDatePath);
     }
     if (id == BATTERY_PROP_FIRST_USAGE_DATE) {
-        if (!mHealthdConfig->batteryFirstUsageDatePath.isEmpty())
+        if (!mHealthdConfig->batteryFirstUsageDatePath.empty())
             return getIntField(mHealthdConfig->batteryFirstUsageDatePath);
     }
     if (id == BATTERY_PROP_STATE_OF_HEALTH) {
-        if (!mHealthdConfig->batteryStateOfHealthPath.isEmpty())
+        if (!mHealthdConfig->batteryStateOfHealthPath.empty())
             return getIntField(mHealthdConfig->batteryStateOfHealthPath);
     }
     return 0;
@@ -607,7 +607,7 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
 
     switch(id) {
     case BATTERY_PROP_CHARGE_COUNTER:
-        if (!mHealthdConfig->batteryChargeCounterPath.isEmpty()) {
+        if (!mHealthdConfig->batteryChargeCounterPath.empty()) {
             val->valueInt64 =
                 getIntField(mHealthdConfig->batteryChargeCounterPath);
             ret = OK;
@@ -617,7 +617,7 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
         break;
 
     case BATTERY_PROP_CURRENT_NOW:
-        if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
+        if (!mHealthdConfig->batteryCurrentNowPath.empty()) {
             val->valueInt64 =
                 getIntField(mHealthdConfig->batteryCurrentNowPath);
             ret = OK;
@@ -627,7 +627,7 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
         break;
 
     case BATTERY_PROP_CURRENT_AVG:
-        if (!mHealthdConfig->batteryCurrentAvgPath.isEmpty()) {
+        if (!mHealthdConfig->batteryCurrentAvgPath.empty()) {
             val->valueInt64 =
                 getIntField(mHealthdConfig->batteryCurrentAvgPath);
             ret = OK;
@@ -637,7 +637,7 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
         break;
 
     case BATTERY_PROP_CAPACITY:
-        if (!mHealthdConfig->batteryCapacityPath.isEmpty()) {
+        if (!mHealthdConfig->batteryCapacityPath.empty()) {
             val->valueInt64 =
                 getIntField(mHealthdConfig->batteryCapacityPath);
             ret = OK;
@@ -704,35 +704,35 @@ void BatteryMonitor::dumpState(int fd) {
              props.batteryVoltageMillivolts, props.batteryTemperatureTenthsCelsius);
     write(fd, vs, strlen(vs));
 
-    if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
+    if (!mHealthdConfig->batteryCurrentNowPath.empty()) {
         v = getIntField(mHealthdConfig->batteryCurrentNowPath);
         snprintf(vs, sizeof(vs), "current now: %d\n", v);
         write(fd, vs, strlen(vs));
     }
 
-    if (!mHealthdConfig->batteryCurrentAvgPath.isEmpty()) {
+    if (!mHealthdConfig->batteryCurrentAvgPath.empty()) {
         v = getIntField(mHealthdConfig->batteryCurrentAvgPath);
         snprintf(vs, sizeof(vs), "current avg: %d\n", v);
         write(fd, vs, strlen(vs));
     }
 
-    if (!mHealthdConfig->batteryChargeCounterPath.isEmpty()) {
+    if (!mHealthdConfig->batteryChargeCounterPath.empty()) {
         v = getIntField(mHealthdConfig->batteryChargeCounterPath);
         snprintf(vs, sizeof(vs), "charge counter: %d\n", v);
         write(fd, vs, strlen(vs));
     }
 
-    if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
+    if (!mHealthdConfig->batteryCurrentNowPath.empty()) {
         snprintf(vs, sizeof(vs), "current now: %d\n", props.batteryCurrentMicroamps);
         write(fd, vs, strlen(vs));
     }
 
-    if (!mHealthdConfig->batteryCycleCountPath.isEmpty()) {
+    if (!mHealthdConfig->batteryCycleCountPath.empty()) {
         snprintf(vs, sizeof(vs), "cycle count: %d\n", props.batteryCycleCount);
         write(fd, vs, strlen(vs));
     }
 
-    if (!mHealthdConfig->batteryFullChargePath.isEmpty()) {
+    if (!mHealthdConfig->batteryFullChargePath.empty()) {
         snprintf(vs, sizeof(vs), "Full charge: %d\n", props.batteryFullChargeUah);
         write(fd, vs, strlen(vs));
     }
@@ -782,7 +782,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                 if (isScopedPowerSupply(name)) continue;
                 mBatteryDevicePresent = true;
 
-                if (mHealthdConfig->batteryStatusPath.isEmpty()) {
+                if (mHealthdConfig->batteryStatusPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/status", POWER_SUPPLY_SYSFS_PATH,
                                       name);
@@ -790,7 +790,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryStatusPath = path;
                 }
 
-                if (mHealthdConfig->batteryHealthPath.isEmpty()) {
+                if (mHealthdConfig->batteryHealthPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/health", POWER_SUPPLY_SYSFS_PATH,
                                       name);
@@ -798,7 +798,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryHealthPath = path;
                 }
 
-                if (mHealthdConfig->batteryPresentPath.isEmpty()) {
+                if (mHealthdConfig->batteryPresentPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/present", POWER_SUPPLY_SYSFS_PATH,
                                       name);
@@ -806,7 +806,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryPresentPath = path;
                 }
 
-                if (mHealthdConfig->batteryCapacityPath.isEmpty()) {
+                if (mHealthdConfig->batteryCapacityPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/capacity", POWER_SUPPLY_SYSFS_PATH,
                                       name);
@@ -814,7 +814,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryCapacityPath = path;
                 }
 
-                if (mHealthdConfig->batteryVoltagePath.isEmpty()) {
+                if (mHealthdConfig->batteryVoltagePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/voltage_now",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -823,7 +823,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     }
                 }
 
-                if (mHealthdConfig->batteryFullChargePath.isEmpty()) {
+                if (mHealthdConfig->batteryFullChargePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/charge_full",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -831,7 +831,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryFullChargePath = path;
                 }
 
-                if (mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
+                if (mHealthdConfig->batteryCurrentNowPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/current_now",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -839,7 +839,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryCurrentNowPath = path;
                 }
 
-                if (mHealthdConfig->batteryCycleCountPath.isEmpty()) {
+                if (mHealthdConfig->batteryCycleCountPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/cycle_count",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -847,27 +847,27 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryCycleCountPath = path;
                 }
 
-                if (mHealthdConfig->batteryCapacityLevelPath.isEmpty()) {
+                if (mHealthdConfig->batteryCapacityLevelPath.empty()) {
                     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()) {
+                if (mHealthdConfig->batteryChargeTimeToFullNowPath.empty()) {
                     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->batteryFullChargeDesignCapacityUahPath.isEmpty()) {
+                if (mHealthdConfig->batteryFullChargeDesignCapacityUahPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/charge_full_design", POWER_SUPPLY_SYSFS_PATH, name);
                     if (access(path, R_OK) == 0)
                         mHealthdConfig->batteryFullChargeDesignCapacityUahPath = path;
                 }
 
-                if (mHealthdConfig->batteryCurrentAvgPath.isEmpty()) {
+                if (mHealthdConfig->batteryCurrentAvgPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/current_avg",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -875,7 +875,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryCurrentAvgPath = path;
                 }
 
-                if (mHealthdConfig->batteryChargeCounterPath.isEmpty()) {
+                if (mHealthdConfig->batteryChargeCounterPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/charge_counter",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -883,7 +883,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryChargeCounterPath = path;
                 }
 
-                if (mHealthdConfig->batteryTemperaturePath.isEmpty()) {
+                if (mHealthdConfig->batteryTemperaturePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/temp", POWER_SUPPLY_SYSFS_PATH,
                                       name);
@@ -892,7 +892,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     }
                 }
 
-                if (mHealthdConfig->batteryTechnologyPath.isEmpty()) {
+                if (mHealthdConfig->batteryTechnologyPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/technology",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -900,7 +900,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryTechnologyPath = path;
                 }
 
-                if (mHealthdConfig->batteryStateOfHealthPath.isEmpty()) {
+                if (mHealthdConfig->batteryStateOfHealthPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/state_of_health", POWER_SUPPLY_SYSFS_PATH, name);
                     if (access(path, R_OK) == 0) {
@@ -913,32 +913,32 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     }
                 }
 
-                if (mHealthdConfig->batteryHealthStatusPath.isEmpty()) {
+                if (mHealthdConfig->batteryHealthStatusPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/health_status", POWER_SUPPLY_SYSFS_PATH, name);
                     if (access(path, R_OK) == 0) mHealthdConfig->batteryHealthStatusPath = path;
                 }
 
-                if (mHealthdConfig->batteryManufacturingDatePath.isEmpty()) {
+                if (mHealthdConfig->batteryManufacturingDatePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/manufacturing_date", POWER_SUPPLY_SYSFS_PATH, name);
                     if (access(path, R_OK) == 0)
                         mHealthdConfig->batteryManufacturingDatePath = path;
                 }
 
-                if (mHealthdConfig->batteryFirstUsageDatePath.isEmpty()) {
+                if (mHealthdConfig->batteryFirstUsageDatePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/first_usage_date", POWER_SUPPLY_SYSFS_PATH, name);
                     if (access(path, R_OK) == 0) mHealthdConfig->batteryFirstUsageDatePath = path;
                 }
 
-                if (mHealthdConfig->chargingStatePath.isEmpty()) {
+                if (mHealthdConfig->chargingStatePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/charging_state", POWER_SUPPLY_SYSFS_PATH, name);
                     if (access(path, R_OK) == 0) mHealthdConfig->chargingStatePath = path;
                 }
 
-                if (mHealthdConfig->chargingPolicyPath.isEmpty()) {
+                if (mHealthdConfig->chargingPolicyPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/charging_policy", POWER_SUPPLY_SYSFS_PATH, name);
                     if (access(path, R_OK) == 0) mHealthdConfig->chargingPolicyPath = path;
@@ -968,43 +968,43 @@ void BatteryMonitor::init(struct healthd_config *hc) {
         hc->periodic_chores_interval_fast = -1;
         hc->periodic_chores_interval_slow = -1;
     } else {
-        if (mHealthdConfig->batteryStatusPath.isEmpty())
+        if (mHealthdConfig->batteryStatusPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryStatusPath not found\n");
-        if (mHealthdConfig->batteryHealthPath.isEmpty())
+        if (mHealthdConfig->batteryHealthPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryHealthPath not found\n");
-        if (mHealthdConfig->batteryPresentPath.isEmpty())
+        if (mHealthdConfig->batteryPresentPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryPresentPath not found\n");
-        if (mHealthdConfig->batteryCapacityPath.isEmpty())
+        if (mHealthdConfig->batteryCapacityPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryCapacityPath not found\n");
-        if (mHealthdConfig->batteryVoltagePath.isEmpty())
+        if (mHealthdConfig->batteryVoltagePath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryVoltagePath not found\n");
-        if (mHealthdConfig->batteryTemperaturePath.isEmpty())
+        if (mHealthdConfig->batteryTemperaturePath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryTemperaturePath not found\n");
-        if (mHealthdConfig->batteryTechnologyPath.isEmpty())
+        if (mHealthdConfig->batteryTechnologyPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryTechnologyPath not found\n");
-        if (mHealthdConfig->batteryCurrentNowPath.isEmpty())
+        if (mHealthdConfig->batteryCurrentNowPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryCurrentNowPath not found\n");
-        if (mHealthdConfig->batteryFullChargePath.isEmpty())
+        if (mHealthdConfig->batteryFullChargePath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryFullChargePath not found\n");
-        if (mHealthdConfig->batteryCycleCountPath.isEmpty())
+        if (mHealthdConfig->batteryCycleCountPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryCycleCountPath not found\n");
-        if (mHealthdConfig->batteryCapacityLevelPath.isEmpty())
+        if (mHealthdConfig->batteryCapacityLevelPath.empty())
             KLOG_WARNING(LOG_TAG, "batteryCapacityLevelPath not found\n");
-        if (mHealthdConfig->batteryChargeTimeToFullNowPath.isEmpty())
+        if (mHealthdConfig->batteryChargeTimeToFullNowPath.empty())
             KLOG_WARNING(LOG_TAG, "batteryChargeTimeToFullNowPath. not found\n");
-        if (mHealthdConfig->batteryFullChargeDesignCapacityUahPath.isEmpty())
+        if (mHealthdConfig->batteryFullChargeDesignCapacityUahPath.empty())
             KLOG_WARNING(LOG_TAG, "batteryFullChargeDesignCapacityUahPath. not found\n");
-        if (mHealthdConfig->batteryStateOfHealthPath.isEmpty())
+        if (mHealthdConfig->batteryStateOfHealthPath.empty())
             KLOG_WARNING(LOG_TAG, "batteryStateOfHealthPath not found\n");
-        if (mHealthdConfig->batteryHealthStatusPath.isEmpty())
+        if (mHealthdConfig->batteryHealthStatusPath.empty())
             KLOG_WARNING(LOG_TAG, "batteryHealthStatusPath not found\n");
-        if (mHealthdConfig->batteryManufacturingDatePath.isEmpty())
+        if (mHealthdConfig->batteryManufacturingDatePath.empty())
             KLOG_WARNING(LOG_TAG, "batteryManufacturingDatePath not found\n");
-        if (mHealthdConfig->batteryFirstUsageDatePath.isEmpty())
+        if (mHealthdConfig->batteryFirstUsageDatePath.empty())
             KLOG_WARNING(LOG_TAG, "batteryFirstUsageDatePath not found\n");
-        if (mHealthdConfig->chargingStatePath.isEmpty())
+        if (mHealthdConfig->chargingStatePath.empty())
             KLOG_WARNING(LOG_TAG, "chargingStatePath not found\n");
-        if (mHealthdConfig->chargingPolicyPath.isEmpty())
+        if (mHealthdConfig->chargingPolicyPath.empty())
             KLOG_WARNING(LOG_TAG, "chargingPolicyPath not found\n");
     }
 
diff --git a/healthd/BatteryMonitor_v1.cpp b/healthd/BatteryMonitor_v1.cpp
index b2d6518f7a29..686c338cc10e 100644
--- a/healthd/BatteryMonitor_v1.cpp
+++ b/healthd/BatteryMonitor_v1.cpp
@@ -301,7 +301,7 @@ static bool isScopedPowerSupply(const char* name) {
 void BatteryMonitor::updateValues(void) {
     initHealthInfo(mHealthInfo.get());
 
-    if (!mHealthdConfig->batteryPresentPath.isEmpty())
+    if (!mHealthdConfig->batteryPresentPath.empty())
         mHealthInfo->batteryPresent = getBooleanField(mHealthdConfig->batteryPresentPath);
     else
         mHealthInfo->batteryPresent = mBatteryDevicePresent;
@@ -311,28 +311,28 @@ void BatteryMonitor::updateValues(void) {
                                         : getIntField(mHealthdConfig->batteryCapacityPath);
     mHealthInfo->batteryVoltageMillivolts = getIntField(mHealthdConfig->batteryVoltagePath) / 1000;
 
-    if (!mHealthdConfig->batteryCurrentNowPath.isEmpty())
+    if (!mHealthdConfig->batteryCurrentNowPath.empty())
         mHealthInfo->batteryCurrentMicroamps = getIntField(mHealthdConfig->batteryCurrentNowPath);
 
-    if (!mHealthdConfig->batteryFullChargePath.isEmpty())
+    if (!mHealthdConfig->batteryFullChargePath.empty())
         mHealthInfo->batteryFullChargeUah = getIntField(mHealthdConfig->batteryFullChargePath);
 
-    if (!mHealthdConfig->batteryCycleCountPath.isEmpty())
+    if (!mHealthdConfig->batteryCycleCountPath.empty())
         mHealthInfo->batteryCycleCount = getIntField(mHealthdConfig->batteryCycleCountPath);
 
-    if (!mHealthdConfig->batteryChargeCounterPath.isEmpty())
+    if (!mHealthdConfig->batteryChargeCounterPath.empty())
         mHealthInfo->batteryChargeCounterUah =
                 getIntField(mHealthdConfig->batteryChargeCounterPath);
 
-    if (!mHealthdConfig->batteryCurrentAvgPath.isEmpty())
+    if (!mHealthdConfig->batteryCurrentAvgPath.empty())
         mHealthInfo->batteryCurrentAverageMicroamps =
                 getIntField(mHealthdConfig->batteryCurrentAvgPath);
 
-    if (!mHealthdConfig->batteryChargeTimeToFullNowPath.isEmpty())
+    if (!mHealthdConfig->batteryChargeTimeToFullNowPath.empty())
         mHealthInfo->batteryChargeTimeToFullNowSeconds =
                 getIntField(mHealthdConfig->batteryChargeTimeToFullNowPath);
 
-    if (!mHealthdConfig->batteryFullChargeDesignCapacityUahPath.isEmpty())
+    if (!mHealthdConfig->batteryFullChargeDesignCapacityUahPath.empty())
         mHealthInfo->batteryFullChargeDesignCapacityUah =
                 getIntField(mHealthdConfig->batteryFullChargeDesignCapacityUahPath);
 
@@ -420,17 +420,17 @@ static void doLogValues(const HealthInfo& props, const struct healthd_config& he
                  props.batteryStatus);
 
         len = strlen(dmesgline);
-        if (!healthd_config.batteryCurrentNowPath.isEmpty()) {
+        if (!healthd_config.batteryCurrentNowPath.empty()) {
             len += snprintf(dmesgline + len, sizeof(dmesgline) - len, " c=%d",
                             props.batteryCurrentMicroamps);
         }
 
-        if (!healthd_config.batteryFullChargePath.isEmpty()) {
+        if (!healthd_config.batteryFullChargePath.empty()) {
             len += snprintf(dmesgline + len, sizeof(dmesgline) - len, " fc=%d",
                             props.batteryFullChargeUah);
         }
 
-        if (!healthd_config.batteryCycleCountPath.isEmpty()) {
+        if (!healthd_config.batteryCycleCountPath.empty()) {
             len += snprintf(dmesgline + len, sizeof(dmesgline) - len, " cc=%d",
                             props.batteryCycleCount);
         }
@@ -464,7 +464,7 @@ bool BatteryMonitor::isChargerOnline() {
 
 int BatteryMonitor::getChargeStatus() {
     BatteryStatus result = BatteryStatus::UNKNOWN;
-    if (!mHealthdConfig->batteryStatusPath.isEmpty()) {
+    if (!mHealthdConfig->batteryStatusPath.empty()) {
         std::string buf;
         if (readFromFile(mHealthdConfig->batteryStatusPath, &buf) > 0)
             result = getBatteryStatus(buf.c_str());
@@ -480,7 +480,7 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
 
     switch(id) {
     case BATTERY_PROP_CHARGE_COUNTER:
-        if (!mHealthdConfig->batteryChargeCounterPath.isEmpty()) {
+        if (!mHealthdConfig->batteryChargeCounterPath.empty()) {
             val->valueInt64 =
                 getIntField(mHealthdConfig->batteryChargeCounterPath);
             ret = OK;
@@ -490,7 +490,7 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
         break;
 
     case BATTERY_PROP_CURRENT_NOW:
-        if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
+        if (!mHealthdConfig->batteryCurrentNowPath.empty()) {
             val->valueInt64 =
                 getIntField(mHealthdConfig->batteryCurrentNowPath);
             ret = OK;
@@ -500,7 +500,7 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
         break;
 
     case BATTERY_PROP_CURRENT_AVG:
-        if (!mHealthdConfig->batteryCurrentAvgPath.isEmpty()) {
+        if (!mHealthdConfig->batteryCurrentAvgPath.empty()) {
             val->valueInt64 =
                 getIntField(mHealthdConfig->batteryCurrentAvgPath);
             ret = OK;
@@ -510,7 +510,7 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
         break;
 
     case BATTERY_PROP_CAPACITY:
-        if (!mHealthdConfig->batteryCapacityPath.isEmpty()) {
+        if (!mHealthdConfig->batteryCapacityPath.empty()) {
             val->valueInt64 =
                 getIntField(mHealthdConfig->batteryCapacityPath);
             ret = OK;
@@ -557,35 +557,35 @@ void BatteryMonitor::dumpState(int fd) {
              props.batteryVoltageMillivolts, props.batteryTemperatureTenthsCelsius);
     write(fd, vs, strlen(vs));
 
-    if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
+    if (!mHealthdConfig->batteryCurrentNowPath.empty()) {
         v = getIntField(mHealthdConfig->batteryCurrentNowPath);
         snprintf(vs, sizeof(vs), "current now: %d\n", v);
         write(fd, vs, strlen(vs));
     }
 
-    if (!mHealthdConfig->batteryCurrentAvgPath.isEmpty()) {
+    if (!mHealthdConfig->batteryCurrentAvgPath.empty()) {
         v = getIntField(mHealthdConfig->batteryCurrentAvgPath);
         snprintf(vs, sizeof(vs), "current avg: %d\n", v);
         write(fd, vs, strlen(vs));
     }
 
-    if (!mHealthdConfig->batteryChargeCounterPath.isEmpty()) {
+    if (!mHealthdConfig->batteryChargeCounterPath.empty()) {
         v = getIntField(mHealthdConfig->batteryChargeCounterPath);
         snprintf(vs, sizeof(vs), "charge counter: %d\n", v);
         write(fd, vs, strlen(vs));
     }
 
-    if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
+    if (!mHealthdConfig->batteryCurrentNowPath.empty()) {
         snprintf(vs, sizeof(vs), "current now: %d\n", props.batteryCurrentMicroamps);
         write(fd, vs, strlen(vs));
     }
 
-    if (!mHealthdConfig->batteryCycleCountPath.isEmpty()) {
+    if (!mHealthdConfig->batteryCycleCountPath.empty()) {
         snprintf(vs, sizeof(vs), "cycle count: %d\n", props.batteryCycleCount);
         write(fd, vs, strlen(vs));
     }
 
-    if (!mHealthdConfig->batteryFullChargePath.isEmpty()) {
+    if (!mHealthdConfig->batteryFullChargePath.empty()) {
         snprintf(vs, sizeof(vs), "Full charge: %d\n", props.batteryFullChargeUah);
         write(fd, vs, strlen(vs));
     }
@@ -635,7 +635,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                 if (isScopedPowerSupply(name)) continue;
                 mBatteryDevicePresent = true;
 
-                if (mHealthdConfig->batteryStatusPath.isEmpty()) {
+                if (mHealthdConfig->batteryStatusPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/status", POWER_SUPPLY_SYSFS_PATH,
                                       name);
@@ -643,7 +643,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryStatusPath = path;
                 }
 
-                if (mHealthdConfig->batteryHealthPath.isEmpty()) {
+                if (mHealthdConfig->batteryHealthPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/health", POWER_SUPPLY_SYSFS_PATH,
                                       name);
@@ -651,7 +651,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryHealthPath = path;
                 }
 
-                if (mHealthdConfig->batteryPresentPath.isEmpty()) {
+                if (mHealthdConfig->batteryPresentPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/present", POWER_SUPPLY_SYSFS_PATH,
                                       name);
@@ -659,7 +659,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryPresentPath = path;
                 }
 
-                if (mHealthdConfig->batteryCapacityPath.isEmpty()) {
+                if (mHealthdConfig->batteryCapacityPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/capacity", POWER_SUPPLY_SYSFS_PATH,
                                       name);
@@ -667,7 +667,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryCapacityPath = path;
                 }
 
-                if (mHealthdConfig->batteryVoltagePath.isEmpty()) {
+                if (mHealthdConfig->batteryVoltagePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/voltage_now",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -676,7 +676,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     }
                 }
 
-                if (mHealthdConfig->batteryFullChargePath.isEmpty()) {
+                if (mHealthdConfig->batteryFullChargePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/charge_full",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -684,7 +684,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryFullChargePath = path;
                 }
 
-                if (mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
+                if (mHealthdConfig->batteryCurrentNowPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/current_now",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -692,7 +692,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryCurrentNowPath = path;
                 }
 
-                if (mHealthdConfig->batteryCycleCountPath.isEmpty()) {
+                if (mHealthdConfig->batteryCycleCountPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/cycle_count",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -700,27 +700,27 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryCycleCountPath = path;
                 }
 
-                if (mHealthdConfig->batteryCapacityLevelPath.isEmpty()) {
+                if (mHealthdConfig->batteryCapacityLevelPath.empty()) {
                     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()) {
+                if (mHealthdConfig->batteryChargeTimeToFullNowPath.empty()) {
                     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->batteryFullChargeDesignCapacityUahPath.isEmpty()) {
+                if (mHealthdConfig->batteryFullChargeDesignCapacityUahPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/charge_full_design", POWER_SUPPLY_SYSFS_PATH, name);
                     if (access(path, R_OK) == 0)
                         mHealthdConfig->batteryFullChargeDesignCapacityUahPath = path;
                 }
 
-                if (mHealthdConfig->batteryCurrentAvgPath.isEmpty()) {
+                if (mHealthdConfig->batteryCurrentAvgPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/current_avg",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -728,7 +728,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryCurrentAvgPath = path;
                 }
 
-                if (mHealthdConfig->batteryChargeCounterPath.isEmpty()) {
+                if (mHealthdConfig->batteryChargeCounterPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/charge_counter",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -736,7 +736,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                         mHealthdConfig->batteryChargeCounterPath = path;
                 }
 
-                if (mHealthdConfig->batteryTemperaturePath.isEmpty()) {
+                if (mHealthdConfig->batteryTemperaturePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/temp", POWER_SUPPLY_SYSFS_PATH,
                                       name);
@@ -745,7 +745,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     }
                 }
 
-                if (mHealthdConfig->batteryTechnologyPath.isEmpty()) {
+                if (mHealthdConfig->batteryTechnologyPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/technology",
                                       POWER_SUPPLY_SYSFS_PATH, name);
@@ -777,31 +777,31 @@ void BatteryMonitor::init(struct healthd_config *hc) {
         hc->periodic_chores_interval_fast = -1;
         hc->periodic_chores_interval_slow = -1;
     } else {
-        if (mHealthdConfig->batteryStatusPath.isEmpty())
+        if (mHealthdConfig->batteryStatusPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryStatusPath not found\n");
-        if (mHealthdConfig->batteryHealthPath.isEmpty())
+        if (mHealthdConfig->batteryHealthPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryHealthPath not found\n");
-        if (mHealthdConfig->batteryPresentPath.isEmpty())
+        if (mHealthdConfig->batteryPresentPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryPresentPath not found\n");
-        if (mHealthdConfig->batteryCapacityPath.isEmpty())
+        if (mHealthdConfig->batteryCapacityPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryCapacityPath not found\n");
-        if (mHealthdConfig->batteryVoltagePath.isEmpty())
+        if (mHealthdConfig->batteryVoltagePath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryVoltagePath not found\n");
-        if (mHealthdConfig->batteryTemperaturePath.isEmpty())
+        if (mHealthdConfig->batteryTemperaturePath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryTemperaturePath not found\n");
-        if (mHealthdConfig->batteryTechnologyPath.isEmpty())
+        if (mHealthdConfig->batteryTechnologyPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryTechnologyPath not found\n");
-        if (mHealthdConfig->batteryCurrentNowPath.isEmpty())
+        if (mHealthdConfig->batteryCurrentNowPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryCurrentNowPath not found\n");
-        if (mHealthdConfig->batteryFullChargePath.isEmpty())
+        if (mHealthdConfig->batteryFullChargePath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryFullChargePath not found\n");
-        if (mHealthdConfig->batteryCycleCountPath.isEmpty())
+        if (mHealthdConfig->batteryCycleCountPath.empty())
             KLOG_WARNING(LOG_TAG, "BatteryCycleCountPath not found\n");
-        if (mHealthdConfig->batteryCapacityLevelPath.isEmpty())
+        if (mHealthdConfig->batteryCapacityLevelPath.empty())
             KLOG_WARNING(LOG_TAG, "batteryCapacityLevelPath not found\n");
-        if (mHealthdConfig->batteryChargeTimeToFullNowPath.isEmpty())
+        if (mHealthdConfig->batteryChargeTimeToFullNowPath.empty())
             KLOG_WARNING(LOG_TAG, "batteryChargeTimeToFullNowPath. not found\n");
-        if (mHealthdConfig->batteryFullChargeDesignCapacityUahPath.isEmpty())
+        if (mHealthdConfig->batteryFullChargeDesignCapacityUahPath.empty())
             KLOG_WARNING(LOG_TAG, "batteryFullChargeDesignCapacityUahPath. not found\n");
     }
 
diff --git a/libutils/String8_fuzz.cpp b/libutils/String8_fuzz.cpp
index e5dcd316ecb0..09dcacd8afc2 100644
--- a/libutils/String8_fuzz.cpp
+++ b/libutils/String8_fuzz.cpp
@@ -34,7 +34,7 @@ std::vector<std::function<void(FuzzedDataProvider*, android::String8*, android::
                     str1->bytes();
                 },
                 [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->isEmpty();
+                    str1->empty();
                 },
                 [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
                     str1->length();

From d479afa0372598d1417fbd4ba7cd2459df1aed4a Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Fri, 18 Aug 2023 13:13:54 -0700
Subject: [PATCH 0333/1487] Load kernel modules from /lib/modules/`uname
 -r`_$(page_size) if present

To support booting from both 4k/16k kernels, init need to tell which
kernel we are currently booting and load the right modules. To resolve
this issue, we store 16K modules into /lib/modules/`uname -r`_16k
directory.

Test: th
Bug: 293313353
Change-Id: I4a8296384537a71e16cd20e76e6c5dfb9074f574
---
 init/first_stage_init.cpp | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index 88300cb29c36..3239eb7ca203 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -35,6 +35,7 @@
 #include <android-base/chrono_utils.h>
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include <android-base/stringprintf.h>
 #include <modprobe/modprobe.h>
 #include <private/android_filesystem_config.h>
 
@@ -153,6 +154,15 @@ void PrepareSwitchRoot() {
         Copy(snapuserd, dst);
     }
 }
+
+std::string GetPageSizeSuffix() {
+    static const size_t page_size = sysconf(_SC_PAGE_SIZE);
+    if (page_size <= 4096) {
+        return "";
+    }
+    return android::base::StringPrintf("_%zuk", page_size / 1024);
+}
+
 }  // namespace
 
 std::string GetModuleLoadList(BootMode boot_mode, const std::string& dir_path) {
@@ -201,10 +211,18 @@ bool LoadKernelModules(BootMode boot_mode, bool want_console, bool want_parallel
     }
     dirent* entry = nullptr;
     std::vector<std::string> module_dirs;
+    const std::string release_specific_module_dir = uts.release + GetPageSizeSuffix();
     while ((entry = readdir(base_dir.get()))) {
         if (entry->d_type != DT_DIR) {
             continue;
         }
+        if (entry->d_name == release_specific_module_dir) {
+            LOG(INFO) << "Release specific kernel module dir " << release_specific_module_dir
+                      << " found, loading modules from here with no fallbacks.";
+            module_dirs.clear();
+            module_dirs.emplace_back(entry->d_name);
+            break;
+        }
         int dir_major = 0, dir_minor = 0;
         if (sscanf(entry->d_name, "%d.%d", &dir_major, &dir_minor) != 2 || dir_major != major ||
             dir_minor != minor) {
@@ -228,6 +246,7 @@ bool LoadKernelModules(BootMode boot_mode, bool want_console, bool want_parallel
         bool retval = m.LoadListedModules(!want_console);
         modules_loaded = m.GetModuleCount();
         if (modules_loaded > 0) {
+            LOG(INFO) << "Loaded " << modules_loaded << " modules from " << dir_path;
             return retval;
         }
     }
@@ -237,6 +256,7 @@ bool LoadKernelModules(BootMode boot_mode, bool want_console, bool want_parallel
                                   : m.LoadListedModules(!want_console);
     modules_loaded = m.GetModuleCount();
     if (modules_loaded > 0) {
+        LOG(INFO) << "Loaded " << modules_loaded << " modules from " << MODULE_BASE_DIR;
         return retval;
     }
     return true;

From 646e001bb5e232f38a79cc5ac3d9b4ed9c74ac65 Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Mon, 21 Aug 2023 17:34:37 +0900
Subject: [PATCH 0334/1487] init: clean up DelayService()

ServiceList's services_update_finished flag was overlapped with the
global flag: is_default_mount_namespace_ready. Now DelayService() relies
on the is_default_mount_namespace_ready flag.

Add a service description with 'updatable' flag and invoke 'start
<name>' in 'on init' block (which comes before APEX activation).
See the log for "Cannot start an updatable service".

Bug: 293535323
Test: see the comment
Change-Id: I9341ba1a95d9b3b7c6081b530850d61f105f0a56
---
 init/builtins.cpp     | 3 +--
 init/service.cpp      | 4 ++--
 init/service_list.cpp | 7 ++-----
 init/service_list.h   | 9 ++-------
 4 files changed, 7 insertions(+), 16 deletions(-)

diff --git a/init/builtins.cpp b/init/builtins.cpp
index a5b762cbb834..7715424f5162 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -1304,8 +1304,7 @@ static Result<void> do_perform_apex_config(const BuiltinArguments& args) {
     }
 
     if (!bootstrap) {
-        // Now start delayed services
-        ServiceList::GetInstance().MarkServicesUpdate();
+        ServiceList::GetInstance().StartDelayedServices();
     }
     return {};
 }
diff --git a/init/service.cpp b/init/service.cpp
index a0b3478c0b41..5e900ee4d0b0 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -420,7 +420,7 @@ Result<void> Service::ExecStart() {
         }
     });
 
-    if (is_updatable() && !ServiceList::GetInstance().IsServicesUpdated()) {
+    if (is_updatable() && !IsDefaultMountNamespaceReady()) {
         // Don't delay the service for ExecStart() as the semantic is that
         // the caller might depend on the side effect of the execution.
         return Error() << "Cannot start an updatable service '" << name_
@@ -581,7 +581,7 @@ Result<void> Service::Start() {
         }
     });
 
-    if (is_updatable() && !ServiceList::GetInstance().IsServicesUpdated()) {
+    if (is_updatable() && !IsDefaultMountNamespaceReady()) {
         ServiceList::GetInstance().DelayService(*this);
         return Error() << "Cannot start an updatable service '" << name_
                        << "' before configs from APEXes are all loaded. "
diff --git a/init/service_list.cpp b/init/service_list.cpp
index 937d82e20c6b..1c56e8a596c7 100644
--- a/init/service_list.cpp
+++ b/init/service_list.cpp
@@ -76,10 +76,7 @@ bool ServiceList::IsPostData() {
     return post_data_;
 }
 
-void ServiceList::MarkServicesUpdate() {
-    services_update_finished_ = true;
-
-    // start the delayed services
+void ServiceList::StartDelayedServices() {
     for (const auto& name : delayed_service_names_) {
         Service* service = FindService(name);
         if (service == nullptr) {
@@ -94,7 +91,7 @@ void ServiceList::MarkServicesUpdate() {
 }
 
 void ServiceList::DelayService(const Service& service) {
-    if (services_update_finished_) {
+    if (IsDefaultMountNamespaceReady()) {
         LOG(ERROR) << "Cannot delay the start of service '" << service.name()
                    << "' because all services are already updated. Ignoring.";
         return;
diff --git a/init/service_list.h b/init/service_list.h
index f858bc37086f..44e84535cdab 100644
--- a/init/service_list.h
+++ b/init/service_list.h
@@ -85,14 +85,10 @@ class ServiceList {
 
     void MarkPostData();
     bool IsPostData();
-    void MarkServicesUpdate();
-    bool IsServicesUpdated() const { return services_update_finished_; }
     void DelayService(const Service& service);
+    void StartDelayedServices();
 
-    void ResetState() {
-        post_data_ = false;
-        services_update_finished_ = false;
-    }
+    void ResetState() { post_data_ = false; }
 
     auto size() const { return services_.size(); }
 
@@ -100,7 +96,6 @@ class ServiceList {
     std::vector<std::unique_ptr<Service>> services_;
 
     bool post_data_ = false;
-    bool services_update_finished_ = false;
     std::vector<std::string> delayed_service_names_;
 };
 

From d6b65fb307fa38ad44fe4da38497d4f78fcdad7a Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Tue, 22 Aug 2023 09:59:26 +0900
Subject: [PATCH 0335/1487] init: reset errno in do_start

do_start() ignores ENOENT intentionally to avoid logspam. It's
implemented in ErrorIgnoreEnoent. However, without resetting errno,
ErrorIgnoreEnoent will ignore unrelated errors from Service::Start() due
to the sticking errono set from other commands.

Bug: 296821716
Test: launch_cvd
Change-Id: I71d3113bdb69bdca82e2ff4f3a793301749f6c08
---
 init/builtins.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/init/builtins.cpp b/init/builtins.cpp
index 7715424f5162..a70e86683f52 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -746,6 +746,7 @@ static Result<void> do_setrlimit(const BuiltinArguments& args) {
 static Result<void> do_start(const BuiltinArguments& args) {
     Service* svc = ServiceList::GetInstance().FindService(args[1]);
     if (!svc) return Error() << "service " << args[1] << " not found";
+    errno = 0;
     if (auto result = svc->Start(); !result.ok()) {
         return ErrorIgnoreEnoent() << "Could not start service: " << result.error();
     }

From e10d8405a2ec05d5e81dcaa5cdd645a072100989 Mon Sep 17 00:00:00 2001
From: Suren Baghdasaryan <surenb@google.com>
Date: Tue, 25 Jul 2023 14:50:18 -0700
Subject: [PATCH 0336/1487] libprocessgroup: fix reset of file_v2_name

ProfileAttribute::Reset does not reset file_v2_name, fix that. Also
provide ProfileAttribute::file_name() to consolidate the code.

Bug: 292636609
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
(cherry picked from commit 2ffbeaef3a926b0b5fd873136588deb3ec61ef96)
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:72254810d9d63f8267d32d251456a78cd4891698)
Merged-In: I5b33ca47b4fa5cabf582c8804bd13f72f6e58411
Change-Id: I5b33ca47b4fa5cabf582c8804bd13f72f6e58411
---
 libprocessgroup/task_profiles.cpp      | 22 +++++++++++++---------
 libprocessgroup/task_profiles.h        |  8 +++++---
 libprocessgroup/task_profiles_test.cpp |  7 +++----
 3 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 44dba2a16694..59b135013326 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -114,9 +114,16 @@ bool FdCacheHelper::IsAppDependentPath(const std::string& path) {
 
 IProfileAttribute::~IProfileAttribute() = default;
 
-void ProfileAttribute::Reset(const CgroupController& controller, const std::string& file_name) {
+const std::string& ProfileAttribute::file_name() const {
+    if (controller()->version() == 2 && !file_v2_name_.empty()) return file_v2_name_;
+    return file_name_;
+}
+
+void ProfileAttribute::Reset(const CgroupController& controller, const std::string& file_name,
+                             const std::string& file_v2_name) {
     controller_ = controller;
     file_name_ = file_name;
+    file_v2_name_ = file_v2_name;
 }
 
 bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
@@ -129,12 +136,11 @@ bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
         return true;
     }
 
-    const std::string& file_name =
-            controller()->version() == 2 && !file_v2_name_.empty() ? file_v2_name_ : file_name_;
     if (subgroup.empty()) {
-        *path = StringPrintf("%s/%s", controller()->path(), file_name.c_str());
+        *path = StringPrintf("%s/%s", controller()->path(), file_name().c_str());
     } else {
-        *path = StringPrintf("%s/%s/%s", controller()->path(), subgroup.c_str(), file_name.c_str());
+        *path = StringPrintf("%s/%s/%s", controller()->path(), subgroup.c_str(),
+                             file_name().c_str());
     }
     return true;
 }
@@ -144,9 +150,7 @@ bool ProfileAttribute::GetPathForUID(uid_t uid, std::string* path) const {
         return true;
     }
 
-    const std::string& file_name =
-            controller()->version() == 2 && !file_v2_name_.empty() ? file_v2_name_ : file_name_;
-    *path = StringPrintf("%s/uid_%d/%s", controller()->path(), uid, file_name.c_str());
+    *path = StringPrintf("%s/uid_%u/%s", controller()->path(), uid, file_name().c_str());
     return true;
 }
 
@@ -816,7 +820,7 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                 attributes_[name] =
                         std::make_unique<ProfileAttribute>(controller, file_attr, file_v2_attr);
             } else {
-                iter->second->Reset(controller, file_attr);
+                iter->second->Reset(controller, file_attr, file_v2_attr);
             }
         } else {
             LOG(WARNING) << "Controller " << controller_name << " is not found";
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index a62c5b0a9e8c..ac8918e650fc 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -32,7 +32,8 @@
 class IProfileAttribute {
   public:
     virtual ~IProfileAttribute() = 0;
-    virtual void Reset(const CgroupController& controller, const std::string& file_name) = 0;
+    virtual void Reset(const CgroupController& controller, const std::string& file_name,
+                       const std::string& file_v2_name) = 0;
     virtual const CgroupController* controller() const = 0;
     virtual const std::string& file_name() const = 0;
     virtual bool GetPathForTask(int tid, std::string* path) const = 0;
@@ -50,8 +51,9 @@ class ProfileAttribute : public IProfileAttribute {
     ~ProfileAttribute() = default;
 
     const CgroupController* controller() const override { return &controller_; }
-    const std::string& file_name() const override { return file_name_; }
-    void Reset(const CgroupController& controller, const std::string& file_name) override;
+    const std::string& file_name() const override;
+    void Reset(const CgroupController& controller, const std::string& file_name,
+               const std::string& file_v2_name) override;
 
     bool GetPathForTask(int tid, std::string* path) const override;
     bool GetPathForUID(uid_t uid, std::string* path) const override;
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index eadbe7697b07..da74bb012f8f 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -102,7 +102,8 @@ class ProfileAttributeMock : public IProfileAttribute {
   public:
     ProfileAttributeMock(const std::string& file_name) : file_name_(file_name) {}
     ~ProfileAttributeMock() override = default;
-    void Reset(const CgroupController& controller, const std::string& file_name) override {
+    void Reset(const CgroupController& controller, const std::string& file_name,
+               const std::string& file_v2_name) override {
         CHECK(false);
     }
     const CgroupController* controller() const override {
@@ -125,9 +126,7 @@ class ProfileAttributeMock : public IProfileAttribute {
         return true;
     };
 
-    bool GetPathForUID(uid_t, std::string*) const override {
-        return false;
-    }
+    bool GetPathForUID(uid_t, std::string*) const override { return false; }
 
   private:
     const std::string file_name_;

From cfd2e50e2db63e98e18418b1ec63eb9272a7425a Mon Sep 17 00:00:00 2001
From: Suren Baghdasaryan <surenb@google.com>
Date: Tue, 25 Jul 2023 15:45:45 -0700
Subject: [PATCH 0337/1487] libprocessgroup: optimize
 SetAttributeAction::ExecuteForProcess performance

Current implementation of SetAttributeAction::ExecuteForProcess reuses
SetAttributeAction::ExecuteForTask while not utilizing available uid/pid
information. This results in a call to GetPathForTask() which is an
expensive function due to it reading and parsing /proc/$pid/cgroups.
This can be avoided if we utilize available uid/pid info and the fact
that cgroup v2 attributes share the cgroup v2 hierarchy as process
groups, which use a known path template.

Bug: 292636609
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
(cherry picked from commit 961c01ce23bb886583ca8cac1640806346c09a7f)
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:1e81ee13638c5ca03157db674009d4cf7c2a1263)
Merged-In: I02e3046bd85d0dfebc68ab444f1796bb54cc69c7
Change-Id: I02e3046bd85d0dfebc68ab444f1796bb54cc69c7
---
 libprocessgroup/task_profiles.cpp      | 45 +++++++++++++++++++-------
 libprocessgroup/task_profiles.h        |  4 +++
 libprocessgroup/task_profiles_test.cpp |  3 ++
 3 files changed, 40 insertions(+), 12 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 59b135013326..f51b07671bf1 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -126,6 +126,16 @@ void ProfileAttribute::Reset(const CgroupController& controller, const std::stri
     file_v2_name_ = file_v2_name;
 }
 
+bool ProfileAttribute::GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const {
+    if (controller()->version() == 2) {
+        // all cgroup v2 attributes use the same process group hierarchy
+        *path = StringPrintf("%s/uid_%u/pid_%d/%s", controller()->path(), uid, pid,
+                             file_name().c_str());
+        return true;
+    }
+    return GetPathForTask(pid, path);
+}
+
 bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
     std::string subgroup;
     if (!controller()->GetTaskGroup(tid, &subgroup)) {
@@ -209,18 +219,7 @@ bool SetTimerSlackAction::ExecuteForTask(int) const {
 
 #endif
 
-bool SetAttributeAction::ExecuteForProcess(uid_t, pid_t pid) const {
-    return ExecuteForTask(pid);
-}
-
-bool SetAttributeAction::ExecuteForTask(int tid) const {
-    std::string path;
-
-    if (!attribute_->GetPathForTask(tid, &path)) {
-        LOG(ERROR) << "Failed to find cgroup for tid " << tid;
-        return false;
-    }
-
+bool SetAttributeAction::WriteValueToFile(const std::string& path) const {
     if (!WriteStringToFile(value_, path)) {
         if (access(path.c_str(), F_OK) < 0) {
             if (optional_) {
@@ -240,6 +239,28 @@ bool SetAttributeAction::ExecuteForTask(int tid) const {
     return true;
 }
 
+bool SetAttributeAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
+    std::string path;
+
+    if (!attribute_->GetPathForProcess(uid, pid, &path)) {
+        LOG(ERROR) << "Failed to find cgroup for uid " << uid << " pid " << pid;
+        return false;
+    }
+
+    return WriteValueToFile(path);
+}
+
+bool SetAttributeAction::ExecuteForTask(int tid) const {
+    std::string path;
+
+    if (!attribute_->GetPathForTask(tid, &path)) {
+        LOG(ERROR) << "Failed to find cgroup for tid " << tid;
+        return false;
+    }
+
+    return WriteValueToFile(path);
+}
+
 bool SetAttributeAction::ExecuteForUID(uid_t uid) const {
     std::string path;
 
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index ac8918e650fc..4663f64e2a7e 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -36,6 +36,7 @@ class IProfileAttribute {
                        const std::string& file_v2_name) = 0;
     virtual const CgroupController* controller() const = 0;
     virtual const std::string& file_name() const = 0;
+    virtual bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const = 0;
     virtual bool GetPathForTask(int tid, std::string* path) const = 0;
     virtual bool GetPathForUID(uid_t uid, std::string* path) const = 0;
 };
@@ -55,6 +56,7 @@ class ProfileAttribute : public IProfileAttribute {
     void Reset(const CgroupController& controller, const std::string& file_name,
                const std::string& file_v2_name) override;
 
+    bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const override;
     bool GetPathForTask(int tid, std::string* path) const override;
     bool GetPathForUID(uid_t uid, std::string* path) const override;
 
@@ -133,6 +135,8 @@ class SetAttributeAction : public ProfileAction {
     const IProfileAttribute* attribute_;
     std::string value_;
     bool optional_;
+
+    bool WriteValueToFile(const std::string& path) const;
 };
 
 // Set cgroup profile element
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index da74bb012f8f..99d819a7cc4c 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -111,6 +111,9 @@ class ProfileAttributeMock : public IProfileAttribute {
         return {};
     }
     const std::string& file_name() const override { return file_name_; }
+    bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const override {
+        return GetPathForTask(pid, path);
+    }
     bool GetPathForTask(int tid, std::string* path) const override {
 #ifdef __ANDROID__
         CHECK(CgroupGetControllerPath(CGROUPV2_CONTROLLER_NAME, path));

From d35715c0210b6bdb7010968a445f1fe0eb521d98 Mon Sep 17 00:00:00 2001
From: Alessio Balsini <balsini@google.com>
Date: Tue, 22 Aug 2023 10:02:19 +0100
Subject: [PATCH 0338/1487] Update bug component from Android Systems to OTA
 client

It's been a while since the Android Systems bug component does not
access the creation of new bugs for triage, instead, new bugs must
be created in the subcomponents of the team.
This change updates the bug component originally associated to this
subsystem from the Android Systems' 30545 to OTA client's 1014951.

Test: none
Bug: 270571229
Change-Id: I5455086bf777dd20abb2e2f0360f76a003120126
Signed-off-by: Alessio Balsini <balsini@google.com>
---
 fs_mgr/libsnapshot/OWNERS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/OWNERS b/fs_mgr/libsnapshot/OWNERS
index 1ee4175cffca..c8b1003779bf 100644
--- a/fs_mgr/libsnapshot/OWNERS
+++ b/fs_mgr/libsnapshot/OWNERS
@@ -1,4 +1,4 @@
-# Bug component: 30545
+# Bug component: 1014951
 balsini@google.com
 dvander@google.com
 elsk@google.com

From 2326e056bdb699d6ce11653d515cecff6f636da3 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 22 Aug 2023 14:23:37 -0700
Subject: [PATCH 0339/1487] Add documentation to README

adding documentation on how to use fastboot-info inside of fastboot
README

Test: na
Bug: 297084293
Change-Id: Ic2d17c92a776f1cae9ef80f6b615ddbc841afb74
---
 fastboot/README.md | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/fastboot/README.md b/fastboot/README.md
index 63db5c38bf2d..55583eb0efc0 100644
--- a/fastboot/README.md
+++ b/fastboot/README.md
@@ -165,6 +165,28 @@ The various currently defined commands are:
                        using the new bootloader.
 
 
+## Flashing Logic
+
+Fastboot binary will follow directions listed out fastboot-info.txt
+build artifact for fastboot flashall && fastboot update comamnds.
+This build artifact will live inside of ANDROID_PRODUCT_OUT &&
+target_files_package && updatepackage.
+
+
+The currently defined commands are:
+
+    flash %s           Flash a given partition. Optional arguments include
+                       --slot-other, {filename_path}, --apply-vbmeta
+
+    reboot %s          Reboot to either bootloader or fastbootd
+
+    update-super       Updates the super partition
+
+    if-wipe            Conditionally run some other functionality if
+                       wipe is specified
+
+    erase %s           Erase a given partition (can only be used in conjunction)
+                       with if-wipe -> eg. if-wipe erase cache
 
 ## Client Variables
 

From b497e6f317e66e5dcfa4d3ed08c6e563c66e7a2a Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 22 Aug 2023 09:41:09 -0700
Subject: [PATCH 0340/1487] Fix one liner

Ensuring that the expression is evaluated before being outputed. In
response to comment from aosp/2708333

Test: th
Change-Id: I073c143f1c4e32af11e235ce782947b250117dc5
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index d3c3d59a7f25..ee445a2d0c16 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -174,7 +174,7 @@ void CowWriterV2::InitBatchWrites() {
         current_data_pos_ = next_data_pos_;
     }
 
-    LOG_INFO << "Batch writes: " << batch_write_ ? "enabled" : "disabled";
+    LOG_INFO << "Batch writes: " << (batch_write_ ? "enabled" : "disabled");
 }
 
 void CowWriterV2::InitWorkers() {

From eb70926ad6c344a61ecbad5bc326dfaac6fe184b Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 22 Aug 2023 16:49:25 -0700
Subject: [PATCH 0341/1487] Add unit test for cow compressor performance

Adding test to measure performance differences between cow compression
algorithms + levels. This gives us an easy way to test performance
between the tunables without having to run an OTA every time. Ultimately we want this to be separate from
cow_api_test so it would be nice to have this be it's own binary. Can
add some tests for decompression + compressing from a part of an actual
img file too.

Test: m cow_benchmark
Change-Id: Iba92ae3c0b2ad4ff6f842556b701b223d7d37823
---
 .../include/libsnapshot/cow_compress.h        |   1 -
 fs_mgr/libsnapshot/tools/Android.bp           |  22 ++
 fs_mgr/libsnapshot/tools/cow_benchmark.cpp    | 188 ++++++++++++++++++
 3 files changed, 210 insertions(+), 1 deletion(-)
 create mode 100644 fs_mgr/libsnapshot/tools/Android.bp
 create mode 100644 fs_mgr/libsnapshot/tools/cow_benchmark.cpp

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
index 97974c414524..cf6561559574 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
@@ -17,7 +17,6 @@
 #pragma once
 
 #include <memory>
-#include <string_view>
 #include "libsnapshot/cow_format.h"
 
 namespace android {
diff --git a/fs_mgr/libsnapshot/tools/Android.bp b/fs_mgr/libsnapshot/tools/Android.bp
new file mode 100644
index 000000000000..cfa0cefe764c
--- /dev/null
+++ b/fs_mgr/libsnapshot/tools/Android.bp
@@ -0,0 +1,22 @@
+
+cc_binary {
+    name: "cow_benchmark",
+    host_supported: true,
+    defaults: [
+        "fs_mgr_defaults",
+        "libsnapshot_cow_defaults",
+    ],
+
+    srcs: ["cow_benchmark.cpp"],
+
+    static_libs: [
+        "libsnapshot_cow",
+    ],
+
+    shared_libs: [
+        "libbase",
+        "liblog",
+    ],
+
+    cflags: ["-Werror"],
+}
diff --git a/fs_mgr/libsnapshot/tools/cow_benchmark.cpp b/fs_mgr/libsnapshot/tools/cow_benchmark.cpp
new file mode 100644
index 000000000000..da2b87922927
--- /dev/null
+++ b/fs_mgr/libsnapshot/tools/cow_benchmark.cpp
@@ -0,0 +1,188 @@
+
+#include <memory>
+
+#include <array>
+#include <iostream>
+#include <random>
+
+#include <libsnapshot/cow_compress.h>
+#include <libsnapshot/cow_format.h>
+
+static const uint32_t BLOCK_SZ = 4096;
+static const uint32_t SEED_NUMBER = 10;
+
+namespace android {
+namespace snapshot {
+
+static std::string CompressionToString(CowCompression& compression) {
+    std::string output;
+    switch (compression.algorithm) {
+        case kCowCompressBrotli:
+            output.append("brotli");
+            break;
+        case kCowCompressGz:
+            output.append("gz");
+            break;
+        case kCowCompressLz4:
+            output.append("lz4");
+            break;
+        case kCowCompressZstd:
+            output.append("zstd");
+            break;
+        case kCowCompressNone:
+            return "No Compression";
+    }
+    output.append(" " + std::to_string(compression.compression_level));
+    return output;
+}
+
+void OneShotCompressionTest() {
+    std::cout << "\n-------One Shot Compressor Perf Analysis-------\n";
+
+    std::vector<CowCompression> compression_list = {
+            {kCowCompressLz4, 0},     {kCowCompressBrotli, 1}, {kCowCompressBrotli, 3},
+            {kCowCompressBrotli, 11}, {kCowCompressZstd, 3},   {kCowCompressZstd, 6},
+            {kCowCompressZstd, 9},    {kCowCompressZstd, 22},  {kCowCompressGz, 1},
+            {kCowCompressGz, 3},      {kCowCompressGz, 6},     {kCowCompressGz, 9}};
+    std::vector<std::unique_ptr<ICompressor>> compressors;
+    for (auto i : compression_list) {
+        compressors.emplace_back(ICompressor::Create(i, BLOCK_SZ));
+    }
+
+    // Allocate a buffer of size 8 blocks.
+    std::array<char, 32768> buffer;
+
+    // Generate a random 4k buffer of characters
+    std::default_random_engine gen(SEED_NUMBER);
+    std::uniform_int_distribution<int> distribution(0, 10);
+    for (int i = 0; i < buffer.size(); i++) {
+        buffer[i] = static_cast<char>(distribution(gen));
+    }
+
+    std::vector<std::pair<double, std::string>> latencies;
+    std::vector<std::pair<double, std::string>> ratios;
+
+    for (size_t i = 0; i < compressors.size(); i++) {
+        const auto start = std::chrono::steady_clock::now();
+        std::basic_string<uint8_t> compressed_data =
+                compressors[i]->Compress(buffer.data(), buffer.size());
+        const auto end = std::chrono::steady_clock::now();
+        const auto latency =
+                std::chrono::duration_cast<std::chrono::nanoseconds>(end - start) / 1000.0;
+        const double compression_ratio =
+                static_cast<uint16_t>(compressed_data.size()) * 1.00 / buffer.size();
+
+        std::cout << "Metrics for " << CompressionToString(compression_list[i]) << ": latency -> "
+                  << latency.count() << "ms "
+                  << " compression ratio ->" << compression_ratio << " \n";
+
+        latencies.emplace_back(
+                std::make_pair(latency.count(), CompressionToString(compression_list[i])));
+        ratios.emplace_back(
+                std::make_pair(compression_ratio, CompressionToString(compression_list[i])));
+    }
+
+    int best_speed = 0;
+    int best_ratio = 0;
+
+    for (size_t i = 1; i < latencies.size(); i++) {
+        if (latencies[i].first < latencies[best_speed].first) {
+            best_speed = i;
+        }
+        if (ratios[i].first < ratios[best_ratio].first) {
+            best_ratio = i;
+        }
+    }
+
+    std::cout << "BEST SPEED: " << latencies[best_speed].first << "ms "
+              << latencies[best_speed].second << "\n";
+    std::cout << "BEST RATIO: " << ratios[best_ratio].first << " " << ratios[best_ratio].second
+              << "\n";
+}
+
+void IncrementalCompressionTest() {
+    std::cout << "\n-------Incremental Compressor Perf Analysis-------\n";
+
+    std::vector<CowCompression> compression_list = {
+            {kCowCompressLz4, 0},     {kCowCompressBrotli, 1}, {kCowCompressBrotli, 3},
+            {kCowCompressBrotli, 11}, {kCowCompressZstd, 3},   {kCowCompressZstd, 6},
+            {kCowCompressZstd, 9},    {kCowCompressZstd, 22},  {kCowCompressGz, 1},
+            {kCowCompressGz, 3},      {kCowCompressGz, 6},     {kCowCompressGz, 9}};
+    std::vector<std::unique_ptr<ICompressor>> compressors;
+    for (auto i : compression_list) {
+        compressors.emplace_back(ICompressor::Create(i, BLOCK_SZ));
+    }
+
+    // Allocate a buffer of size 8 blocks.
+    std::array<char, 32768> buffer;
+
+    // Generate a random 4k buffer of characters
+    std::default_random_engine gen(SEED_NUMBER);
+    std::uniform_int_distribution<int> distribution(0, 10);
+    for (int i = 0; i < buffer.size(); i++) {
+        buffer[i] = static_cast<char>(distribution(gen));
+    }
+
+    std::vector<std::pair<double, std::string>> latencies;
+    std::vector<std::pair<double, std::string>> ratios;
+
+    for (size_t i = 0; i < compressors.size(); i++) {
+        std::vector<std::basic_string<uint8_t>> compressed_data_vec;
+        int num_blocks = buffer.size() / BLOCK_SZ;
+        const uint8_t* iter = reinterpret_cast<const uint8_t*>(buffer.data());
+
+        const auto start = std::chrono::steady_clock::now();
+        while (num_blocks > 0) {
+            std::basic_string<uint8_t> compressed_data = compressors[i]->Compress(iter, BLOCK_SZ);
+            compressed_data_vec.emplace_back(compressed_data);
+            num_blocks--;
+            iter += BLOCK_SZ;
+        }
+
+        const auto end = std::chrono::steady_clock::now();
+        const auto latency =
+                std::chrono::duration_cast<std::chrono::nanoseconds>(end - start) / 1000.0;
+
+        size_t size = 0;
+        for (auto& i : compressed_data_vec) {
+            size += i.size();
+        }
+        const double compression_ratio = size * 1.00 / buffer.size();
+
+        std::cout << "Metrics for " << CompressionToString(compression_list[i]) << ": latency -> "
+                  << latency.count() << "ms "
+                  << " compression ratio ->" << compression_ratio << " \n";
+
+        latencies.emplace_back(
+                std::make_pair(latency.count(), CompressionToString(compression_list[i])));
+        ratios.emplace_back(
+                std::make_pair(compression_ratio, CompressionToString(compression_list[i])));
+    }
+
+    int best_speed = 0;
+    int best_ratio = 0;
+
+    for (size_t i = 1; i < latencies.size(); i++) {
+        if (latencies[i].first < latencies[best_speed].first) {
+            best_speed = i;
+        }
+        if (ratios[i].first < ratios[best_ratio].first) {
+            best_ratio = i;
+        }
+    }
+
+    std::cout << "BEST SPEED: " << latencies[best_speed].first << "ms "
+              << latencies[best_speed].second << "\n";
+    std::cout << "BEST RATIO: " << ratios[best_ratio].first << " " << ratios[best_ratio].second
+              << "\n";
+}
+
+}  // namespace snapshot
+}  // namespace android
+
+int main() {
+    android::snapshot::OneShotCompressionTest();
+    android::snapshot::IncrementalCompressionTest();
+
+    return 0;
+}
\ No newline at end of file

From 1d98fe0d393f05283f3a10a896f1054ecd3043cd Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 13 Jul 2021 17:14:20 -0700
Subject: [PATCH 0342/1487] Lose convertToResPath to aapt.

aapt (not aapt2) is the only user.

Test: treehugger
Change-Id: Ie69f84f4f805c69f838e345b44755a316b9f9b06
---
 libutils/String8.cpp                          | 20 -------------------
 libutils/String8_fuzz.cpp                     |  3 ---
 .../arm64/source-based/libutils.so.lsdump     | 16 ---------------
 .../arm_arm64/source-based/libutils.so.lsdump | 16 ---------------
 libutils/include/utils/String8.h              |  9 ---------
 5 files changed, 64 deletions(-)

diff --git a/libutils/String8.cpp b/libutils/String8.cpp
index 79b7edfe9a12..2b72847e52bd 100644
--- a/libutils/String8.cpp
+++ b/libutils/String8.cpp
@@ -39,10 +39,6 @@
 
 namespace android {
 
-// Separator used by resource paths. This is not platform dependent contrary
-// to OS_PATH_SEPARATOR.
-#define RES_PATH_SEPARATOR '/'
-
 static inline char* getEmptyString() {
     static SharedBuffer* gEmptyStringBuf = [] {
         SharedBuffer* buf = SharedBuffer::alloc(1);
@@ -582,20 +578,4 @@ String8& String8::appendPath(const char* name)
     }
 }
 
-String8& String8::convertToResPath()
-{
-#if OS_PATH_SEPARATOR != RES_PATH_SEPARATOR
-    size_t len = length();
-    if (len > 0) {
-        char * buf = lockBuffer(len);
-        for (char * end = buf + len; buf < end; ++buf) {
-            if (*buf == OS_PATH_SEPARATOR)
-                *buf = RES_PATH_SEPARATOR;
-        }
-        unlockBuffer(len);
-    }
-#endif
-    return *this;
-}
-
 }; // namespace android
diff --git a/libutils/String8_fuzz.cpp b/libutils/String8_fuzz.cpp
index e5dcd316ecb0..a1cb3354af53 100644
--- a/libutils/String8_fuzz.cpp
+++ b/libutils/String8_fuzz.cpp
@@ -82,9 +82,6 @@ std::vector<std::function<void(FuzzedDataProvider*, android::String8*, android::
                 [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
                     str1->getPathDir();
                 },
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->convertToResPath();
-                },
                 [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
                     std::shared_ptr<android::String8> path_out_str =
                             std::make_shared<android::String8>();
diff --git a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
index c89af9e8b220..46baddecde7b 100644
--- a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
@@ -724,9 +724,6 @@
   {
    "name" : "_ZN7android7String813appendFormatVEPKcSt9__va_list"
   },
-  {
-   "name" : "_ZN7android7String816convertToResPathEv"
-  },
   {
    "name" : "_ZN7android7String85clearEv"
   },
@@ -6927,19 +6924,6 @@
    "return_type" : "_ZTIi",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::convertToResPath",
-   "linker_set_key" : "_ZN7android7String816convertToResPathEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIRN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String8::clear",
    "linker_set_key" : "_ZN7android7String85clearEv",
diff --git a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
index f88da15e00bb..219c76665bb9 100644
--- a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
@@ -724,9 +724,6 @@
   {
    "name" : "_ZN7android7String813appendFormatVEPKcSt9__va_list"
   },
-  {
-   "name" : "_ZN7android7String816convertToResPathEv"
-  },
   {
    "name" : "_ZN7android7String85clearEv"
   },
@@ -6923,19 +6920,6 @@
    "return_type" : "_ZTIi",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::convertToResPath",
-   "linker_set_key" : "_ZN7android7String816convertToResPathEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIRN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String8::clear",
    "linker_set_key" : "_ZN7android7String85clearEv",
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index e58f1a5d1992..43909f7f7b73 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -202,15 +202,6 @@ class String8
                                              { String8 p(*this); p.appendPath(leaf); return p; }
     String8 appendPathCopy(const String8& leaf) const { return appendPathCopy(leaf.c_str()); }
 
-    /*
-     * Converts all separators in this string to /, the default path separator.
-     *
-     * If the default OS separator is backslash, this converts all
-     * backslashes to slashes, in-place. Otherwise it does nothing.
-     * Returns self.
-     */
-    String8& convertToResPath();
-
 private:
             status_t            real_append(const char* other, size_t numChars);
             char*               find_extension(void) const;

From 3343ca2380dc6ccea641dc3b99156c2d15c2f9d8 Mon Sep 17 00:00:00 2001
From: Yinchu Chen <chenyc5@motorola.com>
Date: Fri, 25 Aug 2023 04:22:06 +0000
Subject: [PATCH 0343/1487] Increase the number of service supplementary group

OEM can add self-owned groups, but the system init cannot support if the group numbers are over than 12, relax some restrictions as appropriate.

Bug: b/296826987

Signed-off-by: Haichao Li <liuhc3@motorola.com>
Change-Id: I231d9f6c82e93c08bc97ca32df70e5b28760acbc
---
 init/service.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/service.h b/init/service.h
index b858eeff03d6..9f09cefb8618 100644
--- a/init/service.h
+++ b/init/service.h
@@ -60,7 +60,7 @@
 #define SVC_GENTLE_KILL 0x2000  // This service should be stopped with SIGTERM instead of SIGKILL
                                 // Will still be SIGKILLed after timeout period of 200 ms
 
-#define NR_SVC_SUPP_GIDS 12    // twelve supplementary groups
+#define NR_SVC_SUPP_GIDS 32    // thirty two supplementary groups
 
 namespace android {
 namespace init {

From 81c4e225bf1546ff3f9ce4019f5bd3a58c57ba5f Mon Sep 17 00:00:00 2001
From: Cole Faust <colefaust@google.com>
Date: Fri, 25 Aug 2023 15:34:08 -0700
Subject: [PATCH 0344/1487] Make simg2img host-only

This is supposed to be a host tool, but was being installed on
cuttlefish devices.

Bug: 205632228
Test: Presubmits
Change-Id: I9eb1ae1a5c171253617fa12283e2ec651afb5539
---
 libsparse/Android.bp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/libsparse/Android.bp b/libsparse/Android.bp
index 5a7d0fc78f7c..44907a1f0770 100644
--- a/libsparse/Android.bp
+++ b/libsparse/Android.bp
@@ -41,9 +41,8 @@ cc_library {
     ],
 }
 
-cc_binary {
+cc_binary_host {
     name: "simg2img",
-    host_supported: true,
     srcs: [
         "simg2img.cpp",
         "sparse_crc32.cpp",
@@ -62,9 +61,8 @@ cc_binary {
     },
 }
 
-cc_binary {
+cc_binary_host {
     name: "img2simg",
-    host_supported: true,
     srcs: ["img2simg.cpp"],
     static_libs: [
         "libsparse",

From 1ef66b70ffb91c4e94acae268137f8a915271337 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 24 Aug 2023 15:44:56 -0700
Subject: [PATCH 0345/1487] Fixing optimization logic

Adding a hard pattern check for optimized task formation. To keep
behavior consistent, we will remove the old initialization path and add
resize tasks after attempting optimization.

Test: fastboot_test
Bug: 297085098
Change-Id: Ie0e656af9be7abdd130290fe547ffbf385ce75d6
---
 fastboot/fastboot.cpp |  61 ++++++++++------------
 fastboot/task.cpp     | 116 ++++++++++++++++--------------------------
 fastboot/task.h       |  38 ++++++++------
 3 files changed, 93 insertions(+), 122 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 71a228ea1053..8c607dd8370d 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1678,7 +1678,7 @@ bool AddResizeTasks(const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>*
     }
     for (size_t i = 0; i < tasks->size(); i++) {
         if (auto flash_task = tasks->at(i)->AsFlashTask()) {
-            if (should_flash_in_userspace(*metadata.get(), flash_task->GetPartitionAndSlot())) {
+            if (FlashTask::IsDynamicParitition(fp->source, flash_task)) {
                 if (!loc) {
                     loc = i;
                 }
@@ -1760,25 +1760,15 @@ std::vector<std::unique_ptr<Task>> ParseFastbootInfo(const FlashingPlan* fp,
         }
         tasks.emplace_back(std::move(task));
     }
-    if (auto flash_super_task = OptimizedFlashSuperTask::InitializeFromTasks(fp, tasks)) {
-        auto it = tasks.begin();
-        for (size_t i = 0; i < tasks.size(); i++) {
-            if (auto flash_task = tasks[i]->AsFlashTask()) {
-                if (should_flash_in_userspace(flash_task->GetPartitionAndSlot())) {
-                    break;
-                }
-            }
-            if (auto wipe_task = tasks[i]->AsWipeTask()) {
-                break;
-            }
-            it++;
-        }
-        tasks.insert(it, std::move(flash_super_task));
+
+    if (auto flash_super_task = OptimizedFlashSuperTask::Initialize(fp, tasks)) {
+        tasks.emplace_back(std::move(flash_super_task));
     } else {
         if (!AddResizeTasks(fp, &tasks)) {
             LOG(WARNING) << "Failed to add resize tasks";
-        };
+        }
     }
+
     return tasks;
 }
 
@@ -1885,30 +1875,35 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasksFromImageList() {
     // or in bootloader fastboot.
     std::vector<std::unique_ptr<Task>> tasks;
     AddFlashTasks(boot_images_, tasks);
-    if (auto flash_super_task = OptimizedFlashSuperTask::Initialize(fp_, os_images_)) {
+
+    // Sync the super partition. This will reboot to userspace fastboot if needed.
+    tasks.emplace_back(std::make_unique<UpdateSuperTask>(fp_));
+    for (const auto& [image, slot] : os_images_) {
+        // Retrofit devices have two super partitions, named super_a and super_b.
+        // On these devices, secondary slots must be flashed as physical
+        // partitions (otherwise they would not mount on first boot). To enforce
+        // this, we delete any logical partitions for the "other" slot.
+        if (is_retrofit_device(fp_->fb)) {
+            std::string partition_name = image->part_name + "_"s + slot;
+            if (image->IsSecondary() && should_flash_in_userspace(partition_name)) {
+                fp_->fb->DeletePartition(partition_name);
+            }
+            tasks.emplace_back(std::make_unique<DeleteTask>(fp_, partition_name));
+        }
+    }
+
+    AddFlashTasks(os_images_, tasks);
+
+    if (auto flash_super_task = OptimizedFlashSuperTask::Initialize(fp_, tasks)) {
         tasks.emplace_back(std::move(flash_super_task));
     } else {
-        // Sync the super partition. This will reboot to userspace fastboot if needed.
-        tasks.emplace_back(std::make_unique<UpdateSuperTask>(fp_));
         // Resize any logical partition to 0, so each partition is reset to 0
         // extents, and will achieve more optimal allocation.
-        for (const auto& [image, slot] : os_images_) {
-            // Retrofit devices have two super partitions, named super_a and super_b.
-            // On these devices, secondary slots must be flashed as physical
-            // partitions (otherwise they would not mount on first boot). To enforce
-            // this, we delete any logical partitions for the "other" slot.
-            if (is_retrofit_device(fp_->fb)) {
-                std::string partition_name = image->part_name + "_"s + slot;
-                if (image->IsSecondary() && should_flash_in_userspace(partition_name)) {
-                    fp_->fb->DeletePartition(partition_name);
-                }
-                tasks.emplace_back(std::make_unique<DeleteTask>(fp_, partition_name));
-            }
-            tasks.emplace_back(std::make_unique<ResizeTask>(fp_, image->part_name, "0", slot));
+        if (!AddResizeTasks(fp_, &tasks)) {
+            LOG(WARNING) << "Failed to add resize tasks";
         }
     }
 
-    AddFlashTasks(os_images_, tasks);
     return tasks;
 }
 
diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index 146064cc5b3f..f0eed0cd1c7b 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -15,6 +15,7 @@
 //
 #include "task.h"
 
+#include <cstddef>
 #include <iostream>
 
 #include <android-base/logging.h>
@@ -30,6 +31,15 @@ FlashTask::FlashTask(const std::string& slot, const std::string& pname, const st
                      const bool apply_vbmeta, const FlashingPlan* fp)
     : pname_(pname), fname_(fname), slot_(slot), apply_vbmeta_(apply_vbmeta), fp_(fp) {}
 
+bool FlashTask::IsDynamicParitition(const ImageSource* source, const FlashTask* task) {
+    std::vector<char> contents;
+    if (!source->ReadFile("super_empty.img", &contents)) {
+        return false;
+    }
+    auto metadata = android::fs_mgr::ReadFromImageBlob(contents.data(), contents.size());
+    return should_flash_in_userspace(*metadata.get(), task->GetPartitionAndSlot());
+}
+
 void FlashTask::Run() {
     auto flash = [&](const std::string& partition) {
         if (should_flash_in_userspace(partition) && !is_userspace_fastboot() && !fp_->force_flash) {
@@ -46,7 +56,7 @@ void FlashTask::Run() {
     do_for_partitions(pname_, slot_, flash, true);
 }
 
-std::string FlashTask::ToString() {
+std::string FlashTask::ToString() const {
     std::string apply_vbmeta_string = "";
     if (apply_vbmeta_) {
         apply_vbmeta_string = " --apply_vbmeta";
@@ -54,7 +64,7 @@ std::string FlashTask::ToString() {
     return "flash" + apply_vbmeta_string + " " + pname_ + " " + fname_;
 }
 
-std::string FlashTask::GetPartitionAndSlot() {
+std::string FlashTask::GetPartitionAndSlot() const {
     auto slot = slot_;
     if (slot.empty()) {
         slot = get_current_slot();
@@ -92,7 +102,7 @@ void RebootTask::Run() {
     }
 }
 
-std::string RebootTask::ToString() {
+std::string RebootTask::ToString() const {
     return "reboot " + reboot_target_;
 }
 
@@ -120,79 +130,36 @@ void OptimizedFlashSuperTask::Run() {
     // Send the data to the device.
     flash_partition_files(super_name_, files);
 }
-std::string OptimizedFlashSuperTask::ToString() {
+std::string OptimizedFlashSuperTask::ToString() const {
     return "optimized-flash-super";
 }
 
-std::unique_ptr<OptimizedFlashSuperTask> OptimizedFlashSuperTask::Initialize(
-        const FlashingPlan* fp, std::vector<ImageEntry>& os_images) {
-    if (!fp->should_optimize_flash_super) {
-        LOG(INFO) << "super optimization is disabled";
-        return nullptr;
-    }
-    if (!supports_AB()) {
-        LOG(VERBOSE) << "Cannot optimize flashing super on non-AB device";
-        return nullptr;
-    }
-    if (fp->slot_override == "all") {
-        LOG(VERBOSE) << "Cannot optimize flashing super for all slots";
-        return nullptr;
-    }
-
-    // Does this device use dynamic partitions at all?
-    unique_fd fd = fp->source->OpenFile("super_empty.img");
-
-    if (fd < 0) {
-        LOG(VERBOSE) << "could not open super_empty.img";
-        return nullptr;
-    }
-
-    std::string super_name;
-    // Try to find whether there is a super partition.
-    if (fp->fb->GetVar("super-partition-name", &super_name) != fastboot::SUCCESS) {
-        super_name = "super";
-    }
-
-    uint64_t partition_size;
-    std::string partition_size_str;
-    if (fp->fb->GetVar("partition-size:" + super_name, &partition_size_str) != fastboot::SUCCESS) {
-        LOG(VERBOSE) << "Cannot optimize super flashing: could not determine super partition";
-        return nullptr;
-    }
-    partition_size_str = fb_fix_numeric_var(partition_size_str);
-    if (!android::base::ParseUint(partition_size_str, &partition_size)) {
-        LOG(VERBOSE) << "Could not parse " << super_name << " size: " << partition_size_str;
-        return nullptr;
-    }
-
-    std::unique_ptr<SuperFlashHelper> helper = std::make_unique<SuperFlashHelper>(*fp->source);
-    if (!helper->Open(fd)) {
-        return nullptr;
-    }
-
-    for (const auto& entry : os_images) {
-        auto partition = GetPartitionName(entry, fp->current_slot);
-        auto image = entry.first;
-
-        if (!helper->AddPartition(partition, image->img_name, image->optional_if_no_image)) {
-            return nullptr;
+// This looks for a block within tasks that has the following pattern [reboot fastboot,
+// update-super, $LIST_OF_DYNAMIC_FLASH_TASKS] and returns true if this is found.Theoretically
+// this check is just a pattern match and could break if fastboot-info has a bunch of junk commands
+// but all devices should pretty much follow this pattern
+bool OptimizedFlashSuperTask::CanOptimize(const ImageSource* source,
+                                          const std::vector<std::unique_ptr<Task>>& tasks) {
+    for (size_t i = 0; i < tasks.size(); i++) {
+        auto reboot_task = tasks[i]->AsRebootTask();
+        if (!reboot_task || reboot_task->GetTarget() != "fastboot") {
+            continue;
+        }
+        // The check for i >= tasks.size() - 2 is because we are peeking two tasks ahead. We need to
+        // check for an update-super && flash {dynamic_partition}
+        if (i >= tasks.size() - 2 || !tasks[i + 1]->AsUpdateSuperTask()) {
+            continue;
+        }
+        auto flash_task = tasks[i + 2]->AsFlashTask();
+        if (!FlashTask::IsDynamicParitition(source, flash_task)) {
+            continue;
         }
+        return true;
     }
-
-    auto s = helper->GetSparseLayout();
-    if (!s) return nullptr;
-
-    // Remove images that we already flashed, just in case we have non-dynamic OS images.
-    auto remove_if_callback = [&](const ImageEntry& entry) -> bool {
-        return helper->WillFlash(GetPartitionName(entry, fp->current_slot));
-    };
-    os_images.erase(std::remove_if(os_images.begin(), os_images.end(), remove_if_callback),
-                    os_images.end());
-    return std::make_unique<OptimizedFlashSuperTask>(super_name, std::move(helper), std::move(s),
-                                                     partition_size, fp);
+    return false;
 }
 
-std::unique_ptr<OptimizedFlashSuperTask> OptimizedFlashSuperTask::InitializeFromTasks(
+std::unique_ptr<OptimizedFlashSuperTask> OptimizedFlashSuperTask::Initialize(
         const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>& tasks) {
     if (!fp->should_optimize_flash_super) {
         LOG(INFO) << "super optimization is disabled";
@@ -206,6 +173,9 @@ std::unique_ptr<OptimizedFlashSuperTask> OptimizedFlashSuperTask::InitializeFrom
         LOG(VERBOSE) << "Cannot optimize flashing super for all slots";
         return nullptr;
     }
+    if (!CanOptimize(fp->source, tasks)) {
+        return nullptr;
+    }
 
     // Does this device use dynamic partitions at all?
     unique_fd fd = fp->source->OpenFile("super_empty.img");
@@ -288,7 +258,7 @@ void UpdateSuperTask::Run() {
     }
     fp_->fb->RawCommand(command, "Updating super partition");
 }
-std::string UpdateSuperTask::ToString() {
+std::string UpdateSuperTask::ToString() const {
     return "update-super";
 }
 
@@ -305,7 +275,7 @@ void ResizeTask::Run() {
     do_for_partitions(pname_, slot_, resize_partition, false);
 }
 
-std::string ResizeTask::ToString() {
+std::string ResizeTask::ToString() const {
     return "resize " + pname_;
 }
 
@@ -315,7 +285,7 @@ void DeleteTask::Run() {
     fp_->fb->DeletePartition(pname_);
 }
 
-std::string DeleteTask::ToString() {
+std::string DeleteTask::ToString() const {
     return "delete " + pname_;
 }
 
@@ -335,6 +305,6 @@ void WipeTask::Run() {
     fb_perform_format(pname_, 1, partition_type, "", fp_->fs_options, fp_);
 }
 
-std::string WipeTask::ToString() {
+std::string WipeTask::ToString() const {
     return "erase " + pname_;
 }
diff --git a/fastboot/task.h b/fastboot/task.h
index f7c8801f9239..6ebe381230d3 100644
--- a/fastboot/task.h
+++ b/fastboot/task.h
@@ -30,17 +30,18 @@ class FlashTask;
 class RebootTask;
 class UpdateSuperTask;
 class WipeTask;
-
+class ResizeTask;
 class Task {
   public:
     Task() = default;
     virtual void Run() = 0;
-    virtual std::string ToString() = 0;
+    virtual std::string ToString() const = 0;
 
     virtual FlashTask* AsFlashTask() { return nullptr; }
     virtual RebootTask* AsRebootTask() { return nullptr; }
     virtual UpdateSuperTask* AsUpdateSuperTask() { return nullptr; }
     virtual WipeTask* AsWipeTask() { return nullptr; }
+    virtual ResizeTask* AsResizeTask() { return nullptr; }
 
     virtual ~Task() = default;
 };
@@ -51,12 +52,13 @@ class FlashTask : public Task {
               const bool apply_vbmeta, const FlashingPlan* fp);
     virtual FlashTask* AsFlashTask() override { return this; }
 
+    static bool IsDynamicParitition(const ImageSource* source, const FlashTask* task);
     void Run() override;
-    std::string ToString() override;
-    std::string GetPartition() { return pname_; }
-    std::string GetImageName() { return fname_; }
-    std::string GetSlot() { return slot_; }
-    std::string GetPartitionAndSlot();
+    std::string ToString() const override;
+    std::string GetPartition() const { return pname_; }
+    std::string GetImageName() const { return fname_; }
+    std::string GetSlot() const { return slot_; }
+    std::string GetPartitionAndSlot() const;
 
   private:
     const std::string pname_;
@@ -72,7 +74,8 @@ class RebootTask : public Task {
     RebootTask(const FlashingPlan* fp, const std::string& reboot_target);
     virtual RebootTask* AsRebootTask() override { return this; }
     void Run() override;
-    std::string ToString() override;
+    std::string ToString() const override;
+    std::string GetTarget() const { return reboot_target_; };
 
   private:
     const std::string reboot_target_ = "";
@@ -83,13 +86,15 @@ class OptimizedFlashSuperTask : public Task {
   public:
     OptimizedFlashSuperTask(const std::string& super_name, std::unique_ptr<SuperFlashHelper> helper,
                             SparsePtr sparse_layout, uint64_t super_size, const FlashingPlan* fp);
-    static std::unique_ptr<OptimizedFlashSuperTask> Initialize(const FlashingPlan* fp,
-                                                               std::vector<ImageEntry>& os_images);
-    static std::unique_ptr<OptimizedFlashSuperTask> InitializeFromTasks(
+
+    static std::unique_ptr<OptimizedFlashSuperTask> Initialize(
             const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>& tasks);
+    static bool CanOptimize(const ImageSource* source,
+                            const std::vector<std::unique_ptr<Task>>& tasks);
+
     using ImageEntry = std::pair<const Image*, std::string>;
     void Run() override;
-    std::string ToString() override;
+    std::string ToString() const override;
 
   private:
     const std::string super_name_;
@@ -105,7 +110,7 @@ class UpdateSuperTask : public Task {
     virtual UpdateSuperTask* AsUpdateSuperTask() override { return this; }
 
     void Run() override;
-    std::string ToString() override;
+    std::string ToString() const override;
 
   private:
     const FlashingPlan* fp_;
@@ -116,7 +121,8 @@ class ResizeTask : public Task {
     ResizeTask(const FlashingPlan* fp, const std::string& pname, const std::string& size,
                const std::string& slot);
     void Run() override;
-    std::string ToString() override;
+    std::string ToString() const override;
+    virtual ResizeTask* AsResizeTask() override { return this; }
 
   private:
     const FlashingPlan* fp_;
@@ -129,7 +135,7 @@ class DeleteTask : public Task {
   public:
     DeleteTask(const FlashingPlan* fp, const std::string& pname);
     void Run() override;
-    std::string ToString() override;
+    std::string ToString() const override;
 
   private:
     const FlashingPlan* fp_;
@@ -141,7 +147,7 @@ class WipeTask : public Task {
     WipeTask(const FlashingPlan* fp, const std::string& pname);
     virtual WipeTask* AsWipeTask() override { return this; }
     void Run() override;
-    std::string ToString() override;
+    std::string ToString() const override;
 
   private:
     const FlashingPlan* fp_;

From 1fff690c180a06e76e2e89b08cf20c6ef8c5efcd Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 24 Aug 2023 09:47:43 -0700
Subject: [PATCH 0346/1487] Adding testing for optimized flash super

Adding test cases for correct formation of optimized flash super task.
We are adding an explicit pattern match for this task to be correctly
formed. Changing Optimized flash task to only remove the reboot to
userspace as a user might want to reboot back to bootloader after
flashing. We also need to change a couple functions to take a
IFastbootDriver to mock up the initialization path.

Test: fastboot_test
Bug: 297085098
Change-Id: Ic5c63bd4057ca6d64647134e5ce33fef12077fdb
---
 fastboot/fastboot.cpp            |  20 +++---
 fastboot/fastboot.h              |   4 +-
 fastboot/fastboot_driver.h       |   3 -
 fastboot/fuzzy_fastboot/main.cpp |  45 ++++++-------
 fastboot/task.cpp                |  14 ++--
 fastboot/task.h                  |   6 +-
 fastboot/task_test.cpp           | 111 ++++++++++++++++++++++++++++++-
 7 files changed, 152 insertions(+), 51 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 8c607dd8370d..81787f58e2aa 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1285,7 +1285,7 @@ std::string get_current_slot() {
     return current_slot;
 }
 
-static int get_slot_count() {
+static int get_slot_count(fastboot::IFastBootDriver* fb) {
     std::string var;
     int count = 0;
     if (fb->GetVar("slot-count", &var) != fastboot::SUCCESS ||
@@ -1295,8 +1295,8 @@ static int get_slot_count() {
     return count;
 }
 
-bool supports_AB() {
-    return get_slot_count() >= 2;
+bool supports_AB(fastboot::IFastBootDriver* fb) {
+    return get_slot_count(fb) >= 2;
 }
 
 // Given a current slot, this returns what the 'other' slot is.
@@ -1308,7 +1308,7 @@ static std::string get_other_slot(const std::string& current_slot, int count) {
 }
 
 static std::string get_other_slot(const std::string& current_slot) {
-    return get_other_slot(current_slot, get_slot_count());
+    return get_other_slot(current_slot, get_slot_count(fb));
 }
 
 static std::string get_other_slot(int count) {
@@ -1316,7 +1316,7 @@ static std::string get_other_slot(int count) {
 }
 
 static std::string get_other_slot() {
-    return get_other_slot(get_current_slot(), get_slot_count());
+    return get_other_slot(get_current_slot(), get_slot_count(fb));
 }
 
 static std::string verify_slot(const std::string& slot_name, bool allow_all) {
@@ -1325,7 +1325,7 @@ static std::string verify_slot(const std::string& slot_name, bool allow_all) {
         if (allow_all) {
             return "all";
         } else {
-            int count = get_slot_count();
+            int count = get_slot_count(fb);
             if (count > 0) {
                 return "a";
             } else {
@@ -1334,7 +1334,7 @@ static std::string verify_slot(const std::string& slot_name, bool allow_all) {
         }
     }
 
-    int count = get_slot_count();
+    int count = get_slot_count(fb);
     if (count == 0) die("Device does not support slots");
 
     if (slot == "other") {
@@ -1407,7 +1407,7 @@ void do_for_partitions(const std::string& part, const std::string& slot,
                 slot.c_str());
         }
         if (has_slot == "yes") {
-            for (int i = 0; i < get_slot_count(); i++) {
+            for (int i = 0; i < get_slot_count(fb); i++) {
                 do_for_partition(part, std::string(1, (char)(i + 'a')), func, force_slot);
             }
         } else {
@@ -1528,7 +1528,7 @@ void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,
 // Sets slot_override as the active slot. If slot_override is blank,
 // set current slot as active instead. This clears slot-unbootable.
 static void set_active(const std::string& slot_override) {
-    if (!supports_AB()) return;
+    if (!supports_AB(fb)) return;
 
     if (slot_override != "") {
         fb->SetActive(slot_override);
@@ -1845,7 +1845,7 @@ void FlashAllTool::DetermineSlot() {
         fp_->secondary_slot = get_other_slot();
     }
     if (fp_->secondary_slot == "") {
-        if (supports_AB()) {
+        if (supports_AB(fb)) {
             fprintf(stderr, "Warning: Could not determine slot for secondary images. Ignoring.\n");
         }
         fp_->skip_secondary = true;
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index 75b8d290f385..35deea7d2a96 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -29,10 +29,8 @@
 
 #include <functional>
 #include <string>
-#include "fastboot_driver.h"
 #include "fastboot_driver_interface.h"
 #include "filesystem.h"
-#include "super_flash_helper.h"
 #include "task.h"
 #include "util.h"
 
@@ -183,12 +181,12 @@ struct NetworkSerial {
 };
 
 Result<NetworkSerial, FastbootError> ParseNetworkSerial(const std::string& serial);
-bool supports_AB();
 std::string GetPartitionName(const ImageEntry& entry, const std::string& current_slot_);
 void flash_partition_files(const std::string& partition, const std::vector<SparsePtr>& files);
 int64_t get_sparse_limit(int64_t size, const FlashingPlan* fp);
 std::vector<SparsePtr> resparse_file(sparse_file* s, int64_t max_size);
 
+bool supports_AB(fastboot::IFastBootDriver* fb);
 bool is_retrofit_device(fastboot::IFastBootDriver* fb);
 bool is_logical(const std::string& partition);
 void fb_perform_format(const std::string& partition, int skip_if_not_supported,
diff --git a/fastboot/fastboot_driver.h b/fastboot/fastboot_driver.h
index 8774eadc6a6f..48b90ed7d789 100644
--- a/fastboot/fastboot_driver.h
+++ b/fastboot/fastboot_driver.h
@@ -27,7 +27,6 @@
  */
 #pragma once
 #include <cstdlib>
-#include <deque>
 #include <functional>
 #include <limits>
 #include <string>
@@ -37,10 +36,8 @@
 #include <android-base/stringprintf.h>
 #include <android-base/unique_fd.h>
 #include <bootimg.h>
-#include <inttypes.h>
 #include <sparse/sparse.h>
 
-#include "constants.h"
 #include "fastboot_driver_interface.h"
 #include "transport.h"
 
diff --git a/fastboot/fuzzy_fastboot/main.cpp b/fastboot/fuzzy_fastboot/main.cpp
index e6359374eb32..95778e144711 100644
--- a/fastboot/fuzzy_fastboot/main.cpp
+++ b/fastboot/fuzzy_fastboot/main.cpp
@@ -50,6 +50,7 @@
 #include <gtest/gtest.h>
 #include <sparse/sparse.h>
 
+#include "constants.h"
 #include "fastboot_driver.h"
 #include "usb.h"
 
@@ -929,8 +930,7 @@ TEST_F(Fuzz, BadCommandTooLarge) {
 
     ASSERT_TRUE(UsbStillAvailible()) << USB_PORT_GONE;
     std::string resp;
-    EXPECT_EQ(fb->GetVar("product", &resp), SUCCESS)
-                << "Device is unresponsive to getvar command";
+    EXPECT_EQ(fb->GetVar("product", &resp), SUCCESS) << "Device is unresponsive to getvar command";
 }
 
 TEST_F(Fuzz, CommandTooLarge) {
@@ -986,11 +986,10 @@ TEST_F(Fuzz, SparseZeroLength) {
 TEST_F(Fuzz, SparseZeroBlkSize) {
     // handcrafted malform sparse file with zero as block size
     const std::vector<char> buf = {
-        '\x3a', '\xff', '\x26', '\xed', '\x01', '\x00', '\x00', '\x00', '\x1c', '\x00', '\x0c', '\x00',
-        '\x00', '\x00', '\x00', '\x00', '\x01', '\x00', '\x00', '\x00', '\x01', '\x00', '\x00', '\x00',
-        '\x00', '\x00', '\x00', '\x00', '\xc2', '\xca', '\x00', '\x00', '\x01', '\x00', '\x00', '\x00',
-        '\x10', '\x00', '\x00', '\x00', '\x11', '\x22', '\x33', '\x44'
-    };
+            '\x3a', '\xff', '\x26', '\xed', '\x01', '\x00', '\x00', '\x00', '\x1c', '\x00', '\x0c',
+            '\x00', '\x00', '\x00', '\x00', '\x00', '\x01', '\x00', '\x00', '\x00', '\x01', '\x00',
+            '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\xc2', '\xca', '\x00', '\x00', '\x01',
+            '\x00', '\x00', '\x00', '\x10', '\x00', '\x00', '\x00', '\x11', '\x22', '\x33', '\x44'};
 
     ASSERT_EQ(DownloadCommand(buf.size()), SUCCESS) << "Device rejected download command";
     ASSERT_EQ(SendBuffer(buf), SUCCESS) << "Downloading payload failed";
@@ -1005,13 +1004,10 @@ TEST_F(Fuzz, SparseZeroBlkSize) {
 TEST_F(Fuzz, SparseVeryLargeBlkSize) {
     // handcrafted sparse file with block size of ~4GB and divisible 4
     const std::vector<char> buf = {
-        '\x3a', '\xff', '\x26', '\xed', '\x01', '\x00', '\x00', '\x00',
-        '\x1c', '\x00', '\x0c', '\x00', '\xF0', '\xFF', '\xFF', '\xFF',
-        '\x01', '\x00', '\x00', '\x00', '\x01', '\x00', '\x00', '\x00',
-        '\x00', '\x00', '\x00', '\x00', '\xc3', '\xca', '\x00', '\x00',
-        '\x01', '\x00', '\x00', '\x00', '\x0c', '\x00', '\x00', '\x00',
-        '\x11', '\x22', '\x33', '\x44'
-    };
+            '\x3a', '\xff', '\x26', '\xed', '\x01', '\x00', '\x00', '\x00', '\x1c', '\x00', '\x0c',
+            '\x00', '\xF0', '\xFF', '\xFF', '\xFF', '\x01', '\x00', '\x00', '\x00', '\x01', '\x00',
+            '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\xc3', '\xca', '\x00', '\x00', '\x01',
+            '\x00', '\x00', '\x00', '\x0c', '\x00', '\x00', '\x00', '\x11', '\x22', '\x33', '\x44'};
 
     ASSERT_EQ(DownloadCommand(buf.size()), SUCCESS) << "Device rejected download command";
     ASSERT_EQ(SendBuffer(buf), SUCCESS) << "Downloading payload failed";
@@ -1022,11 +1018,10 @@ TEST_F(Fuzz, SparseVeryLargeBlkSize) {
 TEST_F(Fuzz, SparseTrimmed) {
     // handcrafted malform sparse file which is trimmed
     const std::vector<char> buf = {
-        '\x3a', '\xff', '\x26', '\xed', '\x01', '\x00', '\x00', '\x00', '\x1c', '\x00', '\x0c', '\x00',
-        '\x00', '\x10', '\x00', '\x00', '\x00', '\x00', '\x08', '\x00', '\x01', '\x00', '\x00', '\x00',
-        '\x00', '\x00', '\x00', '\x00', '\xc1', '\xca', '\x00', '\x00', '\x01', '\x00', '\x00', '\x00',
-        '\x00', '\x00', '\x00', '\x80', '\x11', '\x22', '\x33', '\x44'
-    };
+            '\x3a', '\xff', '\x26', '\xed', '\x01', '\x00', '\x00', '\x00', '\x1c', '\x00', '\x0c',
+            '\x00', '\x00', '\x10', '\x00', '\x00', '\x00', '\x00', '\x08', '\x00', '\x01', '\x00',
+            '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\xc1', '\xca', '\x00', '\x00', '\x01',
+            '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x80', '\x11', '\x22', '\x33', '\x44'};
 
     ASSERT_EQ(DownloadCommand(buf.size()), SUCCESS) << "Device rejected download command";
     ASSERT_EQ(SendBuffer(buf), SUCCESS) << "Downloading payload failed";
@@ -1041,11 +1036,10 @@ TEST_F(Fuzz, SparseTrimmed) {
 TEST_F(Fuzz, SparseInvalidChurk) {
     // handcrafted malform sparse file with invalid churk
     const std::vector<char> buf = {
-        '\x3a', '\xff', '\x26', '\xed', '\x01', '\x00', '\x00', '\x00', '\x1c', '\x00', '\x0c', '\x00',
-        '\x00', '\x10', '\x00', '\x00', '\x00', '\x00', '\x08', '\x00', '\x01', '\x00', '\x00', '\x00',
-        '\x00', '\x00', '\x00', '\x00', '\xc1', '\xca', '\x00', '\x00', '\x01', '\x00', '\x00', '\x00',
-        '\x10', '\x00', '\x00', '\x00', '\x11', '\x22', '\x33', '\x44'
-    };
+            '\x3a', '\xff', '\x26', '\xed', '\x01', '\x00', '\x00', '\x00', '\x1c', '\x00', '\x0c',
+            '\x00', '\x00', '\x10', '\x00', '\x00', '\x00', '\x00', '\x08', '\x00', '\x01', '\x00',
+            '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\xc1', '\xca', '\x00', '\x00', '\x01',
+            '\x00', '\x00', '\x00', '\x10', '\x00', '\x00', '\x00', '\x11', '\x22', '\x33', '\x44'};
 
     ASSERT_EQ(DownloadCommand(buf.size()), SUCCESS) << "Device rejected download command";
     ASSERT_EQ(SendBuffer(buf), SUCCESS) << "Downloading payload failed";
@@ -1895,7 +1889,8 @@ int main(int argc, char** argv) {
     if (!fastboot::FastBootTest::IsFastbootOverTcp()) {
         printf("<Waiting for Device>\n");
         const auto matcher = [](usb_ifc_info* info) -> int {
-            return fastboot::FastBootTest::MatchFastboot(info, fastboot::FastBootTest::device_serial);
+            return fastboot::FastBootTest::MatchFastboot(info,
+                                                         fastboot::FastBootTest::device_serial);
         };
         Transport* transport = nullptr;
         while (!transport) {
diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index f0eed0cd1c7b..f13dd55b35be 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -15,8 +15,7 @@
 //
 #include "task.h"
 
-#include <cstddef>
-#include <iostream>
+#include "fastboot_driver.h"
 
 #include <android-base/logging.h>
 #include <android-base/parseint.h>
@@ -130,6 +129,7 @@ void OptimizedFlashSuperTask::Run() {
     // Send the data to the device.
     flash_partition_files(super_name_, files);
 }
+
 std::string OptimizedFlashSuperTask::ToString() const {
     return "optimized-flash-super";
 }
@@ -165,7 +165,7 @@ std::unique_ptr<OptimizedFlashSuperTask> OptimizedFlashSuperTask::Initialize(
         LOG(INFO) << "super optimization is disabled";
         return nullptr;
     }
-    if (!supports_AB()) {
+    if (!supports_AB(fp->fb)) {
         LOG(VERBOSE) << "Cannot optimize flashing super on non-AB device";
         return nullptr;
     }
@@ -218,17 +218,21 @@ std::unique_ptr<OptimizedFlashSuperTask> OptimizedFlashSuperTask::Initialize(
 
     auto s = helper->GetSparseLayout();
     if (!s) return nullptr;
-    // Remove images that we already flashed, just in case we have non-dynamic OS images.
+
+    // Remove tasks that are concatenated into this optimized task
     auto remove_if_callback = [&](const auto& task) -> bool {
         if (auto flash_task = task->AsFlashTask()) {
             return helper->WillFlash(flash_task->GetPartitionAndSlot());
         } else if (auto update_super_task = task->AsUpdateSuperTask()) {
             return true;
         } else if (auto reboot_task = task->AsRebootTask()) {
-            return true;
+            if (reboot_task->GetTarget() == "fastboot") {
+                return true;
+            }
         }
         return false;
     };
+
     tasks.erase(std::remove_if(tasks.begin(), tasks.end(), remove_if_callback), tasks.end());
 
     return std::make_unique<OptimizedFlashSuperTask>(super_name, std::move(helper), std::move(s),
diff --git a/fastboot/task.h b/fastboot/task.h
index 6ebe381230d3..a98c87419c52 100644
--- a/fastboot/task.h
+++ b/fastboot/task.h
@@ -15,10 +15,8 @@
 //
 #pragma once
 
-#include <sstream>
 #include <string>
 
-#include "fastboot_driver.h"
 #include "super_flash_helper.h"
 #include "util.h"
 
@@ -29,6 +27,7 @@ using ImageEntry = std::pair<const Image*, std::string>;
 class FlashTask;
 class RebootTask;
 class UpdateSuperTask;
+class OptimizedFlashSuperTask;
 class WipeTask;
 class ResizeTask;
 class Task {
@@ -40,6 +39,7 @@ class Task {
     virtual FlashTask* AsFlashTask() { return nullptr; }
     virtual RebootTask* AsRebootTask() { return nullptr; }
     virtual UpdateSuperTask* AsUpdateSuperTask() { return nullptr; }
+    virtual OptimizedFlashSuperTask* AsOptimizedFlashSuperTask() { return nullptr; }
     virtual WipeTask* AsWipeTask() { return nullptr; }
     virtual ResizeTask* AsResizeTask() { return nullptr; }
 
@@ -86,13 +86,13 @@ class OptimizedFlashSuperTask : public Task {
   public:
     OptimizedFlashSuperTask(const std::string& super_name, std::unique_ptr<SuperFlashHelper> helper,
                             SparsePtr sparse_layout, uint64_t super_size, const FlashingPlan* fp);
+    virtual OptimizedFlashSuperTask* AsOptimizedFlashSuperTask() override { return this; }
 
     static std::unique_ptr<OptimizedFlashSuperTask> Initialize(
             const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>& tasks);
     static bool CanOptimize(const ImageSource* source,
                             const std::vector<std::unique_ptr<Task>>& tasks);
 
-    using ImageEntry = std::pair<const Image*, std::string>;
     void Run() override;
     std::string ToString() const override;
 
diff --git a/fastboot/task_test.cpp b/fastboot/task_test.cpp
index 1ba3f4ae426e..42be3cb653ec 100644
--- a/fastboot/task_test.cpp
+++ b/fastboot/task_test.cpp
@@ -19,11 +19,10 @@
 #include "fastboot_driver_mock.h"
 
 #include <gtest/gtest.h>
-#include <fstream>
 #include <iostream>
 #include <memory>
-#include <unordered_map>
 #include "android-base/strings.h"
+#include "gmock/gmock.h"
 
 using android::base::Split;
 using testing::_;
@@ -235,3 +234,111 @@ TEST_F(ParseTest, CorrectTaskLists) {
             << "size of fastboot-info task list: " << fastboot_info_tasks.size()
             << " size of hardcoded task list: " << hardcoded_tasks.size();
 }
+
+TEST_F(ParseTest, CanOptimizeTest) {
+    if (!get_android_product_out()) {
+        GTEST_SKIP();
+    }
+
+    LocalImageSource s;
+    fp->source = &s;
+    fp->sparse_limit = std::numeric_limits<int64_t>::max();
+
+    fastboot::MockFastbootDriver fb;
+    fp->fb = &fb;
+    fp->should_optimize_flash_super = false;
+    fp->should_use_fastboot_info = true;
+
+    std::vector<std::pair<std::vector<std::string>, bool>> patternmatchtest = {
+            {{"flash boot", "flash init_boot", "flash vendor_boot", "reboot fastboot",
+              "update-super", "flash product", "flash system", "flash system_ext", "flash odm",
+              "if-wipe erase userdata"},
+             true},
+            {{"flash boot", "flash init_boot", "flash vendor_boot", "reboot fastboot",
+              "update-super", "flash product", "flash system", "flash system_ext", "flash odm",
+              "if-wipe erase userdata"},
+             true},
+            {{"flash boot", "flash init_boot", "flash vendor_boot", "reboot fastboot",
+              "flash product", "flash system", "flash system_ext", "flash odm",
+              "if-wipe erase userdata"},
+             false},
+            {{"flash boot", "flash init_boot", "flash vendor_boot", "update-super", "flash product",
+              "flash system", "flash system_ext", "flash odm", "if-wipe erase userdata"},
+             false},
+    };
+
+    auto remove_if_callback = [&](const auto& task) -> bool { return !!task->AsResizeTask(); };
+
+    for (auto& test : patternmatchtest) {
+        std::vector<std::unique_ptr<Task>> tasks = ParseFastbootInfo(fp.get(), test.first);
+        tasks.erase(std::remove_if(tasks.begin(), tasks.end(), remove_if_callback), tasks.end());
+        ASSERT_EQ(OptimizedFlashSuperTask::CanOptimize(fp->source, tasks), test.second);
+    }
+}
+// Note: this test is exclusively testing that optimized flash super pattern matches a given task
+// list and is able to optimized based on a correct sequence of tasks
+TEST_F(ParseTest, OptimizedFlashSuperPatternMatchTest) {
+    if (!get_android_product_out()) {
+        GTEST_SKIP();
+    }
+
+    LocalImageSource s;
+    fp->source = &s;
+    fp->sparse_limit = std::numeric_limits<int64_t>::max();
+
+    fastboot::MockFastbootDriver fb;
+    fp->fb = &fb;
+    fp->should_optimize_flash_super = true;
+    fp->should_use_fastboot_info = true;
+
+    ON_CALL(fb, GetVar("super-partition-name", _, _))
+            .WillByDefault(testing::Return(fastboot::BAD_ARG));
+
+    ON_CALL(fb, GetVar("slot-count", _, _))
+            .WillByDefault(testing::DoAll(testing::SetArgPointee<1>("2"),
+                                          testing::Return(fastboot::SUCCESS)));
+
+    ON_CALL(fb, GetVar("partition-size:super", _, _))
+            .WillByDefault(testing::DoAll(testing::SetArgPointee<1>("1000"),
+                                          testing::Return(fastboot::SUCCESS)));
+
+    std::vector<std::pair<std::vector<std::string>, bool>> patternmatchtest = {
+            {{"flash boot", "flash init_boot", "flash vendor_boot", "reboot fastboot",
+              "update-super", "flash product", "flash system", "flash system_ext", "flash odm",
+              "if-wipe erase userdata"},
+             true},
+            {{"flash boot", "flash init_boot", "flash vendor_boot", "reboot fastboot",
+              "update-super", "flash product", "flash system", "flash system_ext", "flash odm",
+              "if-wipe erase userdata"},
+             true},
+            {{"flash boot", "flash init_boot", "flash vendor_boot", "reboot fastboot",
+              "flash product", "flash system", "flash system_ext", "flash odm",
+              "if-wipe erase userdata"},
+             false},
+            {{"flash boot", "flash init_boot", "flash vendor_boot", "update-super", "flash product",
+              "flash system", "flash system_ext", "flash odm", "if-wipe erase userdata"},
+             false},
+    };
+
+    for (auto& test : patternmatchtest) {
+        std::vector<std::unique_ptr<Task>> tasks = ParseFastbootInfo(fp.get(), test.first);
+        // Check to make sure we have an optimized flash super task && no more dynamic partition
+        // flashing tasks
+        auto&& IsOptimized = [](const FlashingPlan* fp,
+                                const std::vector<std::unique_ptr<Task>>& tasks) {
+            bool contains_optimized_task = false;
+            for (auto& task : tasks) {
+                if (auto optimized_task = task->AsOptimizedFlashSuperTask()) {
+                    contains_optimized_task = true;
+                }
+                if (auto flash_task = task->AsFlashTask()) {
+                    if (FlashTask::IsDynamicParitition(fp->source, flash_task)) {
+                        return false;
+                    }
+                }
+            }
+            return contains_optimized_task;
+        };
+        ASSERT_EQ(IsOptimized(fp.get(), tasks), test.second);
+    }
+}

From 2d4261ca4356839711b55397418bf63c334a9da3 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 23 Aug 2023 13:36:41 -0700
Subject: [PATCH 0347/1487] documenting optimized flash super

Adding documentation on the explicit pattern match we are going to add
to optimizing flash super.

Test: na
Change-Id: I57c19fb2a85d74beea5b91e38f6f46fa47637117
---
 fastboot/README.md | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/fastboot/README.md b/fastboot/README.md
index 55583eb0efc0..28e623ca798b 100644
--- a/fastboot/README.md
+++ b/fastboot/README.md
@@ -188,6 +188,21 @@ The currently defined commands are:
     erase %s           Erase a given partition (can only be used in conjunction)
                        with if-wipe -> eg. if-wipe erase cache
 
+Flashing Optimization:
+
+    After generating the list of tasks to execute, Fastboot will try and
+    optimize the flashing of the dynamic partitions by constructing an
+    optimized flash super task. Fastboot will explicitly pattern match the
+    following commands and try and concatenate it into this task. (doing so
+    will allow us to avoid the reboot into userspace fastbootd which takes
+    significant time)
+
+    //Optimizable Block
+    reboot fastboot
+    update-super                        ---> generate optimized flash super task
+    $FOR EACH {dynamic partition}
+        flash {dynamic partition}
+
 ## Client Variables
 
 The "getvar:%s" command is used to read client variables which

From afe1163ade57699c1d251f0ae06100a2af42b952 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Fri, 25 Aug 2023 14:02:24 -0700
Subject: [PATCH 0348/1487] Adding test for IsDynamicPartition

Adding a test case for checking if flash task is a dynamic partition
flash task. This function is used since is-logical only works in
fastbootd, and should_flash_in_userspace() only works if
$ANDROID_PRODUCT_OUT is set. This function works with fastboot update
when called in bootloader without $OUT dir set

Test: fastboot_test
Change-Id: I65309f97e04fdfc449e61de5cd3a6feff18bc9ab
---
 fastboot/task_test.cpp | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/fastboot/task_test.cpp b/fastboot/task_test.cpp
index 42be3cb653ec..1e25b6f63e39 100644
--- a/fastboot/task_test.cpp
+++ b/fastboot/task_test.cpp
@@ -234,6 +234,35 @@ TEST_F(ParseTest, CorrectTaskLists) {
             << "size of fastboot-info task list: " << fastboot_info_tasks.size()
             << " size of hardcoded task list: " << hardcoded_tasks.size();
 }
+TEST_F(ParseTest, IsDynamicParitiontest) {
+    if (!get_android_product_out()) {
+        GTEST_SKIP();
+    }
+
+    LocalImageSource s;
+    fp->source = &s;
+
+    fastboot::MockFastbootDriver fb;
+    fp->fb = &fb;
+    fp->should_optimize_flash_super = true;
+    fp->should_use_fastboot_info = true;
+
+    std::vector<std::pair<std::string, bool>> test_cases = {
+            {"flash boot", false},
+            {"flash init_boot", false},
+            {"flash --apply-vbmeta vbmeta", false},
+            {"flash product", true},
+            {"flash system", true},
+            {"flash --slot-other system system_other.img", true},
+    };
+    for (auto& test : test_cases) {
+        std::unique_ptr<Task> task =
+                ParseFastbootInfoLine(fp.get(), android::base::Tokenize(test.first, " "));
+        auto flash_task = task->AsFlashTask();
+        ASSERT_FALSE(flash_task == nullptr);
+        ASSERT_EQ(FlashTask::IsDynamicParitition(fp->source, flash_task), test.second);
+    }
+}
 
 TEST_F(ParseTest, CanOptimizeTest) {
     if (!get_android_product_out()) {
@@ -275,6 +304,7 @@ TEST_F(ParseTest, CanOptimizeTest) {
         ASSERT_EQ(OptimizedFlashSuperTask::CanOptimize(fp->source, tasks), test.second);
     }
 }
+
 // Note: this test is exclusively testing that optimized flash super pattern matches a given task
 // list and is able to optimized based on a correct sequence of tasks
 TEST_F(ParseTest, OptimizedFlashSuperPatternMatchTest) {

From 18ff56d8d7a45706288d6f32752dc2802c5d44bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Thi=C3=A9baud=20Weksteen?= <tweek@google.com>
Date: Thu, 31 Aug 2023 14:22:15 +1000
Subject: [PATCH 0349/1487] Remove SeamendcHostTest from TEST_MAPPING

Bug: 297794885
Test: TH
Change-Id: I49c6caa575ccd570085de15ddf51ea9a71abe90f
---
 init/TEST_MAPPING | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/init/TEST_MAPPING b/init/TEST_MAPPING
index 402b501b9a67..36ca3793bcf9 100644
--- a/init/TEST_MAPPING
+++ b/init/TEST_MAPPING
@@ -8,14 +8,6 @@
     },
     {
       "name": "MicrodroidHostTestCases"
-    },
-    {
-      "name": "CtsSecurityHostTestCases",
-      "options": [
-        {
-          "include-filter": "android.security.cts.SeamendcHostTest"
-        }
-      ]
     }
   ],
   "hwasan-presubmit": [
@@ -27,14 +19,6 @@
     },
     {
       "name": "MicrodroidHostTestCases"
-    },
-    {
-      "name": "CtsSecurityHostTestCases",
-      "options": [
-        {
-          "include-filter": "android.security.cts.SeamendcHostTest"
-        }
-      ]
     }
   ]
 }

From dba385eddaf8dc0178d8b7f0d4c8c4f97024801e Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 24 Aug 2023 13:40:36 -0700
Subject: [PATCH 0350/1487] Ignore 16K kernel modules when running on 4K kernel

Test: th
Bug: 293313353
Change-Id: I02ea01c8e67b9ded164c7492eea3be0aead75de1
---
 init/first_stage_init.cpp | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index 3239eb7ca203..c6a287ab6278 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -163,6 +163,21 @@ std::string GetPageSizeSuffix() {
     return android::base::StringPrintf("_%zuk", page_size / 1024);
 }
 
+constexpr bool EndsWith(const std::string_view str, const std::string_view suffix) {
+    return str.size() >= suffix.size() &&
+           0 == str.compare(str.size() - suffix.size(), suffix.size(), suffix);
+}
+
+constexpr std::string_view GetPageSizeSuffix(std::string_view dirname) {
+    if (EndsWith(dirname, "_16k")) {
+        return "_16k";
+    }
+    if (EndsWith(dirname, "_64k")) {
+        return "_64k";
+    }
+    return "";
+}
+
 }  // namespace
 
 std::string GetModuleLoadList(BootMode boot_mode, const std::string& dir_path) {
@@ -211,7 +226,8 @@ bool LoadKernelModules(BootMode boot_mode, bool want_console, bool want_parallel
     }
     dirent* entry = nullptr;
     std::vector<std::string> module_dirs;
-    const std::string release_specific_module_dir = uts.release + GetPageSizeSuffix();
+    const auto page_size_suffix = GetPageSizeSuffix();
+    const std::string release_specific_module_dir = uts.release + page_size_suffix;
     while ((entry = readdir(base_dir.get()))) {
         if (entry->d_type != DT_DIR) {
             continue;
@@ -223,6 +239,10 @@ bool LoadKernelModules(BootMode boot_mode, bool want_console, bool want_parallel
             module_dirs.emplace_back(entry->d_name);
             break;
         }
+        // Ignore _16k/_64k module dirs on 4K kernels
+        if (GetPageSizeSuffix(entry->d_name) != page_size_suffix) {
+            continue;
+        }
         int dir_major = 0, dir_minor = 0;
         if (sscanf(entry->d_name, "%d.%d", &dir_major, &dir_minor) != 2 || dir_major != major ||
             dir_minor != minor) {

From 0b627d92c45baca2070f0ad88154a49472de542a Mon Sep 17 00:00:00 2001
From: Dmitrii Merkurev <dimorinny@google.com>
Date: Sun, 3 Sep 2023 17:30:46 +0100
Subject: [PATCH 0351/1487] fastboot: get rid of manual transport memory
 management

Existing code has transport memory leaks. Use smart pointers
for transport to get rid of those cases and manual memory
management

Test: atest fastboot_test
Test: manually checked transport isn't leaking anymore
Bug: 296629925
Change-Id: Ifdf162d5084f61ae5c1d2b56a897464af58100da
Signed-off-by: Dmitrii Merkurev <dimorinny@google.com>
---
 fastboot/fastboot.cpp                | 58 +++++++++++++---------------
 fastboot/fastboot_driver.cpp         | 10 ++---
 fastboot/fastboot_driver.h           |  9 ++---
 fastboot/fastboot_driver_test.cpp    | 38 ++++++++++--------
 fastboot/fuzzy_fastboot/fixtures.cpp | 10 ++---
 fastboot/fuzzy_fastboot/main.cpp     |  9 ++---
 fastboot/usb.h                       |  3 +-
 fastboot/usb_linux.cpp               | 10 ++++-
 fastboot/usb_osx.cpp                 | 12 ++++--
 fastboot/usb_windows.cpp             | 10 ++++-
 10 files changed, 92 insertions(+), 77 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 71a228ea1053..fa21ab72fdcc 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -350,23 +350,22 @@ Result<NetworkSerial, FastbootError> ParseNetworkSerial(const std::string& seria
 //
 // The returned Transport is a singleton, so multiple calls to this function will return the same
 // object, and the caller should not attempt to delete the returned Transport.
-static Transport* open_device(const char* local_serial, bool wait_for_device = true,
-                              bool announce = true) {
+static std::unique_ptr<Transport> open_device(const char* local_serial,
+                                              bool wait_for_device = true,
+                                              bool announce = true) {
     const Result<NetworkSerial, FastbootError> network_serial = ParseNetworkSerial(local_serial);
 
-    Transport* transport = nullptr;
+    std::unique_ptr<Transport> transport;
     while (true) {
         if (network_serial.ok()) {
             std::string error;
             if (network_serial->protocol == Socket::Protocol::kTcp) {
-                transport = tcp::Connect(network_serial->address, network_serial->port, &error)
-                                    .release();
+                transport = tcp::Connect(network_serial->address, network_serial->port, &error);
             } else if (network_serial->protocol == Socket::Protocol::kUdp) {
-                transport = udp::Connect(network_serial->address, network_serial->port, &error)
-                                    .release();
+                transport = udp::Connect(network_serial->address, network_serial->port, &error);
             }
 
-            if (transport == nullptr && announce) {
+            if (!transport && announce) {
                 LOG(ERROR) << "error: " << error;
             }
         } else if (network_serial.error().code() ==
@@ -378,12 +377,12 @@ static Transport* open_device(const char* local_serial, bool wait_for_device = t
             Expect(network_serial);
         }
 
-        if (transport != nullptr) {
+        if (transport) {
             return transport;
         }
 
         if (!wait_for_device) {
-            return nullptr;
+            return transport;
         }
 
         if (announce) {
@@ -394,9 +393,9 @@ static Transport* open_device(const char* local_serial, bool wait_for_device = t
     }
 }
 
-static Transport* NetworkDeviceConnected(bool print = false) {
-    Transport* transport = nullptr;
-    Transport* result = nullptr;
+static std::unique_ptr<Transport> NetworkDeviceConnected(bool print = false) {
+    std::unique_ptr<Transport> transport;
+    std::unique_ptr<Transport> result;
 
     ConnectedDevicesStorage storage;
     std::set<std::string> devices;
@@ -409,11 +408,11 @@ static Transport* NetworkDeviceConnected(bool print = false) {
         transport = open_device(device.c_str(), false, false);
 
         if (print) {
-            PrintDevice(device.c_str(), transport == nullptr ? "offline" : "fastboot");
+            PrintDevice(device.c_str(), transport ? "offline" : "fastboot");
         }
 
-        if (transport != nullptr) {
-            result = transport;
+        if (transport) {
+            result = std::move(transport);
         }
     }
 
@@ -431,21 +430,21 @@ static Transport* NetworkDeviceConnected(bool print = false) {
 //
 // The returned Transport is a singleton, so multiple calls to this function will return the same
 // object, and the caller should not attempt to delete the returned Transport.
-static Transport* open_device() {
+static std::unique_ptr<Transport> open_device() {
     if (serial != nullptr) {
         return open_device(serial);
     }
 
     bool announce = true;
-    Transport* transport = nullptr;
+    std::unique_ptr<Transport> transport;
     while (true) {
         transport = usb_open(match_fastboot(nullptr));
-        if (transport != nullptr) {
+        if (transport) {
             return transport;
         }
 
         transport = NetworkDeviceConnected();
-        if (transport != nullptr) {
+        if (transport) {
             return transport;
         }
 
@@ -455,6 +454,8 @@ static Transport* open_device() {
         }
         std::this_thread::sleep_for(std::chrono::seconds(1));
     }
+
+    return transport;
 }
 
 static int Connect(int argc, char* argv[]) {
@@ -466,8 +467,7 @@ static int Connect(int argc, char* argv[]) {
     const char* local_serial = *argv;
     Expect(ParseNetworkSerial(local_serial));
 
-    const Transport* transport = open_device(local_serial, false);
-    if (transport == nullptr) {
+    if (!open_device(local_serial, false)) {
         return 1;
     }
 
@@ -531,6 +531,7 @@ static void list_devices() {
     usb_open(list_devices_callback);
     NetworkDeviceConnected(/* print */ true);
 }
+
 void syntax_error(const char* fmt, ...) {
     fprintf(stderr, "fastboot: usage: ");
 
@@ -1547,9 +1548,7 @@ bool is_userspace_fastboot() {
 
 void reboot_to_userspace_fastboot() {
     fb->RebootTo("fastboot");
-
-    auto* old_transport = fb->set_transport(nullptr);
-    delete old_transport;
+    fb->set_transport(nullptr);
 
     // Give the current connection time to close.
     std::this_thread::sleep_for(std::chrono::seconds(1));
@@ -2377,8 +2376,8 @@ int FastBootTool::Main(int argc, char* argv[]) {
         return show_help();
     }
 
-    Transport* transport = open_device();
-    if (transport == nullptr) {
+    std::unique_ptr<Transport> transport = open_device();
+    if (!transport) {
         return 1;
     }
     fastboot::DriverCallbacks driver_callbacks = {
@@ -2388,7 +2387,7 @@ int FastBootTool::Main(int argc, char* argv[]) {
             .text = TextMessage,
     };
 
-    fastboot::FastBootDriver fastboot_driver(transport, driver_callbacks, false);
+    fastboot::FastBootDriver fastboot_driver(std::move(transport), driver_callbacks, false);
     fb = &fastboot_driver;
     fp->fb = &fastboot_driver;
 
@@ -2633,9 +2632,6 @@ int FastBootTool::Main(int argc, char* argv[]) {
     }
     fprintf(stderr, "Finished. Total time: %.3fs\n", (now() - start));
 
-    auto* old_transport = fb->set_transport(nullptr);
-    delete old_transport;
-
     return 0;
 }
 
diff --git a/fastboot/fastboot_driver.cpp b/fastboot/fastboot_driver.cpp
index 9770ab25cfc1..e5ef66bafe90 100644
--- a/fastboot/fastboot_driver.cpp
+++ b/fastboot/fastboot_driver.cpp
@@ -58,9 +58,10 @@ using namespace android::storage_literals;
 namespace fastboot {
 
 /*************************** PUBLIC *******************************/
-FastBootDriver::FastBootDriver(Transport* transport, DriverCallbacks driver_callbacks,
+FastBootDriver::FastBootDriver(std::unique_ptr<Transport> transport,
+                               DriverCallbacks driver_callbacks,
                                bool no_checks)
-    : transport_(transport),
+    : transport_(std::move(transport)),
       prolog_(std::move(driver_callbacks.prolog)),
       epilog_(std::move(driver_callbacks.epilog)),
       info_(std::move(driver_callbacks.info)),
@@ -627,9 +628,8 @@ int FastBootDriver::SparseWriteCallback(std::vector<char>& tpbuf, const char* da
     return 0;
 }
 
-Transport* FastBootDriver::set_transport(Transport* transport) {
-    std::swap(transport_, transport);
-    return transport;
+void FastBootDriver::set_transport(std::unique_ptr<Transport> transport) {
+    transport_ = std::move(transport);
 }
 
 }  // End namespace fastboot
diff --git a/fastboot/fastboot_driver.h b/fastboot/fastboot_driver.h
index 8774eadc6a6f..30298cb2072c 100644
--- a/fastboot/fastboot_driver.h
+++ b/fastboot/fastboot_driver.h
@@ -30,6 +30,7 @@
 #include <deque>
 #include <functional>
 #include <limits>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -63,7 +64,7 @@ class FastBootDriver : public IFastBootDriver {
     static constexpr uint32_t MAX_DOWNLOAD_SIZE = std::numeric_limits<uint32_t>::max();
     static constexpr size_t TRANSPORT_CHUNK_SIZE = 1024;
 
-    FastBootDriver(Transport* transport, DriverCallbacks driver_callbacks = {},
+    FastBootDriver(std::unique_ptr<Transport> transport, DriverCallbacks driver_callbacks = {},
                    bool no_checks = false);
     ~FastBootDriver();
 
@@ -124,9 +125,7 @@ class FastBootDriver : public IFastBootDriver {
     std::string Error();
     RetCode WaitForDisconnect() override;
 
-    // Note: set_transport will return the previous transport.
-    Transport* set_transport(Transport* transport);
-    Transport* transport() const { return transport_; }
+    void set_transport(std::unique_ptr<Transport> transport);
 
     RetCode RawCommand(const std::string& cmd, const std::string& message,
                        std::string* response = nullptr, std::vector<std::string>* info = nullptr,
@@ -143,7 +142,7 @@ class FastBootDriver : public IFastBootDriver {
 
     std::string ErrnoStr(const std::string& msg);
 
-    Transport* transport_;
+    std::unique_ptr<Transport> transport_;
 
   private:
     RetCode SendBuffer(android::base::borrowed_fd fd, size_t size);
diff --git a/fastboot/fastboot_driver_test.cpp b/fastboot/fastboot_driver_test.cpp
index 6f6cf8c49b04..d2033b0e2081 100644
--- a/fastboot/fastboot_driver_test.cpp
+++ b/fastboot/fastboot_driver_test.cpp
@@ -16,6 +16,7 @@
 
 #include "fastboot_driver.h"
 
+#include <memory>
 #include <optional>
 
 #include <gtest/gtest.h>
@@ -30,13 +31,14 @@ class DriverTest : public ::testing::Test {
 };
 
 TEST_F(DriverTest, GetVar) {
-    MockTransport transport;
-    FastBootDriver driver(&transport);
+    std::unique_ptr<MockTransport> transport_pointer = std::make_unique<MockTransport>();
+    MockTransport* transport = transport_pointer.get();
+    FastBootDriver driver(std::move(transport_pointer));
 
-    EXPECT_CALL(transport, Write(_, _))
+    EXPECT_CALL(*transport, Write(_, _))
             .With(AllArgs(RawData("getvar:version")))
             .WillOnce(ReturnArg<1>());
-    EXPECT_CALL(transport, Read(_, _)).WillOnce(Invoke(CopyData("OKAY0.4")));
+    EXPECT_CALL(*transport, Read(_, _)).WillOnce(Invoke(CopyData("OKAY0.4")));
 
     std::string output;
     ASSERT_EQ(driver.GetVar("version", &output), SUCCESS) << driver.Error();
@@ -44,14 +46,15 @@ TEST_F(DriverTest, GetVar) {
 }
 
 TEST_F(DriverTest, InfoMessage) {
-    MockTransport transport;
-    FastBootDriver driver(&transport);
+    std::unique_ptr<MockTransport> transport_pointer = std::make_unique<MockTransport>();
+    MockTransport* transport = transport_pointer.get();
+    FastBootDriver driver(std::move(transport_pointer));
 
-    EXPECT_CALL(transport, Write(_, _))
+    EXPECT_CALL(*transport, Write(_, _))
             .With(AllArgs(RawData("oem dmesg")))
             .WillOnce(ReturnArg<1>());
-    EXPECT_CALL(transport, Read(_, _)).WillOnce(Invoke(CopyData("INFOthis is an info line")));
-    EXPECT_CALL(transport, Read(_, _)).WillOnce(Invoke(CopyData("OKAY")));
+    EXPECT_CALL(*transport, Read(_, _)).WillOnce(Invoke(CopyData("INFOthis is an info line")));
+    EXPECT_CALL(*transport, Read(_, _)).WillOnce(Invoke(CopyData("OKAY")));
 
     std::vector<std::string> info;
     ASSERT_EQ(driver.RawCommand("oem dmesg", "", nullptr, &info), SUCCESS) << driver.Error();
@@ -60,28 +63,29 @@ TEST_F(DriverTest, InfoMessage) {
 }
 
 TEST_F(DriverTest, TextMessage) {
-    MockTransport transport;
     std::string text;
+    std::unique_ptr<MockTransport> transport_pointer = std::make_unique<MockTransport>();
+    MockTransport* transport = transport_pointer.get();
 
     DriverCallbacks callbacks{[](const std::string&) {}, [](int) {}, [](const std::string&) {},
                               [&text](const std::string& extra_text) { text += extra_text; }};
 
-    FastBootDriver driver(&transport, callbacks);
+    FastBootDriver driver(std::move(transport_pointer), callbacks);
 
-    EXPECT_CALL(transport, Write(_, _))
+    EXPECT_CALL(*transport, Write(_, _))
             .With(AllArgs(RawData("oem trusty runtest trusty.hwaes.bench")))
             .WillOnce(ReturnArg<1>());
-    EXPECT_CALL(transport, Read(_, _)).WillOnce(Invoke(CopyData("TEXTthis is a text line")));
-    EXPECT_CALL(transport, Read(_, _))
+    EXPECT_CALL(*transport, Read(_, _)).WillOnce(Invoke(CopyData("TEXTthis is a text line")));
+    EXPECT_CALL(*transport, Read(_, _))
             .WillOnce(Invoke(
                     CopyData("TEXT, albeit very long and split over multiple TEXT messages.")));
-    EXPECT_CALL(transport, Read(_, _))
+    EXPECT_CALL(*transport, Read(_, _))
             .WillOnce(Invoke(CopyData("TEXT Indeed we can do that now with a TEXT message whenever "
                                       "we feel like it.")));
-    EXPECT_CALL(transport, Read(_, _))
+    EXPECT_CALL(*transport, Read(_, _))
             .WillOnce(Invoke(CopyData("TEXT Isn't that truly super cool?")));
 
-    EXPECT_CALL(transport, Read(_, _)).WillOnce(Invoke(CopyData("OKAY")));
+    EXPECT_CALL(*transport, Read(_, _)).WillOnce(Invoke(CopyData("OKAY")));
 
     std::vector<std::string> info;
     ASSERT_EQ(driver.RawCommand("oem trusty runtest trusty.hwaes.bench", "", nullptr, &info),
diff --git a/fastboot/fuzzy_fastboot/fixtures.cpp b/fastboot/fuzzy_fastboot/fixtures.cpp
index 9b5e5f7bd2c2..94a53ed8c0c3 100644
--- a/fastboot/fuzzy_fastboot/fixtures.cpp
+++ b/fastboot/fuzzy_fastboot/fixtures.cpp
@@ -128,7 +128,7 @@ void FastBootTest::SetUp() {
             return MatchFastboot(info, device_serial);
         };
         for (int i = 0; i < MAX_USB_TRIES && !transport; i++) {
-            std::unique_ptr<UsbTransport> usb(usb_open(matcher, USB_TIMEOUT));
+            std::unique_ptr<UsbTransport> usb = usb_open(matcher, USB_TIMEOUT);
             if (usb)
                 transport = std::unique_ptr<TransportSniffer>(
                         new TransportSniffer(std::move(usb), serial_port));
@@ -143,7 +143,7 @@ void FastBootTest::SetUp() {
     } else {
         ASSERT_EQ(device_path, cb_scratch);  // The path can not change
     }
-    fb = std::unique_ptr<FastBootDriver>(new FastBootDriver(transport.get(), {}, true));
+    fb = std::unique_ptr<FastBootDriver>(new FastBootDriver(std::move(transport), {}, true));
     // No error checking since non-A/B devices may not support the command
     fb->GetVar("current-slot", &initial_slot);
 }
@@ -200,7 +200,7 @@ void FastBootTest::ReconnectFastbootDevice() {
     if (IsFastbootOverTcp()) {
         ConnectTcpFastbootDevice();
         device_path = cb_scratch;
-        fb = std::unique_ptr<FastBootDriver>(new FastBootDriver(transport.get(), {}, true));
+        fb = std::unique_ptr<FastBootDriver>(new FastBootDriver(std::move(transport), {}, true));
         return;
     }
 
@@ -212,7 +212,7 @@ void FastBootTest::ReconnectFastbootDevice() {
         return MatchFastboot(info, device_serial);
     };
     while (!transport) {
-        std::unique_ptr<UsbTransport> usb(usb_open(matcher, USB_TIMEOUT));
+        std::unique_ptr<UsbTransport> usb = usb_open(matcher, USB_TIMEOUT);
         if (usb) {
             transport = std::unique_ptr<TransportSniffer>(
                     new TransportSniffer(std::move(usb), serial_port));
@@ -220,7 +220,7 @@ void FastBootTest::ReconnectFastbootDevice() {
         std::this_thread::sleep_for(1s);
     }
     device_path = cb_scratch;
-    fb = std::unique_ptr<FastBootDriver>(new FastBootDriver(transport.get(), {}, true));
+    fb = std::unique_ptr<FastBootDriver>(new FastBootDriver(std::move(transport), {}, true));
 }
 
 void FastBootTest::SetLockState(bool unlock, bool assert_change) {
diff --git a/fastboot/fuzzy_fastboot/main.cpp b/fastboot/fuzzy_fastboot/main.cpp
index e6359374eb32..43aaec9d122a 100644
--- a/fastboot/fuzzy_fastboot/main.cpp
+++ b/fastboot/fuzzy_fastboot/main.cpp
@@ -166,16 +166,15 @@ TEST(USBFunctionality, USBConnect) {
     const auto matcher = [](usb_ifc_info* info) -> int {
         return FastBootTest::MatchFastboot(info, fastboot::FastBootTest::device_serial);
     };
-    Transport* transport = nullptr;
+    std::unique_ptr<Transport> transport;
     for (int i = 0; i < FastBootTest::MAX_USB_TRIES && !transport; i++) {
         transport = usb_open(matcher);
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
     }
-    ASSERT_NE(transport, nullptr) << "Could not find the fastboot device after: "
-                                  << 10 * FastBootTest::MAX_USB_TRIES << "ms";
+    ASSERT_NE(transport.get(), nullptr) << "Could not find the fastboot device after: "
+                                        << 10 * FastBootTest::MAX_USB_TRIES << "ms";
     if (transport) {
         transport->Close();
-        delete transport;
     }
 }
 
@@ -1897,7 +1896,7 @@ int main(int argc, char** argv) {
         const auto matcher = [](usb_ifc_info* info) -> int {
             return fastboot::FastBootTest::MatchFastboot(info, fastboot::FastBootTest::device_serial);
         };
-        Transport* transport = nullptr;
+        std::unique_ptr<Transport> transport;
         while (!transport) {
             transport = usb_open(matcher);
             std::this_thread::sleep_for(std::chrono::milliseconds(10));
diff --git a/fastboot/usb.h b/fastboot/usb.h
index 69581ab128d7..d85cb81868ec 100644
--- a/fastboot/usb.h
+++ b/fastboot/usb.h
@@ -29,6 +29,7 @@
 #pragma once
 
 #include <functional>
+#include <memory>
 
 #include "transport.h"
 
@@ -66,4 +67,4 @@ class UsbTransport : public Transport {
 typedef std::function<int(usb_ifc_info*)> ifc_match_func;
 
 // 0 is non blocking
-UsbTransport* usb_open(ifc_match_func callback, uint32_t timeout_ms = 0);
+std::unique_ptr<UsbTransport> usb_open(ifc_match_func callback, uint32_t timeout_ms = 0);
diff --git a/fastboot/usb_linux.cpp b/fastboot/usb_linux.cpp
index 964488cc87b5..37bb304ea127 100644
--- a/fastboot/usb_linux.cpp
+++ b/fastboot/usb_linux.cpp
@@ -503,9 +503,15 @@ int LinuxUsbTransport::Reset() {
     return 0;
 }
 
-UsbTransport* usb_open(ifc_match_func callback, uint32_t timeout_ms) {
+std::unique_ptr<UsbTransport> usb_open(ifc_match_func callback, uint32_t timeout_ms) {
+    std::unique_ptr<UsbTransport> result;
     std::unique_ptr<usb_handle> handle = find_usb_device("/sys/bus/usb/devices", callback);
-    return handle ? new LinuxUsbTransport(std::move(handle), timeout_ms) : nullptr;
+
+    if (handle) {
+        result = std::make_unique<LinuxUsbTransport>(std::move(handle), timeout_ms);
+    }
+
+    return result;
 }
 
 /* Wait for the system to notice the device is gone, so that a subsequent
diff --git a/fastboot/usb_osx.cpp b/fastboot/usb_osx.cpp
index 8b852f567a1f..28300b2e1808 100644
--- a/fastboot/usb_osx.cpp
+++ b/fastboot/usb_osx.cpp
@@ -469,16 +469,20 @@ static int init_usb(ifc_match_func callback, std::unique_ptr<usb_handle>* handle
 /*
  * Definitions of this file's public functions.
  */
-
-UsbTransport* usb_open(ifc_match_func callback, uint32_t timeout_ms) {
+std::unique_ptr<UsbTransport> usb_open(ifc_match_func callback, uint32_t timeout_ms) {
+    std::unique_ptr<UsbTransport> result;
     std::unique_ptr<usb_handle> handle;
 
     if (init_usb(callback, &handle) < 0) {
         /* Something went wrong initializing USB. */
-        return nullptr;
+        return result;
+    }
+
+    if (handle) {
+        result = std::make_unique<OsxUsbTransport>(std::move(handle), timeout_ms);
     }
 
-    return new OsxUsbTransport(std::move(handle), timeout_ms);
+    return result;
 }
 
 OsxUsbTransport::~OsxUsbTransport() {
diff --git a/fastboot/usb_windows.cpp b/fastboot/usb_windows.cpp
index 67bf8a30bf24..56a6e7d0e70d 100644
--- a/fastboot/usb_windows.cpp
+++ b/fastboot/usb_windows.cpp
@@ -381,7 +381,13 @@ static std::unique_ptr<usb_handle> find_usb_device(ifc_match_func callback) {
     return handle;
 }
 
-UsbTransport* usb_open(ifc_match_func callback, uint32_t) {
+std::unique_ptr<UsbTransport> usb_open(ifc_match_func callback, uint32_t) {
+    std::unique_ptr<UsbTransport> result;
     std::unique_ptr<usb_handle> handle = find_usb_device(callback);
-    return handle ? new WindowsUsbTransport(std::move(handle)) : nullptr;
+
+    if (handle) {
+        result = std::make_unique<WindowsUsbTransport>(std::move(handle));
+    }
+
+    return result;
 }

From e474f21a45b5e2b8973ffd378b119bf378cd0282 Mon Sep 17 00:00:00 2001
From: Hsin-Yi Chen <hsinyichen@google.com>
Date: Mon, 4 Sep 2023 11:16:34 +0800
Subject: [PATCH 0352/1487] Check the ABI of libutils for vendor and product
 only

It is not necessary to compare the dumps with the library installed in
system partition.

Test: m out/target/product/generic_x86_64/lsdump_paths.txt
Bug: 280008249
Change-Id: I8fc39ad17d37cd43bf1d77ba23dde55d05dadce1
---
 libutils/Android.bp | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/libutils/Android.bp b/libutils/Android.bp
index 162f0f44b73e..2c05fbc24cc5 100644
--- a/libutils/Android.bp
+++ b/libutils/Android.bp
@@ -185,10 +185,21 @@ cc_library {
         support_system_process: true,
     },
 
-    header_abi_checker: {
-        // AFDO affects weak symbols.
-        diff_flags: ["-allow-adding-removing-weak-symbols"],
-        ref_dump_dirs: ["abi-dumps"],
+    target: {
+        product: {
+            header_abi_checker: {
+                // AFDO affects weak symbols.
+                diff_flags: ["-allow-adding-removing-weak-symbols"],
+                ref_dump_dirs: ["abi-dumps"],
+            },
+        },
+        vendor: {
+            header_abi_checker: {
+                // AFDO affects weak symbols.
+                diff_flags: ["-allow-adding-removing-weak-symbols"],
+                ref_dump_dirs: ["abi-dumps"],
+            },
+        },
     },
 }
 

From 671a2a551a8f40c7d54ff30b148fd79dc8de0053 Mon Sep 17 00:00:00 2001
From: Chun-Wei Wang <wangchun@google.com>
Date: Wed, 30 Aug 2023 07:55:43 +0000
Subject: [PATCH 0353/1487] Add a fastboot command to show GSI status

The command will be used by RMA tool to skip
device wiping when it is already in GSI mode.

This change also makes it easier to add more
gsi commands in the future without needing to
update the host side tool (fastboot).

Bug: 298130522
Bug: 298138572
Test: 1. reboot into fastboot mode
      2. fastboot gsi status
Change-Id: Ic81f89a93b854f9ec70aebe2d209bfd1f98e3645
---
 fastboot/device/commands.cpp | 11 +++++++++++
 fastboot/fastboot.cpp        | 12 +++++-------
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/fastboot/device/commands.cpp b/fastboot/device/commands.cpp
index e929f42c2402..d60539332aea 100644
--- a/fastboot/device/commands.cpp
+++ b/fastboot/device/commands.cpp
@@ -661,6 +661,17 @@ bool GsiHandler(FastbootDevice* device, const std::vector<std::string>& args) {
         if (!android::gsi::DisableGsi()) {
             return device->WriteStatus(FastbootResult::FAIL, strerror(errno));
         }
+    } else if (args[1] == "status") {
+        std::string active_dsu;
+        if (!android::gsi::IsGsiRunning()) {
+            device->WriteInfo("Not running");
+        } else if (!android::gsi::GetActiveDsu(&active_dsu)) {
+            return device->WriteFail(strerror(errno));
+        } else {
+            device->WriteInfo("Running active DSU: " + active_dsu);
+        }
+    } else {
+        return device->WriteFail("Invalid arguments");
     }
     return device->WriteStatus(FastbootResult::OKAY, "Success");
 }
diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 71a228ea1053..f76afba0bda7 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -2579,14 +2579,12 @@ int FastBootTool::Main(int argc, char* argv[]) {
                     std::make_unique<ResizeTask>(fp.get(), partition, size, fp->slot_override);
             resize_task->Run();
         } else if (command == "gsi") {
-            std::string arg = next_arg(&args);
-            if (arg == "wipe") {
-                fb->RawCommand("gsi:wipe", "wiping GSI");
-            } else if (arg == "disable") {
-                fb->RawCommand("gsi:disable", "disabling GSI");
-            } else {
-                syntax_error("expected 'wipe' or 'disable'");
+            if (args.empty()) syntax_error("invalid gsi command");
+            std::string cmd("gsi");
+            while (!args.empty()) {
+                cmd += ":" + next_arg(&args);
             }
+            fb->RawCommand(cmd, "");
         } else if (command == "wipe-super") {
             std::string image;
             if (args.empty()) {

From e3bda36e0be2ad690ec48666d56eefcb26489378 Mon Sep 17 00:00:00 2001
From: Andrei Diea <adiea@google.com>
Date: Tue, 5 Sep 2023 19:29:13 +0000
Subject: [PATCH 0354/1487] debuggerd: add socksetopt to seccomp policy

aosp/2734054 added socket timeouts for nonblocking liblog ops.
seccomp policy was not updated so tests failed when unallowed
socksetopt syscall was made.

Bug: 298420226
Test: atest debuggerd_test

Change-Id: Iace232ec8b94e5d316d344abc5d866fe314607e0
Signed-off-by: Andrei Diea <adiea@google.com>
---
 debuggerd/seccomp_policy/crash_dump.arm.policy     | 1 +
 debuggerd/seccomp_policy/crash_dump.arm64.policy   | 1 +
 debuggerd/seccomp_policy/crash_dump.policy.def     | 1 +
 debuggerd/seccomp_policy/crash_dump.riscv64.policy | 1 +
 debuggerd/seccomp_policy/crash_dump.x86.policy     | 1 +
 debuggerd/seccomp_policy/crash_dump.x86_64.policy  | 1 +
 6 files changed, 6 insertions(+)

diff --git a/debuggerd/seccomp_policy/crash_dump.arm.policy b/debuggerd/seccomp_policy/crash_dump.arm.policy
index 8fd03c4273ce..a70ab203d257 100644
--- a/debuggerd/seccomp_policy/crash_dump.arm.policy
+++ b/debuggerd/seccomp_policy/crash_dump.arm.policy
@@ -20,6 +20,7 @@ getdents64: 1
 faccessat: 1
 recvmsg: 1
 recvfrom: 1
+setsockopt: 1
 sysinfo: 1
 process_vm_readv: 1
 tgkill: 1
diff --git a/debuggerd/seccomp_policy/crash_dump.arm64.policy b/debuggerd/seccomp_policy/crash_dump.arm64.policy
index 8241f0ee443b..adf87380e4bf 100644
--- a/debuggerd/seccomp_policy/crash_dump.arm64.policy
+++ b/debuggerd/seccomp_policy/crash_dump.arm64.policy
@@ -19,6 +19,7 @@ getdents64: 1
 faccessat: 1
 recvmsg: 1
 recvfrom: 1
+setsockopt: 1
 sysinfo: 1
 process_vm_readv: 1
 tgkill: 1
diff --git a/debuggerd/seccomp_policy/crash_dump.policy.def b/debuggerd/seccomp_policy/crash_dump.policy.def
index 0cb8e081dfff..972a575457b5 100644
--- a/debuggerd/seccomp_policy/crash_dump.policy.def
+++ b/debuggerd/seccomp_policy/crash_dump.policy.def
@@ -26,6 +26,7 @@ faccessat: 1
 recvmsg: 1
 recvfrom: 1
 sysinfo: 1
+setsockopt: 1
 
 process_vm_readv: 1
 
diff --git a/debuggerd/seccomp_policy/crash_dump.riscv64.policy b/debuggerd/seccomp_policy/crash_dump.riscv64.policy
index 281e231b0135..94a56772a672 100644
--- a/debuggerd/seccomp_policy/crash_dump.riscv64.policy
+++ b/debuggerd/seccomp_policy/crash_dump.riscv64.policy
@@ -19,6 +19,7 @@ getdents64: 1
 faccessat: 1
 recvmsg: 1
 recvfrom: 1
+setsockopt: 1
 sysinfo: 1
 process_vm_readv: 1
 tgkill: 1
diff --git a/debuggerd/seccomp_policy/crash_dump.x86.policy b/debuggerd/seccomp_policy/crash_dump.x86.policy
index 8fd03c4273ce..a70ab203d257 100644
--- a/debuggerd/seccomp_policy/crash_dump.x86.policy
+++ b/debuggerd/seccomp_policy/crash_dump.x86.policy
@@ -20,6 +20,7 @@ getdents64: 1
 faccessat: 1
 recvmsg: 1
 recvfrom: 1
+setsockopt: 1
 sysinfo: 1
 process_vm_readv: 1
 tgkill: 1
diff --git a/debuggerd/seccomp_policy/crash_dump.x86_64.policy b/debuggerd/seccomp_policy/crash_dump.x86_64.policy
index 281e231b0135..94a56772a672 100644
--- a/debuggerd/seccomp_policy/crash_dump.x86_64.policy
+++ b/debuggerd/seccomp_policy/crash_dump.x86_64.policy
@@ -19,6 +19,7 @@ getdents64: 1
 faccessat: 1
 recvmsg: 1
 recvfrom: 1
+setsockopt: 1
 sysinfo: 1
 process_vm_readv: 1
 tgkill: 1

From f83c5c8fecf89d9315945368aa20350c2f235cc0 Mon Sep 17 00:00:00 2001
From: Keith Mok <keithmok@google.com>
Date: Thu, 31 Aug 2023 00:31:35 +0000
Subject: [PATCH 0355/1487] Add seal if ashmem-dev is backed by memfd

Need to seal the buffer size in align with ashmem if set to PROT_READ
only to prevent untrusted remote process to shrink the buffer size and
crash it.

Bug: 294609150
Test: build
Ignore-AOSP-First: Security
Change-Id: I9288cf30b41e84ad8d3247c204e20482912bff69
---
 libcutils/ashmem-dev.cpp | 29 +++++++++++++++++++++++++----
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index 6a27f9a2004b..56d68759f348 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -349,6 +349,12 @@ static int memfd_create_region(const char* name, size_t size) {
         return -1;
     }
 
+    // forbid size changes to match ashmem behaviour
+    if (fcntl(fd, F_ADD_SEALS, F_SEAL_GROW | F_SEAL_SHRINK) == -1) {
+        ALOGE("memfd_create(%s, %zd) F_ADD_SEALS failed: %m", name, size);
+        return -1;
+    }
+
     if (debug_log) {
         ALOGE("memfd_create(%s, %zd) success. fd=%d\n", name, size, fd.get());
     }
@@ -400,14 +406,29 @@ int ashmem_create_region(const char *name, size_t size)
 }
 
 static int memfd_set_prot_region(int fd, int prot) {
-    /* Only proceed if an fd needs to be write-protected */
+    int seals = fcntl(fd, F_GET_SEALS);
+    if (seals == -1) {
+        ALOGE("memfd_set_prot_region(%d, %d): F_GET_SEALS failed: %s\n", fd, prot, strerror(errno));
+        return -1;
+    }
+
     if (prot & PROT_WRITE) {
+        /* Now we want the buffer to be read-write, let's check if the buffer
+         * has been previously marked as read-only before, if so return error
+         */
+        if (seals & F_SEAL_FUTURE_WRITE) {
+            ALOGE("memfd_set_prot_region(%d, %d): region is write protected\n", fd, prot);
+            errno = EINVAL;  // inline with ashmem error code, if already in
+                             // read-only mode
+            return -1;
+        }
         return 0;
     }
 
-    if (fcntl(fd, F_ADD_SEALS, F_SEAL_FUTURE_WRITE) == -1) {
-        ALOGE("memfd_set_prot_region(%d, %d): F_SEAL_FUTURE_WRITE seal failed: %s\n", fd, prot,
-              strerror(errno));
+    /* We would only allow read-only for any future file operations */
+    if (fcntl(fd, F_ADD_SEALS, F_SEAL_FUTURE_WRITE | F_SEAL_SEAL) == -1) {
+        ALOGE("memfd_set_prot_region(%d, %d): F_SEAL_FUTURE_WRITE | F_SEAL_SEAL seal failed: %s\n",
+              fd, prot, strerror(errno));
         return -1;
     }
 

From 214d62e3f79a80e1c8e1cd466f2b2412f56e2894 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 4 Sep 2023 00:47:19 -0700
Subject: [PATCH 0356/1487] create_snapshot: Create snapshot patch comparing
 two partition images

This is a host based tool wherein it compares two Android images and generates snapshot patches which are similar to Android OTA format.

There are few advantages:

1: All the computation of snapshot logic is pushed onto the host.
2: Each partition can have different compression algorithm.
3: All the libsnapshot_cow changes can be tested very quickly.

Here is the test run. This compares two builds which are 24 hours apart.

```

create_snapshot --source=$ANDROID_PRODUCT_OUT/system.img --target=./images/system.img --compression="zstd" &
create_snapshot --source=$ANDROID_PRODUCT_OUT/product.img --target=./images/product.img --compression="lz4" &
create_snapshot --source=$ANDROID_PRODUCT_OUT/vendor.img --target=./images/vendor.img &
create_snapshot --source=$ANDROID_PRODUCT_OUT/system_ext.img --target=./images/system_ext.img --compression="gz" &
create_snapshot --source=$ANDROID_PRODUCT_OUT/vendor_dlkm.img --target=./images/vendor_dlkm.img &

echo "Waiting for snapshot patch creation"
wait $(jobs -p)
echo "Snapshot patch creation completed"
```

========================================
Waiting for snapshot patch creation
Snapshot patch: vendor_dlkm.patch created successfully
Snapshot patch: vendor.patch created successfully
Snapshot patch: system_ext.patch created successfully
Snapshot patch: product.patch created successfully
Snapshot patch: system.patch created successfully
Snapshot patch creation completed

real	0m3.848s
user	0m14.239s
sys	0m8.045s
========================================

It takes ~4 seconds to generate the snapshot patches on the host. Snapshot patches are named as <partition-name>.patch.

Bug: 299011882
Test: create_snapshot between two builds as mentioned above.
Change-Id: Ic87dd3349a866b5626fa03f1f879f417a8116cc2
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/Android.bp                 |  32 ++
 .../libsnapshot_cow/create_cow.cpp            | 359 ++++++++++++++++++
 2 files changed, 391 insertions(+)
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 04b5a021ad5f..b0f2b846d5ec 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -446,6 +446,38 @@ cc_binary {
     ],
 }
 
+cc_binary {
+    name: "create_snapshot",
+    host_supported: true,
+    device_supported: false,
+
+    srcs: ["libsnapshot_cow/create_cow.cpp"],
+
+    cflags: [
+        "-Wall",
+        "-Werror",
+    ],
+
+    static_libs: [
+        "liblog",
+        "libbase",
+        "libext4_utils",
+        "libsnapshot_cow",
+        "libcrypto",
+        "libbrotli",
+        "libz",
+        "liblz4",
+        "libzstd",
+        "libgflags",
+    ],
+    shared_libs: [
+    ],
+
+    header_libs: [
+        "libstorage_literals_headers",
+    ],
+}
+
 python_library_host {
     name: "snapshot_proto_python",
     srcs: [
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
new file mode 100644
index 000000000000..4e07fe3b3e0b
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
@@ -0,0 +1,359 @@
+#include <linux/types.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <condition_variable>
+#include <cstring>
+#include <future>
+#include <iostream>
+#include <limits>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/stringprintf.h>
+#include <android-base/unique_fd.h>
+#include <ext4_utils/ext4_utils.h>
+#include <storage_literals/storage_literals.h>
+
+#include <android-base/chrono_utils.h>
+#include <android-base/scopeguard.h>
+#include <android-base/strings.h>
+
+#include <gflags/gflags.h>
+#include <libsnapshot/cow_writer.h>
+
+#include <openssl/sha.h>
+
+DEFINE_string(source, "", "Source partition image");
+DEFINE_string(target, "", "Target partition image");
+DEFINE_string(compression, "lz4",
+              "Compression algorithm. Default is set to lz4. Available options: lz4, zstd, gz");
+
+namespace android {
+namespace snapshot {
+
+using namespace android::storage_literals;
+using namespace android;
+using android::base::unique_fd;
+
+using android::snapshot::CreateCowWriter;
+using android::snapshot::ICowWriter;
+
+class CreateSnapshot {
+  public:
+    CreateSnapshot(const std::string& src_file, const std::string& target_file,
+                   const std::string& patch_file, const std::string& compression);
+    bool CreateSnapshotPatch();
+
+  private:
+    /* source.img */
+    std::string src_file_;
+    /* target.img */
+    std::string target_file_;
+    /* snapshot-patch generated */
+    std::string patch_file_;
+
+    /*
+     * Active file which is being parsed by this instance.
+     * It will either be source.img or target.img.
+     */
+    std::string parsing_file_;
+    bool create_snapshot_patch_ = false;
+
+    const int kNumThreads = 6;
+    const size_t kBlockSizeToRead = 1_MiB;
+
+    std::unordered_map<std::string, int> source_block_hash_;
+    std::mutex source_block_hash_lock_;
+
+    std::unique_ptr<ICowWriter> writer_;
+    std::mutex write_lock_;
+
+    std::unique_ptr<uint8_t[]> zblock_;
+
+    std::string compression_ = "lz4";
+    unique_fd fd_;
+
+    const int BLOCK_SZ = 4_KiB;
+    void SHA256(const void* data, size_t length, uint8_t out[32]);
+    bool IsBlockAligned(uint64_t read_size) { return ((read_size & (BLOCK_SZ - 1)) == 0); }
+    bool ReadBlocks(off_t offset, const int skip_blocks, const uint64_t dev_sz);
+    std::string ToHexString(const uint8_t* buf, size_t len);
+
+    bool CreateSnapshotFile();
+    bool FindSourceBlockHash();
+    bool PrepareParse(std::string& parsing_file, const bool createSnapshot);
+    bool ParsePartition();
+    bool WriteSnapshot(const void* buffer, uint64_t block, std::string& block_hash);
+};
+
+void CreateSnapshotLogger(android::base::LogId, android::base::LogSeverity severity, const char*,
+                          const char*, unsigned int, const char* message) {
+    if (severity == android::base::ERROR) {
+        fprintf(stderr, "%s\n", message);
+    } else {
+        fprintf(stdout, "%s\n", message);
+    }
+}
+
+CreateSnapshot::CreateSnapshot(const std::string& src_file, const std::string& target_file,
+                               const std::string& patch_file, const std::string& compression)
+    : src_file_(src_file), target_file_(target_file), patch_file_(patch_file) {
+    if (!compression.empty()) {
+        compression_ = compression;
+    }
+}
+
+bool CreateSnapshot::PrepareParse(std::string& parsing_file, const bool createSnapshot) {
+    parsing_file_ = parsing_file;
+    create_snapshot_patch_ = createSnapshot;
+
+    if (createSnapshot) {
+        fd_.reset(open(patch_file_.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666));
+        if (fd_ < 0) {
+            PLOG(ERROR) << "Failed to open the snapshot-patch file: " << patch_file_;
+            return false;
+        }
+
+        zblock_ = std::make_unique<uint8_t[]>(BLOCK_SZ);
+        std::memset(zblock_.get(), 0, BLOCK_SZ);
+
+        CowOptions options;
+        options.compression = compression_;
+        options.num_compress_threads = 2;
+        options.batch_write = true;
+        options.cluster_ops = 600;
+        writer_ = CreateCowWriter(2, options, std::move(fd_));
+    }
+    return true;
+}
+
+/*
+ * Create per-block sha256 hash of source partition
+ */
+bool CreateSnapshot::FindSourceBlockHash() {
+    if (!PrepareParse(src_file_, false)) {
+        return false;
+    }
+    return ParsePartition();
+}
+
+/*
+ * Create snapshot file by comparing sha256 per block
+ * of target.img with the constructed per-block sha256 hash
+ * of source partition.
+ */
+bool CreateSnapshot::CreateSnapshotFile() {
+    if (!PrepareParse(target_file_, true)) {
+        return false;
+    }
+    return ParsePartition();
+}
+
+/*
+ * Creates snapshot patch file by comparing source.img and target.img
+ */
+bool CreateSnapshot::CreateSnapshotPatch() {
+    if (!FindSourceBlockHash()) {
+        return false;
+    }
+    return CreateSnapshotFile();
+}
+
+void CreateSnapshot::SHA256(const void* data, size_t length, uint8_t out[32]) {
+    SHA256_CTX c;
+    SHA256_Init(&c);
+    SHA256_Update(&c, data, length);
+    SHA256_Final(out, &c);
+}
+
+std::string CreateSnapshot::ToHexString(const uint8_t* buf, size_t len) {
+    char lookup[] = "0123456789abcdef";
+    std::string out(len * 2 + 1, '\0');
+    char* outp = out.data();
+    for (; len > 0; len--, buf++) {
+        *outp++ = (char)lookup[*buf >> 4];
+        *outp++ = (char)lookup[*buf & 0xf];
+    }
+    return out;
+}
+
+bool CreateSnapshot::WriteSnapshot(const void* buffer, uint64_t block, std::string& block_hash) {
+    if (std::memcmp(zblock_.get(), buffer, BLOCK_SZ) == 0) {
+        std::lock_guard<std::mutex> lock(write_lock_);
+        return writer_->AddZeroBlocks(block, 1);
+    }
+
+    auto iter = source_block_hash_.find(block_hash);
+    if (iter != source_block_hash_.end()) {
+        std::lock_guard<std::mutex> lock(write_lock_);
+        return writer_->AddCopy(block, iter->second, 1);
+    }
+    std::lock_guard<std::mutex> lock(write_lock_);
+    return writer_->AddRawBlocks(block, buffer, BLOCK_SZ);
+}
+
+bool CreateSnapshot::ReadBlocks(off_t offset, const int skip_blocks, const uint64_t dev_sz) {
+    unique_fd fd(TEMP_FAILURE_RETRY(open(parsing_file_.c_str(), O_RDONLY)));
+    if (fd < 0) {
+        LOG(ERROR) << "open failed: " << parsing_file_;
+        return false;
+    }
+
+    loff_t file_offset = offset;
+    const uint64_t read_sz = kBlockSizeToRead;
+    std::unique_ptr<uint8_t[]> buffer = std::make_unique<uint8_t[]>(read_sz);
+
+    while (true) {
+        size_t to_read = std::min((dev_sz - file_offset), read_sz);
+
+        if (!android::base::ReadFullyAtOffset(fd.get(), buffer.get(), to_read, file_offset)) {
+            LOG(ERROR) << "Failed to read block from block device: " << parsing_file_
+                       << " at offset: " << file_offset << " read-size: " << to_read
+                       << " block-size: " << dev_sz;
+            return false;
+        }
+
+        if (!IsBlockAligned(to_read)) {
+            LOG(ERROR) << "unable to parse the un-aligned request: " << to_read;
+            return false;
+        }
+
+        size_t num_blocks = to_read / BLOCK_SZ;
+        uint64_t buffer_offset = 0;
+        off_t foffset = file_offset;
+
+        while (num_blocks) {
+            const void* bufptr = (char*)buffer.get() + buffer_offset;
+            uint64_t blkindex = foffset / BLOCK_SZ;
+
+            uint8_t checksum[32];
+            SHA256(bufptr, BLOCK_SZ, checksum);
+            std::string hash = ToHexString(checksum, sizeof(checksum));
+
+            if (create_snapshot_patch_ && !WriteSnapshot(bufptr, blkindex, hash)) {
+                LOG(ERROR) << "WriteSnapshot failed for block: " << blkindex;
+                return false;
+            } else {
+                std::lock_guard<std::mutex> lock(source_block_hash_lock_);
+                {
+                    if (source_block_hash_.count(hash) == 0) {
+                        source_block_hash_[hash] = blkindex;
+                    }
+                }
+            }
+            buffer_offset += BLOCK_SZ;
+            foffset += BLOCK_SZ;
+            num_blocks -= 1;
+        }
+
+        file_offset += (skip_blocks * kBlockSizeToRead);
+        if (file_offset >= dev_sz) {
+            break;
+        }
+    }
+
+    return true;
+}
+
+bool CreateSnapshot::ParsePartition() {
+    unique_fd fd(TEMP_FAILURE_RETRY(open(parsing_file_.c_str(), O_RDONLY)));
+    if (fd < 0) {
+        LOG(ERROR) << "open failed: " << parsing_file_;
+        return false;
+    }
+
+    uint64_t dev_sz = lseek(fd.get(), 0, SEEK_END);
+    if (!dev_sz) {
+        LOG(ERROR) << "Could not determine block device size: " << parsing_file_;
+        return false;
+    }
+
+    if (!IsBlockAligned(dev_sz)) {
+        LOG(ERROR) << "dev_sz: " << dev_sz << " is not block aligned";
+        return false;
+    }
+
+    int num_threads = kNumThreads;
+
+    std::vector<std::future<bool>> threads;
+    off_t start_offset = 0;
+    const int skip_blocks = num_threads;
+
+    while (num_threads) {
+        threads.emplace_back(std::async(std::launch::async, &CreateSnapshot::ReadBlocks, this,
+                                        start_offset, skip_blocks, dev_sz));
+        start_offset += kBlockSizeToRead;
+        num_threads -= 1;
+        if (start_offset >= dev_sz) {
+            break;
+        }
+    }
+
+    bool ret = true;
+    for (auto& t : threads) {
+        ret = t.get() && ret;
+    }
+
+    if (ret && create_snapshot_patch_ && !writer_->Finalize()) {
+        LOG(ERROR) << "Finzalize failed";
+        return false;
+    }
+
+    return ret;
+}
+
+}  // namespace snapshot
+}  // namespace android
+
+constexpr char kUsage[] = R"(
+NAME
+    create_snapshot - Create snapshot patches by comparing two partition images
+
+SYNOPSIS
+    create_snapshot --source=<source.img> --target=<target.img> --compression="<compression-algorithm"
+
+    source.img -> Source partition image
+    target.img -> Target partition image
+    compressoin -> compression algorithm. Default set to lz4. Supported types are gz, lz4, zstd.
+
+EXAMPLES
+
+   $ create_snapshot $SOURCE_BUILD/system.img $TARGET_BUILD/system.img
+   $ create_snapshot $SOURCE_BUILD/product.img $TARGET_BUILD/product.img --compression="zstd"
+
+)";
+
+int main(int argc, char* argv[]) {
+    android::base::InitLogging(argv, &android::snapshot::CreateSnapshotLogger);
+    ::gflags::SetUsageMessage(kUsage);
+    ::gflags::ParseCommandLineFlags(&argc, &argv, true);
+
+    if (FLAGS_source.empty() || FLAGS_target.empty()) {
+        LOG(INFO) << kUsage;
+        return 0;
+    }
+
+    std::string fname = android::base::Basename(FLAGS_target.c_str());
+    auto parts = android::base::Split(fname, ".");
+    std::string snapshotfile = parts[0] + ".patch";
+    android::snapshot::CreateSnapshot snapshot(FLAGS_source, FLAGS_target, snapshotfile,
+                                               FLAGS_compression);
+
+    if (!snapshot.CreateSnapshotPatch()) {
+        LOG(ERROR) << "Snapshot creation failed";
+        return -1;
+    }
+
+    LOG(INFO) << "Snapshot patch: " << snapshotfile << " created successfully";
+    return 0;
+}

From 50f03fd58e4cfd75cbdde1d779893f66485e4a49 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Thi=C3=A9baud=20Weksteen?= <tweek@google.com>
Date: Wed, 6 Sep 2023 10:52:49 +1000
Subject: [PATCH 0357/1487] Revert "Use Apex sepolicy if it's available"

This reverts commit baeece6d0c0ff72f667318ec365e5281955c8f42.

Test: boot aosp_cf_x86_64_phone-userdebug
Bug: 297794885
Change-Id: I0515bc30eba42589c407deb587684b4da011aead
---
 init/Android.bp           |   3 -
 init/property_service.cpp |   4 -
 init/selinux.cpp          | 247 +++-----------------------------------
 3 files changed, 16 insertions(+), 238 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index d4852d6483be..4c25ad7b7adc 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -174,7 +174,6 @@ libinit_cc_defaults {
         "libprotobuf-cpp-lite",
         "libpropertyinfoserializer",
         "libpropertyinfoparser",
-        "libsigningutils",
         "libsnapshot_cow",
         "libsnapshot_init",
         "libxml2",
@@ -183,7 +182,6 @@ libinit_cc_defaults {
     ],
     shared_libs: [
         "libbase",
-        "libcrypto",
         "libcutils",
         "libdl",
         "libext4_utils",
@@ -199,7 +197,6 @@ libinit_cc_defaults {
         "libselinux",
         "libunwindstack",
         "libutils",
-        "libziparchive",
     ],
     header_libs: ["bionic_libc_platform_headers"],
     bootstrap: true,
diff --git a/init/property_service.cpp b/init/property_service.cpp
index f5de17d82bf1..2064fae8f14c 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1247,9 +1247,6 @@ void CreateSerializedPropertyInfo() {
         // Don't check for failure here, since we don't always have all of these partitions.
         // E.g. In case of recovery, the vendor partition will not have mounted and we
         // still need the system / platform properties to function.
-        if (access("/dev/selinux/apex_property_contexts", R_OK) != -1) {
-            LoadPropertyInfoFromFile("/dev/selinux/apex_property_contexts", &property_infos);
-        }
         if (access("/system_ext/etc/selinux/system_ext_property_contexts", R_OK) != -1) {
             LoadPropertyInfoFromFile("/system_ext/etc/selinux/system_ext_property_contexts",
                                      &property_infos);
@@ -1273,7 +1270,6 @@ void CreateSerializedPropertyInfo() {
         LoadPropertyInfoFromFile("/vendor_property_contexts", &property_infos);
         LoadPropertyInfoFromFile("/product_property_contexts", &property_infos);
         LoadPropertyInfoFromFile("/odm_property_contexts", &property_infos);
-        LoadPropertyInfoFromFile("/dev/selinux/apex_property_contexts", &property_infos);
     }
 
     auto serialized_contexts = std::string();
diff --git a/init/selinux.cpp b/init/selinux.cpp
index ac102eb4e4ce..9095b854eb18 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -26,29 +26,26 @@
 // The monolithic policy variant is for legacy non-treble devices that contain a single SEPolicy
 // file located at /sepolicy and is directly loaded into the kernel SELinux subsystem.
 
-// The split policy is for supporting treble devices and updateable apexes.  It splits the SEPolicy
-// across files on /system/etc/selinux (the 'plat' portion of the policy), /vendor/etc/selinux
-// (the 'vendor' portion of the policy), /system_ext/etc/selinux, /product/etc/selinux,
-// /odm/etc/selinux, and /dev/selinux (the apex portion of policy).  This is necessary to allow
-// images to be updated independently of the vendor image, while maintaining contributions from
-// multiple partitions in the SEPolicy.  This is especially important for VTS testing, where the
-// SEPolicy on the Google System Image may not be identical to the system image shipped on a
-// vendor's device.
+// The split policy is for supporting treble devices.  It splits the SEPolicy across files on
+// /system/etc/selinux (the 'plat' portion of the policy) and /vendor/etc/selinux (the 'vendor'
+// portion of the policy).  This is necessary to allow the system image to be updated independently
+// of the vendor image, while maintaining contributions from both partitions in the SEPolicy.  This
+// is especially important for VTS testing, where the SEPolicy on the Google System Image may not be
+// identical to the system image shipped on a vendor's device.
 
 // The split SEPolicy is loaded as described below:
 // 1) There is a precompiled SEPolicy located at either /vendor/etc/selinux/precompiled_sepolicy or
 //    /odm/etc/selinux/precompiled_sepolicy if odm parition is present.  Stored along with this file
-//    are the sha256 hashes of the parts of the SEPolicy on /system, /system_ext, /product, and apex
-//    that were used to compile this precompiled policy.  The system partition contains a similar
-//    sha256 of the parts of the SEPolicy that it currently contains. Symmetrically, system_ext,
-//    product, and apex contain sha256 hashes of their SEPolicy. Init loads this
+//    are the sha256 hashes of the parts of the SEPolicy on /system, /system_ext and /product that
+//    were used to compile this precompiled policy.  The system partition contains a similar sha256
+//    of the parts of the SEPolicy that it currently contains.  Symmetrically, system_ext and
+//    product paritition contain sha256 hashes of their SEPolicy.  The init loads this
 //    precompiled_sepolicy directly if and only if the hashes along with the precompiled SEPolicy on
-//    /vendor or /odm match the hashes for system, system_ext, product, and apex SEPolicy,
-//    respectively.
-// 2) If these hashes do not match, then either /system or /system_ext /product, or apex (or some of
-//    them) have been updated out of sync with /vendor (or /odm if it is present) and the init needs
-//    to compile the SEPolicy.  /system contains the SEPolicy compiler, secilc, and it is used by
-//    the OpenSplitPolicy() function below to compile the SEPolicy to a temp directory and load it.
+//    /vendor or /odm match the hashes for system, system_ext and product SEPolicy, respectively.
+// 2) If these hashes do not match, then either /system or /system_ext or /product (or some of them)
+//    have been updated out of sync with /vendor (or /odm if it is present) and the init needs to
+//    compile the SEPolicy.  /system contains the SEPolicy compiler, secilc, and it is used by the
+//    OpenSplitPolicy() function below to compile the SEPolicy to a temp directory and load it.
 //    That function contains even more documentation with the specific implementation details of how
 //    the SEPolicy is compiled if needed.
 
@@ -61,15 +58,12 @@
 #include <stdlib.h>
 #include <sys/wait.h>
 #include <unistd.h>
-#include <fstream>
 
-#include <CertUtils.h>
 #include <android-base/chrono_utils.h>
 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/parseint.h>
 #include <android-base/result.h>
-#include <android-base/scopeguard.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 #include <fs_avb/fs_avb.h>
@@ -77,7 +71,6 @@
 #include <libgsi/libgsi.h>
 #include <libsnapshot/snapshot.h>
 #include <selinux/android.h>
-#include <ziparchive/zip_archive.h>
 
 #include "block_dev_initializer.h"
 #include "debug_ramdisk.h"
@@ -245,7 +238,6 @@ Result<std::string> FindPrecompiledSplitPolicy() {
              precompiled_sepolicy + ".system_ext_sepolicy_and_mapping.sha256"},
             {"/product/etc/selinux/product_sepolicy_and_mapping.sha256",
              precompiled_sepolicy + ".product_sepolicy_and_mapping.sha256"},
-            {"/dev/selinux/apex_sepolicy.sha256", precompiled_sepolicy + ".apex_sepolicy.sha256"},
     };
 
     for (const auto& [actual_id_path, precompiled_id_path] : sepolicy_hashes) {
@@ -324,7 +316,7 @@ bool OpenSplitPolicy(PolicyFile* policy_file) {
     // * vendor -- policy needed due to logic contained in the vendor image,
     // * mapping -- mapping policy which helps preserve forward-compatibility of non-platform policy
     //   with newer versions of platform policy.
-    // * (optional) policy needed due to logic on product, system_ext, odm, or apex.
+    // * (optional) policy needed due to logic on product, system_ext, or odm images.
     // secilc is invoked to compile the above three policy files into a single monolithic policy
     // file. This file is then loaded into the kernel.
 
@@ -420,12 +412,6 @@ bool OpenSplitPolicy(PolicyFile* policy_file) {
     if (access(odm_policy_cil_file.c_str(), F_OK) == -1) {
         odm_policy_cil_file.clear();
     }
-
-    // apex_sepolicy.cil is default but optional.
-    std::string apex_policy_cil_file("/dev/selinux/apex_sepolicy.cil");
-    if (access(apex_policy_cil_file.c_str(), F_OK) == -1) {
-        apex_policy_cil_file.clear();
-    }
     const std::string version_as_string = std::to_string(SEPOLICY_VERSION);
 
     // clang-format off
@@ -468,9 +454,6 @@ bool OpenSplitPolicy(PolicyFile* policy_file) {
     if (!odm_policy_cil_file.empty()) {
         compile_args.push_back(odm_policy_cil_file.c_str());
     }
-    if (!apex_policy_cil_file.empty()) {
-        compile_args.push_back(apex_policy_cil_file.c_str());
-    }
     compile_args.push_back(nullptr);
 
     if (!ForkExecveAndWaitForCompletion(compile_args[0], (char**)compile_args.data())) {
@@ -497,194 +480,6 @@ bool OpenMonolithicPolicy(PolicyFile* policy_file) {
     return true;
 }
 
-constexpr const char* kSigningCertRelease =
-        "/system/etc/selinux/com.android.sepolicy.cert-release.der";
-const std::string kSepolicyApexMetadataDir = "/metadata/sepolicy/";
-const std::string kSepolicyApexSystemDir = "/system/etc/selinux/apex/";
-const std::string kSepolicyZip = "SEPolicy.zip";
-const std::string kSepolicySignature = "SEPolicy.zip.sig";
-
-const std::string kTmpfsDir = "/dev/selinux/";
-
-// Files that are deleted after policy is compiled/loaded.
-const std::vector<std::string> kApexSepolicyTmp{"apex_sepolicy.cil", "apex_sepolicy.sha256"};
-// Files that need to persist because they are used by userspace processes.
-const std::vector<std::string> kApexSepolicy{"apex_file_contexts", "apex_property_contexts",
-                                             "apex_service_contexts", "apex_seapp_contexts",
-                                             "apex_test"};
-
-Result<void> CreateTmpfsDir() {
-    mode_t mode = 0744;
-    struct stat stat_data;
-    if (stat(kTmpfsDir.c_str(), &stat_data) != 0) {
-        if (errno != ENOENT) {
-            return ErrnoError() << "Could not stat " << kTmpfsDir;
-        }
-        if (mkdir(kTmpfsDir.c_str(), mode) != 0) {
-            return ErrnoError() << "Could not mkdir " << kTmpfsDir;
-        }
-    } else {
-        if (!S_ISDIR(stat_data.st_mode)) {
-            return Error() << kTmpfsDir << " exists and is not a directory.";
-        }
-        LOG(WARNING) << "Directory " << kTmpfsDir << " already exists";
-    }
-
-    // Need to manually call chmod because mkdir will create a folder with
-    // permissions mode & ~umask.
-    if (chmod(kTmpfsDir.c_str(), mode) != 0) {
-        return ErrnoError() << "Could not chmod " << kTmpfsDir;
-    }
-
-    return {};
-}
-
-Result<void> PutFileInTmpfs(ZipArchiveHandle archive, const std::string& fileName) {
-    ZipEntry entry;
-    std::string dstPath = kTmpfsDir + fileName;
-
-    int ret = FindEntry(archive, fileName, &entry);
-    if (ret != 0) {
-        // All files are optional. If a file doesn't exist, return without error.
-        return {};
-    }
-
-    unique_fd fd(TEMP_FAILURE_RETRY(
-            open(dstPath.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, S_IRUSR | S_IWUSR)));
-    if (fd == -1) {
-        return ErrnoError() << "Failed to open " << dstPath;
-    }
-
-    ret = ExtractEntryToFile(archive, &entry, fd.get());
-    if (ret != 0) {
-        return Error() << "Failed to extract entry \"" << fileName << "\" ("
-                       << entry.uncompressed_length << " bytes) to \"" << dstPath
-                       << "\": " << ErrorCodeString(ret);
-    }
-
-    return {};
-}
-
-Result<void> GetPolicyFromApex(const std::string& dir) {
-    LOG(INFO) << "Loading APEX Sepolicy from " << dir + kSepolicyZip;
-    unique_fd fd(open((dir + kSepolicyZip).c_str(), O_RDONLY | O_BINARY | O_CLOEXEC));
-    if (fd < 0) {
-        return ErrnoError() << "Failed to open package " << dir + kSepolicyZip;
-    }
-
-    ZipArchiveHandle handle;
-    int ret = OpenArchiveFd(fd.get(), (dir + kSepolicyZip).c_str(), &handle,
-                            /*assume_ownership=*/false);
-    if (ret < 0) {
-        return Error() << "Failed to open package " << dir + kSepolicyZip << ": "
-                       << ErrorCodeString(ret);
-    }
-
-    auto handle_guard = android::base::make_scope_guard([&handle] { CloseArchive(handle); });
-
-    auto create = CreateTmpfsDir();
-    if (!create.ok()) {
-        return create.error();
-    }
-
-    for (const auto& file : kApexSepolicy) {
-        auto extract = PutFileInTmpfs(handle, file);
-        if (!extract.ok()) {
-            return extract.error();
-        }
-    }
-    for (const auto& file : kApexSepolicyTmp) {
-        auto extract = PutFileInTmpfs(handle, file);
-        if (!extract.ok()) {
-            return extract.error();
-        }
-    }
-    return {};
-}
-
-Result<void> SepolicyCheckSignature(const std::string& dir) {
-    std::string signature;
-    if (!android::base::ReadFileToString(dir + kSepolicySignature, &signature)) {
-        return ErrnoError() << "Failed to read " << kSepolicySignature;
-    }
-
-    std::fstream sepolicyZip(dir + kSepolicyZip, std::ios::in | std::ios::binary);
-    if (!sepolicyZip) {
-        return Error() << "Failed to open " << kSepolicyZip;
-    }
-    sepolicyZip.seekg(0);
-    std::string sepolicyStr((std::istreambuf_iterator<char>(sepolicyZip)),
-                            std::istreambuf_iterator<char>());
-
-    auto releaseKey = extractPublicKeyFromX509(kSigningCertRelease);
-    if (!releaseKey.ok()) {
-        return releaseKey.error();
-    }
-
-    return verifySignature(sepolicyStr, signature, *releaseKey);
-}
-
-Result<void> SepolicyVerify(const std::string& dir) {
-    auto sepolicySignature = SepolicyCheckSignature(dir);
-    if (!sepolicySignature.ok()) {
-        return Error() << "Apex SEPolicy failed signature check";
-    }
-    return {};
-}
-
-void CleanupApexSepolicy() {
-    for (const auto& file : kApexSepolicyTmp) {
-        std::string path = kTmpfsDir + file;
-        unlink(path.c_str());
-    }
-}
-
-// Updatable sepolicy is shipped within an zip within an APEX. Because
-// it needs to be available before Apexes are mounted, apexd copies
-// the zip from the APEX and stores it in /metadata/sepolicy. If there is
-// no updatable sepolicy in /metadata/sepolicy, then the updatable policy is
-// loaded from /system/etc/selinux/apex. Init performs the following
-// steps on boot:
-//
-// 1. Validates the zip by checking its signature against a public key that is
-// stored in /system/etc/selinux.
-// 2. Extracts files from zip and stores them in /dev/selinux.
-// 3. Checks if the apex_sepolicy.sha256 matches the sha256 of precompiled_sepolicy.
-// if so, the precompiled sepolicy is used. Otherwise, an on-device compile of the policy
-// is used. This is the same flow as on-device compilation of policy for Treble.
-// 4. Cleans up files in /dev/selinux which are no longer needed.
-// 5. Restorecons the remaining files in /dev/selinux.
-// 6. Sets selinux into enforcing mode and continues normal booting.
-//
-void PrepareApexSepolicy() {
-    // If apex sepolicy zip exists in /metadata/sepolicy, use that, otherwise use version on
-    // /system. If neither exists, do nothing.
-    std::string dir;
-    if (access((kSepolicyApexMetadataDir + kSepolicyZip).c_str(), F_OK) == 0) {
-        dir = kSepolicyApexMetadataDir;
-    } else if (access((kSepolicyApexSystemDir + kSepolicyZip).c_str(), F_OK) == 0) {
-        dir = kSepolicyApexSystemDir;
-    } else {
-        LOG(INFO) << "APEX Sepolicy not found";
-        return;
-    }
-
-    auto sepolicyVerify = SepolicyVerify(dir);
-    if (!sepolicyVerify.ok()) {
-        LOG(INFO) << "Error: " << sepolicyVerify.error();
-        // If signature verification fails, fall back to version on /system.
-        // This file doesn't need to be verified because it lives on the system partition which
-        // is signed and protected by verified boot.
-        dir = kSepolicyApexSystemDir;
-    }
-
-    auto apex = GetPolicyFromApex(dir);
-    if (!apex.ok()) {
-        // TODO(b/199914227) Make failure fatal. For now continue booting with non-apex sepolicy.
-        LOG(ERROR) << apex.error();
-    }
-}
-
 void ReadPolicy(std::string* policy) {
     PolicyFile policy_file;
 
@@ -961,12 +756,9 @@ void LoadSelinuxPolicyAndroid() {
 
     LOG(INFO) << "Opening SELinux policy";
 
-    PrepareApexSepolicy();
-
     // Read the policy before potentially killing snapuserd.
     std::string policy;
     ReadPolicy(&policy);
-    CleanupApexSepolicy();
 
     auto snapuserd_helper = SnapuserdSelinuxHelper::CreateIfNeeded();
     if (snapuserd_helper) {
@@ -982,13 +774,6 @@ void LoadSelinuxPolicyAndroid() {
         snapuserd_helper->FinishTransition();
         snapuserd_helper = nullptr;
     }
-
-    // This restorecon is intentionally done before SelinuxSetEnforcement because the permissions
-    // needed to transition files from tmpfs to *_contexts_file context should not be granted to
-    // any process after selinux is set into enforcing mode.
-    if (selinux_android_restorecon("/dev/selinux/", SELINUX_ANDROID_RESTORECON_RECURSE) == -1) {
-        PLOG(FATAL) << "restorecon failed of /dev/selinux failed";
-    }
 }
 
 int SetupSelinux(char** argv) {

From e433fde7d21d01d0d671a6bd24b5e15aa577e0e0 Mon Sep 17 00:00:00 2001
From: Chun-Wei Wang <wangchun@google.com>
Date: Wed, 30 Aug 2023 07:55:43 +0000
Subject: [PATCH 0358/1487] Add a fastboot command to show GSI status

The command will be used by RMA tool to skip
device wiping when it is already in GSI mode.

This change also makes it easier to add more
gsi commands in the future without needing to
update the host side tool (fastboot).

(Cherry-picked from aosp/2735077)

Bug: 298533290
Bug: 298138572
Test: 1. reboot into fastboot mode
      2. fastboot gsi status
Merged-In: Ic81f89a93b854f9ec70aebe2d209bfd1f98e3645
Change-Id: Ic81f89a93b854f9ec70aebe2d209bfd1f98e3645
---
 fastboot/device/commands.cpp | 11 +++++++++++
 fastboot/fastboot.cpp        | 12 +++++-------
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/fastboot/device/commands.cpp b/fastboot/device/commands.cpp
index e929f42c2402..d60539332aea 100644
--- a/fastboot/device/commands.cpp
+++ b/fastboot/device/commands.cpp
@@ -661,6 +661,17 @@ bool GsiHandler(FastbootDevice* device, const std::vector<std::string>& args) {
         if (!android::gsi::DisableGsi()) {
             return device->WriteStatus(FastbootResult::FAIL, strerror(errno));
         }
+    } else if (args[1] == "status") {
+        std::string active_dsu;
+        if (!android::gsi::IsGsiRunning()) {
+            device->WriteInfo("Not running");
+        } else if (!android::gsi::GetActiveDsu(&active_dsu)) {
+            return device->WriteFail(strerror(errno));
+        } else {
+            device->WriteInfo("Running active DSU: " + active_dsu);
+        }
+    } else {
+        return device->WriteFail("Invalid arguments");
     }
     return device->WriteStatus(FastbootResult::OKAY, "Success");
 }
diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index cdcd0363a2fc..037916ea4418 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -2565,14 +2565,12 @@ int FastBootTool::Main(int argc, char* argv[]) {
                     std::make_unique<ResizeTask>(fp.get(), partition, size, fp->slot_override);
             resize_task->Run();
         } else if (command == "gsi") {
-            std::string arg = next_arg(&args);
-            if (arg == "wipe") {
-                fb->RawCommand("gsi:wipe", "wiping GSI");
-            } else if (arg == "disable") {
-                fb->RawCommand("gsi:disable", "disabling GSI");
-            } else {
-                syntax_error("expected 'wipe' or 'disable'");
+            if (args.empty()) syntax_error("invalid gsi command");
+            std::string cmd("gsi");
+            while (!args.empty()) {
+                cmd += ":" + next_arg(&args);
             }
+            fb->RawCommand(cmd, "");
         } else if (command == "wipe-super") {
             std::string image;
             if (args.empty()) {

From 9ccb84a8bac43271055786d26da54dca4b58121e Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 4 Sep 2023 16:19:05 -0700
Subject: [PATCH 0359/1487] snapshotctl: Create and write pre-created snapshots

Extend snapshotctl binary on the device
to create and apply pre-created snapshots.

snapshotctl map-snapshots <directory-where snapshot patches are present>

1: snapshotctl creates the block device based on the size of the
       snapshot patches.

2: snapshotctl will copy the data to the block device.

unmap and delete snapshots will cleanup.

No change in libsnapshot library except with minor refactoring.

This patch doesn't yet prepare the device to reboot from these
snapshots.

On Pixel 6 Pro, applying pre-created snapshots for all partitions
takes ~3 seconds wherein the delta between two builds are 24 hours apart.

Bug: 299011882

Test: snapshotctl map-snapshots /data/test-snapshots/
snapshotctl unmap-snapshots
snapshotctl delete-snapshots

Change-Id: I98a0fbd9cf7234c2188bad85cdd092ded8997710
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../include/libsnapshot/snapshot.h            |   1 +
 fs_mgr/libsnapshot/snapshotctl.cpp            | 301 +++++++++++++++++-
 2 files changed, 300 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index c056a19f83a1..6bc8b9b5a013 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -441,6 +441,7 @@ class SnapshotManager final : public ISnapshotManager {
     friend class FlashAfterUpdateTest;
     friend class LockTestConsumer;
     friend class SnapshotFuzzEnv;
+    friend class MapSnapshots;
     friend struct AutoDeleteCowImage;
     friend struct AutoDeleteSnapshot;
     friend struct PartitionCowCreator;
diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 38eb719fd277..1323b0bc8a64 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -17,14 +17,25 @@
 #include <sysexits.h>
 
 #include <chrono>
+#include <filesystem>
+#include <fstream>
+#include <future>
 #include <iostream>
 #include <map>
 #include <sstream>
+#include <thread>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/unique_fd.h>
 
+#include <android-base/chrono_utils.h>
+#include <android-base/parseint.h>
+#include <android-base/properties.h>
+#include <android-base/scopeguard.h>
+#include <android-base/stringprintf.h>
+#include <android-base/strings.h>
+
 #include <fs_mgr.h>
 #include <fs_mgr_dm_linear.h>
 #include <fstab/fstab.h>
@@ -33,6 +44,8 @@
 #include <libsnapshot/snapshot.h>
 #include <storage_literals/storage_literals.h>
 
+#include "partition_cow_creator.h"
+
 #ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
 #include <BootControlClient.h>
 #endif
@@ -56,13 +69,179 @@ int Usage() {
                  "  merge\n"
                  "    Deprecated.\n"
                  "  map\n"
-                 "    Map all partitions at /dev/block/mapper\n";
+                 "    Map all partitions at /dev/block/mapper\n"
+                 "  map-snapshots <directory where snapshot patches are present>\n"
+                 "    Map all snapshots based on patches present in the directory\n"
+                 "  unmap-snapshots\n"
+                 "    Unmap all pre-created snapshots\n"
+                 "  delete-snapshots\n"
+                 "    Delete all pre-created snapshots\n";
     return EX_USAGE;
 }
 
 namespace android {
 namespace snapshot {
 
+class MapSnapshots {
+  public:
+    MapSnapshots(std::string path = "");
+    bool CreateSnapshotDevice(std::string& partition_name, std::string& patch);
+    bool InitiateThreadedSnapshotWrite(std::string& pname, std::string& snapshot_patch);
+    bool WaitForSnapshotWritesToComplete();
+    bool UnmapCowImagePath(std::string& name);
+    bool DeleteCowImage(std::string& name);
+
+  private:
+    std::optional<std::string> GetCowImagePath(std::string& name);
+    bool WriteSnapshotPatch(std::string cow_device, std::string patch);
+    std::unique_ptr<SnapshotManager::LockedFile> lock_;
+    std::unique_ptr<SnapshotManager> sm_;
+    std::vector<std::future<bool>> threads_;
+    std::string snapshot_dir_path_;
+};
+
+MapSnapshots::MapSnapshots(std::string path) {
+    sm_ = SnapshotManager::New();
+    if (!sm_) {
+        std::cout << "Failed to create snapshotmanager";
+        exit(1);
+    }
+    snapshot_dir_path_ = path + "/";
+    lock_ = sm_->LockExclusive();
+}
+
+bool MapSnapshots::CreateSnapshotDevice(std::string& partition_name, std::string& patchfile) {
+    std::string parsing_file = snapshot_dir_path_ + patchfile;
+
+    android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(parsing_file.c_str(), O_RDONLY)));
+    if (fd < 0) {
+        LOG(ERROR) << "Failed to open file: " << parsing_file;
+        return false;
+    }
+
+    uint64_t dev_sz = lseek(fd.get(), 0, SEEK_END);
+    if (!dev_sz) {
+        LOG(ERROR) << "Could not determine block device size: " << parsing_file;
+        return false;
+    }
+
+    const int block_sz = 4_KiB;
+    dev_sz += block_sz - 1;
+    dev_sz &= ~(block_sz - 1);
+
+    SnapshotStatus status;
+    status.set_name(partition_name);
+    status.set_cow_file_size(dev_sz);
+    status.set_cow_partition_size(0);
+
+    PartitionCowCreator cow_creator;
+    cow_creator.using_snapuserd = true;
+
+    if (!sm_->CreateSnapshot(lock_.get(), &cow_creator, &status)) {
+        LOG(ERROR) << "CreateSnapshot failed";
+        return false;
+    }
+
+    if (!sm_->CreateCowImage(lock_.get(), partition_name)) {
+        LOG(ERROR) << "CreateCowImage failed";
+        return false;
+    }
+
+    return true;
+}
+
+std::optional<std::string> MapSnapshots::GetCowImagePath(std::string& name) {
+    auto cow_dev = sm_->MapCowImage(name, 5s);
+    if (!cow_dev.has_value()) {
+        LOG(ERROR) << "Failed to get COW device path";
+        return std::nullopt;
+    }
+
+    LOG(INFO) << "COW Device path: " << cow_dev.value();
+    return cow_dev;
+}
+
+bool MapSnapshots::WriteSnapshotPatch(std::string cow_device, std::string patch) {
+    std::string patch_file = snapshot_dir_path_ + patch;
+
+    android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(patch_file.c_str(), O_RDONLY)));
+    if (fd < 0) {
+        LOG(ERROR) << "Failed to open file: " << patch_file;
+        return false;
+    }
+
+    uint64_t dev_sz = lseek(fd.get(), 0, SEEK_END);
+    if (!dev_sz) {
+        std::cout << "Could not determine block device size: " << patch_file;
+        return false;
+    }
+
+    android::base::unique_fd cfd(TEMP_FAILURE_RETRY(open(cow_device.c_str(), O_RDWR)));
+    if (cfd < 0) {
+        LOG(ERROR) << "Failed to open file: " << cow_device;
+        return false;
+    }
+
+    const uint64_t read_sz = 1_MiB;
+    std::unique_ptr<uint8_t[]> buffer = std::make_unique<uint8_t[]>(read_sz);
+    off_t file_offset = 0;
+
+    while (true) {
+        size_t to_read = std::min((dev_sz - file_offset), read_sz);
+        if (!android::base::ReadFullyAtOffset(fd.get(), buffer.get(), to_read, file_offset)) {
+            PLOG(ERROR) << "ReadFullyAtOffset failed";
+            return false;
+        }
+
+        if (!android::base::WriteFullyAtOffset(cfd, buffer.get(), to_read, file_offset)) {
+            PLOG(ERROR) << "WriteFullyAtOffset failed";
+            return false;
+        }
+        file_offset += to_read;
+        if (file_offset >= dev_sz) {
+            break;
+        }
+    }
+    fsync(cfd.get());
+    return true;
+}
+
+bool MapSnapshots::InitiateThreadedSnapshotWrite(std::string& pname, std::string& snapshot_patch) {
+    auto path = GetCowImagePath(pname);
+    if (!path.has_value()) {
+        return false;
+    }
+    threads_.emplace_back(std::async(std::launch::async, &MapSnapshots::WriteSnapshotPatch, this,
+                                     path.value(), snapshot_patch));
+    return true;
+}
+
+bool MapSnapshots::WaitForSnapshotWritesToComplete() {
+    bool ret = true;
+    for (auto& t : threads_) {
+        ret = t.get() && ret;
+    }
+
+    if (ret) {
+        LOG(INFO) << "Pre-created snapshots successfully copied";
+    } else {
+        LOG(ERROR) << "Snapshot copy failed";
+    }
+    return ret;
+}
+
+bool MapSnapshots::UnmapCowImagePath(std::string& name) {
+    return sm_->UnmapCowImage(name);
+}
+
+bool MapSnapshots::DeleteCowImage(std::string& name) {
+    if (!sm_->DeleteSnapshot(lock_.get(), name)) {
+        LOG(ERROR) << "Delete snapshot failed";
+        return false;
+    }
+    return true;
+}
+
 bool DumpCmdHandler(int /*argc*/, char** argv) {
     android::base::InitLogging(argv, &android::base::StderrLogger);
     return SnapshotManager::New()->Dump(std::cout);
@@ -85,6 +264,121 @@ bool MergeCmdHandler(int /*argc*/, char** argv) {
     return false;
 }
 
+bool GetVerityPartitions(std::vector<std::string>& partitions) {
+    auto& dm = android::dm::DeviceMapper::Instance();
+    auto dm_block_devices = dm.FindDmPartitions();
+    if (dm_block_devices.empty()) {
+        LOG(ERROR) << "No dm-enabled block device is found.";
+        return false;
+    }
+
+    for (auto& block_device : dm_block_devices) {
+        std::string dm_block_name = block_device.first;
+        std::string slot_suffix = fs_mgr_get_slot_suffix();
+        std::string partition = dm_block_name + slot_suffix;
+        partitions.push_back(partition);
+    }
+    return true;
+}
+
+bool UnMapPrecreatedSnapshots(int, char**) {
+    // Make sure we are root.
+    if (::getuid() != 0) {
+        LOG(ERROR) << "Not running as root. Try \"adb root\" first.";
+        return EXIT_FAILURE;
+    }
+
+    std::vector<std::string> partitions;
+    if (!GetVerityPartitions(partitions)) {
+        return false;
+    }
+
+    MapSnapshots snapshot;
+    for (auto partition : partitions) {
+        if (!snapshot.UnmapCowImagePath(partition)) {
+            LOG(ERROR) << "UnmapCowImagePath failed: " << partition;
+        }
+    }
+    return true;
+}
+
+bool DeletePrecreatedSnapshots(int, char**) {
+    // Make sure we are root.
+    if (::getuid() != 0) {
+        LOG(ERROR) << "Not running as root. Try \"adb root\" first.";
+        return EXIT_FAILURE;
+    }
+
+    std::vector<std::string> partitions;
+    if (!GetVerityPartitions(partitions)) {
+        return false;
+    }
+
+    MapSnapshots snapshot;
+    for (auto partition : partitions) {
+        if (!snapshot.DeleteCowImage(partition)) {
+            LOG(ERROR) << "DeleteCowImage failed: " << partition;
+        }
+    }
+    return true;
+}
+
+bool MapPrecreatedSnapshots(int argc, char** argv) {
+    android::base::InitLogging(argv, &android::base::StderrLogger);
+
+    // Make sure we are root.
+    if (::getuid() != 0) {
+        LOG(ERROR) << "Not running as root. Try \"adb root\" first.";
+        return EXIT_FAILURE;
+    }
+
+    if (argc < 3) {
+        std::cerr << " map-snapshots <directory location where snapshot patches are present>"
+                     "    Map all snapshots based on patches present in the directory\n";
+        return false;
+    }
+
+    std::string path = std::string(argv[2]);
+    std::vector<std::string> patchfiles;
+
+    for (const auto& entry : std::filesystem::directory_iterator(path)) {
+        if (android::base::EndsWith(entry.path().generic_string(), ".patch")) {
+            patchfiles.push_back(android::base::Basename(entry.path().generic_string()));
+        }
+    }
+    auto& dm = android::dm::DeviceMapper::Instance();
+    auto dm_block_devices = dm.FindDmPartitions();
+    if (dm_block_devices.empty()) {
+        LOG(ERROR) << "No dm-enabled block device is found.";
+        return false;
+    }
+
+    std::vector<std::pair<std::string, std::string>> partitions;
+    for (auto& patchfile : patchfiles) {
+        auto npos = patchfile.rfind(".patch");
+        auto dm_block_name = patchfile.substr(0, npos);
+        if (dm_block_devices.find(dm_block_name) != dm_block_devices.end()) {
+            std::string slot_suffix = fs_mgr_get_slot_suffix();
+            std::string partition = dm_block_name + slot_suffix;
+            partitions.push_back(std::make_pair(partition, patchfile));
+        }
+    }
+
+    MapSnapshots cow(path);
+    for (auto& pair : partitions) {
+        if (!cow.CreateSnapshotDevice(pair.first, pair.second)) {
+            LOG(ERROR) << "CreateSnapshotDevice failed for: " << pair.first;
+            return false;
+        }
+        if (!cow.InitiateThreadedSnapshotWrite(pair.first, pair.second)) {
+            LOG(ERROR) << "InitiateThreadedSnapshotWrite failed for: " << pair.first;
+            return false;
+        }
+    }
+
+    return cow.WaitForSnapshotWritesToComplete();
+}
+
 #ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
 bool CreateTestUpdate(SnapshotManager* sm) {
     chromeos_update_engine::DeltaArchiveManifest manifest;
@@ -137,8 +431,8 @@ bool CreateTestUpdate(SnapshotManager* sm) {
             .block_device = fs_mgr_get_super_partition_name(target_slot_number),
             .metadata_slot = {target_slot_number},
             .partition_name = system_target_name,
-            .partition_opener = &opener,
             .timeout_ms = 10s,
+            .partition_opener = &opener,
     };
     auto writer = sm->OpenSnapshotWriter(clpp, std::nullopt);
     if (!writer) {
@@ -211,6 +505,9 @@ static std::map<std::string, std::function<bool(int, char**)>> kCmdMap = {
         {"test-blank-ota", TestOtaHandler},
 #endif
         {"unmap", UnmapCmdHandler},
+        {"map-snapshots", MapPrecreatedSnapshots},
+        {"unmap-snapshots", UnMapPrecreatedSnapshots},
+        {"delete-snapshots", DeletePrecreatedSnapshots},
         // clang-format on
 };
 

From bf72b25a07eeb24f4467d397dfeb2d94265f95b6 Mon Sep 17 00:00:00 2001
From: Julien Desprez <jdesprez@google.com>
Date: Wed, 6 Sep 2023 11:10:03 -0700
Subject: [PATCH 0360/1487] Export create_snapshot to sdk targets

Similar to fastboot binaries. This will ease the
automation to use this tool

Test: presubmit
Bug: 290951369
Change-Id: I5c879acc7cdecbafebfa074ef76034403cb0cd72
---
 fs_mgr/libsnapshot/Android.bp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index b0f2b846d5ec..abdff1a429db 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -476,6 +476,14 @@ cc_binary {
     header_libs: [
         "libstorage_literals_headers",
     ],
+
+    dist: {
+        targets: [
+            "sdk",
+            "sdk-repo-platform-tools",
+            "sdk_repo",
+        ],
+    },
 }
 
 python_library_host {

From e72b3ad20409ed6e31d376c497089cdc4c076eb5 Mon Sep 17 00:00:00 2001
From: Chun-Wei Wang <wangchun@google.com>
Date: Thu, 7 Sep 2023 09:53:11 +0800
Subject: [PATCH 0361/1487] Disallow fastboot to modify locked DSU

This enhances the security requirement by only allowing
the owner app to change a locked DSU.

Bug: 277691885
Bug: 296985785
Test: 1. ensure device is OEM locked
      2. adb shell am start-activity \
         -n com.android.dynsystem/com.android.dynsystem.VerificationActivity \
         -a android.os.image.action.START_INSTALL \
         --el KEY_USERDATA_SIZE 2147483648 \
	 --es KEY_DSU_SLOT foo.lock
      3. adb reboot fastboot
      4. `fastboot gsi disable|wipe` should be blocked

Change-Id: I1a0cb8a074412468d16043ddf4101fbb76490115
---
 fastboot/device/commands.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/fastboot/device/commands.cpp b/fastboot/device/commands.cpp
index d60539332aea..6de598f6934d 100644
--- a/fastboot/device/commands.cpp
+++ b/fastboot/device/commands.cpp
@@ -639,6 +639,12 @@ bool UpdateSuperHandler(FastbootDevice* device, const std::vector<std::string>&
     return UpdateSuper(device, args[1], wipe);
 }
 
+static bool IsLockedDsu() {
+    std::string active_dsu;
+    android::gsi::GetActiveDsu(&active_dsu);
+    return android::base::EndsWith(active_dsu, ".lock");
+}
+
 bool GsiHandler(FastbootDevice* device, const std::vector<std::string>& args) {
     if (args.size() != 2) {
         return device->WriteFail("Invalid arguments");
@@ -653,6 +659,11 @@ bool GsiHandler(FastbootDevice* device, const std::vector<std::string>& args) {
         return device->WriteStatus(FastbootResult::FAIL, "No GSI is installed");
     }
 
+    if ((args[1] == "wipe" || args[1] == "disable") && GetDeviceLockStatus() && IsLockedDsu()) {
+        // Block commands that modify the states of locked DSU
+        return device->WriteFail("Command not available on locked DSU/devices");
+    }
+
     if (args[1] == "wipe") {
         if (!android::gsi::UninstallGsi()) {
             return device->WriteStatus(FastbootResult::FAIL, strerror(errno));

From a4d34c5715ca554edfc67471ece5b52142a85d29 Mon Sep 17 00:00:00 2001
From: Marvin Ramin <marvinramin@google.com>
Date: Thu, 7 Sep 2023 08:14:26 +0000
Subject: [PATCH 0362/1487] Revert "Export create_snapshot to sdk targets"

This reverts commit bf72b25a07eeb24f4467d397dfeb2d94265f95b6.

Reason for revert: DroidMonitor: Culprit for b/299411079

Change-Id: I9d46abcbcc81d43fde23d4431b6757d3520d4b2c
---
 fs_mgr/libsnapshot/Android.bp | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index abdff1a429db..b0f2b846d5ec 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -476,14 +476,6 @@ cc_binary {
     header_libs: [
         "libstorage_literals_headers",
     ],
-
-    dist: {
-        targets: [
-            "sdk",
-            "sdk-repo-platform-tools",
-            "sdk_repo",
-        ],
-    },
 }
 
 python_library_host {

From 670f983f45906849ed64ed6ac4387a1207862a55 Mon Sep 17 00:00:00 2001
From: Julien Desprez <jdesprez@google.com>
Date: Thu, 7 Sep 2023 09:38:38 -0700
Subject: [PATCH 0363/1487] Reland exporting create_snapshot

Previous attempt: aosp/2743815
Disabled on windows & mac.

Test: presubmit, (previously failed build: https://android-build.googleplex.com/builds/abtd/run/L06100000962955289?referrer=email now passing)
Bug: 290951369
Change-Id: I3d8084c13d843ea5919e3b50a0513faf386ccfed
---
 fs_mgr/libsnapshot/Android.bp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index b0f2b846d5ec..0131f732e6fa 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -476,6 +476,22 @@ cc_binary {
     header_libs: [
         "libstorage_literals_headers",
     ],
+
+    dist: {
+        targets: [
+            "sdk",
+            "sdk-repo-platform-tools",
+            "sdk_repo",
+        ],
+    },
+    target: {
+        darwin: {
+            enabled: false,
+        },
+        windows: {
+            enabled: false,
+        },
+    },
 }
 
 python_library_host {

From a8e259db663e6308d6d9fcfd8db95f84346f2c68 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 7 Sep 2023 18:52:11 +0000
Subject: [PATCH 0364/1487] Remove stray newline from err() call.

err() does this itself, and includes strerror() too.

Test: treehugger
Change-Id: I0e844f9cc3992e80a302b2f3ca1084b165582a9b
---
 toolbox/getevent.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/toolbox/getevent.c b/toolbox/getevent.c
index e2c77c37fb91..f65bb20b5806 100644
--- a/toolbox/getevent.c
+++ b/toolbox/getevent.c
@@ -111,8 +111,7 @@ static int print_possible_events(int fd, int print_flags)
                 break;
             bits_size = res + 16;
             bits = realloc(bits, bits_size * 2);
-            if(bits == NULL)
-                err(1, "failed to allocate buffer of size %d\n", (int)bits_size);
+            if (bits == NULL) err(1, "failed to allocate buffer of size %zd", bits_size);
         }
         res2 = 0;
         switch(i) {

From b9dc1c2991de9ca87bdbf00c413b7f2bb4477fe2 Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Tue, 22 Aug 2023 20:45:21 +0000
Subject: [PATCH 0365/1487] Drop all path-related methods from android::String8

Move them to androidfw and aapt, the last users.

Bug: 295394788
Test: m checkbuild
Change-Id: I7268b88d11bf221f93efed06cfd1ee65449a2421
---
 libutils/String8.cpp                          | 136 ------------------
 libutils/String8_fuzz.cpp                     |  24 ----
 .../arm64/source-based/libutils.so.lsdump     | 105 +-------------
 .../arm_arm64/source-based/libutils.so.lsdump | 105 +-------------
 libutils/include/utils/String8.h              |  74 +---------
 5 files changed, 4 insertions(+), 440 deletions(-)

diff --git a/libutils/String8.cpp b/libutils/String8.cpp
index 2b72847e52bd..a2cfc088084b 100644
--- a/libutils/String8.cpp
+++ b/libutils/String8.cpp
@@ -430,31 +430,6 @@ void String8::toLower()
 // ---------------------------------------------------------------------------
 // Path functions
 
-static void setPathName(String8& s, const char* name) {
-    size_t len = strlen(name);
-    char* buf = s.lockBuffer(len);
-
-    memcpy(buf, name, len);
-
-    // remove trailing path separator, if present
-    if (len > 0 && buf[len - 1] == OS_PATH_SEPARATOR) len--;
-    buf[len] = '\0';
-
-    s.unlockBuffer(len);
-}
-
-String8 String8::getPathLeaf(void) const
-{
-    const char* cp;
-    const char*const buf = mString;
-
-    cp = strrchr(buf, OS_PATH_SEPARATOR);
-    if (cp == nullptr)
-        return String8(*this);
-    else
-        return String8(cp+1);
-}
-
 String8 String8::getPathDir(void) const
 {
     const char* cp;
@@ -467,115 +442,4 @@ String8 String8::getPathDir(void) const
         return String8(str, cp - str);
 }
 
-String8 String8::walkPath(String8* outRemains) const
-{
-    const char* cp;
-    const char*const str = mString;
-    const char* buf = str;
-
-    cp = strchr(buf, OS_PATH_SEPARATOR);
-    if (cp == buf) {
-        // don't include a leading '/'.
-        buf = buf+1;
-        cp = strchr(buf, OS_PATH_SEPARATOR);
-    }
-
-    if (cp == nullptr) {
-        String8 res = buf != str ? String8(buf) : *this;
-        if (outRemains) *outRemains = String8("");
-        return res;
-    }
-
-    String8 res(buf, cp-buf);
-    if (outRemains) *outRemains = String8(cp+1);
-    return res;
-}
-
-/*
- * Helper function for finding the start of an extension in a pathname.
- *
- * Returns a pointer inside mString, or NULL if no extension was found.
- */
-char* String8::find_extension(void) const
-{
-    const char* lastSlash;
-    const char* lastDot;
-    const char* const str = mString;
-
-    // only look at the filename
-    lastSlash = strrchr(str, OS_PATH_SEPARATOR);
-    if (lastSlash == nullptr)
-        lastSlash = str;
-    else
-        lastSlash++;
-
-    // find the last dot
-    lastDot = strrchr(lastSlash, '.');
-    if (lastDot == nullptr)
-        return nullptr;
-
-    // looks good, ship it
-    return const_cast<char*>(lastDot);
-}
-
-String8 String8::getPathExtension(void) const
-{
-    char* ext;
-
-    ext = find_extension();
-    if (ext != nullptr)
-        return String8(ext);
-    else
-        return String8("");
-}
-
-String8 String8::getBasePath(void) const
-{
-    char* ext;
-    const char* const str = mString;
-
-    ext = find_extension();
-    if (ext == nullptr)
-        return String8(*this);
-    else
-        return String8(str, ext - str);
-}
-
-String8& String8::appendPath(const char* name)
-{
-    // TODO: The test below will fail for Win32 paths. Fix later or ignore.
-    if (name[0] != OS_PATH_SEPARATOR) {
-        if (*name == '\0') {
-            // nothing to do
-            return *this;
-        }
-
-        size_t len = length();
-        if (len == 0) {
-            // no existing filename, just use the new one
-            setPathName(*this, name);
-            return *this;
-        }
-
-        // make room for oldPath + '/' + newPath
-        int newlen = strlen(name);
-
-        char* buf = lockBuffer(len+1+newlen);
-
-        // insert a '/' if needed
-        if (buf[len-1] != OS_PATH_SEPARATOR)
-            buf[len++] = OS_PATH_SEPARATOR;
-
-        memcpy(buf+len, name, newlen+1);
-        len += newlen;
-
-        unlockBuffer(len);
-
-        return *this;
-    } else {
-        setPathName(*this, name);
-        return *this;
-    }
-}
-
 }; // namespace android
diff --git a/libutils/String8_fuzz.cpp b/libutils/String8_fuzz.cpp
index 6f7a54f9f310..cbce0505891e 100644
--- a/libutils/String8_fuzz.cpp
+++ b/libutils/String8_fuzz.cpp
@@ -68,30 +68,6 @@ std::vector<std::function<void(FuzzedDataProvider*, android::String8*, android::
                     int start_index = dataProvider->ConsumeIntegralInRange<int>(0, str1->size());
                     str1->find(str2->c_str(), start_index);
                 },
-
-                // Path handling
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->getBasePath();
-                },
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->getPathExtension();
-                },
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->getPathLeaf();
-                },
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->getPathDir();
-                },
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    std::shared_ptr<android::String8> path_out_str =
-                            std::make_shared<android::String8>();
-                    str1->walkPath(path_out_str.get());
-                    path_out_str->clear();
-                },
-                [](FuzzedDataProvider* dataProvider, android::String8* str1,
-                   android::String8*) -> void {
-                    str1->appendPath(dataProvider->ConsumeBytesWithTerminator<char>(5).data());
-                },
 };
 
 void fuzzFormat(FuzzedDataProvider* dataProvider, android::String8* str1, bool shouldAppend) {
diff --git a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
index 46baddecde7b..55e1e275fc58 100644
--- a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
@@ -703,9 +703,6 @@
   {
    "name" : "_ZN7android7RefBaseD2Ev"
   },
-  {
-   "name" : "_ZN7android7String810appendPathEPKc"
-  },
   {
    "name" : "_ZN7android7String810lockBufferEm"
   },
@@ -1144,27 +1141,12 @@
   {
    "name" : "_ZNK7android7String810getPathDirEv"
   },
-  {
-   "name" : "_ZNK7android7String811getBasePathEv"
-  },
-  {
-   "name" : "_ZNK7android7String811getPathLeafEv"
-  },
-  {
-   "name" : "_ZNK7android7String814find_extensionEv"
-  },
-  {
-   "name" : "_ZNK7android7String816getPathExtensionEv"
-  },
   {
    "name" : "_ZNK7android7String84findEPKcm"
   },
   {
    "name" : "_ZNK7android7String86lengthEv"
   },
-  {
-   "name" : "_ZNK7android7String88walkPathEPS0_"
-  },
   {
    "name" : "_ZNK7android8String1610startsWithEPKDs"
   },
@@ -6808,22 +6790,6 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
-  {
-   "function_name" : "android::String8::appendPath",
-   "linker_set_key" : "_ZN7android7String810appendPathEPKc",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    },
-    {
-     "referenced_type" : "_ZTIPKc"
-    }
-   ],
-   "return_type" : "_ZTIRN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String8::lockBuffer",
    "linker_set_key" : "_ZN7android7String810lockBufferEm",
@@ -9104,6 +9070,7 @@
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
   {
+   "access" : "private",
    "function_name" : "android::String8::getPathDir",
    "linker_set_key" : "_ZNK7android7String810getPathDirEv",
    "parameters" :
@@ -9116,59 +9083,6 @@
    "return_type" : "_ZTIN7android7String8E",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::getBasePath",
-   "linker_set_key" : "_ZNK7android7String811getBasePathEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
-   "function_name" : "android::String8::getPathLeaf",
-   "linker_set_key" : "_ZNK7android7String811getPathLeafEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
-   "access" : "private",
-   "function_name" : "android::String8::find_extension",
-   "linker_set_key" : "_ZNK7android7String814find_extensionEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIPc",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
-   "function_name" : "android::String8::getPathExtension",
-   "linker_set_key" : "_ZNK7android7String816getPathExtensionEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String8::find",
    "linker_set_key" : "_ZNK7android7String84findEPKcm",
@@ -9202,23 +9116,6 @@
    "return_type" : "_ZTIm",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::walkPath",
-   "linker_set_key" : "_ZNK7android7String88walkPathEPS0_",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    },
-    {
-     "default_arg" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String16::startsWith",
    "linker_set_key" : "_ZNK7android8String1610startsWithEPKDs",
diff --git a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
index 219c76665bb9..c14469890758 100644
--- a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
@@ -703,9 +703,6 @@
   {
    "name" : "_ZN7android7RefBaseD2Ev"
   },
-  {
-   "name" : "_ZN7android7String810appendPathEPKc"
-  },
   {
    "name" : "_ZN7android7String810lockBufferEj"
   },
@@ -1144,27 +1141,12 @@
   {
    "name" : "_ZNK7android7String810getPathDirEv"
   },
-  {
-   "name" : "_ZNK7android7String811getBasePathEv"
-  },
-  {
-   "name" : "_ZNK7android7String811getPathLeafEv"
-  },
-  {
-   "name" : "_ZNK7android7String814find_extensionEv"
-  },
-  {
-   "name" : "_ZNK7android7String816getPathExtensionEv"
-  },
   {
    "name" : "_ZNK7android7String84findEPKcj"
   },
   {
    "name" : "_ZNK7android7String86lengthEv"
   },
-  {
-   "name" : "_ZNK7android7String88walkPathEPS0_"
-  },
   {
    "name" : "_ZNK7android8String1610startsWithEPKDs"
   },
@@ -6804,22 +6786,6 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
-  {
-   "function_name" : "android::String8::appendPath",
-   "linker_set_key" : "_ZN7android7String810appendPathEPKc",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    },
-    {
-     "referenced_type" : "_ZTIPKc"
-    }
-   ],
-   "return_type" : "_ZTIRN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String8::lockBuffer",
    "linker_set_key" : "_ZN7android7String810lockBufferEj",
@@ -9100,6 +9066,7 @@
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
   {
+   "access" : "private",
    "function_name" : "android::String8::getPathDir",
    "linker_set_key" : "_ZNK7android7String810getPathDirEv",
    "parameters" :
@@ -9112,59 +9079,6 @@
    "return_type" : "_ZTIN7android7String8E",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::getBasePath",
-   "linker_set_key" : "_ZNK7android7String811getBasePathEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
-   "function_name" : "android::String8::getPathLeaf",
-   "linker_set_key" : "_ZNK7android7String811getPathLeafEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
-   "access" : "private",
-   "function_name" : "android::String8::find_extension",
-   "linker_set_key" : "_ZNK7android7String814find_extensionEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIPc",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
-   "function_name" : "android::String8::getPathExtension",
-   "linker_set_key" : "_ZNK7android7String816getPathExtensionEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String8::find",
    "linker_set_key" : "_ZNK7android7String84findEPKcj",
@@ -9198,23 +9112,6 @@
    "return_type" : "_ZTIj",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::walkPath",
-   "linker_set_key" : "_ZNK7android7String88walkPathEPS0_",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    },
-    {
-     "default_arg" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String16::startsWith",
    "linker_set_key" : "_ZNK7android8String1610startsWithEPKDs",
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index ea25c6aa3947..9cef9f67854f 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -130,80 +130,10 @@ class String8
 
             void                toLower();
 
-
-    /*
-     * These methods operate on the string as if it were a path name.
-     */
-
-    /*
-     * Get just the filename component.
-     *
-     * "/tmp/foo/bar.c" --> "bar.c"
-     */
-    String8 getPathLeaf(void) const;
-
-    /*
-     * Remove the last (file name) component, leaving just the directory
-     * name.
-     *
-     * "/tmp/foo/bar.c" --> "/tmp/foo"
-     * "/tmp" --> "" // ????? shouldn't this be "/" ???? XXX
-     * "bar.c" --> ""
-     */
-    String8 getPathDir(void) const;
-
-    /*
-     * Retrieve the front (root dir) component.  Optionally also return the
-     * remaining components.
-     *
-     * "/tmp/foo/bar.c" --> "tmp" (remain = "foo/bar.c")
-     * "/tmp" --> "tmp" (remain = "")
-     * "bar.c" --> "bar.c" (remain = "")
-     */
-    String8 walkPath(String8* outRemains = nullptr) const;
-
-    /*
-     * Return the filename extension.  This is the last '.' and any number
-     * of characters that follow it.  The '.' is included in case we
-     * decide to expand our definition of what constitutes an extension.
-     *
-     * "/tmp/foo/bar.c" --> ".c"
-     * "/tmp" --> ""
-     * "/tmp/foo.bar/baz" --> ""
-     * "foo.jpeg" --> ".jpeg"
-     * "foo." --> ""
-     */
-    String8 getPathExtension(void) const;
-
-    /*
-     * Return the path without the extension.  Rules for what constitutes
-     * an extension are described in the comment for getPathExtension().
-     *
-     * "/tmp/foo/bar.c" --> "/tmp/foo/bar"
-     */
-    String8 getBasePath(void) const;
-
-    /*
-     * Add a component to the pathname.  We guarantee that there is
-     * exactly one path separator between the old path and the new.
-     * If there is no existing name, we just copy the new name in.
-     *
-     * If leaf is a fully qualified path (i.e. starts with '/', it
-     * replaces whatever was there before.
-     */
-    String8& appendPath(const char* leaf);
-    String8& appendPath(const String8& leaf) { return appendPath(leaf.c_str()); }
-
-    /*
-     * Like appendPath(), but does not affect this string.  Returns a new one instead.
-     */
-    String8 appendPathCopy(const char* leaf) const
-                                             { String8 p(*this); p.appendPath(leaf); return p; }
-    String8 appendPathCopy(const String8& leaf) const { return appendPathCopy(leaf.c_str()); }
-
 private:
+            String8 getPathDir(void) const;
+
             status_t            real_append(const char* other, size_t numChars);
-            char*               find_extension(void) const;
 
             const char* mString;
 };

From bcbc93f83d48b3f9b2ca3972764bed011983432c Mon Sep 17 00:00:00 2001
From: Chun-Wei Wang <wangchun@google.com>
Date: Thu, 7 Sep 2023 09:53:11 +0800
Subject: [PATCH 0366/1487] Disallow fastboot to modify locked DSU

This enhances the security requirement by only allowing
the owner app to change a locked DSU.

(Cherry-picked from aosp/2744993)

Bug: 277691885
Bug: 296985785
Test: 1. ensure device is OEM locked
      2. adb shell am start-activity \
         -n com.android.dynsystem/com.android.dynsystem.VerificationActivity \
         -a android.os.image.action.START_INSTALL \
         --el KEY_USERDATA_SIZE 2147483648 \
	 --es KEY_DSU_SLOT foo.lock
      3. adb reboot fastboot
      4. `fastboot gsi disable|wipe` should be blocked

Merged-In: I1a0cb8a074412468d16043ddf4101fbb76490115
Change-Id: I1a0cb8a074412468d16043ddf4101fbb76490115
---
 fastboot/device/commands.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/fastboot/device/commands.cpp b/fastboot/device/commands.cpp
index d60539332aea..6de598f6934d 100644
--- a/fastboot/device/commands.cpp
+++ b/fastboot/device/commands.cpp
@@ -639,6 +639,12 @@ bool UpdateSuperHandler(FastbootDevice* device, const std::vector<std::string>&
     return UpdateSuper(device, args[1], wipe);
 }
 
+static bool IsLockedDsu() {
+    std::string active_dsu;
+    android::gsi::GetActiveDsu(&active_dsu);
+    return android::base::EndsWith(active_dsu, ".lock");
+}
+
 bool GsiHandler(FastbootDevice* device, const std::vector<std::string>& args) {
     if (args.size() != 2) {
         return device->WriteFail("Invalid arguments");
@@ -653,6 +659,11 @@ bool GsiHandler(FastbootDevice* device, const std::vector<std::string>& args) {
         return device->WriteStatus(FastbootResult::FAIL, "No GSI is installed");
     }
 
+    if ((args[1] == "wipe" || args[1] == "disable") && GetDeviceLockStatus() && IsLockedDsu()) {
+        // Block commands that modify the states of locked DSU
+        return device->WriteFail("Command not available on locked DSU/devices");
+    }
+
     if (args[1] == "wipe") {
         if (!android::gsi::UninstallGsi()) {
             return device->WriteStatus(FastbootResult::FAIL, strerror(errno));

From 32f69204046c24c15ff2d2bac7122cbfd5896596 Mon Sep 17 00:00:00 2001
From: Hongguang Chen <hgchen@google.com>
Date: Thu, 7 Sep 2023 21:15:00 -0700
Subject: [PATCH 0367/1487] Only restart media.tuner when it's running

Fix: 287520719
Test: Kill system_server on TV device w/o tuner. media.tuner is not restarted.
Change-Id: I13006f16746a12c33960feca1288aa17ef2ed9c9
---
 rootdir/init.zygote32.rc | 2 +-
 rootdir/init.zygote64.rc | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/rootdir/init.zygote32.rc b/rootdir/init.zygote32.rc
index 2f0ec8a17d4c..442bd153f5db 100644
--- a/rootdir/init.zygote32.rc
+++ b/rootdir/init.zygote32.rc
@@ -13,7 +13,7 @@ service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-sys
     onrestart restart audioserver
     onrestart restart cameraserver
     onrestart restart media
-    onrestart restart media.tuner
+    onrestart restart --only-if-running media.tuner
     onrestart restart netd
     onrestart restart wificond
     task_profiles ProcessCapacityHigh
diff --git a/rootdir/init.zygote64.rc b/rootdir/init.zygote64.rc
index 74a64c80f465..342212123de5 100644
--- a/rootdir/init.zygote64.rc
+++ b/rootdir/init.zygote64.rc
@@ -13,7 +13,7 @@ service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-s
     onrestart restart audioserver
     onrestart restart cameraserver
     onrestart restart media
-    onrestart restart media.tuner
+    onrestart restart --only-if-running media.tuner
     onrestart restart netd
     onrestart restart wificond
     task_profiles ProcessCapacityHigh MaxPerformance

From 3a60e825126bbcfebecd57a728a1a87cacc5b497 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 5 Jun 2023 15:00:30 -0700
Subject: [PATCH 0368/1487] Move ENOSPC tests to libfiemap.

These tests are still giving us trouble. Move them to libfiemap, which
(1) is closer to the source of implementation, and (2) allows us to
re-use the temporary filesystem code. This won't perturb the state of
the actual device.

The new test creates a 64MB ext4 or f2fs mount point as a sandbox, which
should be much safer.

Bug: 285197715
Bug: 298346574
Bug: 299142557
Test: fiemap_writer_test
Merged-In: I33502d49613be4f269a80e5c632514fc56a0246a
Ignore-AOSP-First: cherry-pick
Change-Id: Iedb7c32a594c3b1fca2904f3441029aaed7edf2a
---
 fs_mgr/libfiemap/Android.bp                   |   3 +
 fs_mgr/libfiemap/fiemap_writer_test.cpp       | 118 ++++++++++++------
 fs_mgr/libsnapshot/snapshot_test.cpp          |  70 -----------
 .../storage_literals/storage_literals.h       |   6 +
 4 files changed, 87 insertions(+), 110 deletions(-)

diff --git a/fs_mgr/libfiemap/Android.bp b/fs_mgr/libfiemap/Android.bp
index 5deba659dd56..ddda648d8e88 100644
--- a/fs_mgr/libfiemap/Android.bp
+++ b/fs_mgr/libfiemap/Android.bp
@@ -93,6 +93,9 @@ cc_test {
     test_options: {
         min_shipping_api_level: 29,
     },
+    header_libs: [
+        "libstorage_literals_headers",
+    ],
     require_root: true,
 }
 
diff --git a/fs_mgr/libfiemap/fiemap_writer_test.cpp b/fs_mgr/libfiemap/fiemap_writer_test.cpp
index c65481b78d36..bd97a78ae8f7 100644
--- a/fs_mgr/libfiemap/fiemap_writer_test.cpp
+++ b/fs_mgr/libfiemap/fiemap_writer_test.cpp
@@ -22,21 +22,25 @@
 #include <string.h>
 #include <sys/mount.h>
 #include <sys/stat.h>
+#include <sys/statvfs.h>
 #include <sys/types.h>
 #include <sys/vfs.h>
 #include <unistd.h>
 
 #include <string>
+#include <utility>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
 #include <android-base/unique_fd.h>
+#include <fstab/fstab.h>
 #include <gtest/gtest.h>
 #include <libdm/loop_control.h>
 #include <libfiemap/fiemap_writer.h>
 #include <libfiemap/split_fiemap_writer.h>
 #include <libgsi/libgsi.h>
+#include <storage_literals/storage_literals.h>
 
 #include "utility.h"
 
@@ -46,6 +50,7 @@ namespace fiemap {
 using namespace std;
 using namespace std::string_literals;
 using namespace android::fiemap;
+using namespace android::storage_literals;
 using unique_fd = android::base::unique_fd;
 using LoopDevice = android::dm::LoopDevice;
 
@@ -427,90 +432,123 @@ TEST_F(SplitFiemapTest, WritePastEnd) {
     ASSERT_FALSE(ptr->Write(buffer.get(), kSize));
 }
 
-class VerifyBlockWritesExt4 : public ::testing::Test {
+// Get max file size and free space.
+std::pair<uint64_t, uint64_t> GetBigFileLimit(const std::string& mount_point) {
+    struct statvfs fs;
+    if (statvfs(mount_point.c_str(), &fs) < 0) {
+        PLOG(ERROR) << "statfs failed";
+        return {0, 0};
+    }
+
+    auto fs_limit = static_cast<uint64_t>(fs.f_blocks) * (fs.f_bsize - 1);
+    auto fs_free = static_cast<uint64_t>(fs.f_bfree) * fs.f_bsize;
+
+    LOG(INFO) << "Big file limit: " << fs_limit << ", free space: " << fs_free;
+
+    return {fs_limit, fs_free};
+}
+
+class FsTest : public ::testing::Test {
+  protected:
     // 2GB Filesystem and 4k block size by default
     static constexpr uint64_t block_size = 4096;
-    static constexpr uint64_t fs_size = 2147483648;
+    static constexpr uint64_t fs_size = 64 * 1024 * 1024;
+
+    void SetUp() {
+        android::fs_mgr::Fstab fstab;
+        ASSERT_TRUE(android::fs_mgr::ReadFstabFromFile("/proc/mounts", &fstab));
+
+        ASSERT_EQ(access(tmpdir_.path, F_OK), 0);
+        fs_path_ = tmpdir_.path + "/fs_image"s;
+        mntpoint_ = tmpdir_.path + "/mnt_point"s;
+
+        auto entry = android::fs_mgr::GetEntryForMountPoint(&fstab, "/data");
+        ASSERT_NE(entry, nullptr);
+        if (entry->fs_type == "ext4") {
+            SetUpExt4();
+        } else if (entry->fs_type == "f2fs") {
+            SetUpF2fs();
+        } else {
+            FAIL() << "Unrecognized fs_type: " << entry->fs_type;
+        }
+    }
 
-  protected:
-    void SetUp() override {
-        fs_path = std::string(getenv("TMPDIR")) + "/ext4_2G.img";
+    void SetUpExt4() {
         uint64_t count = fs_size / block_size;
         std::string dd_cmd =
                 ::android::base::StringPrintf("/system/bin/dd if=/dev/zero of=%s bs=%" PRIu64
                                               " count=%" PRIu64 " > /dev/null 2>&1",
-                                              fs_path.c_str(), block_size, count);
+                                              fs_path_.c_str(), block_size, count);
         std::string mkfs_cmd =
-                ::android::base::StringPrintf("/system/bin/mkfs.ext4 -q %s", fs_path.c_str());
+                ::android::base::StringPrintf("/system/bin/mkfs.ext4 -q %s", fs_path_.c_str());
         // create mount point
-        mntpoint = std::string(getenv("TMPDIR")) + "/fiemap_mnt";
-        ASSERT_EQ(mkdir(mntpoint.c_str(), S_IRWXU), 0);
+        ASSERT_EQ(mkdir(mntpoint_.c_str(), S_IRWXU), 0);
         // create file for the file system
         int ret = system(dd_cmd.c_str());
         ASSERT_EQ(ret, 0);
         // Get and attach a loop device to the filesystem we created
-        LoopDevice loop_dev(fs_path, 10s);
+        LoopDevice loop_dev(fs_path_, 10s);
         ASSERT_TRUE(loop_dev.valid());
         // create file system
         ret = system(mkfs_cmd.c_str());
         ASSERT_EQ(ret, 0);
 
         // mount the file system
-        ASSERT_EQ(mount(loop_dev.device().c_str(), mntpoint.c_str(), "ext4", 0, nullptr), 0);
-    }
-
-    void TearDown() override {
-        umount(mntpoint.c_str());
-        rmdir(mntpoint.c_str());
-        unlink(fs_path.c_str());
+        ASSERT_EQ(mount(loop_dev.device().c_str(), mntpoint_.c_str(), "ext4", 0, nullptr), 0);
     }
 
-    std::string mntpoint;
-    std::string fs_path;
-};
-
-class VerifyBlockWritesF2fs : public ::testing::Test {
-    // 2GB Filesystem and 4k block size by default
-    static constexpr uint64_t block_size = 4096;
-    static constexpr uint64_t fs_size = 2147483648;
-
-  protected:
-    void SetUp() override {
-        fs_path = std::string(getenv("TMPDIR")) + "/f2fs_2G.img";
+    void SetUpF2fs() {
         uint64_t count = fs_size / block_size;
         std::string dd_cmd =
                 ::android::base::StringPrintf("/system/bin/dd if=/dev/zero of=%s bs=%" PRIu64
                                               " count=%" PRIu64 " > /dev/null 2>&1",
-                                              fs_path.c_str(), block_size, count);
+                                              fs_path_.c_str(), block_size, count);
         std::string mkfs_cmd =
-                ::android::base::StringPrintf("/system/bin/make_f2fs -q %s", fs_path.c_str());
+                ::android::base::StringPrintf("/system/bin/make_f2fs -q %s", fs_path_.c_str());
         // create mount point
-        mntpoint = std::string(getenv("TMPDIR")) + "/fiemap_mnt";
-        ASSERT_EQ(mkdir(mntpoint.c_str(), S_IRWXU), 0);
+        ASSERT_EQ(mkdir(mntpoint_.c_str(), S_IRWXU), 0);
         // create file for the file system
         int ret = system(dd_cmd.c_str());
         ASSERT_EQ(ret, 0);
         // Get and attach a loop device to the filesystem we created
-        LoopDevice loop_dev(fs_path, 10s);
+        LoopDevice loop_dev(fs_path_, 10s);
         ASSERT_TRUE(loop_dev.valid());
         // create file system
         ret = system(mkfs_cmd.c_str());
         ASSERT_EQ(ret, 0);
 
         // mount the file system
-        ASSERT_EQ(mount(loop_dev.device().c_str(), mntpoint.c_str(), "f2fs", 0, nullptr), 0);
+        ASSERT_EQ(mount(loop_dev.device().c_str(), mntpoint_.c_str(), "f2fs", 0, nullptr), 0);
     }
 
     void TearDown() override {
-        umount(mntpoint.c_str());
-        rmdir(mntpoint.c_str());
-        unlink(fs_path.c_str());
+        umount(mntpoint_.c_str());
+        rmdir(mntpoint_.c_str());
+        unlink(fs_path_.c_str());
     }
 
-    std::string mntpoint;
-    std::string fs_path;
+    TemporaryDir tmpdir_;
+    std::string mntpoint_;
+    std::string fs_path_;
 };
 
+TEST_F(FsTest, LowSpaceError) {
+    auto limits = GetBigFileLimit(mntpoint_);
+    ASSERT_GE(limits.first, 0);
+
+    FiemapUniquePtr ptr;
+
+    auto test_file = mntpoint_ + "/big_file";
+    auto status = FiemapWriter::Open(test_file, limits.first, &ptr);
+    ASSERT_FALSE(status.is_ok());
+    ASSERT_EQ(status.error_code(), FiemapStatus::ErrorCode::NO_SPACE);
+
+    // Also test for EFBIG.
+    status = FiemapWriter::Open(test_file, 16_TiB, &ptr);
+    ASSERT_FALSE(status.is_ok());
+    ASSERT_NE(status.error_code(), FiemapStatus::ErrorCode::NO_SPACE);
+}
+
 bool DetermineBlockSize() {
     struct statfs s;
     if (statfs(gTestDir.c_str(), &s)) {
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 460d49db2a8b..ce75a54167bf 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2312,32 +2312,6 @@ TEST_F(SnapshotUpdateTest, Overflow) {
             << "FinishedSnapshotWrites should detect overflow of CoW device.";
 }
 
-TEST_F(SnapshotUpdateTest, LowSpace) {
-    static constexpr auto kMaxFree = 10_MiB;
-    auto userdata = std::make_unique<LowSpaceUserdata>();
-    ASSERT_TRUE(userdata->Init(kMaxFree));
-
-    // Grow all partitions to 10_MiB, total 30_MiB. This requires 30 MiB of CoW space. After
-    // using the empty space in super (< 1 MiB), it uses 30 MiB of /userdata space.
-    constexpr uint64_t partition_size = 10_MiB;
-    SetSize(sys_, partition_size);
-    SetSize(vnd_, partition_size);
-    SetSize(prd_, partition_size);
-    sys_->set_estimate_cow_size(partition_size);
-    vnd_->set_estimate_cow_size(partition_size);
-    prd_->set_estimate_cow_size(partition_size);
-
-    AddOperationForPartitions();
-
-    // Execute the update.
-    ASSERT_TRUE(sm->BeginUpdate());
-    auto res = sm->CreateUpdateSnapshots(manifest_);
-    ASSERT_FALSE(res);
-    ASSERT_EQ(Return::ErrorCode::NO_SPACE, res.error_code());
-    ASSERT_GE(res.required_size(), 14_MiB);
-    ASSERT_LT(res.required_size(), 40_MiB);
-}
-
 TEST_F(SnapshotUpdateTest, AddPartition) {
     group_->add_partition_names("dlkm");
 
@@ -2699,50 +2673,6 @@ INSTANTIATE_TEST_SUITE_P(Snapshot, FlashAfterUpdateTest, Combine(Values(0, 1), B
                                     "Merge"s;
                          });
 
-class ImageManagerTest : public SnapshotTest {
-  protected:
-    void SetUp() override {
-        SKIP_IF_NON_VIRTUAL_AB();
-        SnapshotTest::SetUp();
-    }
-    void TearDown() override {
-        RETURN_IF_NON_VIRTUAL_AB();
-        CleanUp();
-    }
-    void CleanUp() {
-        if (!image_manager_) {
-            return;
-        }
-        EXPECT_TRUE(!image_manager_->BackingImageExists(kImageName) ||
-                    image_manager_->DeleteBackingImage(kImageName));
-    }
-
-    static constexpr const char* kImageName = "my_image";
-};
-
-TEST_F(ImageManagerTest, CreateImageNoSpace) {
-    bool at_least_one_failure = false;
-    for (uint64_t size = 1_MiB; size <= 512_MiB; size *= 2) {
-        auto userdata = std::make_unique<LowSpaceUserdata>();
-        ASSERT_TRUE(userdata->Init(size));
-
-        uint64_t to_allocate = userdata->free_space() + userdata->bsize();
-
-        auto res = image_manager_->CreateBackingImage(kImageName, to_allocate,
-                                                      IImageManager::CREATE_IMAGE_DEFAULT);
-        if (!res) {
-            at_least_one_failure = true;
-        } else {
-            ASSERT_EQ(res.error_code(), FiemapStatus::ErrorCode::NO_SPACE) << res.string();
-        }
-
-        CleanUp();
-    }
-
-    ASSERT_TRUE(at_least_one_failure)
-            << "We should have failed to allocate at least one over-sized image";
-}
-
 bool Mkdir(const std::string& path) {
     if (mkdir(path.c_str(), 0700) && errno != EEXIST) {
         std::cerr << "Could not mkdir " << path << ": " << strerror(errno) << std::endl;
diff --git a/fs_mgr/libstorage_literals/storage_literals/storage_literals.h b/fs_mgr/libstorage_literals/storage_literals/storage_literals.h
index ac0dfbdb7004..bbeabd5c987b 100644
--- a/fs_mgr/libstorage_literals/storage_literals/storage_literals.h
+++ b/fs_mgr/libstorage_literals/storage_literals/storage_literals.h
@@ -37,6 +37,7 @@ using B = Size<0>;
 using KiB = Size<10>;
 using MiB = Size<20>;
 using GiB = Size<30>;
+using TiB = Size<40>;
 
 constexpr B operator""_B(unsigned long long v) {  // NOLINT
     return B{v};
@@ -54,6 +55,10 @@ constexpr GiB operator""_GiB(unsigned long long v) {  // NOLINT
     return GiB{v};
 }
 
+constexpr TiB operator""_TiB(unsigned long long v) {  // NOLINT
+    return TiB{v};
+}
+
 template <typename Dest, typename Src>
 constexpr Dest size_cast(Src src) {
     if (Src::power < Dest::power) {
@@ -69,6 +74,7 @@ static_assert(1_B == 1);
 static_assert(1_KiB == 1 << 10);
 static_assert(1_MiB == 1 << 20);
 static_assert(1_GiB == 1 << 30);
+static_assert(1_TiB == 1ULL << 40);
 static_assert(size_cast<KiB>(1_B).count() == 0);
 static_assert(size_cast<KiB>(1024_B).count() == 1);
 static_assert(size_cast<KiB>(1_MiB).count() == 1024);

From adaf33026a32e336dd727cb4d03e9cd656c2869c Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Fri, 8 Sep 2023 09:51:24 -0700
Subject: [PATCH 0369/1487] Drop String8::std_string

This method was preserved under assumption it would be baked into many
prebuilts, but since it's inline, there should be no linkage to libutils
- thus, should be safe to remove anyway.

Bug: 35363681
Bug: 295394788
Test: treehugger
Change-Id: I59964935600e9e786424136177bfc8a70bebec67
---
 libutils/include/utils/String16.h | 8 --------
 libutils/include/utils/String8.h  | 9 ---------
 2 files changed, 17 deletions(-)

diff --git a/libutils/include/utils/String16.h b/libutils/include/utils/String16.h
index b48b90765612..ec2a3241c49c 100644
--- a/libutils/include/utils/String16.h
+++ b/libutils/include/utils/String16.h
@@ -56,9 +56,6 @@ class String16
     inline  const char16_t*     c_str() const;
     inline  const char16_t*     string() const;
 
-private:
-    static inline std::string   std_string(const String16& str);
-public:
             size_t              size() const;
     inline  bool                empty() const;
 
@@ -249,11 +246,6 @@ inline const char16_t* String16::string() const
     return mString;
 }
 
-inline std::string String16::std_string(const String16& str)
-{
-    return std::string(String8(str).c_str());
-}
-
 inline bool String16::empty() const
 {
     return length() == 0;
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index 9cef9f67854f..764b92a18f8a 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -58,10 +58,6 @@ class String8
     inline  const char*         c_str() const;
     inline  const char*         string() const;
 
-private:
-    static inline std::string   std_string(const String8& str);
-public:
-
     inline  size_t              size() const;
     inline  size_t              bytes() const;
     inline  bool                empty() const;
@@ -169,11 +165,6 @@ inline const char* String8::string() const
     return mString;
 }
 
-inline std::string String8::std_string(const String8& str)
-{
-    return std::string(str.c_str());
-}
-
 inline size_t String8::size() const
 {
     return length();

From cff2e40d19113fa7ed57fedae072ad605cef1be7 Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Fri, 8 Sep 2023 17:08:39 +0000
Subject: [PATCH 0370/1487] Revert "Drop all path-related methods from
 android::String8"

This reverts commit b9dc1c2991de9ca87bdbf00c413b7f2bb4477fe2.

Reason for revert: http://b/299624573

Change-Id: I0d5993295df65ec31c180b6b5a76fbe939891f45
---
 libutils/String8.cpp                          | 136 ++++++++++++++++++
 libutils/String8_fuzz.cpp                     |  24 ++++
 .../arm64/source-based/libutils.so.lsdump     | 105 +++++++++++++-
 .../arm_arm64/source-based/libutils.so.lsdump | 105 +++++++++++++-
 libutils/include/utils/String8.h              |  74 +++++++++-
 5 files changed, 440 insertions(+), 4 deletions(-)

diff --git a/libutils/String8.cpp b/libutils/String8.cpp
index a2cfc088084b..2b72847e52bd 100644
--- a/libutils/String8.cpp
+++ b/libutils/String8.cpp
@@ -430,6 +430,31 @@ void String8::toLower()
 // ---------------------------------------------------------------------------
 // Path functions
 
+static void setPathName(String8& s, const char* name) {
+    size_t len = strlen(name);
+    char* buf = s.lockBuffer(len);
+
+    memcpy(buf, name, len);
+
+    // remove trailing path separator, if present
+    if (len > 0 && buf[len - 1] == OS_PATH_SEPARATOR) len--;
+    buf[len] = '\0';
+
+    s.unlockBuffer(len);
+}
+
+String8 String8::getPathLeaf(void) const
+{
+    const char* cp;
+    const char*const buf = mString;
+
+    cp = strrchr(buf, OS_PATH_SEPARATOR);
+    if (cp == nullptr)
+        return String8(*this);
+    else
+        return String8(cp+1);
+}
+
 String8 String8::getPathDir(void) const
 {
     const char* cp;
@@ -442,4 +467,115 @@ String8 String8::getPathDir(void) const
         return String8(str, cp - str);
 }
 
+String8 String8::walkPath(String8* outRemains) const
+{
+    const char* cp;
+    const char*const str = mString;
+    const char* buf = str;
+
+    cp = strchr(buf, OS_PATH_SEPARATOR);
+    if (cp == buf) {
+        // don't include a leading '/'.
+        buf = buf+1;
+        cp = strchr(buf, OS_PATH_SEPARATOR);
+    }
+
+    if (cp == nullptr) {
+        String8 res = buf != str ? String8(buf) : *this;
+        if (outRemains) *outRemains = String8("");
+        return res;
+    }
+
+    String8 res(buf, cp-buf);
+    if (outRemains) *outRemains = String8(cp+1);
+    return res;
+}
+
+/*
+ * Helper function for finding the start of an extension in a pathname.
+ *
+ * Returns a pointer inside mString, or NULL if no extension was found.
+ */
+char* String8::find_extension(void) const
+{
+    const char* lastSlash;
+    const char* lastDot;
+    const char* const str = mString;
+
+    // only look at the filename
+    lastSlash = strrchr(str, OS_PATH_SEPARATOR);
+    if (lastSlash == nullptr)
+        lastSlash = str;
+    else
+        lastSlash++;
+
+    // find the last dot
+    lastDot = strrchr(lastSlash, '.');
+    if (lastDot == nullptr)
+        return nullptr;
+
+    // looks good, ship it
+    return const_cast<char*>(lastDot);
+}
+
+String8 String8::getPathExtension(void) const
+{
+    char* ext;
+
+    ext = find_extension();
+    if (ext != nullptr)
+        return String8(ext);
+    else
+        return String8("");
+}
+
+String8 String8::getBasePath(void) const
+{
+    char* ext;
+    const char* const str = mString;
+
+    ext = find_extension();
+    if (ext == nullptr)
+        return String8(*this);
+    else
+        return String8(str, ext - str);
+}
+
+String8& String8::appendPath(const char* name)
+{
+    // TODO: The test below will fail for Win32 paths. Fix later or ignore.
+    if (name[0] != OS_PATH_SEPARATOR) {
+        if (*name == '\0') {
+            // nothing to do
+            return *this;
+        }
+
+        size_t len = length();
+        if (len == 0) {
+            // no existing filename, just use the new one
+            setPathName(*this, name);
+            return *this;
+        }
+
+        // make room for oldPath + '/' + newPath
+        int newlen = strlen(name);
+
+        char* buf = lockBuffer(len+1+newlen);
+
+        // insert a '/' if needed
+        if (buf[len-1] != OS_PATH_SEPARATOR)
+            buf[len++] = OS_PATH_SEPARATOR;
+
+        memcpy(buf+len, name, newlen+1);
+        len += newlen;
+
+        unlockBuffer(len);
+
+        return *this;
+    } else {
+        setPathName(*this, name);
+        return *this;
+    }
+}
+
 }; // namespace android
diff --git a/libutils/String8_fuzz.cpp b/libutils/String8_fuzz.cpp
index cbce0505891e..6f7a54f9f310 100644
--- a/libutils/String8_fuzz.cpp
+++ b/libutils/String8_fuzz.cpp
@@ -68,6 +68,30 @@ std::vector<std::function<void(FuzzedDataProvider*, android::String8*, android::
                     int start_index = dataProvider->ConsumeIntegralInRange<int>(0, str1->size());
                     str1->find(str2->c_str(), start_index);
                 },
+
+                // Path handling
+                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
+                    str1->getBasePath();
+                },
+                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
+                    str1->getPathExtension();
+                },
+                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
+                    str1->getPathLeaf();
+                },
+                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
+                    str1->getPathDir();
+                },
+                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
+                    std::shared_ptr<android::String8> path_out_str =
+                            std::make_shared<android::String8>();
+                    str1->walkPath(path_out_str.get());
+                    path_out_str->clear();
+                },
+                [](FuzzedDataProvider* dataProvider, android::String8* str1,
+                   android::String8*) -> void {
+                    str1->appendPath(dataProvider->ConsumeBytesWithTerminator<char>(5).data());
+                },
 };
 
 void fuzzFormat(FuzzedDataProvider* dataProvider, android::String8* str1, bool shouldAppend) {
diff --git a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
index 55e1e275fc58..46baddecde7b 100644
--- a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
@@ -703,6 +703,9 @@
   {
    "name" : "_ZN7android7RefBaseD2Ev"
   },
+  {
+   "name" : "_ZN7android7String810appendPathEPKc"
+  },
   {
    "name" : "_ZN7android7String810lockBufferEm"
   },
@@ -1141,12 +1144,27 @@
   {
    "name" : "_ZNK7android7String810getPathDirEv"
   },
+  {
+   "name" : "_ZNK7android7String811getBasePathEv"
+  },
+  {
+   "name" : "_ZNK7android7String811getPathLeafEv"
+  },
+  {
+   "name" : "_ZNK7android7String814find_extensionEv"
+  },
+  {
+   "name" : "_ZNK7android7String816getPathExtensionEv"
+  },
   {
    "name" : "_ZNK7android7String84findEPKcm"
   },
   {
    "name" : "_ZNK7android7String86lengthEv"
   },
+  {
+   "name" : "_ZNK7android7String88walkPathEPS0_"
+  },
   {
    "name" : "_ZNK7android8String1610startsWithEPKDs"
   },
@@ -6790,6 +6808,22 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "function_name" : "android::String8::appendPath",
+   "linker_set_key" : "_ZN7android7String810appendPathEPKc",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android7String8E"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIRN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
   {
    "function_name" : "android::String8::lockBuffer",
    "linker_set_key" : "_ZN7android7String810lockBufferEm",
@@ -9070,7 +9104,6 @@
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
   {
-   "access" : "private",
    "function_name" : "android::String8::getPathDir",
    "linker_set_key" : "_ZNK7android7String810getPathDirEv",
    "parameters" :
@@ -9083,6 +9116,59 @@
    "return_type" : "_ZTIN7android7String8E",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "function_name" : "android::String8::getBasePath",
+   "linker_set_key" : "_ZNK7android7String811getBasePathEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
+  {
+   "function_name" : "android::String8::getPathLeaf",
+   "linker_set_key" : "_ZNK7android7String811getPathLeafEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
+  {
+   "access" : "private",
+   "function_name" : "android::String8::find_extension",
+   "linker_set_key" : "_ZNK7android7String814find_extensionEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIPc",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
+  {
+   "function_name" : "android::String8::getPathExtension",
+   "linker_set_key" : "_ZNK7android7String816getPathExtensionEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
   {
    "function_name" : "android::String8::find",
    "linker_set_key" : "_ZNK7android7String84findEPKcm",
@@ -9116,6 +9202,23 @@
    "return_type" : "_ZTIm",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "function_name" : "android::String8::walkPath",
+   "linker_set_key" : "_ZNK7android7String88walkPathEPS0_",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    },
+    {
+     "default_arg" : true,
+     "referenced_type" : "_ZTIPN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
   {
    "function_name" : "android::String16::startsWith",
    "linker_set_key" : "_ZNK7android8String1610startsWithEPKDs",
diff --git a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
index c14469890758..219c76665bb9 100644
--- a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
@@ -703,6 +703,9 @@
   {
    "name" : "_ZN7android7RefBaseD2Ev"
   },
+  {
+   "name" : "_ZN7android7String810appendPathEPKc"
+  },
   {
    "name" : "_ZN7android7String810lockBufferEj"
   },
@@ -1141,12 +1144,27 @@
   {
    "name" : "_ZNK7android7String810getPathDirEv"
   },
+  {
+   "name" : "_ZNK7android7String811getBasePathEv"
+  },
+  {
+   "name" : "_ZNK7android7String811getPathLeafEv"
+  },
+  {
+   "name" : "_ZNK7android7String814find_extensionEv"
+  },
+  {
+   "name" : "_ZNK7android7String816getPathExtensionEv"
+  },
   {
    "name" : "_ZNK7android7String84findEPKcj"
   },
   {
    "name" : "_ZNK7android7String86lengthEv"
   },
+  {
+   "name" : "_ZNK7android7String88walkPathEPS0_"
+  },
   {
    "name" : "_ZNK7android8String1610startsWithEPKDs"
   },
@@ -6786,6 +6804,22 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "function_name" : "android::String8::appendPath",
+   "linker_set_key" : "_ZN7android7String810appendPathEPKc",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android7String8E"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIRN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
   {
    "function_name" : "android::String8::lockBuffer",
    "linker_set_key" : "_ZN7android7String810lockBufferEj",
@@ -9066,7 +9100,6 @@
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
   {
-   "access" : "private",
    "function_name" : "android::String8::getPathDir",
    "linker_set_key" : "_ZNK7android7String810getPathDirEv",
    "parameters" :
@@ -9079,6 +9112,59 @@
    "return_type" : "_ZTIN7android7String8E",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "function_name" : "android::String8::getBasePath",
+   "linker_set_key" : "_ZNK7android7String811getBasePathEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
+  {
+   "function_name" : "android::String8::getPathLeaf",
+   "linker_set_key" : "_ZNK7android7String811getPathLeafEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
+  {
+   "access" : "private",
+   "function_name" : "android::String8::find_extension",
+   "linker_set_key" : "_ZNK7android7String814find_extensionEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIPc",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
+  {
+   "function_name" : "android::String8::getPathExtension",
+   "linker_set_key" : "_ZNK7android7String816getPathExtensionEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
   {
    "function_name" : "android::String8::find",
    "linker_set_key" : "_ZNK7android7String84findEPKcj",
@@ -9112,6 +9198,23 @@
    "return_type" : "_ZTIj",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "function_name" : "android::String8::walkPath",
+   "linker_set_key" : "_ZNK7android7String88walkPathEPS0_",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    },
+    {
+     "default_arg" : true,
+     "referenced_type" : "_ZTIPN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
   {
    "function_name" : "android::String16::startsWith",
    "linker_set_key" : "_ZNK7android8String1610startsWithEPKDs",
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index 9cef9f67854f..ea25c6aa3947 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -130,10 +130,80 @@ class String8
 
             void                toLower();
 
-private:
-            String8 getPathDir(void) const;
 
+    /*
+     * These methods operate on the string as if it were a path name.
+     */
+
+    /*
+     * Get just the filename component.
+     *
+     * "/tmp/foo/bar.c" --> "bar.c"
+     */
+    String8 getPathLeaf(void) const;
+
+    /*
+     * Remove the last (file name) component, leaving just the directory
+     * name.
+     *
+     * "/tmp/foo/bar.c" --> "/tmp/foo"
+     * "/tmp" --> "" // ????? shouldn't this be "/" ???? XXX
+     * "bar.c" --> ""
+     */
+    String8 getPathDir(void) const;
+
+    /*
+     * Retrieve the front (root dir) component.  Optionally also return the
+     * remaining components.
+     *
+     * "/tmp/foo/bar.c" --> "tmp" (remain = "foo/bar.c")
+     * "/tmp" --> "tmp" (remain = "")
+     * "bar.c" --> "bar.c" (remain = "")
+     */
+    String8 walkPath(String8* outRemains = nullptr) const;
+
+    /*
+     * Return the filename extension.  This is the last '.' and any number
+     * of characters that follow it.  The '.' is included in case we
+     * decide to expand our definition of what constitutes an extension.
+     *
+     * "/tmp/foo/bar.c" --> ".c"
+     * "/tmp" --> ""
+     * "/tmp/foo.bar/baz" --> ""
+     * "foo.jpeg" --> ".jpeg"
+     * "foo." --> ""
+     */
+    String8 getPathExtension(void) const;
+
+    /*
+     * Return the path without the extension.  Rules for what constitutes
+     * an extension are described in the comment for getPathExtension().
+     *
+     * "/tmp/foo/bar.c" --> "/tmp/foo/bar"
+     */
+    String8 getBasePath(void) const;
+
+    /*
+     * Add a component to the pathname.  We guarantee that there is
+     * exactly one path separator between the old path and the new.
+     * If there is no existing name, we just copy the new name in.
+     *
+     * If leaf is a fully qualified path (i.e. starts with '/', it
+     * replaces whatever was there before.
+     */
+    String8& appendPath(const char* leaf);
+    String8& appendPath(const String8& leaf) { return appendPath(leaf.c_str()); }
+
+    /*
+     * Like appendPath(), but does not affect this string.  Returns a new one instead.
+     */
+    String8 appendPathCopy(const char* leaf) const
+                                             { String8 p(*this); p.appendPath(leaf); return p; }
+    String8 appendPathCopy(const String8& leaf) const { return appendPathCopy(leaf.c_str()); }
+
+private:
             status_t            real_append(const char* other, size_t numChars);
+            char*               find_extension(void) const;
 
             const char* mString;
 };

From 4b6a7c3940bc6d5e89e15179d8d49600e6dd4857 Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Fri, 8 Sep 2023 17:11:39 +0000
Subject: [PATCH 0371/1487] Revert "Revert "Drop all path-related methods from
 android::String8""

This reverts commit cff2e40d19113fa7ed57fedae072ad605cef1be7.

Reason for revert: Attempt re-submit

Change-Id: I8802b519e4ae3046858b854815ba580c7a6b965d
---
 libutils/String8.cpp                          | 108 +-----------------
 libutils/String8_fuzz.cpp                     |  24 ----
 .../arm64/source-based/libutils.so.lsdump     |  88 +-------------
 .../arm_arm64/source-based/libutils.so.lsdump |  88 +-------------
 libutils/include/utils/String8.h              |  75 +-----------
 5 files changed, 8 insertions(+), 375 deletions(-)

diff --git a/libutils/String8.cpp b/libutils/String8.cpp
index 2b72847e52bd..4301f0ea3a77 100644
--- a/libutils/String8.cpp
+++ b/libutils/String8.cpp
@@ -430,31 +430,6 @@ void String8::toLower()
 // ---------------------------------------------------------------------------
 // Path functions
 
-static void setPathName(String8& s, const char* name) {
-    size_t len = strlen(name);
-    char* buf = s.lockBuffer(len);
-
-    memcpy(buf, name, len);
-
-    // remove trailing path separator, if present
-    if (len > 0 && buf[len - 1] == OS_PATH_SEPARATOR) len--;
-    buf[len] = '\0';
-
-    s.unlockBuffer(len);
-}
-
-String8 String8::getPathLeaf(void) const
-{
-    const char* cp;
-    const char*const buf = mString;
-
-    cp = strrchr(buf, OS_PATH_SEPARATOR);
-    if (cp == nullptr)
-        return String8(*this);
-    else
-        return String8(cp+1);
-}
-
 String8 String8::getPathDir(void) const
 {
     const char* cp;
@@ -467,40 +442,14 @@ String8 String8::getPathDir(void) const
         return String8(str, cp - str);
 }
 
-String8 String8::walkPath(String8* outRemains) const
-{
-    const char* cp;
-    const char*const str = mString;
-    const char* buf = str;
-
-    cp = strchr(buf, OS_PATH_SEPARATOR);
-    if (cp == buf) {
-        // don't include a leading '/'.
-        buf = buf+1;
-        cp = strchr(buf, OS_PATH_SEPARATOR);
-    }
-
-    if (cp == nullptr) {
-        String8 res = buf != str ? String8(buf) : *this;
-        if (outRemains) *outRemains = String8("");
-        return res;
-    }
-
-    String8 res(buf, cp-buf);
-    if (outRemains) *outRemains = String8(cp+1);
-    return res;
-}
-
 /*
  * Helper function for finding the start of an extension in a pathname.
  *
  * Returns a pointer inside mString, or NULL if no extension was found.
  */
-char* String8::find_extension(void) const
-{
+static const char* find_extension(const char* str) {
     const char* lastSlash;
     const char* lastDot;
-    const char* const str = mString;
 
     // only look at the filename
     lastSlash = strrchr(str, OS_PATH_SEPARATOR);
@@ -515,67 +464,16 @@ char* String8::find_extension(void) const
         return nullptr;
 
     // looks good, ship it
-    return const_cast<char*>(lastDot);
+    return lastDot;
 }
 
 String8 String8::getPathExtension(void) const
 {
-    char* ext;
-
-    ext = find_extension();
+    auto ext = find_extension(mString);
     if (ext != nullptr)
         return String8(ext);
     else
         return String8("");
 }
 
-String8 String8::getBasePath(void) const
-{
-    char* ext;
-    const char* const str = mString;
-
-    ext = find_extension();
-    if (ext == nullptr)
-        return String8(*this);
-    else
-        return String8(str, ext - str);
-}
-
-String8& String8::appendPath(const char* name)
-{
-    // TODO: The test below will fail for Win32 paths. Fix later or ignore.
-    if (name[0] != OS_PATH_SEPARATOR) {
-        if (*name == '\0') {
-            // nothing to do
-            return *this;
-        }
-
-        size_t len = length();
-        if (len == 0) {
-            // no existing filename, just use the new one
-            setPathName(*this, name);
-            return *this;
-        }
-
-        // make room for oldPath + '/' + newPath
-        int newlen = strlen(name);
-
-        char* buf = lockBuffer(len+1+newlen);
-
-        // insert a '/' if needed
-        if (buf[len-1] != OS_PATH_SEPARATOR)
-            buf[len++] = OS_PATH_SEPARATOR;
-
-        memcpy(buf+len, name, newlen+1);
-        len += newlen;
-
-        unlockBuffer(len);
-
-        return *this;
-    } else {
-        setPathName(*this, name);
-        return *this;
-    }
-}
-
 }; // namespace android
diff --git a/libutils/String8_fuzz.cpp b/libutils/String8_fuzz.cpp
index 6f7a54f9f310..cbce0505891e 100644
--- a/libutils/String8_fuzz.cpp
+++ b/libutils/String8_fuzz.cpp
@@ -68,30 +68,6 @@ std::vector<std::function<void(FuzzedDataProvider*, android::String8*, android::
                     int start_index = dataProvider->ConsumeIntegralInRange<int>(0, str1->size());
                     str1->find(str2->c_str(), start_index);
                 },
-
-                // Path handling
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->getBasePath();
-                },
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->getPathExtension();
-                },
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->getPathLeaf();
-                },
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->getPathDir();
-                },
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    std::shared_ptr<android::String8> path_out_str =
-                            std::make_shared<android::String8>();
-                    str1->walkPath(path_out_str.get());
-                    path_out_str->clear();
-                },
-                [](FuzzedDataProvider* dataProvider, android::String8* str1,
-                   android::String8*) -> void {
-                    str1->appendPath(dataProvider->ConsumeBytesWithTerminator<char>(5).data());
-                },
 };
 
 void fuzzFormat(FuzzedDataProvider* dataProvider, android::String8* str1, bool shouldAppend) {
diff --git a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
index 46baddecde7b..8881b44eb181 100644
--- a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
@@ -703,9 +703,6 @@
   {
    "name" : "_ZN7android7RefBaseD2Ev"
   },
-  {
-   "name" : "_ZN7android7String810appendPathEPKc"
-  },
   {
    "name" : "_ZN7android7String810lockBufferEm"
   },
@@ -1144,15 +1141,6 @@
   {
    "name" : "_ZNK7android7String810getPathDirEv"
   },
-  {
-   "name" : "_ZNK7android7String811getBasePathEv"
-  },
-  {
-   "name" : "_ZNK7android7String811getPathLeafEv"
-  },
-  {
-   "name" : "_ZNK7android7String814find_extensionEv"
-  },
   {
    "name" : "_ZNK7android7String816getPathExtensionEv"
   },
@@ -1162,9 +1150,6 @@
   {
    "name" : "_ZNK7android7String86lengthEv"
   },
-  {
-   "name" : "_ZNK7android7String88walkPathEPS0_"
-  },
   {
    "name" : "_ZNK7android8String1610startsWithEPKDs"
   },
@@ -6808,22 +6793,6 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
-  {
-   "function_name" : "android::String8::appendPath",
-   "linker_set_key" : "_ZN7android7String810appendPathEPKc",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    },
-    {
-     "referenced_type" : "_ZTIPKc"
-    }
-   ],
-   "return_type" : "_ZTIRN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String8::lockBuffer",
    "linker_set_key" : "_ZN7android7String810lockBufferEm",
@@ -9104,6 +9073,7 @@
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
   {
+   "access" : "private",
    "function_name" : "android::String8::getPathDir",
    "linker_set_key" : "_ZNK7android7String810getPathDirEv",
    "parameters" :
@@ -9116,47 +9086,8 @@
    "return_type" : "_ZTIN7android7String8E",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::getBasePath",
-   "linker_set_key" : "_ZNK7android7String811getBasePathEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
-   "function_name" : "android::String8::getPathLeaf",
-   "linker_set_key" : "_ZNK7android7String811getPathLeafEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "access" : "private",
-   "function_name" : "android::String8::find_extension",
-   "linker_set_key" : "_ZNK7android7String814find_extensionEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIPc",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
    "function_name" : "android::String8::getPathExtension",
    "linker_set_key" : "_ZNK7android7String816getPathExtensionEv",
    "parameters" :
@@ -9202,23 +9133,6 @@
    "return_type" : "_ZTIm",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::walkPath",
-   "linker_set_key" : "_ZNK7android7String88walkPathEPS0_",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    },
-    {
-     "default_arg" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String16::startsWith",
    "linker_set_key" : "_ZNK7android8String1610startsWithEPKDs",
diff --git a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
index 219c76665bb9..e8236ea5b6af 100644
--- a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
@@ -703,9 +703,6 @@
   {
    "name" : "_ZN7android7RefBaseD2Ev"
   },
-  {
-   "name" : "_ZN7android7String810appendPathEPKc"
-  },
   {
    "name" : "_ZN7android7String810lockBufferEj"
   },
@@ -1144,15 +1141,6 @@
   {
    "name" : "_ZNK7android7String810getPathDirEv"
   },
-  {
-   "name" : "_ZNK7android7String811getBasePathEv"
-  },
-  {
-   "name" : "_ZNK7android7String811getPathLeafEv"
-  },
-  {
-   "name" : "_ZNK7android7String814find_extensionEv"
-  },
   {
    "name" : "_ZNK7android7String816getPathExtensionEv"
   },
@@ -1162,9 +1150,6 @@
   {
    "name" : "_ZNK7android7String86lengthEv"
   },
-  {
-   "name" : "_ZNK7android7String88walkPathEPS0_"
-  },
   {
    "name" : "_ZNK7android8String1610startsWithEPKDs"
   },
@@ -6804,22 +6789,6 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
-  {
-   "function_name" : "android::String8::appendPath",
-   "linker_set_key" : "_ZN7android7String810appendPathEPKc",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    },
-    {
-     "referenced_type" : "_ZTIPKc"
-    }
-   ],
-   "return_type" : "_ZTIRN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String8::lockBuffer",
    "linker_set_key" : "_ZN7android7String810lockBufferEj",
@@ -9100,6 +9069,7 @@
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
   {
+   "access" : "private",
    "function_name" : "android::String8::getPathDir",
    "linker_set_key" : "_ZNK7android7String810getPathDirEv",
    "parameters" :
@@ -9112,47 +9082,8 @@
    "return_type" : "_ZTIN7android7String8E",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::getBasePath",
-   "linker_set_key" : "_ZNK7android7String811getBasePathEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
-   "function_name" : "android::String8::getPathLeaf",
-   "linker_set_key" : "_ZNK7android7String811getPathLeafEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "access" : "private",
-   "function_name" : "android::String8::find_extension",
-   "linker_set_key" : "_ZNK7android7String814find_extensionEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIPc",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
    "function_name" : "android::String8::getPathExtension",
    "linker_set_key" : "_ZNK7android7String816getPathExtensionEv",
    "parameters" :
@@ -9198,23 +9129,6 @@
    "return_type" : "_ZTIj",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::walkPath",
-   "linker_set_key" : "_ZNK7android7String88walkPathEPS0_",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    },
-    {
-     "default_arg" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String16::startsWith",
    "linker_set_key" : "_ZNK7android8String1610startsWithEPKDs",
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index ea25c6aa3947..fbb0a0ae32ae 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -130,80 +130,11 @@ class String8
 
             void                toLower();
 
-
-    /*
-     * These methods operate on the string as if it were a path name.
-     */
-
-    /*
-     * Get just the filename component.
-     *
-     * "/tmp/foo/bar.c" --> "bar.c"
-     */
-    String8 getPathLeaf(void) const;
-
-    /*
-     * Remove the last (file name) component, leaving just the directory
-     * name.
-     *
-     * "/tmp/foo/bar.c" --> "/tmp/foo"
-     * "/tmp" --> "" // ????? shouldn't this be "/" ???? XXX
-     * "bar.c" --> ""
-     */
-    String8 getPathDir(void) const;
-
-    /*
-     * Retrieve the front (root dir) component.  Optionally also return the
-     * remaining components.
-     *
-     * "/tmp/foo/bar.c" --> "tmp" (remain = "foo/bar.c")
-     * "/tmp" --> "tmp" (remain = "")
-     * "bar.c" --> "bar.c" (remain = "")
-     */
-    String8 walkPath(String8* outRemains = nullptr) const;
-
-    /*
-     * Return the filename extension.  This is the last '.' and any number
-     * of characters that follow it.  The '.' is included in case we
-     * decide to expand our definition of what constitutes an extension.
-     *
-     * "/tmp/foo/bar.c" --> ".c"
-     * "/tmp" --> ""
-     * "/tmp/foo.bar/baz" --> ""
-     * "foo.jpeg" --> ".jpeg"
-     * "foo." --> ""
-     */
-    String8 getPathExtension(void) const;
-
-    /*
-     * Return the path without the extension.  Rules for what constitutes
-     * an extension are described in the comment for getPathExtension().
-     *
-     * "/tmp/foo/bar.c" --> "/tmp/foo/bar"
-     */
-    String8 getBasePath(void) const;
-
-    /*
-     * Add a component to the pathname.  We guarantee that there is
-     * exactly one path separator between the old path and the new.
-     * If there is no existing name, we just copy the new name in.
-     *
-     * If leaf is a fully qualified path (i.e. starts with '/', it
-     * replaces whatever was there before.
-     */
-    String8& appendPath(const char* leaf);
-    String8& appendPath(const String8& leaf) { return appendPath(leaf.c_str()); }
-
-    /*
-     * Like appendPath(), but does not affect this string.  Returns a new one instead.
-     */
-    String8 appendPathCopy(const char* leaf) const
-                                             { String8 p(*this); p.appendPath(leaf); return p; }
-    String8 appendPathCopy(const String8& leaf) const { return appendPathCopy(leaf.c_str()); }
-
 private:
+            String8 getPathDir(void) const;
+            String8 getPathExtension(void) const;
+
             status_t            real_append(const char* other, size_t numChars);
-            char*               find_extension(void) const;
 
             const char* mString;
 };

From bcae6b5e608278bad272a278f9ffd273fb465609 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Fri, 8 Sep 2023 17:01:15 -0700
Subject: [PATCH 0372/1487] libsnapshot_cow: Prepare device to boot from
 pre-created snapshots

Two new API's have been added:

1: BootFromSnapshotsWithoutSlotSwitch: This will create a new marker
which indicates first-stage init to mount the partitions off snapshots.

We need this marker as during boot, there are couple of places during
mounting snapshots wherein the marker is used. However, there is no
change in the existing I/O path related to OTA.

2: PrepareDeviceToBootWithoutSnapshot: This will delete the marker so
that subsequent reboot will not have the partitions mounted without the
snapshots.

VTS tests covers both these API's. Additionally, when these
markers are present, new OTA's cannot be installed. All these
are covered in VTS tests.

===========================================================

snapshotctl: General flow to apply and revert pre-created snapshots

1: To install the pre-created snapshots:

$snapshotctl map-snapshots <directory path containing snapshots patches>

Now the device is ready to boot from snapshots.

2: After device reboots, partitions are mounted off the snapshots. There
   is no snapshot-merge.

3: In order to go back to previous build:

$snapshotctl revert-snapshots

Now the device is ready to boot from base build.

4: After device reboots back to previous build, all the snapshot states
   and COW images are removed.

============================================

Additional commands:

To delete the pre-created snapshots:

$snapshotctl delete-snapshots

======================================

Tested it on Pixel 6 Pro between two builds which are ~24 hours apart.

1: Creating snapshots on a linux-host - ~4-6 seconds
2: Applying pre-created snapshots - ~10-15 seconds (includes intermediate
   transfer of patches to the device). This depends on the size of snapshot patches.
3: Device reboot - ~12-14 seconds.

Bug: 299011882
Test: 1: Apply pre-created snapshots
2: Reboot device: Verify new build
3: Apply OTA when partitions are mounted of snapshots and verify OTA
   fails.
3: Revert-snapshot and reboot.
4: Verify device goes back to base build.

Full OTA on Pixel. vts_libsnapshot_test

Change-Id: I36a72d973d8f70ae49773ebd45dd996fac22a4e3
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../include/libsnapshot/snapshot.h            |  18 ++-
 fs_mgr/libsnapshot/snapshot.cpp               | 122 ++++++++++++++++--
 fs_mgr/libsnapshot/snapshot_test.cpp          |  50 +++++++
 fs_mgr/libsnapshot/snapshotctl.cpp            |  92 +++++++++----
 4 files changed, 250 insertions(+), 32 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index 6bc8b9b5a013..e7b0020ead86 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -73,6 +73,9 @@ class ISnapshotMergeStats;
 class SnapshotMergeStats;
 class SnapshotStatus;
 
+using std::chrono::duration_cast;
+using namespace std::chrono_literals;
+
 static constexpr const std::string_view kCowGroupName = "cow";
 static constexpr char kVirtualAbCompressionProp[] = "ro.virtual_ab.compression.enabled";
 
@@ -424,6 +427,7 @@ class SnapshotManager final : public ISnapshotManager {
     FRIEND_TEST(SnapshotTest, MergeFailureCode);
     FRIEND_TEST(SnapshotTest, NoMergeBeforeReboot);
     FRIEND_TEST(SnapshotTest, UpdateBootControlHal);
+    FRIEND_TEST(SnapshotTest, BootSnapshotWithoutSlotSwitch);
     FRIEND_TEST(SnapshotUpdateTest, AddPartition);
     FRIEND_TEST(SnapshotUpdateTest, ConsistencyCheckResume);
     FRIEND_TEST(SnapshotUpdateTest, DaemonTransition);
@@ -436,6 +440,7 @@ class SnapshotManager final : public ISnapshotManager {
     FRIEND_TEST(SnapshotUpdateTest, QueryStatusError);
     FRIEND_TEST(SnapshotUpdateTest, SnapshotStatusFileWithoutCow);
     FRIEND_TEST(SnapshotUpdateTest, SpaceSwapUpdate);
+    FRIEND_TEST(SnapshotUpdateTest, MapAllSnapshotsWithoutSlotSwitch);
     friend class SnapshotTest;
     friend class SnapshotUpdateTest;
     friend class FlashAfterUpdateTest;
@@ -456,7 +461,7 @@ class SnapshotManager final : public ISnapshotManager {
     bool EnsureImageManager();
 
     // Ensure we're connected to snapuserd.
-    bool EnsureSnapuserdConnected();
+    bool EnsureSnapuserdConnected(std::chrono::milliseconds timeout_ms = 10s);
 
     // Helpers for first-stage init.
     const std::unique_ptr<IDeviceInfo>& device() const { return device_; }
@@ -549,6 +554,16 @@ class SnapshotManager final : public ISnapshotManager {
     // Unmap and remove all known snapshots.
     bool RemoveAllSnapshots(LockedFile* lock);
 
+    // Boot device off snapshots without slot switch
+    bool BootFromSnapshotsWithoutSlotSwitch();
+
+    // Remove kBootSnapshotsWithoutSlotSwitch so that device can boot
+    // without snapshots on the current slot
+    bool PrepareDeviceToBootWithoutSnapshot();
+
+    // Is the kBootSnapshotsWithoutSlotSwitch present
+    bool IsSnapshotWithoutSlotSwitch();
+
     // List the known snapshot names.
     bool ListSnapshots(LockedFile* lock, std::vector<std::string>* snapshots,
                        const std::string& suffix = "");
@@ -663,6 +678,7 @@ class SnapshotManager final : public ISnapshotManager {
     std::string GetRollbackIndicatorPath();
     std::string GetForwardMergeIndicatorPath();
     std::string GetOldPartitionMetadataPath();
+    std::string GetBootSnapshotsWithoutSlotSwitchPath();
 
     const LpMetadata* ReadOldPartitionMetadata(LockedFile* lock);
 
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 51389a0dbf27..4743a42a4b23 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -83,6 +83,8 @@ using std::chrono::duration_cast;
 using namespace std::chrono_literals;
 using namespace std::string_literals;
 
+static constexpr char kBootSnapshotsWithoutSlotSwitch[] =
+        "/metadata/ota/snapshot-boot-without-slot-switch";
 static constexpr char kBootIndicatorPath[] = "/metadata/ota/snapshot-boot";
 static constexpr char kRollbackIndicatorPath[] = "/metadata/ota/rollback-indicator";
 static constexpr auto kUpdateStateCheckInterval = 2s;
@@ -217,6 +219,12 @@ bool SnapshotManager::TryCancelUpdate(bool* needs_merge) {
     auto file = LockExclusive();
     if (!file) return false;
 
+    if (IsSnapshotWithoutSlotSwitch()) {
+        LOG(ERROR) << "Cannot cancel the snapshots as partitions are mounted off the snapshots on "
+                      "current slot.";
+        return false;
+    }
+
     UpdateState state = ReadUpdateState(file.get());
     if (state == UpdateState::None) {
         RemoveInvalidSnapshots(file.get());
@@ -299,10 +307,9 @@ bool SnapshotManager::RemoveAllUpdateState(LockedFile* lock, const std::function
     // - For ForwardMerge, FinishedSnapshotWrites asserts that the existence of the indicator
     // matches the incoming update.
     std::vector<std::string> files = {
-            GetSnapshotBootIndicatorPath(),
-            GetRollbackIndicatorPath(),
-            GetForwardMergeIndicatorPath(),
-            GetOldPartitionMetadataPath(),
+            GetSnapshotBootIndicatorPath(),          GetRollbackIndicatorPath(),
+            GetForwardMergeIndicatorPath(),          GetOldPartitionMetadataPath(),
+            GetBootSnapshotsWithoutSlotSwitchPath(),
     };
     for (const auto& file : files) {
         RemoveFileIfExists(file);
@@ -483,6 +490,32 @@ bool SnapshotManager::MapDmUserCow(LockedFile* lock, const std::string& name,
             LOG(ERROR) << "Failed to retrieve base_sectors from Snapuserd";
             return false;
         }
+    } else if (IsSnapshotWithoutSlotSwitch()) {
+        // When snapshots are on current slot, we determine the size
+        // of block device based on the number of COW operations. We cannot
+        // use base device as it will be from older image.
+        size_t num_ops = 0;
+        uint64_t dev_sz = 0;
+        unique_fd fd(open(cow_file.c_str(), O_RDONLY | O_CLOEXEC));
+        if (fd < 0) {
+            PLOG(ERROR) << "Failed to open " << cow_file;
+            return false;
+        }
+
+        CowReader reader;
+        if (!reader.Parse(std::move(fd))) {
+            LOG(ERROR) << "Failed to parse cow " << cow_file;
+            return false;
+        }
+
+        const auto& header = reader.GetHeader();
+        if (header.prefix.major_version > 2) {
+            LOG(ERROR) << "COW format not supported";
+            return false;
+        }
+        num_ops = reader.get_num_total_data_ops();
+        dev_sz = (num_ops * header.block_size);
+        base_sectors = dev_sz >> 9;
     } else {
         // For userspace snapshots, the size of the base device is taken as the
         // size of the dm-user block device. Since there is no pseudo mapping
@@ -1479,6 +1512,10 @@ MergeFailureCode SnapshotManager::MergeSecondPhaseSnapshots(LockedFile* lock) {
     return result;
 }
 
+std::string SnapshotManager::GetBootSnapshotsWithoutSlotSwitchPath() {
+    return metadata_dir_ + "/" + android::base::Basename(kBootSnapshotsWithoutSlotSwitch);
+}
+
 std::string SnapshotManager::GetSnapshotBootIndicatorPath() {
     return metadata_dir_ + "/" + android::base::Basename(kBootIndicatorPath);
 }
@@ -2120,6 +2157,10 @@ UpdateState SnapshotManager::GetUpdateState(double* progress) {
     return state;
 }
 
+bool SnapshotManager::IsSnapshotWithoutSlotSwitch() {
+    return (access(GetBootSnapshotsWithoutSlotSwitchPath().c_str(), F_OK) == 0);
+}
+
 bool SnapshotManager::UpdateUsesCompression() {
     auto lock = LockShared();
     if (!lock) return false;
@@ -2212,6 +2253,13 @@ std::string SnapshotManager::GetGlobalRollbackIndicatorPath() {
 }
 
 bool SnapshotManager::NeedSnapshotsInFirstStageMount() {
+    if (IsSnapshotWithoutSlotSwitch()) {
+        if (GetCurrentSlot() != Slot::Source) {
+            LOG(ERROR) << "Snapshots marked to boot without slot switch; but slot is wrong";
+            return false;
+        }
+        return true;
+    }
     // If we fail to read, we'll wind up using CreateLogicalPartitions, which
     // will create devices that look like the old slot, except with extra
     // content at the end of each device. This will confuse dm-verity, and
@@ -2347,7 +2395,8 @@ bool SnapshotManager::MapPartitionWithSnapshot(LockedFile* lock,
     // completed, live_snapshot_status is set to nullopt.
     std::optional<SnapshotStatus> live_snapshot_status;
     do {
-        if (!(params.partition->attributes & LP_PARTITION_ATTR_UPDATED)) {
+        if (!IsSnapshotWithoutSlotSwitch() &&
+            !(params.partition->attributes & LP_PARTITION_ATTR_UPDATED)) {
             LOG(INFO) << "Detected re-flashing of partition, will skip snapshot: "
                       << params.GetPartitionName();
             break;
@@ -2703,7 +2752,7 @@ bool SnapshotManager::UnmapUserspaceSnapshotDevice(LockedFile* lock,
     // to unmap; hence, we can't be deleting the device
     // as the table would be mounted off partitions and will fail.
     if (snapshot_status.state() != SnapshotState::MERGE_COMPLETED) {
-        if (!DeleteDeviceIfExists(dm_user_name)) {
+        if (!DeleteDeviceIfExists(dm_user_name, 4000ms)) {
             LOG(ERROR) << "Cannot unmap " << dm_user_name;
             return false;
         }
@@ -3098,7 +3147,7 @@ bool SnapshotManager::EnsureImageManager() {
     return true;
 }
 
-bool SnapshotManager::EnsureSnapuserdConnected() {
+bool SnapshotManager::EnsureSnapuserdConnected(std::chrono::milliseconds timeout_ms) {
     if (snapuserd_client_) {
         return true;
     }
@@ -3107,7 +3156,7 @@ bool SnapshotManager::EnsureSnapuserdConnected() {
         return false;
     }
 
-    snapuserd_client_ = SnapuserdClient::Connect(kSnapuserdSocket, 10s);
+    snapuserd_client_ = SnapuserdClient::Connect(kSnapuserdSocket, timeout_ms);
     if (!snapuserd_client_) {
         LOG(ERROR) << "Unable to connect to snapuserd";
         return false;
@@ -4372,13 +4421,70 @@ std::string SnapshotManager::ReadSourceBuildFingerprint() {
 bool SnapshotManager::IsUserspaceSnapshotUpdateInProgress() {
     auto slot = GetCurrentSlot();
     if (slot == Slot::Target) {
+        // Merge in-progress
         if (IsSnapuserdRequired()) {
             return true;
         }
     }
 
+    // Let's check more deeper to see if snapshots are mounted
+    auto lock = LockExclusive();
+    if (!lock) {
+        return false;
+    }
+
+    std::vector<std::string> snapshots;
+    if (!ListSnapshots(lock.get(), &snapshots)) {
+        return false;
+    }
+
+    for (const auto& snapshot : snapshots) {
+        // Active snapshot and daemon is alive
+        if (IsSnapshotDevice(snapshot) && EnsureSnapuserdConnected(2s)) {
+            return true;
+        }
+    }
+
     return false;
 }
 
+bool SnapshotManager::BootFromSnapshotsWithoutSlotSwitch() {
+    auto lock = LockExclusive();
+    if (!lock) return false;
+
+    auto contents = device_->GetSlotSuffix();
+    // This is the indicator which tells first-stage init
+    // to boot from snapshots even though there was no slot-switch
+    auto boot_file = GetBootSnapshotsWithoutSlotSwitchPath();
+    if (!WriteStringToFileAtomic(contents, boot_file)) {
+        PLOG(ERROR) << "write failed: " << boot_file;
+        return false;
+    }
+
+    SnapshotUpdateStatus update_status = ReadSnapshotUpdateStatus(lock.get());
+    update_status.set_state(UpdateState::Initiated);
+    update_status.set_userspace_snapshots(true);
+    update_status.set_using_snapuserd(true);
+    if (!WriteSnapshotUpdateStatus(lock.get(), update_status)) {
+        return false;
+    }
+    return true;
+}
+
+bool SnapshotManager::PrepareDeviceToBootWithoutSnapshot() {
+    auto lock = LockExclusive();
+    if (!lock) return false;
+
+    android::base::RemoveFileIfExists(GetSnapshotBootIndicatorPath());
+    android::base::RemoveFileIfExists(GetBootSnapshotsWithoutSlotSwitchPath());
+
+    SnapshotUpdateStatus update_status = ReadSnapshotUpdateStatus(lock.get());
+    update_status.set_state(UpdateState::Cancelled);
+    if (!WriteSnapshotUpdateStatus(lock.get(), update_status)) {
+        return false;
+    }
+    return true;
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 3b6d26aa11ff..e506110b61a7 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2559,6 +2559,56 @@ TEST_F(SnapshotUpdateTest, DaemonTransition) {
     }
 }
 
+TEST_F(SnapshotUpdateTest, MapAllSnapshotsWithoutSlotSwitch) {
+    MountMetadata();
+    AddOperationForPartitions();
+    // Execute the update.
+    ASSERT_TRUE(sm->BeginUpdate());
+    ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
+
+    if (!sm->UpdateUsesUserSnapshots()) {
+        GTEST_SKIP() << "Test does not apply as UserSnapshots aren't enabled.";
+    }
+
+    ASSERT_TRUE(WriteSnapshots());
+    ASSERT_TRUE(sm->FinishedSnapshotWrites(false));
+
+    if (ShouldSkipLegacyMerging()) {
+        GTEST_SKIP() << "Skipping legacy merge test";
+    }
+    // Mark the indicator
+    ASSERT_TRUE(sm->BootFromSnapshotsWithoutSlotSwitch());
+
+    ASSERT_TRUE(sm->EnsureSnapuserdConnected());
+    sm->set_use_first_stage_snapuserd(true);
+
+    ASSERT_TRUE(sm->NeedSnapshotsInFirstStageMount());
+
+    // Map snapshots
+    ASSERT_TRUE(sm->MapAllSnapshots(10s));
+
+    // New updates should fail
+    ASSERT_FALSE(sm->BeginUpdate());
+
+    // Snapshots cannot be cancelled
+    ASSERT_FALSE(sm->CancelUpdate());
+
+    // Merge cannot start
+    ASSERT_FALSE(sm->InitiateMerge());
+
+    // Read bytes back and verify they match the cache.
+    ASSERT_TRUE(IsPartitionUnchanged("sys_b"));
+
+    // Remove the indicators
+    ASSERT_TRUE(sm->PrepareDeviceToBootWithoutSnapshot());
+
+    // Ensure snapshots are still mounted
+    ASSERT_TRUE(sm->IsUserspaceSnapshotUpdateInProgress());
+
+    // Cleanup snapshots
+    ASSERT_TRUE(sm->UnmapAllSnapshots());
+}
+
 TEST_F(SnapshotUpdateTest, MapAllSnapshots) {
     AddOperationForPartitions();
     // Execute the update.
diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 1323b0bc8a64..ebaca2dbe92a 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -75,7 +75,11 @@ int Usage() {
                  "  unmap-snapshots\n"
                  "    Unmap all pre-created snapshots\n"
                  "  delete-snapshots\n"
-                 "    Delete all pre-created snapshots\n";
+                 "    Delete all pre-created snapshots\n"
+                 "  revert-snapshots\n"
+                 "    Prepares devices to boot without snapshots on next boot.\n"
+                 "    This does not delete the snapshot. It only removes the indicators\n"
+                 "    so that first stage init will not mount from snapshots.\n";
     return EX_USAGE;
 }
 
@@ -87,9 +91,11 @@ class MapSnapshots {
     MapSnapshots(std::string path = "");
     bool CreateSnapshotDevice(std::string& partition_name, std::string& patch);
     bool InitiateThreadedSnapshotWrite(std::string& pname, std::string& snapshot_patch);
-    bool WaitForSnapshotWritesToComplete();
+    bool FinishSnapshotWrites();
     bool UnmapCowImagePath(std::string& name);
-    bool DeleteCowImage(std::string& name);
+    bool DeleteSnapshots();
+    bool CleanupSnapshot() { return sm_->PrepareDeviceToBootWithoutSnapshot(); }
+    bool BeginUpdate();
 
   private:
     std::optional<std::string> GetCowImagePath(std::string& name);
@@ -107,7 +113,24 @@ MapSnapshots::MapSnapshots(std::string path) {
         exit(1);
     }
     snapshot_dir_path_ = path + "/";
+}
+
+bool MapSnapshots::BeginUpdate() {
     lock_ = sm_->LockExclusive();
+    std::vector<std::string> snapshots;
+    sm_->ListSnapshots(lock_.get(), &snapshots);
+    if (!snapshots.empty()) {
+        // Snapshots are already present.
+        return true;
+    }
+
+    lock_ = nullptr;
+    if (!sm_->BeginUpdate()) {
+        LOG(ERROR) << "BeginUpdate failed";
+        return false;
+    }
+    lock_ = sm_->LockExclusive();
+    return true;
 }
 
 bool MapSnapshots::CreateSnapshotDevice(std::string& partition_name, std::string& patchfile) {
@@ -130,6 +153,9 @@ bool MapSnapshots::CreateSnapshotDevice(std::string& partition_name, std::string
     dev_sz &= ~(block_sz - 1);
 
     SnapshotStatus status;
+    status.set_state(SnapshotState::CREATED);
+    status.set_using_snapuserd(true);
+    status.set_old_partition_size(0);
     status.set_name(partition_name);
     status.set_cow_file_size(dev_sz);
     status.set_cow_partition_size(0);
@@ -216,27 +242,33 @@ bool MapSnapshots::InitiateThreadedSnapshotWrite(std::string& pname, std::string
     return true;
 }
 
-bool MapSnapshots::WaitForSnapshotWritesToComplete() {
+bool MapSnapshots::FinishSnapshotWrites() {
     bool ret = true;
     for (auto& t : threads_) {
         ret = t.get() && ret;
     }
 
+    lock_ = nullptr;
     if (ret) {
         LOG(INFO) << "Pre-created snapshots successfully copied";
-    } else {
-        LOG(ERROR) << "Snapshot copy failed";
+        if (!sm_->FinishedSnapshotWrites(false)) {
+            return false;
+        }
+        return sm_->BootFromSnapshotsWithoutSlotSwitch();
     }
-    return ret;
+
+    LOG(ERROR) << "Snapshot copy failed";
+    return false;
 }
 
 bool MapSnapshots::UnmapCowImagePath(std::string& name) {
     return sm_->UnmapCowImage(name);
 }
 
-bool MapSnapshots::DeleteCowImage(std::string& name) {
-    if (!sm_->DeleteSnapshot(lock_.get(), name)) {
-        LOG(ERROR) << "Delete snapshot failed";
+bool MapSnapshots::DeleteSnapshots() {
+    lock_ = sm_->LockExclusive();
+    if (!sm_->RemoveAllUpdateState(lock_.get())) {
+        LOG(ERROR) << "Remove All Update State failed";
         return false;
     }
     return true;
@@ -281,7 +313,8 @@ bool GetVerityPartitions(std::vector<std::string>& partitions) {
     return true;
 }
 
-bool UnMapPrecreatedSnapshots(int, char**) {
+bool UnMapPrecreatedSnapshots(int, char** argv) {
+    android::base::InitLogging(argv, &android::base::KernelLogger);
     // Make sure we are root.
     if (::getuid() != 0) {
         LOG(ERROR) << "Not running as root. Try \"adb root\" first.";
@@ -302,29 +335,36 @@ bool UnMapPrecreatedSnapshots(int, char**) {
     return true;
 }
 
-bool DeletePrecreatedSnapshots(int, char**) {
+bool RemovePrecreatedSnapshots(int, char** argv) {
+    android::base::InitLogging(argv, &android::base::KernelLogger);
     // Make sure we are root.
     if (::getuid() != 0) {
         LOG(ERROR) << "Not running as root. Try \"adb root\" first.";
-        return EXIT_FAILURE;
-    }
-
-    std::vector<std::string> partitions;
-    if (!GetVerityPartitions(partitions)) {
         return false;
     }
 
     MapSnapshots snapshot;
-    for (auto partition : partitions) {
-        if (!snapshot.DeleteCowImage(partition)) {
-            LOG(ERROR) << "DeleteCowImage failed: " << partition;
-        }
+    if (!snapshot.CleanupSnapshot()) {
+        LOG(ERROR) << "CleanupSnapshot failed";
+        return false;
     }
     return true;
 }
 
+bool DeletePrecreatedSnapshots(int, char** argv) {
+    android::base::InitLogging(argv, &android::base::KernelLogger);
+    // Make sure we are root.
+    if (::getuid() != 0) {
+        LOG(ERROR) << "Not running as root. Try \"adb root\" first.";
+        return EXIT_FAILURE;
+    }
+
+    MapSnapshots snapshot;
+    return snapshot.DeleteSnapshots();
+}
+
 bool MapPrecreatedSnapshots(int argc, char** argv) {
-    android::base::InitLogging(argv, &android::base::StderrLogger);
+    android::base::InitLogging(argv, &android::base::KernelLogger);
 
     // Make sure we are root.
     if (::getuid() != 0) {
@@ -365,6 +405,11 @@ bool MapPrecreatedSnapshots(int argc, char** argv) {
     }
 
     MapSnapshots cow(path);
+    if (!cow.BeginUpdate()) {
+        LOG(ERROR) << "BeginUpdate failed";
+        return false;
+    }
+
     for (auto& pair : partitions) {
         if (!cow.CreateSnapshotDevice(pair.first, pair.second)) {
             LOG(ERROR) << "CreateSnapshotDevice failed for: " << pair.first;
@@ -376,7 +421,7 @@ bool MapPrecreatedSnapshots(int argc, char** argv) {
         }
     }
 
-    return cow.WaitForSnapshotWritesToComplete();
+    return cow.FinishSnapshotWrites();
 }
 
 #ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
@@ -508,6 +553,7 @@ static std::map<std::string, std::function<bool(int, char**)>> kCmdMap = {
         {"map-snapshots", MapPrecreatedSnapshots},
         {"unmap-snapshots", UnMapPrecreatedSnapshots},
         {"delete-snapshots", DeletePrecreatedSnapshots},
+        {"revert-snapshots", RemovePrecreatedSnapshots},
         // clang-format on
 };
 

From 141255f30c35372bba80bfff9ac164f34e38784b Mon Sep 17 00:00:00 2001
From: Rhed Jao <rhedjao@google.com>
Date: Mon, 11 Sep 2023 02:05:58 +0000
Subject: [PATCH 0373/1487] Revert "Revert "Revert "Drop all path-related
 methods from android::String8"""

This reverts commit 4b6a7c3940bc6d5e89e15179d8d49600e6dd4857.

Reason for revert: b/299695302, b/299694769

Change-Id: I89c6719d23446f2f9ce24e5b75d321538b580431
---
 libutils/String8.cpp                          | 108 +++++++++++++++++-
 libutils/String8_fuzz.cpp                     |  24 ++++
 .../arm64/source-based/libutils.so.lsdump     |  88 +++++++++++++-
 .../arm_arm64/source-based/libutils.so.lsdump |  88 +++++++++++++-
 libutils/include/utils/String8.h              |  75 +++++++++++-
 5 files changed, 375 insertions(+), 8 deletions(-)

diff --git a/libutils/String8.cpp b/libutils/String8.cpp
index 4301f0ea3a77..2b72847e52bd 100644
--- a/libutils/String8.cpp
+++ b/libutils/String8.cpp
@@ -430,6 +430,31 @@ void String8::toLower()
 // ---------------------------------------------------------------------------
 // Path functions
 
+static void setPathName(String8& s, const char* name) {
+    size_t len = strlen(name);
+    char* buf = s.lockBuffer(len);
+
+    memcpy(buf, name, len);
+
+    // remove trailing path separator, if present
+    if (len > 0 && buf[len - 1] == OS_PATH_SEPARATOR) len--;
+    buf[len] = '\0';
+
+    s.unlockBuffer(len);
+}
+
+String8 String8::getPathLeaf(void) const
+{
+    const char* cp;
+    const char*const buf = mString;
+
+    cp = strrchr(buf, OS_PATH_SEPARATOR);
+    if (cp == nullptr)
+        return String8(*this);
+    else
+        return String8(cp+1);
+}
+
 String8 String8::getPathDir(void) const
 {
     const char* cp;
@@ -442,14 +467,40 @@ String8 String8::getPathDir(void) const
         return String8(str, cp - str);
 }
 
+String8 String8::walkPath(String8* outRemains) const
+{
+    const char* cp;
+    const char*const str = mString;
+    const char* buf = str;
+
+    cp = strchr(buf, OS_PATH_SEPARATOR);
+    if (cp == buf) {
+        // don't include a leading '/'.
+        buf = buf+1;
+        cp = strchr(buf, OS_PATH_SEPARATOR);
+    }
+
+    if (cp == nullptr) {
+        String8 res = buf != str ? String8(buf) : *this;
+        if (outRemains) *outRemains = String8("");
+        return res;
+    }
+
+    String8 res(buf, cp-buf);
+    if (outRemains) *outRemains = String8(cp+1);
+    return res;
+}
+
 /*
  * Helper function for finding the start of an extension in a pathname.
  *
  * Returns a pointer inside mString, or NULL if no extension was found.
  */
-static const char* find_extension(const char* str) {
+char* String8::find_extension(void) const
+{
     const char* lastSlash;
     const char* lastDot;
+    const char* const str = mString;
 
     // only look at the filename
     lastSlash = strrchr(str, OS_PATH_SEPARATOR);
@@ -464,16 +515,67 @@ static const char* find_extension(const char* str) {
         return nullptr;
 
     // looks good, ship it
-    return lastDot;
+    return const_cast<char*>(lastDot);
 }
 
 String8 String8::getPathExtension(void) const
 {
-    auto ext = find_extension(mString);
+    char* ext;
+
+    ext = find_extension();
     if (ext != nullptr)
         return String8(ext);
     else
         return String8("");
 }
 
+String8 String8::getBasePath(void) const
+{
+    char* ext;
+    const char* const str = mString;
+
+    ext = find_extension();
+    if (ext == nullptr)
+        return String8(*this);
+    else
+        return String8(str, ext - str);
+}
+
+String8& String8::appendPath(const char* name)
+{
+    // TODO: The test below will fail for Win32 paths. Fix later or ignore.
+    if (name[0] != OS_PATH_SEPARATOR) {
+        if (*name == '\0') {
+            // nothing to do
+            return *this;
+        }
+
+        size_t len = length();
+        if (len == 0) {
+            // no existing filename, just use the new one
+            setPathName(*this, name);
+            return *this;
+        }
+
+        // make room for oldPath + '/' + newPath
+        int newlen = strlen(name);
+
+        char* buf = lockBuffer(len+1+newlen);
+
+        // insert a '/' if needed
+        if (buf[len-1] != OS_PATH_SEPARATOR)
+            buf[len++] = OS_PATH_SEPARATOR;
+
+        memcpy(buf+len, name, newlen+1);
+        len += newlen;
+
+        unlockBuffer(len);
+
+        return *this;
+    } else {
+        setPathName(*this, name);
+        return *this;
+    }
+}
+
 }; // namespace android
diff --git a/libutils/String8_fuzz.cpp b/libutils/String8_fuzz.cpp
index cbce0505891e..6f7a54f9f310 100644
--- a/libutils/String8_fuzz.cpp
+++ b/libutils/String8_fuzz.cpp
@@ -68,6 +68,30 @@ std::vector<std::function<void(FuzzedDataProvider*, android::String8*, android::
                     int start_index = dataProvider->ConsumeIntegralInRange<int>(0, str1->size());
                     str1->find(str2->c_str(), start_index);
                 },
+
+                // Path handling
+                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
+                    str1->getBasePath();
+                },
+                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
+                    str1->getPathExtension();
+                },
+                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
+                    str1->getPathLeaf();
+                },
+                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
+                    str1->getPathDir();
+                },
+                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
+                    std::shared_ptr<android::String8> path_out_str =
+                            std::make_shared<android::String8>();
+                    str1->walkPath(path_out_str.get());
+                    path_out_str->clear();
+                },
+                [](FuzzedDataProvider* dataProvider, android::String8* str1,
+                   android::String8*) -> void {
+                    str1->appendPath(dataProvider->ConsumeBytesWithTerminator<char>(5).data());
+                },
 };
 
 void fuzzFormat(FuzzedDataProvider* dataProvider, android::String8* str1, bool shouldAppend) {
diff --git a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
index 8881b44eb181..46baddecde7b 100644
--- a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
@@ -703,6 +703,9 @@
   {
    "name" : "_ZN7android7RefBaseD2Ev"
   },
+  {
+   "name" : "_ZN7android7String810appendPathEPKc"
+  },
   {
    "name" : "_ZN7android7String810lockBufferEm"
   },
@@ -1141,6 +1144,15 @@
   {
    "name" : "_ZNK7android7String810getPathDirEv"
   },
+  {
+   "name" : "_ZNK7android7String811getBasePathEv"
+  },
+  {
+   "name" : "_ZNK7android7String811getPathLeafEv"
+  },
+  {
+   "name" : "_ZNK7android7String814find_extensionEv"
+  },
   {
    "name" : "_ZNK7android7String816getPathExtensionEv"
   },
@@ -1150,6 +1162,9 @@
   {
    "name" : "_ZNK7android7String86lengthEv"
   },
+  {
+   "name" : "_ZNK7android7String88walkPathEPS0_"
+  },
   {
    "name" : "_ZNK7android8String1610startsWithEPKDs"
   },
@@ -6793,6 +6808,22 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "function_name" : "android::String8::appendPath",
+   "linker_set_key" : "_ZN7android7String810appendPathEPKc",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android7String8E"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIRN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
   {
    "function_name" : "android::String8::lockBuffer",
    "linker_set_key" : "_ZN7android7String810lockBufferEm",
@@ -9073,7 +9104,6 @@
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
   {
-   "access" : "private",
    "function_name" : "android::String8::getPathDir",
    "linker_set_key" : "_ZNK7android7String810getPathDirEv",
    "parameters" :
@@ -9086,8 +9116,47 @@
    "return_type" : "_ZTIN7android7String8E",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "function_name" : "android::String8::getBasePath",
+   "linker_set_key" : "_ZNK7android7String811getBasePathEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
+  {
+   "function_name" : "android::String8::getPathLeaf",
+   "linker_set_key" : "_ZNK7android7String811getPathLeafEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
   {
    "access" : "private",
+   "function_name" : "android::String8::find_extension",
+   "linker_set_key" : "_ZNK7android7String814find_extensionEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIPc",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
+  {
    "function_name" : "android::String8::getPathExtension",
    "linker_set_key" : "_ZNK7android7String816getPathExtensionEv",
    "parameters" :
@@ -9133,6 +9202,23 @@
    "return_type" : "_ZTIm",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "function_name" : "android::String8::walkPath",
+   "linker_set_key" : "_ZNK7android7String88walkPathEPS0_",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    },
+    {
+     "default_arg" : true,
+     "referenced_type" : "_ZTIPN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
   {
    "function_name" : "android::String16::startsWith",
    "linker_set_key" : "_ZNK7android8String1610startsWithEPKDs",
diff --git a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
index e8236ea5b6af..219c76665bb9 100644
--- a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
@@ -703,6 +703,9 @@
   {
    "name" : "_ZN7android7RefBaseD2Ev"
   },
+  {
+   "name" : "_ZN7android7String810appendPathEPKc"
+  },
   {
    "name" : "_ZN7android7String810lockBufferEj"
   },
@@ -1141,6 +1144,15 @@
   {
    "name" : "_ZNK7android7String810getPathDirEv"
   },
+  {
+   "name" : "_ZNK7android7String811getBasePathEv"
+  },
+  {
+   "name" : "_ZNK7android7String811getPathLeafEv"
+  },
+  {
+   "name" : "_ZNK7android7String814find_extensionEv"
+  },
   {
    "name" : "_ZNK7android7String816getPathExtensionEv"
   },
@@ -1150,6 +1162,9 @@
   {
    "name" : "_ZNK7android7String86lengthEv"
   },
+  {
+   "name" : "_ZNK7android7String88walkPathEPS0_"
+  },
   {
    "name" : "_ZNK7android8String1610startsWithEPKDs"
   },
@@ -6789,6 +6804,22 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "function_name" : "android::String8::appendPath",
+   "linker_set_key" : "_ZN7android7String810appendPathEPKc",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android7String8E"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "return_type" : "_ZTIRN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
   {
    "function_name" : "android::String8::lockBuffer",
    "linker_set_key" : "_ZN7android7String810lockBufferEj",
@@ -9069,7 +9100,6 @@
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
   {
-   "access" : "private",
    "function_name" : "android::String8::getPathDir",
    "linker_set_key" : "_ZNK7android7String810getPathDirEv",
    "parameters" :
@@ -9082,8 +9112,47 @@
    "return_type" : "_ZTIN7android7String8E",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "function_name" : "android::String8::getBasePath",
+   "linker_set_key" : "_ZNK7android7String811getBasePathEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
+  {
+   "function_name" : "android::String8::getPathLeaf",
+   "linker_set_key" : "_ZNK7android7String811getPathLeafEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
   {
    "access" : "private",
+   "function_name" : "android::String8::find_extension",
+   "linker_set_key" : "_ZNK7android7String814find_extensionEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIPc",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
+  {
    "function_name" : "android::String8::getPathExtension",
    "linker_set_key" : "_ZNK7android7String816getPathExtensionEv",
    "parameters" :
@@ -9129,6 +9198,23 @@
    "return_type" : "_ZTIj",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "function_name" : "android::String8::walkPath",
+   "linker_set_key" : "_ZNK7android7String88walkPathEPS0_",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPKN7android7String8E"
+    },
+    {
+     "default_arg" : true,
+     "referenced_type" : "_ZTIPN7android7String8E"
+    }
+   ],
+   "return_type" : "_ZTIN7android7String8E",
+   "source_file" : "system/core/libutils/include/utils/String8.h"
+  },
   {
    "function_name" : "android::String16::startsWith",
    "linker_set_key" : "_ZNK7android8String1610startsWithEPKDs",
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index fbb0a0ae32ae..ea25c6aa3947 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -130,11 +130,80 @@ class String8
 
             void                toLower();
 
-private:
-            String8 getPathDir(void) const;
-            String8 getPathExtension(void) const;
 
+    /*
+     * These methods operate on the string as if it were a path name.
+     */
+
+    /*
+     * Get just the filename component.
+     *
+     * "/tmp/foo/bar.c" --> "bar.c"
+     */
+    String8 getPathLeaf(void) const;
+
+    /*
+     * Remove the last (file name) component, leaving just the directory
+     * name.
+     *
+     * "/tmp/foo/bar.c" --> "/tmp/foo"
+     * "/tmp" --> "" // ????? shouldn't this be "/" ???? XXX
+     * "bar.c" --> ""
+     */
+    String8 getPathDir(void) const;
+
+    /*
+     * Retrieve the front (root dir) component.  Optionally also return the
+     * remaining components.
+     *
+     * "/tmp/foo/bar.c" --> "tmp" (remain = "foo/bar.c")
+     * "/tmp" --> "tmp" (remain = "")
+     * "bar.c" --> "bar.c" (remain = "")
+     */
+    String8 walkPath(String8* outRemains = nullptr) const;
+
+    /*
+     * Return the filename extension.  This is the last '.' and any number
+     * of characters that follow it.  The '.' is included in case we
+     * decide to expand our definition of what constitutes an extension.
+     *
+     * "/tmp/foo/bar.c" --> ".c"
+     * "/tmp" --> ""
+     * "/tmp/foo.bar/baz" --> ""
+     * "foo.jpeg" --> ".jpeg"
+     * "foo." --> ""
+     */
+    String8 getPathExtension(void) const;
+
+    /*
+     * Return the path without the extension.  Rules for what constitutes
+     * an extension are described in the comment for getPathExtension().
+     *
+     * "/tmp/foo/bar.c" --> "/tmp/foo/bar"
+     */
+    String8 getBasePath(void) const;
+
+    /*
+     * Add a component to the pathname.  We guarantee that there is
+     * exactly one path separator between the old path and the new.
+     * If there is no existing name, we just copy the new name in.
+     *
+     * If leaf is a fully qualified path (i.e. starts with '/', it
+     * replaces whatever was there before.
+     */
+    String8& appendPath(const char* leaf);
+    String8& appendPath(const String8& leaf) { return appendPath(leaf.c_str()); }
+
+    /*
+     * Like appendPath(), but does not affect this string.  Returns a new one instead.
+     */
+    String8 appendPathCopy(const char* leaf) const
+                                             { String8 p(*this); p.appendPath(leaf); return p; }
+    String8 appendPathCopy(const String8& leaf) const { return appendPathCopy(leaf.c_str()); }
+
+private:
             status_t            real_append(const char* other, size_t numChars);
+            char*               find_extension(void) const;
 
             const char* mString;
 };

From a1853516ff0dc78b677eeafa792cdfa9e5d9a2ee Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Mon, 11 Sep 2023 17:45:16 +0000
Subject: [PATCH 0374/1487] Revert "Revert "Revert "Revert "Drop all
 path-related methods from android::String8""""

This reverts commit 141255f30c35372bba80bfff9ac164f34e38784b.

Reason for revert: Attempt re-submit again

Change-Id: I0e568fdf8f7a141ee3c5d54f68530ff478a47439
---
 libutils/String8.cpp                          | 108 +-----------------
 libutils/String8_fuzz.cpp                     |  24 ----
 .../arm64/source-based/libutils.so.lsdump     |  88 +-------------
 .../arm_arm64/source-based/libutils.so.lsdump |  88 +-------------
 libutils/include/utils/String8.h              |  75 +-----------
 5 files changed, 8 insertions(+), 375 deletions(-)

diff --git a/libutils/String8.cpp b/libutils/String8.cpp
index 2b72847e52bd..4301f0ea3a77 100644
--- a/libutils/String8.cpp
+++ b/libutils/String8.cpp
@@ -430,31 +430,6 @@ void String8::toLower()
 // ---------------------------------------------------------------------------
 // Path functions
 
-static void setPathName(String8& s, const char* name) {
-    size_t len = strlen(name);
-    char* buf = s.lockBuffer(len);
-
-    memcpy(buf, name, len);
-
-    // remove trailing path separator, if present
-    if (len > 0 && buf[len - 1] == OS_PATH_SEPARATOR) len--;
-    buf[len] = '\0';
-
-    s.unlockBuffer(len);
-}
-
-String8 String8::getPathLeaf(void) const
-{
-    const char* cp;
-    const char*const buf = mString;
-
-    cp = strrchr(buf, OS_PATH_SEPARATOR);
-    if (cp == nullptr)
-        return String8(*this);
-    else
-        return String8(cp+1);
-}
-
 String8 String8::getPathDir(void) const
 {
     const char* cp;
@@ -467,40 +442,14 @@ String8 String8::getPathDir(void) const
         return String8(str, cp - str);
 }
 
-String8 String8::walkPath(String8* outRemains) const
-{
-    const char* cp;
-    const char*const str = mString;
-    const char* buf = str;
-
-    cp = strchr(buf, OS_PATH_SEPARATOR);
-    if (cp == buf) {
-        // don't include a leading '/'.
-        buf = buf+1;
-        cp = strchr(buf, OS_PATH_SEPARATOR);
-    }
-
-    if (cp == nullptr) {
-        String8 res = buf != str ? String8(buf) : *this;
-        if (outRemains) *outRemains = String8("");
-        return res;
-    }
-
-    String8 res(buf, cp-buf);
-    if (outRemains) *outRemains = String8(cp+1);
-    return res;
-}
-
 /*
  * Helper function for finding the start of an extension in a pathname.
  *
  * Returns a pointer inside mString, or NULL if no extension was found.
  */
-char* String8::find_extension(void) const
-{
+static const char* find_extension(const char* str) {
     const char* lastSlash;
     const char* lastDot;
-    const char* const str = mString;
 
     // only look at the filename
     lastSlash = strrchr(str, OS_PATH_SEPARATOR);
@@ -515,67 +464,16 @@ char* String8::find_extension(void) const
         return nullptr;
 
     // looks good, ship it
-    return const_cast<char*>(lastDot);
+    return lastDot;
 }
 
 String8 String8::getPathExtension(void) const
 {
-    char* ext;
-
-    ext = find_extension();
+    auto ext = find_extension(mString);
     if (ext != nullptr)
         return String8(ext);
     else
         return String8("");
 }
 
-String8 String8::getBasePath(void) const
-{
-    char* ext;
-    const char* const str = mString;
-
-    ext = find_extension();
-    if (ext == nullptr)
-        return String8(*this);
-    else
-        return String8(str, ext - str);
-}
-
-String8& String8::appendPath(const char* name)
-{
-    // TODO: The test below will fail for Win32 paths. Fix later or ignore.
-    if (name[0] != OS_PATH_SEPARATOR) {
-        if (*name == '\0') {
-            // nothing to do
-            return *this;
-        }
-
-        size_t len = length();
-        if (len == 0) {
-            // no existing filename, just use the new one
-            setPathName(*this, name);
-            return *this;
-        }
-
-        // make room for oldPath + '/' + newPath
-        int newlen = strlen(name);
-
-        char* buf = lockBuffer(len+1+newlen);
-
-        // insert a '/' if needed
-        if (buf[len-1] != OS_PATH_SEPARATOR)
-            buf[len++] = OS_PATH_SEPARATOR;
-
-        memcpy(buf+len, name, newlen+1);
-        len += newlen;
-
-        unlockBuffer(len);
-
-        return *this;
-    } else {
-        setPathName(*this, name);
-        return *this;
-    }
-}
-
 }; // namespace android
diff --git a/libutils/String8_fuzz.cpp b/libutils/String8_fuzz.cpp
index 6f7a54f9f310..cbce0505891e 100644
--- a/libutils/String8_fuzz.cpp
+++ b/libutils/String8_fuzz.cpp
@@ -68,30 +68,6 @@ std::vector<std::function<void(FuzzedDataProvider*, android::String8*, android::
                     int start_index = dataProvider->ConsumeIntegralInRange<int>(0, str1->size());
                     str1->find(str2->c_str(), start_index);
                 },
-
-                // Path handling
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->getBasePath();
-                },
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->getPathExtension();
-                },
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->getPathLeaf();
-                },
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    str1->getPathDir();
-                },
-                [](FuzzedDataProvider*, android::String8* str1, android::String8*) -> void {
-                    std::shared_ptr<android::String8> path_out_str =
-                            std::make_shared<android::String8>();
-                    str1->walkPath(path_out_str.get());
-                    path_out_str->clear();
-                },
-                [](FuzzedDataProvider* dataProvider, android::String8* str1,
-                   android::String8*) -> void {
-                    str1->appendPath(dataProvider->ConsumeBytesWithTerminator<char>(5).data());
-                },
 };
 
 void fuzzFormat(FuzzedDataProvider* dataProvider, android::String8* str1, bool shouldAppend) {
diff --git a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
index 46baddecde7b..8881b44eb181 100644
--- a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
@@ -703,9 +703,6 @@
   {
    "name" : "_ZN7android7RefBaseD2Ev"
   },
-  {
-   "name" : "_ZN7android7String810appendPathEPKc"
-  },
   {
    "name" : "_ZN7android7String810lockBufferEm"
   },
@@ -1144,15 +1141,6 @@
   {
    "name" : "_ZNK7android7String810getPathDirEv"
   },
-  {
-   "name" : "_ZNK7android7String811getBasePathEv"
-  },
-  {
-   "name" : "_ZNK7android7String811getPathLeafEv"
-  },
-  {
-   "name" : "_ZNK7android7String814find_extensionEv"
-  },
   {
    "name" : "_ZNK7android7String816getPathExtensionEv"
   },
@@ -1162,9 +1150,6 @@
   {
    "name" : "_ZNK7android7String86lengthEv"
   },
-  {
-   "name" : "_ZNK7android7String88walkPathEPS0_"
-  },
   {
    "name" : "_ZNK7android8String1610startsWithEPKDs"
   },
@@ -6808,22 +6793,6 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
-  {
-   "function_name" : "android::String8::appendPath",
-   "linker_set_key" : "_ZN7android7String810appendPathEPKc",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    },
-    {
-     "referenced_type" : "_ZTIPKc"
-    }
-   ],
-   "return_type" : "_ZTIRN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String8::lockBuffer",
    "linker_set_key" : "_ZN7android7String810lockBufferEm",
@@ -9104,6 +9073,7 @@
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
   {
+   "access" : "private",
    "function_name" : "android::String8::getPathDir",
    "linker_set_key" : "_ZNK7android7String810getPathDirEv",
    "parameters" :
@@ -9116,47 +9086,8 @@
    "return_type" : "_ZTIN7android7String8E",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::getBasePath",
-   "linker_set_key" : "_ZNK7android7String811getBasePathEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
-   "function_name" : "android::String8::getPathLeaf",
-   "linker_set_key" : "_ZNK7android7String811getPathLeafEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "access" : "private",
-   "function_name" : "android::String8::find_extension",
-   "linker_set_key" : "_ZNK7android7String814find_extensionEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIPc",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
    "function_name" : "android::String8::getPathExtension",
    "linker_set_key" : "_ZNK7android7String816getPathExtensionEv",
    "parameters" :
@@ -9202,23 +9133,6 @@
    "return_type" : "_ZTIm",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::walkPath",
-   "linker_set_key" : "_ZNK7android7String88walkPathEPS0_",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    },
-    {
-     "default_arg" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String16::startsWith",
    "linker_set_key" : "_ZNK7android8String1610startsWithEPKDs",
diff --git a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
index 219c76665bb9..e8236ea5b6af 100644
--- a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
@@ -703,9 +703,6 @@
   {
    "name" : "_ZN7android7RefBaseD2Ev"
   },
-  {
-   "name" : "_ZN7android7String810appendPathEPKc"
-  },
   {
    "name" : "_ZN7android7String810lockBufferEj"
   },
@@ -1144,15 +1141,6 @@
   {
    "name" : "_ZNK7android7String810getPathDirEv"
   },
-  {
-   "name" : "_ZNK7android7String811getBasePathEv"
-  },
-  {
-   "name" : "_ZNK7android7String811getPathLeafEv"
-  },
-  {
-   "name" : "_ZNK7android7String814find_extensionEv"
-  },
   {
    "name" : "_ZNK7android7String816getPathExtensionEv"
   },
@@ -1162,9 +1150,6 @@
   {
    "name" : "_ZNK7android7String86lengthEv"
   },
-  {
-   "name" : "_ZNK7android7String88walkPathEPS0_"
-  },
   {
    "name" : "_ZNK7android8String1610startsWithEPKDs"
   },
@@ -6804,22 +6789,6 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
-  {
-   "function_name" : "android::String8::appendPath",
-   "linker_set_key" : "_ZN7android7String810appendPathEPKc",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    },
-    {
-     "referenced_type" : "_ZTIPKc"
-    }
-   ],
-   "return_type" : "_ZTIRN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String8::lockBuffer",
    "linker_set_key" : "_ZN7android7String810lockBufferEj",
@@ -9100,6 +9069,7 @@
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
   {
+   "access" : "private",
    "function_name" : "android::String8::getPathDir",
    "linker_set_key" : "_ZNK7android7String810getPathDirEv",
    "parameters" :
@@ -9112,47 +9082,8 @@
    "return_type" : "_ZTIN7android7String8E",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::getBasePath",
-   "linker_set_key" : "_ZNK7android7String811getBasePathEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
-   "function_name" : "android::String8::getPathLeaf",
-   "linker_set_key" : "_ZNK7android7String811getPathLeafEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "access" : "private",
-   "function_name" : "android::String8::find_extension",
-   "linker_set_key" : "_ZNK7android7String814find_extensionEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIPc",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
    "function_name" : "android::String8::getPathExtension",
    "linker_set_key" : "_ZNK7android7String816getPathExtensionEv",
    "parameters" :
@@ -9198,23 +9129,6 @@
    "return_type" : "_ZTIj",
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
-  {
-   "function_name" : "android::String8::walkPath",
-   "linker_set_key" : "_ZNK7android7String88walkPathEPS0_",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
-    },
-    {
-     "default_arg" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
-    }
-   ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
   {
    "function_name" : "android::String16::startsWith",
    "linker_set_key" : "_ZNK7android8String1610startsWithEPKDs",
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index ea25c6aa3947..fbb0a0ae32ae 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -130,80 +130,11 @@ class String8
 
             void                toLower();
 
-
-    /*
-     * These methods operate on the string as if it were a path name.
-     */
-
-    /*
-     * Get just the filename component.
-     *
-     * "/tmp/foo/bar.c" --> "bar.c"
-     */
-    String8 getPathLeaf(void) const;
-
-    /*
-     * Remove the last (file name) component, leaving just the directory
-     * name.
-     *
-     * "/tmp/foo/bar.c" --> "/tmp/foo"
-     * "/tmp" --> "" // ????? shouldn't this be "/" ???? XXX
-     * "bar.c" --> ""
-     */
-    String8 getPathDir(void) const;
-
-    /*
-     * Retrieve the front (root dir) component.  Optionally also return the
-     * remaining components.
-     *
-     * "/tmp/foo/bar.c" --> "tmp" (remain = "foo/bar.c")
-     * "/tmp" --> "tmp" (remain = "")
-     * "bar.c" --> "bar.c" (remain = "")
-     */
-    String8 walkPath(String8* outRemains = nullptr) const;
-
-    /*
-     * Return the filename extension.  This is the last '.' and any number
-     * of characters that follow it.  The '.' is included in case we
-     * decide to expand our definition of what constitutes an extension.
-     *
-     * "/tmp/foo/bar.c" --> ".c"
-     * "/tmp" --> ""
-     * "/tmp/foo.bar/baz" --> ""
-     * "foo.jpeg" --> ".jpeg"
-     * "foo." --> ""
-     */
-    String8 getPathExtension(void) const;
-
-    /*
-     * Return the path without the extension.  Rules for what constitutes
-     * an extension are described in the comment for getPathExtension().
-     *
-     * "/tmp/foo/bar.c" --> "/tmp/foo/bar"
-     */
-    String8 getBasePath(void) const;
-
-    /*
-     * Add a component to the pathname.  We guarantee that there is
-     * exactly one path separator between the old path and the new.
-     * If there is no existing name, we just copy the new name in.
-     *
-     * If leaf is a fully qualified path (i.e. starts with '/', it
-     * replaces whatever was there before.
-     */
-    String8& appendPath(const char* leaf);
-    String8& appendPath(const String8& leaf) { return appendPath(leaf.c_str()); }
-
-    /*
-     * Like appendPath(), but does not affect this string.  Returns a new one instead.
-     */
-    String8 appendPathCopy(const char* leaf) const
-                                             { String8 p(*this); p.appendPath(leaf); return p; }
-    String8 appendPathCopy(const String8& leaf) const { return appendPathCopy(leaf.c_str()); }
-
 private:
+            String8 getPathDir(void) const;
+            String8 getPathExtension(void) const;
+
             status_t            real_append(const char* other, size_t numChars);
-            char*               find_extension(void) const;
 
             const char* mString;
 };

From 244e581a31da30508648b1a118f864dae491935f Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Tue, 12 Sep 2023 15:53:19 +0800
Subject: [PATCH 0375/1487] fs_mgr: Use /proc/mounts to check if /cache is
 mounted

The fstab provided by the user/caller might not be the default fstab,
which might not include the /cache mount entry. We should just use the
procfs mount info to determine if /cache is currently mounted.

Bug: 300036012
Test: adb_remount test
Change-Id: I4643d0a21ae21f3513f715de424f0be1fe64ff9e
---
 fs_mgr/fs_mgr_overlayfs_control.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_control.cpp b/fs_mgr/fs_mgr_overlayfs_control.cpp
index 68576f22086d..2cc0d2d5ea9c 100644
--- a/fs_mgr/fs_mgr_overlayfs_control.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_control.cpp
@@ -688,7 +688,7 @@ bool fs_mgr_overlayfs_setup(const Fstab& fstab, const char* mount_point, bool* w
                 continue;
             }
         } else {
-            if (GetEntryForMountPoint(&fstab, overlay_mount_point) == nullptr) {
+            if (!fs_mgr_overlayfs_already_mounted(overlay_mount_point, false /* overlay */)) {
                 continue;
             }
         }

From 37467f36658aa8ef82eef3e4674099ad6b140940 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Tue, 12 Sep 2023 15:31:24 +0800
Subject: [PATCH 0376/1487] fs_mgr: Refactor fs_mgr_overlayfs_already_mounted()
 to be more readable

Bug: 293695109
Test: adb_remount test
Change-Id: Idadd5b99e48fa601b1046aef533027ea6ba5c2f6
---
 fs_mgr/fs_mgr_overlayfs_mount.cpp | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index 8fb63b17435a..9f17c06f7a8f 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -733,15 +733,18 @@ bool fs_mgr_overlayfs_is_setup() {
 
 bool fs_mgr_overlayfs_already_mounted(const std::string& mount_point, bool overlay_only) {
     Fstab fstab;
-    if (!ReadFstabFromFile("/proc/mounts", &fstab)) {
+    if (!ReadFstabFromProcMounts(&fstab)) {
         return false;
     }
     const auto lowerdir = kLowerdirOption + mount_point;
-    for (const auto& entry : fstab) {
-        if (overlay_only && "overlay" != entry.fs_type && "overlayfs" != entry.fs_type) continue;
-        if (mount_point != entry.mount_point) continue;
-        if (!overlay_only) return true;
-        const auto options = android::base::Split(entry.fs_options, ",");
+    for (const auto& entry : GetEntriesForMountPoint(&fstab, mount_point)) {
+        if (!overlay_only) {
+            return true;
+        }
+        if (entry->fs_type != "overlay" && entry->fs_type != "overlayfs") {
+            continue;
+        }
+        const auto options = android::base::Split(entry->fs_options, ",");
         for (const auto& opt : options) {
             if (opt == lowerdir) {
                 return true;

From 86c9ea8f861ec80399305f6f5aff422e45e0ac70 Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Tue, 12 Sep 2023 16:23:13 +0000
Subject: [PATCH 0377/1487] Implement android::String access methods that avoid
 C string cast

Bug: 295394788
Test: m checkbuild
Change-Id: If25fd69319171e8c549fc8fcfd95a0819291d8e6
---
 libutils/include/utils/String16.h | 24 +++++++++++++++++
 libutils/include/utils/String8.h  | 43 ++++++++++++++++++++++++++++++-
 2 files changed, 66 insertions(+), 1 deletion(-)

diff --git a/libutils/include/utils/String16.h b/libutils/include/utils/String16.h
index b48b90765612..fb94174da667 100644
--- a/libutils/include/utils/String16.h
+++ b/libutils/include/utils/String16.h
@@ -24,6 +24,11 @@
 #include <utils/String8.h>
 #include <utils/TypeHelpers.h>
 
+#if __has_include(<string_view>)
+#include <string_view>
+#define HAS_STRING_VIEW
+#endif
+
 // ---------------------------------------------------------------------------
 
 namespace android {
@@ -91,6 +96,7 @@ class String16
             bool                startsWith(const char16_t* prefix) const;
 
             bool                contains(const char16_t* chrs) const;
+    inline  bool                contains(const String16& other) const;
 
             status_t            replaceAll(char16_t replaceThis,
                                            char16_t withThis);
@@ -113,6 +119,12 @@ class String16
 
     inline                      operator const char16_t*() const;
 
+#ifdef HAS_STRING_VIEW
+    // Implicit cast to std::u16string is not implemented on purpose - u16string_view is much
+    // lighter and if one needs, they can still create u16string from u16string_view.
+    inline                      operator std::u16string_view() const;
+#endif
+
     // Static and non-static String16 behave the same for the users, so
     // this method isn't of much use for the users. It is public for testing.
             bool                isStaticString() const;
@@ -264,6 +276,11 @@ inline size_t String16::length() const
     return size();
 }
 
+inline bool String16::contains(const String16& other) const
+{
+    return contains(other.c_str());
+}
+
 inline String16& String16::operator=(const String16& other)
 {
     setTo(other);
@@ -353,8 +370,15 @@ inline String16::operator const char16_t*() const
     return mString;
 }
 
+inline String16::operator std::u16string_view() const
+{
+    return {mString, length()};
+}
+
 }  // namespace android
 
 // ---------------------------------------------------------------------------
 
+#undef HAS_STRING_VIEW
+
 #endif // ANDROID_STRING16_H
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index ea25c6aa3947..38930186575a 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -18,7 +18,6 @@
 #define ANDROID_STRING8_H
 
 #include <iostream>
-#include <string>
 
 #include <utils/Errors.h>
 #include <utils/Unicode.h>
@@ -27,6 +26,16 @@
 #include <string.h> // for strcmp
 #include <stdarg.h>
 
+#if __has_include(<string>)
+#include <string>
+#define HAS_STRING
+#endif
+
+#if __has_include(<string_view>)
+#include <string_view>
+#define HAS_STRING_VIEW
+#endif
+
 // ---------------------------------------------------------------------------
 
 namespace android {
@@ -113,6 +122,10 @@ class String8
 
     inline                      operator const char*() const;
 
+#ifdef HAS_STRING_VIEW
+    inline explicit             operator std::string_view() const;
+#endif
+
             char*               lockBuffer(size_t size);
             void                unlockBuffer();
             status_t            unlockBuffer(size_t size);
@@ -120,13 +133,16 @@ class String8
             // return the index of the first byte of other in this at or after
             // start, or -1 if not found
             ssize_t             find(const char* other, size_t start = 0) const;
+    inline  ssize_t             find(const String8& other, size_t start = 0) const;
 
             // return true if this string contains the specified substring
     inline  bool                contains(const char* other) const;
+    inline  bool                contains(const String8& other) const;
 
             // removes all occurrence of the specified substring
             // returns true if any were found and removed
             bool                removeAll(const char* other);
+    inline  bool                removeAll(const String8& other);
 
             void                toLower();
 
@@ -264,11 +280,26 @@ inline size_t String8::bytes() const
     return length();
 }
 
+inline ssize_t String8::find(const String8& other, size_t start) const
+{
+    return find(other.c_str(), start);
+}
+
 inline bool String8::contains(const char* other) const
 {
     return find(other) >= 0;
 }
 
+inline bool String8::contains(const String8& other) const
+{
+    return contains(other.c_str());
+}
+
+inline bool String8::removeAll(const String8& other)
+{
+    return removeAll(other.c_str());
+}
+
 inline String8& String8::operator=(const String8& other)
 {
     setTo(other);
@@ -377,8 +408,18 @@ inline String8::operator const char*() const
     return mString;
 }
 
+#ifdef HAS_STRING_VIEW
+inline String8::operator std::string_view() const
+{
+    return {mString, length()};
+}
+#endif
+
 }  // namespace android
 
 // ---------------------------------------------------------------------------
 
+#undef HAS_STRING
+#undef HAS_STRING_VIEW
+
 #endif // ANDROID_STRING8_H

From f58b009b7b31aca813092f104c84e91e7a8662b7 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Tue, 12 Sep 2023 13:01:10 -0700
Subject: [PATCH 0378/1487] Disable warning which is not detecting problems.

A clang update enabled -Wreorder-init-list by default. Since it doesn't
provide any benefit to the debuggerd code, disable the warning.

Test: Builds without warnings.
Change-Id: I75cfe064ba92c74312ba33f329b1364258eba06c
---
 debuggerd/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 5393e25e5098..267571b50175 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -12,6 +12,7 @@ cc_defaults {
         "-Wno-unused-argument",
         "-Wno-unused-function",
         "-Wno-nullability-completeness",
+        "-Wno-reorder-init-list",
         "-Os",
         "-fno-finite-loops",
         "-DANDROID_DEBUGGABLE=0",

From b309292859edc1ec9b4df298e6e236067b2b6ed8 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 12 Sep 2023 13:34:07 -0700
Subject: [PATCH 0379/1487] Adding block sz to compressors

Adding block sz to compressor classes to prepare for variable block size
compression

Test: m libsnapshot
Change-Id: I84db20c80c0f95188f79ccc73b5c30678bd75e78
---
 .../include/libsnapshot/cow_compress.h        | 12 ++---
 .../libsnapshot_cow/cow_compress.cpp          | 45 +++++++++++--------
 2 files changed, 33 insertions(+), 24 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
index cf6561559574..fd12b84fe7b1 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
@@ -24,24 +24,26 @@ namespace snapshot {
 
 class ICompressor {
   public:
-    explicit ICompressor(uint32_t compression_level) : compression_level_(compression_level) {}
+    explicit ICompressor(uint32_t compression_level, uint32_t block_size)
+        : compression_level_(compression_level), block_size_(block_size) {}
 
     virtual ~ICompressor() {}
     // Factory methods for compression methods.
-    static std::unique_ptr<ICompressor> Gz(uint32_t compression_level);
-    static std::unique_ptr<ICompressor> Brotli(uint32_t compression_level);
-    static std::unique_ptr<ICompressor> Lz4(uint32_t compression_level);
+    static std::unique_ptr<ICompressor> Gz(uint32_t compression_level, const int32_t BLOCK_SZ);
+    static std::unique_ptr<ICompressor> Brotli(uint32_t compression_level, const int32_t BLOCK_SZ);
+    static std::unique_ptr<ICompressor> Lz4(uint32_t compression_level, const int32_t BLOCK_SZ);
     static std::unique_ptr<ICompressor> Zstd(uint32_t compression_level, const int32_t BLOCK_SZ);
 
     static std::unique_ptr<ICompressor> Create(CowCompression compression, const int32_t BLOCK_SZ);
 
     uint32_t GetCompressionLevel() const { return compression_level_; }
-
+    uint32_t GetBlockSize() const { return block_size_; }
     [[nodiscard]] virtual std::basic_string<uint8_t> Compress(const void* data,
                                                               size_t length) const = 0;
 
   private:
     uint32_t compression_level_;
+    uint32_t block_size_;
 };
 }  // namespace snapshot
 }  // namespace android
\ No newline at end of file
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
index 71ac59f20d20..abc7d336f40c 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
@@ -56,16 +56,16 @@ std::optional<CowCompressionAlgorithm> CompressionAlgorithmFromString(std::strin
 }
 
 std::unique_ptr<ICompressor> ICompressor::Create(CowCompression compression,
-                                                 const int32_t BLOCK_SZ) {
+                                                 const int32_t block_size) {
     switch (compression.algorithm) {
         case kCowCompressLz4:
-            return ICompressor::Lz4(compression.compression_level);
+            return ICompressor::Lz4(compression.compression_level, block_size);
         case kCowCompressBrotli:
-            return ICompressor::Brotli(compression.compression_level);
+            return ICompressor::Brotli(compression.compression_level, block_size);
         case kCowCompressGz:
-            return ICompressor::Gz(compression.compression_level);
+            return ICompressor::Gz(compression.compression_level, block_size);
         case kCowCompressZstd:
-            return ICompressor::Zstd(compression.compression_level, BLOCK_SZ);
+            return ICompressor::Zstd(compression.compression_level, block_size);
         case kCowCompressNone:
             return nullptr;
     }
@@ -100,7 +100,8 @@ uint32_t CompressWorker::GetDefaultCompressionLevel(CowCompressionAlgorithm comp
 
 class GzCompressor final : public ICompressor {
   public:
-    GzCompressor(uint32_t compression_level) : ICompressor(compression_level){};
+    GzCompressor(uint32_t compression_level, const uint32_t block_size)
+        : ICompressor(compression_level, block_size){};
 
     std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
         const auto bound = compressBound(length);
@@ -120,7 +121,8 @@ class GzCompressor final : public ICompressor {
 
 class Lz4Compressor final : public ICompressor {
   public:
-    Lz4Compressor(uint32_t compression_level) : ICompressor(compression_level){};
+    Lz4Compressor(uint32_t compression_level, const uint32_t block_size)
+        : ICompressor(compression_level, block_size){};
 
     std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
         const auto bound = LZ4_compressBound(length);
@@ -151,7 +153,8 @@ class Lz4Compressor final : public ICompressor {
 
 class BrotliCompressor final : public ICompressor {
   public:
-    BrotliCompressor(uint32_t compression_level) : ICompressor(compression_level){};
+    BrotliCompressor(uint32_t compression_level, const uint32_t block_size)
+        : ICompressor(compression_level, block_size){};
 
     std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
         const auto bound = BrotliEncoderMaxCompressedSize(length);
@@ -176,10 +179,11 @@ class BrotliCompressor final : public ICompressor {
 
 class ZstdCompressor final : public ICompressor {
   public:
-    ZstdCompressor(uint32_t compression_level, const uint32_t MAX_BLOCK_SIZE)
-        : ICompressor(compression_level), zstd_context_(ZSTD_createCCtx(), ZSTD_freeCCtx) {
+    ZstdCompressor(uint32_t compression_level, const uint32_t block_size)
+        : ICompressor(compression_level, block_size),
+          zstd_context_(ZSTD_createCCtx(), ZSTD_freeCCtx) {
         ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_compressionLevel, compression_level);
-        ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_windowLog, log2(MAX_BLOCK_SIZE));
+        ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_windowLog, log2(GetBlockSize()));
     };
 
     std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
@@ -313,20 +317,23 @@ bool CompressWorker::GetCompressedBuffers(std::vector<std::basic_string<uint8_t>
     return true;
 }
 
-std::unique_ptr<ICompressor> ICompressor::Brotli(uint32_t compression_level) {
-    return std::make_unique<BrotliCompressor>(compression_level);
+std::unique_ptr<ICompressor> ICompressor::Brotli(uint32_t compression_level,
+                                                 const int32_t block_size) {
+    return std::make_unique<BrotliCompressor>(compression_level, block_size);
 }
 
-std::unique_ptr<ICompressor> ICompressor::Gz(uint32_t compression_level) {
-    return std::make_unique<GzCompressor>(compression_level);
+std::unique_ptr<ICompressor> ICompressor::Gz(uint32_t compression_level, const int32_t block_size) {
+    return std::make_unique<GzCompressor>(compression_level, block_size);
 }
 
-std::unique_ptr<ICompressor> ICompressor::Lz4(uint32_t compression_level) {
-    return std::make_unique<Lz4Compressor>(compression_level);
+std::unique_ptr<ICompressor> ICompressor::Lz4(uint32_t compression_level,
+                                              const int32_t block_size) {
+    return std::make_unique<Lz4Compressor>(compression_level, block_size);
 }
 
-std::unique_ptr<ICompressor> ICompressor::Zstd(uint32_t compression_level, const int32_t BLOCK_SZ) {
-    return std::make_unique<ZstdCompressor>(compression_level, BLOCK_SZ);
+std::unique_ptr<ICompressor> ICompressor::Zstd(uint32_t compression_level,
+                                               const int32_t block_size) {
+    return std::make_unique<ZstdCompressor>(compression_level, block_size);
 }
 
 void CompressWorker::Finalize() {

From 19a6aa624174f5c21a2e57773c7e1faa5979117c Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 13 Sep 2023 14:28:54 -0700
Subject: [PATCH 0380/1487] Concatenate conditional

Move two separate conditional checks to one in writer_v2

Test: m libsnapshot
Change-Id: Id70db313754b770e3fa091e9c127839b9f2a5138
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index ee445a2d0c16..699529b013f4 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -636,10 +636,8 @@ bool CowWriterV2::FlushCluster() {
 }
 
 bool CowWriterV2::WriteOperation(const CowOperation& op, const void* data, size_t size) {
-    if (!EnsureSpaceAvailable(next_op_pos_ + sizeof(op))) {
-        return false;
-    }
-    if (!EnsureSpaceAvailable(next_data_pos_ + size)) {
+    if (!EnsureSpaceAvailable(next_op_pos_ + sizeof(op)) ||
+        !EnsureSpaceAvailable(next_data_pos_ + size)) {
         return false;
     }
 

From 8b5c8477f915e8680257657042e64181104b9bda Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Mon, 14 Aug 2023 18:20:02 +0000
Subject: [PATCH 0381/1487] Lock down String8.isEmpty() usage

All users should migrate to .empty()

Bug: 295394788
Test: make checkbuild
Change-Id: I5ec7921b9cf70e6b0857e1087f141dce958d2587
---
 libutils/include/utils/String8.h | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index ea25c6aa3947..c79876296034 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -65,7 +65,6 @@ class String8
     inline  size_t              size() const;
     inline  size_t              bytes() const;
     inline  bool                empty() const;
-    inline  bool                isEmpty() const;
 
             size_t              length() const;
 
@@ -206,6 +205,14 @@ class String8
             char*               find_extension(void) const;
 
             const char* mString;
+
+// These symbols are for potential backward compatibility with prebuilts. To be removed.
+#ifdef ENABLE_STRING8_OBSOLETE_METHODS
+public:
+#else
+private:
+#endif
+    inline  bool                isEmpty() const;
 };
 
 // String8 can be trivially moved using memcpy() because moving does not

From 8b95a1248945b8ed565d44dda2500fc5a1a0f6fb Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Fri, 11 Aug 2023 18:43:23 +0000
Subject: [PATCH 0382/1487] Lock down String8|16.string() usage

All users should migrate to .c_str()

Bug: 295394788
Test: make checkbuild
Change-Id: Ic6295848cf3377e0bf5334448d5ed7ea53fae7ae
---
 libutils/include/utils/String16.h | 9 ++++++++-
 libutils/include/utils/String8.h  | 2 +-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/libutils/include/utils/String16.h b/libutils/include/utils/String16.h
index 1fa3723b79ef..44a4fd7859ea 100644
--- a/libutils/include/utils/String16.h
+++ b/libutils/include/utils/String16.h
@@ -59,7 +59,6 @@ class String16
                                 ~String16();
 
     inline  const char16_t*     c_str() const;
-    inline  const char16_t*     string() const;
 
             size_t              size() const;
     inline  bool                empty() const;
@@ -188,6 +187,14 @@ class String16
 
     template <size_t N>
     explicit constexpr String16(const StaticData<N>& s) : mString(s.data) {}
+
+// These symbols are for potential backward compatibility with prebuilts. To be removed.
+#ifdef ENABLE_STRING8_OBSOLETE_METHODS
+public:
+#else
+private:
+#endif
+    inline  const char16_t*     string() const;
 };
 
 // String16 can be trivially moved using memcpy() because moving does not
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index 0b92f5b10ccf..6d250723b628 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -65,7 +65,6 @@ class String8
     static String8              formatV(const char* fmt, va_list args);
 
     inline  const char*         c_str() const;
-    inline  const char*         string() const;
 
     inline  size_t              size() const;
     inline  size_t              bytes() const;
@@ -155,6 +154,7 @@ class String8
 #else
 private:
 #endif
+    inline  const char*         string() const;
     inline  bool                isEmpty() const;
 };
 

From 7210b285c2a7c8220789e039c9b2a72a931224cc Mon Sep 17 00:00:00 2001
From: Devika Krishnadas <kdevika@google.com>
Date: Fri, 15 Sep 2023 18:46:03 +0000
Subject: [PATCH 0383/1487] Revert "Lock down String8|16.string() usage"

This reverts commit 8b95a1248945b8ed565d44dda2500fc5a1a0f6fb.

Reason for revert: DroidMonitor: Test failure

Change-Id: I09230ea7c3b80e1b4d277d3c6c6355a38f7bbc92
---
 libutils/include/utils/String16.h | 9 +--------
 libutils/include/utils/String8.h  | 2 +-
 2 files changed, 2 insertions(+), 9 deletions(-)

diff --git a/libutils/include/utils/String16.h b/libutils/include/utils/String16.h
index 44a4fd7859ea..1fa3723b79ef 100644
--- a/libutils/include/utils/String16.h
+++ b/libutils/include/utils/String16.h
@@ -59,6 +59,7 @@ class String16
                                 ~String16();
 
     inline  const char16_t*     c_str() const;
+    inline  const char16_t*     string() const;
 
             size_t              size() const;
     inline  bool                empty() const;
@@ -187,14 +188,6 @@ class String16
 
     template <size_t N>
     explicit constexpr String16(const StaticData<N>& s) : mString(s.data) {}
-
-// These symbols are for potential backward compatibility with prebuilts. To be removed.
-#ifdef ENABLE_STRING8_OBSOLETE_METHODS
-public:
-#else
-private:
-#endif
-    inline  const char16_t*     string() const;
 };
 
 // String16 can be trivially moved using memcpy() because moving does not
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index 6d250723b628..0b92f5b10ccf 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -65,6 +65,7 @@ class String8
     static String8              formatV(const char* fmt, va_list args);
 
     inline  const char*         c_str() const;
+    inline  const char*         string() const;
 
     inline  size_t              size() const;
     inline  size_t              bytes() const;
@@ -154,7 +155,6 @@ class String8
 #else
 private:
 #endif
-    inline  const char*         string() const;
     inline  bool                isEmpty() const;
 };
 

From 61a2897733e15a12b7aa2dfd99957e83cbe59351 Mon Sep 17 00:00:00 2001
From: Keith Mok <keithmok@google.com>
Date: Thu, 31 Aug 2023 00:31:35 +0000
Subject: [PATCH 0384/1487] Add seal if ashmem-dev is backed by memfd

Need to seal the buffer size in align with ashmem if set to PROT_READ
only to prevent untrusted remote process to shrink the buffer size and
crash it.

Bug: 294609150
Test: build
Ignore-AOSP-First: Security
Change-Id: I9288cf30b41e84ad8d3247c204e20482912bff69
Merged-In: I9288cf30b41e84ad8d3247c204e20482912bff69
(cherry picked from commit f83c5c8fecf89d9315945368aa20350c2f235cc0)
---
 libcutils/ashmem-dev.cpp | 29 +++++++++++++++++++++++++----
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index 8c232f0cd0dc..501a4acd7256 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -341,6 +341,12 @@ static int memfd_create_region(const char* name, size_t size) {
         return -1;
     }
 
+    // forbid size changes to match ashmem behaviour
+    if (fcntl(fd, F_ADD_SEALS, F_SEAL_GROW | F_SEAL_SHRINK) == -1) {
+        ALOGE("memfd_create(%s, %zd) F_ADD_SEALS failed: %m", name, size);
+        return -1;
+    }
+
     if (debug_log) {
         ALOGE("memfd_create(%s, %zd) success. fd=%d\n", name, size, fd.get());
     }
@@ -392,14 +398,29 @@ int ashmem_create_region(const char *name, size_t size)
 }
 
 static int memfd_set_prot_region(int fd, int prot) {
-    /* Only proceed if an fd needs to be write-protected */
+    int seals = fcntl(fd, F_GET_SEALS);
+    if (seals == -1) {
+        ALOGE("memfd_set_prot_region(%d, %d): F_GET_SEALS failed: %s\n", fd, prot, strerror(errno));
+        return -1;
+    }
+
     if (prot & PROT_WRITE) {
+        /* Now we want the buffer to be read-write, let's check if the buffer
+         * has been previously marked as read-only before, if so return error
+         */
+        if (seals & F_SEAL_FUTURE_WRITE) {
+            ALOGE("memfd_set_prot_region(%d, %d): region is write protected\n", fd, prot);
+            errno = EINVAL;  // inline with ashmem error code, if already in
+                             // read-only mode
+            return -1;
+        }
         return 0;
     }
 
-    if (fcntl(fd, F_ADD_SEALS, F_SEAL_FUTURE_WRITE) == -1) {
-        ALOGE("memfd_set_prot_region(%d, %d): F_SEAL_FUTURE_WRITE seal failed: %s\n", fd, prot,
-              strerror(errno));
+    /* We would only allow read-only for any future file operations */
+    if (fcntl(fd, F_ADD_SEALS, F_SEAL_FUTURE_WRITE | F_SEAL_SEAL) == -1) {
+        ALOGE("memfd_set_prot_region(%d, %d): F_SEAL_FUTURE_WRITE | F_SEAL_SEAL seal failed: %s\n",
+              fd, prot, strerror(errno));
         return -1;
     }
 

From 010c37b6154d6a1d04125b3f140592c83ec70df7 Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Fri, 15 Sep 2023 22:21:53 +0000
Subject: [PATCH 0385/1487] Revert "Revert "Lock down String8|16.string()
 usage""

This reverts commit 7210b285c2a7c8220789e039c9b2a72a931224cc.

Reason for revert: attempt re-submit

Change-Id: Ia95d11628c512163ae3d13cbdd5ebbe60f435937
---
 libutils/include/utils/String16.h | 9 ++++++++-
 libutils/include/utils/String8.h  | 2 +-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/libutils/include/utils/String16.h b/libutils/include/utils/String16.h
index 1fa3723b79ef..c7135766b097 100644
--- a/libutils/include/utils/String16.h
+++ b/libutils/include/utils/String16.h
@@ -59,7 +59,6 @@ class String16
                                 ~String16();
 
     inline  const char16_t*     c_str() const;
-    inline  const char16_t*     string() const;
 
             size_t              size() const;
     inline  bool                empty() const;
@@ -188,6 +187,14 @@ class String16
 
     template <size_t N>
     explicit constexpr String16(const StaticData<N>& s) : mString(s.data) {}
+
+// These symbols are for potential backward compatibility with prebuilts. To be removed.
+#ifdef ENABLE_STRING16_OBSOLETE_METHODS
+public:
+#else
+private:
+#endif
+    inline  const char16_t*     string() const;
 };
 
 // String16 can be trivially moved using memcpy() because moving does not
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
index 0b92f5b10ccf..6d250723b628 100644
--- a/libutils/include/utils/String8.h
+++ b/libutils/include/utils/String8.h
@@ -65,7 +65,6 @@ class String8
     static String8              formatV(const char* fmt, va_list args);
 
     inline  const char*         c_str() const;
-    inline  const char*         string() const;
 
     inline  size_t              size() const;
     inline  size_t              bytes() const;
@@ -155,6 +154,7 @@ class String8
 #else
 private:
 #endif
+    inline  const char*         string() const;
     inline  bool                isEmpty() const;
 };
 

From 0a59994c5a37ff3a035950f0f7d145c259d1ea38 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Sun, 17 Sep 2023 09:34:43 -0700
Subject: [PATCH 0386/1487] Compile with -D_FILE_OFFSET_BITS to support 32-bit
 userspace

This is to support when partition sizes are greater than 2GB (2^31)
on 32-bit userspace.

Bug: 300178204
Test: OTA on device with 32-bit userspace + product partition > 2GB
Change-Id: I7074682352d8388ed410c684cb7cb0fa346ba24c
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapuserd/Android.bp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index e56ffbe63d47..7aac4be98060 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -104,6 +104,10 @@ cc_defaults {
         "user-space-merge/snapuserd_server.cpp",
     ],
 
+    cflags: [
+        "-D_FILE_OFFSET_BITS=64",
+    ],
+
     static_libs: [
         "libbase",
         "libbrotli",

From c449ba34d8dc2b605e419515249c0ef3c299306a Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Sun, 17 Sep 2023 09:34:43 -0700
Subject: [PATCH 0387/1487] Compile with -D_FILE_OFFSET_BITS to support 32-bit
 userspace

This is to support when partition sizes are greater than 2GB (2^31)
on 32-bit userspace.

Bug: 300178204
Test: OTA on device with 32-bit userspace + product partition > 2GB
Ignore-AOSP-First: Cherrypick from AOSP
Change-Id: I7074682352d8388ed410c684cb7cb0fa346ba24c
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapuserd/Android.bp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 926148201713..dca9f49388eb 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -96,6 +96,10 @@ cc_defaults {
         "user-space-merge/snapuserd_server.cpp",
     ],
 
+    cflags: [
+        "-D_FILE_OFFSET_BITS=64",
+    ],
+
     static_libs: [
         "libbase",
         "libbrotli",

From d2ad53cf81651ca53be4e8e8ab279ccb38ad1d69 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 31 Aug 2023 10:42:54 -0700
Subject: [PATCH 0388/1487] Add CowOperationV2

this is going to replace the current version of CowOperation and will
work with writer v2 and parser v2. This will be the on disk format of
the cow, while CowOperation will be updated to be the in memory format
of 15 bytes (implicitly will be the v3 version).

Test: m libsnapshot

Test: m libsnapshot
Change-Id: Ibd00ef014a9fc11cdf2bad97c52462db8eef9502
---
 .../include/libsnapshot/cow_format.h          | 36 +++++++++++++++++++
 .../include/libsnapshot/cow_reader.h          |  1 -
 2 files changed, 36 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index c9a4dee3af41..aac71de9c774 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -143,6 +143,42 @@ struct CowOperation {
     uint64_t source;
 } __attribute__((packed));
 
+// The on disk format of cow (currently ==  CowOperation)
+struct CowOperationV2 {
+    // The operation code (see the constants and structures below).
+    uint8_t type;
+
+    // If this operation reads from the data section of the COW, this contains
+    // the compression type of that data (see constants below).
+    uint8_t compression;
+
+    // If this operation reads from the data section of the COW, this contains
+    // the length.
+    uint16_t data_length;
+
+    // The block of data in the new image that this operation modifies.
+    uint64_t new_block;
+
+    // The value of |source| depends on the operation code.
+    //
+    // For copy operations, this is a block location in the source image.
+    //
+    // For replace operations, this is a byte offset within the COW's data
+    // sections (eg, not landing within the header or metadata). It is an
+    // absolute position within the image.
+    //
+    // For zero operations (replace with all zeroes), this is unused and must
+    // be zero.
+    //
+    // For Label operations, this is the value of the applied label.
+    //
+    // For Cluster operations, this is the length of the following data region
+    //
+    // For Xor operations, this is the byte location in the source image.
+    uint64_t source;
+} __attribute__((packed));
+
+static_assert(sizeof(CowOperationV2) == sizeof(CowOperation));
 static_assert(sizeof(CowOperation) == sizeof(CowFooterOperation));
 
 static constexpr uint8_t kCowCopyOp = 1;
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index f4ce52fa3622..67d301d70cff 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -165,7 +165,6 @@ class CowReader final : public ICowReader {
     void UpdateMergeOpsCompleted(int num_merge_ops) { header_.num_merge_ops += num_merge_ops; }
 
   private:
-    bool ParseOps(std::optional<uint64_t> label);
     bool PrepMergeOps();
     uint64_t FindNumCopyops();
     uint8_t GetCompressionType(const CowOperation* op);

From cc44c374684ee2f54c6446e97b6f1060784153be Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 18 Sep 2023 14:02:17 -0700
Subject: [PATCH 0389/1487] Updating comments on cow layout

Updating comments to match current format. Scratch space exists in
between header and operation

Test: th
Change-Id: I2f86e9dc4078f03370cdc38918136c894c6ca484
---
 fs_mgr/libsnapshot/include/libsnapshot/cow_format.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index aac71de9c774..9359b9ec1294 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -49,7 +49,9 @@ static constexpr uint32_t kDefaultCowVersion = 2;
 //      |    Footer (fixed)     |
 //      +-----------------------+
 //
-// The operations begin immediately after the header, and the "raw data"
+// After the header is a 2mb scratch space that is used to read ahead data during merge operations
+//
+// The operations begin immediately after the scratch space, and the "raw data"
 // immediately follows the operation which refers to it. While streaming
 // an OTA, we can immediately write the op and data, syncing after each pair,
 // while storing operation metadata in memory. At the end, we compute data and

From 6ea36bd1e48597ea070727c6e0851b0591337657 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 18 Sep 2023 14:09:27 -0700
Subject: [PATCH 0390/1487] Add static_assert to check sizeof off_t

Add compile time flags which got dropped during refactoring.

Bug: 300178204
Test: Build on 32-bit userspace
Change-Id: I16be0973cb2cb2e174ff98c8b10fde27f997e4ab
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapuserd/Android.bp              | 12 ++++++++++++
 .../snapuserd/user-space-merge/snapuserd_core.h      |  1 +
 2 files changed, 13 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 7aac4be98060..47a86858a7fb 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -74,6 +74,11 @@ cc_library_static {
         "user-space-merge/worker.cpp",
         "utility.cpp",
     ],
+    cflags: [
+        "-D_FILE_OFFSET_BITS=64",
+        "-Wall",
+        "-Werror",
+    ],
     static_libs: [
         "libbase",
         "libdm",
@@ -106,6 +111,8 @@ cc_defaults {
 
     cflags: [
         "-D_FILE_OFFSET_BITS=64",
+        "-Wall",
+        "-Werror",
     ],
 
     static_libs: [
@@ -230,6 +237,11 @@ cc_defaults {
         "testing/host_harness.cpp",
         "user-space-merge/snapuserd_test.cpp",
     ],
+    cflags: [
+        "-D_FILE_OFFSET_BITS=64",
+        "-Wall",
+        "-Werror",
+    ],
     shared_libs: [
         "libbase",
         "liblog",
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index 622fc5028dbe..e401c118e893 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -249,6 +249,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
 };
 
 std::ostream& operator<<(std::ostream& os, MERGE_IO_TRANSITION value);
+static_assert(sizeof(off_t) == sizeof(uint64_t));
 
 }  // namespace snapshot
 }  // namespace android

From 4080e344265593bf3dea3b419b64e39d0deeb1cf Mon Sep 17 00:00:00 2001
From: Harsh Abichandani <harsh.abichandani@ittiam.com>
Date: Tue, 20 Jun 2023 16:01:16 +0530
Subject: [PATCH 0391/1487] Added liblp_builder_fuzzer and
 liblp_super_layout_builder_fuzzer

exec/s: 17002
Test: ./liblp_builder_fuzzer
exec/s: 31273
Test: ./liblp_super_layout_builder_fuzzer
Bug: 285829660

Change-Id: I05d0a6c72069e500b2c838f9c6d900ca1ce2c8cc
---
 fs_mgr/liblp/fuzzer/Android.bp                |  58 +++
 fs_mgr/liblp/fuzzer/README.md                 |  93 ++++
 fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp  | 438 ++++++++++++++++++
 .../liblp_super_layout_builder_fuzzer.cpp     | 151 ++++++
 4 files changed, 740 insertions(+)
 create mode 100644 fs_mgr/liblp/fuzzer/Android.bp
 create mode 100644 fs_mgr/liblp/fuzzer/README.md
 create mode 100644 fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
 create mode 100644 fs_mgr/liblp/fuzzer/liblp_super_layout_builder_fuzzer.cpp

diff --git a/fs_mgr/liblp/fuzzer/Android.bp b/fs_mgr/liblp/fuzzer/Android.bp
new file mode 100644
index 000000000000..bdeb377bfe4e
--- /dev/null
+++ b/fs_mgr/liblp/fuzzer/Android.bp
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2023 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_defaults {
+    name: "liblp_fuzz_defaults",
+    header_libs: [
+        "libstorage_literals_headers",
+    ],
+    shared_libs: [
+        "liblp",
+        "libbase",
+        "liblog",
+    ],
+    static_libs: [
+        "libcutils",
+    ],
+    include_dirs: [
+        "system/core/fs_mgr/liblp",
+    ],
+    fuzz_config: {
+        cc: [
+            "android-media-fuzzing-reports@google.com",
+        ],
+        componentid: 59148,
+        hotlists: ["4593311"],
+        description: "The fuzzers target the APIs of all liblp modules",
+        vector: "local_no_privileges_required",
+        service_privilege: "privileged",
+        users: "multi_user",
+        fuzzed_code_usage: "shipped"
+    }
+}
+
+cc_fuzz {
+    name: "liblp_builder_fuzzer",
+    srcs: ["liblp_builder_fuzzer.cpp"],
+    defaults: ["liblp_fuzz_defaults"],
+}
+
+cc_fuzz {
+    name: "liblp_super_layout_builder_fuzzer",
+    srcs: ["liblp_super_layout_builder_fuzzer.cpp"],
+    defaults: ["liblp_fuzz_defaults"],
+}
diff --git a/fs_mgr/liblp/fuzzer/README.md b/fs_mgr/liblp/fuzzer/README.md
new file mode 100644
index 000000000000..be9adbd8e535
--- /dev/null
+++ b/fs_mgr/liblp/fuzzer/README.md
@@ -0,0 +1,93 @@
+# Fuzzers for liblp
+## Table of contents
++  [liblp_builder_fuzzer](#Builder)
++  [liblp_super_layout_builder_fuzzer](#SuperBuilder)
+
+# <a  name="Builder"></a> Fuzzer for LiblpBuilder
+
+LiblpBuilder supports the following parameters:
+1. kAttributeTypes (parameter name: "attribute")
+2. blockDevSize (parameter name: "blockdev_size")
+3. metadataMaxSize (parameter name: "metadata_max_size")
+4. metadataSlotCount (parameter name: "metadata_slot_count")
+5. partitionName (parameter name: "partition_name")
+6. superBlockDeviceName (parameter name: "block_device_name")
+7. blockDeviceInfoSize (parameter name: "block_device_info_size")
+8. alignment (parameter name: "alignment")
+9. alignmentOffset (parameter name: "alignment_offset")
+10. logicalBlockSize (parameter name: "logical_block_size")
+11. maxMetadataSize (parameter name: "max_metadata_size")
+12. numSlots (parameter name: "metadata_slot_count")
+13. deviceIndex (parameter name: "device_index")
+14. start (parameter name: "start")
+15. end (parameter name: "end")
+16. addedGroupName (parameter name: "group_name")
+17. partitionGroupName (parameter name: "partition_name")
+18. numSectors (parameter name: "num_sectors")
+19. physicalSector (parameter name: "physical_sector")
+20. resizedPartitionSize (parameter name: "requested_size")
+
+| Parameter| Valid Values| Configured Value|
+|------------- |-------------| ----- |
+|`kAttributeTypes`| 1.`LP_PARTITION_ATTR_NONE`,<br/> 2.`LP_PARTITION_ATTR_READONLY`,<br/> 3.`LP_PARTITION_ATTR_SLOT_SUFFIXED`,<br/> 4.`LP_PARTITION_ATTR_UPDATED`,<br/> 5.`LP_PARTITION_ATTR_DISABLED`|Value obtained from FuzzedDataProvider|
+|`blockDevSize`| Integer value from `0` to `100000`|Value obtained from FuzzedDataProvider|
+|`metadataMaxSize`| Integer value from `0` to `10000` |Value obtained from FuzzedDataProvider|
+|`metadataSlotCount`| Integer value from `0` to `2` |Value obtained from FuzzedDataProvider|
+|`partitionName`| String |Value obtained from FuzzedDataProvider|
+|`superBlockDeviceName`| String |Value obtained from FuzzedDataProvider|
+|`blockDeviceInfoSize`| Integer |Value obtained from FuzzedDataProvider|
+|`alignment`| Integer |Value obtained from FuzzedDataProvider|
+|`alignmentOffset`| Integer |Value obtained from FuzzedDataProvider|
+|`logicalBlockSize`| Integer |Value obtained from FuzzedDataProvider|
+|`maxMetadataSize`| Integer value from `0` to `10000` |Value obtained from FuzzedDataProvider|
+|`numSlots`| Integer value from `0` to `2` |Value obtained from FuzzedDataProvider|
+|`deviceIndex`| Integer |Value obtained from FuzzedDataProvider|
+|`start`| Integer |Value obtained from FuzzedDataProvider|
+|`end`| Integer |Value obtained from FuzzedDataProvider|
+|`partitionGroupName`| String |Value obtained from FuzzedDataProvider|
+|`numSectors`| Integer value from `1` to `1000000` |Value obtained from FuzzedDataProvider|
+|`physicalSector`| Integer value from `1` to `1000000` |Value obtained from FuzzedDataProvider|
+|`resizedPartitionSize`| Integer value from `0` to `10000` |Value obtained from FuzzedDataProvider|
+
+#### Steps to run
+1. Build the fuzzer
+```
+  $ mm -j$(nproc) liblp_builder_fuzzer
+```
+2. Run on device
+```
+  $ adb sync data
+  $ adb shell /data/fuzz/arm64/liblp_builder_fuzzer/liblp_builder_fuzzer
+```
+
+# <a  name="SuperBuilder"></a> Fuzzer for LiblpSuperLayoutBuilder
+
+SuperLayoutBuilder supports the following parameters:
+1. kAttributeTypes (parameter name: "attribute")
+2. blockDevSize (parameter name: "blockdev_size")
+3. metadataMaxSize (parameter name: "metadata_max_size")
+4. metadataSlotCount (parameter name: "metadata_slot_count")
+5. partitionName (parameter name: "partition_name")
+6. data (parameter name: "data")
+7. imageName (parameter name: "image_name")
+
+| Parameter| Valid Values| Configured Value|
+|------------- |-------------| ----- |
+|`kAttributeTypes`| 1.`LP_PARTITION_ATTR_NONE`,<br/> 2.`LP_PARTITION_ATTR_READONLY`,<br/> 3.`LP_PARTITION_ATTR_SLOT_SUFFIXED`,<br/> 4.`LP_PARTITION_ATTR_UPDATED`,<br/> 5.`LP_PARTITION_ATTR_DISABLED`|Value obtained from FuzzedDataProvider|
+|`blockDevSize`| Integer value from `0` to `100000`|Value obtained from FuzzedDataProvider|
+|`metadataMaxSize`| Integer value from `0` to `10000` |Value obtained from FuzzedDataProvider|
+|`metadataSlotCount`| Integer value from `0` to `2` |Value obtained from FuzzedDataProvider|
+|`partitionName`| String |Value obtained from FuzzedDataProvider|
+|`data`| String |Value obtained from FuzzedDataProvider|
+|`imageName`| String |Value obtained from FuzzedDataProvider|
+
+#### Steps to run
+1. Build the fuzzer
+```
+  $ mm -j$(nproc) liblp_super_layout_builder_fuzzer
+```
+2. Run on device
+```
+  $ adb sync data
+  $ adb shell /data/fuzz/arm64/liblp_super_layout_builder_fuzzer/liblp_super_layout_builder_fuzzer
+```
diff --git a/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp b/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
new file mode 100644
index 000000000000..e5fbe272aef7
--- /dev/null
+++ b/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
@@ -0,0 +1,438 @@
+/*
+ * Copyright (C) 2023 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 <fuzzer/FuzzedDataProvider.h>
+#include <liblp/builder.h>
+#include <liblp/property_fetcher.h>
+#include <storage_literals/storage_literals.h>
+
+using namespace android::fs_mgr;
+using namespace std;
+using namespace android::storage_literals;
+
+static constexpr uint64_t kValidBlockSize = 4096 * 50;
+static constexpr uint64_t kBlockDeviceInfoSize = 1024 * 1024;
+static constexpr uint64_t kValidBlockDeviceInfoSize = 8_GiB;
+static constexpr uint64_t kValidMaxGroupSize = 40960;
+static constexpr uint64_t kMinBlockDevValue = 0;
+static constexpr uint64_t kMaxBlockDevValue = 100000;
+static constexpr uint64_t kMinSectorValue = 1;
+static constexpr uint64_t kMaxSectorValue = 1000000;
+static constexpr uint64_t kMinValue = 0;
+static constexpr uint64_t kMaxValue = 10000;
+static constexpr uint64_t kValidNumSectors = 1901568;
+static constexpr uint64_t kValidPhysicalSector = 3608576;
+static constexpr uint64_t kMinElements = 0;
+static constexpr uint64_t kMaxElements = 10;
+static constexpr uint32_t kValidAlignment = 786432;
+static constexpr uint32_t kValidMetadataSize = 40960;
+static constexpr uint32_t kValidAlignmentOffset = 229376;
+static constexpr uint32_t kValidLogicalBlockSize = 4096;
+static constexpr uint32_t kValidMaxMetadataSize = 65536;
+static constexpr uint32_t kMinMetadataValue = 0;
+static constexpr uint32_t kMaxMetadataValue = 10000;
+static constexpr uint32_t kZeroAlignment = 0;
+static constexpr uint32_t kZeroAlignmentOffset = 0;
+static constexpr uint32_t kMaxBytes = 20;
+static constexpr uint32_t kMinSlot = 0;
+static constexpr uint32_t kMaxSlot = 10;
+static constexpr uint32_t kMinBuilder = 0;
+static constexpr uint32_t kMaxBuilder = 4;
+
+const uint64_t kAttributeTypes[] = {
+        LP_PARTITION_ATTR_NONE,    LP_PARTITION_ATTR_READONLY, LP_PARTITION_ATTR_SLOT_SUFFIXED,
+        LP_PARTITION_ATTR_UPDATED, LP_PARTITION_ATTR_DISABLED,
+};
+
+const string kFuzzPartitionName = "fuzz_partition_name";
+const string kSuperPartitionName = "super_partition";
+const string kDeviceInfoName = "super";
+const string kDefaultGroupName = "default";
+
+class BuilderFuzzer {
+  public:
+    BuilderFuzzer(const uint8_t* data, size_t size) : mFdp(data, size){};
+    void process();
+
+  private:
+    FuzzedDataProvider mFdp;
+    void invokeBuilderAPIs();
+    void selectRandomBuilder(int32_t randomBuilder, string superBlockDeviceName);
+    void setupBuilder(string superBlockDeviceName);
+    void callChangePartitionGroup();
+    void callVerifyExtentsAgainstSourceMetadata();
+    vector<BlockDeviceInfo> mBlockDevices;
+    unique_ptr<MetadataBuilder> mBuilder;
+    string mResizePartitionName;
+    string mGroupNames[4] = {
+            "default",
+            "group_a",
+            "group_b",
+            mFdp.ConsumeRandomLengthString(kMaxBytes),
+    };
+    string mPartitionNames[5] = {
+            "system_a",
+            "vendor_a",
+            "system_b",
+            "vendor_b",
+            mFdp.ConsumeRandomLengthString(kMaxBytes),
+    };
+    Partition* mPartition;
+    Partition* mFuzzPartition;
+    Partition* mResizePartition;
+    template <typename T>
+    T getParamValue(T validValue) {
+        T parameter = validValue;
+        if (mFdp.ConsumeBool()) {
+            parameter = mFdp.ConsumeIntegralInRange<T>(kMinValue, kMaxValue);
+        }
+        return parameter;
+    }
+};
+
+void BuilderFuzzer::selectRandomBuilder(int32_t randomBuilder, string superBlockDeviceName) {
+    switch (randomBuilder) {
+        case 0: {
+            uint32_t maxMetadataSize = getParamValue(kValidMaxMetadataSize);
+            uint32_t numSlots = mFdp.ConsumeBool()
+                                        ? kMaxSlot
+                                        : mFdp.ConsumeIntegralInRange<uint32_t>(kMinSlot, kMaxSlot);
+            mBuilder = MetadataBuilder::New(mBlockDevices, superBlockDeviceName, maxMetadataSize,
+                                            numSlots);
+            break;
+        }
+        case 1: {
+            uint64_t blockDevSize =
+                    mFdp.ConsumeIntegralInRange<uint64_t>(kMinBlockDevValue, kMaxBlockDevValue);
+            uint32_t metadataMaxSize =
+                    mFdp.ConsumeIntegralInRange<uint32_t>(kMinMetadataValue, kMaxMetadataValue);
+            uint32_t metadataSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(kMinSlot, kMaxSlot);
+            mBuilder = MetadataBuilder::New(blockDevSize, metadataMaxSize, metadataSlotCount);
+            break;
+        }
+        case 2: {
+            uint64_t blockDevSize = getParamValue(kValidBlockSize);
+            uint32_t metadataSize = getParamValue(kValidMetadataSize);
+            uint32_t metadataSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(kMinSlot, kMaxSlot);
+            mBuilder = MetadataBuilder::New(blockDevSize, metadataSize, metadataSlotCount);
+            break;
+        }
+        case 3: {
+            string superPartitionName = mFdp.ConsumeBool()
+                                                ? kSuperPartitionName
+                                                : mFdp.ConsumeRandomLengthString(kMaxBytes);
+            mBuilder = MetadataBuilder::New(PartitionOpener(), superPartitionName,
+                                            mFdp.ConsumeIntegralInRange(0, 1) /* slot_number */);
+            break;
+        }
+        case 4: {
+            string superPartitionName = mFdp.ConsumeBool()
+                                                ? kSuperPartitionName
+                                                : mFdp.ConsumeRandomLengthString(kMaxBytes);
+            mBuilder = MetadataBuilder::New(
+                    superPartitionName,
+                    mFdp.ConsumeIntegralInRange<uint32_t>(0, 1) /* slot_number */);
+            break;
+        }
+    }
+}
+
+void BuilderFuzzer::setupBuilder(string superBlockDeviceName) {
+    uint64_t blockDeviceInfoSize =
+            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint64_t>() : kValidBlockDeviceInfoSize;
+    uint32_t alignment = mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>() : kValidAlignment;
+    uint32_t alignmentOffset =
+            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>() : kValidAlignmentOffset;
+    uint32_t logicalBlockSize =
+            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>() : kValidLogicalBlockSize;
+    BlockDeviceInfo super(superBlockDeviceName, blockDeviceInfoSize, alignment, alignmentOffset,
+                          logicalBlockSize);
+    mBlockDevices.push_back(super);
+
+    mBuilder->AddGroup(kDefaultGroupName, mFdp.ConsumeIntegral<uint64_t>() /* max_size */);
+    mPartition = mBuilder->AddPartition(kSuperPartitionName, LP_PARTITION_ATTR_READONLY);
+
+    mFuzzPartition = mBuilder->AddPartition(kFuzzPartitionName, kDefaultGroupName,
+                                            LP_PARTITION_ATTR_READONLY);
+
+    string mResizePartitionName = mFdp.ConsumeRandomLengthString(kMaxBytes);
+    if (!mResizePartitionName.size()) {
+        mResizePartitionName = "resize_partition";
+    }
+    mResizePartition = mBuilder->AddPartition(mResizePartitionName, kDefaultGroupName,
+                                              LP_PARTITION_ATTR_READONLY);
+
+    string changePartitionDeviceInfoName =
+            mFdp.ConsumeBool() ? kDeviceInfoName : mFdp.ConsumeRandomLengthString(kMaxBytes);
+    BlockDeviceInfo changePartitionDeviceInfo(
+            changePartitionDeviceInfoName,
+            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint64_t>() : kBlockDeviceInfoSize /* size */,
+            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>()
+                               : kZeroAlignmentOffset /* alignment */,
+            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>()
+                               : kZeroAlignmentOffset /* alignment_offset */,
+            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>()
+                               : kValidLogicalBlockSize /* logical_block_size */);
+    mBlockDevices.push_back(changePartitionDeviceInfo);
+}
+
+void BuilderFuzzer::callChangePartitionGroup() {
+    string group1 = mFdp.ConsumeBool() ? mFdp.ConsumeRandomLengthString(kMaxBytes) : "group1";
+    uint64_t group1Size = getParamValue(0);
+
+    string group2 = mFdp.ConsumeBool() ? mFdp.ConsumeRandomLengthString(kMaxBytes) : "group2";
+    uint64_t group2Size = getParamValue(0);
+
+    bool group1Added = mBuilder->AddGroup(group1, group1Size);
+    bool group2Added = mBuilder->AddGroup(group2, group2Size);
+
+    string changeGroupPartitionName = mFdp.ConsumeRandomLengthString(kMaxBytes);
+    if (changeGroupPartitionName.size() && group1Added && group2Added) {
+        Partition* changeGroupPartition = mBuilder->AddPartition(changeGroupPartitionName, group1,
+                                                                 LP_PARTITION_ATTR_READONLY);
+        if (changeGroupPartition) {
+            mBuilder->ChangePartitionGroup(changeGroupPartition, group2);
+        }
+    }
+}
+
+void BuilderFuzzer::callVerifyExtentsAgainstSourceMetadata() {
+    uint64_t sourceBlockDevSize = getParamValue(kValidBlockSize);
+    uint32_t sourceMetadataMaxSize = getParamValue(kValidMetadataSize);
+    uint32_t sourceSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(0, 2);
+    auto sourceBuilder =
+            MetadataBuilder::New(sourceBlockDevSize, sourceMetadataMaxSize, sourceSlotCount);
+
+    uint64_t targetBlockDevSize = getParamValue(kValidBlockSize);
+    uint32_t targetMetadataMaxSize = getParamValue(kValidMetadataSize);
+    uint32_t targetSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(0, 2);
+    auto targetBuilder =
+            MetadataBuilder::New(targetBlockDevSize, targetMetadataMaxSize, targetSlotCount);
+
+    if (sourceBuilder && targetBuilder) {
+        int64_t sourceGroups = mFdp.ConsumeIntegralInRange<int64_t>(kMinElements, kMaxElements);
+        for (int64_t idx = 0; idx < sourceGroups; ++idx) {
+            sourceBuilder->AddGroup(
+                    mFdp.PickValueInArray(mGroupNames),
+                    mFdp.ConsumeBool() ? kValidMaxGroupSize : mFdp.ConsumeIntegral<uint64_t>());
+        }
+
+        int64_t sourcePartitions = mFdp.ConsumeIntegralInRange<int64_t>(kMinElements, kMaxElements);
+        for (int64_t idx = 0; idx < sourcePartitions; ++idx) {
+            sourceBuilder->AddPartition(mFdp.PickValueInArray(mPartitionNames),
+                                        LP_PARTITION_ATTR_READONLY);
+        }
+
+        int64_t targetGroups = mFdp.ConsumeIntegralInRange<int64_t>(kMinElements, kMaxElements);
+        for (int64_t idx = 0; idx < targetGroups; ++idx) {
+            targetBuilder->AddGroup(
+                    mFdp.PickValueInArray(mGroupNames),
+                    mFdp.ConsumeBool() ? kValidMaxGroupSize : mFdp.ConsumeIntegral<uint64_t>());
+        }
+
+        int64_t targetPartitions = mFdp.ConsumeIntegralInRange<int64_t>(kMinElements, kMaxElements);
+        for (int64_t idx = 0; idx < targetPartitions; ++idx) {
+            targetBuilder->AddPartition(mFdp.PickValueInArray(mPartitionNames),
+                                        LP_PARTITION_ATTR_READONLY);
+        }
+
+        MetadataBuilder::VerifyExtentsAgainstSourceMetadata(
+                *sourceBuilder, mFdp.ConsumeBool() ? 0 : 1 /* source_slot_number */, *targetBuilder,
+                mFdp.ConsumeBool() ? 0 : 1 /* target_slot_number */,
+                vector<string>{"system", "vendor", mFdp.ConsumeRandomLengthString(kMaxBytes)});
+    }
+}
+
+void BuilderFuzzer::invokeBuilderAPIs() {
+    string superBlockDeviceName =
+            mFdp.ConsumeBool() ? mFdp.ConsumeRandomLengthString(kMaxBytes) : kDeviceInfoName;
+    uint32_t randomBuilder = mFdp.ConsumeIntegralInRange<uint32_t>(kMinBuilder, kMaxBuilder);
+    selectRandomBuilder(randomBuilder, superBlockDeviceName);
+
+    if (mBuilder.get()) {
+        setupBuilder(superBlockDeviceName);
+
+        while (mFdp.remaining_bytes()) {
+            auto invokeAPIs = mFdp.PickValueInArray<const function<void()>>({
+                    [&]() { callChangePartitionGroup(); },
+                    [&]() {
+                        string addedGroupName = mFdp.PickValueInArray(mGroupNames);
+                        mBuilder->AddGroup(addedGroupName,
+                                           mFdp.ConsumeIntegralInRange<uint64_t>(
+                                                   kMinValue, kMaxValue) /* max_size */);
+                    },
+                    [&]() {
+                        string partitionName = mFdp.PickValueInArray(mPartitionNames);
+                        Partition* addedPartition = mBuilder->AddPartition(
+                                partitionName, mFdp.PickValueInArray(kAttributeTypes));
+                    },
+                    [&]() {
+                        int64_t numSectors = mFdp.ConsumeBool()
+                                                     ? mFdp.ConsumeIntegralInRange<uint64_t>(
+                                                               kMinSectorValue, kMaxSectorValue)
+                                                     : kValidNumSectors;
+                        int64_t physicalSector = mFdp.ConsumeBool()
+                                                         ? mFdp.ConsumeIntegralInRange<uint64_t>(
+                                                                   kMinSectorValue, kMaxSectorValue)
+                                                         : kValidPhysicalSector;
+
+                        int64_t numExtents =
+                                mFdp.ConsumeIntegralInRange<int64_t>(kMinElements, kMaxElements);
+                        bool extentAdded = false;
+                        for (int64_t i = 0; i <= numExtents; ++i) {
+                            extentAdded = mBuilder->AddLinearExtent(mFuzzPartition, kDeviceInfoName,
+                                                                    numSectors, physicalSector);
+                        }
+
+                        if (extentAdded) {
+                            unique_ptr<LpMetadata> metadata = mBuilder->Export();
+                            uint64_t alignedSize =
+                                    mFdp.ConsumeIntegralInRange<uint64_t>(kMinValue, kMaxValue);
+                            mFuzzPartition->GetBeginningExtents(LP_SECTOR_SIZE * numExtents);
+                        }
+                    },
+                    [&]() { callVerifyExtentsAgainstSourceMetadata(); },
+                    [&]() { mBuilder->ListPartitionsInGroup(mFdp.PickValueInArray(mGroupNames)); },
+                    [&]() {
+                        int64_t maxSize = mFdp.ConsumeIntegral<uint64_t>();
+                        mBuilder->ChangeGroupSize(mFdp.PickValueInArray(mGroupNames), maxSize);
+                    },
+                    [&]() {
+                        string deviceInfoName = mFdp.ConsumeBool()
+                                                        ? kDeviceInfoName
+                                                        : mFdp.ConsumeRandomLengthString(kMaxBytes);
+                        mBuilder->GetBlockDeviceInfo(deviceInfoName, &mBlockDevices[1]);
+                    },
+                    [&]() {
+                        string deviceInfoName = mFdp.ConsumeBool()
+                                                        ? kDeviceInfoName
+                                                        : mFdp.ConsumeRandomLengthString(kMaxBytes);
+                        mBuilder->UpdateBlockDeviceInfo(deviceInfoName, mBlockDevices[1]);
+                    },
+                    [&]() {
+                        unique_ptr<LpMetadata> metadata = mBuilder->Export();
+                        mBuilder->ImportPartitions(*metadata.get(),
+                                                   {mFdp.PickValueInArray(mPartitionNames)});
+                    },
+                    [&]() { mBuilder->HasBlockDevice(mFdp.PickValueInArray(mPartitionNames)); },
+                    [&]() { mBuilder->SetVirtualABDeviceFlag(); },
+                    [&]() { mBuilder->SetAutoSlotSuffixing(); },
+                    [&]() { mBuilder->ListGroups(); },
+                    [&]() { mBuilder->UsedSpace(); },
+                    [&]() { mBuilder->RequireExpandedMetadataHeader(); },
+                    [&]() {
+                        uint64_t resizedPartitionSize = getParamValue(0);
+                        mBuilder->ResizePartition(mResizePartition, resizedPartitionSize);
+                    },
+                    [&]() {
+                        uint32_t sourceSlot = mFdp.ConsumeBool() ? 0 : 1;
+                        uint32_t targetSlot = mFdp.ConsumeBool() ? 0 : 1;
+                        PartitionOpener partitionOpener;
+                        string sourcePartition =
+                                mFdp.ConsumeBool() ? kFuzzPartitionName : kDeviceInfoName;
+
+                        MetadataBuilder::NewForUpdate(partitionOpener, sourcePartition, sourceSlot,
+                                                      targetSlot);
+                        partitionOpener.GetDeviceString(mFdp.PickValueInArray(mPartitionNames));
+                    },
+                    [&]() {
+                        unique_ptr<LpMetadata> metadata = mBuilder->Export();
+                        MetadataBuilder::New(*metadata.get());
+                    },
+                    [&]() { mBuilder->AllocatableSpace(); },
+                    [&]() {
+                        PartitionOpener pOpener;
+                        string superPartitionName =
+                                mFdp.ConsumeBool() ? kSuperPartitionName
+                                                   : mFdp.ConsumeRandomLengthString(kMaxBytes);
+                        pOpener.Open(superPartitionName, O_RDONLY);
+                        pOpener.GetInfo(superPartitionName, &mBlockDevices[0]);
+                    },
+                    [&]() {
+                        PartitionOpener pOpener;
+                        string superPartitionName =
+                                mFdp.ConsumeBool() ? kSuperPartitionName
+                                                   : mFdp.ConsumeRandomLengthString(kMaxBytes);
+                        pOpener.Open(superPartitionName, O_RDONLY);
+                        pOpener.GetDeviceString(superPartitionName);
+                    },
+                    [&]() {
+                        Interval::Intersect(
+                                Interval(mFdp.ConsumeIntegral<uint64_t>() /* device _index */,
+                                         mFdp.ConsumeIntegral<uint64_t>() /* start */,
+                                         mFdp.ConsumeIntegral<uint64_t>()) /* end */,
+                                Interval(mFdp.ConsumeIntegral<uint64_t>() /* device _index */,
+                                         mFdp.ConsumeIntegral<uint64_t>() /* start */,
+                                         mFdp.ConsumeIntegral<uint64_t>() /* end */));
+                    },
+                    [&]() {
+                        vector<Interval> intervalVectorA;
+                        int64_t internalVectorAElements =
+                                mFdp.ConsumeIntegralInRange<int64_t>(kMinElements, kMaxElements);
+                        for (int64_t idx = 0; idx < internalVectorAElements; ++idx) {
+                            intervalVectorA.push_back(
+                                    Interval(mFdp.ConsumeIntegral<uint64_t>() /* device _index */,
+                                             mFdp.ConsumeIntegral<uint64_t>() /* start */,
+                                             mFdp.ConsumeIntegral<uint64_t>() /* end */));
+                        }
+
+                        vector<Interval> intervalVectorB;
+                        int64_t internalVectorBElements =
+                                mFdp.ConsumeIntegralInRange<int64_t>(kMinElements, kMaxElements);
+                        for (int64_t idx = 0; idx < internalVectorBElements; ++idx) {
+                            intervalVectorB.push_back(
+                                    Interval(mFdp.ConsumeIntegral<uint64_t>() /* device _index */,
+                                             mFdp.ConsumeIntegral<uint64_t>() /* start */,
+                                             mFdp.ConsumeIntegral<uint64_t>() /* end */));
+                        }
+
+                        Interval::Intersect(intervalVectorA, intervalVectorB);
+                    },
+                    [&]() {
+                        uint64_t numSectors =
+                                mFdp.ConsumeIntegralInRange<uint64_t>(kMinValue, kMaxValue);
+                        uint32_t deviceIndex =
+                                mFdp.ConsumeIntegralInRange<uint32_t>(kMinValue, kMaxValue);
+                        uint64_t physicalSector =
+                                mFdp.ConsumeIntegralInRange<uint64_t>(kMinValue, kMaxValue);
+                        LinearExtent extent(numSectors, deviceIndex, physicalSector);
+                        extent.AsInterval();
+                    },
+                    [&]() {
+                        IPropertyFetcher::OverrideForTesting(std::make_unique<PropertyFetcher>());
+                    },
+            });
+            invokeAPIs();
+        }
+        if (mFdp.ConsumeBool()) {
+            mBuilder->RemoveGroupAndPartitions(mFdp.PickValueInArray(mGroupNames));
+        } else {
+            string removePartition = mFdp.PickValueInArray(mPartitionNames);
+            mBuilder->RemovePartition(removePartition);
+        }
+    }
+}
+
+void BuilderFuzzer::process() {
+    invokeBuilderAPIs();
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+    BuilderFuzzer builderFuzzer(data, size);
+    builderFuzzer.process();
+    return 0;
+}
diff --git a/fs_mgr/liblp/fuzzer/liblp_super_layout_builder_fuzzer.cpp b/fs_mgr/liblp/fuzzer/liblp_super_layout_builder_fuzzer.cpp
new file mode 100644
index 000000000000..887093c88b21
--- /dev/null
+++ b/fs_mgr/liblp/fuzzer/liblp_super_layout_builder_fuzzer.cpp
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2023 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 <android-base/unique_fd.h>
+#include <fcntl.h>
+#include <fuzzer/FuzzedDataProvider.h>
+#include <liblp/metadata_format.h>
+#include <liblp/super_layout_builder.h>
+#include <linux/memfd.h>
+#include <storage_literals/storage_literals.h>
+#include <sys/syscall.h>
+
+using namespace android::fs_mgr;
+using namespace std;
+using unique_fd = android::base::unique_fd;
+using namespace android::storage_literals;
+
+static constexpr uint64_t kSuperLayoutValidBlockDevSize = 4_MiB;
+static constexpr uint64_t kMinBlockDevValue = 0;
+static constexpr uint64_t kMaxBlockDevValue = 100000;
+static constexpr uint64_t kMinElements = 0;
+static constexpr uint64_t kMaxElements = 10;
+static constexpr uint32_t kSuperLayoutValidMetadataSize = 8_KiB;
+static constexpr uint32_t kMinMetadataValue = 0;
+static constexpr uint32_t kMaxMetadataValue = 10000;
+static constexpr uint32_t kMaxBytes = 20;
+static constexpr uint32_t kMinSlot = 0;
+static constexpr uint32_t kMaxSlot = 10;
+static constexpr uint32_t kMinOpen = 0;
+static constexpr uint32_t kMaxOpen = 2;
+
+const uint64_t kAttributeTypes[] = {
+        LP_PARTITION_ATTR_NONE,    LP_PARTITION_ATTR_READONLY, LP_PARTITION_ATTR_SLOT_SUFFIXED,
+        LP_PARTITION_ATTR_UPDATED, LP_PARTITION_ATTR_DISABLED,
+};
+
+class SuperLayoutBuilderFuzzer {
+  public:
+    SuperLayoutBuilderFuzzer(const uint8_t* data, size_t size) : mFdp(data, size){};
+    void process();
+
+  private:
+    FuzzedDataProvider mFdp;
+    void invokeSuperLayoutBuilderAPIs();
+    void callRandomOpen(int32_t open);
+    void addMultiplePartitions(int32_t numPartitions);
+    void setupSuperLayoutBuilder(string fuzzPartitionName);
+    SuperLayoutBuilder mSuperLayoutBuilder;
+    unique_ptr<MetadataBuilder> mSuperBuilder;
+    unique_ptr<LpMetadata> mMetadata;
+    bool mOpenSuccess = false;
+};
+
+void SuperLayoutBuilderFuzzer::setupSuperLayoutBuilder(string fuzzPartitionName) {
+    uint64_t randomBlockDevSize =
+            mFdp.ConsumeIntegralInRange<uint64_t>(kMinBlockDevValue, kMaxBlockDevValue);
+    uint64_t blockDevSize = mFdp.ConsumeBool() ? kSuperLayoutValidBlockDevSize : randomBlockDevSize;
+    uint32_t randomMetadataMaxSize =
+            mFdp.ConsumeIntegralInRange<uint32_t>(kMinMetadataValue, kMaxMetadataValue);
+    uint32_t metadataMaxSize =
+            mFdp.ConsumeBool() ? kSuperLayoutValidMetadataSize : randomMetadataMaxSize;
+    uint32_t metadataSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(kMinSlot, kMaxSlot);
+    mSuperBuilder = MetadataBuilder::New(blockDevSize, metadataMaxSize, metadataSlotCount);
+
+    if (mSuperBuilder.get()) {
+        if (mFdp.ConsumeBool()) {
+            int32_t numPartitions =
+                    mFdp.ConsumeIntegralInRange<int32_t>(kMinElements, kMaxElements);
+            addMultiplePartitions(numPartitions);
+        }
+
+        uint32_t randomOpen = mFdp.ConsumeIntegralInRange<uint32_t>(kMinOpen, kMaxOpen);
+        callRandomOpen(randomOpen);
+
+        if (!fuzzPartitionName.size()) {
+            fuzzPartitionName = "builder_partition";
+        }
+    }
+}
+
+void SuperLayoutBuilderFuzzer::addMultiplePartitions(int32_t numPartitions) {
+    for (int32_t idx = 0; idx < numPartitions; ++idx) {
+        string partitionName = mFdp.ConsumeBool() ? mFdp.ConsumeRandomLengthString(kMaxBytes)
+                                                  : "builder_partition";
+        mSuperBuilder->AddPartition(partitionName, mFdp.PickValueInArray(kAttributeTypes));
+    }
+}
+
+void SuperLayoutBuilderFuzzer::callRandomOpen(int32_t open) {
+    mMetadata = mSuperBuilder->Export();
+    switch (open) {
+        case 0: {
+            vector<uint8_t> imageData = mFdp.ConsumeBytes<uint8_t>(kMaxBytes);
+            mOpenSuccess = mSuperLayoutBuilder.Open((void*)(imageData.data()), imageData.size());
+            break;
+        }
+        case 1: {
+            mOpenSuccess = mSuperLayoutBuilder.Open(*mMetadata.get());
+            break;
+        }
+        case 2: {
+            unique_fd fd(syscall(__NR_memfd_create, "image_file", 0));
+            WriteToImageFile(fd, *mMetadata.get());
+            mOpenSuccess = mSuperLayoutBuilder.Open(fd);
+            break;
+        }
+    }
+}
+
+void SuperLayoutBuilderFuzzer::invokeSuperLayoutBuilderAPIs() {
+    string imageName = mFdp.ConsumeRandomLengthString(kMaxBytes);
+    string fuzzPartitionName =
+            mFdp.ConsumeBool() ? "builder_partition" : mFdp.ConsumeRandomLengthString(kMaxBytes);
+    setupSuperLayoutBuilder(fuzzPartitionName);
+    if (mOpenSuccess) {
+        while (mFdp.remaining_bytes()) {
+            auto invokeSuperAPIs = mFdp.PickValueInArray<const function<void()>>({
+                    [&]() { mSuperLayoutBuilder.GetImageLayout(); },
+                    [&]() {
+                        mSuperLayoutBuilder.AddPartition(fuzzPartitionName, imageName,
+                                                         mFdp.ConsumeIntegral<uint64_t>());
+                    },
+            });
+            invokeSuperAPIs();
+        }
+    }
+}
+
+void SuperLayoutBuilderFuzzer::process() {
+    invokeSuperLayoutBuilderAPIs();
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+    SuperLayoutBuilderFuzzer superLayoutBuilderFuzzer(data, size);
+    superLayoutBuilderFuzzer.process();
+    return 0;
+}

From 072af6eec1458620578b06acad867557302df080 Mon Sep 17 00:00:00 2001
From: Harsh Abichandani <harsh.abichandani@ittiam.com>
Date: Tue, 18 Jul 2023 11:27:05 +0530
Subject: [PATCH 0392/1487] Added TestPartitionOpener_group

Added TestPartitionOpener_group for test_partition_opener.cpp, as this
file shall be used by liblp_apis_fuzzer and liblp_test_defaults

Test: make TestPartitionOpener_group
Bug: 285829660

Change-Id: I01da0a6896409af99af9e89092f6e1e3760cf4c2
---
 fs_mgr/liblp/Android.bp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/liblp/Android.bp b/fs_mgr/liblp/Android.bp
index 996ffd759d6d..24eebdfb9192 100644
--- a/fs_mgr/liblp/Android.bp
+++ b/fs_mgr/liblp/Android.bp
@@ -93,8 +93,8 @@ cc_defaults {
     srcs: [
         "builder_test.cpp",
         "super_layout_builder_test.cpp",
-        "test_partition_opener.cpp",
         "utility_test.cpp",
+        ":TestPartitionOpener_group",
     ],
 }
 
@@ -122,3 +122,8 @@ cc_test {
     name: "vts_kernel_liblp_test",
     defaults: ["liblp_test_defaults"],
 }
+
+filegroup {
+   name: "TestPartitionOpener_group",
+   srcs: [ "test_partition_opener.cpp"],
+}

From b60befa806ffbdd413aa0c470b311d01d5fdbadd Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 19 Sep 2023 18:47:18 +0000
Subject: [PATCH 0393/1487] riscv64: minor ASLR bits changes.

Improve the comment, and increase the "minimum maximum" to 24 --- we
only support 64-bit, and 64-bit never has less than 24 bits.

Bug: https://github.com/google/android-riscv64/issues/1
Test: treehugger
Change-Id: I478c7649aa19258352c908a449cabe12da94952c
---
 init/security.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/init/security.cpp b/init/security.cpp
index 6e616be93c5f..445286aa5695 100644
--- a/init/security.cpp
+++ b/init/security.cpp
@@ -117,10 +117,10 @@ Result<void> SetMmapRndBitsAction(const BuiltinArguments&) {
         return {};
     }
 #elif defined(__riscv)
-    // TODO: sv48 and sv57 were both added to the kernel this year, so we
-    // probably just need some kernel fixes to enable higher ASLR randomization,
-    // but for now 24 is the maximum that the kernel supports.
-    if (SetMmapRndBitsMin(24, 18, false)) {
+    // TODO: sv48 and sv57 have both been added to the kernel, but the kernel
+    // still doesn't support more than 24 bits.
+    // https://github.com/google/android-riscv64/issues/1
+    if (SetMmapRndBitsMin(24, 24, false)) {
         return {};
     }
 #elif defined(__x86_64__)

From 6bc53ff7dd4d3da6a52dbda626db30aec7e67389 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 19 Sep 2023 18:40:03 +0000
Subject: [PATCH 0394/1487] arm64: update the "minimum maximum" comment.

Noticed while looking at riscv64. Looks like a bug, but actually nothing
we can do about it now or for the foreseeable future.

Bug: https://github.com/google/android-riscv64/issues/45
Test: treehugger
Change-Id: I2be81b2fd7095df40958a1f641d7b89cf5a8e41d
---
 init/security.cpp | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/init/security.cpp b/init/security.cpp
index 6e616be93c5f..499978aa9727 100644
--- a/init/security.cpp
+++ b/init/security.cpp
@@ -106,13 +106,9 @@ Result<void> SetMmapRndBitsAction(const BuiltinArguments&) {
     // uml does not support mmap_rnd_bits
     return {};
 #elif defined(__aarch64__)
-    // arm64 architecture supports 18 - 33 rnd bits depending on pagesize and
-    // VA_SIZE. However the kernel might have been compiled with a narrower
-    // range using CONFIG_ARCH_MMAP_RND_BITS_MIN/MAX. To use the maximum
-    // supported number of bits, we start from the theoretical maximum of 33
-    // bits and try smaller values until we reach 24 bits which is the
-    // Android-specific minimum. Don't go lower even if the configured maximum
-    // is smaller than 24.
+    // arm64 supports 14 - 33 rnd bits depending on page size and ARM64_VA_BITS.
+    // The kernel (6.5) still defaults to 39 va bits for 4KiB pages, so shipping
+    // devices are only getting 24 bits of randomness in practice.
     if (SetMmapRndBitsMin(33, 24, false) && (!Has32BitAbi() || SetMmapRndBitsMin(16, 16, true))) {
         return {};
     }

From 2e6aee53163cd5e6e31599c7948b54a2458d2344 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 19 Sep 2023 16:14:50 -0700
Subject: [PATCH 0395/1487] Removing double delete from flashall

From aosp/2475604 the functionality of deleting retrofit partitions
wasn't added back correctly. aosp/837186 adds this logic in. We should
only have one delete that exists if the image is secondary and is
dynamic.

Unfortunately don't have a retrofit device to test on, but from an eye
test this logic seems to match the old functionality and should be
working

Test: m fastboot
Change-Id: I5481893ab1638541d21813efe1c4aab5219e1dcd
---
 fastboot/fastboot.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 21df729dc9a1..8ad10dee24a4 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -350,8 +350,7 @@ Result<NetworkSerial, FastbootError> ParseNetworkSerial(const std::string& seria
 //
 // The returned Transport is a singleton, so multiple calls to this function will return the same
 // object, and the caller should not attempt to delete the returned Transport.
-static std::unique_ptr<Transport> open_device(const char* local_serial,
-                                              bool wait_for_device = true,
+static std::unique_ptr<Transport> open_device(const char* local_serial, bool wait_for_device = true,
                                               bool announce = true) {
     const Result<NetworkSerial, FastbootError> network_serial = ParseNetworkSerial(local_serial);
 
@@ -1885,9 +1884,8 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasksFromImageList() {
         if (is_retrofit_device(fp_->fb)) {
             std::string partition_name = image->part_name + "_"s + slot;
             if (image->IsSecondary() && should_flash_in_userspace(partition_name)) {
-                fp_->fb->DeletePartition(partition_name);
+                tasks.emplace_back(std::make_unique<DeleteTask>(fp_, partition_name));
             }
-            tasks.emplace_back(std::make_unique<DeleteTask>(fp_, partition_name));
         }
     }
 

From 8aba6d022cddb153f144488a9fabd445b08afb71 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 19 Sep 2023 16:59:13 -0700
Subject: [PATCH 0396/1487] Removing headers + using string

Removing some unused headers and swapping out std::string_literal to
strings

Test: fastboot flashall
Change-Id: I343272f4a678398a0446660a639c525e42e25891
---
 fastboot/fastboot.cpp | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 8ad10dee24a4..080ad4261a49 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -28,7 +28,6 @@
 
 #include "fastboot.h"
 
-#include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <getopt.h>
@@ -44,12 +43,10 @@
 #include <unistd.h>
 
 #include <chrono>
-#include <fstream>
 #include <functional>
 #include <iostream>
 #include <memory>
 #include <regex>
-#include <sstream>
 #include <string>
 #include <thread>
 #include <utility>
@@ -79,7 +76,6 @@
 #include "fastboot_driver_interface.h"
 #include "fs.h"
 #include "storage.h"
-#include "super_flash_helper.h"
 #include "task.h"
 #include "tcp.h"
 #include "transport.h"
@@ -93,7 +89,6 @@ using android::base::ReadFully;
 using android::base::Split;
 using android::base::Trim;
 using android::base::unique_fd;
-using namespace std::string_literals;
 using namespace std::placeholders;
 
 #define FASTBOOT_INFO_VERSION 1
@@ -1882,7 +1877,7 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasksFromImageList() {
         // partitions (otherwise they would not mount on first boot). To enforce
         // this, we delete any logical partitions for the "other" slot.
         if (is_retrofit_device(fp_->fb)) {
-            std::string partition_name = image->part_name + "_"s + slot;
+            std::string partition_name = image->part_name + "_" + slot;
             if (image->IsSecondary() && should_flash_in_userspace(partition_name)) {
                 tasks.emplace_back(std::make_unique<DeleteTask>(fp_, partition_name));
             }
@@ -2134,7 +2129,7 @@ static bool wipe_super(const android::fs_mgr::LpMetadata& metadata, const std::s
     if (metadata.block_devices.size() > 1) {
         ok = WriteSplitImageFiles(temp_dir.path, metadata, block_size, {}, true);
     } else {
-        auto image_path = temp_dir.path + "/"s + super_bdev_name + ".img";
+        auto image_path = std::string(temp_dir.path) + "/" + std::string(super_bdev_name) + ".img";
         ok = WriteToImageFile(image_path, metadata, block_size, {}, true);
     }
     if (!ok) {
@@ -2153,7 +2148,7 @@ static bool wipe_super(const android::fs_mgr::LpMetadata& metadata, const std::s
             image_name = partition + ".img";
         }
 
-        auto image_path = temp_dir.path + "/"s + image_name;
+        auto image_path = std::string(temp_dir.path) + "/" + image_name;
         auto flash = [&](const std::string& partition_name) {
             do_flash(partition_name.c_str(), image_path.c_str(), false, fp);
         };

From 78fb21c0f8dba54eb9a21f6c71923fd20fbb0511 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 19 Sep 2023 22:23:11 -0700
Subject: [PATCH 0397/1487] Removing extra includes

Removing includes we aren't using

Test: th
Change-Id: Ia5d00436f34138789e43008ecd73d65cbad84bde
---
 fastboot/fastboot.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 8ad10dee24a4..b3f7147e1c0b 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -28,7 +28,6 @@
 
 #include "fastboot.h"
 
-#include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <getopt.h>
@@ -44,12 +43,10 @@
 #include <unistd.h>
 
 #include <chrono>
-#include <fstream>
 #include <functional>
 #include <iostream>
 #include <memory>
 #include <regex>
-#include <sstream>
 #include <string>
 #include <thread>
 #include <utility>
@@ -79,7 +76,6 @@
 #include "fastboot_driver_interface.h"
 #include "fs.h"
 #include "storage.h"
-#include "super_flash_helper.h"
 #include "task.h"
 #include "tcp.h"
 #include "transport.h"

From 2b1a0599c4530c34b57ba109917904451b55214e Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Tue, 12 Sep 2023 15:26:15 +0000
Subject: [PATCH 0398/1487] Don't depend on String8 cast to C string

Bug: 295394788
Test: m checkbuild
Change-Id: I5b86ae56250d409a23ab3f2bc72b725bcf6ab23e
---
 healthd/BatteryMonitor.cpp       | 56 +++++++++++++------------
 healthd/BatteryMonitor_v1.cpp    | 38 ++++++++---------
 libutils/CallStack.cpp           |  2 +-
 libutils/String16_test.cpp       | 70 ++++++++++++++++----------------
 libutils/String8_test.cpp        | 16 ++++----
 trusty/stats/test/stats_test.cpp | 22 +++++-----
 6 files changed, 102 insertions(+), 102 deletions(-)

diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index e4cf582fbdcf..0c976322d2cd 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -432,7 +432,7 @@ void BatteryMonitor::updateValues(void) {
     }
 
     if (readFromFile(mHealthdConfig->batteryTechnologyPath, &buf) > 0)
-        mHealthInfo->batteryTechnology = String8(buf.c_str());
+        mHealthInfo->batteryTechnology = buf;
 
     if (readFromFile(mHealthdConfig->chargingPolicyPath, &buf) > 0)
         mHealthInfo->chargingPolicy = getBatteryChargingPolicy(buf.c_str());
@@ -786,39 +786,35 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/status", POWER_SUPPLY_SYSFS_PATH,
                                       name);
-                    if (access(path, R_OK) == 0)
-                        mHealthdConfig->batteryStatusPath = path;
+                    if (access(path.c_str(), R_OK) == 0) mHealthdConfig->batteryStatusPath = path;
                 }
 
                 if (mHealthdConfig->batteryHealthPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/health", POWER_SUPPLY_SYSFS_PATH,
                                       name);
-                    if (access(path, R_OK) == 0)
-                        mHealthdConfig->batteryHealthPath = path;
+                    if (access(path.c_str(), R_OK) == 0) mHealthdConfig->batteryHealthPath = path;
                 }
 
                 if (mHealthdConfig->batteryPresentPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/present", POWER_SUPPLY_SYSFS_PATH,
                                       name);
-                    if (access(path, R_OK) == 0)
-                        mHealthdConfig->batteryPresentPath = path;
+                    if (access(path.c_str(), R_OK) == 0) mHealthdConfig->batteryPresentPath = path;
                 }
 
                 if (mHealthdConfig->batteryCapacityPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/capacity", POWER_SUPPLY_SYSFS_PATH,
                                       name);
-                    if (access(path, R_OK) == 0)
-                        mHealthdConfig->batteryCapacityPath = path;
+                    if (access(path.c_str(), R_OK) == 0) mHealthdConfig->batteryCapacityPath = path;
                 }
 
                 if (mHealthdConfig->batteryVoltagePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/voltage_now",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0) {
+                    if (access(path.c_str(), R_OK) == 0) {
                         mHealthdConfig->batteryVoltagePath = path;
                     }
                 }
@@ -827,7 +823,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/charge_full",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryFullChargePath = path;
                 }
 
@@ -835,7 +831,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/current_now",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryCurrentNowPath = path;
                 }
 
@@ -843,27 +839,29 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/cycle_count",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryCycleCountPath = path;
                 }
 
                 if (mHealthdConfig->batteryCapacityLevelPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/capacity_level", POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0) mHealthdConfig->batteryCapacityLevelPath = path;
+                    if (access(path.c_str(), R_OK) == 0) {
+                        mHealthdConfig->batteryCapacityLevelPath = path;
+                    }
                 }
 
                 if (mHealthdConfig->batteryChargeTimeToFullNowPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/time_to_full_now", POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryChargeTimeToFullNowPath = path;
                 }
 
                 if (mHealthdConfig->batteryFullChargeDesignCapacityUahPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/charge_full_design", POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryFullChargeDesignCapacityUahPath = path;
                 }
 
@@ -871,7 +869,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/current_avg",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryCurrentAvgPath = path;
                 }
 
@@ -879,7 +877,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/charge_counter",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryChargeCounterPath = path;
                 }
 
@@ -887,7 +885,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/temp", POWER_SUPPLY_SYSFS_PATH,
                                       name);
-                    if (access(path, R_OK) == 0) {
+                    if (access(path.c_str(), R_OK) == 0) {
                         mHealthdConfig->batteryTemperaturePath = path;
                     }
                 }
@@ -896,19 +894,19 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/technology",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryTechnologyPath = path;
                 }
 
                 if (mHealthdConfig->batteryStateOfHealthPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/state_of_health", POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0) {
+                    if (access(path.c_str(), R_OK) == 0) {
                         mHealthdConfig->batteryStateOfHealthPath = path;
                     } else {
                         path.clear();
                         path.appendFormat("%s/%s/health_index", POWER_SUPPLY_SYSFS_PATH, name);
-                        if (access(path, R_OK) == 0)
+                        if (access(path.c_str(), R_OK) == 0)
                             mHealthdConfig->batteryStateOfHealthPath = path;
                     }
                 }
@@ -916,32 +914,36 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                 if (mHealthdConfig->batteryHealthStatusPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/health_status", POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0) mHealthdConfig->batteryHealthStatusPath = path;
+                    if (access(path.c_str(), R_OK) == 0) {
+                        mHealthdConfig->batteryHealthStatusPath = path;
+                    }
                 }
 
                 if (mHealthdConfig->batteryManufacturingDatePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/manufacturing_date", POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryManufacturingDatePath = path;
                 }
 
                 if (mHealthdConfig->batteryFirstUsageDatePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/first_usage_date", POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0) mHealthdConfig->batteryFirstUsageDatePath = path;
+                    if (access(path.c_str(), R_OK) == 0) {
+                        mHealthdConfig->batteryFirstUsageDatePath = path;
+                    }
                 }
 
                 if (mHealthdConfig->chargingStatePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/charging_state", POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0) mHealthdConfig->chargingStatePath = path;
+                    if (access(path.c_str(), R_OK) == 0) mHealthdConfig->chargingStatePath = path;
                 }
 
                 if (mHealthdConfig->chargingPolicyPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/charging_policy", POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0) mHealthdConfig->chargingPolicyPath = path;
+                    if (access(path.c_str(), R_OK) == 0) mHealthdConfig->chargingPolicyPath = path;
                 }
 
                 break;
diff --git a/healthd/BatteryMonitor_v1.cpp b/healthd/BatteryMonitor_v1.cpp
index 686c338cc10e..2e0cfc97182a 100644
--- a/healthd/BatteryMonitor_v1.cpp
+++ b/healthd/BatteryMonitor_v1.cpp
@@ -352,7 +352,7 @@ void BatteryMonitor::updateValues(void) {
         mHealthInfo->batteryHealth = getBatteryHealth(buf.c_str());
 
     if (readFromFile(mHealthdConfig->batteryTechnologyPath, &buf) > 0)
-        mHealthInfo->batteryTechnology = String8(buf.c_str());
+        mHealthInfo->batteryTechnology = buf;
 
     double MaxPower = 0;
 
@@ -639,39 +639,35 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/status", POWER_SUPPLY_SYSFS_PATH,
                                       name);
-                    if (access(path, R_OK) == 0)
-                        mHealthdConfig->batteryStatusPath = path;
+                    if (access(path.c_str(), R_OK) == 0) mHealthdConfig->batteryStatusPath = path;
                 }
 
                 if (mHealthdConfig->batteryHealthPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/health", POWER_SUPPLY_SYSFS_PATH,
                                       name);
-                    if (access(path, R_OK) == 0)
-                        mHealthdConfig->batteryHealthPath = path;
+                    if (access(path.c_str(), R_OK) == 0) mHealthdConfig->batteryHealthPath = path;
                 }
 
                 if (mHealthdConfig->batteryPresentPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/present", POWER_SUPPLY_SYSFS_PATH,
                                       name);
-                    if (access(path, R_OK) == 0)
-                        mHealthdConfig->batteryPresentPath = path;
+                    if (access(path.c_str(), R_OK) == 0) mHealthdConfig->batteryPresentPath = path;
                 }
 
                 if (mHealthdConfig->batteryCapacityPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/capacity", POWER_SUPPLY_SYSFS_PATH,
                                       name);
-                    if (access(path, R_OK) == 0)
-                        mHealthdConfig->batteryCapacityPath = path;
+                    if (access(path.c_str(), R_OK) == 0) mHealthdConfig->batteryCapacityPath = path;
                 }
 
                 if (mHealthdConfig->batteryVoltagePath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/voltage_now",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0) {
+                    if (access(path.c_str(), R_OK) == 0) {
                         mHealthdConfig->batteryVoltagePath = path;
                     }
                 }
@@ -680,7 +676,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/charge_full",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryFullChargePath = path;
                 }
 
@@ -688,7 +684,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/current_now",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryCurrentNowPath = path;
                 }
 
@@ -696,27 +692,29 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/cycle_count",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryCycleCountPath = path;
                 }
 
                 if (mHealthdConfig->batteryCapacityLevelPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/capacity_level", POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0) mHealthdConfig->batteryCapacityLevelPath = path;
+                    if (access(path.c_str(), R_OK) == 0) {
+                        mHealthdConfig->batteryCapacityLevelPath = path;
+                    }
                 }
 
                 if (mHealthdConfig->batteryChargeTimeToFullNowPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/time_to_full_now", POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryChargeTimeToFullNowPath = path;
                 }
 
                 if (mHealthdConfig->batteryFullChargeDesignCapacityUahPath.empty()) {
                     path.clear();
                     path.appendFormat("%s/%s/charge_full_design", POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryFullChargeDesignCapacityUahPath = path;
                 }
 
@@ -724,7 +722,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/current_avg",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryCurrentAvgPath = path;
                 }
 
@@ -732,7 +730,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/charge_counter",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryChargeCounterPath = path;
                 }
 
@@ -740,7 +738,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/temp", POWER_SUPPLY_SYSFS_PATH,
                                       name);
-                    if (access(path, R_OK) == 0) {
+                    if (access(path.c_str(), R_OK) == 0) {
                         mHealthdConfig->batteryTemperaturePath = path;
                     }
                 }
@@ -749,7 +747,7 @@ void BatteryMonitor::init(struct healthd_config *hc) {
                     path.clear();
                     path.appendFormat("%s/%s/technology",
                                       POWER_SUPPLY_SYSFS_PATH, name);
-                    if (access(path, R_OK) == 0)
+                    if (access(path.c_str(), R_OK) == 0)
                         mHealthdConfig->batteryTechnologyPath = path;
                 }
 
diff --git a/libutils/CallStack.cpp b/libutils/CallStack.cpp
index 4dcb35b3657b..11f2c9262048 100644
--- a/libutils/CallStack.cpp
+++ b/libutils/CallStack.cpp
@@ -82,7 +82,7 @@ String8 CallStack::toString(const char* prefix) const {
 
 void CallStack::print(Printer& printer) const {
     for (size_t i = 0; i < mFrameLines.size(); i++) {
-        printer.printLine(mFrameLines[i]);
+        printer.printLine(mFrameLines[i].c_str());
     }
 }
 
diff --git a/libutils/String16_test.cpp b/libutils/String16_test.cpp
index c6e6f746a858..6f4642e8fb6d 100644
--- a/libutils/String16_test.cpp
+++ b/libutils/String16_test.cpp
@@ -33,50 +33,50 @@ ::testing::AssertionResult Char16_tStringEquals(const char16_t* a, const char16_
 
 TEST(String16Test, FromChar16_t) {
     String16 tmp(u"Verify me");
-    EXPECT_STR16EQ(u"Verify me", tmp);
+    EXPECT_STR16EQ(u"Verify me", tmp.c_str());
 }
 
 TEST(String16Test, FromChar16_tSized) {
     String16 tmp(u"Verify me", 7);
-    EXPECT_STR16EQ(u"Verify ", tmp);
+    EXPECT_STR16EQ(u"Verify ", tmp.c_str());
 }
 
 TEST(String16Test, FromChar) {
     String16 tmp("Verify me");
-    EXPECT_STR16EQ(u"Verify me", tmp);
+    EXPECT_STR16EQ(u"Verify me", tmp.c_str());
 }
 
 TEST(String16Test, FromCharSized) {
     String16 tmp("Verify me", 7);
-    EXPECT_STR16EQ(u"Verify ", tmp);
+    EXPECT_STR16EQ(u"Verify ", tmp.c_str());
 }
 
 TEST(String16Test, Copy) {
     String16 tmp("Verify me");
     String16 another = tmp;
-    EXPECT_STR16EQ(u"Verify me", tmp);
-    EXPECT_STR16EQ(u"Verify me", another);
+    EXPECT_STR16EQ(u"Verify me", tmp.c_str());
+    EXPECT_STR16EQ(u"Verify me", another.c_str());
 }
 
 TEST(String16Test, CopyAssign) {
     String16 tmp("Verify me");
     String16 another;
     another = tmp;
-    EXPECT_STR16EQ(u"Verify me", tmp);
-    EXPECT_STR16EQ(u"Verify me", another);
+    EXPECT_STR16EQ(u"Verify me", tmp.c_str());
+    EXPECT_STR16EQ(u"Verify me", another.c_str());
 }
 
 TEST(String16Test, Move) {
     String16 tmp("Verify me");
     String16 another(std::move(tmp));
-    EXPECT_STR16EQ(u"Verify me", another);
+    EXPECT_STR16EQ(u"Verify me", another.c_str());
 }
 
 TEST(String16Test, MoveAssign) {
     String16 tmp("Verify me");
     String16 another;
     another = std::move(tmp);
-    EXPECT_STR16EQ(u"Verify me", another);
+    EXPECT_STR16EQ(u"Verify me", another.c_str());
 }
 
 TEST(String16Test, Size) {
@@ -88,27 +88,27 @@ TEST(String16Test, setTo) {
     String16 tmp("Verify me");
     tmp.setTo(u"New content");
     EXPECT_EQ(11U, tmp.size());
-    EXPECT_STR16EQ(u"New content", tmp);
+    EXPECT_STR16EQ(u"New content", tmp.c_str());
 }
 
 TEST(String16Test, Append) {
     String16 tmp("Verify me");
     tmp.append(String16("Hello"));
     EXPECT_EQ(14U, tmp.size());
-    EXPECT_STR16EQ(u"Verify meHello", tmp);
+    EXPECT_STR16EQ(u"Verify meHello", tmp.c_str());
 }
 
 TEST(String16Test, Insert) {
     String16 tmp("Verify me");
     tmp.insert(6, u"Insert");
     EXPECT_EQ(15U, tmp.size());
-    EXPECT_STR16EQ(u"VerifyInsert me", tmp);
+    EXPECT_STR16EQ(u"VerifyInsert me", tmp.c_str());
 }
 
 TEST(String16Test, ReplaceAll) {
     String16 tmp("Verify verify Verify");
     tmp.replaceAll(u'r', u'!');
-    EXPECT_STR16EQ(u"Ve!ify ve!ify Ve!ify", tmp);
+    EXPECT_STR16EQ(u"Ve!ify ve!ify Ve!ify", tmp.c_str());
 }
 
 TEST(String16Test, Compare) {
@@ -127,8 +127,8 @@ TEST(String16Test, StaticString) {
 TEST(String16Test, StaticStringCopy) {
     StaticString16 tmp(u"Verify me");
     String16 another = tmp;
-    EXPECT_STR16EQ(u"Verify me", tmp);
-    EXPECT_STR16EQ(u"Verify me", another);
+    EXPECT_STR16EQ(u"Verify me", tmp.c_str());
+    EXPECT_STR16EQ(u"Verify me", another.c_str());
     EXPECT_TRUE(tmp.isStaticString());
     EXPECT_TRUE(another.isStaticString());
 }
@@ -136,7 +136,7 @@ TEST(String16Test, StaticStringCopy) {
 TEST(String16Test, StaticStringMove) {
     StaticString16 tmp(u"Verify me");
     String16 another(std::move(tmp));
-    EXPECT_STR16EQ(u"Verify me", another);
+    EXPECT_STR16EQ(u"Verify me", another.c_str());
     EXPECT_TRUE(another.isStaticString());
 }
 
@@ -157,7 +157,7 @@ TEST(String16Test, StaticStringAppend) {
     StaticString16 tmp(u"Verify me");
     tmp.append(String16("Hello"));
     EXPECT_EQ(14U, tmp.size());
-    EXPECT_STR16EQ(u"Verify meHello", tmp);
+    EXPECT_STR16EQ(u"Verify meHello", tmp.c_str());
     EXPECT_FALSE(tmp.isStaticString());
 }
 
@@ -165,14 +165,14 @@ TEST(String16Test, StaticStringInsert) {
     StaticString16 tmp(u"Verify me");
     tmp.insert(6, u"Insert");
     EXPECT_EQ(15U, tmp.size());
-    EXPECT_STR16EQ(u"VerifyInsert me", tmp);
+    EXPECT_STR16EQ(u"VerifyInsert me", tmp.c_str());
     EXPECT_FALSE(tmp.isStaticString());
 }
 
 TEST(String16Test, StaticStringReplaceAll) {
     StaticString16 tmp(u"Verify verify Verify");
     tmp.replaceAll(u'r', u'!');
-    EXPECT_STR16EQ(u"Ve!ify ve!ify Ve!ify", tmp);
+    EXPECT_STR16EQ(u"Ve!ify ve!ify Ve!ify", tmp.c_str());
     EXPECT_FALSE(tmp.isStaticString());
 }
 
@@ -185,17 +185,17 @@ TEST(String16Test, StringSetToStaticString) {
     StaticString16 tmp(u"Verify me");
     String16 another(u"nonstatic");
     another = tmp;
-    EXPECT_STR16EQ(u"Verify me", tmp);
-    EXPECT_STR16EQ(u"Verify me", another);
+    EXPECT_STR16EQ(u"Verify me", tmp.c_str());
+    EXPECT_STR16EQ(u"Verify me", another.c_str());
 }
 
 TEST(String16Test, StringCopyAssignFromStaticString) {
     StaticString16 tmp(u"Verify me");
     String16 another(u"nonstatic");
     another = tmp;
-    EXPECT_STR16EQ(u"Verify me", another);
+    EXPECT_STR16EQ(u"Verify me", another.c_str());
     EXPECT_TRUE(another.isStaticString());
-    EXPECT_STR16EQ(u"Verify me", tmp);
+    EXPECT_STR16EQ(u"Verify me", tmp.c_str());
     EXPECT_TRUE(tmp.isStaticString());
 }
 
@@ -203,7 +203,7 @@ TEST(String16Test, StringMoveAssignFromStaticString) {
     StaticString16 tmp(u"Verify me");
     String16 another(u"nonstatic");
     another = std::move(tmp);
-    EXPECT_STR16EQ(u"Verify me", another);
+    EXPECT_STR16EQ(u"Verify me", another.c_str());
     EXPECT_TRUE(another.isStaticString());
 }
 
@@ -221,19 +221,19 @@ TEST(String16Test, OverreadUtf8Conversion) {
 TEST(String16Test, ValidUtf8Conversion) {
     String16 another("abcdef");
     EXPECT_EQ(6U, another.size());
-    EXPECT_STR16EQ(another, u"abcdef");
+    EXPECT_STR16EQ(another.c_str(), u"abcdef");
 }
 
 TEST(String16Test, append) {
     String16 s;
     EXPECT_EQ(OK, s.append(String16(u"foo")));
-    EXPECT_STR16EQ(u"foo", s);
+    EXPECT_STR16EQ(u"foo", s.c_str());
     EXPECT_EQ(OK, s.append(String16(u"bar")));
-    EXPECT_STR16EQ(u"foobar", s);
+    EXPECT_STR16EQ(u"foobar", s.c_str());
     EXPECT_EQ(OK, s.append(u"baz", 0));
-    EXPECT_STR16EQ(u"foobar", s);
+    EXPECT_STR16EQ(u"foobar", s.c_str());
     EXPECT_EQ(NO_MEMORY, s.append(u"baz", SIZE_MAX));
-    EXPECT_STR16EQ(u"foobar", s);
+    EXPECT_STR16EQ(u"foobar", s.c_str());
 }
 
 TEST(String16Test, insert) {
@@ -241,19 +241,19 @@ TEST(String16Test, insert) {
 
     // Inserting into the empty string inserts at the start.
     EXPECT_EQ(OK, s.insert(123, u"foo"));
-    EXPECT_STR16EQ(u"foo", s);
+    EXPECT_STR16EQ(u"foo", s.c_str());
 
     // Inserting zero characters at any position is okay, but won't expand the string.
     EXPECT_EQ(OK, s.insert(123, u"foo", 0));
-    EXPECT_STR16EQ(u"foo", s);
+    EXPECT_STR16EQ(u"foo", s.c_str());
 
     // Inserting past the end of a non-empty string appends.
     EXPECT_EQ(OK, s.insert(123, u"bar"));
-    EXPECT_STR16EQ(u"foobar", s);
+    EXPECT_STR16EQ(u"foobar", s.c_str());
 
     EXPECT_EQ(OK, s.insert(3, u"!"));
-    EXPECT_STR16EQ(u"foo!bar", s);
+    EXPECT_STR16EQ(u"foo!bar", s.c_str());
 
     EXPECT_EQ(NO_MEMORY, s.insert(3, u"", SIZE_MAX));
-    EXPECT_STR16EQ(u"foo!bar", s);
+    EXPECT_STR16EQ(u"foo!bar", s.c_str());
 }
diff --git a/libutils/String8_test.cpp b/libutils/String8_test.cpp
index 9c12cb12df84..e1fd13a9e137 100644
--- a/libutils/String8_test.cpp
+++ b/libutils/String8_test.cpp
@@ -100,19 +100,19 @@ TEST_F(String8Test, CheckUtf32Conversion) {
 TEST_F(String8Test, ValidUtf16Conversion) {
     char16_t tmp[] = u"abcdef";
     String8 valid = String8(String16(tmp));
-    EXPECT_STREQ(valid, "abcdef");
+    EXPECT_STREQ(valid.c_str(), "abcdef");
 }
 
 TEST_F(String8Test, append) {
     String8 s;
     EXPECT_EQ(OK, s.append("foo"));
-    EXPECT_STREQ("foo", s);
+    EXPECT_STREQ("foo", s.c_str());
     EXPECT_EQ(OK, s.append("bar"));
-    EXPECT_STREQ("foobar", s);
+    EXPECT_STREQ("foobar", s.c_str());
     EXPECT_EQ(OK, s.append("baz", 0));
-    EXPECT_STREQ("foobar", s);
+    EXPECT_STREQ("foobar", s.c_str());
     EXPECT_EQ(NO_MEMORY, s.append("baz", SIZE_MAX));
-    EXPECT_STREQ("foobar", s);
+    EXPECT_STREQ("foobar", s.c_str());
 }
 
 TEST_F(String8Test, removeAll) {
@@ -123,12 +123,12 @@ TEST_F(String8Test, removeAll) {
 
     // expect to return true and string content should remain unchanged
     EXPECT_TRUE(s.removeAll(""));
-    EXPECT_STREQ("Hello, world!", s);
+    EXPECT_STREQ("Hello, world!", s.c_str());
 
     // expect to return false
     EXPECT_FALSE(s.removeAll("x"));
-    EXPECT_STREQ("Hello, world!", s);
+    EXPECT_STREQ("Hello, world!", s.c_str());
 
     EXPECT_TRUE(s.removeAll("o"));
-    EXPECT_STREQ("Hell, wrld!", s);
+    EXPECT_STREQ("Hell, wrld!", s.c_str());
 }
diff --git a/trusty/stats/test/stats_test.cpp b/trusty/stats/test/stats_test.cpp
index 1edddeb5abd3..1d6eb34a6d4c 100644
--- a/trusty/stats/test/stats_test.cpp
+++ b/trusty/stats/test/stats_test.cpp
@@ -252,20 +252,20 @@ TEST_F(TrustyStatsTest, CheckAtoms) {
                     ::testing::AnyOf(::testing::Eq(TrustyAtoms::TrustyAppCrashed),
                                      ::testing::Eq(TrustyAtoms::TrustyError),
                                      ::testing::Eq(TrustyAtoms::TrustyStorageError)));
-        ASSERT_STREQ(String8(vendorAtom.reverseDomainName), "google.android.trusty");
+        ASSERT_EQ(String8(vendorAtom.reverseDomainName), "google.android.trusty");
         switch (vendorAtom.atomId) {
             case TrustyAtoms::TrustyAppCrashed:
                 ++atomAppCrashedCnt;
-                ASSERT_STREQ(String8(vendorAtom.values[0].get<VendorAtomValue::stringValue>()),
-                             "5247d19b-cf09-4272-a450-3ef20dbefc14");
+                ASSERT_EQ(String8(vendorAtom.values[0].get<VendorAtomValue::stringValue>()),
+                          "5247d19b-cf09-4272-a450-3ef20dbefc14");
                 break;
             case TrustyAtoms::TrustyStorageError:
                 ++atomStorageErrorCnt;
                 ASSERT_EQ(vendorAtom.values[0].get<VendorAtomValue::intValue>(), 5);
-                ASSERT_STREQ(String8(vendorAtom.values[1].get<VendorAtomValue::stringValue>()),
-                             "5247d19b-cf09-4272-a450-3ef20dbefc14");
-                ASSERT_STREQ(String8(vendorAtom.values[2].get<VendorAtomValue::stringValue>()),
-                             "5247d19b-cf09-4272-a450-3ef20dbefc14");
+                ASSERT_EQ(String8(vendorAtom.values[1].get<VendorAtomValue::stringValue>()),
+                          "5247d19b-cf09-4272-a450-3ef20dbefc14");
+                ASSERT_EQ(String8(vendorAtom.values[2].get<VendorAtomValue::stringValue>()),
+                          "5247d19b-cf09-4272-a450-3ef20dbefc14");
                 ASSERT_EQ(vendorAtom.values[3].get<VendorAtomValue::intValue>(), 1);
                 ASSERT_EQ(vendorAtom.values[4].get<VendorAtomValue::intValue>(), 3);
                 ASSERT_EQ(vendorAtom.values[5].get<VendorAtomValue::longValue>(),
@@ -330,13 +330,13 @@ TEST_F(TrustyMetricsCrashTest, CheckTrustyCrashAtoms) {
                     ::testing::AnyOf(::testing::Eq(TrustyAtoms::TrustyAppCrashed),
                                      ::testing::Eq(TrustyAtoms::TrustyError),
                                      ::testing::Eq(TrustyAtoms::TrustyStorageError)));
-        ASSERT_STREQ(String8(vendorAtom.reverseDomainName), "google.android.trusty");
+        ASSERT_EQ(String8(vendorAtom.reverseDomainName), "google.android.trusty");
 
         switch (vendorAtom.atomId) {
             case TrustyAtoms::TrustyAppCrashed:
                 ++atomAppCrashedCnt;
-                ASSERT_STREQ(String8(vendorAtom.values[0].get<VendorAtomValue::stringValue>()),
-                             kTrustyCrasherUuid);
+                ASSERT_EQ(String8(vendorAtom.values[0].get<VendorAtomValue::stringValue>()),
+                          kTrustyCrasherUuid);
                 atomCrashReasons.push_back(vendorAtom.values[1].get<VendorAtomValue::intValue>());
                 break;
             case TrustyAtoms::TrustyStorageError:
@@ -344,7 +344,7 @@ TEST_F(TrustyMetricsCrashTest, CheckTrustyCrashAtoms) {
                 break;
             case TrustyAtoms::TrustyError:
                 ++atomTrustyErrorCnt;
-                ASSERT_STREQ(String8(vendorAtom.values[1].get<VendorAtomValue::stringValue>()), "");
+                ASSERT_EQ(String8(vendorAtom.values[1].get<VendorAtomValue::stringValue>()), "");
                 break;
             default:
                 FAIL() << "Unknown vendor atom ID: " << vendorAtom.atomId;

From a95ed0aeaccf22439e1a6306f42446e48b6f2030 Mon Sep 17 00:00:00 2001
From: Dan Shi <dshi@google.com>
Date: Mon, 18 Sep 2023 16:42:57 -0700
Subject: [PATCH 0399/1487] Move CF only tests to CF test mapping suite

This change doesn't modify presubmit coverage, the tests will still
run in the lab as test mapping suite, just on a different ATP test
config that dedicated to tests can only run on CF (not aosp_cf), on
git_main branch.

Bug: 300519349
Test: atest presubmit check
Change-Id: Ib179c034dc58f8d8a763d374af0d103baf51343b
---
 trusty/keymaster/TEST_MAPPING | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/trusty/keymaster/TEST_MAPPING b/trusty/keymaster/TEST_MAPPING
index 0475e04018f7..c4fba677ce5a 100644
--- a/trusty/keymaster/TEST_MAPPING
+++ b/trusty/keymaster/TEST_MAPPING
@@ -7,16 +7,20 @@
         "name": "VtsHalRemotelyProvisionedComponentTargetTest"
       },
       {
-        "name": "RkpdAppUnitTests"
+        "name": "RkpdAppUnitTests",
+        "keywords": ["internal"]
       },
       {
-        "name": "RkpdAppGoogleUnitTests"
+        "name": "RkpdAppGoogleUnitTests",
+        "keywords": ["internal"]
       },
       {
-        "name": "RkpdAppIntegrationTests"
+        "name": "RkpdAppIntegrationTests",
+        "keywords": ["internal"]
       },
       {
-        "name": "RkpdAppGoogleIntegrationTests"
+        "name": "RkpdAppGoogleIntegrationTests",
+        "keywords": ["internal"]
       }
   ]
 }

From 43c87b3291e7d2d706c287d2b6c5770fb77e5175 Mon Sep 17 00:00:00 2001
From: Dan Shi <dshi@google.com>
Date: Wed, 20 Sep 2023 13:24:46 -0700
Subject: [PATCH 0400/1487] Remove unnecessary keyword setting

These 2 tests can run on aosp cf.

Bug: 300519349
Test: atest presubmit check
Change-Id: I8ee41c2abe464be2c2ee4537de5edf86308183aa
---
 trusty/keymaster/TEST_MAPPING | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/trusty/keymaster/TEST_MAPPING b/trusty/keymaster/TEST_MAPPING
index c4fba677ce5a..4f082d8956e7 100644
--- a/trusty/keymaster/TEST_MAPPING
+++ b/trusty/keymaster/TEST_MAPPING
@@ -7,16 +7,14 @@
         "name": "VtsHalRemotelyProvisionedComponentTargetTest"
       },
       {
-        "name": "RkpdAppUnitTests",
-        "keywords": ["internal"]
+        "name": "RkpdAppUnitTests"
       },
       {
         "name": "RkpdAppGoogleUnitTests",
         "keywords": ["internal"]
       },
       {
-        "name": "RkpdAppIntegrationTests",
-        "keywords": ["internal"]
+        "name": "RkpdAppIntegrationTests"
       },
       {
         "name": "RkpdAppGoogleIntegrationTests",

From f06e218e826039bf5113de5a773803fccfcac561 Mon Sep 17 00:00:00 2001
From: Andrew Scull <ascull@google.com>
Date: Thu, 21 Sep 2023 14:50:55 +0000
Subject: [PATCH 0401/1487] Delete unused DATA_MNT_POINT macro

The macros isn't used anywhere but was a distraction when tracking down
/data mounting behaviour.

Test: build
Change-Id: Ie23574326cbebd7f515c8409e1dcb91a00cafc6f
---
 init/builtins.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/init/builtins.cpp b/init/builtins.cpp
index a70e86683f52..a95a4a315b64 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -475,8 +475,6 @@ static struct {
     { 0,            0 },
 };
 
-#define DATA_MNT_POINT "/data"
-
 /* mount <type> <device> <path> <flags ...> <options> */
 static Result<void> do_mount(const BuiltinArguments& args) {
     const char* options = nullptr;

From 93377e99e2ffa260f1da5b53326d51ef19ab74f6 Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Tue, 19 Sep 2023 21:04:39 -0700
Subject: [PATCH 0402/1487] snapuserd_test: don't discard result of std::async

std::async returns a std::future whose destructor blocks until the
async function has completed, which defeats the purpose of using
std::async. The future needs to be kept alive to allow the function to
run concurrently.

Starting in C++20, std::async marked [[nodiscard]] to help catch this
misuse. Upgrading libc++ adds the [[nodiscard]] attribute to
std::async, so fixing this bug is necessary to keep the code compiling
after libc++ is updated.

Bug: 175635923
Test: treehugger
Test: m && m snapuserd_test
Change-Id: Id2e820248c2b6111aa843fb709e08a2c19677066
---
 .../snapuserd/user-space-merge/snapuserd_test.cpp         | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 01fe06fe79bf..620ecbd3f102 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -714,10 +714,12 @@ TEST_F(SnapuserdTest, Snapshot_MERGE_IO_TEST) {
     }
     ASSERT_NO_FATAL_FAILURE(SetupDefault());
     // Issue I/O before merge begins
-    std::async(std::launch::async, &SnapuserdTest::ReadSnapshotDeviceAndValidate, this);
+    auto read_future =
+            std::async(std::launch::async, &SnapuserdTest::ReadSnapshotDeviceAndValidate, this);
     // Start the merge
     ASSERT_TRUE(Merge());
     ValidateMerge();
+    read_future.wait();
 }
 
 TEST_F(SnapuserdTest, Snapshot_MERGE_IO_TEST_1) {
@@ -728,9 +730,11 @@ TEST_F(SnapuserdTest, Snapshot_MERGE_IO_TEST_1) {
     // Start the merge
     ASSERT_TRUE(StartMerge());
     // Issue I/O in parallel when merge is in-progress
-    std::async(std::launch::async, &SnapuserdTest::ReadSnapshotDeviceAndValidate, this);
+    auto read_future =
+            std::async(std::launch::async, &SnapuserdTest::ReadSnapshotDeviceAndValidate, this);
     CheckMergeCompletion();
     ValidateMerge();
+    read_future.wait();
 }
 
 TEST_F(SnapuserdTest, Snapshot_Merge_Resume) {

From 999efbef093214bf8302591a17a777439a0a85e6 Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Thu, 21 Sep 2023 17:51:52 -0700
Subject: [PATCH 0403/1487] Add missing <functional> and <vector> includes

Bug: 175635923
Test: m MODULES-IN-system-core-libutils
Change-Id: I065907a58a88723ae512f155dfde2d2fcb3fc322
---
 libutils/String16_fuzz.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libutils/String16_fuzz.cpp b/libutils/String16_fuzz.cpp
index a271aeebd897..8f9781bfef9b 100644
--- a/libutils/String16_fuzz.cpp
+++ b/libutils/String16_fuzz.cpp
@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <functional>
 #include <iostream>
+#include <vector>
 
 #include "fuzzer/FuzzedDataProvider.h"
 #include "utils/String16.h"

From 87c90e7b65c734ba553a4655d0aee8c7dd939676 Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Thu, 21 Sep 2023 19:44:47 -0700
Subject: [PATCH 0404/1487] Add missing <assert.h> include

Bug: 175635923
Test: m MODULES-IN-system-core-trusty
Change-Id: I7790dde8eba948cf95cb14dd2b436c3f6f88765a
---
 trusty/apploader/apploader.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/trusty/apploader/apploader.cpp b/trusty/apploader/apploader.cpp
index 17d083c735cd..f782d2acb842 100644
--- a/trusty/apploader/apploader.cpp
+++ b/trusty/apploader/apploader.cpp
@@ -19,6 +19,7 @@
 #include <BufferAllocator/BufferAllocator.h>
 #include <android-base/logging.h>
 #include <android-base/unique_fd.h>
+#include <assert.h>
 #include <fcntl.h>
 #include <getopt.h>
 #include <stdbool.h>

From 7107c582fa1948c3ccdaafa251dcd91ec0e847d1 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 22 Sep 2023 14:33:47 +0000
Subject: [PATCH 0405/1487] Remove unused files.

Test: treehugger
Change-Id: I7ea71395b87eb12044fb3e7d19c171149f4cc90b
---
 libcutils/arch-x86/cache.h    | 28 ----------------------------
 libcutils/arch-x86_64/cache.h | 22 ----------------------
 2 files changed, 50 deletions(-)
 delete mode 100644 libcutils/arch-x86/cache.h
 delete mode 100644 libcutils/arch-x86_64/cache.h

diff --git a/libcutils/arch-x86/cache.h b/libcutils/arch-x86/cache.h
deleted file mode 100644
index 1c22feaa7ae8..000000000000
--- a/libcutils/arch-x86/cache.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2010 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.
- */
-
-#if defined(__slm__)
-/* Values are optimized for Silvermont */
-#define SHARED_CACHE_SIZE   (1024*1024)         /* Silvermont L2 Cache */
-#define DATA_CACHE_SIZE     (24*1024)           /* Silvermont L1 Data Cache */
-#else
-/* Values are optimized for Atom */
-#define SHARED_CACHE_SIZE   (512*1024)          /* Atom L2 Cache */
-#define DATA_CACHE_SIZE     (24*1024)           /* Atom L1 Data Cache */
-#endif
-
-#define SHARED_CACHE_SIZE_HALF  (SHARED_CACHE_SIZE / 2)
-#define DATA_CACHE_SIZE_HALF    (DATA_CACHE_SIZE / 2)
diff --git a/libcutils/arch-x86_64/cache.h b/libcutils/arch-x86_64/cache.h
deleted file mode 100644
index f1443093909e..000000000000
--- a/libcutils/arch-x86_64/cache.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (C) 2014 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.
- */
-
-/* Values are optimized for Silvermont */
-#define SHARED_CACHE_SIZE	(1024*1024)			/* Silvermont L2 Cache */
-#define DATA_CACHE_SIZE		(24*1024)			/* Silvermont L1 Data Cache */
-
-#define SHARED_CACHE_SIZE_HALF	(SHARED_CACHE_SIZE / 2)
-#define DATA_CACHE_SIZE_HALF	(DATA_CACHE_SIZE / 2)

From 1faedd02a3d1c392136cfcdb38afa698721a7d6f Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 22 Sep 2023 14:45:20 +0000
Subject: [PATCH 0406/1487] Remove redefinition of uapi constant added in R.

Test: treehugger
Change-Id: If0ef9c36b2f54eb59d222dedc6bf575d46c9db1d
---
 libcutils/ashmem-dev.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index 6a27f9a2004b..5e01da9b890b 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -44,9 +44,6 @@
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 
-/* Will be added to UAPI once upstream change is merged */
-#define F_SEAL_FUTURE_WRITE 0x0010
-
 /*
  * The minimum vendor API level at and after which it is safe to use memfd.
  * This is to facilitate deprecation of ashmem.

From 3369fe9cbb0cce75ff61fbfaac5aaa83dff0b6a7 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 22 Sep 2023 14:51:26 +0000
Subject: [PATCH 0407/1487] Don't duplicate uapi ioprio constants.

This code is only used in init and vold, so I suspect all the
conditional compilation could be moved into the .bp file instead, but
I'm just trying to clean up duplication today...

Test: treehugger
Change-Id: I97013f5de41e109a0cc377400c396145aed569db
---
 libcutils/iosched_policy.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/libcutils/iosched_policy.cpp b/libcutils/iosched_policy.cpp
index 012c537ac688..f7c724da900b 100644
--- a/libcutils/iosched_policy.cpp
+++ b/libcutils/iosched_policy.cpp
@@ -24,8 +24,7 @@
 #include <unistd.h>
 
 #if defined(__ANDROID__)
-#define IOPRIO_WHO_PROCESS (1)
-#define IOPRIO_CLASS_SHIFT (13)
+#include <linux/ioprio.h>
 #include <sys/syscall.h>
 #define __android_unused
 #else

From f6a84e4462c8425869093f26f7e83bc1cb24ee70 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 22 Sep 2023 14:37:37 +0000
Subject: [PATCH 0408/1487] Remove Windows workaround in file not built for
 Windows.

Test: treehugger
Change-Id: I311cfbc9245cbe90ed6fc4fa379ff5b9abdf21e7
---
 libcutils/fs_config.cpp | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/libcutils/fs_config.cpp b/libcutils/fs_config.cpp
index 26ac576070fc..919be2ff2a0b 100644
--- a/libcutils/fs_config.cpp
+++ b/libcutils/fs_config.cpp
@@ -41,10 +41,6 @@
 
 #include "fs_config.h"
 
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
-
 using android::base::EndsWith;
 using android::base::StartsWith;
 
@@ -257,12 +253,12 @@ static int fs_config_open(int dir, int which, const char* target_out_path) {
         len = strip(target_out_path, len, "/");
         len = strip(target_out_path, len, "/system");
         if (asprintf(&name, "%.*s%s", (int)len, target_out_path, conf[which][dir]) != -1) {
-            fd = TEMP_FAILURE_RETRY(open(name, O_RDONLY | O_BINARY));
+            fd = TEMP_FAILURE_RETRY(open(name, O_RDONLY));
             free(name);
         }
     }
     if (fd < 0) {
-        fd = TEMP_FAILURE_RETRY(open(conf[which][dir], O_RDONLY | O_BINARY));
+        fd = TEMP_FAILURE_RETRY(open(conf[which][dir], O_RDONLY));
     }
     return fd;
 }

From b4987345ff1f97d529cc23b03ca73b58ff7a7e1b Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 21 Sep 2023 15:52:19 -0700
Subject: [PATCH 0409/1487] Only skip _16k/_64k kernel modules dirs on 4K
 builds

The initramfs.img from kernel builds do not store kernel modules under
_16k directory. Currently, init is programmed to only load kernel
modules from _16k dir if running on 16K page size kernel. Relax this
restriction so that booting on custom 16K kernel would work without
going through platform rebuild.

Test: th
Bug: 293313353
Bug: 300184677

Change-Id: I9ee3c74066ad9ec5127f1e8662f7c1273445994c
---
 init/first_stage_init.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index c6a287ab6278..e48fa155420f 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -239,8 +239,12 @@ bool LoadKernelModules(BootMode boot_mode, bool want_console, bool want_parallel
             module_dirs.emplace_back(entry->d_name);
             break;
         }
-        // Ignore _16k/_64k module dirs on 4K kernels
-        if (GetPageSizeSuffix(entry->d_name) != page_size_suffix) {
+        // Is a directory does not have page size suffix, it does not mean this directory is for 4K
+        // kernels. Certain 16K kernel builds put all modules in /lib/modules/`uname -r` without any
+        // suffix. Therefore, only ignore a directory if it has _16k/_64k suffix and the suffix does
+        // not match system page size.
+        const auto dir_page_size_suffix = GetPageSizeSuffix(entry->d_name);
+        if (!dir_page_size_suffix.empty() && dir_page_size_suffix != page_size_suffix) {
             continue;
         }
         int dir_major = 0, dir_minor = 0;

From 5cbcdfae4ec2cfd9ff1f90ecb363504d97b81875 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 21 Sep 2023 18:27:09 -0700
Subject: [PATCH 0410/1487] is_retrofit_device to work in bootloader

Changing is_retrofit_device() to work in bootloader. Previously flashall
flow was to boot into fastbootd and then  make a call to get
"super-image-name", however this does not work in bootloader. Since all
tasks are generated ahead of time, this old check will now fail and we
will fail to add the correct delete tasks in collectTasks(). This change
does make it so that is_retrofit check only works during fastboot
flashall + fastboot update (since this function is only used here,
nothing is currently affected).

To determine if a device is retrofit, it must satisfy two conditions -> Has
dynamic partitions && does not contain a super partition. The check for
if source has super_empty.img is sufficient for determining if a device
has dynamic partitions and if any single partition has
LP_PARTITION_ATTR_SLOT_SUFFIXED it is determined to be retrofit

Test: logs from fastboot update on sargo device confirms this check
returns true. Fastboot update on sargo
Bug: 300287332

Change-Id: Iadf5c56de51993a79307c60e45d6cc4988436f23
---
 fastboot/fastboot.cpp | 17 ++++++++++++-----
 fastboot/fastboot.h   |  2 +-
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 080ad4261a49..63f78435923e 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1413,12 +1413,19 @@ void do_for_partitions(const std::string& part, const std::string& slot,
     }
 }
 
-bool is_retrofit_device(fastboot::IFastBootDriver* fb) {
-    std::string value;
-    if (fb->GetVar("super-partition-name", &value) != fastboot::SUCCESS) {
+bool is_retrofit_device(const ImageSource* source) {
+    // Does this device use dynamic partitions at all?
+    std::vector<char> contents;
+    if (!source->ReadFile("super_empty.img", &contents)) {
         return false;
     }
-    return android::base::StartsWith(value, "system_");
+    auto metadata = android::fs_mgr::ReadFromImageBlob(contents.data(), contents.size());
+    for (const auto& partition : metadata->partitions) {
+        if (partition.attributes & LP_PARTITION_ATTR_SLOT_SUFFIXED) {
+            return true;
+        }
+    }
+    return false;
 }
 
 // Fetch a partition from the device to a given fd. This is a wrapper over FetchToFd to fetch
@@ -1876,7 +1883,7 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasksFromImageList() {
         // On these devices, secondary slots must be flashed as physical
         // partitions (otherwise they would not mount on first boot). To enforce
         // this, we delete any logical partitions for the "other" slot.
-        if (is_retrofit_device(fp_->fb)) {
+        if (is_retrofit_device(fp_->source)) {
             std::string partition_name = image->part_name + "_" + slot;
             if (image->IsSecondary() && should_flash_in_userspace(partition_name)) {
                 tasks.emplace_back(std::make_unique<DeleteTask>(fp_, partition_name));
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index 35deea7d2a96..eead82c92f8e 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -187,7 +187,7 @@ int64_t get_sparse_limit(int64_t size, const FlashingPlan* fp);
 std::vector<SparsePtr> resparse_file(sparse_file* s, int64_t max_size);
 
 bool supports_AB(fastboot::IFastBootDriver* fb);
-bool is_retrofit_device(fastboot::IFastBootDriver* fb);
+bool is_retrofit_device(const ImageSource* source);
 bool is_logical(const std::string& partition);
 void fb_perform_format(const std::string& partition, int skip_if_not_supported,
                        const std::string& type_override, const std::string& size_override,

From 810274071da6be521d9e198bf6fde64afd1fd077 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Sat, 23 Sep 2023 01:07:47 -0700
Subject: [PATCH 0411/1487] Create_cow: Hash of target blocks should not be
 stored.

Target block hash was in-correctly getting added to map thereby
overriding the source-hash.

Bug: 299011882
Test: Flash Pixel 6 Pro from A->B and from B->A
Change-Id: Ib3887c29cd6b8f2abd50e932273a5cfc2a096bd5
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
index 4e07fe3b3e0b..efb1035c2524 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
@@ -240,9 +240,11 @@ bool CreateSnapshot::ReadBlocks(off_t offset, const int skip_blocks, const uint6
             SHA256(bufptr, BLOCK_SZ, checksum);
             std::string hash = ToHexString(checksum, sizeof(checksum));
 
-            if (create_snapshot_patch_ && !WriteSnapshot(bufptr, blkindex, hash)) {
-                LOG(ERROR) << "WriteSnapshot failed for block: " << blkindex;
-                return false;
+            if (create_snapshot_patch_) {
+                if (!WriteSnapshot(bufptr, blkindex, hash)) {
+                    LOG(ERROR) << "WriteSnapshot failed for block: " << blkindex;
+                    return false;
+                }
             } else {
                 std::lock_guard<std::mutex> lock(source_block_hash_lock_);
                 {
@@ -256,7 +258,7 @@ bool CreateSnapshot::ReadBlocks(off_t offset, const int skip_blocks, const uint6
             num_blocks -= 1;
         }
 
-        file_offset += (skip_blocks * kBlockSizeToRead);
+        file_offset += (skip_blocks * to_read);
         if (file_offset >= dev_sz) {
             break;
         }

From 45d88d496eeef3bbdd0b54a2b0c1618b81d533a4 Mon Sep 17 00:00:00 2001
From: Kiyoung Kim <kiyoungkim@google.com>
Date: Thu, 21 Sep 2023 16:03:41 +0900
Subject: [PATCH 0412/1487] Do not check with vendor vndk version

Current libcutils checks if memfd is supported with vendor VNDK version,
but this is no longer valid if VNDK is deprecated. As we can assume that
any vendor using this code is supported as long as it is treblelized,
simplify logic to check if memfd is valid to vendor only with
'ro.treble.enabled' property.

Bug: 290159430
Test: Cuttlefish with VNDK deprecated worked without error from
libcutils

Change-Id: I351f0798da99cb4827bc3e424b63a2eaee5c7461
---
 libcutils/ashmem-dev.cpp | 57 +++++-----------------------------------
 1 file changed, 6 insertions(+), 51 deletions(-)

diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index 5e01da9b890b..410dbfd5e05f 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -44,13 +44,6 @@
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 
-/*
- * The minimum vendor API level at and after which it is safe to use memfd.
- * This is to facilitate deprecation of ashmem.
- */
-#define MIN_MEMFD_VENDOR_API_LEVEL 29
-#define MIN_MEMFD_VENDOR_API_LEVEL_CHAR 'Q'
-
 /* ashmem identity */
 static dev_t __ashmem_rdev;
 /*
@@ -88,55 +81,17 @@ static bool pin_deprecation_warn = true; /* Log the pin deprecation warning only
 
 /* Determine if vendor processes would be ok with memfd in the system:
  *
- * If VNDK is using older libcutils, don't use memfd. This is so that the
- * same shared memory mechanism is used across binder transactions between
- * vendor partition processes and system partition processes.
+ * Previously this function checked if memfd is supported by checking if
+ * vendor VNDK version is greater than Q. As we can assume all treblelized
+ * device using this code is up to date enough to use memfd, memfd is allowed
+ * if the device is treblelized.
  */
 static bool check_vendor_memfd_allowed() {
-    std::string vndk_version = android::base::GetProperty("ro.vndk.version", "");
-
-    if (vndk_version == "") {
-        ALOGE("memfd: ro.vndk.version not defined or invalid (%s), this is mandated since P.\n",
-              vndk_version.c_str());
-        return false;
-    }
-
-    /* No issues if vendor is targetting current Dessert */
-    if (vndk_version == "current") {
-        return false;
-    }
-
-    /* Check if VNDK version is a number and act on it */
-    char* p;
-    long int vers = strtol(vndk_version.c_str(), &p, 10);
-    if (*p == 0) {
-        if (vers < MIN_MEMFD_VENDOR_API_LEVEL) {
-            ALOGI("memfd: device VNDK version (%s) is < Q so using ashmem.\n",
-                  vndk_version.c_str());
-            return false;
-        }
+    static bool is_treblelized = android::base::GetBoolProperty("ro.treble.enabled", false);
 
-        return true;
-    }
-
-    // Non-numeric should be a single ASCII character. Characters after the
-    // first are ignored.
-    if (tolower(vndk_version[0]) < 'a' || tolower(vndk_version[0]) > 'z') {
-        ALOGE("memfd: ro.vndk.version not defined or invalid (%s), this is mandated since P.\n",
-              vndk_version.c_str());
-        return false;
-    }
-
-    if (tolower(vndk_version[0]) < tolower(MIN_MEMFD_VENDOR_API_LEVEL_CHAR)) {
-        ALOGI("memfd: device is using VNDK version (%s) which is less than Q. Use ashmem only.\n",
-              vndk_version.c_str());
-        return false;
-    }
-
-    return true;
+    return is_treblelized;
 }
 
-
 /* Determine if memfd can be supported. This is just one-time hardwork
  * which will be cached by the caller.
  */

From a6b5f94687676032028ae9c72d324bda9ced06f1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Thi=C3=A9baud=20Weksteen?= <tweek@google.com>
Date: Mon, 25 Sep 2023 16:07:47 +1000
Subject: [PATCH 0413/1487] Skip /metadata/sepolicy creation

Bug: 297794885
Test: presubmit
Change-Id: I93f94f319d0f86e1cad6f2a4912b5df3aae09cec
---
 rootdir/init.rc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 487e5da44953..8eec16c9b4f1 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -610,7 +610,6 @@ on post-fs
     restorecon_recursive /metadata/apex
 
     mkdir /metadata/staged-install 0770 root system
-    mkdir /metadata/sepolicy 0700 root root
 on late-fs
     # Ensure that tracefs has the correct permissions.
     # This does not work correctly if it is called in post-fs.

From 94ccdc06d0bb9725441c7340a2d1606bb32fa303 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 22 Sep 2023 18:44:28 +0000
Subject: [PATCH 0414/1487] Stop duplicating <linux/capabilities.h>.

This doesn't help the person who wants CAP_BPF, but we can fix that
better by adding it to our stale glibc (and our future switch to musl
will mean we'll never have similar problems again).

I think this just dates from when we still supported building the OS on
darwin, but those days are long gone, and I think this hack can be put
to rest now...

Test: treehugger
Change-Id: I3c2e56c68a5b00c1ad0aed422c6ce60886063f50
---
 libcutils/Android.bp                          |  10 +-
 .../private/android_filesystem_capability.h   | 119 ------------------
 libcutils/include/private/fs_config.h         |   4 -
 3 files changed, 6 insertions(+), 127 deletions(-)
 delete mode 100644 libcutils/include/private/android_filesystem_capability.h

diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index 55a8694ffc31..8ae7d9e5922f 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -171,11 +171,15 @@ cc_library {
                 "libasync_safe",
             ],
         },
+        linux: {
+            srcs: [
+                "canned_fs_config.cpp",
+                "fs_config.cpp",
+            ],
+        },
         not_windows: {
             srcs: libcutils_nonwindows_sources + [
                 "ashmem-host.cpp",
-                "canned_fs_config.cpp",
-                "fs_config.cpp",
                 "trace-host.cpp",
             ],
         },
@@ -201,8 +205,6 @@ cc_library {
             srcs: libcutils_nonwindows_sources + [
                 "android_reboot.cpp",
                 "ashmem-dev.cpp",
-                "canned_fs_config.cpp",
-                "fs_config.cpp",
                 "klog.cpp",
                 "partition_utils.cpp",
                 "qtaguid.cpp",
diff --git a/libcutils/include/private/android_filesystem_capability.h b/libcutils/include/private/android_filesystem_capability.h
deleted file mode 100644
index 0227b1de8702..000000000000
--- a/libcutils/include/private/android_filesystem_capability.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright (C) 2013 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.
- */
-
-/*
- * Taken from linux/capability.h, with minor modifications
- */
-
-#ifndef _SYSTEM_CORE_INCLUDE_PRIVATE_ANDROID_FILESYSTEM_CAPABILITY_H
-#define _SYSTEM_CORE_INCLUDE_PRIVATE_ANDROID_FILESYSTEM_CAPABILITY_H
-
-#include <stdint.h>
-
-#define __user
-#define __u32 uint32_t
-#define __le32 uint32_t
-
-#define _LINUX_CAPABILITY_VERSION_1 0x19980330
-#define _LINUX_CAPABILITY_U32S_1 1
-#define _LINUX_CAPABILITY_VERSION_2 0x20071026
-#define _LINUX_CAPABILITY_U32S_2 2
-#define _LINUX_CAPABILITY_VERSION_3 0x20080522
-#define _LINUX_CAPABILITY_U32S_3 2
-
-typedef struct __user_cap_header_struct {
-    __u32 version;
-    int pid;
-} __user* cap_user_header_t;
-
-typedef struct __user_cap_data_struct {
-    __u32 effective;
-    __u32 permitted;
-    __u32 inheritable;
-} __user* cap_user_data_t;
-
-#define VFS_CAP_REVISION_MASK 0xFF000000
-#define VFS_CAP_REVISION_SHIFT 24
-#define VFS_CAP_FLAGS_MASK ~VFS_CAP_REVISION_MASK
-#define VFS_CAP_FLAGS_EFFECTIVE 0x000001
-#define VFS_CAP_REVISION_1 0x01000000
-#define VFS_CAP_U32_1 1
-#define XATTR_CAPS_SZ_1 (sizeof(__le32) * (1 + 2 * VFS_CAP_U32_1))
-#define VFS_CAP_REVISION_2 0x02000000
-#define VFS_CAP_U32_2 2
-#define XATTR_CAPS_SZ_2 (sizeof(__le32) * (1 + 2 * VFS_CAP_U32_2))
-#define XATTR_CAPS_SZ XATTR_CAPS_SZ_2
-#define VFS_CAP_U32 VFS_CAP_U32_2
-#define VFS_CAP_REVISION VFS_CAP_REVISION_2
-
-struct vfs_cap_data {
-    __le32 magic_etc;
-    struct {
-        __le32 permitted;
-        __le32 inheritable;
-    } data[VFS_CAP_U32];
-};
-
-#define _LINUX_CAPABILITY_VERSION _LINUX_CAPABILITY_VERSION_1
-#define _LINUX_CAPABILITY_U32S _LINUX_CAPABILITY_U32S_1
-#define CAP_CHOWN 0
-#define CAP_DAC_OVERRIDE 1
-#define CAP_DAC_READ_SEARCH 2
-#define CAP_FOWNER 3
-#define CAP_FSETID 4
-#define CAP_KILL 5
-#define CAP_SETGID 6
-#define CAP_SETUID 7
-#define CAP_SETPCAP 8
-#define CAP_LINUX_IMMUTABLE 9
-#define CAP_NET_BIND_SERVICE 10
-#define CAP_NET_BROADCAST 11
-#define CAP_NET_ADMIN 12
-#define CAP_NET_RAW 13
-#define CAP_IPC_LOCK 14
-#define CAP_IPC_OWNER 15
-#define CAP_SYS_MODULE 16
-#define CAP_SYS_RAWIO 17
-#define CAP_SYS_CHROOT 18
-#define CAP_SYS_PTRACE 19
-#define CAP_SYS_PACCT 20
-#define CAP_SYS_ADMIN 21
-#define CAP_SYS_BOOT 22
-#define CAP_SYS_NICE 23
-#define CAP_SYS_RESOURCE 24
-#define CAP_SYS_TIME 25
-#define CAP_SYS_TTY_CONFIG 26
-#define CAP_MKNOD 27
-#define CAP_LEASE 28
-#define CAP_AUDIT_WRITE 29
-#define CAP_AUDIT_CONTROL 30
-#define CAP_SETFCAP 31
-#define CAP_MAC_OVERRIDE 32
-#define CAP_MAC_ADMIN 33
-#define CAP_SYSLOG 34
-#define CAP_WAKE_ALARM 35
-#define CAP_BLOCK_SUSPEND 36
-#define CAP_AUDIT_READ 37
-#define CAP_LAST_CAP CAP_AUDIT_READ
-#define cap_valid(x) ((x) >= 0 && (x) <= CAP_LAST_CAP)
-#define CAP_TO_INDEX(x) ((x) >> 5)
-#define CAP_TO_MASK(x) (1 << ((x)&31))
-
-#undef __user
-#undef __u32
-#undef __le32
-
-#endif
diff --git a/libcutils/include/private/fs_config.h b/libcutils/include/private/fs_config.h
index 8a9a1ffd7700..45f46e5494da 100644
--- a/libcutils/include/private/fs_config.h
+++ b/libcutils/include/private/fs_config.h
@@ -24,11 +24,7 @@
 #include <stdint.h>
 #include <sys/cdefs.h>
 
-#if defined(__BIONIC__)
 #include <linux/capability.h>
-#else  // defined(__BIONIC__)
-#include <private/android_filesystem_capability.h>
-#endif  // defined(__BIONIC__)
 
 /* Rules for directories and files has moved to system/code/libcutils/fs_config.c */
 

From 589c8d1e44cff96092c943f22cc10a9c23b81c01 Mon Sep 17 00:00:00 2001
From: Khyber Sen <khyber@google.com>
Date: Sun, 30 Jul 2023 05:31:46 +0000
Subject: [PATCH 0415/1487] rpc_binder: Change `trusty_tipc_fuzzer` to support
 multiple connections and messages

This changes `trusty_tipc_fuzzer` to be more like the existing binder rpc_fuzzer,
which opens and closes multiple connections and sends multiple messages in a single fuzz input.

The max number of connections is controlled by the define `TRUSTY_APP_MAX_CONNECTIONS`,
which defaults to `1`, thus keeping the existing behavior for now.

In the next CL, I'll add more fuzzers with `-DTRUSTY_APP_MAX_CONNECTIONS=10` instead.

Test: Build and run in trusty emulator
Change-Id: I9692e4d0295052a8da2204f63be9e52939e70ac3
---
 trusty/fuzz/tipc_fuzzer.cpp | 79 ++++++++++++++++++++++++++++---------
 1 file changed, 61 insertions(+), 18 deletions(-)

diff --git a/trusty/fuzz/tipc_fuzzer.cpp b/trusty/fuzz/tipc_fuzzer.cpp
index f265cedb698f..edc2a79a5260 100644
--- a/trusty/fuzz/tipc_fuzzer.cpp
+++ b/trusty/fuzz/tipc_fuzzer.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include <android-base/result.h>
+#include <fuzzer/FuzzedDataProvider.h>
 #include <stdlib.h>
 #include <trusty/coverage/coverage.h>
 #include <trusty/coverage/uuid.h>
@@ -23,6 +25,7 @@
 #include <iostream>
 #include <memory>
 
+using android::base::Result;
 using android::trusty::coverage::CoverageRecord;
 using android::trusty::fuzz::ExtraCounters;
 using android::trusty::fuzz::TrustyApp;
@@ -41,7 +44,14 @@ using android::trusty::fuzz::TrustyApp;
 #error "Binary file name must be parameterized using -DTRUSTY_APP_FILENAME."
 #endif
 
-static TrustyApp kTrustyApp(TIPC_DEV, TRUSTY_APP_PORT);
+#ifdef TRUSTY_APP_MAX_CONNECTIONS
+constexpr size_t MAX_CONNECTIONS = TRUSTY_APP_MAX_CONNECTIONS;
+#else
+constexpr size_t MAX_CONNECTIONS = 1;
+#endif
+
+static_assert(MAX_CONNECTIONS >= 1);
+
 static std::unique_ptr<CoverageRecord> record;
 
 extern "C" int LLVMFuzzerInitialize(int* /* argc */, char*** /* argv */) {
@@ -53,7 +63,8 @@ extern "C" int LLVMFuzzerInitialize(int* /* argc */, char*** /* argv */) {
     }
 
     /* Make sure lazy-loaded TAs have started and connected to coverage service. */
-    auto ret = kTrustyApp.Connect();
+    TrustyApp ta(TIPC_DEV, TRUSTY_APP_PORT);
+    auto ret = ta.Connect();
     if (!ret.ok()) {
         std::cerr << ret.error() << std::endl;
         exit(-1);
@@ -73,24 +84,56 @@ extern "C" int LLVMFuzzerInitialize(int* /* argc */, char*** /* argv */) {
     return 0;
 }
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-    static uint8_t buf[TIPC_MAX_MSG_SIZE];
+Result<void> testOneInput(FuzzedDataProvider& provider) {
+    std::vector<TrustyApp> trustyApps;
+
+    while (provider.remaining_bytes() > 0) {
+        if (trustyApps.size() < MAX_CONNECTIONS && provider.ConsumeBool()) {
+            auto& ta = trustyApps.emplace_back(TIPC_DEV, TRUSTY_APP_PORT);
+            const auto result = ta.Connect();
+            if (!result.ok()) {
+                return result;
+            }
+        } else {
+            const auto i = provider.ConsumeIntegralInRange<size_t>(0, trustyApps.size());
+            std::swap(trustyApps[i], trustyApps.back());
+
+            if (provider.ConsumeBool()) {
+                auto& ta = trustyApps.back();
+
+                const auto data = provider.ConsumeRandomLengthString();
+                auto result = ta.Write(data.data(), data.size());
+                if (!result.ok()) {
+                    return result;
+                }
+
+                std::array<uint8_t, TIPC_MAX_MSG_SIZE> buf;
+                result = ta.Read(buf.data(), buf.size());
+                if (!result.ok()) {
+                    return result;
+                }
+
+                // Reconnect to ensure that the service is still up.
+                ta.Disconnect();
+                result = ta.Connect();
+                if (!result.ok()) {
+                    std::cerr << result.error() << std::endl;
+                    android::trusty::fuzz::Abort();
+                    return result;
+                }
+            } else {
+                trustyApps.pop_back();
+            }
+        }
+    }
+    return {};
+}
 
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
     ExtraCounters counters(record.get());
     counters.Reset();
 
-    auto ret = kTrustyApp.Write(data, size);
-    if (ret.ok()) {
-        ret = kTrustyApp.Read(&buf, sizeof(buf));
-    }
-
-    // Reconnect to ensure that the service is still up
-    kTrustyApp.Disconnect();
-    ret = kTrustyApp.Connect();
-    if (!ret.ok()) {
-        std::cerr << ret.error() << std::endl;
-        android::trusty::fuzz::Abort();
-    }
-
-    return ret.ok() ? 0 : -1;
+    FuzzedDataProvider provider(data, size);
+    const auto result = testOneInput(provider);
+    return result.ok() ? 0 : -1;
 }

From d7c55110956b329b5d314aa851c923e7f1fe3e1e Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 26 Sep 2023 12:27:33 -0700
Subject: [PATCH 0416/1487] Add binary to write basic COW

Adding small binary to write a simple COW for version 2. We will then
use updated reader to make sure we can read this version 2 cow. Think it
would be a good idea to keep the binary here to see how exactly we
generated the cow (useful for debugging and if we ever need to recreate
this cow)

Test: m basic_v2_cow_writer
Change-Id: I28435025b7a8280fc5c4574876cc9110b391cb0e
---
 fs_mgr/libsnapshot/tools/Android.bp           |  23 +++++++++
 .../libsnapshot/tools/basic_v2_cow_writer.cpp |  48 ++++++++++++++++++
 fs_mgr/libsnapshot/tools/testdata/cow_v2      | Bin 0 -> 2105826 bytes
 3 files changed, 71 insertions(+)
 create mode 100644 fs_mgr/libsnapshot/tools/basic_v2_cow_writer.cpp
 create mode 100644 fs_mgr/libsnapshot/tools/testdata/cow_v2

diff --git a/fs_mgr/libsnapshot/tools/Android.bp b/fs_mgr/libsnapshot/tools/Android.bp
index cfa0cefe764c..0f0828699dc7 100644
--- a/fs_mgr/libsnapshot/tools/Android.bp
+++ b/fs_mgr/libsnapshot/tools/Android.bp
@@ -20,3 +20,26 @@ cc_binary {
 
     cflags: ["-Werror"],
 }
+
+
+cc_binary {
+    name: "basic_v2_cow_writer",
+    host_supported: true,
+    defaults: [
+        "fs_mgr_defaults",
+        "libsnapshot_cow_defaults",
+    ],
+
+    srcs: ["basic_v2_cow_writer.cpp"],
+
+    static_libs: [
+        "libsnapshot_cow",
+    ],
+
+    shared_libs: [
+        "libbase",
+        "liblog",
+    ],
+
+    cflags: ["-Werror"],
+}
diff --git a/fs_mgr/libsnapshot/tools/basic_v2_cow_writer.cpp b/fs_mgr/libsnapshot/tools/basic_v2_cow_writer.cpp
new file mode 100644
index 000000000000..59d35399aedb
--- /dev/null
+++ b/fs_mgr/libsnapshot/tools/basic_v2_cow_writer.cpp
@@ -0,0 +1,48 @@
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <libsnapshot/cow_compress.h>
+#include <libsnapshot/cow_format.h>
+#include <libsnapshot/cow_writer.h>
+#include <filesystem>
+
+#include "android-base/unique_fd.h"
+
+using namespace android::snapshot;
+
+// This writes a simple cow v2 file in the current directory. This file will serve as testdata for
+// ensuring our v3 cow reader will be able to read a cow file created by the v2 writer.
+//
+// WARNING: We should not be overriding this test file, as it will serve as historic marker for what
+// a device with old writer_v2 will write as a cow.
+void write_cow_v2() {
+    CowOptions options;
+    options.cluster_ops = 5;
+    options.num_merge_ops = 1;
+    std::string data = "This is some data, believe it";
+    data.resize(options.block_size, '\0');
+
+    char cwd_buffer[1024];
+    size_t cwd_buffer_size = sizeof(cwd_buffer);
+
+    // Get the current working directory path.
+    char* err = getcwd(cwd_buffer, cwd_buffer_size);
+    if (!err) {
+        LOG(ERROR) << "Couldn't get current directory";
+    }
+    android::base::unique_fd fd(open(strcat(cwd_buffer, "/cow_v2"), O_CREAT | O_RDWR, 0666));
+    if (fd.get() == -1) {
+        LOG(FATAL) << "couldn't open tmp_cow";
+    }
+    std::unique_ptr<ICowWriter> writer = CreateCowWriter(2, options, std::move(fd));
+    writer->AddCopy(0, 5);
+    writer->AddRawBlocks(2, data.data(), data.size());
+    writer->AddLabel(1);
+    writer->AddXorBlocks(50, data.data(), data.size(), 24, 10);
+    writer->AddZeroBlocks(5, 10);
+    writer->AddLabel(2);
+    writer->Finalize();
+}
+
+int main() {
+    write_cow_v2();
+}
diff --git a/fs_mgr/libsnapshot/tools/testdata/cow_v2 b/fs_mgr/libsnapshot/tools/testdata/cow_v2
new file mode 100644
index 0000000000000000000000000000000000000000..9f37dfc50c5550a2ed796d046ab52b3f6960d05b
GIT binary patch
literal 2105826
zcmeI&yGjE=6b9gvXuQM=L41HsV`b$N2tI&Kz&h$e0!oSmZLNK2oxMRaL=YPZe8X;L
z=if6s%ePfv#^Z<kr}xEOKO(MT5|<I9h(Q|l(%H14yU-ILK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1pZB+x3==2z3xYh(pk69DC&N{8P>nuoP$(%
z)8@mECheY4$3=5<GMg`pbSxLIW$`>+O|Of`@?~DWmBoD3&estjK!5-N0t5&UAV7cs
z0Rp=%;Q#+_e?M<efB*pk1PBlyK!5-N0t9{|u$PK9_64MIm8Jay8?DL?H<G6AD9iF^
wRky3T$5~yK4Yy<`Te8zE`)Q4{tgc$)Jj>SiN_6`uzT!4!?Z%0Vtp2aVZ!rKH(EtDd

literal 0
HcmV?d00001


From 301acae35b35d97171a4d316e02a90b3c24181e4 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 26 Sep 2023 16:43:41 -0700
Subject: [PATCH 0417/1487] Add copyright to libsnapshot/tools

Adding copyright to cow_benchmark + basic_v2_cow_writer

Test: th
Change-Id: Ic6c32b68bbeaa3c0c365f146ef4342356e13706a
---
 fs_mgr/libsnapshot/tools/basic_v2_cow_writer.cpp | 15 +++++++++++++++
 fs_mgr/libsnapshot/tools/cow_benchmark.cpp       | 16 +++++++++++++++-
 2 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/tools/basic_v2_cow_writer.cpp b/fs_mgr/libsnapshot/tools/basic_v2_cow_writer.cpp
index 59d35399aedb..72fb0f547b6a 100644
--- a/fs_mgr/libsnapshot/tools/basic_v2_cow_writer.cpp
+++ b/fs_mgr/libsnapshot/tools/basic_v2_cow_writer.cpp
@@ -1,3 +1,18 @@
+//
+// Copyright (C) 2023 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 <android-base/file.h>
 #include <android-base/logging.h>
 #include <libsnapshot/cow_compress.h>
diff --git a/fs_mgr/libsnapshot/tools/cow_benchmark.cpp b/fs_mgr/libsnapshot/tools/cow_benchmark.cpp
index da2b87922927..4d5e346c4cd4 100644
--- a/fs_mgr/libsnapshot/tools/cow_benchmark.cpp
+++ b/fs_mgr/libsnapshot/tools/cow_benchmark.cpp
@@ -1,4 +1,18 @@
-
+//
+// Copyright (C) 2023 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 <memory>
 
 #include <array>

From 7a8f82acbd3c24ce5ecc7e57d633576b74af30e9 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 21 Sep 2023 20:37:47 -0700
Subject: [PATCH 0418/1487] should_flash_in_userspace signature change

We should change should_flash_in_userspace to work without
$ANDROID_PRODUCT_OUT being set and fall back on $OUT directory when
source isn't specified

This also fixes the flashing issue of flashing retrofit devices without
$ANDROID_PRODUCT_OUT set. If we
call fastboot update on a retrofit device, copy_avb_footer will resize
buf->sz of secondary partitions to the partition size, causing us to
send the unsparsed payload to the device -> "Invalid Size" issue.

This is because secondary partitions are considered physical partitions
on retrofit devices && should_flash_in_userspace wouldn't work if
$ANDROID_PRODUCT_OUT is set, so our first return clause in
copy_avb_footer doesn't catch this edge case causing us to resize the
buf-> sz incorrectly.

Did some testing, and also observed a case where flashing is able to
succeed despite $ANDROID_PRODUCT_OUT not being set before, so there
might still be some other edge case that we are still missing.

Test: fastboot update on sargo without $ANDROID_PRODUCT_OUT

Change-Id: I0e4781d96709b712f7d71657ec0d16d99b90214d
---
 fastboot/fastboot.cpp | 48 ++++++++++++++++++++++++++-----------------
 fastboot/fastboot.h   |  2 +-
 fastboot/task.cpp     |  3 ++-
 3 files changed, 32 insertions(+), 21 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 63f78435923e..3ce81417958f 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1185,9 +1185,10 @@ static uint64_t get_partition_size(const std::string& partition) {
     return partition_size;
 }
 
-static void copy_avb_footer(const std::string& partition, struct fastboot_buffer* buf) {
+static void copy_avb_footer(const ImageSource* source, const std::string& partition,
+                            struct fastboot_buffer* buf) {
     if (buf->sz < AVB_FOOTER_SIZE || is_logical(partition) ||
-        should_flash_in_userspace(partition)) {
+        should_flash_in_userspace(source, partition)) {
         return;
     }
     // If overflows and negative, it should be < buf->sz.
@@ -1244,9 +1245,9 @@ void flash_partition_files(const std::string& partition, const std::vector<Spars
     }
 }
 
-static void flash_buf(const std::string& partition, struct fastboot_buffer* buf,
-                      const bool apply_vbmeta) {
-    copy_avb_footer(partition, buf);
+static void flash_buf(const ImageSource* source, const std::string& partition,
+                      struct fastboot_buffer* buf, const bool apply_vbmeta) {
+    copy_avb_footer(source, partition, buf);
 
     // Rewrite vbmeta if that's what we're flashing and modification has been requested.
     if (g_disable_verity || g_disable_verification) {
@@ -1524,7 +1525,7 @@ void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,
         fb->ResizePartition(pname, std::to_string(buf.image_size));
     }
     std::string flash_pname = repack_ramdisk(pname, &buf, fp->fb);
-    flash_buf(flash_pname, &buf, apply_vbmeta);
+    flash_buf(fp->source, flash_pname, &buf, apply_vbmeta);
 }
 
 // Sets slot_override as the active slot. If slot_override is blank,
@@ -1807,9 +1808,9 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasks() {
         tasks = CollectTasksFromImageList();
     }
     if (fp_->exclude_dynamic_partitions) {
-        auto is_non_static_flash_task = [](const auto& task) -> bool {
+        auto is_non_static_flash_task = [&](const auto& task) -> bool {
             if (auto flash_task = task->AsFlashTask()) {
-                if (!should_flash_in_userspace(flash_task->GetPartitionAndSlot())) {
+                if (!should_flash_in_userspace(fp_->source, flash_task->GetPartitionAndSlot())) {
                     return false;
                 }
             }
@@ -1885,7 +1886,7 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasksFromImageList() {
         // this, we delete any logical partitions for the "other" slot.
         if (is_retrofit_device(fp_->source)) {
             std::string partition_name = image->part_name + "_" + slot;
-            if (image->IsSecondary() && should_flash_in_userspace(partition_name)) {
+            if (image->IsSecondary() && should_flash_in_userspace(fp_->source, partition_name)) {
                 tasks.emplace_back(std::make_unique<DeleteTask>(fp_, partition_name));
             }
         }
@@ -2087,7 +2088,8 @@ void fb_perform_format(const std::string& partition, int skip_if_not_supported,
     if (!load_buf_fd(std::move(fd), &buf, fp)) {
         die("Cannot read image: %s", strerror(errno));
     }
-    flash_buf(partition, &buf, is_vbmeta_partition(partition));
+
+    flash_buf(fp->source, partition, &buf, is_vbmeta_partition(partition));
     return;
 
 failed:
@@ -2101,18 +2103,26 @@ void fb_perform_format(const std::string& partition, int skip_if_not_supported,
     }
 }
 
-bool should_flash_in_userspace(const std::string& partition_name) {
-    if (!get_android_product_out()) {
-        return false;
-    }
-    auto path = find_item_given_name("super_empty.img");
-    if (path.empty() || access(path.c_str(), R_OK)) {
-        return false;
+bool should_flash_in_userspace(const ImageSource* source, const std::string& partition_name) {
+    if (!source) {
+        if (!get_android_product_out()) {
+            return false;
+        }
+        auto path = find_item_given_name("super_empty.img");
+        if (path.empty() || access(path.c_str(), R_OK)) {
+            return false;
+        }
+        auto metadata = android::fs_mgr::ReadFromImageFile(path);
+        if (!metadata) {
+            return false;
+        }
+        return should_flash_in_userspace(*metadata.get(), partition_name);
     }
-    auto metadata = android::fs_mgr::ReadFromImageFile(path);
-    if (!metadata) {
+    std::vector<char> contents;
+    if (!source->ReadFile("super_empty.img", &contents)) {
         return false;
     }
+    auto metadata = android::fs_mgr::ReadFromImageBlob(contents.data(), contents.size());
     return should_flash_in_userspace(*metadata.get(), partition_name);
 }
 
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index eead82c92f8e..4859cebc2895 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -148,7 +148,7 @@ class LocalImageSource final : public ImageSource {
 };
 
 char* get_android_product_out();
-bool should_flash_in_userspace(const std::string& partition_name);
+bool should_flash_in_userspace(const ImageSource* source, const std::string& partition_name);
 bool is_userspace_fastboot();
 void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,
               const FlashingPlan* fp);
diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index f13dd55b35be..4b2b9e316cc8 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -41,7 +41,8 @@ bool FlashTask::IsDynamicParitition(const ImageSource* source, const FlashTask*
 
 void FlashTask::Run() {
     auto flash = [&](const std::string& partition) {
-        if (should_flash_in_userspace(partition) && !is_userspace_fastboot() && !fp_->force_flash) {
+        if (should_flash_in_userspace(fp_->source, partition) && !is_userspace_fastboot() &&
+            !fp_->force_flash) {
             die("The partition you are trying to flash is dynamic, and "
                 "should be flashed via fastbootd. Please run:\n"
                 "\n"

From 566f1371e4d6ee2b7bc2d027c93d51d08e8b5c20 Mon Sep 17 00:00:00 2001
From: Kiyoung Kim <kiyoungkim@google.com>
Date: Wed, 27 Sep 2023 10:02:23 +0900
Subject: [PATCH 0419/1487] Remove libbinder_rpc_unstable from system required
 libs

libbinder_rpc_unstable is in the list of system required libs, but the
library is already located in the system/{LIB}, and this creates link to
the self namespace. Remove libbinder_rpc_unstable from system required
libs as it doesn't make sense to have require and provide same library
in a single image.

Bug: 298333253
Test: Cuttlefish build and boot succeded
Change-Id: Idb40e1dbc1053d4882093c188a36b2cc8d86e918
---
 rootdir/etc/linker.config.json | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/rootdir/etc/linker.config.json b/rootdir/etc/linker.config.json
index 47f77b198cc0..d72ac66813dd 100644
--- a/rootdir/etc/linker.config.json
+++ b/rootdir/etc/linker.config.json
@@ -11,9 +11,6 @@
     "libsigchain.so",
     // TODO(b/122876336): Remove libpac.so once it's migrated to Webview
     "libpac.so",
-    // TODO(b/184872979): Remove libbinder_rpc_unstable.so once stablized and
-    // added to libbinder_ndk.
-    "libbinder_rpc_unstable.so",
     // TODO(b/120786417 or b/134659294): libicuuc.so
     // and libicui18n.so are kept for app compat.
     "libicui18n.so",

From 6a12d23eabdfba1bf99016da328b515ae2b5559f Mon Sep 17 00:00:00 2001
From: Snehal <snehalreddy@google.com>
Date: Wed, 27 Sep 2023 12:08:45 +0000
Subject: [PATCH 0420/1487] Remove ambgiuity in format specifier

Bug: 302163991

Test: m trusty-coverage-controller

Change-Id: I26318eeb4a6770bd01d3c677ca3cf5c76ce33fa0
---
 trusty/utils/coverage-controller/controller.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/utils/coverage-controller/controller.cpp b/trusty/utils/coverage-controller/controller.cpp
index 0047046d7566..381a45285c2c 100644
--- a/trusty/utils/coverage-controller/controller.cpp
+++ b/trusty/utils/coverage-controller/controller.cpp
@@ -54,7 +54,7 @@ void Controller::run(std::string output_dir) {
             if (complete_cnt != counters[index] && start_cnt == complete_cnt) {
                 WRITE_ONCE(control->cntrl_flags, FLAG_NONE);
                 std::string filename;
-                filename = android::base::StringPrintf("/%s.%lu.profraw",
+                filename = android::base::StringPrintf("/%s.%" PRIu64 ".profraw",
                                                     uuid_list_[index].c_str(),
                                                     counters[index]);
                 filename.insert(0, output_dir);

From 5ebc6573863624c98b42cff59244f94614b3e23f Mon Sep 17 00:00:00 2001
From: Steve Muckle <smuckle@google.com>
Date: Wed, 16 Aug 2023 17:16:50 +0000
Subject: [PATCH 0421/1487] disable sync_on_suspend when flag is set

Bug: 285395636
Test: suspend/resume testing
Change-Id: I2d97d8366b864ab3e72d7ae38a0f4906dc74ec6f
---
 rootdir/init.rc | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 8eec16c9b4f1..fb6473666d7c 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1056,6 +1056,9 @@ on boot && property:ro.config.low_ram=true
     write /proc/sys/vm/dirty_expire_centisecs 200
     write /proc/sys/vm/dirty_background_ratio  5
 
+on boot && property:suspend.disable_sync_on_suspend=true
+    write /sys/power/sync_on_suspend 0
+
 on boot
     # basic network init
     ifup lo

From 69f57f98c5ee9b314405c6d85e08ccb5c6a0dd4c Mon Sep 17 00:00:00 2001
From: Dan Shi <dshi@google.com>
Date: Thu, 28 Sep 2023 06:32:29 +0000
Subject: [PATCH 0422/1487] Keep fs_mgr_vendor_overlay_test in internal cf.

Bug: 302382476
Change-Id: I369927033b407660d2c0e7bdb85494c826c0b406
Test: presubmit
---
 fs_mgr/TEST_MAPPING | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index 169496929bdd..37b4988dcee2 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -16,7 +16,8 @@
       "name": "fiemap_writer_test"
     },
     {
-      "name": "fs_mgr_vendor_overlay_test"
+      "name": "fs_mgr_vendor_overlay_test",
+      "keywords": ["internal"]
     },
     {
       "name": "vts_libsnapshot_test"

From 250aa5ed7218219b4b62dbaf37655a7eb40e8efa Mon Sep 17 00:00:00 2001
From: wuhaitao3 <wuhaitao3@xiaomi.corp-partner.google.com>
Date: Thu, 28 Sep 2023 14:20:40 +0800
Subject: [PATCH 0423/1487] Adjust unit tests for supporting chain partition
 with no ab

Test: libfs_avb_internal_test
      libfs_avb_test
Signed-off-by: wuhaitao3 <wuhaitao3@xiaomi.corp-partner.google.com>
Change-Id: I5f91510e72776ed2ed53756ae94a87b1417ae1a5
---
 fs_mgr/libfs_avb/tests/avb_util_test.cpp | 11 ++++++++---
 fs_mgr/libfs_avb/tests/basic_test.cpp    |  4 +++-
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libfs_avb/tests/avb_util_test.cpp b/fs_mgr/libfs_avb/tests/avb_util_test.cpp
index 2e34920124c9..ee83cda38d79 100644
--- a/fs_mgr/libfs_avb/tests/avb_util_test.cpp
+++ b/fs_mgr/libfs_avb/tests/avb_util_test.cpp
@@ -655,10 +655,12 @@ TEST_F(AvbUtilTest, VerifyVBMetaDataWithoutFooter) {
             "      Partition Name:          boot\n"
             "      Rollback Index Location: 1\n"
             "      Public key (sha1):       cdbb77177f731920bbe0a0f94f84d9038ae0617d\n"
+            "      Flags:                   0\n"
             "    Chain Partition descriptor:\n"
             "      Partition Name:          system\n"
             "      Rollback Index Location: 2\n"
-            "      Public key (sha1):       2597c218aae470a130f61162feaae70afd97f011\n",
+            "      Public key (sha1):       2597c218aae470a130f61162feaae70afd97f011\n"
+            "      Flags:                   0\n",
             InfoImage("vbmeta.img"));
 
     android::base::unique_fd fd(open(vbmeta_path.value().c_str(), O_RDONLY | O_CLOEXEC));
@@ -876,10 +878,12 @@ TEST_F(AvbUtilTest, GetChainPartitionInfo) {
             "      Partition Name:          boot\n"
             "      Rollback Index Location: 1\n"
             "      Public key (sha1):       cdbb77177f731920bbe0a0f94f84d9038ae0617d\n"
+            "      Flags:                   0\n"
             "    Chain Partition descriptor:\n"
             "      Partition Name:          vbmeta_system\n"
             "      Rollback Index Location: 2\n"
-            "      Public key (sha1):       2597c218aae470a130f61162feaae70afd97f011\n",
+            "      Public key (sha1):       2597c218aae470a130f61162feaae70afd97f011\n"
+            "      Flags:                   0\n",
             InfoImage("vbmeta.img"));
 
     bool fatal_error = false;
@@ -909,7 +913,8 @@ TEST_F(AvbUtilTest, GetChainPartitionInfo) {
             "    Chain Partition descriptor:\n"
             "      Partition Name:          system\n"
             "      Rollback Index Location: 3\n"
-            "      Public key (sha1):       2597c218aae470a130f61162feaae70afd97f011\n",
+            "      Public key (sha1):       2597c218aae470a130f61162feaae70afd97f011\n"
+            "      Flags:                   0\n",
             InfoImage("vbmeta_system.img"));
 
     chained_descriptors = GetChainPartitionInfo(LoadVBMetaData("vbmeta_system.img"), &fatal_error);
diff --git a/fs_mgr/libfs_avb/tests/basic_test.cpp b/fs_mgr/libfs_avb/tests/basic_test.cpp
index 1c47c0758692..d49affb424d7 100644
--- a/fs_mgr/libfs_avb/tests/basic_test.cpp
+++ b/fs_mgr/libfs_avb/tests/basic_test.cpp
@@ -268,10 +268,12 @@ TEST_F(BaseFsAvbTest, GenerateVBMetaImageWithChainDescriptors) {
             "      Partition Name:          boot\n"
             "      Rollback Index Location: 1\n"
             "      Public key (sha1):       cdbb77177f731920bbe0a0f94f84d9038ae0617d\n"
+            "      Flags:                   0\n"
             "    Chain Partition descriptor:\n"
             "      Partition Name:          system\n"
             "      Rollback Index Location: 2\n"
-            "      Public key (sha1):       2597c218aae470a130f61162feaae70afd97f011\n",
+            "      Public key (sha1):       2597c218aae470a130f61162feaae70afd97f011\n"
+            "      Flags:                   0\n",
             InfoImage("vbmeta.img"));
 }
 

From 041afb2883b804d7fab52ae606f20786ed68a0e3 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 28 Sep 2023 10:41:21 -0700
Subject: [PATCH 0424/1487] Add the missing copyright headers to the .S files.

Dates taken from `git log --follow`.

Test: treehugger
Change-Id: I80e9ea6aa01f8e0553295453749afcbc3af827f9
---
 debuggerd/crasher/arm/crashglue.S     | 16 ++++++++++++++++
 debuggerd/crasher/arm64/crashglue.S   | 16 ++++++++++++++++
 debuggerd/crasher/riscv64/crashglue.S | 16 ++++++++++++++++
 debuggerd/crasher/x86/crashglue.S     | 16 ++++++++++++++++
 debuggerd/crasher/x86_64/crashglue.S  | 16 ++++++++++++++++
 5 files changed, 80 insertions(+)

diff --git a/debuggerd/crasher/arm/crashglue.S b/debuggerd/crasher/arm/crashglue.S
index 0def8aee3f7b..3001ca19e9b7 100644
--- a/debuggerd/crasher/arm/crashglue.S
+++ b/debuggerd/crasher/arm/crashglue.S
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2006, 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.
+ */
+
 .globl crash1
 .type crash1, %function
 crash1:
diff --git a/debuggerd/crasher/arm64/crashglue.S b/debuggerd/crasher/arm64/crashglue.S
index c56e19a388c7..90ba9a1eb2b0 100644
--- a/debuggerd/crasher/arm64/crashglue.S
+++ b/debuggerd/crasher/arm64/crashglue.S
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2013, 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.
+ */
+
 .globl crash1
 .type crash1, %function
 crash1:
diff --git a/debuggerd/crasher/riscv64/crashglue.S b/debuggerd/crasher/riscv64/crashglue.S
index f179e336810f..804a511b917f 100644
--- a/debuggerd/crasher/riscv64/crashglue.S
+++ b/debuggerd/crasher/riscv64/crashglue.S
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2022, 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.
+ */
+
 .globl crash1
 crash1:
 	.cfi_startproc
diff --git a/debuggerd/crasher/x86/crashglue.S b/debuggerd/crasher/x86/crashglue.S
index 453035bf81ab..fe7c6480a448 100644
--- a/debuggerd/crasher/x86/crashglue.S
+++ b/debuggerd/crasher/x86/crashglue.S
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2010, 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.
+ */
+
 .globl crash1
 crash1:
 	movl $0xa5a50000, %eax
diff --git a/debuggerd/crasher/x86_64/crashglue.S b/debuggerd/crasher/x86_64/crashglue.S
index c3d39c483f3c..ae13aa7e61eb 100644
--- a/debuggerd/crasher/x86_64/crashglue.S
+++ b/debuggerd/crasher/x86_64/crashglue.S
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2010, 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.
+ */
+
 .globl crash1
 crash1:
 	movl $0xa5a50000, %eax

From 5eea7e384bb1c2b99622608c327832344937a9ec Mon Sep 17 00:00:00 2001
From: Bradley Furman <bfurman@google.com>
Date: Fri, 29 Sep 2023 21:16:57 +0000
Subject: [PATCH 0425/1487] Update the fastboot command size from 64 to 4096 to
 cover the changes from
 https://android-review.git.corp.google.com/c/platform/system/core/+/2214970

BUG=182864081

Change-Id: I6766647e53d777fd61df6e40cfefb45c7b138c77
---
 fastboot/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fastboot/README.md b/fastboot/README.md
index 28e623ca798b..6996d4a00247 100644
--- a/fastboot/README.md
+++ b/fastboot/README.md
@@ -25,7 +25,7 @@ Linux, macOS, or Windows.
 ## Transport and Framing
 
 1. Host sends a command, which is an ascii string in a single
-   packet no greater than 64 bytes.
+   packet no greater than 4096 bytes.
 
 2. Client response with a single packet no greater than 256 bytes.
    The first four bytes of the response are "OKAY", "FAIL", "DATA",

From 7d46c3fd7acae054ba5214a7dba99af004c99cad Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 29 Sep 2023 22:45:59 +0000
Subject: [PATCH 0426/1487] Remove obsolete <linux/capabilities.h> workarounds.

We've updated the glibc header (and musl will just use the bionic uapi
headers), so this is obsolete (and getting in the way of someone trying
to use the PERFMON capability).

Test: treehugger
Change-Id: Ife7ee076179e1db6246738aa41c2b82bd8546265
---
 init/capabilities.cpp |  6 ------
 init/capabilities.h   | 11 -----------
 2 files changed, 17 deletions(-)

diff --git a/init/capabilities.cpp b/init/capabilities.cpp
index ab6ff03ef623..0e2cd2acc3e7 100644
--- a/init/capabilities.cpp
+++ b/init/capabilities.cpp
@@ -66,18 +66,12 @@ static const std::map<std::string, int> cap_map = {
         CAP_MAP_ENTRY(WAKE_ALARM),
         CAP_MAP_ENTRY(BLOCK_SUSPEND),
         CAP_MAP_ENTRY(AUDIT_READ),
-#if defined(__BIONIC__)
         CAP_MAP_ENTRY(PERFMON),
         CAP_MAP_ENTRY(BPF),
         CAP_MAP_ENTRY(CHECKPOINT_RESTORE),
-#endif
 };
 
-#if defined(__BIONIC__)
 static_assert(CAP_LAST_CAP == CAP_CHECKPOINT_RESTORE, "CAP_LAST_CAP is not CAP_CHECKPOINT_RESTORE");
-#else
-static_assert(CAP_LAST_CAP == CAP_AUDIT_READ, "CAP_LAST_CAP is not CAP_AUDIT_READ");
-#endif
 
 static bool ComputeCapAmbientSupported() {
 #if defined(__ANDROID__)
diff --git a/init/capabilities.h b/init/capabilities.h
index 891e0ac982cd..fc80c9864f7a 100644
--- a/init/capabilities.h
+++ b/init/capabilities.h
@@ -21,17 +21,6 @@
 #include <string>
 #include <type_traits>
 
-#if !defined(__ANDROID__)
-#ifndef CAP_BLOCK_SUSPEND
-#define CAP_BLOCK_SUSPEND 36
-#endif
-#ifndef CAP_AUDIT_READ
-#define CAP_AUDIT_READ 37
-#endif
-#undef CAP_LAST_CAP
-#define CAP_LAST_CAP CAP_AUDIT_READ
-#endif
-
 namespace android {
 namespace init {
 

From ab4c9621d420f92031d1171ed83813280843c914 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Mon, 2 Oct 2023 11:02:18 -0700
Subject: [PATCH 0427/1487] Log the CowOperation when decompression failed

Test: th
Bug: 302992208
Change-Id: I617062d75a79ae73dfdff13c2e9d2a62c5dfcfc0
---
 .../snapuserd/dm-snapshot-merge/snapuserd_worker.cpp           | 2 +-
 fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp  | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
index 559dcc793e98..571b352385a0 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
@@ -103,7 +103,7 @@ bool WorkerThread::ProcessReplaceOp(const CowOperation* cow_op) {
     ssize_t rv = reader_->ReadData(cow_op, buffer, BLOCK_SZ);
     if (rv != BLOCK_SZ) {
         SNAP_LOG(ERROR) << "ProcessReplaceOp failed for block " << cow_op->new_block
-                        << ", return = " << rv;
+                        << ", return = " << rv << ", COW operation = " << *cow_op;
         return false;
     }
     return true;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index b9ecfa5b3235..5cb13e8bcd43 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -283,7 +283,8 @@ bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
                 // We found the sector in mapping. Check the type of COW OP and
                 // process it.
                 if (!ProcessCowOp(it->second, buffer)) {
-                    SNAP_LOG(ERROR) << "ProcessCowOp failed";
+                    SNAP_LOG(ERROR)
+                            << "ProcessCowOp failed, sector = " << sector << ", size = " << sz;
                     return false;
                 }
 

From 9dabc9ef320ce3651dda4db4881cdb49686c4f52 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Mon, 2 Oct 2023 17:02:05 -0700
Subject: [PATCH 0428/1487] Change source to be a unique_ptr.

The current code keeps a pointer to a local variable which doesn't
work too well. Change this to a unique_ptr and allocate the source
object that will be used instead.

Test: All unit tests pass.
Test: fastboot -w flashall on a mokey which crashed without this change.
Change-Id: Ief5437374181e514928c45dd540b42898901a137
---
 fastboot/fastboot.cpp  | 20 ++++++++++----------
 fastboot/fastboot.h    |  3 ++-
 fastboot/task.cpp      |  4 ++--
 fastboot/task_test.cpp | 18 +++++++-----------
 4 files changed, 21 insertions(+), 24 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 3ce81417958f..b12e584d6506 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1525,7 +1525,7 @@ void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,
         fb->ResizePartition(pname, std::to_string(buf.image_size));
     }
     std::string flash_pname = repack_ramdisk(pname, &buf, fp->fb);
-    flash_buf(fp->source, flash_pname, &buf, apply_vbmeta);
+    flash_buf(fp->source.get(), flash_pname, &buf, apply_vbmeta);
 }
 
 // Sets slot_override as the active slot. If slot_override is blank,
@@ -1679,7 +1679,7 @@ bool AddResizeTasks(const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>*
     }
     for (size_t i = 0; i < tasks->size(); i++) {
         if (auto flash_task = tasks->at(i)->AsFlashTask()) {
-            if (FlashTask::IsDynamicParitition(fp->source, flash_task)) {
+            if (FlashTask::IsDynamicParitition(fp->source.get(), flash_task)) {
                 if (!loc) {
                     loc = i;
                 }
@@ -1810,7 +1810,8 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasks() {
     if (fp_->exclude_dynamic_partitions) {
         auto is_non_static_flash_task = [&](const auto& task) -> bool {
             if (auto flash_task = task->AsFlashTask()) {
-                if (!should_flash_in_userspace(fp_->source, flash_task->GetPartitionAndSlot())) {
+                if (!should_flash_in_userspace(fp_->source.get(),
+                                               flash_task->GetPartitionAndSlot())) {
                     return false;
                 }
             }
@@ -1884,9 +1885,10 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasksFromImageList() {
         // On these devices, secondary slots must be flashed as physical
         // partitions (otherwise they would not mount on first boot). To enforce
         // this, we delete any logical partitions for the "other" slot.
-        if (is_retrofit_device(fp_->source)) {
+        if (is_retrofit_device(fp_->source.get())) {
             std::string partition_name = image->part_name + "_" + slot;
-            if (image->IsSecondary() && should_flash_in_userspace(fp_->source, partition_name)) {
+            if (image->IsSecondary() &&
+                should_flash_in_userspace(fp_->source.get(), partition_name)) {
                 tasks.emplace_back(std::make_unique<DeleteTask>(fp_, partition_name));
             }
         }
@@ -1949,8 +1951,7 @@ static void do_update(const char* filename, FlashingPlan* fp) {
     if (error != 0) {
         die("failed to open zip file '%s': %s", filename, ErrorCodeString(error));
     }
-    ZipImageSource zp = ZipImageSource(zip);
-    fp->source = &zp;
+    fp->source.reset(new ZipImageSource(zip));
     FlashAllTool tool(fp);
     tool.Flash();
 
@@ -1971,8 +1972,7 @@ unique_fd LocalImageSource::OpenFile(const std::string& name) const {
 }
 
 static void do_flashall(FlashingPlan* fp) {
-    LocalImageSource s = LocalImageSource();
-    fp->source = &s;
+    fp->source.reset(new LocalImageSource());
     FlashAllTool tool(fp);
     tool.Flash();
 }
@@ -2089,7 +2089,7 @@ void fb_perform_format(const std::string& partition, int skip_if_not_supported,
         die("Cannot read image: %s", strerror(errno));
     }
 
-    flash_buf(fp->source, partition, &buf, is_vbmeta_partition(partition));
+    flash_buf(fp->source.get(), partition, &buf, is_vbmeta_partition(partition));
     return;
 
 failed:
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index 4859cebc2895..cd7bc2d982b6 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -28,6 +28,7 @@
 #pragma once
 
 #include <functional>
+#include <memory>
 #include <string>
 #include "fastboot_driver_interface.h"
 #include "filesystem.h"
@@ -89,7 +90,7 @@ struct FlashingPlan {
     // If the image uses the default slot, or the user specified "all", then
     // the paired string will be empty. If the image requests a specific slot
     // (for example, system_other) it is specified instead.
-    ImageSource* source;
+    std::unique_ptr<ImageSource> source;
     bool wants_wipe = false;
     bool skip_reboot = false;
     bool wants_set_active = false;
diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index 4b2b9e316cc8..25c5a6e6bb30 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -41,7 +41,7 @@ bool FlashTask::IsDynamicParitition(const ImageSource* source, const FlashTask*
 
 void FlashTask::Run() {
     auto flash = [&](const std::string& partition) {
-        if (should_flash_in_userspace(fp_->source, partition) && !is_userspace_fastboot() &&
+        if (should_flash_in_userspace(fp_->source.get(), partition) && !is_userspace_fastboot() &&
             !fp_->force_flash) {
             die("The partition you are trying to flash is dynamic, and "
                 "should be flashed via fastbootd. Please run:\n"
@@ -174,7 +174,7 @@ std::unique_ptr<OptimizedFlashSuperTask> OptimizedFlashSuperTask::Initialize(
         LOG(VERBOSE) << "Cannot optimize flashing super for all slots";
         return nullptr;
     }
-    if (!CanOptimize(fp->source, tasks)) {
+    if (!CanOptimize(fp->source.get(), tasks)) {
         return nullptr;
     }
 
diff --git a/fastboot/task_test.cpp b/fastboot/task_test.cpp
index 1e25b6f63e39..9cde1a81e9a8 100644
--- a/fastboot/task_test.cpp
+++ b/fastboot/task_test.cpp
@@ -192,8 +192,7 @@ TEST_F(ParseTest, CorrectTaskLists) {
         GTEST_SKIP();
     }
 
-    LocalImageSource s;
-    fp->source = &s;
+    fp->source.reset(new LocalImageSource);
     fp->sparse_limit = std::numeric_limits<int64_t>::max();
 
     fastboot::MockFastbootDriver fb;
@@ -239,8 +238,7 @@ TEST_F(ParseTest, IsDynamicParitiontest) {
         GTEST_SKIP();
     }
 
-    LocalImageSource s;
-    fp->source = &s;
+    fp->source.reset(new LocalImageSource);
 
     fastboot::MockFastbootDriver fb;
     fp->fb = &fb;
@@ -260,7 +258,7 @@ TEST_F(ParseTest, IsDynamicParitiontest) {
                 ParseFastbootInfoLine(fp.get(), android::base::Tokenize(test.first, " "));
         auto flash_task = task->AsFlashTask();
         ASSERT_FALSE(flash_task == nullptr);
-        ASSERT_EQ(FlashTask::IsDynamicParitition(fp->source, flash_task), test.second);
+        ASSERT_EQ(FlashTask::IsDynamicParitition(fp->source.get(), flash_task), test.second);
     }
 }
 
@@ -269,8 +267,7 @@ TEST_F(ParseTest, CanOptimizeTest) {
         GTEST_SKIP();
     }
 
-    LocalImageSource s;
-    fp->source = &s;
+    fp->source.reset(new LocalImageSource);
     fp->sparse_limit = std::numeric_limits<int64_t>::max();
 
     fastboot::MockFastbootDriver fb;
@@ -301,7 +298,7 @@ TEST_F(ParseTest, CanOptimizeTest) {
     for (auto& test : patternmatchtest) {
         std::vector<std::unique_ptr<Task>> tasks = ParseFastbootInfo(fp.get(), test.first);
         tasks.erase(std::remove_if(tasks.begin(), tasks.end(), remove_if_callback), tasks.end());
-        ASSERT_EQ(OptimizedFlashSuperTask::CanOptimize(fp->source, tasks), test.second);
+        ASSERT_EQ(OptimizedFlashSuperTask::CanOptimize(fp->source.get(), tasks), test.second);
     }
 }
 
@@ -312,8 +309,7 @@ TEST_F(ParseTest, OptimizedFlashSuperPatternMatchTest) {
         GTEST_SKIP();
     }
 
-    LocalImageSource s;
-    fp->source = &s;
+    fp->source.reset(new LocalImageSource);
     fp->sparse_limit = std::numeric_limits<int64_t>::max();
 
     fastboot::MockFastbootDriver fb;
@@ -362,7 +358,7 @@ TEST_F(ParseTest, OptimizedFlashSuperPatternMatchTest) {
                     contains_optimized_task = true;
                 }
                 if (auto flash_task = task->AsFlashTask()) {
-                    if (FlashTask::IsDynamicParitition(fp->source, flash_task)) {
+                    if (FlashTask::IsDynamicParitition(fp->source.get(), flash_task)) {
                         return false;
                     }
                 }

From 5248c5d72ad2a14f3426b7872b8867f97818650f Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Tue, 3 Oct 2023 17:13:10 +0000
Subject: [PATCH 0429/1487] libvndksupport: log sphal namespace fallback

If someone is trying to use the sphal namespace, but it
isn't available, we should probably fix this code or add an
sphal namespace there or similar. Add log for more clarity.

Bug: N/A
Test: boot cuttlefish, this doesn't get logged
Change-Id: I2fd2cddc90f529218c99ede8daf2891d84ceb94c
---
 libvndksupport/linker.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libvndksupport/linker.cpp b/libvndksupport/linker.cpp
index ad4fb31ef3fb..b2b257e87931 100644
--- a/libvndksupport/linker.cpp
+++ b/libvndksupport/linker.cpp
@@ -75,7 +75,7 @@ void* android_load_sphal_library(const char* name, int flag) {
         }
         return handle;
     } else {
-        ALOGD("Loading %s from current namespace instead of sphal namespace.", name);
+        ALOGW("Loading %s from current namespace instead of sphal namespace.", name);
         return dlopen(name, flag);
     }
 }

From 8a28163d33d85b9742900f173ed765145a449a56 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 3 Oct 2023 15:55:09 -0700
Subject: [PATCH 0430/1487] inspect_cow: Add an --extract-to argument.

This adds an --extract-to argument to inspect_cow to verify that full
OTA snapshots contain correct data. It does not yet work for ordered
ops.

Test: inspect_cow
Bug: N/A
Change-Id: I9014da3e83fd4fb5ea54ac1d36e527b3e3e6c9d5

Change-Id: I7e256e8ddec626980cdcf8680bbeac3c2e9d8de1
---
 .../libsnapshot_cow/inspect_cow.cpp           | 29 +++++++++++++++++--
 1 file changed, 26 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
index a6dee4f43138..83b5a12955a7 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
@@ -22,6 +22,7 @@
 #include <string>
 #include <vector>
 
+#include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/unique_fd.h>
 #include <gflags/gflags.h>
@@ -38,11 +39,13 @@ DEFINE_bool(show_merged, false,
 DEFINE_bool(verify_merge_sequence, false, "Verify merge order sequencing");
 DEFINE_bool(show_merge_sequence, false, "Show merge order sequence");
 DEFINE_bool(show_raw_ops, false, "Show raw ops directly from the underlying parser");
+DEFINE_string(extract_to, "", "Extract the COW contents to the given file");
 
 namespace android {
 namespace snapshot {
 
 using android::base::borrowed_fd;
+using android::base::unique_fd;
 
 void MyLogger(android::base::LogId, android::base::LogSeverity severity, const char*, const char*,
               unsigned int, const char* message) {
@@ -53,7 +56,7 @@ void MyLogger(android::base::LogId, android::base::LogSeverity severity, const c
     }
 }
 
-static void ShowBad(CowReader& reader, const struct CowOperation* op) {
+static void ShowBad(CowReader& reader, const CowOperation* op) {
     size_t count;
     auto buffer = std::make_unique<uint8_t[]>(op->data_length);
 
@@ -104,12 +107,21 @@ static bool ShowRawOpStream(borrowed_fd fd) {
 }
 
 static bool Inspect(const std::string& path) {
-    android::base::unique_fd fd(open(path.c_str(), O_RDONLY));
+    unique_fd fd(open(path.c_str(), O_RDONLY));
     if (fd < 0) {
         PLOG(ERROR) << "open failed: " << path;
         return false;
     }
 
+    unique_fd extract_to;
+    if (!FLAGS_extract_to.empty()) {
+        extract_to.reset(open(FLAGS_extract_to.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0664));
+        if (extract_to < 0) {
+            PLOG(ERROR) << "could not open " << FLAGS_extract_to << " for writing";
+            return false;
+        }
+    }
+
     CowReader reader;
 
     auto start_time = std::chrono::steady_clock::now();
@@ -186,12 +198,23 @@ static bool Inspect(const std::string& path) {
 
         if (!FLAGS_silent && FLAGS_show_ops) std::cout << *op << "\n";
 
-        if (FLAGS_decompress && op->type == kCowReplaceOp && op->compression != kCowCompressNone) {
+        if ((FLAGS_decompress || extract_to >= 0) && op->type == kCowReplaceOp) {
             if (reader.ReadData(op, buffer.data(), buffer.size()) < 0) {
                 std::cerr << "Failed to decompress for :" << *op << "\n";
                 success = false;
                 if (FLAGS_show_bad_data) ShowBad(reader, op);
             }
+            if (extract_to >= 0) {
+                off_t offset = uint64_t(op->new_block) * header.block_size;
+                if (!android::base::WriteFullyAtOffset(extract_to, buffer.data(), buffer.size(),
+                                                       offset)) {
+                    PLOG(ERROR) << "failed to write block " << op->new_block;
+                    return false;
+                }
+            }
+        } else if (extract_to >= 0 && !IsMetadataOp(*op) && op->type != kCowZeroOp) {
+            PLOG(ERROR) << "Cannot extract op yet: " << *op;
+            return false;
         }
 
         if (op->type == kCowSequenceOp && FLAGS_show_merge_sequence) {

From c942daf179983d1f9ccf76eb387ec4b809ff6445 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 3 Oct 2023 19:50:53 -0700
Subject: [PATCH 0431/1487] snapuserd: Add an extractor tool.

This is similar to inspect_cow --extract-to, except it uses snapuserd.
It is a diagnostic host tool and uses the tooling added for host
testing.

Usage: snapuserd_extractor -cow COW_FILE -base BASE_FILE -out OUT_FILE
                           -num_sectors NUM_SECTORS

Unlike inspect_cow, this supports xor/copy operations.

The extractor code is separated into a utility file so we can use it for
additional tests later on.

Bug: N/A
Test: manual test
Change-Id: Ib7509508cba45e6c3a0db8c75454e33c2a503e03
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       | 45 ++++++++++
 .../snapuserd/snapuserd_extractor.cpp         | 68 ++++++++++++++
 .../snapuserd/user-space-merge/extractor.cpp  | 90 +++++++++++++++++++
 .../snapuserd/user-space-merge/extractor.h    | 51 +++++++++++
 4 files changed, 254 insertions(+)
 create mode 100644 fs_mgr/libsnapshot/snapuserd/snapuserd_extractor.cpp
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.cpp
 create mode 100644 fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 47a86858a7fb..1b0c5639ee92 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -293,3 +293,48 @@ cc_test {
         "vts",
     ],
 }
+
+cc_binary_host {
+    name: "snapuserd_extractor",
+    defaults: [
+        "fs_mgr_defaults",
+        "libsnapshot_cow_defaults",
+    ],
+    srcs: [
+        "testing/dm_user_harness.cpp",
+        "testing/harness.cpp",
+        "testing/host_harness.cpp",
+        "user-space-merge/extractor.cpp",
+        "snapuserd_extractor.cpp",
+    ],
+    cflags: [
+        "-D_FILE_OFFSET_BITS=64",
+        "-Wall",
+        "-Werror",
+    ],
+    shared_libs: [
+        "libbase",
+        "liblog",
+    ],
+    static_libs: [
+        "libbrotli",
+        "libcutils_sockets",
+        "libdm",
+        "libext2_uuid",
+        "libext4_utils",
+        "libfs_mgr_file_wait",
+        "libgflags",
+        "libsnapshot_cow",
+        "libsnapuserd",
+        "liburing",
+        "libz",
+    ],
+    include_dirs: [
+        "bionic/libc/kernel",
+        ".",
+    ],
+    header_libs: [
+        "libstorage_literals_headers",
+        "libfiemap_headers",
+    ],
+}
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_extractor.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_extractor.cpp
new file mode 100644
index 000000000000..f46cd5bc53c9
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_extractor.cpp
@@ -0,0 +1,68 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <fcntl.h>
+#include <linux/fs.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <iostream>
+#include <memory>
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <gflags/gflags.h>
+#include "user-space-merge/extractor.h"
+
+using namespace std::string_literals;
+
+DEFINE_string(base, "", "Base device/image");
+DEFINE_string(cow, "", "COW device/image");
+DEFINE_string(out, "", "Output path");
+DEFINE_int32(num_sectors, 0, "Number of sectors to read");
+
+int main([[maybe_unused]] int argc, [[maybe_unused]] char** argv) {
+    android::base::InitLogging(argv);
+    gflags::ParseCommandLineFlags(&argc, &argv, true);
+
+    if (FLAGS_out.empty()) {
+        LOG(ERROR) << "Missing -out argument.";
+        return 1;
+    }
+    if (FLAGS_base.empty()) {
+        LOG(ERROR) << "Missing -base argument.";
+        return 1;
+    }
+    if (FLAGS_cow.empty()) {
+        LOG(ERROR) << "missing -out argument.";
+        return 1;
+    }
+    if (!FLAGS_num_sectors) {
+        LOG(ERROR) << "missing -num_sectors argument.";
+        return 1;
+    }
+
+    android::snapshot::Extractor extractor(FLAGS_base, FLAGS_cow);
+    if (!extractor.Init()) {
+        return 1;
+    }
+    if (!extractor.Extract(FLAGS_num_sectors, FLAGS_out)) {
+        return 1;
+    }
+    return 0;
+}
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.cpp
new file mode 100644
index 000000000000..c5718d5b76a8
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.cpp
@@ -0,0 +1,90 @@
+// Copyright (C) 2023 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 "extractor.h"
+
+#include <fcntl.h>
+#include <linux/fs.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <iostream>
+#include <memory>
+
+#include <android-base/file.h>
+#include <android-base/properties.h>
+#include <android-base/unique_fd.h>
+
+using android::base::unique_fd;
+using namespace std::string_literals;
+
+namespace android {
+namespace snapshot {
+
+Extractor::Extractor(const std::string& base_path, const std::string& cow_path)
+    : base_path_(base_path), cow_path_(cow_path), control_name_("test") {}
+
+bool Extractor::Init() {
+    auto opener = factory_.CreateTestOpener(control_name_);
+    handler_ = std::make_shared<SnapshotHandler>(control_name_, cow_path_, base_path_, base_path_,
+                                                 opener, 1, false, false);
+    if (!handler_->InitCowDevice()) {
+        return false;
+    }
+    if (!handler_->InitializeWorkers()) {
+        return false;
+    }
+
+    read_worker_ = std::make_unique<ReadWorker>(cow_path_, base_path_, control_name_, base_path_,
+                                                handler_->GetSharedPtr(), opener);
+    if (!read_worker_->Init()) {
+        return false;
+    }
+    block_server_ = static_cast<TestBlockServer*>(read_worker_->block_server());
+
+    handler_thread_ = std::async(std::launch::async, &SnapshotHandler::Start, handler_.get());
+    return true;
+}
+
+Extractor::~Extractor() {
+    factory_.DeleteQueue(control_name_);
+}
+
+bool Extractor::Extract(off_t num_sectors, const std::string& out_path) {
+    unique_fd out_fd(open(out_path.c_str(), O_RDWR | O_CLOEXEC | O_TRUNC | O_CREAT, 0664));
+    if (out_fd < 0) {
+        PLOG(ERROR) << "Could not open for writing: " << out_path;
+        return false;
+    }
+
+    for (off_t i = 0; i < num_sectors; i++) {
+        if (!read_worker_->RequestSectors(i, 512)) {
+            LOG(ERROR) << "Read sector " << i << " failed.";
+            return false;
+        }
+        std::string result = std::move(block_server_->sent_io());
+        off_t offset = i * 512;
+        if (!android::base::WriteFullyAtOffset(out_fd, result.data(), result.size(), offset)) {
+            PLOG(ERROR) << "write failed";
+            return false;
+        }
+    }
+    return true;
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.h
new file mode 100644
index 000000000000..65285b1fa5f7
--- /dev/null
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.h
@@ -0,0 +1,51 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <string>
+#include <thread>
+
+#include <android-base/unique_fd.h>
+#include "merge_worker.h"
+#include "read_worker.h"
+#include "snapuserd_core.h"
+#include "testing/host_harness.h"
+
+namespace android {
+namespace snapshot {
+
+class Extractor final {
+  public:
+    Extractor(const std::string& base_path, const std::string& cow_path);
+    ~Extractor();
+
+    bool Init();
+    bool Extract(off_t num_sectors, const std::string& out_path);
+
+  private:
+    std::string base_path_;
+    std::string cow_path_;
+
+    TestBlockServerFactory factory_;
+    HostTestHarness harness_;
+    std::string control_name_;
+    std::shared_ptr<SnapshotHandler> handler_;
+    std::unique_ptr<ReadWorker> read_worker_;
+    std::future<bool> handler_thread_;
+    TestBlockServer* block_server_ = nullptr;
+};
+
+}  // namespace snapshot
+}  // namespace android

From 716ff7b55adf56b212974ea98783422b5682251f Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 4 Oct 2023 23:31:09 +0000
Subject: [PATCH 0432/1487] s/master/main/

Test: treehugger
Change-Id: Iabb23436d92686b934f2f2609217714b64ae75de
---
 libcutils/sockets_windows.cpp            | 2 +-
 rootdir/etc/public.libraries.android.txt | 2 +-
 rootdir/etc/public.libraries.iot.txt     | 2 +-
 rootdir/etc/public.libraries.wear.txt    | 2 +-
 trusty/stats/test/README.md              | 4 ++--
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/libcutils/sockets_windows.cpp b/libcutils/sockets_windows.cpp
index 4adb79691d8d..99a2e2ddeeb5 100644
--- a/libcutils/sockets_windows.cpp
+++ b/libcutils/sockets_windows.cpp
@@ -35,7 +35,7 @@
 // can be extremely tricky and cause deadlock when using threads or atexit().
 //
 // Both adb (1) and Chrome (2) purposefully avoid WSACleanup() with no issues.
-// (1) https://android.googlesource.com/platform/system/core.git/+/master/adb/sysdeps_win32.cpp
+// (1) https://android.googlesource.com/platform/packages/modules/adb.git/+/main/sysdeps_win32.cpp
 // (2) https://code.google.com/p/chromium/codesearch#chromium/src/net/base/winsock_init.cc
 bool initialize_windows_sockets() {
     // There's no harm in calling WSAStartup() multiple times but no benefit
diff --git a/rootdir/etc/public.libraries.android.txt b/rootdir/etc/public.libraries.android.txt
index cacc47c59b89..9be2ef69df09 100644
--- a/rootdir/etc/public.libraries.android.txt
+++ b/rootdir/etc/public.libraries.android.txt
@@ -1,4 +1,4 @@
-# See https://android.googlesource.com/platform/ndk/+/master/docs/PlatformApis.md
+# See https://android.googlesource.com/platform/ndk/+/main/docs/PlatformApis.md
 libandroid.so
 libaaudio.so
 libamidi.so
diff --git a/rootdir/etc/public.libraries.iot.txt b/rootdir/etc/public.libraries.iot.txt
index 77f8bb802f3b..051396812690 100644
--- a/rootdir/etc/public.libraries.iot.txt
+++ b/rootdir/etc/public.libraries.iot.txt
@@ -1,4 +1,4 @@
-# See https://android.googlesource.com/platform/ndk/+/master/docs/PlatformApis.md
+# See https://android.googlesource.com/platform/ndk/+/main/docs/PlatformApis.md
 libandroid.so
 libandroidthings.so
 libaaudio.so
diff --git a/rootdir/etc/public.libraries.wear.txt b/rootdir/etc/public.libraries.wear.txt
index ea1e234373de..5915dcb0695e 100644
--- a/rootdir/etc/public.libraries.wear.txt
+++ b/rootdir/etc/public.libraries.wear.txt
@@ -1,4 +1,4 @@
-# See https://android.googlesource.com/platform/ndk/+/master/docs/PlatformApis.md
+# See https://android.googlesource.com/platform/ndk/+/main/docs/PlatformApis.md
 libandroid.so
 libaaudio.so
 libamidi.so
diff --git a/trusty/stats/test/README.md b/trusty/stats/test/README.md
index 45e6af8b066b..175409e99df2 100644
--- a/trusty/stats/test/README.md
+++ b/trusty/stats/test/README.md
@@ -1,8 +1,8 @@
 # Development Notes
 
-*    First get [repo_pull.py and gerrit.py](https://android.googlesource.com/platform/development/+/master/tools/repo_pull/) from aosp.
+*    First get [repo_pull.py and gerrit.py](https://android.googlesource.com/platform/development/+/main/tools/repo_pull/) from aosp.
 
-*    Although this repo is not currently in Trusty’s manifest, it’s sufficient to copy these two python scripts to the root of the Trusty project and run them from there. Make sure to follow the [repo_pull installation](https://android.googlesource.com/platform/development/+/master/tools/repo_pull/#installation) steps if necessary.
+*    Although this repo is not currently in Trusty’s manifest, it’s sufficient to copy these two python scripts to the root of the Trusty project and run them from there. Make sure to follow the [repo_pull installation](https://android.googlesource.com/platform/development/+/main/tools/repo_pull/#installation) steps if necessary.
 
 ## Build
 

From a16436d5d737f65d7dca3335a834ef877b0e9c7b Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 26 Sep 2023 17:22:36 -0700
Subject: [PATCH 0433/1487] Adding test for reader compatibility

Reader + Parser v3 should be able to read V2 cow format written to disk.
This test reads in a small cow file written by basic_v2_cow_writer and
parses it to ensure this compatibility checks out.

Test: cow_api_test
Change-Id: I46ebf4e3f12cdb3e4716ca5b624aab5836086733
---
 fs_mgr/libsnapshot/Android.bp                 |  3 ++
 .../libsnapshot/libsnapshot_cow/test_v2.cpp   | 31 +++++++++++++++++++
 2 files changed, 34 insertions(+)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 0131f732e6fa..fe47801f3f72 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -415,6 +415,9 @@ cc_test {
     test_options: {
         min_shipping_api_level: 30,
     },
+    data: [
+        "tools/testdata/cow_v2",
+    ],
     auto_gen_config: true,
     require_root: false,
     host_supported: true,
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index e59bd927fe08..9676bf9b23b4 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -1504,6 +1504,37 @@ TEST_F(CowTest, InvalidMergeOrderTest) {
     ASSERT_FALSE(reader.VerifyMergeOps());
 }
 
+unique_fd OpenTestFile(const std::string& file, int flags) {
+    std::string path = "tools/testdata/" + file;
+
+    unique_fd fd(open(path.c_str(), flags));
+    if (fd >= 0) {
+        return fd;
+    }
+
+    path = android::base::GetExecutableDirectory() + "/" + path;
+    return unique_fd{open(path.c_str(), flags)};
+}
+
+TEST_F(CowTest, CompatibilityTest) {
+    std::string filename = "cow_v2";
+    auto fd = OpenTestFile(filename, O_RDONLY);
+    if (fd.get() == -1) {
+        LOG(ERROR) << filename << " not found";
+        GTEST_SKIP();
+    }
+    CowReader reader;
+    reader.Parse(fd);
+
+    const auto& header = reader.GetHeader();
+    ASSERT_EQ(header.prefix.magic, kCowMagicNumber);
+    ASSERT_EQ(header.prefix.major_version, kCowVersionMajor);
+    ASSERT_EQ(header.prefix.minor_version, kCowVersionMinor);
+
+    CowFooter footer;
+    ASSERT_TRUE(reader.GetFooter(&footer));
+}
+
 }  // namespace snapshot
 }  // namespace android
 

From c9770b29b94b6bcb2a5f8c08fa92e99c460fd7dd Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 31 Aug 2023 13:22:05 -0700
Subject: [PATCH 0434/1487] Refactor off V2 Cow Ops

Refactor writer, reader + parser to work off v2 version of
CowOperations.

Test: m libsnapshot. ota on cuttlefish
Change-Id: Iec59be91e5f54782272b37702d645942df38c771
---
 .../include/libsnapshot/cow_format.h          |  55 ++++-----
 .../include/libsnapshot/cow_reader.h          |   4 +-
 .../libsnapshot_cow/cow_format.cpp            | 114 ++++++++++++------
 .../libsnapshot_cow/cow_reader.cpp            |  47 +++++++-
 .../libsnapshot/libsnapshot_cow/parser_v2.cpp |  22 ++--
 .../libsnapshot/libsnapshot_cow/parser_v2.h   |   4 +-
 .../libsnapshot/libsnapshot_cow/test_v2.cpp   |  39 +++---
 .../libsnapshot/libsnapshot_cow/writer_v2.cpp |  49 ++++----
 .../libsnapshot/libsnapshot_cow/writer_v2.h   |   6 +-
 9 files changed, 205 insertions(+), 135 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 9359b9ec1294..2a2cee2b72b5 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -22,6 +22,9 @@
 namespace android {
 namespace snapshot {
 
+struct CowOperationV3;
+typedef CowOperationV3 CowOperation;
+
 static constexpr uint64_t kCowMagicNumber = 0x436f77634f572121ULL;
 static constexpr uint32_t kCowVersionMajor = 2;
 static constexpr uint32_t kCowVersionMinor = 0;
@@ -109,9 +112,8 @@ struct CowFooterOperation {
     uint64_t num_ops;
 } __attribute__((packed));
 
-// Cow operations are currently fixed-size entries, but this may change if
-// needed.
-struct CowOperation {
+// V2 version of COW. On disk format for older devices
+struct CowOperationV2 {
     // The operation code (see the constants and structures below).
     uint8_t type;
 
@@ -146,42 +148,32 @@ struct CowOperation {
 } __attribute__((packed));
 
 // The on disk format of cow (currently ==  CowOperation)
-struct CowOperationV2 {
+struct CowOperationV3 {
     // The operation code (see the constants and structures below).
     uint8_t type;
 
-    // If this operation reads from the data section of the COW, this contains
-    // the compression type of that data (see constants below).
-    uint8_t compression;
-
     // If this operation reads from the data section of the COW, this contains
     // the length.
     uint16_t data_length;
 
     // The block of data in the new image that this operation modifies.
-    uint64_t new_block;
+    uint32_t new_block;
 
     // The value of |source| depends on the operation code.
     //
-    // For copy operations, this is a block location in the source image.
-    //
-    // For replace operations, this is a byte offset within the COW's data
-    // sections (eg, not landing within the header or metadata). It is an
-    // absolute position within the image.
-    //
-    // For zero operations (replace with all zeroes), this is unused and must
-    // be zero.
-    //
-    // For Label operations, this is the value of the applied label.
-    //
-    // For Cluster operations, this is the length of the following data region
+    // CopyOp: a 32-bit block location in the source image.
+    // ReplaceOp: an absolute byte offset within the COW's data section.
+    // XorOp: an absolute byte offset in the source image.
+    // ZeroOp: unused
+    // LabelOp: a 64-bit opaque identifier.
     //
-    // For Xor operations, this is the byte location in the source image.
-    uint64_t source;
+    // For ops other than Label:
+    //  Bits 47-62 are reserved and must be zero.
+    // A block is compressed if it’s data is < block_sz
+    uint64_t source_info;
 } __attribute__((packed));
 
-static_assert(sizeof(CowOperationV2) == sizeof(CowOperation));
-static_assert(sizeof(CowOperation) == sizeof(CowFooterOperation));
+static_assert(sizeof(CowOperationV2) == sizeof(CowFooterOperation));
 
 static constexpr uint8_t kCowCopyOp = 1;
 static constexpr uint8_t kCowReplaceOp = 2;
@@ -208,11 +200,14 @@ static constexpr uint8_t kCowReadAheadNotStarted = 0;
 static constexpr uint8_t kCowReadAheadInProgress = 1;
 static constexpr uint8_t kCowReadAheadDone = 2;
 
+static constexpr uint64_t kCowOpSourceInfoDataMask = (1ULL << 48) - 1;
+static constexpr uint64_t kCowOpSourceInfoCompressBit = (1ULL << 63);
+
 static inline uint64_t GetCowOpSourceInfoData(const CowOperation* op) {
-    return op->source;
+    return op->source_info & kCowOpSourceInfoDataMask;
 }
 static inline bool GetCowOpSourceInfoCompression(const CowOperation* op) {
-    return op->compression != kCowCompressNone;
+    return !!(op->source_info & kCowOpSourceInfoCompressBit);
 }
 
 struct CowFooter {
@@ -236,10 +231,12 @@ struct BufferState {
 // 2MB Scratch space used for read-ahead
 static constexpr uint64_t BUFFER_REGION_DEFAULT_SIZE = (1ULL << 21);
 
+std::ostream& operator<<(std::ostream& os, CowOperationV2 const& arg);
+
 std::ostream& operator<<(std::ostream& os, CowOperation const& arg);
 
-int64_t GetNextOpOffset(const CowOperation& op, uint32_t cluster_size);
-int64_t GetNextDataOffset(const CowOperation& op, uint32_t cluster_size);
+int64_t GetNextOpOffset(const CowOperationV2& op, uint32_t cluster_size);
+int64_t GetNextDataOffset(const CowOperationV2& op, uint32_t cluster_size);
 
 // Ops that are internal to the Cow Format and not OTA data
 bool IsMetadataOp(const CowOperation& op);
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index 67d301d70cff..1d6fd62b4046 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -165,9 +165,10 @@ class CowReader final : public ICowReader {
     void UpdateMergeOpsCompleted(int num_merge_ops) { header_.num_merge_ops += num_merge_ops; }
 
   private:
+    bool ParseV2(android::base::borrowed_fd fd, std::optional<uint64_t> label);
     bool PrepMergeOps();
     uint64_t FindNumCopyops();
-    uint8_t GetCompressionType(const CowOperation* op);
+    uint8_t GetCompressionType();
 
     android::base::unique_fd owned_fd_;
     android::base::borrowed_fd fd_;
@@ -184,6 +185,7 @@ class CowReader final : public ICowReader {
     std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
     ReaderFlags reader_flag_;
     bool is_merge_{};
+    uint8_t compression_type_ = kCowCompressNone;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
index ff3ccecb86aa..58dca64e19bd 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
@@ -14,11 +14,14 @@
 // limitations under the License.
 //
 
+#include <inttypes.h>
 #include <libsnapshot/cow_format.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <android-base/logging.h>
+#include <android-base/stringprintf.h>
+#include <libsnapshot/cow_format.h>
 #include "writer_v2.h"
 
 namespace android {
@@ -26,45 +29,82 @@ namespace snapshot {
 
 using android::base::unique_fd;
 
-std::ostream& operator<<(std::ostream& os, CowOperation const& op) {
-    os << "CowOperation(type:";
-    if (op.type == kCowCopyOp)
-        os << "kCowCopyOp,    ";
-    else if (op.type == kCowReplaceOp)
-        os << "kCowReplaceOp, ";
-    else if (op.type == kCowZeroOp)
-        os << "kZeroOp,       ";
-    else if (op.type == kCowFooterOp)
-        os << "kCowFooterOp,  ";
-    else if (op.type == kCowLabelOp)
-        os << "kCowLabelOp,   ";
-    else if (op.type == kCowClusterOp)
-        os << "kCowClusterOp  ";
-    else if (op.type == kCowXorOp)
-        os << "kCowXorOp      ";
-    else if (op.type == kCowSequenceOp)
-        os << "kCowSequenceOp ";
-    else if (op.type == kCowFooterOp)
-        os << "kCowFooterOp  ";
-    else
-        os << (int)op.type << "?,";
-    os << "compression:";
-    if (op.compression == kCowCompressNone)
-        os << "kCowCompressNone,   ";
-    else if (op.compression == kCowCompressGz)
-        os << "kCowCompressGz,     ";
-    else if (op.compression == kCowCompressBrotli)
-        os << "kCowCompressBrotli, ";
-    else
-        os << (int)op.compression << "?, ";
-    os << "data_length:" << op.data_length << ",\t";
-    os << "new_block:" << op.new_block << ",\t";
+std::ostream& EmitCowTypeString(std::ostream& os, uint8_t cow_type) {
+    switch (cow_type) {
+        case kCowCopyOp:
+            return os << "kCowCopyOp";
+        case kCowReplaceOp:
+            return os << "kCowReplaceOp";
+        case kCowZeroOp:
+            return os << "kZeroOp";
+        case kCowFooterOp:
+            return os << "kCowFooterOp";
+        case kCowLabelOp:
+            return os << "kCowLabelOp";
+        case kCowClusterOp:
+            return os << "kCowClusterOp";
+        case kCowXorOp:
+            return os << "kCowXorOp";
+        case kCowSequenceOp:
+            return os << "kCowSequenceOp";
+        default:
+            return os << (int)cow_type << "unknown";
+    }
+}
+
+std::ostream& operator<<(std::ostream& os, CowOperationV2 const& op) {
+    os << "CowOperationV2(";
+    EmitCowTypeString(os, op.type) << ", ";
+    switch (op.compression) {
+        case kCowCompressNone:
+            os << "uncompressed, ";
+            break;
+        case kCowCompressGz:
+            os << "gz, ";
+            break;
+        case kCowCompressBrotli:
+            os << "brotli, ";
+            break;
+        case kCowCompressLz4:
+            os << "lz4, ";
+            break;
+        case kCowCompressZstd:
+            os << "zstd, ";
+            break;
+    }
+    os << "data_length:" << op.data_length << ", ";
+    os << "new_block:" << op.new_block << ", ";
     os << "source:" << op.source;
     os << ")";
     return os;
 }
 
-int64_t GetNextOpOffset(const CowOperation& op, uint32_t cluster_ops) {
+std::ostream& operator<<(std::ostream& os, CowOperation const& op) {
+    os << "CowOperation(";
+    EmitCowTypeString(os, op.type);
+    if (op.type == kCowReplaceOp || op.type == kCowXorOp || op.type == kCowSequenceOp) {
+        if (op.source_info & kCowOpSourceInfoCompressBit) {
+            os << ", compressed";
+        } else {
+            os << ", uncompressed";
+        }
+        os << ", data_length:" << op.data_length;
+    }
+    if (op.type != kCowClusterOp && op.type != kCowSequenceOp && op.type != kCowLabelOp) {
+        os << ", new_block:" << op.new_block;
+    }
+    if (op.type == kCowXorOp || op.type == kCowReplaceOp || op.type == kCowCopyOp) {
+        os << ", source:" << (op.source_info & kCowOpSourceInfoDataMask);
+    } else if (op.type == kCowClusterOp) {
+        os << ", cluster_data:" << (op.source_info & kCowOpSourceInfoDataMask);
+    } else {
+        os << ", label:0x" << android::base::StringPrintf("%" PRIx64, op.source_info);
+    }
+    os << ")";
+    return os;
+}
+
+int64_t GetNextOpOffset(const CowOperationV2& op, uint32_t cluster_ops) {
     if (op.type == kCowClusterOp) {
         return op.source;
     } else if ((op.type == kCowReplaceOp || op.type == kCowXorOp) && cluster_ops == 0) {
@@ -74,11 +114,11 @@ int64_t GetNextOpOffset(const CowOperation& op, uint32_t cluster_ops) {
     }
 }
 
-int64_t GetNextDataOffset(const CowOperation& op, uint32_t cluster_ops) {
+int64_t GetNextDataOffset(const CowOperationV2& op, uint32_t cluster_ops) {
     if (op.type == kCowClusterOp) {
-        return cluster_ops * sizeof(CowOperation);
+        return cluster_ops * sizeof(CowOperationV2);
     } else if (cluster_ops == 0) {
-        return sizeof(CowOperation);
+        return sizeof(CowOperationV2);
     } else {
         return 0;
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 1b5d72484a5a..bf50f2f5eb2d 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -55,6 +55,7 @@ std::unique_ptr<CowReader> CowReader::CloneCowReader() {
     cow->data_loc_ = data_loc_;
     cow->block_pos_index_ = block_pos_index_;
     cow->is_merge_ = is_merge_;
+    cow->compression_type_ = compression_type_;
     return cow;
 }
 
@@ -101,8 +102,44 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
     footer_ = parser.footer();
     fd_size_ = parser.fd_size();
     last_label_ = parser.last_label();
-    ops_ = parser.ops();
     data_loc_ = parser.data_loc();
+    ops_ = std::make_shared<std::vector<CowOperation>>(parser.ops()->size());
+
+    // Translate the operation buffer from on disk to in memory
+    for (size_t i = 0; i < parser.ops()->size(); i++) {
+        const auto& v2_op = parser.ops()->at(i);
+
+        auto& new_op = ops_->at(i);
+        new_op.type = v2_op.type;
+        new_op.data_length = v2_op.data_length;
+
+        if (v2_op.new_block > std::numeric_limits<uint32_t>::max()) {
+            LOG(ERROR) << "Out-of-range new block in COW op: " << v2_op;
+            return false;
+        }
+        new_op.new_block = v2_op.new_block;
+
+        uint64_t source_info = v2_op.source;
+        if (new_op.type != kCowLabelOp) {
+            source_info &= kCowOpSourceInfoDataMask;
+            if (source_info != v2_op.source) {
+                LOG(ERROR) << "Out-of-range source value in COW op: " << v2_op;
+                return false;
+            }
+        }
+        if (v2_op.compression != kCowCompressNone) {
+            if (compression_type_ == kCowCompressNone) {
+                compression_type_ = v2_op.compression;
+            } else if (compression_type_ != v2_op.compression) {
+                LOG(ERROR) << "COW has mixed compression types which is not supported;"
+                           << " previously saw " << compression_type_ << ", got "
+                           << v2_op.compression << ", op: " << v2_op;
+                return false;
+            }
+            source_info |= kCowOpSourceInfoCompressBit;
+        }
+        new_op.source_info = source_info;
+    }
 
     // If we're resuming a write, we're not ready to merge
     if (label.has_value()) return true;
@@ -597,14 +634,14 @@ class CowDataStream final : public IByteStream {
     size_t remaining_;
 };
 
-uint8_t CowReader::GetCompressionType(const CowOperation* op) {
-    return op->compression;
+uint8_t CowReader::GetCompressionType() {
+    return compression_type_;
 }
 
 ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_size,
                             size_t ignore_bytes) {
     std::unique_ptr<IDecompressor> decompressor;
-    switch (GetCompressionType(op)) {
+    switch (GetCompressionType()) {
         case kCowCompressNone:
             break;
         case kCowCompressGz:
@@ -624,7 +661,7 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
             }
             break;
         default:
-            LOG(ERROR) << "Unknown compression type: " << GetCompressionType(op);
+            LOG(ERROR) << "Unknown compression type: " << GetCompressionType();
             return -1;
     }
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
index fdb5c5911d1c..8edeae127ac8 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
@@ -66,18 +66,18 @@ bool CowParserV2::Parse(borrowed_fd fd, const CowHeader& header, std::optional<u
                    << sizeof(CowFooter);
         return false;
     }
-    if (header_.op_size != sizeof(CowOperation)) {
+    if (header_.op_size != sizeof(CowOperationV2)) {
         LOG(ERROR) << "Operation size unknown, read " << header_.op_size << ", expected "
-                   << sizeof(CowOperation);
+                   << sizeof(CowOperationV2);
         return false;
     }
     if (header_.cluster_ops == 1) {
         LOG(ERROR) << "Clusters must contain at least two operations to function.";
         return false;
     }
-    if (header_.op_size != sizeof(CowOperation)) {
+    if (header_.op_size != sizeof(CowOperationV2)) {
         LOG(ERROR) << "Operation size unknown, read " << header_.op_size << ", expected "
-                   << sizeof(CowOperation);
+                   << sizeof(CowOperationV2);
         return false;
     }
     if (header_.cluster_ops == 1) {
@@ -123,23 +123,23 @@ bool CowParserV2::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
     uint64_t data_pos = 0;
 
     if (header_.cluster_ops) {
-        data_pos = pos + header_.cluster_ops * sizeof(CowOperation);
+        data_pos = pos + header_.cluster_ops * sizeof(CowOperationV2);
     } else {
-        data_pos = pos + sizeof(CowOperation);
+        data_pos = pos + sizeof(CowOperationV2);
     }
 
-    auto ops_buffer = std::make_shared<std::vector<CowOperation>>();
+    auto ops_buffer = std::make_shared<std::vector<CowOperationV2>>();
     uint64_t current_op_num = 0;
     uint64_t cluster_ops = header_.cluster_ops ?: 1;
     bool done = false;
 
     // Alternating op clusters and data
     while (!done) {
-        uint64_t to_add = std::min(cluster_ops, (fd_size_ - pos) / sizeof(CowOperation));
+        uint64_t to_add = std::min(cluster_ops, (fd_size_ - pos) / sizeof(CowOperationV2));
         if (to_add == 0) break;
         ops_buffer->resize(current_op_num + to_add);
         if (!android::base::ReadFully(fd, &ops_buffer->data()[current_op_num],
-                                      to_add * sizeof(CowOperation))) {
+                                      to_add * sizeof(CowOperationV2))) {
             PLOG(ERROR) << "read op failed";
             return false;
         }
@@ -150,7 +150,7 @@ bool CowParserV2::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
             if (current_op.type == kCowXorOp) {
                 data_loc->insert({current_op.new_block, data_pos});
             }
-            pos += sizeof(CowOperation) + GetNextOpOffset(current_op, header_.cluster_ops);
+            pos += sizeof(CowOperationV2) + GetNextOpOffset(current_op, header_.cluster_ops);
             data_pos += current_op.data_length + GetNextDataOffset(current_op, header_.cluster_ops);
 
             if (current_op.type == kCowClusterOp) {
@@ -222,7 +222,7 @@ bool CowParserV2::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
                        << ops_buffer->size();
             return false;
         }
-        if (ops_buffer->size() * sizeof(CowOperation) != footer_->op.ops_size) {
+        if (ops_buffer->size() * sizeof(CowOperationV2) != footer_->op.ops_size) {
             LOG(ERROR) << "ops size does not match ";
             return false;
         }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
index afcf687fd67a..92e2b08c42d4 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
@@ -33,7 +33,7 @@ class CowParserV2 {
 
     const CowHeader& header() const { return header_; }
     const std::optional<CowFooter>& footer() const { return footer_; }
-    std::shared_ptr<std::vector<CowOperation>> ops() { return ops_; }
+    std::shared_ptr<std::vector<CowOperationV2>> ops() { return ops_; }
     std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const { return data_loc_; }
     uint64_t fd_size() const { return fd_size_; }
     const std::optional<uint64_t>& last_label() const { return last_label_; }
@@ -43,7 +43,7 @@ class CowParserV2 {
 
     CowHeader header_ = {};
     std::optional<CowFooter> footer_;
-    std::shared_ptr<std::vector<CowOperation>> ops_;
+    std::shared_ptr<std::vector<CowOperationV2>> ops_;
     std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
     uint64_t fd_size_;
     std::optional<uint64_t> last_label_;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 9676bf9b23b4..8f3f03f38f3f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -86,10 +86,9 @@ TEST_F(CowTest, CopyContiguous) {
     while (!iter->AtEnd()) {
         auto op = iter->Get();
         ASSERT_EQ(op->type, kCowCopyOp);
-        ASSERT_EQ(op->compression, kCowCompressNone);
         ASSERT_EQ(op->data_length, 0);
         ASSERT_EQ(op->new_block, 10 + i);
-        ASSERT_EQ(op->source, 1000 + i);
+        ASSERT_EQ(op->source_info, 1000 + i);
         iter->Next();
         i += 1;
     }
@@ -133,10 +132,9 @@ TEST_F(CowTest, ReadWrite) {
     auto op = iter->Get();
 
     ASSERT_EQ(op->type, kCowCopyOp);
-    ASSERT_EQ(op->compression, kCowCompressNone);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 10);
-    ASSERT_EQ(op->source, 20);
+    ASSERT_EQ(op->source_info, 20);
 
     std::string sink(data.size(), '\0');
 
@@ -157,20 +155,18 @@ TEST_F(CowTest, ReadWrite) {
 
     // Note: the zero operation gets split into two blocks.
     ASSERT_EQ(op->type, kCowZeroOp);
-    ASSERT_EQ(op->compression, kCowCompressNone);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 51);
-    ASSERT_EQ(op->source, 0);
+    ASSERT_EQ(op->source_info, 0);
 
     iter->Next();
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
     ASSERT_EQ(op->type, kCowZeroOp);
-    ASSERT_EQ(op->compression, kCowCompressNone);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 52);
-    ASSERT_EQ(op->source, 0);
+    ASSERT_EQ(op->source_info, 0);
 
     iter->Next();
     ASSERT_TRUE(iter->AtEnd());
@@ -212,10 +208,9 @@ TEST_F(CowTest, ReadWriteXor) {
     auto op = iter->Get();
 
     ASSERT_EQ(op->type, kCowCopyOp);
-    ASSERT_EQ(op->compression, kCowCompressNone);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 10);
-    ASSERT_EQ(op->source, 20);
+    ASSERT_EQ(op->source_info, 20);
 
     std::string sink(data.size(), '\0');
 
@@ -237,20 +232,18 @@ TEST_F(CowTest, ReadWriteXor) {
 
     // Note: the zero operation gets split into two blocks.
     ASSERT_EQ(op->type, kCowZeroOp);
-    ASSERT_EQ(op->compression, kCowCompressNone);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 51);
-    ASSERT_EQ(op->source, 0);
+    ASSERT_EQ(op->source_info, 0);
 
     iter->Next();
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
     ASSERT_EQ(op->type, kCowZeroOp);
-    ASSERT_EQ(op->compression, kCowCompressNone);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 52);
-    ASSERT_EQ(op->source, 0);
+    ASSERT_EQ(op->source_info, 0);
 
     iter->Next();
     ASSERT_TRUE(iter->AtEnd());
@@ -677,7 +670,7 @@ TEST_F(CowTest, AppendLabelSmall) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source, 3);
+    ASSERT_EQ(op->source_info, 3);
 
     iter->Next();
 
@@ -730,7 +723,7 @@ TEST_F(CowTest, AppendLabelMissing) {
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source, 0);
+    ASSERT_EQ(op->source_info, 0);
 
     iter->Next();
 
@@ -788,7 +781,7 @@ TEST_F(CowTest, AppendExtendedCorrupted) {
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source, 5);
+    ASSERT_EQ(op->source_info, 5);
 
     iter->Next();
     ASSERT_TRUE(iter->AtEnd());
@@ -857,7 +850,7 @@ TEST_F(CowTest, AppendbyLabel) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source, 4);
+    ASSERT_EQ(op->source_info, 4);
 
     iter->Next();
 
@@ -875,7 +868,7 @@ TEST_F(CowTest, AppendbyLabel) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source, 5);
+    ASSERT_EQ(op->source_info, 5);
 
     iter->Next();
 
@@ -928,7 +921,7 @@ TEST_F(CowTest, ClusterTest) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source, 4);
+    ASSERT_EQ(op->source_info, 4);
 
     iter->Next();
 
@@ -953,7 +946,7 @@ TEST_F(CowTest, ClusterTest) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source, 5);
+    ASSERT_EQ(op->source_info, 5);
 
     iter->Next();
 
@@ -972,7 +965,7 @@ TEST_F(CowTest, ClusterTest) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source, 6);
+    ASSERT_EQ(op->source_info, 6);
 
     iter->Next();
 
@@ -1019,7 +1012,7 @@ TEST_F(CowTest, ClusterAppendTest) {
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source, 50);
+    ASSERT_EQ(op->source_info, 50);
 
     iter->Next();
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index 699529b013f4..a52297ffc0ce 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -110,7 +110,7 @@ void CowWriterV2::SetupHeaders() {
     header_.prefix.minor_version = kCowVersionMinor;
     header_.prefix.header_size = sizeof(CowHeader);
     header_.footer_size = sizeof(CowFooter);
-    header_.op_size = sizeof(CowOperation);
+    header_.op_size = sizeof(CowOperationV2);
     header_.block_size = options_.block_size;
     header_.num_merge_ops = options_.num_merge_ops;
     header_.cluster_ops = options_.cluster_ops;
@@ -159,9 +159,9 @@ void CowWriterV2::InitBatchWrites() {
         struct iovec* cowop_ptr = cowop_vec_.get();
         struct iovec* data_ptr = data_vec_.get();
         for (size_t i = 0; i < header_.cluster_ops; i++) {
-            std::unique_ptr<CowOperation> op = std::make_unique<CowOperation>();
+            std::unique_ptr<CowOperationV2> op = std::make_unique<CowOperationV2>();
             cowop_ptr[i].iov_base = op.get();
-            cowop_ptr[i].iov_len = sizeof(CowOperation);
+            cowop_ptr[i].iov_len = sizeof(CowOperationV2);
             opbuffer_vec_.push_back(std::move(op));
 
             std::unique_ptr<uint8_t[]> buffer = std::make_unique<uint8_t[]>(header_.block_size * 2);
@@ -214,19 +214,19 @@ bool CowWriterV2::Initialize(std::optional<uint64_t> label) {
 }
 
 void CowWriterV2::InitPos() {
-    next_op_pos_ = sizeof(header_) + header_.buffer_size;
-    cluster_size_ = header_.cluster_ops * sizeof(CowOperation);
+    next_op_pos_ = sizeof(CowHeader) + header_.buffer_size;
+    cluster_size_ = header_.cluster_ops * sizeof(CowOperationV2);
     if (header_.cluster_ops) {
         next_data_pos_ = next_op_pos_ + cluster_size_;
     } else {
-        next_data_pos_ = next_op_pos_ + sizeof(CowOperation);
+        next_data_pos_ = next_op_pos_ + sizeof(CowOperationV2);
     }
     current_cluster_size_ = 0;
     current_data_size_ = 0;
 }
 
 bool CowWriterV2::OpenForWrite() {
-    // This limitation is tied to the data field size in CowOperation.
+    // This limitation is tied to the data field size in CowOperationV2.
     if (header_.block_size > std::numeric_limits<uint16_t>::max()) {
         LOG(ERROR) << "Block size is too large";
         return false;
@@ -313,7 +313,7 @@ bool CowWriterV2::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_
     CHECK(!merge_in_progress_);
 
     for (size_t i = 0; i < num_blocks; i++) {
-        CowOperation op = {};
+        CowOperationV2 op = {};
         op.type = kCowCopyOp;
         op.new_block = new_block + i;
         op.source = old_block + i;
@@ -399,7 +399,7 @@ bool CowWriterV2::EmitBlocks(uint64_t new_block_start, const void* data, size_t
         num_blocks -= pending_blocks;
 
         while (i < size / header_.block_size && pending_blocks) {
-            CowOperation op = {};
+            CowOperationV2 op = {};
             op.new_block = new_block_start + i;
             op.type = type;
             if (type == kCowXorOp) {
@@ -451,7 +451,7 @@ bool CowWriterV2::EmitBlocks(uint64_t new_block_start, const void* data, size_t
 bool CowWriterV2::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
     CHECK(!merge_in_progress_);
     for (uint64_t i = 0; i < num_blocks; i++) {
-        CowOperation op = {};
+        CowOperationV2 op = {};
         op.type = kCowZeroOp;
         op.new_block = new_block_start + i;
         op.source = 0;
@@ -462,7 +462,7 @@ bool CowWriterV2::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks)
 
 bool CowWriterV2::EmitLabel(uint64_t label) {
     CHECK(!merge_in_progress_);
-    CowOperation op = {};
+    CowOperationV2 op = {};
     op.type = kCowLabelOp;
     op.source = label;
     return WriteOperation(op) && Sync();
@@ -473,7 +473,7 @@ bool CowWriterV2::EmitSequenceData(size_t num_ops, const uint32_t* data) {
     size_t to_add = 0;
     size_t max_ops = (header_.block_size * 2) / sizeof(uint32_t);
     while (num_ops > 0) {
-        CowOperation op = {};
+        CowOperationV2 op = {};
         op.type = kCowSequenceOp;
         op.source = next_data_pos_;
         to_add = std::min(num_ops, max_ops);
@@ -489,16 +489,16 @@ bool CowWriterV2::EmitSequenceData(size_t num_ops, const uint32_t* data) {
 }
 
 bool CowWriterV2::EmitCluster() {
-    CowOperation op = {};
+    CowOperationV2 op = {};
     op.type = kCowClusterOp;
     // Next cluster starts after remainder of current cluster and the next data block.
-    op.source = current_data_size_ + cluster_size_ - current_cluster_size_ - sizeof(CowOperation);
+    op.source = current_data_size_ + cluster_size_ - current_cluster_size_ - sizeof(CowOperationV2);
     return WriteOperation(op);
 }
 
 bool CowWriterV2::EmitClusterIfNeeded() {
     // If there isn't room for another op and the cluster end op, end the current cluster
-    if (cluster_size_ && cluster_size_ < current_cluster_size_ + 2 * sizeof(CowOperation)) {
+    if (cluster_size_ && cluster_size_ < current_cluster_size_ + 2 * sizeof(CowOperationV2)) {
         if (!EmitCluster()) return false;
     }
     return true;
@@ -539,7 +539,7 @@ bool CowWriterV2::Finalize() {
         extra_cluster = true;
     }
 
-    footer_.op.ops_size = footer_.op.num_ops * sizeof(CowOperation);
+    footer_.op.ops_size = footer_.op.num_ops * sizeof(CowOperationV2);
     if (lseek(fd_.get(), next_op_pos_, SEEK_SET) < 0) {
         PLOG(ERROR) << "Failed to seek to footer position.";
         return false;
@@ -611,9 +611,9 @@ bool CowWriterV2::FlushCluster() {
 
     if (op_vec_index_) {
         ret = pwritev(fd_.get(), cowop_vec_.get(), op_vec_index_, current_op_pos_);
-        if (ret != (op_vec_index_ * sizeof(CowOperation))) {
-            PLOG(ERROR) << "pwritev failed for CowOperation. Expected: "
-                        << (op_vec_index_ * sizeof(CowOperation));
+        if (ret != (op_vec_index_ * sizeof(CowOperationV2))) {
+            PLOG(ERROR) << "pwritev failed for CowOperationV2. Expected: "
+                        << (op_vec_index_ * sizeof(CowOperationV2));
             return false;
         }
     }
@@ -635,15 +635,16 @@ bool CowWriterV2::FlushCluster() {
     return true;
 }
 
-bool CowWriterV2::WriteOperation(const CowOperation& op, const void* data, size_t size) {
+bool CowWriterV2::WriteOperation(const CowOperationV2& op, const void* data, size_t size) {
     if (!EnsureSpaceAvailable(next_op_pos_ + sizeof(op)) ||
         !EnsureSpaceAvailable(next_data_pos_ + size)) {
         return false;
     }
 
     if (batch_write_) {
-        CowOperation* cow_op = reinterpret_cast<CowOperation*>(cowop_vec_[op_vec_index_].iov_base);
-        std::memcpy(cow_op, &op, sizeof(CowOperation));
+        CowOperationV2* cow_op =
+                reinterpret_cast<CowOperationV2*>(cowop_vec_[op_vec_index_].iov_base);
+        std::memcpy(cow_op, &op, sizeof(CowOperationV2));
         op_vec_index_ += 1;
 
         if (data != nullptr && size > 0) {
@@ -681,7 +682,7 @@ bool CowWriterV2::WriteOperation(const CowOperation& op, const void* data, size_
     return EmitClusterIfNeeded();
 }
 
-void CowWriterV2::AddOperation(const CowOperation& op) {
+void CowWriterV2::AddOperation(const CowOperationV2& op) {
     footer_.op.num_ops++;
 
     if (op.type == kCowClusterOp) {
@@ -693,7 +694,7 @@ void CowWriterV2::AddOperation(const CowOperation& op) {
     }
 
     next_data_pos_ += op.data_length + GetNextDataOffset(op, header_.cluster_ops);
-    next_op_pos_ += sizeof(CowOperation) + GetNextOpOffset(op, header_.cluster_ops);
+    next_op_pos_ += sizeof(CowOperationV2) + GetNextOpOffset(op, header_.cluster_ops);
 }
 
 bool CowWriterV2::WriteRawData(const void* data, const size_t size) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
index 131a068455ba..c72a9b47c5d7 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
@@ -50,8 +50,8 @@ class CowWriterV2 : public CowWriterBase {
     bool OpenForAppend(uint64_t label);
     bool GetDataPos(uint64_t* pos);
     bool WriteRawData(const void* data, size_t size);
-    bool WriteOperation(const CowOperation& op, const void* data = nullptr, size_t size = 0);
-    void AddOperation(const CowOperation& op);
+    bool WriteOperation(const CowOperationV2& op, const void* data = nullptr, size_t size = 0);
+    void AddOperation(const CowOperationV2& op);
     void InitPos();
     void InitBatchWrites();
     void InitWorkers();
@@ -84,7 +84,7 @@ class CowWriterV2 : public CowWriterBase {
     std::vector<std::basic_string<uint8_t>> compressed_buf_;
     std::vector<std::basic_string<uint8_t>>::iterator buf_iter_;
 
-    std::vector<std::unique_ptr<CowOperation>> opbuffer_vec_;
+    std::vector<std::unique_ptr<CowOperationV2>> opbuffer_vec_;
     std::vector<std::unique_ptr<uint8_t[]>> databuffer_vec_;
     std::unique_ptr<struct iovec[]> cowop_vec_;
     int op_vec_index_ = 0;

From 4ac5b76d9661d77f79f4cad7476d207bf5c96d3d Mon Sep 17 00:00:00 2001
From: Harsh Abichandani <harsh.abichandani@ittiam.com>
Date: Fri, 23 Jun 2023 14:51:16 +0530
Subject: [PATCH 0435/1487] Added liblp_apis_fuzzer

exec/s: 9393
Test: ./liblp_apis_fuzzer
Bug: 285829660

Change-Id: I9830baf7ffbcffa7571aea75e69d1ced64fe613a
---
 fs_mgr/liblp/fuzzer/Android.bp            | 143 +++++++++++++
 fs_mgr/liblp/fuzzer/README.md             |  43 ++++
 fs_mgr/liblp/fuzzer/image_gen_rand.py     |  32 +++
 fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp | 243 ++++++++++++++++++++++
 4 files changed, 461 insertions(+)
 create mode 100644 fs_mgr/liblp/fuzzer/image_gen_rand.py
 create mode 100644 fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp

diff --git a/fs_mgr/liblp/fuzzer/Android.bp b/fs_mgr/liblp/fuzzer/Android.bp
index bdeb377bfe4e..a9e3509af7fa 100644
--- a/fs_mgr/liblp/fuzzer/Android.bp
+++ b/fs_mgr/liblp/fuzzer/Android.bp
@@ -56,3 +56,146 @@ cc_fuzz {
     srcs: ["liblp_super_layout_builder_fuzzer.cpp"],
     defaults: ["liblp_fuzz_defaults"],
 }
+
+python_binary_host {
+    name: "image_gen_rand",
+    srcs: ["image_gen_rand.py"],
+}
+
+genrule_defaults {
+    name: "test_data_gen_defaults",
+    tools: [
+        "image_gen_rand",
+    ],
+}
+
+// Fake dtb image.
+genrule {
+    name: "test_dtb",
+    defaults: ["test_data_gen_defaults"],
+    out: ["test_dtb.img"],
+    cmd: "$(location image_gen_rand) --seed dtb --length 1024 > $(out)",
+}
+
+// Fake bootconfig image.
+genrule {
+    name: "test_bootconfig",
+    defaults: ["test_data_gen_defaults"],
+    out: ["test_bootconfig.img"],
+    cmd: "$(location image_gen_rand) --seed bootconfig --length 1024 > $(out)",
+}
+
+// Fake vendor ramdisk with type "none".
+genrule {
+    name: "test_vendor_ramdisk_none",
+    defaults: ["test_data_gen_defaults"],
+    out: ["test_vendor_ramdisk_none.img"],
+    cmd: "$(location image_gen_rand) --seed vendor_ramdisk_none --length 1024 > $(out)",
+}
+
+// Fake vendor ramdisk with type "platform".
+genrule {
+    name: "test_vendor_ramdisk_platform",
+    defaults: ["test_data_gen_defaults"],
+    out: ["test_vendor_ramdisk_platform.img"],
+    cmd: "$(location image_gen_rand) --seed vendor_ramdisk_platform --length 1024 > $(out)",
+}
+
+// Fake replacement ramdisk.
+genrule {
+    name: "test_vendor_ramdisk_replace",
+    defaults: ["test_data_gen_defaults"],
+    out: ["test_vendor_ramdisk_replace.img"],
+    cmd: "$(location image_gen_rand) --seed replace --length 3072 > $(out)",
+}
+
+// Genrules for test vendor boot images.
+fastboot_sign_test_image = "$(location avbtool) add_hash_footer --salt 00 --image $(out) " +
+    "--partition_name vendor_boot --partition_size $$(( 1 * 1024 * 1024 ))"
+
+genrule_defaults {
+    name: "test_vendor_boot_gen_defaults",
+    defaults: ["test_data_gen_defaults"],
+    tools: [
+        "avbtool",
+        "mkbootimg",
+    ],
+}
+
+genrule {
+    name: "test_vendor_boot_v3",
+    defaults: ["test_vendor_boot_gen_defaults"],
+    out: ["test_vendor_boot_v3.img"],
+    srcs: [
+        ":test_dtb",
+        ":test_vendor_ramdisk_none",
+    ],
+    cmd: "$(location mkbootimg) --header_version 3 " +
+        "--vendor_ramdisk $(location :test_vendor_ramdisk_none) " +
+        "--dtb $(location :test_dtb) " +
+        "--vendor_boot $(out) && " +
+        fastboot_sign_test_image,
+}
+
+genrule {
+    name: "test_vendor_boot_v4_without_frag",
+    defaults: ["test_vendor_boot_gen_defaults"],
+    out: ["test_vendor_boot_v4_without_frag.img"],
+    srcs: [
+        ":test_dtb",
+        ":test_vendor_ramdisk_none",
+        ":test_bootconfig",
+    ],
+    cmd: "$(location mkbootimg) --header_version 4 " +
+        "--vendor_ramdisk $(location :test_vendor_ramdisk_none) " +
+        "--dtb $(location :test_dtb) " +
+        "--vendor_bootconfig $(location :test_bootconfig) " +
+        "--vendor_boot $(out) && " +
+        fastboot_sign_test_image,
+}
+
+genrule {
+    name: "test_vendor_boot_v4_with_frag",
+    defaults: ["test_vendor_boot_gen_defaults"],
+    out: ["test_vendor_boot_v4_with_frag.img"],
+    srcs: [
+        ":test_dtb",
+        ":test_vendor_ramdisk_none",
+        ":test_vendor_ramdisk_platform",
+        ":test_bootconfig",
+    ],
+    cmd: "$(location mkbootimg) --header_version 4 " +
+        "--dtb $(location :test_dtb) " +
+        "--vendor_bootconfig $(location :test_bootconfig) " +
+        "--ramdisk_type none --ramdisk_name none_ramdisk " +
+        "--vendor_ramdisk_fragment $(location :test_vendor_ramdisk_none) " +
+        "--ramdisk_type platform --ramdisk_name platform_ramdisk " +
+        "--vendor_ramdisk_fragment $(location :test_vendor_ramdisk_platform) " +
+        "--vendor_boot $(out) && " +
+        fastboot_sign_test_image,
+}
+
+cc_fuzz {
+    name: "liblp_apis_fuzzer",
+    srcs: [
+        "liblp_apis_fuzzer.cpp",
+        ":TestPartitionOpener_group",
+    ],
+    defaults: ["liblp_fuzz_defaults"],
+    shared_libs: [
+        "libsparse",
+    ],
+    data: [
+        ":test_dtb",
+        ":test_bootconfig",
+        ":test_vendor_ramdisk_none",
+        ":test_vendor_ramdisk_platform",
+        ":test_vendor_ramdisk_replace",
+        ":test_vendor_boot_v3",
+        ":test_vendor_boot_v4_without_frag",
+        ":test_vendor_boot_v4_with_frag",
+    ],
+    cflags: [
+      "-Wno-unused-parameter",
+   ],
+}
diff --git a/fs_mgr/liblp/fuzzer/README.md b/fs_mgr/liblp/fuzzer/README.md
index be9adbd8e535..f831e2e5db8e 100644
--- a/fs_mgr/liblp/fuzzer/README.md
+++ b/fs_mgr/liblp/fuzzer/README.md
@@ -2,6 +2,7 @@
 ## Table of contents
 +  [liblp_builder_fuzzer](#Builder)
 +  [liblp_super_layout_builder_fuzzer](#SuperBuilder)
++  [liblp_apis_fuzzer](#APIs)
 
 # <a  name="Builder"></a> Fuzzer for LiblpBuilder
 
@@ -91,3 +92,45 @@ SuperLayoutBuilder supports the following parameters:
   $ adb sync data
   $ adb shell /data/fuzz/arm64/liblp_super_layout_builder_fuzzer/liblp_super_layout_builder_fuzzer
 ```
+
+# <a  name="APIs"></a> Fuzzer for LiblpApis
+
+LiblpAPIs supports the following parameters:
+1. blockDeviceInfoSize (parameter name: "block_device_info_size")
+2. alignment (parameter name: "alignment")
+3. alignmentOffset (parameter name: "alignment_offset")
+4. logicalBlockSize (parameter name: "logical_block_size")
+5. blockDevSize (parameter name: "blockdev_size")
+6. metadataMaxSize (parameter name: "metadata_max_size")
+7. metadataSlotCount (parameter name: "metadata_slot_count")
+8. blockDeviceInfoName (parameter name: "block_device_info_name")
+9. numSectors (parameter name: "num_sectors")
+10. physicalSector (parameter name: "physical_sector")
+11. sparsify (parameter name: "sparsify")
+12. buffer (parameter name: "data")
+
+| Parameter| Valid Values| Configured Value|
+|------------- |-------------| ----- |
+|`blockDeviceInfoSize`| Integer |Value obtained from FuzzedDataProvider|
+|`alignment`| Integer |Value obtained from FuzzedDataProvider|
+|`alignmentOffset`| Integer |Value obtained from FuzzedDataProvider|
+|`logicalBlockSize`| Integer |Value obtained from FuzzedDataProvider|
+|`blockDevSize`| Integer value in multiples of `LP_SECTOR_SIZE`|Value obtained from FuzzedDataProvider|
+|`metadataMaxSize`| Integer value from `0` to `10000` |Value obtained from FuzzedDataProvider|
+|`metadataSlotCount`| Integer value from `0` to `2` |Value obtained from FuzzedDataProvider|
+|`blockDeviceInfoName`| String |Value obtained from FuzzedDataProvider|
+|`numSectors`| Integer value from `1` to `1000000` |Value obtained from FuzzedDataProvider|
+|`physicalSector`| Integer value from `1` to `1000000` |Value obtained from FuzzedDataProvider|
+|`alignment`| Bool |Value obtained from FuzzedDataProvider|
+|`alignment`| Vector |Value obtained from FuzzedDataProvider|
+
+#### Steps to run
+1. Build the fuzzer
+```
+  $ mm -j$(nproc) liblp_apis_fuzzer
+```
+2. Run on device
+```
+  $ adb sync data
+  $ adb shell /data/fuzz/arm64/liblp_apis_fuzzer/liblp_apis_fuzzer
+```
diff --git a/fs_mgr/liblp/fuzzer/image_gen_rand.py b/fs_mgr/liblp/fuzzer/image_gen_rand.py
new file mode 100644
index 000000000000..6e8547276102
--- /dev/null
+++ b/fs_mgr/liblp/fuzzer/image_gen_rand.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2023 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.
+
+"""
+Write given number of random bytes, generated with optional seed.
+"""
+
+import random, argparse
+
+if __name__ == '__main__':
+  parser = argparse.ArgumentParser(description=__doc__)
+  parser.add_argument('--seed', help='Seed to random generator')
+  parser.add_argument('--length', type=int, required=True, help='Length of output')
+  args = parser.parse_args()
+
+  if args.seed:
+    random.seed(args.seed)
+
+  print(''.join(chr(random.randrange(0,0xff)) for _ in range(args.length)))
diff --git a/fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp b/fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp
new file mode 100644
index 000000000000..b6fbc142a0c9
--- /dev/null
+++ b/fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp
@@ -0,0 +1,243 @@
+/*
+ * Copyright (C) 2023 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 <android-base/file.h>
+#include <fcntl.h>
+#include <fuzzer/FuzzedDataProvider.h>
+#include <liblp/builder.h>
+#include <liblp/partition_opener.h>
+#include <linux/memfd.h>
+#include <sys/syscall.h>
+#include <writer.h>
+#include "images.h"
+#include "test_partition_opener.h"
+
+using namespace std;
+using namespace android;
+using namespace android::fs_mgr;
+using unique_fd = android::base::unique_fd;
+
+static constexpr size_t kDiskSize = 131072;
+static constexpr size_t kMetadataSize = 512;
+static constexpr size_t kMetadataSlots = 2;
+static constexpr uint32_t kMaxBytes = 20;
+static constexpr uint32_t kValidAlignment = 0;
+static constexpr uint32_t kValidAlignmentOffset = 0;
+static constexpr uint32_t kValidLogicalBlockSize = 4096;
+static constexpr uint32_t kMinMetadataSize = 0;
+static constexpr uint32_t kMaxMetadataSize = 10000;
+static constexpr uint32_t kMinSlot = 0;
+static constexpr uint32_t kMaxSlot = 10;
+static constexpr uint32_t kMinFactor = 0;
+static constexpr uint32_t kMaxFactor = 10;
+static constexpr uint32_t kMetadataGeometrySize = 4096;
+static constexpr uint64_t kValidNumSectors = 1901568;
+static constexpr uint64_t kValidPhysicalSector = 3608576;
+static constexpr uint64_t kMinSectorValue = 1;
+static constexpr uint64_t kMaxSectorValue = 1000000;
+static constexpr uint64_t kMaxBufferSize = 100000;
+
+const string kImageFile = "image_file";
+const string kSuperName = "super";
+const string kSystemPartitionName = "system";
+const string kPartitionName = "builder_partition";
+const string kSuperPartitionName = "super_partition";
+
+const string kSuffix[] = {"_a", "_b", "a", "b"};
+
+class LiplpApisFuzzer {
+  public:
+    LiplpApisFuzzer(const uint8_t* data, size_t size) : mFdp(data, size){};
+    void process();
+
+  private:
+    void setupBuilder();
+    BlockDeviceInfo getBlockDevice();
+    FuzzedDataProvider mFdp;
+    unique_ptr<MetadataBuilder> mBuilder;
+    string mBlockDeviceInfoName;
+    string mSuperPartitionName;
+    string mPartitionName;
+    const string mImagePaths[10] = {
+            "data/test_dtb.img",
+            "data/test_bootconfig.img",
+            "data/test_vendor_ramdisk_none.img",
+            "data/test_vendor_ramdisk_platform.img",
+            "data/test_vendor_ramdisk_replace.img",
+            "data/test_vendor_boot_v4_with_frag.img",
+            "data/test_vendor_boot_v4_without_frag.img",
+            "data/test_vendor_boot_v3.img",
+            "dev/null",
+            mFdp.ConsumeRandomLengthString(kMaxBytes),
+    };
+};
+
+BlockDeviceInfo LiplpApisFuzzer::getBlockDevice() {
+    mBlockDeviceInfoName =
+            mFdp.ConsumeBool() ? kSuperName : mFdp.ConsumeRandomLengthString(kMaxBytes);
+    uint64_t blockDeviceInfoSize =
+            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint64_t>() : kDiskSize;
+    uint32_t alignment = mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>() : kValidAlignment;
+    uint32_t alignmentOffset =
+            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>() : kValidAlignmentOffset;
+    uint32_t logicalBlockSize =
+            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>() : kValidLogicalBlockSize;
+
+    BlockDeviceInfo superInfo{mBlockDeviceInfoName, blockDeviceInfoSize, alignment, alignmentOffset,
+                              logicalBlockSize};
+    return superInfo;
+}
+
+void LiplpApisFuzzer::setupBuilder() {
+    uint64_t randomBlockDevSize =
+            mFdp.ConsumeIntegralInRange<uint64_t>(kMinFactor, kMaxFactor) * LP_SECTOR_SIZE;
+    uint64_t blockDevSize = mFdp.ConsumeBool() ? randomBlockDevSize : kDiskSize;
+    uint32_t randomMetadataMaxSize =
+            mFdp.ConsumeIntegralInRange<uint32_t>(kMinMetadataSize, kMaxMetadataSize);
+    uint32_t metadataMaxSize = mFdp.ConsumeBool() ? kMetadataSize : randomMetadataMaxSize;
+    uint32_t metadataSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(kMinSlot, kMaxSlot);
+    mBuilder = MetadataBuilder::New(blockDevSize, metadataMaxSize, metadataSlotCount);
+
+    if (mBuilder.get()) {
+        mBuilder->AddPartition(kSystemPartitionName, LP_PARTITION_ATTR_READONLY);
+
+        mPartitionName =
+                mFdp.ConsumeBool() ? mFdp.ConsumeRandomLengthString(kMaxBytes) : kPartitionName;
+        if (!mPartitionName.size()) {
+            mPartitionName = kPartitionName;
+        }
+        mSuperPartitionName = mFdp.ConsumeBool() ? mFdp.ConsumeRandomLengthString(kMaxBytes)
+                                                 : kSuperPartitionName;
+        if (!mSuperPartitionName.size()) {
+            mSuperPartitionName = kSuperPartitionName;
+        }
+
+        Partition* super = mBuilder->AddPartition(mSuperPartitionName, LP_PARTITION_ATTR_READONLY);
+        mBuilder->AddPartition(mPartitionName, LP_PARTITION_ATTR_READONLY);
+
+        int64_t numSectors = mFdp.ConsumeBool() ? mFdp.ConsumeIntegralInRange<uint64_t>(
+                                                          kMinSectorValue, kMaxSectorValue)
+                                                : kValidNumSectors;
+        int64_t physicalSector = mFdp.ConsumeBool() ? mFdp.ConsumeIntegralInRange<uint64_t>(
+                                                              kMinSectorValue, kMaxSectorValue)
+                                                    : kValidPhysicalSector;
+
+        mBuilder->AddLinearExtent(super, mBlockDeviceInfoName, numSectors, physicalSector);
+    }
+}
+
+void LiplpApisFuzzer::process() {
+    BlockDeviceInfo superInfo = getBlockDevice();
+    unique_fd fd(syscall(__NR_memfd_create, "image_file", MFD_ALLOW_SEALING));
+    setupBuilder();
+
+    TestPartitionOpener opener(
+            {{mFdp.ConsumeBool() ? mFdp.ConsumeRandomLengthString(kMaxBytes) : kSuperName, fd}},
+            {{mFdp.ConsumeBool() ? mFdp.ConsumeRandomLengthString(kMaxBytes) : kSuperName,
+              superInfo}});
+
+    if (mBuilder.get()) {
+        unique_ptr<LpMetadata> metadata = mBuilder->Export();
+        const LpMetadata& metadataValue = *metadata.get();
+
+        map<string, string> images = {};
+        if (mFdp.ConsumeBool()) {
+            images[mSuperPartitionName] = mFdp.PickValueInArray(mImagePaths);
+        }
+
+        while (mFdp.remaining_bytes()) {
+            auto invokeAPIs = mFdp.PickValueInArray<const function<void()>>({
+                    [&]() { WriteToImageFile(fd, metadataValue); },
+                    [&]() { WriteToImageFile(kImageFile.c_str(), metadataValue); },
+                    [&]() { FlashPartitionTable(opener, kSuperName, metadataValue); },
+                    [&]() {
+                        UpdatePartitionTable(opener, mPartitionName, metadataValue,
+                                             mFdp.ConsumeBool() ? 0 : 1 /* slot_number */);
+                    },
+                    [&]() {
+                        ReadMetadata(mPartitionName, mFdp.ConsumeBool() ? 0 : 1 /* slot_number */);
+                    },
+                    [&]() { FlashPartitionTable(mPartitionName, metadataValue); },
+                    [&]() {
+                        UpdatePartitionTable(mPartitionName, metadataValue,
+                                             mFdp.ConsumeBool() ? 0 : 1 /* slot_number */);
+                    },
+                    [&]() {
+                        WriteToImageFile(kImageFile.c_str(), metadataValue,
+                                         metadata->geometry.logical_block_size, images,
+                                         mFdp.ConsumeBool() ? true : false /* sparsify */);
+                    },
+
+                    [&]() {
+                        WriteSplitImageFiles(kImageFile.c_str(), metadataValue,
+                                             metadata->geometry.logical_block_size, images,
+                                             mFdp.ConsumeBool() ? true : false /* sparsify */);
+                    },
+                    [&]() { ReadFromImageFile(kImageFile.c_str()); },
+                    [&]() { IsEmptySuperImage(kImageFile.c_str()); },
+                    [&]() {
+                        uint64_t bufferSize = mFdp.ConsumeIntegralInRange<uint64_t>(
+                                2 * kMetadataGeometrySize, kMaxBufferSize);
+                        vector<uint8_t> buffer = mFdp.ConsumeBytes<uint8_t>(kMaxBytes);
+                        buffer.resize(bufferSize);
+                        ReadFromImageBlob(buffer.data(), buffer.size());
+                    },
+                    [&]() {
+                        uint32_t groupVectorSize = metadata->groups.size();
+                        uint32_t randomGroupIndex =
+                                mFdp.ConsumeIntegralInRange<uint32_t>(0, groupVectorSize);
+                        GetPartitionGroupName(metadata->groups[randomGroupIndex]);
+                    },
+                    [&]() {
+                        uint32_t blockDeviceVectorSize = metadata->block_devices.size();
+                        uint32_t randomBlockDeviceIndex =
+                                mFdp.ConsumeIntegralInRange<uint32_t>(0, blockDeviceVectorSize);
+                        GetBlockDevicePartitionName(
+                                metadata->block_devices[randomBlockDeviceIndex]);
+                    },
+                    [&]() { GetMetadataSuperBlockDevice(metadataValue); },
+                    [&]() {
+                        string suffix = mFdp.ConsumeBool()
+                                                ? mFdp.PickValueInArray<string>(kSuffix)
+                                                : mFdp.ConsumeRandomLengthString(kMaxBytes);
+                        SlotNumberForSlotSuffix(suffix);
+                    },
+                    [&]() {
+                        auto entry = FindPartition(metadataValue, kSystemPartitionName);
+                        GetPartitionSize(metadataValue, *entry);
+                    },
+                    [&]() { GetPartitionSlotSuffix(mPartitionName); },
+                    [&]() { FindPartition(metadataValue, mPartitionName); },
+                    [&]() {
+                        uint32_t partitionVectorSize = metadata->partitions.size();
+                        uint32_t randomPartitionIndex =
+                                mFdp.ConsumeIntegralInRange<uint32_t>(0, partitionVectorSize);
+                        GetPartitionName(metadata->partitions[randomPartitionIndex]);
+                    },
+                    [&]() { GetTotalSuperPartitionSize(metadataValue); },
+                    [&]() { GetBlockDevicePartitionNames(metadataValue); },
+            });
+            invokeAPIs();
+        }
+        remove(kImageFile.c_str());
+    }
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+    LiplpApisFuzzer liplpApisFuzzer(data, size);
+    liplpApisFuzzer.process();
+    return 0;
+}

From cffa413de4e91c62893b57959ac44b058d380e4a Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 2 Oct 2023 22:22:36 -0700
Subject: [PATCH 0436/1487] snapuserd: I/O request on overlapping blocks during
 snapshot-merge.

This fixes the case when all the following conditions are true:

1: Incremental OTA
2: When there are sequence of overlapping COPY operations within one merge-window
   (510 blocks)
3: Device is rebooted when snapshot-merge is in-progress of this
   merge-window. When device reboots, the state of merge-window (of 510 blocks) was
   merge-in-progress (aka - only partial set of blocks were merged in
   this window thereby the state of the base device is in-complete for
   this window)
4: During the next boot, if there any I/O request from the filesystem
   which maps to the merge-window in (3):
   	a: The data has to be retrieved from the scratch space of the
	COW until the snapshot-merge for that window is completed.

	b: Once the snapshot-merge is complete for that window, data
	has to be retrieved from base device.

The bug was in step 4(a) wherein I/O request was getting routed to base
device.

This patch addresses the above flow by fixing step 4(a).

A new vts test has been added to explicitly track this issue.

Additionally, there is no need to re-scan the partition if partition is in merge resume path. This should cut down the overhead of the scan.

Bug: 275296365
Test: 1: 100 iterations of ./vts_snapuserd_test --gtest_filter=SnapuserdTest.Snapshot_COPY_Overlap_Merge_Resume_IO_Validate_TEST
2: Incremental OTA on Pixel 6 Pro with multiple iterations of device
   reboot when merge is in progress

Change-Id: Ib53be7f07ff192a84ec7f7049b2c6be01dad1041
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../user-space-merge/snapuserd_core.cpp       | 13 ++-
 .../user-space-merge/snapuserd_core.h         |  4 +
 .../user-space-merge/snapuserd_readahead.cpp  |  9 +-
 .../user-space-merge/snapuserd_test.cpp       | 95 +++++++++++++++++++
 .../snapuserd_transitions.cpp                 | 28 +++++-
 5 files changed, 145 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index c2958512d1c1..e886ec399bee 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -173,6 +173,10 @@ bool SnapshotHandler::ReadMetadata() {
     }
 
     SNAP_LOG(INFO) << "Merge-ops: " << header.num_merge_ops;
+    if (header.num_merge_ops) {
+        resume_merge_ = true;
+        SNAP_LOG(INFO) << "Resume Snapshot-merge";
+    }
 
     if (!MmapMetadata()) {
         SNAP_LOG(ERROR) << "mmap failed";
@@ -295,6 +299,11 @@ bool SnapshotHandler::Start() {
     if (ra_thread_) {
         ra_thread_status =
                 std::async(std::launch::async, &ReadAhead::RunThread, read_ahead_thread_.get());
+        // If this is a merge-resume path, wait until RA thread is fully up as
+        // the data has to be re-constructed from the scratch space.
+        if (resume_merge_ && ShouldReconstructDataFromCow()) {
+            WaitForRaThreadToStart();
+        }
     }
 
     // Launch worker threads
@@ -307,7 +316,9 @@ bool SnapshotHandler::Start() {
             std::async(std::launch::async, &MergeWorker::Run, merge_thread_.get());
 
     // Now that the worker threads are up, scan the partitions.
-    if (perform_verification_) {
+    // If the snapshot-merge is being resumed, there is no need to scan as the
+    // current slot is already marked as boot complete.
+    if (perform_verification_ && !resume_merge_) {
         update_verify_->VerifyUpdatePartition();
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index e401c118e893..f88406d2aa46 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -147,6 +147,8 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     void WakeupMonitorMergeThread();
     void WaitForMergeComplete();
     bool WaitForMergeBegin();
+    void RaThreadStarted();
+    void WaitForRaThreadToStart();
     void NotifyRAForMergeReady();
     bool WaitForMergeReady();
     void MergeFailed();
@@ -221,6 +223,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     // Read-ahead related
     bool populate_data_from_cow_ = false;
     bool ra_thread_ = false;
+    bool ra_thread_started_ = false;
     int total_ra_blocks_merged_ = 0;
     MERGE_IO_TRANSITION io_state_ = MERGE_IO_TRANSITION::INVALID;
     std::unique_ptr<ReadAhead> read_ahead_thread_;
@@ -242,6 +245,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     bool scratch_space_ = false;
     int num_worker_threads_ = kNumWorkerThreads;
     bool perform_verification_ = true;
+    bool resume_merge_ = false;
 
     std::unique_ptr<struct io_uring> ring_;
     std::unique_ptr<UpdateVerify> update_verify_;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index d2128c5d02fa..998d233d5ad1 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -206,6 +206,7 @@ bool ReadAhead::ReconstructDataFromCow() {
         return false;
     }
 
+    snapuserd_->RaThreadStarted();
     SNAP_LOG(INFO) << "ReconstructDataFromCow success";
     notify_read_ahead_failed.Cancel();
     return true;
@@ -716,9 +717,13 @@ bool ReadAhead::ReadAheadIOStart() {
     total_ra_blocks_completed_ += total_blocks_merged_;
     snapuserd_->SetMergedBlockCountForNextCommit(total_blocks_merged_);
 
-    // Flush the data only if we have a overlapping blocks in the region
+    // Flush the scratch data - Technically, we should flush only for overlapping
+    // blocks; However, since this region is mmap'ed, the dirty pages can still
+    // get flushed to disk at any random point in time. Instead, make sure
+    // the data in scratch is in the correct state before merge thread resumes.
+    //
     // Notify the Merge thread to resume merging this window
-    if (!snapuserd_->ReadAheadIOCompleted(overlap_)) {
+    if (!snapuserd_->ReadAheadIOCompleted(true)) {
         SNAP_LOG(ERROR) << "ReadAheadIOCompleted failed...";
         snapuserd_->ReadAheadIOFailed();
         return false;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 620ecbd3f102..65f31cf7c7cb 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -235,9 +235,11 @@ class SnapuserdTest : public SnapuserdTestBase {
     bool Merge();
     void ValidateMerge();
     void ReadSnapshotDeviceAndValidate();
+    void ReadSnapshotAndValidateOverlappingBlocks();
     void Shutdown();
     void MergeInterrupt();
     void MergeInterruptFixed(int duration);
+    void MergeInterruptAndValidate(int duration);
     void MergeInterruptRandomly(int max_duration);
     bool StartMerge();
     void CheckMergeCompletion();
@@ -358,6 +360,76 @@ void SnapuserdTest::ReadSnapshotDeviceAndValidate() {
     ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + (size_ * 4), size_), 0);
 }
 
+void SnapuserdTest::ReadSnapshotAndValidateOverlappingBlocks() {
+    // Open COW device
+    unique_fd fd(open(cow_system_->path, O_RDONLY));
+    ASSERT_GE(fd, 0);
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(fd));
+
+    const auto& header = reader.GetHeader();
+    size_t total_mapped_addr_length = header.prefix.header_size + BUFFER_REGION_DEFAULT_SIZE;
+
+    ASSERT_GE(header.prefix.major_version, 2);
+
+    void* mapped_addr = mmap(NULL, total_mapped_addr_length, PROT_READ, MAP_SHARED, fd.get(), 0);
+    ASSERT_NE(mapped_addr, MAP_FAILED);
+
+    bool populate_data_from_scratch = false;
+    struct BufferState* ra_state =
+            reinterpret_cast<struct BufferState*>((char*)mapped_addr + header.prefix.header_size);
+    if (ra_state->read_ahead_state == kCowReadAheadDone) {
+        populate_data_from_scratch = true;
+    }
+
+    size_t num_merge_ops = header.num_merge_ops;
+    // We have some partial merge operations completed.
+    // To test the merge-resume path, forcefully corrupt the data of the base
+    // device for the offsets where the merge is still pending.
+    if (num_merge_ops && populate_data_from_scratch) {
+        std::string corrupt_buffer(4096, 0);
+        // Corrupt two blocks from the point where the merge has to be resumed by
+        // writing down zeroe's.
+        //
+        // Now, since this is a merge-resume path, the "correct" data should be
+        // in the scratch space of the COW device. When there is an I/O request
+        // from the snapshot device, the data has to be retrieved from the
+        // scratch space. If not and I/O is routed to the base device, we
+        // may end up with corruption.
+        off_t corrupt_offset = (num_merge_ops + 2) * 4096;
+
+        if (corrupt_offset < size_) {
+            ASSERT_EQ(android::base::WriteFullyAtOffset(base_fd_, (void*)corrupt_buffer.c_str(),
+                                                        4096, corrupt_offset),
+                      true);
+            corrupt_offset -= 4096;
+            ASSERT_EQ(android::base::WriteFullyAtOffset(base_fd_, (void*)corrupt_buffer.c_str(),
+                                                        4096, corrupt_offset),
+                      true);
+            fsync(base_fd_.get());
+        }
+    }
+
+    // Time to read the snapshot device.
+    unique_fd snapshot_fd(open(dmuser_dev_->GetPath().c_str(), O_RDONLY | O_DIRECT | O_SYNC));
+    ASSERT_GE(snapshot_fd, 0);
+
+    void* buff_addr;
+    ASSERT_EQ(posix_memalign(&buff_addr, 4096, size_), 0);
+
+    std::unique_ptr<void, decltype(&::free)> snapshot_buffer(buff_addr, ::free);
+
+    // Scan the entire snapshot device and read the data and verify data
+    // integrity. Since the base device was forcefully corrupted, the data from
+    // this scan should be retrieved from scratch space of the COW partition.
+    //
+    // Furthermore, after the merge is complete, base device data is again
+    // verified as the aforementioned corrupted blocks aren't persisted.
+    ASSERT_EQ(ReadFullyAtOffset(snapshot_fd, snapshot_buffer.get(), size_, 0), true);
+    ASSERT_EQ(memcmp(snapshot_buffer.get(), orig_buffer_.get(), size_), 0);
+}
+
 void SnapuserdTest::CreateCowDeviceWithCopyOverlap_2() {
     auto writer = CreateCowDeviceInternal();
     ASSERT_NE(writer, nullptr);
@@ -665,6 +737,20 @@ void SnapuserdTest::MergeInterruptFixed(int duration) {
     ASSERT_TRUE(Merge());
 }
 
+void SnapuserdTest::MergeInterruptAndValidate(int duration) {
+    ASSERT_TRUE(StartMerge());
+
+    for (int i = 0; i < 15; i++) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(duration));
+        ASSERT_NO_FATAL_FAILURE(SimulateDaemonRestart());
+        ReadSnapshotAndValidateOverlappingBlocks();
+        ASSERT_TRUE(StartMerge());
+    }
+
+    ASSERT_NO_FATAL_FAILURE(SimulateDaemonRestart());
+    ASSERT_TRUE(Merge());
+}
+
 void SnapuserdTest::MergeInterrupt() {
     // Interrupt merge at various intervals
     ASSERT_TRUE(StartMerge());
@@ -761,6 +847,15 @@ TEST_F(SnapuserdTest, Snapshot_COPY_Overlap_Merge_Resume_TEST) {
     ValidateMerge();
 }
 
+TEST_F(SnapuserdTest, Snapshot_COPY_Overlap_Merge_Resume_IO_Validate_TEST) {
+    if (!harness_->HasUserDevice()) {
+        GTEST_SKIP() << "Skipping snapshot read; not supported";
+    }
+    ASSERT_NO_FATAL_FAILURE(SetupCopyOverlap_2());
+    ASSERT_NO_FATAL_FAILURE(MergeInterruptAndValidate(2));
+    ValidateMerge();
+}
+
 TEST_F(SnapuserdTest, Snapshot_Merge_Crash_Fixed_Ordered) {
     ASSERT_NO_FATAL_FAILURE(SetupOrderedOps());
     ASSERT_NO_FATAL_FAILURE(MergeInterruptFixed(300));
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
index f3e00195266a..8d090bf58955 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
@@ -366,6 +366,26 @@ void SnapshotHandler::WaitForMergeComplete() {
     }
 }
 
+void SnapshotHandler::RaThreadStarted() {
+    std::unique_lock<std::mutex> lock(lock_);
+    ra_thread_started_ = true;
+}
+
+void SnapshotHandler::WaitForRaThreadToStart() {
+    auto now = std::chrono::system_clock::now();
+    auto deadline = now + 3s;
+    {
+        std::unique_lock<std::mutex> lock(lock_);
+        while (!ra_thread_started_) {
+            auto status = cv.wait_until(lock, deadline);
+            if (status == std::cv_status::timeout) {
+                SNAP_LOG(ERROR) << "Read-ahead thread did not start";
+                return;
+            }
+        }
+    }
+}
+
 std::string SnapshotHandler::GetMergeStatus() {
     bool merge_not_initiated = false;
     bool merge_monitored = false;
@@ -618,7 +638,6 @@ bool SnapshotHandler::GetRABuffer(std::unique_lock<std::mutex>* lock, uint64_t b
     std::unordered_map<uint64_t, void*>::iterator it = read_ahead_buffer_map_.find(block);
 
     if (it == read_ahead_buffer_map_.end()) {
-        SNAP_LOG(ERROR) << "Block: " << block << " not found in RA buffer";
         return false;
     }
 
@@ -642,6 +661,13 @@ MERGE_GROUP_STATE SnapshotHandler::ProcessMergingBlock(uint64_t new_block, void*
         MERGE_GROUP_STATE state = blk_state->merge_state_;
         switch (state) {
             case MERGE_GROUP_STATE::GROUP_MERGE_PENDING: {
+                // If this is a merge-resume path, check if the data is
+                // available from scratch space. Data from scratch space takes
+                // higher precedence than from source device for overlapping
+                // blocks.
+                if (resume_merge_ && GetRABuffer(&lock, new_block, buffer)) {
+                    return (MERGE_GROUP_STATE::GROUP_MERGE_IN_PROGRESS);
+                }
                 blk_state->num_ios_in_progress += 1;  // ref count
                 [[fallthrough]];
             }

From 7fa8dd655ac242fef79184a611aa9e5d7a8c62eb Mon Sep 17 00:00:00 2001
From: Harry Pan <gspj@google.com>
Date: Tue, 3 Oct 2023 17:48:26 +0000
Subject: [PATCH 0437/1487] Add new fastbootd battery-soc variable

Introduce new battery-soc variable to read battery
SSOC, this benefits manufacturing to better track
the SSOC after FSI image flashing in the userspace
fastbootd using the same approach as Android space,
otherwise it is difficult to implement the entire
battery SW stack from Android to fastboot bootloader
and generate the same test experience monotonically.

Bug: 303561559
Test: fastboot getvar battery-soc # in fastbootd
Change-Id: Ia3f68e314263d7dd4d4c45a908a0a49db6e761f9
Signed-off-by: Harry Pan <gspj@google.com>
---
 fastboot/constants.h          |  1 +
 fastboot/device/commands.cpp  |  1 +
 fastboot/device/variables.cpp | 26 ++++++++++++++++++++++++++
 fastboot/device/variables.h   |  2 ++
 4 files changed, 30 insertions(+)

diff --git a/fastboot/constants.h b/fastboot/constants.h
index ad169d1dc5cc..a803307466da 100644
--- a/fastboot/constants.h
+++ b/fastboot/constants.h
@@ -69,6 +69,7 @@
 #define FB_VAR_VARIANT "variant"
 #define FB_VAR_OFF_MODE_CHARGE_STATE "off-mode-charge"
 #define FB_VAR_BATTERY_VOLTAGE "battery-voltage"
+#define FB_VAR_BATTERY_SOC "battery-soc"
 #define FB_VAR_BATTERY_SOC_OK "battery-soc-ok"
 #define FB_VAR_SUPER_PARTITION_NAME "super-partition-name"
 #define FB_VAR_SNAPSHOT_UPDATE_STATUS "snapshot-update-status"
diff --git a/fastboot/device/commands.cpp b/fastboot/device/commands.cpp
index 6de598f6934d..bd936ae771dc 100644
--- a/fastboot/device/commands.cpp
+++ b/fastboot/device/commands.cpp
@@ -134,6 +134,7 @@ const std::unordered_map<std::string, VariableHandlers> kVariableMap = {
         {FB_VAR_IS_FORCE_DEBUGGABLE, {GetIsForceDebuggable, nullptr}},
         {FB_VAR_OFF_MODE_CHARGE_STATE, {GetOffModeChargeState, nullptr}},
         {FB_VAR_BATTERY_VOLTAGE, {GetBatteryVoltage, nullptr}},
+        {FB_VAR_BATTERY_SOC, {GetBatterySoC, nullptr}},
         {FB_VAR_BATTERY_SOC_OK, {GetBatterySoCOk, nullptr}},
         {FB_VAR_HW_REVISION, {GetHardwareRevision, nullptr}},
         {FB_VAR_SUPER_PARTITION_NAME, {GetSuperPartitionName, nullptr}},
diff --git a/fastboot/device/variables.cpp b/fastboot/device/variables.cpp
index d2a794715ba8..2847e35ab6ad 100644
--- a/fastboot/device/variables.cpp
+++ b/fastboot/device/variables.cpp
@@ -130,6 +130,21 @@ bool GetBatteryVoltageHelper(FastbootDevice* device, int32_t* battery_voltage) {
     return true;
 }
 
+bool GetBatterySoCHelper(FastbootDevice* device, int32_t* battery_soc) {
+    using aidl::android::hardware::health::HealthInfo;
+
+    auto health_hal = device->health_hal();
+    if (!health_hal) {
+        return false;
+    }
+
+    HealthInfo health_info;
+    auto res = health_hal->getHealthInfo(&health_info);
+    if (!res.isOk()) return false;
+    *battery_soc = health_info.batteryLevel;
+    return true;
+}
+
 bool GetBatterySoCOk(FastbootDevice* device, const std::vector<std::string>& /* args */,
                      std::string* message) {
     int32_t battery_voltage = 0;
@@ -185,6 +200,17 @@ bool GetBatteryVoltage(FastbootDevice* device, const std::vector<std::string>& /
     return false;
 }
 
+bool GetBatterySoC(FastbootDevice* device, const std::vector<std::string>& /* args */,
+                   std::string* message) {
+    int32_t battery_soc = 0;
+    if (GetBatterySoCHelper(device, &battery_soc)) {
+        *message = std::to_string(battery_soc);
+        return true;
+    }
+    *message = "Unable to get battery soc";
+    return false;
+}
+
 bool GetCurrentSlot(FastbootDevice* device, const std::vector<std::string>& /* args */,
                     std::string* message) {
     std::string suffix = device->GetCurrentSlot();
diff --git a/fastboot/device/variables.h b/fastboot/device/variables.h
index 3b2d48447473..9a46786410b9 100644
--- a/fastboot/device/variables.h
+++ b/fastboot/device/variables.h
@@ -63,6 +63,8 @@ bool GetOffModeChargeState(FastbootDevice* device, const std::vector<std::string
                            std::string* message);
 bool GetBatteryVoltage(FastbootDevice* device, const std::vector<std::string>& args,
                        std::string* message);
+bool GetBatterySoC(FastbootDevice* device, const std::vector<std::string>& args,
+                   std::string* message);
 bool GetBatterySoCOk(FastbootDevice* device, const std::vector<std::string>& args,
                      std::string* message);
 bool GetSuperPartitionName(FastbootDevice* device, const std::vector<std::string>& args,

From 1a3456f0bce99cdbec087cfb0199c113ca722304 Mon Sep 17 00:00:00 2001
From: Arun Sharma <arsharma@google.com>
Date: Tue, 3 Oct 2023 14:55:48 -0700
Subject: [PATCH 0438/1487] FastbootDevice::boot1_1 null pointer dereference

FastbootDevice::boot1_1 attempts to dereference a null pointer when the
boot_control_hal_ is not set. It needs a guard statement to prevent
that.

Test: Manually tested on device without BootControl.
Bug: 301682120
Change-Id: Id86bcb915c8e2857bda26f64738dd5b643048e98
---
 fastboot/device/fastboot_device.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/fastboot/device/fastboot_device.cpp b/fastboot/device/fastboot_device.cpp
index 6b6a9820e212..0dc4e97640c0 100644
--- a/fastboot/device/fastboot_device.cpp
+++ b/fastboot/device/fastboot_device.cpp
@@ -151,7 +151,8 @@ std::string FastbootDevice::GetCurrentSlot() {
 }
 
 BootControlClient* FastbootDevice::boot1_1() const {
-    if (boot_control_hal_->GetVersion() >= android::hal::BootControlVersion::BOOTCTL_V1_1) {
+    if (boot_control_hal_ &&
+        boot_control_hal_->GetVersion() >= android::hal::BootControlVersion::BOOTCTL_V1_1) {
         return boot_control_hal_.get();
     }
     return nullptr;

From 3e9b88d50401177820c522bf2b762292c320368b Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 25 Sep 2023 16:41:05 -0700
Subject: [PATCH 0439/1487] Removing is_retrofit code path

This code path was never invoked. is_logical will return false on
secondary partitions in retrofit devices, so nothing actually is ever
deleted. If we manage to call the delete, the device side code will
fail with "cannot open the super partition"

Test: fastboot flashall on sargo device
Change-Id: I20b430c5c30bf992506190ea4e00b0b69c7b1005
---
 fastboot/fastboot.cpp | 28 ----------------------------
 fastboot/fastboot.h   |  1 -
 2 files changed, 29 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index b12e584d6506..56b90b98179b 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1414,21 +1414,6 @@ void do_for_partitions(const std::string& part, const std::string& slot,
     }
 }
 
-bool is_retrofit_device(const ImageSource* source) {
-    // Does this device use dynamic partitions at all?
-    std::vector<char> contents;
-    if (!source->ReadFile("super_empty.img", &contents)) {
-        return false;
-    }
-    auto metadata = android::fs_mgr::ReadFromImageBlob(contents.data(), contents.size());
-    for (const auto& partition : metadata->partitions) {
-        if (partition.attributes & LP_PARTITION_ATTR_SLOT_SUFFIXED) {
-            return true;
-        }
-    }
-    return false;
-}
-
 // Fetch a partition from the device to a given fd. This is a wrapper over FetchToFd to fetch
 // the full image.
 static uint64_t fetch_partition(const std::string& partition, borrowed_fd fd,
@@ -1880,19 +1865,6 @@ std::vector<std::unique_ptr<Task>> FlashAllTool::CollectTasksFromImageList() {
 
     // Sync the super partition. This will reboot to userspace fastboot if needed.
     tasks.emplace_back(std::make_unique<UpdateSuperTask>(fp_));
-    for (const auto& [image, slot] : os_images_) {
-        // Retrofit devices have two super partitions, named super_a and super_b.
-        // On these devices, secondary slots must be flashed as physical
-        // partitions (otherwise they would not mount on first boot). To enforce
-        // this, we delete any logical partitions for the "other" slot.
-        if (is_retrofit_device(fp_->source.get())) {
-            std::string partition_name = image->part_name + "_" + slot;
-            if (image->IsSecondary() &&
-                should_flash_in_userspace(fp_->source.get(), partition_name)) {
-                tasks.emplace_back(std::make_unique<DeleteTask>(fp_, partition_name));
-            }
-        }
-    }
 
     AddFlashTasks(os_images_, tasks);
 
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index cd7bc2d982b6..2c40890b5105 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -188,7 +188,6 @@ int64_t get_sparse_limit(int64_t size, const FlashingPlan* fp);
 std::vector<SparsePtr> resparse_file(sparse_file* s, int64_t max_size);
 
 bool supports_AB(fastboot::IFastBootDriver* fb);
-bool is_retrofit_device(const ImageSource* source);
 bool is_logical(const std::string& partition);
 void fb_perform_format(const std::string& partition, int skip_if_not_supported,
                        const std::string& type_override, const std::string& size_override,

From 5880692ae2dc37cd0c5d3bb7722b2cf55cc0b300 Mon Sep 17 00:00:00 2001
From: Sophia Coldren <coldren@google.com>
Date: Fri, 6 Oct 2023 18:46:11 +0000
Subject: [PATCH 0440/1487] Add an include

Change-Id: I0a6c64d9f1ddd9211de994fd4c6c44d53499775f
---
 libcutils/socket_local_unix.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libcutils/socket_local_unix.h b/libcutils/socket_local_unix.h
index 45b9856b6040..ea98c0815a5f 100644
--- a/libcutils/socket_local_unix.h
+++ b/libcutils/socket_local_unix.h
@@ -17,6 +17,8 @@
 #ifndef __SOCKET_LOCAL_H
 #define __SOCKET_LOCAL_H
 
+#include <sys/socket.h>
+
 #define FILESYSTEM_SOCKET_PREFIX "/tmp/" 
 #define ANDROID_RESERVED_SOCKET_PREFIX "/dev/socket/"
 

From d8a9a0c81c6d9da9d1a5118d19adbc1f9bd8522a Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 6 Oct 2023 14:52:08 -0700
Subject: [PATCH 0441/1487] init: Remove arbitrary delay in async persist
 writes.

Bug: 297093092
Test: manual test
Change-Id: Ia80b33d2fe87aa5da64b4f156fefeb474e68dc93
---
 init/property_service.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index 2064fae8f14c..cdd0afe8b70a 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1461,8 +1461,6 @@ void PersistWriteThread::Work() {
             work_.pop_front();
         }
 
-        std::this_thread::sleep_for(1s);
-
         // Perform write/fsync outside the lock.
         WritePersistentProperty(std::get<0>(item), std::get<1>(item));
         NotifyPropertyChange(std::get<0>(item), std::get<1>(item));

From b02f94490dc84877c210eb1b46a9b57d96fc45b2 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 6 Oct 2023 23:11:09 +0000
Subject: [PATCH 0442/1487] libprocessgroup: Don't sleep after last cgroup
 removal attempt

Currently we sleep for 5ms before decrementing retries for the last
time. This is a waste of time, so bail out of the loop if the last
rmdir attempt fails.

Change-Id: Ia20840d27592b4eb3d9762647b19c111ff94209f
---
 libprocessgroup/processgroup.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 450643912e09..cc2565fadfa8 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -219,7 +219,7 @@ static int RemoveProcessGroup(const char* cgroup, uid_t uid, int pid, unsigned i
 
     while (retries--) {
         ret = rmdir(uid_pid_path.c_str());
-        if (!ret || errno != EBUSY) break;
+        if (!ret || errno != EBUSY || !retries) break;
         std::this_thread::sleep_for(5ms);
     }
 

From 066e625b6b74028f10848ce73a758bd8ea83f378 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Sat, 7 Oct 2023 00:29:44 +0000
Subject: [PATCH 0443/1487] libutils: use log/log.h internally

utils/Log.h is one less file we need if we're
splitting up this library for binder.

Bug: 302720583
Test: build
Change-Id: Ibc7ec5402df342627f465354d7cf59e98f450a31
---
 libutils/CallStack.cpp    | 2 +-
 libutils/FileMap.cpp      | 2 +-
 libutils/Printer.cpp      | 2 +-
 libutils/RefBase_fuzz.cpp | 2 +-
 libutils/StopWatch.cpp    | 2 +-
 libutils/String16.cpp     | 2 +-
 libutils/String8.cpp      | 2 +-
 libutils/String8_test.cpp | 2 +-
 libutils/SystemClock.cpp  | 2 +-
 libutils/Threads.cpp      | 2 +-
 libutils/Timers.cpp       | 2 +-
 libutils/Tokenizer.cpp    | 2 +-
 libutils/Vector_fuzz.cpp  | 2 +-
 libutils/misc.cpp         | 2 +-
 14 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/libutils/CallStack.cpp b/libutils/CallStack.cpp
index 11f2c9262048..fe827eb0e208 100644
--- a/libutils/CallStack.cpp
+++ b/libutils/CallStack.cpp
@@ -18,7 +18,7 @@
 
 #include <utils/Printer.h>
 #include <utils/Errors.h>
-#include <utils/Log.h>
+#include <log/log.h>
 
 #include <unwindstack/AndroidUnwinder.h>
 
diff --git a/libutils/FileMap.cpp b/libutils/FileMap.cpp
index 0abb86191f04..3acbce98b03e 100644
--- a/libutils/FileMap.cpp
+++ b/libutils/FileMap.cpp
@@ -21,7 +21,7 @@
 #define LOG_TAG "filemap"
 
 #include <utils/FileMap.h>
-#include <utils/Log.h>
+#include <log/log.h>
 
 #if defined(__MINGW32__) && !defined(__USE_MINGW_ANSI_STDIO)
 # define PRId32 "I32d"
diff --git a/libutils/Printer.cpp b/libutils/Printer.cpp
index c9ae210ba7bc..4bd49f19e4ae 100644
--- a/libutils/Printer.cpp
+++ b/libutils/Printer.cpp
@@ -19,7 +19,7 @@
 
 #include <utils/Printer.h>
 #include <utils/String8.h>
-#include <utils/Log.h>
+#include <log/log.h>
 
 #include <stdlib.h>
 
diff --git a/libutils/RefBase_fuzz.cpp b/libutils/RefBase_fuzz.cpp
index 8291be93af52..05f47a0de6c8 100644
--- a/libutils/RefBase_fuzz.cpp
+++ b/libutils/RefBase_fuzz.cpp
@@ -19,7 +19,7 @@
 #include <thread>
 
 #include "fuzzer/FuzzedDataProvider.h"
-#include "utils/Log.h"
+#include "log/log.h"
 #include "utils/RWLock.h"
 #include "utils/RefBase.h"
 #include "utils/StrongPointer.h"
diff --git a/libutils/StopWatch.cpp b/libutils/StopWatch.cpp
index 28e2d76bcf7e..c88d60fc0562 100644
--- a/libutils/StopWatch.cpp
+++ b/libutils/StopWatch.cpp
@@ -24,7 +24,7 @@
 #endif
 #include <inttypes.h>
 
-#include <utils/Log.h>
+#include <log/log.h>
 
 namespace android {
 
diff --git a/libutils/String16.cpp b/libutils/String16.cpp
index 38d483e9495e..07a3d23f694c 100644
--- a/libutils/String16.cpp
+++ b/libutils/String16.cpp
@@ -16,7 +16,7 @@
 
 #include <utils/String16.h>
 
-#include <utils/Log.h>
+#include <log/log.h>
 
 #include <ctype.h>
 
diff --git a/libutils/String8.cpp b/libutils/String8.cpp
index 4301f0ea3a77..6a754843117f 100644
--- a/libutils/String8.cpp
+++ b/libutils/String8.cpp
@@ -20,7 +20,7 @@
 #include <utils/String8.h>
 
 #include <utils/Compat.h>
-#include <utils/Log.h>
+#include <log/log.h>
 #include <utils/String16.h>
 
 #include <ctype.h>
diff --git a/libutils/String8_test.cpp b/libutils/String8_test.cpp
index e1fd13a9e137..6f7882a3892b 100644
--- a/libutils/String8_test.cpp
+++ b/libutils/String8_test.cpp
@@ -16,7 +16,7 @@
 
 #define LOG_TAG "String8_test"
 
-#include <utils/Log.h>
+#include <log/log.h>
 #include <utils/String8.h>
 #include <utils/String16.h>
 
diff --git a/libutils/SystemClock.cpp b/libutils/SystemClock.cpp
index 9c71141f2d5a..df3a8986520e 100644
--- a/libutils/SystemClock.cpp
+++ b/libutils/SystemClock.cpp
@@ -30,7 +30,7 @@
 #include <cutils/compiler.h>
 
 #include <utils/Timers.h>
-#include <utils/Log.h>
+#include <log/log.h>
 
 namespace android {
 
diff --git a/libutils/Threads.cpp b/libutils/Threads.cpp
index e756fecca001..90ea29b22887 100644
--- a/libutils/Threads.cpp
+++ b/libutils/Threads.cpp
@@ -34,7 +34,7 @@
 #include <sys/prctl.h>
 #endif
 
-#include <utils/Log.h>
+#include <log/log.h>
 
 #if defined(__ANDROID__)
 #include <processgroup/processgroup.h>
diff --git a/libutils/Timers.cpp b/libutils/Timers.cpp
index 4cfac57be024..98082c95761d 100644
--- a/libutils/Timers.cpp
+++ b/libutils/Timers.cpp
@@ -21,7 +21,7 @@
 #include <time.h>
 
 #include <android-base/macros.h>
-#include <utils/Log.h>
+#include <log/log.h>
 
 static constexpr size_t clock_id_max = 5;
 
diff --git a/libutils/Tokenizer.cpp b/libutils/Tokenizer.cpp
index 9fc955c1a37d..aa097aeadba9 100644
--- a/libutils/Tokenizer.cpp
+++ b/libutils/Tokenizer.cpp
@@ -19,7 +19,7 @@
 #include <utils/Tokenizer.h>
 #include <fcntl.h>
 #include <sys/stat.h>
-#include <utils/Log.h>
+#include <log/log.h>
 
 #ifndef DEBUG_TOKENIZER
 // Enables debug output for the tokenizer.
diff --git a/libutils/Vector_fuzz.cpp b/libutils/Vector_fuzz.cpp
index 6fd2baf17ca2..3cef4870915a 100644
--- a/libutils/Vector_fuzz.cpp
+++ b/libutils/Vector_fuzz.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include <fuzzer/FuzzedDataProvider.h>
-#include <utils/Log.h>
+#include <log/log.h>
 #include <utils/Vector.h>
 
 #include <functional>
diff --git a/libutils/misc.cpp b/libutils/misc.cpp
index f77e1899ffe5..e1b5f013ccec 100644
--- a/libutils/misc.cpp
+++ b/libutils/misc.cpp
@@ -20,7 +20,7 @@
 
 #include <pthread.h>
 
-#include <utils/Log.h>
+#include <log/log.h>
 #include <utils/Vector.h>
 
 #if defined(__ANDROID__) && !defined(__ANDROID_RECOVERY__)

From 0666c3a632e811fc1f49685ddfff21ce6b3efa34 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Sat, 7 Oct 2023 00:35:38 +0000
Subject: [PATCH 0444/1487] libutils: remove unused 'CALLSTACKS'

This macro is set, but it doesn't exist.

Bug: 302720583
Test: build
Change-Id: I88032c24b8bc8dc52d521e769149cbd8f619dde8
---
 libutils/Android.bp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/libutils/Android.bp b/libutils/Android.bp
index 2c05fbc24cc5..0f63df43d016 100644
--- a/libutils/Android.bp
+++ b/libutils/Android.bp
@@ -208,7 +208,6 @@ cc_library {
     defaults: ["libutils_impl_defaults"],
 
     cflags: [
-        "-DCALLSTACKS=1",
         "-DDEBUG_POLL_AND_WAKE=1",
         "-DDEBUG_REFS=1",
         "-DDEBUG_TOKENIZER=1",

From f75464d65e935a7216cbd3db5753716a9cd6e546 Mon Sep 17 00:00:00 2001
From: Yurii Shutkin <shutkin@google.com>
Date: Mon, 9 Oct 2023 15:25:29 +0200
Subject: [PATCH 0445/1487] acvp: handle flush commond in modulewrapper as
 stated in BoringSSL.

Change-Id: Ife655f0764851cf2d9677abd507daec3f531031e
Bug: 287626912
Test: ACVP test
---
 trusty/utils/acvp/trusty_modulewrapper.cpp | 35 +++++++++++++++-------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/trusty/utils/acvp/trusty_modulewrapper.cpp b/trusty/utils/acvp/trusty_modulewrapper.cpp
index 70ffb52ec19c..85b7159d3ced 100644
--- a/trusty/utils/acvp/trusty_modulewrapper.cpp
+++ b/trusty/utils/acvp/trusty_modulewrapper.cpp
@@ -21,15 +21,16 @@
 #include <android-base/result.h>
 #include <android-base/unique_fd.h>
 #include <errno.h>
+#include <iostream>
 #include <log/log.h>
 #include <modulewrapper.h>
 #include <openssl/span.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/mman.h>
 #include <trusty/tipc.h>
 #include <unistd.h>
-#include <iostream>
 
 #include "acvp_ipc.h"
 
@@ -208,6 +209,11 @@ Result<void> ModuleWrapper::ForwardResponse() {
     return {};
 }
 
+static bool EqString(bssl::Span<const uint8_t> cmd, const char *str) {
+    return cmd.size() == strlen(str) &&
+           memcmp(str, cmd.data(), cmd.size()) == 0;
+}
+
 int main() {
     for (;;) {
         auto buffer = bssl::acvp::RequestBuffer::New();
@@ -217,17 +223,24 @@ int main() {
             return EXIT_FAILURE;
         }
 
-        ModuleWrapper wrapper;
-        auto res = wrapper.SendMessage(args);
-        if (!res.ok()) {
-            std::cerr << res.error() << std::endl;
-            return EXIT_FAILURE;
-        }
+        if (EqString(args[0], "flush")) {
+            if (!bssl::acvp::FlushBuffer(STDOUT_FILENO)) {
+                ALOGE("Could not flush the buffer to stdout\n");
+                return EXIT_FAILURE;
+            }
+        } else {
+            ModuleWrapper wrapper;
+            auto res = wrapper.SendMessage(args);
+            if (!res.ok()) {
+                std::cerr << res.error() << std::endl;
+                return EXIT_FAILURE;
+            }
 
-        res = wrapper.ForwardResponse();
-        if (!res.ok()) {
-            std::cerr << res.error() << std::endl;
-            return EXIT_FAILURE;
+            res = wrapper.ForwardResponse();
+            if (!res.ok()) {
+                std::cerr << res.error() << std::endl;
+                return EXIT_FAILURE;
+            }
         }
     }
 

From 04e4c2a6c2ad0dd8d8380877cb5adf1fa9628293 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 12 Sep 2023 15:35:31 -0700
Subject: [PATCH 0446/1487] Add v3 writer

Adding v3 writer that works off of Cow Operation v3. Adding test file
that will test this new writer. Adding in stub implementations to v3 writer. None of these functions
have to work yet, we just need the implementations here to compile.

Test: m libsnapshot
Change-Id: If86437d5ceb2c33520d4ca26dea5193984f86546
---
 fs_mgr/libsnapshot/Android.bp                 |   2 +
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   |  53 ++++++++
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 117 ++++++++++++++++++
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |  43 +++++++
 4 files changed, 215 insertions(+)
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index fe47801f3f72..6fad6626655e 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -201,6 +201,7 @@ cc_library_static {
         "libsnapshot_cow/snapshot_reader.cpp",
         "libsnapshot_cow/writer_base.cpp",
         "libsnapshot_cow/writer_v2.cpp",
+        "libsnapshot_cow/writer_v3.cpp",
     ],
     export_include_dirs: ["include"],
     host_supported: true,
@@ -392,6 +393,7 @@ cc_test {
     srcs: [
         "libsnapshot_cow/snapshot_reader_test.cpp",
         "libsnapshot_cow/test_v2.cpp",
+        "libsnapshot_cow/test_v3.cpp",
     ],
     cflags: [
         "-D_FILE_OFFSET_BITS=64",
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
new file mode 100644
index 000000000000..2373d4df5bf3
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -0,0 +1,53 @@
+// Copyright (C) 2023 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 <sys/stat.h>
+
+#include <cstdio>
+#include <iostream>
+#include <memory>
+#include <string_view>
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <gtest/gtest.h>
+#include <libsnapshot/cow_reader.h>
+#include <libsnapshot/cow_writer.h>
+#include "cow_decompress.h"
+#include "libsnapshot/cow_format.h"
+#include "writer_v3.h"
+using android::base::unique_fd;
+using testing::AssertionFailure;
+using testing::AssertionResult;
+using testing::AssertionSuccess;
+
+namespace android {
+namespace snapshot {
+
+class CowOperationV3Test : public ::testing::Test {
+  protected:
+    virtual void SetUp() override {
+        cow_ = std::make_unique<TemporaryFile>();
+        ASSERT_GE(cow_->fd, 0) << strerror(errno);
+    }
+
+    virtual void TearDown() override { cow_ = nullptr; }
+
+    unique_fd GetCowFd() { return unique_fd{dup(cow_->fd)}; }
+
+    std::unique_ptr<TemporaryFile> cow_;
+};
+
+}  // namespace snapshot
+}  // namespace android
\ No newline at end of file
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
new file mode 100644
index 000000000000..2b9867ef1b0c
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -0,0 +1,117 @@
+//
+// Copyright (C) 2020 The Android Open Source_info 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 "writer_v3.h"
+
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <unistd.h>
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/parseint.h>
+#include <android-base/properties.h>
+#include <android-base/strings.h>
+#include <android-base/unique_fd.h>
+#include <brotli/encode.h>
+#include <libsnapshot/cow_format.h>
+#include <libsnapshot/cow_reader.h>
+#include <libsnapshot/cow_writer.h>
+#include <lz4.h>
+#include <zlib.h>
+
+#include <fcntl.h>
+#include <linux/fs.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+// The info messages here are spammy, but as useful for update_engine. Disable
+// them when running on the host.
+#ifdef __ANDROID__
+#define LOG_INFO LOG(INFO)
+#else
+#define LOG_INFO LOG(VERBOSE)
+#endif
+
+namespace android {
+namespace snapshot {
+
+static_assert(sizeof(off_t) == sizeof(uint64_t));
+
+using android::base::unique_fd;
+
+CowWriterV3::CowWriterV3(const CowOptions& options, unique_fd&& fd)
+    : CowWriterBase(options, std::move(fd)) {}
+
+CowWriterV3::~CowWriterV3() {}
+
+bool CowWriterV3::Initialize(std::optional<uint64_t> label) {
+    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
+    if (label) return false;
+    return false;
+}
+
+bool CowWriterV3::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks) {
+    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
+    if (new_block || old_block || num_blocks) return false;
+    return false;
+}
+
+bool CowWriterV3::EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) {
+    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
+
+    if (new_block_start || data || size) return false;
+    return false;
+}
+
+bool CowWriterV3::EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size,
+                                uint32_t old_block, uint16_t offset) {
+    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
+    if (new_block_start || old_block || offset || data || size) return false;
+    return false;
+}
+
+bool CowWriterV3::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
+    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
+    if (new_block_start && num_blocks) return false;
+    return false;
+}
+
+bool CowWriterV3::EmitLabel(uint64_t label) {
+    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
+    if (label) return false;
+    return false;
+}
+
+bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
+    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
+    if (num_ops && data) return false;
+    return false;
+}
+
+bool CowWriterV3::Finalize() {
+    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
+    return false;
+}
+
+uint64_t CowWriterV3::GetCowSize() {
+    LOG(ERROR) << __LINE__ << " " << __FILE__
+               << " <- Get Cow Size function here should never be called";
+    return 0;
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
new file mode 100644
index 000000000000..ddd72873c1b8
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -0,0 +1,43 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <future>
+#include "writer_base.h"
+
+namespace android {
+namespace snapshot {
+
+class CowWriterV3 : public CowWriterBase {
+  public:
+    explicit CowWriterV3(const CowOptions& options, android::base::unique_fd&& fd);
+    ~CowWriterV3() override;
+
+    bool Initialize(std::optional<uint64_t> label = {}) override;
+    bool Finalize() override;
+    uint64_t GetCowSize() override;
+
+  protected:
+    virtual bool EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) override;
+    virtual bool EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) override;
+    virtual bool EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size,
+                               uint32_t old_block, uint16_t offset) override;
+    virtual bool EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) override;
+    virtual bool EmitLabel(uint64_t label) override;
+    virtual bool EmitSequenceData(size_t num_ops, const uint32_t* data) override;
+};
+
+}  // namespace snapshot
+}  // namespace android

From ce57c58e6b0efd4621e1c84abfce38f4e30deff3 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 5 Oct 2023 13:22:52 -0700
Subject: [PATCH 0447/1487] Removing compression bit from v3 op

We don't need the compression bit in v3 op since all operations will
have the same compression per COW Device and it will be stored within the COW header.
We can check to see if an operation contains compressioned data by
checking data_length and see if it's less than BLOCK_SZ

Test: 4 critical OTA paths
Change-Id: I3f86756d83bf54bf6efd15d9cb7ac064eefdd949
---
 fs_mgr/libsnapshot/include/libsnapshot/cow_format.h | 4 ----
 fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp   | 5 -----
 fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp   | 1 -
 fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp      | 6 ------
 4 files changed, 16 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 2a2cee2b72b5..1c92f9157fae 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -201,14 +201,10 @@ static constexpr uint8_t kCowReadAheadInProgress = 1;
 static constexpr uint8_t kCowReadAheadDone = 2;
 
 static constexpr uint64_t kCowOpSourceInfoDataMask = (1ULL << 48) - 1;
-static constexpr uint64_t kCowOpSourceInfoCompressBit = (1ULL << 63);
 
 static inline uint64_t GetCowOpSourceInfoData(const CowOperation* op) {
     return op->source_info & kCowOpSourceInfoDataMask;
 }
-static inline bool GetCowOpSourceInfoCompression(const CowOperation* op) {
-    return !!(op->source_info & kCowOpSourceInfoCompressBit);
-}
 
 struct CowFooter {
     CowFooterOperation op;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
index 58dca64e19bd..5ab4f7a52226 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
@@ -83,11 +83,6 @@ std::ostream& operator<<(std::ostream& os, CowOperation const& op) {
     os << "CowOperation(";
     EmitCowTypeString(os, op.type);
     if (op.type == kCowReplaceOp || op.type == kCowXorOp || op.type == kCowSequenceOp) {
-        if (op.source_info & kCowOpSourceInfoCompressBit) {
-            os << ", compressed";
-        } else {
-            os << ", uncompressed";
-        }
         os << ", data_length:" << op.data_length;
     }
     if (op.type != kCowClusterOp && op.type != kCowSequenceOp && op.type != kCowLabelOp) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index bf50f2f5eb2d..0285c175526f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -136,7 +136,6 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
                            << v2_op.compression << ", op: " << v2_op;
                 return false;
             }
-            source_info |= kCowOpSourceInfoCompressBit;
         }
         new_op.source_info = source_info;
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 8f3f03f38f3f..100b13778a5b 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -143,7 +143,6 @@ TEST_F(CowTest, ReadWrite) {
     op = iter->Get();
 
     ASSERT_EQ(op->type, kCowReplaceOp);
-    ASSERT_FALSE(GetCowOpSourceInfoCompression(op));
     ASSERT_EQ(op->data_length, 4096);
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -219,7 +218,6 @@ TEST_F(CowTest, ReadWriteXor) {
     op = iter->Get();
 
     ASSERT_EQ(op->type, kCowXorOp);
-    ASSERT_FALSE(GetCowOpSourceInfoCompression(op));
     ASSERT_EQ(op->data_length, 4096);
     ASSERT_EQ(op->new_block, 50);
     ASSERT_EQ(GetCowOpSourceInfoData(op), 98314);  // 4096 * 24 + 10
@@ -276,7 +274,6 @@ TEST_F(CowTest, CompressGz) {
     std::string sink(data.size(), '\0');
 
     ASSERT_EQ(op->type, kCowReplaceOp);
-    ASSERT_TRUE(GetCowOpSourceInfoCompression(op));
     ASSERT_EQ(op->data_length, 56);  // compressed!
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -523,7 +520,6 @@ TEST_F(CowTest, ClusterCompressGz) {
     std::string sink(data.size(), '\0');
 
     ASSERT_EQ(op->type, kCowReplaceOp);
-    ASSERT_TRUE(GetCowOpSourceInfoCompression(op));
     ASSERT_EQ(op->data_length, 56);  // compressed!
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -541,7 +537,6 @@ TEST_F(CowTest, ClusterCompressGz) {
 
     sink = {};
     sink.resize(data2.size(), '\0');
-    ASSERT_TRUE(GetCowOpSourceInfoCompression(op));
     ASSERT_EQ(op->data_length, 41);  // compressed!
     ASSERT_EQ(op->new_block, 51);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -586,7 +581,6 @@ TEST_F(CowTest, CompressTwoBlocks) {
 
     auto op = iter->Get();
     ASSERT_EQ(op->type, kCowReplaceOp);
-    ASSERT_TRUE(GetCowOpSourceInfoCompression(op));
     ASSERT_EQ(op->new_block, 51);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
 }

From 7a1ca59839f3ebb8fd73037c7380af958e03ef07 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Sat, 7 Oct 2023 01:09:39 +0000
Subject: [PATCH 0448/1487] libutils: split out libutils_binder

Dependencies of libbinder, so we can build
a core libbinder library, libbinder_sdk.

This is preparing the way to move this part of libbinder
together with binder code into a single project.

Bug: 302720583
Change-Id: Icff078ac6e36c7f2b91cf815d5b9ed19b2e706e1
---
 libutils/Android.bp                           |  48 +-
 libutils/TEST_MAPPING                         |   3 +
 libutils/binder/Android.bp                    | 126 +++
 libutils/{ => binder}/Errors.cpp              |   0
 libutils/{ => binder}/Errors_test.cpp         |   0
 libutils/{ => binder}/FuzzFormatTypes.h       |   0
 libutils/{ => binder}/RefBase.cpp             |  13 +-
 libutils/{ => binder}/RefBase_fuzz.cpp        |   0
 libutils/{ => binder}/RefBase_test.cpp        |   0
 libutils/{ => binder}/SharedBuffer.cpp        |   0
 libutils/{ => binder}/SharedBuffer.h          |   0
 libutils/{ => binder}/SharedBuffer_test.cpp   |   0
 libutils/{ => binder}/String16.cpp            |   0
 libutils/{ => binder}/String16_fuzz.cpp       |   0
 libutils/{ => binder}/String16_test.cpp       |   0
 libutils/{ => binder}/String8.cpp             |   0
 libutils/{ => binder}/String8_fuzz.cpp        |   0
 libutils/{ => binder}/String8_test.cpp        |   0
 libutils/{ => binder}/StrongPointer.cpp       |   0
 libutils/{ => binder}/StrongPointer_test.cpp  |   0
 libutils/{ => binder}/Unicode.cpp             |   0
 libutils/{ => binder}/Unicode_test.cpp        |   0
 libutils/{ => binder}/VectorImpl.cpp          |   0
 libutils/{ => binder}/Vector_benchmark.cpp    |   0
 libutils/{ => binder}/Vector_fuzz.cpp         |   0
 libutils/{ => binder}/Vector_test.cpp         |   0
 libutils/binder/include/utils/Errors.h        |  77 ++
 libutils/binder/include/utils/RefBase.h       | 819 +++++++++++++++++
 libutils/binder/include/utils/String16.h      | 383 ++++++++
 libutils/binder/include/utils/String8.h       | 354 ++++++++
 libutils/binder/include/utils/StrongPointer.h | 361 ++++++++
 libutils/binder/include/utils/Unicode.h       | 139 +++
 libutils/binder/include/utils/Vector.h        | 418 +++++++++
 libutils/binder/include/utils/VectorImpl.h    | 182 ++++
 libutils/include/utils/Errors.h               |  78 +-
 libutils/include/utils/RefBase.h              | 820 +-----------------
 libutils/include/utils/String16.h             | 384 +-------
 libutils/include/utils/String8.h              | 355 +-------
 libutils/include/utils/StrongPointer.h        | 362 +-------
 libutils/include/utils/Unicode.h              | 140 +--
 libutils/include/utils/Vector.h               | 419 +--------
 libutils/include/utils/VectorImpl.h           | 183 +---
 42 files changed, 2878 insertions(+), 2786 deletions(-)
 create mode 100644 libutils/binder/Android.bp
 rename libutils/{ => binder}/Errors.cpp (100%)
 rename libutils/{ => binder}/Errors_test.cpp (100%)
 rename libutils/{ => binder}/FuzzFormatTypes.h (100%)
 rename libutils/{ => binder}/RefBase.cpp (99%)
 rename libutils/{ => binder}/RefBase_fuzz.cpp (100%)
 rename libutils/{ => binder}/RefBase_test.cpp (100%)
 rename libutils/{ => binder}/SharedBuffer.cpp (100%)
 rename libutils/{ => binder}/SharedBuffer.h (100%)
 rename libutils/{ => binder}/SharedBuffer_test.cpp (100%)
 rename libutils/{ => binder}/String16.cpp (100%)
 rename libutils/{ => binder}/String16_fuzz.cpp (100%)
 rename libutils/{ => binder}/String16_test.cpp (100%)
 rename libutils/{ => binder}/String8.cpp (100%)
 rename libutils/{ => binder}/String8_fuzz.cpp (100%)
 rename libutils/{ => binder}/String8_test.cpp (100%)
 rename libutils/{ => binder}/StrongPointer.cpp (100%)
 rename libutils/{ => binder}/StrongPointer_test.cpp (100%)
 rename libutils/{ => binder}/Unicode.cpp (100%)
 rename libutils/{ => binder}/Unicode_test.cpp (100%)
 rename libutils/{ => binder}/VectorImpl.cpp (100%)
 rename libutils/{ => binder}/Vector_benchmark.cpp (100%)
 rename libutils/{ => binder}/Vector_fuzz.cpp (100%)
 rename libutils/{ => binder}/Vector_test.cpp (100%)
 create mode 100644 libutils/binder/include/utils/Errors.h
 create mode 100644 libutils/binder/include/utils/RefBase.h
 create mode 100644 libutils/binder/include/utils/String16.h
 create mode 100644 libutils/binder/include/utils/String8.h
 create mode 100644 libutils/binder/include/utils/StrongPointer.h
 create mode 100644 libutils/binder/include/utils/Unicode.h
 create mode 100644 libutils/binder/include/utils/Vector.h
 create mode 100644 libutils/binder/include/utils/VectorImpl.h
 mode change 100644 => 120000 libutils/include/utils/Errors.h
 mode change 100644 => 120000 libutils/include/utils/RefBase.h
 mode change 100644 => 120000 libutils/include/utils/String16.h
 mode change 100644 => 120000 libutils/include/utils/String8.h
 mode change 100644 => 120000 libutils/include/utils/StrongPointer.h
 mode change 100644 => 120000 libutils/include/utils/Unicode.h
 mode change 100644 => 120000 libutils/include/utils/Vector.h
 mode change 100644 => 120000 libutils/include/utils/VectorImpl.h

diff --git a/libutils/Android.bp b/libutils/Android.bp
index 0f63df43d016..b3ddda3b372d 100644
--- a/libutils/Android.bp
+++ b/libutils/Android.bp
@@ -132,25 +132,19 @@ cc_defaults {
     ],
     native_bridge_supported: true,
 
+    whole_static_libs: ["libutils_binder"],
+
     srcs: [
-        "Errors.cpp",
         "FileMap.cpp",
         "JenkinsHash.cpp",
         "LightRefBase.cpp",
         "NativeHandle.cpp",
         "Printer.cpp",
-        "RefBase.cpp",
-        "SharedBuffer.cpp",
         "StopWatch.cpp",
-        "String8.cpp",
-        "String16.cpp",
-        "StrongPointer.cpp",
         "SystemClock.cpp",
         "Threads.cpp",
         "Timers.cpp",
         "Tokenizer.cpp",
-        "Unicode.cpp",
-        "VectorImpl.cpp",
         "misc.cpp",
     ],
 
@@ -273,24 +267,6 @@ cc_fuzz {
     srcs: ["FileMap_fuzz.cpp"],
 }
 
-cc_fuzz {
-    name: "libutils_fuzz_string8",
-    defaults: ["libutils_fuzz_defaults"],
-    srcs: ["String8_fuzz.cpp"],
-}
-
-cc_fuzz {
-    name: "libutils_fuzz_string16",
-    defaults: ["libutils_fuzz_defaults"],
-    srcs: ["String16_fuzz.cpp"],
-}
-
-cc_fuzz {
-    name: "libutils_fuzz_vector",
-    defaults: ["libutils_fuzz_defaults"],
-    srcs: ["Vector_fuzz.cpp"],
-}
-
 cc_fuzz {
     name: "libutils_fuzz_printer",
     defaults: ["libutils_fuzz_defaults"],
@@ -315,12 +291,6 @@ cc_fuzz {
     ],
 }
 
-cc_fuzz {
-    name: "libutils_fuzz_refbase",
-    defaults: ["libutils_fuzz_defaults"],
-    srcs: ["RefBase_fuzz.cpp"],
-}
-
 cc_fuzz {
     name: "libutils_fuzz_lrucache",
     defaults: ["libutils_fuzz_defaults"],
@@ -340,18 +310,11 @@ cc_test {
     srcs: [
         "BitSet_test.cpp",
         "CallStack_test.cpp",
-        "Errors_test.cpp",
         "FileMap_test.cpp",
         "LruCache_test.cpp",
         "Mutex_test.cpp",
-        "SharedBuffer_test.cpp",
         "Singleton_test.cpp",
-        "String16_test.cpp",
-        "String8_test.cpp",
-        "StrongPointer_test.cpp",
         "Timers_test.cpp",
-        "Unicode_test.cpp",
-        "Vector_test.cpp",
     ],
 
     target: {
@@ -373,7 +336,6 @@ cc_test {
         linux: {
             srcs: [
                 "Looper_test.cpp",
-                "RefBase_test.cpp",
             ],
         },
         host: {
@@ -427,9 +389,3 @@ cc_test_library {
     shared_libs: ["libutils_test_singleton1"],
     header_libs: ["libutils_headers"],
 }
-
-cc_benchmark {
-    name: "libutils_benchmark",
-    srcs: ["Vector_benchmark.cpp"],
-    shared_libs: ["libutils"],
-}
diff --git a/libutils/TEST_MAPPING b/libutils/TEST_MAPPING
index c8ef45cc3ba5..472146f139de 100644
--- a/libutils/TEST_MAPPING
+++ b/libutils/TEST_MAPPING
@@ -2,6 +2,9 @@
   "presubmit": [
     {
       "name": "libutils_test"
+    },
+    {
+      "name": "libutils_binder_test"
     }
   ]
 }
diff --git a/libutils/binder/Android.bp b/libutils/binder/Android.bp
new file mode 100644
index 000000000000..e2eddb332f0d
--- /dev/null
+++ b/libutils/binder/Android.bp
@@ -0,0 +1,126 @@
+package {
+    default_applicable_licenses: ["system_core_libutils_license"],
+}
+
+cc_defaults {
+    name: "libutils_binder_impl_defaults",
+    defaults: [
+        "libutils_defaults",
+        "apex-lowest-min-sdk-version",
+    ],
+    native_bridge_supported: true,
+
+    srcs: [
+        "Errors.cpp",
+        "RefBase.cpp",
+        "SharedBuffer.cpp",
+        "String16.cpp",
+        "String8.cpp",
+        "StrongPointer.cpp",
+        "Unicode.cpp",
+        "VectorImpl.cpp",
+    ],
+
+    apex_available: [
+        "//apex_available:anyapex",
+        "//apex_available:platform",
+    ],
+
+    afdo: true,
+}
+
+cc_library {
+    name: "libutils_binder",
+    defaults: ["libutils_binder_impl_defaults"],
+}
+
+cc_library {
+    name: "libutils_binder_test_compile",
+    defaults: ["libutils_binder_impl_defaults"],
+
+    cflags: [
+        "-DDEBUG_REFS=1",
+    ],
+
+    visibility: [":__subpackages__"],
+}
+
+cc_fuzz {
+    name: "libutils_fuzz_string8",
+    defaults: ["libutils_fuzz_defaults"],
+    srcs: ["String8_fuzz.cpp"],
+}
+
+cc_fuzz {
+    name: "libutils_fuzz_string16",
+    defaults: ["libutils_fuzz_defaults"],
+    srcs: ["String16_fuzz.cpp"],
+}
+
+cc_fuzz {
+    name: "libutils_fuzz_vector",
+    defaults: ["libutils_fuzz_defaults"],
+    srcs: ["Vector_fuzz.cpp"],
+}
+
+cc_fuzz {
+    name: "libutils_fuzz_refbase",
+    defaults: ["libutils_fuzz_defaults"],
+    srcs: ["RefBase_fuzz.cpp"],
+}
+
+cc_test {
+    name: "libutils_binder_test",
+    host_supported: true,
+
+    srcs: [
+        "Errors_test.cpp",
+        "SharedBuffer_test.cpp",
+        "String16_test.cpp",
+        "String8_test.cpp",
+        "StrongPointer_test.cpp",
+        "Unicode_test.cpp",
+        "Vector_test.cpp",
+    ],
+
+    target: {
+        android: {
+            shared_libs: [
+                "libbase",
+                "libcutils",
+                "liblog",
+                "liblzma",
+                "libutils", // which includes libutils_binder
+                "libz",
+            ],
+        },
+        linux: {
+            srcs: [
+                "RefBase_test.cpp",
+            ],
+        },
+        host: {
+            static_libs: [
+                "libbase",
+                "liblog",
+                "liblzma",
+                "libutils", // which includes libutils_binder
+            ],
+        },
+    },
+
+    cflags: [
+        "-Wall",
+        "-Wextra",
+        "-Werror",
+        "-Wthread-safety",
+    ],
+
+    test_suites: ["device-tests"],
+}
+
+cc_benchmark {
+    name: "libutils_binder_benchmark",
+    srcs: ["Vector_benchmark.cpp"],
+    shared_libs: ["libutils"],
+}
diff --git a/libutils/Errors.cpp b/libutils/binder/Errors.cpp
similarity index 100%
rename from libutils/Errors.cpp
rename to libutils/binder/Errors.cpp
diff --git a/libutils/Errors_test.cpp b/libutils/binder/Errors_test.cpp
similarity index 100%
rename from libutils/Errors_test.cpp
rename to libutils/binder/Errors_test.cpp
diff --git a/libutils/FuzzFormatTypes.h b/libutils/binder/FuzzFormatTypes.h
similarity index 100%
rename from libutils/FuzzFormatTypes.h
rename to libutils/binder/FuzzFormatTypes.h
diff --git a/libutils/RefBase.cpp b/libutils/binder/RefBase.cpp
similarity index 99%
rename from libutils/RefBase.cpp
rename to libutils/binder/RefBase.cpp
index e0a2846d4a7a..c7055fb48350 100644
--- a/libutils/RefBase.cpp
+++ b/libutils/binder/RefBase.cpp
@@ -18,6 +18,7 @@
 // #define LOG_NDEBUG 0
 
 #include <memory>
+#include <mutex>
 
 #include <android-base/macros.h>
 
@@ -27,8 +28,6 @@
 #include <utils/RefBase.h>
 #include <utils/String8.h>
 
-#include <utils/Mutex.h>
-
 #ifndef __unused
 #define __unused __attribute__((__unused__))
 #endif
@@ -310,7 +309,7 @@ class RefBase::weakref_impl : public RefBase::weakref_type
         String8 text;
 
         {
-            Mutex::Autolock _l(mMutex);
+            std::lock_guard<std::mutex> _l(mMutex);
             char buf[128];
             snprintf(buf, sizeof(buf),
                      "Strong references on RefBase %p (weakref_type %p):\n",
@@ -353,7 +352,7 @@ class RefBase::weakref_impl : public RefBase::weakref_type
     void addRef(ref_entry** refs, const void* id, int32_t mRef)
     {
         if (mTrackEnabled) {
-            AutoMutex _l(mMutex);
+            std::lock_guard<std::mutex> _l(mMutex);
 
             ref_entry* ref = new ref_entry;
             // Reference count at the time of the snapshot, but before the
@@ -372,7 +371,7 @@ class RefBase::weakref_impl : public RefBase::weakref_type
     void removeRef(ref_entry** refs, const void* id)
     {
         if (mTrackEnabled) {
-            AutoMutex _l(mMutex);
+            std::lock_guard<std::mutex> _l(mMutex);
 
             ref_entry* const head = *refs;
             ref_entry* ref = head;
@@ -406,7 +405,7 @@ class RefBase::weakref_impl : public RefBase::weakref_type
     void renameRefsId(ref_entry* r, const void* old_id, const void* new_id)
     {
         if (mTrackEnabled) {
-            AutoMutex _l(mMutex);
+            std::lock_guard<std::mutex> _l(mMutex);
             ref_entry* ref = r;
             while (ref != NULL) {
                 if (ref->id == old_id) {
@@ -434,7 +433,7 @@ class RefBase::weakref_impl : public RefBase::weakref_type
         }
     }
 
-    mutable Mutex mMutex;
+    mutable std::mutex mMutex;
     ref_entry* mStrongRefs;
     ref_entry* mWeakRefs;
 
diff --git a/libutils/RefBase_fuzz.cpp b/libutils/binder/RefBase_fuzz.cpp
similarity index 100%
rename from libutils/RefBase_fuzz.cpp
rename to libutils/binder/RefBase_fuzz.cpp
diff --git a/libutils/RefBase_test.cpp b/libutils/binder/RefBase_test.cpp
similarity index 100%
rename from libutils/RefBase_test.cpp
rename to libutils/binder/RefBase_test.cpp
diff --git a/libutils/SharedBuffer.cpp b/libutils/binder/SharedBuffer.cpp
similarity index 100%
rename from libutils/SharedBuffer.cpp
rename to libutils/binder/SharedBuffer.cpp
diff --git a/libutils/SharedBuffer.h b/libutils/binder/SharedBuffer.h
similarity index 100%
rename from libutils/SharedBuffer.h
rename to libutils/binder/SharedBuffer.h
diff --git a/libutils/SharedBuffer_test.cpp b/libutils/binder/SharedBuffer_test.cpp
similarity index 100%
rename from libutils/SharedBuffer_test.cpp
rename to libutils/binder/SharedBuffer_test.cpp
diff --git a/libutils/String16.cpp b/libutils/binder/String16.cpp
similarity index 100%
rename from libutils/String16.cpp
rename to libutils/binder/String16.cpp
diff --git a/libutils/String16_fuzz.cpp b/libutils/binder/String16_fuzz.cpp
similarity index 100%
rename from libutils/String16_fuzz.cpp
rename to libutils/binder/String16_fuzz.cpp
diff --git a/libutils/String16_test.cpp b/libutils/binder/String16_test.cpp
similarity index 100%
rename from libutils/String16_test.cpp
rename to libutils/binder/String16_test.cpp
diff --git a/libutils/String8.cpp b/libutils/binder/String8.cpp
similarity index 100%
rename from libutils/String8.cpp
rename to libutils/binder/String8.cpp
diff --git a/libutils/String8_fuzz.cpp b/libutils/binder/String8_fuzz.cpp
similarity index 100%
rename from libutils/String8_fuzz.cpp
rename to libutils/binder/String8_fuzz.cpp
diff --git a/libutils/String8_test.cpp b/libutils/binder/String8_test.cpp
similarity index 100%
rename from libutils/String8_test.cpp
rename to libutils/binder/String8_test.cpp
diff --git a/libutils/StrongPointer.cpp b/libutils/binder/StrongPointer.cpp
similarity index 100%
rename from libutils/StrongPointer.cpp
rename to libutils/binder/StrongPointer.cpp
diff --git a/libutils/StrongPointer_test.cpp b/libutils/binder/StrongPointer_test.cpp
similarity index 100%
rename from libutils/StrongPointer_test.cpp
rename to libutils/binder/StrongPointer_test.cpp
diff --git a/libutils/Unicode.cpp b/libutils/binder/Unicode.cpp
similarity index 100%
rename from libutils/Unicode.cpp
rename to libutils/binder/Unicode.cpp
diff --git a/libutils/Unicode_test.cpp b/libutils/binder/Unicode_test.cpp
similarity index 100%
rename from libutils/Unicode_test.cpp
rename to libutils/binder/Unicode_test.cpp
diff --git a/libutils/VectorImpl.cpp b/libutils/binder/VectorImpl.cpp
similarity index 100%
rename from libutils/VectorImpl.cpp
rename to libutils/binder/VectorImpl.cpp
diff --git a/libutils/Vector_benchmark.cpp b/libutils/binder/Vector_benchmark.cpp
similarity index 100%
rename from libutils/Vector_benchmark.cpp
rename to libutils/binder/Vector_benchmark.cpp
diff --git a/libutils/Vector_fuzz.cpp b/libutils/binder/Vector_fuzz.cpp
similarity index 100%
rename from libutils/Vector_fuzz.cpp
rename to libutils/binder/Vector_fuzz.cpp
diff --git a/libutils/Vector_test.cpp b/libutils/binder/Vector_test.cpp
similarity index 100%
rename from libutils/Vector_test.cpp
rename to libutils/binder/Vector_test.cpp
diff --git a/libutils/binder/include/utils/Errors.h b/libutils/binder/include/utils/Errors.h
new file mode 100644
index 000000000000..22fb36d2500e
--- /dev/null
+++ b/libutils/binder/include/utils/Errors.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <errno.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <string>
+
+namespace android {
+
+/**
+ * The type used to return success/failure from frameworks APIs.
+ * See the anonymous enum below for valid values.
+ */
+typedef int32_t status_t;
+
+/*
+ * Error codes. 
+ * All error codes are negative values.
+ */
+
+enum {
+    OK                = 0,    // Preferred constant for checking success.
+#ifndef NO_ERROR
+    // Win32 #defines NO_ERROR as well.  It has the same value, so there's no
+    // real conflict, though it's a bit awkward.
+    NO_ERROR          = OK,   // Deprecated synonym for `OK`. Prefer `OK` because it doesn't conflict with Windows.
+#endif
+
+    UNKNOWN_ERROR       = (-2147483647-1), // INT32_MIN value
+
+    NO_MEMORY           = -ENOMEM,
+    INVALID_OPERATION   = -ENOSYS,
+    BAD_VALUE           = -EINVAL,
+    BAD_TYPE            = (UNKNOWN_ERROR + 1),
+    NAME_NOT_FOUND      = -ENOENT,
+    PERMISSION_DENIED   = -EPERM,
+    NO_INIT             = -ENODEV,
+    ALREADY_EXISTS      = -EEXIST,
+    DEAD_OBJECT         = -EPIPE,
+    FAILED_TRANSACTION  = (UNKNOWN_ERROR + 2),
+#if !defined(_WIN32)
+    BAD_INDEX           = -EOVERFLOW,
+    NOT_ENOUGH_DATA     = -ENODATA,
+    WOULD_BLOCK         = -EWOULDBLOCK, 
+    TIMED_OUT           = -ETIMEDOUT,
+    UNKNOWN_TRANSACTION = -EBADMSG,
+#else    
+    BAD_INDEX           = -E2BIG,
+    NOT_ENOUGH_DATA     = (UNKNOWN_ERROR + 3),
+    WOULD_BLOCK         = (UNKNOWN_ERROR + 4),
+    TIMED_OUT           = (UNKNOWN_ERROR + 5),
+    UNKNOWN_TRANSACTION = (UNKNOWN_ERROR + 6),
+#endif    
+    FDS_NOT_ALLOWED     = (UNKNOWN_ERROR + 7),
+    UNEXPECTED_NULL     = (UNKNOWN_ERROR + 8),
+};
+
+// Human readable name of error
+std::string statusToString(status_t status);
+
+}  // namespace android
diff --git a/libutils/binder/include/utils/RefBase.h b/libutils/binder/include/utils/RefBase.h
new file mode 100644
index 000000000000..5e3fa7d13c8a
--- /dev/null
+++ b/libutils/binder/include/utils/RefBase.h
@@ -0,0 +1,819 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+
+// SOME COMMENTS ABOUT USAGE:
+
+// This provides primarily wp<> weak pointer types and RefBase, which work
+// together with sp<> from <StrongPointer.h>.
+
+// sp<> (and wp<>) are a type of smart pointer that use a well defined protocol
+// to operate. As long as the object they are templated with implements that
+// protocol, these smart pointers work. In several places the platform
+// instantiates sp<> with non-RefBase objects; the two are not tied to each
+// other.
+
+// RefBase is such an implementation and it supports strong pointers, weak
+// pointers and some magic features for the binder.
+
+// So, when using RefBase objects, you have the ability to use strong and weak
+// pointers through sp<> and wp<>.
+
+// Normally, when the last strong pointer goes away, the object is destroyed,
+// i.e. it's destructor is called. HOWEVER, parts of its associated memory is not
+// freed until the last weak pointer is released.
+
+// Weak pointers are essentially "safe" pointers. They are always safe to
+// access through promote(). They may return nullptr if the object was
+// destroyed because it ran out of strong pointers. This makes them good candidates
+// for keys in a cache for instance.
+
+// Weak pointers remain valid for comparison purposes even after the underlying
+// object has been destroyed. Even if object A is destroyed and its memory reused
+// for B, A remaining weak pointer to A will not compare equal to one to B.
+// This again makes them attractive for use as keys.
+
+// How is this supposed / intended to be used?
+
+// Our recommendation is to use strong references (sp<>) when there is an
+// ownership relation. e.g. when an object "owns" another one, use a strong
+// ref. And of course use strong refs as arguments of functions (it's extremely
+// rare that a function will take a wp<>).
+
+// Typically a newly allocated object will immediately be used to initialize
+// a strong pointer, which may then be used to construct or assign to other
+// strong and weak pointers.
+
+// Use weak references when there are no ownership relation. e.g. the keys in a
+// cache (you cannot use plain pointers because there is no safe way to acquire
+// a strong reference from a vanilla pointer).
+
+// This implies that two objects should never (or very rarely) have sp<> on
+// each other, because they can't both own each other.
+
+
+// Caveats with reference counting
+
+// Obviously, circular strong references are a big problem; this creates leaks
+// and it's hard to debug -- except it's in fact really easy because RefBase has
+// tons of debugging code for that. It can basically tell you exactly where the
+// leak is.
+
+// Another problem has to do with destructors with side effects. You must
+// assume that the destructor of reference counted objects can be called AT ANY
+// TIME. For instance code as simple as this:
+
+// void setStuff(const sp<Stuff>& stuff) {
+//   std::lock_guard<std::mutex> lock(mMutex);
+//   mStuff = stuff;
+// }
+
+// is very dangerous. This code WILL deadlock one day or another.
+
+// What isn't obvious is that ~Stuff() can be called as a result of the
+// assignment. And it gets called with the lock held. First of all, the lock is
+// protecting mStuff, not ~Stuff(). Secondly, if ~Stuff() uses its own internal
+// mutex, now you have mutex ordering issues.  Even worse, if ~Stuff() is
+// virtual, now you're calling into "user" code (potentially), by that, I mean,
+// code you didn't even write.
+
+// A correct way to write this code is something like:
+
+// void setStuff(const sp<Stuff>& stuff) {
+//   std::unique_lock<std::mutex> lock(mMutex);
+//   sp<Stuff> hold = mStuff;
+//   mStuff = stuff;
+//   lock.unlock();
+// }
+
+// More importantly, reference counted objects should do as little work as
+// possible in their destructor, or at least be mindful that their destructor
+// could be called from very weird and unintended places.
+
+// Other more specific restrictions for wp<> and sp<>:
+
+// Do not construct a strong pointer to "this" in an object's constructor.
+// The onFirstRef() callback would be made on an incompletely constructed
+// object.
+// Construction of a weak pointer to "this" in an object's constructor is also
+// discouraged. But the implementation was recently changed so that, in the
+// absence of extendObjectLifetime() calls, weak pointers no longer impact
+// object lifetime, and hence this no longer risks premature deallocation,
+// and hence usually works correctly.
+
+// Such strong or weak pointers can be safely created in the RefBase onFirstRef()
+// callback.
+
+// Use of wp::unsafe_get() for any purpose other than debugging is almost
+// always wrong.  Unless you somehow know that there is a longer-lived sp<> to
+// the same object, it may well return a pointer to a deallocated object that
+// has since been reallocated for a different purpose. (And if you know there
+// is a longer-lived sp<>, why not use an sp<> directly?) A wp<> should only be
+// dereferenced by using promote().
+
+// Any object inheriting from RefBase should always be destroyed as the result
+// of a reference count decrement, not via any other means.  Such objects
+// should never be stack allocated, or appear directly as data members in other
+// objects. Objects inheriting from RefBase should have their strong reference
+// count incremented as soon as possible after construction. Usually this
+// will be done via construction of an sp<> to the object, but may instead
+// involve other means of calling RefBase::incStrong().
+// Explicitly deleting or otherwise destroying a RefBase object with outstanding
+// wp<> or sp<> pointers to it will result in an abort or heap corruption.
+
+// It is particularly important not to mix sp<> and direct storage management
+// since the sp from raw pointer constructor is implicit. Thus if a RefBase-
+// -derived object of type T is managed without ever incrementing its strong
+// count, and accidentally passed to f(sp<T>), a strong pointer to the object
+// will be temporarily constructed and destroyed, prematurely deallocating the
+// object, and resulting in heap corruption. None of this would be easily
+// visible in the source. See below on
+// ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION for a compile time
+// option which helps avoid this case.
+
+// Extra Features:
+
+// RefBase::extendObjectLifetime() can be used to prevent destruction of the
+// object while there are still weak references. This is really special purpose
+// functionality to support Binder.
+
+// Wp::promote(), implemented via the attemptIncStrong() member function, is
+// used to try to convert a weak pointer back to a strong pointer.  It's the
+// normal way to try to access the fields of an object referenced only through
+// a wp<>.  Binder code also sometimes uses attemptIncStrong() directly.
+
+// RefBase provides a number of additional callbacks for certain reference count
+// events, as well as some debugging facilities.
+
+// Debugging support can be enabled by turning on DEBUG_REFS in RefBase.cpp.
+// Otherwise little checking is provided.
+
+// Thread safety:
+
+// Like std::shared_ptr, sp<> and wp<> allow concurrent accesses to DIFFERENT
+// sp<> and wp<> instances that happen to refer to the same underlying object.
+// They do NOT support concurrent access (where at least one access is a write)
+// to THE SAME sp<> or wp<>.  In effect, their thread-safety properties are
+// exactly like those of T*, NOT atomic<T*>.
+
+// Safety option: ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION
+//
+// This flag makes the semantics for using a RefBase object with wp<> and sp<>
+// much stricter by disabling implicit conversion from raw pointers to these
+// objects. In order to use this, apply this flag in Android.bp like so:
+//
+//    cflags: [
+//        "-DANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION",
+//    ],
+//
+// REGARDLESS of whether this flag is on, best usage of sp<> is shown below. If
+// this flag is on, no other usage is possible (directly calling RefBase methods
+// is possible, but seeing code using 'incStrong' instead of 'sp<>', for
+// instance, should already set off big alarm bells. With carefully constructed
+// data structures, it should NEVER be necessary to directly use RefBase
+// methods). Proper RefBase usage:
+//
+//    class Foo : virtual public RefBase { ... };
+//
+//    // always construct an sp object with sp::make
+//    sp<Foo> myFoo = sp<Foo>::make(/*args*/);
+//
+//    // if you need a weak pointer, it must be constructed from a strong
+//    // pointer
+//    wp<Foo> weakFoo = myFoo; // NOT myFoo.get()
+//
+//    // If you are inside of a method of Foo and need access to a strong
+//    // explicitly call this function. This documents your intention to code
+//    // readers, and it will give a runtime error for what otherwise would
+//    // be potential double ownership
+//    .... Foo::someMethod(...) {
+//        // asserts if there is a memory issue
+//        sp<Foo> thiz = sp<Foo>::fromExisting(this);
+//    }
+//
+
+#ifndef ANDROID_REF_BASE_H
+#define ANDROID_REF_BASE_H
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <type_traits>  // for common_type.
+
+#include <stdint.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <string.h>
+
+// LightRefBase used to be declared in this header, so we have to include it
+#include <utils/LightRefBase.h>
+
+#include <utils/StrongPointer.h>
+#include <utils/TypeHelpers.h>
+
+// ---------------------------------------------------------------------------
+namespace android {
+
+// ---------------------------------------------------------------------------
+
+#define COMPARE_WEAK(_op_)                                      \
+template<typename U>                                            \
+inline bool operator _op_ (const U* o) const {                  \
+    return m_ptr _op_ o;                                        \
+}                                                               \
+/* Needed to handle type inference for nullptr: */              \
+inline bool operator _op_ (const T* o) const {                  \
+    return m_ptr _op_ o;                                        \
+}
+
+template<template<typename C> class comparator, typename T, typename U>
+static inline bool _wp_compare_(T* a, U* b) {
+    return comparator<typename std::common_type<T*, U*>::type>()(a, b);
+}
+
+// Use std::less and friends to avoid undefined behavior when ordering pointers
+// to different objects.
+#define COMPARE_WEAK_FUNCTIONAL(_op_, _compare_)                 \
+template<typename U>                                             \
+inline bool operator _op_ (const U* o) const {                   \
+    return _wp_compare_<_compare_>(m_ptr, o);                    \
+}
+
+// ---------------------------------------------------------------------------
+
+// RefererenceRenamer is pure abstract, there is no virtual method
+// implementation to put in a translation unit in order to silence the
+// weak vtables warning.
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+class ReferenceRenamer {
+protected:
+    // destructor is purposely not virtual so we avoid code overhead from
+    // subclasses; we have to make it protected to guarantee that it
+    // cannot be called from this base class (and to make strict compilers
+    // happy).
+    ~ReferenceRenamer() { }
+public:
+    virtual void operator()(size_t i) const = 0;
+};
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+// ---------------------------------------------------------------------------
+
+class RefBase
+{
+public:
+            void            incStrong(const void* id) const;
+            void            incStrongRequireStrong(const void* id) const;
+            void            decStrong(const void* id) const;
+    
+            void            forceIncStrong(const void* id) const;
+
+            //! DEBUGGING ONLY: Get current strong ref count.
+            int32_t         getStrongCount() const;
+
+    class weakref_type
+    {
+    public:
+        RefBase*            refBase() const;
+
+        void                incWeak(const void* id);
+        void                incWeakRequireWeak(const void* id);
+        void                decWeak(const void* id);
+
+        // acquires a strong reference if there is already one.
+        bool                attemptIncStrong(const void* id);
+
+        // acquires a weak reference if there is already one.
+        // This is not always safe. see ProcessState.cpp and BpBinder.cpp
+        // for proper use.
+        bool                attemptIncWeak(const void* id);
+
+        //! DEBUGGING ONLY: Get current weak ref count.
+        int32_t             getWeakCount() const;
+
+        //! DEBUGGING ONLY: Print references held on object.
+        void                printRefs() const;
+
+        //! DEBUGGING ONLY: Enable tracking for this object.
+        // enable -- enable/disable tracking
+        // retain -- when tracking is enable, if true, then we save a stack trace
+        //           for each reference and dereference; when retain == false, we
+        //           match up references and dereferences and keep only the
+        //           outstanding ones.
+
+        void                trackMe(bool enable, bool retain);
+    };
+
+            weakref_type*   createWeak(const void* id) const;
+            
+            weakref_type*   getWeakRefs() const;
+
+            //! DEBUGGING ONLY: Print references held on object.
+    inline  void            printRefs() const { getWeakRefs()->printRefs(); }
+
+            //! DEBUGGING ONLY: Enable tracking of object.
+    inline  void            trackMe(bool enable, bool retain)
+    { 
+        getWeakRefs()->trackMe(enable, retain); 
+    }
+
+protected:
+    // When constructing these objects, prefer using sp::make<>. Using a RefBase
+    // object on the stack or with other refcount mechanisms (e.g.
+    // std::shared_ptr) is inherently wrong. RefBase types have an implicit
+    // ownership model and cannot be safely used with other ownership models.
+
+                            RefBase();
+    virtual                 ~RefBase();
+    
+    //! Flags for extendObjectLifetime()
+    enum {
+        OBJECT_LIFETIME_STRONG  = 0x0000,
+        OBJECT_LIFETIME_WEAK    = 0x0001,
+        OBJECT_LIFETIME_MASK    = 0x0001
+    };
+    
+            void            extendObjectLifetime(int32_t mode);
+            
+    //! Flags for onIncStrongAttempted()
+    enum {
+        FIRST_INC_STRONG = 0x0001
+    };
+    
+    // Invoked after creation of initial strong pointer/reference.
+    virtual void            onFirstRef();
+    // Invoked when either the last strong reference goes away, or we need to undo
+    // the effect of an unnecessary onIncStrongAttempted.
+    virtual void            onLastStrongRef(const void* id);
+    // Only called in OBJECT_LIFETIME_WEAK case.  Returns true if OK to promote to
+    // strong reference. May have side effects if it returns true.
+    // The first flags argument is always FIRST_INC_STRONG.
+    // TODO: Remove initial flag argument.
+    virtual bool            onIncStrongAttempted(uint32_t flags, const void* id);
+    // Invoked in the OBJECT_LIFETIME_WEAK case when the last reference of either
+    // kind goes away.  Unused.
+    // TODO: Remove.
+    virtual void            onLastWeakRef(const void* id);
+
+private:
+    friend class weakref_type;
+    class weakref_impl;
+    
+                            RefBase(const RefBase& o);
+            RefBase&        operator=(const RefBase& o);
+
+private:
+    friend class ReferenceMover;
+
+    static void renameRefs(size_t n, const ReferenceRenamer& renamer);
+
+    static void renameRefId(weakref_type* ref,
+            const void* old_id, const void* new_id);
+
+    static void renameRefId(RefBase* ref,
+            const void* old_id, const void* new_id);
+
+        weakref_impl* const mRefs;
+};
+
+// ---------------------------------------------------------------------------
+
+template <typename T>
+class wp
+{
+public:
+    typedef typename RefBase::weakref_type weakref_type;
+
+    inline wp() : m_ptr(nullptr), m_refs(nullptr) { }
+
+    // if nullptr, returns nullptr
+    //
+    // if a weak pointer is already available, this will retrieve it,
+    // otherwise, this will abort
+    static inline wp<T> fromExisting(T* other);
+
+    // for more information about this flag, see above
+#if defined(ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION)
+    wp(std::nullptr_t) : wp() {}
+#else
+    wp(T* other);  // NOLINT(implicit)
+    template <typename U>
+    wp(U* other);  // NOLINT(implicit)
+    wp& operator=(T* other);
+    template <typename U>
+    wp& operator=(U* other);
+#endif
+
+    wp(const wp<T>& other);
+    explicit wp(const sp<T>& other);
+
+    template<typename U> wp(const sp<U>& other);  // NOLINT(implicit)
+    template<typename U> wp(const wp<U>& other);  // NOLINT(implicit)
+
+    ~wp();
+
+    // Assignment
+
+    wp& operator = (const wp<T>& other);
+    wp& operator = (const sp<T>& other);
+
+    template<typename U> wp& operator = (const wp<U>& other);
+    template<typename U> wp& operator = (const sp<U>& other);
+
+    void set_object_and_refs(T* other, weakref_type* refs);
+
+    // promotion to sp
+
+    sp<T> promote() const;
+
+    // Reset
+
+    void clear();
+
+    // Accessors
+
+    inline  weakref_type* get_refs() const { return m_refs; }
+
+    inline  T* unsafe_get() const { return m_ptr; }
+
+    // Operators
+
+    COMPARE_WEAK(==)
+    COMPARE_WEAK(!=)
+    COMPARE_WEAK_FUNCTIONAL(>, std::greater)
+    COMPARE_WEAK_FUNCTIONAL(<, std::less)
+    COMPARE_WEAK_FUNCTIONAL(<=, std::less_equal)
+    COMPARE_WEAK_FUNCTIONAL(>=, std::greater_equal)
+
+    template<typename U>
+    inline bool operator == (const wp<U>& o) const {
+        return m_refs == o.m_refs;  // Implies m_ptr == o.mptr; see invariants below.
+    }
+
+    template<typename U>
+    inline bool operator == (const sp<U>& o) const {
+        // Just comparing m_ptr fields is often dangerous, since wp<> may refer to an older
+        // object at the same address.
+        if (o == nullptr) {
+          return m_ptr == nullptr;
+        } else {
+          return m_refs == o->getWeakRefs();  // Implies m_ptr == o.mptr.
+        }
+    }
+
+    template<typename U>
+    inline bool operator != (const sp<U>& o) const {
+        return !(*this == o);
+    }
+
+    template<typename U>
+    inline bool operator > (const wp<U>& o) const {
+        if (m_ptr == o.m_ptr) {
+            return _wp_compare_<std::greater>(m_refs, o.m_refs);
+        } else {
+            return _wp_compare_<std::greater>(m_ptr, o.m_ptr);
+        }
+    }
+
+    template<typename U>
+    inline bool operator < (const wp<U>& o) const {
+        if (m_ptr == o.m_ptr) {
+            return _wp_compare_<std::less>(m_refs, o.m_refs);
+        } else {
+            return _wp_compare_<std::less>(m_ptr, o.m_ptr);
+        }
+    }
+    template<typename U> inline bool operator != (const wp<U>& o) const { return !operator == (o); }
+    template<typename U> inline bool operator <= (const wp<U>& o) const { return !operator > (o); }
+    template<typename U> inline bool operator >= (const wp<U>& o) const { return !operator < (o); }
+
+private:
+    template<typename Y> friend class sp;
+    template<typename Y> friend class wp;
+
+    T*              m_ptr;
+    weakref_type*   m_refs;
+};
+
+#undef COMPARE_WEAK
+#undef COMPARE_WEAK_FUNCTIONAL
+
+// ---------------------------------------------------------------------------
+// No user serviceable parts below here.
+
+// Implementation invariants:
+// Either
+// 1) m_ptr and m_refs are both null, or
+// 2) m_refs == m_ptr->mRefs, or
+// 3) *m_ptr is no longer live, and m_refs points to the weakref_type object that corresponded
+//    to m_ptr while it was live. *m_refs remains live while a wp<> refers to it.
+//
+// The m_refs field in a RefBase object is allocated on construction, unique to that RefBase
+// object, and never changes. Thus if two wp's have identical m_refs fields, they are either both
+// null or point to the same object. If two wp's have identical m_ptr fields, they either both
+// point to the same live object and thus have the same m_ref fields, or at least one of the
+// objects is no longer live.
+//
+// Note that the above comparison operations go out of their way to provide an ordering consistent
+// with ordinary pointer comparison; otherwise they could ignore m_ptr, and just compare m_refs.
+
+template <typename T>
+wp<T> wp<T>::fromExisting(T* other) {
+    if (!other) return nullptr;
+
+    auto refs = other->getWeakRefs();
+    refs->incWeakRequireWeak(other);
+
+    wp<T> ret;
+    ret.m_ptr = other;
+    ret.m_refs = refs;
+    return ret;
+}
+
+#if !defined(ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION)
+template<typename T>
+wp<T>::wp(T* other)
+    : m_ptr(other)
+{
+    m_refs = other ? m_refs = other->createWeak(this) : nullptr;
+}
+
+template <typename T>
+template <typename U>
+wp<T>::wp(U* other) : m_ptr(other) {
+    m_refs = other ? other->createWeak(this) : nullptr;
+}
+
+template <typename T>
+wp<T>& wp<T>::operator=(T* other) {
+    weakref_type* newRefs = other ? other->createWeak(this) : nullptr;
+    if (m_ptr) m_refs->decWeak(this);
+    m_ptr = other;
+    m_refs = newRefs;
+    return *this;
+}
+
+template <typename T>
+template <typename U>
+wp<T>& wp<T>::operator=(U* other) {
+    weakref_type* newRefs = other ? other->createWeak(this) : 0;
+    if (m_ptr) m_refs->decWeak(this);
+    m_ptr = other;
+    m_refs = newRefs;
+    return *this;
+}
+#endif
+
+template<typename T>
+wp<T>::wp(const wp<T>& other)
+    : m_ptr(other.m_ptr), m_refs(other.m_refs)
+{
+    if (m_ptr) m_refs->incWeak(this);
+}
+
+template<typename T>
+wp<T>::wp(const sp<T>& other)
+    : m_ptr(other.m_ptr)
+{
+    m_refs = m_ptr ? m_ptr->createWeak(this) : nullptr;
+}
+
+template<typename T> template<typename U>
+wp<T>::wp(const wp<U>& other)
+    : m_ptr(other.m_ptr)
+{
+    if (m_ptr) {
+        m_refs = other.m_refs;
+        m_refs->incWeak(this);
+    } else {
+        m_refs = nullptr;
+    }
+}
+
+template<typename T> template<typename U>
+wp<T>::wp(const sp<U>& other)
+    : m_ptr(other.m_ptr)
+{
+    m_refs = m_ptr ? m_ptr->createWeak(this) : nullptr;
+}
+
+template<typename T>
+wp<T>::~wp()
+{
+    if (m_ptr) m_refs->decWeak(this);
+}
+
+template<typename T>
+wp<T>& wp<T>::operator = (const wp<T>& other)
+{
+    weakref_type* otherRefs(other.m_refs);
+    T* otherPtr(other.m_ptr);
+    if (otherPtr) otherRefs->incWeak(this);
+    if (m_ptr) m_refs->decWeak(this);
+    m_ptr = otherPtr;
+    m_refs = otherRefs;
+    return *this;
+}
+
+template<typename T>
+wp<T>& wp<T>::operator = (const sp<T>& other)
+{
+    weakref_type* newRefs =
+        other != nullptr ? other->createWeak(this) : nullptr;
+    T* otherPtr(other.m_ptr);
+    if (m_ptr) m_refs->decWeak(this);
+    m_ptr = otherPtr;
+    m_refs = newRefs;
+    return *this;
+}
+
+template<typename T> template<typename U>
+wp<T>& wp<T>::operator = (const wp<U>& other)
+{
+    weakref_type* otherRefs(other.m_refs);
+    U* otherPtr(other.m_ptr);
+    if (otherPtr) otherRefs->incWeak(this);
+    if (m_ptr) m_refs->decWeak(this);
+    m_ptr = otherPtr;
+    m_refs = otherRefs;
+    return *this;
+}
+
+template<typename T> template<typename U>
+wp<T>& wp<T>::operator = (const sp<U>& other)
+{
+    weakref_type* newRefs =
+        other != nullptr ? other->createWeak(this) : 0;
+    U* otherPtr(other.m_ptr);
+    if (m_ptr) m_refs->decWeak(this);
+    m_ptr = otherPtr;
+    m_refs = newRefs;
+    return *this;
+}
+
+template<typename T>
+void wp<T>::set_object_and_refs(T* other, weakref_type* refs)
+{
+    if (other) refs->incWeak(this);
+    if (m_ptr) m_refs->decWeak(this);
+    m_ptr = other;
+    m_refs = refs;
+}
+
+template<typename T>
+sp<T> wp<T>::promote() const
+{
+    sp<T> result;
+    if (m_ptr && m_refs->attemptIncStrong(&result)) {
+        result.set_pointer(m_ptr);
+    }
+    return result;
+}
+
+template<typename T>
+void wp<T>::clear()
+{
+    if (m_ptr) {
+        m_refs->decWeak(this);
+        m_refs = 0;
+        m_ptr = 0;
+    }
+}
+
+// ---------------------------------------------------------------------------
+
+// this class just serves as a namespace so TYPE::moveReferences can stay
+// private.
+class ReferenceMover {
+public:
+    // it would be nice if we could make sure no extra code is generated
+    // for sp<TYPE> or wp<TYPE> when TYPE is a descendant of RefBase:
+    // Using a sp<RefBase> override doesn't work; it's a bit like we wanted
+    // a template<typename TYPE inherits RefBase> template...
+
+    template<typename TYPE> static inline
+    void move_references(sp<TYPE>* dest, sp<TYPE> const* src, size_t n) {
+
+        class Renamer : public ReferenceRenamer {
+            sp<TYPE>* d_;
+            sp<TYPE> const* s_;
+            virtual void operator()(size_t i) const {
+                // The id are known to be the sp<>'s this pointer
+                TYPE::renameRefId(d_[i].get(), &s_[i], &d_[i]);
+            }
+        public:
+            Renamer(sp<TYPE>* d, sp<TYPE> const* s) : d_(d), s_(s) { }
+            virtual ~Renamer() { }
+        };
+
+        memmove(dest, src, n*sizeof(sp<TYPE>));
+        TYPE::renameRefs(n, Renamer(dest, src));
+    }
+
+
+    template<typename TYPE> static inline
+    void move_references(wp<TYPE>* dest, wp<TYPE> const* src, size_t n) {
+
+        class Renamer : public ReferenceRenamer {
+            wp<TYPE>* d_;
+            wp<TYPE> const* s_;
+            virtual void operator()(size_t i) const {
+                // The id are known to be the wp<>'s this pointer
+                TYPE::renameRefId(d_[i].get_refs(), &s_[i], &d_[i]);
+            }
+        public:
+            Renamer(wp<TYPE>* rd, wp<TYPE> const* rs) : d_(rd), s_(rs) { }
+            virtual ~Renamer() { }
+        };
+
+        memmove(dest, src, n*sizeof(wp<TYPE>));
+        TYPE::renameRefs(n, Renamer(dest, src));
+    }
+};
+
+// specialization for moving sp<> and wp<> types.
+// these are used by the [Sorted|Keyed]Vector<> implementations
+// sp<> and wp<> need to be handled specially, because they do not
+// have trivial copy operation in the general case (see RefBase.cpp
+// when DEBUG ops are enabled), but can be implemented very
+// efficiently in most cases.
+
+template<typename TYPE> inline
+void move_forward_type(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
+    ReferenceMover::move_references(d, s, n);
+}
+
+template<typename TYPE> inline
+void move_backward_type(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
+    ReferenceMover::move_references(d, s, n);
+}
+
+template<typename TYPE> inline
+void move_forward_type(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
+    ReferenceMover::move_references(d, s, n);
+}
+
+template<typename TYPE> inline
+void move_backward_type(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
+    ReferenceMover::move_references(d, s, n);
+}
+
+}  // namespace android
+
+namespace libutilsinternal {
+template <typename T, typename = void>
+struct is_complete_type : std::false_type {};
+
+template <typename T>
+struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
+}  // namespace libutilsinternal
+
+namespace std {
+
+// Define `RefBase` specific versions of `std::make_shared` and
+// `std::make_unique` to block people from using them. Using them to allocate
+// `RefBase` objects results in double ownership. Use
+// `sp<T>::make(...)` instead.
+//
+// Note: We exclude incomplete types because `std::is_base_of` is undefined in
+// that case.
+
+template <typename T, typename... Args,
+          typename std::enable_if<libutilsinternal::is_complete_type<T>::value, bool>::value = true,
+          typename std::enable_if<std::is_base_of<android::RefBase, T>::value, bool>::value = true>
+shared_ptr<T> make_shared(Args...) {  // SEE COMMENT ABOVE.
+    static_assert(!std::is_base_of<android::RefBase, T>::value, "Must use RefBase with sp<>");
+}
+
+template <typename T, typename... Args,
+          typename std::enable_if<libutilsinternal::is_complete_type<T>::value, bool>::value = true,
+          typename std::enable_if<std::is_base_of<android::RefBase, T>::value, bool>::value = true>
+unique_ptr<T> make_unique(Args...) {  // SEE COMMENT ABOVE.
+    static_assert(!std::is_base_of<android::RefBase, T>::value, "Must use RefBase with sp<>");
+}
+
+}  // namespace std
+
+// ---------------------------------------------------------------------------
+
+#endif // ANDROID_REF_BASE_H
diff --git a/libutils/binder/include/utils/String16.h b/libutils/binder/include/utils/String16.h
new file mode 100644
index 000000000000..c7135766b097
--- /dev/null
+++ b/libutils/binder/include/utils/String16.h
@@ -0,0 +1,383 @@
+/*
+ * Copyright (C) 2005 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.
+ */
+
+#ifndef ANDROID_STRING16_H
+#define ANDROID_STRING16_H
+
+#include <iostream>
+#include <string>
+
+#include <utils/Errors.h>
+#include <utils/String8.h>
+#include <utils/TypeHelpers.h>
+
+#if __has_include(<string_view>)
+#include <string_view>
+#define HAS_STRING_VIEW
+#endif
+
+// ---------------------------------------------------------------------------
+
+namespace android {
+
+// ---------------------------------------------------------------------------
+
+template <size_t N>
+class StaticString16;
+
+// DO NOT USE: please use std::u16string
+
+//! This is a string holding UTF-16 characters.
+class String16
+{
+public:
+                                String16();
+                                String16(const String16& o);
+                                String16(String16&& o) noexcept;
+                                String16(const String16& o,
+                                         size_t len,
+                                         size_t begin=0);
+    explicit                    String16(const char16_t* o);
+    explicit                    String16(const char16_t* o, size_t len);
+    explicit                    String16(const String8& o);
+    explicit                    String16(const char* o);
+    explicit                    String16(const char* o, size_t len);
+
+                                ~String16();
+
+    inline  const char16_t*     c_str() const;
+
+            size_t              size() const;
+    inline  bool                empty() const;
+
+    inline  size_t              length() const;
+
+            void                setTo(const String16& other);
+            status_t            setTo(const char16_t* other);
+            status_t            setTo(const char16_t* other, size_t len);
+            status_t            setTo(const String16& other,
+                                      size_t len,
+                                      size_t begin=0);
+
+            status_t            append(const String16& other);
+            status_t            append(const char16_t* other, size_t len);
+
+    inline  String16&           operator=(const String16& other);
+            String16&           operator=(String16&& other) noexcept;
+
+    inline  String16&           operator+=(const String16& other);
+    inline  String16            operator+(const String16& other) const;
+
+            status_t            insert(size_t pos, const char16_t* chrs);
+            status_t            insert(size_t pos,
+                                       const char16_t* chrs, size_t len);
+
+            ssize_t             findFirst(char16_t c) const;
+            ssize_t             findLast(char16_t c) const;
+
+            bool                startsWith(const String16& prefix) const;
+            bool                startsWith(const char16_t* prefix) const;
+
+            bool                contains(const char16_t* chrs) const;
+    inline  bool                contains(const String16& other) const;
+
+            status_t            replaceAll(char16_t replaceThis,
+                                           char16_t withThis);
+
+    inline  int                 compare(const String16& other) const;
+
+    inline  bool                operator<(const String16& other) const;
+    inline  bool                operator<=(const String16& other) const;
+    inline  bool                operator==(const String16& other) const;
+    inline  bool                operator!=(const String16& other) const;
+    inline  bool                operator>=(const String16& other) const;
+    inline  bool                operator>(const String16& other) const;
+
+    inline  bool                operator<(const char16_t* other) const;
+    inline  bool                operator<=(const char16_t* other) const;
+    inline  bool                operator==(const char16_t* other) const;
+    inline  bool                operator!=(const char16_t* other) const;
+    inline  bool                operator>=(const char16_t* other) const;
+    inline  bool                operator>(const char16_t* other) const;
+
+    inline                      operator const char16_t*() const;
+
+#ifdef HAS_STRING_VIEW
+    // Implicit cast to std::u16string is not implemented on purpose - u16string_view is much
+    // lighter and if one needs, they can still create u16string from u16string_view.
+    inline                      operator std::u16string_view() const;
+#endif
+
+    // Static and non-static String16 behave the same for the users, so
+    // this method isn't of much use for the users. It is public for testing.
+            bool                isStaticString() const;
+
+  private:
+    /*
+     * A flag indicating the type of underlying buffer.
+     */
+    static constexpr uint32_t kIsSharedBufferAllocated = 0x80000000;
+
+    /*
+     * alloc() returns void* so that SharedBuffer class is not exposed.
+     */
+    static void* alloc(size_t size);
+    static char16_t* allocFromUTF8(const char* u8str, size_t u8len);
+    static char16_t* allocFromUTF16(const char16_t* u16str, size_t u16len);
+
+    /*
+     * edit() and editResize() return void* so that SharedBuffer class
+     * is not exposed.
+     */
+    void* edit();
+    void* editResize(size_t new_size);
+
+    void acquire();
+    void release();
+
+    size_t staticStringSize() const;
+
+    const char16_t* mString;
+
+protected:
+    /*
+     * Data structure used to allocate static storage for static String16.
+     *
+     * Note that this data structure and SharedBuffer are used interchangably
+     * as the underlying data structure for a String16.  Therefore, the layout
+     * of this data structure must match the part in SharedBuffer that is
+     * visible to String16.
+     */
+    template <size_t N>
+    struct StaticData {
+        // The high bit of 'size' is used as a flag.
+        static_assert(N - 1 < kIsSharedBufferAllocated, "StaticString16 too long!");
+        constexpr StaticData() : size(N - 1), data{0} {}
+        const uint32_t size;
+        char16_t data[N];
+
+        constexpr StaticData(const StaticData<N>&) = default;
+    };
+
+    /*
+     * Helper function for constructing a StaticData object.
+     */
+    template <size_t N>
+    static constexpr const StaticData<N> makeStaticData(const char16_t (&s)[N]) {
+        StaticData<N> r;
+        // The 'size' field is at the same location where mClientMetadata would
+        // be for a SharedBuffer.  We do NOT set kIsSharedBufferAllocated flag
+        // here.
+        for (size_t i = 0; i < N - 1; ++i) r.data[i] = s[i];
+        return r;
+    }
+
+    template <size_t N>
+    explicit constexpr String16(const StaticData<N>& s) : mString(s.data) {}
+
+// These symbols are for potential backward compatibility with prebuilts. To be removed.
+#ifdef ENABLE_STRING16_OBSOLETE_METHODS
+public:
+#else
+private:
+#endif
+    inline  const char16_t*     string() const;
+};
+
+// String16 can be trivially moved using memcpy() because moving does not
+// require any change to the underlying SharedBuffer contents or reference count.
+ANDROID_TRIVIAL_MOVE_TRAIT(String16)
+
+static inline std::ostream& operator<<(std::ostream& os, const String16& str) {
+    os << String8(str);
+    return os;
+}
+
+// ---------------------------------------------------------------------------
+
+/*
+ * A StaticString16 object is a specialized String16 object.  Instead of holding
+ * the string data in a ref counted SharedBuffer object, it holds data in a
+ * buffer within StaticString16 itself.  Note that this buffer is NOT ref
+ * counted and is assumed to be available for as long as there is at least a
+ * String16 object using it.  Therefore, one must be extra careful to NEVER
+ * assign a StaticString16 to a String16 that outlives the StaticString16
+ * object.
+ *
+ * THE SAFEST APPROACH IS TO USE StaticString16 ONLY AS GLOBAL VARIABLES.
+ *
+ * A StaticString16 SHOULD NEVER APPEAR IN APIs.  USE String16 INSTEAD.
+ */
+template <size_t N>
+class StaticString16 : public String16 {
+public:
+    constexpr StaticString16(const char16_t (&s)[N]) : String16(mData), mData(makeStaticData(s)) {}
+
+    constexpr StaticString16(const StaticString16<N>& other)
+        : String16(mData), mData(other.mData) {}
+
+    constexpr StaticString16(const StaticString16<N>&&) = delete;
+
+    // There is no reason why one would want to 'new' a StaticString16.  Delete
+    // it to discourage misuse.
+    static void* operator new(std::size_t) = delete;
+
+private:
+    const StaticData<N> mData;
+};
+
+template <typename F>
+StaticString16(const F&)->StaticString16<sizeof(F) / sizeof(char16_t)>;
+
+// ---------------------------------------------------------------------------
+// No user servicable parts below.
+
+inline int compare_type(const String16& lhs, const String16& rhs)
+{
+    return lhs.compare(rhs);
+}
+
+inline int strictly_order_type(const String16& lhs, const String16& rhs)
+{
+    return compare_type(lhs, rhs) < 0;
+}
+
+inline const char16_t* String16::c_str() const
+{
+    return mString;
+}
+
+inline const char16_t* String16::string() const
+{
+    return mString;
+}
+
+inline bool String16::empty() const
+{
+    return length() == 0;
+}
+
+inline size_t String16::length() const
+{
+    return size();
+}
+
+inline bool String16::contains(const String16& other) const
+{
+    return contains(other.c_str());
+}
+
+inline String16& String16::operator=(const String16& other)
+{
+    setTo(other);
+    return *this;
+}
+
+inline String16& String16::operator+=(const String16& other)
+{
+    append(other);
+    return *this;
+}
+
+inline String16 String16::operator+(const String16& other) const
+{
+    String16 tmp(*this);
+    tmp += other;
+    return tmp;
+}
+
+inline int String16::compare(const String16& other) const
+{
+    return strzcmp16(mString, size(), other.mString, other.size());
+}
+
+inline bool String16::operator<(const String16& other) const
+{
+    return strzcmp16(mString, size(), other.mString, other.size()) < 0;
+}
+
+inline bool String16::operator<=(const String16& other) const
+{
+    return strzcmp16(mString, size(), other.mString, other.size()) <= 0;
+}
+
+inline bool String16::operator==(const String16& other) const
+{
+    return strzcmp16(mString, size(), other.mString, other.size()) == 0;
+}
+
+inline bool String16::operator!=(const String16& other) const
+{
+    return strzcmp16(mString, size(), other.mString, other.size()) != 0;
+}
+
+inline bool String16::operator>=(const String16& other) const
+{
+    return strzcmp16(mString, size(), other.mString, other.size()) >= 0;
+}
+
+inline bool String16::operator>(const String16& other) const
+{
+    return strzcmp16(mString, size(), other.mString, other.size()) > 0;
+}
+
+inline bool String16::operator<(const char16_t* other) const
+{
+    return strcmp16(mString, other) < 0;
+}
+
+inline bool String16::operator<=(const char16_t* other) const
+{
+    return strcmp16(mString, other) <= 0;
+}
+
+inline bool String16::operator==(const char16_t* other) const
+{
+    return strcmp16(mString, other) == 0;
+}
+
+inline bool String16::operator!=(const char16_t* other) const
+{
+    return strcmp16(mString, other) != 0;
+}
+
+inline bool String16::operator>=(const char16_t* other) const
+{
+    return strcmp16(mString, other) >= 0;
+}
+
+inline bool String16::operator>(const char16_t* other) const
+{
+    return strcmp16(mString, other) > 0;
+}
+
+inline String16::operator const char16_t*() const
+{
+    return mString;
+}
+
+inline String16::operator std::u16string_view() const
+{
+    return {mString, length()};
+}
+
+}  // namespace android
+
+// ---------------------------------------------------------------------------
+
+#undef HAS_STRING_VIEW
+
+#endif // ANDROID_STRING16_H
diff --git a/libutils/binder/include/utils/String8.h b/libutils/binder/include/utils/String8.h
new file mode 100644
index 000000000000..6d250723b628
--- /dev/null
+++ b/libutils/binder/include/utils/String8.h
@@ -0,0 +1,354 @@
+/*
+ * Copyright (C) 2005 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.
+ */
+
+#ifndef ANDROID_STRING8_H
+#define ANDROID_STRING8_H
+
+#include <iostream>
+
+#include <utils/Errors.h>
+#include <utils/Unicode.h>
+#include <utils/TypeHelpers.h>
+
+#include <string.h> // for strcmp
+#include <stdarg.h>
+
+#if __has_include(<string>)
+#include <string>
+#define HAS_STRING
+#endif
+
+#if __has_include(<string_view>)
+#include <string_view>
+#define HAS_STRING_VIEW
+#endif
+
+// ---------------------------------------------------------------------------
+
+namespace android {
+
+class String16;
+
+// DO NOT USE: please use std::string
+
+//! This is a string holding UTF-8 characters. Does not allow the value more
+// than 0x10FFFF, which is not valid unicode codepoint.
+class String8
+{
+public:
+                                String8();
+                                String8(const String8& o);
+    explicit                    String8(const char* o);
+    explicit                    String8(const char* o, size_t numChars);
+
+    explicit                    String8(const String16& o);
+    explicit                    String8(const char16_t* o);
+    explicit                    String8(const char16_t* o, size_t numChars);
+    explicit                    String8(const char32_t* o);
+    explicit                    String8(const char32_t* o, size_t numChars);
+                                ~String8();
+
+    static String8              format(const char* fmt, ...) __attribute__((format (printf, 1, 2)));
+    static String8              formatV(const char* fmt, va_list args);
+
+    inline  const char*         c_str() const;
+
+    inline  size_t              size() const;
+    inline  size_t              bytes() const;
+    inline  bool                empty() const;
+
+            size_t              length() const;
+
+            void                clear();
+
+            void                setTo(const String8& other);
+            status_t            setTo(const char* other);
+            status_t            setTo(const char* other, size_t numChars);
+            status_t            setTo(const char16_t* other, size_t numChars);
+            status_t            setTo(const char32_t* other,
+                                      size_t length);
+
+            status_t            append(const String8& other);
+            status_t            append(const char* other);
+            status_t            append(const char* other, size_t numChars);
+
+            status_t            appendFormat(const char* fmt, ...)
+                    __attribute__((format (printf, 2, 3)));
+            status_t            appendFormatV(const char* fmt, va_list args);
+
+    inline  String8&            operator=(const String8& other);
+    inline  String8&            operator=(const char* other);
+
+    inline  String8&            operator+=(const String8& other);
+    inline  String8             operator+(const String8& other) const;
+
+    inline  String8&            operator+=(const char* other);
+    inline  String8             operator+(const char* other) const;
+
+    inline  int                 compare(const String8& other) const;
+
+    inline  bool                operator<(const String8& other) const;
+    inline  bool                operator<=(const String8& other) const;
+    inline  bool                operator==(const String8& other) const;
+    inline  bool                operator!=(const String8& other) const;
+    inline  bool                operator>=(const String8& other) const;
+    inline  bool                operator>(const String8& other) const;
+
+    inline  bool                operator<(const char* other) const;
+    inline  bool                operator<=(const char* other) const;
+    inline  bool                operator==(const char* other) const;
+    inline  bool                operator!=(const char* other) const;
+    inline  bool                operator>=(const char* other) const;
+    inline  bool                operator>(const char* other) const;
+
+    inline                      operator const char*() const;
+
+#ifdef HAS_STRING_VIEW
+    inline explicit             operator std::string_view() const;
+#endif
+
+            char*               lockBuffer(size_t size);
+            void                unlockBuffer();
+            status_t            unlockBuffer(size_t size);
+
+            // return the index of the first byte of other in this at or after
+            // start, or -1 if not found
+            ssize_t             find(const char* other, size_t start = 0) const;
+    inline  ssize_t             find(const String8& other, size_t start = 0) const;
+
+            // return true if this string contains the specified substring
+    inline  bool                contains(const char* other) const;
+    inline  bool                contains(const String8& other) const;
+
+            // removes all occurrence of the specified substring
+            // returns true if any were found and removed
+            bool                removeAll(const char* other);
+    inline  bool                removeAll(const String8& other);
+
+            void                toLower();
+
+private:
+            String8 getPathDir(void) const;
+            String8 getPathExtension(void) const;
+
+            status_t            real_append(const char* other, size_t numChars);
+
+            const char* mString;
+
+// These symbols are for potential backward compatibility with prebuilts. To be removed.
+#ifdef ENABLE_STRING8_OBSOLETE_METHODS
+public:
+#else
+private:
+#endif
+    inline  const char*         string() const;
+    inline  bool                isEmpty() const;
+};
+
+// String8 can be trivially moved using memcpy() because moving does not
+// require any change to the underlying SharedBuffer contents or reference count.
+ANDROID_TRIVIAL_MOVE_TRAIT(String8)
+
+static inline std::ostream& operator<<(std::ostream& os, const String8& str) {
+    os << str.c_str();
+    return os;
+}
+
+// ---------------------------------------------------------------------------
+// No user servicable parts below.
+
+inline int compare_type(const String8& lhs, const String8& rhs)
+{
+    return lhs.compare(rhs);
+}
+
+inline int strictly_order_type(const String8& lhs, const String8& rhs)
+{
+    return compare_type(lhs, rhs) < 0;
+}
+
+inline const char* String8::c_str() const
+{
+    return mString;
+}
+inline const char* String8::string() const
+{
+    return mString;
+}
+
+inline size_t String8::size() const
+{
+    return length();
+}
+
+inline bool String8::empty() const
+{
+    return length() == 0;
+}
+
+inline bool String8::isEmpty() const
+{
+    return length() == 0;
+}
+
+inline size_t String8::bytes() const
+{
+    return length();
+}
+
+inline ssize_t String8::find(const String8& other, size_t start) const
+{
+    return find(other.c_str(), start);
+}
+
+inline bool String8::contains(const char* other) const
+{
+    return find(other) >= 0;
+}
+
+inline bool String8::contains(const String8& other) const
+{
+    return contains(other.c_str());
+}
+
+inline bool String8::removeAll(const String8& other)
+{
+    return removeAll(other.c_str());
+}
+
+inline String8& String8::operator=(const String8& other)
+{
+    setTo(other);
+    return *this;
+}
+
+inline String8& String8::operator=(const char* other)
+{
+    setTo(other);
+    return *this;
+}
+
+inline String8& String8::operator+=(const String8& other)
+{
+    append(other);
+    return *this;
+}
+
+inline String8 String8::operator+(const String8& other) const
+{
+    String8 tmp(*this);
+    tmp += other;
+    return tmp;
+}
+
+inline String8& String8::operator+=(const char* other)
+{
+    append(other);
+    return *this;
+}
+
+inline String8 String8::operator+(const char* other) const
+{
+    String8 tmp(*this);
+    tmp += other;
+    return tmp;
+}
+
+inline int String8::compare(const String8& other) const
+{
+    return strcmp(mString, other.mString);
+}
+
+inline bool String8::operator<(const String8& other) const
+{
+    return strcmp(mString, other.mString) < 0;
+}
+
+inline bool String8::operator<=(const String8& other) const
+{
+    return strcmp(mString, other.mString) <= 0;
+}
+
+inline bool String8::operator==(const String8& other) const
+{
+    return strcmp(mString, other.mString) == 0;
+}
+
+inline bool String8::operator!=(const String8& other) const
+{
+    return strcmp(mString, other.mString) != 0;
+}
+
+inline bool String8::operator>=(const String8& other) const
+{
+    return strcmp(mString, other.mString) >= 0;
+}
+
+inline bool String8::operator>(const String8& other) const
+{
+    return strcmp(mString, other.mString) > 0;
+}
+
+inline bool String8::operator<(const char* other) const
+{
+    return strcmp(mString, other) < 0;
+}
+
+inline bool String8::operator<=(const char* other) const
+{
+    return strcmp(mString, other) <= 0;
+}
+
+inline bool String8::operator==(const char* other) const
+{
+    return strcmp(mString, other) == 0;
+}
+
+inline bool String8::operator!=(const char* other) const
+{
+    return strcmp(mString, other) != 0;
+}
+
+inline bool String8::operator>=(const char* other) const
+{
+    return strcmp(mString, other) >= 0;
+}
+
+inline bool String8::operator>(const char* other) const
+{
+    return strcmp(mString, other) > 0;
+}
+
+inline String8::operator const char*() const
+{
+    return mString;
+}
+
+#ifdef HAS_STRING_VIEW
+inline String8::operator std::string_view() const
+{
+    return {mString, length()};
+}
+#endif
+
+}  // namespace android
+
+// ---------------------------------------------------------------------------
+
+#undef HAS_STRING
+#undef HAS_STRING_VIEW
+
+#endif // ANDROID_STRING8_H
diff --git a/libutils/binder/include/utils/StrongPointer.h b/libutils/binder/include/utils/StrongPointer.h
new file mode 100644
index 000000000000..54aa691e03c2
--- /dev/null
+++ b/libutils/binder/include/utils/StrongPointer.h
@@ -0,0 +1,361 @@
+/*
+ * Copyright (C) 2005 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.
+ */
+
+#ifndef ANDROID_STRONG_POINTER_H
+#define ANDROID_STRONG_POINTER_H
+
+#include <functional>
+#include <type_traits>  // for common_type.
+
+// ---------------------------------------------------------------------------
+namespace android {
+
+template<typename T> class wp;
+
+// ---------------------------------------------------------------------------
+
+template<typename T>
+class sp {
+public:
+    inline sp() : m_ptr(nullptr) { }
+
+    // The old way of using sp<> was like this. This is bad because it relies
+    // on implicit conversion to sp<>, which we would like to remove (if an
+    // object is being managed some other way, this is double-ownership). We
+    // want to move away from this:
+    //
+    //     sp<Foo> foo = new Foo(...); // DO NOT DO THIS
+    //
+    // Instead, prefer to do this:
+    //
+    //     sp<Foo> foo = sp<Foo>::make(...); // DO THIS
+    //
+    // Sometimes, in order to use this, when a constructor is marked as private,
+    // you may need to add this to your class:
+    //
+    //     friend class sp<Foo>;
+    template <typename... Args>
+    static inline sp<T> make(Args&&... args);
+
+    // if nullptr, returns nullptr
+    //
+    // if a strong pointer is already available, this will retrieve it,
+    // otherwise, this will abort
+    static inline sp<T> fromExisting(T* other);
+
+    // for more information about this macro and correct RefBase usage, see
+    // the comment at the top of utils/RefBase.h
+#if defined(ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION)
+    sp(std::nullptr_t) : sp() {}
+#else
+    sp(T* other);  // NOLINT(implicit)
+    template <typename U>
+    sp(U* other);  // NOLINT(implicit)
+    sp& operator=(T* other);
+    template <typename U>
+    sp& operator=(U* other);
+#endif
+
+    sp(const sp<T>& other);
+    sp(sp<T>&& other) noexcept;
+
+    template<typename U> sp(const sp<U>& other);  // NOLINT(implicit)
+    template<typename U> sp(sp<U>&& other);  // NOLINT(implicit)
+
+    // Cast a strong pointer directly from one type to another. Constructors
+    // allow changing types, but only if they are pointer-compatible. This does
+    // a static_cast internally.
+    template <typename U>
+    static inline sp<T> cast(const sp<U>& other);
+
+    ~sp();
+
+    // Assignment
+
+    sp& operator = (const sp<T>& other);
+    sp& operator=(sp<T>&& other) noexcept;
+
+    template<typename U> sp& operator = (const sp<U>& other);
+    template<typename U> sp& operator = (sp<U>&& other);
+
+    //! Special optimization for use by ProcessState (and nobody else).
+    void force_set(T* other);
+
+    // Reset
+
+    void clear();
+
+    // Accessors
+
+    inline T&       operator* () const     { return *m_ptr; }
+    inline T*       operator-> () const    { return m_ptr;  }
+    inline T*       get() const            { return m_ptr; }
+    inline explicit operator bool () const { return m_ptr != nullptr; }
+
+    // Punt these to the wp<> implementation.
+    template<typename U>
+    inline bool operator == (const wp<U>& o) const {
+        return o == *this;
+    }
+
+    template<typename U>
+    inline bool operator != (const wp<U>& o) const {
+        return o != *this;
+    }
+
+private:
+    template<typename Y> friend class sp;
+    template<typename Y> friend class wp;
+    void set_pointer(T* ptr);
+    T* m_ptr;
+};
+
+#define COMPARE_STRONG(_op_)                                           \
+    template <typename T, typename U>                                  \
+    static inline bool operator _op_(const sp<T>& t, const sp<U>& u) { \
+        return t.get() _op_ u.get();                                   \
+    }                                                                  \
+    template <typename T, typename U>                                  \
+    static inline bool operator _op_(const T* t, const sp<U>& u) {     \
+        return t _op_ u.get();                                         \
+    }                                                                  \
+    template <typename T, typename U>                                  \
+    static inline bool operator _op_(const sp<T>& t, const U* u) {     \
+        return t.get() _op_ u;                                         \
+    }                                                                  \
+    template <typename T>                                              \
+    static inline bool operator _op_(const sp<T>& t, std::nullptr_t) { \
+        return t.get() _op_ nullptr;                                   \
+    }                                                                  \
+    template <typename T>                                              \
+    static inline bool operator _op_(std::nullptr_t, const sp<T>& t) { \
+        return nullptr _op_ t.get();                                   \
+    }
+
+template <template <typename C> class comparator, typename T, typename U>
+static inline bool _sp_compare_(T* a, U* b) {
+    return comparator<typename std::common_type<T*, U*>::type>()(a, b);
+}
+
+#define COMPARE_STRONG_FUNCTIONAL(_op_, _compare_)                     \
+    template <typename T, typename U>                                  \
+    static inline bool operator _op_(const sp<T>& t, const sp<U>& u) { \
+        return _sp_compare_<_compare_>(t.get(), u.get());              \
+    }                                                                  \
+    template <typename T, typename U>                                  \
+    static inline bool operator _op_(const T* t, const sp<U>& u) {     \
+        return _sp_compare_<_compare_>(t, u.get());                    \
+    }                                                                  \
+    template <typename T, typename U>                                  \
+    static inline bool operator _op_(const sp<T>& t, const U* u) {     \
+        return _sp_compare_<_compare_>(t.get(), u);                    \
+    }                                                                  \
+    template <typename T>                                              \
+    static inline bool operator _op_(const sp<T>& t, std::nullptr_t) { \
+        return _sp_compare_<_compare_>(t.get(), nullptr);              \
+    }                                                                  \
+    template <typename T>                                              \
+    static inline bool operator _op_(std::nullptr_t, const sp<T>& t) { \
+        return _sp_compare_<_compare_>(nullptr, t.get());              \
+    }
+
+COMPARE_STRONG(==)
+COMPARE_STRONG(!=)
+COMPARE_STRONG_FUNCTIONAL(>, std::greater)
+COMPARE_STRONG_FUNCTIONAL(<, std::less)
+COMPARE_STRONG_FUNCTIONAL(<=, std::less_equal)
+COMPARE_STRONG_FUNCTIONAL(>=, std::greater_equal)
+
+#undef COMPARE_STRONG
+#undef COMPARE_STRONG_FUNCTIONAL
+
+// For code size reasons, we do not want these inlined or templated.
+void sp_report_race();
+
+// ---------------------------------------------------------------------------
+// No user serviceable parts below here.
+
+// TODO: Ideally we should find a way to increment the reference count before running the
+// constructor, so that generating an sp<> to this in the constructor is no longer dangerous.
+template <typename T>
+template <typename... Args>
+sp<T> sp<T>::make(Args&&... args) {
+    T* t = new T(std::forward<Args>(args)...);
+    sp<T> result;
+    result.m_ptr = t;
+    t->incStrong(t);
+    return result;
+}
+
+template <typename T>
+sp<T> sp<T>::fromExisting(T* other) {
+    if (other) {
+        other->incStrongRequireStrong(other);
+        sp<T> result;
+        result.m_ptr = other;
+        return result;
+    }
+    return nullptr;
+}
+
+#if !defined(ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION)
+template<typename T>
+sp<T>::sp(T* other)
+        : m_ptr(other) {
+    if (other) {
+        other->incStrong(this);
+    }
+}
+
+template <typename T>
+template <typename U>
+sp<T>::sp(U* other) : m_ptr(other) {
+    if (other) {
+        (static_cast<T*>(other))->incStrong(this);
+    }
+}
+
+template <typename T>
+sp<T>& sp<T>::operator=(T* other) {
+    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
+    if (other) {
+        other->incStrong(this);
+    }
+    if (oldPtr) oldPtr->decStrong(this);
+    if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
+    m_ptr = other;
+    return *this;
+}
+#endif
+
+template<typename T>
+sp<T>::sp(const sp<T>& other)
+        : m_ptr(other.m_ptr) {
+    if (m_ptr)
+        m_ptr->incStrong(this);
+}
+
+template <typename T>
+sp<T>::sp(sp<T>&& other) noexcept : m_ptr(other.m_ptr) {
+    other.m_ptr = nullptr;
+}
+
+template<typename T> template<typename U>
+sp<T>::sp(const sp<U>& other)
+        : m_ptr(other.m_ptr) {
+    if (m_ptr)
+        m_ptr->incStrong(this);
+}
+
+template<typename T> template<typename U>
+sp<T>::sp(sp<U>&& other)
+        : m_ptr(other.m_ptr) {
+    other.m_ptr = nullptr;
+}
+
+template <typename T>
+template <typename U>
+sp<T> sp<T>::cast(const sp<U>& other) {
+    return sp<T>::fromExisting(static_cast<T*>(other.get()));
+}
+
+template<typename T>
+sp<T>::~sp() {
+    if (m_ptr)
+        m_ptr->decStrong(this);
+}
+
+template<typename T>
+sp<T>& sp<T>::operator =(const sp<T>& other) {
+    // Force m_ptr to be read twice, to heuristically check for data races.
+    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
+    T* otherPtr(other.m_ptr);
+    if (otherPtr) otherPtr->incStrong(this);
+    if (oldPtr) oldPtr->decStrong(this);
+    if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
+    m_ptr = otherPtr;
+    return *this;
+}
+
+template <typename T>
+sp<T>& sp<T>::operator=(sp<T>&& other) noexcept {
+    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
+    if (oldPtr) oldPtr->decStrong(this);
+    if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
+    m_ptr = other.m_ptr;
+    other.m_ptr = nullptr;
+    return *this;
+}
+
+template<typename T> template<typename U>
+sp<T>& sp<T>::operator =(const sp<U>& other) {
+    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
+    T* otherPtr(other.m_ptr);
+    if (otherPtr) otherPtr->incStrong(this);
+    if (oldPtr) oldPtr->decStrong(this);
+    if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
+    m_ptr = otherPtr;
+    return *this;
+}
+
+template<typename T> template<typename U>
+sp<T>& sp<T>::operator =(sp<U>&& other) {
+    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
+    if (m_ptr) m_ptr->decStrong(this);
+    if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
+    m_ptr = other.m_ptr;
+    other.m_ptr = nullptr;
+    return *this;
+}
+
+#if !defined(ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION)
+template<typename T> template<typename U>
+sp<T>& sp<T>::operator =(U* other) {
+    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
+    if (other) (static_cast<T*>(other))->incStrong(this);
+    if (oldPtr) oldPtr->decStrong(this);
+    if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
+    m_ptr = other;
+    return *this;
+}
+#endif
+
+template<typename T>
+void sp<T>::force_set(T* other) {
+    other->forceIncStrong(this);
+    m_ptr = other;
+}
+
+template<typename T>
+void sp<T>::clear() {
+    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
+    if (oldPtr) {
+        oldPtr->decStrong(this);
+        if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
+        m_ptr = nullptr;
+    }
+}
+
+template<typename T>
+void sp<T>::set_pointer(T* ptr) {
+    m_ptr = ptr;
+}
+
+}  // namespace android
+
+// ---------------------------------------------------------------------------
+
+#endif // ANDROID_STRONG_POINTER_H
diff --git a/libutils/binder/include/utils/Unicode.h b/libutils/binder/include/utils/Unicode.h
new file mode 100644
index 000000000000..d60d5d6ba634
--- /dev/null
+++ b/libutils/binder/include/utils/Unicode.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2005 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.
+ */
+
+#ifndef ANDROID_UNICODE_H
+#define ANDROID_UNICODE_H
+
+#include <sys/types.h>
+#include <stdint.h>
+
+extern "C" {
+
+// Standard string functions on char16_t strings.
+int strcmp16(const char16_t *, const char16_t *);
+int strncmp16(const char16_t *s1, const char16_t *s2, size_t n);
+size_t strlen16(const char16_t *);
+size_t strnlen16(const char16_t *, size_t);
+char16_t *strstr16(const char16_t*, const char16_t*);
+
+// Version of comparison that supports embedded NULs.
+// This is different than strncmp() because we don't stop
+// at a nul character and consider the strings to be different
+// if the lengths are different (thus we need to supply the
+// lengths of both strings).  This can also be used when
+// your string is not nul-terminated as it will have the
+// equivalent result as strcmp16 (unlike strncmp16).
+int strzcmp16(const char16_t *s1, size_t n1, const char16_t *s2, size_t n2);
+
+/**
+ * Measure the length of a UTF-32 string in UTF-8. If the string is invalid
+ * such as containing a surrogate character, -1 will be returned.
+ */
+ssize_t utf32_to_utf8_length(const char32_t *src, size_t src_len);
+
+/**
+ * Stores a UTF-8 string converted from "src" in "dst", if "dst_length" is not
+ * large enough to store the string, the part of the "src" string is stored
+ * into "dst" as much as possible. See the examples for more detail.
+ * Returns the size actually used for storing the string.
+ * dst" is not nul-terminated when dst_len is fully used (like strncpy).
+ *
+ * \code
+ * Example 1
+ * "src" == \u3042\u3044 (\xE3\x81\x82\xE3\x81\x84)
+ * "src_len" == 2
+ * "dst_len" >= 7
+ * ->
+ * Returned value == 6
+ * "dst" becomes \xE3\x81\x82\xE3\x81\x84\0
+ * (note that "dst" is nul-terminated)
+ *
+ * Example 2
+ * "src" == \u3042\u3044 (\xE3\x81\x82\xE3\x81\x84)
+ * "src_len" == 2
+ * "dst_len" == 5
+ * ->
+ * Returned value == 3
+ * "dst" becomes \xE3\x81\x82\0
+ * (note that "dst" is nul-terminated, but \u3044 is not stored in "dst"
+ * since "dst" does not have enough size to store the character)
+ *
+ * Example 3
+ * "src" == \u3042\u3044 (\xE3\x81\x82\xE3\x81\x84)
+ * "src_len" == 2
+ * "dst_len" == 6
+ * ->
+ * Returned value == 6
+ * "dst" becomes \xE3\x81\x82\xE3\x81\x84
+ * (note that "dst" is NOT nul-terminated, like strncpy)
+ * \endcode
+ */
+void utf32_to_utf8(const char32_t* src, size_t src_len, char* dst, size_t dst_len);
+
+/**
+ * Returns the unicode value at "index".
+ * Returns -1 when the index is invalid (equals to or more than "src_len").
+ * If returned value is positive, it is able to be converted to char32_t, which
+ * is unsigned. Then, if "next_index" is not NULL, the next index to be used is
+ * stored in "next_index". "next_index" can be NULL.
+ */
+int32_t utf32_from_utf8_at(const char *src, size_t src_len, size_t index, size_t *next_index);
+
+
+/**
+ * Returns the UTF-8 length of UTF-16 string "src".
+ */
+ssize_t utf16_to_utf8_length(const char16_t *src, size_t src_len);
+
+/**
+ * Converts a UTF-16 string to UTF-8. The destination buffer must be large
+ * enough to fit the UTF-16 as measured by utf16_to_utf8_length with an added
+ * NUL terminator.
+ */
+void utf16_to_utf8(const char16_t* src, size_t src_len, char* dst, size_t dst_len);
+
+/**
+ * Returns the UTF-16 length of UTF-8 string "src". Returns -1 in case
+ * it's invalid utf8. No buffer over-read occurs because of bound checks. Using overreadIsFatal you
+ * can ask to log a message and fail in case the invalid utf8 could have caused an override if no
+ * bound checks were used (otherwise -1 is returned).
+ */
+ssize_t utf8_to_utf16_length(const uint8_t* src, size_t srcLen, bool overreadIsFatal = false);
+
+/**
+ * Convert UTF-8 to UTF-16 including surrogate pairs.
+ * Returns a pointer to the end of the string (where a NUL terminator might go
+ * if you wanted to add one). At most dstLen characters are written; it won't emit half a surrogate
+ * pair. If dstLen == 0 nothing is written and dst is returned. If dstLen > SSIZE_MAX it aborts
+ * (this being probably a negative number returned as an error and casted to unsigned).
+ */
+char16_t* utf8_to_utf16_no_null_terminator(
+        const uint8_t* src, size_t srcLen, char16_t* dst, size_t dstLen);
+
+/**
+ * Convert UTF-8 to UTF-16 including surrogate pairs. At most dstLen - 1
+ * characters are written; it won't emit half a surrogate pair; and a NUL terminator is appended
+ * after. dstLen - 1 can be measured beforehand using utf8_to_utf16_length. Aborts if dstLen == 0
+ * (at least one character is needed for the NUL terminator) or dstLen > SSIZE_MAX (the latter
+ * case being likely a negative number returned as an error and casted to unsigned) . Returns a
+ * pointer to the NUL terminator.
+ */
+char16_t *utf8_to_utf16(
+        const uint8_t* src, size_t srcLen, char16_t* dst, size_t dstLen);
+
+}
+
+#endif
diff --git a/libutils/binder/include/utils/Vector.h b/libutils/binder/include/utils/Vector.h
new file mode 100644
index 000000000000..d5db3cb482fe
--- /dev/null
+++ b/libutils/binder/include/utils/Vector.h
@@ -0,0 +1,418 @@
+/*
+ * Copyright (C) 2005 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.
+ */
+
+#ifndef ANDROID_VECTOR_H
+#define ANDROID_VECTOR_H
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include <log/log.h>
+#include <utils/TypeHelpers.h>
+#include <utils/VectorImpl.h>
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#endif
+
+/*
+ * Used to exclude some functions from CFI.
+ */
+#if __has_attribute(no_sanitize)
+#define UTILS_VECTOR_NO_CFI __attribute__((no_sanitize("cfi")))
+#else
+#define UTILS_VECTOR_NO_CFI
+#endif
+
+// ---------------------------------------------------------------------------
+
+namespace android {
+
+template <typename TYPE>
+class SortedVector;
+
+/*!
+ * The main templated vector class ensuring type safety
+ * while making use of VectorImpl.
+ * This is the class users want to use.
+ *
+ * DO NOT USE: please use std::vector
+ */
+
+template <class TYPE>
+class Vector : private VectorImpl
+{
+public:
+            typedef TYPE    value_type;
+
+    /*!
+     * Constructors and destructors
+     */
+
+                            Vector();
+                            Vector(const Vector<TYPE>& rhs);
+    explicit                Vector(const SortedVector<TYPE>& rhs);
+    virtual                 ~Vector();
+
+    /*! copy operator */
+    Vector<TYPE>& operator=(const Vector<TYPE>& rhs);        // NOLINT(cert-oop54-cpp)
+    Vector<TYPE>& operator=(const SortedVector<TYPE>& rhs);  // NOLINT(cert-oop54-cpp)
+
+    /*
+     * empty the vector
+     */
+
+    inline  void            clear()             { VectorImpl::clear(); }
+
+    /*!
+     * vector stats
+     */
+
+    //! returns number of items in the vector
+    inline  size_t          size() const                { return VectorImpl::size(); }
+    //! returns whether or not the vector is empty
+    inline  bool            isEmpty() const             { return VectorImpl::isEmpty(); }
+    //! returns how many items can be stored without reallocating the backing store
+    inline  size_t          capacity() const            { return VectorImpl::capacity(); }
+    //! sets the capacity. capacity can never be reduced less than size()
+    inline  ssize_t         setCapacity(size_t size)    { return VectorImpl::setCapacity(size); }
+
+    /*!
+     * set the size of the vector. items are appended with the default
+     * constructor, or removed from the end as needed.
+     */
+    inline  ssize_t         resize(size_t size)         { return VectorImpl::resize(size); }
+
+    /*!
+     * C-style array access
+     */
+
+    //! read-only C-style access
+    inline  const TYPE*     array() const;
+    //! read-write C-style access
+            TYPE*           editArray();
+
+    /*!
+     * accessors
+     */
+
+    //! read-only access to an item at a given index
+    inline  const TYPE&     operator [] (size_t index) const;
+    //! alternate name for operator []
+    inline  const TYPE&     itemAt(size_t index) const;
+    //! stack-usage of the vector. returns the top of the stack (last element)
+            const TYPE&     top() const;
+
+    /*!
+     * modifying the array
+     */
+
+    //! copy-on write support, grants write access to an item
+            TYPE&           editItemAt(size_t index);
+    //! grants right access to the top of the stack (last element)
+            TYPE&           editTop();
+
+            /*!
+             * append/insert another vector
+             */
+
+    //! insert another vector at a given index
+            ssize_t         insertVectorAt(const Vector<TYPE>& vector, size_t index);
+
+    //! append another vector at the end of this one
+            ssize_t         appendVector(const Vector<TYPE>& vector);
+
+
+    //! insert an array at a given index
+            ssize_t         insertArrayAt(const TYPE* array, size_t index, size_t length);
+
+    //! append an array at the end of this vector
+            ssize_t         appendArray(const TYPE* array, size_t length);
+
+            /*!
+             * add/insert/replace items
+             */
+
+    //! insert one or several items initialized with their default constructor
+    inline  ssize_t         insertAt(size_t index, size_t numItems = 1);
+    //! insert one or several items initialized from a prototype item
+            ssize_t         insertAt(const TYPE& prototype_item, size_t index, size_t numItems = 1);
+    //! pop the top of the stack (removes the last element). No-op if the stack's empty
+    inline  void            pop();
+    //! pushes an item initialized with its default constructor
+    inline  void            push();
+    //! pushes an item on the top of the stack
+            void            push(const TYPE& item);
+    //! same as push() but returns the index the item was added at (or an error)
+    inline  ssize_t         add();
+    //! same as push() but returns the index the item was added at (or an error)
+            ssize_t         add(const TYPE& item);
+    //! replace an item with a new one initialized with its default constructor
+    inline  ssize_t         replaceAt(size_t index);
+    //! replace an item with a new one
+            ssize_t         replaceAt(const TYPE& item, size_t index);
+
+    /*!
+     * remove items
+     */
+
+    //! remove several items
+    inline  ssize_t         removeItemsAt(size_t index, size_t count = 1);
+    //! remove one item
+    inline  ssize_t         removeAt(size_t index)  { return removeItemsAt(index); }
+
+    /*!
+     * sort (stable) the array
+     */
+
+     typedef int (*compar_t)(const TYPE* lhs, const TYPE* rhs);
+     typedef int (*compar_r_t)(const TYPE* lhs, const TYPE* rhs, void* state);
+
+     inline status_t        sort(compar_t cmp);
+     inline status_t        sort(compar_r_t cmp, void* state);
+
+     // for debugging only
+     inline size_t getItemSize() const { return itemSize(); }
+
+
+     /*
+      * these inlines add some level of compatibility with STL. eventually
+      * we should probably turn things around.
+      */
+     typedef TYPE* iterator;
+     typedef TYPE const* const_iterator;
+
+     inline iterator begin() { return editArray(); }
+     inline iterator end()   { return editArray() + size(); }
+     inline const_iterator begin() const { return array(); }
+     inline const_iterator end() const   { return array() + size(); }
+     inline void reserve(size_t n) { setCapacity(n); }
+     inline bool empty() const{ return isEmpty(); }
+     inline void push_back(const TYPE& item)  { insertAt(item, size(), 1); }
+     inline void push_front(const TYPE& item) { insertAt(item, 0, 1); }
+     inline iterator erase(iterator pos) {
+         ssize_t index = removeItemsAt(static_cast<size_t>(pos-array()));
+         return begin() + index;
+     }
+
+protected:
+    virtual void    do_construct(void* storage, size_t num) const;
+    virtual void    do_destroy(void* storage, size_t num) const;
+    virtual void    do_copy(void* dest, const void* from, size_t num) const;
+    virtual void    do_splat(void* dest, const void* item, size_t num) const;
+    virtual void    do_move_forward(void* dest, const void* from, size_t num) const;
+    virtual void    do_move_backward(void* dest, const void* from, size_t num) const;
+};
+
+// ---------------------------------------------------------------------------
+// No user serviceable parts from here...
+// ---------------------------------------------------------------------------
+
+template<class TYPE> inline
+Vector<TYPE>::Vector()
+    : VectorImpl(sizeof(TYPE),
+                ((traits<TYPE>::has_trivial_ctor   ? HAS_TRIVIAL_CTOR   : 0)
+                |(traits<TYPE>::has_trivial_dtor   ? HAS_TRIVIAL_DTOR   : 0)
+                |(traits<TYPE>::has_trivial_copy   ? HAS_TRIVIAL_COPY   : 0))
+                )
+{
+}
+
+template<class TYPE> inline
+Vector<TYPE>::Vector(const Vector<TYPE>& rhs)
+    : VectorImpl(rhs) {
+}
+
+template<class TYPE> inline
+Vector<TYPE>::Vector(const SortedVector<TYPE>& rhs)
+    : VectorImpl(static_cast<const VectorImpl&>(rhs)) {
+}
+
+template<class TYPE> inline
+Vector<TYPE>::~Vector() {
+    finish_vector();
+}
+
+template <class TYPE>
+inline Vector<TYPE>& Vector<TYPE>::operator=(const Vector<TYPE>& rhs)  // NOLINT(cert-oop54-cpp)
+{
+    VectorImpl::operator=(rhs);
+    return *this;
+}
+
+template <class TYPE>
+inline Vector<TYPE>& Vector<TYPE>::operator=(
+        const SortedVector<TYPE>& rhs)  // NOLINT(cert-oop54-cpp)
+{
+    VectorImpl::operator=(static_cast<const VectorImpl&>(rhs));
+    return *this;
+}
+
+template<class TYPE> inline
+const TYPE* Vector<TYPE>::array() const {
+    return static_cast<const TYPE *>(arrayImpl());
+}
+
+template<class TYPE> inline
+TYPE* Vector<TYPE>::editArray() {
+    return static_cast<TYPE *>(editArrayImpl());
+}
+
+
+template<class TYPE> inline
+const TYPE& Vector<TYPE>::operator[](size_t index) const {
+    LOG_FATAL_IF(index>=size(),
+            "%s: index=%u out of range (%u)", __PRETTY_FUNCTION__,
+            int(index), int(size()));
+    return *(array() + index);
+}
+
+template<class TYPE> inline
+const TYPE& Vector<TYPE>::itemAt(size_t index) const {
+    return operator[](index);
+}
+
+template<class TYPE> inline
+const TYPE& Vector<TYPE>::top() const {
+    return *(array() + size() - 1);
+}
+
+template<class TYPE> inline
+TYPE& Vector<TYPE>::editItemAt(size_t index) {
+    return *( static_cast<TYPE *>(editItemLocation(index)) );
+}
+
+template<class TYPE> inline
+TYPE& Vector<TYPE>::editTop() {
+    return *( static_cast<TYPE *>(editItemLocation(size()-1)) );
+}
+
+template<class TYPE> inline
+ssize_t Vector<TYPE>::insertVectorAt(const Vector<TYPE>& vector, size_t index) {
+    return VectorImpl::insertVectorAt(reinterpret_cast<const VectorImpl&>(vector), index);
+}
+
+template<class TYPE> inline
+ssize_t Vector<TYPE>::appendVector(const Vector<TYPE>& vector) {
+    return VectorImpl::appendVector(reinterpret_cast<const VectorImpl&>(vector));
+}
+
+template<class TYPE> inline
+ssize_t Vector<TYPE>::insertArrayAt(const TYPE* array, size_t index, size_t length) {
+    return VectorImpl::insertArrayAt(array, index, length);
+}
+
+template<class TYPE> inline
+ssize_t Vector<TYPE>::appendArray(const TYPE* array, size_t length) {
+    return VectorImpl::appendArray(array, length);
+}
+
+template<class TYPE> inline
+ssize_t Vector<TYPE>::insertAt(const TYPE& item, size_t index, size_t numItems) {
+    return VectorImpl::insertAt(&item, index, numItems);
+}
+
+template<class TYPE> inline
+void Vector<TYPE>::push(const TYPE& item) {
+    return VectorImpl::push(&item);
+}
+
+template<class TYPE> inline
+ssize_t Vector<TYPE>::add(const TYPE& item) {
+    return VectorImpl::add(&item);
+}
+
+template<class TYPE> inline
+ssize_t Vector<TYPE>::replaceAt(const TYPE& item, size_t index) {
+    return VectorImpl::replaceAt(&item, index);
+}
+
+template<class TYPE> inline
+ssize_t Vector<TYPE>::insertAt(size_t index, size_t numItems) {
+    return VectorImpl::insertAt(index, numItems);
+}
+
+template<class TYPE> inline
+void Vector<TYPE>::pop() {
+    VectorImpl::pop();
+}
+
+template<class TYPE> inline
+void Vector<TYPE>::push() {
+    VectorImpl::push();
+}
+
+template<class TYPE> inline
+ssize_t Vector<TYPE>::add() {
+    return VectorImpl::add();
+}
+
+template<class TYPE> inline
+ssize_t Vector<TYPE>::replaceAt(size_t index) {
+    return VectorImpl::replaceAt(index);
+}
+
+template<class TYPE> inline
+ssize_t Vector<TYPE>::removeItemsAt(size_t index, size_t count) {
+    return VectorImpl::removeItemsAt(index, count);
+}
+
+template<class TYPE> inline
+status_t Vector<TYPE>::sort(Vector<TYPE>::compar_t cmp) {
+    return VectorImpl::sort(reinterpret_cast<VectorImpl::compar_t>(cmp));
+}
+
+template<class TYPE> inline
+status_t Vector<TYPE>::sort(Vector<TYPE>::compar_r_t cmp, void* state) {
+    return VectorImpl::sort(reinterpret_cast<VectorImpl::compar_r_t>(cmp), state);
+}
+
+// ---------------------------------------------------------------------------
+
+template<class TYPE>
+UTILS_VECTOR_NO_CFI void Vector<TYPE>::do_construct(void* storage, size_t num) const {
+    construct_type( reinterpret_cast<TYPE*>(storage), num );
+}
+
+template<class TYPE>
+void Vector<TYPE>::do_destroy(void* storage, size_t num) const {
+    destroy_type( reinterpret_cast<TYPE*>(storage), num );
+}
+
+template<class TYPE>
+UTILS_VECTOR_NO_CFI void Vector<TYPE>::do_copy(void* dest, const void* from, size_t num) const {
+    copy_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
+}
+
+template<class TYPE>
+UTILS_VECTOR_NO_CFI void Vector<TYPE>::do_splat(void* dest, const void* item, size_t num) const {
+    splat_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(item), num );
+}
+
+template<class TYPE>
+UTILS_VECTOR_NO_CFI void Vector<TYPE>::do_move_forward(void* dest, const void* from, size_t num) const {
+    move_forward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
+}
+
+template<class TYPE>
+UTILS_VECTOR_NO_CFI void Vector<TYPE>::do_move_backward(void* dest, const void* from, size_t num) const {
+    move_backward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
+}
+
+}  // namespace android
+
+// ---------------------------------------------------------------------------
+
+#endif // ANDROID_VECTOR_H
diff --git a/libutils/binder/include/utils/VectorImpl.h b/libutils/binder/include/utils/VectorImpl.h
new file mode 100644
index 000000000000..41b9f331060d
--- /dev/null
+++ b/libutils/binder/include/utils/VectorImpl.h
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2005 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.
+ */
+
+#ifndef ANDROID_VECTOR_IMPL_H
+#define ANDROID_VECTOR_IMPL_H
+
+#include <assert.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <utils/Errors.h>
+
+// ---------------------------------------------------------------------------
+// No user serviceable parts in here...
+// ---------------------------------------------------------------------------
+
+namespace android {
+
+/*!
+ * Implementation of the guts of the vector<> class
+ * this ensures backward binary compatibility and
+ * reduces code size.
+ * For performance reasons, we expose mStorage and mCount
+ * so these fields are set in stone.
+ *
+ */
+
+class VectorImpl
+{
+public:
+    enum { // flags passed to the ctor
+        HAS_TRIVIAL_CTOR    = 0x00000001,
+        HAS_TRIVIAL_DTOR    = 0x00000002,
+        HAS_TRIVIAL_COPY    = 0x00000004,
+    };
+
+                            VectorImpl(size_t itemSize, uint32_t flags);
+                            VectorImpl(const VectorImpl& rhs);
+    virtual                 ~VectorImpl();
+
+    /*! must be called from subclasses destructor */
+            void            finish_vector();
+
+            VectorImpl&     operator = (const VectorImpl& rhs);    
+            
+    /*! C-style array access */
+    inline  const void*     arrayImpl() const       { return mStorage; }
+            void*           editArrayImpl();
+            
+    /*! vector stats */
+    inline  size_t          size() const        { return mCount; }
+    inline  bool            isEmpty() const     { return mCount == 0; }
+            size_t          capacity() const;
+            ssize_t         setCapacity(size_t size);
+            ssize_t         resize(size_t size);
+
+            /*! append/insert another vector or array */
+            ssize_t         insertVectorAt(const VectorImpl& vector, size_t index);
+            ssize_t         appendVector(const VectorImpl& vector);
+            ssize_t         insertArrayAt(const void* array, size_t index, size_t length);
+            ssize_t         appendArray(const void* array, size_t length);
+            
+            /*! add/insert/replace items */
+            ssize_t         insertAt(size_t where, size_t numItems = 1);
+            ssize_t         insertAt(const void* item, size_t where, size_t numItems = 1);
+            void            pop();
+            void            push();
+            void            push(const void* item);
+            ssize_t         add();
+            ssize_t         add(const void* item);
+            ssize_t         replaceAt(size_t index);
+            ssize_t         replaceAt(const void* item, size_t index);
+
+            /*! remove items */
+            ssize_t         removeItemsAt(size_t index, size_t count = 1);
+            void            clear();
+
+            const void*     itemLocation(size_t index) const;
+            void*           editItemLocation(size_t index);
+
+            typedef int (*compar_t)(const void* lhs, const void* rhs);
+            typedef int (*compar_r_t)(const void* lhs, const void* rhs, void* state);
+            status_t        sort(compar_t cmp);
+            status_t        sort(compar_r_t cmp, void* state);
+
+protected:
+            size_t          itemSize() const;
+            void            release_storage();
+
+    virtual void            do_construct(void* storage, size_t num) const = 0;
+    virtual void            do_destroy(void* storage, size_t num) const = 0;
+    virtual void            do_copy(void* dest, const void* from, size_t num) const = 0;
+    virtual void            do_splat(void* dest, const void* item, size_t num) const = 0;
+    virtual void            do_move_forward(void* dest, const void* from, size_t num) const = 0;
+    virtual void            do_move_backward(void* dest, const void* from, size_t num) const = 0;
+    
+private:
+        void* _grow(size_t where, size_t amount);
+        void  _shrink(size_t where, size_t amount);
+
+        inline void _do_construct(void* storage, size_t num) const;
+        inline void _do_destroy(void* storage, size_t num) const;
+        inline void _do_copy(void* dest, const void* from, size_t num) const;
+        inline void _do_splat(void* dest, const void* item, size_t num) const;
+        inline void _do_move_forward(void* dest, const void* from, size_t num) const;
+        inline void _do_move_backward(void* dest, const void* from, size_t num) const;
+
+            // These 2 fields are exposed in the inlines below,
+            // so they're set in stone.
+            void *      mStorage;   // base address of the vector
+            size_t      mCount;     // number of items
+
+    const   uint32_t    mFlags;
+    const   size_t      mItemSize;
+};
+
+
+
+class SortedVectorImpl : public VectorImpl
+{
+public:
+                            SortedVectorImpl(size_t itemSize, uint32_t flags);
+    explicit                SortedVectorImpl(const VectorImpl& rhs);
+    virtual                 ~SortedVectorImpl();
+    
+    SortedVectorImpl&     operator = (const SortedVectorImpl& rhs);    
+
+    //! finds the index of an item
+            ssize_t         indexOf(const void* item) const;
+
+    //! finds where this item should be inserted
+            size_t          orderOf(const void* item) const;
+
+    //! add an item in the right place (or replaces it if there is one)
+            ssize_t         add(const void* item);
+
+    //! merges a vector into this one
+            ssize_t         merge(const VectorImpl& vector);
+            ssize_t         merge(const SortedVectorImpl& vector);
+             
+    //! removes an item
+            ssize_t         remove(const void* item);
+        
+protected:
+    virtual int             do_compare(const void* lhs, const void* rhs) const = 0;
+
+private:
+            ssize_t         _indexOrderOf(const void* item, size_t* order = nullptr) const;
+
+            // these are made private, because they can't be used on a SortedVector
+            // (they don't have an implementation either)
+            ssize_t         add();
+            void            pop();
+            void            push();
+            void            push(const void* item);
+            ssize_t         insertVectorAt(const VectorImpl& vector, size_t index);
+            ssize_t         appendVector(const VectorImpl& vector);
+            ssize_t         insertArrayAt(const void* array, size_t index, size_t length);
+            ssize_t         appendArray(const void* array, size_t length);
+            ssize_t         insertAt(size_t where, size_t numItems = 1);
+            ssize_t         insertAt(const void* item, size_t where, size_t numItems = 1);
+            ssize_t         replaceAt(size_t index);
+            ssize_t         replaceAt(const void* item, size_t index);
+};
+
+}  // namespace android
+
+// ---------------------------------------------------------------------------
+
+#endif // ANDROID_VECTOR_IMPL_H
diff --git a/libutils/include/utils/Errors.h b/libutils/include/utils/Errors.h
deleted file mode 100644
index 22fb36d2500e..000000000000
--- a/libutils/include/utils/Errors.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (C) 2007 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <errno.h>
-#include <stdint.h>
-#include <sys/types.h>
-#include <string>
-
-namespace android {
-
-/**
- * The type used to return success/failure from frameworks APIs.
- * See the anonymous enum below for valid values.
- */
-typedef int32_t status_t;
-
-/*
- * Error codes. 
- * All error codes are negative values.
- */
-
-enum {
-    OK                = 0,    // Preferred constant for checking success.
-#ifndef NO_ERROR
-    // Win32 #defines NO_ERROR as well.  It has the same value, so there's no
-    // real conflict, though it's a bit awkward.
-    NO_ERROR          = OK,   // Deprecated synonym for `OK`. Prefer `OK` because it doesn't conflict with Windows.
-#endif
-
-    UNKNOWN_ERROR       = (-2147483647-1), // INT32_MIN value
-
-    NO_MEMORY           = -ENOMEM,
-    INVALID_OPERATION   = -ENOSYS,
-    BAD_VALUE           = -EINVAL,
-    BAD_TYPE            = (UNKNOWN_ERROR + 1),
-    NAME_NOT_FOUND      = -ENOENT,
-    PERMISSION_DENIED   = -EPERM,
-    NO_INIT             = -ENODEV,
-    ALREADY_EXISTS      = -EEXIST,
-    DEAD_OBJECT         = -EPIPE,
-    FAILED_TRANSACTION  = (UNKNOWN_ERROR + 2),
-#if !defined(_WIN32)
-    BAD_INDEX           = -EOVERFLOW,
-    NOT_ENOUGH_DATA     = -ENODATA,
-    WOULD_BLOCK         = -EWOULDBLOCK, 
-    TIMED_OUT           = -ETIMEDOUT,
-    UNKNOWN_TRANSACTION = -EBADMSG,
-#else    
-    BAD_INDEX           = -E2BIG,
-    NOT_ENOUGH_DATA     = (UNKNOWN_ERROR + 3),
-    WOULD_BLOCK         = (UNKNOWN_ERROR + 4),
-    TIMED_OUT           = (UNKNOWN_ERROR + 5),
-    UNKNOWN_TRANSACTION = (UNKNOWN_ERROR + 6),
-#endif    
-    FDS_NOT_ALLOWED     = (UNKNOWN_ERROR + 7),
-    UNEXPECTED_NULL     = (UNKNOWN_ERROR + 8),
-};
-
-// Human readable name of error
-std::string statusToString(status_t status);
-
-}  // namespace android
diff --git a/libutils/include/utils/Errors.h b/libutils/include/utils/Errors.h
new file mode 120000
index 000000000000..2eba10bf815b
--- /dev/null
+++ b/libutils/include/utils/Errors.h
@@ -0,0 +1 @@
+../../binder/include/utils/Errors.h
\ No newline at end of file
diff --git a/libutils/include/utils/RefBase.h b/libutils/include/utils/RefBase.h
deleted file mode 100644
index 5e3fa7d13c8a..000000000000
--- a/libutils/include/utils/RefBase.h
+++ /dev/null
@@ -1,819 +0,0 @@
-/*
- * Copyright (C) 2016 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.
- */
-
-
-// SOME COMMENTS ABOUT USAGE:
-
-// This provides primarily wp<> weak pointer types and RefBase, which work
-// together with sp<> from <StrongPointer.h>.
-
-// sp<> (and wp<>) are a type of smart pointer that use a well defined protocol
-// to operate. As long as the object they are templated with implements that
-// protocol, these smart pointers work. In several places the platform
-// instantiates sp<> with non-RefBase objects; the two are not tied to each
-// other.
-
-// RefBase is such an implementation and it supports strong pointers, weak
-// pointers and some magic features for the binder.
-
-// So, when using RefBase objects, you have the ability to use strong and weak
-// pointers through sp<> and wp<>.
-
-// Normally, when the last strong pointer goes away, the object is destroyed,
-// i.e. it's destructor is called. HOWEVER, parts of its associated memory is not
-// freed until the last weak pointer is released.
-
-// Weak pointers are essentially "safe" pointers. They are always safe to
-// access through promote(). They may return nullptr if the object was
-// destroyed because it ran out of strong pointers. This makes them good candidates
-// for keys in a cache for instance.
-
-// Weak pointers remain valid for comparison purposes even after the underlying
-// object has been destroyed. Even if object A is destroyed and its memory reused
-// for B, A remaining weak pointer to A will not compare equal to one to B.
-// This again makes them attractive for use as keys.
-
-// How is this supposed / intended to be used?
-
-// Our recommendation is to use strong references (sp<>) when there is an
-// ownership relation. e.g. when an object "owns" another one, use a strong
-// ref. And of course use strong refs as arguments of functions (it's extremely
-// rare that a function will take a wp<>).
-
-// Typically a newly allocated object will immediately be used to initialize
-// a strong pointer, which may then be used to construct or assign to other
-// strong and weak pointers.
-
-// Use weak references when there are no ownership relation. e.g. the keys in a
-// cache (you cannot use plain pointers because there is no safe way to acquire
-// a strong reference from a vanilla pointer).
-
-// This implies that two objects should never (or very rarely) have sp<> on
-// each other, because they can't both own each other.
-
-
-// Caveats with reference counting
-
-// Obviously, circular strong references are a big problem; this creates leaks
-// and it's hard to debug -- except it's in fact really easy because RefBase has
-// tons of debugging code for that. It can basically tell you exactly where the
-// leak is.
-
-// Another problem has to do with destructors with side effects. You must
-// assume that the destructor of reference counted objects can be called AT ANY
-// TIME. For instance code as simple as this:
-
-// void setStuff(const sp<Stuff>& stuff) {
-//   std::lock_guard<std::mutex> lock(mMutex);
-//   mStuff = stuff;
-// }
-
-// is very dangerous. This code WILL deadlock one day or another.
-
-// What isn't obvious is that ~Stuff() can be called as a result of the
-// assignment. And it gets called with the lock held. First of all, the lock is
-// protecting mStuff, not ~Stuff(). Secondly, if ~Stuff() uses its own internal
-// mutex, now you have mutex ordering issues.  Even worse, if ~Stuff() is
-// virtual, now you're calling into "user" code (potentially), by that, I mean,
-// code you didn't even write.
-
-// A correct way to write this code is something like:
-
-// void setStuff(const sp<Stuff>& stuff) {
-//   std::unique_lock<std::mutex> lock(mMutex);
-//   sp<Stuff> hold = mStuff;
-//   mStuff = stuff;
-//   lock.unlock();
-// }
-
-// More importantly, reference counted objects should do as little work as
-// possible in their destructor, or at least be mindful that their destructor
-// could be called from very weird and unintended places.
-
-// Other more specific restrictions for wp<> and sp<>:
-
-// Do not construct a strong pointer to "this" in an object's constructor.
-// The onFirstRef() callback would be made on an incompletely constructed
-// object.
-// Construction of a weak pointer to "this" in an object's constructor is also
-// discouraged. But the implementation was recently changed so that, in the
-// absence of extendObjectLifetime() calls, weak pointers no longer impact
-// object lifetime, and hence this no longer risks premature deallocation,
-// and hence usually works correctly.
-
-// Such strong or weak pointers can be safely created in the RefBase onFirstRef()
-// callback.
-
-// Use of wp::unsafe_get() for any purpose other than debugging is almost
-// always wrong.  Unless you somehow know that there is a longer-lived sp<> to
-// the same object, it may well return a pointer to a deallocated object that
-// has since been reallocated for a different purpose. (And if you know there
-// is a longer-lived sp<>, why not use an sp<> directly?) A wp<> should only be
-// dereferenced by using promote().
-
-// Any object inheriting from RefBase should always be destroyed as the result
-// of a reference count decrement, not via any other means.  Such objects
-// should never be stack allocated, or appear directly as data members in other
-// objects. Objects inheriting from RefBase should have their strong reference
-// count incremented as soon as possible after construction. Usually this
-// will be done via construction of an sp<> to the object, but may instead
-// involve other means of calling RefBase::incStrong().
-// Explicitly deleting or otherwise destroying a RefBase object with outstanding
-// wp<> or sp<> pointers to it will result in an abort or heap corruption.
-
-// It is particularly important not to mix sp<> and direct storage management
-// since the sp from raw pointer constructor is implicit. Thus if a RefBase-
-// -derived object of type T is managed without ever incrementing its strong
-// count, and accidentally passed to f(sp<T>), a strong pointer to the object
-// will be temporarily constructed and destroyed, prematurely deallocating the
-// object, and resulting in heap corruption. None of this would be easily
-// visible in the source. See below on
-// ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION for a compile time
-// option which helps avoid this case.
-
-// Extra Features:
-
-// RefBase::extendObjectLifetime() can be used to prevent destruction of the
-// object while there are still weak references. This is really special purpose
-// functionality to support Binder.
-
-// Wp::promote(), implemented via the attemptIncStrong() member function, is
-// used to try to convert a weak pointer back to a strong pointer.  It's the
-// normal way to try to access the fields of an object referenced only through
-// a wp<>.  Binder code also sometimes uses attemptIncStrong() directly.
-
-// RefBase provides a number of additional callbacks for certain reference count
-// events, as well as some debugging facilities.
-
-// Debugging support can be enabled by turning on DEBUG_REFS in RefBase.cpp.
-// Otherwise little checking is provided.
-
-// Thread safety:
-
-// Like std::shared_ptr, sp<> and wp<> allow concurrent accesses to DIFFERENT
-// sp<> and wp<> instances that happen to refer to the same underlying object.
-// They do NOT support concurrent access (where at least one access is a write)
-// to THE SAME sp<> or wp<>.  In effect, their thread-safety properties are
-// exactly like those of T*, NOT atomic<T*>.
-
-// Safety option: ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION
-//
-// This flag makes the semantics for using a RefBase object with wp<> and sp<>
-// much stricter by disabling implicit conversion from raw pointers to these
-// objects. In order to use this, apply this flag in Android.bp like so:
-//
-//    cflags: [
-//        "-DANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION",
-//    ],
-//
-// REGARDLESS of whether this flag is on, best usage of sp<> is shown below. If
-// this flag is on, no other usage is possible (directly calling RefBase methods
-// is possible, but seeing code using 'incStrong' instead of 'sp<>', for
-// instance, should already set off big alarm bells. With carefully constructed
-// data structures, it should NEVER be necessary to directly use RefBase
-// methods). Proper RefBase usage:
-//
-//    class Foo : virtual public RefBase { ... };
-//
-//    // always construct an sp object with sp::make
-//    sp<Foo> myFoo = sp<Foo>::make(/*args*/);
-//
-//    // if you need a weak pointer, it must be constructed from a strong
-//    // pointer
-//    wp<Foo> weakFoo = myFoo; // NOT myFoo.get()
-//
-//    // If you are inside of a method of Foo and need access to a strong
-//    // explicitly call this function. This documents your intention to code
-//    // readers, and it will give a runtime error for what otherwise would
-//    // be potential double ownership
-//    .... Foo::someMethod(...) {
-//        // asserts if there is a memory issue
-//        sp<Foo> thiz = sp<Foo>::fromExisting(this);
-//    }
-//
-
-#ifndef ANDROID_REF_BASE_H
-#define ANDROID_REF_BASE_H
-
-#include <atomic>
-#include <functional>
-#include <memory>
-#include <type_traits>  // for common_type.
-
-#include <stdint.h>
-#include <sys/types.h>
-#include <stdlib.h>
-#include <string.h>
-
-// LightRefBase used to be declared in this header, so we have to include it
-#include <utils/LightRefBase.h>
-
-#include <utils/StrongPointer.h>
-#include <utils/TypeHelpers.h>
-
-// ---------------------------------------------------------------------------
-namespace android {
-
-// ---------------------------------------------------------------------------
-
-#define COMPARE_WEAK(_op_)                                      \
-template<typename U>                                            \
-inline bool operator _op_ (const U* o) const {                  \
-    return m_ptr _op_ o;                                        \
-}                                                               \
-/* Needed to handle type inference for nullptr: */              \
-inline bool operator _op_ (const T* o) const {                  \
-    return m_ptr _op_ o;                                        \
-}
-
-template<template<typename C> class comparator, typename T, typename U>
-static inline bool _wp_compare_(T* a, U* b) {
-    return comparator<typename std::common_type<T*, U*>::type>()(a, b);
-}
-
-// Use std::less and friends to avoid undefined behavior when ordering pointers
-// to different objects.
-#define COMPARE_WEAK_FUNCTIONAL(_op_, _compare_)                 \
-template<typename U>                                             \
-inline bool operator _op_ (const U* o) const {                   \
-    return _wp_compare_<_compare_>(m_ptr, o);                    \
-}
-
-// ---------------------------------------------------------------------------
-
-// RefererenceRenamer is pure abstract, there is no virtual method
-// implementation to put in a translation unit in order to silence the
-// weak vtables warning.
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
-
-class ReferenceRenamer {
-protected:
-    // destructor is purposely not virtual so we avoid code overhead from
-    // subclasses; we have to make it protected to guarantee that it
-    // cannot be called from this base class (and to make strict compilers
-    // happy).
-    ~ReferenceRenamer() { }
-public:
-    virtual void operator()(size_t i) const = 0;
-};
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-// ---------------------------------------------------------------------------
-
-class RefBase
-{
-public:
-            void            incStrong(const void* id) const;
-            void            incStrongRequireStrong(const void* id) const;
-            void            decStrong(const void* id) const;
-    
-            void            forceIncStrong(const void* id) const;
-
-            //! DEBUGGING ONLY: Get current strong ref count.
-            int32_t         getStrongCount() const;
-
-    class weakref_type
-    {
-    public:
-        RefBase*            refBase() const;
-
-        void                incWeak(const void* id);
-        void                incWeakRequireWeak(const void* id);
-        void                decWeak(const void* id);
-
-        // acquires a strong reference if there is already one.
-        bool                attemptIncStrong(const void* id);
-
-        // acquires a weak reference if there is already one.
-        // This is not always safe. see ProcessState.cpp and BpBinder.cpp
-        // for proper use.
-        bool                attemptIncWeak(const void* id);
-
-        //! DEBUGGING ONLY: Get current weak ref count.
-        int32_t             getWeakCount() const;
-
-        //! DEBUGGING ONLY: Print references held on object.
-        void                printRefs() const;
-
-        //! DEBUGGING ONLY: Enable tracking for this object.
-        // enable -- enable/disable tracking
-        // retain -- when tracking is enable, if true, then we save a stack trace
-        //           for each reference and dereference; when retain == false, we
-        //           match up references and dereferences and keep only the
-        //           outstanding ones.
-
-        void                trackMe(bool enable, bool retain);
-    };
-
-            weakref_type*   createWeak(const void* id) const;
-            
-            weakref_type*   getWeakRefs() const;
-
-            //! DEBUGGING ONLY: Print references held on object.
-    inline  void            printRefs() const { getWeakRefs()->printRefs(); }
-
-            //! DEBUGGING ONLY: Enable tracking of object.
-    inline  void            trackMe(bool enable, bool retain)
-    { 
-        getWeakRefs()->trackMe(enable, retain); 
-    }
-
-protected:
-    // When constructing these objects, prefer using sp::make<>. Using a RefBase
-    // object on the stack or with other refcount mechanisms (e.g.
-    // std::shared_ptr) is inherently wrong. RefBase types have an implicit
-    // ownership model and cannot be safely used with other ownership models.
-
-                            RefBase();
-    virtual                 ~RefBase();
-    
-    //! Flags for extendObjectLifetime()
-    enum {
-        OBJECT_LIFETIME_STRONG  = 0x0000,
-        OBJECT_LIFETIME_WEAK    = 0x0001,
-        OBJECT_LIFETIME_MASK    = 0x0001
-    };
-    
-            void            extendObjectLifetime(int32_t mode);
-            
-    //! Flags for onIncStrongAttempted()
-    enum {
-        FIRST_INC_STRONG = 0x0001
-    };
-    
-    // Invoked after creation of initial strong pointer/reference.
-    virtual void            onFirstRef();
-    // Invoked when either the last strong reference goes away, or we need to undo
-    // the effect of an unnecessary onIncStrongAttempted.
-    virtual void            onLastStrongRef(const void* id);
-    // Only called in OBJECT_LIFETIME_WEAK case.  Returns true if OK to promote to
-    // strong reference. May have side effects if it returns true.
-    // The first flags argument is always FIRST_INC_STRONG.
-    // TODO: Remove initial flag argument.
-    virtual bool            onIncStrongAttempted(uint32_t flags, const void* id);
-    // Invoked in the OBJECT_LIFETIME_WEAK case when the last reference of either
-    // kind goes away.  Unused.
-    // TODO: Remove.
-    virtual void            onLastWeakRef(const void* id);
-
-private:
-    friend class weakref_type;
-    class weakref_impl;
-    
-                            RefBase(const RefBase& o);
-            RefBase&        operator=(const RefBase& o);
-
-private:
-    friend class ReferenceMover;
-
-    static void renameRefs(size_t n, const ReferenceRenamer& renamer);
-
-    static void renameRefId(weakref_type* ref,
-            const void* old_id, const void* new_id);
-
-    static void renameRefId(RefBase* ref,
-            const void* old_id, const void* new_id);
-
-        weakref_impl* const mRefs;
-};
-
-// ---------------------------------------------------------------------------
-
-template <typename T>
-class wp
-{
-public:
-    typedef typename RefBase::weakref_type weakref_type;
-
-    inline wp() : m_ptr(nullptr), m_refs(nullptr) { }
-
-    // if nullptr, returns nullptr
-    //
-    // if a weak pointer is already available, this will retrieve it,
-    // otherwise, this will abort
-    static inline wp<T> fromExisting(T* other);
-
-    // for more information about this flag, see above
-#if defined(ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION)
-    wp(std::nullptr_t) : wp() {}
-#else
-    wp(T* other);  // NOLINT(implicit)
-    template <typename U>
-    wp(U* other);  // NOLINT(implicit)
-    wp& operator=(T* other);
-    template <typename U>
-    wp& operator=(U* other);
-#endif
-
-    wp(const wp<T>& other);
-    explicit wp(const sp<T>& other);
-
-    template<typename U> wp(const sp<U>& other);  // NOLINT(implicit)
-    template<typename U> wp(const wp<U>& other);  // NOLINT(implicit)
-
-    ~wp();
-
-    // Assignment
-
-    wp& operator = (const wp<T>& other);
-    wp& operator = (const sp<T>& other);
-
-    template<typename U> wp& operator = (const wp<U>& other);
-    template<typename U> wp& operator = (const sp<U>& other);
-
-    void set_object_and_refs(T* other, weakref_type* refs);
-
-    // promotion to sp
-
-    sp<T> promote() const;
-
-    // Reset
-
-    void clear();
-
-    // Accessors
-
-    inline  weakref_type* get_refs() const { return m_refs; }
-
-    inline  T* unsafe_get() const { return m_ptr; }
-
-    // Operators
-
-    COMPARE_WEAK(==)
-    COMPARE_WEAK(!=)
-    COMPARE_WEAK_FUNCTIONAL(>, std::greater)
-    COMPARE_WEAK_FUNCTIONAL(<, std::less)
-    COMPARE_WEAK_FUNCTIONAL(<=, std::less_equal)
-    COMPARE_WEAK_FUNCTIONAL(>=, std::greater_equal)
-
-    template<typename U>
-    inline bool operator == (const wp<U>& o) const {
-        return m_refs == o.m_refs;  // Implies m_ptr == o.mptr; see invariants below.
-    }
-
-    template<typename U>
-    inline bool operator == (const sp<U>& o) const {
-        // Just comparing m_ptr fields is often dangerous, since wp<> may refer to an older
-        // object at the same address.
-        if (o == nullptr) {
-          return m_ptr == nullptr;
-        } else {
-          return m_refs == o->getWeakRefs();  // Implies m_ptr == o.mptr.
-        }
-    }
-
-    template<typename U>
-    inline bool operator != (const sp<U>& o) const {
-        return !(*this == o);
-    }
-
-    template<typename U>
-    inline bool operator > (const wp<U>& o) const {
-        if (m_ptr == o.m_ptr) {
-            return _wp_compare_<std::greater>(m_refs, o.m_refs);
-        } else {
-            return _wp_compare_<std::greater>(m_ptr, o.m_ptr);
-        }
-    }
-
-    template<typename U>
-    inline bool operator < (const wp<U>& o) const {
-        if (m_ptr == o.m_ptr) {
-            return _wp_compare_<std::less>(m_refs, o.m_refs);
-        } else {
-            return _wp_compare_<std::less>(m_ptr, o.m_ptr);
-        }
-    }
-    template<typename U> inline bool operator != (const wp<U>& o) const { return !operator == (o); }
-    template<typename U> inline bool operator <= (const wp<U>& o) const { return !operator > (o); }
-    template<typename U> inline bool operator >= (const wp<U>& o) const { return !operator < (o); }
-
-private:
-    template<typename Y> friend class sp;
-    template<typename Y> friend class wp;
-
-    T*              m_ptr;
-    weakref_type*   m_refs;
-};
-
-#undef COMPARE_WEAK
-#undef COMPARE_WEAK_FUNCTIONAL
-
-// ---------------------------------------------------------------------------
-// No user serviceable parts below here.
-
-// Implementation invariants:
-// Either
-// 1) m_ptr and m_refs are both null, or
-// 2) m_refs == m_ptr->mRefs, or
-// 3) *m_ptr is no longer live, and m_refs points to the weakref_type object that corresponded
-//    to m_ptr while it was live. *m_refs remains live while a wp<> refers to it.
-//
-// The m_refs field in a RefBase object is allocated on construction, unique to that RefBase
-// object, and never changes. Thus if two wp's have identical m_refs fields, they are either both
-// null or point to the same object. If two wp's have identical m_ptr fields, they either both
-// point to the same live object and thus have the same m_ref fields, or at least one of the
-// objects is no longer live.
-//
-// Note that the above comparison operations go out of their way to provide an ordering consistent
-// with ordinary pointer comparison; otherwise they could ignore m_ptr, and just compare m_refs.
-
-template <typename T>
-wp<T> wp<T>::fromExisting(T* other) {
-    if (!other) return nullptr;
-
-    auto refs = other->getWeakRefs();
-    refs->incWeakRequireWeak(other);
-
-    wp<T> ret;
-    ret.m_ptr = other;
-    ret.m_refs = refs;
-    return ret;
-}
-
-#if !defined(ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION)
-template<typename T>
-wp<T>::wp(T* other)
-    : m_ptr(other)
-{
-    m_refs = other ? m_refs = other->createWeak(this) : nullptr;
-}
-
-template <typename T>
-template <typename U>
-wp<T>::wp(U* other) : m_ptr(other) {
-    m_refs = other ? other->createWeak(this) : nullptr;
-}
-
-template <typename T>
-wp<T>& wp<T>::operator=(T* other) {
-    weakref_type* newRefs = other ? other->createWeak(this) : nullptr;
-    if (m_ptr) m_refs->decWeak(this);
-    m_ptr = other;
-    m_refs = newRefs;
-    return *this;
-}
-
-template <typename T>
-template <typename U>
-wp<T>& wp<T>::operator=(U* other) {
-    weakref_type* newRefs = other ? other->createWeak(this) : 0;
-    if (m_ptr) m_refs->decWeak(this);
-    m_ptr = other;
-    m_refs = newRefs;
-    return *this;
-}
-#endif
-
-template<typename T>
-wp<T>::wp(const wp<T>& other)
-    : m_ptr(other.m_ptr), m_refs(other.m_refs)
-{
-    if (m_ptr) m_refs->incWeak(this);
-}
-
-template<typename T>
-wp<T>::wp(const sp<T>& other)
-    : m_ptr(other.m_ptr)
-{
-    m_refs = m_ptr ? m_ptr->createWeak(this) : nullptr;
-}
-
-template<typename T> template<typename U>
-wp<T>::wp(const wp<U>& other)
-    : m_ptr(other.m_ptr)
-{
-    if (m_ptr) {
-        m_refs = other.m_refs;
-        m_refs->incWeak(this);
-    } else {
-        m_refs = nullptr;
-    }
-}
-
-template<typename T> template<typename U>
-wp<T>::wp(const sp<U>& other)
-    : m_ptr(other.m_ptr)
-{
-    m_refs = m_ptr ? m_ptr->createWeak(this) : nullptr;
-}
-
-template<typename T>
-wp<T>::~wp()
-{
-    if (m_ptr) m_refs->decWeak(this);
-}
-
-template<typename T>
-wp<T>& wp<T>::operator = (const wp<T>& other)
-{
-    weakref_type* otherRefs(other.m_refs);
-    T* otherPtr(other.m_ptr);
-    if (otherPtr) otherRefs->incWeak(this);
-    if (m_ptr) m_refs->decWeak(this);
-    m_ptr = otherPtr;
-    m_refs = otherRefs;
-    return *this;
-}
-
-template<typename T>
-wp<T>& wp<T>::operator = (const sp<T>& other)
-{
-    weakref_type* newRefs =
-        other != nullptr ? other->createWeak(this) : nullptr;
-    T* otherPtr(other.m_ptr);
-    if (m_ptr) m_refs->decWeak(this);
-    m_ptr = otherPtr;
-    m_refs = newRefs;
-    return *this;
-}
-
-template<typename T> template<typename U>
-wp<T>& wp<T>::operator = (const wp<U>& other)
-{
-    weakref_type* otherRefs(other.m_refs);
-    U* otherPtr(other.m_ptr);
-    if (otherPtr) otherRefs->incWeak(this);
-    if (m_ptr) m_refs->decWeak(this);
-    m_ptr = otherPtr;
-    m_refs = otherRefs;
-    return *this;
-}
-
-template<typename T> template<typename U>
-wp<T>& wp<T>::operator = (const sp<U>& other)
-{
-    weakref_type* newRefs =
-        other != nullptr ? other->createWeak(this) : 0;
-    U* otherPtr(other.m_ptr);
-    if (m_ptr) m_refs->decWeak(this);
-    m_ptr = otherPtr;
-    m_refs = newRefs;
-    return *this;
-}
-
-template<typename T>
-void wp<T>::set_object_and_refs(T* other, weakref_type* refs)
-{
-    if (other) refs->incWeak(this);
-    if (m_ptr) m_refs->decWeak(this);
-    m_ptr = other;
-    m_refs = refs;
-}
-
-template<typename T>
-sp<T> wp<T>::promote() const
-{
-    sp<T> result;
-    if (m_ptr && m_refs->attemptIncStrong(&result)) {
-        result.set_pointer(m_ptr);
-    }
-    return result;
-}
-
-template<typename T>
-void wp<T>::clear()
-{
-    if (m_ptr) {
-        m_refs->decWeak(this);
-        m_refs = 0;
-        m_ptr = 0;
-    }
-}
-
-// ---------------------------------------------------------------------------
-
-// this class just serves as a namespace so TYPE::moveReferences can stay
-// private.
-class ReferenceMover {
-public:
-    // it would be nice if we could make sure no extra code is generated
-    // for sp<TYPE> or wp<TYPE> when TYPE is a descendant of RefBase:
-    // Using a sp<RefBase> override doesn't work; it's a bit like we wanted
-    // a template<typename TYPE inherits RefBase> template...
-
-    template<typename TYPE> static inline
-    void move_references(sp<TYPE>* dest, sp<TYPE> const* src, size_t n) {
-
-        class Renamer : public ReferenceRenamer {
-            sp<TYPE>* d_;
-            sp<TYPE> const* s_;
-            virtual void operator()(size_t i) const {
-                // The id are known to be the sp<>'s this pointer
-                TYPE::renameRefId(d_[i].get(), &s_[i], &d_[i]);
-            }
-        public:
-            Renamer(sp<TYPE>* d, sp<TYPE> const* s) : d_(d), s_(s) { }
-            virtual ~Renamer() { }
-        };
-
-        memmove(dest, src, n*sizeof(sp<TYPE>));
-        TYPE::renameRefs(n, Renamer(dest, src));
-    }
-
-
-    template<typename TYPE> static inline
-    void move_references(wp<TYPE>* dest, wp<TYPE> const* src, size_t n) {
-
-        class Renamer : public ReferenceRenamer {
-            wp<TYPE>* d_;
-            wp<TYPE> const* s_;
-            virtual void operator()(size_t i) const {
-                // The id are known to be the wp<>'s this pointer
-                TYPE::renameRefId(d_[i].get_refs(), &s_[i], &d_[i]);
-            }
-        public:
-            Renamer(wp<TYPE>* rd, wp<TYPE> const* rs) : d_(rd), s_(rs) { }
-            virtual ~Renamer() { }
-        };
-
-        memmove(dest, src, n*sizeof(wp<TYPE>));
-        TYPE::renameRefs(n, Renamer(dest, src));
-    }
-};
-
-// specialization for moving sp<> and wp<> types.
-// these are used by the [Sorted|Keyed]Vector<> implementations
-// sp<> and wp<> need to be handled specially, because they do not
-// have trivial copy operation in the general case (see RefBase.cpp
-// when DEBUG ops are enabled), but can be implemented very
-// efficiently in most cases.
-
-template<typename TYPE> inline
-void move_forward_type(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
-    ReferenceMover::move_references(d, s, n);
-}
-
-template<typename TYPE> inline
-void move_backward_type(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
-    ReferenceMover::move_references(d, s, n);
-}
-
-template<typename TYPE> inline
-void move_forward_type(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
-    ReferenceMover::move_references(d, s, n);
-}
-
-template<typename TYPE> inline
-void move_backward_type(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
-    ReferenceMover::move_references(d, s, n);
-}
-
-}  // namespace android
-
-namespace libutilsinternal {
-template <typename T, typename = void>
-struct is_complete_type : std::false_type {};
-
-template <typename T>
-struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
-}  // namespace libutilsinternal
-
-namespace std {
-
-// Define `RefBase` specific versions of `std::make_shared` and
-// `std::make_unique` to block people from using them. Using them to allocate
-// `RefBase` objects results in double ownership. Use
-// `sp<T>::make(...)` instead.
-//
-// Note: We exclude incomplete types because `std::is_base_of` is undefined in
-// that case.
-
-template <typename T, typename... Args,
-          typename std::enable_if<libutilsinternal::is_complete_type<T>::value, bool>::value = true,
-          typename std::enable_if<std::is_base_of<android::RefBase, T>::value, bool>::value = true>
-shared_ptr<T> make_shared(Args...) {  // SEE COMMENT ABOVE.
-    static_assert(!std::is_base_of<android::RefBase, T>::value, "Must use RefBase with sp<>");
-}
-
-template <typename T, typename... Args,
-          typename std::enable_if<libutilsinternal::is_complete_type<T>::value, bool>::value = true,
-          typename std::enable_if<std::is_base_of<android::RefBase, T>::value, bool>::value = true>
-unique_ptr<T> make_unique(Args...) {  // SEE COMMENT ABOVE.
-    static_assert(!std::is_base_of<android::RefBase, T>::value, "Must use RefBase with sp<>");
-}
-
-}  // namespace std
-
-// ---------------------------------------------------------------------------
-
-#endif // ANDROID_REF_BASE_H
diff --git a/libutils/include/utils/RefBase.h b/libutils/include/utils/RefBase.h
new file mode 120000
index 000000000000..86d72b128038
--- /dev/null
+++ b/libutils/include/utils/RefBase.h
@@ -0,0 +1 @@
+../../binder/include/utils/RefBase.h
\ No newline at end of file
diff --git a/libutils/include/utils/String16.h b/libutils/include/utils/String16.h
deleted file mode 100644
index c7135766b097..000000000000
--- a/libutils/include/utils/String16.h
+++ /dev/null
@@ -1,383 +0,0 @@
-/*
- * Copyright (C) 2005 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.
- */
-
-#ifndef ANDROID_STRING16_H
-#define ANDROID_STRING16_H
-
-#include <iostream>
-#include <string>
-
-#include <utils/Errors.h>
-#include <utils/String8.h>
-#include <utils/TypeHelpers.h>
-
-#if __has_include(<string_view>)
-#include <string_view>
-#define HAS_STRING_VIEW
-#endif
-
-// ---------------------------------------------------------------------------
-
-namespace android {
-
-// ---------------------------------------------------------------------------
-
-template <size_t N>
-class StaticString16;
-
-// DO NOT USE: please use std::u16string
-
-//! This is a string holding UTF-16 characters.
-class String16
-{
-public:
-                                String16();
-                                String16(const String16& o);
-                                String16(String16&& o) noexcept;
-                                String16(const String16& o,
-                                         size_t len,
-                                         size_t begin=0);
-    explicit                    String16(const char16_t* o);
-    explicit                    String16(const char16_t* o, size_t len);
-    explicit                    String16(const String8& o);
-    explicit                    String16(const char* o);
-    explicit                    String16(const char* o, size_t len);
-
-                                ~String16();
-
-    inline  const char16_t*     c_str() const;
-
-            size_t              size() const;
-    inline  bool                empty() const;
-
-    inline  size_t              length() const;
-
-            void                setTo(const String16& other);
-            status_t            setTo(const char16_t* other);
-            status_t            setTo(const char16_t* other, size_t len);
-            status_t            setTo(const String16& other,
-                                      size_t len,
-                                      size_t begin=0);
-
-            status_t            append(const String16& other);
-            status_t            append(const char16_t* other, size_t len);
-
-    inline  String16&           operator=(const String16& other);
-            String16&           operator=(String16&& other) noexcept;
-
-    inline  String16&           operator+=(const String16& other);
-    inline  String16            operator+(const String16& other) const;
-
-            status_t            insert(size_t pos, const char16_t* chrs);
-            status_t            insert(size_t pos,
-                                       const char16_t* chrs, size_t len);
-
-            ssize_t             findFirst(char16_t c) const;
-            ssize_t             findLast(char16_t c) const;
-
-            bool                startsWith(const String16& prefix) const;
-            bool                startsWith(const char16_t* prefix) const;
-
-            bool                contains(const char16_t* chrs) const;
-    inline  bool                contains(const String16& other) const;
-
-            status_t            replaceAll(char16_t replaceThis,
-                                           char16_t withThis);
-
-    inline  int                 compare(const String16& other) const;
-
-    inline  bool                operator<(const String16& other) const;
-    inline  bool                operator<=(const String16& other) const;
-    inline  bool                operator==(const String16& other) const;
-    inline  bool                operator!=(const String16& other) const;
-    inline  bool                operator>=(const String16& other) const;
-    inline  bool                operator>(const String16& other) const;
-
-    inline  bool                operator<(const char16_t* other) const;
-    inline  bool                operator<=(const char16_t* other) const;
-    inline  bool                operator==(const char16_t* other) const;
-    inline  bool                operator!=(const char16_t* other) const;
-    inline  bool                operator>=(const char16_t* other) const;
-    inline  bool                operator>(const char16_t* other) const;
-
-    inline                      operator const char16_t*() const;
-
-#ifdef HAS_STRING_VIEW
-    // Implicit cast to std::u16string is not implemented on purpose - u16string_view is much
-    // lighter and if one needs, they can still create u16string from u16string_view.
-    inline                      operator std::u16string_view() const;
-#endif
-
-    // Static and non-static String16 behave the same for the users, so
-    // this method isn't of much use for the users. It is public for testing.
-            bool                isStaticString() const;
-
-  private:
-    /*
-     * A flag indicating the type of underlying buffer.
-     */
-    static constexpr uint32_t kIsSharedBufferAllocated = 0x80000000;
-
-    /*
-     * alloc() returns void* so that SharedBuffer class is not exposed.
-     */
-    static void* alloc(size_t size);
-    static char16_t* allocFromUTF8(const char* u8str, size_t u8len);
-    static char16_t* allocFromUTF16(const char16_t* u16str, size_t u16len);
-
-    /*
-     * edit() and editResize() return void* so that SharedBuffer class
-     * is not exposed.
-     */
-    void* edit();
-    void* editResize(size_t new_size);
-
-    void acquire();
-    void release();
-
-    size_t staticStringSize() const;
-
-    const char16_t* mString;
-
-protected:
-    /*
-     * Data structure used to allocate static storage for static String16.
-     *
-     * Note that this data structure and SharedBuffer are used interchangably
-     * as the underlying data structure for a String16.  Therefore, the layout
-     * of this data structure must match the part in SharedBuffer that is
-     * visible to String16.
-     */
-    template <size_t N>
-    struct StaticData {
-        // The high bit of 'size' is used as a flag.
-        static_assert(N - 1 < kIsSharedBufferAllocated, "StaticString16 too long!");
-        constexpr StaticData() : size(N - 1), data{0} {}
-        const uint32_t size;
-        char16_t data[N];
-
-        constexpr StaticData(const StaticData<N>&) = default;
-    };
-
-    /*
-     * Helper function for constructing a StaticData object.
-     */
-    template <size_t N>
-    static constexpr const StaticData<N> makeStaticData(const char16_t (&s)[N]) {
-        StaticData<N> r;
-        // The 'size' field is at the same location where mClientMetadata would
-        // be for a SharedBuffer.  We do NOT set kIsSharedBufferAllocated flag
-        // here.
-        for (size_t i = 0; i < N - 1; ++i) r.data[i] = s[i];
-        return r;
-    }
-
-    template <size_t N>
-    explicit constexpr String16(const StaticData<N>& s) : mString(s.data) {}
-
-// These symbols are for potential backward compatibility with prebuilts. To be removed.
-#ifdef ENABLE_STRING16_OBSOLETE_METHODS
-public:
-#else
-private:
-#endif
-    inline  const char16_t*     string() const;
-};
-
-// String16 can be trivially moved using memcpy() because moving does not
-// require any change to the underlying SharedBuffer contents or reference count.
-ANDROID_TRIVIAL_MOVE_TRAIT(String16)
-
-static inline std::ostream& operator<<(std::ostream& os, const String16& str) {
-    os << String8(str);
-    return os;
-}
-
-// ---------------------------------------------------------------------------
-
-/*
- * A StaticString16 object is a specialized String16 object.  Instead of holding
- * the string data in a ref counted SharedBuffer object, it holds data in a
- * buffer within StaticString16 itself.  Note that this buffer is NOT ref
- * counted and is assumed to be available for as long as there is at least a
- * String16 object using it.  Therefore, one must be extra careful to NEVER
- * assign a StaticString16 to a String16 that outlives the StaticString16
- * object.
- *
- * THE SAFEST APPROACH IS TO USE StaticString16 ONLY AS GLOBAL VARIABLES.
- *
- * A StaticString16 SHOULD NEVER APPEAR IN APIs.  USE String16 INSTEAD.
- */
-template <size_t N>
-class StaticString16 : public String16 {
-public:
-    constexpr StaticString16(const char16_t (&s)[N]) : String16(mData), mData(makeStaticData(s)) {}
-
-    constexpr StaticString16(const StaticString16<N>& other)
-        : String16(mData), mData(other.mData) {}
-
-    constexpr StaticString16(const StaticString16<N>&&) = delete;
-
-    // There is no reason why one would want to 'new' a StaticString16.  Delete
-    // it to discourage misuse.
-    static void* operator new(std::size_t) = delete;
-
-private:
-    const StaticData<N> mData;
-};
-
-template <typename F>
-StaticString16(const F&)->StaticString16<sizeof(F) / sizeof(char16_t)>;
-
-// ---------------------------------------------------------------------------
-// No user servicable parts below.
-
-inline int compare_type(const String16& lhs, const String16& rhs)
-{
-    return lhs.compare(rhs);
-}
-
-inline int strictly_order_type(const String16& lhs, const String16& rhs)
-{
-    return compare_type(lhs, rhs) < 0;
-}
-
-inline const char16_t* String16::c_str() const
-{
-    return mString;
-}
-
-inline const char16_t* String16::string() const
-{
-    return mString;
-}
-
-inline bool String16::empty() const
-{
-    return length() == 0;
-}
-
-inline size_t String16::length() const
-{
-    return size();
-}
-
-inline bool String16::contains(const String16& other) const
-{
-    return contains(other.c_str());
-}
-
-inline String16& String16::operator=(const String16& other)
-{
-    setTo(other);
-    return *this;
-}
-
-inline String16& String16::operator+=(const String16& other)
-{
-    append(other);
-    return *this;
-}
-
-inline String16 String16::operator+(const String16& other) const
-{
-    String16 tmp(*this);
-    tmp += other;
-    return tmp;
-}
-
-inline int String16::compare(const String16& other) const
-{
-    return strzcmp16(mString, size(), other.mString, other.size());
-}
-
-inline bool String16::operator<(const String16& other) const
-{
-    return strzcmp16(mString, size(), other.mString, other.size()) < 0;
-}
-
-inline bool String16::operator<=(const String16& other) const
-{
-    return strzcmp16(mString, size(), other.mString, other.size()) <= 0;
-}
-
-inline bool String16::operator==(const String16& other) const
-{
-    return strzcmp16(mString, size(), other.mString, other.size()) == 0;
-}
-
-inline bool String16::operator!=(const String16& other) const
-{
-    return strzcmp16(mString, size(), other.mString, other.size()) != 0;
-}
-
-inline bool String16::operator>=(const String16& other) const
-{
-    return strzcmp16(mString, size(), other.mString, other.size()) >= 0;
-}
-
-inline bool String16::operator>(const String16& other) const
-{
-    return strzcmp16(mString, size(), other.mString, other.size()) > 0;
-}
-
-inline bool String16::operator<(const char16_t* other) const
-{
-    return strcmp16(mString, other) < 0;
-}
-
-inline bool String16::operator<=(const char16_t* other) const
-{
-    return strcmp16(mString, other) <= 0;
-}
-
-inline bool String16::operator==(const char16_t* other) const
-{
-    return strcmp16(mString, other) == 0;
-}
-
-inline bool String16::operator!=(const char16_t* other) const
-{
-    return strcmp16(mString, other) != 0;
-}
-
-inline bool String16::operator>=(const char16_t* other) const
-{
-    return strcmp16(mString, other) >= 0;
-}
-
-inline bool String16::operator>(const char16_t* other) const
-{
-    return strcmp16(mString, other) > 0;
-}
-
-inline String16::operator const char16_t*() const
-{
-    return mString;
-}
-
-inline String16::operator std::u16string_view() const
-{
-    return {mString, length()};
-}
-
-}  // namespace android
-
-// ---------------------------------------------------------------------------
-
-#undef HAS_STRING_VIEW
-
-#endif // ANDROID_STRING16_H
diff --git a/libutils/include/utils/String16.h b/libutils/include/utils/String16.h
new file mode 120000
index 000000000000..b88792fa4633
--- /dev/null
+++ b/libutils/include/utils/String16.h
@@ -0,0 +1 @@
+../../binder/include/utils/String16.h
\ No newline at end of file
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
deleted file mode 100644
index 6d250723b628..000000000000
--- a/libutils/include/utils/String8.h
+++ /dev/null
@@ -1,354 +0,0 @@
-/*
- * Copyright (C) 2005 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.
- */
-
-#ifndef ANDROID_STRING8_H
-#define ANDROID_STRING8_H
-
-#include <iostream>
-
-#include <utils/Errors.h>
-#include <utils/Unicode.h>
-#include <utils/TypeHelpers.h>
-
-#include <string.h> // for strcmp
-#include <stdarg.h>
-
-#if __has_include(<string>)
-#include <string>
-#define HAS_STRING
-#endif
-
-#if __has_include(<string_view>)
-#include <string_view>
-#define HAS_STRING_VIEW
-#endif
-
-// ---------------------------------------------------------------------------
-
-namespace android {
-
-class String16;
-
-// DO NOT USE: please use std::string
-
-//! This is a string holding UTF-8 characters. Does not allow the value more
-// than 0x10FFFF, which is not valid unicode codepoint.
-class String8
-{
-public:
-                                String8();
-                                String8(const String8& o);
-    explicit                    String8(const char* o);
-    explicit                    String8(const char* o, size_t numChars);
-
-    explicit                    String8(const String16& o);
-    explicit                    String8(const char16_t* o);
-    explicit                    String8(const char16_t* o, size_t numChars);
-    explicit                    String8(const char32_t* o);
-    explicit                    String8(const char32_t* o, size_t numChars);
-                                ~String8();
-
-    static String8              format(const char* fmt, ...) __attribute__((format (printf, 1, 2)));
-    static String8              formatV(const char* fmt, va_list args);
-
-    inline  const char*         c_str() const;
-
-    inline  size_t              size() const;
-    inline  size_t              bytes() const;
-    inline  bool                empty() const;
-
-            size_t              length() const;
-
-            void                clear();
-
-            void                setTo(const String8& other);
-            status_t            setTo(const char* other);
-            status_t            setTo(const char* other, size_t numChars);
-            status_t            setTo(const char16_t* other, size_t numChars);
-            status_t            setTo(const char32_t* other,
-                                      size_t length);
-
-            status_t            append(const String8& other);
-            status_t            append(const char* other);
-            status_t            append(const char* other, size_t numChars);
-
-            status_t            appendFormat(const char* fmt, ...)
-                    __attribute__((format (printf, 2, 3)));
-            status_t            appendFormatV(const char* fmt, va_list args);
-
-    inline  String8&            operator=(const String8& other);
-    inline  String8&            operator=(const char* other);
-
-    inline  String8&            operator+=(const String8& other);
-    inline  String8             operator+(const String8& other) const;
-
-    inline  String8&            operator+=(const char* other);
-    inline  String8             operator+(const char* other) const;
-
-    inline  int                 compare(const String8& other) const;
-
-    inline  bool                operator<(const String8& other) const;
-    inline  bool                operator<=(const String8& other) const;
-    inline  bool                operator==(const String8& other) const;
-    inline  bool                operator!=(const String8& other) const;
-    inline  bool                operator>=(const String8& other) const;
-    inline  bool                operator>(const String8& other) const;
-
-    inline  bool                operator<(const char* other) const;
-    inline  bool                operator<=(const char* other) const;
-    inline  bool                operator==(const char* other) const;
-    inline  bool                operator!=(const char* other) const;
-    inline  bool                operator>=(const char* other) const;
-    inline  bool                operator>(const char* other) const;
-
-    inline                      operator const char*() const;
-
-#ifdef HAS_STRING_VIEW
-    inline explicit             operator std::string_view() const;
-#endif
-
-            char*               lockBuffer(size_t size);
-            void                unlockBuffer();
-            status_t            unlockBuffer(size_t size);
-
-            // return the index of the first byte of other in this at or after
-            // start, or -1 if not found
-            ssize_t             find(const char* other, size_t start = 0) const;
-    inline  ssize_t             find(const String8& other, size_t start = 0) const;
-
-            // return true if this string contains the specified substring
-    inline  bool                contains(const char* other) const;
-    inline  bool                contains(const String8& other) const;
-
-            // removes all occurrence of the specified substring
-            // returns true if any were found and removed
-            bool                removeAll(const char* other);
-    inline  bool                removeAll(const String8& other);
-
-            void                toLower();
-
-private:
-            String8 getPathDir(void) const;
-            String8 getPathExtension(void) const;
-
-            status_t            real_append(const char* other, size_t numChars);
-
-            const char* mString;
-
-// These symbols are for potential backward compatibility with prebuilts. To be removed.
-#ifdef ENABLE_STRING8_OBSOLETE_METHODS
-public:
-#else
-private:
-#endif
-    inline  const char*         string() const;
-    inline  bool                isEmpty() const;
-};
-
-// String8 can be trivially moved using memcpy() because moving does not
-// require any change to the underlying SharedBuffer contents or reference count.
-ANDROID_TRIVIAL_MOVE_TRAIT(String8)
-
-static inline std::ostream& operator<<(std::ostream& os, const String8& str) {
-    os << str.c_str();
-    return os;
-}
-
-// ---------------------------------------------------------------------------
-// No user servicable parts below.
-
-inline int compare_type(const String8& lhs, const String8& rhs)
-{
-    return lhs.compare(rhs);
-}
-
-inline int strictly_order_type(const String8& lhs, const String8& rhs)
-{
-    return compare_type(lhs, rhs) < 0;
-}
-
-inline const char* String8::c_str() const
-{
-    return mString;
-}
-inline const char* String8::string() const
-{
-    return mString;
-}
-
-inline size_t String8::size() const
-{
-    return length();
-}
-
-inline bool String8::empty() const
-{
-    return length() == 0;
-}
-
-inline bool String8::isEmpty() const
-{
-    return length() == 0;
-}
-
-inline size_t String8::bytes() const
-{
-    return length();
-}
-
-inline ssize_t String8::find(const String8& other, size_t start) const
-{
-    return find(other.c_str(), start);
-}
-
-inline bool String8::contains(const char* other) const
-{
-    return find(other) >= 0;
-}
-
-inline bool String8::contains(const String8& other) const
-{
-    return contains(other.c_str());
-}
-
-inline bool String8::removeAll(const String8& other)
-{
-    return removeAll(other.c_str());
-}
-
-inline String8& String8::operator=(const String8& other)
-{
-    setTo(other);
-    return *this;
-}
-
-inline String8& String8::operator=(const char* other)
-{
-    setTo(other);
-    return *this;
-}
-
-inline String8& String8::operator+=(const String8& other)
-{
-    append(other);
-    return *this;
-}
-
-inline String8 String8::operator+(const String8& other) const
-{
-    String8 tmp(*this);
-    tmp += other;
-    return tmp;
-}
-
-inline String8& String8::operator+=(const char* other)
-{
-    append(other);
-    return *this;
-}
-
-inline String8 String8::operator+(const char* other) const
-{
-    String8 tmp(*this);
-    tmp += other;
-    return tmp;
-}
-
-inline int String8::compare(const String8& other) const
-{
-    return strcmp(mString, other.mString);
-}
-
-inline bool String8::operator<(const String8& other) const
-{
-    return strcmp(mString, other.mString) < 0;
-}
-
-inline bool String8::operator<=(const String8& other) const
-{
-    return strcmp(mString, other.mString) <= 0;
-}
-
-inline bool String8::operator==(const String8& other) const
-{
-    return strcmp(mString, other.mString) == 0;
-}
-
-inline bool String8::operator!=(const String8& other) const
-{
-    return strcmp(mString, other.mString) != 0;
-}
-
-inline bool String8::operator>=(const String8& other) const
-{
-    return strcmp(mString, other.mString) >= 0;
-}
-
-inline bool String8::operator>(const String8& other) const
-{
-    return strcmp(mString, other.mString) > 0;
-}
-
-inline bool String8::operator<(const char* other) const
-{
-    return strcmp(mString, other) < 0;
-}
-
-inline bool String8::operator<=(const char* other) const
-{
-    return strcmp(mString, other) <= 0;
-}
-
-inline bool String8::operator==(const char* other) const
-{
-    return strcmp(mString, other) == 0;
-}
-
-inline bool String8::operator!=(const char* other) const
-{
-    return strcmp(mString, other) != 0;
-}
-
-inline bool String8::operator>=(const char* other) const
-{
-    return strcmp(mString, other) >= 0;
-}
-
-inline bool String8::operator>(const char* other) const
-{
-    return strcmp(mString, other) > 0;
-}
-
-inline String8::operator const char*() const
-{
-    return mString;
-}
-
-#ifdef HAS_STRING_VIEW
-inline String8::operator std::string_view() const
-{
-    return {mString, length()};
-}
-#endif
-
-}  // namespace android
-
-// ---------------------------------------------------------------------------
-
-#undef HAS_STRING
-#undef HAS_STRING_VIEW
-
-#endif // ANDROID_STRING8_H
diff --git a/libutils/include/utils/String8.h b/libutils/include/utils/String8.h
new file mode 120000
index 000000000000..fa5a082f55cb
--- /dev/null
+++ b/libutils/include/utils/String8.h
@@ -0,0 +1 @@
+../../binder/include/utils/String8.h
\ No newline at end of file
diff --git a/libutils/include/utils/StrongPointer.h b/libutils/include/utils/StrongPointer.h
deleted file mode 100644
index 54aa691e03c2..000000000000
--- a/libutils/include/utils/StrongPointer.h
+++ /dev/null
@@ -1,361 +0,0 @@
-/*
- * Copyright (C) 2005 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.
- */
-
-#ifndef ANDROID_STRONG_POINTER_H
-#define ANDROID_STRONG_POINTER_H
-
-#include <functional>
-#include <type_traits>  // for common_type.
-
-// ---------------------------------------------------------------------------
-namespace android {
-
-template<typename T> class wp;
-
-// ---------------------------------------------------------------------------
-
-template<typename T>
-class sp {
-public:
-    inline sp() : m_ptr(nullptr) { }
-
-    // The old way of using sp<> was like this. This is bad because it relies
-    // on implicit conversion to sp<>, which we would like to remove (if an
-    // object is being managed some other way, this is double-ownership). We
-    // want to move away from this:
-    //
-    //     sp<Foo> foo = new Foo(...); // DO NOT DO THIS
-    //
-    // Instead, prefer to do this:
-    //
-    //     sp<Foo> foo = sp<Foo>::make(...); // DO THIS
-    //
-    // Sometimes, in order to use this, when a constructor is marked as private,
-    // you may need to add this to your class:
-    //
-    //     friend class sp<Foo>;
-    template <typename... Args>
-    static inline sp<T> make(Args&&... args);
-
-    // if nullptr, returns nullptr
-    //
-    // if a strong pointer is already available, this will retrieve it,
-    // otherwise, this will abort
-    static inline sp<T> fromExisting(T* other);
-
-    // for more information about this macro and correct RefBase usage, see
-    // the comment at the top of utils/RefBase.h
-#if defined(ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION)
-    sp(std::nullptr_t) : sp() {}
-#else
-    sp(T* other);  // NOLINT(implicit)
-    template <typename U>
-    sp(U* other);  // NOLINT(implicit)
-    sp& operator=(T* other);
-    template <typename U>
-    sp& operator=(U* other);
-#endif
-
-    sp(const sp<T>& other);
-    sp(sp<T>&& other) noexcept;
-
-    template<typename U> sp(const sp<U>& other);  // NOLINT(implicit)
-    template<typename U> sp(sp<U>&& other);  // NOLINT(implicit)
-
-    // Cast a strong pointer directly from one type to another. Constructors
-    // allow changing types, but only if they are pointer-compatible. This does
-    // a static_cast internally.
-    template <typename U>
-    static inline sp<T> cast(const sp<U>& other);
-
-    ~sp();
-
-    // Assignment
-
-    sp& operator = (const sp<T>& other);
-    sp& operator=(sp<T>&& other) noexcept;
-
-    template<typename U> sp& operator = (const sp<U>& other);
-    template<typename U> sp& operator = (sp<U>&& other);
-
-    //! Special optimization for use by ProcessState (and nobody else).
-    void force_set(T* other);
-
-    // Reset
-
-    void clear();
-
-    // Accessors
-
-    inline T&       operator* () const     { return *m_ptr; }
-    inline T*       operator-> () const    { return m_ptr;  }
-    inline T*       get() const            { return m_ptr; }
-    inline explicit operator bool () const { return m_ptr != nullptr; }
-
-    // Punt these to the wp<> implementation.
-    template<typename U>
-    inline bool operator == (const wp<U>& o) const {
-        return o == *this;
-    }
-
-    template<typename U>
-    inline bool operator != (const wp<U>& o) const {
-        return o != *this;
-    }
-
-private:
-    template<typename Y> friend class sp;
-    template<typename Y> friend class wp;
-    void set_pointer(T* ptr);
-    T* m_ptr;
-};
-
-#define COMPARE_STRONG(_op_)                                           \
-    template <typename T, typename U>                                  \
-    static inline bool operator _op_(const sp<T>& t, const sp<U>& u) { \
-        return t.get() _op_ u.get();                                   \
-    }                                                                  \
-    template <typename T, typename U>                                  \
-    static inline bool operator _op_(const T* t, const sp<U>& u) {     \
-        return t _op_ u.get();                                         \
-    }                                                                  \
-    template <typename T, typename U>                                  \
-    static inline bool operator _op_(const sp<T>& t, const U* u) {     \
-        return t.get() _op_ u;                                         \
-    }                                                                  \
-    template <typename T>                                              \
-    static inline bool operator _op_(const sp<T>& t, std::nullptr_t) { \
-        return t.get() _op_ nullptr;                                   \
-    }                                                                  \
-    template <typename T>                                              \
-    static inline bool operator _op_(std::nullptr_t, const sp<T>& t) { \
-        return nullptr _op_ t.get();                                   \
-    }
-
-template <template <typename C> class comparator, typename T, typename U>
-static inline bool _sp_compare_(T* a, U* b) {
-    return comparator<typename std::common_type<T*, U*>::type>()(a, b);
-}
-
-#define COMPARE_STRONG_FUNCTIONAL(_op_, _compare_)                     \
-    template <typename T, typename U>                                  \
-    static inline bool operator _op_(const sp<T>& t, const sp<U>& u) { \
-        return _sp_compare_<_compare_>(t.get(), u.get());              \
-    }                                                                  \
-    template <typename T, typename U>                                  \
-    static inline bool operator _op_(const T* t, const sp<U>& u) {     \
-        return _sp_compare_<_compare_>(t, u.get());                    \
-    }                                                                  \
-    template <typename T, typename U>                                  \
-    static inline bool operator _op_(const sp<T>& t, const U* u) {     \
-        return _sp_compare_<_compare_>(t.get(), u);                    \
-    }                                                                  \
-    template <typename T>                                              \
-    static inline bool operator _op_(const sp<T>& t, std::nullptr_t) { \
-        return _sp_compare_<_compare_>(t.get(), nullptr);              \
-    }                                                                  \
-    template <typename T>                                              \
-    static inline bool operator _op_(std::nullptr_t, const sp<T>& t) { \
-        return _sp_compare_<_compare_>(nullptr, t.get());              \
-    }
-
-COMPARE_STRONG(==)
-COMPARE_STRONG(!=)
-COMPARE_STRONG_FUNCTIONAL(>, std::greater)
-COMPARE_STRONG_FUNCTIONAL(<, std::less)
-COMPARE_STRONG_FUNCTIONAL(<=, std::less_equal)
-COMPARE_STRONG_FUNCTIONAL(>=, std::greater_equal)
-
-#undef COMPARE_STRONG
-#undef COMPARE_STRONG_FUNCTIONAL
-
-// For code size reasons, we do not want these inlined or templated.
-void sp_report_race();
-
-// ---------------------------------------------------------------------------
-// No user serviceable parts below here.
-
-// TODO: Ideally we should find a way to increment the reference count before running the
-// constructor, so that generating an sp<> to this in the constructor is no longer dangerous.
-template <typename T>
-template <typename... Args>
-sp<T> sp<T>::make(Args&&... args) {
-    T* t = new T(std::forward<Args>(args)...);
-    sp<T> result;
-    result.m_ptr = t;
-    t->incStrong(t);
-    return result;
-}
-
-template <typename T>
-sp<T> sp<T>::fromExisting(T* other) {
-    if (other) {
-        other->incStrongRequireStrong(other);
-        sp<T> result;
-        result.m_ptr = other;
-        return result;
-    }
-    return nullptr;
-}
-
-#if !defined(ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION)
-template<typename T>
-sp<T>::sp(T* other)
-        : m_ptr(other) {
-    if (other) {
-        other->incStrong(this);
-    }
-}
-
-template <typename T>
-template <typename U>
-sp<T>::sp(U* other) : m_ptr(other) {
-    if (other) {
-        (static_cast<T*>(other))->incStrong(this);
-    }
-}
-
-template <typename T>
-sp<T>& sp<T>::operator=(T* other) {
-    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
-    if (other) {
-        other->incStrong(this);
-    }
-    if (oldPtr) oldPtr->decStrong(this);
-    if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
-    m_ptr = other;
-    return *this;
-}
-#endif
-
-template<typename T>
-sp<T>::sp(const sp<T>& other)
-        : m_ptr(other.m_ptr) {
-    if (m_ptr)
-        m_ptr->incStrong(this);
-}
-
-template <typename T>
-sp<T>::sp(sp<T>&& other) noexcept : m_ptr(other.m_ptr) {
-    other.m_ptr = nullptr;
-}
-
-template<typename T> template<typename U>
-sp<T>::sp(const sp<U>& other)
-        : m_ptr(other.m_ptr) {
-    if (m_ptr)
-        m_ptr->incStrong(this);
-}
-
-template<typename T> template<typename U>
-sp<T>::sp(sp<U>&& other)
-        : m_ptr(other.m_ptr) {
-    other.m_ptr = nullptr;
-}
-
-template <typename T>
-template <typename U>
-sp<T> sp<T>::cast(const sp<U>& other) {
-    return sp<T>::fromExisting(static_cast<T*>(other.get()));
-}
-
-template<typename T>
-sp<T>::~sp() {
-    if (m_ptr)
-        m_ptr->decStrong(this);
-}
-
-template<typename T>
-sp<T>& sp<T>::operator =(const sp<T>& other) {
-    // Force m_ptr to be read twice, to heuristically check for data races.
-    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
-    T* otherPtr(other.m_ptr);
-    if (otherPtr) otherPtr->incStrong(this);
-    if (oldPtr) oldPtr->decStrong(this);
-    if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
-    m_ptr = otherPtr;
-    return *this;
-}
-
-template <typename T>
-sp<T>& sp<T>::operator=(sp<T>&& other) noexcept {
-    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
-    if (oldPtr) oldPtr->decStrong(this);
-    if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
-    m_ptr = other.m_ptr;
-    other.m_ptr = nullptr;
-    return *this;
-}
-
-template<typename T> template<typename U>
-sp<T>& sp<T>::operator =(const sp<U>& other) {
-    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
-    T* otherPtr(other.m_ptr);
-    if (otherPtr) otherPtr->incStrong(this);
-    if (oldPtr) oldPtr->decStrong(this);
-    if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
-    m_ptr = otherPtr;
-    return *this;
-}
-
-template<typename T> template<typename U>
-sp<T>& sp<T>::operator =(sp<U>&& other) {
-    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
-    if (m_ptr) m_ptr->decStrong(this);
-    if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
-    m_ptr = other.m_ptr;
-    other.m_ptr = nullptr;
-    return *this;
-}
-
-#if !defined(ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION)
-template<typename T> template<typename U>
-sp<T>& sp<T>::operator =(U* other) {
-    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
-    if (other) (static_cast<T*>(other))->incStrong(this);
-    if (oldPtr) oldPtr->decStrong(this);
-    if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
-    m_ptr = other;
-    return *this;
-}
-#endif
-
-template<typename T>
-void sp<T>::force_set(T* other) {
-    other->forceIncStrong(this);
-    m_ptr = other;
-}
-
-template<typename T>
-void sp<T>::clear() {
-    T* oldPtr(*const_cast<T* volatile*>(&m_ptr));
-    if (oldPtr) {
-        oldPtr->decStrong(this);
-        if (oldPtr != *const_cast<T* volatile*>(&m_ptr)) sp_report_race();
-        m_ptr = nullptr;
-    }
-}
-
-template<typename T>
-void sp<T>::set_pointer(T* ptr) {
-    m_ptr = ptr;
-}
-
-}  // namespace android
-
-// ---------------------------------------------------------------------------
-
-#endif // ANDROID_STRONG_POINTER_H
diff --git a/libutils/include/utils/StrongPointer.h b/libutils/include/utils/StrongPointer.h
new file mode 120000
index 000000000000..fd8bc60311e4
--- /dev/null
+++ b/libutils/include/utils/StrongPointer.h
@@ -0,0 +1 @@
+../../binder/include/utils/StrongPointer.h
\ No newline at end of file
diff --git a/libutils/include/utils/Unicode.h b/libutils/include/utils/Unicode.h
deleted file mode 100644
index d60d5d6ba634..000000000000
--- a/libutils/include/utils/Unicode.h
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Copyright (C) 2005 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.
- */
-
-#ifndef ANDROID_UNICODE_H
-#define ANDROID_UNICODE_H
-
-#include <sys/types.h>
-#include <stdint.h>
-
-extern "C" {
-
-// Standard string functions on char16_t strings.
-int strcmp16(const char16_t *, const char16_t *);
-int strncmp16(const char16_t *s1, const char16_t *s2, size_t n);
-size_t strlen16(const char16_t *);
-size_t strnlen16(const char16_t *, size_t);
-char16_t *strstr16(const char16_t*, const char16_t*);
-
-// Version of comparison that supports embedded NULs.
-// This is different than strncmp() because we don't stop
-// at a nul character and consider the strings to be different
-// if the lengths are different (thus we need to supply the
-// lengths of both strings).  This can also be used when
-// your string is not nul-terminated as it will have the
-// equivalent result as strcmp16 (unlike strncmp16).
-int strzcmp16(const char16_t *s1, size_t n1, const char16_t *s2, size_t n2);
-
-/**
- * Measure the length of a UTF-32 string in UTF-8. If the string is invalid
- * such as containing a surrogate character, -1 will be returned.
- */
-ssize_t utf32_to_utf8_length(const char32_t *src, size_t src_len);
-
-/**
- * Stores a UTF-8 string converted from "src" in "dst", if "dst_length" is not
- * large enough to store the string, the part of the "src" string is stored
- * into "dst" as much as possible. See the examples for more detail.
- * Returns the size actually used for storing the string.
- * dst" is not nul-terminated when dst_len is fully used (like strncpy).
- *
- * \code
- * Example 1
- * "src" == \u3042\u3044 (\xE3\x81\x82\xE3\x81\x84)
- * "src_len" == 2
- * "dst_len" >= 7
- * ->
- * Returned value == 6
- * "dst" becomes \xE3\x81\x82\xE3\x81\x84\0
- * (note that "dst" is nul-terminated)
- *
- * Example 2
- * "src" == \u3042\u3044 (\xE3\x81\x82\xE3\x81\x84)
- * "src_len" == 2
- * "dst_len" == 5
- * ->
- * Returned value == 3
- * "dst" becomes \xE3\x81\x82\0
- * (note that "dst" is nul-terminated, but \u3044 is not stored in "dst"
- * since "dst" does not have enough size to store the character)
- *
- * Example 3
- * "src" == \u3042\u3044 (\xE3\x81\x82\xE3\x81\x84)
- * "src_len" == 2
- * "dst_len" == 6
- * ->
- * Returned value == 6
- * "dst" becomes \xE3\x81\x82\xE3\x81\x84
- * (note that "dst" is NOT nul-terminated, like strncpy)
- * \endcode
- */
-void utf32_to_utf8(const char32_t* src, size_t src_len, char* dst, size_t dst_len);
-
-/**
- * Returns the unicode value at "index".
- * Returns -1 when the index is invalid (equals to or more than "src_len").
- * If returned value is positive, it is able to be converted to char32_t, which
- * is unsigned. Then, if "next_index" is not NULL, the next index to be used is
- * stored in "next_index". "next_index" can be NULL.
- */
-int32_t utf32_from_utf8_at(const char *src, size_t src_len, size_t index, size_t *next_index);
-
-
-/**
- * Returns the UTF-8 length of UTF-16 string "src".
- */
-ssize_t utf16_to_utf8_length(const char16_t *src, size_t src_len);
-
-/**
- * Converts a UTF-16 string to UTF-8. The destination buffer must be large
- * enough to fit the UTF-16 as measured by utf16_to_utf8_length with an added
- * NUL terminator.
- */
-void utf16_to_utf8(const char16_t* src, size_t src_len, char* dst, size_t dst_len);
-
-/**
- * Returns the UTF-16 length of UTF-8 string "src". Returns -1 in case
- * it's invalid utf8. No buffer over-read occurs because of bound checks. Using overreadIsFatal you
- * can ask to log a message and fail in case the invalid utf8 could have caused an override if no
- * bound checks were used (otherwise -1 is returned).
- */
-ssize_t utf8_to_utf16_length(const uint8_t* src, size_t srcLen, bool overreadIsFatal = false);
-
-/**
- * Convert UTF-8 to UTF-16 including surrogate pairs.
- * Returns a pointer to the end of the string (where a NUL terminator might go
- * if you wanted to add one). At most dstLen characters are written; it won't emit half a surrogate
- * pair. If dstLen == 0 nothing is written and dst is returned. If dstLen > SSIZE_MAX it aborts
- * (this being probably a negative number returned as an error and casted to unsigned).
- */
-char16_t* utf8_to_utf16_no_null_terminator(
-        const uint8_t* src, size_t srcLen, char16_t* dst, size_t dstLen);
-
-/**
- * Convert UTF-8 to UTF-16 including surrogate pairs. At most dstLen - 1
- * characters are written; it won't emit half a surrogate pair; and a NUL terminator is appended
- * after. dstLen - 1 can be measured beforehand using utf8_to_utf16_length. Aborts if dstLen == 0
- * (at least one character is needed for the NUL terminator) or dstLen > SSIZE_MAX (the latter
- * case being likely a negative number returned as an error and casted to unsigned) . Returns a
- * pointer to the NUL terminator.
- */
-char16_t *utf8_to_utf16(
-        const uint8_t* src, size_t srcLen, char16_t* dst, size_t dstLen);
-
-}
-
-#endif
diff --git a/libutils/include/utils/Unicode.h b/libutils/include/utils/Unicode.h
new file mode 120000
index 000000000000..8a480bcbb6d2
--- /dev/null
+++ b/libutils/include/utils/Unicode.h
@@ -0,0 +1 @@
+../../binder/include/utils/Unicode.h
\ No newline at end of file
diff --git a/libutils/include/utils/Vector.h b/libutils/include/utils/Vector.h
deleted file mode 100644
index d5db3cb482fe..000000000000
--- a/libutils/include/utils/Vector.h
+++ /dev/null
@@ -1,418 +0,0 @@
-/*
- * Copyright (C) 2005 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.
- */
-
-#ifndef ANDROID_VECTOR_H
-#define ANDROID_VECTOR_H
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#include <log/log.h>
-#include <utils/TypeHelpers.h>
-#include <utils/VectorImpl.h>
-#ifndef __has_attribute
-#define __has_attribute(x) 0
-#endif
-
-/*
- * Used to exclude some functions from CFI.
- */
-#if __has_attribute(no_sanitize)
-#define UTILS_VECTOR_NO_CFI __attribute__((no_sanitize("cfi")))
-#else
-#define UTILS_VECTOR_NO_CFI
-#endif
-
-// ---------------------------------------------------------------------------
-
-namespace android {
-
-template <typename TYPE>
-class SortedVector;
-
-/*!
- * The main templated vector class ensuring type safety
- * while making use of VectorImpl.
- * This is the class users want to use.
- *
- * DO NOT USE: please use std::vector
- */
-
-template <class TYPE>
-class Vector : private VectorImpl
-{
-public:
-            typedef TYPE    value_type;
-
-    /*!
-     * Constructors and destructors
-     */
-
-                            Vector();
-                            Vector(const Vector<TYPE>& rhs);
-    explicit                Vector(const SortedVector<TYPE>& rhs);
-    virtual                 ~Vector();
-
-    /*! copy operator */
-    Vector<TYPE>& operator=(const Vector<TYPE>& rhs);        // NOLINT(cert-oop54-cpp)
-    Vector<TYPE>& operator=(const SortedVector<TYPE>& rhs);  // NOLINT(cert-oop54-cpp)
-
-    /*
-     * empty the vector
-     */
-
-    inline  void            clear()             { VectorImpl::clear(); }
-
-    /*!
-     * vector stats
-     */
-
-    //! returns number of items in the vector
-    inline  size_t          size() const                { return VectorImpl::size(); }
-    //! returns whether or not the vector is empty
-    inline  bool            isEmpty() const             { return VectorImpl::isEmpty(); }
-    //! returns how many items can be stored without reallocating the backing store
-    inline  size_t          capacity() const            { return VectorImpl::capacity(); }
-    //! sets the capacity. capacity can never be reduced less than size()
-    inline  ssize_t         setCapacity(size_t size)    { return VectorImpl::setCapacity(size); }
-
-    /*!
-     * set the size of the vector. items are appended with the default
-     * constructor, or removed from the end as needed.
-     */
-    inline  ssize_t         resize(size_t size)         { return VectorImpl::resize(size); }
-
-    /*!
-     * C-style array access
-     */
-
-    //! read-only C-style access
-    inline  const TYPE*     array() const;
-    //! read-write C-style access
-            TYPE*           editArray();
-
-    /*!
-     * accessors
-     */
-
-    //! read-only access to an item at a given index
-    inline  const TYPE&     operator [] (size_t index) const;
-    //! alternate name for operator []
-    inline  const TYPE&     itemAt(size_t index) const;
-    //! stack-usage of the vector. returns the top of the stack (last element)
-            const TYPE&     top() const;
-
-    /*!
-     * modifying the array
-     */
-
-    //! copy-on write support, grants write access to an item
-            TYPE&           editItemAt(size_t index);
-    //! grants right access to the top of the stack (last element)
-            TYPE&           editTop();
-
-            /*!
-             * append/insert another vector
-             */
-
-    //! insert another vector at a given index
-            ssize_t         insertVectorAt(const Vector<TYPE>& vector, size_t index);
-
-    //! append another vector at the end of this one
-            ssize_t         appendVector(const Vector<TYPE>& vector);
-
-
-    //! insert an array at a given index
-            ssize_t         insertArrayAt(const TYPE* array, size_t index, size_t length);
-
-    //! append an array at the end of this vector
-            ssize_t         appendArray(const TYPE* array, size_t length);
-
-            /*!
-             * add/insert/replace items
-             */
-
-    //! insert one or several items initialized with their default constructor
-    inline  ssize_t         insertAt(size_t index, size_t numItems = 1);
-    //! insert one or several items initialized from a prototype item
-            ssize_t         insertAt(const TYPE& prototype_item, size_t index, size_t numItems = 1);
-    //! pop the top of the stack (removes the last element). No-op if the stack's empty
-    inline  void            pop();
-    //! pushes an item initialized with its default constructor
-    inline  void            push();
-    //! pushes an item on the top of the stack
-            void            push(const TYPE& item);
-    //! same as push() but returns the index the item was added at (or an error)
-    inline  ssize_t         add();
-    //! same as push() but returns the index the item was added at (or an error)
-            ssize_t         add(const TYPE& item);
-    //! replace an item with a new one initialized with its default constructor
-    inline  ssize_t         replaceAt(size_t index);
-    //! replace an item with a new one
-            ssize_t         replaceAt(const TYPE& item, size_t index);
-
-    /*!
-     * remove items
-     */
-
-    //! remove several items
-    inline  ssize_t         removeItemsAt(size_t index, size_t count = 1);
-    //! remove one item
-    inline  ssize_t         removeAt(size_t index)  { return removeItemsAt(index); }
-
-    /*!
-     * sort (stable) the array
-     */
-
-     typedef int (*compar_t)(const TYPE* lhs, const TYPE* rhs);
-     typedef int (*compar_r_t)(const TYPE* lhs, const TYPE* rhs, void* state);
-
-     inline status_t        sort(compar_t cmp);
-     inline status_t        sort(compar_r_t cmp, void* state);
-
-     // for debugging only
-     inline size_t getItemSize() const { return itemSize(); }
-
-
-     /*
-      * these inlines add some level of compatibility with STL. eventually
-      * we should probably turn things around.
-      */
-     typedef TYPE* iterator;
-     typedef TYPE const* const_iterator;
-
-     inline iterator begin() { return editArray(); }
-     inline iterator end()   { return editArray() + size(); }
-     inline const_iterator begin() const { return array(); }
-     inline const_iterator end() const   { return array() + size(); }
-     inline void reserve(size_t n) { setCapacity(n); }
-     inline bool empty() const{ return isEmpty(); }
-     inline void push_back(const TYPE& item)  { insertAt(item, size(), 1); }
-     inline void push_front(const TYPE& item) { insertAt(item, 0, 1); }
-     inline iterator erase(iterator pos) {
-         ssize_t index = removeItemsAt(static_cast<size_t>(pos-array()));
-         return begin() + index;
-     }
-
-protected:
-    virtual void    do_construct(void* storage, size_t num) const;
-    virtual void    do_destroy(void* storage, size_t num) const;
-    virtual void    do_copy(void* dest, const void* from, size_t num) const;
-    virtual void    do_splat(void* dest, const void* item, size_t num) const;
-    virtual void    do_move_forward(void* dest, const void* from, size_t num) const;
-    virtual void    do_move_backward(void* dest, const void* from, size_t num) const;
-};
-
-// ---------------------------------------------------------------------------
-// No user serviceable parts from here...
-// ---------------------------------------------------------------------------
-
-template<class TYPE> inline
-Vector<TYPE>::Vector()
-    : VectorImpl(sizeof(TYPE),
-                ((traits<TYPE>::has_trivial_ctor   ? HAS_TRIVIAL_CTOR   : 0)
-                |(traits<TYPE>::has_trivial_dtor   ? HAS_TRIVIAL_DTOR   : 0)
-                |(traits<TYPE>::has_trivial_copy   ? HAS_TRIVIAL_COPY   : 0))
-                )
-{
-}
-
-template<class TYPE> inline
-Vector<TYPE>::Vector(const Vector<TYPE>& rhs)
-    : VectorImpl(rhs) {
-}
-
-template<class TYPE> inline
-Vector<TYPE>::Vector(const SortedVector<TYPE>& rhs)
-    : VectorImpl(static_cast<const VectorImpl&>(rhs)) {
-}
-
-template<class TYPE> inline
-Vector<TYPE>::~Vector() {
-    finish_vector();
-}
-
-template <class TYPE>
-inline Vector<TYPE>& Vector<TYPE>::operator=(const Vector<TYPE>& rhs)  // NOLINT(cert-oop54-cpp)
-{
-    VectorImpl::operator=(rhs);
-    return *this;
-}
-
-template <class TYPE>
-inline Vector<TYPE>& Vector<TYPE>::operator=(
-        const SortedVector<TYPE>& rhs)  // NOLINT(cert-oop54-cpp)
-{
-    VectorImpl::operator=(static_cast<const VectorImpl&>(rhs));
-    return *this;
-}
-
-template<class TYPE> inline
-const TYPE* Vector<TYPE>::array() const {
-    return static_cast<const TYPE *>(arrayImpl());
-}
-
-template<class TYPE> inline
-TYPE* Vector<TYPE>::editArray() {
-    return static_cast<TYPE *>(editArrayImpl());
-}
-
-
-template<class TYPE> inline
-const TYPE& Vector<TYPE>::operator[](size_t index) const {
-    LOG_FATAL_IF(index>=size(),
-            "%s: index=%u out of range (%u)", __PRETTY_FUNCTION__,
-            int(index), int(size()));
-    return *(array() + index);
-}
-
-template<class TYPE> inline
-const TYPE& Vector<TYPE>::itemAt(size_t index) const {
-    return operator[](index);
-}
-
-template<class TYPE> inline
-const TYPE& Vector<TYPE>::top() const {
-    return *(array() + size() - 1);
-}
-
-template<class TYPE> inline
-TYPE& Vector<TYPE>::editItemAt(size_t index) {
-    return *( static_cast<TYPE *>(editItemLocation(index)) );
-}
-
-template<class TYPE> inline
-TYPE& Vector<TYPE>::editTop() {
-    return *( static_cast<TYPE *>(editItemLocation(size()-1)) );
-}
-
-template<class TYPE> inline
-ssize_t Vector<TYPE>::insertVectorAt(const Vector<TYPE>& vector, size_t index) {
-    return VectorImpl::insertVectorAt(reinterpret_cast<const VectorImpl&>(vector), index);
-}
-
-template<class TYPE> inline
-ssize_t Vector<TYPE>::appendVector(const Vector<TYPE>& vector) {
-    return VectorImpl::appendVector(reinterpret_cast<const VectorImpl&>(vector));
-}
-
-template<class TYPE> inline
-ssize_t Vector<TYPE>::insertArrayAt(const TYPE* array, size_t index, size_t length) {
-    return VectorImpl::insertArrayAt(array, index, length);
-}
-
-template<class TYPE> inline
-ssize_t Vector<TYPE>::appendArray(const TYPE* array, size_t length) {
-    return VectorImpl::appendArray(array, length);
-}
-
-template<class TYPE> inline
-ssize_t Vector<TYPE>::insertAt(const TYPE& item, size_t index, size_t numItems) {
-    return VectorImpl::insertAt(&item, index, numItems);
-}
-
-template<class TYPE> inline
-void Vector<TYPE>::push(const TYPE& item) {
-    return VectorImpl::push(&item);
-}
-
-template<class TYPE> inline
-ssize_t Vector<TYPE>::add(const TYPE& item) {
-    return VectorImpl::add(&item);
-}
-
-template<class TYPE> inline
-ssize_t Vector<TYPE>::replaceAt(const TYPE& item, size_t index) {
-    return VectorImpl::replaceAt(&item, index);
-}
-
-template<class TYPE> inline
-ssize_t Vector<TYPE>::insertAt(size_t index, size_t numItems) {
-    return VectorImpl::insertAt(index, numItems);
-}
-
-template<class TYPE> inline
-void Vector<TYPE>::pop() {
-    VectorImpl::pop();
-}
-
-template<class TYPE> inline
-void Vector<TYPE>::push() {
-    VectorImpl::push();
-}
-
-template<class TYPE> inline
-ssize_t Vector<TYPE>::add() {
-    return VectorImpl::add();
-}
-
-template<class TYPE> inline
-ssize_t Vector<TYPE>::replaceAt(size_t index) {
-    return VectorImpl::replaceAt(index);
-}
-
-template<class TYPE> inline
-ssize_t Vector<TYPE>::removeItemsAt(size_t index, size_t count) {
-    return VectorImpl::removeItemsAt(index, count);
-}
-
-template<class TYPE> inline
-status_t Vector<TYPE>::sort(Vector<TYPE>::compar_t cmp) {
-    return VectorImpl::sort(reinterpret_cast<VectorImpl::compar_t>(cmp));
-}
-
-template<class TYPE> inline
-status_t Vector<TYPE>::sort(Vector<TYPE>::compar_r_t cmp, void* state) {
-    return VectorImpl::sort(reinterpret_cast<VectorImpl::compar_r_t>(cmp), state);
-}
-
-// ---------------------------------------------------------------------------
-
-template<class TYPE>
-UTILS_VECTOR_NO_CFI void Vector<TYPE>::do_construct(void* storage, size_t num) const {
-    construct_type( reinterpret_cast<TYPE*>(storage), num );
-}
-
-template<class TYPE>
-void Vector<TYPE>::do_destroy(void* storage, size_t num) const {
-    destroy_type( reinterpret_cast<TYPE*>(storage), num );
-}
-
-template<class TYPE>
-UTILS_VECTOR_NO_CFI void Vector<TYPE>::do_copy(void* dest, const void* from, size_t num) const {
-    copy_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
-}
-
-template<class TYPE>
-UTILS_VECTOR_NO_CFI void Vector<TYPE>::do_splat(void* dest, const void* item, size_t num) const {
-    splat_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(item), num );
-}
-
-template<class TYPE>
-UTILS_VECTOR_NO_CFI void Vector<TYPE>::do_move_forward(void* dest, const void* from, size_t num) const {
-    move_forward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
-}
-
-template<class TYPE>
-UTILS_VECTOR_NO_CFI void Vector<TYPE>::do_move_backward(void* dest, const void* from, size_t num) const {
-    move_backward_type( reinterpret_cast<TYPE*>(dest), reinterpret_cast<const TYPE*>(from), num );
-}
-
-}  // namespace android
-
-// ---------------------------------------------------------------------------
-
-#endif // ANDROID_VECTOR_H
diff --git a/libutils/include/utils/Vector.h b/libutils/include/utils/Vector.h
new file mode 120000
index 000000000000..e1571efb5cf5
--- /dev/null
+++ b/libutils/include/utils/Vector.h
@@ -0,0 +1 @@
+../../binder/include/utils/Vector.h
\ No newline at end of file
diff --git a/libutils/include/utils/VectorImpl.h b/libutils/include/utils/VectorImpl.h
deleted file mode 100644
index 41b9f331060d..000000000000
--- a/libutils/include/utils/VectorImpl.h
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * Copyright (C) 2005 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.
- */
-
-#ifndef ANDROID_VECTOR_IMPL_H
-#define ANDROID_VECTOR_IMPL_H
-
-#include <assert.h>
-#include <stdint.h>
-#include <sys/types.h>
-#include <utils/Errors.h>
-
-// ---------------------------------------------------------------------------
-// No user serviceable parts in here...
-// ---------------------------------------------------------------------------
-
-namespace android {
-
-/*!
- * Implementation of the guts of the vector<> class
- * this ensures backward binary compatibility and
- * reduces code size.
- * For performance reasons, we expose mStorage and mCount
- * so these fields are set in stone.
- *
- */
-
-class VectorImpl
-{
-public:
-    enum { // flags passed to the ctor
-        HAS_TRIVIAL_CTOR    = 0x00000001,
-        HAS_TRIVIAL_DTOR    = 0x00000002,
-        HAS_TRIVIAL_COPY    = 0x00000004,
-    };
-
-                            VectorImpl(size_t itemSize, uint32_t flags);
-                            VectorImpl(const VectorImpl& rhs);
-    virtual                 ~VectorImpl();
-
-    /*! must be called from subclasses destructor */
-            void            finish_vector();
-
-            VectorImpl&     operator = (const VectorImpl& rhs);    
-            
-    /*! C-style array access */
-    inline  const void*     arrayImpl() const       { return mStorage; }
-            void*           editArrayImpl();
-            
-    /*! vector stats */
-    inline  size_t          size() const        { return mCount; }
-    inline  bool            isEmpty() const     { return mCount == 0; }
-            size_t          capacity() const;
-            ssize_t         setCapacity(size_t size);
-            ssize_t         resize(size_t size);
-
-            /*! append/insert another vector or array */
-            ssize_t         insertVectorAt(const VectorImpl& vector, size_t index);
-            ssize_t         appendVector(const VectorImpl& vector);
-            ssize_t         insertArrayAt(const void* array, size_t index, size_t length);
-            ssize_t         appendArray(const void* array, size_t length);
-            
-            /*! add/insert/replace items */
-            ssize_t         insertAt(size_t where, size_t numItems = 1);
-            ssize_t         insertAt(const void* item, size_t where, size_t numItems = 1);
-            void            pop();
-            void            push();
-            void            push(const void* item);
-            ssize_t         add();
-            ssize_t         add(const void* item);
-            ssize_t         replaceAt(size_t index);
-            ssize_t         replaceAt(const void* item, size_t index);
-
-            /*! remove items */
-            ssize_t         removeItemsAt(size_t index, size_t count = 1);
-            void            clear();
-
-            const void*     itemLocation(size_t index) const;
-            void*           editItemLocation(size_t index);
-
-            typedef int (*compar_t)(const void* lhs, const void* rhs);
-            typedef int (*compar_r_t)(const void* lhs, const void* rhs, void* state);
-            status_t        sort(compar_t cmp);
-            status_t        sort(compar_r_t cmp, void* state);
-
-protected:
-            size_t          itemSize() const;
-            void            release_storage();
-
-    virtual void            do_construct(void* storage, size_t num) const = 0;
-    virtual void            do_destroy(void* storage, size_t num) const = 0;
-    virtual void            do_copy(void* dest, const void* from, size_t num) const = 0;
-    virtual void            do_splat(void* dest, const void* item, size_t num) const = 0;
-    virtual void            do_move_forward(void* dest, const void* from, size_t num) const = 0;
-    virtual void            do_move_backward(void* dest, const void* from, size_t num) const = 0;
-    
-private:
-        void* _grow(size_t where, size_t amount);
-        void  _shrink(size_t where, size_t amount);
-
-        inline void _do_construct(void* storage, size_t num) const;
-        inline void _do_destroy(void* storage, size_t num) const;
-        inline void _do_copy(void* dest, const void* from, size_t num) const;
-        inline void _do_splat(void* dest, const void* item, size_t num) const;
-        inline void _do_move_forward(void* dest, const void* from, size_t num) const;
-        inline void _do_move_backward(void* dest, const void* from, size_t num) const;
-
-            // These 2 fields are exposed in the inlines below,
-            // so they're set in stone.
-            void *      mStorage;   // base address of the vector
-            size_t      mCount;     // number of items
-
-    const   uint32_t    mFlags;
-    const   size_t      mItemSize;
-};
-
-
-
-class SortedVectorImpl : public VectorImpl
-{
-public:
-                            SortedVectorImpl(size_t itemSize, uint32_t flags);
-    explicit                SortedVectorImpl(const VectorImpl& rhs);
-    virtual                 ~SortedVectorImpl();
-    
-    SortedVectorImpl&     operator = (const SortedVectorImpl& rhs);    
-
-    //! finds the index of an item
-            ssize_t         indexOf(const void* item) const;
-
-    //! finds where this item should be inserted
-            size_t          orderOf(const void* item) const;
-
-    //! add an item in the right place (or replaces it if there is one)
-            ssize_t         add(const void* item);
-
-    //! merges a vector into this one
-            ssize_t         merge(const VectorImpl& vector);
-            ssize_t         merge(const SortedVectorImpl& vector);
-             
-    //! removes an item
-            ssize_t         remove(const void* item);
-        
-protected:
-    virtual int             do_compare(const void* lhs, const void* rhs) const = 0;
-
-private:
-            ssize_t         _indexOrderOf(const void* item, size_t* order = nullptr) const;
-
-            // these are made private, because they can't be used on a SortedVector
-            // (they don't have an implementation either)
-            ssize_t         add();
-            void            pop();
-            void            push();
-            void            push(const void* item);
-            ssize_t         insertVectorAt(const VectorImpl& vector, size_t index);
-            ssize_t         appendVector(const VectorImpl& vector);
-            ssize_t         insertArrayAt(const void* array, size_t index, size_t length);
-            ssize_t         appendArray(const void* array, size_t length);
-            ssize_t         insertAt(size_t where, size_t numItems = 1);
-            ssize_t         insertAt(const void* item, size_t where, size_t numItems = 1);
-            ssize_t         replaceAt(size_t index);
-            ssize_t         replaceAt(const void* item, size_t index);
-};
-
-}  // namespace android
-
-// ---------------------------------------------------------------------------
-
-#endif // ANDROID_VECTOR_IMPL_H
diff --git a/libutils/include/utils/VectorImpl.h b/libutils/include/utils/VectorImpl.h
new file mode 120000
index 000000000000..47264464b596
--- /dev/null
+++ b/libutils/include/utils/VectorImpl.h
@@ -0,0 +1 @@
+../../binder/include/utils/VectorImpl.h
\ No newline at end of file

From f9f833066d4aac40648f0b528d56967317ff77a0 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 9 Oct 2023 13:02:21 -0700
Subject: [PATCH 0449/1487] Move Sync to base class

This function will be called in header write for both v3 and v2 writer.
Seems okay to move to base class as theres no unique functionality to
the v2 writer.

Test: cow_api_test

Change-Id: I70c1b08ce67127c9dcbd0f54b574d2cd5ad1d0b5
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_base.cpp | 11 +++++++++++
 fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h   |  1 +
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp   | 11 -----------
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h     |  1 -
 4 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.cpp
index ff34c597b34b..2ffc37b7d0aa 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.cpp
@@ -191,5 +191,16 @@ std::unique_ptr<chromeos_update_engine::FileDescriptor> CowWriterBase::OpenFileD
                                                       block_dev_size);
 }
 
+bool CowWriterBase::Sync() {
+    if (is_dev_null_) {
+        return true;
+    }
+    if (fsync(fd_.get()) < 0) {
+        PLOG(ERROR) << "fsync failed";
+        return false;
+    }
+    return true;
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
index c8b477275822..cdf62226866f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
@@ -34,6 +34,7 @@ class CowWriterBase : public ICowWriter {
     // If the given label is not found, Initialize will fail.
     virtual bool Initialize(std::optional<uint64_t> label = {}) = 0;
 
+    bool Sync();
     bool AddCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) override;
     bool AddRawBlocks(uint64_t new_block_start, const void* data, size_t size) override;
     bool AddXorBlocks(uint32_t new_block_start, const void* data, size_t size, uint32_t old_block,
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index a52297ffc0ce..e51dbde6340c 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -704,17 +704,6 @@ bool CowWriterV2::WriteRawData(const void* data, const size_t size) {
     return true;
 }
 
-bool CowWriterV2::Sync() {
-    if (is_dev_null_) {
-        return true;
-    }
-    if (fsync(fd_.get()) < 0) {
-        PLOG(ERROR) << "fsync failed";
-        return false;
-    }
-    return true;
-}
-
 bool CowWriterV2::Truncate(off_t length) {
     if (is_dev_null_ || is_block_device_) {
         return true;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
index c72a9b47c5d7..ce97b0182fd0 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
@@ -58,7 +58,6 @@ class CowWriterV2 : public CowWriterBase {
     bool FlushCluster();
 
     bool CompressBlocks(size_t num_blocks, const void* data);
-    bool Sync();
     bool Truncate(off_t length);
     bool EnsureSpaceAvailable(const uint64_t bytes_needed) const;
 

From c197df70d8d45a0ca2880e01d884725eb3252bb7 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 9 Oct 2023 14:50:08 -0700
Subject: [PATCH 0450/1487] Update API usage for source

replacing any instance of op->source_info with GetCowSourceinfoData as
that's what we're really looking for. This function will return the 48
bits associated with the source and not the extra bits that will store
type + other information. We should never be making a reference to
op->source_info directly as that has no real meaning, we should be
masking for the data that we really need

Test: cow_api_test
Change-Id: I259c790efdd13c61a4599e9edfc75cf0ba000c61
---
 .../include/libsnapshot/cow_format.h          |  4 +--
 .../libsnapshot_cow/cow_reader.cpp            |  8 ++---
 .../libsnapshot/libsnapshot_cow/test_v2.cpp   | 36 +++++++++----------
 .../snapuserd/dm-snapshot-merge/snapuserd.cpp |  2 +-
 .../dm-snapshot-merge/snapuserd_readahead.cpp |  6 ++--
 5 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 1c92f9157fae..2beeb9f62a35 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -202,8 +202,8 @@ static constexpr uint8_t kCowReadAheadDone = 2;
 
 static constexpr uint64_t kCowOpSourceInfoDataMask = (1ULL << 48) - 1;
 
-static inline uint64_t GetCowOpSourceInfoData(const CowOperation* op) {
-    return op->source_info & kCowOpSourceInfoDataMask;
+static inline uint64_t GetCowOpSourceInfoData(const CowOperation& op) {
+    return op.source_info & kCowOpSourceInfoDataMask;
 }
 
 struct CowFooter {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 0285c175526f..85fd4c37bcad 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -576,7 +576,7 @@ bool CowReader::GetRawBytes(const CowOperation* op, void* buffer, size_t len, si
         case kCowSequenceOp:
         case kCowReplaceOp:
         case kCowXorOp:
-            return GetRawBytes(GetCowOpSourceInfoData(op), buffer, len, read);
+            return GetRawBytes(GetCowOpSourceInfoData(*op), buffer, len, read);
         default:
             LOG(ERROR) << "Cannot get raw bytes of non-data op: " << *op;
             return false;
@@ -668,7 +668,7 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
     if (op->type == kCowXorOp) {
         offset = data_loc_->at(op->new_block);
     } else {
-        offset = GetCowOpSourceInfoData(op);
+        offset = GetCowOpSourceInfoData(*op);
     }
 
     if (!decompressor) {
@@ -684,10 +684,10 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
 bool CowReader::GetSourceOffset(const CowOperation* op, uint64_t* source_offset) {
     switch (op->type) {
         case kCowCopyOp:
-            *source_offset = GetCowOpSourceInfoData(op) * header_.block_size;
+            *source_offset = GetCowOpSourceInfoData(*op) * header_.block_size;
             return true;
         case kCowXorOp:
-            *source_offset = GetCowOpSourceInfoData(op);
+            *source_offset = GetCowOpSourceInfoData(*op);
             return true;
         default:
             return false;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 100b13778a5b..35d74bac0502 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -88,7 +88,7 @@ TEST_F(CowTest, CopyContiguous) {
         ASSERT_EQ(op->type, kCowCopyOp);
         ASSERT_EQ(op->data_length, 0);
         ASSERT_EQ(op->new_block, 10 + i);
-        ASSERT_EQ(op->source_info, 1000 + i);
+        ASSERT_EQ(GetCowOpSourceInfoData(*op), 1000 + i);
         iter->Next();
         i += 1;
     }
@@ -134,7 +134,7 @@ TEST_F(CowTest, ReadWrite) {
     ASSERT_EQ(op->type, kCowCopyOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 10);
-    ASSERT_EQ(op->source_info, 20);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 20);
 
     std::string sink(data.size(), '\0');
 
@@ -156,7 +156,7 @@ TEST_F(CowTest, ReadWrite) {
     ASSERT_EQ(op->type, kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 51);
-    ASSERT_EQ(op->source_info, 0);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
 
     iter->Next();
     ASSERT_FALSE(iter->AtEnd());
@@ -165,7 +165,7 @@ TEST_F(CowTest, ReadWrite) {
     ASSERT_EQ(op->type, kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 52);
-    ASSERT_EQ(op->source_info, 0);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
 
     iter->Next();
     ASSERT_TRUE(iter->AtEnd());
@@ -209,7 +209,7 @@ TEST_F(CowTest, ReadWriteXor) {
     ASSERT_EQ(op->type, kCowCopyOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 10);
-    ASSERT_EQ(op->source_info, 20);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 20);
 
     std::string sink(data.size(), '\0');
 
@@ -220,7 +220,7 @@ TEST_F(CowTest, ReadWriteXor) {
     ASSERT_EQ(op->type, kCowXorOp);
     ASSERT_EQ(op->data_length, 4096);
     ASSERT_EQ(op->new_block, 50);
-    ASSERT_EQ(GetCowOpSourceInfoData(op), 98314);  // 4096 * 24 + 10
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 98314);  // 4096 * 24 + 10
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data);
 
@@ -232,7 +232,7 @@ TEST_F(CowTest, ReadWriteXor) {
     ASSERT_EQ(op->type, kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 51);
-    ASSERT_EQ(op->source_info, 0);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
 
     iter->Next();
     ASSERT_FALSE(iter->AtEnd());
@@ -241,7 +241,7 @@ TEST_F(CowTest, ReadWriteXor) {
     ASSERT_EQ(op->type, kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 52);
-    ASSERT_EQ(op->source_info, 0);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
 
     iter->Next();
     ASSERT_TRUE(iter->AtEnd());
@@ -329,7 +329,7 @@ TEST_P(CompressionTest, ThreadedBatchWrites) {
             total_blocks += 1;
             std::string sink(xor_data.size(), '\0');
             ASSERT_EQ(op->new_block, 50);
-            ASSERT_EQ(GetCowOpSourceInfoData(op), 98314);  // 4096 * 24 + 10
+            ASSERT_EQ(GetCowOpSourceInfoData(*op), 98314);  // 4096 * 24 + 10
             ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
             ASSERT_EQ(sink, xor_data);
         }
@@ -664,7 +664,7 @@ TEST_F(CowTest, AppendLabelSmall) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source_info, 3);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 3);
 
     iter->Next();
 
@@ -717,7 +717,7 @@ TEST_F(CowTest, AppendLabelMissing) {
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source_info, 0);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
 
     iter->Next();
 
@@ -775,7 +775,7 @@ TEST_F(CowTest, AppendExtendedCorrupted) {
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source_info, 5);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 5);
 
     iter->Next();
     ASSERT_TRUE(iter->AtEnd());
@@ -844,7 +844,7 @@ TEST_F(CowTest, AppendbyLabel) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source_info, 4);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 4);
 
     iter->Next();
 
@@ -862,7 +862,7 @@ TEST_F(CowTest, AppendbyLabel) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source_info, 5);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 5);
 
     iter->Next();
 
@@ -915,7 +915,7 @@ TEST_F(CowTest, ClusterTest) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source_info, 4);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 4);
 
     iter->Next();
 
@@ -940,7 +940,7 @@ TEST_F(CowTest, ClusterTest) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source_info, 5);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 5);
 
     iter->Next();
 
@@ -959,7 +959,7 @@ TEST_F(CowTest, ClusterTest) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source_info, 6);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 6);
 
     iter->Next();
 
@@ -1006,7 +1006,7 @@ TEST_F(CowTest, ClusterAppendTest) {
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
     ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(op->source_info, 50);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 50);
 
     iter->Next();
 
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
index 71664bfa91b6..6dc082e86ffa 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
@@ -508,7 +508,7 @@ bool Snapuserd::ReadMetadata() {
             // the merge of operations are done based on the ops present
             // in the file.
             //===========================================================
-            uint64_t block_source = GetCowOpSourceInfoData(cow_op);
+            uint64_t block_source = GetCowOpSourceInfoData(*cow_op);
             if (prev_id.has_value()) {
                 if (dest_blocks.count(cow_op->new_block) || source_blocks.count(block_source)) {
                     break;
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
index d5fbe91a32f1..ab0b3094b5fd 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
@@ -172,7 +172,7 @@ ReadAheadThread::ReadAheadThread(const std::string& cow_device, const std::strin
 }
 
 void ReadAheadThread::CheckOverlap(const CowOperation* cow_op) {
-    uint64_t source_block = GetCowOpSourceInfoData(cow_op);
+    uint64_t source_block = GetCowOpSourceInfoData(*cow_op);
     if (dest_blocks_.count(cow_op->new_block) || source_blocks_.count(source_block)) {
         overlap_ = true;
     }
@@ -191,7 +191,7 @@ void ReadAheadThread::PrepareReadAhead(uint64_t* source_offset, int* pending_ops
         // Get the first block with offset
         const CowOperation* cow_op = GetRAOpIter();
         CHECK_NE(cow_op, nullptr);
-        *source_offset = GetCowOpSourceInfoData(cow_op);
+        *source_offset = GetCowOpSourceInfoData(*cow_op);
         if (cow_op->type == kCowCopyOp) {
             *source_offset *= BLOCK_SZ;
         }
@@ -210,7 +210,7 @@ void ReadAheadThread::PrepareReadAhead(uint64_t* source_offset, int* pending_ops
         while (!RAIterDone() && num_ops) {
             const CowOperation* op = GetRAOpIter();
             CHECK_NE(op, nullptr);
-            uint64_t next_offset = GetCowOpSourceInfoData(op);
+            uint64_t next_offset = GetCowOpSourceInfoData(*op);
             if (op->type == kCowCopyOp) {
                 next_offset *= BLOCK_SZ;
             }

From 76b1e83fad64526a201deb3639a318a1ac1f07ee Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 10 Oct 2023 10:25:41 -0700
Subject: [PATCH 0451/1487] Move ReadCowHeader to CowReader

Moving this function to cow reader first we have to read the version of
cow from the header before deciding which parser to use. This is a more
logical place for this code to be in

Test: th
Change-Id: Ie5ba53439b4fc3c4c409426b818a2d53c0cbc3e5
---
 .../include/libsnapshot/cow_reader.h          |  2 ++
 .../libsnapshot_cow/cow_reader.cpp            | 29 +++++++++++++++++++
 .../libsnapshot/libsnapshot_cow/parser_v2.cpp | 29 -------------------
 .../libsnapshot/libsnapshot_cow/parser_v2.h   |  2 --
 4 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index 1d6fd62b4046..27219379624e 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -188,5 +188,7 @@ class CowReader final : public ICowReader {
     uint8_t compression_type_ = kCowCompressNone;
 };
 
+bool ReadCowHeader(android::base::borrowed_fd fd, CowHeader* header);
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index c52705ca898c..996037efcaca 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -34,6 +34,35 @@
 namespace android {
 namespace snapshot {
 
+bool ReadCowHeader(android::base::borrowed_fd fd, CowHeader* header) {
+    if (lseek(fd.get(), 0, SEEK_SET) < 0) {
+        PLOG(ERROR) << "lseek header failed";
+        return false;
+    }
+
+    memset(header, 0, sizeof(*header));
+
+    if (!android::base::ReadFully(fd, &header->prefix, sizeof(header->prefix))) {
+        return false;
+    }
+    if (header->prefix.magic != kCowMagicNumber) {
+        LOG(ERROR) << "Header Magic corrupted. Magic: " << header->prefix.magic
+                   << "Expected: " << kCowMagicNumber;
+        return false;
+    }
+    if (header->prefix.header_size > sizeof(CowHeader)) {
+        LOG(ERROR) << "Unknown CowHeader size (got " << header->prefix.header_size
+                   << " bytes, expected at most " << sizeof(CowHeader) << " bytes)";
+        return false;
+    }
+
+    if (lseek(fd.get(), 0, SEEK_SET) < 0) {
+        PLOG(ERROR) << "lseek header failed";
+        return false;
+    }
+    return android::base::ReadFully(fd, header, header->prefix.header_size);
+}
+
 CowReader::CowReader(ReaderFlags reader_flag, bool is_merge)
     : fd_(-1),
       header_(),
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
index 8edeae127ac8..a7307bf63931 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
@@ -23,35 +23,6 @@ namespace snapshot {
 
 using android::base::borrowed_fd;
 
-bool ReadCowHeader(android::base::borrowed_fd fd, CowHeader* header) {
-    if (lseek(fd.get(), 0, SEEK_SET) < 0) {
-        PLOG(ERROR) << "lseek header failed";
-        return false;
-    }
-
-    memset(header, 0, sizeof(*header));
-
-    if (!android::base::ReadFully(fd, &header->prefix, sizeof(header->prefix))) {
-        return false;
-    }
-    if (header->prefix.magic != kCowMagicNumber) {
-        LOG(ERROR) << "Header Magic corrupted. Magic: " << header->prefix.magic
-                   << "Expected: " << kCowMagicNumber;
-        return false;
-    }
-    if (header->prefix.header_size > sizeof(CowHeader)) {
-        LOG(ERROR) << "Unknown CowHeader size (got " << header->prefix.header_size
-                   << " bytes, expected at most " << sizeof(CowHeader) << " bytes)";
-        return false;
-    }
-
-    if (lseek(fd.get(), 0, SEEK_SET) < 0) {
-        PLOG(ERROR) << "lseek header failed";
-        return false;
-    }
-    return android::base::ReadFully(fd, header, header->prefix.header_size);
-}
-
 bool CowParserV2::Parse(borrowed_fd fd, const CowHeader& header, std::optional<uint64_t> label) {
     auto pos = lseek(fd.get(), 0, SEEK_END);
     if (pos < 0) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
index 92e2b08c42d4..f51ff88cb15a 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
@@ -49,7 +49,5 @@ class CowParserV2 {
     std::optional<uint64_t> last_label_;
 };
 
-bool ReadCowHeader(android::base::borrowed_fd fd, CowHeader* header);
-
 }  // namespace snapshot
 }  // namespace android

From e90a39aee237cd619d0c20d9878df108031f29d7 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 5 Oct 2023 14:01:56 -0700
Subject: [PATCH 0452/1487] Shove type into source_info

We can shove type into source info to save 8 bits in per cow operation.
We only need 4 bits inside of source_info to enumerate all the types of
Cow Operation:

static constexpr uint8_t kCowCopyOp = 1;
static constexpr uint8_t kCowReplaceOp = 2;
static constexpr uint8_t kCowZeroOp = 3;
static constexpr uint8_t kCowLabelOp = 4;
static constexpr uint8_t kCowClusterOp = 5;
static constexpr uint8_t kCowXorOp = 6;
static constexpr uint8_t kCowSequenceOp = 7;
static constexpr uint8_t kCowFooterOp = -1;

Test: critical ota paths on pixel
Change-Id: I22049db0b39a55bd8f863339f3751d3146d5c1e9
---
 .../include/libsnapshot/cow_format.h          | 25 +++--
 .../libsnapshot_cow/cow_format.cpp            | 17 ++--
 .../libsnapshot_cow/cow_reader.cpp            | 15 +--
 .../libsnapshot_cow/inspect_cow.cpp           | 16 ++--
 .../libsnapshot_cow/snapshot_reader.cpp       | 11 ++-
 .../libsnapshot/libsnapshot_cow/test_v2.cpp   | 95 ++++++++++---------
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   |  9 ++
 .../snapuserd/dm-snapshot-merge/snapuserd.cpp |  7 +-
 .../dm-snapshot-merge/snapuserd_readahead.cpp |  5 +-
 .../dm-snapshot-merge/snapuserd_worker.cpp    |  6 +-
 .../user-space-merge/merge_worker.cpp         |  5 +-
 .../user-space-merge/read_worker.cpp          |  9 +-
 .../user-space-merge/snapuserd_core.cpp       |  9 +-
 .../user-space-merge/snapuserd_readahead.cpp  |  5 +-
 14 files changed, 135 insertions(+), 99 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 2beeb9f62a35..bfa8f6bea4bb 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -149,9 +149,6 @@ struct CowOperationV2 {
 
 // The on disk format of cow (currently ==  CowOperation)
 struct CowOperationV3 {
-    // The operation code (see the constants and structures below).
-    uint8_t type;
-
     // If this operation reads from the data section of the COW, this contains
     // the length.
     uint16_t data_length;
@@ -159,6 +156,10 @@ struct CowOperationV3 {
     // The block of data in the new image that this operation modifies.
     uint32_t new_block;
 
+    // source_info with have the following layout
+    // |---4 bits ---| ---12 bits---| --- 48 bits ---|
+    // |--- type --- | -- unused -- | --- source --- |
+    //
     // The value of |source| depends on the operation code.
     //
     // CopyOp: a 32-bit block location in the source image.
@@ -167,8 +168,6 @@ struct CowOperationV3 {
     // ZeroOp: unused
     // LabelOp: a 64-bit opaque identifier.
     //
-    // For ops other than Label:
-    //  Bits 47-62 are reserved and must be zero.
     // A block is compressed if it’s data is < block_sz
     uint64_t source_info;
 } __attribute__((packed));
@@ -200,9 +199,21 @@ static constexpr uint8_t kCowReadAheadNotStarted = 0;
 static constexpr uint8_t kCowReadAheadInProgress = 1;
 static constexpr uint8_t kCowReadAheadDone = 2;
 
-static constexpr uint64_t kCowOpSourceInfoDataMask = (1ULL << 48) - 1;
+// this is a mask to grab the last 48 bits of a 64 bit integer
+static constexpr uint64_t kCowOpSourceInfoDataMask = (0x1ULL << 48) - 1;
+// this is a mask to grab the first 4 bits of a 64 bit integer
+static constexpr uint64_t kCowOpSourceInfoTypeBit = 60;
+static constexpr uint64_t kCowOpSourceInfoTypeNumBits = 4;
+static constexpr uint64_t kCowOpSourceInfoTypeMask = (1 << kCowOpSourceInfoTypeNumBits) - 1;
+
+static constexpr void SetCowOpSourceInfoType(CowOperation* op, const uint8_t type) {
+    op->source_info |= uint64_t(type) << kCowOpSourceInfoTypeBit;
+}
+static constexpr uint64_t GetCowOpSourceInfoType(const CowOperation& op) {
+    return (op.source_info >> kCowOpSourceInfoTypeBit) & kCowOpSourceInfoTypeMask;
+}
 
-static inline uint64_t GetCowOpSourceInfoData(const CowOperation& op) {
+static constexpr uint64_t GetCowOpSourceInfoData(const CowOperation& op) {
     return op.source_info & kCowOpSourceInfoDataMask;
 }
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
index 5ab4f7a52226..1be592d21c65 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
@@ -81,16 +81,19 @@ std::ostream& operator<<(std::ostream& os, CowOperationV2 const& op) {
 
 std::ostream& operator<<(std::ostream& os, CowOperation const& op) {
     os << "CowOperation(";
-    EmitCowTypeString(os, op.type);
-    if (op.type == kCowReplaceOp || op.type == kCowXorOp || op.type == kCowSequenceOp) {
+    EmitCowTypeString(os, GetCowOpSourceInfoType(op));
+    if (GetCowOpSourceInfoType(op) == kCowReplaceOp || GetCowOpSourceInfoType(op) == kCowXorOp ||
+        GetCowOpSourceInfoType(op) == kCowSequenceOp) {
         os << ", data_length:" << op.data_length;
     }
-    if (op.type != kCowClusterOp && op.type != kCowSequenceOp && op.type != kCowLabelOp) {
+    if (GetCowOpSourceInfoType(op) != kCowClusterOp &&
+        GetCowOpSourceInfoType(op) != kCowSequenceOp && GetCowOpSourceInfoType(op) != kCowLabelOp) {
         os << ", new_block:" << op.new_block;
     }
-    if (op.type == kCowXorOp || op.type == kCowReplaceOp || op.type == kCowCopyOp) {
+    if (GetCowOpSourceInfoType(op) == kCowXorOp || GetCowOpSourceInfoType(op) == kCowReplaceOp ||
+        GetCowOpSourceInfoType(op) == kCowCopyOp) {
         os << ", source:" << (op.source_info & kCowOpSourceInfoDataMask);
-    } else if (op.type == kCowClusterOp) {
+    } else if (GetCowOpSourceInfoType(op) == kCowClusterOp) {
         os << ", cluster_data:" << (op.source_info & kCowOpSourceInfoDataMask);
     } else {
         os << ", label:0x" << android::base::StringPrintf("%" PRIx64, op.source_info);
@@ -120,7 +123,7 @@ int64_t GetNextDataOffset(const CowOperationV2& op, uint32_t cluster_ops) {
 }
 
 bool IsMetadataOp(const CowOperation& op) {
-    switch (op.type) {
+    switch (GetCowOpSourceInfoType(op)) {
         case kCowLabelOp:
         case kCowClusterOp:
         case kCowFooterOp:
@@ -132,7 +135,7 @@ bool IsMetadataOp(const CowOperation& op) {
 }
 
 bool IsOrderedOp(const CowOperation& op) {
-    switch (op.type) {
+    switch (GetCowOpSourceInfoType(op)) {
         case kCowCopyOp:
         case kCowXorOp:
             return true;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 85fd4c37bcad..c52705ca898c 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -24,6 +24,7 @@
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include <libsnapshot/cow_format.h>
 #include <libsnapshot/cow_reader.h>
 #include <zlib.h>
 
@@ -110,7 +111,7 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
         const auto& v2_op = parser.ops()->at(i);
 
         auto& new_op = ops_->at(i);
-        new_op.type = v2_op.type;
+        SetCowOpSourceInfoType(&new_op, v2_op.type);
         new_op.data_length = v2_op.data_length;
 
         if (v2_op.new_block > std::numeric_limits<uint32_t>::max()) {
@@ -120,7 +121,7 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
         new_op.new_block = v2_op.new_block;
 
         uint64_t source_info = v2_op.source;
-        if (new_op.type != kCowLabelOp) {
+        if (GetCowOpSourceInfoType(new_op) != kCowLabelOp) {
             source_info &= kCowOpSourceInfoDataMask;
             if (source_info != v2_op.source) {
                 LOG(ERROR) << "Out-of-range source value in COW op: " << v2_op;
@@ -137,7 +138,7 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
                 return false;
             }
         }
-        new_op.source_info = source_info;
+        new_op.source_info |= source_info;
     }
 
     // If we're resuming a write, we're not ready to merge
@@ -260,7 +261,7 @@ bool CowReader::PrepMergeOps() {
     for (size_t i = 0; i < ops_->size(); i++) {
         auto& current_op = ops_->data()[i];
 
-        if (current_op.type == kCowSequenceOp) {
+        if (GetCowOpSourceInfoType(current_op) == kCowSequenceOp) {
             size_t seq_len = current_op.data_length / sizeof(uint32_t);
 
             merge_op_blocks->resize(merge_op_blocks->size() + seq_len);
@@ -572,7 +573,7 @@ std::unique_ptr<ICowOpIter> CowReader::GetMergeOpIter(bool ignore_progress) {
 }
 
 bool CowReader::GetRawBytes(const CowOperation* op, void* buffer, size_t len, size_t* read) {
-    switch (op->type) {
+    switch (GetCowOpSourceInfoType(*op)) {
         case kCowSequenceOp:
         case kCowReplaceOp:
         case kCowXorOp:
@@ -665,7 +666,7 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
     }
 
     uint64_t offset;
-    if (op->type == kCowXorOp) {
+    if (GetCowOpSourceInfoType(*op) == kCowXorOp) {
         offset = data_loc_->at(op->new_block);
     } else {
         offset = GetCowOpSourceInfoData(*op);
@@ -682,7 +683,7 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
 }
 
 bool CowReader::GetSourceOffset(const CowOperation* op, uint64_t* source_offset) {
-    switch (op->type) {
+    switch (GetCowOpSourceInfoType(*op)) {
         case kCowCopyOp:
             *source_offset = GetCowOpSourceInfoData(*op) * header_.block_size;
             return true;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
index 83b5a12955a7..aaaf20c2f69e 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
@@ -26,6 +26,7 @@
 #include <android-base/logging.h>
 #include <android-base/unique_fd.h>
 #include <gflags/gflags.h>
+#include <libsnapshot/cow_format.h>
 #include <libsnapshot/cow_reader.h>
 #include "parser_v2.h"
 
@@ -198,7 +199,7 @@ static bool Inspect(const std::string& path) {
 
         if (!FLAGS_silent && FLAGS_show_ops) std::cout << *op << "\n";
 
-        if ((FLAGS_decompress || extract_to >= 0) && op->type == kCowReplaceOp) {
+        if ((FLAGS_decompress || extract_to >= 0) && GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
             if (reader.ReadData(op, buffer.data(), buffer.size()) < 0) {
                 std::cerr << "Failed to decompress for :" << *op << "\n";
                 success = false;
@@ -212,12 +213,13 @@ static bool Inspect(const std::string& path) {
                     return false;
                 }
             }
-        } else if (extract_to >= 0 && !IsMetadataOp(*op) && op->type != kCowZeroOp) {
+        } else if (extract_to >= 0 && !IsMetadataOp(*op) &&
+                   GetCowOpSourceInfoType(*op) != kCowZeroOp) {
             PLOG(ERROR) << "Cannot extract op yet: " << *op;
             return false;
         }
 
-        if (op->type == kCowSequenceOp && FLAGS_show_merge_sequence) {
+        if (GetCowOpSourceInfoType(*op) == kCowSequenceOp && FLAGS_show_merge_sequence) {
             size_t read;
             std::vector<uint32_t> merge_op_blocks;
             size_t seq_len = op->data_length / sizeof(uint32_t);
@@ -235,13 +237,13 @@ static bool Inspect(const std::string& path) {
             }
         }
 
-        if (op->type == kCowCopyOp) {
+        if (GetCowOpSourceInfoType(*op) == kCowCopyOp) {
             copy_ops++;
-        } else if (op->type == kCowReplaceOp) {
+        } else if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
             replace_ops++;
-        } else if (op->type == kCowZeroOp) {
+        } else if (GetCowOpSourceInfoType(*op) == kCowZeroOp) {
             zero_ops++;
-        } else if (op->type == kCowXorOp) {
+        } else if (GetCowOpSourceInfoType(*op) == kCowXorOp) {
             xor_ops++;
         }
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
index a3e40d962ce7..d7ee432f4502 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
@@ -147,7 +147,7 @@ ssize_t CompressedSnapshotReader::ReadBlock(uint64_t chunk, size_t start_offset,
         op = ops_[chunk];
     }
 
-    if (!op || op->type == kCowCopyOp) {
+    if (!op || GetCowOpSourceInfoType(*op) == kCowCopyOp) {
         borrowed_fd fd = GetSourceFd();
         if (fd < 0) {
             // GetSourceFd sets errno.
@@ -169,15 +169,15 @@ ssize_t CompressedSnapshotReader::ReadBlock(uint64_t chunk, size_t start_offset,
             // ReadFullyAtOffset sets errno.
             return -1;
         }
-    } else if (op->type == kCowZeroOp) {
+    } else if (GetCowOpSourceInfoType(*op) == kCowZeroOp) {
         memset(buffer, 0, bytes_to_read);
-    } else if (op->type == kCowReplaceOp) {
+    } else if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
         if (cow_->ReadData(op, buffer, bytes_to_read, start_offset) < bytes_to_read) {
             LOG(ERROR) << "CompressedSnapshotReader failed to read replace op";
             errno = EIO;
             return -1;
         }
-    } else if (op->type == kCowXorOp) {
+    } else if (GetCowOpSourceInfoType(*op) == kCowXorOp) {
         borrowed_fd fd = GetSourceFd();
         if (fd < 0) {
             // GetSourceFd sets errno.
@@ -208,7 +208,8 @@ ssize_t CompressedSnapshotReader::ReadBlock(uint64_t chunk, size_t start_offset,
             ((char*)buffer)[i] ^= data[i];
         }
     } else {
-        LOG(ERROR) << "CompressedSnapshotReader unknown op type: " << uint32_t(op->type);
+        LOG(ERROR) << "CompressedSnapshotReader unknown op type: "
+                   << uint32_t(GetCowOpSourceInfoType(*op));
         errno = EINVAL;
         return -1;
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 35d74bac0502..d9628758e5cb 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -25,6 +25,7 @@
 #include <libsnapshot/cow_reader.h>
 #include <libsnapshot/cow_writer.h>
 #include "cow_decompress.h"
+#include "libsnapshot/cow_format.h"
 #include "writer_v2.h"
 
 using android::base::unique_fd;
@@ -85,7 +86,7 @@ TEST_F(CowTest, CopyContiguous) {
     size_t i = 0;
     while (!iter->AtEnd()) {
         auto op = iter->Get();
-        ASSERT_EQ(op->type, kCowCopyOp);
+        ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowCopyOp);
         ASSERT_EQ(op->data_length, 0);
         ASSERT_EQ(op->new_block, 10 + i);
         ASSERT_EQ(GetCowOpSourceInfoData(*op), 1000 + i);
@@ -131,7 +132,7 @@ TEST_F(CowTest, ReadWrite) {
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowCopyOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowCopyOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 10);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 20);
@@ -142,7 +143,7 @@ TEST_F(CowTest, ReadWrite) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
     ASSERT_EQ(op->data_length, 4096);
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -153,7 +154,7 @@ TEST_F(CowTest, ReadWrite) {
     op = iter->Get();
 
     // Note: the zero operation gets split into two blocks.
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 51);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
@@ -162,7 +163,7 @@ TEST_F(CowTest, ReadWrite) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 52);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
@@ -206,7 +207,7 @@ TEST_F(CowTest, ReadWriteXor) {
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowCopyOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowCopyOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 10);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 20);
@@ -217,7 +218,7 @@ TEST_F(CowTest, ReadWriteXor) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowXorOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowXorOp);
     ASSERT_EQ(op->data_length, 4096);
     ASSERT_EQ(op->new_block, 50);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 98314);  // 4096 * 24 + 10
@@ -229,7 +230,7 @@ TEST_F(CowTest, ReadWriteXor) {
     op = iter->Get();
 
     // Note: the zero operation gets split into two blocks.
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 51);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
@@ -238,7 +239,7 @@ TEST_F(CowTest, ReadWriteXor) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 52);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
@@ -273,7 +274,7 @@ TEST_F(CowTest, CompressGz) {
 
     std::string sink(data.size(), '\0');
 
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
     ASSERT_EQ(op->data_length, 56);  // compressed!
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -325,7 +326,7 @@ TEST_P(CompressionTest, ThreadedBatchWrites) {
     while (!iter->AtEnd()) {
         auto op = iter->Get();
 
-        if (op->type == kCowXorOp) {
+        if (GetCowOpSourceInfoType(*op) == kCowXorOp) {
             total_blocks += 1;
             std::string sink(xor_data.size(), '\0');
             ASSERT_EQ(op->new_block, 50);
@@ -334,7 +335,7 @@ TEST_P(CompressionTest, ThreadedBatchWrites) {
             ASSERT_EQ(sink, xor_data);
         }
 
-        if (op->type == kCowReplaceOp) {
+        if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
             total_blocks += 1;
             if (op->new_block == 100) {
                 data.resize(options.block_size);
@@ -399,7 +400,7 @@ TEST_P(CompressionTest, NoBatchWrites) {
     while (!iter->AtEnd()) {
         auto op = iter->Get();
 
-        if (op->type == kCowReplaceOp) {
+        if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
             total_blocks += 1;
             if (op->new_block == 50) {
                 data.resize(options.block_size);
@@ -519,7 +520,7 @@ TEST_F(CowTest, ClusterCompressGz) {
 
     std::string sink(data.size(), '\0');
 
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
     ASSERT_EQ(op->data_length, 56);  // compressed!
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -529,7 +530,7 @@ TEST_F(CowTest, ClusterCompressGz) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowClusterOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowClusterOp);
 
     iter->Next();
     ASSERT_FALSE(iter->AtEnd());
@@ -546,7 +547,7 @@ TEST_F(CowTest, ClusterCompressGz) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowClusterOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowClusterOp);
 
     iter->Next();
     ASSERT_TRUE(iter->AtEnd());
@@ -580,7 +581,7 @@ TEST_F(CowTest, CompressTwoBlocks) {
     std::string sink(options.block_size, '\0');
 
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
     ASSERT_EQ(op->new_block, 51);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
 }
@@ -653,7 +654,7 @@ TEST_F(CowTest, AppendLabelSmall) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data);
 
@@ -663,14 +664,14 @@ TEST_F(CowTest, AppendLabelSmall) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 3);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data2);
 
@@ -716,14 +717,14 @@ TEST_F(CowTest, AppendLabelMissing) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
 
     iter->Next();
 
@@ -774,7 +775,7 @@ TEST_F(CowTest, AppendExtendedCorrupted) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 5);
 
     iter->Next();
@@ -825,7 +826,7 @@ TEST_F(CowTest, AppendbyLabel) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data.substr(0, options.block_size));
 
@@ -835,7 +836,7 @@ TEST_F(CowTest, AppendbyLabel) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data.substr(options.block_size, 2 * options.block_size));
 
@@ -843,25 +844,25 @@ TEST_F(CowTest, AppendbyLabel) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 4);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
 
     iter->Next();
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 5);
 
     iter->Next();
@@ -906,7 +907,7 @@ TEST_F(CowTest, ClusterTest) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data.substr(0, options.block_size));
 
@@ -914,51 +915,51 @@ TEST_F(CowTest, ClusterTest) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 4);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowClusterOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowClusterOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 5);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowCopyOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowCopyOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowClusterOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowClusterOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 6);
 
     iter->Next();
@@ -1005,14 +1006,14 @@ TEST_F(CowTest, ClusterAppendTest) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 50);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data2);
 
@@ -1020,7 +1021,7 @@ TEST_F(CowTest, ClusterAppendTest) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowClusterOp);
+    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowClusterOp);
 
     iter->Next();
 
@@ -1117,12 +1118,12 @@ TEST_F(CowTest, ResumeMidCluster) {
         num_in_cluster++;
         max_in_cluster = std::max(max_in_cluster, num_in_cluster);
 
-        if (op->type == kCowReplaceOp) {
+        if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
             num_replace++;
 
             ASSERT_EQ(op->new_block, num_replace);
             ASSERT_TRUE(CompareDataBlock(&reader, op, "Block " + std::to_string(num_replace)));
-        } else if (op->type == kCowClusterOp) {
+        } else if (GetCowOpSourceInfoType(*op) == kCowClusterOp) {
             num_in_cluster = 0;
             num_clusters++;
         }
@@ -1178,12 +1179,12 @@ TEST_F(CowTest, ResumeEndCluster) {
         num_in_cluster++;
         max_in_cluster = std::max(max_in_cluster, num_in_cluster);
 
-        if (op->type == kCowReplaceOp) {
+        if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
             num_replace++;
 
             ASSERT_EQ(op->new_block, num_replace);
             ASSERT_TRUE(CompareDataBlock(&reader, op, "Block " + std::to_string(num_replace)));
-        } else if (op->type == kCowClusterOp) {
+        } else if (GetCowOpSourceInfoType(*op) == kCowClusterOp) {
             num_in_cluster = 0;
             num_clusters++;
         }
@@ -1229,12 +1230,12 @@ TEST_F(CowTest, DeleteMidCluster) {
 
         num_in_cluster++;
         max_in_cluster = std::max(max_in_cluster, num_in_cluster);
-        if (op->type == kCowReplaceOp) {
+        if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
             num_replace++;
 
             ASSERT_EQ(op->new_block, num_replace);
             ASSERT_TRUE(CompareDataBlock(&reader, op, "Block " + std::to_string(num_replace)));
-        } else if (op->type == kCowClusterOp) {
+        } else if (GetCowOpSourceInfoType(*op) == kCowClusterOp) {
             num_in_cluster = 0;
             num_clusters++;
         }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 2373d4df5bf3..a4d617f26d0b 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -49,5 +49,14 @@ class CowOperationV3Test : public ::testing::Test {
     std::unique_ptr<TemporaryFile> cow_;
 };
 
+TEST_F(CowOperationV3Test, CowTypeTest) {
+    CowOperationV3 new_op;
+    CowOperationV2 old_op;
+    old_op.type = kCowReplaceOp;
+    ASSERT_NE(GetCowOpSourceInfoType(new_op), old_op.type);
+    SetCowOpSourceInfoType(&new_op, old_op.type);
+    ASSERT_EQ(GetCowOpSourceInfoType(new_op), old_op.type);
+}
+
 }  // namespace snapshot
 }  // namespace android
\ No newline at end of file
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
index 6dc082e86ffa..0be6ff518414 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
@@ -25,6 +25,7 @@
 #include <csignal>
 #include <optional>
 #include <set>
+#include "libsnapshot/cow_format.h"
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
@@ -406,9 +407,9 @@ bool Snapuserd::ReadMetadata() {
             break;
         }
 
-        if (cow_op->type == kCowReplaceOp) {
+        if (GetCowOpSourceInfoType(*cow_op) == kCowReplaceOp) {
             replace_ops++;
-        } else if (cow_op->type == kCowZeroOp) {
+        } else if (GetCowOpSourceInfoType(*cow_op) == kCowZeroOp) {
             zero_ops++;
         }
 
@@ -540,7 +541,7 @@ bool Snapuserd::ReadMetadata() {
             chunk_vec_.push_back(std::make_pair(ChunkToSector(data_chunk_id), cow_op));
             offset += sizeof(struct disk_exception);
             num_ops += 1;
-            if (cow_op->type == kCowCopyOp) {
+            if (GetCowOpSourceInfoType(*cow_op) == kCowCopyOp) {
                 copy_ops++;
             }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
index ab0b3094b5fd..b2a4f2c8fcfe 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "libsnapshot/cow_format.h"
 #include "snapuserd.h"
 
 #include <csignal>
@@ -192,7 +193,7 @@ void ReadAheadThread::PrepareReadAhead(uint64_t* source_offset, int* pending_ops
         const CowOperation* cow_op = GetRAOpIter();
         CHECK_NE(cow_op, nullptr);
         *source_offset = GetCowOpSourceInfoData(*cow_op);
-        if (cow_op->type == kCowCopyOp) {
+        if (GetCowOpSourceInfoData(*cow_op) == kCowCopyOp) {
             *source_offset *= BLOCK_SZ;
         }
         RAIterNext();
@@ -211,7 +212,7 @@ void ReadAheadThread::PrepareReadAhead(uint64_t* source_offset, int* pending_ops
             const CowOperation* op = GetRAOpIter();
             CHECK_NE(op, nullptr);
             uint64_t next_offset = GetCowOpSourceInfoData(*op);
-            if (op->type == kCowCopyOp) {
+            if (GetCowOpSourceInfoData(*op) == kCowCopyOp) {
                 next_offset *= BLOCK_SZ;
             }
             if (next_offset + nr_consecutive * BLOCK_SZ != *source_offset) {
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
index 571b352385a0..0930a5d9ce40 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "libsnapshot/cow_format.h"
 #include "snapuserd.h"
 
 #include <csignal>
@@ -177,7 +178,7 @@ bool WorkerThread::ProcessCowOp(const CowOperation* cow_op) {
         return false;
     }
 
-    switch (cow_op->type) {
+    switch (GetCowOpSourceInfoType(*cow_op)) {
         case kCowReplaceOp: {
             return ProcessReplaceOp(cow_op);
         }
@@ -191,7 +192,8 @@ bool WorkerThread::ProcessCowOp(const CowOperation* cow_op) {
         }
 
         default: {
-            SNAP_LOG(ERROR) << "Unsupported operation-type found: " << cow_op->type;
+            SNAP_LOG(ERROR) << "Unsupported operation-type found: "
+                            << GetCowOpSourceInfoType(*cow_op);
         }
     }
     return false;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index 11b8d7c92f0e..d06ba588f328 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -17,6 +17,7 @@
 
 #include <pthread.h>
 
+#include "libsnapshot/cow_format.h"
 #include "snapuserd_core.h"
 #include "utility.h"
 
@@ -114,13 +115,13 @@ bool MergeWorker::MergeReplaceZeroOps() {
                 SNAP_LOG(ERROR) << "AcquireBuffer failed in MergeReplaceOps";
                 return false;
             }
-            if (cow_op->type == kCowReplaceOp) {
+            if (GetCowOpSourceInfoType(*cow_op) == kCowReplaceOp) {
                 if (!reader_->ReadData(cow_op, buffer, BLOCK_SZ)) {
                     SNAP_LOG(ERROR) << "Failed to read COW in merge";
                     return false;
                 }
             } else {
-                CHECK(cow_op->type == kCowZeroOp);
+                CHECK(GetCowOpSourceInfoType(*cow_op) == kCowZeroOp);
                 memset(buffer, 0, BLOCK_SZ);
             }
         }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index 5cb13e8bcd43..ffa23ead44c4 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -18,6 +18,7 @@
 
 #include <pthread.h>
 
+#include "libsnapshot/cow_format.h"
 #include "snapuserd_core.h"
 #include "utility.h"
 
@@ -63,7 +64,7 @@ bool ReadWorker::ReadFromSourceDevice(const CowOperation* cow_op, void* buffer)
                     << " Op: " << *cow_op;
     if (!android::base::ReadFullyAtOffset(backing_store_fd_, buffer, BLOCK_SZ, offset)) {
         std::string op;
-        if (cow_op->type == kCowCopyOp)
+        if (GetCowOpSourceInfoType(*cow_op) == kCowCopyOp)
             op = "Copy-op";
         else {
             op = "Xor-op";
@@ -133,7 +134,7 @@ bool ReadWorker::ProcessOrderedOp(const CowOperation* cow_op, void* buffer) {
         }
         case MERGE_GROUP_STATE::GROUP_MERGE_PENDING: {
             bool ret;
-            if (cow_op->type == kCowCopyOp) {
+            if (GetCowOpSourceInfoType(*cow_op) == kCowCopyOp) {
                 ret = ProcessCopyOp(cow_op, buffer);
             } else {
                 ret = ProcessXorOp(cow_op, buffer);
@@ -167,7 +168,7 @@ bool ReadWorker::ProcessCowOp(const CowOperation* cow_op, void* buffer) {
         return false;
     }
 
-    switch (cow_op->type) {
+    switch (GetCowOpSourceInfoType(*cow_op)) {
         case kCowReplaceOp: {
             return ProcessReplaceOp(cow_op, buffer);
         }
@@ -183,7 +184,7 @@ bool ReadWorker::ProcessCowOp(const CowOperation* cow_op, void* buffer) {
         }
 
         default: {
-            SNAP_LOG(ERROR) << "Unknown operation-type found: " << cow_op->type;
+            SNAP_LOG(ERROR) << "Unknown operation-type found: " << GetCowOpSourceInfoType(*cow_op);
         }
     }
     return false;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index e886ec399bee..536ff2f63990 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -24,6 +24,7 @@
 #include <android-base/strings.h>
 #include <snapuserd/dm_user_block_server.h>
 
+#include "libsnapshot/cow_format.h"
 #include "merge_worker.h"
 #include "read_worker.h"
 
@@ -196,13 +197,13 @@ bool SnapshotHandler::ReadMetadata() {
     while (!cowop_iter->AtEnd()) {
         const CowOperation* cow_op = cowop_iter->Get();
 
-        if (cow_op->type == kCowCopyOp) {
+        if (GetCowOpSourceInfoType(*cow_op) == kCowCopyOp) {
             copy_ops += 1;
-        } else if (cow_op->type == kCowReplaceOp) {
+        } else if (GetCowOpSourceInfoType(*cow_op) == kCowReplaceOp) {
             replace_ops += 1;
-        } else if (cow_op->type == kCowZeroOp) {
+        } else if (GetCowOpSourceInfoType(*cow_op) == kCowZeroOp) {
             zero_ops += 1;
-        } else if (cow_op->type == kCowXorOp) {
+        } else if (GetCowOpSourceInfoType(*cow_op) == kCowXorOp) {
             xor_ops += 1;
         }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index 998d233d5ad1..d7d43a6a0614 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -18,6 +18,7 @@
 
 #include <pthread.h>
 
+#include "libsnapshot/cow_format.h"
 #include "snapuserd_core.h"
 #include "utility.h"
 
@@ -77,7 +78,7 @@ int ReadAhead::PrepareNextReadAhead(uint64_t* source_offset, int* pending_ops,
         SNAP_LOG(ERROR) << "PrepareNextReadAhead operation has no source offset: " << *cow_op;
         return nr_consecutive;
     }
-    if (cow_op->type == kCowXorOp) {
+    if (GetCowOpSourceInfoType(*cow_op) == kCowXorOp) {
         xor_op_vec.push_back(cow_op);
     }
 
@@ -106,7 +107,7 @@ int ReadAhead::PrepareNextReadAhead(uint64_t* source_offset, int* pending_ops,
             break;
         }
 
-        if (op->type == kCowXorOp) {
+        if (GetCowOpSourceInfoType(*op) == kCowXorOp) {
             xor_op_vec.push_back(op);
         }
 

From 73b3428e1ca7473e10368d2b1164889fa113c3e6 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 10 Oct 2023 10:31:54 -0700
Subject: [PATCH 0453/1487] Rename BLOCK_SZ to block_size

BLOCK_SZ name to block_size as we should reserve all caps for compile
time constants

Test: th
Change-Id: I542632662e81b272ffec50d6b50c290d701b08e3
---
 .../libsnapshot/include/libsnapshot/cow_compress.h | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
index fd12b84fe7b1..8191d616e831 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
@@ -29,12 +29,14 @@ class ICompressor {
 
     virtual ~ICompressor() {}
     // Factory methods for compression methods.
-    static std::unique_ptr<ICompressor> Gz(uint32_t compression_level, const int32_t BLOCK_SZ);
-    static std::unique_ptr<ICompressor> Brotli(uint32_t compression_level, const int32_t BLOCK_SZ);
-    static std::unique_ptr<ICompressor> Lz4(uint32_t compression_level, const int32_t BLOCK_SZ);
-    static std::unique_ptr<ICompressor> Zstd(uint32_t compression_level, const int32_t BLOCK_SZ);
-
-    static std::unique_ptr<ICompressor> Create(CowCompression compression, const int32_t BLOCK_SZ);
+    static std::unique_ptr<ICompressor> Gz(uint32_t compression_level, const int32_t block_size);
+    static std::unique_ptr<ICompressor> Brotli(uint32_t compression_level,
+                                               const int32_t block_size);
+    static std::unique_ptr<ICompressor> Lz4(uint32_t compression_level, const int32_t block_size);
+    static std::unique_ptr<ICompressor> Zstd(uint32_t compression_level, const int32_t block_size);
+
+    static std::unique_ptr<ICompressor> Create(CowCompression compression,
+                                               const int32_t block_size);
 
     uint32_t GetCompressionLevel() const { return compression_level_; }
     uint32_t GetBlockSize() const { return block_size_; }

From ed1a7d5fafd98049777c2c26349984ae31563a86 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 12 Sep 2023 14:37:44 -0700
Subject: [PATCH 0454/1487] Add v3 Cow Header

Adding Version 3 of CowHeader. This will inherit from original
CowHeader and add a compression field. We are no longer supporting
different compressions per operation so having this one field is enough.

Test: cow_api_test
Change-Id: If88dceda139807cc5e647b706ddeb2b3e83c024f
---
 fs_mgr/libsnapshot/include/libsnapshot/cow_format.h | 12 ++++++++++++
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp    |  4 ++--
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index bfa8f6bea4bb..b271dad6ce2f 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -91,6 +91,18 @@ struct CowHeader {
 
     // Scratch space used during merge
     uint32_t buffer_size;
+
+} __attribute__((packed));
+
+struct CowHeaderV3 : public CowHeader {
+    // Location of sequence buffer in COW.
+    uint64_t sequence_buffer_offset;
+    // Size, in bytes, of the CowResumePoint buffer.
+    uint32_t resume_buffer_size;
+    // Size, in bytes, of the CowOperation buffer.
+    uint32_t op_buffer_size;
+    // Compression Algorithm
+    uint32_t compression_algorithm;
 } __attribute__((packed));
 
 // This structure is the same size of a normal Operation, but is repurposed for the footer.
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index e51dbde6340c..a6f449faac5e 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -243,7 +243,7 @@ bool CowWriterV2::OpenForWrite() {
 
     // Headers are not complete, but this ensures the file is at the right
     // position.
-    if (!android::base::WriteFully(fd_, &header_, sizeof(header_))) {
+    if (!android::base::WriteFully(fd_, &header_, sizeof(CowHeader))) {
         PLOG(ERROR) << "write failed";
         return false;
     }
@@ -262,7 +262,7 @@ bool CowWriterV2::OpenForWrite() {
         return false;
     }
 
-    if (lseek(fd_.get(), sizeof(header_) + header_.buffer_size, SEEK_SET) < 0) {
+    if (lseek(fd_.get(), sizeof(CowHeader) + header_.buffer_size, SEEK_SET) < 0) {
         PLOG(ERROR) << "lseek failed";
         return false;
     }

From bb45742ba141ad149c3960854ff32074390a9f5a Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 10 Oct 2023 13:19:56 -0700
Subject: [PATCH 0455/1487] Move Cow Header child writer

v2 writer and v3 writer will write different versions of the header.
It's better to have each writer hold it's own header.

Test: th
Change-Id: Ibe310d58b830950ad556aabcd0c1009483fc8d86
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h | 1 -
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h   | 1 +
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
index cdf62226866f..709b248e6f35 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
@@ -63,7 +63,6 @@ class CowWriterBase : public ICowWriter {
     bool ValidateNewBlock(uint64_t new_block);
 
     CowOptions options_;
-    CowHeader header_{};
 
     android::base::unique_fd fd_;
     bool is_dev_null_ = false;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
index ce97b0182fd0..24170ebbdc33 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
@@ -63,6 +63,7 @@ class CowWriterV2 : public CowWriterBase {
 
   private:
     CowFooter footer_{};
+    CowHeader header_{};
     CowCompression compression_;
     // in the case that we are using one thread for compression, we can store and re-use the same
     // compressor

From 942a31e7be9d6584cb46badf502fe098fd76bc58 Mon Sep 17 00:00:00 2001
From: Edward Liaw <edliaw@google.com>
Date: Tue, 10 Oct 2023 21:30:19 +0000
Subject: [PATCH 0456/1487] libdm_test: Add to kernel-presubmit

Bug: 284307085
Test: atest :kernel-presubmit
Change-Id: I13ae25f17c943825bdf5ee67c00b7d297cf6e319
Signed-off-by: Edward Liaw <edliaw@google.com>
---
 fs_mgr/TEST_MAPPING | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index 37b4988dcee2..a0fe4fd53902 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -36,7 +36,7 @@
   ],
   "kernel-presubmit": [
     {
-      "name": "vts_libdm_test"
+      "name": "libdm_test"
     },
     {
       "name": "vts_core_liblp_test"

From eafffc0c9c6d8f9dced5fcf58c631e98ce46dd14 Mon Sep 17 00:00:00 2001
From: Edward Liaw <edliaw@google.com>
Date: Tue, 10 Oct 2023 21:41:36 +0000
Subject: [PATCH 0457/1487] liblp_test: Add to kernel-presubmit

Bug: 284307085
Test: atest :kernel-presubmit
Change-Id: I2a138cf55a2af07b5c231f163196266f8b3dd524
Signed-off-by: Edward Liaw <edliaw@google.com>
---
 fs_mgr/TEST_MAPPING | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index 37b4988dcee2..2a2f1728d39c 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -39,7 +39,7 @@
       "name": "vts_libdm_test"
     },
     {
-      "name": "vts_core_liblp_test"
+      "name": "liblp_test"
     },
     {
       "name": "vts_libsnapshot_test"

From 1a3dd7eb4b8cd9b0a8c534aa872f90a7fee253a0 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Wed, 11 Oct 2023 02:06:26 +0000
Subject: [PATCH 0458/1487] Revert "init_first_stage: Disable ThinLTO"

This reverts commit 4d6fa8ccaf37f5ba5b501036cd187a184f119438.

Reason for revert: b/295944813 is fixed

Bug: 304290959
Change-Id: I2d6f5216800d6ee26b25623898836dc216c8be18
Test: adb-remount-test.sh
---
 init/Android.bp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index 0b8c7dc0971d..1af398a9a0ae 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -394,10 +394,6 @@ init_first_stage_cc_defaults {
     ],
 
     static_executable: true,
-    lto: {
-        // b/169004486 ThinLTO breaks x86 static executables.
-        never: true,
-    },
     system_shared_libs: [],
 
     cflags: [

From cb33fb400846a5aa99c03f6dd96b891a75a073a8 Mon Sep 17 00:00:00 2001
From: Nolen Johnson <johnsonnolen@gmail.com>
Date: Thu, 6 Jan 2022 16:59:08 -0500
Subject: [PATCH 0459/1487] fs_mgr: Don't run clean_scratch_files on
 non-dynamic devices

* This results in a metric ton of denials on some devices and
  eats up valuable resources on boot, plus there's 0 need for it,
  so kill it.

Change-Id: Ic52d5b3f06724430e9505345024cf0041b37ca49
---
 fs_mgr/clean_scratch_files.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/clean_scratch_files.rc b/fs_mgr/clean_scratch_files.rc
index 25a7e690ac05..71708f8c1dff 100644
--- a/fs_mgr/clean_scratch_files.rc
+++ b/fs_mgr/clean_scratch_files.rc
@@ -1,2 +1,2 @@
-on post-fs-data && property:ro.debuggable=1
+on post-fs-data && property:ro.debuggable=1 && property:ro.boot.dynamic_partitions=true
     exec_background - root root -- /system/bin/clean_scratch_files

From b6153adde108acb648ddb863e5802c9514694f27 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Wed, 11 Oct 2023 19:44:38 +0000
Subject: [PATCH 0460/1487] Revert "Shove type into source_info"

This reverts commit e90a39aee237cd619d0c20d9878df108031f29d7.

Reason for revert: 304602386

Change-Id: Ib9d31bdadc7511e67f4c7e5731d18e7bf0162bfc
---
 .../include/libsnapshot/cow_format.h          | 25 ++---
 .../libsnapshot_cow/cow_format.cpp            | 17 ++--
 .../libsnapshot_cow/cow_reader.cpp            | 15 ++-
 .../libsnapshot_cow/inspect_cow.cpp           | 16 ++--
 .../libsnapshot_cow/snapshot_reader.cpp       | 11 +--
 .../libsnapshot/libsnapshot_cow/test_v2.cpp   | 95 +++++++++----------
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   |  9 --
 .../snapuserd/dm-snapshot-merge/snapuserd.cpp |  7 +-
 .../dm-snapshot-merge/snapuserd_readahead.cpp |  5 +-
 .../dm-snapshot-merge/snapuserd_worker.cpp    |  6 +-
 .../user-space-merge/merge_worker.cpp         |  5 +-
 .../user-space-merge/read_worker.cpp          |  9 +-
 .../user-space-merge/snapuserd_core.cpp       |  9 +-
 .../user-space-merge/snapuserd_readahead.cpp  |  5 +-
 14 files changed, 99 insertions(+), 135 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index bfa8f6bea4bb..2beeb9f62a35 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -149,6 +149,9 @@ struct CowOperationV2 {
 
 // The on disk format of cow (currently ==  CowOperation)
 struct CowOperationV3 {
+    // The operation code (see the constants and structures below).
+    uint8_t type;
+
     // If this operation reads from the data section of the COW, this contains
     // the length.
     uint16_t data_length;
@@ -156,10 +159,6 @@ struct CowOperationV3 {
     // The block of data in the new image that this operation modifies.
     uint32_t new_block;
 
-    // source_info with have the following layout
-    // |---4 bits ---| ---12 bits---| --- 48 bits ---|
-    // |--- type --- | -- unused -- | --- source --- |
-    //
     // The value of |source| depends on the operation code.
     //
     // CopyOp: a 32-bit block location in the source image.
@@ -168,6 +167,8 @@ struct CowOperationV3 {
     // ZeroOp: unused
     // LabelOp: a 64-bit opaque identifier.
     //
+    // For ops other than Label:
+    //  Bits 47-62 are reserved and must be zero.
     // A block is compressed if it’s data is < block_sz
     uint64_t source_info;
 } __attribute__((packed));
@@ -199,21 +200,9 @@ static constexpr uint8_t kCowReadAheadNotStarted = 0;
 static constexpr uint8_t kCowReadAheadInProgress = 1;
 static constexpr uint8_t kCowReadAheadDone = 2;
 
-// this is a mask to grab the last 48 bits of a 64 bit integer
-static constexpr uint64_t kCowOpSourceInfoDataMask = (0x1ULL << 48) - 1;
-// this is a mask to grab the first 4 bits of a 64 bit integer
-static constexpr uint64_t kCowOpSourceInfoTypeBit = 60;
-static constexpr uint64_t kCowOpSourceInfoTypeNumBits = 4;
-static constexpr uint64_t kCowOpSourceInfoTypeMask = (1 << kCowOpSourceInfoTypeNumBits) - 1;
-
-static constexpr void SetCowOpSourceInfoType(CowOperation* op, const uint8_t type) {
-    op->source_info |= uint64_t(type) << kCowOpSourceInfoTypeBit;
-}
-static constexpr uint64_t GetCowOpSourceInfoType(const CowOperation& op) {
-    return (op.source_info >> kCowOpSourceInfoTypeBit) & kCowOpSourceInfoTypeMask;
-}
+static constexpr uint64_t kCowOpSourceInfoDataMask = (1ULL << 48) - 1;
 
-static constexpr uint64_t GetCowOpSourceInfoData(const CowOperation& op) {
+static inline uint64_t GetCowOpSourceInfoData(const CowOperation& op) {
     return op.source_info & kCowOpSourceInfoDataMask;
 }
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
index 1be592d21c65..5ab4f7a52226 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
@@ -81,19 +81,16 @@ std::ostream& operator<<(std::ostream& os, CowOperationV2 const& op) {
 
 std::ostream& operator<<(std::ostream& os, CowOperation const& op) {
     os << "CowOperation(";
-    EmitCowTypeString(os, GetCowOpSourceInfoType(op));
-    if (GetCowOpSourceInfoType(op) == kCowReplaceOp || GetCowOpSourceInfoType(op) == kCowXorOp ||
-        GetCowOpSourceInfoType(op) == kCowSequenceOp) {
+    EmitCowTypeString(os, op.type);
+    if (op.type == kCowReplaceOp || op.type == kCowXorOp || op.type == kCowSequenceOp) {
         os << ", data_length:" << op.data_length;
     }
-    if (GetCowOpSourceInfoType(op) != kCowClusterOp &&
-        GetCowOpSourceInfoType(op) != kCowSequenceOp && GetCowOpSourceInfoType(op) != kCowLabelOp) {
+    if (op.type != kCowClusterOp && op.type != kCowSequenceOp && op.type != kCowLabelOp) {
         os << ", new_block:" << op.new_block;
     }
-    if (GetCowOpSourceInfoType(op) == kCowXorOp || GetCowOpSourceInfoType(op) == kCowReplaceOp ||
-        GetCowOpSourceInfoType(op) == kCowCopyOp) {
+    if (op.type == kCowXorOp || op.type == kCowReplaceOp || op.type == kCowCopyOp) {
         os << ", source:" << (op.source_info & kCowOpSourceInfoDataMask);
-    } else if (GetCowOpSourceInfoType(op) == kCowClusterOp) {
+    } else if (op.type == kCowClusterOp) {
         os << ", cluster_data:" << (op.source_info & kCowOpSourceInfoDataMask);
     } else {
         os << ", label:0x" << android::base::StringPrintf("%" PRIx64, op.source_info);
@@ -123,7 +120,7 @@ int64_t GetNextDataOffset(const CowOperationV2& op, uint32_t cluster_ops) {
 }
 
 bool IsMetadataOp(const CowOperation& op) {
-    switch (GetCowOpSourceInfoType(op)) {
+    switch (op.type) {
         case kCowLabelOp:
         case kCowClusterOp:
         case kCowFooterOp:
@@ -135,7 +132,7 @@ bool IsMetadataOp(const CowOperation& op) {
 }
 
 bool IsOrderedOp(const CowOperation& op) {
-    switch (GetCowOpSourceInfoType(op)) {
+    switch (op.type) {
         case kCowCopyOp:
         case kCowXorOp:
             return true;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index c52705ca898c..85fd4c37bcad 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -24,7 +24,6 @@
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
-#include <libsnapshot/cow_format.h>
 #include <libsnapshot/cow_reader.h>
 #include <zlib.h>
 
@@ -111,7 +110,7 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
         const auto& v2_op = parser.ops()->at(i);
 
         auto& new_op = ops_->at(i);
-        SetCowOpSourceInfoType(&new_op, v2_op.type);
+        new_op.type = v2_op.type;
         new_op.data_length = v2_op.data_length;
 
         if (v2_op.new_block > std::numeric_limits<uint32_t>::max()) {
@@ -121,7 +120,7 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
         new_op.new_block = v2_op.new_block;
 
         uint64_t source_info = v2_op.source;
-        if (GetCowOpSourceInfoType(new_op) != kCowLabelOp) {
+        if (new_op.type != kCowLabelOp) {
             source_info &= kCowOpSourceInfoDataMask;
             if (source_info != v2_op.source) {
                 LOG(ERROR) << "Out-of-range source value in COW op: " << v2_op;
@@ -138,7 +137,7 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
                 return false;
             }
         }
-        new_op.source_info |= source_info;
+        new_op.source_info = source_info;
     }
 
     // If we're resuming a write, we're not ready to merge
@@ -261,7 +260,7 @@ bool CowReader::PrepMergeOps() {
     for (size_t i = 0; i < ops_->size(); i++) {
         auto& current_op = ops_->data()[i];
 
-        if (GetCowOpSourceInfoType(current_op) == kCowSequenceOp) {
+        if (current_op.type == kCowSequenceOp) {
             size_t seq_len = current_op.data_length / sizeof(uint32_t);
 
             merge_op_blocks->resize(merge_op_blocks->size() + seq_len);
@@ -573,7 +572,7 @@ std::unique_ptr<ICowOpIter> CowReader::GetMergeOpIter(bool ignore_progress) {
 }
 
 bool CowReader::GetRawBytes(const CowOperation* op, void* buffer, size_t len, size_t* read) {
-    switch (GetCowOpSourceInfoType(*op)) {
+    switch (op->type) {
         case kCowSequenceOp:
         case kCowReplaceOp:
         case kCowXorOp:
@@ -666,7 +665,7 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
     }
 
     uint64_t offset;
-    if (GetCowOpSourceInfoType(*op) == kCowXorOp) {
+    if (op->type == kCowXorOp) {
         offset = data_loc_->at(op->new_block);
     } else {
         offset = GetCowOpSourceInfoData(*op);
@@ -683,7 +682,7 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
 }
 
 bool CowReader::GetSourceOffset(const CowOperation* op, uint64_t* source_offset) {
-    switch (GetCowOpSourceInfoType(*op)) {
+    switch (op->type) {
         case kCowCopyOp:
             *source_offset = GetCowOpSourceInfoData(*op) * header_.block_size;
             return true;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
index aaaf20c2f69e..83b5a12955a7 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
@@ -26,7 +26,6 @@
 #include <android-base/logging.h>
 #include <android-base/unique_fd.h>
 #include <gflags/gflags.h>
-#include <libsnapshot/cow_format.h>
 #include <libsnapshot/cow_reader.h>
 #include "parser_v2.h"
 
@@ -199,7 +198,7 @@ static bool Inspect(const std::string& path) {
 
         if (!FLAGS_silent && FLAGS_show_ops) std::cout << *op << "\n";
 
-        if ((FLAGS_decompress || extract_to >= 0) && GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
+        if ((FLAGS_decompress || extract_to >= 0) && op->type == kCowReplaceOp) {
             if (reader.ReadData(op, buffer.data(), buffer.size()) < 0) {
                 std::cerr << "Failed to decompress for :" << *op << "\n";
                 success = false;
@@ -213,13 +212,12 @@ static bool Inspect(const std::string& path) {
                     return false;
                 }
             }
-        } else if (extract_to >= 0 && !IsMetadataOp(*op) &&
-                   GetCowOpSourceInfoType(*op) != kCowZeroOp) {
+        } else if (extract_to >= 0 && !IsMetadataOp(*op) && op->type != kCowZeroOp) {
             PLOG(ERROR) << "Cannot extract op yet: " << *op;
             return false;
         }
 
-        if (GetCowOpSourceInfoType(*op) == kCowSequenceOp && FLAGS_show_merge_sequence) {
+        if (op->type == kCowSequenceOp && FLAGS_show_merge_sequence) {
             size_t read;
             std::vector<uint32_t> merge_op_blocks;
             size_t seq_len = op->data_length / sizeof(uint32_t);
@@ -237,13 +235,13 @@ static bool Inspect(const std::string& path) {
             }
         }
 
-        if (GetCowOpSourceInfoType(*op) == kCowCopyOp) {
+        if (op->type == kCowCopyOp) {
             copy_ops++;
-        } else if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
+        } else if (op->type == kCowReplaceOp) {
             replace_ops++;
-        } else if (GetCowOpSourceInfoType(*op) == kCowZeroOp) {
+        } else if (op->type == kCowZeroOp) {
             zero_ops++;
-        } else if (GetCowOpSourceInfoType(*op) == kCowXorOp) {
+        } else if (op->type == kCowXorOp) {
             xor_ops++;
         }
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
index d7ee432f4502..a3e40d962ce7 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
@@ -147,7 +147,7 @@ ssize_t CompressedSnapshotReader::ReadBlock(uint64_t chunk, size_t start_offset,
         op = ops_[chunk];
     }
 
-    if (!op || GetCowOpSourceInfoType(*op) == kCowCopyOp) {
+    if (!op || op->type == kCowCopyOp) {
         borrowed_fd fd = GetSourceFd();
         if (fd < 0) {
             // GetSourceFd sets errno.
@@ -169,15 +169,15 @@ ssize_t CompressedSnapshotReader::ReadBlock(uint64_t chunk, size_t start_offset,
             // ReadFullyAtOffset sets errno.
             return -1;
         }
-    } else if (GetCowOpSourceInfoType(*op) == kCowZeroOp) {
+    } else if (op->type == kCowZeroOp) {
         memset(buffer, 0, bytes_to_read);
-    } else if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
+    } else if (op->type == kCowReplaceOp) {
         if (cow_->ReadData(op, buffer, bytes_to_read, start_offset) < bytes_to_read) {
             LOG(ERROR) << "CompressedSnapshotReader failed to read replace op";
             errno = EIO;
             return -1;
         }
-    } else if (GetCowOpSourceInfoType(*op) == kCowXorOp) {
+    } else if (op->type == kCowXorOp) {
         borrowed_fd fd = GetSourceFd();
         if (fd < 0) {
             // GetSourceFd sets errno.
@@ -208,8 +208,7 @@ ssize_t CompressedSnapshotReader::ReadBlock(uint64_t chunk, size_t start_offset,
             ((char*)buffer)[i] ^= data[i];
         }
     } else {
-        LOG(ERROR) << "CompressedSnapshotReader unknown op type: "
-                   << uint32_t(GetCowOpSourceInfoType(*op));
+        LOG(ERROR) << "CompressedSnapshotReader unknown op type: " << uint32_t(op->type);
         errno = EINVAL;
         return -1;
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index d9628758e5cb..35d74bac0502 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -25,7 +25,6 @@
 #include <libsnapshot/cow_reader.h>
 #include <libsnapshot/cow_writer.h>
 #include "cow_decompress.h"
-#include "libsnapshot/cow_format.h"
 #include "writer_v2.h"
 
 using android::base::unique_fd;
@@ -86,7 +85,7 @@ TEST_F(CowTest, CopyContiguous) {
     size_t i = 0;
     while (!iter->AtEnd()) {
         auto op = iter->Get();
-        ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowCopyOp);
+        ASSERT_EQ(op->type, kCowCopyOp);
         ASSERT_EQ(op->data_length, 0);
         ASSERT_EQ(op->new_block, 10 + i);
         ASSERT_EQ(GetCowOpSourceInfoData(*op), 1000 + i);
@@ -132,7 +131,7 @@ TEST_F(CowTest, ReadWrite) {
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
 
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowCopyOp);
+    ASSERT_EQ(op->type, kCowCopyOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 10);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 20);
@@ -143,7 +142,7 @@ TEST_F(CowTest, ReadWrite) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
+    ASSERT_EQ(op->type, kCowReplaceOp);
     ASSERT_EQ(op->data_length, 4096);
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -154,7 +153,7 @@ TEST_F(CowTest, ReadWrite) {
     op = iter->Get();
 
     // Note: the zero operation gets split into two blocks.
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
+    ASSERT_EQ(op->type, kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 51);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
@@ -163,7 +162,7 @@ TEST_F(CowTest, ReadWrite) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
+    ASSERT_EQ(op->type, kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 52);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
@@ -207,7 +206,7 @@ TEST_F(CowTest, ReadWriteXor) {
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
 
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowCopyOp);
+    ASSERT_EQ(op->type, kCowCopyOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 10);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 20);
@@ -218,7 +217,7 @@ TEST_F(CowTest, ReadWriteXor) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowXorOp);
+    ASSERT_EQ(op->type, kCowXorOp);
     ASSERT_EQ(op->data_length, 4096);
     ASSERT_EQ(op->new_block, 50);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 98314);  // 4096 * 24 + 10
@@ -230,7 +229,7 @@ TEST_F(CowTest, ReadWriteXor) {
     op = iter->Get();
 
     // Note: the zero operation gets split into two blocks.
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
+    ASSERT_EQ(op->type, kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 51);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
@@ -239,7 +238,7 @@ TEST_F(CowTest, ReadWriteXor) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
+    ASSERT_EQ(op->type, kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 52);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
@@ -274,7 +273,7 @@ TEST_F(CowTest, CompressGz) {
 
     std::string sink(data.size(), '\0');
 
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
+    ASSERT_EQ(op->type, kCowReplaceOp);
     ASSERT_EQ(op->data_length, 56);  // compressed!
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -326,7 +325,7 @@ TEST_P(CompressionTest, ThreadedBatchWrites) {
     while (!iter->AtEnd()) {
         auto op = iter->Get();
 
-        if (GetCowOpSourceInfoType(*op) == kCowXorOp) {
+        if (op->type == kCowXorOp) {
             total_blocks += 1;
             std::string sink(xor_data.size(), '\0');
             ASSERT_EQ(op->new_block, 50);
@@ -335,7 +334,7 @@ TEST_P(CompressionTest, ThreadedBatchWrites) {
             ASSERT_EQ(sink, xor_data);
         }
 
-        if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
+        if (op->type == kCowReplaceOp) {
             total_blocks += 1;
             if (op->new_block == 100) {
                 data.resize(options.block_size);
@@ -400,7 +399,7 @@ TEST_P(CompressionTest, NoBatchWrites) {
     while (!iter->AtEnd()) {
         auto op = iter->Get();
 
-        if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
+        if (op->type == kCowReplaceOp) {
             total_blocks += 1;
             if (op->new_block == 50) {
                 data.resize(options.block_size);
@@ -520,7 +519,7 @@ TEST_F(CowTest, ClusterCompressGz) {
 
     std::string sink(data.size(), '\0');
 
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
+    ASSERT_EQ(op->type, kCowReplaceOp);
     ASSERT_EQ(op->data_length, 56);  // compressed!
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -530,7 +529,7 @@ TEST_F(CowTest, ClusterCompressGz) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowClusterOp);
+    ASSERT_EQ(op->type, kCowClusterOp);
 
     iter->Next();
     ASSERT_FALSE(iter->AtEnd());
@@ -547,7 +546,7 @@ TEST_F(CowTest, ClusterCompressGz) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowClusterOp);
+    ASSERT_EQ(op->type, kCowClusterOp);
 
     iter->Next();
     ASSERT_TRUE(iter->AtEnd());
@@ -581,7 +580,7 @@ TEST_F(CowTest, CompressTwoBlocks) {
     std::string sink(options.block_size, '\0');
 
     auto op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
+    ASSERT_EQ(op->type, kCowReplaceOp);
     ASSERT_EQ(op->new_block, 51);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
 }
@@ -654,7 +653,7 @@ TEST_F(CowTest, AppendLabelSmall) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
+    ASSERT_EQ(op->type, kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data);
 
@@ -664,14 +663,14 @@ TEST_F(CowTest, AppendLabelSmall) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
+    ASSERT_EQ(op->type, kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 3);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
+    ASSERT_EQ(op->type, kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data2);
 
@@ -717,14 +716,14 @@ TEST_F(CowTest, AppendLabelMissing) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
+    ASSERT_EQ(op->type, kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
+    ASSERT_EQ(op->type, kCowZeroOp);
 
     iter->Next();
 
@@ -775,7 +774,7 @@ TEST_F(CowTest, AppendExtendedCorrupted) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
+    ASSERT_EQ(op->type, kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 5);
 
     iter->Next();
@@ -826,7 +825,7 @@ TEST_F(CowTest, AppendbyLabel) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
+    ASSERT_EQ(op->type, kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data.substr(0, options.block_size));
 
@@ -836,7 +835,7 @@ TEST_F(CowTest, AppendbyLabel) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
+    ASSERT_EQ(op->type, kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data.substr(options.block_size, 2 * options.block_size));
 
@@ -844,25 +843,25 @@ TEST_F(CowTest, AppendbyLabel) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
+    ASSERT_EQ(op->type, kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 4);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
+    ASSERT_EQ(op->type, kCowZeroOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
+    ASSERT_EQ(op->type, kCowZeroOp);
 
     iter->Next();
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
+    ASSERT_EQ(op->type, kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 5);
 
     iter->Next();
@@ -907,7 +906,7 @@ TEST_F(CowTest, ClusterTest) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
+    ASSERT_EQ(op->type, kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data.substr(0, options.block_size));
 
@@ -915,51 +914,51 @@ TEST_F(CowTest, ClusterTest) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
+    ASSERT_EQ(op->type, kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 4);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
+    ASSERT_EQ(op->type, kCowZeroOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowClusterOp);
+    ASSERT_EQ(op->type, kCowClusterOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowZeroOp);
+    ASSERT_EQ(op->type, kCowZeroOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
+    ASSERT_EQ(op->type, kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 5);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowCopyOp);
+    ASSERT_EQ(op->type, kCowCopyOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowClusterOp);
+    ASSERT_EQ(op->type, kCowClusterOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
+    ASSERT_EQ(op->type, kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 6);
 
     iter->Next();
@@ -1006,14 +1005,14 @@ TEST_F(CowTest, ClusterAppendTest) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowLabelOp);
+    ASSERT_EQ(op->type, kCowLabelOp);
     ASSERT_EQ(GetCowOpSourceInfoData(*op), 50);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowReplaceOp);
+    ASSERT_EQ(op->type, kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data2);
 
@@ -1021,7 +1020,7 @@ TEST_F(CowTest, ClusterAppendTest) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(GetCowOpSourceInfoType(*op), kCowClusterOp);
+    ASSERT_EQ(op->type, kCowClusterOp);
 
     iter->Next();
 
@@ -1118,12 +1117,12 @@ TEST_F(CowTest, ResumeMidCluster) {
         num_in_cluster++;
         max_in_cluster = std::max(max_in_cluster, num_in_cluster);
 
-        if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
+        if (op->type == kCowReplaceOp) {
             num_replace++;
 
             ASSERT_EQ(op->new_block, num_replace);
             ASSERT_TRUE(CompareDataBlock(&reader, op, "Block " + std::to_string(num_replace)));
-        } else if (GetCowOpSourceInfoType(*op) == kCowClusterOp) {
+        } else if (op->type == kCowClusterOp) {
             num_in_cluster = 0;
             num_clusters++;
         }
@@ -1179,12 +1178,12 @@ TEST_F(CowTest, ResumeEndCluster) {
         num_in_cluster++;
         max_in_cluster = std::max(max_in_cluster, num_in_cluster);
 
-        if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
+        if (op->type == kCowReplaceOp) {
             num_replace++;
 
             ASSERT_EQ(op->new_block, num_replace);
             ASSERT_TRUE(CompareDataBlock(&reader, op, "Block " + std::to_string(num_replace)));
-        } else if (GetCowOpSourceInfoType(*op) == kCowClusterOp) {
+        } else if (op->type == kCowClusterOp) {
             num_in_cluster = 0;
             num_clusters++;
         }
@@ -1230,12 +1229,12 @@ TEST_F(CowTest, DeleteMidCluster) {
 
         num_in_cluster++;
         max_in_cluster = std::max(max_in_cluster, num_in_cluster);
-        if (GetCowOpSourceInfoType(*op) == kCowReplaceOp) {
+        if (op->type == kCowReplaceOp) {
             num_replace++;
 
             ASSERT_EQ(op->new_block, num_replace);
             ASSERT_TRUE(CompareDataBlock(&reader, op, "Block " + std::to_string(num_replace)));
-        } else if (GetCowOpSourceInfoType(*op) == kCowClusterOp) {
+        } else if (op->type == kCowClusterOp) {
             num_in_cluster = 0;
             num_clusters++;
         }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index a4d617f26d0b..2373d4df5bf3 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -49,14 +49,5 @@ class CowOperationV3Test : public ::testing::Test {
     std::unique_ptr<TemporaryFile> cow_;
 };
 
-TEST_F(CowOperationV3Test, CowTypeTest) {
-    CowOperationV3 new_op;
-    CowOperationV2 old_op;
-    old_op.type = kCowReplaceOp;
-    ASSERT_NE(GetCowOpSourceInfoType(new_op), old_op.type);
-    SetCowOpSourceInfoType(&new_op, old_op.type);
-    ASSERT_EQ(GetCowOpSourceInfoType(new_op), old_op.type);
-}
-
 }  // namespace snapshot
 }  // namespace android
\ No newline at end of file
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
index 0be6ff518414..6dc082e86ffa 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
@@ -25,7 +25,6 @@
 #include <csignal>
 #include <optional>
 #include <set>
-#include "libsnapshot/cow_format.h"
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
@@ -407,9 +406,9 @@ bool Snapuserd::ReadMetadata() {
             break;
         }
 
-        if (GetCowOpSourceInfoType(*cow_op) == kCowReplaceOp) {
+        if (cow_op->type == kCowReplaceOp) {
             replace_ops++;
-        } else if (GetCowOpSourceInfoType(*cow_op) == kCowZeroOp) {
+        } else if (cow_op->type == kCowZeroOp) {
             zero_ops++;
         }
 
@@ -541,7 +540,7 @@ bool Snapuserd::ReadMetadata() {
             chunk_vec_.push_back(std::make_pair(ChunkToSector(data_chunk_id), cow_op));
             offset += sizeof(struct disk_exception);
             num_ops += 1;
-            if (GetCowOpSourceInfoType(*cow_op) == kCowCopyOp) {
+            if (cow_op->type == kCowCopyOp) {
                 copy_ops++;
             }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
index b2a4f2c8fcfe..ab0b3094b5fd 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#include "libsnapshot/cow_format.h"
 #include "snapuserd.h"
 
 #include <csignal>
@@ -193,7 +192,7 @@ void ReadAheadThread::PrepareReadAhead(uint64_t* source_offset, int* pending_ops
         const CowOperation* cow_op = GetRAOpIter();
         CHECK_NE(cow_op, nullptr);
         *source_offset = GetCowOpSourceInfoData(*cow_op);
-        if (GetCowOpSourceInfoData(*cow_op) == kCowCopyOp) {
+        if (cow_op->type == kCowCopyOp) {
             *source_offset *= BLOCK_SZ;
         }
         RAIterNext();
@@ -212,7 +211,7 @@ void ReadAheadThread::PrepareReadAhead(uint64_t* source_offset, int* pending_ops
             const CowOperation* op = GetRAOpIter();
             CHECK_NE(op, nullptr);
             uint64_t next_offset = GetCowOpSourceInfoData(*op);
-            if (GetCowOpSourceInfoData(*op) == kCowCopyOp) {
+            if (op->type == kCowCopyOp) {
                 next_offset *= BLOCK_SZ;
             }
             if (next_offset + nr_consecutive * BLOCK_SZ != *source_offset) {
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
index 0930a5d9ce40..571b352385a0 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#include "libsnapshot/cow_format.h"
 #include "snapuserd.h"
 
 #include <csignal>
@@ -178,7 +177,7 @@ bool WorkerThread::ProcessCowOp(const CowOperation* cow_op) {
         return false;
     }
 
-    switch (GetCowOpSourceInfoType(*cow_op)) {
+    switch (cow_op->type) {
         case kCowReplaceOp: {
             return ProcessReplaceOp(cow_op);
         }
@@ -192,8 +191,7 @@ bool WorkerThread::ProcessCowOp(const CowOperation* cow_op) {
         }
 
         default: {
-            SNAP_LOG(ERROR) << "Unsupported operation-type found: "
-                            << GetCowOpSourceInfoType(*cow_op);
+            SNAP_LOG(ERROR) << "Unsupported operation-type found: " << cow_op->type;
         }
     }
     return false;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index d06ba588f328..11b8d7c92f0e 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -17,7 +17,6 @@
 
 #include <pthread.h>
 
-#include "libsnapshot/cow_format.h"
 #include "snapuserd_core.h"
 #include "utility.h"
 
@@ -115,13 +114,13 @@ bool MergeWorker::MergeReplaceZeroOps() {
                 SNAP_LOG(ERROR) << "AcquireBuffer failed in MergeReplaceOps";
                 return false;
             }
-            if (GetCowOpSourceInfoType(*cow_op) == kCowReplaceOp) {
+            if (cow_op->type == kCowReplaceOp) {
                 if (!reader_->ReadData(cow_op, buffer, BLOCK_SZ)) {
                     SNAP_LOG(ERROR) << "Failed to read COW in merge";
                     return false;
                 }
             } else {
-                CHECK(GetCowOpSourceInfoType(*cow_op) == kCowZeroOp);
+                CHECK(cow_op->type == kCowZeroOp);
                 memset(buffer, 0, BLOCK_SZ);
             }
         }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index ffa23ead44c4..5cb13e8bcd43 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -18,7 +18,6 @@
 
 #include <pthread.h>
 
-#include "libsnapshot/cow_format.h"
 #include "snapuserd_core.h"
 #include "utility.h"
 
@@ -64,7 +63,7 @@ bool ReadWorker::ReadFromSourceDevice(const CowOperation* cow_op, void* buffer)
                     << " Op: " << *cow_op;
     if (!android::base::ReadFullyAtOffset(backing_store_fd_, buffer, BLOCK_SZ, offset)) {
         std::string op;
-        if (GetCowOpSourceInfoType(*cow_op) == kCowCopyOp)
+        if (cow_op->type == kCowCopyOp)
             op = "Copy-op";
         else {
             op = "Xor-op";
@@ -134,7 +133,7 @@ bool ReadWorker::ProcessOrderedOp(const CowOperation* cow_op, void* buffer) {
         }
         case MERGE_GROUP_STATE::GROUP_MERGE_PENDING: {
             bool ret;
-            if (GetCowOpSourceInfoType(*cow_op) == kCowCopyOp) {
+            if (cow_op->type == kCowCopyOp) {
                 ret = ProcessCopyOp(cow_op, buffer);
             } else {
                 ret = ProcessXorOp(cow_op, buffer);
@@ -168,7 +167,7 @@ bool ReadWorker::ProcessCowOp(const CowOperation* cow_op, void* buffer) {
         return false;
     }
 
-    switch (GetCowOpSourceInfoType(*cow_op)) {
+    switch (cow_op->type) {
         case kCowReplaceOp: {
             return ProcessReplaceOp(cow_op, buffer);
         }
@@ -184,7 +183,7 @@ bool ReadWorker::ProcessCowOp(const CowOperation* cow_op, void* buffer) {
         }
 
         default: {
-            SNAP_LOG(ERROR) << "Unknown operation-type found: " << GetCowOpSourceInfoType(*cow_op);
+            SNAP_LOG(ERROR) << "Unknown operation-type found: " << cow_op->type;
         }
     }
     return false;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 536ff2f63990..e886ec399bee 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -24,7 +24,6 @@
 #include <android-base/strings.h>
 #include <snapuserd/dm_user_block_server.h>
 
-#include "libsnapshot/cow_format.h"
 #include "merge_worker.h"
 #include "read_worker.h"
 
@@ -197,13 +196,13 @@ bool SnapshotHandler::ReadMetadata() {
     while (!cowop_iter->AtEnd()) {
         const CowOperation* cow_op = cowop_iter->Get();
 
-        if (GetCowOpSourceInfoType(*cow_op) == kCowCopyOp) {
+        if (cow_op->type == kCowCopyOp) {
             copy_ops += 1;
-        } else if (GetCowOpSourceInfoType(*cow_op) == kCowReplaceOp) {
+        } else if (cow_op->type == kCowReplaceOp) {
             replace_ops += 1;
-        } else if (GetCowOpSourceInfoType(*cow_op) == kCowZeroOp) {
+        } else if (cow_op->type == kCowZeroOp) {
             zero_ops += 1;
-        } else if (GetCowOpSourceInfoType(*cow_op) == kCowXorOp) {
+        } else if (cow_op->type == kCowXorOp) {
             xor_ops += 1;
         }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index d7d43a6a0614..998d233d5ad1 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -18,7 +18,6 @@
 
 #include <pthread.h>
 
-#include "libsnapshot/cow_format.h"
 #include "snapuserd_core.h"
 #include "utility.h"
 
@@ -78,7 +77,7 @@ int ReadAhead::PrepareNextReadAhead(uint64_t* source_offset, int* pending_ops,
         SNAP_LOG(ERROR) << "PrepareNextReadAhead operation has no source offset: " << *cow_op;
         return nr_consecutive;
     }
-    if (GetCowOpSourceInfoType(*cow_op) == kCowXorOp) {
+    if (cow_op->type == kCowXorOp) {
         xor_op_vec.push_back(cow_op);
     }
 
@@ -107,7 +106,7 @@ int ReadAhead::PrepareNextReadAhead(uint64_t* source_offset, int* pending_ops,
             break;
         }
 
-        if (GetCowOpSourceInfoType(*op) == kCowXorOp) {
+        if (op->type == kCowXorOp) {
             xor_op_vec.push_back(op);
         }
 

From 786aabd7060431d3abce2215dac7c96dc710f369 Mon Sep 17 00:00:00 2001
From: Raymond Hernandez <rayhdez@google.com>
Date: Wed, 11 Oct 2023 17:52:25 -0700
Subject: [PATCH 0461/1487] Add monicamwang and rayhdez to
 system/core/libstats/OWNERS

Test: m -j
Bug: N/A
Change-Id: Ifb866dc90818423260c8ff4337edaa2e622d9d56
---
 libstats/OWNERS | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libstats/OWNERS b/libstats/OWNERS
index d39167947bd1..efd368627753 100644
--- a/libstats/OWNERS
+++ b/libstats/OWNERS
@@ -1,8 +1,8 @@
 jeffreyhuang@google.com
-jtnguyen@google.com
+monicamwang@google.com
 muhammadq@google.com
+rayhdez@google.com
 sharaienko@google.com
 singhtejinder@google.com
 tsaichristine@google.com
 yaochen@google.com
-yro@google.com

From 5a2b8794fc64ac0bcb285e53c44b3d67529950fb Mon Sep 17 00:00:00 2001
From: Kalesh Singh <kaleshsingh@google.com>
Date: Wed, 6 Sep 2023 14:08:26 -0700
Subject: [PATCH 0462/1487] trusty: tipc_fuzzer: Remove use of PAGE_SIZE

tipc_fuzzer writes random data of length 'size' and then
attempts to read back data up to 'TIPC_MAX_MSG_SIZE' in length.

Since 'size' is unrestricted we can always write more than the
subsequent read; and in effect the fuzzer only checks that we
can read something.

Remove the read buffer's dependency on PAGE_SIZE.

Bug: 294914413
Test: mma
Change-Id: I909b49fda4e6ebf49f69b3c09ac29ff8629215ef
Signed-off-by: Kalesh Singh <kaleshsingh@google.com>
---
 trusty/fuzz/include/trusty/fuzz/utils.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/fuzz/include/trusty/fuzz/utils.h b/trusty/fuzz/include/trusty/fuzz/utils.h
index c9064125801e..cf4962ee90d4 100644
--- a/trusty/fuzz/include/trusty/fuzz/utils.h
+++ b/trusty/fuzz/include/trusty/fuzz/utils.h
@@ -21,7 +21,7 @@
 #include <android-base/result.h>
 #include <android-base/unique_fd.h>
 
-#define TIPC_MAX_MSG_SIZE PAGE_SIZE
+#define TIPC_MAX_MSG_SIZE 4096
 
 namespace android {
 namespace trusty {

From bbc4bc54f2c268eebe4d11683955ca199a65d9eb Mon Sep 17 00:00:00 2001
From: Kalesh Singh <kaleshsingh@google.com>
Date: Fri, 8 Sep 2023 13:47:18 -0700
Subject: [PATCH 0463/1487] keymaster: Remove usage of PAGE_SIZE

bionic provides PAGE_SIZE macro which happens to also match the
size keymaster send buffer (4096) and half the size of the recv
buffer.

PAGE_SIZE is being removed as no other libc provides this and
Android is moving towards being page-size-agnostic.

Use a 4096 constant instead.

Test: Boot 16k device
Bug: 294914413
Change-Id:  I2dc10b48811e24d25ba08cfe4ffb514e94d42a8f
Signed-off-by: Kalesh Singh <kaleshsingh@google.com>
---
 .../include/trusty_keymaster/ipc/trusty_keymaster_ipc.h       | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/trusty/keymaster/include/trusty_keymaster/ipc/trusty_keymaster_ipc.h b/trusty/keymaster/include/trusty_keymaster/ipc/trusty_keymaster_ipc.h
index 16207e6d9843..efad254c8b9b 100644
--- a/trusty/keymaster/include/trusty_keymaster/ipc/trusty_keymaster_ipc.h
+++ b/trusty/keymaster/include/trusty_keymaster/ipc/trusty_keymaster_ipc.h
@@ -22,9 +22,9 @@
 
 __BEGIN_DECLS
 
-const uint32_t TRUSTY_KEYMASTER_RECV_BUF_SIZE = 2 * PAGE_SIZE;
+const uint32_t TRUSTY_KEYMASTER_RECV_BUF_SIZE = 2 * 4096;
 const uint32_t TRUSTY_KEYMASTER_SEND_BUF_SIZE =
-        (PAGE_SIZE - sizeof(struct keymaster_message) - 16 /* tipc header */);
+        (4096 - sizeof(struct keymaster_message) - 16 /* tipc header */);
 
 int trusty_keymaster_connect(void);
 int trusty_keymaster_call(uint32_t cmd, void* in, uint32_t in_size, uint8_t* out,

From efeb096c409fe0d60d573661f1964be4d48aeaca Mon Sep 17 00:00:00 2001
From: Kalesh Singh <kaleshsingh@google.com>
Date: Fri, 8 Sep 2023 13:34:48 -0700
Subject: [PATCH 0464/1487] libtrusty: Remove PAGE_SIZE usage

bionic provides PAGE_SIZE macro which happens to also match the
4096 chunk size in the tips_test.

PAGE_SIZE is being removed as no other libc provides this and
Android is moving towards being page-size-agnostic.

Use 4096 chunk size for tipc-tests; fix incorrect size in
munmap cleanup; and add failure log for send-fd test.

Test: tipc-test -t "send-fd"
Bug: 294914413
Change-Id: I7e5ec6480fff6bc1b4e8eed57eadf081cf82a72f
Signed-off-by: Kalesh Singh <kaleshsingh@google.com>
---
 trusty/libtrusty/tipc-test/tipc_test.c | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/trusty/libtrusty/tipc-test/tipc_test.c b/trusty/libtrusty/tipc-test/tipc_test.c
index 81c988110a5b..0f5078753219 100644
--- a/trusty/libtrusty/tipc-test/tipc_test.c
+++ b/trusty/libtrusty/tipc-test/tipc_test.c
@@ -44,6 +44,7 @@ static const char *closer2_name = "com.android.ipc-unittest.srv.closer2";
 static const char *closer3_name = "com.android.ipc-unittest.srv.closer3";
 static const char *main_ctrl_name = "com.android.ipc-unittest.ctrl";
 static const char* receiver_name = "com.android.trusty.memref.receiver";
+static const size_t memref_chunk_size = 4096;
 
 static const char* _sopts = "hsvDS:t:r:m:b:";
 /* clang-format off */
@@ -878,7 +879,7 @@ static int send_fd_test(void) {
     volatile char* buf = MAP_FAILED;
     BufferAllocator* allocator = NULL;
 
-    const size_t num_pages = 10;
+    const size_t num_chunks = 10;
 
     fd = tipc_connect(dev_name, receiver_name);
     if (fd < 0) {
@@ -894,7 +895,7 @@ static int send_fd_test(void) {
         goto cleanup;
     }
 
-    size_t buf_size = PAGE_SIZE * num_pages;
+    size_t buf_size = memref_chunk_size * num_chunks;
     dma_buf = DmabufHeapAlloc(allocator, "system", buf_size, 0, 0 /* legacy align */);
     if (dma_buf < 0) {
         ret = dma_buf;
@@ -927,13 +928,17 @@ static int send_fd_test(void) {
     tipc_close(fd);
 
     ret = 0;
-    for (size_t skip = 0; skip < num_pages; skip++) {
-        ret |= strcmp("Hello from Trusty!", (const char*)&buf[skip * PAGE_SIZE]) ? (-1) : 0;
+    for (size_t skip = 0; skip < num_chunks; skip++) {
+        int cmp = strcmp("Hello from Trusty!",
+                         (const char*)&buf[skip * memref_chunk_size]) ? (-1) : 0;
+        if (cmp)
+            fprintf(stderr, "Failed: Unexpected content at page %zu in dmabuf\n", skip);
+        ret |= cmp;
     }
 
 cleanup:
     if (buf != MAP_FAILED) {
-        munmap((char*)buf, PAGE_SIZE);
+        munmap((char*)buf, buf_size);
     }
     close(dma_buf);
     if (allocator) {

From 623d140cc02b2415bbab05bec4afc11a7d0e23e6 Mon Sep 17 00:00:00 2001
From: Kalesh Singh <kaleshsingh@google.com>
Date: Wed, 6 Sep 2023 11:32:53 -0700
Subject: [PATCH 0465/1487] trusty: Remove explicit page-alignment of mmap and
 dmabuf allocations

bionic hard codes the PAGE_SIZE macro as 4096. This is going away as
Android begins to support larger page sizes.

trusty uses PAGE_SIZE to round up the allocation size of the DMA
buffers and mmap sizes. This is not explicitly needed since the kernel
will always give you a page-aligned and page-sized multiple allocation
when allocating a dmabuf or mmap-ing.

Remove this PAGE_SIZE usage from TrustyApp, app_fuzzer, coverage,
line-coverage, modulewrapper.

Bug: 294914413
Test: Boot test on 16k device
Change-Id: Iad922e0a152cb80db2e59e696d7556602fd17d67
Signed-off-by: Kalesh Singh <kaleshsingh@google.com>
---
 trusty/apploader/fuzz/app_fuzzer.cpp       |  6 +-----
 trusty/confirmationui/TrustyApp.cpp        |  6 +-----
 trusty/coverage/coverage.cpp               |  6 +-----
 trusty/line-coverage/coverage.cpp          |  6 +-----
 trusty/utils/acvp/trusty_modulewrapper.cpp | 11 +++--------
 5 files changed, 7 insertions(+), 28 deletions(-)

diff --git a/trusty/apploader/fuzz/app_fuzzer.cpp b/trusty/apploader/fuzz/app_fuzzer.cpp
index aa0caca81c1c..0a037f9e04ba 100644
--- a/trusty/apploader/fuzz/app_fuzzer.cpp
+++ b/trusty/apploader/fuzz/app_fuzzer.cpp
@@ -43,10 +43,6 @@ static struct uuid apploader_uuid = {
         {0xb5, 0xe8, 0xa7, 0xe9, 0xef, 0x17, 0x3a, 0x97},
 };
 
-static inline uintptr_t RoundPageUp(uintptr_t val) {
-    return (val + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
-}
-
 static bool SendLoadMsg(int chan, int dma_buf, size_t dma_buf_size) {
     apploader_header hdr = {
             .cmd = APPLOADER_CMD_LOAD_APPLICATION,
@@ -107,7 +103,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
         android::trusty::fuzz::Abort();
     }
 
-    uint64_t shm_len = size ? RoundPageUp(size) : PAGE_SIZE;
+    uint64_t shm_len = size ? size : 4096;
     BufferAllocator alloc;
     unique_fd dma_buf(alloc.Alloc(kDmabufSystemHeapName, shm_len));
     if (dma_buf < 0) {
diff --git a/trusty/confirmationui/TrustyApp.cpp b/trusty/confirmationui/TrustyApp.cpp
index cee8655e0609..2356eef4e683 100644
--- a/trusty/confirmationui/TrustyApp.cpp
+++ b/trusty/confirmationui/TrustyApp.cpp
@@ -30,10 +30,6 @@ namespace confirmationui {
 
 using ::android::base::unique_fd;
 
-static inline uintptr_t RoundPageUp(uintptr_t val) {
-    return (val + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
-}
-
 ssize_t TrustyApp::TrustyRpc(const uint8_t* obegin, const uint8_t* oend, uint8_t* ibegin,
                              uint8_t* iend) {
     uint32_t olen = oend - obegin;
@@ -99,7 +95,7 @@ TrustyApp::TrustyApp(const std::string& path, const std::string& appname)
         return;
     }
 
-    uint32_t shm_len = RoundPageUp(CONFIRMATIONUI_MAX_MSG_SIZE);
+    uint32_t shm_len = CONFIRMATIONUI_MAX_MSG_SIZE;
     BufferAllocator allocator;
     unique_fd dma_buf(allocator.Alloc("system", shm_len));
     if (dma_buf < 0) {
diff --git a/trusty/coverage/coverage.cpp b/trusty/coverage/coverage.cpp
index 3c6b5c510cf5..8fc2f5ca8329 100644
--- a/trusty/coverage/coverage.cpp
+++ b/trusty/coverage/coverage.cpp
@@ -43,10 +43,6 @@ using std::string;
 using std::to_string;
 using std::unique_ptr;
 
-static inline uintptr_t RoundPageUp(uintptr_t val) {
-    return (val + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
-}
-
 CoverageRecord::CoverageRecord(string tipc_dev, struct uuid* uuid)
     : tipc_dev_(std::move(tipc_dev)),
       coverage_srv_fd_(-1),
@@ -136,7 +132,7 @@ Result<void> CoverageRecord::Open() {
         return Error() << "failed to open coverage client: " << ret.error();
     }
     record_len_ = resp.open_args.record_len;
-    shm_len_ = RoundPageUp(record_len_);
+    shm_len_ = record_len_;
 
     BufferAllocator allocator;
 
diff --git a/trusty/line-coverage/coverage.cpp b/trusty/line-coverage/coverage.cpp
index 57b702510da7..5f7b3a3f65bb 100644
--- a/trusty/line-coverage/coverage.cpp
+++ b/trusty/line-coverage/coverage.cpp
@@ -50,10 +50,6 @@ using ::android::base::ErrnoError;
 using ::android::base::Error;
 using ::std::string;
 
-static inline uintptr_t RoundPageUp(uintptr_t val) {
-    return (val + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
-}
-
 CoverageRecord::CoverageRecord(string tipc_dev, struct uuid* uuid)
     : tipc_dev_(std::move(tipc_dev)),
       coverage_srv_fd_(-1),
@@ -129,7 +125,7 @@ Result<void> CoverageRecord::Open(int fd) {
         return Error() << "failed to open coverage client: " << ret.error();
     }
     record_len_ = resp.open_args.record_len;
-    shm_len_ = RoundPageUp(record_len_);
+    shm_len_ = record_len_;
 
     BufferAllocator allocator;
 
diff --git a/trusty/utils/acvp/trusty_modulewrapper.cpp b/trusty/utils/acvp/trusty_modulewrapper.cpp
index 85b7159d3ced..817b60061004 100644
--- a/trusty/utils/acvp/trusty_modulewrapper.cpp
+++ b/trusty/utils/acvp/trusty_modulewrapper.cpp
@@ -31,6 +31,7 @@
 #include <sys/mman.h>
 #include <trusty/tipc.h>
 #include <unistd.h>
+#include <algorithm>
 
 #include "acvp_ipc.h"
 
@@ -42,9 +43,6 @@ using android::base::Result;
 using android::base::unique_fd;
 using android::base::WriteFully;
 
-static inline size_t AlignUpToPage(size_t size) {
-    return (size + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
-}
 
 namespace {
 
@@ -104,15 +102,12 @@ Result<void> ModuleWrapper::SendMessage(bssl::Span<const bssl::Span<const uint8_
     struct acvp_req request;
     request.num_args = args.size();
 
-    size_t total_args_size = 0;
+    int total_args_size = 0;
     for (auto arg : args) {
         total_args_size += arg.size();
     }
 
-    shm_size_ = ACVP_MIN_SHARED_MEMORY;
-    if (total_args_size > shm_size_) {
-        shm_size_ = AlignUpToPage(total_args_size);
-    }
+    shm_size_ = std::max(ACVP_MIN_SHARED_MEMORY, total_args_size);
     request.buffer_size = shm_size_;
 
     struct iovec iov = {

From cab8646a07e5afd8dd5f3aa6b2809bc89d88292d Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 12 Oct 2023 14:10:50 -0700
Subject: [PATCH 0466/1487] Add v3 to CreateCowWriter

Adding v3 writer as a return type to CreateCowWriter

Test: write_cow
Change-Id: Ia68ddf17b9f5f9fae27da4d6ab5fb150078d0c38
---
 fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
index 5ab4f7a52226..b9052915e189 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
@@ -23,6 +23,7 @@
 #include <android-base/stringprintf.h>
 #include <libsnapshot/cow_format.h>
 #include "writer_v2.h"
+#include "writer_v3.h"
 
 namespace android {
 namespace snapshot {
@@ -149,6 +150,9 @@ std::unique_ptr<ICowWriter> CreateCowWriter(uint32_t version, const CowOptions&
         case 2:
             base = std::make_unique<CowWriterV2>(options, std::move(fd));
             break;
+        case 3:
+            base = std::make_unique<CowWriterV3>(options, std::move(fd));
+            break;
         default:
             LOG(ERROR) << "Cannot create unknown cow version: " << version;
             return nullptr;

From 678d268848b983ae7c811c62e63b2c8634d214d8 Mon Sep 17 00:00:00 2001
From: Dennis Shen <dzshen@google.com>
Date: Mon, 18 Sep 2023 19:52:52 +0000
Subject: [PATCH 0467/1487] apply staged property value when loading persistent
 props

Bug: b/300111812
Change-Id: I81b6bd984aad8f7ddec93ce74f4543e4f71be508
Merged-In: I81b6bd984aad8f7ddec93ce74f4543e4f71be508
---
 init/persistent_properties.cpp | 18 +++++++-------
 init/persistent_properties.h   |  2 ++
 init/property_service.cpp      | 43 +++++++++++++++++++++++++++++-----
 3 files changed, 48 insertions(+), 15 deletions(-)

diff --git a/init/persistent_properties.cpp b/init/persistent_properties.cpp
index 8db72679ee75..8efb72c7ea94 100644
--- a/init/persistent_properties.cpp
+++ b/init/persistent_properties.cpp
@@ -46,13 +46,6 @@ namespace {
 
 constexpr const char kLegacyPersistentPropertyDir[] = "/data/property";
 
-void AddPersistentProperty(const std::string& name, const std::string& value,
-                           PersistentProperties* persistent_properties) {
-    auto persistent_property_record = persistent_properties->add_properties();
-    persistent_property_record->set_name(name);
-    persistent_property_record->set_value(value);
-}
-
 Result<PersistentProperties> LoadLegacyPersistentProperties() {
     std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(kLegacyPersistentPropertyDir), closedir);
     if (!dir) {
@@ -161,9 +154,9 @@ Result<PersistentProperties> ParsePersistentPropertyFile(const std::string& file
         return Error() << "Unable to parse persistent property file: Could not parse protobuf";
     }
     for (auto& prop : persistent_properties.properties()) {
-        if (!StartsWith(prop.name(), "persist.")) {
+        if (!StartsWith(prop.name(), "persist.") && !StartsWith(prop.name(), "next_boot.")) {
             return Error() << "Unable to load persistent property file: property '" << prop.name()
-                           << "' doesn't start with 'persist.'";
+                           << "' doesn't start with 'persist.' or 'next_boot.'";
         }
     }
     return persistent_properties;
@@ -171,6 +164,13 @@ Result<PersistentProperties> ParsePersistentPropertyFile(const std::string& file
 
 }  // namespace
 
+void AddPersistentProperty(const std::string& name, const std::string& value,
+                           PersistentProperties* persistent_properties) {
+    auto persistent_property_record = persistent_properties->add_properties();
+    persistent_property_record->set_name(name);
+    persistent_property_record->set_value(value);
+}
+
 Result<PersistentProperties> LoadPersistentPropertyFile() {
     auto file_contents = ReadPersistentPropertyFile();
     if (!file_contents.ok()) return file_contents.error();
diff --git a/init/persistent_properties.h b/init/persistent_properties.h
index 3845a0d86714..a6f80e64f51d 100644
--- a/init/persistent_properties.h
+++ b/init/persistent_properties.h
@@ -25,6 +25,8 @@
 namespace android {
 namespace init {
 
+void AddPersistentProperty(const std::string& name, const std::string& value,
+                           PersistentProperties* persistent_properties);
 PersistentProperties LoadPersistentProperties();
 void WritePersistentProperty(const std::string& name, const std::string& value);
 
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 2064fae8f14c..bf8680310827 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -412,9 +412,8 @@ static std::optional<uint32_t> PropertySet(const std::string& name, const std::s
         }
     }
 
-    // Don't write properties to disk until after we have read all default
-    // properties to prevent them from being overwritten by default values.
-    if (socket && persistent_properties_loaded && StartsWith(name, "persist.")) {
+    bool need_persist = StartsWith(name, "persist.") || StartsWith(name, "next_boot.");
+    if (socket && persistent_properties_loaded && need_persist) {
         if (persist_write_thread) {
             persist_write_thread->Write(name, value, std::move(*socket));
             return {};
@@ -1398,11 +1397,43 @@ static void HandleInitSocket() {
         case InitMessage::kLoadPersistentProperties: {
             load_override_properties();
             // Read persistent properties after all default values have been loaded.
+            // Apply staged and persistent properties
+            bool has_staged_prop = false;
+            auto const staged_prefix = std::string_view("next_boot.");
+            auto const staged_persist_prefix = std::string_view("next_boot.persist.");
+            auto persist_props_map = std::unordered_map<std::string, std::string>();
+
             auto persistent_properties = LoadPersistentProperties();
-            for (const auto& persistent_property_record : persistent_properties.properties()) {
-                InitPropertySet(persistent_property_record.name(),
-                                persistent_property_record.value());
+            for (const auto& property_record : persistent_properties.properties()) {
+                auto const& prop_name = property_record.name();
+                auto const& prop_value = property_record.value();
+
+                if (StartsWith(prop_name, staged_prefix)) {
+                  has_staged_prop = true;
+                  auto actual_prop_name = prop_name.substr(staged_prefix.size());
+                  InitPropertySet(actual_prop_name, prop_value);
+                  if (StartsWith(prop_name, staged_persist_prefix)) {
+                    persist_props_map[actual_prop_name] = prop_value;
+                  }
+                } else if (!persist_props_map.count(prop_name)) {
+                  InitPropertySet(prop_name, prop_value);
+                }
+            }
+
+            // Update persist prop file if there are staged props
+            if (has_staged_prop) {
+                PersistentProperties updated_persist_props;
+                for (auto const& [prop_name, prop_value] : persist_props_map) {
+                    AddPersistentProperty(prop_name, prop_value, &updated_persist_props);
+                }
+
+                // write current updated persist prop file
+                auto result = WritePersistentPropertyFile(updated_persist_props);
+                if (!result.ok()) {
+                    LOG(ERROR) << "Could not store persistent property: " << result.error();
+                }
             }
+
             // Apply debug ramdisk special settings after persistent properties are loaded.
             if (android::base::GetBoolProperty("ro.force.debuggable", false)) {
                 // Always enable usb adb if device is booted with debug ramdisk.

From ecf8e1cf2fc907bfd5f747cd8fb456076dd48d66 Mon Sep 17 00:00:00 2001
From: Dennis Shen <dzshen@google.com>
Date: Mon, 18 Sep 2023 19:52:52 +0000
Subject: [PATCH 0468/1487] apply staged property value when loading persistent
 props

Bug: b/300111812
Change-Id: I81b6bd984aad8f7ddec93ce74f4543e4f71be508
Ignore-AOSP-First: see cherry pick to aosp/2781147
---
 init/persistent_properties.cpp | 18 +++++++--------
 init/persistent_properties.h   |  2 ++
 init/property_service.cpp      | 41 ++++++++++++++++++++++++++++++----
 3 files changed, 48 insertions(+), 13 deletions(-)

diff --git a/init/persistent_properties.cpp b/init/persistent_properties.cpp
index 8db72679ee75..8efb72c7ea94 100644
--- a/init/persistent_properties.cpp
+++ b/init/persistent_properties.cpp
@@ -46,13 +46,6 @@ namespace {
 
 constexpr const char kLegacyPersistentPropertyDir[] = "/data/property";
 
-void AddPersistentProperty(const std::string& name, const std::string& value,
-                           PersistentProperties* persistent_properties) {
-    auto persistent_property_record = persistent_properties->add_properties();
-    persistent_property_record->set_name(name);
-    persistent_property_record->set_value(value);
-}
-
 Result<PersistentProperties> LoadLegacyPersistentProperties() {
     std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(kLegacyPersistentPropertyDir), closedir);
     if (!dir) {
@@ -161,9 +154,9 @@ Result<PersistentProperties> ParsePersistentPropertyFile(const std::string& file
         return Error() << "Unable to parse persistent property file: Could not parse protobuf";
     }
     for (auto& prop : persistent_properties.properties()) {
-        if (!StartsWith(prop.name(), "persist.")) {
+        if (!StartsWith(prop.name(), "persist.") && !StartsWith(prop.name(), "next_boot.")) {
             return Error() << "Unable to load persistent property file: property '" << prop.name()
-                           << "' doesn't start with 'persist.'";
+                           << "' doesn't start with 'persist.' or 'next_boot.'";
         }
     }
     return persistent_properties;
@@ -171,6 +164,13 @@ Result<PersistentProperties> ParsePersistentPropertyFile(const std::string& file
 
 }  // namespace
 
+void AddPersistentProperty(const std::string& name, const std::string& value,
+                           PersistentProperties* persistent_properties) {
+    auto persistent_property_record = persistent_properties->add_properties();
+    persistent_property_record->set_name(name);
+    persistent_property_record->set_value(value);
+}
+
 Result<PersistentProperties> LoadPersistentPropertyFile() {
     auto file_contents = ReadPersistentPropertyFile();
     if (!file_contents.ok()) return file_contents.error();
diff --git a/init/persistent_properties.h b/init/persistent_properties.h
index 3845a0d86714..a6f80e64f51d 100644
--- a/init/persistent_properties.h
+++ b/init/persistent_properties.h
@@ -25,6 +25,8 @@
 namespace android {
 namespace init {
 
+void AddPersistentProperty(const std::string& name, const std::string& value,
+                           PersistentProperties* persistent_properties);
 PersistentProperties LoadPersistentProperties();
 void WritePersistentProperty(const std::string& name, const std::string& value);
 
diff --git a/init/property_service.cpp b/init/property_service.cpp
index a1b0b8ed51d0..ec18694f52c8 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -420,7 +420,8 @@ static std::optional<uint32_t> PropertySet(const std::string& name, const std::s
 
         // Don't write properties to disk until after we have read all default
         // properties to prevent them from being overwritten by default values.
-        if (socket && persistent_properties_loaded && StartsWith(name, "persist.")) {
+        bool need_persist = StartsWith(name, "persist.") || StartsWith(name, "next_boot.");
+        if (socket && persistent_properties_loaded && need_persist) {
             if (persist_write_thread) {
                 persist_write_thread->Write(name, value, std::move(*socket));
                 return {};
@@ -1405,11 +1406,43 @@ static void HandleInitSocket() {
         case InitMessage::kLoadPersistentProperties: {
             load_override_properties();
             // Read persistent properties after all default values have been loaded.
+            // Apply staged and persistent properties
+            bool has_staged_prop = false;
+            auto const staged_prefix = std::string_view("next_boot.");
+            auto const staged_persist_prefix = std::string_view("next_boot.persist.");
+            auto persist_props_map = std::unordered_map<std::string, std::string>();
+
             auto persistent_properties = LoadPersistentProperties();
-            for (const auto& persistent_property_record : persistent_properties.properties()) {
-                InitPropertySet(persistent_property_record.name(),
-                                persistent_property_record.value());
+            for (const auto& property_record : persistent_properties.properties()) {
+                auto const& prop_name = property_record.name();
+                auto const& prop_value = property_record.value();
+
+                if (StartsWith(prop_name, staged_prefix)) {
+                  has_staged_prop = true;
+                  auto actual_prop_name = prop_name.substr(staged_prefix.size());
+                  InitPropertySet(actual_prop_name, prop_value);
+                  if (StartsWith(prop_name, staged_persist_prefix)) {
+                    persist_props_map[actual_prop_name] = prop_value;
+                  }
+                } else if (!persist_props_map.count(prop_name)) {
+                  InitPropertySet(prop_name, prop_value);
+                }
+            }
+
+            // Update persist prop file if there are staged props
+            if (has_staged_prop) {
+                PersistentProperties updated_persist_props;
+                for (auto const& [prop_name, prop_value] : persist_props_map) {
+                    AddPersistentProperty(prop_name, prop_value, &updated_persist_props);
+                }
+
+                // write current updated persist prop file
+                auto result = WritePersistentPropertyFile(updated_persist_props);
+                if (!result.ok()) {
+                    LOG(ERROR) << "Could not store persistent property: " << result.error();
+                }
             }
+
             // Apply debug ramdisk special settings after persistent properties are loaded.
             if (android::base::GetBoolProperty("ro.force.debuggable", false)) {
                 // Always enable usb adb if device is booted with debug ramdisk.

From 7e407514ddcd27b6c1e2e0b44aefc9a1f1dc39c1 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 13 Oct 2023 14:30:43 -0700
Subject: [PATCH 0469/1487] Remove unused variable in snapuserd_core.

Bug: N/A
Test: builds
Change-Id: I8fc3bd2dd8eb3cfa3c6bfe513f054a4d6a674de1
---
 fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index f88406d2aa46..6a1dab867a31 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -43,7 +43,6 @@
 #include <libdm/dm.h>
 #include <libsnapshot/cow_reader.h>
 #include <libsnapshot/cow_writer.h>
-#include <liburing.h>
 #include <snapuserd/block_server.h>
 #include <snapuserd/snapuserd_buffer.h>
 #include <snapuserd/snapuserd_kernel.h>
@@ -247,7 +246,6 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     bool perform_verification_ = true;
     bool resume_merge_ = false;
 
-    std::unique_ptr<struct io_uring> ring_;
     std::unique_ptr<UpdateVerify> update_verify_;
     std::shared_ptr<IBlockServerOpener> block_server_opener_;
 };

From 78d5352289ad07487d7bac77341c5ba582b46072 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 12 Oct 2023 10:16:44 -0700
Subject: [PATCH 0470/1487] Make partition metadata write atomic

We have seen multiple OTA failures with invalid geometry magic
signature. Make partition metadata write atomic by writing to a tmpfile
first and then do a rename.

Test: th
Bug: 303770065
Bug: 298149189
Change-Id: Id1d565de73439b95b665144c2f02fc97273d341c
---
 fs_mgr/libfiemap/metadata.cpp |  8 +------
 fs_mgr/liblp/images.cpp       | 44 +++++++++++++++++++++++++++++++----
 2 files changed, 40 insertions(+), 12 deletions(-)

diff --git a/fs_mgr/libfiemap/metadata.cpp b/fs_mgr/libfiemap/metadata.cpp
index 22b8afb7dadc..0a56f6af7f83 100644
--- a/fs_mgr/libfiemap/metadata.cpp
+++ b/fs_mgr/libfiemap/metadata.cpp
@@ -111,13 +111,7 @@ bool SaveMetadata(MetadataBuilder* builder, const std::string& metadata_dir) {
         return true;
     }
 
-    unique_fd fd(open(metadata_file.c_str(), O_CREAT | O_RDWR | O_TRUNC | O_CLOEXEC | O_BINARY | O_SYNC, 0644));
-    if (fd < 0) {
-        LOG(ERROR) << "open failed: " << metadata_file;
-        return false;
-    }
-
-    if (!WriteToImageFile(fd, *exported.get())) {
+    if (!WriteToImageFile(metadata_file, *exported.get())) {
         LOG(ERROR) << "Unable to save new metadata";
         return false;
     }
diff --git a/fs_mgr/liblp/images.cpp b/fs_mgr/liblp/images.cpp
index 02b64ac45e4d..a2dbb1052ca6 100644
--- a/fs_mgr/liblp/images.cpp
+++ b/fs_mgr/liblp/images.cpp
@@ -123,13 +123,46 @@ bool WriteToImageFile(borrowed_fd fd, const LpMetadata& input) {
     return true;
 }
 
+#if !defined(_WIN32)
+bool FsyncDirectory(const char* dirname) {
+    android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(dirname, O_RDONLY | O_CLOEXEC)));
+    if (fd == -1) {
+        PLOG(ERROR) << "Failed to open " << dirname;
+        return false;
+    }
+    if (fsync(fd) == -1) {
+        if (errno == EROFS || errno == EINVAL) {
+            PLOG(WARNING) << "Skip fsync " << dirname
+                          << " on a file system does not support synchronization";
+        } else {
+            PLOG(ERROR) << "Failed to fsync " << dirname;
+            return false;
+        }
+    }
+    return true;
+}
+#endif
+
 bool WriteToImageFile(const std::string& file, const LpMetadata& input) {
-    unique_fd fd(open(file.c_str(), O_CREAT | O_RDWR | O_TRUNC | O_CLOEXEC | O_BINARY, 0644));
-    if (fd < 0) {
-        PERROR << __PRETTY_FUNCTION__ << " open failed: " << file;
+    const auto parent_dir = base::Dirname(file);
+    TemporaryFile tmpfile(parent_dir);
+    if (!WriteToImageFile(tmpfile.fd, input)) {
+        PLOG(ERROR) << "Failed to write geometry data to tmpfile " << tmpfile.path;
         return false;
     }
-    return WriteToImageFile(fd, input);
+
+#if !defined(_WIN32)
+    fsync(tmpfile.fd);
+#endif
+    const auto err = rename(tmpfile.path, file.c_str());
+    if (err != 0) {
+        PLOG(ERROR) << "Failed to rename tmp geometry file " << tmpfile.path << " to " << file;
+        return false;
+    }
+#if !defined(_WIN32)
+    FsyncDirectory(parent_dir.c_str());
+#endif
+    return true;
 }
 
 ImageBuilder::ImageBuilder(const LpMetadata& metadata, uint32_t block_size,
@@ -208,7 +241,8 @@ bool ImageBuilder::ExportFiles(const std::string& output_dir) {
         std::string file_name = "super_" + name + ".img";
         std::string file_path = output_dir + "/" + file_name;
 
-        static const int kOpenFlags = O_CREAT | O_RDWR | O_TRUNC | O_CLOEXEC | O_NOFOLLOW | O_BINARY;
+        static const int kOpenFlags =
+                O_CREAT | O_RDWR | O_TRUNC | O_CLOEXEC | O_NOFOLLOW | O_BINARY;
         unique_fd fd(open(file_path.c_str(), kOpenFlags, 0644));
         if (fd < 0) {
             PERROR << "open failed: " << file_path;

From 5ae7a8053af634487a3abff927af97e9c1656e70 Mon Sep 17 00:00:00 2001
From: Nate Myren <ntmyren@google.com>
Date: Fri, 25 Aug 2023 14:30:50 -0700
Subject: [PATCH 0471/1487] Initialize the appcompat system property folder

Certain applications may have their system properties overlaid with the
contents overlaid for appcompat purposes. Init must initialize the
appcompat folder, same as it does the standard folder.

Bug: 291814949
Ignore-AOSP-First: must be merged with ag/24558703, which has an   Aosp -> internal merge conflict
Test: manual

Change-Id: I0c6a0f66dc543c6e861bc86a417e4feb5ecd7789
---
 init/property_service.cpp                        | 16 +++++++++++++---
 .../property_info_parser/property_info_parser.h  |  2 ++
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index a1b0b8ed51d0..dc25a9d24b12 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -76,6 +76,10 @@
 #include "system/core/init/property_service.pb.h"
 #include "util.h"
 
+static constexpr char APPCOMPAT_OVERRIDE_PROP_FOLDERNAME[] =
+        "/dev/__properties__/appcompat_override";
+static constexpr char APPCOMPAT_OVERRIDE_PROP_TREE_FILE[] =
+        "/dev/__properties__/appcompat_override/property_info";
 using namespace std::literals;
 
 using android::base::ErrnoError;
@@ -1287,11 +1291,17 @@ void CreateSerializedPropertyInfo() {
         return;
     }
 
-    constexpr static const char kPropertyInfosPath[] = "/dev/__properties__/property_info";
-    if (!WriteStringToFile(serialized_contexts, kPropertyInfosPath, 0444, 0, 0, false)) {
+    if (!WriteStringToFile(serialized_contexts, PROP_TREE_FILE, 0444, 0, 0, false)) {
         PLOG(ERROR) << "Unable to write serialized property infos to file";
     }
-    selinux_android_restorecon(kPropertyInfosPath, 0);
+    selinux_android_restorecon(PROP_TREE_FILE, 0);
+
+    mkdir(APPCOMPAT_OVERRIDE_PROP_FOLDERNAME, S_IRWXU | S_IXGRP | S_IXOTH);
+    if (!WriteStringToFile(serialized_contexts, APPCOMPAT_OVERRIDE_PROP_TREE_FILE, 0444, 0, 0,
+                           false)) {
+        PLOG(ERROR) << "Unable to write appcompat override property infos to file";
+    }
+    selinux_android_restorecon(APPCOMPAT_OVERRIDE_PROP_TREE_FILE, 0);
 }
 
 static void ExportKernelBootProps() {
diff --git a/property_service/libpropertyinfoparser/include/property_info_parser/property_info_parser.h b/property_service/libpropertyinfoparser/include/property_info_parser/property_info_parser.h
index 054802197a5f..65705accbc78 100644
--- a/property_service/libpropertyinfoparser/include/property_info_parser/property_info_parser.h
+++ b/property_service/libpropertyinfoparser/include/property_info_parser/property_info_parser.h
@@ -20,6 +20,8 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+static constexpr char PROP_TREE_FILE[] = "/dev/__properties__/property_info";
+
 namespace android {
 namespace properties {
 

From e02b831aef8f3ba7641f75903f0e8bc64ea17f50 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Sun, 15 Oct 2023 17:00:43 -0700
Subject: [PATCH 0472/1487] libsnapshot: Remove consistency check after merge

Merge thread will mark merge-completion after msync on header is
complete. This should be definitive enough to track the completion
status.

Bug: 305187301
Test: OTA on Pixel
Change-Id: I366dc5052fa91a6eacf394a1970200cdebc0e135
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../include/libsnapshot/snapshot.h            | 12 ---
 fs_mgr/libsnapshot/snapshot.cpp               | 87 +-----------------
 fs_mgr/libsnapshot/snapshot_test.cpp          | 91 -------------------
 .../user-space-merge/snapuserd_core.cpp       |  4 +
 .../user-space-merge/snapuserd_core.h         |  2 +
 .../snapuserd_transitions.cpp                 | 12 ++-
 6 files changed, 15 insertions(+), 193 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index e7b0020ead86..08a79baed097 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -405,15 +405,6 @@ class SnapshotManager final : public ISnapshotManager {
 
     // Add new public entries above this line.
 
-    // Helpers for failure injection.
-    using MergeConsistencyChecker =
-            std::function<MergeFailureCode(const std::string& name, const SnapshotStatus& status)>;
-
-    void set_merge_consistency_checker(MergeConsistencyChecker checker) {
-        merge_consistency_checker_ = checker;
-    }
-    MergeConsistencyChecker merge_consistency_checker() const { return merge_consistency_checker_; }
-
   private:
     FRIEND_TEST(SnapshotTest, CleanFirstStageMount);
     FRIEND_TEST(SnapshotTest, CreateSnapshot);
@@ -657,8 +648,6 @@ class SnapshotManager final : public ISnapshotManager {
     MergeResult CheckMergeState(LockedFile* lock, const std::function<bool()>& before_cancel);
     MergeResult CheckTargetMergeState(LockedFile* lock, const std::string& name,
                                       const SnapshotUpdateStatus& update_status);
-    MergeFailureCode CheckMergeConsistency(LockedFile* lock, const std::string& name,
-                                           const SnapshotStatus& update_status);
 
     auto UpdateStateToStr(enum UpdateState state);
     // Get status or table information about a device-mapper node with a single target.
@@ -847,7 +836,6 @@ class SnapshotManager final : public ISnapshotManager {
     std::unique_ptr<SnapuserdClient> snapuserd_client_;
     std::unique_ptr<LpMetadata> old_partition_metadata_;
     std::optional<bool> is_snapshot_userspace_;
-    MergeConsistencyChecker merge_consistency_checker_;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 4743a42a4b23..f5732fc90a73 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -89,8 +89,6 @@ static constexpr char kBootIndicatorPath[] = "/metadata/ota/snapshot-boot";
 static constexpr char kRollbackIndicatorPath[] = "/metadata/ota/rollback-indicator";
 static constexpr auto kUpdateStateCheckInterval = 2s;
 
-MergeFailureCode CheckMergeConsistency(const std::string& name, const SnapshotStatus& status);
-
 // Note: IImageManager is an incomplete type in the header, so the default
 // destructor doesn't work.
 SnapshotManager::~SnapshotManager() {}
@@ -120,9 +118,7 @@ std::unique_ptr<SnapshotManager> SnapshotManager::NewForFirstStageMount(IDeviceI
 }
 
 SnapshotManager::SnapshotManager(IDeviceInfo* device)
-    : dm_(device->GetDeviceMapper()), device_(device), metadata_dir_(device_->GetMetadataDir()) {
-    merge_consistency_checker_ = android::snapshot::CheckMergeConsistency;
-}
+    : dm_(device->GetDeviceMapper()), device_(device), metadata_dir_(device_->GetMetadataDir()) {}
 
 static std::string GetCowName(const std::string& snapshot_name) {
     return snapshot_name + "-cow";
@@ -1365,13 +1361,6 @@ auto SnapshotManager::CheckTargetMergeState(LockedFile* lock, const std::string&
         }
     }
 
-    // Merge is complete at this point
-
-    auto code = CheckMergeConsistency(lock, name, snapshot_status);
-    if (code != MergeFailureCode::Ok) {
-        return MergeResult(UpdateState::MergeFailed, code);
-    }
-
     // Merging is done. First, update the status file to indicate the merge
     // is complete. We do this before calling OnSnapshotMergeComplete, even
     // though this means the write is potentially wasted work (since in the
@@ -1401,80 +1390,6 @@ static std::string GetMappedCowDeviceName(const std::string& snapshot,
     return GetCowName(snapshot);
 }
 
-MergeFailureCode SnapshotManager::CheckMergeConsistency(LockedFile* lock, const std::string& name,
-                                                        const SnapshotStatus& status) {
-    CHECK(lock);
-
-    return merge_consistency_checker_(name, status);
-}
-
-MergeFailureCode CheckMergeConsistency(const std::string& name, const SnapshotStatus& status) {
-    if (!status.using_snapuserd()) {
-        // Do not try to verify old-style COWs yet.
-        return MergeFailureCode::Ok;
-    }
-
-    auto& dm = DeviceMapper::Instance();
-
-    std::string cow_image_name = GetMappedCowDeviceName(name, status);
-    std::string cow_image_path;
-    if (!dm.GetDmDevicePathByName(cow_image_name, &cow_image_path)) {
-        LOG(ERROR) << "Failed to get path for cow device: " << cow_image_name;
-        return MergeFailureCode::GetCowPathConsistencyCheck;
-    }
-
-    // First pass, count # of ops.
-    size_t num_ops = 0;
-    {
-        unique_fd fd(open(cow_image_path.c_str(), O_RDONLY | O_CLOEXEC));
-        if (fd < 0) {
-            PLOG(ERROR) << "Failed to open " << cow_image_name;
-            return MergeFailureCode::OpenCowConsistencyCheck;
-        }
-
-        CowReader reader;
-        if (!reader.Parse(std::move(fd))) {
-            LOG(ERROR) << "Failed to parse cow " << cow_image_path;
-            return MergeFailureCode::ParseCowConsistencyCheck;
-        }
-
-        num_ops = reader.get_num_total_data_ops();
-    }
-
-    // Second pass, try as hard as we can to get the actual number of blocks
-    // the system thinks is merged.
-    unique_fd fd(open(cow_image_path.c_str(), O_RDONLY | O_DIRECT | O_SYNC | O_CLOEXEC));
-    if (fd < 0) {
-        PLOG(ERROR) << "Failed to open direct " << cow_image_name;
-        return MergeFailureCode::OpenCowDirectConsistencyCheck;
-    }
-
-    void* addr;
-    size_t page_size = getpagesize();
-    if (posix_memalign(&addr, page_size, page_size) < 0) {
-        PLOG(ERROR) << "posix_memalign with page size " << page_size;
-        return MergeFailureCode::MemAlignConsistencyCheck;
-    }
-
-    // COWs are always at least 2MB, this is guaranteed in snapshot creation.
-    std::unique_ptr<void, decltype(&::free)> buffer(addr, ::free);
-    if (!android::base::ReadFully(fd, buffer.get(), page_size)) {
-        PLOG(ERROR) << "Direct read failed " << cow_image_name;
-        return MergeFailureCode::DirectReadConsistencyCheck;
-    }
-
-    auto header = reinterpret_cast<CowHeader*>(buffer.get());
-    if (header->num_merge_ops != num_ops) {
-        LOG(ERROR) << "COW consistency check failed, expected " << num_ops << " to be merged, "
-                   << "but " << header->num_merge_ops << " were actually recorded.";
-        LOG(ERROR) << "Aborting merge progress for snapshot " << name
-                   << ", will try again next boot";
-        return MergeFailureCode::WrongMergeCountConsistencyCheck;
-    }
-
-    return MergeFailureCode::Ok;
-}
-
 MergeFailureCode SnapshotManager::MergeSecondPhaseSnapshots(LockedFile* lock) {
     std::vector<std::string> snapshots;
     if (!ListSnapshots(lock, &snapshots)) {
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index e506110b61a7..4e6b5e1033bd 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -1601,97 +1601,6 @@ TEST_F(SnapshotUpdateTest, SpaceSwapUpdate) {
     }
 }
 
-// Test that a transient merge consistency check failure can resume properly.
-TEST_F(SnapshotUpdateTest, ConsistencyCheckResume) {
-    if (!snapuserd_required_) {
-        // b/179111359
-        GTEST_SKIP() << "Skipping snapuserd test";
-    }
-
-    auto old_sys_size = GetSize(sys_);
-    auto old_prd_size = GetSize(prd_);
-
-    // Grow |sys| but shrink |prd|.
-    SetSize(sys_, old_sys_size * 2);
-    sys_->set_estimate_cow_size(8_MiB);
-    SetSize(prd_, old_prd_size / 2);
-    prd_->set_estimate_cow_size(1_MiB);
-
-    AddOperationForPartitions();
-
-    ASSERT_TRUE(sm->BeginUpdate());
-    ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
-    ASSERT_TRUE(WriteSnapshotAndHash(sys_));
-    ASSERT_TRUE(WriteSnapshotAndHash(vnd_));
-    ASSERT_TRUE(ShiftAllSnapshotBlocks("prd_b", old_prd_size));
-
-    sync();
-
-    // Assert that source partitions aren't affected.
-    for (const auto& name : {"sys_a", "vnd_a", "prd_a"}) {
-        ASSERT_TRUE(IsPartitionUnchanged(name));
-    }
-
-    ASSERT_TRUE(sm->FinishedSnapshotWrites(false));
-
-    // Simulate shutting down the device.
-    ASSERT_TRUE(UnmapAll());
-
-    // After reboot, init does first stage mount.
-    auto init = NewManagerForFirstStageMount("_b");
-    ASSERT_NE(init, nullptr);
-    ASSERT_TRUE(init->NeedSnapshotsInFirstStageMount());
-    ASSERT_TRUE(init->CreateLogicalAndSnapshotPartitions("super", snapshot_timeout_));
-
-    // Check that the target partitions have the same content.
-    for (const auto& name : {"sys_b", "vnd_b", "prd_b"}) {
-        ASSERT_TRUE(IsPartitionUnchanged(name));
-    }
-
-    auto old_checker = init->merge_consistency_checker();
-
-    init->set_merge_consistency_checker(
-            [](const std::string&, const SnapshotStatus&) -> MergeFailureCode {
-                return MergeFailureCode::WrongMergeCountConsistencyCheck;
-            });
-
-    // Initiate the merge and wait for it to be completed.
-    if (ShouldSkipLegacyMerging()) {
-        LOG(INFO) << "Skipping legacy merge in test";
-        return;
-    }
-    ASSERT_TRUE(init->InitiateMerge());
-    ASSERT_EQ(init->IsSnapuserdRequired(), snapuserd_required_);
-    {
-        // Check that the merge phase is FIRST_PHASE until at least one call
-        // to ProcessUpdateState() occurs.
-        ASSERT_TRUE(AcquireLock());
-        auto local_lock = std::move(lock_);
-        auto status = init->ReadSnapshotUpdateStatus(local_lock.get());
-        ASSERT_EQ(status.merge_phase(), MergePhase::FIRST_PHASE);
-    }
-
-    // Merge should have failed.
-    ASSERT_EQ(UpdateState::MergeFailed, init->ProcessUpdateState());
-
-    // Simulate shutting down the device and creating partitions again.
-    ASSERT_TRUE(UnmapAll());
-
-    // Restore the checker.
-    init->set_merge_consistency_checker(std::move(old_checker));
-
-    ASSERT_TRUE(init->CreateLogicalAndSnapshotPartitions("super", snapshot_timeout_));
-
-    // Complete the merge.
-    ASSERT_EQ(UpdateState::MergeCompleted, init->ProcessUpdateState());
-
-    // Check that the target partitions have the same content after the merge.
-    for (const auto& name : {"sys_b", "vnd_b", "prd_b"}) {
-        ASSERT_TRUE(IsPartitionUnchanged(name))
-                << "Content of " << name << " changes after the merge";
-    }
-}
-
 // Test that if new system partitions uses empty space in super, that region is not snapshotted.
 TEST_F(SnapshotUpdateTest, DirectWriteEmptySpace) {
     GTEST_SKIP() << "b/141889746";
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index e886ec399bee..97848fbbd8fc 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -83,6 +83,10 @@ void SnapshotHandler::UpdateMergeCompletionPercentage() {
     SNAP_LOG(DEBUG) << "Merge-complete %: " << merge_completion_percentage_
                     << " num_merge_ops: " << ch->num_merge_ops
                     << " total-ops: " << reader_->get_num_total_data_ops();
+
+    if (ch->num_merge_ops == reader_->get_num_total_data_ops()) {
+        MarkMergeComplete();
+    }
 }
 
 bool SnapshotHandler::CommitMerge(int num_merge_ops) {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index 6a1dab867a31..fa1e7a0ab8e2 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -159,6 +159,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
 
     bool ShouldReconstructDataFromCow() { return populate_data_from_cow_; }
     void FinishReconstructDataFromCow() { populate_data_from_cow_ = false; }
+    void MarkMergeComplete();
     // Return the snapshot status
     std::string GetMergeStatus();
 
@@ -245,6 +246,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     int num_worker_threads_ = kNumWorkerThreads;
     bool perform_verification_ = true;
     bool resume_merge_ = false;
+    bool merge_complete_ = false;
 
     std::unique_ptr<UpdateVerify> update_verify_;
     std::shared_ptr<IBlockServerOpener> block_server_opener_;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
index 8d090bf58955..2ad4ea1c29d6 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
@@ -386,10 +386,16 @@ void SnapshotHandler::WaitForRaThreadToStart() {
     }
 }
 
+void SnapshotHandler::MarkMergeComplete() {
+    std::lock_guard<std::mutex> lock(lock_);
+    merge_complete_ = true;
+}
+
 std::string SnapshotHandler::GetMergeStatus() {
     bool merge_not_initiated = false;
     bool merge_monitored = false;
     bool merge_failed = false;
+    bool merge_complete = false;
 
     {
         std::lock_guard<std::mutex> lock(lock_);
@@ -405,10 +411,9 @@ std::string SnapshotHandler::GetMergeStatus() {
         if (io_state_ == MERGE_IO_TRANSITION::MERGE_FAILED) {
             merge_failed = true;
         }
-    }
 
-    struct CowHeader* ch = reinterpret_cast<struct CowHeader*>(mapped_addr_);
-    bool merge_complete = (ch->num_merge_ops == reader_->get_num_total_data_ops());
+        merge_complete = merge_complete_;
+    }
 
     if (merge_not_initiated) {
         // Merge was not initiated yet; however, we have merge completion
@@ -444,7 +449,6 @@ std::string SnapshotHandler::GetMergeStatus() {
         return "snapshot-merge-failed";
     }
 
-    // Merge complete
     if (merge_complete) {
         return "snapshot-merge-complete";
     }

From f7d07db67915c63b6e4ff2675f05cda7016db747 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 13 Oct 2023 20:32:29 -0700
Subject: [PATCH 0473/1487] snapuserd: Test both async and sync paths.

Rather than split this into two binaries as we did for libsnapshot, this
uses test parameterization. I went this route because even for async
builds, the sync path must always work as a fallback.

Bug: N/A
Test: snapuserd_test
Change-Id: Ib68c8fd831c345f41a4e14a99fd0a0b8b1d47b6d
---
 .../user-space-merge/snapuserd_core.cpp       | 20 +-----
 .../user-space-merge/snapuserd_test.cpp       | 62 ++++++++++++-------
 fs_mgr/libsnapshot/snapuserd/utility.cpp      | 15 +++++
 fs_mgr/libsnapshot/snapuserd/utility.h        |  1 +
 4 files changed, 56 insertions(+), 42 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index e886ec399bee..474ba7dbcd3c 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -16,8 +16,6 @@
 
 #include "snapuserd_core.h"
 
-#include <sys/utsname.h>
-
 #include <android-base/chrono_utils.h>
 #include <android-base/properties.h>
 #include <android-base/scopeguard.h>
@@ -26,6 +24,7 @@
 
 #include "merge_worker.h"
 #include "read_worker.h"
+#include "utility.h"
 
 namespace android {
 namespace snapshot {
@@ -417,22 +416,7 @@ struct BufferState* SnapshotHandler::GetBufferState() {
 }
 
 bool SnapshotHandler::IsIouringSupported() {
-    struct utsname uts;
-    unsigned int major, minor;
-
-    if ((uname(&uts) != 0) || (sscanf(uts.release, "%u.%u", &major, &minor) != 2)) {
-        SNAP_LOG(ERROR) << "Could not parse the kernel version from uname. "
-                        << " io_uring not supported";
-        return false;
-    }
-
-    // We will only support kernels from 5.6 onwards as IOSQE_ASYNC flag and
-    // IO_URING_OP_READ/WRITE opcodes were introduced only on 5.6 kernel
-    if (major >= 5) {
-        if (major == 5 && minor < 6) {
-            return false;
-        }
-    } else {
+    if (!KernelSupportsIoUring()) {
         return false;
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 65f31cf7c7cb..bed71cf9f6e0 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -47,8 +47,6 @@
 #include "testing/temp_device.h"
 #include "utility.h"
 
-DEFINE_string(force_config, "", "Force testing mode with iouring disabled");
-
 namespace android {
 namespace snapshot {
 
@@ -62,7 +60,7 @@ using testing::AssertionFailure;
 using testing::AssertionResult;
 using testing::AssertionSuccess;
 
-class SnapuserdTestBase : public ::testing::Test {
+class SnapuserdTestBase : public ::testing::TestWithParam<bool> {
   protected:
     void SetUp() override;
     void TearDown() override;
@@ -627,16 +625,11 @@ void SnapuserdTest::CreateCowDeviceOrderedOps() {
 }
 
 void SnapuserdTest::InitCowDevice() {
-    bool use_iouring = true;
-    if (FLAGS_force_config == "iouring_disabled") {
-        use_iouring = false;
-    }
-
     auto factory = harness_->GetBlockServerFactory();
     auto opener = factory->CreateOpener(system_device_ctrl_name_);
     auto handler =
             handlers_->AddHandler(system_device_ctrl_name_, cow_system_->path, base_dev_->GetPath(),
-                                  base_dev_->GetPath(), opener, 1, use_iouring, false);
+                                  base_dev_->GetPath(), opener, 1, GetParam(), false);
     ASSERT_NE(handler, nullptr);
     ASSERT_NE(handler->snapuserd(), nullptr);
 #ifdef __ANDROID__
@@ -780,7 +773,7 @@ void SnapuserdTest::MergeInterrupt() {
     ASSERT_TRUE(Merge());
 }
 
-TEST_F(SnapuserdTest, Snapshot_IO_TEST) {
+TEST_P(SnapuserdTest, Snapshot_IO_TEST) {
     if (!harness_->HasUserDevice()) {
         GTEST_SKIP() << "Skipping snapshot read; not supported";
     }
@@ -794,7 +787,7 @@ TEST_F(SnapuserdTest, Snapshot_IO_TEST) {
     ASSERT_NO_FATAL_FAILURE(ReadSnapshotDeviceAndValidate());
 }
 
-TEST_F(SnapuserdTest, Snapshot_MERGE_IO_TEST) {
+TEST_P(SnapuserdTest, Snapshot_MERGE_IO_TEST) {
     if (!harness_->HasUserDevice()) {
         GTEST_SKIP() << "Skipping snapshot read; not supported";
     }
@@ -808,7 +801,7 @@ TEST_F(SnapuserdTest, Snapshot_MERGE_IO_TEST) {
     read_future.wait();
 }
 
-TEST_F(SnapuserdTest, Snapshot_MERGE_IO_TEST_1) {
+TEST_P(SnapuserdTest, Snapshot_MERGE_IO_TEST_1) {
     if (!harness_->HasUserDevice()) {
         GTEST_SKIP() << "Skipping snapshot read; not supported";
     }
@@ -823,31 +816,31 @@ TEST_F(SnapuserdTest, Snapshot_MERGE_IO_TEST_1) {
     read_future.wait();
 }
 
-TEST_F(SnapuserdTest, Snapshot_Merge_Resume) {
+TEST_P(SnapuserdTest, Snapshot_Merge_Resume) {
     ASSERT_NO_FATAL_FAILURE(SetupDefault());
     ASSERT_NO_FATAL_FAILURE(MergeInterrupt());
     ValidateMerge();
 }
 
-TEST_F(SnapuserdTest, Snapshot_COPY_Overlap_TEST_1) {
+TEST_P(SnapuserdTest, Snapshot_COPY_Overlap_TEST_1) {
     ASSERT_NO_FATAL_FAILURE(SetupCopyOverlap_1());
     ASSERT_TRUE(Merge());
     ValidateMerge();
 }
 
-TEST_F(SnapuserdTest, Snapshot_COPY_Overlap_TEST_2) {
+TEST_P(SnapuserdTest, Snapshot_COPY_Overlap_TEST_2) {
     ASSERT_NO_FATAL_FAILURE(SetupCopyOverlap_2());
     ASSERT_TRUE(Merge());
     ValidateMerge();
 }
 
-TEST_F(SnapuserdTest, Snapshot_COPY_Overlap_Merge_Resume_TEST) {
+TEST_P(SnapuserdTest, Snapshot_COPY_Overlap_Merge_Resume_TEST) {
     ASSERT_NO_FATAL_FAILURE(SetupCopyOverlap_1());
     ASSERT_NO_FATAL_FAILURE(MergeInterrupt());
     ValidateMerge();
 }
 
-TEST_F(SnapuserdTest, Snapshot_COPY_Overlap_Merge_Resume_IO_Validate_TEST) {
+TEST_P(SnapuserdTest, Snapshot_COPY_Overlap_Merge_Resume_IO_Validate_TEST) {
     if (!harness_->HasUserDevice()) {
         GTEST_SKIP() << "Skipping snapshot read; not supported";
     }
@@ -856,25 +849,25 @@ TEST_F(SnapuserdTest, Snapshot_COPY_Overlap_Merge_Resume_IO_Validate_TEST) {
     ValidateMerge();
 }
 
-TEST_F(SnapuserdTest, Snapshot_Merge_Crash_Fixed_Ordered) {
+TEST_P(SnapuserdTest, Snapshot_Merge_Crash_Fixed_Ordered) {
     ASSERT_NO_FATAL_FAILURE(SetupOrderedOps());
     ASSERT_NO_FATAL_FAILURE(MergeInterruptFixed(300));
     ValidateMerge();
 }
 
-TEST_F(SnapuserdTest, Snapshot_Merge_Crash_Random_Ordered) {
+TEST_P(SnapuserdTest, Snapshot_Merge_Crash_Random_Ordered) {
     ASSERT_NO_FATAL_FAILURE(SetupOrderedOps());
     ASSERT_NO_FATAL_FAILURE(MergeInterruptRandomly(500));
     ValidateMerge();
 }
 
-TEST_F(SnapuserdTest, Snapshot_Merge_Crash_Fixed_Inverted) {
+TEST_P(SnapuserdTest, Snapshot_Merge_Crash_Fixed_Inverted) {
     ASSERT_NO_FATAL_FAILURE(SetupOrderedOpsInverted());
     ASSERT_NO_FATAL_FAILURE(MergeInterruptFixed(50));
     ValidateMerge();
 }
 
-TEST_F(SnapuserdTest, Snapshot_Merge_Crash_Random_Inverted) {
+TEST_P(SnapuserdTest, Snapshot_Merge_Crash_Random_Inverted) {
     ASSERT_NO_FATAL_FAILURE(SetupOrderedOpsInverted());
     ASSERT_NO_FATAL_FAILURE(MergeInterruptRandomly(50));
     ValidateMerge();
@@ -941,7 +934,7 @@ AssertionResult HandlerTest::ReadSectors(sector_t sector, uint64_t size, void* b
 }
 
 // This test mirrors ReadSnapshotDeviceAndValidate.
-TEST_F(HandlerTest, Read) {
+TEST_P(HandlerTest, Read) {
     std::unique_ptr<uint8_t[]> snapuserd_buffer = std::make_unique<uint8_t[]>(size_);
 
     // COPY
@@ -970,20 +963,41 @@ TEST_F(HandlerTest, Read) {
     ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + (size_ * 4), size_), 0);
 }
 
-TEST_F(HandlerTest, ReadUnalignedSector) {
+TEST_P(HandlerTest, ReadUnalignedSector) {
     std::unique_ptr<uint8_t[]> snapuserd_buffer = std::make_unique<uint8_t[]>(BLOCK_SZ);
 
     ASSERT_TRUE(ReadSectors(1, BLOCK_SZ, snapuserd_buffer.get()));
     ASSERT_EQ(memcmp(snapuserd_buffer.get(), orig_buffer_.get() + SECTOR_SIZE, BLOCK_SZ), 0);
 }
 
-TEST_F(HandlerTest, ReadUnalignedSize) {
+TEST_P(HandlerTest, ReadUnalignedSize) {
     std::unique_ptr<uint8_t[]> snapuserd_buffer = std::make_unique<uint8_t[]>(SECTOR_SIZE);
 
     ASSERT_TRUE(ReadSectors(0, SECTOR_SIZE, snapuserd_buffer.get()));
     ASSERT_EQ(memcmp(snapuserd_buffer.get(), orig_buffer_.get(), SECTOR_SIZE), 0);
 }
 
+std::vector<bool> GetIoUringConfigs() {
+#if __ANDROID__
+    if (!android::base::GetBoolProperty("ro.virtual_ab.io_uring.enabled", false)) {
+        return {false};
+    }
+#endif
+    if (!KernelSupportsIoUring()) {
+        return {false};
+    }
+    return {false, true};
+}
+
+std::string IoUringConfigName(const testing::TestParamInfo<SnapuserdTest::ParamType>& info) {
+    return info.param ? "io_uring" : "sync";
+}
+
+INSTANTIATE_TEST_SUITE_P(Io, SnapuserdTest, ::testing::ValuesIn(GetIoUringConfigs()),
+                         IoUringConfigName);
+INSTANTIATE_TEST_SUITE_P(Io, HandlerTest, ::testing::ValuesIn(GetIoUringConfigs()),
+                         IoUringConfigName);
+
 }  // namespace snapshot
 }  // namespace android
 
diff --git a/fs_mgr/libsnapshot/snapuserd/utility.cpp b/fs_mgr/libsnapshot/snapuserd/utility.cpp
index a84a7c14fc5e..fcdb69dd1ae7 100644
--- a/fs_mgr/libsnapshot/snapuserd/utility.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/utility.cpp
@@ -15,6 +15,7 @@
 #include "utility.h"
 
 #include <sys/resource.h>
+#include <sys/utsname.h>
 #include <unistd.h>
 
 #include <android-base/file.h>
@@ -32,5 +33,19 @@ bool SetThreadPriority([[maybe_unused]] int priority) {
 #endif
 }
 
+bool KernelSupportsIoUring() {
+    struct utsname uts {};
+    unsigned int major, minor;
+
+    uname(&uts);
+    if (sscanf(uts.release, "%u.%u", &major, &minor) != 2) {
+        return false;
+    }
+
+    // We will only support kernels from 5.6 onwards as IOSQE_ASYNC flag and
+    // IO_URING_OP_READ/WRITE opcodes were introduced only on 5.6 kernel
+    return major > 5 || (major == 5 && minor >= 6);
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/utility.h b/fs_mgr/libsnapshot/snapuserd/utility.h
index 58ec3e63a3b3..255aee195014 100644
--- a/fs_mgr/libsnapshot/snapuserd/utility.h
+++ b/fs_mgr/libsnapshot/snapuserd/utility.h
@@ -18,6 +18,7 @@ namespace android {
 namespace snapshot {
 
 bool SetThreadPriority(int priority);
+bool KernelSupportsIoUring();
 
 }  // namespace snapshot
 }  // namespace android

From 7a19bf8e0dffa084e0cc342500afa0632669248a Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 16 Oct 2023 22:28:11 +0000
Subject: [PATCH 0474/1487] init: don't use magic numbers for RLIMIT_
 constants.

Also, why are we accepting the completely made-up "RLIM_AS" but not the
real "RLIMIT_AS" in .rc files?

Bug: http://b/293894041
Test: treehugger
Change-Id: I18b10b6dd77265a9a14b88bfdf1cc0b474800a94
---
 init/rlimit_parser.cpp      | 14 ++++++++++----
 init/rlimit_parser_test.cpp | 20 ++++++++++++++++++++
 2 files changed, 30 insertions(+), 4 deletions(-)

diff --git a/init/rlimit_parser.cpp b/init/rlimit_parser.cpp
index 476a46ab8ff6..c2a3fa1298a1 100644
--- a/init/rlimit_parser.cpp
+++ b/init/rlimit_parser.cpp
@@ -30,10 +30,14 @@ namespace init {
 // Builtins and service definitions both have their arguments start at 1 and finish at 3.
 Result<std::pair<int, rlimit>> ParseRlimit(const std::vector<std::string>& args) {
     static const std::vector<std::pair<const char*, int>> text_to_resources = {
-        {"cpu", 0},       {"fsize", 1}, {"data", 2},    {"stack", 3},
-        {"core", 4},      {"rss", 5},   {"nproc", 6},   {"nofile", 7},
-        {"memlock", 8},   {"as", 9},    {"locks", 10},  {"sigpending", 11},
-        {"msgqueue", 12}, {"nice", 13}, {"rtprio", 14}, {"rttime", 15},
+            {"cpu", RLIMIT_CPU},           {"fsize", RLIMIT_FSIZE},
+            {"data", RLIMIT_DATA},         {"stack", RLIMIT_STACK},
+            {"core", RLIMIT_CORE},         {"rss", RLIMIT_RSS},
+            {"nproc", RLIMIT_NPROC},       {"nofile", RLIMIT_NOFILE},
+            {"memlock", RLIMIT_MEMLOCK},   {"as", RLIMIT_AS},
+            {"locks", RLIMIT_LOCKS},       {"sigpending", RLIMIT_SIGPENDING},
+            {"msgqueue", RLIMIT_MSGQUEUE}, {"nice", RLIMIT_NICE},
+            {"rtprio", RLIMIT_RTPRIO},     {"rttime", RLIMIT_RTTIME},
     };
 
     int resource;
@@ -49,6 +53,8 @@ Result<std::pair<int, rlimit>> ParseRlimit(const std::vector<std::string>& args)
         std::string resource_string;
         if (StartsWith(args[1], "RLIM_")) {
             resource_string = args[1].substr(5);
+        } else if (StartsWith(args[1], "RLIMIT_")) {
+            resource_string = args[1].substr(7);
         } else {
             resource_string = args[1];
         }
diff --git a/init/rlimit_parser_test.cpp b/init/rlimit_parser_test.cpp
index 3c3f848b5e4e..a6955f6b4745 100644
--- a/init/rlimit_parser_test.cpp
+++ b/init/rlimit_parser_test.cpp
@@ -67,6 +67,7 @@ TEST(rlimit, RlimitSuccess) {
                     {{"rtprio", "10", "10"}, {14, {10, 10}}},
                     {{"rttime", "10", "10"}, {15, {10, 10}}},
 
+                    // For some reason, we spelled these wrong.
                     {{"RLIM_CPU", "10", "10"}, {0, {10, 10}}},
                     {{"RLIM_FSIZE", "10", "10"}, {1, {10, 10}}},
                     {{"RLIM_DATA", "10", "10"}, {2, {10, 10}}},
@@ -84,6 +85,24 @@ TEST(rlimit, RlimitSuccess) {
                     {{"RLIM_RTPRIO", "10", "10"}, {14, {10, 10}}},
                     {{"RLIM_RTTIME", "10", "10"}, {15, {10, 10}}},
 
+                    // These are the correct spellings.
+                    {{"RLIMIT_CPU", "10", "10"}, {0, {10, 10}}},
+                    {{"RLIMIT_FSIZE", "10", "10"}, {1, {10, 10}}},
+                    {{"RLIMIT_DATA", "10", "10"}, {2, {10, 10}}},
+                    {{"RLIMIT_STACK", "10", "10"}, {3, {10, 10}}},
+                    {{"RLIMIT_CORE", "10", "10"}, {4, {10, 10}}},
+                    {{"RLIMIT_RSS", "10", "10"}, {5, {10, 10}}},
+                    {{"RLIMIT_NPROC", "10", "10"}, {6, {10, 10}}},
+                    {{"RLIMIT_NOFILE", "10", "10"}, {7, {10, 10}}},
+                    {{"RLIMIT_MEMLOCK", "10", "10"}, {8, {10, 10}}},
+                    {{"RLIMIT_AS", "10", "10"}, {9, {10, 10}}},
+                    {{"RLIMIT_LOCKS", "10", "10"}, {10, {10, 10}}},
+                    {{"RLIMIT_SIGPENDING", "10", "10"}, {11, {10, 10}}},
+                    {{"RLIMIT_MSGQUEUE", "10", "10"}, {12, {10, 10}}},
+                    {{"RLIMIT_NICE", "10", "10"}, {13, {10, 10}}},
+                    {{"RLIMIT_RTPRIO", "10", "10"}, {14, {10, 10}}},
+                    {{"RLIMIT_RTTIME", "10", "10"}, {15, {10, 10}}},
+
                     {{"0", "10", "10"}, {0, {10, 10}}},
                     {{"1", "10", "10"}, {1, {10, 10}}},
                     {{"2", "10", "10"}, {2, {10, 10}}},
@@ -113,6 +132,7 @@ TEST(rlimit, RlimitFailure) {
             {{"100", "10", "10"}, "Resource '100' over the maximum resource value '16'"},
             {{"bad_string", "10", "10"}, "Could not parse resource 'bad_string'"},
             {{"RLIM_", "10", "10"}, "Could not parse resource 'RLIM_'"},
+            {{"RLIMIT_", "10", "10"}, "Could not parse resource 'RLIMIT_'"},
             {{"cpu", "abc", "10"}, "Could not parse soft limit 'abc'"},
             {{"cpu", "10", "abc"}, "Could not parse hard limit 'abc'"},
             {{"cpu", "unlimit", "10"}, "Could not parse soft limit 'unlimit'"},

From 06c086dd731b503d55b5c5979e6f97dc34b34dc7 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 10 Oct 2023 15:09:55 -0700
Subject: [PATCH 0475/1487] Rename basic_v2_writer

Gonna add to this binary options to write v2 + v3 cow, + some additional
configurations (for testing purposes). I think this binary can serve as
something to use in parallel with inspect_cow

Test: m write_cow
Change-Id: I93c703b246baa5b400044436a94b33a32e03ea68
---
 fs_mgr/libsnapshot/tools/Android.bp                           | 4 ++--
 .../tools/{basic_v2_cow_writer.cpp => write_cow.cpp}          | 0
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename fs_mgr/libsnapshot/tools/{basic_v2_cow_writer.cpp => write_cow.cpp} (100%)

diff --git a/fs_mgr/libsnapshot/tools/Android.bp b/fs_mgr/libsnapshot/tools/Android.bp
index 0f0828699dc7..a7449b4b6c8b 100644
--- a/fs_mgr/libsnapshot/tools/Android.bp
+++ b/fs_mgr/libsnapshot/tools/Android.bp
@@ -23,14 +23,14 @@ cc_binary {
 
 
 cc_binary {
-    name: "basic_v2_cow_writer",
+    name: "write_cow",
     host_supported: true,
     defaults: [
         "fs_mgr_defaults",
         "libsnapshot_cow_defaults",
     ],
 
-    srcs: ["basic_v2_cow_writer.cpp"],
+    srcs: ["write_cow.cpp"],
 
     static_libs: [
         "libsnapshot_cow",
diff --git a/fs_mgr/libsnapshot/tools/basic_v2_cow_writer.cpp b/fs_mgr/libsnapshot/tools/write_cow.cpp
similarity index 100%
rename from fs_mgr/libsnapshot/tools/basic_v2_cow_writer.cpp
rename to fs_mgr/libsnapshot/tools/write_cow.cpp

From f0a28dae2836a88b187e4e54776f2eb1f26c02f9 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 10 Oct 2023 15:48:25 -0700
Subject: [PATCH 0476/1487] Add write_cow functionality

Adding gflags + some basic functionality to this binary. We should be
able to use this to write v2 or v3 cow, and then use inspect_cow to
inspect the contents

Test: write_cow
Change-Id: I44bf5a8c807c4c4759e54624c51e966f2ea18ce9
---
 fs_mgr/libsnapshot/tools/Android.bp    |  1 +
 fs_mgr/libsnapshot/tools/write_cow.cpp | 59 ++++++++++++++++++++++++--
 2 files changed, 56 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/tools/Android.bp b/fs_mgr/libsnapshot/tools/Android.bp
index a7449b4b6c8b..a1c92c03beae 100644
--- a/fs_mgr/libsnapshot/tools/Android.bp
+++ b/fs_mgr/libsnapshot/tools/Android.bp
@@ -34,6 +34,7 @@ cc_binary {
 
     static_libs: [
         "libsnapshot_cow",
+        "libgflags",
     ],
 
     shared_libs: [
diff --git a/fs_mgr/libsnapshot/tools/write_cow.cpp b/fs_mgr/libsnapshot/tools/write_cow.cpp
index 72fb0f547b6a..bd51174dd7e3 100644
--- a/fs_mgr/libsnapshot/tools/write_cow.cpp
+++ b/fs_mgr/libsnapshot/tools/write_cow.cpp
@@ -18,10 +18,18 @@
 #include <libsnapshot/cow_compress.h>
 #include <libsnapshot/cow_format.h>
 #include <libsnapshot/cow_writer.h>
-#include <filesystem>
+
+#include <gflags/gflags.h>
+#include <iostream>
 
 #include "android-base/unique_fd.h"
 
+DEFINE_bool(silent, false, "Run silently");
+DEFINE_int32(writer_version, 2, "which version of COW writer to be used");
+DEFINE_bool(write_legacy, false,
+            "Writes a legacy cow_v2 in current directory, this cow was used to test backwards "
+            "compatibility between version 2 and version 3");
+DEFINE_bool(write_header, false, "Test reading/writing just the header");
 using namespace android::snapshot;
 
 // This writes a simple cow v2 file in the current directory. This file will serve as testdata for
@@ -29,7 +37,7 @@ using namespace android::snapshot;
 //
 // WARNING: We should not be overriding this test file, as it will serve as historic marker for what
 // a device with old writer_v2 will write as a cow.
-void write_cow_v2() {
+static void write_legacy_cow_v2() {
     CowOptions options;
     options.cluster_ops = 5;
     options.num_merge_ops = 1;
@@ -58,6 +66,49 @@ void write_cow_v2() {
     writer->Finalize();
 }
 
-int main() {
-    write_cow_v2();
+static bool WriteCow(const std::string& path) {
+    android::base::unique_fd fd(open(path.c_str(), O_RDONLY));
+    fd.reset(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0664));
+    if (fd < 0) {
+        PLOG(ERROR) << "could not open " << path << " for writing";
+        return false;
+    }
+    CowOptions options;
+    std::string data = "This is some data, believe it";
+    data.resize(options.block_size, '\0');
+
+    std::unique_ptr<ICowWriter> writer =
+            CreateCowWriter(FLAGS_writer_version, options, std::move(fd));
+    if (!writer) {
+        return false;
+    }
+
+    writer->AddCopy(0, 5);
+    writer->AddRawBlocks(2, data.data(), data.size());
+    writer->AddLabel(1);
+    writer->AddXorBlocks(50, data.data(), data.size(), 24, 10);
+    writer->AddZeroBlocks(5, 10);
+    writer->AddLabel(2);
+    writer->Finalize();
+
+    if (!FLAGS_silent) {
+        std::cout << "Writing COW with writer v" << FLAGS_writer_version << "\n";
+    }
+
+    return true;
+}
+
+int main(int argc, char** argv) {
+    gflags::ParseCommandLineFlags(&argc, &argv, true);
+    if (FLAGS_write_legacy) {
+        write_legacy_cow_v2();
+        return 0;
+    }
+    if (argc < 2) {
+        gflags::ShowUsageWithFlags(argv[0]);
+        return 1;
+    }
+    if (!WriteCow(argv[1])) {
+        return 1;
+    }
 }

From 94a732e0266926315910c007a201fea2cf0a3859 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 16 Oct 2023 19:53:57 -0700
Subject: [PATCH 0477/1487] Remove duplicate parser v2 code

Remove a duplicate check

Test: th
Change-Id: Ia9c3c8ff1ee524005f95aa57dc3d6da9641ce2e6
---
 fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
index a7307bf63931..8f2031783f5f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
@@ -46,15 +46,6 @@ bool CowParserV2::Parse(borrowed_fd fd, const CowHeader& header, std::optional<u
         LOG(ERROR) << "Clusters must contain at least two operations to function.";
         return false;
     }
-    if (header_.op_size != sizeof(CowOperationV2)) {
-        LOG(ERROR) << "Operation size unknown, read " << header_.op_size << ", expected "
-                   << sizeof(CowOperationV2);
-        return false;
-    }
-    if (header_.cluster_ops == 1) {
-        LOG(ERROR) << "Clusters must contain at least two operations to function.";
-        return false;
-    }
 
     if ((header_.prefix.major_version > kCowVersionMajor) ||
         (header_.prefix.minor_version != kCowVersionMinor)) {

From f8c50df1c74c5f72d38514050dfc3a7fd32c0c6d Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 17 Oct 2023 10:44:49 -0700
Subject: [PATCH 0478/1487] Remove v2_writer lseek call

Removing lseek call as writefully() should be sufficient in ensuring our
fd is moved to the correct spot

Test: cow_api_test
Change-Id: I404b192335ab1672ed61de426e17e63ab9d51ece
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index a6f449faac5e..63bed0741d0a 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -262,11 +262,6 @@ bool CowWriterV2::OpenForWrite() {
         return false;
     }
 
-    if (lseek(fd_.get(), sizeof(CowHeader) + header_.buffer_size, SEEK_SET) < 0) {
-        PLOG(ERROR) << "lseek failed";
-        return false;
-    }
-
     InitPos();
     InitBatchWrites();
 

From f2270d2bb67c78e4c8071c5249ba1b2ea4d435b2 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 5 Oct 2023 10:20:05 -0700
Subject: [PATCH 0479/1487] V3 writer header

V3 writer set up header. Anything related to cluster ops can be set to
zero, as V3 cow format will no longer support this. All footer related
code can also be dropped as the footer isn't being used.

Test: cow_api_test
Change-Id: I39ece8eaa0813c5991d53b5e0ff9271f27e0662a
---
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 110 +++++++++++++++++-
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |  16 +++
 2 files changed, 122 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 2b9867ef1b0c..5ae5f19b7a33 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -54,14 +54,116 @@ static_assert(sizeof(off_t) == sizeof(uint64_t));
 using android::base::unique_fd;
 
 CowWriterV3::CowWriterV3(const CowOptions& options, unique_fd&& fd)
-    : CowWriterBase(options, std::move(fd)) {}
+    : CowWriterBase(options, std::move(fd)) {
+    SetupHeaders();
+}
+
+void CowWriterV3::SetupHeaders() {
+    header_ = {};
+    header_.prefix.magic = kCowMagicNumber;
+    header_.prefix.major_version = 3;
+    header_.prefix.minor_version = 0;
+    header_.prefix.header_size = sizeof(CowHeaderV3);
+    header_.footer_size = 0;
+    header_.op_size = sizeof(CowOperationV3);
+    header_.block_size = options_.block_size;
+    header_.num_merge_ops = options_.num_merge_ops;
+    header_.cluster_ops = 0;
+    if (options_.scratch_space) {
+        header_.buffer_size = BUFFER_REGION_DEFAULT_SIZE;
+    }
+
+    // v3 specific fields
+    // WIP: not quite sure how some of these are calculated yet, assuming buffer_size is determined
+    // during COW size estimation
+    header_.sequence_buffer_offset = 0;
+    header_.resume_buffer_size = 0;
+    header_.op_buffer_size = 0;
+    header_.compression_algorithm = kCowCompressNone;
+    return;
+}
+
+bool CowWriterV3::ParseOptions() {
+    num_compress_threads_ = std::max(options_.num_compress_threads, 1);
+    auto parts = android::base::Split(options_.compression, ",");
+    if (parts.size() > 2) {
+        LOG(ERROR) << "failed to parse compression parameters: invalid argument count: "
+                   << parts.size() << " " << options_.compression;
+        return false;
+    }
+    auto algorithm = CompressionAlgorithmFromString(parts[0]);
+    if (!algorithm) {
+        LOG(ERROR) << "unrecognized compression: " << options_.compression;
+        return false;
+    }
+    if (parts.size() > 1) {
+        if (!android::base::ParseUint(parts[1], &compression_.compression_level)) {
+            LOG(ERROR) << "failed to parse compression level invalid type: " << parts[1];
+            return false;
+        }
+    } else {
+        compression_.compression_level =
+                CompressWorker::GetDefaultCompressionLevel(algorithm.value());
+    }
+
+    compression_.algorithm = *algorithm;
+    return true;
+}
 
 CowWriterV3::~CowWriterV3() {}
 
 bool CowWriterV3::Initialize(std::optional<uint64_t> label) {
-    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
-    if (label) return false;
-    return false;
+    if (!InitFd() || !ParseOptions()) {
+        return false;
+    }
+
+    CHECK(!label.has_value());
+
+    if (!OpenForWrite()) {
+        return false;
+    }
+
+    return true;
+}
+
+bool CowWriterV3::OpenForWrite() {
+    // This limitation is tied to the data field size in CowOperationV2.
+    // Keeping this for V3 writer <- although we
+    if (header_.block_size > std::numeric_limits<uint16_t>::max()) {
+        LOG(ERROR) << "Block size is too large";
+        return false;
+    }
+
+    if (lseek(fd_.get(), 0, SEEK_SET) < 0) {
+        PLOG(ERROR) << "lseek failed";
+        return false;
+    }
+
+    // Headers are not complete, but this ensures the file is at the right
+    // position.
+    if (!android::base::WriteFully(fd_, &header_, sizeof(header_))) {
+        PLOG(ERROR) << "write failed";
+        return false;
+    }
+
+    if (options_.scratch_space) {
+        // Initialize the scratch space
+        std::string data(header_.buffer_size, 0);
+        if (!android::base::WriteFully(fd_, data.data(), header_.buffer_size)) {
+            PLOG(ERROR) << "writing scratch space failed";
+            return false;
+        }
+    }
+
+    if (!Sync()) {
+        LOG(ERROR) << "Header sync failed";
+        return false;
+    }
+
+    next_op_pos_ = 0;
+    next_data_pos_ = 0;
+
+    return true;
 }
 
 bool CowWriterV3::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index ddd72873c1b8..2a88a12bca60 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -37,6 +37,22 @@ class CowWriterV3 : public CowWriterBase {
     virtual bool EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) override;
     virtual bool EmitLabel(uint64_t label) override;
     virtual bool EmitSequenceData(size_t num_ops, const uint32_t* data) override;
+
+  private:
+    void SetupHeaders();
+    bool ParseOptions();
+    bool OpenForWrite();
+
+  private:
+    CowHeaderV3 header_{};
+    CowCompression compression_;
+    // in the case that we are using one thread for compression, we can store and re-use the same
+    // compressor
+
+    uint64_t next_op_pos_ = 0;
+    uint64_t next_data_pos_ = 0;
+
+    int num_compress_threads_ = 1;
 };
 
 }  // namespace snapshot

From 7a9e007a01d50157bc70db82985a91df8ee0ae43 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 16 Oct 2023 20:12:56 -0700
Subject: [PATCH 0480/1487] Refactor off COW header v3

Cow reader will store header v3 in memory. ReadCowHeader can remain
mostly unchanged since the cow prefix is the same.
header->prefix.header_size will then tell us if we're reading a v3 or v2
header. v3 header is strictly a superset of v2 header so we can read a
v2 header into a v3 struct.

Added a test case to test_v3 where we write a header using v2_writer and
ensure CowReader is able to read it.

Test: cow_api_test
Change-Id: I142f18d871322930b7dc341c342c8b63a481341c
---
 .../include/libsnapshot/cow_reader.h          |  7 ++++--
 .../libsnapshot_cow/cow_reader.cpp            |  7 +++---
 .../libsnapshot_cow/inspect_cow.cpp           |  2 +-
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 24 +++++++++++++++++++
 .../libsnapshot/libsnapshot_cow/writer_v2.cpp |  4 +++-
 fs_mgr/libsnapshot/snapshot.cpp               |  2 +-
 6 files changed, 38 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index 27219379624e..debaf3683c9f 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -172,7 +172,7 @@ class CowReader final : public ICowReader {
 
     android::base::unique_fd owned_fd_;
     android::base::borrowed_fd fd_;
-    CowHeader header_;
+    CowHeaderV3 header_;
     std::optional<CowFooter> footer_;
     uint64_t fd_size_;
     std::optional<uint64_t> last_label_;
@@ -188,7 +188,10 @@ class CowReader final : public ICowReader {
     uint8_t compression_type_ = kCowCompressNone;
 };
 
-bool ReadCowHeader(android::base::borrowed_fd fd, CowHeader* header);
+// Though this function takes in a CowHeaderV3, the struct could be populated as a v1/v2 CowHeader.
+// The extra fields will just be filled as 0. V3 header is strictly a superset of v1/v2 header and
+// contains all of the latter's field
+bool ReadCowHeader(android::base::borrowed_fd fd, CowHeaderV3* header);
 
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 607d610848c0..3b84c95ccb2e 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -28,12 +28,13 @@
 #include <zlib.h>
 
 #include "cow_decompress.h"
+#include "libsnapshot/cow_format.h"
 #include "parser_v2.h"
 
 namespace android {
 namespace snapshot {
 
-bool ReadCowHeader(android::base::borrowed_fd fd, CowHeader* header) {
+bool ReadCowHeader(android::base::borrowed_fd fd, CowHeaderV3* header) {
     if (lseek(fd.get(), 0, SEEK_SET) < 0) {
         PLOG(ERROR) << "lseek header failed";
         return false;
@@ -49,9 +50,9 @@ bool ReadCowHeader(android::base::borrowed_fd fd, CowHeader* header) {
                    << "Expected: " << kCowMagicNumber;
         return false;
     }
-    if (header->prefix.header_size > sizeof(CowHeader)) {
+    if (header->prefix.header_size > sizeof(CowHeaderV3)) {
         LOG(ERROR) << "Unknown CowHeader size (got " << header->prefix.header_size
-                   << " bytes, expected at most " << sizeof(CowHeader) << " bytes)";
+                   << " bytes, expected at most " << sizeof(CowHeaderV3) << " bytes)";
         return false;
     }
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
index 83b5a12955a7..a29146985142 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
@@ -90,7 +90,7 @@ static bool ShowRawOpStreamV2(borrowed_fd fd, const CowHeader& header) {
 }
 
 static bool ShowRawOpStream(borrowed_fd fd) {
-    CowHeader header;
+    CowHeaderV3 header;
     if (!ReadCowHeader(fd, &header)) {
         LOG(ERROR) << "parse header failed";
         return false;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 2373d4df5bf3..cc8dd8360187 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -26,7 +26,9 @@
 #include <libsnapshot/cow_writer.h>
 #include "cow_decompress.h"
 #include "libsnapshot/cow_format.h"
+#include "writer_v2.h"
 #include "writer_v3.h"
+
 using android::base::unique_fd;
 using testing::AssertionFailure;
 using testing::AssertionResult;
@@ -49,5 +51,27 @@ class CowOperationV3Test : public ::testing::Test {
     std::unique_ptr<TemporaryFile> cow_;
 };
 
+TEST_F(CowOperationV3Test, CowHeaderV2Test) {
+    CowOptions options;
+    options.cluster_ops = 5;
+    options.num_merge_ops = 1;
+    options.block_size = 4096;
+    std::string data = "This is some data, believe it";
+    data.resize(options.block_size, '\0');
+    auto writer_v2 = std::make_unique<CowWriterV2>(options, GetCowFd());
+    ASSERT_TRUE(writer_v2->Initialize());
+    ASSERT_TRUE(writer_v2->Finalize());
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    const auto& header = reader.GetHeader();
+    ASSERT_EQ(header.prefix.magic, kCowMagicNumber);
+    ASSERT_EQ(header.prefix.major_version, kCowVersionMajor);
+    ASSERT_EQ(header.prefix.minor_version, kCowVersionMinor);
+    ASSERT_EQ(header.block_size, options.block_size);
+    ASSERT_EQ(header.cluster_ops, options.cluster_ops);
+}
+
 }  // namespace snapshot
 }  // namespace android
\ No newline at end of file
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index 63bed0741d0a..83a9b1b2230f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -269,9 +269,11 @@ bool CowWriterV2::OpenForWrite() {
 }
 
 bool CowWriterV2::OpenForAppend(uint64_t label) {
-    if (!ReadCowHeader(fd_, &header_)) {
+    CowHeaderV3 header_v3;
+    if (!ReadCowHeader(fd_, &header_v3)) {
         return false;
     }
+    header_ = header_v3;
 
     CowParserV2 parser;
     if (!parser.Parse(fd_, header_, {label})) {
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index f5732fc90a73..eb4beb780fba 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -3658,7 +3658,7 @@ std::unique_ptr<ICowWriter> SnapshotManager::OpenCompressedSnapshotWriter(
         return nullptr;
     }
 
-    CowHeader header;
+    CowHeaderV3 header;
     if (!ReadCowHeader(cow_fd, &header)) {
         LOG(ERROR) << "OpenCompressedSnapshotWriter: read header failed";
         return nullptr;

From 9032b39ea50033b6779952423c573e1ca953f073 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Wed, 18 Oct 2023 19:22:57 +0800
Subject: [PATCH 0481/1487] fs_mgr_overlayfs: Setup remount scratch dir with
 encoded mountpoint name

Instead of using the basename(mounpoint) as partition scratch dir name,
which could lead to name collision, use the normalized and encoded
mountpoint as scratch dir name.

Bug: 243503963
Bug: 306124139
Test: adb-remount-test
Change-Id: I5a64f17bc3b88f0ce42bd0c5779c8dd23a07917f
---
 fs_mgr/fs_mgr_overlayfs_control.cpp |  9 ++---
 fs_mgr/fs_mgr_overlayfs_mount.cpp   | 54 +++++++++++++++++------------
 fs_mgr/fs_mgr_overlayfs_mount.h     |  1 +
 3 files changed, 37 insertions(+), 27 deletions(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_control.cpp b/fs_mgr/fs_mgr_overlayfs_control.cpp
index 2cc0d2d5ea9c..50d8280e9062 100644
--- a/fs_mgr/fs_mgr_overlayfs_control.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_control.cpp
@@ -144,7 +144,8 @@ bool fs_mgr_overlayfs_setup_one(const std::string& overlay, const std::string& m
     if (fs_mgr_overlayfs_already_mounted(mount_point)) {
         return true;
     }
-    auto fsrec_mount_point = overlay + "/" + android::base::Basename(mount_point) + "/";
+    const auto base = GetEncodedBaseDirForMountPoint(mount_point);
+    auto fsrec_mount_point = overlay + "/" + base + "/";
 
     AutoSetFsCreateCon createcon(kOverlayfsFileContext);
     if (!createcon.Ok()) {
@@ -286,10 +287,10 @@ bool fs_mgr_overlayfs_teardown_one(const std::string& overlay, const std::string
     }
 
     auto cleanup_all = mount_point.empty();
-    const auto partition_name = android::base::Basename(mount_point);
-    const auto oldpath = top + (cleanup_all ? "" : ("/" + partition_name));
+    const auto base = GetEncodedBaseDirForMountPoint(mount_point);
+    const auto oldpath = top + (cleanup_all ? "" : ("/" + base));
     const auto newpath = cleanup_all ? overlay + "/." + kOverlayTopDir + ".teardown"
-                                     : top + "/." + partition_name + ".teardown";
+                                     : top + "/." + base + ".teardown";
     auto ret = fs_mgr_rm_all(newpath);
     if (!rename(oldpath.c_str(), newpath.c_str())) {
         if (change) *change = true;
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index 9f17c06f7a8f..0dadbffc625c 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -60,6 +60,7 @@ constexpr char kPhysicalDevice[] = "/dev/block/by-name/";
 
 constexpr char kLowerdirOption[] = "lowerdir=";
 constexpr char kUpperdirOption[] = "upperdir=";
+constexpr char kWorkdirOption[] = "workdir=";
 
 bool fs_mgr_is_dsu_running() {
     // Since android::gsi::CanBootIntoGsi() or android::gsi::MarkSystemAsGsi() is
@@ -89,6 +90,14 @@ std::vector<const std::string> OverlayMountPoints() {
     return {kScratchMountPoint, kCacheMountPoint};
 }
 
+std::string GetEncodedBaseDirForMountPoint(const std::string& mount_point) {
+    std::string normalized_path;
+    if (mount_point.empty() || !android::base::Realpath(mount_point, &normalized_path)) {
+        return "";
+    }
+    return android::base::StringReplace(normalized_path, "/", "@", true);
+}
+
 static bool fs_mgr_is_dir(const std::string& path) {
     struct stat st;
     return !stat(path.c_str(), &st) && S_ISDIR(st.st_mode);
@@ -202,21 +211,6 @@ static bool fs_mgr_overlayfs_enabled(FstabEntry* entry) {
     return has_shared_blocks;
 }
 
-static std::string fs_mgr_get_overlayfs_candidate(const std::string& mount_point) {
-    if (!fs_mgr_is_dir(mount_point)) return "";
-    const auto base = android::base::Basename(mount_point) + "/";
-    for (const auto& overlay_mount_point : OverlayMountPoints()) {
-        auto dir = overlay_mount_point + "/" + kOverlayTopDir + "/" + base;
-        auto upper = dir + kUpperName;
-        if (!fs_mgr_is_dir(upper)) continue;
-        auto work = dir + kWorkName;
-        if (!fs_mgr_is_dir(work)) continue;
-        if (access(work.c_str(), R_OK | W_OK)) continue;
-        return dir;
-    }
-    return "";
-}
-
 const std::string fs_mgr_mount_point(const std::string& mount_point) {
     if ("/"s != mount_point) return mount_point;
     return "/system";
@@ -225,16 +219,30 @@ const std::string fs_mgr_mount_point(const std::string& mount_point) {
 // default options for mount_point, returns empty string for none available.
 static std::string fs_mgr_get_overlayfs_options(const FstabEntry& entry) {
     const auto mount_point = fs_mgr_mount_point(entry.mount_point);
-    auto candidate = fs_mgr_get_overlayfs_candidate(mount_point);
-    if (candidate.empty()) return "";
-    auto ret = kLowerdirOption + mount_point + "," + kUpperdirOption + candidate + kUpperName +
-               ",workdir=" + candidate + kWorkName + android::fs_mgr::CheckOverlayfs().mount_flags;
-    for (const auto& flag : android::base::Split(entry.fs_options, ",")) {
-        if (android::base::StartsWith(flag, "context=")) {
-            ret += "," + flag;
+    if (!fs_mgr_is_dir(mount_point)) {
+        return "";
+    }
+    const auto base = GetEncodedBaseDirForMountPoint(mount_point);
+    if (base.empty()) {
+        return "";
+    }
+    for (const auto& overlay_mount_point : OverlayMountPoints()) {
+        const auto dir = overlay_mount_point + "/" + kOverlayTopDir + "/" + base + "/";
+        const auto upper = dir + kUpperName;
+        const auto work = dir + kWorkName;
+        if (!fs_mgr_is_dir(upper) || !fs_mgr_is_dir(work) || access(work.c_str(), R_OK | W_OK)) {
+            continue;
         }
+        auto ret = kLowerdirOption + mount_point + "," + kUpperdirOption + upper + "," +
+                   kWorkdirOption + work + android::fs_mgr::CheckOverlayfs().mount_flags;
+        for (const auto& flag : android::base::Split(entry.fs_options, ",")) {
+            if (android::base::StartsWith(flag, "context=")) {
+                ret += "," + flag;
+            }
+        }
+        return ret;
     }
-    return ret;
+    return "";
 }
 
 bool AutoSetFsCreateCon::Set(const std::string& context) {
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.h b/fs_mgr/fs_mgr_overlayfs_mount.h
index f0afac1edfe9..98b9007b505f 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.h
+++ b/fs_mgr/fs_mgr_overlayfs_mount.h
@@ -58,3 +58,4 @@ std::vector<const std::string> OverlayMountPoints();
 bool fs_mgr_overlayfs_already_mounted(const std::string& mount_point, bool overlay_only = true);
 bool fs_mgr_wants_overlayfs(android::fs_mgr::FstabEntry* entry);
 android::fs_mgr::Fstab fs_mgr_overlayfs_candidate_list(const android::fs_mgr::Fstab& fstab);
+std::string GetEncodedBaseDirForMountPoint(const std::string& mount_point);

From b010393fe537d855ec18a623c46e6efb6df261df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Thi=C3=A9baud=20Weksteen?= <tweek@google.com>
Date: Thu, 19 Oct 2023 11:27:49 +1100
Subject: [PATCH 0482/1487] Remove write to /sys/fs/selinux/checkreqprot

This SELinux option has been deprecated in the kernel since v5.7. In
v6.4, commit a7e4676e made any write to this file a no-op.

Since v4.4, the default value of 0 is set by the kernel. Skip the
setting of this value since we only support kernel >= 4.14.

Test: presubmit
Change-Id: Ied5945532e10b156dc0d9996b2a41a99d04e750b
---
 init/selinux.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/init/selinux.cpp b/init/selinux.cpp
index 9095b854eb18..1f211ddfa189 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -503,10 +503,6 @@ void SelinuxSetEnforcement() {
                         << ") failed";
         }
     }
-
-    if (auto result = WriteFile("/sys/fs/selinux/checkreqprot", "0"); !result.ok()) {
-        LOG(FATAL) << "Unable to write to /sys/fs/selinux/checkreqprot: " << result.error();
-    }
 }
 
 constexpr size_t kKlogMessageSize = 1024;

From b92b52c0714c3fd3aa45e97f63d9f87df8d03498 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Mon, 16 Oct 2023 19:14:28 -0700
Subject: [PATCH 0483/1487] Add ability to handle multiple intercepts per pid.

While doing this, refactor the intercept code to be easier to understand.

The primary use case for this is to perform a parallel stack dump (both Java and native) for specific ANRs.

Add tests for all of the different intercept conditions.

Modify the tests to display the error message from the intercept
response if there is an error.

Bug: 254634348
Test: All unit tests pass.
Test: Ran debuggerd on native and java processes.
Test: Created a bugreport without error.
Change-Id: Ic531ccee05b9a470748b815cf109e0076150a0b6
---
 debuggerd/common/include/dump_type.h       |  24 +-
 debuggerd/debuggerd_test.cpp               | 215 +++++++++++++---
 debuggerd/protocol.h                       |   2 +-
 debuggerd/tombstoned/intercept_manager.cpp | 276 ++++++++++++---------
 debuggerd/tombstoned/intercept_manager.h   |  17 +-
 debuggerd/tombstoned/tombstoned.cpp        |   4 +-
 6 files changed, 361 insertions(+), 177 deletions(-)

diff --git a/debuggerd/common/include/dump_type.h b/debuggerd/common/include/dump_type.h
index a3e171b25162..82ef7b67ca02 100644
--- a/debuggerd/common/include/dump_type.h
+++ b/debuggerd/common/include/dump_type.h
@@ -28,26 +28,24 @@ enum DebuggerdDumpType : uint8_t {
   kDebuggerdTombstoneProto,
 };
 
-inline std::ostream& operator<<(std::ostream& stream, const DebuggerdDumpType& rhs) {
-  switch (rhs) {
+inline const char* get_dump_type_name(const DebuggerdDumpType& dump_type) {
+  switch (dump_type) {
     case kDebuggerdNativeBacktrace:
-      stream << "kDebuggerdNativeBacktrace";
-      break;
+      return "kDebuggerdNativeBacktrace";
     case kDebuggerdTombstone:
-      stream << "kDebuggerdTombstone";
-      break;
+      return "kDebuggerdTombstone";
     case kDebuggerdJavaBacktrace:
-      stream << "kDebuggerdJavaBacktrace";
-      break;
+      return "kDebuggerdJavaBacktrace";
     case kDebuggerdAnyIntercept:
-      stream << "kDebuggerdAnyIntercept";
-      break;
+      return "kDebuggerdAnyIntercept";
     case kDebuggerdTombstoneProto:
-      stream << "kDebuggerdTombstoneProto";
-      break;
+      return "kDebuggerdTombstoneProto";
     default:
-      stream << "[unknown]";
+      return "[unknown]";
   }
+}
 
+inline std::ostream& operator<<(std::ostream& stream, const DebuggerdDumpType& rhs) {
+  stream << get_dump_type_name(rhs);
   return stream;
 }
diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 19ff7ebf0b44..c3e1302b94f2 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -114,7 +114,7 @@ constexpr char kWaitForDebuggerKey[] = "debug.debuggerd.wait_for_debugger";
                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) {
+                                 InterceptResponse* response, DebuggerdDumpType intercept_type) {
   intercept_fd->reset(socket_local_client(kTombstonedInterceptSocketName,
                                           ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_SEQPACKET));
   if (intercept_fd->get() == -1) {
@@ -155,18 +155,15 @@ static void tombstoned_intercept(pid_t target_pid, unique_fd* intercept_fd, uniq
     FAIL() << "failed to send output fd to tombstoned: " << strerror(errno);
   }
 
-  InterceptResponse response;
-  rc = TEMP_FAILURE_RETRY(read(intercept_fd->get(), &response, sizeof(response)));
+  rc = TEMP_FAILURE_RETRY(read(intercept_fd->get(), response, sizeof(*response)));
   if (rc == -1) {
     FAIL() << "failed to read response from tombstoned: " << strerror(errno);
   } else if (rc == 0) {
     FAIL() << "failed to read response from tombstoned (EOF)";
-  } else if (rc != sizeof(response)) {
-    FAIL() << "received packet of unexpected length from tombstoned: expected " << sizeof(response)
+  } else if (rc != sizeof(*response)) {
+    FAIL() << "received packet of unexpected length from tombstoned: expected " << sizeof(*response)
            << ", received " << rc;
   }
-
-  *status = response.status;
 }
 
 static bool pac_supported() {
@@ -225,9 +222,10 @@ void CrasherTest::StartIntercept(unique_fd* output_fd, DebuggerdDumpType interce
     FAIL() << "crasher hasn't been started";
   }
 
-  InterceptStatus status;
-  tombstoned_intercept(crasher_pid, &this->intercept_fd, output_fd, &status, intercept_type);
-  ASSERT_EQ(InterceptStatus::kRegistered, status);
+  InterceptResponse response = {};
+  tombstoned_intercept(crasher_pid, &this->intercept_fd, output_fd, &response, intercept_type);
+  ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+      << "Error message: " << response.error_message;
 }
 
 void CrasherTest::FinishIntercept(int* result) {
@@ -1744,9 +1742,10 @@ TEST(tombstoned, no_notify) {
     pid_t pid = 123'456'789 + i;
 
     unique_fd intercept_fd, output_fd;
-    InterceptStatus status;
-    tombstoned_intercept(pid, &intercept_fd, &output_fd, &status, kDebuggerdTombstone);
-    ASSERT_EQ(InterceptStatus::kRegistered, status);
+    InterceptResponse response = {};
+    tombstoned_intercept(pid, &intercept_fd, &output_fd, &response, kDebuggerdTombstone);
+    ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+        << "Error message: " << response.error_message;
 
     {
       unique_fd tombstoned_socket, input_fd;
@@ -1778,9 +1777,10 @@ TEST(tombstoned, stress) {
       pid_t pid = pid_base + dump;
 
       unique_fd intercept_fd, output_fd;
-      InterceptStatus status;
-      tombstoned_intercept(pid, &intercept_fd, &output_fd, &status, kDebuggerdTombstone);
-      ASSERT_EQ(InterceptStatus::kRegistered, status);
+      InterceptResponse response = {};
+      tombstoned_intercept(pid, &intercept_fd, &output_fd, &response, kDebuggerdTombstone);
+      ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+          << "Error messeage: " << response.error_message;
 
       // Pretend to crash, and then immediately close the socket.
       unique_fd sockfd(socket_local_client(kTombstonedCrashSocketName,
@@ -1811,9 +1811,10 @@ TEST(tombstoned, stress) {
       pid_t pid = pid_base + dump;
 
       unique_fd intercept_fd, output_fd;
-      InterceptStatus status;
-      tombstoned_intercept(pid, &intercept_fd, &output_fd, &status, kDebuggerdTombstone);
-      ASSERT_EQ(InterceptStatus::kRegistered, status);
+      InterceptResponse response = {};
+      tombstoned_intercept(pid, &intercept_fd, &output_fd, &response, kDebuggerdTombstone);
+      ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+          << "Error message: " << response.error_message;
 
       {
         unique_fd tombstoned_socket, input_fd;
@@ -1838,16 +1839,17 @@ TEST(tombstoned, stress) {
   }
 }
 
-TEST(tombstoned, java_trace_intercept_smoke) {
+TEST(tombstoned, intercept_java_trace_smoke) {
   // Using a "real" PID is a little dangerous here - if the test fails
   // or crashes, we might end up getting a bogus / unreliable stack
   // trace.
   const pid_t self = getpid();
 
   unique_fd intercept_fd, output_fd;
-  InterceptStatus status;
-  tombstoned_intercept(self, &intercept_fd, &output_fd, &status, kDebuggerdJavaBacktrace);
-  ASSERT_EQ(InterceptStatus::kRegistered, status);
+  InterceptResponse response = {};
+  tombstoned_intercept(self, &intercept_fd, &output_fd, &response, kDebuggerdJavaBacktrace);
+  ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+      << "Error message: " << response.error_message;
 
   // First connect to tombstoned requesting a native tombstone. This
   // should result in a "regular" FD and not the installed intercept.
@@ -1869,25 +1871,96 @@ TEST(tombstoned, java_trace_intercept_smoke) {
   ASSERT_STREQ("java", outbuf);
 }
 
-TEST(tombstoned, multiple_intercepts) {
+TEST(tombstoned, intercept_multiple_dump_types) {
   const pid_t fake_pid = 1'234'567;
   unique_fd intercept_fd, output_fd;
-  InterceptStatus status;
-  tombstoned_intercept(fake_pid, &intercept_fd, &output_fd, &status, kDebuggerdJavaBacktrace);
-  ASSERT_EQ(InterceptStatus::kRegistered, status);
+  InterceptResponse response = {};
+  tombstoned_intercept(fake_pid, &intercept_fd, &output_fd, &response, kDebuggerdJavaBacktrace);
+  ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+      << "Error message: " << response.error_message;
 
   unique_fd intercept_fd_2, output_fd_2;
-  tombstoned_intercept(fake_pid, &intercept_fd_2, &output_fd_2, &status, kDebuggerdNativeBacktrace);
-  ASSERT_EQ(InterceptStatus::kFailedAlreadyRegistered, status);
+  tombstoned_intercept(fake_pid, &intercept_fd_2, &output_fd_2, &response,
+                       kDebuggerdNativeBacktrace);
+  ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+      << "Error message: " << response.error_message;
+}
+
+TEST(tombstoned, intercept_bad_pid) {
+  const pid_t fake_pid = -1;
+  unique_fd intercept_fd, output_fd;
+  InterceptResponse response = {};
+  tombstoned_intercept(fake_pid, &intercept_fd, &output_fd, &response, kDebuggerdNativeBacktrace);
+  ASSERT_EQ(InterceptStatus::kFailed, response.status)
+      << "Error message: " << response.error_message;
+  ASSERT_MATCH(response.error_message, "bad pid");
+}
+
+TEST(tombstoned, intercept_bad_dump_types) {
+  const pid_t fake_pid = 1'234'567;
+  unique_fd intercept_fd, output_fd;
+  InterceptResponse response = {};
+  tombstoned_intercept(fake_pid, &intercept_fd, &output_fd, &response,
+                       static_cast<DebuggerdDumpType>(20));
+  ASSERT_EQ(InterceptStatus::kFailed, response.status)
+      << "Error message: " << response.error_message;
+  ASSERT_MATCH(response.error_message, "bad dump type \\[unknown\\]");
+
+  tombstoned_intercept(fake_pid, &intercept_fd, &output_fd, &response, kDebuggerdAnyIntercept);
+  ASSERT_EQ(InterceptStatus::kFailed, response.status)
+      << "Error message: " << response.error_message;
+  ASSERT_MATCH(response.error_message, "bad dump type kDebuggerdAnyIntercept");
+
+  tombstoned_intercept(fake_pid, &intercept_fd, &output_fd, &response, kDebuggerdTombstoneProto);
+  ASSERT_EQ(InterceptStatus::kFailed, response.status)
+      << "Error message: " << response.error_message;
+  ASSERT_MATCH(response.error_message, "bad dump type kDebuggerdTombstoneProto");
+}
+
+TEST(tombstoned, intercept_already_registered) {
+  const pid_t fake_pid = 1'234'567;
+  unique_fd intercept_fd1, output_fd1;
+  InterceptResponse response = {};
+  tombstoned_intercept(fake_pid, &intercept_fd1, &output_fd1, &response, kDebuggerdTombstone);
+  ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+      << "Error message: " << response.error_message;
+
+  unique_fd intercept_fd2, output_fd2;
+  tombstoned_intercept(fake_pid, &intercept_fd2, &output_fd2, &response, kDebuggerdTombstone);
+  ASSERT_EQ(InterceptStatus::kFailedAlreadyRegistered, response.status)
+      << "Error message: " << response.error_message;
+  ASSERT_MATCH(response.error_message, "already registered, type kDebuggerdTombstone");
+}
+
+TEST(tombstoned, intercept_tombstone_proto_matched_to_tombstone) {
+  const pid_t fake_pid = 1'234'567;
+
+  unique_fd intercept_fd, output_fd;
+  InterceptResponse response = {};
+  tombstoned_intercept(fake_pid, &intercept_fd, &output_fd, &response, kDebuggerdTombstone);
+  ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+      << "Error message: " << response.error_message;
+
+  const char data[] = "tombstone_proto";
+  unique_fd tombstoned_socket, input_fd;
+  ASSERT_TRUE(
+      tombstoned_connect(fake_pid, &tombstoned_socket, &input_fd, kDebuggerdTombstoneProto));
+  ASSERT_TRUE(android::base::WriteFully(input_fd.get(), data, sizeof(data)));
+  tombstoned_notify_completion(tombstoned_socket.get());
+
+  char outbuf[sizeof(data)];
+  ASSERT_TRUE(android::base::ReadFully(output_fd.get(), outbuf, sizeof(outbuf)));
+  ASSERT_STREQ("tombstone_proto", outbuf);
 }
 
 TEST(tombstoned, intercept_any) {
   const pid_t fake_pid = 1'234'567;
 
   unique_fd intercept_fd, output_fd;
-  InterceptStatus status;
-  tombstoned_intercept(fake_pid, &intercept_fd, &output_fd, &status, kDebuggerdNativeBacktrace);
-  ASSERT_EQ(InterceptStatus::kRegistered, status);
+  InterceptResponse response = {};
+  tombstoned_intercept(fake_pid, &intercept_fd, &output_fd, &response, kDebuggerdNativeBacktrace);
+  ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+      << "Error message: " << response.error_message;
 
   const char any[] = "any";
   unique_fd tombstoned_socket, input_fd;
@@ -1900,6 +1973,77 @@ TEST(tombstoned, intercept_any) {
   ASSERT_STREQ("any", outbuf);
 }
 
+TEST(tombstoned, intercept_any_failed_with_multiple_intercepts) {
+  const pid_t fake_pid = 1'234'567;
+
+  InterceptResponse response = {};
+  unique_fd intercept_fd1, output_fd1;
+  tombstoned_intercept(fake_pid, &intercept_fd1, &output_fd1, &response, kDebuggerdNativeBacktrace);
+  ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+      << "Error message: " << response.error_message;
+
+  unique_fd intercept_fd2, output_fd2;
+  tombstoned_intercept(fake_pid, &intercept_fd2, &output_fd2, &response, kDebuggerdJavaBacktrace);
+  ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+      << "Error message: " << response.error_message;
+
+  unique_fd tombstoned_socket, input_fd;
+  ASSERT_FALSE(tombstoned_connect(fake_pid, &tombstoned_socket, &input_fd, kDebuggerdAnyIntercept));
+}
+
+TEST(tombstoned, intercept_multiple_verify_intercept) {
+  // Need to use our pid for java since that will verify the pid.
+  const pid_t fake_pid = getpid();
+
+  InterceptResponse response = {};
+  unique_fd intercept_fd1, output_fd1;
+  tombstoned_intercept(fake_pid, &intercept_fd1, &output_fd1, &response, kDebuggerdNativeBacktrace);
+  ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+      << "Error message: " << response.error_message;
+
+  unique_fd intercept_fd2, output_fd2;
+  tombstoned_intercept(fake_pid, &intercept_fd2, &output_fd2, &response, kDebuggerdJavaBacktrace);
+  ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+      << "Error message: " << response.error_message;
+
+  unique_fd intercept_fd3, output_fd3;
+  tombstoned_intercept(fake_pid, &intercept_fd3, &output_fd3, &response, kDebuggerdTombstone);
+  ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+      << "Error message: " << response.error_message;
+
+  const char native_data[] = "native";
+  unique_fd tombstoned_socket1, input_fd1;
+  ASSERT_TRUE(
+      tombstoned_connect(fake_pid, &tombstoned_socket1, &input_fd1, kDebuggerdNativeBacktrace));
+  ASSERT_TRUE(android::base::WriteFully(input_fd1.get(), native_data, sizeof(native_data)));
+  tombstoned_notify_completion(tombstoned_socket1.get());
+
+  char native_outbuf[sizeof(native_data)];
+  ASSERT_TRUE(android::base::ReadFully(output_fd1.get(), native_outbuf, sizeof(native_outbuf)));
+  ASSERT_STREQ("native", native_outbuf);
+
+  const char java_data[] = "java";
+  unique_fd tombstoned_socket2, input_fd2;
+  ASSERT_TRUE(
+      tombstoned_connect(fake_pid, &tombstoned_socket2, &input_fd2, kDebuggerdJavaBacktrace));
+  ASSERT_TRUE(android::base::WriteFully(input_fd2.get(), java_data, sizeof(java_data)));
+  tombstoned_notify_completion(tombstoned_socket2.get());
+
+  char java_outbuf[sizeof(java_data)];
+  ASSERT_TRUE(android::base::ReadFully(output_fd2.get(), java_outbuf, sizeof(java_outbuf)));
+  ASSERT_STREQ("java", java_outbuf);
+
+  const char tomb_data[] = "tombstone";
+  unique_fd tombstoned_socket3, input_fd3;
+  ASSERT_TRUE(tombstoned_connect(fake_pid, &tombstoned_socket3, &input_fd3, kDebuggerdTombstone));
+  ASSERT_TRUE(android::base::WriteFully(input_fd3.get(), tomb_data, sizeof(tomb_data)));
+  tombstoned_notify_completion(tombstoned_socket3.get());
+
+  char tomb_outbuf[sizeof(tomb_data)];
+  ASSERT_TRUE(android::base::ReadFully(output_fd3.get(), tomb_outbuf, sizeof(tomb_outbuf)));
+  ASSERT_STREQ("tombstone", tomb_outbuf);
+}
+
 TEST(tombstoned, interceptless_backtrace) {
   // Generate 50 backtraces, and then check to see that we haven't created 50 new tombstones.
   auto get_tombstone_timestamps = []() -> std::map<int, time_t> {
@@ -2132,10 +2276,11 @@ TEST(tombstoned, proto) {
 TEST(tombstoned, proto_intercept) {
   const pid_t self = getpid();
   unique_fd intercept_fd, output_fd;
-  InterceptStatus status;
 
-  tombstoned_intercept(self, &intercept_fd, &output_fd, &status, kDebuggerdTombstone);
-  ASSERT_EQ(InterceptStatus::kRegistered, status);
+  InterceptResponse response = {};
+  tombstoned_intercept(self, &intercept_fd, &output_fd, &response, kDebuggerdTombstone);
+  ASSERT_EQ(InterceptStatus::kRegistered, response.status)
+      << "Error message: " << response.error_message;
 
   unique_fd tombstoned_socket, text_fd, proto_fd;
   ASSERT_TRUE(
diff --git a/debuggerd/protocol.h b/debuggerd/protocol.h
index b60cf5bb6295..212d6dc2827d 100644
--- a/debuggerd/protocol.h
+++ b/debuggerd/protocol.h
@@ -65,7 +65,7 @@ struct InterceptRequest {
 };
 
 enum class InterceptStatus : uint8_t {
-  // Returned when an intercept of a different type has already been
+  // Returned when an intercept of the same type has already been
   // registered (and is active) for a given PID.
   kFailedAlreadyRegistered,
   // Returned in all other failure cases.
diff --git a/debuggerd/tombstoned/intercept_manager.cpp b/debuggerd/tombstoned/intercept_manager.cpp
index 613e6f57d4d3..ac7b43132900 100644
--- a/debuggerd/tombstoned/intercept_manager.cpp
+++ b/debuggerd/tombstoned/intercept_manager.cpp
@@ -19,7 +19,10 @@
 #include <inttypes.h>
 #include <sys/types.h>
 
+#include <limits>
+#include <memory>
 #include <unordered_map>
+#include <utility>
 
 #include <event2/event.h>
 #include <event2/listener.h>
@@ -36,8 +39,7 @@ using android::base::ReceiveFileDescriptors;
 using android::base::unique_fd;
 
 static void intercept_close_cb(evutil_socket_t sockfd, short event, void* arg) {
-  auto intercept = reinterpret_cast<Intercept*>(arg);
-  InterceptManager* intercept_manager = intercept->intercept_manager;
+  std::unique_ptr<Intercept> intercept(reinterpret_cast<Intercept*>(arg));
 
   CHECK_EQ(sockfd, intercept->sockfd.get());
 
@@ -46,131 +48,108 @@ static void intercept_close_cb(evutil_socket_t sockfd, short event, void* arg) {
 
   // Ownership of intercept differs based on whether we've registered it with InterceptManager.
   if (!intercept->registered) {
-    delete intercept;
-  } else {
-    auto it = intercept_manager->intercepts.find(intercept->intercept_pid);
-    if (it == intercept_manager->intercepts.end()) {
-      LOG(FATAL) << "intercept close callback called after intercept was already removed?";
-    }
-    if (it->second.get() != intercept) {
-      LOG(FATAL) << "intercept close callback has different Intercept from InterceptManager?";
-    }
-
-    const char* reason;
-    if ((event & EV_TIMEOUT) != 0) {
-      reason = "due to timeout";
-    } else {
-      reason = "due to input";
-    }
-
-    LOG(INFO) << "intercept for pid " << intercept->intercept_pid << " and type "
-              << intercept->dump_type << " terminated: " << reason;
-    intercept_manager->intercepts.erase(it);
+    LOG(WARNING) << "intercept for pid " << intercept->pid << " and type " << intercept->dump_type
+                 << " closed before being registered.";
+    return;
   }
+
+  const char* reason = (event & EV_TIMEOUT) ? "due to timeout" : "due to input";
+  LOG(INFO) << "intercept for pid " << intercept->pid << " and type " << intercept->dump_type
+            << " terminated: " << reason;
 }
 
-static bool is_intercept_request_valid(const InterceptRequest& request) {
-  if (request.pid <= 0 || request.pid > std::numeric_limits<pid_t>::max()) {
-    return false;
+void InterceptManager::Unregister(Intercept* intercept) {
+  CHECK(intercept->registered);
+  auto pid_entry = intercepts.find(intercept->pid);
+  if (pid_entry == intercepts.end()) {
+    LOG(FATAL) << "No intercepts found for pid " << intercept->pid;
   }
-
-  if (request.dump_type < 0 || request.dump_type > kDebuggerdJavaBacktrace) {
-    return false;
+  auto& dump_type_hash = pid_entry->second;
+  auto dump_type_entry = dump_type_hash.find(intercept->dump_type);
+  if (dump_type_entry == dump_type_hash.end()) {
+    LOG(FATAL) << "Unknown intercept " << intercept->pid << " " << intercept->dump_type;
+  }
+  if (intercept != dump_type_entry->second) {
+    LOG(FATAL) << "Mismatch pointer trying to unregister intercept " << intercept->pid << " "
+               << intercept->dump_type;
   }
 
-  return true;
+  dump_type_hash.erase(dump_type_entry);
+  if (dump_type_hash.empty()) {
+    intercepts.erase(pid_entry);
+  }
 }
 
 static void intercept_request_cb(evutil_socket_t sockfd, short ev, void* arg) {
-  auto intercept = reinterpret_cast<Intercept*>(arg);
+  std::unique_ptr<Intercept> intercept(reinterpret_cast<Intercept*>(arg));
   InterceptManager* intercept_manager = intercept->intercept_manager;
 
   CHECK_EQ(sockfd, intercept->sockfd.get());
 
   if ((ev & EV_TIMEOUT) != 0) {
     LOG(WARNING) << "tombstoned didn't receive InterceptRequest before timeout";
-    goto fail;
+    return;
   } else if ((ev & EV_READ) == 0) {
     LOG(WARNING) << "tombstoned received unexpected event on intercept socket";
-    goto fail;
-  }
-
-  {
-    unique_fd rcv_fd;
-    InterceptRequest intercept_request;
-    ssize_t result =
-        ReceiveFileDescriptors(sockfd, &intercept_request, sizeof(intercept_request), &rcv_fd);
-
-    if (result == -1) {
-      PLOG(WARNING) << "failed to read from intercept socket";
-      goto fail;
-    } else if (result != sizeof(intercept_request)) {
-      LOG(WARNING) << "intercept socket received short read of length " << result << " (expected "
-                   << sizeof(intercept_request) << ")";
-      goto fail;
-    }
+    return;
+  }
 
-    // Move the received FD to the upper half, in order to more easily notice FD leaks.
-    int moved_fd = fcntl(rcv_fd.get(), F_DUPFD, 512);
-    if (moved_fd == -1) {
-      LOG(WARNING) << "failed to move received fd (" << rcv_fd.get() << ")";
-      goto fail;
-    }
-    rcv_fd.reset(moved_fd);
-
-    // We trust the other side, so only do minimal validity checking.
-    if (!is_intercept_request_valid(intercept_request)) {
-      InterceptResponse response = {};
-      response.status = InterceptStatus::kFailed;
-      snprintf(response.error_message, sizeof(response.error_message), "invalid intercept request");
-      TEMP_FAILURE_RETRY(write(sockfd, &response, sizeof(response)));
-      goto fail;
-    }
+  unique_fd rcv_fd;
+  InterceptRequest intercept_request;
+  ssize_t result =
+      ReceiveFileDescriptors(sockfd, &intercept_request, sizeof(intercept_request), &rcv_fd);
 
-    intercept->intercept_pid = intercept_request.pid;
-    intercept->dump_type = intercept_request.dump_type;
-
-    // Check if it's already registered.
-    if (intercept_manager->intercepts.count(intercept_request.pid) > 0) {
-      InterceptResponse response = {};
-      response.status = InterceptStatus::kFailedAlreadyRegistered;
-      snprintf(response.error_message, sizeof(response.error_message),
-               "pid %" PRId32 " already intercepted, type %d", intercept_request.pid,
-               intercept_request.dump_type);
-      TEMP_FAILURE_RETRY(write(sockfd, &response, sizeof(response)));
-      LOG(WARNING) << response.error_message;
-      goto fail;
-    }
+  if (result == -1) {
+    PLOG(WARNING) << "failed to read from intercept socket";
+    return;
+  }
+  if (result != sizeof(intercept_request)) {
+    LOG(WARNING) << "intercept socket received short read of length " << result << " (expected "
+                 << sizeof(intercept_request) << ")";
+    return;
+  }
 
-    // Let the other side know that the intercept has been registered, now that we know we can't
-    // fail. tombstoned is single threaded, so this isn't racy.
-    InterceptResponse response = {};
-    response.status = InterceptStatus::kRegistered;
-    if (TEMP_FAILURE_RETRY(write(sockfd, &response, sizeof(response))) == -1) {
-      PLOG(WARNING) << "failed to notify interceptor of registration";
-      goto fail;
-    }
+  // Move the received FD to the upper half, in order to more easily notice FD leaks.
+  int moved_fd = fcntl(rcv_fd.get(), F_DUPFD, 512);
+  if (moved_fd == -1) {
+    LOG(WARNING) << "failed to move received fd (" << rcv_fd.get() << ")";
+    return;
+  }
+  rcv_fd.reset(moved_fd);
 
-    intercept->output_fd = std::move(rcv_fd);
-    intercept_manager->intercepts[intercept_request.pid] = std::unique_ptr<Intercept>(intercept);
-    intercept->registered = true;
+  // See if we can properly register the intercept.
+  InterceptResponse response = {};
+  if (!intercept_manager->CanRegister(intercept_request, response)) {
+    TEMP_FAILURE_RETRY(write(sockfd, &response, sizeof(response)));
+    LOG(WARNING) << response.error_message;
+    return;
+  }
 
-    LOG(INFO) << "registered intercept for pid " << intercept_request.pid << " and type "
-              << intercept_request.dump_type;
+  // Let the other side know that the intercept has been registered, now that we know we can't
+  // fail. tombstoned is single threaded, so this isn't racy.
+  response.status = InterceptStatus::kRegistered;
+  if (TEMP_FAILURE_RETRY(write(sockfd, &response, sizeof(response))) == -1) {
+    PLOG(WARNING) << "failed to notify interceptor of registration";
+    return;
+  }
 
-    // Register a different read event on the socket so that we can remove intercepts if the socket
-    // closes (e.g. if a user CTRL-C's the process that requested the intercept).
-    event_assign(intercept->intercept_event, intercept_manager->base, sockfd, EV_READ | EV_TIMEOUT,
-                 intercept_close_cb, arg);
+  intercept->pid = intercept_request.pid;
+  intercept->dump_type = intercept_request.dump_type;
+  intercept->output_fd = std::move(rcv_fd);
+  intercept_manager->Register(intercept.get());
 
-    struct timeval timeout = {.tv_sec = 10 * android::base::HwTimeoutMultiplier(), .tv_usec = 0};
-    event_add(intercept->intercept_event, &timeout);
-  }
+  LOG(INFO) << "registered intercept for pid " << intercept_request.pid << " and type "
+            << intercept_request.dump_type;
 
-  return;
+  // Register a different read event on the socket so that we can remove intercepts if the socket
+  // closes (e.g. if a user CTRL-C's the process that requested the intercept).
+  event_assign(intercept->intercept_event, intercept_manager->base, sockfd, EV_READ | EV_TIMEOUT,
+               intercept_close_cb, arg);
 
-fail:
-  delete intercept;
+  // If no request comes in, then this will close the intercept and free the pointer.
+  struct timeval timeout = {.tv_sec = 10 * android::base::HwTimeoutMultiplier(), .tv_usec = 0};
+  event_add(intercept->intercept_event, &timeout);
+  intercept.release();
 }
 
 static void intercept_accept_cb(evconnlistener* listener, evutil_socket_t sockfd, sockaddr*, int,
@@ -187,41 +166,97 @@ static void intercept_accept_cb(evconnlistener* listener, evutil_socket_t sockfd
   event_add(intercept_event, &timeout);
 }
 
+Intercept::~Intercept() {
+  event_free(intercept_event);
+  if (registered) {
+    CHECK(intercept_manager != nullptr);
+    intercept_manager->Unregister(this);
+  }
+}
+
 InterceptManager::InterceptManager(event_base* base, int intercept_socket) : base(base) {
   this->listener = evconnlistener_new(base, intercept_accept_cb, this, LEV_OPT_CLOSE_ON_FREE,
                                       /* backlog */ -1, intercept_socket);
 }
 
-bool dump_types_compatible(DebuggerdDumpType interceptor, DebuggerdDumpType dump) {
-  if (interceptor == dump) {
-    return true;
+static DebuggerdDumpType canonical_dump_type(const DebuggerdDumpType dump_type) {
+  // kDebuggerdTombstone and kDebuggerdTombstoneProto should be treated as
+  // a single dump_type for intercepts (kDebuggerdTombstone).
+  if (dump_type == kDebuggerdTombstoneProto) {
+    return kDebuggerdTombstone;
   }
+  return dump_type;
+}
 
-  if (interceptor == kDebuggerdTombstone && dump == kDebuggerdTombstoneProto) {
-    return true;
+Intercept* InterceptManager::Get(const pid_t pid, const DebuggerdDumpType dump_type) {
+  auto pid_entry = intercepts.find(pid);
+  if (pid_entry == intercepts.end()) {
+    return nullptr;
   }
 
-  return false;
+  const auto& dump_type_hash = pid_entry->second;
+  auto dump_type_entry = dump_type_hash.find(canonical_dump_type(dump_type));
+  if (dump_type_entry == dump_type_hash.end()) {
+    if (dump_type != kDebuggerdAnyIntercept) {
+      return nullptr;
+    }
+    // If doing a dump with an any intercept, only allow an any to match
+    // a single intercept. If there are multiple dump types with intercepts
+    // then there would be no way to figure out which to use.
+    if (dump_type_hash.size() != 1) {
+      LOG(WARNING) << "Cannot intercept using kDebuggerdAnyIntercept: there is more than one "
+                      "intercept registered for pid "
+                   << pid;
+      return nullptr;
+    }
+    dump_type_entry = dump_type_hash.begin();
+  }
+  return dump_type_entry->second;
 }
 
-bool InterceptManager::GetIntercept(pid_t pid, DebuggerdDumpType dump_type,
-                                    android::base::unique_fd* out_fd) {
-  auto it = this->intercepts.find(pid);
-  if (it == this->intercepts.end()) {
+bool InterceptManager::CanRegister(const InterceptRequest& request, InterceptResponse& response) {
+  if (request.pid <= 0 || request.pid > std::numeric_limits<pid_t>::max()) {
+    response.status = InterceptStatus::kFailed;
+    snprintf(response.error_message, sizeof(response.error_message),
+             "invalid intercept request: bad pid %" PRId32, request.pid);
     return false;
   }
+  if (request.dump_type < 0 || request.dump_type > kDebuggerdJavaBacktrace) {
+    response.status = InterceptStatus::kFailed;
+    snprintf(response.error_message, sizeof(response.error_message),
+             "invalid intercept request: bad dump type %s", get_dump_type_name(request.dump_type));
+    return false;
+  }
+
+  if (Get(request.pid, request.dump_type) != nullptr) {
+    response.status = InterceptStatus::kFailedAlreadyRegistered;
+    snprintf(response.error_message, sizeof(response.error_message),
+             "pid %" PRId32 " already registered, type %s", request.pid,
+             get_dump_type_name(request.dump_type));
+    return false;
+  }
+
+  return true;
+}
+
+void InterceptManager::Register(Intercept* intercept) {
+  CHECK(!intercept->registered);
+  auto& dump_type_hash = intercepts[intercept->pid];
+  dump_type_hash[canonical_dump_type(intercept->dump_type)] = intercept;
+  intercept->registered = true;
+}
 
-  if (dump_type == kDebuggerdAnyIntercept) {
-    LOG(INFO) << "found registered intercept of type " << it->second->dump_type
-              << " for requested type kDebuggerdAnyIntercept";
-  } else if (!dump_types_compatible(it->second->dump_type, dump_type)) {
-    LOG(WARNING) << "found non-matching intercept of type " << it->second->dump_type
-                 << " for requested type: " << dump_type;
+bool InterceptManager::FindIntercept(pid_t pid, DebuggerdDumpType dump_type,
+                                     android::base::unique_fd* out_fd) {
+  Intercept* intercept = Get(pid, dump_type);
+  if (intercept == nullptr) {
     return false;
   }
 
-  auto intercept = std::move(it->second);
-  this->intercepts.erase(it);
+  if (dump_type != intercept->dump_type) {
+    LOG(INFO) << "found registered intercept of type " << intercept->dump_type
+              << " for requested type " << dump_type;
+  }
 
   LOG(INFO) << "found intercept fd " << intercept->output_fd.get() << " for pid " << pid
             << " and type " << intercept->dump_type;
@@ -230,5 +265,8 @@ bool InterceptManager::GetIntercept(pid_t pid, DebuggerdDumpType dump_type,
   TEMP_FAILURE_RETRY(write(intercept->sockfd, &response, sizeof(response)));
   *out_fd = std::move(intercept->output_fd);
 
+  // Delete the intercept data, which will unregister the intercept and remove the timeout event.
+  delete intercept;
+
   return true;
 }
diff --git a/debuggerd/tombstoned/intercept_manager.h b/debuggerd/tombstoned/intercept_manager.h
index a11d565a32ab..dc13aa9c0129 100644
--- a/debuggerd/tombstoned/intercept_manager.h
+++ b/debuggerd/tombstoned/intercept_manager.h
@@ -28,17 +28,17 @@
 #include "dump_type.h"
 
 struct InterceptManager;
+struct InterceptRequest;
+struct InterceptResponse;
 
 struct Intercept {
-  ~Intercept() {
-    event_free(intercept_event);
-  }
+  ~Intercept();
 
   InterceptManager* intercept_manager = nullptr;
   event* intercept_event = nullptr;
   android::base::unique_fd sockfd;
 
-  pid_t intercept_pid = -1;
+  pid_t pid = -1;
   android::base::unique_fd output_fd;
   bool registered = false;
   DebuggerdDumpType dump_type = kDebuggerdNativeBacktrace;
@@ -46,12 +46,17 @@ struct Intercept {
 
 struct InterceptManager {
   event_base* base;
-  std::unordered_map<pid_t, std::unique_ptr<Intercept>> intercepts;
+  std::unordered_map<pid_t, std::unordered_map<DebuggerdDumpType, Intercept*>> intercepts;
   evconnlistener* listener = nullptr;
 
   InterceptManager(event_base* _Nonnull base, int intercept_socket);
   InterceptManager(InterceptManager& copy) = delete;
   InterceptManager(InterceptManager&& move) = delete;
 
-  bool GetIntercept(pid_t pid, DebuggerdDumpType dump_type, android::base::unique_fd* out_fd);
+  bool CanRegister(const InterceptRequest& request, InterceptResponse& response);
+  Intercept* Get(const pid_t pid, const DebuggerdDumpType dump_type);
+  void Register(Intercept* intercept);
+  void Unregister(Intercept* intercept);
+
+  bool FindIntercept(pid_t pid, DebuggerdDumpType dump_type, android::base::unique_fd* out_fd);
 };
diff --git a/debuggerd/tombstoned/tombstoned.cpp b/debuggerd/tombstoned/tombstoned.cpp
index 50558f7a3c3c..cf7904f81980 100644
--- a/debuggerd/tombstoned/tombstoned.cpp
+++ b/debuggerd/tombstoned/tombstoned.cpp
@@ -283,9 +283,7 @@ static void crash_completed_cb(evutil_socket_t sockfd, short ev, void* arg);
 
 static void perform_request(std::unique_ptr<Crash> crash) {
   unique_fd output_fd;
-  bool intercepted =
-      intercept_manager->GetIntercept(crash->crash_pid, crash->crash_type, &output_fd);
-  if (intercepted) {
+  if (intercept_manager->FindIntercept(crash->crash_pid, crash->crash_type, &output_fd)) {
     if (crash->crash_type == kDebuggerdTombstoneProto) {
       crash->output.proto = CrashArtifact::devnull();
     }

From c25abe47392f4f86ce3706846995fe6c948caf84 Mon Sep 17 00:00:00 2001
From: Nate Myren <ntmyren@google.com>
Date: Fri, 25 Aug 2023 14:30:50 -0700
Subject: [PATCH 0484/1487] Initialize the appcompat system property folder

Certain applications may have their system properties overlaid with the
contents overlaid for appcompat purposes. Init must initialize the
appcompat folder, same as it does the standard folder.

Bug: 291814949
Test: manual
Change-Id: I6d239e0a10a1c81a05d4121e5fc2c41da5b3dbc4
Merged-In: I0c6a0f66dc543c6e861bc86a417e4feb5ecd7789
---
 init/property_service.cpp                        | 16 +++++++++++++---
 .../property_info_parser/property_info_parser.h  |  2 ++
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index cdd0afe8b70a..21502fb35216 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -76,6 +76,10 @@
 #include "system/core/init/property_service.pb.h"
 #include "util.h"
 
+static constexpr char APPCOMPAT_OVERRIDE_PROP_FOLDERNAME[] =
+        "/dev/__properties__/appcompat_override";
+static constexpr char APPCOMPAT_OVERRIDE_PROP_TREE_FILE[] =
+        "/dev/__properties__/appcompat_override/property_info";
 using namespace std::literals;
 
 using android::base::ErrnoError;
@@ -1280,11 +1284,17 @@ void CreateSerializedPropertyInfo() {
         return;
     }
 
-    constexpr static const char kPropertyInfosPath[] = "/dev/__properties__/property_info";
-    if (!WriteStringToFile(serialized_contexts, kPropertyInfosPath, 0444, 0, 0, false)) {
+    if (!WriteStringToFile(serialized_contexts, PROP_TREE_FILE, 0444, 0, 0, false)) {
         PLOG(ERROR) << "Unable to write serialized property infos to file";
     }
-    selinux_android_restorecon(kPropertyInfosPath, 0);
+    selinux_android_restorecon(PROP_TREE_FILE, 0);
+
+    mkdir(APPCOMPAT_OVERRIDE_PROP_FOLDERNAME, S_IRWXU | S_IXGRP | S_IXOTH);
+    if (!WriteStringToFile(serialized_contexts, APPCOMPAT_OVERRIDE_PROP_TREE_FILE, 0444, 0, 0,
+                           false)) {
+        PLOG(ERROR) << "Unable to write vendor overrides to file";
+    }
+    selinux_android_restorecon(APPCOMPAT_OVERRIDE_PROP_TREE_FILE, 0);
 }
 
 static void ExportKernelBootProps() {
diff --git a/property_service/libpropertyinfoparser/include/property_info_parser/property_info_parser.h b/property_service/libpropertyinfoparser/include/property_info_parser/property_info_parser.h
index 054802197a5f..65705accbc78 100644
--- a/property_service/libpropertyinfoparser/include/property_info_parser/property_info_parser.h
+++ b/property_service/libpropertyinfoparser/include/property_info_parser/property_info_parser.h
@@ -20,6 +20,8 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+static constexpr char PROP_TREE_FILE[] = "/dev/__properties__/property_info";
+
 namespace android {
 namespace properties {
 

From d07ec304232865eef16f79d2f829c48386aa2f46 Mon Sep 17 00:00:00 2001
From: Jason Chiu <jasoncschiu@google.com>
Date: Thu, 12 Oct 2023 17:11:27 +0800
Subject: [PATCH 0485/1487] bootstat: add more bootreasons

add more bootreasons for new design.

Bug: 296637681
Test: trigger apc watchdog then "adb root; adb shell bootstat -p"
Change-Id: Ia78146ba9299eea45e7d89376179e01cbd37cca8
Signed-off-by: Jason Chiu <jasoncschiu@google.com>
---
 bootstat/bootstat.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/bootstat/bootstat.cpp b/bootstat/bootstat.cpp
index 3b8866e51afb..2d55e5a5550c 100644
--- a/bootstat/bootstat.cpp
+++ b/bootstat/bootstat.cpp
@@ -461,6 +461,14 @@ const std::map<std::string, int32_t> kBootReasonMap = {
     {"reboot,smpl_timeout,pmic,main", 229},
     {"reboot,ota,.*", 230},
     {"reboot,periodic,.*", 231},
+    {"reboot,early,abl", 232},
+    {"reboot,early,bl2", 233},
+    {"reboot,longkey,pmic_cold", 234},
+    {"reboot,longkey,master_dc", 235},
+    {"reboot,ocp2,pmic,if", 236},
+    {"reboot,ocp,pmic,if", 237},
+    {"reboot,fship", 238},
+    {"reboot,ocp,.*", 239},
 };
 
 // Converts a string value representing the reason the system booted to an

From f2e7170cbaf6f93039a79830208ac762d82bbd04 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Fri, 20 Oct 2023 18:06:53 +0800
Subject: [PATCH 0486/1487] fs_mgr_overlayfs: Don't try to mount scratch if
 already mounted

This eliminates spammy logs.

Bug: 306124139
Test: adb remount -v && check the output logs
Change-Id: I3143f5865b5292ba581009179c7e7141afa8fda5
---
 fs_mgr/fs_mgr_overlayfs_mount.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index 0dadbffc625c..66faecda7f92 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -707,7 +707,7 @@ bool fs_mgr_overlayfs_mount_all(Fstab* fstab) {
         return false;
     }
     auto ret = true;
-    auto scratch_can_be_mounted = true;
+    auto scratch_can_be_mounted = !fs_mgr_overlayfs_already_mounted(kScratchMountPoint, false);
     for (const auto& entry : fs_mgr_overlayfs_candidate_list(*fstab)) {
         if (fs_mgr_is_verity_enabled(entry)) continue;
         auto mount_point = fs_mgr_mount_point(entry.mount_point);

From c7230a1eb1d1c2786e351d7e580d36eb399dfc66 Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Fri, 20 Oct 2023 20:42:56 +0900
Subject: [PATCH 0487/1487] Don't overwrite persistent property files

This fixes a bug introduced by I81b6bd984aad8f7ddec93ce74f4543e4f71be508

In the original CL, setting a sysprop `next_boot.<name>` and then
rebooting the device could remove all the persistent properties stored
in /data/property/persistent_properties. It happened because the
function `WritePersistentProperty` is called with a properties set which
is initialized as an empty set and then added with the properties which
had the next_boot prefix.

As a result...

Before the boot:
* persist.a = 1
* next_boot.b = 2
* next_boot.persist.c = 3

After the reboot:
* b = 2
* persist.c = 3

persist.a gets lost.

This change fixes the issue by populating properties set from the memory
and then save it to the file.

Bug: 306062513
Bug: 300111812
Test: do the following.
$ adb root
$ adb shell setprop persist.a 1
$ adb shell setprop next_boot.b 1
$ adb shell setprop next_boot.persist.c 1

$ adb reboot
$ adb shell getprop persist.a
1    // was (none) before this change
$ adb shell getprop b
1
$ adb shell getprop persist.c
1

$ adb reboot
$ adb shell getprop persist.a
1    // was (none) before this change
$ adb shell getprop b
     // (none) because b isn't persisted. WAI.
$ adb shell getprop persist.c
1

Change-Id: I85d3777f9b32523b010e49b8ca53f4319dd2ce05
---
 init/persistent_properties.cpp | 36 +++++++++++++++++-----------------
 init/persistent_properties.h   |  1 +
 init/property_service.cpp      | 15 +++-----------
 3 files changed, 22 insertions(+), 30 deletions(-)

diff --git a/init/persistent_properties.cpp b/init/persistent_properties.cpp
index 8efb72c7ea94..e89244f13be0 100644
--- a/init/persistent_properties.cpp
+++ b/init/persistent_properties.cpp
@@ -115,24 +115,6 @@ void RemoveLegacyPersistentPropertyFiles() {
     }
 }
 
-PersistentProperties LoadPersistentPropertiesFromMemory() {
-    PersistentProperties persistent_properties;
-    __system_property_foreach(
-        [](const prop_info* pi, void* cookie) {
-            __system_property_read_callback(
-                pi,
-                [](void* cookie, const char* name, const char* value, unsigned serial) {
-                    if (StartsWith(name, "persist.")) {
-                        auto properties = reinterpret_cast<PersistentProperties*>(cookie);
-                        AddPersistentProperty(name, value, properties);
-                    }
-                },
-                cookie);
-        },
-        &persistent_properties);
-    return persistent_properties;
-}
-
 Result<std::string> ReadPersistentPropertyFile() {
     const std::string temp_filename = persistent_property_filename + ".tmp";
     if (access(temp_filename.c_str(), F_OK) == 0) {
@@ -221,6 +203,24 @@ Result<void> WritePersistentPropertyFile(const PersistentProperties& persistent_
     return {};
 }
 
+PersistentProperties LoadPersistentPropertiesFromMemory() {
+    PersistentProperties persistent_properties;
+    __system_property_foreach(
+            [](const prop_info* pi, void* cookie) {
+                __system_property_read_callback(
+                        pi,
+                        [](void* cookie, const char* name, const char* value, unsigned serial) {
+                            if (StartsWith(name, "persist.")) {
+                                auto properties = reinterpret_cast<PersistentProperties*>(cookie);
+                                AddPersistentProperty(name, value, properties);
+                            }
+                        },
+                        cookie);
+            },
+            &persistent_properties);
+    return persistent_properties;
+}
+
 // Persistent properties are not written often, so we rather not keep any data in memory and read
 // then rewrite the persistent property file for each update.
 void WritePersistentProperty(const std::string& name, const std::string& value) {
diff --git a/init/persistent_properties.h b/init/persistent_properties.h
index a6f80e64f51d..7e9d4387a602 100644
--- a/init/persistent_properties.h
+++ b/init/persistent_properties.h
@@ -29,6 +29,7 @@ void AddPersistentProperty(const std::string& name, const std::string& value,
                            PersistentProperties* persistent_properties);
 PersistentProperties LoadPersistentProperties();
 void WritePersistentProperty(const std::string& name, const std::string& value);
+PersistentProperties LoadPersistentPropertiesFromMemory();
 
 // Exposed only for testing
 Result<PersistentProperties> LoadPersistentPropertyFile();
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 38cbea3786b1..b08a904a7c6a 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1400,8 +1400,6 @@ static void HandleInitSocket() {
             // Apply staged and persistent properties
             bool has_staged_prop = false;
             auto const staged_prefix = std::string_view("next_boot.");
-            auto const staged_persist_prefix = std::string_view("next_boot.persist.");
-            auto persist_props_map = std::unordered_map<std::string, std::string>();
 
             auto persistent_properties = LoadPersistentProperties();
             for (const auto& property_record : persistent_properties.properties()) {
@@ -1412,23 +1410,16 @@ static void HandleInitSocket() {
                   has_staged_prop = true;
                   auto actual_prop_name = prop_name.substr(staged_prefix.size());
                   InitPropertySet(actual_prop_name, prop_value);
-                  if (StartsWith(prop_name, staged_persist_prefix)) {
-                    persist_props_map[actual_prop_name] = prop_value;
-                  }
-                } else if (!persist_props_map.count(prop_name)) {
+                } else {
                   InitPropertySet(prop_name, prop_value);
                 }
             }
 
             // Update persist prop file if there are staged props
             if (has_staged_prop) {
-                PersistentProperties updated_persist_props;
-                for (auto const& [prop_name, prop_value] : persist_props_map) {
-                    AddPersistentProperty(prop_name, prop_value, &updated_persist_props);
-                }
-
+                PersistentProperties props = LoadPersistentPropertiesFromMemory();
                 // write current updated persist prop file
-                auto result = WritePersistentPropertyFile(updated_persist_props);
+                auto result = WritePersistentPropertyFile(props);
                 if (!result.ok()) {
                     LOG(ERROR) << "Could not store persistent property: " << result.error();
                 }

From 0bc02bfe71017757343657dff4f26b6c86ddb302 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 20 Oct 2023 11:17:44 -0700
Subject: [PATCH 0488/1487] fastboot: Fix flashing failure when a sparse image
 has an avb footer.

Trying to move the AVB footer on a sparse file will corrupt the sparse
format. Rather than implement this properly, for now, have the
copy_avb_footer() function gracefully fail by skipping the operation.

Bug: 304574023
Test: fastboot flash sparse image with avb footer
Change-Id: Ia6f0711789a04897ec266ad604a3d243c7184082
---
 fastboot/fastboot.cpp | 11 +++++++++++
 fastboot/fastboot.h   |  3 ++-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 56b90b98179b..ac2a20f90c80 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1053,8 +1053,10 @@ static bool load_buf_fd(unique_fd fd, struct fastboot_buffer* buf, const Flashin
             return false;
         }
         sparse_file_destroy(s);
+        buf->file_type = FB_BUFFER_SPARSE;
     } else {
         buf->image_size = sz;
+        buf->file_type = FB_BUFFER_FD;
     }
 
     lseek(fd.get(), 0, SEEK_SET);
@@ -1191,6 +1193,15 @@ static void copy_avb_footer(const ImageSource* source, const std::string& partit
         should_flash_in_userspace(source, partition)) {
         return;
     }
+
+    // If the image is sparse, moving the footer will simply corrupt the sparse
+    // format, so currently we don't support moving the footer on sparse files.
+    if (buf->file_type == FB_BUFFER_SPARSE) {
+        LOG(ERROR) << "Warning: skip copying " << partition << " image avb footer due to sparse "
+                   << "image.";
+        return;
+    }
+
     // If overflows and negative, it should be < buf->sz.
     int64_t partition_size = static_cast<int64_t>(get_partition_size(partition));
 
diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h
index 2c40890b5105..6a4997049cde 100644
--- a/fastboot/fastboot.h
+++ b/fastboot/fastboot.h
@@ -57,7 +57,8 @@ enum fb_buffer_type {
 };
 
 struct fastboot_buffer {
-    enum fb_buffer_type type;
+    fb_buffer_type type;
+    fb_buffer_type file_type;
     std::vector<SparsePtr> files;
     int64_t sz;
     unique_fd fd;

From c78df87fad9a42a50d4bdbd86933ea13feca75d3 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Thu, 19 Oct 2023 18:16:42 +0800
Subject: [PATCH 0489/1487] fs_mgr_overlayfs: Support remounting submounts

The move mount motions logic are built on top of heuristics and allow
non-fatal failures.
If the overlay was setup and mounted without reboot (this could happen
if AVB is disabled), the mount state (especially the MS_SHARED and
MS_PRIVATE flags) can still get skewed somehow, due to unforeseen errors
or resource race.
It is always advised to reboot after initial overlay setup, as the
overlay mount logic is less likely to require moving submounts when
executed by `init`, this provides the greatest chance of success.

Below is an example of the expected outcome of remounting submounts:
[precondition]
* AVB is already disabled, so overlay is setup and mounted w/o reboot
* No existing overlay; is initial overlay setup

0. /proc/self/mountinfo would contain something like:
<id> <parent id> <mountpoint> <shared/private> <filesystem>
2    1           /product     shared:2         erofs
3    2           /product/app shared:3         erofs

1. adb remount /product/app
(note how the mount flag of <3> changes to private so <30> can be
MS_MOVE later)
2    1           /product     shared:2         erofs
3    2           /product/app private          erofs
30   3           /product/app shared:30        overlay

2. adb remount /product
(note how the parent of <30> changes to <40> as the result of MS_MOVE)
(note that <3> is _not_ moved)
2    1           /product     private          erofs
3    2           /product/app private          erofs
30   40          /product/app shared:30        overlay
40   2           /product     shared:40        overlay

Bug: 306124139
Test: adb-remount-test
Test: Verified with a remount submount scenario by editing the fstab.
Test: remount /system/bin then /system and verify the submount overlay
  (/system/bin) is moved under the parent mount overlay (/system).
Change-Id: I6cdbe8c52d826a6f03fd363c909ebb0005446b96
---
 fs_mgr/fs_mgr_overlayfs_mount.cpp | 75 +++++++++++++++++++------------
 fs_mgr/fs_mgr_remount.cpp         | 19 --------
 2 files changed, 47 insertions(+), 47 deletions(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index 66faecda7f92..f149a31d59ad 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -381,32 +381,64 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
 
     auto retval = true;
 
-    struct move_entry {
+    struct MoveEntry {
         std::string mount_point;
         std::string dir;
         bool shared_flag;
     };
-    std::vector<move_entry> move;
+
+    std::vector<MoveEntry> moved_mounts;
     auto parent_private = false;
     auto parent_made_private = false;
     auto dev_private = false;
     auto dev_made_private = false;
-    for (auto& entry : ReadMountinfoFromFile("/proc/self/mountinfo")) {
+
+    // There could be multiple mount entries with the same mountpoint.
+    // Group these entries together with stable_sort, and keep only the last entry of a group.
+    // Only move mount the last entry in an over mount group, because the other entries are
+    // overshadowed and only the filesystem mounted with the last entry participates in file
+    // pathname resolution.
+    auto mountinfo = ReadMountinfoFromFile("/proc/self/mountinfo");
+    std::stable_sort(mountinfo.begin(), mountinfo.end(), [](const auto& lhs, const auto& rhs) {
+        return lhs.mount_point < rhs.mount_point;
+    });
+    std::reverse(mountinfo.begin(), mountinfo.end());
+    auto erase_from = std::unique(
+            mountinfo.begin(), mountinfo.end(),
+            [](const auto& lhs, const auto& rhs) { return lhs.mount_point == rhs.mount_point; });
+    mountinfo.erase(erase_from, mountinfo.end());
+    std::reverse(mountinfo.begin(), mountinfo.end());
+    // mountinfo is reversed twice, so still is in lexical sorted order.
+
+    for (const auto& entry : mountinfo) {
         if ((entry.mount_point == mount_point) && !entry.shared_flag) {
             parent_private = true;
         }
         if ((entry.mount_point == "/dev") && !entry.shared_flag) {
             dev_private = true;
         }
+    }
+
+    // Need to make the original mountpoint MS_PRIVATE, so that the overlayfs can be MS_MOVE.
+    // This could happen if its parent mount is remounted later.
+    if (!parent_private) {
+        parent_made_private = fs_mgr_overlayfs_set_shared_mount(mount_point, false);
+    }
 
+    for (const auto& entry : mountinfo) {
+        // Find all immediate submounts.
         if (!android::base::StartsWith(entry.mount_point, mount_point + "/")) {
             continue;
         }
-        if (std::find_if(move.begin(), move.end(), [&entry](const auto& it) {
-                return android::base::StartsWith(entry.mount_point, it.mount_point + "/");
-            }) != move.end()) {
+        // Exclude duplicated or more specific entries.
+        if (std::find_if(moved_mounts.begin(), moved_mounts.end(), [&entry](const auto& it) {
+                return it.mount_point == entry.mount_point ||
+                       android::base::StartsWith(entry.mount_point, it.mount_point + "/");
+            }) != moved_mounts.end()) {
             continue;
         }
+        // mountinfo is in lexical order, so no need to worry about |entry| being a parent mount of
+        // entries of |moved_mounts|.
 
         // use as the bound directory in /dev.
         AutoSetFsCreateCon createcon;
@@ -414,8 +446,7 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
         if (new_context.empty() || !createcon.Set(new_context)) {
             continue;
         }
-        move_entry new_entry = {std::move(entry.mount_point), "/dev/TemporaryDir-XXXXXX",
-                                entry.shared_flag};
+        MoveEntry new_entry{entry.mount_point, "/dev/TemporaryDir-XXXXXX", entry.shared_flag};
         const auto target = mkdtemp(new_entry.dir.data());
         if (!createcon.Restore()) {
             return false;
@@ -426,9 +457,6 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
             continue;
         }
 
-        if (!parent_private && !parent_made_private) {
-            parent_made_private = fs_mgr_overlayfs_set_shared_mount(mount_point, false);
-        }
         if (new_entry.shared_flag) {
             new_entry.shared_flag = fs_mgr_overlayfs_set_shared_mount(new_entry.mount_point, false);
         }
@@ -439,7 +467,7 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
             }
             continue;
         }
-        move.emplace_back(std::move(new_entry));
+        moved_mounts.push_back(std::move(new_entry));
     }
 
     // hijack __mount() report format to help triage
@@ -463,7 +491,7 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
     }
 
     // Move submounts back.
-    for (const auto& entry : move) {
+    for (const auto& entry : moved_mounts) {
         if (!dev_private && !dev_made_private) {
             dev_made_private = fs_mgr_overlayfs_set_shared_mount("/dev", false);
         }
@@ -658,22 +686,13 @@ Fstab fs_mgr_overlayfs_candidate_list(const Fstab& fstab) {
             !fs_mgr_wants_overlayfs(&new_entry)) {
             continue;
         }
-        auto new_mount_point = fs_mgr_mount_point(entry.mount_point);
-        auto duplicate_or_more_specific = false;
-        for (auto it = candidates.begin(); it != candidates.end();) {
-            auto it_mount_point = fs_mgr_mount_point(it->mount_point);
-            if ((it_mount_point == new_mount_point) ||
-                (android::base::StartsWith(new_mount_point, it_mount_point + "/"))) {
-                duplicate_or_more_specific = true;
-                break;
-            }
-            if (android::base::StartsWith(it_mount_point, new_mount_point + "/")) {
-                it = candidates.erase(it);
-            } else {
-                ++it;
-            }
+        const auto new_mount_point = fs_mgr_mount_point(new_entry.mount_point);
+        if (std::find_if(candidates.begin(), candidates.end(), [&](const auto& it) {
+                return fs_mgr_mount_point(it.mount_point) == new_mount_point;
+            }) != candidates.end()) {
+            continue;
         }
-        if (!duplicate_or_more_specific) candidates.emplace_back(std::move(new_entry));
+        candidates.push_back(std::move(new_entry));
     }
     return candidates;
 }
diff --git a/fs_mgr/fs_mgr_remount.cpp b/fs_mgr/fs_mgr_remount.cpp
index 4b3a5d3ea0fe..18892f985529 100644
--- a/fs_mgr/fs_mgr_remount.cpp
+++ b/fs_mgr/fs_mgr_remount.cpp
@@ -88,17 +88,6 @@ const std::string system_mount_point(const android::fs_mgr::FstabEntry& entry) {
     return entry.mount_point;
 }
 
-const FstabEntry* GetWrappedEntry(const Fstab& overlayfs_candidates, const FstabEntry& entry) {
-    auto mount_point = system_mount_point(entry);
-    auto it = std::find_if(overlayfs_candidates.begin(), overlayfs_candidates.end(),
-                           [&mount_point](const auto& entry) {
-                               return android::base::StartsWith(mount_point,
-                                                                system_mount_point(entry) + "/");
-                           });
-    if (it == overlayfs_candidates.end()) return nullptr;
-    return &(*it);
-}
-
 class MyLogger {
   public:
     explicit MyLogger(bool verbose) : verbose_(verbose) {}
@@ -196,9 +185,6 @@ static bool IsRemountable(Fstab& candidates, const FstabEntry& entry) {
     if (auto candidate_entry = GetEntryForMountPoint(&candidates, entry.mount_point)) {
         return candidate_entry->fs_type == entry.fs_type;
     }
-    if (GetWrappedEntry(candidates, entry)) {
-        return false;
-    }
     return true;
 }
 
@@ -252,11 +238,6 @@ bool GetRemountList(const Fstab& fstab, const std::vector<std::string>& argv, Fs
         }
 
         const FstabEntry* entry = &*it;
-        if (auto wrap = GetWrappedEntry(candidates, *entry); wrap != nullptr) {
-            LOG(INFO) << "partition " << arg << " covered by overlayfs for " << wrap->mount_point
-                      << ", switching";
-            entry = wrap;
-        }
 
         // If it's already remounted, include it so it gets gracefully skipped
         // later on.

From 05d3adb7138c05dcc77ee93411c07ca117bd3322 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Fri, 20 Oct 2023 20:40:49 +0800
Subject: [PATCH 0490/1487] fs_mgr_overlayfs: Remove temp dir under /dev when
 aborting

When aborting from fs_mgr_overlayfs_mount, we should remove any temp dir
we created under /dev before aborting the program.

Bug: 306124139
Test: adb-remount-test
Change-Id: I6debf84935e39d884f2f5b3e9720fdfd4332465c
---
 fs_mgr/fs_mgr_overlayfs_mount.cpp | 31 ++++++++++++++++++-------------
 1 file changed, 18 insertions(+), 13 deletions(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index f149a31d59ad..ae7ed4ccf056 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -441,20 +441,24 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
         // entries of |moved_mounts|.
 
         // use as the bound directory in /dev.
-        AutoSetFsCreateCon createcon;
-        auto new_context = fs_mgr_get_context(entry.mount_point);
-        if (new_context.empty() || !createcon.Set(new_context)) {
-            continue;
-        }
         MoveEntry new_entry{entry.mount_point, "/dev/TemporaryDir-XXXXXX", entry.shared_flag};
-        const auto target = mkdtemp(new_entry.dir.data());
-        if (!createcon.Restore()) {
-            return false;
-        }
-        if (!target) {
-            retval = false;
-            PERROR << "temporary directory for MS_BIND";
-            continue;
+        {
+            AutoSetFsCreateCon createcon;
+            auto new_context = fs_mgr_get_context(entry.mount_point);
+            if (new_context.empty() || !createcon.Set(new_context)) {
+                continue;
+            }
+            const auto target = mkdtemp(new_entry.dir.data());
+            if (!target) {
+                retval = false;
+                PERROR << "temporary directory for MS_MOVE";
+                continue;
+            }
+            if (!createcon.Restore()) {
+                retval = false;
+                rmdir(new_entry.dir.c_str());
+                continue;
+            }
         }
 
         if (new_entry.shared_flag) {
@@ -465,6 +469,7 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
             if (new_entry.shared_flag) {
                 fs_mgr_overlayfs_set_shared_mount(new_entry.mount_point, true);
             }
+            rmdir(new_entry.dir.c_str());
             continue;
         }
         moved_mounts.push_back(std::move(new_entry));

From 35817eeb55b91beaf2c68345bb4fac707e43156b Mon Sep 17 00:00:00 2001
From: Philip Chen <philipchen@google.com>
Date: Mon, 23 Oct 2023 21:41:28 +0000
Subject: [PATCH 0491/1487] vts_fs_test: Do not check /metadata for automotive

This aligns with GAS req 4.0.

Bug: 307215040
Test: build
Change-Id: I2115e147d484d066f892ea50eeca626e64beebfc
---
 fs_mgr/tests/vts_fs_test.cpp | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/tests/vts_fs_test.cpp b/fs_mgr/tests/vts_fs_test.cpp
index 4d771fa046d6..bf003eef7c7e 100644
--- a/fs_mgr/tests/vts_fs_test.cpp
+++ b/fs_mgr/tests/vts_fs_test.cpp
@@ -30,6 +30,24 @@ static int GetVsrLevel() {
     return android::base::GetIntProperty("ro.vendor.api_level", -1);
 }
 
+// Returns true iff the device has the specified feature.
+bool DeviceSupportsFeature(const char* feature) {
+    bool device_supports_feature = false;
+    FILE* p = popen("pm list features", "re");
+    if (p) {
+        char* line = NULL;
+        size_t len = 0;
+        while (getline(&line, &len, p) > 0) {
+            if (strstr(line, feature)) {
+                device_supports_feature = true;
+                break;
+            }
+        }
+        pclose(p);
+    }
+    return device_supports_feature;
+}
+
 TEST(fs, ErofsSupported) {
     // T-launch GKI kernels and higher must support EROFS.
     if (GetVsrLevel() < __ANDROID_API_T__) {
@@ -80,7 +98,8 @@ TEST(fs, PartitionTypes) {
     ASSERT_TRUE(android::base::Readlink("/dev/block/by-name/userdata", &userdata_bdev));
 
     std::vector<std::string> must_be_f2fs = {"/data"};
-    if (vsr_level >= __ANDROID_API_U__) {
+    if (vsr_level >= __ANDROID_API_U__ &&
+        !DeviceSupportsFeature("android.hardware.type.automotive")) {
         must_be_f2fs.emplace_back("/metadata");
     }
 

From 50dca4a77b68478dab9d887a938fc3791dd76ede Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Tue, 24 Oct 2023 20:59:39 +0800
Subject: [PATCH 0492/1487] remount: If checkpoint is in progress, wait for it
 to complete

Instead of having the user to retry the `remount` command until success
(manual poll). Just block the remount command until checkpoint is
complete, and then continue.

Bug: 252989722
Test: adb remount on a cold device, remount command would block for a
  few dozens of seconds and then continue.
Test: adb remount on a warm device, remount command would process
  immediately. Do not show "force end checkpointing" instructions.
Change-Id: I65f3a5ade4c9538a55892345c75b45ac3a1755fd
---
 fs_mgr/fs_mgr_remount.cpp | 28 +++++++++++++++++++---------
 1 file changed, 19 insertions(+), 9 deletions(-)

diff --git a/fs_mgr/fs_mgr_remount.cpp b/fs_mgr/fs_mgr_remount.cpp
index 18892f985529..7ba4d2be4f23 100644
--- a/fs_mgr/fs_mgr_remount.cpp
+++ b/fs_mgr/fs_mgr_remount.cpp
@@ -158,15 +158,25 @@ bool VerifyCheckpointing() {
     // not checkpointing.
     auto vold = GetVold();
     bool checkpointing = false;
-    if (!vold->isCheckpointing(&checkpointing).isOk()) {
-        LOG(ERROR) << "Could not determine checkpointing status.";
-        return false;
-    }
-    if (checkpointing) {
-        LOG(ERROR) << "Cannot use remount when a checkpoint is in progress.";
-        LOG(ERROR) << "To force end checkpointing, call 'vdc checkpoint commitChanges'";
-        LOG(ERROR) << "Warning: this can lead to data corruption if rolled back.";
-        return false;
+    bool show_help = true;
+
+    while (true) {
+        if (!vold->isCheckpointing(&checkpointing).isOk()) {
+            LOG(ERROR) << "Could not determine checkpointing status.";
+            return false;
+        }
+        if (!checkpointing) {
+            break;
+        }
+        if (show_help) {
+            show_help = false;
+            std::cerr << "WARNING: Userdata checkpoint is in progress. To force end checkpointing, "
+                         "call 'vdc checkpoint commitChanges'. This can lead to data corruption if "
+                         "rolled back."
+                      << std::endl;
+            LOG(INFO) << "Waiting for checkpoint to complete and then continue remount.";
+        }
+        std::this_thread::sleep_for(4s);
     }
     return true;
 }

From 6c625e5d2e33bdaed7b9933b237502968c4b16e1 Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Mon, 23 Oct 2023 14:33:14 -0700
Subject: [PATCH 0493/1487] Run fsck to resolve possible data corruption

Trigger fsck on mount of /data if the value of ro.preventative_fsck is
not equal to the contents of /metadata/vold/preventative_fsck, then set
the file to the property to prevent future runs

See b/305658663 for context

Bug: 305658663
Test: Make sure fsck run after first boot and not after second
Ignore-AOSP-First: Critical UDC only bug
Change-Id: I856c812d22363cc1d1e8aa88706d4d3b89044f52
---
 fs_mgr/fs_mgr.cpp | 25 ++++++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 742cdfab012a..8b9bce1dbb5d 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -699,6 +699,29 @@ static void SetReadAheadSize(const std::string& entry_block_device, off64_t size
     }
 }
 
+//
+// Mechanism to allow fsck to be triggered by setting ro.preventative_fsck
+// Introduced to address b/305658663
+// If the property value is not equal to the flag file contents, trigger
+// fsck and store the property value in the flag file
+// If we want to trigger again, simply change the property value
+//
+static bool check_if_preventative_fsck_needed(const FstabEntry& entry) {
+    const char* flag_file = "/metadata/vold/preventative_fsck";
+    if (entry.mount_point != "/data") return false;
+
+    // Don't error check - both default to empty string, which is OK
+    std::string prop = android::base::GetProperty("ro.preventative_fsck", "");
+    std::string flag;
+    android::base::ReadFileToString(flag_file, &flag);
+    if (prop == flag) return false;
+    // fsck is run immediately, so assume it runs or there is some deeper problem
+    if (!android::base::WriteStringToFile(prop, flag_file))
+        PERROR << "Failed to write file " << flag_file;
+    LINFO << "Run preventative fsck on /data";
+    return true;
+}
+
 //
 // Prepare the filesystem on the given block device to be mounted.
 //
@@ -749,7 +772,7 @@ static int prepare_fs_for_mount(const std::string& blk_device, const FstabEntry&
         }
     }
 
-    if (entry.fs_mgr_flags.check ||
+    if (check_if_preventative_fsck_needed(entry) || entry.fs_mgr_flags.check ||
         (fs_stat & (FS_STAT_UNCLEAN_SHUTDOWN | FS_STAT_QUOTA_ENABLED))) {
         check_fs(blk_device, entry.fs_type, mount_point, &fs_stat);
     }

From 14e997fe433237011f9ab3c82f3c7f896e83c1e0 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Tue, 24 Oct 2023 14:38:49 -0700
Subject: [PATCH 0494/1487] Fix indices in fuzzer.

There are a few places where an index is randomly generated, but the
max is incorrectly set to the size of the value not one less than
the size.

All of these occurrences have been fixed.

Bug: 306230574

Test: Ran fuzzer instance that failed, no longer fails.
Change-Id: I20dfbc19a0df9cb160f8c861e072f083e24a4fab
---
 fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp b/fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp
index b6fbc142a0c9..a15bc8905575 100644
--- a/fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp
+++ b/fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp
@@ -198,13 +198,13 @@ void LiplpApisFuzzer::process() {
                     [&]() {
                         uint32_t groupVectorSize = metadata->groups.size();
                         uint32_t randomGroupIndex =
-                                mFdp.ConsumeIntegralInRange<uint32_t>(0, groupVectorSize);
+                                mFdp.ConsumeIntegralInRange<uint32_t>(0, groupVectorSize - 1);
                         GetPartitionGroupName(metadata->groups[randomGroupIndex]);
                     },
                     [&]() {
                         uint32_t blockDeviceVectorSize = metadata->block_devices.size();
                         uint32_t randomBlockDeviceIndex =
-                                mFdp.ConsumeIntegralInRange<uint32_t>(0, blockDeviceVectorSize);
+                                mFdp.ConsumeIntegralInRange<uint32_t>(0, blockDeviceVectorSize - 1);
                         GetBlockDevicePartitionName(
                                 metadata->block_devices[randomBlockDeviceIndex]);
                     },
@@ -224,7 +224,7 @@ void LiplpApisFuzzer::process() {
                     [&]() {
                         uint32_t partitionVectorSize = metadata->partitions.size();
                         uint32_t randomPartitionIndex =
-                                mFdp.ConsumeIntegralInRange<uint32_t>(0, partitionVectorSize);
+                                mFdp.ConsumeIntegralInRange<uint32_t>(0, partitionVectorSize - 1);
                         GetPartitionName(metadata->partitions[randomPartitionIndex]);
                     },
                     [&]() { GetTotalSuperPartitionSize(metadataValue); },

From c7383702733f5a9f954a3f151ee9a555ff0576ff Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Sat, 21 Oct 2023 00:43:52 +0000
Subject: [PATCH 0495/1487] libutils_binder: isolate headers

This isolated all libutils_binder headers from libutils
except for RefBase use of CallStack.h. This header can
be disabled with a macro option easily.

Bug: N/A
Test: N/A
Change-Id: I83af091fc17b5418ab9e4d7fc41fb43792ec547d
---
 libutils/Android.bp                          |  23 +-
 libutils/binder/Android.bp                   |   1 +
 libutils/binder/RefBase.cpp                  |   6 +-
 libutils/binder/String8.cpp                  |   8 +-
 libutils/binder/Unicode.cpp                  |  49 ++-
 libutils/binder/include/utils/LightRefBase.h |  76 +++++
 libutils/binder/include/utils/TypeHelpers.h  | 336 ++++++++++++++++++
 libutils/include/utils/LightRefBase.h        |  77 +----
 libutils/include/utils/TypeHelpers.h         | 337 +------------------
 9 files changed, 464 insertions(+), 449 deletions(-)
 create mode 100644 libutils/binder/include/utils/LightRefBase.h
 create mode 100644 libutils/binder/include/utils/TypeHelpers.h
 mode change 100644 => 120000 libutils/include/utils/LightRefBase.h
 mode change 100644 => 120000 libutils/include/utils/TypeHelpers.h

diff --git a/libutils/Android.bp b/libutils/Android.bp
index b3ddda3b372d..4d4294b9bf2e 100644
--- a/libutils/Android.bp
+++ b/libutils/Android.bp
@@ -68,13 +68,6 @@ cc_defaults {
         "-Wno-exit-time-destructors",
         "-DANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION",
     ],
-    header_libs: [
-        "libbase_headers",
-        "libutils_headers",
-    ],
-    export_header_lib_headers: [
-        "libutils_headers",
-    ],
 
     shared_libs: [
         "libcutils",
@@ -134,6 +127,14 @@ cc_defaults {
 
     whole_static_libs: ["libutils_binder"],
 
+    header_libs: [
+        "libbase_headers",
+        "libutils_headers",
+    ],
+    export_header_lib_headers: [
+        "libutils_headers",
+    ],
+
     srcs: [
         "FileMap.cpp",
         "JenkinsHash.cpp",
@@ -221,6 +222,14 @@ cc_library {
         support_system_process: true,
     },
 
+    header_libs: [
+        "libbase_headers",
+        "libutils_headers",
+    ],
+    export_header_lib_headers: [
+        "libutils_headers",
+    ],
+
     srcs: [
         "CallStack.cpp",
     ],
diff --git a/libutils/binder/Android.bp b/libutils/binder/Android.bp
index e2eddb332f0d..a049f3d805b0 100644
--- a/libutils/binder/Android.bp
+++ b/libutils/binder/Android.bp
@@ -10,6 +10,7 @@ cc_defaults {
     ],
     native_bridge_supported: true,
 
+    export_include_dirs: ["include"],
     srcs: [
         "Errors.cpp",
         "RefBase.cpp",
diff --git a/libutils/binder/RefBase.cpp b/libutils/binder/RefBase.cpp
index c7055fb48350..4b0cc161bc45 100644
--- a/libutils/binder/RefBase.cpp
+++ b/libutils/binder/RefBase.cpp
@@ -20,8 +20,6 @@
 #include <memory>
 #include <mutex>
 
-#include <android-base/macros.h>
-
 #include <fcntl.h>
 #include <log/log.h>
 
@@ -65,7 +63,7 @@
 #endif
 
 #if CALLSTACK_ENABLED
-#include <utils/CallStack.h>
+#include "../../include/utils/CallStack.h"
 #endif
 
 // ---------------------------------------------------------------------------
@@ -536,7 +534,7 @@ void RefBase::forceIncStrong(const void* id) const
     case INITIAL_STRONG_VALUE:
         refs->mStrong.fetch_sub(INITIAL_STRONG_VALUE,
                 std::memory_order_relaxed);
-        FALLTHROUGH_INTENDED;
+        [[fallthrough]];
     case 0:
         refs->mBase->onFirstRef();
     }
diff --git a/libutils/binder/String8.cpp b/libutils/binder/String8.cpp
index 6a754843117f..749bfcbb510d 100644
--- a/libutils/binder/String8.cpp
+++ b/libutils/binder/String8.cpp
@@ -19,7 +19,6 @@
 
 #include <utils/String8.h>
 
-#include <utils/Compat.h>
 #include <log/log.h>
 #include <utils/String16.h>
 
@@ -430,6 +429,13 @@ void String8::toLower()
 // ---------------------------------------------------------------------------
 // Path functions
 
+// TODO: we should remove all the path functions from String8
+#if defined(_WIN32)
+#define OS_PATH_SEPARATOR '\\'
+#else
+#define OS_PATH_SEPARATOR '/'
+#endif
+
 String8 String8::getPathDir(void) const
 {
     const char* cp;
diff --git a/libutils/binder/Unicode.cpp b/libutils/binder/Unicode.cpp
index 364a1778c632..2ed2d4f80ae2 100644
--- a/libutils/binder/Unicode.cpp
+++ b/libutils/binder/Unicode.cpp
@@ -16,7 +16,6 @@
 
 #define LOG_TAG "unicode"
 
-#include <android-base/macros.h>
 #include <limits.h>
 #include <utils/Unicode.h>
 
@@ -92,11 +91,11 @@ static inline void utf32_codepoint_to_utf8(uint8_t* dstP, char32_t srcChar, size
     switch (bytes)
     {   /* note: everything falls through. */
         case 4: *--dstP = (uint8_t)((srcChar | kByteMark) & kByteMask); srcChar >>= 6;
-            FALLTHROUGH_INTENDED;
+            [[fallthrough]];
         case 3: *--dstP = (uint8_t)((srcChar | kByteMark) & kByteMask); srcChar >>= 6;
-            FALLTHROUGH_INTENDED;
+            [[fallthrough]];
         case 2: *--dstP = (uint8_t)((srcChar | kByteMark) & kByteMask); srcChar >>= 6;
-            FALLTHROUGH_INTENDED;
+            [[fallthrough]];
         case 1: *--dstP = (uint8_t)(srcChar | kFirstByteMark[bytes]);
     }
 }
@@ -304,15 +303,15 @@ ssize_t utf16_to_utf8_length(const char16_t *src, size_t src_len)
 
     while (in < end) {
         char16_t w = *in++;
-        if (LIKELY(w < 0x0080)) {
+        if (w < 0x0080) [[likely]] {
             utf8_len += 1;
             continue;
         }
-        if (LIKELY(w < 0x0800)) {
+        if (w < 0x0800) [[likely]] {
             utf8_len += 2;
             continue;
         }
-        if (LIKELY(!is_any_surrogate(w))) {
+        if (!is_any_surrogate(w)) [[likely]] {
             utf8_len += 3;
             continue;
         }
@@ -345,20 +344,20 @@ void utf16_to_utf8(const char16_t* src, size_t src_len, char* dst, size_t dst_le
 
     while (in < in_end) {
         char16_t w = *in++;
-        if (LIKELY(w < 0x0080)) {
+        if (w < 0x0080) [[likely]] {
             if (out + 1 > out_end)
                 return err_out();
             *out++ = (char)(w & 0xff);
             continue;
         }
-        if (LIKELY(w < 0x0800)) {
+        if (w < 0x0800) [[likely]] {
             if (out + 2 > out_end)
                 return err_out();
             *out++ = (char)(0xc0 | ((w >> 6) & 0x1f));
             *out++ = (char)(0x80 | ((w >> 0) & 0x3f));
             continue;
         }
-        if (LIKELY(!is_any_surrogate(w))) {
+        if (!is_any_surrogate(w)) [[likely]] {
             if (out + 3 > out_end)
                 return err_out();
             *out++ = (char)(0xe0 | ((w >> 12) & 0xf));
@@ -420,25 +419,25 @@ ssize_t utf8_to_utf16_length(const uint8_t* u8str, size_t u8len, bool overreadIs
     while (in < in_end) {
         uint8_t c = *in;
         utf16_len++;
-        if (LIKELY((c & 0x80) == 0)) {
+        if ((c & 0x80) == 0) [[likely]] {
             in++;
             continue;
         }
-        if (UNLIKELY(c < 0xc0)) {
+        if (c < 0xc0) [[unlikely]] {
             ALOGW("Invalid UTF-8 leading byte: 0x%02x", c);
             in++;
             continue;
         }
-        if (LIKELY(c < 0xe0)) {
+        if (c < 0xe0) [[likely]] {
             in += 2;
             continue;
         }
-        if (LIKELY(c < 0xf0)) {
+        if (c < 0xf0) [[likely]] {
             in += 3;
             continue;
         } else {
             uint8_t c2, c3, c4;
-            if (UNLIKELY(c >= 0xf8)) {
+            if (c >= 0xf8) [[unlikely]] {
                 ALOGW("Invalid UTF-8 leading byte: 0x%02x", c);
             }
             c2 = in[1]; c3 = in[2]; c4 = in[3];
@@ -487,25 +486,25 @@ char16_t* utf8_to_utf16_no_null_terminator(
 
     while (in < in_end && out < out_end) {
         c = *in++;
-        if (LIKELY((c & 0x80) == 0)) {
+        if ((c & 0x80) == 0) [[likely]] {
             *out++ = (char16_t)(c);
             continue;
         }
-        if (UNLIKELY(c < 0xc0)) {
+        if (c < 0xc0) [[unlikely]] {
             ALOGW("Invalid UTF-8 leading byte: 0x%02x", c);
             *out++ = (char16_t)(c);
             continue;
         }
-        if (LIKELY(c < 0xe0)) {
-            if (UNLIKELY(in + 1 > in_end)) {
+        if (c < 0xe0) [[likely]] {
+            if (in + 1 > in_end) [[unlikely]] {
                 return err_in();
             }
             c2 = *in++;
             *out++ = (char16_t)(((c & 0x1f) << 6) | (c2 & 0x3f));
             continue;
         }
-        if (LIKELY(c < 0xf0)) {
-            if (UNLIKELY(in + 2 > in_end)) {
+        if (c < 0xf0) [[likely]] {
+            if (in + 2 > in_end) [[unlikely]] {
                 return err_in();
             }
             c2 = *in++; c3 = *in++;
@@ -513,19 +512,19 @@ char16_t* utf8_to_utf16_no_null_terminator(
                                 ((c2 & 0x3f) << 6) | (c3 & 0x3f));
             continue;
         } else {
-            if (UNLIKELY(in + 3 > in_end)) {
+            if (in + 3 > in_end) [[unlikely]] {
                 return err_in();
             }
-            if (UNLIKELY(c >= 0xf8)) {
+            if (c >= 0xf8) [[unlikely]] {
                 ALOGW("Invalid UTF-8 leading byte: 0x%02x", c);
             }
             // Multiple UTF16 characters with surrogates
             c2 = *in++; c3 = *in++; c4 = *in++;
             w = utf8_4b_to_utf32(c, c2, c3, c4);
-            if (UNLIKELY(w < 0x10000)) {
+            if (w < 0x10000) [[unlikely]] {
                 *out++ = (char16_t)(w);
             } else {
-                if (UNLIKELY(out + 2 > out_end)) {
+                if (out + 2 > out_end) [[unlikely]] {
                     // Ooops.... not enough room for this surrogate pair.
                     return out;
                 }
diff --git a/libutils/binder/include/utils/LightRefBase.h b/libutils/binder/include/utils/LightRefBase.h
new file mode 100644
index 000000000000..40edf6718d33
--- /dev/null
+++ b/libutils/binder/include/utils/LightRefBase.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+/*
+ * See documentation in RefBase.h
+ */
+
+#include <atomic>
+
+#include <sys/types.h>
+
+namespace android {
+
+class ReferenceRenamer;
+
+void LightRefBase_reportIncStrongRequireStrongFailed(const void* thiz);
+
+template <class T>
+class LightRefBase
+{
+public:
+    inline LightRefBase() : mCount(0) { }
+    inline void incStrong(__attribute__((unused)) const void* id) const {
+        mCount.fetch_add(1, std::memory_order_relaxed);
+    }
+    inline void incStrongRequireStrong(__attribute__((unused)) const void* id) const {
+        if (0 == mCount.fetch_add(1, std::memory_order_relaxed)) {
+            LightRefBase_reportIncStrongRequireStrongFailed(this);
+        }
+    }
+    inline void decStrong(__attribute__((unused)) const void* id) const {
+        if (mCount.fetch_sub(1, std::memory_order_release) == 1) {
+            std::atomic_thread_fence(std::memory_order_acquire);
+            delete static_cast<const T*>(this);
+        }
+    }
+    //! DEBUGGING ONLY: Get current strong ref count.
+    inline int32_t getStrongCount() const {
+        return mCount.load(std::memory_order_relaxed);
+    }
+
+protected:
+    inline ~LightRefBase() { }
+
+private:
+    friend class ReferenceMover;
+    inline static void renameRefs(size_t /*n*/, const ReferenceRenamer& /*renamer*/) { }
+    inline static void renameRefId(T* /*ref*/, const void* /*old_id*/ , const void* /*new_id*/) { }
+
+private:
+    mutable std::atomic<int32_t> mCount;
+};
+
+// This is a wrapper around LightRefBase that simply enforces a virtual
+// destructor to eliminate the template requirement of LightRefBase
+class VirtualLightRefBase : public LightRefBase<VirtualLightRefBase> {
+public:
+    virtual ~VirtualLightRefBase() = default;
+};
+
+}  // namespace android
diff --git a/libutils/binder/include/utils/TypeHelpers.h b/libutils/binder/include/utils/TypeHelpers.h
new file mode 100644
index 000000000000..1554f52ee176
--- /dev/null
+++ b/libutils/binder/include/utils/TypeHelpers.h
@@ -0,0 +1,336 @@
+/*
+ * Copyright (C) 2005 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.
+ */
+
+#ifndef ANDROID_TYPE_HELPERS_H
+#define ANDROID_TYPE_HELPERS_H
+
+#include <new>
+#include <type_traits>
+
+#include <stdint.h>
+#include <string.h>
+#include <sys/types.h>
+
+// ---------------------------------------------------------------------------
+
+namespace android {
+
+/*
+ * Types traits
+ */
+
+template <typename T> struct trait_trivial_ctor { enum { value = false }; };
+template <typename T> struct trait_trivial_dtor { enum { value = false }; };
+template <typename T> struct trait_trivial_copy { enum { value = false }; };
+template <typename T> struct trait_trivial_move { enum { value = false }; };
+template <typename T> struct trait_pointer      { enum { value = false }; };
+template <typename T> struct trait_pointer<T*>  { enum { value = true }; };
+
+template <typename TYPE>
+struct traits {
+    enum {
+        // whether this type is a pointer
+        is_pointer          = trait_pointer<TYPE>::value,
+        // whether this type's constructor is a no-op
+        has_trivial_ctor    = is_pointer || trait_trivial_ctor<TYPE>::value,
+        // whether this type's destructor is a no-op
+        has_trivial_dtor    = is_pointer || trait_trivial_dtor<TYPE>::value,
+        // whether this type type can be copy-constructed with memcpy
+        has_trivial_copy    = is_pointer || trait_trivial_copy<TYPE>::value,
+        // whether this type can be moved with memmove
+        has_trivial_move    = is_pointer || trait_trivial_move<TYPE>::value
+    };
+};
+
+template <typename T, typename U>
+struct aggregate_traits {
+    enum {
+        is_pointer          = false,
+        has_trivial_ctor    =
+            traits<T>::has_trivial_ctor && traits<U>::has_trivial_ctor,
+        has_trivial_dtor    =
+            traits<T>::has_trivial_dtor && traits<U>::has_trivial_dtor,
+        has_trivial_copy    =
+            traits<T>::has_trivial_copy && traits<U>::has_trivial_copy,
+        has_trivial_move    =
+            traits<T>::has_trivial_move && traits<U>::has_trivial_move
+    };
+};
+
+#define ANDROID_TRIVIAL_CTOR_TRAIT( T ) \
+    template<> struct trait_trivial_ctor< T >   { enum { value = true }; };
+
+#define ANDROID_TRIVIAL_DTOR_TRAIT( T ) \
+    template<> struct trait_trivial_dtor< T >   { enum { value = true }; };
+
+#define ANDROID_TRIVIAL_COPY_TRAIT( T ) \
+    template<> struct trait_trivial_copy< T >   { enum { value = true }; };
+
+#define ANDROID_TRIVIAL_MOVE_TRAIT( T ) \
+    template<> struct trait_trivial_move< T >   { enum { value = true }; };
+
+#define ANDROID_BASIC_TYPES_TRAITS( T ) \
+    ANDROID_TRIVIAL_CTOR_TRAIT( T ) \
+    ANDROID_TRIVIAL_DTOR_TRAIT( T ) \
+    ANDROID_TRIVIAL_COPY_TRAIT( T ) \
+    ANDROID_TRIVIAL_MOVE_TRAIT( T )
+
+// ---------------------------------------------------------------------------
+
+/*
+ * basic types traits
+ */
+
+ANDROID_BASIC_TYPES_TRAITS( void )
+ANDROID_BASIC_TYPES_TRAITS( bool )
+ANDROID_BASIC_TYPES_TRAITS( char )
+ANDROID_BASIC_TYPES_TRAITS( unsigned char )
+ANDROID_BASIC_TYPES_TRAITS( short )
+ANDROID_BASIC_TYPES_TRAITS( unsigned short )
+ANDROID_BASIC_TYPES_TRAITS( int )
+ANDROID_BASIC_TYPES_TRAITS( unsigned int )
+ANDROID_BASIC_TYPES_TRAITS( long )
+ANDROID_BASIC_TYPES_TRAITS( unsigned long )
+ANDROID_BASIC_TYPES_TRAITS( long long )
+ANDROID_BASIC_TYPES_TRAITS( unsigned long long )
+ANDROID_BASIC_TYPES_TRAITS( float )
+ANDROID_BASIC_TYPES_TRAITS( double )
+
+// ---------------------------------------------------------------------------
+
+
+/*
+ * compare and order types
+ */
+
+template<typename TYPE> inline
+int strictly_order_type(const TYPE& lhs, const TYPE& rhs) {
+    return (lhs < rhs) ? 1 : 0;
+}
+
+template<typename TYPE> inline
+int compare_type(const TYPE& lhs, const TYPE& rhs) {
+    return strictly_order_type(rhs, lhs) - strictly_order_type(lhs, rhs);
+}
+
+/*
+ * create, destroy, copy and move types...
+ */
+
+template<typename TYPE> inline
+void construct_type(TYPE* p, size_t n) {
+    if (!traits<TYPE>::has_trivial_ctor) {
+        while (n > 0) {
+            n--;
+            new(p++) TYPE;
+        }
+    }
+}
+
+template<typename TYPE> inline
+void destroy_type(TYPE* p, size_t n) {
+    if (!traits<TYPE>::has_trivial_dtor) {
+        while (n > 0) {
+            n--;
+            p->~TYPE();
+            p++;
+        }
+    }
+}
+
+template<typename TYPE>
+typename std::enable_if<traits<TYPE>::has_trivial_copy>::type
+inline
+copy_type(TYPE* d, const TYPE* s, size_t n) {
+    memcpy(d,s,n*sizeof(TYPE));
+}
+
+template<typename TYPE>
+typename std::enable_if<!traits<TYPE>::has_trivial_copy>::type
+inline
+copy_type(TYPE* d, const TYPE* s, size_t n) {
+    while (n > 0) {
+        n--;
+        new(d) TYPE(*s);
+        d++, s++;
+    }
+}
+
+template<typename TYPE> inline
+void splat_type(TYPE* where, const TYPE* what, size_t n) {
+    if (!traits<TYPE>::has_trivial_copy) {
+        while (n > 0) {
+            n--;
+            new(where) TYPE(*what);
+            where++;
+        }
+    } else {
+        while (n > 0) {
+            n--;
+            *where++ = *what;
+        }
+    }
+}
+
+template<typename TYPE>
+struct use_trivial_move : public std::integral_constant<bool,
+    (traits<TYPE>::has_trivial_dtor && traits<TYPE>::has_trivial_copy)
+    || traits<TYPE>::has_trivial_move
+> {};
+
+template<typename TYPE>
+typename std::enable_if<use_trivial_move<TYPE>::value>::type
+inline
+move_forward_type(TYPE* d, const TYPE* s, size_t n = 1) {
+    memmove(d, s, n*sizeof(TYPE));
+}
+
+template<typename TYPE>
+typename std::enable_if<!use_trivial_move<TYPE>::value>::type
+inline
+move_forward_type(TYPE* d, const TYPE* s, size_t n = 1) {
+    d += n;
+    s += n;
+    while (n > 0) {
+        n--;
+        --d, --s;
+        if (!traits<TYPE>::has_trivial_copy) {
+            new(d) TYPE(*s);
+        } else {
+            *d = *s;
+        }
+        if (!traits<TYPE>::has_trivial_dtor) {
+            s->~TYPE();
+        }
+    }
+}
+
+template<typename TYPE>
+typename std::enable_if<use_trivial_move<TYPE>::value>::type
+inline
+move_backward_type(TYPE* d, const TYPE* s, size_t n = 1) {
+    memmove(d, s, n*sizeof(TYPE));
+}
+
+template<typename TYPE>
+typename std::enable_if<!use_trivial_move<TYPE>::value>::type
+inline
+move_backward_type(TYPE* d, const TYPE* s, size_t n = 1) {
+    while (n > 0) {
+        n--;
+        if (!traits<TYPE>::has_trivial_copy) {
+            new(d) TYPE(*s);
+        } else {
+            *d = *s;
+        }
+        if (!traits<TYPE>::has_trivial_dtor) {
+            s->~TYPE();
+        }
+        d++, s++;
+    }
+}
+
+// ---------------------------------------------------------------------------
+
+/*
+ * a key/value pair
+ */
+
+template <typename KEY, typename VALUE>
+struct key_value_pair_t {
+    typedef KEY key_t;
+    typedef VALUE value_t;
+
+    KEY     key;
+    VALUE   value;
+    key_value_pair_t() { }
+    key_value_pair_t(const key_value_pair_t& o) : key(o.key), value(o.value) { }
+    key_value_pair_t& operator=(const key_value_pair_t& o) {
+        key = o.key;
+        value = o.value;
+        return *this;
+    }
+    key_value_pair_t(const KEY& k, const VALUE& v) : key(k), value(v)  { }
+    explicit key_value_pair_t(const KEY& k) : key(k) { }
+    inline bool operator < (const key_value_pair_t& o) const {
+        return strictly_order_type(key, o.key);
+    }
+    inline const KEY& getKey() const {
+        return key;
+    }
+    inline const VALUE& getValue() const {
+        return value;
+    }
+};
+
+template <typename K, typename V>
+struct trait_trivial_ctor< key_value_pair_t<K, V> >
+{ enum { value = aggregate_traits<K,V>::has_trivial_ctor }; };
+template <typename K, typename V>
+struct trait_trivial_dtor< key_value_pair_t<K, V> >
+{ enum { value = aggregate_traits<K,V>::has_trivial_dtor }; };
+template <typename K, typename V>
+struct trait_trivial_copy< key_value_pair_t<K, V> >
+{ enum { value = aggregate_traits<K,V>::has_trivial_copy }; };
+template <typename K, typename V>
+struct trait_trivial_move< key_value_pair_t<K, V> >
+{ enum { value = aggregate_traits<K,V>::has_trivial_move }; };
+
+// ---------------------------------------------------------------------------
+
+/*
+ * Hash codes.
+ */
+typedef uint32_t hash_t;
+
+template <typename TKey>
+hash_t hash_type(const TKey& key);
+
+/* Built-in hash code specializations */
+#define ANDROID_INT32_HASH(T) \
+        template <> inline hash_t hash_type(const T& value) { return hash_t(value); }
+#define ANDROID_INT64_HASH(T) \
+        template <> inline hash_t hash_type(const T& value) { \
+                return hash_t((value >> 32) ^ value); }
+#define ANDROID_REINTERPRET_HASH(T, R) \
+        template <> inline hash_t hash_type(const T& value) { \
+            R newValue; \
+            static_assert(sizeof(newValue) == sizeof(value), "size mismatch"); \
+            memcpy(&newValue, &value, sizeof(newValue)); \
+            return hash_type(newValue); \
+        }
+
+ANDROID_INT32_HASH(bool)
+ANDROID_INT32_HASH(int8_t)
+ANDROID_INT32_HASH(uint8_t)
+ANDROID_INT32_HASH(int16_t)
+ANDROID_INT32_HASH(uint16_t)
+ANDROID_INT32_HASH(int32_t)
+ANDROID_INT32_HASH(uint32_t)
+ANDROID_INT64_HASH(int64_t)
+ANDROID_INT64_HASH(uint64_t)
+ANDROID_REINTERPRET_HASH(float, uint32_t)
+ANDROID_REINTERPRET_HASH(double, uint64_t)
+
+template <typename T> inline hash_t hash_type(T* const & value) {
+    return hash_type(uintptr_t(value));
+}
+
+}  // namespace android
+
+// ---------------------------------------------------------------------------
+
+#endif // ANDROID_TYPE_HELPERS_H
diff --git a/libutils/include/utils/LightRefBase.h b/libutils/include/utils/LightRefBase.h
deleted file mode 100644
index 40edf6718d33..000000000000
--- a/libutils/include/utils/LightRefBase.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-/*
- * See documentation in RefBase.h
- */
-
-#include <atomic>
-
-#include <sys/types.h>
-
-namespace android {
-
-class ReferenceRenamer;
-
-void LightRefBase_reportIncStrongRequireStrongFailed(const void* thiz);
-
-template <class T>
-class LightRefBase
-{
-public:
-    inline LightRefBase() : mCount(0) { }
-    inline void incStrong(__attribute__((unused)) const void* id) const {
-        mCount.fetch_add(1, std::memory_order_relaxed);
-    }
-    inline void incStrongRequireStrong(__attribute__((unused)) const void* id) const {
-        if (0 == mCount.fetch_add(1, std::memory_order_relaxed)) {
-            LightRefBase_reportIncStrongRequireStrongFailed(this);
-        }
-    }
-    inline void decStrong(__attribute__((unused)) const void* id) const {
-        if (mCount.fetch_sub(1, std::memory_order_release) == 1) {
-            std::atomic_thread_fence(std::memory_order_acquire);
-            delete static_cast<const T*>(this);
-        }
-    }
-    //! DEBUGGING ONLY: Get current strong ref count.
-    inline int32_t getStrongCount() const {
-        return mCount.load(std::memory_order_relaxed);
-    }
-
-protected:
-    inline ~LightRefBase() { }
-
-private:
-    friend class ReferenceMover;
-    inline static void renameRefs(size_t /*n*/, const ReferenceRenamer& /*renamer*/) { }
-    inline static void renameRefId(T* /*ref*/, const void* /*old_id*/ , const void* /*new_id*/) { }
-
-private:
-    mutable std::atomic<int32_t> mCount;
-};
-
-// This is a wrapper around LightRefBase that simply enforces a virtual
-// destructor to eliminate the template requirement of LightRefBase
-class VirtualLightRefBase : public LightRefBase<VirtualLightRefBase> {
-public:
-    virtual ~VirtualLightRefBase() = default;
-};
-
-}  // namespace android
diff --git a/libutils/include/utils/LightRefBase.h b/libutils/include/utils/LightRefBase.h
new file mode 120000
index 000000000000..9da2cf07e034
--- /dev/null
+++ b/libutils/include/utils/LightRefBase.h
@@ -0,0 +1 @@
+../../binder/include/utils/LightRefBase.h
\ No newline at end of file
diff --git a/libutils/include/utils/TypeHelpers.h b/libutils/include/utils/TypeHelpers.h
deleted file mode 100644
index 1554f52ee176..000000000000
--- a/libutils/include/utils/TypeHelpers.h
+++ /dev/null
@@ -1,336 +0,0 @@
-/*
- * Copyright (C) 2005 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.
- */
-
-#ifndef ANDROID_TYPE_HELPERS_H
-#define ANDROID_TYPE_HELPERS_H
-
-#include <new>
-#include <type_traits>
-
-#include <stdint.h>
-#include <string.h>
-#include <sys/types.h>
-
-// ---------------------------------------------------------------------------
-
-namespace android {
-
-/*
- * Types traits
- */
-
-template <typename T> struct trait_trivial_ctor { enum { value = false }; };
-template <typename T> struct trait_trivial_dtor { enum { value = false }; };
-template <typename T> struct trait_trivial_copy { enum { value = false }; };
-template <typename T> struct trait_trivial_move { enum { value = false }; };
-template <typename T> struct trait_pointer      { enum { value = false }; };
-template <typename T> struct trait_pointer<T*>  { enum { value = true }; };
-
-template <typename TYPE>
-struct traits {
-    enum {
-        // whether this type is a pointer
-        is_pointer          = trait_pointer<TYPE>::value,
-        // whether this type's constructor is a no-op
-        has_trivial_ctor    = is_pointer || trait_trivial_ctor<TYPE>::value,
-        // whether this type's destructor is a no-op
-        has_trivial_dtor    = is_pointer || trait_trivial_dtor<TYPE>::value,
-        // whether this type type can be copy-constructed with memcpy
-        has_trivial_copy    = is_pointer || trait_trivial_copy<TYPE>::value,
-        // whether this type can be moved with memmove
-        has_trivial_move    = is_pointer || trait_trivial_move<TYPE>::value
-    };
-};
-
-template <typename T, typename U>
-struct aggregate_traits {
-    enum {
-        is_pointer          = false,
-        has_trivial_ctor    =
-            traits<T>::has_trivial_ctor && traits<U>::has_trivial_ctor,
-        has_trivial_dtor    =
-            traits<T>::has_trivial_dtor && traits<U>::has_trivial_dtor,
-        has_trivial_copy    =
-            traits<T>::has_trivial_copy && traits<U>::has_trivial_copy,
-        has_trivial_move    =
-            traits<T>::has_trivial_move && traits<U>::has_trivial_move
-    };
-};
-
-#define ANDROID_TRIVIAL_CTOR_TRAIT( T ) \
-    template<> struct trait_trivial_ctor< T >   { enum { value = true }; };
-
-#define ANDROID_TRIVIAL_DTOR_TRAIT( T ) \
-    template<> struct trait_trivial_dtor< T >   { enum { value = true }; };
-
-#define ANDROID_TRIVIAL_COPY_TRAIT( T ) \
-    template<> struct trait_trivial_copy< T >   { enum { value = true }; };
-
-#define ANDROID_TRIVIAL_MOVE_TRAIT( T ) \
-    template<> struct trait_trivial_move< T >   { enum { value = true }; };
-
-#define ANDROID_BASIC_TYPES_TRAITS( T ) \
-    ANDROID_TRIVIAL_CTOR_TRAIT( T ) \
-    ANDROID_TRIVIAL_DTOR_TRAIT( T ) \
-    ANDROID_TRIVIAL_COPY_TRAIT( T ) \
-    ANDROID_TRIVIAL_MOVE_TRAIT( T )
-
-// ---------------------------------------------------------------------------
-
-/*
- * basic types traits
- */
-
-ANDROID_BASIC_TYPES_TRAITS( void )
-ANDROID_BASIC_TYPES_TRAITS( bool )
-ANDROID_BASIC_TYPES_TRAITS( char )
-ANDROID_BASIC_TYPES_TRAITS( unsigned char )
-ANDROID_BASIC_TYPES_TRAITS( short )
-ANDROID_BASIC_TYPES_TRAITS( unsigned short )
-ANDROID_BASIC_TYPES_TRAITS( int )
-ANDROID_BASIC_TYPES_TRAITS( unsigned int )
-ANDROID_BASIC_TYPES_TRAITS( long )
-ANDROID_BASIC_TYPES_TRAITS( unsigned long )
-ANDROID_BASIC_TYPES_TRAITS( long long )
-ANDROID_BASIC_TYPES_TRAITS( unsigned long long )
-ANDROID_BASIC_TYPES_TRAITS( float )
-ANDROID_BASIC_TYPES_TRAITS( double )
-
-// ---------------------------------------------------------------------------
-
-
-/*
- * compare and order types
- */
-
-template<typename TYPE> inline
-int strictly_order_type(const TYPE& lhs, const TYPE& rhs) {
-    return (lhs < rhs) ? 1 : 0;
-}
-
-template<typename TYPE> inline
-int compare_type(const TYPE& lhs, const TYPE& rhs) {
-    return strictly_order_type(rhs, lhs) - strictly_order_type(lhs, rhs);
-}
-
-/*
- * create, destroy, copy and move types...
- */
-
-template<typename TYPE> inline
-void construct_type(TYPE* p, size_t n) {
-    if (!traits<TYPE>::has_trivial_ctor) {
-        while (n > 0) {
-            n--;
-            new(p++) TYPE;
-        }
-    }
-}
-
-template<typename TYPE> inline
-void destroy_type(TYPE* p, size_t n) {
-    if (!traits<TYPE>::has_trivial_dtor) {
-        while (n > 0) {
-            n--;
-            p->~TYPE();
-            p++;
-        }
-    }
-}
-
-template<typename TYPE>
-typename std::enable_if<traits<TYPE>::has_trivial_copy>::type
-inline
-copy_type(TYPE* d, const TYPE* s, size_t n) {
-    memcpy(d,s,n*sizeof(TYPE));
-}
-
-template<typename TYPE>
-typename std::enable_if<!traits<TYPE>::has_trivial_copy>::type
-inline
-copy_type(TYPE* d, const TYPE* s, size_t n) {
-    while (n > 0) {
-        n--;
-        new(d) TYPE(*s);
-        d++, s++;
-    }
-}
-
-template<typename TYPE> inline
-void splat_type(TYPE* where, const TYPE* what, size_t n) {
-    if (!traits<TYPE>::has_trivial_copy) {
-        while (n > 0) {
-            n--;
-            new(where) TYPE(*what);
-            where++;
-        }
-    } else {
-        while (n > 0) {
-            n--;
-            *where++ = *what;
-        }
-    }
-}
-
-template<typename TYPE>
-struct use_trivial_move : public std::integral_constant<bool,
-    (traits<TYPE>::has_trivial_dtor && traits<TYPE>::has_trivial_copy)
-    || traits<TYPE>::has_trivial_move
-> {};
-
-template<typename TYPE>
-typename std::enable_if<use_trivial_move<TYPE>::value>::type
-inline
-move_forward_type(TYPE* d, const TYPE* s, size_t n = 1) {
-    memmove(d, s, n*sizeof(TYPE));
-}
-
-template<typename TYPE>
-typename std::enable_if<!use_trivial_move<TYPE>::value>::type
-inline
-move_forward_type(TYPE* d, const TYPE* s, size_t n = 1) {
-    d += n;
-    s += n;
-    while (n > 0) {
-        n--;
-        --d, --s;
-        if (!traits<TYPE>::has_trivial_copy) {
-            new(d) TYPE(*s);
-        } else {
-            *d = *s;
-        }
-        if (!traits<TYPE>::has_trivial_dtor) {
-            s->~TYPE();
-        }
-    }
-}
-
-template<typename TYPE>
-typename std::enable_if<use_trivial_move<TYPE>::value>::type
-inline
-move_backward_type(TYPE* d, const TYPE* s, size_t n = 1) {
-    memmove(d, s, n*sizeof(TYPE));
-}
-
-template<typename TYPE>
-typename std::enable_if<!use_trivial_move<TYPE>::value>::type
-inline
-move_backward_type(TYPE* d, const TYPE* s, size_t n = 1) {
-    while (n > 0) {
-        n--;
-        if (!traits<TYPE>::has_trivial_copy) {
-            new(d) TYPE(*s);
-        } else {
-            *d = *s;
-        }
-        if (!traits<TYPE>::has_trivial_dtor) {
-            s->~TYPE();
-        }
-        d++, s++;
-    }
-}
-
-// ---------------------------------------------------------------------------
-
-/*
- * a key/value pair
- */
-
-template <typename KEY, typename VALUE>
-struct key_value_pair_t {
-    typedef KEY key_t;
-    typedef VALUE value_t;
-
-    KEY     key;
-    VALUE   value;
-    key_value_pair_t() { }
-    key_value_pair_t(const key_value_pair_t& o) : key(o.key), value(o.value) { }
-    key_value_pair_t& operator=(const key_value_pair_t& o) {
-        key = o.key;
-        value = o.value;
-        return *this;
-    }
-    key_value_pair_t(const KEY& k, const VALUE& v) : key(k), value(v)  { }
-    explicit key_value_pair_t(const KEY& k) : key(k) { }
-    inline bool operator < (const key_value_pair_t& o) const {
-        return strictly_order_type(key, o.key);
-    }
-    inline const KEY& getKey() const {
-        return key;
-    }
-    inline const VALUE& getValue() const {
-        return value;
-    }
-};
-
-template <typename K, typename V>
-struct trait_trivial_ctor< key_value_pair_t<K, V> >
-{ enum { value = aggregate_traits<K,V>::has_trivial_ctor }; };
-template <typename K, typename V>
-struct trait_trivial_dtor< key_value_pair_t<K, V> >
-{ enum { value = aggregate_traits<K,V>::has_trivial_dtor }; };
-template <typename K, typename V>
-struct trait_trivial_copy< key_value_pair_t<K, V> >
-{ enum { value = aggregate_traits<K,V>::has_trivial_copy }; };
-template <typename K, typename V>
-struct trait_trivial_move< key_value_pair_t<K, V> >
-{ enum { value = aggregate_traits<K,V>::has_trivial_move }; };
-
-// ---------------------------------------------------------------------------
-
-/*
- * Hash codes.
- */
-typedef uint32_t hash_t;
-
-template <typename TKey>
-hash_t hash_type(const TKey& key);
-
-/* Built-in hash code specializations */
-#define ANDROID_INT32_HASH(T) \
-        template <> inline hash_t hash_type(const T& value) { return hash_t(value); }
-#define ANDROID_INT64_HASH(T) \
-        template <> inline hash_t hash_type(const T& value) { \
-                return hash_t((value >> 32) ^ value); }
-#define ANDROID_REINTERPRET_HASH(T, R) \
-        template <> inline hash_t hash_type(const T& value) { \
-            R newValue; \
-            static_assert(sizeof(newValue) == sizeof(value), "size mismatch"); \
-            memcpy(&newValue, &value, sizeof(newValue)); \
-            return hash_type(newValue); \
-        }
-
-ANDROID_INT32_HASH(bool)
-ANDROID_INT32_HASH(int8_t)
-ANDROID_INT32_HASH(uint8_t)
-ANDROID_INT32_HASH(int16_t)
-ANDROID_INT32_HASH(uint16_t)
-ANDROID_INT32_HASH(int32_t)
-ANDROID_INT32_HASH(uint32_t)
-ANDROID_INT64_HASH(int64_t)
-ANDROID_INT64_HASH(uint64_t)
-ANDROID_REINTERPRET_HASH(float, uint32_t)
-ANDROID_REINTERPRET_HASH(double, uint64_t)
-
-template <typename T> inline hash_t hash_type(T* const & value) {
-    return hash_type(uintptr_t(value));
-}
-
-}  // namespace android
-
-// ---------------------------------------------------------------------------
-
-#endif // ANDROID_TYPE_HELPERS_H
diff --git a/libutils/include/utils/TypeHelpers.h b/libutils/include/utils/TypeHelpers.h
new file mode 120000
index 000000000000..848f6d7bd5c7
--- /dev/null
+++ b/libutils/include/utils/TypeHelpers.h
@@ -0,0 +1 @@
+../../binder/include/utils/TypeHelpers.h
\ No newline at end of file

From bdf0b1bb835fe355ebfa1dab3eabb46ef25c9d82 Mon Sep 17 00:00:00 2001
From: William Hester <williamhester@google.com>
Date: Tue, 24 Oct 2023 16:53:24 -0700
Subject: [PATCH 0496/1487] Create integration test for fastboot CLI

We rely on parsing the `fastboot devices` output in device labs, and a
format change previously broke us. This test will ensure that the output
is exactly what we expect.

Test: atest --host fastboot_integration_test

Change-Id: I7606e7b3e4a1edfe487ff14bb06cbd3c0a3aa777
---
 fastboot/Android.bp                    | 11 ++++++
 fastboot/fastboot_integration_test.xml | 19 +++++++++
 fastboot/test_fastboot.py              | 53 ++++++++++++++++++++++++++
 3 files changed, 83 insertions(+)
 create mode 100644 fastboot/fastboot_integration_test.xml
 create mode 100644 fastboot/test_fastboot.py

diff --git a/fastboot/Android.bp b/fastboot/Android.bp
index 56cac88d3828..f85d1dea4427 100644
--- a/fastboot/Android.bp
+++ b/fastboot/Android.bp
@@ -446,3 +446,14 @@ cc_library_headers {
     host_supported: true,
     export_include_dirs: ["."],
 }
+
+python_test_host {
+    name: "fastboot_integration_test",
+    main: "test_fastboot.py",
+    srcs: ["test_fastboot.py"],
+    data: [":fastboot"],
+    test_config: "fastboot_integration_test.xml",
+    test_options: {
+        unit_test: false,
+    },
+}
diff --git a/fastboot/fastboot_integration_test.xml b/fastboot/fastboot_integration_test.xml
new file mode 100644
index 000000000000..ad14caba1ef0
--- /dev/null
+++ b/fastboot/fastboot_integration_test.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2023 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.
+-->
+<configuration description="Config to run fastboot integration tests">
+    <option name="test-suite-tag" value="fastboot_unittests" />
+    <test class="com.android.tradefed.testtype.python.PythonBinaryHostTest" >
+        <option name="par-file-name" value="fastboot_integration_test" />
+        <option name="test-timeout" value="1m" />
+    </test>
+</configuration>
\ No newline at end of file
diff --git a/fastboot/test_fastboot.py b/fastboot/test_fastboot.py
new file mode 100644
index 000000000000..adcaec7694f9
--- /dev/null
+++ b/fastboot/test_fastboot.py
@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+#
+# Copyright (C) 2023 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.
+#
+"""Tests for the fastboot command line utility.
+"""
+
+import re
+import subprocess
+import unittest
+
+
+class DevicesTest(unittest.TestCase):
+    """Tests for `fastboot devices`."""
+
+
+    def test_devices(self):
+        """Ensure that the format of `fastboot devices` does not change.
+
+        `fastboot devices` should alternate between a line containing the
+        device's serial number and fastboot state and an empty line
+        """
+        output = subprocess.check_output(["fastboot", "devices"])
+
+        previous_line_was_empty = True
+        for line in output.decode().splitlines():
+            if previous_line_was_empty:
+                if not re.match(r"[a-zA-Z\d]+\s+(bootloader|fastbootd)", line):
+                    self.fail("%s does not match the expected format <serial no>\\s+(bootloader|fastbootd)" % line)
+                previous_line_was_empty = False
+            else:
+                if line:
+                    self.fail("Expected an empty line. Received '%s'" % line)
+                previous_line_was_empty = True
+
+        if len(output) == 0:
+            self.fail("Output is empty. Are any devices connected?")
+
+
+if __name__ == '__main__':
+    unittest.main()

From af5be1dcd661868f58abfdf3fe6869db13ad42d0 Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Mon, 23 Oct 2023 14:33:14 -0700
Subject: [PATCH 0497/1487] Run fsck to resolve possible data corruption

Trigger fsck on mount of /data if the value of ro.preventative_fsck is
not equal to the contents of /metadata/vold/preventative_fsck, then set
the file to the property to prevent future runs

See b/305658663 for context

Bug: 305658663
Test: Make sure fsck run after first boot and not after second
Ignore-AOSP-First: Critical UDC only bug
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:6c625e5d2e33bdaed7b9933b237502968c4b16e1)
Merged-In: I856c812d22363cc1d1e8aa88706d4d3b89044f52
Change-Id: I856c812d22363cc1d1e8aa88706d4d3b89044f52
---
 fs_mgr/fs_mgr.cpp | 25 ++++++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 742cdfab012a..8b9bce1dbb5d 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -699,6 +699,29 @@ static void SetReadAheadSize(const std::string& entry_block_device, off64_t size
     }
 }
 
+//
+// Mechanism to allow fsck to be triggered by setting ro.preventative_fsck
+// Introduced to address b/305658663
+// If the property value is not equal to the flag file contents, trigger
+// fsck and store the property value in the flag file
+// If we want to trigger again, simply change the property value
+//
+static bool check_if_preventative_fsck_needed(const FstabEntry& entry) {
+    const char* flag_file = "/metadata/vold/preventative_fsck";
+    if (entry.mount_point != "/data") return false;
+
+    // Don't error check - both default to empty string, which is OK
+    std::string prop = android::base::GetProperty("ro.preventative_fsck", "");
+    std::string flag;
+    android::base::ReadFileToString(flag_file, &flag);
+    if (prop == flag) return false;
+    // fsck is run immediately, so assume it runs or there is some deeper problem
+    if (!android::base::WriteStringToFile(prop, flag_file))
+        PERROR << "Failed to write file " << flag_file;
+    LINFO << "Run preventative fsck on /data";
+    return true;
+}
+
 //
 // Prepare the filesystem on the given block device to be mounted.
 //
@@ -749,7 +772,7 @@ static int prepare_fs_for_mount(const std::string& blk_device, const FstabEntry&
         }
     }
 
-    if (entry.fs_mgr_flags.check ||
+    if (check_if_preventative_fsck_needed(entry) || entry.fs_mgr_flags.check ||
         (fs_stat & (FS_STAT_UNCLEAN_SHUTDOWN | FS_STAT_QUOTA_ENABLED))) {
         check_fs(blk_device, entry.fs_type, mount_point, &fs_stat);
     }

From b6f459abbc594e3b5821bd500a3dca33fe6af84c Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Thu, 26 Oct 2023 15:55:08 -0700
Subject: [PATCH 0498/1487] Allow disabling callstack

Bug: 302723053
Test: mma
Change-Id: Idea326cc9914d4c81d75dad287e169c09a736486
---
 libutils/binder/RefBase.cpp | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/libutils/binder/RefBase.cpp b/libutils/binder/RefBase.cpp
index 4b0cc161bc45..2d2e40b7e3b5 100644
--- a/libutils/binder/RefBase.cpp
+++ b/libutils/binder/RefBase.cpp
@@ -55,14 +55,16 @@
 // log all reference counting operations
 #define PRINT_REFS 0
 
+#if !defined(ANDROID_UTILS_CALLSTACK_ENABLED)
 #if defined(__linux__)
 // CallStack is only supported on linux type platforms.
-#define CALLSTACK_ENABLED 1
+#define ANDROID_UTILS_CALLSTACK_ENABLED 1
 #else
-#define CALLSTACK_ENABLED 0
-#endif
+#define ANDROID_UTILS_CALLSTACK_ENABLED 0
+#endif  // defined(__linux__)
+#endif  // !defined(ANDROID_UTILS_CALLSTACK_ENABLED)
 
-#if CALLSTACK_ENABLED
+#if ANDROID_UTILS_CALLSTACK_ENABLED
 #include "../../include/utils/CallStack.h"
 #endif
 
@@ -230,7 +232,7 @@ class RefBase::weakref_impl : public RefBase::weakref_type
             while (refs) {
                 char inc = refs->ref >= 0 ? '+' : '-';
                 ALOGD("\t%c ID %p (ref %d):", inc, refs->id, refs->ref);
-#if DEBUG_REFS_CALLSTACK_ENABLED && CALLSTACK_ENABLED
+#if DEBUG_REFS_CALLSTACK_ENABLED && ANDROID_UTILS_CALLSTACK_ENABLED
                 CallStack::logStack(LOG_TAG, refs->stack.get());
 #endif
                 refs = refs->next;
@@ -244,7 +246,7 @@ class RefBase::weakref_impl : public RefBase::weakref_type
             while (refs) {
                 char inc = refs->ref >= 0 ? '+' : '-';
                 ALOGD("\t%c ID %p (ref %d):", inc, refs->id, refs->ref);
-#if DEBUG_REFS_CALLSTACK_ENABLED && CALLSTACK_ENABLED
+#if DEBUG_REFS_CALLSTACK_ENABLED && ANDROID_UTILS_CALLSTACK_ENABLED
                 CallStack::logStack(LOG_TAG, refs->stack.get());
 #endif
                 refs = refs->next;
@@ -252,7 +254,7 @@ class RefBase::weakref_impl : public RefBase::weakref_type
         }
         if (dumpStack) {
             ALOGE("above errors at:");
-#if CALLSTACK_ENABLED
+#if ANDROID_UTILS_CALLSTACK_ENABLED
             CallStack::logStack(LOG_TAG);
 #endif
         }
@@ -341,7 +343,7 @@ class RefBase::weakref_impl : public RefBase::weakref_type
     {
         ref_entry* next;
         const void* id;
-#if DEBUG_REFS_CALLSTACK_ENABLED && CALLSTACK_ENABLED
+#if DEBUG_REFS_CALLSTACK_ENABLED && ANDROID_UTILS_CALLSTACK_ENABLED
         CallStack::CallStackUPtr stack;
 #endif
         int32_t ref;
@@ -358,7 +360,7 @@ class RefBase::weakref_impl : public RefBase::weakref_type
             // decrement the reference count.
             ref->ref = mRef;
             ref->id = id;
-#if DEBUG_REFS_CALLSTACK_ENABLED && CALLSTACK_ENABLED
+#if DEBUG_REFS_CALLSTACK_ENABLED && ANDROID_UTILS_CALLSTACK_ENABLED
             ref->stack = CallStack::getCurrent(2);
 #endif
             ref->next = *refs;
@@ -394,7 +396,7 @@ class RefBase::weakref_impl : public RefBase::weakref_type
                 ref = ref->next;
             }
 
-#if CALLSTACK_ENABLED
+#if ANDROID_UTILS_CALLSTACK_ENABLED
             CallStack::logStack(LOG_TAG);
 #endif
         }
@@ -422,7 +424,7 @@ class RefBase::weakref_impl : public RefBase::weakref_type
             snprintf(buf, sizeof(buf), "\t%c ID %p (ref %d):\n",
                      inc, refs->id, refs->ref);
             out->append(buf);
-#if DEBUG_REFS_CALLSTACK_ENABLED && CALLSTACK_ENABLED
+#if DEBUG_REFS_CALLSTACK_ENABLED && ANDROID_UTILS_CALLSTACK_ENABLED
             out->append(CallStack::stackToString("\t\t", refs->stack.get()));
 #else
             out->append("\t\t(call stacks disabled)");
@@ -788,7 +790,7 @@ RefBase::~RefBase()
                   "object.",
                   mRefs->mWeak.load(), this);
 
-#if CALLSTACK_ENABLED
+#if ANDROID_UTILS_CALLSTACK_ENABLED
             CallStack::logStack(LOG_TAG);
 #endif
         } else if (strongs != 0) {

From 260e48f07e4ab5272d347e7ad06d042aa18735fc Mon Sep 17 00:00:00 2001
From: Kiyoung Kim <kiyoungkim@google.com>
Date: Thu, 26 Oct 2023 22:54:31 +0900
Subject: [PATCH 0499/1487] Deprecate Vendor Overlay when VNDK is deprecated

Vendor overlay was introduced to enable system-only update with small
changes on the vendor, but this is no longer required with same reason
of VNDK deprecation - more frequent Vendor update than expected, and
makes system-vendor interface unstable. This change adds more comments
to explain that Vendor overlay will be deprecated along with VNDK, and
skip test if VNDK is deprecated.

Bug: 307925435
Bug: 307902290
Test: fs_mgr_vendor_overlay_test passed with CF trunk-staging device
Change-Id: I7b9359a5754e8740e749c48f6265a1b0f92f13af
---
 fs_mgr/fs_mgr_vendor_overlay.cpp                       |  1 +
 .../tests/vendoroverlay/VendorOverlayHostTest.java     | 10 ++++++----
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/fs_mgr_vendor_overlay.cpp b/fs_mgr/fs_mgr_vendor_overlay.cpp
index bacfa4b59bfe..6b742e55e1b0 100644
--- a/fs_mgr/fs_mgr_vendor_overlay.cpp
+++ b/fs_mgr/fs_mgr_vendor_overlay.cpp
@@ -112,6 +112,7 @@ bool fs_mgr_vendor_overlay_mount_all() {
     // properties are loaded.
     static const auto vndk_version = android::base::GetProperty(kVndkVersionPropertyName, "");
     if (vndk_version.empty()) {
+        // Vendor overlay is disabled from VNDK deprecated devices.
         LINFO << "vendor overlay: vndk version not defined";
         return false;
     }
diff --git a/fs_mgr/tests/src/com/android/tests/vendoroverlay/VendorOverlayHostTest.java b/fs_mgr/tests/src/com/android/tests/vendoroverlay/VendorOverlayHostTest.java
index f08cab239773..91f235c861e3 100644
--- a/fs_mgr/tests/src/com/android/tests/vendoroverlay/VendorOverlayHostTest.java
+++ b/fs_mgr/tests/src/com/android/tests/vendoroverlay/VendorOverlayHostTest.java
@@ -21,10 +21,8 @@
 import com.android.tradefed.testtype.junit4.BaseHostJUnit4Test;
 import com.android.tradefed.util.CommandResult;
 import com.android.tradefed.util.CommandStatus;
-
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Assume;
@@ -38,9 +36,15 @@
 @RunWith(DeviceJUnit4ClassRunner.class)
 public class VendorOverlayHostTest extends BaseHostJUnit4Test {
   boolean wasRoot = false;
+  String vndkVersion = null;
 
   @Before
   public void setup() throws DeviceNotAvailableException {
+    vndkVersion = getDevice().executeShellV2Command("getprop ro.vndk.version").getStdout();
+    Assume.assumeTrue(
+        "Vendor Overlay is disabled for VNDK deprecated devices",
+        vndkVersion != null && !vndkVersion.trim().isEmpty());
+
     wasRoot = getDevice().isAdbRoot();
     if (!wasRoot) {
       Assume.assumeTrue("Test requires root", getDevice().enableAdbRoot());
@@ -74,8 +78,6 @@ private void assumeMkdirSuccess(String dir) throws DeviceNotAvailableException {
    */
   @Test
   public void testVendorOverlay() throws DeviceNotAvailableException {
-    String vndkVersion = getDevice().executeShellV2Command("getprop ro.vndk.version").getStdout();
-
     // Create files and modify policy
     CommandResult result = getDevice().executeShellV2Command(
         "echo '/(product|system/product)/vendor_overlay/" + vndkVersion +

From 686bff6e5ca6c5f180959732d5d302e1a2ef115e Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Tue, 24 Oct 2023 17:53:49 +0800
Subject: [PATCH 0500/1487] fs_mgr_overlayfs: Fix submount propagation type
 after remount

When juggling submounts, the temp dir holding the references to
submounts should be MS_PRIVATE. Otherwise the submount propagation type
would be changed according to section 5d,
https://www.kernel.org/doc/Documentation/filesystems/sharedsubtree.txt

For example, a root mount tree of
  <mountpoint> <shared/private>
  /dev         shared
  /product     shared
  /product/app private

When executing "remount /product", "/product/app" would be moved to a
temp dir under "/dev", which is MS_SHARED. This would also change the
state of the mount to MS_SHARED.
  /dev         shared
  /product     shared
  /dev/temp    shared  (moved from /product/app)

Thus after "/product" overlay is mounted, and "/dev/temp" is moved back,
"/product/app" would be unintentionally changed to MS_SHARED.
  /dev         shared
  /product     private
  /product     shared  (overlayfs override)
  /product/app shared  (moved from /dev/temp)


This change fixes this issue by setting up a standalone mount tree under
/dev to hold the temporary moved submounts.
This way we don't need to modify the state of "/dev" whatsoever, and can
guarantee the propagation type of mounts moved in and out of the temp
dir are not changed.

Bug: 306124139
Test: adb-remount-test
Test: remount a parent mount and then verify the mount flag of submount
Change-Id: I8174257cff6b93dd95303c6ab49b42f90b02df0c
---
 fs_mgr/fs_mgr_overlayfs_mount.cpp | 75 +++++++++++++++++++------------
 1 file changed, 47 insertions(+), 28 deletions(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index ae7ed4ccf056..4cadeece8c4c 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -34,6 +34,7 @@
 #include <android-base/file.h>
 #include <android-base/macros.h>
 #include <android-base/properties.h>
+#include <android-base/scopeguard.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 #include <ext4_utils/ext4_utils.h>
@@ -58,6 +59,9 @@ constexpr char kPreferCacheBackingStorageProp[] = "fs_mgr.overlayfs.prefer_cache
 constexpr char kCacheMountPoint[] = "/cache";
 constexpr char kPhysicalDevice[] = "/dev/block/by-name/";
 
+// Mount tree to temporarily hold references to submounts.
+constexpr char kMoveMountTempDir[] = "/dev/remount";
+
 constexpr char kLowerdirOption[] = "lowerdir=";
 constexpr char kUpperdirOption[] = "upperdir=";
 constexpr char kWorkdirOption[] = "workdir=";
@@ -374,24 +378,21 @@ static std::vector<mount_info> ReadMountinfoFromFile(const std::string& path) {
     return info;
 }
 
-static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
-    const auto mount_point = fs_mgr_mount_point(entry.mount_point);
-    const auto options = fs_mgr_get_overlayfs_options(entry);
+static bool fs_mgr_overlayfs_mount_one(const FstabEntry& fstab_entry) {
+    const auto mount_point = fs_mgr_mount_point(fstab_entry.mount_point);
+    const auto options = fs_mgr_get_overlayfs_options(fstab_entry);
     if (options.empty()) return false;
 
-    auto retval = true;
-
     struct MoveEntry {
         std::string mount_point;
         std::string dir;
         bool shared_flag;
     };
-
     std::vector<MoveEntry> moved_mounts;
-    auto parent_private = false;
-    auto parent_made_private = false;
-    auto dev_private = false;
-    auto dev_made_private = false;
+
+    bool retval = true;
+    bool move_dir_shared = true;
+    bool parent_shared = true;
 
     // There could be multiple mount entries with the same mountpoint.
     // Group these entries together with stable_sort, and keep only the last entry of a group.
@@ -411,19 +412,24 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
     // mountinfo is reversed twice, so still is in lexical sorted order.
 
     for (const auto& entry : mountinfo) {
-        if ((entry.mount_point == mount_point) && !entry.shared_flag) {
-            parent_private = true;
+        if (entry.mount_point == kMoveMountTempDir) {
+            move_dir_shared = entry.shared_flag;
         }
-        if ((entry.mount_point == "/dev") && !entry.shared_flag) {
-            dev_private = true;
+        if (entry.mount_point == mount_point ||
+            (mount_point == "/system" && entry.mount_point == "/")) {
+            parent_shared = entry.shared_flag;
         }
     }
 
+    // Precondition is that kMoveMountTempDir is MS_PRIVATE, otherwise don't try to move any
+    // submount in to or out of it.
+    if (move_dir_shared) {
+        mountinfo.clear();
+    }
+
     // Need to make the original mountpoint MS_PRIVATE, so that the overlayfs can be MS_MOVE.
     // This could happen if its parent mount is remounted later.
-    if (!parent_private) {
-        parent_made_private = fs_mgr_overlayfs_set_shared_mount(mount_point, false);
-    }
+    fs_mgr_overlayfs_set_shared_mount(mount_point, false);
 
     for (const auto& entry : mountinfo) {
         // Find all immediate submounts.
@@ -440,8 +446,8 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
         // mountinfo is in lexical order, so no need to worry about |entry| being a parent mount of
         // entries of |moved_mounts|.
 
-        // use as the bound directory in /dev.
-        MoveEntry new_entry{entry.mount_point, "/dev/TemporaryDir-XXXXXX", entry.shared_flag};
+        MoveEntry new_entry{entry.mount_point, kMoveMountTempDir + "/TemporaryDir-XXXXXX"s,
+                            entry.shared_flag};
         {
             AutoSetFsCreateCon createcon;
             auto new_context = fs_mgr_get_context(entry.mount_point);
@@ -497,10 +503,6 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
 
     // Move submounts back.
     for (const auto& entry : moved_mounts) {
-        if (!dev_private && !dev_made_private) {
-            dev_made_private = fs_mgr_overlayfs_set_shared_mount("/dev", false);
-        }
-
         if (!fs_mgr_overlayfs_move_mount(entry.dir, entry.mount_point)) {
             retval = false;
         } else if (entry.shared_flag &&
@@ -509,10 +511,8 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) {
         }
         rmdir(entry.dir.c_str());
     }
-    if (dev_made_private) {
-        fs_mgr_overlayfs_set_shared_mount("/dev", true);
-    }
-    if (parent_made_private) {
+    // If the original (overridden) mount was MS_SHARED, then set the overlayfs mount to MS_SHARED.
+    if (parent_shared) {
         fs_mgr_overlayfs_set_shared_mount(mount_point, true);
     }
 
@@ -730,6 +730,25 @@ bool fs_mgr_overlayfs_mount_all(Fstab* fstab) {
     if (!OverlayfsSetupAllowed()) {
         return false;
     }
+
+    // Ensure kMoveMountTempDir is standalone mount tree with 'private' propagation by bind mounting
+    // to itself and set to MS_PRIVATE.
+    // Otherwise mounts moved in to it would have their propagation type changed unintentionally.
+    // Section 5d, https://www.kernel.org/doc/Documentation/filesystems/sharedsubtree.txt
+    if (!fs_mgr_overlayfs_already_mounted(kMoveMountTempDir, false)) {
+        if (mkdir(kMoveMountTempDir, 0755) && errno != EEXIST) {
+            PERROR << "mkdir " << kMoveMountTempDir;
+        }
+        if (mount(kMoveMountTempDir, kMoveMountTempDir, nullptr, MS_BIND, nullptr)) {
+            PERROR << "bind mount " << kMoveMountTempDir;
+        }
+    }
+    fs_mgr_overlayfs_set_shared_mount(kMoveMountTempDir, false);
+    android::base::ScopeGuard umountDir([]() {
+        umount(kMoveMountTempDir);
+        rmdir(kMoveMountTempDir);
+    });
+
     auto ret = true;
     auto scratch_can_be_mounted = !fs_mgr_overlayfs_already_mounted(kScratchMountPoint, false);
     for (const auto& entry : fs_mgr_overlayfs_candidate_list(*fstab)) {
@@ -742,7 +761,7 @@ bool fs_mgr_overlayfs_mount_all(Fstab* fstab) {
             scratch_can_be_mounted = false;
             TryMountScratch();
         }
-        ret &= fs_mgr_overlayfs_mount(entry);
+        ret &= fs_mgr_overlayfs_mount_one(entry);
     }
     return ret;
 }

From db620ef5313555f9896c08aa3120b7348a1af8ed Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Thu, 26 Oct 2023 15:24:19 +0800
Subject: [PATCH 0501/1487] fs_mgr_overlayfs: Fix "/" mount propagation type
 after remount

If remounting "/system" caused "/" to be set to MS_PRIVATE, restore it
to MS_SHARED after remount.

Bug: 306124139
Test: adb-remount-test
Test: remount /system and verify /proc/self/mountinfo
Change-Id: I12bc2ccdaf7d2b2de330064b61a8533b96defe00
---
 fs_mgr/fs_mgr_overlayfs_mount.cpp | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index 4cadeece8c4c..cdbac00c654e 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -288,10 +288,6 @@ static bool fs_mgr_overlayfs_set_shared_mount(const std::string& mount_point, bo
     if (ret) {
         PERROR << "__mount(target=" << mount_point
                << ",flag=" << (shared_flag ? "MS_SHARED" : "MS_PRIVATE") << ")=" << ret;
-        // If "/system" doesn't look like a mountpoint, retry with "/".
-        if (errno == EINVAL && mount_point == "/system") {
-            return fs_mgr_overlayfs_set_shared_mount("/", shared_flag);
-        }
         return false;
     }
     return true;
@@ -393,6 +389,8 @@ static bool fs_mgr_overlayfs_mount_one(const FstabEntry& fstab_entry) {
     bool retval = true;
     bool move_dir_shared = true;
     bool parent_shared = true;
+    bool root_shared = true;
+    bool root_made_private = false;
 
     // There could be multiple mount entries with the same mountpoint.
     // Group these entries together with stable_sort, and keep only the last entry of a group.
@@ -419,6 +417,9 @@ static bool fs_mgr_overlayfs_mount_one(const FstabEntry& fstab_entry) {
             (mount_point == "/system" && entry.mount_point == "/")) {
             parent_shared = entry.shared_flag;
         }
+        if (entry.mount_point == "/") {
+            root_shared = entry.shared_flag;
+        }
     }
 
     // Precondition is that kMoveMountTempDir is MS_PRIVATE, otherwise don't try to move any
@@ -429,7 +430,13 @@ static bool fs_mgr_overlayfs_mount_one(const FstabEntry& fstab_entry) {
 
     // Need to make the original mountpoint MS_PRIVATE, so that the overlayfs can be MS_MOVE.
     // This could happen if its parent mount is remounted later.
-    fs_mgr_overlayfs_set_shared_mount(mount_point, false);
+    if (!fs_mgr_overlayfs_set_shared_mount(mount_point, false)) {
+        // If failed to set "/system" mount type, it might be due to "/system" not being a valid
+        // mountpoint after switch root. Retry with "/" in this case.
+        if (errno == EINVAL && mount_point == "/system") {
+            root_made_private = fs_mgr_overlayfs_set_shared_mount("/", false);
+        }
+    }
 
     for (const auto& entry : mountinfo) {
         // Find all immediate submounts.
@@ -515,6 +522,9 @@ static bool fs_mgr_overlayfs_mount_one(const FstabEntry& fstab_entry) {
     if (parent_shared) {
         fs_mgr_overlayfs_set_shared_mount(mount_point, true);
     }
+    if (root_shared && root_made_private) {
+        fs_mgr_overlayfs_set_shared_mount("/", true);
+    }
 
     return retval;
 }

From 8fb49bc0a234453a33a2b0de49791a3136803257 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 30 Oct 2023 09:39:38 -0700
Subject: [PATCH 0502/1487] libsnapshot: Wait for COW path

After mapping COW device, wait for the device to appear
before initializing it.

Bug: 305829996
Test: OTA on Pixel
Change-Id: If9e0e1ce684aa15bc9f3fd5a01e4f0421de87e81
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshot.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index eb4beb780fba..c639e43d3555 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -3513,6 +3513,11 @@ Return SnapshotManager::InitializeUpdateSnapshots(
             return Return::Error();
         }
 
+        if (!android::fs_mgr::WaitForFile(cow_path, 6s)) {
+            LOG(ERROR) << "Timed out waiting for device to appear: " << cow_path;
+            return Return::Error();
+        }
+
         if (it->second.using_snapuserd()) {
             unique_fd fd(open(cow_path.c_str(), O_RDWR | O_CLOEXEC));
             if (fd < 0) {

From d71f9e5fbbbc1b4a0f910c2c7606915bfeae68a4 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Fri, 20 Oct 2023 13:26:42 -0700
Subject: [PATCH 0503/1487] Reapply "Migrate the blkio controller to the v2
 cgroup hierarchy"

This reverts commit c7a6fe684c7cea3fb9fba6dbb5cceeb698bfd318.
Repply the blkio controller migration because it was not responsible
for the test failures that led to the revert. See also the following bugs:
* https://b.corp.google.com/issues/260143932
  (v2/android-virtual-infra/test_mapping/presubmit-avd test failure)
* https://b.corp.google.com/issues/264620181
  (CtsInitTestCases.RebootTest#StopServicesSIGKILL failure)

The only change compared with the previous version is that the io
controller has been declared optional. This is necessary because some
devices have a kernel that does not support the io controller.

Bug: 213617178
Test: Cuttlefish and various phones
Change-Id: I490740e1c9ee4f7bb5bb7afba721a083f952c8f2
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 libprocessgroup/profiles/cgroups.json       | 13 ++++++-------
 libprocessgroup/profiles/task_profiles.json | 12 ++++--------
 rootdir/init.rc                             | 20 --------------------
 3 files changed, 10 insertions(+), 35 deletions(-)

diff --git a/libprocessgroup/profiles/cgroups.json b/libprocessgroup/profiles/cgroups.json
index 3e4393df2078..d013ec858c1b 100644
--- a/libprocessgroup/profiles/cgroups.json
+++ b/libprocessgroup/profiles/cgroups.json
@@ -1,12 +1,5 @@
 {
   "Cgroups": [
-    {
-      "Controller": "blkio",
-      "Path": "/dev/blkio",
-      "Mode": "0775",
-      "UID": "system",
-      "GID": "system"
-    },
     {
       "Controller": "cpu",
       "Path": "/dev/cpuctl",
@@ -39,6 +32,12 @@
       {
         "Controller": "freezer",
         "Path": "."
+      },
+      {
+        "Controller": "io",
+        "Path": ".",
+        "NeedsActivation": true,
+        "Optional": true
       }
     ]
   }
diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 1fc66ba10a64..6314667ef957 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -442,8 +442,7 @@
           "Name": "JoinCgroup",
           "Params":
           {
-            "Controller": "blkio",
-            "Path": "background"
+            "Controller": "io"
           }
         }
       ]
@@ -455,8 +454,7 @@
           "Name": "JoinCgroup",
           "Params":
           {
-            "Controller": "blkio",
-            "Path": ""
+            "Controller": "io"
           }
         }
       ]
@@ -468,8 +466,7 @@
           "Name": "JoinCgroup",
           "Params":
           {
-            "Controller": "blkio",
-            "Path": ""
+            "Controller": "io"
           }
         }
       ]
@@ -481,8 +478,7 @@
           "Name": "JoinCgroup",
           "Params":
           {
-            "Controller": "blkio",
-            "Path": ""
+            "Controller": "io"
           }
         }
       ]
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 317f80908350..fb6473666d7c 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -219,26 +219,6 @@ on init
     write /dev/stune/nnapi-hal/schedtune.boost 1
     write /dev/stune/nnapi-hal/schedtune.prefer_idle 1
 
-    # Create blkio group and apply initial settings.
-    # This feature needs kernel to support it, and the
-    # device's init.rc must actually set the correct values.
-    mkdir /dev/blkio/background
-    chown system system /dev/blkio
-    chown system system /dev/blkio/background
-    chown system system /dev/blkio/tasks
-    chown system system /dev/blkio/background/tasks
-    chown system system /dev/blkio/cgroup.procs
-    chown system system /dev/blkio/background/cgroup.procs
-    chmod 0664 /dev/blkio/tasks
-    chmod 0664 /dev/blkio/background/tasks
-    chmod 0664 /dev/blkio/cgroup.procs
-    chmod 0664 /dev/blkio/background/cgroup.procs
-    write /dev/blkio/blkio.weight 1000
-    write /dev/blkio/background/blkio.weight 200
-    write /dev/blkio/background/blkio.bfq.weight 10
-    write /dev/blkio/blkio.group_idle 0
-    write /dev/blkio/background/blkio.group_idle 0
-
     restorecon_recursive /mnt
 
     mount configfs none /config nodev noexec nosuid

From 5249953d0b2177eeeb4988433527de30cbcac0f4 Mon Sep 17 00:00:00 2001
From: Harsh Abichandani <harsh.abichandani@ittiam.com>
Date: Tue, 31 Oct 2023 12:01:53 +0530
Subject: [PATCH 0504/1487] Updated liblp fuzzers.

Added a check to avoid possible NPD when duplicate partitions are created and changed slot value range which is being fetched using FuzzedDataProvider.

exec/s: 16440
Test: ./liblp_builder_fuzzer
exec/s: 26412
Test: ./liblp_super_layout_builder_fuzzer
exec/s: 9178
Test: ./liblp_apis_fuzzer
Bug: 307978015

Change-Id: I63abc828cc3f4c44c1dd89a01acfb33dc08813b8
---
 fs_mgr/liblp/fuzzer/README.md                 | 38 ++++++++----------
 fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp     | 19 +++++----
 fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp  | 39 +++++++++----------
 .../liblp_super_layout_builder_fuzzer.cpp     | 17 ++++----
 4 files changed, 51 insertions(+), 62 deletions(-)

diff --git a/fs_mgr/liblp/fuzzer/README.md b/fs_mgr/liblp/fuzzer/README.md
index f831e2e5db8e..015c59b5fd17 100644
--- a/fs_mgr/liblp/fuzzer/README.md
+++ b/fs_mgr/liblp/fuzzer/README.md
@@ -18,15 +18,14 @@ LiblpBuilder supports the following parameters:
 9. alignmentOffset (parameter name: "alignment_offset")
 10. logicalBlockSize (parameter name: "logical_block_size")
 11. maxMetadataSize (parameter name: "max_metadata_size")
-12. numSlots (parameter name: "metadata_slot_count")
-13. deviceIndex (parameter name: "device_index")
-14. start (parameter name: "start")
-15. end (parameter name: "end")
-16. addedGroupName (parameter name: "group_name")
-17. partitionGroupName (parameter name: "partition_name")
-18. numSectors (parameter name: "num_sectors")
-19. physicalSector (parameter name: "physical_sector")
-20. resizedPartitionSize (parameter name: "requested_size")
+12. deviceIndex (parameter name: "device_index")
+13. start (parameter name: "start")
+14. end (parameter name: "end")
+15. addedGroupName (parameter name: "group_name")
+16. partitionGroupName (parameter name: "partition_name")
+17. numSectors (parameter name: "num_sectors")
+18. physicalSector (parameter name: "physical_sector")
+19. resizedPartitionSize (parameter name: "requested_size")
 
 | Parameter| Valid Values| Configured Value|
 |------------- |-------------| ----- |
@@ -41,7 +40,6 @@ LiblpBuilder supports the following parameters:
 |`alignmentOffset`| Integer |Value obtained from FuzzedDataProvider|
 |`logicalBlockSize`| Integer |Value obtained from FuzzedDataProvider|
 |`maxMetadataSize`| Integer value from `0` to `10000` |Value obtained from FuzzedDataProvider|
-|`numSlots`| Integer value from `0` to `2` |Value obtained from FuzzedDataProvider|
 |`deviceIndex`| Integer |Value obtained from FuzzedDataProvider|
 |`start`| Integer |Value obtained from FuzzedDataProvider|
 |`end`| Integer |Value obtained from FuzzedDataProvider|
@@ -67,17 +65,15 @@ SuperLayoutBuilder supports the following parameters:
 1. kAttributeTypes (parameter name: "attribute")
 2. blockDevSize (parameter name: "blockdev_size")
 3. metadataMaxSize (parameter name: "metadata_max_size")
-4. metadataSlotCount (parameter name: "metadata_slot_count")
-5. partitionName (parameter name: "partition_name")
-6. data (parameter name: "data")
-7. imageName (parameter name: "image_name")
+4. partitionName (parameter name: "partition_name")
+5. data (parameter name: "data")
+6. imageName (parameter name: "image_name")
 
 | Parameter| Valid Values| Configured Value|
 |------------- |-------------| ----- |
 |`kAttributeTypes`| 1.`LP_PARTITION_ATTR_NONE`,<br/> 2.`LP_PARTITION_ATTR_READONLY`,<br/> 3.`LP_PARTITION_ATTR_SLOT_SUFFIXED`,<br/> 4.`LP_PARTITION_ATTR_UPDATED`,<br/> 5.`LP_PARTITION_ATTR_DISABLED`|Value obtained from FuzzedDataProvider|
 |`blockDevSize`| Integer value from `0` to `100000`|Value obtained from FuzzedDataProvider|
 |`metadataMaxSize`| Integer value from `0` to `10000` |Value obtained from FuzzedDataProvider|
-|`metadataSlotCount`| Integer value from `0` to `2` |Value obtained from FuzzedDataProvider|
 |`partitionName`| String |Value obtained from FuzzedDataProvider|
 |`data`| String |Value obtained from FuzzedDataProvider|
 |`imageName`| String |Value obtained from FuzzedDataProvider|
@@ -102,12 +98,11 @@ LiblpAPIs supports the following parameters:
 4. logicalBlockSize (parameter name: "logical_block_size")
 5. blockDevSize (parameter name: "blockdev_size")
 6. metadataMaxSize (parameter name: "metadata_max_size")
-7. metadataSlotCount (parameter name: "metadata_slot_count")
-8. blockDeviceInfoName (parameter name: "block_device_info_name")
-9. numSectors (parameter name: "num_sectors")
-10. physicalSector (parameter name: "physical_sector")
-11. sparsify (parameter name: "sparsify")
-12. buffer (parameter name: "data")
+7. blockDeviceInfoName (parameter name: "block_device_info_name")
+8. numSectors (parameter name: "num_sectors")
+9. physicalSector (parameter name: "physical_sector")
+10. sparsify (parameter name: "sparsify")
+11. buffer (parameter name: "data")
 
 | Parameter| Valid Values| Configured Value|
 |------------- |-------------| ----- |
@@ -117,7 +112,6 @@ LiblpAPIs supports the following parameters:
 |`logicalBlockSize`| Integer |Value obtained from FuzzedDataProvider|
 |`blockDevSize`| Integer value in multiples of `LP_SECTOR_SIZE`|Value obtained from FuzzedDataProvider|
 |`metadataMaxSize`| Integer value from `0` to `10000` |Value obtained from FuzzedDataProvider|
-|`metadataSlotCount`| Integer value from `0` to `2` |Value obtained from FuzzedDataProvider|
 |`blockDeviceInfoName`| String |Value obtained from FuzzedDataProvider|
 |`numSectors`| Integer value from `1` to `1000000` |Value obtained from FuzzedDataProvider|
 |`physicalSector`| Integer value from `1` to `1000000` |Value obtained from FuzzedDataProvider|
diff --git a/fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp b/fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp
index a15bc8905575..cb192ea52e1c 100644
--- a/fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp
+++ b/fs_mgr/liblp/fuzzer/liblp_apis_fuzzer.cpp
@@ -39,8 +39,6 @@ static constexpr uint32_t kValidAlignmentOffset = 0;
 static constexpr uint32_t kValidLogicalBlockSize = 4096;
 static constexpr uint32_t kMinMetadataSize = 0;
 static constexpr uint32_t kMaxMetadataSize = 10000;
-static constexpr uint32_t kMinSlot = 0;
-static constexpr uint32_t kMaxSlot = 10;
 static constexpr uint32_t kMinFactor = 0;
 static constexpr uint32_t kMaxFactor = 10;
 static constexpr uint32_t kMetadataGeometrySize = 4096;
@@ -108,7 +106,7 @@ void LiplpApisFuzzer::setupBuilder() {
     uint32_t randomMetadataMaxSize =
             mFdp.ConsumeIntegralInRange<uint32_t>(kMinMetadataSize, kMaxMetadataSize);
     uint32_t metadataMaxSize = mFdp.ConsumeBool() ? kMetadataSize : randomMetadataMaxSize;
-    uint32_t metadataSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(kMinSlot, kMaxSlot);
+    uint32_t metadataSlotCount = mFdp.ConsumeBool() ? 0 : 1;
     mBuilder = MetadataBuilder::New(blockDevSize, metadataMaxSize, metadataSlotCount);
 
     if (mBuilder.get()) {
@@ -128,14 +126,15 @@ void LiplpApisFuzzer::setupBuilder() {
         Partition* super = mBuilder->AddPartition(mSuperPartitionName, LP_PARTITION_ATTR_READONLY);
         mBuilder->AddPartition(mPartitionName, LP_PARTITION_ATTR_READONLY);
 
-        int64_t numSectors = mFdp.ConsumeBool() ? mFdp.ConsumeIntegralInRange<uint64_t>(
-                                                          kMinSectorValue, kMaxSectorValue)
-                                                : kValidNumSectors;
-        int64_t physicalSector = mFdp.ConsumeBool() ? mFdp.ConsumeIntegralInRange<uint64_t>(
+        if (super) {
+            int64_t numSectors = mFdp.ConsumeBool() ? mFdp.ConsumeIntegralInRange<uint64_t>(
                                                               kMinSectorValue, kMaxSectorValue)
-                                                    : kValidPhysicalSector;
-
-        mBuilder->AddLinearExtent(super, mBlockDeviceInfoName, numSectors, physicalSector);
+                                                    : kValidNumSectors;
+            int64_t physicalSector = mFdp.ConsumeBool() ? mFdp.ConsumeIntegralInRange<uint64_t>(
+                                                                  kMinSectorValue, kMaxSectorValue)
+                                                        : kValidPhysicalSector;
+            mBuilder->AddLinearExtent(super, mBlockDeviceInfoName, numSectors, physicalSector);
+        }
     }
 }
 
diff --git a/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp b/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
index e5fbe272aef7..7f09ac828f79 100644
--- a/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
+++ b/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
@@ -48,8 +48,6 @@ static constexpr uint32_t kMaxMetadataValue = 10000;
 static constexpr uint32_t kZeroAlignment = 0;
 static constexpr uint32_t kZeroAlignmentOffset = 0;
 static constexpr uint32_t kMaxBytes = 20;
-static constexpr uint32_t kMinSlot = 0;
-static constexpr uint32_t kMaxSlot = 10;
 static constexpr uint32_t kMinBuilder = 0;
 static constexpr uint32_t kMaxBuilder = 4;
 
@@ -108,9 +106,7 @@ void BuilderFuzzer::selectRandomBuilder(int32_t randomBuilder, string superBlock
     switch (randomBuilder) {
         case 0: {
             uint32_t maxMetadataSize = getParamValue(kValidMaxMetadataSize);
-            uint32_t numSlots = mFdp.ConsumeBool()
-                                        ? kMaxSlot
-                                        : mFdp.ConsumeIntegralInRange<uint32_t>(kMinSlot, kMaxSlot);
+            uint32_t numSlots = mFdp.ConsumeBool() ? 0 : 1;
             mBuilder = MetadataBuilder::New(mBlockDevices, superBlockDeviceName, maxMetadataSize,
                                             numSlots);
             break;
@@ -120,14 +116,14 @@ void BuilderFuzzer::selectRandomBuilder(int32_t randomBuilder, string superBlock
                     mFdp.ConsumeIntegralInRange<uint64_t>(kMinBlockDevValue, kMaxBlockDevValue);
             uint32_t metadataMaxSize =
                     mFdp.ConsumeIntegralInRange<uint32_t>(kMinMetadataValue, kMaxMetadataValue);
-            uint32_t metadataSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(kMinSlot, kMaxSlot);
+            uint32_t metadataSlotCount = mFdp.ConsumeBool() ? 0 : 1;
             mBuilder = MetadataBuilder::New(blockDevSize, metadataMaxSize, metadataSlotCount);
             break;
         }
         case 2: {
             uint64_t blockDevSize = getParamValue(kValidBlockSize);
             uint32_t metadataSize = getParamValue(kValidMetadataSize);
-            uint32_t metadataSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(kMinSlot, kMaxSlot);
+            uint32_t metadataSlotCount = mFdp.ConsumeBool() ? 0 : 1;
             mBuilder = MetadataBuilder::New(blockDevSize, metadataSize, metadataSlotCount);
             break;
         }
@@ -213,13 +209,13 @@ void BuilderFuzzer::callChangePartitionGroup() {
 void BuilderFuzzer::callVerifyExtentsAgainstSourceMetadata() {
     uint64_t sourceBlockDevSize = getParamValue(kValidBlockSize);
     uint32_t sourceMetadataMaxSize = getParamValue(kValidMetadataSize);
-    uint32_t sourceSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(0, 2);
+    uint32_t sourceSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(0, 1);
     auto sourceBuilder =
             MetadataBuilder::New(sourceBlockDevSize, sourceMetadataMaxSize, sourceSlotCount);
 
     uint64_t targetBlockDevSize = getParamValue(kValidBlockSize);
     uint32_t targetMetadataMaxSize = getParamValue(kValidMetadataSize);
-    uint32_t targetSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(0, 2);
+    uint32_t targetSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(0, 1);
     auto targetBuilder =
             MetadataBuilder::New(targetBlockDevSize, targetMetadataMaxSize, targetSlotCount);
 
@@ -292,17 +288,20 @@ void BuilderFuzzer::invokeBuilderAPIs() {
 
                         int64_t numExtents =
                                 mFdp.ConsumeIntegralInRange<int64_t>(kMinElements, kMaxElements);
-                        bool extentAdded = false;
-                        for (int64_t i = 0; i <= numExtents; ++i) {
-                            extentAdded = mBuilder->AddLinearExtent(mFuzzPartition, kDeviceInfoName,
-                                                                    numSectors, physicalSector);
-                        }
-
-                        if (extentAdded) {
-                            unique_ptr<LpMetadata> metadata = mBuilder->Export();
-                            uint64_t alignedSize =
-                                    mFdp.ConsumeIntegralInRange<uint64_t>(kMinValue, kMaxValue);
-                            mFuzzPartition->GetBeginningExtents(LP_SECTOR_SIZE * numExtents);
+                        if (mFuzzPartition) {
+                            bool extentAdded = false;
+                            for (int64_t i = 0; i <= numExtents; ++i) {
+                                extentAdded =
+                                        mBuilder->AddLinearExtent(mFuzzPartition, kDeviceInfoName,
+                                                                  numSectors, physicalSector);
+                            }
+
+                            if (extentAdded) {
+                                unique_ptr<LpMetadata> metadata = mBuilder->Export();
+                                uint64_t alignedSize =
+                                        mFdp.ConsumeIntegralInRange<uint64_t>(kMinValue, kMaxValue);
+                                mFuzzPartition->GetBeginningExtents(LP_SECTOR_SIZE * numExtents);
+                            }
                         }
                     },
                     [&]() { callVerifyExtentsAgainstSourceMetadata(); },
diff --git a/fs_mgr/liblp/fuzzer/liblp_super_layout_builder_fuzzer.cpp b/fs_mgr/liblp/fuzzer/liblp_super_layout_builder_fuzzer.cpp
index 887093c88b21..a6642d7ba9af 100644
--- a/fs_mgr/liblp/fuzzer/liblp_super_layout_builder_fuzzer.cpp
+++ b/fs_mgr/liblp/fuzzer/liblp_super_layout_builder_fuzzer.cpp
@@ -38,8 +38,6 @@ static constexpr uint32_t kSuperLayoutValidMetadataSize = 8_KiB;
 static constexpr uint32_t kMinMetadataValue = 0;
 static constexpr uint32_t kMaxMetadataValue = 10000;
 static constexpr uint32_t kMaxBytes = 20;
-static constexpr uint32_t kMinSlot = 0;
-static constexpr uint32_t kMaxSlot = 10;
 static constexpr uint32_t kMinOpen = 0;
 static constexpr uint32_t kMaxOpen = 2;
 
@@ -58,14 +56,14 @@ class SuperLayoutBuilderFuzzer {
     void invokeSuperLayoutBuilderAPIs();
     void callRandomOpen(int32_t open);
     void addMultiplePartitions(int32_t numPartitions);
-    void setupSuperLayoutBuilder(string fuzzPartitionName);
+    void setupSuperLayoutBuilder();
     SuperLayoutBuilder mSuperLayoutBuilder;
     unique_ptr<MetadataBuilder> mSuperBuilder;
     unique_ptr<LpMetadata> mMetadata;
     bool mOpenSuccess = false;
 };
 
-void SuperLayoutBuilderFuzzer::setupSuperLayoutBuilder(string fuzzPartitionName) {
+void SuperLayoutBuilderFuzzer::setupSuperLayoutBuilder() {
     uint64_t randomBlockDevSize =
             mFdp.ConsumeIntegralInRange<uint64_t>(kMinBlockDevValue, kMaxBlockDevValue);
     uint64_t blockDevSize = mFdp.ConsumeBool() ? kSuperLayoutValidBlockDevSize : randomBlockDevSize;
@@ -73,7 +71,7 @@ void SuperLayoutBuilderFuzzer::setupSuperLayoutBuilder(string fuzzPartitionName)
             mFdp.ConsumeIntegralInRange<uint32_t>(kMinMetadataValue, kMaxMetadataValue);
     uint32_t metadataMaxSize =
             mFdp.ConsumeBool() ? kSuperLayoutValidMetadataSize : randomMetadataMaxSize;
-    uint32_t metadataSlotCount = mFdp.ConsumeIntegralInRange<uint32_t>(kMinSlot, kMaxSlot);
+    uint32_t metadataSlotCount = mFdp.ConsumeBool() ? 0 : 1;
     mSuperBuilder = MetadataBuilder::New(blockDevSize, metadataMaxSize, metadataSlotCount);
 
     if (mSuperBuilder.get()) {
@@ -85,10 +83,6 @@ void SuperLayoutBuilderFuzzer::setupSuperLayoutBuilder(string fuzzPartitionName)
 
         uint32_t randomOpen = mFdp.ConsumeIntegralInRange<uint32_t>(kMinOpen, kMaxOpen);
         callRandomOpen(randomOpen);
-
-        if (!fuzzPartitionName.size()) {
-            fuzzPartitionName = "builder_partition";
-        }
     }
 }
 
@@ -125,7 +119,10 @@ void SuperLayoutBuilderFuzzer::invokeSuperLayoutBuilderAPIs() {
     string imageName = mFdp.ConsumeRandomLengthString(kMaxBytes);
     string fuzzPartitionName =
             mFdp.ConsumeBool() ? "builder_partition" : mFdp.ConsumeRandomLengthString(kMaxBytes);
-    setupSuperLayoutBuilder(fuzzPartitionName);
+    if (!fuzzPartitionName.size()) {
+        fuzzPartitionName = "builder_partition";
+    }
+    setupSuperLayoutBuilder();
     if (mOpenSuccess) {
         while (mFdp.remaining_bytes()) {
             auto invokeSuperAPIs = mFdp.PickValueInArray<const function<void()>>({

From 599d979126a0c60f5cc2955aedc58431f7659270 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 26 Oct 2023 20:46:21 +0000
Subject: [PATCH 0505/1487] libprocessgroup: Remove max_processes from
 KillProcessGroup API

The max_processes calculation is incorrect for KillProcessGroup because
the set of processes in cgroup.procs can differ between the multiple
reads in the implementation. Luckily the exact value isn't very
important because it's just logged. Remove max_processes from the API
and remove the warning about the new behavior in Android 11.

Note that we still always LOG(INFO) that any cgroup is being killed.

Bug: 301871933
Change-Id: I8e449f5089d4a48dbc1797b6d979539e87026f43
---
 init/service.cpp                              | 19 +++++--------------
 init/service.h                                |  2 +-
 .../include/processgroup/processgroup.h       |  7 ++-----
 libprocessgroup/processgroup.cpp              | 18 +++++-------------
 4 files changed, 13 insertions(+), 33 deletions(-)

diff --git a/init/service.cpp b/init/service.cpp
index 5e900ee4d0b0..208745257bf6 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -194,7 +194,7 @@ void Service::NotifyStateChange(const std::string& new_state) const {
     }
 }
 
-void Service::KillProcessGroup(int signal, bool report_oneshot) {
+void Service::KillProcessGroup(int signal) {
     // If we've already seen a successful result from killProcessGroup*(), then we have removed
     // the cgroup already and calling these functions a second time will simply result in an error.
     // This is true regardless of which signal was sent.
@@ -202,20 +202,11 @@ void Service::KillProcessGroup(int signal, bool report_oneshot) {
     if (!process_cgroup_empty_) {
         LOG(INFO) << "Sending signal " << signal << " to service '" << name_ << "' (pid " << pid_
                   << ") process group...";
-        int max_processes = 0;
         int r;
         if (signal == SIGTERM) {
-            r = killProcessGroupOnce(uid(), pid_, signal, &max_processes);
+            r = killProcessGroupOnce(uid(), pid_, signal);
         } else {
-            r = killProcessGroup(uid(), pid_, signal, &max_processes);
-        }
-
-        if (report_oneshot && max_processes > 0) {
-            LOG(WARNING)
-                    << "Killed " << max_processes
-                    << " additional processes from a oneshot process group for service '" << name_
-                    << "'. This is new behavior, previously child processes would not be killed in "
-                       "this case.";
+            r = killProcessGroup(uid(), pid_, signal);
         }
 
         if (r == 0) process_cgroup_empty_ = true;
@@ -265,7 +256,7 @@ void Service::SetProcessAttributesAndCaps(InterprocessFifo setsid_finished) {
 
 void Service::Reap(const siginfo_t& siginfo) {
     if (!(flags_ & SVC_ONESHOT) || (flags_ & SVC_RESTART)) {
-        KillProcessGroup(SIGKILL, false);
+        KillProcessGroup(SIGKILL);
     } else {
         // Legacy behavior from ~2007 until Android R: this else branch did not exist and we did not
         // kill the process group in this case.
@@ -273,7 +264,7 @@ void Service::Reap(const siginfo_t& siginfo) {
             // The new behavior in Android R is to kill these process groups in all cases.  The
             // 'true' parameter instructions KillProcessGroup() to report a warning message where it
             // detects a difference in behavior has occurred.
-            KillProcessGroup(SIGKILL, true);
+            KillProcessGroup(SIGKILL);
         }
     }
 
diff --git a/init/service.h b/init/service.h
index 9f09cefb8618..35521b207a97 100644
--- a/init/service.h
+++ b/init/service.h
@@ -160,7 +160,7 @@ class Service {
   private:
     void NotifyStateChange(const std::string& new_state) const;
     void StopOrReset(int how);
-    void KillProcessGroup(int signal, bool report_oneshot = false);
+    void KillProcessGroup(int signal);
     void SetProcessAttributesAndCaps(InterprocessFifo setsid_finished);
     void ResetFlagsForStart();
     Result<void> CheckConsole();
diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index dbaeb93977bf..5c43224ab321 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -67,14 +67,11 @@ void DropTaskProfilesResourceCaching();
 // Return 0 and removes the cgroup if there are no longer any processes in it.
 // Returns -1 in the case of an error occurring or if there are processes still running
 // even after retrying for up to 200ms.
-// If max_processes is not nullptr, it returns the maximum number of processes seen in the cgroup
-// during the killing process.  Note that this can be 0 if all processes from the process group have
-// already been terminated.
-int killProcessGroup(uid_t uid, int initialPid, int signal, int* max_processes = nullptr);
+int killProcessGroup(uid_t uid, int initialPid, int signal);
 
 // Returns the same as killProcessGroup(), however it does not retry, which means
 // that it only returns 0 in the case that the cgroup exists and it contains no processes.
-int killProcessGroupOnce(uid_t uid, int initialPid, int signal, int* max_processes = nullptr);
+int killProcessGroupOnce(uid_t uid, int initialPid, int signal);
 
 // Sends the provided signal to all members of a process group, but does not wait for processes to
 // exit, or for the cgroup to be removed. Callers should also ensure that killProcessGroup is called
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index cc2565fadfa8..3fa43f8adfc6 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -455,8 +455,7 @@ static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid,
     return (!fd || feof(fd.get())) ? processes : -1;
 }
 
-static int KillProcessGroup(uid_t uid, int initialPid, int signal, int retries,
-                            int* max_processes) {
+static int KillProcessGroup(uid_t uid, int initialPid, int signal, int retries) {
     CHECK_GE(uid, 0);
     CHECK_GT(initialPid, 0);
 
@@ -468,16 +467,9 @@ static int KillProcessGroup(uid_t uid, int initialPid, int signal, int retries,
 
     std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
 
-    if (max_processes != nullptr) {
-        *max_processes = 0;
-    }
-
     int retry = retries;
     int processes;
     while ((processes = DoKillProcessGroupOnce(cgroup, uid, initialPid, signal)) > 0) {
-        if (max_processes != nullptr && processes > *max_processes) {
-            *max_processes = processes;
-        }
         LOG(VERBOSE) << "Killed " << processes << " processes for processgroup " << initialPid;
         if (!CgroupsAvailable()) {
             // makes no sense to retry, because there are no cgroup_procs file
@@ -540,12 +532,12 @@ static int KillProcessGroup(uid_t uid, int initialPid, int signal, int retries,
     }
 }
 
-int killProcessGroup(uid_t uid, int initialPid, int signal, int* max_processes) {
-    return KillProcessGroup(uid, initialPid, signal, 40 /*retries*/, max_processes);
+int killProcessGroup(uid_t uid, int initialPid, int signal) {
+    return KillProcessGroup(uid, initialPid, signal, 40 /*retries*/);
 }
 
-int killProcessGroupOnce(uid_t uid, int initialPid, int signal, int* max_processes) {
-    return KillProcessGroup(uid, initialPid, signal, 0 /*retries*/, max_processes);
+int killProcessGroupOnce(uid_t uid, int initialPid, int signal) {
+    return KillProcessGroup(uid, initialPid, signal, 0 /*retries*/);
 }
 
 int sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {

From 6aa72490dc2bb6959a794e3a9f5f3c76a97155eb Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Tue, 31 Oct 2023 14:01:09 -0700
Subject: [PATCH 0506/1487] Add new segv type SEGV_CPERR.

The new 6.6 kernel headers added a new segv type, SEGV_CPERR. Add this
to the switch statement.

Test: Unit tests pass.
Change-Id: I77eb4748e51c7e7d7291bfd2180b0ccb3b5a6ded
---
 debuggerd/libdebuggerd/utility.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/debuggerd/libdebuggerd/utility.cpp b/debuggerd/libdebuggerd/utility.cpp
index d71fc6c7f14c..15f09b3419b0 100644
--- a/debuggerd/libdebuggerd/utility.cpp
+++ b/debuggerd/libdebuggerd/utility.cpp
@@ -382,8 +382,10 @@ const char* get_sigcode(const siginfo_t* si) {
           return "SEGV_MTEAERR";
         case SEGV_MTESERR:
           return "SEGV_MTESERR";
+        case SEGV_CPERR:
+          return "SEGV_CPERR";
       }
-      static_assert(NSIGSEGV == SEGV_MTESERR, "missing SEGV_* si_code");
+      static_assert(NSIGSEGV == SEGV_CPERR, "missing SEGV_* si_code");
       break;
     case SIGSYS:
       switch (si->si_code) {

From 3b16967f0f60d79aa50531592c387b1367d173ba Mon Sep 17 00:00:00 2001
From: Shin-Yu Wang <shinyuw@google.com>
Date: Wed, 1 Nov 2023 06:24:07 +0000
Subject: [PATCH 0507/1487] Revert "Reapply "Migrate the blkio controller to
 the v2 cgroup hierarchy""

This reverts commit d71f9e5fbbbc1b4a0f910c2c7606915bfeae68a4.

Reason for revert: p0 failed test (b/308687042)

Change-Id: I3d8cb899d79634bb1c80f7d05af5c1311358c25c
---
 libprocessgroup/profiles/cgroups.json       | 13 +++++++------
 libprocessgroup/profiles/task_profiles.json | 12 ++++++++----
 rootdir/init.rc                             | 20 ++++++++++++++++++++
 3 files changed, 35 insertions(+), 10 deletions(-)

diff --git a/libprocessgroup/profiles/cgroups.json b/libprocessgroup/profiles/cgroups.json
index d013ec858c1b..3e4393df2078 100644
--- a/libprocessgroup/profiles/cgroups.json
+++ b/libprocessgroup/profiles/cgroups.json
@@ -1,5 +1,12 @@
 {
   "Cgroups": [
+    {
+      "Controller": "blkio",
+      "Path": "/dev/blkio",
+      "Mode": "0775",
+      "UID": "system",
+      "GID": "system"
+    },
     {
       "Controller": "cpu",
       "Path": "/dev/cpuctl",
@@ -32,12 +39,6 @@
       {
         "Controller": "freezer",
         "Path": "."
-      },
-      {
-        "Controller": "io",
-        "Path": ".",
-        "NeedsActivation": true,
-        "Optional": true
       }
     ]
   }
diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 6314667ef957..1fc66ba10a64 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -442,7 +442,8 @@
           "Name": "JoinCgroup",
           "Params":
           {
-            "Controller": "io"
+            "Controller": "blkio",
+            "Path": "background"
           }
         }
       ]
@@ -454,7 +455,8 @@
           "Name": "JoinCgroup",
           "Params":
           {
-            "Controller": "io"
+            "Controller": "blkio",
+            "Path": ""
           }
         }
       ]
@@ -466,7 +468,8 @@
           "Name": "JoinCgroup",
           "Params":
           {
-            "Controller": "io"
+            "Controller": "blkio",
+            "Path": ""
           }
         }
       ]
@@ -478,7 +481,8 @@
           "Name": "JoinCgroup",
           "Params":
           {
-            "Controller": "io"
+            "Controller": "blkio",
+            "Path": ""
           }
         }
       ]
diff --git a/rootdir/init.rc b/rootdir/init.rc
index fb6473666d7c..317f80908350 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -219,6 +219,26 @@ on init
     write /dev/stune/nnapi-hal/schedtune.boost 1
     write /dev/stune/nnapi-hal/schedtune.prefer_idle 1
 
+    # Create blkio group and apply initial settings.
+    # This feature needs kernel to support it, and the
+    # device's init.rc must actually set the correct values.
+    mkdir /dev/blkio/background
+    chown system system /dev/blkio
+    chown system system /dev/blkio/background
+    chown system system /dev/blkio/tasks
+    chown system system /dev/blkio/background/tasks
+    chown system system /dev/blkio/cgroup.procs
+    chown system system /dev/blkio/background/cgroup.procs
+    chmod 0664 /dev/blkio/tasks
+    chmod 0664 /dev/blkio/background/tasks
+    chmod 0664 /dev/blkio/cgroup.procs
+    chmod 0664 /dev/blkio/background/cgroup.procs
+    write /dev/blkio/blkio.weight 1000
+    write /dev/blkio/background/blkio.weight 200
+    write /dev/blkio/background/blkio.bfq.weight 10
+    write /dev/blkio/blkio.group_idle 0
+    write /dev/blkio/background/blkio.group_idle 0
+
     restorecon_recursive /mnt
 
     mount configfs none /config nodev noexec nosuid

From 6bdb5f86cd9b557d740fcb0c859a9a3f4ddfd63a Mon Sep 17 00:00:00 2001
From: Henri Chataing <henrichataing@google.com>
Date: Wed, 1 Nov 2023 17:25:37 +0000
Subject: [PATCH 0508/1487] Update fmtlib to 10.1.1

Test: m
Change-Id: I1f23ea1a07c792c3b4974414aef9aeb9ae8f11d7
---
 init/service_parser.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/init/service_parser.cpp b/init/service_parser.cpp
index a1b2cc55f472..92e350be607c 100644
--- a/init/service_parser.cpp
+++ b/init/service_parser.cpp
@@ -179,8 +179,9 @@ Result<void> ServiceParser::ParsePriority(std::vector<std::string>&& args) {
     if (!ParseInt(args[1], &service_->proc_attr_.priority,
                   static_cast<int>(ANDROID_PRIORITY_HIGHEST),  // highest is negative
                   static_cast<int>(ANDROID_PRIORITY_LOWEST))) {
-        return Errorf("process priority value must be range {} - {}", ANDROID_PRIORITY_HIGHEST,
-                      ANDROID_PRIORITY_LOWEST);
+        return Errorf("process priority value must be range {} - {}",
+                      static_cast<int>(ANDROID_PRIORITY_HIGHEST),
+                      static_cast<int>(ANDROID_PRIORITY_LOWEST));
     }
     return {};
 }

From c165e84b15554257fbeed7858926815a9060b650 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 23 Oct 2023 20:10:37 -0700
Subject: [PATCH 0509/1487] libsnapshot: Add Parser base class

Add in Parser base class and refactor code to work with it. Base class
will have ops() method which returns a vector of v3 operations.
v2_parser translates it's v2 operations to v3 operations with this
method.

Bug: 307452468
Test: Test with critical OTA paths?
Change-Id: Iccc9755a892911a1638f5b62d7d6a2402c68ab20
---
 .../include/libsnapshot/cow_reader.h          |  1 -
 .../libsnapshot_cow/cow_reader.cpp            | 76 ++++++++-----------
 .../libsnapshot_cow/inspect_cow.cpp           |  4 +-
 .../libsnapshot/libsnapshot_cow/parser_base.h | 53 +++++++++++++
 .../libsnapshot/libsnapshot_cow/parser_v2.cpp | 56 ++++++++++++--
 .../libsnapshot/libsnapshot_cow/parser_v2.h   | 25 +++---
 .../libsnapshot/libsnapshot_cow/writer_v2.cpp |  5 +-
 .../user-space-merge/snapuserd_core.cpp       |  2 +-
 8 files changed, 150 insertions(+), 72 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index debaf3683c9f..4cbcab137570 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -185,7 +185,6 @@ class CowReader final : public ICowReader {
     std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
     ReaderFlags reader_flag_;
     bool is_merge_{};
-    uint8_t compression_type_ = kCowCompressNone;
 };
 
 // Though this function takes in a CowHeaderV3, the struct could be populated as a v1/v2 CowHeader.
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 3b84c95ccb2e..6f1854d0a245 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -28,7 +28,6 @@
 #include <zlib.h>
 
 #include "cow_decompress.h"
-#include "libsnapshot/cow_format.h"
 #include "parser_v2.h"
 
 namespace android {
@@ -85,7 +84,6 @@ std::unique_ptr<CowReader> CowReader::CloneCowReader() {
     cow->data_loc_ = data_loc_;
     cow->block_pos_index_ = block_pos_index_;
     cow->is_merge_ = is_merge_;
-    cow->compression_type_ = compression_type_;
     return cow;
 }
 
@@ -104,11 +102,14 @@ bool CowReader::InitForMerge(android::base::unique_fd&& fd) {
         PLOG(ERROR) << "lseek header failed";
         return false;
     }
-    if (!android::base::ReadFully(fd_, &header_, sizeof(header_))) {
+
+    CHECK_GE(header_.prefix.header_size, sizeof(CowHeader));
+    CHECK_LE(header_.prefix.header_size, sizeof(header_));
+
+    if (!android::base::ReadFully(fd_, &header_, header_.prefix.header_size)) {
         PLOG(ERROR) << "read header failed";
         return false;
     }
-
     return true;
 }
 
@@ -124,52 +125,35 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
         return false;
     }
 
-    CowParserV2 parser;
-    if (!parser.Parse(fd, header_, label)) {
-        return false;
+    std::unique_ptr<CowParserBase> parser;
+    switch (header_.prefix.major_version) {
+        case 1:
+        case 2:
+            parser = std::make_unique<CowParserV2>();
+            break;
+        case 3:
+            break;
+        default:
+            LOG(ERROR) << "Unknown version: " << header_.prefix.major_version;
+            return false;
     }
 
-    footer_ = parser.footer();
-    fd_size_ = parser.fd_size();
-    last_label_ = parser.last_label();
-    data_loc_ = parser.data_loc();
-    ops_ = std::make_shared<std::vector<CowOperation>>(parser.ops()->size());
-
-    // Translate the operation buffer from on disk to in memory
-    for (size_t i = 0; i < parser.ops()->size(); i++) {
-        const auto& v2_op = parser.ops()->at(i);
-
-        auto& new_op = ops_->at(i);
-        new_op.type = v2_op.type;
-        new_op.data_length = v2_op.data_length;
-
-        if (v2_op.new_block > std::numeric_limits<uint32_t>::max()) {
-            LOG(ERROR) << "Out-of-range new block in COW op: " << v2_op;
-            return false;
-        }
-        new_op.new_block = v2_op.new_block;
+    if (!parser->Parse(fd, header_, label)) {
+        return false;
+    }
 
-        uint64_t source_info = v2_op.source;
-        if (new_op.type != kCowLabelOp) {
-            source_info &= kCowOpSourceInfoDataMask;
-            if (source_info != v2_op.source) {
-                LOG(ERROR) << "Out-of-range source value in COW op: " << v2_op;
-                return false;
-            }
-        }
-        if (v2_op.compression != kCowCompressNone) {
-            if (compression_type_ == kCowCompressNone) {
-                compression_type_ = v2_op.compression;
-            } else if (compression_type_ != v2_op.compression) {
-                LOG(ERROR) << "COW has mixed compression types which is not supported;"
-                           << " previously saw " << compression_type_ << ", got "
-                           << v2_op.compression << ", op: " << v2_op;
-                return false;
-            }
-        }
-        new_op.source_info = source_info;
+    TranslatedCowOps ops_info;
+    if (!parser->Translate(&ops_info)) {
+        return false;
     }
 
+    header_ = ops_info.header;
+    ops_ = std::move(ops_info.ops);
+    footer_ = parser->footer();
+    fd_size_ = parser->fd_size();
+    last_label_ = parser->last_label();
+    data_loc_ = parser->data_loc();
+
     // If we're resuming a write, we're not ready to merge
     if (label.has_value()) return true;
     return PrepMergeOps();
@@ -664,7 +648,7 @@ class CowDataStream final : public IByteStream {
 };
 
 uint8_t CowReader::GetCompressionType() {
-    return compression_type_;
+    return header_.compression_algorithm;
 }
 
 ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_size,
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
index a29146985142..76509de78961 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
@@ -74,13 +74,13 @@ static void ShowBad(CowReader& reader, const CowOperation* op) {
     }
 }
 
-static bool ShowRawOpStreamV2(borrowed_fd fd, const CowHeader& header) {
+static bool ShowRawOpStreamV2(borrowed_fd fd, const CowHeaderV3& header) {
     CowParserV2 parser;
     if (!parser.Parse(fd, header)) {
         LOG(ERROR) << "v2 parser failed";
         return false;
     }
-    for (const auto& op : *parser.ops()) {
+    for (const auto& op : *parser.get_v2ops()) {
         std::cout << op << "\n";
         if (auto iter = parser.data_loc()->find(op.new_block); iter != parser.data_loc()->end()) {
             std::cout << "    data loc: " << iter->second << "\n";
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h
new file mode 100644
index 000000000000..278340740bd9
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h
@@ -0,0 +1,53 @@
+//
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#pragma once
+
+#include <optional>
+#include <unordered_map>
+
+#include <android-base/unique_fd.h>
+#include <libsnapshot/cow_format.h>
+
+namespace android {
+namespace snapshot {
+
+struct TranslatedCowOps {
+    CowHeaderV3 header;
+    std::shared_ptr<std::vector<CowOperationV3>> ops;
+};
+
+class CowParserBase {
+  public:
+    virtual ~CowParserBase() = default;
+
+    virtual bool Parse(android::base::borrowed_fd fd, const CowHeaderV3& header,
+                       std::optional<uint64_t> label = {}) = 0;
+    virtual bool Translate(TranslatedCowOps* out) = 0;
+    virtual std::optional<CowFooter> footer() const { return std::nullopt; }
+    virtual std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const = 0;
+
+    uint64_t fd_size() const { return fd_size_; }
+    const std::optional<uint64_t>& last_label() const { return last_label_; }
+
+  protected:
+    CowHeaderV3 header_ = {};
+    uint64_t fd_size_;
+    std::optional<uint64_t> last_label_;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
index 8f2031783f5f..27d437e836bb 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
@@ -17,13 +17,14 @@
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include "libsnapshot/cow_format.h"
 
 namespace android {
 namespace snapshot {
 
 using android::base::borrowed_fd;
 
-bool CowParserV2::Parse(borrowed_fd fd, const CowHeader& header, std::optional<uint64_t> label) {
+bool CowParserV2::Parse(borrowed_fd fd, const CowHeaderV3& header, std::optional<uint64_t> label) {
     auto pos = lseek(fd.get(), 0, SEEK_END);
     if (pos < 0) {
         PLOG(ERROR) << "lseek end failed";
@@ -47,8 +48,7 @@ bool CowParserV2::Parse(borrowed_fd fd, const CowHeader& header, std::optional<u
         return false;
     }
 
-    if ((header_.prefix.major_version > kCowVersionMajor) ||
-        (header_.prefix.minor_version != kCowVersionMinor)) {
+    if (header_.prefix.major_version > 2 || header_.prefix.minor_version != 0) {
         LOG(ERROR) << "Header version mismatch, "
                    << "major version: " << header_.prefix.major_version
                    << ", expected: " << kCowVersionMajor
@@ -190,11 +190,57 @@ bool CowParserV2::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
         }
     }
 
-    ops_ = ops_buffer;
-    ops_->shrink_to_fit();
+    v2_ops_ = ops_buffer;
+    v2_ops_->shrink_to_fit();
     data_loc_ = data_loc;
     return true;
 }
 
+bool CowParserV2::Translate(TranslatedCowOps* out) {
+    out->ops = std::make_shared<std::vector<CowOperationV3>>(v2_ops_->size());
+
+    // Translate the operation buffer from on disk to in memory
+    for (size_t i = 0; i < out->ops->size(); i++) {
+        const auto& v2_op = v2_ops_->at(i);
+
+        auto& new_op = out->ops->at(i);
+        new_op.type = v2_op.type;
+        new_op.data_length = v2_op.data_length;
+
+        if (v2_op.new_block > std::numeric_limits<uint32_t>::max()) {
+            LOG(ERROR) << "Out-of-range new block in COW op: " << v2_op;
+            return false;
+        }
+        new_op.new_block = v2_op.new_block;
+
+        uint64_t source_info = v2_op.source;
+        if (new_op.type != kCowLabelOp) {
+            source_info &= kCowOpSourceInfoDataMask;
+            if (source_info != v2_op.source) {
+                LOG(ERROR) << "Out-of-range source value in COW op: " << v2_op;
+                return false;
+            }
+        }
+        if (v2_op.compression != kCowCompressNone) {
+            if (header_.compression_algorithm == kCowCompressNone) {
+                header_.compression_algorithm = v2_op.compression;
+            } else if (header_.compression_algorithm != v2_op.compression) {
+                LOG(ERROR) << "COW has mixed compression types which is not supported;"
+                           << " previously saw " << header_.compression_algorithm << ", got "
+                           << v2_op.compression << ", op: " << v2_op;
+                return false;
+            }
+        }
+        new_op.source_info = source_info;
+    }
+
+    out->header = header_;
+    return true;
+}
+
+std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> CowParserV2::data_loc() const {
+    return data_loc_;
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
index f51ff88cb15a..a70c780e4143 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
@@ -17,36 +17,31 @@
 
 #include <memory>
 #include <optional>
-#include <unordered_map>
 #include <vector>
 
 #include <android-base/unique_fd.h>
 #include <libsnapshot/cow_format.h>
+#include "parser_base.h"
 
 namespace android {
 namespace snapshot {
 
-class CowParserV2 {
+class CowParserV2 final : public CowParserBase {
   public:
-    bool Parse(android::base::borrowed_fd fd, const CowHeader& header,
-               std::optional<uint64_t> label = {});
+    bool Parse(android::base::borrowed_fd fd, const CowHeaderV3& header,
+               std::optional<uint64_t> label = {}) override;
+    bool Translate(TranslatedCowOps* out) override;
+    std::optional<CowFooter> footer() const override { return footer_; }
 
     const CowHeader& header() const { return header_; }
-    const std::optional<CowFooter>& footer() const { return footer_; }
-    std::shared_ptr<std::vector<CowOperationV2>> ops() { return ops_; }
-    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const { return data_loc_; }
-    uint64_t fd_size() const { return fd_size_; }
-    const std::optional<uint64_t>& last_label() const { return last_label_; }
+    std::shared_ptr<std::vector<CowOperationV2>> get_v2ops() { return v2_ops_; }
+    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const override;
 
   private:
+    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
     bool ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label);
-
-    CowHeader header_ = {};
+    std::shared_ptr<std::vector<CowOperationV2>> v2_ops_;
     std::optional<CowFooter> footer_;
-    std::shared_ptr<std::vector<CowOperationV2>> ops_;
-    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
-    uint64_t fd_size_;
-    std::optional<uint64_t> last_label_;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index 83a9b1b2230f..37324c767835 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -273,10 +273,11 @@ bool CowWriterV2::OpenForAppend(uint64_t label) {
     if (!ReadCowHeader(fd_, &header_v3)) {
         return false;
     }
+
     header_ = header_v3;
 
     CowParserV2 parser;
-    if (!parser.Parse(fd_, header_, {label})) {
+    if (!parser.Parse(fd_, header_v3, {label})) {
         return false;
     }
     if (header_.prefix.major_version > 2) {
@@ -292,7 +293,7 @@ bool CowWriterV2::OpenForAppend(uint64_t label) {
     footer_.op.num_ops = 0;
     InitPos();
 
-    for (const auto& op : *parser.ops()) {
+    for (const auto& op : *parser.get_v2ops()) {
         AddOperation(op);
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 8208d67c8c5a..950d7719d7ba 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -112,7 +112,7 @@ bool SnapshotHandler::CommitMerge(int num_merge_ops) {
             return false;
         }
 
-        if (!android::base::WriteFully(cow_fd_, &header, sizeof(CowHeader))) {
+        if (!android::base::WriteFully(cow_fd_, &header, header.prefix.header_size)) {
             SNAP_PLOG(ERROR) << "Write to header failed";
             return false;
         }

From 4ca81f26d872e6ee0e33b2d553054534d6e2982f Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 10 Oct 2023 10:17:50 -0700
Subject: [PATCH 0510/1487] libsnapshot: Add Parser v3 + stub

Adding in parser v3 plus stub implementation.

Bug: 307452468
Test: th
Change-Id: Ie01f94d036c2062e34dbdf32456dc0a4612492d3
---
 fs_mgr/libsnapshot/Android.bp                 |  1 +
 .../libsnapshot/libsnapshot_cow/parser_v2.h   |  2 +-
 .../libsnapshot/libsnapshot_cow/parser_v3.cpp | 44 ++++++++++++++
 .../libsnapshot/libsnapshot_cow/parser_v3.h   | 57 +++++++++++++++++++
 4 files changed, 103 insertions(+), 1 deletion(-)
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 6fad6626655e..ac58ba08f81c 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -198,6 +198,7 @@ cc_library_static {
         "libsnapshot_cow/cow_format.cpp",
         "libsnapshot_cow/cow_reader.cpp",
         "libsnapshot_cow/parser_v2.cpp",
+        "libsnapshot_cow/parser_v3.cpp",
         "libsnapshot_cow/snapshot_reader.cpp",
         "libsnapshot_cow/writer_base.cpp",
         "libsnapshot_cow/writer_v2.cpp",
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
index a70c780e4143..318a3ac14bb5 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
@@ -21,7 +21,7 @@
 
 #include <android-base/unique_fd.h>
 #include <libsnapshot/cow_format.h>
-#include "parser_base.h"
+#include <libsnapshot_cow/parser_base.h>
 
 namespace android {
 namespace snapshot {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
new file mode 100644
index 000000000000..9880670f4580
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
@@ -0,0 +1,44 @@
+// Copyright (C) 2023 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 "parser_v3.h"
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include "libsnapshot/cow_format.h"
+
+namespace android {
+namespace snapshot {
+
+using android::base::borrowed_fd;
+
+bool CowParserV3::Parse(borrowed_fd fd, const CowHeaderV3& header, std::optional<uint64_t> label) {
+    LOG(ERROR) << "this function should never be called";
+    if (fd.get() || sizeof(header) > 0 || label) return false;
+    return false;
+}
+
+bool CowParserV3::ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label) {
+    LOG(ERROR) << "this function should never be called";
+    if (fd.get() || label) return false;
+    return false;
+}
+
+bool CowParserV3::Translate(TranslatedCowOps* out) {
+    out->ops = ops_;
+    out->header = header_;
+    return true;
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
new file mode 100644
index 000000000000..b766aa728aa1
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
@@ -0,0 +1,57 @@
+// Copyright (C) 2023 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.
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <stdint.h>
+
+#include <memory>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+#include <android-base/unique_fd.h>
+#include <libsnapshot/cow_format.h>
+#include <libsnapshot_cow/parser_base.h>
+
+namespace android {
+namespace snapshot {
+
+class CowParserV3 final : public CowParserBase {
+  public:
+    bool Parse(android::base::borrowed_fd fd, const CowHeaderV3& header,
+               std::optional<uint64_t> label = {}) override;
+    bool Translate(TranslatedCowOps* out) override;
+
+  private:
+    bool ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label);
+
+    CowHeaderV3 header_ = {};
+    std::shared_ptr<std::vector<CowOperationV3>> ops_;
+};
+
+}  // namespace snapshot
+}  // namespace android

From ad37351bd18117a138c34ad75a6043b41fbd3538 Mon Sep 17 00:00:00 2001
From: Hsiu-Chang Chen <hsiuchangchen@google.com>
Date: Thu, 2 Nov 2023 03:25:24 +0000
Subject: [PATCH 0511/1487] Revert "libsnapshot: Add Parser v3 + stub"

Revert submission 2781730

Reason for revert: It breaks build

Reverted changes: /q/submissionid:2781730

Bug: 308868619
Change-Id: I53b6b619635f150455cdba00237d130cae5df347
---
 fs_mgr/libsnapshot/Android.bp                 |  1 -
 .../libsnapshot/libsnapshot_cow/parser_v2.h   |  2 +-
 .../libsnapshot/libsnapshot_cow/parser_v3.cpp | 44 --------------
 .../libsnapshot/libsnapshot_cow/parser_v3.h   | 57 -------------------
 4 files changed, 1 insertion(+), 103 deletions(-)
 delete mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
 delete mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index ac58ba08f81c..6fad6626655e 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -198,7 +198,6 @@ cc_library_static {
         "libsnapshot_cow/cow_format.cpp",
         "libsnapshot_cow/cow_reader.cpp",
         "libsnapshot_cow/parser_v2.cpp",
-        "libsnapshot_cow/parser_v3.cpp",
         "libsnapshot_cow/snapshot_reader.cpp",
         "libsnapshot_cow/writer_base.cpp",
         "libsnapshot_cow/writer_v2.cpp",
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
index 318a3ac14bb5..a70c780e4143 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
@@ -21,7 +21,7 @@
 
 #include <android-base/unique_fd.h>
 #include <libsnapshot/cow_format.h>
-#include <libsnapshot_cow/parser_base.h>
+#include "parser_base.h"
 
 namespace android {
 namespace snapshot {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
deleted file mode 100644
index 9880670f4580..000000000000
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (C) 2023 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 "parser_v3.h"
-
-#include <android-base/file.h>
-#include <android-base/logging.h>
-#include "libsnapshot/cow_format.h"
-
-namespace android {
-namespace snapshot {
-
-using android::base::borrowed_fd;
-
-bool CowParserV3::Parse(borrowed_fd fd, const CowHeaderV3& header, std::optional<uint64_t> label) {
-    LOG(ERROR) << "this function should never be called";
-    if (fd.get() || sizeof(header) > 0 || label) return false;
-    return false;
-}
-
-bool CowParserV3::ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label) {
-    LOG(ERROR) << "this function should never be called";
-    if (fd.get() || label) return false;
-    return false;
-}
-
-bool CowParserV3::Translate(TranslatedCowOps* out) {
-    out->ops = ops_;
-    out->header = header_;
-    return true;
-}
-
-}  // namespace snapshot
-}  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
deleted file mode 100644
index b766aa728aa1..000000000000
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (C) 2023 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.
-// Copyright (C) 2023 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#pragma once
-
-#include <stdint.h>
-
-#include <memory>
-#include <optional>
-#include <unordered_map>
-#include <vector>
-
-#include <android-base/unique_fd.h>
-#include <libsnapshot/cow_format.h>
-#include <libsnapshot_cow/parser_base.h>
-
-namespace android {
-namespace snapshot {
-
-class CowParserV3 final : public CowParserBase {
-  public:
-    bool Parse(android::base::borrowed_fd fd, const CowHeaderV3& header,
-               std::optional<uint64_t> label = {}) override;
-    bool Translate(TranslatedCowOps* out) override;
-
-  private:
-    bool ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label);
-
-    CowHeaderV3 header_ = {};
-    std::shared_ptr<std::vector<CowOperationV3>> ops_;
-};
-
-}  // namespace snapshot
-}  // namespace android

From e2ce495aa23c9bbe5752043451394f1fc9653c88 Mon Sep 17 00:00:00 2001
From: Hsiu-Chang Chen <hsiuchangchen@google.com>
Date: Thu, 2 Nov 2023 03:25:24 +0000
Subject: [PATCH 0512/1487] Revert "libsnapshot: Add Parser base class"

Revert submission 2781730

Reason for revert: It breaks build

Reverted changes: /q/submissionid:2781730

Bug: 308868619
Change-Id: I255263d14a1ced57b80efd373dd22eb22bb6efc1
---
 .../include/libsnapshot/cow_reader.h          |  1 +
 .../libsnapshot_cow/cow_reader.cpp            | 76 +++++++++++--------
 .../libsnapshot_cow/inspect_cow.cpp           |  4 +-
 .../libsnapshot/libsnapshot_cow/parser_base.h | 53 -------------
 .../libsnapshot/libsnapshot_cow/parser_v2.cpp | 56 ++------------
 .../libsnapshot/libsnapshot_cow/parser_v2.h   | 25 +++---
 .../libsnapshot/libsnapshot_cow/writer_v2.cpp |  5 +-
 .../user-space-merge/snapuserd_core.cpp       |  2 +-
 8 files changed, 72 insertions(+), 150 deletions(-)
 delete mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index 4cbcab137570..debaf3683c9f 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -185,6 +185,7 @@ class CowReader final : public ICowReader {
     std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
     ReaderFlags reader_flag_;
     bool is_merge_{};
+    uint8_t compression_type_ = kCowCompressNone;
 };
 
 // Though this function takes in a CowHeaderV3, the struct could be populated as a v1/v2 CowHeader.
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 6f1854d0a245..3b84c95ccb2e 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -28,6 +28,7 @@
 #include <zlib.h>
 
 #include "cow_decompress.h"
+#include "libsnapshot/cow_format.h"
 #include "parser_v2.h"
 
 namespace android {
@@ -84,6 +85,7 @@ std::unique_ptr<CowReader> CowReader::CloneCowReader() {
     cow->data_loc_ = data_loc_;
     cow->block_pos_index_ = block_pos_index_;
     cow->is_merge_ = is_merge_;
+    cow->compression_type_ = compression_type_;
     return cow;
 }
 
@@ -102,14 +104,11 @@ bool CowReader::InitForMerge(android::base::unique_fd&& fd) {
         PLOG(ERROR) << "lseek header failed";
         return false;
     }
-
-    CHECK_GE(header_.prefix.header_size, sizeof(CowHeader));
-    CHECK_LE(header_.prefix.header_size, sizeof(header_));
-
-    if (!android::base::ReadFully(fd_, &header_, header_.prefix.header_size)) {
+    if (!android::base::ReadFully(fd_, &header_, sizeof(header_))) {
         PLOG(ERROR) << "read header failed";
         return false;
     }
+
     return true;
 }
 
@@ -125,34 +124,51 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
         return false;
     }
 
-    std::unique_ptr<CowParserBase> parser;
-    switch (header_.prefix.major_version) {
-        case 1:
-        case 2:
-            parser = std::make_unique<CowParserV2>();
-            break;
-        case 3:
-            break;
-        default:
-            LOG(ERROR) << "Unknown version: " << header_.prefix.major_version;
-            return false;
-    }
-
-    if (!parser->Parse(fd, header_, label)) {
+    CowParserV2 parser;
+    if (!parser.Parse(fd, header_, label)) {
         return false;
     }
 
-    TranslatedCowOps ops_info;
-    if (!parser->Translate(&ops_info)) {
-        return false;
-    }
+    footer_ = parser.footer();
+    fd_size_ = parser.fd_size();
+    last_label_ = parser.last_label();
+    data_loc_ = parser.data_loc();
+    ops_ = std::make_shared<std::vector<CowOperation>>(parser.ops()->size());
+
+    // Translate the operation buffer from on disk to in memory
+    for (size_t i = 0; i < parser.ops()->size(); i++) {
+        const auto& v2_op = parser.ops()->at(i);
 
-    header_ = ops_info.header;
-    ops_ = std::move(ops_info.ops);
-    footer_ = parser->footer();
-    fd_size_ = parser->fd_size();
-    last_label_ = parser->last_label();
-    data_loc_ = parser->data_loc();
+        auto& new_op = ops_->at(i);
+        new_op.type = v2_op.type;
+        new_op.data_length = v2_op.data_length;
+
+        if (v2_op.new_block > std::numeric_limits<uint32_t>::max()) {
+            LOG(ERROR) << "Out-of-range new block in COW op: " << v2_op;
+            return false;
+        }
+        new_op.new_block = v2_op.new_block;
+
+        uint64_t source_info = v2_op.source;
+        if (new_op.type != kCowLabelOp) {
+            source_info &= kCowOpSourceInfoDataMask;
+            if (source_info != v2_op.source) {
+                LOG(ERROR) << "Out-of-range source value in COW op: " << v2_op;
+                return false;
+            }
+        }
+        if (v2_op.compression != kCowCompressNone) {
+            if (compression_type_ == kCowCompressNone) {
+                compression_type_ = v2_op.compression;
+            } else if (compression_type_ != v2_op.compression) {
+                LOG(ERROR) << "COW has mixed compression types which is not supported;"
+                           << " previously saw " << compression_type_ << ", got "
+                           << v2_op.compression << ", op: " << v2_op;
+                return false;
+            }
+        }
+        new_op.source_info = source_info;
+    }
 
     // If we're resuming a write, we're not ready to merge
     if (label.has_value()) return true;
@@ -648,7 +664,7 @@ class CowDataStream final : public IByteStream {
 };
 
 uint8_t CowReader::GetCompressionType() {
-    return header_.compression_algorithm;
+    return compression_type_;
 }
 
 ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_size,
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
index 76509de78961..a29146985142 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
@@ -74,13 +74,13 @@ static void ShowBad(CowReader& reader, const CowOperation* op) {
     }
 }
 
-static bool ShowRawOpStreamV2(borrowed_fd fd, const CowHeaderV3& header) {
+static bool ShowRawOpStreamV2(borrowed_fd fd, const CowHeader& header) {
     CowParserV2 parser;
     if (!parser.Parse(fd, header)) {
         LOG(ERROR) << "v2 parser failed";
         return false;
     }
-    for (const auto& op : *parser.get_v2ops()) {
+    for (const auto& op : *parser.ops()) {
         std::cout << op << "\n";
         if (auto iter = parser.data_loc()->find(op.new_block); iter != parser.data_loc()->end()) {
             std::cout << "    data loc: " << iter->second << "\n";
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h
deleted file mode 100644
index 278340740bd9..000000000000
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h
+++ /dev/null
@@ -1,53 +0,0 @@
-//
-// Copyright (C) 2023 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#pragma once
-
-#include <optional>
-#include <unordered_map>
-
-#include <android-base/unique_fd.h>
-#include <libsnapshot/cow_format.h>
-
-namespace android {
-namespace snapshot {
-
-struct TranslatedCowOps {
-    CowHeaderV3 header;
-    std::shared_ptr<std::vector<CowOperationV3>> ops;
-};
-
-class CowParserBase {
-  public:
-    virtual ~CowParserBase() = default;
-
-    virtual bool Parse(android::base::borrowed_fd fd, const CowHeaderV3& header,
-                       std::optional<uint64_t> label = {}) = 0;
-    virtual bool Translate(TranslatedCowOps* out) = 0;
-    virtual std::optional<CowFooter> footer() const { return std::nullopt; }
-    virtual std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const = 0;
-
-    uint64_t fd_size() const { return fd_size_; }
-    const std::optional<uint64_t>& last_label() const { return last_label_; }
-
-  protected:
-    CowHeaderV3 header_ = {};
-    uint64_t fd_size_;
-    std::optional<uint64_t> last_label_;
-};
-
-}  // namespace snapshot
-}  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
index 27d437e836bb..8f2031783f5f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
@@ -17,14 +17,13 @@
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
-#include "libsnapshot/cow_format.h"
 
 namespace android {
 namespace snapshot {
 
 using android::base::borrowed_fd;
 
-bool CowParserV2::Parse(borrowed_fd fd, const CowHeaderV3& header, std::optional<uint64_t> label) {
+bool CowParserV2::Parse(borrowed_fd fd, const CowHeader& header, std::optional<uint64_t> label) {
     auto pos = lseek(fd.get(), 0, SEEK_END);
     if (pos < 0) {
         PLOG(ERROR) << "lseek end failed";
@@ -48,7 +47,8 @@ bool CowParserV2::Parse(borrowed_fd fd, const CowHeaderV3& header, std::optional
         return false;
     }
 
-    if (header_.prefix.major_version > 2 || header_.prefix.minor_version != 0) {
+    if ((header_.prefix.major_version > kCowVersionMajor) ||
+        (header_.prefix.minor_version != kCowVersionMinor)) {
         LOG(ERROR) << "Header version mismatch, "
                    << "major version: " << header_.prefix.major_version
                    << ", expected: " << kCowVersionMajor
@@ -190,57 +190,11 @@ bool CowParserV2::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
         }
     }
 
-    v2_ops_ = ops_buffer;
-    v2_ops_->shrink_to_fit();
+    ops_ = ops_buffer;
+    ops_->shrink_to_fit();
     data_loc_ = data_loc;
     return true;
 }
 
-bool CowParserV2::Translate(TranslatedCowOps* out) {
-    out->ops = std::make_shared<std::vector<CowOperationV3>>(v2_ops_->size());
-
-    // Translate the operation buffer from on disk to in memory
-    for (size_t i = 0; i < out->ops->size(); i++) {
-        const auto& v2_op = v2_ops_->at(i);
-
-        auto& new_op = out->ops->at(i);
-        new_op.type = v2_op.type;
-        new_op.data_length = v2_op.data_length;
-
-        if (v2_op.new_block > std::numeric_limits<uint32_t>::max()) {
-            LOG(ERROR) << "Out-of-range new block in COW op: " << v2_op;
-            return false;
-        }
-        new_op.new_block = v2_op.new_block;
-
-        uint64_t source_info = v2_op.source;
-        if (new_op.type != kCowLabelOp) {
-            source_info &= kCowOpSourceInfoDataMask;
-            if (source_info != v2_op.source) {
-                LOG(ERROR) << "Out-of-range source value in COW op: " << v2_op;
-                return false;
-            }
-        }
-        if (v2_op.compression != kCowCompressNone) {
-            if (header_.compression_algorithm == kCowCompressNone) {
-                header_.compression_algorithm = v2_op.compression;
-            } else if (header_.compression_algorithm != v2_op.compression) {
-                LOG(ERROR) << "COW has mixed compression types which is not supported;"
-                           << " previously saw " << header_.compression_algorithm << ", got "
-                           << v2_op.compression << ", op: " << v2_op;
-                return false;
-            }
-        }
-        new_op.source_info = source_info;
-    }
-
-    out->header = header_;
-    return true;
-}
-
-std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> CowParserV2::data_loc() const {
-    return data_loc_;
-}
-
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
index a70c780e4143..f51ff88cb15a 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
@@ -17,31 +17,36 @@
 
 #include <memory>
 #include <optional>
+#include <unordered_map>
 #include <vector>
 
 #include <android-base/unique_fd.h>
 #include <libsnapshot/cow_format.h>
-#include "parser_base.h"
 
 namespace android {
 namespace snapshot {
 
-class CowParserV2 final : public CowParserBase {
+class CowParserV2 {
   public:
-    bool Parse(android::base::borrowed_fd fd, const CowHeaderV3& header,
-               std::optional<uint64_t> label = {}) override;
-    bool Translate(TranslatedCowOps* out) override;
-    std::optional<CowFooter> footer() const override { return footer_; }
+    bool Parse(android::base::borrowed_fd fd, const CowHeader& header,
+               std::optional<uint64_t> label = {});
 
     const CowHeader& header() const { return header_; }
-    std::shared_ptr<std::vector<CowOperationV2>> get_v2ops() { return v2_ops_; }
-    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const override;
+    const std::optional<CowFooter>& footer() const { return footer_; }
+    std::shared_ptr<std::vector<CowOperationV2>> ops() { return ops_; }
+    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const { return data_loc_; }
+    uint64_t fd_size() const { return fd_size_; }
+    const std::optional<uint64_t>& last_label() const { return last_label_; }
 
   private:
-    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
     bool ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label);
-    std::shared_ptr<std::vector<CowOperationV2>> v2_ops_;
+
+    CowHeader header_ = {};
     std::optional<CowFooter> footer_;
+    std::shared_ptr<std::vector<CowOperationV2>> ops_;
+    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
+    uint64_t fd_size_;
+    std::optional<uint64_t> last_label_;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index 37324c767835..83a9b1b2230f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -273,11 +273,10 @@ bool CowWriterV2::OpenForAppend(uint64_t label) {
     if (!ReadCowHeader(fd_, &header_v3)) {
         return false;
     }
-
     header_ = header_v3;
 
     CowParserV2 parser;
-    if (!parser.Parse(fd_, header_v3, {label})) {
+    if (!parser.Parse(fd_, header_, {label})) {
         return false;
     }
     if (header_.prefix.major_version > 2) {
@@ -293,7 +292,7 @@ bool CowWriterV2::OpenForAppend(uint64_t label) {
     footer_.op.num_ops = 0;
     InitPos();
 
-    for (const auto& op : *parser.get_v2ops()) {
+    for (const auto& op : *parser.ops()) {
         AddOperation(op);
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 950d7719d7ba..8208d67c8c5a 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -112,7 +112,7 @@ bool SnapshotHandler::CommitMerge(int num_merge_ops) {
             return false;
         }
 
-        if (!android::base::WriteFully(cow_fd_, &header, header.prefix.header_size)) {
+        if (!android::base::WriteFully(cow_fd_, &header, sizeof(CowHeader))) {
             SNAP_PLOG(ERROR) << "Write to header failed";
             return false;
         }

From 79283ef377e9253065d28998fb23a11a92a58537 Mon Sep 17 00:00:00 2001
From: Dennis Shen <dzshen@google.com>
Date: Tue, 24 Oct 2023 17:30:12 +0000
Subject: [PATCH 0513/1487] Move staging value application logic to
 persistent_properties and add unit tests

1, Previous implementation has the staged prop application done in
property_service, which caused a number of unnecessary changes which
including exposing apis like AddPersistentProperty. In addition, it made
the property_service logic complicated. A better design is to have the
staged value application done while reading the persistent properties
from file. This way, no change to property service. In addition, unit
test is much cleaner and efficient.

2, add a unit test to lock down the behavior. Specifically, it locks down that when a prop is staged, it should be applied the next time when the persistent prop is loaded. In addition, it should lock down that other persistent props are not overwritten.

Bug: b/307752841, b/300111812, b/306062513

Change-Id: I43c603efbb803195065dda3f0bc2145716302bbc
---
 init/persistent_properties.cpp      | 65 +++++++++++++++++++++++++----
 init/persistent_properties.h        |  2 -
 init/persistent_properties_test.cpp | 32 ++++++++++++++
 init/property_service.cpp           | 23 +---------
 4 files changed, 90 insertions(+), 32 deletions(-)

diff --git a/init/persistent_properties.cpp b/init/persistent_properties.cpp
index e89244f13be0..6f8a4de93d3c 100644
--- a/init/persistent_properties.cpp
+++ b/init/persistent_properties.cpp
@@ -46,6 +46,13 @@ namespace {
 
 constexpr const char kLegacyPersistentPropertyDir[] = "/data/property";
 
+void AddPersistentProperty(const std::string& name, const std::string& value,
+                           PersistentProperties* persistent_properties) {
+    auto persistent_property_record = persistent_properties->add_properties();
+    persistent_property_record->set_name(name);
+    persistent_property_record->set_value(value);
+}
+
 Result<PersistentProperties> LoadLegacyPersistentProperties() {
     std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(kLegacyPersistentPropertyDir), closedir);
     if (!dir) {
@@ -146,13 +153,6 @@ Result<PersistentProperties> ParsePersistentPropertyFile(const std::string& file
 
 }  // namespace
 
-void AddPersistentProperty(const std::string& name, const std::string& value,
-                           PersistentProperties* persistent_properties) {
-    auto persistent_property_record = persistent_properties->add_properties();
-    persistent_property_record->set_name(name);
-    persistent_property_record->set_value(value);
-}
-
 Result<PersistentProperties> LoadPersistentPropertyFile() {
     auto file_contents = ReadPersistentPropertyFile();
     if (!file_contents.ok()) return file_contents.error();
@@ -266,8 +266,57 @@ PersistentProperties LoadPersistentProperties() {
         }
     }
 
-    return *persistent_properties;
+    // loop over to find all staged props
+    auto const staged_prefix = std::string_view("next_boot.");
+    auto staged_props = std::unordered_map<std::string, std::string>();
+    for (const auto& property_record : persistent_properties->properties()) {
+        auto const& prop_name = property_record.name();
+        auto const& prop_value = property_record.value();
+        if (StartsWith(prop_name, staged_prefix)) {
+            auto actual_prop_name = prop_name.substr(staged_prefix.size());
+            staged_props[actual_prop_name] = prop_value;
+        }
+    }
+
+    if (staged_props.empty()) {
+        return *persistent_properties;
+    }
+
+    // if has staging, apply staging and perserve the original prop order
+    PersistentProperties updated_persistent_properties;
+    for (const auto& property_record : persistent_properties->properties()) {
+        auto const& prop_name = property_record.name();
+        auto const& prop_value = property_record.value();
+
+        // don't include staged props anymore
+        if (StartsWith(prop_name, staged_prefix)) {
+            continue;
+        }
+
+        auto iter = staged_props.find(prop_name);
+        if (iter != staged_props.end()) {
+            AddPersistentProperty(prop_name, iter->second, &updated_persistent_properties);
+            staged_props.erase(iter);
+        } else {
+            AddPersistentProperty(prop_name, prop_value, &updated_persistent_properties);
+        }
+    }
+
+    // add any additional staged props
+    for (auto const& [prop_name, prop_value] : staged_props) {
+        AddPersistentProperty(prop_name, prop_value, &updated_persistent_properties);
+    }
+
+    // write current updated persist prop file
+    auto result = WritePersistentPropertyFile(updated_persistent_properties);
+    if (!result.ok()) {
+        LOG(ERROR) << "Could not store persistent property: " << result.error();
+    }
+
+    return updated_persistent_properties;
 }
 
+
+
 }  // namespace init
 }  // namespace android
diff --git a/init/persistent_properties.h b/init/persistent_properties.h
index 7e9d4387a602..11083da9e183 100644
--- a/init/persistent_properties.h
+++ b/init/persistent_properties.h
@@ -25,8 +25,6 @@
 namespace android {
 namespace init {
 
-void AddPersistentProperty(const std::string& name, const std::string& value,
-                           PersistentProperties* persistent_properties);
 PersistentProperties LoadPersistentProperties();
 void WritePersistentProperty(const std::string& name, const std::string& value);
 PersistentProperties LoadPersistentPropertiesFromMemory();
diff --git a/init/persistent_properties_test.cpp b/init/persistent_properties_test.cpp
index e5d26dbefc52..576305081d52 100644
--- a/init/persistent_properties_test.cpp
+++ b/init/persistent_properties_test.cpp
@@ -178,5 +178,37 @@ TEST(persistent_properties, RejectNonPersistProperty) {
     EXPECT_FALSE(it == read_back_properties.properties().end());
 }
 
+TEST(persistent_properties, StagedPersistProperty) {
+    TemporaryFile tf;
+    ASSERT_TRUE(tf.fd != -1);
+    persistent_property_filename = tf.path;
+
+    std::vector<std::pair<std::string, std::string>> persistent_properties = {
+        {"persist.sys.locale", "en-US"},
+        {"next_boot.persist.test.numbers", "54321"},
+        {"persist.sys.timezone", "America/Los_Angeles"},
+        {"persist.test.numbers", "12345"},
+        {"next_boot.persist.test.extra", "abc"},
+    };
+
+    ASSERT_RESULT_OK(
+            WritePersistentPropertyFile(VectorToPersistentProperties(persistent_properties)));
+
+    std::vector<std::pair<std::string, std::string>> expected_persistent_properties = {
+        {"persist.sys.locale", "en-US"},
+        {"persist.sys.timezone", "America/Los_Angeles"},
+        {"persist.test.numbers", "54321"},
+        {"persist.test.extra", "abc"},
+    };
+
+    // lock down that staged props are applied
+    auto first_read_back_properties = LoadPersistentProperties();
+    CheckPropertiesEqual(expected_persistent_properties, first_read_back_properties);
+
+    // lock down that other props are not overwritten
+    auto second_read_back_properties = LoadPersistentProperties();
+    CheckPropertiesEqual(expected_persistent_properties, second_read_back_properties);
+}
+
 }  // namespace init
 }  // namespace android
diff --git a/init/property_service.cpp b/init/property_service.cpp
index b08a904a7c6a..87fc4c706db8 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1396,33 +1396,12 @@ static void HandleInitSocket() {
     switch (init_message.msg_case()) {
         case InitMessage::kLoadPersistentProperties: {
             load_override_properties();
-            // Read persistent properties after all default values have been loaded.
-            // Apply staged and persistent properties
-            bool has_staged_prop = false;
-            auto const staged_prefix = std::string_view("next_boot.");
 
             auto persistent_properties = LoadPersistentProperties();
             for (const auto& property_record : persistent_properties.properties()) {
                 auto const& prop_name = property_record.name();
                 auto const& prop_value = property_record.value();
-
-                if (StartsWith(prop_name, staged_prefix)) {
-                  has_staged_prop = true;
-                  auto actual_prop_name = prop_name.substr(staged_prefix.size());
-                  InitPropertySet(actual_prop_name, prop_value);
-                } else {
-                  InitPropertySet(prop_name, prop_value);
-                }
-            }
-
-            // Update persist prop file if there are staged props
-            if (has_staged_prop) {
-                PersistentProperties props = LoadPersistentPropertiesFromMemory();
-                // write current updated persist prop file
-                auto result = WritePersistentPropertyFile(props);
-                if (!result.ok()) {
-                    LOG(ERROR) << "Could not store persistent property: " << result.error();
-                }
+                InitPropertySet(prop_name, prop_value);
             }
 
             // Apply debug ramdisk special settings after persistent properties are loaded.

From e5a343b1af1abaf27c56ec69c71b79b0e80d3102 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 23 Oct 2023 20:10:37 -0700
Subject: [PATCH 0514/1487] libsnapshot: Add Parser base class

Add in Parser base class and refactor code to work with it. Base class
will have ops() method which returns a vector of v3 operations.
v2_parser translates it's v2 operations to v3 operations with this
method.

Bug: 307452468
Test: Test with critical OTA paths?
Change-Id: I52d0d0554973714189a6e1013d026f96503238b6
---
 .../include/libsnapshot/cow_reader.h          |  1 -
 .../libsnapshot_cow/cow_reader.cpp            | 76 ++++++++-----------
 .../libsnapshot_cow/inspect_cow.cpp           |  4 +-
 .../libsnapshot/libsnapshot_cow/parser_base.h | 53 +++++++++++++
 .../libsnapshot/libsnapshot_cow/parser_v2.cpp | 57 ++++++++++++--
 .../libsnapshot/libsnapshot_cow/parser_v2.h   | 25 +++---
 .../libsnapshot/libsnapshot_cow/writer_v2.cpp |  5 +-
 .../user-space-merge/snapuserd_core.cpp       |  2 +-
 8 files changed, 151 insertions(+), 72 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index debaf3683c9f..4cbcab137570 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -185,7 +185,6 @@ class CowReader final : public ICowReader {
     std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
     ReaderFlags reader_flag_;
     bool is_merge_{};
-    uint8_t compression_type_ = kCowCompressNone;
 };
 
 // Though this function takes in a CowHeaderV3, the struct could be populated as a v1/v2 CowHeader.
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 3b84c95ccb2e..6f1854d0a245 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -28,7 +28,6 @@
 #include <zlib.h>
 
 #include "cow_decompress.h"
-#include "libsnapshot/cow_format.h"
 #include "parser_v2.h"
 
 namespace android {
@@ -85,7 +84,6 @@ std::unique_ptr<CowReader> CowReader::CloneCowReader() {
     cow->data_loc_ = data_loc_;
     cow->block_pos_index_ = block_pos_index_;
     cow->is_merge_ = is_merge_;
-    cow->compression_type_ = compression_type_;
     return cow;
 }
 
@@ -104,11 +102,14 @@ bool CowReader::InitForMerge(android::base::unique_fd&& fd) {
         PLOG(ERROR) << "lseek header failed";
         return false;
     }
-    if (!android::base::ReadFully(fd_, &header_, sizeof(header_))) {
+
+    CHECK_GE(header_.prefix.header_size, sizeof(CowHeader));
+    CHECK_LE(header_.prefix.header_size, sizeof(header_));
+
+    if (!android::base::ReadFully(fd_, &header_, header_.prefix.header_size)) {
         PLOG(ERROR) << "read header failed";
         return false;
     }
-
     return true;
 }
 
@@ -124,52 +125,35 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
         return false;
     }
 
-    CowParserV2 parser;
-    if (!parser.Parse(fd, header_, label)) {
-        return false;
+    std::unique_ptr<CowParserBase> parser;
+    switch (header_.prefix.major_version) {
+        case 1:
+        case 2:
+            parser = std::make_unique<CowParserV2>();
+            break;
+        case 3:
+            break;
+        default:
+            LOG(ERROR) << "Unknown version: " << header_.prefix.major_version;
+            return false;
     }
 
-    footer_ = parser.footer();
-    fd_size_ = parser.fd_size();
-    last_label_ = parser.last_label();
-    data_loc_ = parser.data_loc();
-    ops_ = std::make_shared<std::vector<CowOperation>>(parser.ops()->size());
-
-    // Translate the operation buffer from on disk to in memory
-    for (size_t i = 0; i < parser.ops()->size(); i++) {
-        const auto& v2_op = parser.ops()->at(i);
-
-        auto& new_op = ops_->at(i);
-        new_op.type = v2_op.type;
-        new_op.data_length = v2_op.data_length;
-
-        if (v2_op.new_block > std::numeric_limits<uint32_t>::max()) {
-            LOG(ERROR) << "Out-of-range new block in COW op: " << v2_op;
-            return false;
-        }
-        new_op.new_block = v2_op.new_block;
+    if (!parser->Parse(fd, header_, label)) {
+        return false;
+    }
 
-        uint64_t source_info = v2_op.source;
-        if (new_op.type != kCowLabelOp) {
-            source_info &= kCowOpSourceInfoDataMask;
-            if (source_info != v2_op.source) {
-                LOG(ERROR) << "Out-of-range source value in COW op: " << v2_op;
-                return false;
-            }
-        }
-        if (v2_op.compression != kCowCompressNone) {
-            if (compression_type_ == kCowCompressNone) {
-                compression_type_ = v2_op.compression;
-            } else if (compression_type_ != v2_op.compression) {
-                LOG(ERROR) << "COW has mixed compression types which is not supported;"
-                           << " previously saw " << compression_type_ << ", got "
-                           << v2_op.compression << ", op: " << v2_op;
-                return false;
-            }
-        }
-        new_op.source_info = source_info;
+    TranslatedCowOps ops_info;
+    if (!parser->Translate(&ops_info)) {
+        return false;
     }
 
+    header_ = ops_info.header;
+    ops_ = std::move(ops_info.ops);
+    footer_ = parser->footer();
+    fd_size_ = parser->fd_size();
+    last_label_ = parser->last_label();
+    data_loc_ = parser->data_loc();
+
     // If we're resuming a write, we're not ready to merge
     if (label.has_value()) return true;
     return PrepMergeOps();
@@ -664,7 +648,7 @@ class CowDataStream final : public IByteStream {
 };
 
 uint8_t CowReader::GetCompressionType() {
-    return compression_type_;
+    return header_.compression_algorithm;
 }
 
 ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_size,
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
index a29146985142..76509de78961 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
@@ -74,13 +74,13 @@ static void ShowBad(CowReader& reader, const CowOperation* op) {
     }
 }
 
-static bool ShowRawOpStreamV2(borrowed_fd fd, const CowHeader& header) {
+static bool ShowRawOpStreamV2(borrowed_fd fd, const CowHeaderV3& header) {
     CowParserV2 parser;
     if (!parser.Parse(fd, header)) {
         LOG(ERROR) << "v2 parser failed";
         return false;
     }
-    for (const auto& op : *parser.ops()) {
+    for (const auto& op : *parser.get_v2ops()) {
         std::cout << op << "\n";
         if (auto iter = parser.data_loc()->find(op.new_block); iter != parser.data_loc()->end()) {
             std::cout << "    data loc: " << iter->second << "\n";
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h
new file mode 100644
index 000000000000..278340740bd9
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h
@@ -0,0 +1,53 @@
+//
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#pragma once
+
+#include <optional>
+#include <unordered_map>
+
+#include <android-base/unique_fd.h>
+#include <libsnapshot/cow_format.h>
+
+namespace android {
+namespace snapshot {
+
+struct TranslatedCowOps {
+    CowHeaderV3 header;
+    std::shared_ptr<std::vector<CowOperationV3>> ops;
+};
+
+class CowParserBase {
+  public:
+    virtual ~CowParserBase() = default;
+
+    virtual bool Parse(android::base::borrowed_fd fd, const CowHeaderV3& header,
+                       std::optional<uint64_t> label = {}) = 0;
+    virtual bool Translate(TranslatedCowOps* out) = 0;
+    virtual std::optional<CowFooter> footer() const { return std::nullopt; }
+    virtual std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const = 0;
+
+    uint64_t fd_size() const { return fd_size_; }
+    const std::optional<uint64_t>& last_label() const { return last_label_; }
+
+  protected:
+    CowHeaderV3 header_ = {};
+    uint64_t fd_size_;
+    std::optional<uint64_t> last_label_;
+};
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
index 8f2031783f5f..51489c83a91e 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
@@ -18,12 +18,14 @@
 #include <android-base/file.h>
 #include <android-base/logging.h>
 
+#include <libsnapshot/cow_format.h>
+
 namespace android {
 namespace snapshot {
 
 using android::base::borrowed_fd;
 
-bool CowParserV2::Parse(borrowed_fd fd, const CowHeader& header, std::optional<uint64_t> label) {
+bool CowParserV2::Parse(borrowed_fd fd, const CowHeaderV3& header, std::optional<uint64_t> label) {
     auto pos = lseek(fd.get(), 0, SEEK_END);
     if (pos < 0) {
         PLOG(ERROR) << "lseek end failed";
@@ -47,8 +49,7 @@ bool CowParserV2::Parse(borrowed_fd fd, const CowHeader& header, std::optional<u
         return false;
     }
 
-    if ((header_.prefix.major_version > kCowVersionMajor) ||
-        (header_.prefix.minor_version != kCowVersionMinor)) {
+    if (header_.prefix.major_version > 2 || header_.prefix.minor_version != 0) {
         LOG(ERROR) << "Header version mismatch, "
                    << "major version: " << header_.prefix.major_version
                    << ", expected: " << kCowVersionMajor
@@ -190,11 +191,57 @@ bool CowParserV2::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
         }
     }
 
-    ops_ = ops_buffer;
-    ops_->shrink_to_fit();
+    v2_ops_ = ops_buffer;
+    v2_ops_->shrink_to_fit();
     data_loc_ = data_loc;
     return true;
 }
 
+bool CowParserV2::Translate(TranslatedCowOps* out) {
+    out->ops = std::make_shared<std::vector<CowOperationV3>>(v2_ops_->size());
+
+    // Translate the operation buffer from on disk to in memory
+    for (size_t i = 0; i < out->ops->size(); i++) {
+        const auto& v2_op = v2_ops_->at(i);
+
+        auto& new_op = out->ops->at(i);
+        new_op.type = v2_op.type;
+        new_op.data_length = v2_op.data_length;
+
+        if (v2_op.new_block > std::numeric_limits<uint32_t>::max()) {
+            LOG(ERROR) << "Out-of-range new block in COW op: " << v2_op;
+            return false;
+        }
+        new_op.new_block = v2_op.new_block;
+
+        uint64_t source_info = v2_op.source;
+        if (new_op.type != kCowLabelOp) {
+            source_info &= kCowOpSourceInfoDataMask;
+            if (source_info != v2_op.source) {
+                LOG(ERROR) << "Out-of-range source value in COW op: " << v2_op;
+                return false;
+            }
+        }
+        if (v2_op.compression != kCowCompressNone) {
+            if (header_.compression_algorithm == kCowCompressNone) {
+                header_.compression_algorithm = v2_op.compression;
+            } else if (header_.compression_algorithm != v2_op.compression) {
+                LOG(ERROR) << "COW has mixed compression types which is not supported;"
+                           << " previously saw " << header_.compression_algorithm << ", got "
+                           << v2_op.compression << ", op: " << v2_op;
+                return false;
+            }
+        }
+        new_op.source_info = source_info;
+    }
+
+    out->header = header_;
+    return true;
+}
+
+std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> CowParserV2::data_loc() const {
+    return data_loc_;
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
index f51ff88cb15a..a70c780e4143 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
@@ -17,36 +17,31 @@
 
 #include <memory>
 #include <optional>
-#include <unordered_map>
 #include <vector>
 
 #include <android-base/unique_fd.h>
 #include <libsnapshot/cow_format.h>
+#include "parser_base.h"
 
 namespace android {
 namespace snapshot {
 
-class CowParserV2 {
+class CowParserV2 final : public CowParserBase {
   public:
-    bool Parse(android::base::borrowed_fd fd, const CowHeader& header,
-               std::optional<uint64_t> label = {});
+    bool Parse(android::base::borrowed_fd fd, const CowHeaderV3& header,
+               std::optional<uint64_t> label = {}) override;
+    bool Translate(TranslatedCowOps* out) override;
+    std::optional<CowFooter> footer() const override { return footer_; }
 
     const CowHeader& header() const { return header_; }
-    const std::optional<CowFooter>& footer() const { return footer_; }
-    std::shared_ptr<std::vector<CowOperationV2>> ops() { return ops_; }
-    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const { return data_loc_; }
-    uint64_t fd_size() const { return fd_size_; }
-    const std::optional<uint64_t>& last_label() const { return last_label_; }
+    std::shared_ptr<std::vector<CowOperationV2>> get_v2ops() { return v2_ops_; }
+    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const override;
 
   private:
+    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
     bool ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label);
-
-    CowHeader header_ = {};
+    std::shared_ptr<std::vector<CowOperationV2>> v2_ops_;
     std::optional<CowFooter> footer_;
-    std::shared_ptr<std::vector<CowOperationV2>> ops_;
-    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
-    uint64_t fd_size_;
-    std::optional<uint64_t> last_label_;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index 83a9b1b2230f..37324c767835 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -273,10 +273,11 @@ bool CowWriterV2::OpenForAppend(uint64_t label) {
     if (!ReadCowHeader(fd_, &header_v3)) {
         return false;
     }
+
     header_ = header_v3;
 
     CowParserV2 parser;
-    if (!parser.Parse(fd_, header_, {label})) {
+    if (!parser.Parse(fd_, header_v3, {label})) {
         return false;
     }
     if (header_.prefix.major_version > 2) {
@@ -292,7 +293,7 @@ bool CowWriterV2::OpenForAppend(uint64_t label) {
     footer_.op.num_ops = 0;
     InitPos();
 
-    for (const auto& op : *parser.ops()) {
+    for (const auto& op : *parser.get_v2ops()) {
         AddOperation(op);
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 8208d67c8c5a..950d7719d7ba 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -112,7 +112,7 @@ bool SnapshotHandler::CommitMerge(int num_merge_ops) {
             return false;
         }
 
-        if (!android::base::WriteFully(cow_fd_, &header, sizeof(CowHeader))) {
+        if (!android::base::WriteFully(cow_fd_, &header, header.prefix.header_size)) {
             SNAP_PLOG(ERROR) << "Write to header failed";
             return false;
         }

From 875df3436db592a863e0e67697c7e878384faea2 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 10 Oct 2023 10:17:50 -0700
Subject: [PATCH 0515/1487] libsnapshot: Add Parser v3 + stub

previously upload patch broke build -> bug id: 308868619

This patch updates the unimplemnted pure virtual method data_loc()
Adding in parser v3 plus stub implementation.

Bug: 307452468
Test: th
Change-Id: I815a741b01c46a11a2e60f59305843ce8329a065
---
 fs_mgr/libsnapshot/Android.bp                 |  1 +
 .../libsnapshot/libsnapshot_cow/parser_v2.h   |  2 +-
 .../libsnapshot/libsnapshot_cow/parser_v3.cpp | 45 ++++++++++++++
 .../libsnapshot/libsnapshot_cow/parser_v3.h   | 60 +++++++++++++++++++
 4 files changed, 107 insertions(+), 1 deletion(-)
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
 create mode 100644 fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 6fad6626655e..ac58ba08f81c 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -198,6 +198,7 @@ cc_library_static {
         "libsnapshot_cow/cow_format.cpp",
         "libsnapshot_cow/cow_reader.cpp",
         "libsnapshot_cow/parser_v2.cpp",
+        "libsnapshot_cow/parser_v3.cpp",
         "libsnapshot_cow/snapshot_reader.cpp",
         "libsnapshot_cow/writer_base.cpp",
         "libsnapshot_cow/writer_v2.cpp",
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
index a70c780e4143..318a3ac14bb5 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
@@ -21,7 +21,7 @@
 
 #include <android-base/unique_fd.h>
 #include <libsnapshot/cow_format.h>
-#include "parser_base.h"
+#include <libsnapshot_cow/parser_base.h>
 
 namespace android {
 namespace snapshot {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
new file mode 100644
index 000000000000..923ab645529e
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
@@ -0,0 +1,45 @@
+// Copyright (C) 2023 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 "parser_v3.h"
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+
+#include <libsnapshot/cow_format.h>
+
+namespace android {
+namespace snapshot {
+
+using android::base::borrowed_fd;
+
+bool CowParserV3::Parse(borrowed_fd fd, const CowHeaderV3& header, std::optional<uint64_t> label) {
+    LOG(ERROR) << "this function should never be called";
+    if (fd.get() || sizeof(header) > 0 || label) return false;
+    return false;
+}
+
+bool CowParserV3::ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label) {
+    LOG(ERROR) << "this function should never be called";
+    if (fd.get() || label) return false;
+    return false;
+}
+
+bool CowParserV3::Translate(TranslatedCowOps* out) {
+    out->ops = ops_;
+    out->header = header_;
+    return true;
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
new file mode 100644
index 000000000000..5760cf2baff1
--- /dev/null
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
@@ -0,0 +1,60 @@
+// Copyright (C) 2023 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.
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include <stdint.h>
+
+#include <memory>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+#include <android-base/unique_fd.h>
+#include <libsnapshot/cow_format.h>
+#include <libsnapshot_cow/parser_base.h>
+
+namespace android {
+namespace snapshot {
+
+class CowParserV3 final : public CowParserBase {
+  public:
+    bool Parse(android::base::borrowed_fd fd, const CowHeaderV3& header,
+               std::optional<uint64_t> label = {}) override;
+    bool Translate(TranslatedCowOps* out) override;
+    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const override {
+        return nullptr;
+    };
+
+  private:
+    bool ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label);
+
+    CowHeaderV3 header_ = {};
+    std::shared_ptr<std::vector<CowOperationV3>> ops_;
+};
+
+}  // namespace snapshot
+}  // namespace android

From ac8b5bd0bc7f48ae7fe6156f8a20732f696ea143 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Thu, 2 Nov 2023 12:55:46 -0700
Subject: [PATCH 0516/1487] init: Fix a compiler warning

Fix the following compiler warning:

system/core/init/init.cpp:754:57: warning: ISO C++ requires field designators to be specified in declaration order; field '' will be initialized after field 'sa_flags' [-Wreorder-init-list]
    const struct sigaction act { .sa_handler = SIG_DFL, .sa_flags = SA_NOCLDSTOP };
                                                        ^~~~~~~~~~~~~~~~~~~~~~~~
system/core/init/init.cpp:754:34: note: previous initialization for field '' is here
    const struct sigaction act { .sa_handler = SIG_DFL, .sa_flags = SA_NOCLDSTOP };
                                 ^~~~~~~~~~~~~~~~~~~~~

Change-Id: I29e2d51dfdff85212a33eebfd51b241268cdfe9a
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 init/init.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/init.cpp b/init/init.cpp
index 40e21696fbdf..19f34dabb284 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -751,7 +751,7 @@ static void UnblockSignals() {
 static void InstallSignalFdHandler(Epoll* epoll) {
     // Applying SA_NOCLDSTOP to a defaulted SIGCHLD handler prevents the signalfd from receiving
     // SIGCHLD when a child process stops or continues (b/77867680#comment9).
-    const struct sigaction act { .sa_handler = SIG_DFL, .sa_flags = SA_NOCLDSTOP };
+    const struct sigaction act { .sa_flags = SA_NOCLDSTOP, .sa_handler = SIG_DFL };
     sigaction(SIGCHLD, &act, nullptr);
 
     sigset_t mask;

From 4844092066bb4e849d7dff3675d4d4a306df9b33 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Thu, 2 Nov 2023 13:02:57 -0700
Subject: [PATCH 0517/1487] init/host_init_verifier: Fix a compiler warning

Fix the following compiler warning:

//system/core/init:host_init_verifier clang++ host_init_verifier.cp
system/core/init/host_init_verifier.cpp:112:9: warning: ISO C++ requires field designators to be specified in declaration order; field 'pw_shell' will be initialized after field 'pw_uid' [-Wreorder-init-list]
        .pw_uid = 0,
        ^~~~~~~~~~~
system/core/init/host_init_verifier.cpp:111:21: note: previous initialization for field 'pw_shell' is here
        .pw_shell = static_shell,
                    ^~~~~~~~~~~~

Change-Id: I930c668d7fb1d12ebe9307b1549776da71a9a95a
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 init/host_init_verifier.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/host_init_verifier.cpp b/init/host_init_verifier.cpp
index f070776ecfd5..662185c44745 100644
--- a/init/host_init_verifier.cpp
+++ b/init/host_init_verifier.cpp
@@ -108,9 +108,9 @@ passwd* getpwnam(const char* login) {  // NOLINT: implementing bad function.
     static passwd static_passwd = {
         .pw_name = static_name,
         .pw_dir = static_dir,
-        .pw_shell = static_shell,
         .pw_uid = 0,
         .pw_gid = 0,
+        .pw_shell = static_shell,
     };
 
     for (size_t n = 0; n < android_id_count; ++n) {

From 7ce6453aa8eda688580f3a28e260554ce930d96f Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Wed, 1 Nov 2023 14:29:07 -0700
Subject: [PATCH 0518/1487] init: Fix a bug in the WaitToBeReaped() logging
 code

Only report status information for the processes that are still running.
Additionally, make the logging output look better by starting the
process information from /proc start on a new line.

Fixes: ea595ba2a05a ("init: Log more information if stopping times out")
Change-Id: I3c882c364f11278087a78efb7a8e8fee8e582417
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 init/sigchld_handler.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/init/sigchld_handler.cpp b/init/sigchld_handler.cpp
index f8c501f8a832..0901a960fb42 100644
--- a/init/sigchld_handler.cpp
+++ b/init/sigchld_handler.cpp
@@ -139,10 +139,10 @@ void WaitToBeReaped(const std::vector<pid_t>& pids, std::chrono::milliseconds ti
     }
     LOG(INFO) << "Waiting for " << pids.size() << " pids to be reaped took " << t << " with "
               << alive_pids.size() << " of them still running";
-    for (pid_t pid : pids) {
+    for (pid_t pid : alive_pids) {
         std::string status = "(no-such-pid)";
         ReadFileToString(StringPrintf("/proc/%d/status", pid), &status);
-        LOG(INFO) << "Still running: " << pid << ' ' << status;
+        LOG(INFO) << "Still running: " << pid << '\n' << status;
     }
 }
 

From f3b98ce0d4ce9f83fefb33a5601b3f9e5f67a8d8 Mon Sep 17 00:00:00 2001
From: Yifan Hong <elsk@google.com>
Date: Thu, 2 Nov 2023 13:12:22 -0700
Subject: [PATCH 0519/1487] healthd: Delete health@2.0-service.

Health 2.0 is deprecated.

Bug: 308450739
Test: TH
Change-Id: Ifcd83b1b8c8e8b36eec5006c2d75ba60927eb915
---
 healthd/Android.bp                            | 38 ------------------
 healthd/HealthServiceDefault.cpp              | 39 -------------------
 .../android.hardware.health@2.0-service.rc    |  6 ---
 3 files changed, 83 deletions(-)
 delete mode 100644 healthd/HealthServiceDefault.cpp
 delete mode 100644 healthd/android.hardware.health@2.0-service.rc

diff --git a/healthd/Android.bp b/healthd/Android.bp
index 235303fd32a7..eb366a5a2671 100644
--- a/healthd/Android.bp
+++ b/healthd/Android.bp
@@ -100,44 +100,6 @@ cc_library_static {
     ],
 }
 
-cc_defaults {
-    name: "android.hardware.health@2.0-service_defaults",
-
-    cflags: [
-        "-Wall",
-        "-Werror",
-    ],
-
-    static_libs: [
-        "android.hardware.health@2.0-impl",
-        "android.hardware.health@1.0-convert",
-        "libhealthservice",
-        "libhealthstoragedefault",
-        "libbatterymonitor",
-    ],
-
-    shared_libs: [
-        "libbase",
-        "libcutils",
-        "libhidlbase",
-        "liblog",
-        "libutils",
-        "android.hardware.health@2.0",
-    ],
-}
-
-cc_binary {
-    name: "android.hardware.health@2.0-service",
-    defaults: ["android.hardware.health@2.0-service_defaults"],
-
-    vendor: true,
-    relative_install_path: "hw",
-    init_rc: ["android.hardware.health@2.0-service.rc"],
-    srcs: [
-        "HealthServiceDefault.cpp",
-    ],
-}
-
 cc_library_static {
     name: "libhealthd_charger_nops",
     recovery_available: true,
diff --git a/healthd/HealthServiceDefault.cpp b/healthd/HealthServiceDefault.cpp
deleted file mode 100644
index 89ecc2fa4247..000000000000
--- a/healthd/HealthServiceDefault.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2017 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 <health2/service.h>
-#include <healthd/healthd.h>
-
-void healthd_board_init(struct healthd_config*) {
-    // Implementation-defined init logic goes here.
-    // 1. config->periodic_chores_interval_* variables
-    // 2. config->battery*Path variables
-    // 3. config->energyCounter. In this implementation, energyCounter is not defined.
-
-    // use defaults
-}
-
-int healthd_board_battery_update(struct android::BatteryProperties*) {
-    // Implementation-defined update logic goes here. An implementation
-    // can make modifications to prop before broadcasting it to all callbacks.
-
-    // return 0 to log periodic polled battery status to kernel log
-    return 0;
-}
-
-int main() {
-    return health_service_main();
-}
diff --git a/healthd/android.hardware.health@2.0-service.rc b/healthd/android.hardware.health@2.0-service.rc
deleted file mode 100644
index 762771e5e023..000000000000
--- a/healthd/android.hardware.health@2.0-service.rc
+++ /dev/null
@@ -1,6 +0,0 @@
-service health-hal-2-0 /vendor/bin/hw/android.hardware.health@2.0-service
-    class hal
-    user system
-    group system
-    capabilities WAKE_ALARM BLOCK_SUSPEND
-    file /dev/kmsg w

From ee35a8184cd4f7e07b416e0e7422c4f1feea3600 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 16 Oct 2023 19:52:48 -0700
Subject: [PATCH 0520/1487] libsnapshot: Parser v3 implementation

Also adds a test for CowWriterV3 + CowParserV3.

Bug: 307452468
Test: read a header written by v3 writer
Change-Id: I77cf048604c82a010cfdbfb38d0f8beef597d112
---
 .../include/libsnapshot/cow_format.h          |  6 +-
 .../libsnapshot_cow/cow_reader.cpp            |  2 +
 .../libsnapshot/libsnapshot_cow/parser_v3.cpp | 57 ++++++++++++++++---
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 26 +++++++--
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 10 +---
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |  5 +-
 6 files changed, 81 insertions(+), 25 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index c9777a3ac10c..91e04252c155 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -99,8 +99,10 @@ struct CowHeaderV3 : public CowHeader {
     uint64_t sequence_buffer_offset;
     // Size, in bytes, of the CowResumePoint buffer.
     uint32_t resume_buffer_size;
-    // Size, in bytes, of the CowOperation buffer.
-    uint32_t op_buffer_size;
+    // Number of CowOperationV3 structs in the operation buffer, currently and total
+    // region size.
+    uint32_t op_count;
+    uint32_t op_count_max;
     // Compression Algorithm
     uint32_t compression_algorithm;
 } __attribute__((packed));
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 6f1854d0a245..c20194d285da 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -29,6 +29,7 @@
 
 #include "cow_decompress.h"
 #include "parser_v2.h"
+#include "parser_v3.h"
 
 namespace android {
 namespace snapshot {
@@ -132,6 +133,7 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
             parser = std::make_unique<CowParserV2>();
             break;
         case 3:
+            parser = std::make_unique<CowParserV3>();
             break;
         default:
             LOG(ERROR) << "Unknown version: " << header_.prefix.major_version;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
index 923ab645529e..23ddaae7194a 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
@@ -24,15 +24,58 @@ namespace snapshot {
 using android::base::borrowed_fd;
 
 bool CowParserV3::Parse(borrowed_fd fd, const CowHeaderV3& header, std::optional<uint64_t> label) {
-    LOG(ERROR) << "this function should never be called";
-    if (fd.get() || sizeof(header) > 0 || label) return false;
-    return false;
+    auto pos = lseek(fd.get(), 0, SEEK_END);
+    if (pos < 0) {
+        PLOG(ERROR) << "lseek end failed";
+        return false;
+    }
+    fd_size_ = pos;
+    header_ = header;
+
+    if (header_.footer_size != 0) {
+        LOG(ERROR) << "Footer size isn't 0, read " << header_.footer_size;
+        return false;
+    }
+    if (header_.op_size != sizeof(CowOperationV3)) {
+        LOG(ERROR) << "Operation size unknown, read " << header_.op_size << ", expected "
+                   << sizeof(CowOperationV3);
+        return false;
+    }
+    if (header_.cluster_ops != 0) {
+        LOG(ERROR) << "Cluster ops not supported in v3";
+        return false;
+    }
+
+    if (header_.prefix.major_version != 3 || header_.prefix.minor_version != 0) {
+        LOG(ERROR) << "Header version mismatch, "
+                   << "major version: " << header_.prefix.major_version
+                   << ", expected: " << kCowVersionMajor
+                   << ", minor version: " << header_.prefix.minor_version
+                   << ", expected: " << kCowVersionMinor;
+        return false;
+    }
+
+    return ParseOps(fd, label);
 }
 
-bool CowParserV3::ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label) {
-    LOG(ERROR) << "this function should never be called";
-    if (fd.get() || label) return false;
-    return false;
+bool CowParserV3::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
+    ops_ = std::make_shared<std::vector<CowOperationV3>>();
+    ops_->resize(header_.op_count);
+
+    const off_t offset = header_.prefix.header_size + header_.buffer_size;
+    if (!android::base::ReadFullyAtOffset(fd, ops_->data(), ops_->size() * sizeof(CowOperationV3),
+                                          offset)) {
+        PLOG(ERROR) << "read ops failed";
+        return false;
+    }
+
+    // :TODO: sequence buffer & resume buffer follow
+    // Once we implement labels, we'll have to discard unused ops and adjust
+    // the header as needed.
+    CHECK(!label);
+
+    ops_->shrink_to_fit();
+    return true;
 }
 
 bool CowParserV3::Translate(TranslatedCowOps* out) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index cc8dd8360187..a07ced55c013 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -37,7 +37,7 @@ using testing::AssertionSuccess;
 namespace android {
 namespace snapshot {
 
-class CowOperationV3Test : public ::testing::Test {
+class CowTestV3 : public ::testing::Test {
   protected:
     virtual void SetUp() override {
         cow_ = std::make_unique<TemporaryFile>();
@@ -51,7 +51,7 @@ class CowOperationV3Test : public ::testing::Test {
     std::unique_ptr<TemporaryFile> cow_;
 };
 
-TEST_F(CowOperationV3Test, CowHeaderV2Test) {
+TEST_F(CowTestV3, CowHeaderV2Test) {
     CowOptions options;
     options.cluster_ops = 5;
     options.num_merge_ops = 1;
@@ -67,11 +67,27 @@ TEST_F(CowOperationV3Test, CowHeaderV2Test) {
 
     const auto& header = reader.GetHeader();
     ASSERT_EQ(header.prefix.magic, kCowMagicNumber);
-    ASSERT_EQ(header.prefix.major_version, kCowVersionMajor);
-    ASSERT_EQ(header.prefix.minor_version, kCowVersionMinor);
+    ASSERT_EQ(header.prefix.major_version, 2);
+    ASSERT_EQ(header.prefix.minor_version, 0);
     ASSERT_EQ(header.block_size, options.block_size);
     ASSERT_EQ(header.cluster_ops, options.cluster_ops);
 }
 
+TEST_F(CowTestV3, Header) {
+    CowOptions options;
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+    ASSERT_TRUE(writer->Finalize());
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    const auto& header = reader.GetHeader();
+    ASSERT_EQ(header.prefix.magic, kCowMagicNumber);
+    ASSERT_EQ(header.prefix.major_version, 3);
+    ASSERT_EQ(header.prefix.minor_version, 0);
+    ASSERT_EQ(header.block_size, options.block_size);
+    ASSERT_EQ(header.cluster_ops, 0);
+}
+
 }  // namespace snapshot
-}  // namespace android
\ No newline at end of file
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 5ae5f19b7a33..d69254ff42c1 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -78,7 +78,8 @@ void CowWriterV3::SetupHeaders() {
     // during COW size estimation
     header_.sequence_buffer_offset = 0;
     header_.resume_buffer_size = 0;
-    header_.op_buffer_size = 0;
+    header_.op_count = 0;
+    header_.op_count_max = 0;
     header_.compression_algorithm = kCowCompressNone;
     return;
 }
@@ -159,10 +160,6 @@ bool CowWriterV3::OpenForWrite() {
         LOG(ERROR) << "Header sync failed";
         return false;
     }
-
-    next_op_pos_ = 0;
-    next_data_pos_ = 0;
-
     return true;
 }
 
@@ -205,8 +202,7 @@ bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
 }
 
 bool CowWriterV3::Finalize() {
-    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
-    return false;
+    return Sync();
 }
 
 uint64_t CowWriterV3::GetCowSize() {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 2a88a12bca60..a0d7ab950304 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -46,12 +46,9 @@ class CowWriterV3 : public CowWriterBase {
   private:
     CowHeaderV3 header_{};
     CowCompression compression_;
+
     // in the case that we are using one thread for compression, we can store and re-use the same
     // compressor
-
-    uint64_t next_op_pos_ = 0;
-    uint64_t next_data_pos_ = 0;
-
     int num_compress_threads_ = 1;
 };
 

From 53bd5585e966808da40cf2f8fc5cab053623c654 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 23 Oct 2023 21:24:50 -0700
Subject: [PATCH 0521/1487] libsnapshot: Implement CowWriterV3::EmitzeroBlocks.

Add zero block operation to writer v3. We currently write this operation
to after the scratch space. Once resume point support is added we may
need to change this to write after the resume point. This CL only
supports zero blocks, so writeoperation does not take in data yet.

Bug: 307452468
Test: cow_api_test
Change-Id: I659b2e2e4f6e0d96e374ed29012318cc34b4158d
---
 .../include/libsnapshot/cow_reader.h          |  1 +
 .../include/libsnapshot/cow_writer.h          |  3 ++
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 31 ++++++++++++++
 .../libsnapshot/libsnapshot_cow/writer_base.h |  2 +
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 41 +++++++++++++++++--
 .../libsnapshot/libsnapshot_cow/writer_v3.h   | 10 ++++-
 6 files changed, 84 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index 4cbcab137570..755a3afa2af0 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -145,6 +145,7 @@ class CowReader final : public ICowReader {
                      size_t ignore_bytes = 0) override;
 
     CowHeader& GetHeader() override { return header_; }
+    const CowHeaderV3& header_v3() const { return header_; }
 
     bool GetRawBytes(const CowOperation* op, void* buffer, size_t len, size_t* read);
     bool GetRawBytes(uint64_t offset, void* buffer, size_t len, size_t* read);
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 3016e933b798..5b1e56c442ce 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -54,6 +54,9 @@ struct CowOptions {
 
     // Batch write cluster ops
     bool batch_write = false;
+
+    // Size of the cow operation buffer; used in v3 only.
+    uint32_t op_count_max = 0;
 };
 
 // Interface for writing to a snapuserd COW. All operations are ordered; merges
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index a07ced55c013..07c1d4fd8a64 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -89,5 +89,36 @@ TEST_F(CowTestV3, Header) {
     ASSERT_EQ(header.cluster_ops, 0);
 }
 
+TEST_F(CowTestV3, ZeroOp) {
+    CowOptions options;
+    options.op_count_max = 20;
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+    ASSERT_TRUE(writer->AddZeroBlocks(1, 2));
+    ASSERT_TRUE(writer->Finalize());
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+    ASSERT_EQ(reader.header_v3().op_count, 2);
+
+    auto iter = reader.GetOpIter();
+    ASSERT_NE(iter, nullptr);
+    ASSERT_FALSE(iter->AtEnd());
+
+    auto op = iter->Get();
+    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(op->data_length, 0);
+    ASSERT_EQ(op->new_block, 1);
+    ASSERT_EQ(op->source_info, 0);
+
+    iter->Next();
+    ASSERT_FALSE(iter->AtEnd());
+    op = iter->Get();
+
+    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(op->data_length, 0);
+    ASSERT_EQ(op->new_block, 2);
+    ASSERT_EQ(op->source_info, 0);
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
index 709b248e6f35..5274456f35c3 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_base.h
@@ -62,6 +62,8 @@ class CowWriterBase : public ICowWriter {
     bool InitFd();
     bool ValidateNewBlock(uint64_t new_block);
 
+    bool IsEstimating() const { return is_dev_null_; }
+
     CowOptions options_;
 
     android::base::unique_fd fd_;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index d69254ff42c1..ecbf97e2b598 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -155,6 +155,7 @@ bool CowWriterV3::OpenForWrite() {
             return false;
         }
     }
+    header_.op_count_max = options_.op_count_max;
 
     if (!Sync()) {
         LOG(ERROR) << "Header sync failed";
@@ -184,9 +185,17 @@ bool CowWriterV3::EmitXorBlocks(uint32_t new_block_start, const void* data, size
 }
 
 bool CowWriterV3::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
-    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
-    if (new_block_start && num_blocks) return false;
-    return false;
+    for (uint64_t i = 0; i < num_blocks; i++) {
+        CowOperationV3 op;
+        op.type = kCowZeroOp;
+        op.data_length = 0;
+        op.new_block = new_block_start + i;
+        op.source_info = 0;
+        if (!WriteOperation(op)) {
+            return false;
+        }
+    }
+    return true;
 }
 
 bool CowWriterV3::EmitLabel(uint64_t label) {
@@ -201,7 +210,33 @@ bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
     return false;
 }
 
+bool CowWriterV3::WriteOperation(const CowOperationV3& op) {
+    if (IsEstimating()) {
+        header_.op_count++;
+        header_.op_count_max++;
+        return true;
+    }
+
+    if (header_.op_count + 1 > header_.op_count_max) {
+        LOG(ERROR) << "Maximum number of ops reached: " << header_.op_count_max;
+        return false;
+    }
+
+    const off_t offset = GetOpOffset(header_.op_count);
+    if (!android::base::WriteFullyAtOffset(fd_, &op, sizeof(op), offset)) {
+        return false;
+    }
+
+    header_.op_count++;
+    return true;
+}
+
 bool CowWriterV3::Finalize() {
+    CHECK_GE(header_.prefix.header_size, sizeof(CowHeaderV3));
+    CHECK_LE(header_.prefix.header_size, sizeof(header_));
+    if (!android::base::WriteFullyAtOffset(fd_, &header_, header_.prefix.header_size, 0)) {
+        return false;
+    }
     return Sync();
 }
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index a0d7ab950304..8717c01878f9 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -14,7 +14,8 @@
 
 #pragma once
 
-#include <future>
+#include <android-base/logging.h>
+
 #include "writer_base.h"
 
 namespace android {
@@ -42,6 +43,13 @@ class CowWriterV3 : public CowWriterBase {
     void SetupHeaders();
     bool ParseOptions();
     bool OpenForWrite();
+    bool WriteOperation(const CowOperationV3& op);
+
+    off_t GetOpOffset(uint32_t op_index) const {
+        CHECK_LT(op_index, header_.op_count_max);
+        return header_.prefix.header_size + header_.buffer_size +
+               (op_index * sizeof(CowOperationV3));
+    }
 
   private:
     CowHeaderV3 header_{};

From 805d10fa16c8fc4bb15e2262d4c17af04b673ca6 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 30 Oct 2023 10:41:40 -0700
Subject: [PATCH 0522/1487] libsnapshot: Implement CowWriterV3:EmitBlocks

Add in replace ops to WriterV3 without compression support (will be
added in later). CowReader also has to be changed since we no longer
have a CowFooter (our checks need to be updated correspondingly).
We need next_data_pos_ to be pointed to after the operation buffer. This
section is appended to incrementally as we write replace + xor
operations

Test: cow_api_test
Change-Id: Ie979c72f842edd04337d900fd43dac8031207517
---
 .../libsnapshot_cow/cow_reader.cpp            |  4 +-
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 86 +++++++++++++++++++
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 49 +++++++++--
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |  7 +-
 4 files changed, 137 insertions(+), 9 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index c20194d285da..93c31bbc9991 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -601,8 +601,8 @@ bool CowReader::GetRawBytes(const CowOperation* op, void* buffer, size_t len, si
 
 bool CowReader::GetRawBytes(uint64_t offset, void* buffer, size_t len, size_t* read) {
     // Validate the offset, taking care to acknowledge possible overflow of offset+len.
-    if (offset < header_.prefix.header_size || offset >= fd_size_ - sizeof(CowFooter) ||
-        len >= fd_size_ || offset + len > fd_size_ - sizeof(CowFooter)) {
+    if (offset < header_.prefix.header_size || offset >= fd_size_ || offset + len > fd_size_ ||
+        len >= fd_size_) {
         LOG(ERROR) << "invalid data offset: " << offset << ", " << len << " bytes";
         return false;
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 07c1d4fd8a64..214eb1cd34a1 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -51,6 +51,11 @@ class CowTestV3 : public ::testing::Test {
     std::unique_ptr<TemporaryFile> cow_;
 };
 
+// Helper to check read sizes.
+static inline bool ReadData(CowReader& reader, const CowOperation* op, void* buffer, size_t size) {
+    return reader.ReadData(op, buffer, size) == size;
+}
+
 TEST_F(CowTestV3, CowHeaderV2Test) {
     CowOptions options;
     options.cluster_ops = 5;
@@ -120,5 +125,86 @@ TEST_F(CowTestV3, ZeroOp) {
     ASSERT_EQ(op->source_info, 0);
 }
 
+TEST_F(CowTestV3, ReplaceOp) {
+    CowOptions options;
+    options.op_count_max = 20;
+    options.scratch_space = false;
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+    std::string data = "This is some data, believe it";
+    data.resize(options.block_size, '\0');
+
+    ASSERT_TRUE(writer->AddRawBlocks(5, data.data(), data.size()));
+    ASSERT_TRUE(writer->Finalize());
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    const auto& header = reader.header_v3();
+    ASSERT_EQ(header.prefix.magic, kCowMagicNumber);
+    ASSERT_EQ(header.prefix.major_version, 3);
+    ASSERT_EQ(header.prefix.minor_version, kCowVersionMinor);
+    ASSERT_EQ(header.block_size, options.block_size);
+    ASSERT_EQ(header.op_count, 1);
+
+    auto iter = reader.GetOpIter();
+    ASSERT_NE(iter, nullptr);
+    ASSERT_FALSE(iter->AtEnd());
+
+    auto op = iter->Get();
+    std::string sink(data.size(), '\0');
+
+    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->data_length, 4096);
+    ASSERT_EQ(op->new_block, 5);
+    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
+    ASSERT_EQ(sink, data);
+}
+
+TEST_F(CowTestV3, ConsecutiveReplaceOp) {
+    CowOptions options;
+    options.op_count_max = 20;
+    options.scratch_space = false;
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+    std::string data;
+    data.resize(options.block_size * 5);
+    for (int i = 0; i < data.size(); i++) {
+        data[i] = char(rand() % 256);
+    }
+
+    ASSERT_TRUE(writer->AddRawBlocks(5, data.data(), data.size()));
+    ASSERT_TRUE(writer->Finalize());
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    const auto& header = reader.header_v3();
+    ASSERT_EQ(header.prefix.magic, kCowMagicNumber);
+    ASSERT_EQ(header.prefix.major_version, 3);
+    ASSERT_EQ(header.prefix.minor_version, kCowVersionMinor);
+    ASSERT_EQ(header.block_size, options.block_size);
+    ASSERT_EQ(header.op_count, 5);
+
+    auto iter = reader.GetOpIter();
+    ASSERT_NE(iter, nullptr);
+    ASSERT_FALSE(iter->AtEnd());
+
+    size_t i = 0;
+    std::string sink(data.size(), '\0');
+
+    while (!iter->AtEnd()) {
+        auto op = iter->Get();
+        ASSERT_EQ(op->type, kCowReplaceOp);
+        ASSERT_EQ(op->data_length, options.block_size);
+        ASSERT_EQ(op->new_block, 5 + i);
+        ASSERT_TRUE(
+                ReadData(reader, op, sink.data() + (i * options.block_size), options.block_size));
+        iter->Next();
+        i++;
+    }
+    ASSERT_EQ(sink, data);
+
+    ASSERT_EQ(i, 5);
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index ecbf97e2b598..d7aee139b89d 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -161,6 +161,9 @@ bool CowWriterV3::OpenForWrite() {
         LOG(ERROR) << "Header sync failed";
         return false;
     }
+    next_data_pos_ =
+            sizeof(CowHeaderV3) + header_.buffer_size + header_.op_count_max * sizeof(CowOperation);
+
     return true;
 }
 
@@ -171,10 +174,7 @@ bool CowWriterV3::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_
 }
 
 bool CowWriterV3::EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) {
-    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
-
-    if (new_block_start || data || size) return false;
-    return false;
+    return EmitBlocks(new_block_start, data, size, 0, 0, kCowReplaceOp);
 }
 
 bool CowWriterV3::EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size,
@@ -184,6 +184,33 @@ bool CowWriterV3::EmitXorBlocks(uint32_t new_block_start, const void* data, size
     return false;
 }
 
+bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t size,
+                             uint64_t old_block, uint16_t offset, uint8_t type) {
+    const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
+
+    // Placing here until we support XOR ops
+    CHECK_EQ(old_block, 0);
+    CHECK_EQ(offset, 0);
+
+    const size_t num_blocks = (size / header_.block_size);
+
+    for (size_t i = 0; i < num_blocks; i++) {
+        CowOperation op = {};
+        op.new_block = new_block_start + i;
+
+        op.type = type;
+        op.source_info = next_data_pos_;
+        op.data_length = static_cast<uint16_t>(header_.block_size);
+        if (!WriteOperation(op, iter, header_.block_size)) {
+            LOG(ERROR) << "AddRawBlocks: write failed";
+            return false;
+        }
+        iter += header_.block_size;
+    }
+
+    return true;
+}
+
 bool CowWriterV3::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
     for (uint64_t i = 0; i < num_blocks; i++) {
         CowOperationV3 op;
@@ -210,7 +237,7 @@ bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
     return false;
 }
 
-bool CowWriterV3::WriteOperation(const CowOperationV3& op) {
+bool CowWriterV3::WriteOperation(const CowOperationV3& op, const void* data, size_t size) {
     if (IsEstimating()) {
         header_.op_count++;
         header_.op_count_max++;
@@ -224,10 +251,20 @@ bool CowWriterV3::WriteOperation(const CowOperationV3& op) {
 
     const off_t offset = GetOpOffset(header_.op_count);
     if (!android::base::WriteFullyAtOffset(fd_, &op, sizeof(op), offset)) {
+        PLOG(ERROR) << "write failed for " << op << " at " << offset;
         return false;
     }
-
+    if (data && size > 0) {
+        if (!android::base::WriteFullyAtOffset(fd_, data, size, next_data_pos_)) {
+            PLOG(ERROR) << "write failed for data of size: " << size
+                        << " at offset: " << next_data_pos_;
+            return false;
+        }
+    }
     header_.op_count++;
+    next_data_pos_ += op.data_length;
+    next_op_pos_ += sizeof(CowOperationV3);
+
     return true;
 }
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 8717c01878f9..af71a030ccb3 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -43,7 +43,9 @@ class CowWriterV3 : public CowWriterBase {
     void SetupHeaders();
     bool ParseOptions();
     bool OpenForWrite();
-    bool WriteOperation(const CowOperationV3& op);
+    bool WriteOperation(const CowOperationV3& op, const void* data = nullptr, size_t size = 0);
+    bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
+                    uint16_t offset, uint8_t type);
 
     off_t GetOpOffset(uint32_t op_index) const {
         CHECK_LT(op_index, header_.op_count_max);
@@ -55,6 +57,9 @@ class CowWriterV3 : public CowWriterBase {
     CowHeaderV3 header_{};
     CowCompression compression_;
 
+    uint64_t next_op_pos_ = 0;
+    uint64_t next_data_pos_ = 0;
+
     // in the case that we are using one thread for compression, we can store and re-use the same
     // compressor
     int num_compress_threads_ = 1;

From a1014852a1d78c6a0aae7421aedd5f7e127c5db7 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 30 Oct 2023 13:50:09 -0700
Subject: [PATCH 0523/1487] libsnapshot: Implement CowWriterV3::EmitCopy

Add copy operation to v3 writer

Test: cow_api_test
Bug: 307452468
Change-Id: I5956084bfadff4536bad11f3683d639408a79892
---
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 36 +++++++++++++++++++
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 14 ++++++--
 2 files changed, 47 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 214eb1cd34a1..c5d7a025f380 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -206,5 +206,41 @@ TEST_F(CowTestV3, ConsecutiveReplaceOp) {
     ASSERT_EQ(i, 5);
 }
 
+TEST_F(CowTestV3, CopyOp) {
+    CowOptions options;
+    options.op_count_max = 100;
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+
+    ASSERT_TRUE(writer->AddCopy(10, 1000, 100));
+    ASSERT_TRUE(writer->Finalize());
+    ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    const auto& header = reader.GetHeader();
+    ASSERT_EQ(header.prefix.magic, kCowMagicNumber);
+    ASSERT_EQ(header.prefix.major_version, 3);
+    ASSERT_EQ(header.prefix.minor_version, kCowVersionMinor);
+    ASSERT_EQ(header.block_size, options.block_size);
+
+    auto iter = reader.GetOpIter();
+    ASSERT_NE(iter, nullptr);
+    ASSERT_FALSE(iter->AtEnd());
+
+    size_t i = 0;
+    while (!iter->AtEnd()) {
+        auto op = iter->Get();
+        ASSERT_EQ(op->type, kCowCopyOp);
+        ASSERT_EQ(op->data_length, 0);
+        ASSERT_EQ(op->new_block, 10 + i);
+        ASSERT_EQ(GetCowOpSourceInfoData(*op), 1000 + i);
+        iter->Next();
+        i += 1;
+    }
+
+    ASSERT_EQ(i, 100);
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index d7aee139b89d..aeb088d2e3bc 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -168,9 +168,17 @@ bool CowWriterV3::OpenForWrite() {
 }
 
 bool CowWriterV3::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks) {
-    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
-    if (new_block || old_block || num_blocks) return false;
-    return false;
+    for (size_t i = 0; i < num_blocks; i++) {
+        CowOperationV3 op = {};
+        op.type = kCowCopyOp;
+        op.new_block = new_block + i;
+        op.source_info = old_block + i;
+        if (!WriteOperation(op)) {
+            return false;
+        }
+    }
+
+    return true;
 }
 
 bool CowWriterV3::EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) {

From 6a974aecb91662947f84d6bdb14112d29631d999 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Fri, 3 Nov 2023 15:11:10 +0800
Subject: [PATCH 0524/1487] fs_mgr: Remove deprecated include path
 system/core/fs_mgr/include_fstab

These headers are exported by libfs_mgr and libfstab. Users should use
those libraries instead of directly referencing the include dir with
LOCAL_C_INCLUDES.

Bug: 293695109
Test: presubmit build pass
Change-Id: I888f59879f31fb75ddd5a0d243d4796415b57c7d
---
 fs_mgr/include_fstab | 1 -
 1 file changed, 1 deletion(-)
 delete mode 120000 fs_mgr/include_fstab

diff --git a/fs_mgr/include_fstab b/fs_mgr/include_fstab
deleted file mode 120000
index 728737fe589c..000000000000
--- a/fs_mgr/include_fstab
+++ /dev/null
@@ -1 +0,0 @@
-libfstab/include
\ No newline at end of file

From a99e7d84cb7d6b7eab5402800ea5ba71a8fe1fd5 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 27 Oct 2023 17:29:01 +0000
Subject: [PATCH 0525/1487] libprocessgroup: Use correct language for cgroups

Refer to cgroups and the cgroup hierarchy by their correct names.

Bug: 301871933
Change-Id: Iebb3eac9363018e923773292786d01977c8763ae
---
 .../include/processgroup/processgroup.h       |  3 ++-
 libprocessgroup/processgroup.cpp              | 20 +++++++++----------
 libprocessgroup/setup/cgroup_map_write.cpp    |  4 ++--
 libprocessgroup/task_profiles_test.cpp        |  2 +-
 4 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 5c43224ab321..a319c631f70f 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -26,7 +26,8 @@
 
 __BEGIN_DECLS
 
-static constexpr const char* CGROUPV2_CONTROLLER_NAME = "cgroup2";
+static constexpr const char* CGROUPV2_HIERARCHY_NAME = "cgroup2";
+[[deprecated]] static constexpr const char* CGROUPV2_CONTROLLER_NAME = "cgroup2";
 
 bool CgroupsAvailable();
 bool CgroupGetControllerPath(const std::string& cgroup_name, std::string* path);
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 3fa43f8adfc6..0b1794eb8138 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -213,7 +213,7 @@ static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, int pid) {
     return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
 }
 
-static int RemoveProcessGroup(const char* cgroup, uid_t uid, int pid, unsigned int retries) {
+static int RemoveCgroup(const char* cgroup, uid_t uid, int pid, unsigned int retries) {
     int ret = 0;
     auto uid_pid_path = ConvertUidPidToPath(cgroup, uid, pid);
 
@@ -233,7 +233,7 @@ static int RemoveProcessGroup(const char* cgroup, uid_t uid, int pid, unsigned i
     return ret;
 }
 
-static bool RemoveUidProcessGroups(const std::string& uid_path, bool empty_only) {
+static bool RemoveUidCgroups(const std::string& uid_path, bool empty_only) {
     std::unique_ptr<DIR, decltype(&closedir)> uid(opendir(uid_path.c_str()), closedir);
     bool empty = true;
     if (uid != NULL) {
@@ -279,7 +279,7 @@ void removeAllProcessGroupsInternal(bool empty_only) {
     std::vector<std::string> cgroups;
     std::string path, memcg_apps_path;
 
-    if (CgroupGetControllerPath(CGROUPV2_CONTROLLER_NAME, &path)) {
+    if (CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &path)) {
         cgroups.push_back(path);
     }
     if (CgroupGetMemcgAppsPath(&memcg_apps_path) && memcg_apps_path != path) {
@@ -302,7 +302,7 @@ void removeAllProcessGroupsInternal(bool empty_only) {
                 }
 
                 auto path = StringPrintf("%s/%s", cgroup_root_path.c_str(), dir->d_name);
-                if (!RemoveUidProcessGroups(path, empty_only)) {
+                if (!RemoveUidCgroups(path, empty_only)) {
                     LOG(VERBOSE) << "Skip removing " << path;
                     continue;
                 }
@@ -461,7 +461,7 @@ static int KillProcessGroup(uid_t uid, int initialPid, int signal, int retries)
 
     std::string hierarchy_root_path;
     if (CgroupsAvailable()) {
-        CgroupGetControllerPath(CGROUPV2_CONTROLLER_NAME, &hierarchy_root_path);
+        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
     }
     const char* cgroup = hierarchy_root_path.c_str();
 
@@ -511,12 +511,12 @@ static int KillProcessGroup(uid_t uid, int initialPid, int signal, int retries)
         }
 
         // 400 retries correspond to 2 secs max timeout
-        int err = RemoveProcessGroup(cgroup, uid, initialPid, 400);
+        int err = RemoveCgroup(cgroup, uid, initialPid, 400);
 
         if (isMemoryCgroupSupported() && UsePerAppMemcg()) {
             std::string memcg_apps_path;
             if (CgroupGetMemcgAppsPath(&memcg_apps_path) &&
-                RemoveProcessGroup(memcg_apps_path.c_str(), uid, initialPid, 400) < 0) {
+                RemoveCgroup(memcg_apps_path.c_str(), uid, initialPid, 400) < 0) {
                 return -1;
             }
         }
@@ -543,7 +543,7 @@ int killProcessGroupOnce(uid_t uid, int initialPid, int signal) {
 int sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
     std::string hierarchy_root_path;
     if (CgroupsAvailable()) {
-        CgroupGetControllerPath(CGROUPV2_CONTROLLER_NAME, &hierarchy_root_path);
+        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
     }
     const char* cgroup = hierarchy_root_path.c_str();
     return DoKillProcessGroupOnce(cgroup, uid, initialPid, signal);
@@ -617,7 +617,7 @@ int createProcessGroup(uid_t uid, int initialPid, bool memControl) {
     }
 
     std::string cgroup;
-    CgroupGetControllerPath(CGROUPV2_CONTROLLER_NAME, &cgroup);
+    CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &cgroup);
     return createProcessGroupInternal(uid, initialPid, cgroup, true);
 }
 
@@ -664,4 +664,4 @@ bool isProfileValidForProcess(const std::string& profile_name, int uid, int pid)
     }
 
     return tp->IsValidForProcess(uid, pid);
-}
\ No newline at end of file
+}
diff --git a/libprocessgroup/setup/cgroup_map_write.cpp b/libprocessgroup/setup/cgroup_map_write.cpp
index fbeedf99c84b..4e44c91befe0 100644
--- a/libprocessgroup/setup/cgroup_map_write.cpp
+++ b/libprocessgroup/setup/cgroup_map_write.cpp
@@ -212,7 +212,7 @@ static bool ReadDescriptorsFromFile(const std::string& file_name,
     if (root.isMember("Cgroups2")) {
         const Json::Value& cgroups2 = root["Cgroups2"];
         std::string root_path = cgroups2["Path"].asString();
-        MergeCgroupToDescriptors(descriptors, cgroups2, CGROUPV2_CONTROLLER_NAME, "", 2);
+        MergeCgroupToDescriptors(descriptors, cgroups2, CGROUPV2_HIERARCHY_NAME, "", 2);
 
         const Json::Value& childGroups = cgroups2["Controllers"];
         for (Json::Value::ArrayIndex i = 0; i < childGroups.size(); ++i) {
@@ -358,7 +358,7 @@ static bool SetupCgroup(const CgroupDescriptor& descriptor) {
     const format::CgroupController* controller = descriptor.controller();
 
     if (controller->version() == 2) {
-        if (!strcmp(controller->name(), CGROUPV2_CONTROLLER_NAME)) {
+        if (!strcmp(controller->name(), CGROUPV2_HIERARCHY_NAME)) {
             return MountV2CgroupController(descriptor);
         } else {
             return ActivateV2CgroupController(descriptor);
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index 99d819a7cc4c..b17e695e562b 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -116,7 +116,7 @@ class ProfileAttributeMock : public IProfileAttribute {
     }
     bool GetPathForTask(int tid, std::string* path) const override {
 #ifdef __ANDROID__
-        CHECK(CgroupGetControllerPath(CGROUPV2_CONTROLLER_NAME, path));
+        CHECK(CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, path));
         CHECK_GT(path->length(), 0);
         if (path->rbegin()[0] != '/') {
             *path += "/";

From 4d0d285926b04d5fbe8747627026a32a60b9e3fb Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 27 Oct 2023 23:44:03 +0000
Subject: [PATCH 0526/1487] libprocessgroup: Convert incorrect PLOGs to LOGs

PLOG depends on errno being set to a useful value, otherwise it will
print a meaningless error string. A few PLOG call sites occur where
either errno is not set at all, or it is set only some of the time where
there are already PLOG calls closer to where the error occurs. Convert
these PLOG calls to LOG.

Bug: 301871933
Change-Id: Ifa6bd2401f9dd9b84b2506e886336e89bac81bb1
---
 libprocessgroup/processgroup.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 0b1794eb8138..9af2682dd904 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -129,7 +129,7 @@ bool CgroupGetAttributePathForTask(const std::string& attr_name, int tid, std::s
     }
 
     if (!attr->GetPathForTask(tid, path)) {
-        PLOG(ERROR) << "Failed to find cgroup for tid " << tid;
+        LOG(ERROR) << "Failed to find cgroup for tid " << tid;
         return false;
     }
 
@@ -601,7 +601,7 @@ int createProcessGroup(uid_t uid, int initialPid, bool memControl) {
     CHECK_GT(initialPid, 0);
 
     if (memControl && !UsePerAppMemcg()) {
-        PLOG(ERROR) << "service memory controls are used without per-process memory cgroup support";
+        LOG(ERROR) << "service memory controls are used without per-process memory cgroup support";
         return -EINVAL;
     }
 
@@ -623,13 +623,13 @@ int createProcessGroup(uid_t uid, int initialPid, bool memControl) {
 
 static bool SetProcessGroupValue(int tid, const std::string& attr_name, int64_t value) {
     if (!isMemoryCgroupSupported()) {
-        PLOG(ERROR) << "Memcg is not mounted.";
+        LOG(ERROR) << "Memcg is not mounted.";
         return false;
     }
 
     std::string path;
     if (!CgroupGetAttributePathForTask(attr_name, tid, &path)) {
-        PLOG(ERROR) << "Failed to find attribute '" << attr_name << "'";
+        LOG(ERROR) << "Failed to find attribute '" << attr_name << "'";
         return false;
     }
 

From 43323a7e7a4ce39a89d55f0b27f4570d711bddce Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Fri, 3 Nov 2023 10:07:59 -0700
Subject: [PATCH 0527/1487] init: Create different file descriptors for SIGCHLD
 and SIGTERM

This change will allow a later CL to wait for SIGCHLD without discarding
the SIGTERM information.

Bug: 308687042
Change-Id: I5b9ab4562060455573cd816cc48bf90576b39ab9
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 init/init.cpp | 41 +++++++++++++++++++++++++++++++++--------
 1 file changed, 33 insertions(+), 8 deletions(-)

diff --git a/init/init.cpp b/init/init.cpp
index 19f34dabb284..68701aa38d3c 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -108,6 +108,7 @@ using android::base::SetProperty;
 using android::base::StringPrintf;
 using android::base::Timer;
 using android::base::Trim;
+using android::base::unique_fd;
 using android::fs_mgr::AvbHandle;
 using android::snapshot::SnapshotManager;
 
@@ -116,7 +117,8 @@ namespace init {
 
 static int property_triggers_enabled = 0;
 
-static int signal_fd = -1;
+static int sigchld_fd = -1;
+static int sigterm_fd = -1;
 static int property_fd = -1;
 
 struct PendingControlMessage {
@@ -713,8 +715,9 @@ static void HandleSigtermSignal(const signalfd_siginfo& siginfo) {
     HandlePowerctlMessage("shutdown,container");
 }
 
-static void HandleSignalFd() {
+static void HandleSignalFd(int signal) {
     signalfd_siginfo siginfo;
+    const int signal_fd = signal == SIGCHLD ? sigchld_fd : sigterm_fd;
     ssize_t bytes_read = TEMP_FAILURE_RETRY(read(signal_fd, &siginfo, sizeof(siginfo)));
     if (bytes_read != sizeof(siginfo)) {
         PLOG(ERROR) << "Failed to read siginfo from signal_fd";
@@ -748,6 +751,24 @@ static void UnblockSignals() {
     }
 }
 
+static Result<int> CreateAndRegisterSignalFd(Epoll* epoll, int signal) {
+    sigset_t mask;
+    sigemptyset(&mask);
+    sigaddset(&mask, signal);
+    unique_fd signal_fd(signalfd(-1, &mask, SFD_CLOEXEC));
+    if (signal_fd == -1) {
+        return ErrnoError() << "failed to create signalfd for signal " << signal;
+    }
+
+    auto result = epoll->RegisterHandler(
+            signal_fd.get(), [signal]() { HandleSignalFd(signal); }, EPOLLIN | EPOLLPRI);
+    if (!result.ok()) {
+        return result.error();
+    }
+
+    return signal_fd.release();
+}
+
 static void InstallSignalFdHandler(Epoll* epoll) {
     // Applying SA_NOCLDSTOP to a defaulted SIGCHLD handler prevents the signalfd from receiving
     // SIGCHLD when a child process stops or continues (b/77867680#comment9).
@@ -774,14 +795,18 @@ static void InstallSignalFdHandler(Epoll* epoll) {
         LOG(FATAL) << "Failed to register a fork handler: " << strerror(result);
     }
 
-    signal_fd = signalfd(-1, &mask, SFD_CLOEXEC);
-    if (signal_fd == -1) {
-        PLOG(FATAL) << "failed to create signalfd";
+    Result<int> cs_result = CreateAndRegisterSignalFd(epoll, SIGCHLD);
+    if (!cs_result.ok()) {
+        PLOG(FATAL) << cs_result.error();
     }
+    sigchld_fd = cs_result.value();
 
-    constexpr int flags = EPOLLIN | EPOLLPRI;
-    if (auto result = epoll->RegisterHandler(signal_fd, HandleSignalFd, flags); !result.ok()) {
-        LOG(FATAL) << result.error();
+    if (sigismember(&mask, SIGTERM)) {
+        Result<int> cs_result = CreateAndRegisterSignalFd(epoll, SIGTERM);
+        if (!cs_result.ok()) {
+            PLOG(FATAL) << cs_result.error();
+        }
+        sigterm_fd = cs_result.value();
     }
 }
 

From 770bb3ec99d608190d88906d89ad880f03b7124a Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 30 Oct 2023 14:31:31 -0700
Subject: [PATCH 0528/1487] libsnapshot: Add XorOp to v3 Cow

Adding in XOR operation to v3 writer. Parser has to go through ops and
create a mapping of XOR operation to it's data

Test: cow_api_test
Bug: 307452468
Change-Id: I51e13a59ba472b62bdcc05921f2e5d6e2c8ad2af
---
 .../include/libsnapshot/cow_reader.h          |  2 +-
 .../libsnapshot_cow/cow_reader.cpp            |  8 +-
 .../libsnapshot_cow/inspect_cow.cpp           |  3 +-
 .../libsnapshot/libsnapshot_cow/parser_base.h |  5 +-
 .../libsnapshot/libsnapshot_cow/parser_v2.cpp | 10 +--
 .../libsnapshot/libsnapshot_cow/parser_v2.h   |  2 -
 .../libsnapshot/libsnapshot_cow/parser_v3.cpp | 16 ++++
 .../libsnapshot/libsnapshot_cow/parser_v3.h   |  5 +-
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 81 ++++++++++++++++++-
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 18 ++---
 10 files changed, 118 insertions(+), 32 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index 755a3afa2af0..1ab6ada6ea3b 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -183,7 +183,7 @@ class CowReader final : public ICowReader {
     uint64_t num_total_data_ops_{};
     uint64_t num_ordered_ops_to_merge_{};
     bool has_seq_ops_{};
-    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
+    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> xor_data_loc_;
     ReaderFlags reader_flag_;
     bool is_merge_{};
 };
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 93c31bbc9991..296987a03f0f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -82,7 +82,7 @@ std::unique_ptr<CowReader> CowReader::CloneCowReader() {
     cow->merge_op_start_ = merge_op_start_;
     cow->num_total_data_ops_ = num_total_data_ops_;
     cow->num_ordered_ops_to_merge_ = num_ordered_ops_to_merge_;
-    cow->data_loc_ = data_loc_;
+    cow->xor_data_loc_ = xor_data_loc_;
     cow->block_pos_index_ = block_pos_index_;
     cow->is_merge_ = is_merge_;
     return cow;
@@ -139,7 +139,6 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
             LOG(ERROR) << "Unknown version: " << header_.prefix.major_version;
             return false;
     }
-
     if (!parser->Parse(fd, header_, label)) {
         return false;
     }
@@ -154,7 +153,7 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
     footer_ = parser->footer();
     fd_size_ = parser->fd_size();
     last_label_ = parser->last_label();
-    data_loc_ = parser->data_loc();
+    xor_data_loc_ = parser->xor_data_loc();
 
     // If we're resuming a write, we're not ready to merge
     if (label.has_value()) return true;
@@ -682,11 +681,10 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
 
     uint64_t offset;
     if (op->type == kCowXorOp) {
-        offset = data_loc_->at(op->new_block);
+        offset = xor_data_loc_->at(op->new_block);
     } else {
         offset = GetCowOpSourceInfoData(*op);
     }
-
     if (!decompressor) {
         CowDataStream stream(this, offset + ignore_bytes, op->data_length - ignore_bytes);
         return stream.ReadFully(buffer, buffer_size);
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
index 76509de78961..993630b04a7c 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
@@ -82,7 +82,8 @@ static bool ShowRawOpStreamV2(borrowed_fd fd, const CowHeaderV3& header) {
     }
     for (const auto& op : *parser.get_v2ops()) {
         std::cout << op << "\n";
-        if (auto iter = parser.data_loc()->find(op.new_block); iter != parser.data_loc()->end()) {
+        if (auto iter = parser.xor_data_loc()->find(op.new_block);
+            iter != parser.xor_data_loc()->end()) {
             std::cout << "    data loc: " << iter->second << "\n";
         }
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h
index 278340740bd9..837b33edbaf1 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_base.h
@@ -38,7 +38,9 @@ class CowParserBase {
                        std::optional<uint64_t> label = {}) = 0;
     virtual bool Translate(TranslatedCowOps* out) = 0;
     virtual std::optional<CowFooter> footer() const { return std::nullopt; }
-    virtual std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const = 0;
+    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> xor_data_loc() {
+        return xor_data_loc_;
+    };
 
     uint64_t fd_size() const { return fd_size_; }
     const std::optional<uint64_t>& last_label() const { return last_label_; }
@@ -47,6 +49,7 @@ class CowParserBase {
     CowHeaderV3 header_ = {};
     uint64_t fd_size_;
     std::optional<uint64_t> last_label_;
+    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> xor_data_loc_ = {};
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
index 51489c83a91e..08a43a4884e2 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
@@ -63,7 +63,7 @@ bool CowParserV2::Parse(borrowed_fd fd, const CowHeaderV3& header, std::optional
 
 bool CowParserV2::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
     uint64_t pos;
-    auto data_loc = std::make_shared<std::unordered_map<uint64_t, uint64_t>>();
+    auto xor_data_loc = std::make_shared<std::unordered_map<uint64_t, uint64_t>>();
 
     // Skip the scratch space
     if (header_.prefix.major_version >= 2 && (header_.buffer_size > 0)) {
@@ -111,7 +111,7 @@ bool CowParserV2::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
             auto& current_op = ops_buffer->data()[current_op_num];
             current_op_num++;
             if (current_op.type == kCowXorOp) {
-                data_loc->insert({current_op.new_block, data_pos});
+                xor_data_loc->insert({current_op.new_block, data_pos});
             }
             pos += sizeof(CowOperationV2) + GetNextOpOffset(current_op, header_.cluster_ops);
             data_pos += current_op.data_length + GetNextDataOffset(current_op, header_.cluster_ops);
@@ -193,7 +193,7 @@ bool CowParserV2::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
 
     v2_ops_ = ops_buffer;
     v2_ops_->shrink_to_fit();
-    data_loc_ = data_loc;
+    xor_data_loc_ = xor_data_loc;
     return true;
 }
 
@@ -239,9 +239,5 @@ bool CowParserV2::Translate(TranslatedCowOps* out) {
     return true;
 }
 
-std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> CowParserV2::data_loc() const {
-    return data_loc_;
-}
-
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
index 318a3ac14bb5..f9ee2e52691d 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.h
@@ -35,10 +35,8 @@ class CowParserV2 final : public CowParserBase {
 
     const CowHeader& header() const { return header_; }
     std::shared_ptr<std::vector<CowOperationV2>> get_v2ops() { return v2_ops_; }
-    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const override;
 
   private:
-    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc_;
     bool ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label);
     std::shared_ptr<std::vector<CowOperationV2>> v2_ops_;
     std::optional<CowFooter> footer_;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
index 23ddaae7194a..a8a63d87ae6c 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
@@ -58,6 +58,10 @@ bool CowParserV3::Parse(borrowed_fd fd, const CowHeaderV3& header, std::optional
     return ParseOps(fd, label);
 }
 
+off_t CowParserV3::GetDataOffset() const {
+    return sizeof(CowHeaderV3) + header_.buffer_size + header_.op_count_max * sizeof(CowOperation);
+}
+
 bool CowParserV3::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
     ops_ = std::make_shared<std::vector<CowOperationV3>>();
     ops_->resize(header_.op_count);
@@ -69,12 +73,24 @@ bool CowParserV3::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
         return false;
     }
 
+    // fill out mapping of XOR op data location
+    uint64_t data_pos = GetDataOffset();
+
+    xor_data_loc_ = std::make_shared<std::unordered_map<uint64_t, uint64_t>>();
+
+    for (auto op : *ops_) {
+        if (op.type == kCowXorOp) {
+            xor_data_loc_->insert({op.new_block, data_pos});
+        }
+        data_pos += op.data_length;
+    }
     // :TODO: sequence buffer & resume buffer follow
     // Once we implement labels, we'll have to discard unused ops and adjust
     // the header as needed.
     CHECK(!label);
 
     ops_->shrink_to_fit();
+
     return true;
 }
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
index 5760cf2baff1..e2663cc59c73 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
@@ -45,13 +45,10 @@ class CowParserV3 final : public CowParserBase {
     bool Parse(android::base::borrowed_fd fd, const CowHeaderV3& header,
                std::optional<uint64_t> label = {}) override;
     bool Translate(TranslatedCowOps* out) override;
-    std::shared_ptr<std::unordered_map<uint64_t, uint64_t>> data_loc() const override {
-        return nullptr;
-    };
 
   private:
     bool ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label);
-
+    off_t GetDataOffset() const;
     CowHeaderV3 header_ = {};
     std::shared_ptr<std::vector<CowOperationV3>> ops_;
 };
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index c5d7a025f380..3277c990ee7c 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -218,7 +218,7 @@ TEST_F(CowTestV3, CopyOp) {
     CowReader reader;
     ASSERT_TRUE(reader.Parse(cow_->fd));
 
-    const auto& header = reader.GetHeader();
+    const auto& header = reader.header_v3();
     ASSERT_EQ(header.prefix.magic, kCowMagicNumber);
     ASSERT_EQ(header.prefix.major_version, 3);
     ASSERT_EQ(header.prefix.minor_version, kCowVersionMinor);
@@ -242,5 +242,84 @@ TEST_F(CowTestV3, CopyOp) {
     ASSERT_EQ(i, 100);
 }
 
+TEST_F(CowTestV3, XorOp) {
+    CowOptions options;
+    options.op_count_max = 100;
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+
+    std::string data = "This is test data-1. Testing xor";
+    data.resize(options.block_size, '\0');
+    ASSERT_TRUE(writer->AddXorBlocks(50, data.data(), data.size(), 24, 10));
+    ASSERT_TRUE(writer->Finalize());
+
+    ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
+
+    CowReader reader;
+
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    const auto& header = reader.header_v3();
+    ASSERT_EQ(header.op_count, 1);
+
+    auto iter = reader.GetOpIter();
+    ASSERT_NE(iter, nullptr);
+    ASSERT_FALSE(iter->AtEnd());
+    auto op = iter->Get();
+    std::string sink(data.size(), '\0');
+
+    ASSERT_EQ(op->type, kCowXorOp);
+    ASSERT_EQ(op->data_length, 4096);
+    ASSERT_EQ(op->new_block, 50);
+    ASSERT_EQ(GetCowOpSourceInfoData(*op), 98314);  // 4096 * 24 + 10
+    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
+    ASSERT_EQ(sink, data);
+}
+
+TEST_F(CowTestV3, ConsecutiveXorOp) {
+    CowOptions options;
+    options.op_count_max = 100;
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+
+    std::string data;
+    data.resize(options.block_size * 5);
+    for (int i = 0; i < data.size(); i++) {
+        data[i] = char(rand() % 256);
+    }
+
+    ASSERT_TRUE(writer->AddXorBlocks(50, data.data(), data.size(), 24, 10));
+    ASSERT_TRUE(writer->Finalize());
+
+    ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
+
+    CowReader reader;
+
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    const auto& header = reader.header_v3();
+    ASSERT_EQ(header.op_count, 5);
+
+    auto iter = reader.GetOpIter();
+    ASSERT_NE(iter, nullptr);
+    ASSERT_FALSE(iter->AtEnd());
+
+    std::string sink(data.size(), '\0');
+    size_t i = 0;
+
+    while (!iter->AtEnd()) {
+        auto op = iter->Get();
+        ASSERT_EQ(op->type, kCowXorOp);
+        ASSERT_EQ(op->data_length, 4096);
+        ASSERT_EQ(op->new_block, 50 + i);
+        ASSERT_EQ(GetCowOpSourceInfoData(*op), 98314 + (i * options.block_size));  // 4096 * 24 + 10
+        ASSERT_TRUE(
+                ReadData(reader, op, sink.data() + (i * options.block_size), options.block_size));
+        iter->Next();
+        i++;
+    }
+    ASSERT_EQ(sink, data);
+
+    ASSERT_EQ(i, 5);
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index aeb088d2e3bc..13b615782561 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -163,7 +163,6 @@ bool CowWriterV3::OpenForWrite() {
     }
     next_data_pos_ =
             sizeof(CowHeaderV3) + header_.buffer_size + header_.op_count_max * sizeof(CowOperation);
-
     return true;
 }
 
@@ -187,19 +186,12 @@ bool CowWriterV3::EmitRawBlocks(uint64_t new_block_start, const void* data, size
 
 bool CowWriterV3::EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size,
                                 uint32_t old_block, uint16_t offset) {
-    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
-    if (new_block_start || old_block || offset || data || size) return false;
-    return false;
+    return EmitBlocks(new_block_start, data, size, old_block, offset, kCowXorOp);
 }
 
 bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t size,
                              uint64_t old_block, uint16_t offset, uint8_t type) {
     const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
-
-    // Placing here until we support XOR ops
-    CHECK_EQ(old_block, 0);
-    CHECK_EQ(offset, 0);
-
     const size_t num_blocks = (size / header_.block_size);
 
     for (size_t i = 0; i < num_blocks; i++) {
@@ -207,12 +199,18 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
         op.new_block = new_block_start + i;
 
         op.type = type;
-        op.source_info = next_data_pos_;
         op.data_length = static_cast<uint16_t>(header_.block_size);
+
+        if (type == kCowXorOp) {
+            op.source_info = (old_block + i) * header_.block_size + offset;
+        } else {
+            op.source_info = next_data_pos_;
+        }
         if (!WriteOperation(op, iter, header_.block_size)) {
             LOG(ERROR) << "AddRawBlocks: write failed";
             return false;
         }
+
         iter += header_.block_size;
     }
 

From 16d35611ed7feaaa5c64d8ae81d09fdecf0b181c Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 2 Nov 2023 14:25:48 -0700
Subject: [PATCH 0529/1487] test_v3: Add max op test case

Add test case to ensure that add blocks will fail when we try to add
more blocks that options.op_count_max specifies. Expected behavior is
that we will write until that count and then fail

Test: cow_api_test
Change-Id: Icb44508c1bacbbe676347df9a58c0526068eebe0
---
 fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 3277c990ee7c..8a67c08c8525 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -94,6 +94,24 @@ TEST_F(CowTestV3, Header) {
     ASSERT_EQ(header.cluster_ops, 0);
 }
 
+TEST_F(CowTestV3, MaxOp) {
+    CowOptions options;
+    options.op_count_max = 20;
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+    ASSERT_FALSE(writer->AddZeroBlocks(1, 21));
+    ASSERT_FALSE(writer->AddZeroBlocks(1, 1));
+    std::string data = "This is some data, believe it";
+    data.resize(options.block_size, '\0');
+
+    ASSERT_FALSE(writer->AddRawBlocks(5, data.data(), data.size()));
+
+    ASSERT_TRUE(writer->Finalize());
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+    ASSERT_EQ(reader.header_v3().op_count, 20);
+}
+
 TEST_F(CowTestV3, ZeroOp) {
     CowOptions options;
     options.op_count_max = 20;

From 1c9f0474a6951a48deb20b9c3a124d50b8ae651d Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 6 Nov 2023 10:47:01 -0800
Subject: [PATCH 0530/1487] test_v3: write multiple ops

test case for reading and writing multiple operations of different types

Test: cow_api_test
Change-Id: I8d59a460a50c7054df0b17dc44dd6605048682aa
---
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 82 +++++++++++++++++++
 1 file changed, 82 insertions(+)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 8a67c08c8525..d39c4a728063 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -339,5 +339,87 @@ TEST_F(CowTestV3, ConsecutiveXorOp) {
     ASSERT_EQ(i, 5);
 }
 
+TEST_F(CowTestV3, AllOps) {
+    CowOptions options;
+    options.op_count_max = 100;
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+
+    std::string data;
+    data.resize(options.block_size * 5);
+    for (int i = 0; i < data.size(); i++) {
+        data[i] = char(rand() % 256);
+    }
+
+    ASSERT_TRUE(writer->AddZeroBlocks(10, 5));
+    ASSERT_TRUE(writer->AddCopy(15, 3, 5));
+    ASSERT_TRUE(writer->AddRawBlocks(18, data.data(), data.size()));
+    ASSERT_TRUE(writer->AddXorBlocks(50, data.data(), data.size(), 24, 10));
+    ASSERT_TRUE(writer->Finalize());
+
+    CowReader reader;
+
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    const auto& header = reader.header_v3();
+    ASSERT_EQ(header.prefix.magic, kCowMagicNumber);
+    ASSERT_EQ(header.prefix.major_version, 3);
+    ASSERT_EQ(header.prefix.minor_version, kCowVersionMinor);
+    ASSERT_EQ(header.block_size, options.block_size);
+    ASSERT_EQ(header.buffer_size, BUFFER_REGION_DEFAULT_SIZE);
+    ASSERT_EQ(header.op_count, 20);
+    ASSERT_EQ(header.op_count_max, 100);
+
+    auto iter = reader.GetOpIter();
+    ASSERT_NE(iter, nullptr);
+    ASSERT_FALSE(iter->AtEnd());
+
+    size_t i = 0;
+
+    while (i < 5) {
+        auto op = iter->Get();
+        ASSERT_EQ(op->type, kCowZeroOp);
+        ASSERT_EQ(op->new_block, 10 + i);
+        iter->Next();
+        i++;
+    }
+    i = 0;
+    while (i < 5) {
+        auto op = iter->Get();
+        ASSERT_EQ(op->type, kCowCopyOp);
+        ASSERT_EQ(op->new_block, 15 + i);
+        ASSERT_EQ(GetCowOpSourceInfoData(*op), 3 + i);
+        iter->Next();
+        i++;
+    }
+    i = 0;
+    std::string sink(data.size(), '\0');
+
+    while (i < 5) {
+        auto op = iter->Get();
+        ASSERT_EQ(op->type, kCowReplaceOp);
+        ASSERT_EQ(op->data_length, options.block_size);
+        ASSERT_EQ(op->new_block, 18 + i);
+        ASSERT_TRUE(
+                ReadData(reader, op, sink.data() + (i * options.block_size), options.block_size));
+        iter->Next();
+        i++;
+    }
+    ASSERT_EQ(sink, data);
+
+    i = 0;
+    std::fill(sink.begin(), sink.end(), '\0');
+    while (i < 5) {
+        auto op = iter->Get();
+        ASSERT_EQ(op->type, kCowXorOp);
+        ASSERT_EQ(op->data_length, 4096);
+        ASSERT_EQ(op->new_block, 50 + i);
+        ASSERT_EQ(GetCowOpSourceInfoData(*op), 98314 + (i * options.block_size));  // 4096 * 24 + 10
+        ASSERT_TRUE(
+                ReadData(reader, op, sink.data() + (i * options.block_size), options.block_size));
+        iter->Next();
+        i++;
+    }
+    ASSERT_EQ(sink, data);
+}
 }  // namespace snapshot
 }  // namespace android

From 9431b63a7c3ed7648ae3a637e02a3c9e102f5bb9 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Mon, 6 Nov 2023 14:56:29 +0000
Subject: [PATCH 0531/1487] libprocessgroup: Internal linkage for
 removeAllProcessGroupsInternal

This function is internal and shouldn't be visible externally.

Bug: 301871933
Change-Id: Ie8261795fa8b010c47da667f21e61949d7a9ae00
---
 libprocessgroup/processgroup.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 9af2682dd904..d352f0e346e2 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -275,7 +275,7 @@ static bool RemoveUidCgroups(const std::string& uid_path, bool empty_only) {
     return empty;
 }
 
-void removeAllProcessGroupsInternal(bool empty_only) {
+static void removeAllProcessGroupsInternal(bool empty_only) {
     std::vector<std::string> cgroups;
     std::string path, memcg_apps_path;
 

From a75f21039809d3ab1a9782f7b97f9071a0dccdbe Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Fri, 3 Nov 2023 10:33:17 -0700
Subject: [PATCH 0532/1487] init: Make WaitToBeReaped() wait less long

Reduce the time spent in WaitToBeReaped() by waiting for SIGCHLD instead
of waiting for 50 ms.

Bug: 308687042
Change-Id: I5e259fdd22dec68e45d27205def2fc6463c06ca3
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 init/init.cpp            |  3 ++-
 init/init.h              |  2 ++
 init/reboot.cpp          |  2 +-
 init/service.cpp         |  1 +
 init/service.h           |  3 +++
 init/sigchld_handler.cpp | 25 +++++++++++++++++++++++--
 init/sigchld_handler.h   |  3 ++-
 7 files changed, 34 insertions(+), 5 deletions(-)

diff --git a/init/init.cpp b/init/init.cpp
index 68701aa38d3c..0439d224a5ea 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -117,7 +117,7 @@ namespace init {
 
 static int property_triggers_enabled = 0;
 
-static int sigchld_fd = -1;
+int sigchld_fd = -1;
 static int sigterm_fd = -1;
 static int property_fd = -1;
 
@@ -800,6 +800,7 @@ static void InstallSignalFdHandler(Epoll* epoll) {
         PLOG(FATAL) << cs_result.error();
     }
     sigchld_fd = cs_result.value();
+    Service::SetSigchldFd(sigchld_fd);
 
     if (sigismember(&mask, SIGTERM)) {
         Result<int> cs_result = CreateAndRegisterSignalFd(epoll, SIGTERM);
diff --git a/init/init.h b/init/init.h
index 9c7e91879aae..b78116721673 100644
--- a/init/init.h
+++ b/init/init.h
@@ -28,6 +28,8 @@
 namespace android {
 namespace init {
 
+extern int sigchld_fd;
+
 Parser CreateParser(ActionManager& action_manager, ServiceList& service_list);
 Parser CreateApexConfigParser(ActionManager& action_manager, ServiceList& service_list);
 
diff --git a/init/reboot.cpp b/init/reboot.cpp
index 3351c4c452da..57579225834e 100644
--- a/init/reboot.cpp
+++ b/init/reboot.cpp
@@ -563,7 +563,7 @@ static void StopServices(const std::set<std::string>& services, std::chrono::mil
         }
     }
     if (timeout > 0ms) {
-        WaitToBeReaped(pids, timeout);
+        WaitToBeReaped(sigchld_fd, pids, timeout);
     } else {
         // Even if we don't to wait for services to stop, we still optimistically reap zombies.
         ReapAnyOutstandingChildren();
diff --git a/init/service.cpp b/init/service.cpp
index 5e900ee4d0b0..66ddc8e8f7cb 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -136,6 +136,7 @@ static bool ExpandArgsAndExecv(const std::vector<std::string>& args, bool sigsto
 
 unsigned long Service::next_start_order_ = 1;
 bool Service::is_exec_service_running_ = false;
+int Service::sigchld_fd_ = -1;
 
 Service::Service(const std::string& name, Subcontext* subcontext_for_restart_commands,
                  const std::string& filename, const std::vector<std::string>& args)
diff --git a/init/service.h b/init/service.h
index 9f09cefb8618..7e73af6d7a84 100644
--- a/init/service.h
+++ b/init/service.h
@@ -156,6 +156,7 @@ class Service {
     const Subcontext* subcontext() const { return subcontext_; }
     const std::string& filename() const { return filename_; }
     void set_filename(const std::string& name) { filename_ = name; }
+    static void SetSigchldFd(int sigchld_fd) { sigchld_fd_ = sigchld_fd; }
 
   private:
     void NotifyStateChange(const std::string& new_state) const;
@@ -168,8 +169,10 @@ class Service {
     void RunService(const std::vector<Descriptor>& descriptors, InterprocessFifo cgroups_activated,
                     InterprocessFifo setsid_finished);
     void SetMountNamespace();
+
     static unsigned long next_start_order_;
     static bool is_exec_service_running_;
+    static int sigchld_fd_;
 
     const std::string name_;
     std::set<std::string> classnames_;
diff --git a/init/sigchld_handler.cpp b/init/sigchld_handler.cpp
index 0901a960fb42..9d4c7c8e3301 100644
--- a/init/sigchld_handler.cpp
+++ b/init/sigchld_handler.cpp
@@ -18,6 +18,7 @@
 
 #include <signal.h>
 #include <string.h>
+#include <sys/signalfd.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/wait.h>
@@ -31,6 +32,7 @@
 
 #include <thread>
 
+#include "epoll.h"
 #include "init.h"
 #include "service.h"
 #include "service_list.h"
@@ -121,8 +123,23 @@ void ReapAnyOutstandingChildren() {
     }
 }
 
-void WaitToBeReaped(const std::vector<pid_t>& pids, std::chrono::milliseconds timeout) {
+static void DiscardSiginfo(int signal_fd) {
+    signalfd_siginfo siginfo;
+    ssize_t bytes_read = TEMP_FAILURE_RETRY(read(signal_fd, &siginfo, sizeof(siginfo)));
+    if (bytes_read != sizeof(siginfo)) {
+        LOG(WARNING) << "Unexpected: " << __func__ << " read " << bytes_read << " bytes instead of "
+                     << sizeof(siginfo);
+    }
+}
+
+void WaitToBeReaped(int sigchld_fd, const std::vector<pid_t>& pids,
+                    std::chrono::milliseconds timeout) {
     Timer t;
+    Epoll epoll;
+    // The init process passes a valid sigchld_fd argument but unit tests do not.
+    if (sigchld_fd >= 0) {
+        epoll.RegisterHandler(sigchld_fd, [sigchld_fd]() { DiscardSiginfo(sigchld_fd); });
+    }
     std::vector<pid_t> alive_pids(pids.begin(), pids.end());
     while (!alive_pids.empty() && t.duration() < timeout) {
         pid_t pid;
@@ -135,7 +152,11 @@ void WaitToBeReaped(const std::vector<pid_t>& pids, std::chrono::milliseconds ti
         if (alive_pids.empty()) {
             break;
         }
-        std::this_thread::sleep_for(50ms);
+        if (sigchld_fd >= 0) {
+            epoll.Wait(std::max(timeout - t.duration(), 0ms));
+        } else {
+            std::this_thread::sleep_for(50ms);
+        }
     }
     LOG(INFO) << "Waiting for " << pids.size() << " pids to be reaped took " << t << " with "
               << alive_pids.size() << " of them still running";
diff --git a/init/sigchld_handler.h b/init/sigchld_handler.h
index fac10201e5ff..e07a7d66af6b 100644
--- a/init/sigchld_handler.h
+++ b/init/sigchld_handler.h
@@ -25,7 +25,8 @@ namespace init {
 
 void ReapAnyOutstandingChildren();
 
-void WaitToBeReaped(const std::vector<pid_t>& pids, std::chrono::milliseconds timeout);
+void WaitToBeReaped(int sigchld_fd, const std::vector<pid_t>& pids,
+                    std::chrono::milliseconds timeout);
 
 }  // namespace init
 }  // namespace android

From e363841e75548a211757b77bf3356d527a1c4c62 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 2 Nov 2023 14:53:14 -0700
Subject: [PATCH 0533/1487] libsnapshot: Add single threaded compression to v3
 writer

Add compression path back into Cow operations. Main change is that the
compression algorithm is stored in the header instead of each individaul
op. Have the writer_v3 set this algorithm when parsing options.

There looks to be a lot of code we'll be able to factor out into the
base class, but we can leave that to a later CL.

Test: cow_api_test
Change-Id: Ie9a8eceb5fbdaecae50911119c75f2e51d776a28
---
 .../libsnapshot_cow/cow_reader.cpp            |  2 +-
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 44 +++++++++++++++++--
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 33 ++++++++++----
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |  6 +++
 4 files changed, 72 insertions(+), 13 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 296987a03f0f..cacd29d5c3c6 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -685,7 +685,7 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
     } else {
         offset = GetCowOpSourceInfoData(*op);
     }
-    if (!decompressor) {
+    if (!decompressor || op->data_length == header_.block_size) {
         CowDataStream stream(this, offset + ignore_bytes, op->data_length - ignore_bytes);
         return stream.ReadFully(buffer, buffer_size);
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index d39c4a728063..d0af0f989acb 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -339,15 +339,16 @@ TEST_F(CowTestV3, ConsecutiveXorOp) {
     ASSERT_EQ(i, 5);
 }
 
-TEST_F(CowTestV3, AllOps) {
+TEST_F(CowTestV3, AllOpsWithCompression) {
     CowOptions options;
+    options.compression = "gz";
     options.op_count_max = 100;
     auto writer = CreateCowWriter(3, options, GetCowFd());
 
     std::string data;
     data.resize(options.block_size * 5);
     for (int i = 0; i < data.size(); i++) {
-        data[i] = char(rand() % 256);
+        data[i] = char(rand() % 4);
     }
 
     ASSERT_TRUE(writer->AddZeroBlocks(10, 5));
@@ -397,7 +398,6 @@ TEST_F(CowTestV3, AllOps) {
     while (i < 5) {
         auto op = iter->Get();
         ASSERT_EQ(op->type, kCowReplaceOp);
-        ASSERT_EQ(op->data_length, options.block_size);
         ASSERT_EQ(op->new_block, 18 + i);
         ASSERT_TRUE(
                 ReadData(reader, op, sink.data() + (i * options.block_size), options.block_size));
@@ -411,7 +411,6 @@ TEST_F(CowTestV3, AllOps) {
     while (i < 5) {
         auto op = iter->Get();
         ASSERT_EQ(op->type, kCowXorOp);
-        ASSERT_EQ(op->data_length, 4096);
         ASSERT_EQ(op->new_block, 50 + i);
         ASSERT_EQ(GetCowOpSourceInfoData(*op), 98314 + (i * options.block_size));  // 4096 * 24 + 10
         ASSERT_TRUE(
@@ -421,5 +420,42 @@ TEST_F(CowTestV3, AllOps) {
     }
     ASSERT_EQ(sink, data);
 }
+
+TEST_F(CowTestV3, GzCompression) {
+    CowOptions options;
+    options.op_count_max = 100;
+    options.compression = "gz";
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+
+    std::string data = "This is some data, believe it";
+    data.resize(options.block_size, '\0');
+
+    ASSERT_TRUE(writer->AddRawBlocks(50, data.data(), data.size()));
+    ASSERT_TRUE(writer->Finalize());
+
+    ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    auto header = reader.header_v3();
+    ASSERT_EQ(header.compression_algorithm, kCowCompressGz);
+
+    auto iter = reader.GetOpIter();
+    ASSERT_NE(iter, nullptr);
+    ASSERT_FALSE(iter->AtEnd());
+    auto op = iter->Get();
+
+    std::string sink(data.size(), '\0');
+
+    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->data_length, 56);  // compressed!
+    ASSERT_EQ(op->new_block, 50);
+    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
+    ASSERT_EQ(sink, data);
+
+    iter->Next();
+    ASSERT_TRUE(iter->AtEnd());
+}
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 13b615782561..86dd9f72fe3d 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -97,6 +97,8 @@ bool CowWriterV3::ParseOptions() {
         LOG(ERROR) << "unrecognized compression: " << options_.compression;
         return false;
     }
+    header_.compression_algorithm = *algorithm;
+
     if (parts.size() > 1) {
         if (!android::base::ParseUint(parts[1], &compression_.compression_level)) {
             LOG(ERROR) << "failed to parse compression level invalid type: " << parts[1];
@@ -108,6 +110,7 @@ bool CowWriterV3::ParseOptions() {
     }
 
     compression_.algorithm = *algorithm;
+    compressor_ = ICompressor::Create(compression_, header_.block_size);
     return true;
 }
 
@@ -191,27 +194,41 @@ bool CowWriterV3::EmitXorBlocks(uint32_t new_block_start, const void* data, size
 
 bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t size,
                              uint64_t old_block, uint16_t offset, uint8_t type) {
-    const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
     const size_t num_blocks = (size / header_.block_size);
-
     for (size_t i = 0; i < num_blocks; i++) {
+        const uint8_t* const iter =
+                reinterpret_cast<const uint8_t*>(data) + (header_.block_size * i);
+
         CowOperation op = {};
         op.new_block = new_block_start + i;
 
         op.type = type;
-        op.data_length = static_cast<uint16_t>(header_.block_size);
-
         if (type == kCowXorOp) {
             op.source_info = (old_block + i) * header_.block_size + offset;
         } else {
             op.source_info = next_data_pos_;
         }
-        if (!WriteOperation(op, iter, header_.block_size)) {
-            LOG(ERROR) << "AddRawBlocks: write failed";
+        std::basic_string<uint8_t> compressed_data;
+        const void* out_data = iter;
+
+        op.data_length = header_.block_size;
+
+        if (compression_.algorithm) {
+            if (!compressor_) {
+                PLOG(ERROR) << "Compressor not initialized";
+                return false;
+            }
+            compressed_data = compressor_->Compress(out_data, header_.block_size);
+            if (compressed_data.size() < op.data_length) {
+                out_data = compressed_data.data();
+                op.data_length = compressed_data.size();
+            }
+        }
+        if (!WriteOperation(op, out_data, op.data_length)) {
+            PLOG(ERROR) << "AddRawBlocks with compression: write failed. new block: "
+                        << new_block_start << " compression: " << compression_.algorithm;
             return false;
         }
-
-        iter += header_.block_size;
     }
 
     return true;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index af71a030ccb3..2347e91ffcb0 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -46,6 +46,7 @@ class CowWriterV3 : public CowWriterBase {
     bool WriteOperation(const CowOperationV3& op, const void* data = nullptr, size_t size = 0);
     bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
                     uint16_t offset, uint8_t type);
+    bool CompressBlocks(size_t num_blocks, const void* data);
 
     off_t GetOpOffset(uint32_t op_index) const {
         CHECK_LT(op_index, header_.op_count_max);
@@ -56,9 +57,14 @@ class CowWriterV3 : public CowWriterBase {
   private:
     CowHeaderV3 header_{};
     CowCompression compression_;
+    // in the case that we are using one thread for compression, we can store and re-use the same
+    // compressor
+    std::unique_ptr<ICompressor> compressor_;
+    std::vector<std::unique_ptr<CompressWorker>> compress_threads_;
 
     uint64_t next_op_pos_ = 0;
     uint64_t next_data_pos_ = 0;
+    std::vector<std::basic_string<uint8_t>> compressed_buf_;
 
     // in the case that we are using one thread for compression, we can store and re-use the same
     // compressor

From bfc115311e2f7d38612d64fe35569687167248a4 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 7 Nov 2023 14:44:24 -0800
Subject: [PATCH 0534/1487] run-as: reduce the scope of changed egid.

There's no bug here that I can see, but having a larger than necessary
scope just seems like a bad idea in case anyone adds anything later.

Also switch to modern struct initialization syntax.

Bug: http://b/308990322
Test: treehugger
Change-Id: If2576f902de62e8c24d4a643c224df8ea6cff5d5
---
 run-as/run-as.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/run-as/run-as.cpp b/run-as/run-as.cpp
index cc92c68d0898..9ebe799e1193 100644
--- a/run-as/run-as.cpp
+++ b/run-as/run-as.cpp
@@ -191,14 +191,13 @@ int main(int argc, char* argv[]) {
   }
 
   // Retrieve package information from system, switching egid so we can read the file.
+  pkg_info info = {.name = pkgname};
   gid_t old_egid = getegid();
   if (setegid(AID_PACKAGE_INFO) == -1) error(1, errno, "setegid(AID_PACKAGE_INFO) failed");
-  pkg_info info;
-  memset(&info, 0, sizeof(info));
-  info.name = pkgname;
   if (!packagelist_parse(packagelist_parse_callback, &info)) {
     error(1, errno, "packagelist_parse failed");
   }
+  if (setegid(old_egid) == -1) error(1, errno, "couldn't restore egid");
 
   // Handle a multi-user data path
   if (userId > 0) {
@@ -211,7 +210,6 @@ int main(int argc, char* argv[]) {
   if (info.uid == 0) {
     error(1, 0, "unknown package: %s", pkgname);
   }
-  if (setegid(old_egid) == -1) error(1, errno, "couldn't restore egid");
 
   // Verify that user id is not too big.
   if ((UID_MAX - info.uid) / AID_USER_OFFSET < (uid_t)userId) {

From 76b553c93bdf2791cc93feae5003bb1ecbf76168 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 7 Nov 2023 21:02:50 -0800
Subject: [PATCH 0535/1487] init: Start snapuserd_proxy after early-init

When service is started prior to early init and if per-app memcg is enabled, service start will fail as the required directories for memcg isn't present viz /dev/memcg/apps.

Bug: 308818430
Test: th and CF OTA test with per-app memcg enabled
Change-Id: Ic65e8d179fbfb8e2135f2de5cc7c77d6c29ea7d2
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 init/init.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/init.cpp b/init/init.cpp
index 0439d224a5ea..83cb78b5187f 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -1085,8 +1085,8 @@ int SecondStageMain(int argc, char** argv) {
     am.QueueBuiltinAction(SetupCgroupsAction, "SetupCgroups");
     am.QueueBuiltinAction(SetKptrRestrictAction, "SetKptrRestrict");
     am.QueueBuiltinAction(TestPerfEventSelinuxAction, "TestPerfEventSelinux");
-    am.QueueBuiltinAction(ConnectEarlyStageSnapuserdAction, "ConnectEarlyStageSnapuserd");
     am.QueueEventTrigger("early-init");
+    am.QueueBuiltinAction(ConnectEarlyStageSnapuserdAction, "ConnectEarlyStageSnapuserd");
 
     // Queue an action that waits for coldboot done so we know ueventd has set up all of /dev...
     am.QueueBuiltinAction(wait_for_coldboot_done_action, "wait_for_coldboot_done");

From d291d68c4c86b06e2f8ca593ad108553323a7d73 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 8 Nov 2023 10:46:51 -0800
Subject: [PATCH 0536/1487] run-as: remove unecessary code.

We haven't had a symlink here for many years, so there's no reason to
allow one any more.

Test: treehugger
Change-Id: Ic10d547a88fc6d9c442a5dfb228c5914ea48a32d
---
 run-as/run-as.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/run-as/run-as.cpp b/run-as/run-as.cpp
index 9ebe799e1193..e7c6e04d4f84 100644
--- a/run-as/run-as.cpp
+++ b/run-as/run-as.cpp
@@ -76,9 +76,6 @@ static void check_directory(const char* path, uid_t uid) {
     error(1, errno, "couldn't stat %s", path);
   }
 
-  // /data/user/0 is a known safe symlink.
-  if (strcmp("/data/user/0", path) == 0) return;
-
   // Must be a real directory, not a symlink.
   if (!S_ISDIR(st.st_mode)) {
     error(1, 0, "%s not a directory: %o", path, st.st_mode);

From 38ab04534294a038fff7440031f714079b97cb05 Mon Sep 17 00:00:00 2001
From: Mattias Simonsson <mattiass@google.com>
Date: Wed, 8 Nov 2023 12:02:46 +0000
Subject: [PATCH 0537/1487] debuggerd_test: Scale timeouts by
 HwTimeoutMultiplier

Timeouts in tombstoned.cpp and intercept_manager.cpp are scaled
by HwTimeoutMultiplier, but the timeouts in debuggerd_test.cpp
are not, which means the CrasherTest#intercept_timeout test will
fail for any platform that has a high enough HwTimeoutMultiplier.

Bug: 309532789
Test: debuggerd_test.CrasherTest#intercept_timeout
Change-Id: I83cd01e87644c011efa155a32fd5d92cc8a43a95
---
 debuggerd/debuggerd_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index c3e1302b94f2..87c4cd2d19ab 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -94,7 +94,7 @@ constexpr char kWaitForDebuggerKey[] = "debug.debuggerd.wait_for_debugger";
     if (sigaction(SIGALRM, &new_sigaction, &old_sigaction) != 0) { \
       err(1, "sigaction failed");                                  \
     }                                                              \
-    alarm(seconds);                                                \
+    alarm(seconds * android::base::HwTimeoutMultiplier());         \
     auto value = expr;                                             \
     int saved_errno = errno;                                       \
     if (sigaction(SIGALRM, &old_sigaction, nullptr) != 0) {        \

From 04ca59d6ffb1d9f071df1d89a3fdd947f7dbd576 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 7 Nov 2023 21:50:59 -0800
Subject: [PATCH 0538/1487] libsnapshot: add compatibility check

Ensure that cow was written by v3 writer for the data_length check to
work. All ops written by v2 writer should go through the decompressor
path if a compressor was used.

Test: cow_api_test
Change-Id: I053d6fdaf29ef7001e68f43b45d5a3ff1a36b1c3
---
 fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index cacd29d5c3c6..8412879340e0 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -685,7 +685,8 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
     } else {
         offset = GetCowOpSourceInfoData(*op);
     }
-    if (!decompressor || op->data_length == header_.block_size) {
+    if (!decompressor ||
+        ((op->data_length == header_.block_size) && (header_.prefix.major_version == 3))) {
         CowDataStream stream(this, offset + ignore_bytes, op->data_length - ignore_bytes);
         return stream.ReadFully(buffer, buffer_size);
     }

From c2ce084889585cfb7a59ed410e96742d84d2b71a Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 6 Nov 2023 21:38:14 -0800
Subject: [PATCH 0539/1487] libsnapshot: implement resume buffer

Add resume space to cow v3. Resume buffer goes after header and scratch
space, and is currently set to contain 4 resume points. When AddLabel is
called, the oldest label is replaced with newest one.

Parser will parse up until the last resumable op from a given label.

Test: cow_api_test
Change-Id: Ie072f245721776887d59c96dad296965ad31a5cc
---
 .../include/libsnapshot/cow_format.h          | 12 +++
 .../include/libsnapshot/cow_reader.h          |  2 +-
 .../libsnapshot_cow/cow_format.cpp            |  5 ++
 .../libsnapshot/libsnapshot_cow/parser_v3.cpp | 50 ++++++++++--
 .../libsnapshot/libsnapshot_cow/parser_v3.h   |  6 +-
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 25 ++++++
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 80 ++++++++++++++++---
 .../libsnapshot/libsnapshot_cow/writer_v3.h   | 10 +++
 8 files changed, 171 insertions(+), 19 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 91e04252c155..8917116d09cb 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -94,6 +94,16 @@ struct CowHeader {
 
 } __attribute__((packed));
 
+// Resume point structure used for resume buffer
+struct ResumePoint {
+    // monotonically increasing value used by update_engine
+    uint64_t label;
+    // Index of last CowOperation guaranteed to be resumable
+    uint32_t op_index;
+} __attribute__((packed));
+
+static constexpr uint8_t kNumResumePoints = 4;
+
 struct CowHeaderV3 : public CowHeader {
     // Location of sequence buffer in COW.
     uint64_t sequence_buffer_offset;
@@ -245,6 +255,8 @@ std::ostream& operator<<(std::ostream& os, CowOperationV2 const& arg);
 
 std::ostream& operator<<(std::ostream& os, CowOperation const& arg);
 
+std::ostream& operator<<(std::ostream& os, ResumePoint const& arg);
+
 int64_t GetNextOpOffset(const CowOperationV2& op, uint32_t cluster_size);
 int64_t GetNextDataOffset(const CowOperationV2& op, uint32_t cluster_size);
 
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index 1ab6ada6ea3b..c87b32d3eacd 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -16,6 +16,7 @@
 
 #include <stdint.h>
 
+#include <deque>
 #include <functional>
 #include <memory>
 #include <optional>
@@ -192,6 +193,5 @@ class CowReader final : public ICowReader {
 // The extra fields will just be filled as 0. V3 header is strictly a superset of v1/v2 header and
 // contains all of the latter's field
 bool ReadCowHeader(android::base::borrowed_fd fd, CowHeaderV3* header);
-
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
index b9052915e189..937065d7d34d 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
@@ -100,6 +100,11 @@ std::ostream& operator<<(std::ostream& os, CowOperation const& op) {
     return os;
 }
 
+std::ostream& operator<<(std::ostream& os, ResumePoint const& resume_point) {
+    os << "ResumePoint(" << resume_point.label << " , " << resume_point.op_index << ")";
+    return os;
+}
+
 int64_t GetNextOpOffset(const CowOperationV2& op, uint32_t cluster_ops) {
     if (op.type == kCowClusterOp) {
         return op.source;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
index a8a63d87ae6c..d411ab94595a 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
@@ -15,8 +15,10 @@
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include <android-base/strings.h>
 
 #include <libsnapshot/cow_format.h>
+#include <libsnapshot/cow_reader.h>
 
 namespace android {
 namespace snapshot {
@@ -36,6 +38,7 @@ bool CowParserV3::Parse(borrowed_fd fd, const CowHeaderV3& header, std::optional
         LOG(ERROR) << "Footer size isn't 0, read " << header_.footer_size;
         return false;
     }
+
     if (header_.op_size != sizeof(CowOperationV3)) {
         LOG(ERROR) << "Operation size unknown, read " << header_.op_size << ", expected "
                    << sizeof(CowOperationV3);
@@ -55,18 +58,54 @@ bool CowParserV3::Parse(borrowed_fd fd, const CowHeaderV3& header, std::optional
         return false;
     }
 
-    return ParseOps(fd, label);
+    std::optional<uint32_t> op_index = header_.op_count;
+    if (label) {
+        if (!ReadResumeBuffer(fd)) {
+            PLOG(ERROR) << "Failed to read resume buffer";
+            return false;
+        }
+        op_index = FindResumeOp(label.value());
+        if (op_index == std::nullopt) {
+            LOG(ERROR) << "failed to get op index from given label: " << label.value();
+            return false;
+        }
+    }
+
+    return ParseOps(fd, op_index.value());
+}
+
+bool CowParserV3::ReadResumeBuffer(borrowed_fd fd) {
+    resume_points_ = std::make_shared<std::vector<ResumePoint>>(header_.resume_buffer_size);
+
+    return android::base::ReadFullyAtOffset(fd, resume_points_->data(),
+                                            header_.resume_buffer_size * sizeof(ResumePoint),
+                                            header_.prefix.header_size + header_.buffer_size);
+}
+
+std::optional<uint32_t> CowParserV3::FindResumeOp(const uint32_t label) {
+    for (auto& resume_point : *resume_points_) {
+        if (resume_point.label == label) {
+            return resume_point.op_index;
+        }
+    }
+    LOG(ERROR) << "failed to find label: " << label << "from following labels";
+    LOG(ERROR) << android::base::Join(*resume_points_, " ");
+
+    return std::nullopt;
 }
 
 off_t CowParserV3::GetDataOffset() const {
-    return sizeof(CowHeaderV3) + header_.buffer_size + header_.op_count_max * sizeof(CowOperation);
+    return sizeof(CowHeaderV3) + header_.buffer_size +
+           header_.resume_buffer_size * sizeof(ResumePoint) +
+           header_.op_count_max * sizeof(CowOperation);
 }
 
-bool CowParserV3::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
+bool CowParserV3::ParseOps(borrowed_fd fd, const uint32_t op_index) {
     ops_ = std::make_shared<std::vector<CowOperationV3>>();
-    ops_->resize(header_.op_count);
+    ops_->resize(op_index);
 
-    const off_t offset = header_.prefix.header_size + header_.buffer_size;
+    const off_t offset = header_.prefix.header_size + header_.buffer_size +
+                         header_.resume_buffer_size * sizeof(ResumePoint);
     if (!android::base::ReadFullyAtOffset(fd, ops_->data(), ops_->size() * sizeof(CowOperationV3),
                                           offset)) {
         PLOG(ERROR) << "read ops failed";
@@ -87,7 +126,6 @@ bool CowParserV3::ParseOps(borrowed_fd fd, std::optional<uint64_t> label) {
     // :TODO: sequence buffer & resume buffer follow
     // Once we implement labels, we'll have to discard unused ops and adjust
     // the header as needed.
-    CHECK(!label);
 
     ops_->shrink_to_fit();
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
index e2663cc59c73..dceb815fe6dd 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
@@ -45,12 +45,16 @@ class CowParserV3 final : public CowParserBase {
     bool Parse(android::base::borrowed_fd fd, const CowHeaderV3& header,
                std::optional<uint64_t> label = {}) override;
     bool Translate(TranslatedCowOps* out) override;
+    std::shared_ptr<std::vector<ResumePoint>> resume_points() const { return resume_points_; }
 
   private:
-    bool ParseOps(android::base::borrowed_fd fd, std::optional<uint64_t> label);
+    bool ParseOps(android::base::borrowed_fd fd, const uint32_t op_index);
+    std::optional<uint32_t> FindResumeOp(const uint32_t label);
     off_t GetDataOffset() const;
     CowHeaderV3 header_ = {};
     std::shared_ptr<std::vector<CowOperationV3>> ops_;
+    bool ReadResumeBuffer(android::base::borrowed_fd fd);
+    std::shared_ptr<std::vector<ResumePoint>> resume_points_;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index d0af0f989acb..c41e07cc2913 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -457,5 +457,30 @@ TEST_F(CowTestV3, GzCompression) {
     iter->Next();
     ASSERT_TRUE(iter->AtEnd());
 }
+
+TEST_F(CowTestV3, ResumePointTest) {
+    CowOptions options;
+    options.op_count_max = 100;
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+
+    ASSERT_TRUE(writer->AddZeroBlocks(0, 15));
+    ASSERT_TRUE(writer->AddLabel(0));
+    ASSERT_TRUE(writer->AddZeroBlocks(15, 15));
+    ASSERT_TRUE(writer->Finalize());
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    auto header = reader.header_v3();
+    ASSERT_EQ(header.op_count, 30);
+
+    CowWriterV3 second_writer(options, GetCowFd());
+    ASSERT_TRUE(second_writer.Initialize(0));
+    ASSERT_TRUE(second_writer.Finalize());
+
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+    header = reader.header_v3();
+    ASSERT_EQ(header.op_count, 15);
+}
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 86dd9f72fe3d..876a45d297fa 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -34,6 +34,7 @@
 #include <zlib.h>
 
 #include <fcntl.h>
+#include <libsnapshot_cow/parser_v3.h>
 #include <linux/fs.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
@@ -77,7 +78,7 @@ void CowWriterV3::SetupHeaders() {
     // WIP: not quite sure how some of these are calculated yet, assuming buffer_size is determined
     // during COW size estimation
     header_.sequence_buffer_offset = 0;
-    header_.resume_buffer_size = 0;
+    header_.resume_buffer_size = kNumResumePoints;
     header_.op_count = 0;
     header_.op_count_max = 0;
     header_.compression_algorithm = kCowCompressNone;
@@ -120,11 +121,14 @@ bool CowWriterV3::Initialize(std::optional<uint64_t> label) {
     if (!InitFd() || !ParseOptions()) {
         return false;
     }
-
-    CHECK(!label.has_value());
-
-    if (!OpenForWrite()) {
-        return false;
+    if (!label) {
+        if (!OpenForWrite()) {
+            return false;
+        }
+    } else {
+        if (!OpenForAppend(*label)) {
+            return false;
+        }
     }
 
     return true;
@@ -159,13 +163,44 @@ bool CowWriterV3::OpenForWrite() {
         }
     }
     header_.op_count_max = options_.op_count_max;
+    resume_points_ = std::make_shared<std::vector<ResumePoint>>();
 
     if (!Sync()) {
         LOG(ERROR) << "Header sync failed";
         return false;
     }
-    next_data_pos_ =
-            sizeof(CowHeaderV3) + header_.buffer_size + header_.op_count_max * sizeof(CowOperation);
+    next_data_pos_ = GetDataOffset();
+    return true;
+}
+
+bool CowWriterV3::OpenForAppend(uint64_t label) {
+    CowHeaderV3 header_v3;
+    if (!ReadCowHeader(fd_, &header_v3)) {
+        LOG(ERROR) << "Couldn't read Cow Header";
+        return false;
+    }
+
+    header_ = header_v3;
+
+    CHECK(label >= 0);
+    CowParserV3 parser;
+    if (!parser.Parse(fd_, header_, label)) {
+        PLOG(ERROR) << "unable to parse with given label: " << label;
+        return false;
+    }
+
+    resume_points_ = parser.resume_points();
+    options_.block_size = header_.block_size;
+    next_data_pos_ = GetDataOffset();
+
+    TranslatedCowOps ops;
+    parser.Translate(&ops);
+    header_.op_count = ops.ops->size();
+
+    for (const auto& op : *ops.ops) {
+        next_data_pos_ += op.data_length;
+    }
+
     return true;
 }
 
@@ -249,9 +284,32 @@ bool CowWriterV3::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks)
 }
 
 bool CowWriterV3::EmitLabel(uint64_t label) {
-    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
-    if (label) return false;
-    return false;
+    // remove all labels greater than this current one. we want to avoid the situation of adding
+    // in
+    // duplicate labels with differing op values
+    auto remove_if_callback = [&](const auto& resume_point) -> bool {
+        if (resume_point.label >= label) return true;
+        return false;
+    };
+    resume_points_->erase(
+            std::remove_if(resume_points_->begin(), resume_points_->end(), remove_if_callback),
+            resume_points_->end());
+
+    resume_points_->push_back({label, header_.op_count});
+    // remove the oldest resume point if resume_buffer is full
+    while (resume_points_->size() > header_.resume_buffer_size) {
+        resume_points_->erase(resume_points_->begin());
+    }
+
+    CHECK_LE(resume_points_->size(), header_.resume_buffer_size);
+
+    if (!android::base::WriteFullyAtOffset(fd_, resume_points_->data(),
+                                           resume_points_->size() * sizeof(ResumePoint),
+                                           GetResumeOffset())) {
+        PLOG(ERROR) << "writing resume buffer failed";
+        return false;
+    }
+    return Sync();
 }
 
 bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 2347e91ffcb0..8a2bd2c6ddfe 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -43,6 +43,7 @@ class CowWriterV3 : public CowWriterBase {
     void SetupHeaders();
     bool ParseOptions();
     bool OpenForWrite();
+    bool OpenForAppend(uint64_t label);
     bool WriteOperation(const CowOperationV3& op, const void* data = nullptr, size_t size = 0);
     bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
                     uint16_t offset, uint8_t type);
@@ -51,8 +52,15 @@ class CowWriterV3 : public CowWriterBase {
     off_t GetOpOffset(uint32_t op_index) const {
         CHECK_LT(op_index, header_.op_count_max);
         return header_.prefix.header_size + header_.buffer_size +
+               (header_.resume_buffer_size * sizeof(ResumePoint)) +
                (op_index * sizeof(CowOperationV3));
     }
+    off_t GetDataOffset() const {
+        return sizeof(CowHeaderV3) + header_.buffer_size +
+               (header_.resume_buffer_size * sizeof(ResumePoint)) +
+               header_.op_count_max * sizeof(CowOperation);
+    }
+    off_t GetResumeOffset() const { return sizeof(CowHeaderV3) + header_.buffer_size; }
 
   private:
     CowHeaderV3 header_{};
@@ -61,6 +69,8 @@ class CowWriterV3 : public CowWriterBase {
     // compressor
     std::unique_ptr<ICompressor> compressor_;
     std::vector<std::unique_ptr<CompressWorker>> compress_threads_;
+    // Resume points contain a laebl + cow_op_index.
+    std::shared_ptr<std::vector<ResumePoint>> resume_points_;
 
     uint64_t next_op_pos_ = 0;
     uint64_t next_data_pos_ = 0;

From 79a68a934b63e4dd5b6f6dd2c902811382a6d0f5 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 9 Nov 2023 15:49:15 -0800
Subject: [PATCH 0540/1487] libsnapshot: update cow estimation

Cow estimator needs to update next_data_pos_ to be in the correct
position

Test: th
Change-Id: I1e3f2c9434573197e840be5637a90c679610ac4e
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 876a45d297fa..89fd903db72d 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -322,6 +322,7 @@ bool CowWriterV3::WriteOperation(const CowOperationV3& op, const void* data, siz
     if (IsEstimating()) {
         header_.op_count++;
         header_.op_count_max++;
+        next_data_pos_ += op.data_length;
         return true;
     }
 

From 1503890fc6071c449bc9d33462c45ffd0e8e9a54 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Fri, 10 Nov 2023 00:05:49 -0800
Subject: [PATCH 0541/1487] Update to support new shared_ptr returns.

Bug: 309857311

Test: All unit tests pass.
Change-Id: Ia44ebeb558d3d1101ab63b064731656f0f89c487
---
 debuggerd/debuggerd_test.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 87c4cd2d19ab..a6d8226e3f09 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -2825,7 +2825,8 @@ TEST_F(CrasherTest, verify_build_id) {
     }
 
     prev_file = match[1];
-    unwindstack::Elf elf(unwindstack::Memory::CreateFileMemory(prev_file, 0).release());
+    auto elf_memory = unwindstack::Memory::CreateFileMemory(prev_file, 0);
+    unwindstack::Elf elf(elf_memory);
     if (!elf.Init() || !elf.valid()) {
       // Skipping invalid elf files.
       continue;

From 84e41ca0e2d39f71dde58e8cd594537c0e4b6c64 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 10 Nov 2023 22:02:00 +0000
Subject: [PATCH 0542/1487] run-as: remove a special case.

This is a change for some system apps that have /data/user_de/0/ in the
package list, but it's easier to reason about and more consistent to
always go down the same path.

Bug: http://b/308990322
Test: treehugger
Change-Id: I479485655c61e8a31fb23f779c66d54b0bb476c0
---
 run-as/run-as.cpp | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/run-as/run-as.cpp b/run-as/run-as.cpp
index e7c6e04d4f84..32057b491e04 100644
--- a/run-as/run-as.cpp
+++ b/run-as/run-as.cpp
@@ -196,14 +196,6 @@ int main(int argc, char* argv[]) {
   }
   if (setegid(old_egid) == -1) error(1, errno, "couldn't restore egid");
 
-  // Handle a multi-user data path
-  if (userId > 0) {
-    free(info.data_dir);
-    if (asprintf(&info.data_dir, "/data/user/%d/%s", userId, pkgname) == -1) {
-      error(1, errno, "asprintf failed");
-    }
-  }
-
   if (info.uid == 0) {
     error(1, 0, "unknown package: %s", pkgname);
   }
@@ -226,6 +218,12 @@ int main(int argc, char* argv[]) {
     error(1, 0, "package not debuggable: %s", pkgname);
   }
 
+  // Ensure we have the right data path for the specific user.
+  free(info.data_dir);
+  if (asprintf(&info.data_dir, "/data/user/%d/%s", userId, pkgname) == -1) {
+    error(1, errno, "asprintf failed");
+  }
+
   // Check that the data directory path is valid.
   check_data_path(pkgname, info.data_dir, userAppId);
 

From 92b29e192520e993e98d834ab9d8d2bff7f732ed Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 10 Nov 2023 16:21:28 -0800
Subject: [PATCH 0543/1487] libsnapshot: Add a test case for recent decompress
 regression.

The attached test data is a 4096 length byte run that gz compresses to
exactly 4096 bytes. This exposes an edge case in CowReader::ReadData
with v2 snapshot files.

Bug: 310191184
Test: cow_api_test
Change-Id: I35e8d7e939d607d1dc118285ebc2f636c2291a20
---
 fs_mgr/libsnapshot/Android.bp                 |   1 +
 .../libsnapshot/libsnapshot_cow/test_v2.cpp   |  31 ++++++++++++++++++
 .../tools/testdata/incompressible_block       | Bin 0 -> 4096 bytes
 3 files changed, 32 insertions(+)
 create mode 100644 fs_mgr/libsnapshot/tools/testdata/incompressible_block

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index ac58ba08f81c..a8a7716aa436 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -420,6 +420,7 @@ cc_test {
     },
     data: [
         "tools/testdata/cow_v2",
+        "tools/testdata/incompressible_block",
     ],
     auto_gen_config: true,
     require_root: false,
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 35d74bac0502..2709059dd40f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -1522,6 +1522,37 @@ TEST_F(CowTest, CompatibilityTest) {
     ASSERT_TRUE(reader.GetFooter(&footer));
 }
 
+TEST_F(CowTest, DecompressIncompressibleBlock) {
+    auto fd = OpenTestFile("incompressible_block", O_RDONLY);
+    ASSERT_GE(fd, 0);
+
+    std::string original;
+    ASSERT_TRUE(android::base::ReadFdToString(fd, &original)) << strerror(errno);
+    ASSERT_EQ(original.size(), 4096);
+
+    CowOptions options;
+    options.compression = "gz";
+    auto writer = CreateCowWriter(2, options, GetCowFd());
+    ASSERT_NE(writer, nullptr);
+    ASSERT_TRUE(writer->AddRawBlocks(0, original.data(), original.size()));
+    ASSERT_TRUE(writer->Finalize());
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    auto iter = reader.GetOpIter();
+    ASSERT_NE(iter, nullptr);
+    ASSERT_FALSE(iter->AtEnd());
+
+    std::string block(original.size(), '\0');
+    ASSERT_EQ(iter->Get()->data_length, 4096);
+    ASSERT_TRUE(ReadData(reader, iter->Get(), block.data(), block.size()));
+
+    for (size_t i = 0; i < block.size(); i++) {
+        ASSERT_EQ(block[i], original[i]) << "mismatch at byte " << i;
+    }
+}
+
 }  // namespace snapshot
 }  // namespace android
 
diff --git a/fs_mgr/libsnapshot/tools/testdata/incompressible_block b/fs_mgr/libsnapshot/tools/testdata/incompressible_block
new file mode 100644
index 0000000000000000000000000000000000000000..cc45cd04e62bf5e9bc25fb044006cfb3db1c04a0
GIT binary patch
literal 4096
zcmbWk1tS~`0|4L?)7>$<7t?0yw25<=VVHI|IUQsA^vv`zb=v9fn>I{$PIJ1uhT;1U
z-}3+f|A+OH@>=O(6Hp7M=<dywVq8}UiTwl;B%?9XOe4Cnj&(?p?oR!(00(3hr5R?#
zYD`kwH}5<#G>ZE|E$~K-YR`th!e9^no0M^w$Na3)%{o_Db=O|vn4@oK0oBl{{k3pT
zRZPEof(QLhp*I>+b@6sLib;oCQKyjOT@)`Up=<bhyI&mJkk{7hhsDX%l(zpHFQD3{
z#jIdcKXy>|>-`#tHeaRvR~z^v4Vt*_MWTZ=Rv29s**uy{psIT3$@`Y3NM!$(Hq0jv
zb-xunt?4AiF(`6=)FHwZXsb=yc#`f4n?rW{4>xWQ8B&3&Lqfc+N}f^AY#hFw#S*z9
ziXmd1?tBxZN><q@WQ{+l1id}M{5A4fxXN|CAhaUtJrbdap5pnW9rdkMG|n(O%hR>T
z)5{3E|AhT6tCWaPkEpi&pDlZNp*Rym!(y?_sL=^-V*A-AKym)9JMhB{t846EZVlSG
zoI{1aHJ&waN0(Ukn+U*N%kaMWwwB+P$5z6;l;_;)zc#uiN!FEUtTZX0>bq|(cMGq6
zZ-pgcFK#Yr;%`z`O_&B>f<lVEeA6#4>C3kYK5A|10g5ltGBMeIYWqm5YzrYw?>PhN
z5{J(Y@rXETog;E1^O?l5s}pKlTbg`m@^x$&MU0NEXh`I^+|)kC7Wo)!0}pE8Fi5RB
zdFnd?X;rk*Lfe}B8o}IZb=h&1$Mj3ZZ|y7BM7Ozdaa4q!FpqJcp&)}4N#?U?{Uj-n
z#;0*DUwH%+eqSl%c9}z`qhVT}fs|W~+24>4E|eA2-DFGyEwcMAy_PH?y`;pvjl$B0
z3BxI$+CIkdw`ayzH7s*VRsy?*2ZEUGt?cM#{G>JUF1TSd6pq2dbBnsNJPiPhd$IJe
zGG?9oubHXh*S~hsL;XbS%GC8oSC4ufeb2uD-2pb5AMwqVClxZVHJ{nwF%6s^?tU>H
zReAwZHErh+u5>Sl&iitgal}DQ@@qC<i`tGZPz#NP392&T@Xztvi9{Nur3v1?xL}>m
z3&jow!)qoKzU%p$9h1Qyp1gHk-?LvH{M~y>2)gQd$tR_**oUq#mK@4%Ao(`ZuDn<Z
zYUF;Vl<+-SKQiAvGVa~?SF1~uoXXcs&1EM_MdVog1QwjnF0t%^KW&<4i8lHR5+Z`w
z?=u{%5z_ns*EXOUG;mX{#b6Y=L1gpp@MfjpfJy3kHzlpLBsb0LX}={Emg#d&0tamP
z&Yru{dkRR#T3uW}1Y4~b(f!8+7~t}=^C*I2eA<`a#KpXIx5_kDT}G3(_!bg-vK#QH
zgBc1ScxkS)uMw3tj``+LZn7%?GvDKz3g`=pOAI$OhXpC1$&W6T(=CQWFrs)m?y~%Q
zjgxuS=v#xU(<EyrD6*|%b&Znp!-Zwn0wgr3x_$(9rXw+yR4il1e{h@)ZyQ7!jX!<f
zp&aTyVZ3l9nQ}@$RSM6tVm+0dfwCgH-=AJROKU$N1Rc4ab;oj1pVi;?I?9<dchnJQ
z+Ow&4C8*eMvOruXBuXE(5_1OR6@<aFDSX$CA>~*=;jQE2Hu9Xu-JX@7R;at5Ox$9E
zR!ehozvPw^aP9_3rr^60cU@kdDXDzwcb0Q{D@d!!*D94jLt=r3`59ZOvo8!&*%n$L
z9`GRabiHZ{BE-&prXjyRzf{`P0q9PUYpCjwLY_ucYa#Aq^vB8K%V)Ioja4ONB({EF
zwZIH~83+`n|A>cl2==)3ZP#^!$=r1>^=<G)uL@K-k8wEF>@Pifs?@OehWF~Kgr<FW
z0qyty?oJx=<GFAxjZ=5i?XF(3DE7)3gl^|PWGwK);>2ynon4<xc+Tlu7W(1Tuo?u%
zAr=I@3)o=RvG#ckd-T78r7XdNjv{TUGeInyQ9d;c#QxyO&Pn8IwV=s8dTJNp+I0P~
zUIxvH<{A)~t65@glG*3x@%4AXg*2{GNi1Rfqgqy-f{L<x`0v6Dp6EJ*+m<@pCxr?c
zg-Hu>UlCdhMXDs=vrNr$6!<q`wL5B0ydc5c6u`wlz_@Osg~%a@02DH>k6yWuM#tv|
zsahXV9Et6Yi=Seyh-3*|>&NzCWWj|eFMV<H&hE%}-u4leAq_6z)xJqxMa7RjboEEC
zFb8Qw6dQ^Dr%C2!-W@4m(R_t-)gu0%Uz$r?ak~-S&;DMF$nb~i(d&vSiVAxZrU)4U
z>~-o6c(2&dEqO|l0WZy?n|Dq7>I!3-673E4*CzYBFyrkgE8W~kzuU*!5h!9@sTP{)
z(M=_miB&~&Kr5NgmuR;b>MklP-{c-xCj|Q*J-8Ja9gn7eO<$IGfvN>+-!dMiM)(fi
zx_Ocx8(?kVrGNiC^!0I7U8;I?TJ<r_R`Op+DeA+$ox=KI0d;=JQO$(Rm#a(OQnU6l
zyk2mBGgx%VSujh{S8eoui8pfgH_x~-#*n&8rqLhFeu+&Pi}P>fbzLLCqf|5aXppdH
z`bPe9Z^iJ%vXc`aCiWChb}YQ8^Px-{a7+p4sicbud5j?2YAp1+h|@G%au+-m=mVfe
z_Wm5jI5;~{)Az{S=`L%2NS6~g{Z^@*yDmWd2kgbY0fJV*SB=djM=e!qam+eVlQ6e*
zrp>F=!2t!fl!@p}z0{#oM}$3ciKo`$6j9pxa29wZ6go=~Six$p;r%=pg3grZSHbC1
z50cWx37Ae6u9^JtEs34SR5wMIxFrX?Lyw#lYENW?W#&{pHY!(c3v1G;W8g*uJzK_u
zhD`quW<Mw+pS%+_?6T!zN6A=mvMDSz5I?r1r^>g|j1CFXo+HhrEG;o}Ta_Yy3&)eU
z!lu|T*uT&blr91VB+@8-tfefHe+FM4+Gt8DGBemwa+FdZn~+;(#u8dDp&=k`Dfui;
zJ`2txTblt?mPAx3jd`a5LYZ_sEd7oq;=Fq8Q#P{4Yi&QxD#}?#IuXK#(J)e)hkD1l
zSIgAzy*wlauV8@H0A^XC?{5V0z*=wNj!WS+ZA&~dp@45D@`)zM7E-wxRf5|}b$;J{
zW%fqTsSV!h0BGH88{AI{d_ivwK`WW-!xvpvt!y<8wi^z%s>m5X7`Jy7om(xYYxOvb
z8ue@SVPctijplh=$Fw+UUCk7^MP$kvzcMq5x{BV|eQ3^#YMs!rmJOYJ^!UhQ`)jP_
z;b{;VLlWi6HZERqO6Hx?EwMUE6<oyYfyF<AGMtdFO0WQ;@uh$KJt?xY&Y=3kydvN(
z?J@bI;@h#wS}>(Ooml$<O~r(nKEBTDmsf+2AowY_;P1=TX+-^PCM%6|He2w*`DHTD
zEq)%y%@%WB-dN2eJ0Skb1w)%z*DuX279sA)vp9QnF`rK}uubTbT;}<%Gu;${s_W#N
z!$#$nwvy6ok6e%xCz7}nuF~Y_V2328VQ2rO_QT{0b*LLarbbegY<?}E>5Le#EZ%5@
zs|X_J6R^ww1<%jvS!Lb*StI>&{&9rQFftM)b{6-smM;87DkZS>`LtdGS1#KG25hmx
zDI0IjSbrHGns0jR>qg%8+Y?lxpg!hzoYjl!q`AA3{*Ei&{kSt|GXWkeg`WV3QDIbx
ztI2{NUBp0shfW3tZno#w%@!ylp+Jo!8)VFguL!Xvis&ZnyfJ!eA6eG$)j)`AK?PUO
zdU=}3(vkE%$MEdMvk&$0Uti3C6Lho0b8l(a%WK!-pJL=hHY3_cyynRr$#lMeEBGYY
z*CS{nuZs7$_MCK8OjNEuuM<26#n9(Trt?LbI2{ZSTpR|>Fqk@t5|iVN`Fgh*{o>{#
zPx+f{$KctLTFxQ}Er*Hwm+AG@-vM$j3)p{>51pOhe4IqSHsnLh?<~^Yi3Unw8Z~0^
ziKLC#_NE9!3VTbtSH@G4l-QF}sMt;!-$UlySEIur>B1&U%&n&xKqbU<QtG1P^yEIC
zo><iif>qbBBQ|8j#0{uV-`1b(yMuD{z$EuJu9F^^G<~)qvtV#ui*ig--k1shKB68F
zr2bxA%ZN;N{TfC@r_hRZT&LoS0UhO_sUyjK-n7V;Ot>yaRIk}aOt$6l9e|WVoS|Qc
z)yJ&H7PlY<4jp3bH7mx)$8!F{%AU9kJv2RK$$egRl{U?<uA*_bN~%dduiU#`rR!a+
zCOsi(RQ17I(vrJUgU|}M{J4hzp_Zh8yx!55vucx5SoQ;&!MxPTgkF6MTOib=45awQ
z41@<=0ZlE-NX;0gbl{ZzDvf>UZiaw@p;Q33cNL-73Gli4!jp7CId{)kd5Rcccg*>_
zXUodo;f=fCUanKVC@fCPwzB03-t?~v%apXcA1E1hNn$@A?vjsoy^DDv<Tmrk6Y~^B
z+y5UT@9=f?V0|9#-Ll(%l6K@fbg4X#e8%~Ad3{%AYc%Tp%yYFaV9Xgp`gLu-hK;zD
zJP`IDt+NM!C8uS68^QeZ`4Ufdw{WY)gCc#{ny<5z*>AbE9A_MgM!NR?9M1Y151;{O
zk`|Ci&p|^sU+owl);jSVW&!W<uVgh4YwC057c4VmX5|151(Z;iA>+)7C~16e{M~Jo
zJMHowjGPJwoS-fIvBBKA{F$C6O?5bBL5vKz#Uujt^8*UYGc}WnMD4-sE<L*vdQ~!b
zq6g(Y&uDX?5jc{3KhJI1v0anW*Sp{3gw0BQaBYlP)Az*A^Xa?MH=|jlg|5)VpHy-u
z*07{ku}d#XoU1SRFourV-`g@8a12?JEfM~6z4@o?W8|@_TD$Pj?ybPp<)gap82F}I
z0j;&)t?L^gK%rE98Z%AoJGI1+Wu6>g`BVOpB}ih=*Z2Ji_!VbNR=Hd);bNfS;%2uN
za1I-H^ez|nN9r2($(V4yC~rTxx)fmiR%e;IC*w=rUt3OTprm%Pc{s1cHr;=wb|@v4
zp>{X<6fpjG0$LqzBwo@J9RXEcOC3ZH|Mv@}*o^z|Ssj5nI{{w`o-viU=E^LFJTcT;
z*<*hw+r4Et!P`J5AMi!LMFcL9OQ)F7+WN*==x0v?WqqUgGi_r*f6mJFP21~^dE^HX
zk?XI`cAvRSiUacTUAV>11)#9d`5dqiM{>NZQ=>R>n2Ps83Xtk6uf?+T3@f(7n@Z4e
zX_z2O_#YR#0=_@$&XEm-p=d#+H2Peun^a*|L8LmKc;NbA{_(3a7LOu)GmF+%NLrTz
zx+!QM8r*FUyeDci|IAOP^Q;z2MGWLq*p?aMCg<~jHM&n_^YkYDGFx?!;zk5w%)(Kj
z$iW_)HGeBs(lyDddtT`#91|+p*`reSy-1F+ALBkZ%?||G$kb9Yo@v$uSkwt@UnjnW
n+4w>AtwkU!w`JQd0)yo9nk=0jteFGNry9#ZHMl$h6$Rvf*O%E@

literal 0
HcmV?d00001


From c1a18756dc2f0a28f32b076e3f9f46b09aac0825 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 9 Nov 2023 14:00:48 -0800
Subject: [PATCH 0544/1487] libsnapshot: v3 writer GetCowSize

Cow size should just be wherever the last data position is written. In
v3 we no longer have a footer, so this calculation is simple. This
function is used by cow estimator

Test: cow_api_test
Change-Id: I08204e2d560b120450019a529baa41de9b8e66d5
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 89fd903db72d..7fe7b4157e23 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -360,9 +360,7 @@ bool CowWriterV3::Finalize() {
 }
 
 uint64_t CowWriterV3::GetCowSize() {
-    LOG(ERROR) << __LINE__ << " " << __FILE__
-               << " <- Get Cow Size function here should never be called";
-    return 0;
+    return next_data_pos_;
 }
 
 }  // namespace snapshot

From a50345376730f98252cf771b20d8c7e7e7682074 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 13 Nov 2023 14:53:28 -0800
Subject: [PATCH 0545/1487] libsnapshot: update FindResumeOp type

Update FindResumeOp to take in a uint64_t to match the value of the
caller function

Test: ota with following CL
Change-Id: I19568d119b7ebd75ea9e98970b311ae7da92ff0e
---
 fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp | 2 +-
 fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
index d411ab94595a..695913a32bd7 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
@@ -82,7 +82,7 @@ bool CowParserV3::ReadResumeBuffer(borrowed_fd fd) {
                                             header_.prefix.header_size + header_.buffer_size);
 }
 
-std::optional<uint32_t> CowParserV3::FindResumeOp(const uint32_t label) {
+std::optional<uint32_t> CowParserV3::FindResumeOp(const uint64_t label) {
     for (auto& resume_point : *resume_points_) {
         if (resume_point.label == label) {
             return resume_point.op_index;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
index dceb815fe6dd..fe3a2fb182f8 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
@@ -49,7 +49,7 @@ class CowParserV3 final : public CowParserBase {
 
   private:
     bool ParseOps(android::base::borrowed_fd fd, const uint32_t op_index);
-    std::optional<uint32_t> FindResumeOp(const uint32_t label);
+    std::optional<uint32_t> FindResumeOp(const uint64_t label);
     off_t GetDataOffset() const;
     CowHeaderV3 header_ = {};
     std::shared_ptr<std::vector<CowOperationV3>> ops_;

From f897650f6ef61db2e1ccb850527362aa9cbb5fa7 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 13 Nov 2023 11:05:35 -0800
Subject: [PATCH 0546/1487] libsnapshot: resume_point_count

We want to add a resume_point_count in the header to represent how many
resume points we've written. In the case that we've written less than
resume_buffer_size, we only want to read the valid resume points.

without these changes incremental OTA runs into segfault or have faulty
data when trying to FindResumeOp() as our resume points contain invalid
entries

Test: full ota followed by inc ota on cuttlefish
Change-Id: I0a8971955439639f2d0f39d9d518c1145ae15c3d
---
 fs_mgr/libsnapshot/include/libsnapshot/cow_format.h | 4 +++-
 fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp    | 8 ++++----
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp    | 8 +++++---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h      | 4 ++--
 4 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 8917116d09cb..2079609c0eac 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -107,8 +107,10 @@ static constexpr uint8_t kNumResumePoints = 4;
 struct CowHeaderV3 : public CowHeader {
     // Location of sequence buffer in COW.
     uint64_t sequence_buffer_offset;
+    // number of currently written resume points
+    uint32_t resume_point_count;
     // Size, in bytes, of the CowResumePoint buffer.
-    uint32_t resume_buffer_size;
+    uint32_t resume_point_max;
     // Number of CowOperationV3 structs in the operation buffer, currently and total
     // region size.
     uint32_t op_count;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
index 695913a32bd7..778ba6270c57 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
@@ -75,10 +75,10 @@ bool CowParserV3::Parse(borrowed_fd fd, const CowHeaderV3& header, std::optional
 }
 
 bool CowParserV3::ReadResumeBuffer(borrowed_fd fd) {
-    resume_points_ = std::make_shared<std::vector<ResumePoint>>(header_.resume_buffer_size);
+    resume_points_ = std::make_shared<std::vector<ResumePoint>>(header_.resume_point_count);
 
     return android::base::ReadFullyAtOffset(fd, resume_points_->data(),
-                                            header_.resume_buffer_size * sizeof(ResumePoint),
+                                            header_.resume_point_count * sizeof(ResumePoint),
                                             header_.prefix.header_size + header_.buffer_size);
 }
 
@@ -96,7 +96,7 @@ std::optional<uint32_t> CowParserV3::FindResumeOp(const uint64_t label) {
 
 off_t CowParserV3::GetDataOffset() const {
     return sizeof(CowHeaderV3) + header_.buffer_size +
-           header_.resume_buffer_size * sizeof(ResumePoint) +
+           header_.resume_point_max * sizeof(ResumePoint) +
            header_.op_count_max * sizeof(CowOperation);
 }
 
@@ -105,7 +105,7 @@ bool CowParserV3::ParseOps(borrowed_fd fd, const uint32_t op_index) {
     ops_->resize(op_index);
 
     const off_t offset = header_.prefix.header_size + header_.buffer_size +
-                         header_.resume_buffer_size * sizeof(ResumePoint);
+                         header_.resume_point_max * sizeof(ResumePoint);
     if (!android::base::ReadFullyAtOffset(fd, ops_->data(), ops_->size() * sizeof(CowOperationV3),
                                           offset)) {
         PLOG(ERROR) << "read ops failed";
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 7fe7b4157e23..e8dad922a1f8 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -78,7 +78,8 @@ void CowWriterV3::SetupHeaders() {
     // WIP: not quite sure how some of these are calculated yet, assuming buffer_size is determined
     // during COW size estimation
     header_.sequence_buffer_offset = 0;
-    header_.resume_buffer_size = kNumResumePoints;
+    header_.resume_point_count = 0;
+    header_.resume_point_max = kNumResumePoints;
     header_.op_count = 0;
     header_.op_count_max = 0;
     header_.compression_algorithm = kCowCompressNone;
@@ -296,12 +297,13 @@ bool CowWriterV3::EmitLabel(uint64_t label) {
             resume_points_->end());
 
     resume_points_->push_back({label, header_.op_count});
+    header_.resume_point_count++;
     // remove the oldest resume point if resume_buffer is full
-    while (resume_points_->size() > header_.resume_buffer_size) {
+    while (resume_points_->size() > header_.resume_point_max) {
         resume_points_->erase(resume_points_->begin());
     }
 
-    CHECK_LE(resume_points_->size(), header_.resume_buffer_size);
+    CHECK_LE(resume_points_->size(), header_.resume_point_max);
 
     if (!android::base::WriteFullyAtOffset(fd_, resume_points_->data(),
                                            resume_points_->size() * sizeof(ResumePoint),
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 8a2bd2c6ddfe..e928d355772f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -52,12 +52,12 @@ class CowWriterV3 : public CowWriterBase {
     off_t GetOpOffset(uint32_t op_index) const {
         CHECK_LT(op_index, header_.op_count_max);
         return header_.prefix.header_size + header_.buffer_size +
-               (header_.resume_buffer_size * sizeof(ResumePoint)) +
+               (header_.resume_point_max * sizeof(ResumePoint)) +
                (op_index * sizeof(CowOperationV3));
     }
     off_t GetDataOffset() const {
         return sizeof(CowHeaderV3) + header_.buffer_size +
-               (header_.resume_buffer_size * sizeof(ResumePoint)) +
+               (header_.resume_point_max * sizeof(ResumePoint)) +
                header_.op_count_max * sizeof(CowOperation);
     }
     off_t GetResumeOffset() const { return sizeof(CowHeaderV3) + header_.buffer_size; }

From f1f06f86786794ede887a8608f2dd2e0bf95de6a Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 13 Nov 2023 22:06:37 -0800
Subject: [PATCH 0547/1487] libsnapshot: Check if OTA update in progress during
 reboot

If any of the read-only partitions are mounted off dm-user
then certainly update is in-progress.

Bug: 308900853
Test: OTA on Pixel, reboot during OTA.
Change-Id: I36121e1d99ec7c1f1110a65fc67996190875af18
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshot.cpp | 40 ++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 21 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index c639e43d3555..e91e3b73cf87 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -4339,32 +4339,30 @@ std::string SnapshotManager::ReadSourceBuildFingerprint() {
 }
 
 bool SnapshotManager::IsUserspaceSnapshotUpdateInProgress() {
-    auto slot = GetCurrentSlot();
-    if (slot == Slot::Target) {
-        // Merge in-progress
-        if (IsSnapuserdRequired()) {
-            return true;
-        }
-    }
-
-    // Let's check more deeper to see if snapshots are mounted
-    auto lock = LockExclusive();
-    if (!lock) {
-        return false;
-    }
-
-    std::vector<std::string> snapshots;
-    if (!ListSnapshots(lock.get(), &snapshots)) {
+    // We cannot grab /metadata/ota lock here as this
+    // is in reboot path. See b/308900853
+    //
+    // Check if any of the partitions are mounted
+    // off dm-user block device. If so, then we are certain
+    // that OTA update in progress.
+    auto current_suffix = device_->GetSlotSuffix();
+    auto& dm = DeviceMapper::Instance();
+    auto dm_block_devices = dm.FindDmPartitions();
+    if (dm_block_devices.empty()) {
+        LOG(ERROR) << "No dm-enabled block device is found.";
         return false;
     }
-
-    for (const auto& snapshot : snapshots) {
-        // Active snapshot and daemon is alive
-        if (IsSnapshotDevice(snapshot) && EnsureSnapuserdConnected(2s)) {
+    for (auto& partition : dm_block_devices) {
+        std::string partition_name = partition.first + current_suffix;
+        DeviceMapper::TargetInfo snap_target;
+        if (!GetSingleTarget(partition_name, TableQuery::Status, &snap_target)) {
+            return false;
+        }
+        auto type = DeviceMapper::GetTargetType(snap_target.spec);
+        if (type == "user") {
             return true;
         }
     }
-
     return false;
 }
 

From 109932146d392da31139c43d4e34e8178bbc73b8 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Mon, 13 Nov 2023 13:42:13 -0800
Subject: [PATCH 0548/1487] Attempt process kill even if cgroup is already
 removed

Test: th
Bug: 308900853
Change-Id: I21ae5bacf4a25cc06a1fd47e2aadbf5ae22661a7
---
 init/service.cpp | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/init/service.cpp b/init/service.cpp
index 311a13299d6a..d351a8fe17af 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -196,11 +196,12 @@ void Service::NotifyStateChange(const std::string& new_state) const {
 }
 
 void Service::KillProcessGroup(int signal) {
-    // If we've already seen a successful result from killProcessGroup*(), then we have removed
-    // the cgroup already and calling these functions a second time will simply result in an error.
-    // This is true regardless of which signal was sent.
-    // These functions handle their own logging, so no additional logging is needed.
-    if (!process_cgroup_empty_) {
+    // Always attempt the process kill if process is still running.
+    // Cgroup clean up routines are idempotent. It's safe to call
+    // killProcessGroup repeatedly. During shutdown, `init` will
+    // call this function to send SIGTERM/SIGKILL to all processes.
+    // These signals must be sent for a successful shutdown.
+    if (!process_cgroup_empty_ || IsRunning()) {
         LOG(INFO) << "Sending signal " << signal << " to service '" << name_ << "' (pid " << pid_
                   << ") process group...";
         int r;

From 59ce7a45d19f4de1cf3ace2e6a6c6858effbf891 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 14 Nov 2023 10:15:28 -0800
Subject: [PATCH 0549/1487] libsnapshot: update offset functions

Since these functions are used across both parser and writer, updating
it as inline functions in cow_format.

Test: cow_api_test
Change-Id: I9824684e3b9b48947accce935335d4019d745ae0
---
 fs_mgr/libsnapshot/include/libsnapshot/cow_format.h | 13 +++++++++++++
 fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp    | 12 +++---------
 fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h      |  1 -
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp    |  8 ++++----
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h      | 13 -------------
 5 files changed, 20 insertions(+), 27 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 2079609c0eac..75467cb79b1d 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -232,6 +232,19 @@ static inline uint64_t GetCowOpSourceInfoData(const CowOperation& op) {
     return op.source_info & kCowOpSourceInfoDataMask;
 }
 
+static constexpr off_t GetOpOffset(uint32_t op_index, const CowHeaderV3 header) {
+    return header.prefix.header_size + header.buffer_size +
+           (header.resume_point_max * sizeof(ResumePoint)) + (op_index * sizeof(CowOperationV3));
+}
+static constexpr off_t GetDataOffset(const CowHeaderV3 header) {
+    return header.prefix.header_size + header.buffer_size +
+           (header.resume_point_max * sizeof(ResumePoint)) +
+           header.op_count_max * sizeof(CowOperation);
+}
+static constexpr off_t GetResumeOffset(const CowHeaderV3 header) {
+    return header.prefix.header_size + header.buffer_size;
+}
+
 struct CowFooter {
     CowFooterOperation op;
     uint8_t unused[64];
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
index 778ba6270c57..52c6348b6657 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
@@ -94,18 +94,12 @@ std::optional<uint32_t> CowParserV3::FindResumeOp(const uint64_t label) {
     return std::nullopt;
 }
 
-off_t CowParserV3::GetDataOffset() const {
-    return sizeof(CowHeaderV3) + header_.buffer_size +
-           header_.resume_point_max * sizeof(ResumePoint) +
-           header_.op_count_max * sizeof(CowOperation);
-}
-
 bool CowParserV3::ParseOps(borrowed_fd fd, const uint32_t op_index) {
     ops_ = std::make_shared<std::vector<CowOperationV3>>();
     ops_->resize(op_index);
 
-    const off_t offset = header_.prefix.header_size + header_.buffer_size +
-                         header_.resume_point_max * sizeof(ResumePoint);
+    // read beginning of operation buffer -> so op_index = 0
+    const off_t offset = GetOpOffset(0, header_);
     if (!android::base::ReadFullyAtOffset(fd, ops_->data(), ops_->size() * sizeof(CowOperationV3),
                                           offset)) {
         PLOG(ERROR) << "read ops failed";
@@ -113,7 +107,7 @@ bool CowParserV3::ParseOps(borrowed_fd fd, const uint32_t op_index) {
     }
 
     // fill out mapping of XOR op data location
-    uint64_t data_pos = GetDataOffset();
+    uint64_t data_pos = GetDataOffset(header_);
 
     xor_data_loc_ = std::make_shared<std::unordered_map<uint64_t, uint64_t>>();
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
index fe3a2fb182f8..afc01afcc961 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.h
@@ -50,7 +50,6 @@ class CowParserV3 final : public CowParserBase {
   private:
     bool ParseOps(android::base::borrowed_fd fd, const uint32_t op_index);
     std::optional<uint32_t> FindResumeOp(const uint64_t label);
-    off_t GetDataOffset() const;
     CowHeaderV3 header_ = {};
     std::shared_ptr<std::vector<CowOperationV3>> ops_;
     bool ReadResumeBuffer(android::base::borrowed_fd fd);
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index e8dad922a1f8..6883c5e93058 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -170,7 +170,7 @@ bool CowWriterV3::OpenForWrite() {
         LOG(ERROR) << "Header sync failed";
         return false;
     }
-    next_data_pos_ = GetDataOffset();
+    next_data_pos_ = GetDataOffset(header_);
     return true;
 }
 
@@ -192,7 +192,7 @@ bool CowWriterV3::OpenForAppend(uint64_t label) {
 
     resume_points_ = parser.resume_points();
     options_.block_size = header_.block_size;
-    next_data_pos_ = GetDataOffset();
+    next_data_pos_ = GetDataOffset(header_);
 
     TranslatedCowOps ops;
     parser.Translate(&ops);
@@ -307,7 +307,7 @@ bool CowWriterV3::EmitLabel(uint64_t label) {
 
     if (!android::base::WriteFullyAtOffset(fd_, resume_points_->data(),
                                            resume_points_->size() * sizeof(ResumePoint),
-                                           GetResumeOffset())) {
+                                           GetResumeOffset(header_))) {
         PLOG(ERROR) << "writing resume buffer failed";
         return false;
     }
@@ -333,7 +333,7 @@ bool CowWriterV3::WriteOperation(const CowOperationV3& op, const void* data, siz
         return false;
     }
 
-    const off_t offset = GetOpOffset(header_.op_count);
+    const off_t offset = GetOpOffset(header_.op_count, header_);
     if (!android::base::WriteFullyAtOffset(fd_, &op, sizeof(op), offset)) {
         PLOG(ERROR) << "write failed for " << op << " at " << offset;
         return false;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index e928d355772f..3dfc33cea032 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -49,19 +49,6 @@ class CowWriterV3 : public CowWriterBase {
                     uint16_t offset, uint8_t type);
     bool CompressBlocks(size_t num_blocks, const void* data);
 
-    off_t GetOpOffset(uint32_t op_index) const {
-        CHECK_LT(op_index, header_.op_count_max);
-        return header_.prefix.header_size + header_.buffer_size +
-               (header_.resume_point_max * sizeof(ResumePoint)) +
-               (op_index * sizeof(CowOperationV3));
-    }
-    off_t GetDataOffset() const {
-        return sizeof(CowHeaderV3) + header_.buffer_size +
-               (header_.resume_point_max * sizeof(ResumePoint)) +
-               header_.op_count_max * sizeof(CowOperation);
-    }
-    off_t GetResumeOffset() const { return sizeof(CowHeaderV3) + header_.buffer_size; }
-
   private:
     CowHeaderV3 header_{};
     CowCompression compression_;

From 889a5d23af3f73023a11d33b773b5f4ac1eb849b Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 13 Nov 2023 20:10:34 -0800
Subject: [PATCH 0550/1487] Disable partition verification when device boots on
 snapshot

No need partition verification when device boots on snapshot without
slot switch.

This also saves couple of seconds of boot time.

Bug: 299011882
Test: Boot device on snapshot, OTA on Pixel
Change-Id: I5b781de7e0f745bbfe9646f88ca912139b2d853e
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../snapuserd/user-space-merge/handler_manager.cpp    |  5 ++---
 .../snapuserd/user-space-merge/handler_manager.h      | 11 +++++++----
 .../snapuserd/user-space-merge/snapuserd_server.cpp   |  9 ++++-----
 .../snapuserd/user-space-merge/snapuserd_server.h     |  2 ++
 .../snapuserd/user-space-merge/snapuserd_test.cpp     |  3 ++-
 5 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index d979e20c0c0a..ffd7a4b8b6ee 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -51,11 +51,10 @@ SnapshotHandlerManager::SnapshotHandlerManager() {
 std::shared_ptr<HandlerThread> SnapshotHandlerManager::AddHandler(
         const std::string& misc_name, const std::string& cow_device_path,
         const std::string& backing_device, const std::string& base_path_merge,
-        std::shared_ptr<IBlockServerOpener> opener, int num_worker_threads, bool use_iouring,
-        bool perform_verification) {
+        std::shared_ptr<IBlockServerOpener> opener, int num_worker_threads, bool use_iouring) {
     auto snapuserd = std::make_shared<SnapshotHandler>(misc_name, cow_device_path, backing_device,
                                                        base_path_merge, opener, num_worker_threads,
-                                                       use_iouring, perform_verification);
+                                                       use_iouring, perform_verification_);
     if (!snapuserd->InitCowDevice()) {
         LOG(ERROR) << "Failed to initialize Snapuserd";
         return nullptr;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
index b1605f0989fe..ff6ee8f1053f 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
@@ -57,8 +57,7 @@ class ISnapshotHandlerManager {
                                                       const std::string& backing_device,
                                                       const std::string& base_path_merge,
                                                       std::shared_ptr<IBlockServerOpener> opener,
-                                                      int num_worker_threads, bool use_iouring,
-                                                      bool perform_verification) = 0;
+                                                      int num_worker_threads, bool use_iouring) = 0;
 
     // Start serving requests on a snapshot handler.
     virtual bool StartHandler(const std::string& misc_name) = 0;
@@ -84,6 +83,9 @@ class ISnapshotHandlerManager {
 
     // Returns whether all snapshots have verified.
     virtual bool GetVerificationStatus() = 0;
+
+    // Disable partition verification
+    virtual void DisableVerification() = 0;
 };
 
 class SnapshotHandlerManager final : public ISnapshotHandlerManager {
@@ -94,8 +96,7 @@ class SnapshotHandlerManager final : public ISnapshotHandlerManager {
                                               const std::string& backing_device,
                                               const std::string& base_path_merge,
                                               std::shared_ptr<IBlockServerOpener> opener,
-                                              int num_worker_threads, bool use_iouring,
-                                              bool perform_verification) override;
+                                              int num_worker_threads, bool use_iouring) override;
     bool StartHandler(const std::string& misc_name) override;
     bool DeleteHandler(const std::string& misc_name) override;
     bool InitiateMerge(const std::string& misc_name) override;
@@ -104,6 +105,7 @@ class SnapshotHandlerManager final : public ISnapshotHandlerManager {
     void TerminateMergeThreads() override;
     double GetMergePercentage() override;
     bool GetVerificationStatus() override;
+    void DisableVerification() override { perform_verification_ = false; }
 
   private:
     bool StartHandler(const std::shared_ptr<HandlerThread>& handler);
@@ -128,6 +130,7 @@ class SnapshotHandlerManager final : public ISnapshotHandlerManager {
     int num_partitions_merge_complete_ = 0;
     std::queue<std::shared_ptr<HandlerThread>> merge_handlers_;
     android::base::unique_fd monitor_merge_event_fd_;
+    bool perform_verification_ = true;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index 13b9a00b8a4b..6eee3571bb5a 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -360,16 +360,15 @@ std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string&
         num_worker_threads = 1;
     }
 
-    bool perform_verification = true;
-    if (android::base::EndsWith(misc_name, "-init") || is_socket_present_) {
-        perform_verification = false;
+    if (android::base::EndsWith(misc_name, "-init") || is_socket_present_ ||
+        (access(kBootSnapshotsWithoutSlotSwitch, F_OK) == 0)) {
+        handlers_->DisableVerification();
     }
 
     auto opener = block_server_factory_->CreateOpener(misc_name);
 
     return handlers_->AddHandler(misc_name, cow_device_path, backing_device, base_path_merge,
-                                 opener, num_worker_threads, io_uring_enabled_,
-                                 perform_verification);
+                                 opener, num_worker_threads, io_uring_enabled_);
 }
 
 bool UserSnapshotServer::WaitForSocket() {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index be285412f903..99260713bd95 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -40,6 +40,8 @@ namespace snapshot {
 
 static constexpr uint32_t kMaxPacketSize = 512;
 static constexpr uint8_t kMaxMergeThreads = 2;
+static constexpr char kBootSnapshotsWithoutSlotSwitch[] =
+        "/metadata/ota/snapshot-boot-without-slot-switch";
 
 class UserSnapshotServer {
   private:
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index bed71cf9f6e0..73c3cbfbb2e2 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -627,9 +627,10 @@ void SnapuserdTest::CreateCowDeviceOrderedOps() {
 void SnapuserdTest::InitCowDevice() {
     auto factory = harness_->GetBlockServerFactory();
     auto opener = factory->CreateOpener(system_device_ctrl_name_);
+    handlers_->DisableVerification();
     auto handler =
             handlers_->AddHandler(system_device_ctrl_name_, cow_system_->path, base_dev_->GetPath(),
-                                  base_dev_->GetPath(), opener, 1, GetParam(), false);
+                                  base_dev_->GetPath(), opener, 1, GetParam());
     ASSERT_NE(handler, nullptr);
     ASSERT_NE(handler->snapuserd(), nullptr);
 #ifdef __ANDROID__

From e4f981dce04b312e6c56e833c5c33097008e25fd Mon Sep 17 00:00:00 2001
From: Daniel Norman <danielnorman@google.com>
Date: Tue, 14 Nov 2023 22:26:48 +0000
Subject: [PATCH 0551/1487] Assigns system user/group to /dev/hidraw* devices.

This allows system_server to access these devices.

Note: This also matches existing ueventd rules used by any
device which followed the Sensor HAL's dynamic sensor README.

Bug: 303522222
Test: ls -l /dev/hidraw0
Change-Id: I0830aca77422d6cab64af05dba1554667737760c
---
 rootdir/ueventd.rc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rootdir/ueventd.rc b/rootdir/ueventd.rc
index 60dcc2a95c9f..3927501a4748 100644
--- a/rootdir/ueventd.rc
+++ b/rootdir/ueventd.rc
@@ -71,6 +71,7 @@ subsystem vfio
 /dev/mtp_usb              0660   root       mtp
 /dev/usb_accessory        0660   root       usb
 /dev/tun                  0660   system     vpn
+/dev/hidraw*              0660   system     system
 
 # CDMA radio interface MUX
 /dev/ppp                  0660   radio      vpn

From 459edb0bd09abe8a56a8b0c279fcb69ee44257bb Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Mon, 13 Nov 2023 13:35:44 -0800
Subject: [PATCH 0552/1487] Make RemoveCgroup idempotent

When attempting to remove a cgroup, a ENOENT means this cgroup is
already removed. Treat such errno as success for idempotency.

Test: th
Bug: 308900853
Change-Id: I6ef3c25f03d185194205b3845784d284fdc4d444
---
 libprocessgroup/processgroup.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index d352f0e346e2..6d075384f982 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -219,6 +219,12 @@ static int RemoveCgroup(const char* cgroup, uid_t uid, int pid, unsigned int ret
 
     while (retries--) {
         ret = rmdir(uid_pid_path.c_str());
+        // If we get an error 2 'No such file or directory' , that means the
+        // cgroup is already removed, treat it as success and return 0 for
+        // idempotency.
+        if (ret < 0 && errno == ENOENT) {
+            ret = 0;
+        }
         if (!ret || errno != EBUSY || !retries) break;
         std::this_thread::sleep_for(5ms);
     }
@@ -228,6 +234,9 @@ static int RemoveCgroup(const char* cgroup, uid_t uid, int pid, unsigned int ret
         // so free up the kernel resources for the UID level cgroup.
         const auto uid_path = ConvertUidToPath(cgroup, uid);
         ret = rmdir(uid_path.c_str());
+        if (ret < 0 && errno == ENOENT) {
+            ret = 0;
+        }
     }
 
     return ret;

From a720fe785c2f548743a2c7d110141384b3a61261 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <jaegeuk@google.com>
Date: Wed, 15 Nov 2023 08:34:20 -0800
Subject: [PATCH 0553/1487] Use target device mapper given mapper target

Let's translate /dev/block/mapper for dm libs.

Bug: 311084775
Change-Id: I23666c5590a15652192e004e1990edd73b7a8df8
Signed-off-by: Jaegeuk Kim <jaegeuk@google.com>
---
 fs_mgr/libdm/dm.cpp             | 8 ++++++--
 fs_mgr/libdm/include/libdm/dm.h | 4 ++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index 3a9ed9b1a4de..e261aa3012f2 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -612,8 +612,12 @@ std::string DeviceMapper::GetTargetType(const struct dm_target_spec& spec) {
 
 std::optional<std::string> ExtractBlockDeviceName(const std::string& path) {
     static constexpr std::string_view kDevBlockPrefix("/dev/block/");
-    if (android::base::StartsWith(path, kDevBlockPrefix)) {
-        return path.substr(kDevBlockPrefix.length());
+    std::string real_path;
+    if (!android::base::Realpath(path, &real_path)) {
+        real_path = path;
+    }
+    if (android::base::StartsWith(real_path, kDevBlockPrefix)) {
+        return real_path.substr(kDevBlockPrefix.length());
     }
     return {};
 }
diff --git a/fs_mgr/libdm/include/libdm/dm.h b/fs_mgr/libdm/include/libdm/dm.h
index 3e7ecc645eec..22c475f1ed84 100644
--- a/fs_mgr/libdm/include/libdm/dm.h
+++ b/fs_mgr/libdm/include/libdm/dm.h
@@ -52,8 +52,8 @@ enum class DmDeviceState { INVALID, SUSPENDED, ACTIVE };
 
 static constexpr uint64_t kSectorSize = 512;
 
-// Returns `path` without /dev/block prefix if and only if `path` starts with
-// that prefix.
+// Returns `path` without /dev/block prefix if `path` starts with that prefix.
+// Or, if `path` is a symlink, do the same with its real path.
 std::optional<std::string> ExtractBlockDeviceName(const std::string& path);
 
 // This interface is for testing purposes. See DeviceMapper proper for what these methods do.

From 0f64c8e23e3cf414e6a38c12f10a257fe9db6271 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Wed, 8 Nov 2023 09:03:10 -0800
Subject: [PATCH 0554/1487] Allow to set scudo allocation buffer size

This is used for fullmte builds, which are optimized for bug detection.

Bug: 309446692
Change-Id: I004635ebb7e1161e63012935271851c806cb8574
---
 rootdir/Android.mk         | 6 ++++++
 rootdir/init.environ.rc.in | 1 +
 2 files changed, 7 insertions(+)

diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index cc6b64a3f4ec..7deb17324ea9 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -72,6 +72,11 @@ ifneq ($(filter hwaddress,$(SANITIZE_TARGET)),)
   endif
 endif
 
+EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE :=
+ifneq ($(PRODUCT_SCUDO_ALLOCATION_RING_BUFFER_SIZE),)
+  EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE := export SCUDO_ALLOCATION_RING_BUFFER_SIZE $(PRODUCT_SCUDO_ALLOCATION_RING_BUFFER_SIZE)
+endif
+
 EXPORT_GLOBAL_GCOV_OPTIONS :=
 ifeq ($(NATIVE_COVERAGE),true)
   EXPORT_GLOBAL_GCOV_OPTIONS := export GCOV_PREFIX /data/misc/trace
@@ -216,6 +221,7 @@ $(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/init.environ.rc.in
 	$(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' $@
+	$(hide) sed -i -e 's?%EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE%?$(EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE)?g' $@
 
 # Append PLATFORM_VNDK_VERSION to base name.
 define append_vndk_version
diff --git a/rootdir/init.environ.rc.in b/rootdir/init.environ.rc.in
index bf6e986c4758..7ba1f46e7a7f 100644
--- a/rootdir/init.environ.rc.in
+++ b/rootdir/init.environ.rc.in
@@ -14,3 +14,4 @@ on early-init
     %EXPORT_GLOBAL_GCOV_OPTIONS%
     %EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS%
     %EXPORT_GLOBAL_HWASAN_OPTIONS%
+    %EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE%

From df98534e199ecfeab0e464e4582a1bb3dd492016 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Mon, 13 Nov 2023 15:19:43 -0800
Subject: [PATCH 0555/1487] libprocessgroup: Make a log message more detailed

For log messages like the following it is not possible to derive why
this message has been logged:

E libprocessgroup: AddTidToCgroup failed to write '3949'; fd=55: Operation not supported on transport endpoint

Hence include the cgroup path and the tid type in the log message.

Change-Id: I057711fe576b82f6454456b7284186ddeece33c3
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 libprocessgroup/task_profiles.cpp | 12 +++++++-----
 libprocessgroup/task_profiles.h   |  2 +-
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index f51b07671bf1..fe3c37565c47 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -316,7 +316,7 @@ SetCgroupAction::SetCgroupAction(const CgroupController& c, const std::string& p
     FdCacheHelper::Init(controller_.GetProcsFilePath(path_, 0, 0), fd_[ProfileAction::RCT_PROCESS]);
 }
 
-bool SetCgroupAction::AddTidToCgroup(int tid, int fd, const char* controller_name) {
+bool SetCgroupAction::AddTidToCgroup(int tid, int fd, ResourceCacheType cache_type) const {
     if (tid <= 0) {
         return true;
     }
@@ -332,6 +332,7 @@ bool SetCgroupAction::AddTidToCgroup(int tid, int fd, const char* controller_nam
         return true;
     }
 
+    const char* controller_name = controller()->name();
     // ENOSPC is returned when cpuset cgroup that we are joining has no online cpus
     if (errno == ENOSPC && !strcmp(controller_name, "cpuset")) {
         // This is an abnormal case happening only in testing, so report it only once
@@ -345,7 +346,8 @@ bool SetCgroupAction::AddTidToCgroup(int tid, int fd, const char* controller_nam
                    << "' into cpuset because all cpus in that cpuset are offline";
         empty_cpuset_reported = true;
     } else {
-        PLOG(ERROR) << "AddTidToCgroup failed to write '" << value << "'; fd=" << fd;
+        PLOG(ERROR) << "AddTidToCgroup failed to write '" << value << "'; path=" << path_ << "; "
+                    << (cache_type == RCT_TASK ? "task" : "process");
     }
 
     return false;
@@ -356,7 +358,7 @@ ProfileAction::CacheUseResult SetCgroupAction::UseCachedFd(ResourceCacheType cac
     std::lock_guard<std::mutex> lock(fd_mutex_);
     if (FdCacheHelper::IsCached(fd_[cache_type])) {
         // fd is cached, reuse it
-        if (!AddTidToCgroup(id, fd_[cache_type], controller()->name())) {
+        if (!AddTidToCgroup(id, fd_[cache_type], cache_type)) {
             LOG(ERROR) << "Failed to add task into cgroup";
             return ProfileAction::FAIL;
         }
@@ -391,7 +393,7 @@ bool SetCgroupAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
         PLOG(WARNING) << Name() << "::" << __func__ << ": failed to open " << procs_path;
         return false;
     }
-    if (!AddTidToCgroup(pid, tmp_fd, controller()->name())) {
+    if (!AddTidToCgroup(pid, tmp_fd, RCT_PROCESS)) {
         LOG(ERROR) << "Failed to add task into cgroup";
         return false;
     }
@@ -412,7 +414,7 @@ bool SetCgroupAction::ExecuteForTask(int tid) const {
         PLOG(WARNING) << Name() << "::" << __func__ << ": failed to open " << tasks_path;
         return false;
     }
-    if (!AddTidToCgroup(tid, tmp_fd, controller()->name())) {
+    if (!AddTidToCgroup(tid, tmp_fd, RCT_TASK)) {
         LOG(ERROR) << "Failed to add task into cgroup";
         return false;
     }
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index 4663f64e2a7e..16ffe6350a3f 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -160,7 +160,7 @@ class SetCgroupAction : public ProfileAction {
     android::base::unique_fd fd_[ProfileAction::RCT_COUNT];
     mutable std::mutex fd_mutex_;
 
-    static bool AddTidToCgroup(int tid, int fd, const char* controller_name);
+    bool AddTidToCgroup(int tid, int fd, ResourceCacheType cache_type) const;
     CacheUseResult UseCachedFd(ResourceCacheType cache_type, int id) const;
 };
 

From 90703b86d9d787ba69d67566cb75d8378b56171d Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <jaegeuk@google.com>
Date: Fri, 17 Nov 2023 09:04:26 -0800
Subject: [PATCH 0556/1487] Use the dm target for userdata

Framework or applications can try to find userdata dm target from "/proc/mounts"
which gives "/dev/block/mapper/userdata".

That causes breaking the assumption in all the places.

Bug: 311165039
Change-Id: I9ea1b4589cdd52021d9807f7240c2e4b6d6d05ef
Signed-off-by: Jaegeuk Kim <jaegeuk@google.com>
---
 fs_mgr/fs_mgr.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index d55f8d3bfd59..faea5eb7aa44 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -828,7 +828,14 @@ static int __mount(const std::string& source, const std::string& target, const F
                   << ",type=" << entry.fs_type << ", gc_allowance=" << gc_allowance << "%)=" << ret
                   << "(" << save_errno << ")";
         }
-        ret = mount(source.c_str(), target.c_str(), entry.fs_type.c_str(), mountflags,
+
+        // Let's get the raw dm target, if it's a symlink, since some existing applications
+        // rely on /proc/mounts to find the userdata's dm target path. Don't break that assumption.
+        std::string real_source;
+        if (!android::base::Realpath(source, &real_source)) {
+            real_source = source;
+        }
+        ret = mount(real_source.c_str(), target.c_str(), entry.fs_type.c_str(), mountflags,
                     opts.c_str());
         save_errno = errno;
         if (try_f2fs_gc_allowance) gc_allowance += 10;

From 24a47eccf7666e0c68d56bfa9dba972c92ab603e Mon Sep 17 00:00:00 2001
From: Kalesh Singh <kaleshsingh@google.com>
Date: Fri, 14 Jul 2023 14:29:42 -0700
Subject: [PATCH 0557/1487] x86_64: mmap rnd bits: Allow min bits of less than
 32

With a regular x86 kernel we are always able to get 32
min bits for mmap randomization.

However to emulate 16KB for x86 app developers the kernel
can only provide 30 bits for the randomization due the to
larger page size (PAGE_SHIFT =+ 2).

Allow the min rand bits to be (32 - (PAGE_SHIFT - 12)) in
order to generically support larger than 4KB page sizes.

This should be a no-op change for all devices, except the
x86 16KB emulator, since they will always be able to get
32 random bits.

Bug: 309816695
Test: Boot test 4k x86 device
Test: Boot test emulated 16k x86 device
Change-Id: I48d47d56ac3aecb71a9e0093a7033bb60b89c2b7
Signed-off-by: Kalesh Singh <kaleshsingh@google.com>
---
 init/security.cpp | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/init/security.cpp b/init/security.cpp
index 0c73faedc914..3e15447506c7 100644
--- a/init/security.cpp
+++ b/init/security.cpp
@@ -20,6 +20,7 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/perf_event.h>
+#include <math.h>
 #include <selinux/selinux.h>
 #include <sys/ioctl.h>
 #include <sys/syscall.h>
@@ -121,8 +122,12 @@ Result<void> SetMmapRndBitsAction(const BuiltinArguments&) {
     }
 #elif defined(__x86_64__)
     // x86_64 supports 28 - 32 rnd bits, but Android wants to ensure that the
-    // theoretical maximum of 32 bits is always supported and used.
-    if (SetMmapRndBitsMin(32, 32, false) && (!Has32BitAbi() || SetMmapRndBitsMin(16, 16, true))) {
+    // theoretical maximum of 32 bits is always supported and used; except in
+    // the case of the x86 page size emulator which supports a maximum
+    // of 30 bits for 16k page size, or 28 bits for 64k page size.
+    int max_bits = 32 - (static_cast<int>(log2(getpagesize())) - 12);
+    if (SetMmapRndBitsMin(max_bits, max_bits, false) &&
+        (!Has32BitAbi() || SetMmapRndBitsMin(16, 16, true))) {
         return {};
     }
 #elif defined(__arm__) || defined(__i386__)

From 2953a9273ea610a18f489b7edb8eafd8e5a38732 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Tue, 14 Nov 2023 07:33:00 -0800
Subject: [PATCH 0558/1487] libprocessgroup: Reject JoinCgroup actions for v2
 controllers

A JoinCgroup action for a v2 cgroup controller migrates a process or task
from the uid_%d/pid_%d cgroup into another cgroup, e.g. the root cgroup.
This may make services unkillable because Service::Stop() only stops a
service if the uid_%d/pid_%d cgroup still exists when Service::Stop() is
called.

Bug: 309674654
Change-Id: I20b797afdf596125ff5a6ed41cb33fe59b84ac88
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 libprocessgroup/task_profiles.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index fe3c37565c47..d5bd47cb2a6a 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -868,7 +868,13 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
 
                 auto controller = cg_map.FindController(controller_name);
                 if (controller.HasValue()) {
-                    profile->Add(std::make_unique<SetCgroupAction>(controller, path));
+                    if (controller.version() == 1) {
+                        profile->Add(std::make_unique<SetCgroupAction>(controller, path));
+                    } else {
+                        LOG(WARNING) << "A JoinCgroup action in the " << profile_name
+                                     << " profile is used for controller " << controller_name
+                                     << " in the cgroup v2 hierarchy and will be ignored";
+                    }
                 } else {
                     LOG(WARNING) << "JoinCgroup: controller " << controller_name << " is not found";
                 }

From f99ca8aeb1d20218663911ec3d1ea12b2ee9fd05 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Tue, 14 Nov 2023 07:49:05 -0800
Subject: [PATCH 0559/1487] Migrate the blkio controller to the v2 cgroup
 hierarchy

There are multiple use cases in Android for which background writes need
to be controlled via the cgroup mechanism. The cgroup mechanism can only
control background writes if both the blkio and memcg controllers are
mounted in the v2 cgroup hierarchy. Hence this patch that migrates the
blkio controller from the v1 to the v2 cgroup hierarchy.

The changes compared to the previous version of this CL are as follows:
- The JoinCgroup actions for the "io" controller have been left out
  since these caused processes to be migrated to the v2 root cgroup.
- The BfqWeight / CfqGroupIdle / CfqWeight settings have been included
  in this CL instead of applying these settings as a separate CL.

Change-Id: I67e06ce3462bb1c1345dba78f8d3d655b6519c74
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 libprocessgroup/profiles/cgroups.json       |  13 +--
 libprocessgroup/profiles/task_profiles.json | 115 ++++++++++++++++++--
 rootdir/init.rc                             |  20 ----
 3 files changed, 109 insertions(+), 39 deletions(-)

diff --git a/libprocessgroup/profiles/cgroups.json b/libprocessgroup/profiles/cgroups.json
index 3e4393df2078..d013ec858c1b 100644
--- a/libprocessgroup/profiles/cgroups.json
+++ b/libprocessgroup/profiles/cgroups.json
@@ -1,12 +1,5 @@
 {
   "Cgroups": [
-    {
-      "Controller": "blkio",
-      "Path": "/dev/blkio",
-      "Mode": "0775",
-      "UID": "system",
-      "GID": "system"
-    },
     {
       "Controller": "cpu",
       "Path": "/dev/cpuctl",
@@ -39,6 +32,12 @@
       {
         "Controller": "freezer",
         "Path": "."
+      },
+      {
+        "Controller": "io",
+        "Path": ".",
+        "NeedsActivation": true,
+        "Optional": true
       }
     ]
   }
diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 1fc66ba10a64..2c08b0b31564 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -76,6 +76,21 @@
       "Name": "FreezerState",
       "Controller": "freezer",
       "File": "cgroup.freeze"
+    },
+    {
+      "Name": "BfqWeight",
+      "Controller": "io",
+      "File": "io.bfq.weight"
+    },
+    {
+      "Name": "CfqGroupIdle",
+      "Controller": "io",
+      "File": "io.group_idle"
+    },
+    {
+      "Name": "CfqWeight",
+      "Controller": "io",
+      "File": "io.weight"
     }
   ],
 
@@ -439,11 +454,30 @@
       "Name": "LowIoPriority",
       "Actions": [
         {
-          "Name": "JoinCgroup",
+          "Name": "SetAttribute",
           "Params":
           {
-            "Controller": "blkio",
-            "Path": "background"
+            "Name": "BfqWeight",
+            "Value": "10",
+            "Optional": "true"
+          }
+        },
+        {
+          "Name": "SetAttribute",
+          "Params":
+          {
+            "Name": "CfqGroupIdle",
+            "Value": "0",
+            "Optional": "true"
+          }
+        },
+        {
+          "Name": "SetAttribute",
+          "Params":
+          {
+            "Name": "CfqWeight",
+            "Value": "200",
+            "Optional": "true"
           }
         }
       ]
@@ -452,11 +486,30 @@
       "Name": "NormalIoPriority",
       "Actions": [
         {
-          "Name": "JoinCgroup",
+          "Name": "SetAttribute",
           "Params":
           {
-            "Controller": "blkio",
-            "Path": ""
+            "Name": "BfqWeight",
+            "Value": "100",
+            "Optional": "true"
+          }
+        },
+        {
+          "Name": "SetAttribute",
+          "Params":
+          {
+            "Name": "CfqGroupIdle",
+            "Value": "0",
+            "Optional": "true"
+          }
+        },
+        {
+          "Name": "SetAttribute",
+          "Params":
+          {
+            "Name": "CfqWeight",
+            "Value": "1000",
+            "Optional": "true"
           }
         }
       ]
@@ -465,11 +518,30 @@
       "Name": "HighIoPriority",
       "Actions": [
         {
-          "Name": "JoinCgroup",
+          "Name": "SetAttribute",
           "Params":
           {
-            "Controller": "blkio",
-            "Path": ""
+            "Name": "BfqWeight",
+            "Value": "100",
+            "Optional": "true"
+          }
+        },
+        {
+          "Name": "SetAttribute",
+          "Params":
+          {
+            "Name": "CfqGroupIdle",
+            "Value": "0",
+            "Optional": "true"
+          }
+        },
+        {
+          "Name": "SetAttribute",
+          "Params":
+          {
+            "Name": "CfqWeight",
+            "Value": "1000",
+            "Optional": "true"
           }
         }
       ]
@@ -478,11 +550,30 @@
       "Name": "MaxIoPriority",
       "Actions": [
         {
-          "Name": "JoinCgroup",
+          "Name": "SetAttribute",
           "Params":
           {
-            "Controller": "blkio",
-            "Path": ""
+            "Name": "BfqWeight",
+            "Value": "100",
+            "Optional": "true"
+          }
+        },
+        {
+          "Name": "SetAttribute",
+          "Params":
+          {
+            "Name": "CfqGroupIdle",
+            "Value": "0",
+            "Optional": "true"
+          }
+        },
+        {
+          "Name": "SetAttribute",
+          "Params":
+          {
+            "Name": "CfqWeight",
+            "Value": "1000",
+            "Optional": "true"
           }
         }
       ]
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 317f80908350..fb6473666d7c 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -219,26 +219,6 @@ on init
     write /dev/stune/nnapi-hal/schedtune.boost 1
     write /dev/stune/nnapi-hal/schedtune.prefer_idle 1
 
-    # Create blkio group and apply initial settings.
-    # This feature needs kernel to support it, and the
-    # device's init.rc must actually set the correct values.
-    mkdir /dev/blkio/background
-    chown system system /dev/blkio
-    chown system system /dev/blkio/background
-    chown system system /dev/blkio/tasks
-    chown system system /dev/blkio/background/tasks
-    chown system system /dev/blkio/cgroup.procs
-    chown system system /dev/blkio/background/cgroup.procs
-    chmod 0664 /dev/blkio/tasks
-    chmod 0664 /dev/blkio/background/tasks
-    chmod 0664 /dev/blkio/cgroup.procs
-    chmod 0664 /dev/blkio/background/cgroup.procs
-    write /dev/blkio/blkio.weight 1000
-    write /dev/blkio/background/blkio.weight 200
-    write /dev/blkio/background/blkio.bfq.weight 10
-    write /dev/blkio/blkio.group_idle 0
-    write /dev/blkio/background/blkio.group_idle 0
-
     restorecon_recursive /mnt
 
     mount configfs none /config nodev noexec nosuid

From c7cc571fa186f5eceb7f52726a156c348b33866e Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Fri, 17 Nov 2023 22:12:14 +0000
Subject: [PATCH 0560/1487] Avoid crashing on bad architecture value.

The only way to get a bad architecture value in the protobuf is if
the data was corrupted or an unsupported architecture was added without
the register support.

If the protobuf is corrupted, this is strictly better since it
still produces a tombstone with the data present.

If there is an unsupported architecture, it will still result in a tombstone,
only the registers would not be present. It would also be very obviously
a problem that needs to be fixed. Again, this is strictly better since
the crash in generation is not necessarily visible unless you look at
the log. Here, the data is in the log and in the tombstone.

This also removes the only dependency in this file on the async_safe
library.

Test: Ran unit tests.
Test: Forced an invalid architecture and verified tombstone is present
Test: with error message, and error message printed in the log.
Change-Id: I8e4a2e3f778fafb5b7241c2f23d5f867f1341ed8
---
 debuggerd/libdebuggerd/tombstone_proto_to_text.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index eed81fc1533a..e44dc109575d 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -28,7 +28,6 @@
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
-#include <async_safe/log.h>
 #include <bionic/macros.h>
 
 #include "tombstone.pb.h"
@@ -138,7 +137,8 @@ static void print_thread_registers(CallbackType callback, const Tombstone& tombs
       break;
 
     default:
-      async_safe_fatal("unknown architecture");
+      CBL("Unknown architecture %d printing thread registers", tombstone.arch());
+      return;
   }
 
   for (const auto& reg : thread.registers()) {

From 304881205579d65819711d8fe733c31f100977fa Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Wed, 15 Nov 2023 09:11:20 -0800
Subject: [PATCH 0561/1487] Revert "libprocessgroup: Add a function to remove
 only empty process groups"

Revert this CL because it tests whether or not cgroup.procs files are
empty with the stat() system call and because the cgroup filesystem
always reports st_size == 0. Rename RemoveUidCgroups() into
RemoveEmptyUidCgroups().

Change-Id: I4de6f16c814c4b47d8d74c8045f0c1ee71975ac0
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 .../include/processgroup/processgroup.h       |  1 -
 libprocessgroup/processgroup.cpp              | 33 +++----------------
 2 files changed, 5 insertions(+), 29 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index a319c631f70f..9107838b8629 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -87,7 +87,6 @@ bool setProcessGroupSwappiness(uid_t uid, int initialPid, int swappiness);
 bool setProcessGroupSoftLimit(uid_t uid, int initialPid, int64_t softLimitInBytes);
 bool setProcessGroupLimit(uid_t uid, int initialPid, int64_t limitInBytes);
 
-void removeAllProcessGroups(void);
 void removeAllEmptyProcessGroups(void);
 
 // Provides the path for an attribute in a specific process group
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index d352f0e346e2..b4482d096cec 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -233,7 +233,7 @@ static int RemoveCgroup(const char* cgroup, uid_t uid, int pid, unsigned int ret
     return ret;
 }
 
-static bool RemoveUidCgroups(const std::string& uid_path, bool empty_only) {
+static bool RemoveEmptyUidCgroups(const std::string& uid_path) {
     std::unique_ptr<DIR, decltype(&closedir)> uid(opendir(uid_path.c_str()), closedir);
     bool empty = true;
     if (uid != NULL) {
@@ -248,21 +248,6 @@ static bool RemoveUidCgroups(const std::string& uid_path, bool empty_only) {
             }
 
             auto path = StringPrintf("%s/%s", uid_path.c_str(), dir->d_name);
-            if (empty_only) {
-                struct stat st;
-                auto procs_file = StringPrintf("%s/%s", path.c_str(),
-                                               PROCESSGROUP_CGROUP_PROCS_FILE);
-                if (stat(procs_file.c_str(), &st) == -1) {
-                    PLOG(ERROR) << "Failed to get stats for " << procs_file;
-                    continue;
-                }
-                if (st.st_size > 0) {
-                    // skip non-empty groups
-                    LOG(VERBOSE) << "Skipping non-empty group " << path;
-                    empty = false;
-                    continue;
-                }
-            }
             LOG(VERBOSE) << "Removing " << path;
             if (rmdir(path.c_str()) == -1) {
                 if (errno != EBUSY) {
@@ -275,7 +260,9 @@ static bool RemoveUidCgroups(const std::string& uid_path, bool empty_only) {
     return empty;
 }
 
-static void removeAllProcessGroupsInternal(bool empty_only) {
+void removeAllEmptyProcessGroups() {
+    LOG(VERBOSE) << "removeAllEmptyProcessGroups()";
+
     std::vector<std::string> cgroups;
     std::string path, memcg_apps_path;
 
@@ -302,7 +289,7 @@ static void removeAllProcessGroupsInternal(bool empty_only) {
                 }
 
                 auto path = StringPrintf("%s/%s", cgroup_root_path.c_str(), dir->d_name);
-                if (!RemoveUidCgroups(path, empty_only)) {
+                if (!RemoveEmptyUidCgroups(path)) {
                     LOG(VERBOSE) << "Skip removing " << path;
                     continue;
                 }
@@ -315,16 +302,6 @@ static void removeAllProcessGroupsInternal(bool empty_only) {
     }
 }
 
-void removeAllProcessGroups() {
-    LOG(VERBOSE) << "removeAllProcessGroups()";
-    removeAllProcessGroupsInternal(false);
-}
-
-void removeAllEmptyProcessGroups() {
-    LOG(VERBOSE) << "removeAllEmptyProcessGroups()";
-    removeAllProcessGroupsInternal(true);
-}
-
 /**
  * Process groups are primarily created by the Zygote, meaning that uid/pid groups are created by
  * the user root. Ownership for the newly created cgroup and all of its files must thus be

From d922df36b26d0c2643f6ee542b8879e333db5212 Mon Sep 17 00:00:00 2001
From: Daniel Rosenberg <drosen@google.com>
Date: Wed, 8 Nov 2023 17:30:17 -0800
Subject: [PATCH 0562/1487] fs_mgr_overlayfs: Support 16k F2FS

Currently, f2fs block size must be equal to page size.
If this is not the case in the future, this code should be revisited.

Bug: 279820706
Test: adb remount on 16k f2fs device
Change-Id: Ib0d1ea81f921be99471d0433c8499ae077208db7
Signed-off-by: Daniel Rosenberg <drosen@google.com>
---
 fs_mgr/fs_mgr_overlayfs_control.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/fs_mgr/fs_mgr_overlayfs_control.cpp b/fs_mgr/fs_mgr_overlayfs_control.cpp
index 50d8280e9062..f6380dd691e7 100644
--- a/fs_mgr/fs_mgr_overlayfs_control.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_control.cpp
@@ -383,6 +383,8 @@ bool MakeScratchFilesystem(const std::string& scratch_device) {
         fs_type = "f2fs";
         command = kMkF2fs + " -w "s;
         command += std::to_string(getpagesize());
+        command = kMkF2fs + " -b "s;
+        command += std::to_string(getpagesize());
         command += " -f -d1 -l" + android::base::Basename(kScratchMountPoint);
     } else if (!access(kMkExt4, X_OK) && fs_mgr_filesystem_available("ext4")) {
         fs_type = "ext4";

From d01ca43d6b67013539b688fcb43bcd848f2d1844 Mon Sep 17 00:00:00 2001
From: Daniel Rosenberg <drosen@google.com>
Date: Fri, 17 Nov 2023 17:14:14 -0800
Subject: [PATCH 0563/1487] fs_mgr: Support 16k F2FS

This passes the block size to mkfs. Currently f2fs must have page size
equal to block size. If this changes, we may want to revisit this.

Change-Id: I1ecdffcb2a271aa80c0bd07fd095941720fb48d0
Signed-off-by: Daniel Rosenberg <drosen@google.com>
Bug: 279820706
Test: Boot 16K device
---
 fs_mgr/fs_mgr_format.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/fs_mgr/fs_mgr_format.cpp b/fs_mgr/fs_mgr_format.cpp
index 622f18135dcd..8e7615010605 100644
--- a/fs_mgr/fs_mgr_format.cpp
+++ b/fs_mgr/fs_mgr_format.cpp
@@ -136,6 +136,7 @@ static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool needs
     /* Format the partition using the calculated length */
 
     const auto size_str = std::to_string(dev_sz / getpagesize());
+    std::string block_size = std::to_string(getpagesize());
 
     std::vector<const char*> args = {"/system/bin/make_f2fs", "-g", "android"};
     if (needs_projid) {
@@ -154,6 +155,10 @@ static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool needs
         args.push_back("-O");
         args.push_back("extra_attr");
     }
+    args.push_back("-w");
+    args.push_back(block_size.c_str());
+    args.push_back("-b");
+    args.push_back(block_size.c_str());
     if (!zoned_device.empty()) {
         args.push_back("-c");
         args.push_back(zoned_device.c_str());

From 95cc6b6f013bc52818dd7eda89632f4fdf21285f Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 16 Nov 2023 11:38:19 -0800
Subject: [PATCH 0564/1487] libsnapshot: update resume offset calculation

Update resume offset calculation to use function call

Test: cow_api_test
Change-Id: I7a9a86dc007110d02d889d1e59b24c3068b8d9e9
---
 fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
index 52c6348b6657..8e0f1907d194 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
@@ -79,7 +79,7 @@ bool CowParserV3::ReadResumeBuffer(borrowed_fd fd) {
 
     return android::base::ReadFullyAtOffset(fd, resume_points_->data(),
                                             header_.resume_point_count * sizeof(ResumePoint),
-                                            header_.prefix.header_size + header_.buffer_size);
+                                            GetResumeOffset(header_));
 }
 
 std::optional<uint32_t> CowParserV3::FindResumeOp(const uint64_t label) {

From e01550bbb6520f00c0826e17e13360f127dfddf6 Mon Sep 17 00:00:00 2001
From: John Reck <jreck@google.com>
Date: Fri, 10 Nov 2023 15:05:35 -0500
Subject: [PATCH 0565/1487] Add StrongPointer::release()

Useful when dealing with raw pointers in unavoidable places. Avoids
an awkward (and "slow") dance of mySp->incStrong(0); mySp->get(); ~mySp;

Test: make && atest --host libutils_binder_test
Change-Id: Ib8d46150592725cc256779bccfed19a16dce78b2
---
 libutils/binder/StrongPointer_test.cpp        | 14 ++++++++++++++
 libutils/binder/include/utils/StrongPointer.h |  9 +++++++++
 2 files changed, 23 insertions(+)

diff --git a/libutils/binder/StrongPointer_test.cpp b/libutils/binder/StrongPointer_test.cpp
index f27c1f1cc193..aa993c3f8433 100644
--- a/libutils/binder/StrongPointer_test.cpp
+++ b/libutils/binder/StrongPointer_test.cpp
@@ -106,3 +106,17 @@ TYPED_TEST(StrongPointer, AssertStrongRefExists) {
     EXPECT_DEATH(sp<TypeParam>::fromExisting(foo), "");
     delete foo;
 }
+
+TYPED_TEST(StrongPointer, release) {
+    bool isDeleted = false;
+    TypeParam* foo = nullptr;
+    {
+        sp<TypeParam> sp1 = sp<TypeParam>::make(&isDeleted);
+        ASSERT_EQ(1, sp1->getStrongCount());
+        foo = sp1.release();
+    }
+    ASSERT_FALSE(isDeleted) << "release failed, deleted anyway when sp left scope";
+    ASSERT_EQ(1, foo->getStrongCount()) << "release mismanaged refcount";
+    foo->decStrong(nullptr);
+    ASSERT_TRUE(isDeleted) << "foo was leaked!";
+}
diff --git a/libutils/binder/include/utils/StrongPointer.h b/libutils/binder/include/utils/StrongPointer.h
index 54aa691e03c2..43c00c95a4c2 100644
--- a/libutils/binder/include/utils/StrongPointer.h
+++ b/libutils/binder/include/utils/StrongPointer.h
@@ -98,6 +98,15 @@ class sp {
 
     void clear();
 
+    // Releases the ownership of the object managed by this instance of sp, if any.
+    // The caller is now responsible for managing it. That is, the caller must ensure
+    // decStrong() is called when the pointer is no longer used.
+    [[nodiscard]] inline T* release() noexcept {
+        auto ret = m_ptr;
+        m_ptr = nullptr;
+        return ret;
+    }
+
     // Accessors
 
     inline T&       operator* () const     { return *m_ptr; }

From 97047b54e952e2d08b10e6d37d510ca653cace00 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Thu, 16 Nov 2023 12:42:35 -0800
Subject: [PATCH 0566/1487] init: Combine two global sigchld_fd variables into
 one

Remove the Service::SetSigchldFd() method. Make the Service::GetSigchldFd()
create a signalfd for SIGCHLD. This makes it possible to use a SIGCHLD
signalfd in unit tests.

Change-Id: I0b41caa8f46c79f4d400e49aaba5227fad53c251
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 init/init.cpp    | 41 ++++++++++++++---------------------------
 init/init.h      |  2 --
 init/reboot.cpp  |  2 +-
 init/service.cpp | 32 +++++++++++++++++++++++++++++++-
 init/service.h   |  7 +++++--
 5 files changed, 51 insertions(+), 33 deletions(-)

diff --git a/init/init.cpp b/init/init.cpp
index 83cb78b5187f..aeccd669692e 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -117,7 +117,6 @@ namespace init {
 
 static int property_triggers_enabled = 0;
 
-int sigchld_fd = -1;
 static int sigterm_fd = -1;
 static int property_fd = -1;
 
@@ -717,7 +716,7 @@ static void HandleSigtermSignal(const signalfd_siginfo& siginfo) {
 
 static void HandleSignalFd(int signal) {
     signalfd_siginfo siginfo;
-    const int signal_fd = signal == SIGCHLD ? sigchld_fd : sigterm_fd;
+    const int signal_fd = signal == SIGCHLD ? Service::GetSigchldFd() : sigterm_fd;
     ssize_t bytes_read = TEMP_FAILURE_RETRY(read(signal_fd, &siginfo, sizeof(siginfo)));
     if (bytes_read != sizeof(siginfo)) {
         PLOG(ERROR) << "Failed to read siginfo from signal_fd";
@@ -751,20 +750,24 @@ static void UnblockSignals() {
     }
 }
 
+static Result<void> RegisterSignalFd(Epoll* epoll, int signal, int fd) {
+    return epoll->RegisterHandler(
+            fd, [signal]() { HandleSignalFd(signal); }, EPOLLIN | EPOLLPRI);
+}
+
 static Result<int> CreateAndRegisterSignalFd(Epoll* epoll, int signal) {
     sigset_t mask;
     sigemptyset(&mask);
     sigaddset(&mask, signal);
-    unique_fd signal_fd(signalfd(-1, &mask, SFD_CLOEXEC));
-    if (signal_fd == -1) {
-        return ErrnoError() << "failed to create signalfd for signal " << signal;
+    if (sigprocmask(SIG_BLOCK, &mask, nullptr) == -1) {
+        return ErrnoError() << "failed to block signal " << signal;
     }
 
-    auto result = epoll->RegisterHandler(
-            signal_fd.get(), [signal]() { HandleSignalFd(signal); }, EPOLLIN | EPOLLPRI);
-    if (!result.ok()) {
-        return result.error();
+    unique_fd signal_fd(signalfd(-1, &mask, SFD_CLOEXEC));
+    if (signal_fd.get() < 0) {
+        return ErrnoError() << "failed to create signalfd for signal " << signal;
     }
+    OR_RETURN(RegisterSignalFd(epoll, signal, signal_fd.get()));
 
     return signal_fd.release();
 }
@@ -775,34 +778,18 @@ static void InstallSignalFdHandler(Epoll* epoll) {
     const struct sigaction act { .sa_flags = SA_NOCLDSTOP, .sa_handler = SIG_DFL };
     sigaction(SIGCHLD, &act, nullptr);
 
-    sigset_t mask;
-    sigemptyset(&mask);
-    sigaddset(&mask, SIGCHLD);
-
-    if (!IsRebootCapable()) {
-        // If init does not have the CAP_SYS_BOOT capability, it is running in a container.
-        // In that case, receiving SIGTERM will cause the system to shut down.
-        sigaddset(&mask, SIGTERM);
-    }
-
-    if (sigprocmask(SIG_BLOCK, &mask, nullptr) == -1) {
-        PLOG(FATAL) << "failed to block signals";
-    }
-
     // Register a handler to unblock signals in the child processes.
     const int result = pthread_atfork(nullptr, nullptr, &UnblockSignals);
     if (result != 0) {
         LOG(FATAL) << "Failed to register a fork handler: " << strerror(result);
     }
 
-    Result<int> cs_result = CreateAndRegisterSignalFd(epoll, SIGCHLD);
+    Result<void> cs_result = RegisterSignalFd(epoll, SIGCHLD, Service::GetSigchldFd());
     if (!cs_result.ok()) {
         PLOG(FATAL) << cs_result.error();
     }
-    sigchld_fd = cs_result.value();
-    Service::SetSigchldFd(sigchld_fd);
 
-    if (sigismember(&mask, SIGTERM)) {
+    if (!IsRebootCapable()) {
         Result<int> cs_result = CreateAndRegisterSignalFd(epoll, SIGTERM);
         if (!cs_result.ok()) {
             PLOG(FATAL) << cs_result.error();
diff --git a/init/init.h b/init/init.h
index b78116721673..9c7e91879aae 100644
--- a/init/init.h
+++ b/init/init.h
@@ -28,8 +28,6 @@
 namespace android {
 namespace init {
 
-extern int sigchld_fd;
-
 Parser CreateParser(ActionManager& action_manager, ServiceList& service_list);
 Parser CreateApexConfigParser(ActionManager& action_manager, ServiceList& service_list);
 
diff --git a/init/reboot.cpp b/init/reboot.cpp
index 57579225834e..1a26c4d3ccae 100644
--- a/init/reboot.cpp
+++ b/init/reboot.cpp
@@ -563,7 +563,7 @@ static void StopServices(const std::set<std::string>& services, std::chrono::mil
         }
     }
     if (timeout > 0ms) {
-        WaitToBeReaped(sigchld_fd, pids, timeout);
+        WaitToBeReaped(Service::GetSigchldFd(), pids, timeout);
     } else {
         // Even if we don't to wait for services to stop, we still optimistically reap zombies.
         ReapAnyOutstandingChildren();
diff --git a/init/service.cpp b/init/service.cpp
index d351a8fe17af..eb24dd593733 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -37,6 +37,7 @@
 #include <cutils/sockets.h>
 #include <processgroup/processgroup.h>
 #include <selinux/selinux.h>
+#include <sys/signalfd.h>
 
 #include <string>
 
@@ -68,6 +69,7 @@ using android::base::make_scope_guard;
 using android::base::SetProperty;
 using android::base::StartsWith;
 using android::base::StringPrintf;
+using android::base::unique_fd;
 using android::base::WriteStringToFile;
 
 namespace android {
@@ -136,7 +138,6 @@ static bool ExpandArgsAndExecv(const std::vector<std::string>& args, bool sigsto
 
 unsigned long Service::next_start_order_ = 1;
 bool Service::is_exec_service_running_ = false;
-int Service::sigchld_fd_ = -1;
 
 Service::Service(const std::string& name, Subcontext* subcontext_for_restart_commands,
                  const std::string& filename, const std::vector<std::string>& args)
@@ -792,6 +793,35 @@ void Service::SetMountNamespace() {
     mount_namespace_ = IsDefaultMountNamespaceReady() ? NS_DEFAULT : NS_BOOTSTRAP;
 }
 
+static int ThreadCount() {
+    std::unique_ptr<DIR, decltype(&closedir)> dir(opendir("/proc/self/task"), closedir);
+    if (!dir) {
+        return -1;
+    }
+
+    int count = 0;
+    dirent* entry;
+    while ((entry = readdir(dir.get())) != nullptr) {
+        if (entry->d_name[0] != '.') {
+            count++;
+        }
+    }
+    return count;
+}
+
+// Must be called BEFORE any threads are created. See also the sigprocmask() man page.
+unique_fd Service::CreateSigchldFd() {
+    CHECK_EQ(ThreadCount(), 1);
+    sigset_t mask;
+    sigemptyset(&mask);
+    sigaddset(&mask, SIGCHLD);
+    if (sigprocmask(SIG_BLOCK, &mask, nullptr) < 0) {
+        PLOG(FATAL) << "Failed to block SIGCHLD";
+    }
+
+    return unique_fd(signalfd(-1, &mask, SFD_CLOEXEC));
+}
+
 void Service::SetStartedInFirstStage(pid_t pid) {
     LOG(INFO) << "adding first-stage service '" << name_ << "'...";
 
diff --git a/init/service.h b/init/service.h
index 13c8b5f789e8..5e9af25db64c 100644
--- a/init/service.h
+++ b/init/service.h
@@ -156,7 +156,10 @@ class Service {
     const Subcontext* subcontext() const { return subcontext_; }
     const std::string& filename() const { return filename_; }
     void set_filename(const std::string& name) { filename_ = name; }
-    static void SetSigchldFd(int sigchld_fd) { sigchld_fd_ = sigchld_fd; }
+    static int GetSigchldFd() {
+        static int sigchld_fd = CreateSigchldFd().release();
+        return sigchld_fd;
+    }
 
   private:
     void NotifyStateChange(const std::string& new_state) const;
@@ -169,10 +172,10 @@ class Service {
     void RunService(const std::vector<Descriptor>& descriptors, InterprocessFifo cgroups_activated,
                     InterprocessFifo setsid_finished);
     void SetMountNamespace();
+    static ::android::base::unique_fd CreateSigchldFd();
 
     static unsigned long next_start_order_;
     static bool is_exec_service_running_;
-    static int sigchld_fd_;
 
     const std::string name_;
     std::set<std::string> classnames_;

From 5d30009a7e12e7a066fb1d9e3b1b16267fe905e2 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 20 Nov 2023 11:40:36 -0800
Subject: [PATCH 0567/1487] libsnapshot: update variable name

updating name to count rather than buffer size

Test: cow_api_test
Change-Id: I9e44330e7a230b5ab5f5e914ef74a63cc4ebaa61
---
 fs_mgr/libsnapshot/include/libsnapshot/cow_format.h | 4 ++--
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp    | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 75467cb79b1d..9e6cfea33c79 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -105,8 +105,8 @@ struct ResumePoint {
 static constexpr uint8_t kNumResumePoints = 4;
 
 struct CowHeaderV3 : public CowHeader {
-    // Location of sequence buffer in COW.
-    uint64_t sequence_buffer_offset;
+    // Number of sequence data stored (each of which is a 32 byte integer)
+    uint64_t sequence_data_count;
     // number of currently written resume points
     uint32_t resume_point_count;
     // Size, in bytes, of the CowResumePoint buffer.
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 6883c5e93058..b3c8a207454b 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -77,7 +77,7 @@ void CowWriterV3::SetupHeaders() {
     // v3 specific fields
     // WIP: not quite sure how some of these are calculated yet, assuming buffer_size is determined
     // during COW size estimation
-    header_.sequence_buffer_offset = 0;
+    header_.sequence_data_count = 0;
     header_.resume_point_count = 0;
     header_.resume_point_max = kNumResumePoints;
     header_.op_count = 0;

From 763776435d848bb781ac89656658be1101065617 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 20 Nov 2023 03:01:03 -0800
Subject: [PATCH 0568/1487] libsnapshot: sync header metadata

After we write emit a label, we need to update the number of resume
points + sequence data and op_count. Realistically we could just call
Finalize, but maybe synching these specific fields could prevent
unexpected outcomes.

Test: cow_api_test
Change-Id: I1585601a134221689ce8d5675a2a3e32f1e8a0e6
---
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 38 +++++++++++++++++++
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp |  2 +-
 2 files changed, 39 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index c41e07cc2913..9f857eeb4c22 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -482,5 +482,43 @@ TEST_F(CowTestV3, ResumePointTest) {
     header = reader.header_v3();
     ASSERT_EQ(header.op_count, 15);
 }
+
+TEST_F(CowTestV3, BufferMetadataSyncTest) {
+    CowOptions options;
+    options.op_count_max = 100;
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+    /*
+    Header metadafields
+    sequence_data_count = 0;
+    resume_point_count = 0;
+    resume_point_max = 4;
+    */
+    ASSERT_TRUE(writer->Finalize());
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    auto header = reader.header_v3();
+    ASSERT_EQ(header.sequence_data_count, 0);
+    ASSERT_EQ(header.resume_point_count, 0);
+    ASSERT_EQ(header.resume_point_max, 4);
+
+    writer->AddLabel(0);
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+    header = reader.header_v3();
+    ASSERT_EQ(header.sequence_data_count, 0);
+    ASSERT_EQ(header.resume_point_count, 1);
+    ASSERT_EQ(header.resume_point_max, 4);
+
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+    header = reader.header_v3();
+
+    /*
+    Header metadafields
+    sequence_data_count = 1;
+    resume_point_count = 0;
+    resume_point_max = 4;
+    */
+}
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index b3c8a207454b..e9e05b088889 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -311,7 +311,7 @@ bool CowWriterV3::EmitLabel(uint64_t label) {
         PLOG(ERROR) << "writing resume buffer failed";
         return false;
     }
-    return Sync();
+    return Finalize();
 }
 
 bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {

From 209fda3562108d83fe109345990092b314722559 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 20 Nov 2023 03:48:07 -0800
Subject: [PATCH 0569/1487] libsnapshot: move header op count setup

Op count should be set before we sync the header. This way subsequence
writers can initialize with the correct op buffer size

Test: cow_api_test
Change-Id: I56a0d747b3f2a1d9d582d8f9d643b81cbdd9b8d7
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index e9e05b088889..81ccea9c1506 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -100,6 +100,7 @@ bool CowWriterV3::ParseOptions() {
         return false;
     }
     header_.compression_algorithm = *algorithm;
+    header_.op_count_max = options_.op_count_max;
 
     if (parts.size() > 1) {
         if (!android::base::ParseUint(parts[1], &compression_.compression_level)) {
@@ -163,7 +164,7 @@ bool CowWriterV3::OpenForWrite() {
             return false;
         }
     }
-    header_.op_count_max = options_.op_count_max;
+
     resume_points_ = std::make_shared<std::vector<ResumePoint>>();
 
     if (!Sync()) {

From 52d8fe9b042b737950683b74c8a075ee7cf20d9b Mon Sep 17 00:00:00 2001
From: Inseob Kim <inseob@google.com>
Date: Mon, 20 Nov 2023 18:34:27 +0900
Subject: [PATCH 0570/1487] Use vendor/etc/ueventd.rc on microdroid

... because vendors should be able to extend ueventd.rc for their own
devices (in microdroid) and microdroid's system.img can't be amended.

Bug: N/A
Test: boot microdroid
Change-Id: I7ceaf3f87453c8e29f9d9bf03d4d1866185d4fec
---
 init/ueventd.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/init/ueventd.cpp b/init/ueventd.cpp
index 586e2cf31e27..3f0d0e95ba08 100644
--- a/init/ueventd.cpp
+++ b/init/ueventd.cpp
@@ -297,6 +297,10 @@ void ColdBoot::Run() {
 }
 
 static UeventdConfiguration GetConfiguration() {
+    if (IsMicrodroid()) {
+        return ParseConfig({"/system/etc/ueventd.rc", "/vendor/etc/ueventd.rc"});
+    }
+
     auto hardware = android::base::GetProperty("ro.hardware", "");
 
     struct LegacyPathInfo {

From e267e31d73dc67dd617dfe848169bf78e5ac0b42 Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Tue, 21 Nov 2023 18:41:43 +0900
Subject: [PATCH 0571/1487] Calculate ro.vendor.api_level with the new vendor
 API format

In Android V, ro.vendor.api_level read ro.board.api_level only if
ro.board.first_api_level is defined. The format of the vendor api
level is YYYYMM.
Update the ro.vendor.api_level initialize funtion with this change.

As ro.product.first_api_level follows the version from the SDK, a
new function `vendor_api_level_of` translates the SDK version to the
vendor API level.

Bug: 312403948
Test: getprop ro.vendor.api_level
Change-Id: I2961ed9a6de8e9156f72c1bbfeabcac9c35f08fb
---
 init/property_service.cpp | 49 +++++++++++++++++++++++----------------
 1 file changed, 29 insertions(+), 20 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index bd743581910b..e2cff957ee19 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -84,6 +84,7 @@ using namespace std::literals;
 
 using android::base::ErrnoError;
 using android::base::Error;
+using android::base::GetIntProperty;
 using android::base::GetProperty;
 using android::base::ParseInt;
 using android::base::ReadFileToString;
@@ -112,7 +113,7 @@ constexpr auto ID_PROP = "ro.build.id";
 constexpr auto LEGACY_ID_PROP = "ro.build.legacy.id";
 constexpr auto VBMETA_DIGEST_PROP = "ro.boot.vbmeta.digest";
 constexpr auto DIGEST_SIZE_USED = 8;
-constexpr auto API_LEVEL_CURRENT = 10000;
+constexpr auto MAX_VENDOR_API_LEVEL = 1000000;
 
 static bool persistent_properties_loaded = false;
 
@@ -1084,15 +1085,16 @@ static void property_initialize_ro_cpu_abilist() {
     }
 }
 
-static int read_api_level_props(const std::vector<std::string>& api_level_props) {
-    int api_level = API_LEVEL_CURRENT;
-    for (const auto& api_level_prop : api_level_props) {
-        api_level = android::base::GetIntProperty(api_level_prop, API_LEVEL_CURRENT);
-        if (api_level != API_LEVEL_CURRENT) {
-            break;
-        }
+static int vendor_api_level_of(int sdk_api_level) {
+    if (sdk_api_level < __ANDROID_API_V__) {
+        return sdk_api_level;
     }
-    return api_level;
+    // In Android V, vendor API level started with version 202404.
+    // The calculation assumes that the SDK api level bumps once a year.
+    if (sdk_api_level < __ANDROID_API_FUTURE__) {
+        return 202404 + ((sdk_api_level - __ANDROID_API_V__) * 100);
+    }
+    return MAX_VENDOR_API_LEVEL;
 }
 
 static void property_initialize_ro_vendor_api_level() {
@@ -1100,20 +1102,27 @@ static void property_initialize_ro_vendor_api_level() {
     // required to support.
     constexpr auto VENDOR_API_LEVEL_PROP = "ro.vendor.api_level";
 
-    // Api level properties of the board. The order of the properties must be kept.
-    std::vector<std::string> BOARD_API_LEVEL_PROPS = {"ro.board.api_level",
-                                                      "ro.board.first_api_level"};
-    // Api level properties of the device. The order of the properties must be kept.
-    std::vector<std::string> DEVICE_API_LEVEL_PROPS = {"ro.product.first_api_level",
-                                                       "ro.build.version.sdk"};
+    auto vendor_api_level = GetIntProperty("ro.board.first_api_level", MAX_VENDOR_API_LEVEL);
+    if (vendor_api_level != MAX_VENDOR_API_LEVEL) {
+        // Update the vendor_api_level with "ro.board.api_level" only if both "ro.board.api_level"
+        // and "ro.board.first_api_level" are defined.
+        vendor_api_level = GetIntProperty("ro.board.api_level", vendor_api_level);
+    }
+
+    auto product_first_api_level =
+            GetIntProperty("ro.product.first_api_level", __ANDROID_API_FUTURE__);
+    if (product_first_api_level == __ANDROID_API_FUTURE__) {
+        // Fallback to "ro.build.version.sdk" if the "ro.product.first_api_level" is not defined.
+        product_first_api_level = GetIntProperty("ro.build.version.sdk", __ANDROID_API_FUTURE__);
+    }
+
+    vendor_api_level = std::min(vendor_api_level_of(product_first_api_level), vendor_api_level);
 
-    int api_level = std::min(read_api_level_props(BOARD_API_LEVEL_PROPS),
-                             read_api_level_props(DEVICE_API_LEVEL_PROPS));
     std::string error;
-    auto res = PropertySetNoSocket(VENDOR_API_LEVEL_PROP, std::to_string(api_level), &error);
+    auto res = PropertySetNoSocket(VENDOR_API_LEVEL_PROP, std::to_string(vendor_api_level), &error);
     if (res != PROP_SUCCESS) {
-        LOG(ERROR) << "Failed to set " << VENDOR_API_LEVEL_PROP << " with " << api_level << ": "
-                   << error << "(" << res << ")";
+        LOG(ERROR) << "Failed to set " << VENDOR_API_LEVEL_PROP << " with " << vendor_api_level
+                   << ": " << error << "(" << res << ")";
     }
 }
 

From 9c6b723adb2341c30fc4958ffa204a941e159d8e Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Mon, 20 Nov 2023 14:38:55 -0800
Subject: [PATCH 0572/1487] init: Introduce the function ReapAndRemove()

Prepare for adding a second caller of ReapAndRemove().

Change-Id: I0f54af6136f49caa0198c123a4c8de968e5f41ba
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 init/sigchld_handler.cpp | 27 ++++++++++++++++++---------
 init/sigchld_handler.h   |  3 ++-
 2 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/init/sigchld_handler.cpp b/init/sigchld_handler.cpp
index 9d4c7c8e3301..02795080a99f 100644
--- a/init/sigchld_handler.cpp
+++ b/init/sigchld_handler.cpp
@@ -118,8 +118,23 @@ static pid_t ReapOneProcess() {
     return pid;
 }
 
-void ReapAnyOutstandingChildren() {
-    while (ReapOneProcess() != 0) {
+std::set<pid_t> ReapAnyOutstandingChildren() {
+    std::set<pid_t> reaped_pids;
+    for (;;) {
+        const pid_t pid = ReapOneProcess();
+        if (pid <= 0) {
+            return reaped_pids;
+        }
+        reaped_pids.emplace(pid);
+    }
+}
+
+static void ReapAndRemove(std::vector<pid_t>& alive_pids) {
+    for (auto pid : ReapAnyOutstandingChildren()) {
+        const auto it = std::find(alive_pids.begin(), alive_pids.end(), pid);
+        if (it != alive_pids.end()) {
+            alive_pids.erase(it);
+        }
     }
 }
 
@@ -142,13 +157,7 @@ void WaitToBeReaped(int sigchld_fd, const std::vector<pid_t>& pids,
     }
     std::vector<pid_t> alive_pids(pids.begin(), pids.end());
     while (!alive_pids.empty() && t.duration() < timeout) {
-        pid_t pid;
-        while ((pid = ReapOneProcess()) != 0) {
-            auto it = std::find(alive_pids.begin(), alive_pids.end(), pid);
-            if (it != alive_pids.end()) {
-                alive_pids.erase(it);
-            }
-        }
+        ReapAndRemove(alive_pids);
         if (alive_pids.empty()) {
             break;
         }
diff --git a/init/sigchld_handler.h b/init/sigchld_handler.h
index e07a7d66af6b..535130296504 100644
--- a/init/sigchld_handler.h
+++ b/init/sigchld_handler.h
@@ -18,12 +18,13 @@
 #define _INIT_SIGCHLD_HANDLER_H_
 
 #include <chrono>
+#include <set>
 #include <vector>
 
 namespace android {
 namespace init {
 
-void ReapAnyOutstandingChildren();
+std::set<pid_t> ReapAnyOutstandingChildren();
 
 void WaitToBeReaped(int sigchld_fd, const std::vector<pid_t>& pids,
                     std::chrono::milliseconds timeout);

From 43aeb228586245b06729d524a296fb307992b232 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 9 Nov 2023 11:14:07 -0800
Subject: [PATCH 0573/1487] libsnapshot: add sequence data

v3 writer to write sequence data. Sequence data will be written after
the scratch space and before the resume space. Since this is just a list
of integers, writing and reading should be trivial

Test: cow_api_test
Change-Id: If3b6b1cfa155aeb65bf693263fc373154ba8e81d
---
 .../include/libsnapshot/cow_format.h          |  26 ++--
 .../include/libsnapshot/cow_reader.h          |   8 +-
 .../libsnapshot_cow/cow_reader.cpp            | 142 ++++++++++++------
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 101 +++++++++++++
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp |  11 +-
 5 files changed, 226 insertions(+), 62 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 9e6cfea33c79..5e5546d44017 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -107,9 +107,9 @@ static constexpr uint8_t kNumResumePoints = 4;
 struct CowHeaderV3 : public CowHeader {
     // Number of sequence data stored (each of which is a 32 byte integer)
     uint64_t sequence_data_count;
-    // number of currently written resume points
+    // Number of currently written resume points &&
     uint32_t resume_point_count;
-    // Size, in bytes, of the CowResumePoint buffer.
+    // Number of max resume points that can be written
     uint32_t resume_point_max;
     // Number of CowOperationV3 structs in the operation buffer, currently and total
     // region size.
@@ -232,17 +232,21 @@ static inline uint64_t GetCowOpSourceInfoData(const CowOperation& op) {
     return op.source_info & kCowOpSourceInfoDataMask;
 }
 
-static constexpr off_t GetOpOffset(uint32_t op_index, const CowHeaderV3 header) {
-    return header.prefix.header_size + header.buffer_size +
-           (header.resume_point_max * sizeof(ResumePoint)) + (op_index * sizeof(CowOperationV3));
+static constexpr off_t GetSequenceOffset(const CowHeaderV3& header) {
+    return header.prefix.header_size + header.buffer_size;
 }
-static constexpr off_t GetDataOffset(const CowHeaderV3 header) {
-    return header.prefix.header_size + header.buffer_size +
-           (header.resume_point_max * sizeof(ResumePoint)) +
-           header.op_count_max * sizeof(CowOperation);
+
+static constexpr off_t GetResumeOffset(const CowHeaderV3& header) {
+    return GetSequenceOffset(header) + (header.sequence_data_count * sizeof(uint32_t));
 }
-static constexpr off_t GetResumeOffset(const CowHeaderV3 header) {
-    return header.prefix.header_size + header.buffer_size;
+
+static constexpr off_t GetOpOffset(uint32_t op_index, const CowHeaderV3& header) {
+    return GetResumeOffset(header) + (header.resume_point_max * sizeof(ResumePoint)) +
+           (op_index * sizeof(CowOperationV3));
+}
+
+static constexpr off_t GetDataOffset(const CowHeaderV3& header) {
+    return GetOpOffset(header.op_count_max, header);
 }
 
 struct CowFooter {
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index c87b32d3eacd..bf4c79f176e3 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -16,8 +16,6 @@
 
 #include <stdint.h>
 
-#include <deque>
-#include <functional>
 #include <memory>
 #include <optional>
 #include <unordered_map>
@@ -169,6 +167,12 @@ class CowReader final : public ICowReader {
   private:
     bool ParseV2(android::base::borrowed_fd fd, std::optional<uint64_t> label);
     bool PrepMergeOps();
+    // sequence data is stored as an operation with actual data residing in the data offset.
+    bool GetSequenceDataV2(std::vector<uint32_t>* merge_op_blocks, std::vector<int>* other_ops,
+                           std::unordered_map<uint32_t, int>* block_map);
+    // v3 of the cow writes sequence data within its own separate sequence buffer.
+    bool GetSequenceData(std::vector<uint32_t>* merge_op_blocks, std::vector<int>* other_ops,
+                         std::unordered_map<uint32_t, int>* block_map);
     uint64_t FindNumCopyops();
     uint8_t GetCompressionType();
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 8412879340e0..7b5370cb2fed 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -24,6 +24,7 @@
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include <libsnapshot/cow_format.h>
 #include <libsnapshot/cow_reader.h>
 #include <zlib.h>
 
@@ -265,52 +266,31 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
 //                        Replace-op-4, Zero-op-9, Replace-op-5 }
 //==============================================================
 bool CowReader::PrepMergeOps() {
-    auto merge_op_blocks = std::make_unique<std::vector<uint32_t>>();
     std::vector<int> other_ops;
-    auto seq_ops_set = std::unordered_set<uint32_t>();
-    auto block_map = std::make_unique<std::unordered_map<uint32_t, int>>();
-    size_t num_seqs = 0;
-    size_t read;
-
-    for (size_t i = 0; i < ops_->size(); i++) {
-        auto& current_op = ops_->data()[i];
-
-        if (current_op.type == kCowSequenceOp) {
-            size_t seq_len = current_op.data_length / sizeof(uint32_t);
-
-            merge_op_blocks->resize(merge_op_blocks->size() + seq_len);
-            if (!GetRawBytes(&current_op, &merge_op_blocks->data()[num_seqs],
-                             current_op.data_length, &read)) {
-                PLOG(ERROR) << "Failed to read sequence op!";
-                return false;
-            }
-            for (size_t j = num_seqs; j < num_seqs + seq_len; j++) {
-                seq_ops_set.insert(merge_op_blocks->data()[j]);
-            }
-            num_seqs += seq_len;
-        }
-
-        if (IsMetadataOp(current_op)) {
-            continue;
-        }
+    std::vector<uint32_t> merge_op_blocks;
+    std::unordered_map<uint32_t, int> block_map;
 
-        // Sequence ops must be the first ops in the stream.
-        if (seq_ops_set.empty() && IsOrderedOp(current_op)) {
-            merge_op_blocks->emplace_back(current_op.new_block);
-        } else if (seq_ops_set.count(current_op.new_block) == 0) {
-            other_ops.push_back(current_op.new_block);
-        }
-        block_map->insert({current_op.new_block, i});
+    switch (header_.prefix.major_version) {
+        case 1:
+        case 2:
+            GetSequenceDataV2(&merge_op_blocks, &other_ops, &block_map);
+            break;
+        case 3:
+            GetSequenceData(&merge_op_blocks, &other_ops, &block_map);
+            break;
+        default:
+            break;
     }
-    for (auto block : *merge_op_blocks) {
-        if (block_map->count(block) == 0) {
+
+    for (auto block : merge_op_blocks) {
+        if (block_map.count(block) == 0) {
             LOG(ERROR) << "Invalid Sequence Ops. Could not find Cow Op for new block " << block;
             return false;
         }
     }
 
-    if (merge_op_blocks->size() > header_.num_merge_ops) {
-        num_ordered_ops_to_merge_ = merge_op_blocks->size() - header_.num_merge_ops;
+    if (merge_op_blocks.size() > header_.num_merge_ops) {
+        num_ordered_ops_to_merge_ = merge_op_blocks.size() - header_.num_merge_ops;
     } else {
         num_ordered_ops_to_merge_ = 0;
     }
@@ -326,9 +306,9 @@ bool CowReader::PrepMergeOps() {
         std::sort(other_ops.begin(), other_ops.end(), std::greater<int>());
     }
 
-    merge_op_blocks->insert(merge_op_blocks->end(), other_ops.begin(), other_ops.end());
+    merge_op_blocks.insert(merge_op_blocks.end(), other_ops.begin(), other_ops.end());
 
-    num_total_data_ops_ = merge_op_blocks->size();
+    num_total_data_ops_ = merge_op_blocks.size();
     if (header_.num_merge_ops > 0) {
         merge_op_start_ = header_.num_merge_ops;
     }
@@ -338,21 +318,91 @@ bool CowReader::PrepMergeOps() {
         // the ops vector as required for merge operations.
         auto merge_ops_buffer = std::make_shared<std::vector<CowOperation>>();
         merge_ops_buffer->reserve(num_total_data_ops_);
-        for (auto block : *merge_op_blocks) {
-            merge_ops_buffer->emplace_back(ops_->data()[block_map->at(block)]);
+        for (auto block : merge_op_blocks) {
+            merge_ops_buffer->emplace_back(ops_->data()[block_map.at(block)]);
         }
         ops_->clear();
         ops_ = merge_ops_buffer;
         ops_->shrink_to_fit();
     } else {
-        for (auto block : *merge_op_blocks) {
-            block_pos_index_->push_back(block_map->at(block));
+        for (auto block : merge_op_blocks) {
+            block_pos_index_->push_back(block_map.at(block));
         }
     }
 
-    block_map->clear();
-    merge_op_blocks->clear();
+    block_map.clear();
+    merge_op_blocks.clear();
+
+    return true;
+}
+
+bool CowReader::GetSequenceDataV2(std::vector<uint32_t>* merge_op_blocks,
+                                  std::vector<int>* other_ops,
+                                  std::unordered_map<uint32_t, int>* block_map) {
+    auto seq_ops_set = std::unordered_set<uint32_t>();
+    size_t num_seqs = 0;
+    size_t read;
+    for (size_t i = 0; i < ops_->size(); i++) {
+        auto& current_op = ops_->data()[i];
+
+        if (current_op.type == kCowSequenceOp) {
+            size_t seq_len = current_op.data_length / sizeof(uint32_t);
+
+            merge_op_blocks->resize(merge_op_blocks->size() + seq_len);
+            if (!GetRawBytes(&current_op, &merge_op_blocks->data()[num_seqs],
+                             current_op.data_length, &read)) {
+                PLOG(ERROR) << "Failed to read sequence op!";
+                return false;
+            }
+            for (size_t j = num_seqs; j < num_seqs + seq_len; j++) {
+                seq_ops_set.insert(merge_op_blocks->at(j));
+            }
+            num_seqs += seq_len;
+        }
+
+        if (IsMetadataOp(current_op)) {
+            continue;
+        }
 
+        // Sequence ops must be the first ops in the stream.
+        if (seq_ops_set.empty() && IsOrderedOp(current_op)) {
+            merge_op_blocks->emplace_back(current_op.new_block);
+        } else if (seq_ops_set.count(current_op.new_block) == 0) {
+            other_ops->push_back(current_op.new_block);
+        }
+        block_map->insert({current_op.new_block, i});
+    }
+    return false;
+}
+
+bool CowReader::GetSequenceData(std::vector<uint32_t>* merge_op_blocks, std::vector<int>* other_ops,
+                                std::unordered_map<uint32_t, int>* block_map) {
+    std::unordered_set<uint32_t> seq_ops_set;
+    // read sequence ops data
+    merge_op_blocks->resize(header_.sequence_data_count);
+    if (!android::base::ReadFullyAtOffset(
+                fd_, merge_op_blocks->data(),
+                header_.sequence_data_count * sizeof(merge_op_blocks->at(0)),
+                GetSequenceOffset(header_))) {
+        PLOG(ERROR) << "failed to read sequence buffer. seq_data_count: "
+                    << header_.sequence_data_count << " at offset: " << GetSequenceOffset(header_);
+        return false;
+    }
+    seq_ops_set.reserve(merge_op_blocks->size());
+    for (auto& i : *merge_op_blocks) {
+        seq_ops_set.insert(i);
+    }
+    // read ordered op data
+    for (size_t i = 0; i < ops_->size(); i++) {
+        auto& current_op = ops_->data()[i];
+        // Sequence ops must be the first ops in the stream.
+        if (seq_ops_set.empty()) {
+            merge_op_blocks->emplace_back(current_op.new_block);
+        } else if (seq_ops_set.count(current_op.new_block) == 0) {
+            other_ops->push_back(current_op.new_block);
+        }
+        block_map->insert({current_op.new_block, i});
+    }
     return true;
 }
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 9f857eeb4c22..9ac14482affe 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -520,5 +520,106 @@ TEST_F(CowTestV3, BufferMetadataSyncTest) {
     resume_point_max = 4;
     */
 }
+
+TEST_F(CowTestV3, SequenceTest) {
+    CowOptions options;
+    options.op_count_max = std::numeric_limits<uint32_t>::max();
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+    // sequence data. This just an arbitrary set of integers that specify the merge order. The
+    // actual calculation is done by update_engine and passed to writer. All we care about here is
+    // writing that data correctly
+    const int seq_len = std::numeric_limits<uint16_t>::max() / sizeof(uint32_t) + 1;
+    uint32_t sequence[seq_len];
+    for (int i = 0; i < seq_len; i++) {
+        sequence[i] = i + 1;
+    }
+
+    ASSERT_TRUE(writer->AddSequenceData(seq_len, sequence));
+    ASSERT_TRUE(writer->AddZeroBlocks(1, seq_len));
+    ASSERT_TRUE(writer->Finalize());
+
+    ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+    auto iter = reader.GetRevMergeOpIter();
+
+    for (int i = 0; i < seq_len; i++) {
+        ASSERT_TRUE(!iter->AtEnd());
+        const auto& op = iter->Get();
+
+        ASSERT_EQ(op->new_block, seq_len - i);
+
+        iter->Next();
+    }
+    ASSERT_TRUE(iter->AtEnd());
+}
+
+TEST_F(CowTestV3, MissingSeqOp) {
+    CowOptions options;
+    options.op_count_max = std::numeric_limits<uint32_t>::max();
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+    const int seq_len = 10;
+    uint32_t sequence[seq_len];
+    for (int i = 0; i < seq_len; i++) {
+        sequence[i] = i + 1;
+    }
+    ASSERT_TRUE(writer->AddSequenceData(seq_len, sequence));
+    ASSERT_TRUE(writer->AddZeroBlocks(1, seq_len - 1));
+    ASSERT_TRUE(writer->Finalize());
+
+    ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
+
+    CowReader reader;
+    ASSERT_FALSE(reader.Parse(cow_->fd));
+}
+
+TEST_F(CowTestV3, ResumeSeqOp) {
+    CowOptions options;
+    options.op_count_max = std::numeric_limits<uint32_t>::max();
+    auto writer = std::make_unique<CowWriterV3>(options, GetCowFd());
+    const int seq_len = 10;
+    uint32_t sequence[seq_len];
+    for (int i = 0; i < seq_len; i++) {
+        sequence[i] = i + 1;
+    }
+    ASSERT_TRUE(writer->Initialize());
+
+    ASSERT_TRUE(writer->AddSequenceData(seq_len, sequence));
+    ASSERT_TRUE(writer->AddZeroBlocks(1, seq_len / 2));
+    ASSERT_TRUE(writer->AddLabel(1));
+    ASSERT_TRUE(writer->AddZeroBlocks(1 + seq_len / 2, 1));
+
+    ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
+    auto reader = std::make_unique<CowReader>();
+    ASSERT_TRUE(reader->Parse(cow_->fd, 1));
+    auto itr = reader->GetRevMergeOpIter();
+    ASSERT_TRUE(itr->AtEnd());
+
+    writer = std::make_unique<CowWriterV3>(options, GetCowFd());
+    ASSERT_TRUE(writer->Initialize({1}));
+    ASSERT_TRUE(writer->AddZeroBlocks(1 + seq_len / 2, seq_len / 2));
+    ASSERT_TRUE(writer->Finalize());
+
+    ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
+
+    reader = std::make_unique<CowReader>();
+    ASSERT_TRUE(reader->Parse(cow_->fd));
+
+    auto iter = reader->GetRevMergeOpIter();
+
+    uint64_t expected_block = 10;
+    while (!iter->AtEnd() && expected_block > 0) {
+        ASSERT_FALSE(iter->AtEnd());
+        const auto& op = iter->Get();
+
+        ASSERT_EQ(op->new_block, expected_block);
+
+        iter->Next();
+        expected_block--;
+    }
+    ASSERT_EQ(expected_block, 0);
+    ASSERT_TRUE(iter->AtEnd());
+}
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 81ccea9c1506..b36c6f3cfe7e 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -316,9 +316,14 @@ bool CowWriterV3::EmitLabel(uint64_t label) {
 }
 
 bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
-    LOG(ERROR) << __LINE__ << " " << __FILE__ << " <- function here should never be called";
-    if (num_ops && data) return false;
-    return false;
+    // TODO: size sequence buffer based on options
+    header_.sequence_data_count = num_ops;
+    if (!android::base::WriteFullyAtOffset(fd_, data, sizeof(data[0]) * num_ops,
+                                           GetSequenceOffset(header_))) {
+        PLOG(ERROR) << "writing sequence buffer failed";
+        return false;
+    }
+    return true;
 }
 
 bool CowWriterV3::WriteOperation(const CowOperationV3& op, const void* data, size_t size) {

From 1daf88d6ceb1530c36f30dad49628434b2bc7b4d Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Thu, 16 Nov 2023 11:19:08 -0800
Subject: [PATCH 0574/1487] init: Fix signalfd support in WaitToBeReaped()

Add an Epoll::Open() call such that the Epoll::Wait() calls wait for the
signalfd. Rename DiscardSiginfo() into HandleSignal(). Handle Epoll method
call failures. Test whether alive_pids is empty once per loop iteration.

Test: CtsInitTestCases:ServiceStopTest
Change-Id: I16c27aa74d61f889b304f3e59cd3c5255c299ce1
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 init/sigchld_handler.cpp | 37 ++++++++++++++++++++++++++-----------
 1 file changed, 26 insertions(+), 11 deletions(-)

diff --git a/init/sigchld_handler.cpp b/init/sigchld_handler.cpp
index 02795080a99f..8e9e713c4840 100644
--- a/init/sigchld_handler.cpp
+++ b/init/sigchld_handler.cpp
@@ -138,7 +138,7 @@ static void ReapAndRemove(std::vector<pid_t>& alive_pids) {
     }
 }
 
-static void DiscardSiginfo(int signal_fd) {
+static void HandleSignal(int signal_fd) {
     signalfd_siginfo siginfo;
     ssize_t bytes_read = TEMP_FAILURE_RETRY(read(signal_fd, &siginfo, sizeof(siginfo)));
     if (bytes_read != sizeof(siginfo)) {
@@ -151,21 +151,36 @@ void WaitToBeReaped(int sigchld_fd, const std::vector<pid_t>& pids,
                     std::chrono::milliseconds timeout) {
     Timer t;
     Epoll epoll;
-    // The init process passes a valid sigchld_fd argument but unit tests do not.
     if (sigchld_fd >= 0) {
-        epoll.RegisterHandler(sigchld_fd, [sigchld_fd]() { DiscardSiginfo(sigchld_fd); });
+        if (auto result = epoll.Open(); result.ok()) {
+            result =
+                    epoll.RegisterHandler(sigchld_fd, [sigchld_fd]() { HandleSignal(sigchld_fd); });
+            if (!result.ok()) {
+                LOG(WARNING) << __func__
+                             << " RegisterHandler() failed. Falling back to sleep_for(): "
+                             << result.error();
+                sigchld_fd = -1;
+            }
+        } else {
+            LOG(WARNING) << __func__ << " Epoll::Open() failed. Falling back to sleep_for(): "
+                         << result.error();
+            sigchld_fd = -1;
+        }
     }
-    std::vector<pid_t> alive_pids(pids.begin(), pids.end());
+    std::vector<pid_t> alive_pids(pids);
+    ReapAndRemove(alive_pids);
     while (!alive_pids.empty() && t.duration() < timeout) {
-        ReapAndRemove(alive_pids);
-        if (alive_pids.empty()) {
-            break;
-        }
         if (sigchld_fd >= 0) {
-            epoll.Wait(std::max(timeout - t.duration(), 0ms));
-        } else {
-            std::this_thread::sleep_for(50ms);
+            auto result = epoll.Wait(std::max(timeout - t.duration(), 0ms));
+            if (result.ok()) {
+                ReapAndRemove(alive_pids);
+                continue;
+            } else {
+                LOG(WARNING) << "Epoll::Wait() failed " << result.error();
+            }
         }
+        std::this_thread::sleep_for(50ms);
+        ReapAndRemove(alive_pids);
     }
     LOG(INFO) << "Waiting for " << pids.size() << " pids to be reaped took " << t << " with "
               << alive_pids.size() << " of them still running";

From 3f9f5950673057c6283b40386747d96bc3e71507 Mon Sep 17 00:00:00 2001
From: yanxu <yanxu.wei@mediatek.com>
Date: Tue, 14 Nov 2023 13:57:37 +0800
Subject: [PATCH 0575/1487] Add exfat fs in fs_mgr

Need to support exfat fs type point mount in recovery mode

Bug:312674538
Test: SIU (Apply update from SD card) in recovery mode

Change-Id: I2735e5068c47b183a25d2305bca89f08de1e32c7
---
 fs_mgr/fs_mgr_roots.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/fs_mgr_roots.cpp b/fs_mgr/fs_mgr_roots.cpp
index 2ad8125e78ff..a697fb3de4b4 100644
--- a/fs_mgr/fs_mgr_roots.cpp
+++ b/fs_mgr/fs_mgr_roots.cpp
@@ -115,8 +115,8 @@ bool TryPathMount(FstabEntry* rec, const std::string& mount_pt) {
         return true;
     }
 
-    static const std::vector<std::string> supported_fs{"ext4", "squashfs", "vfat", "f2fs", "erofs",
-                                                       "none"};
+    static const std::vector<std::string> supported_fs{"ext4", "squashfs", "vfat", "exfat", "f2fs",
+                                                       "erofs", "none"};
     if (std::find(supported_fs.begin(), supported_fs.end(), rec->fs_type) == supported_fs.end()) {
         LERROR << "unknown fs_type \"" << rec->fs_type << "\" for " << mount_point;
         return false;

From 28113cf3f6a471d190ff0de5c5a4c8b5d17b3e7c Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Thu, 23 Nov 2023 14:47:58 +0800
Subject: [PATCH 0576/1487] second-stage-init: Don't move submounts when
 mounting overlayfs

Right now there is a bug in second-stage-init that screws up the
overlayfs overrides. This happens because:
1. second-stage-init mount_all might be executed in the "bootstrap"
   mount namespace.
2. In order to move (MS_MOVE) submounts in fs_mgr_overlayfs_mount_all(),
   we change the mount propagation type of overridden filesystems to
   MS_PRIVATE.
3. This means that the "default" mount namespace would not receive the
   mount events of the overlayfs overrides.
4. After /data is mounted, init would switch to the "default" namespace.
   This means any new processes spawned after this period would not be
   able to see the overlayfs overrides.

We fix this by changing the mount order of second-stage-init mount_all
to mount the overlayfs override of a partition immediately after the
partition is mounted. This way we don't need to move any submounts as
there can't be any, thus we don't need to set any mountpoint to
MS_PRIVATE so the mount event of the overlayfs would be propagated to
the "default" mount namespace, too.

Bug: 309407859
Bug: 306124139
Test: adb-remount-test
Test: verify that overlayfs tookover successfully from second-stage-init
Change-Id: If2ff4852516292ccbc7abdeebe0e9a7c1c7ba606
---
 fs_mgr/fs_mgr.cpp                 |  9 ++--
 fs_mgr/fs_mgr_overlayfs_mount.cpp | 74 +++++++++++++++++++++++--------
 fs_mgr/include/fs_mgr_overlayfs.h |  3 ++
 3 files changed, 63 insertions(+), 23 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index faea5eb7aa44..35c8c639626c 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -1388,6 +1388,8 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
         return {FS_MGR_MNTALL_FAIL, userdata_mounted};
     }
 
+    bool scratch_can_be_mounted = true;
+
     // Keep i int to prevent unsigned integer overflow from (i = top_idx - 1),
     // where top_idx is 0. It will give SIGABRT
     for (int i = 0; i < static_cast<int>(fstab->size()); i++) {
@@ -1520,6 +1522,9 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
             if (current_entry.mount_point == "/data") {
                 userdata_mounted = true;
             }
+
+            MountOverlayfs(attempted_entry, &scratch_can_be_mounted);
+
             // Success!  Go get the next one.
             continue;
         }
@@ -1604,10 +1609,6 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
 
     set_type_property(encryptable);
 
-#if ALLOW_ADBD_DISABLE_VERITY == 1  // "userdebug" build
-    fs_mgr_overlayfs_mount_all(fstab);
-#endif
-
     if (error_count) {
         return {FS_MGR_MNTALL_FAIL, userdata_mounted};
     } else {
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index cdbac00c654e..e0b6721adcbb 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -302,6 +302,25 @@ static bool fs_mgr_overlayfs_move_mount(const std::string& source, const std::st
     return true;
 }
 
+static bool fs_mgr_overlayfs_mount(const std::string& mount_point, const std::string& options) {
+    auto report = "__mount(source=overlay,target="s + mount_point + ",type=overlay";
+    for (const auto& opt : android::base::Split(options, ",")) {
+        if (android::base::StartsWith(opt, kUpperdirOption)) {
+            report = report + "," + opt;
+            break;
+        }
+    }
+    report = report + ")=";
+    auto ret = mount("overlay", mount_point.c_str(), "overlay", MS_RDONLY | MS_NOATIME,
+                     options.c_str());
+    if (ret) {
+        PERROR << report << ret;
+    } else {
+        LINFO << report << ret;
+    }
+    return !ret;
+}
+
 struct mount_info {
     std::string mount_point;
     bool shared_flag;
@@ -488,25 +507,7 @@ static bool fs_mgr_overlayfs_mount_one(const FstabEntry& fstab_entry) {
         moved_mounts.push_back(std::move(new_entry));
     }
 
-    // hijack __mount() report format to help triage
-    auto report = "__mount(source=overlay,target="s + mount_point + ",type=overlay";
-    const auto opt_list = android::base::Split(options, ",");
-    for (const auto& opt : opt_list) {
-        if (android::base::StartsWith(opt, kUpperdirOption)) {
-            report = report + "," + opt;
-            break;
-        }
-    }
-    report = report + ")=";
-
-    auto ret = mount("overlay", mount_point.c_str(), "overlay", MS_RDONLY | MS_NOATIME,
-                     options.c_str());
-    if (ret) {
-        retval = false;
-        PERROR << report << ret;
-    } else {
-        LINFO << report << ret;
-    }
+    retval &= fs_mgr_overlayfs_mount(mount_point, options);
 
     // Move submounts back.
     for (const auto& entry : moved_mounts) {
@@ -814,3 +815,38 @@ bool fs_mgr_overlayfs_already_mounted(const std::string& mount_point, bool overl
     }
     return false;
 }
+
+namespace android {
+namespace fs_mgr {
+
+void MountOverlayfs(const FstabEntry& fstab_entry, bool* scratch_can_be_mounted) {
+    if (!OverlayfsSetupAllowed()) {
+        return;
+    }
+    const auto candidates = fs_mgr_overlayfs_candidate_list({fstab_entry});
+    if (candidates.empty()) {
+        return;
+    }
+    const auto& entry = candidates.front();
+    if (fs_mgr_is_verity_enabled(entry)) {
+        return;
+    }
+    const auto mount_point = fs_mgr_mount_point(entry.mount_point);
+    if (fs_mgr_overlayfs_already_mounted(mount_point)) {
+        return;
+    }
+    if (*scratch_can_be_mounted) {
+        *scratch_can_be_mounted = false;
+        if (!fs_mgr_overlayfs_already_mounted(kScratchMountPoint, false)) {
+            TryMountScratch();
+        }
+    }
+    const auto options = fs_mgr_get_overlayfs_options(entry);
+    if (options.empty()) {
+        return;
+    }
+    fs_mgr_overlayfs_mount(mount_point, options);
+}
+
+}  // namespace fs_mgr
+}  // namespace android
diff --git a/fs_mgr/include/fs_mgr_overlayfs.h b/fs_mgr/include/fs_mgr_overlayfs.h
index bdaabbf07e0b..bf68b2c81362 100644
--- a/fs_mgr/include/fs_mgr_overlayfs.h
+++ b/fs_mgr/include/fs_mgr_overlayfs.h
@@ -30,6 +30,9 @@ bool fs_mgr_overlayfs_is_setup();
 namespace android {
 namespace fs_mgr {
 
+// Mount the overlayfs override for |fstab_entry|.
+void MountOverlayfs(const FstabEntry& fstab_entry, bool* scratch_can_be_mounted);
+
 void MapScratchPartitionIfNeeded(Fstab* fstab,
                                  const std::function<bool(const std::set<std::string>&)>& init);
 

From 16239ad86253d2cde6622efe1a6f69991bd3dbe1 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Fri, 24 Nov 2023 11:39:15 +0800
Subject: [PATCH 0577/1487] fs_mgr_overlayfs: De-dup common methods

Keep only one copy of GetBootScratchDevice().

Bug: 306124139
Test: build
Change-Id: I11603566ab454eb028b50873d66f4ab967b204f9
---
 fs_mgr/fs_mgr_overlayfs_control.cpp | 54 ++++++++++++++---------------
 fs_mgr/fs_mgr_overlayfs_control.h   |  2 ++
 fs_mgr/fs_mgr_overlayfs_mount.cpp   | 42 +---------------------
 3 files changed, 30 insertions(+), 68 deletions(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_control.cpp b/fs_mgr/fs_mgr_overlayfs_control.cpp
index 50d8280e9062..9be236d1e78c 100644
--- a/fs_mgr/fs_mgr_overlayfs_control.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_control.cpp
@@ -347,33 +347,6 @@ static std::string GetDsuScratchDevice() {
     return "";
 }
 
-// This returns the scratch device that was detected during early boot (first-
-// stage init). If the device was created later, for example during setup for
-// the adb remount command, it can return an empty string since it does not
-// query ImageManager. (Note that ImageManager in first-stage init will always
-// use device-mapper, since /data is not available to use loop devices.)
-static std::string GetBootScratchDevice() {
-    // Note: fs_mgr_is_dsu_running() always returns false in recovery or fastbootd.
-    if (fs_mgr_is_dsu_running()) {
-        return GetDsuScratchDevice();
-    }
-
-    auto& dm = DeviceMapper::Instance();
-
-    // If there is a scratch partition allocated in /data or on super, we
-    // automatically prioritize that over super_other or system_other.
-    // Some devices, for example, have a write-protected eMMC and the
-    // super partition cannot be used even if it exists.
-    std::string device;
-    auto partition_name = android::base::Basename(kScratchMountPoint);
-    if (dm.GetState(partition_name) != DmDeviceState::INVALID &&
-        dm.GetDmDevicePathByName(partition_name, &device)) {
-        return device;
-    }
-
-    return "";
-}
-
 bool MakeScratchFilesystem(const std::string& scratch_device) {
     // Force mkfs by design for overlay support of adb remount, simplify and
     // thus do not rely on fsck to correct problems that could creep in.
@@ -922,6 +895,33 @@ void CleanupOldScratchFiles() {
     }
 }
 
+// This returns the scratch device that was detected during early boot (first-
+// stage init). If the device was created later, for example during setup for
+// the adb remount command, it can return an empty string since it does not
+// query ImageManager. (Note that ImageManager in first-stage init will always
+// use device-mapper, since /data is not available to use loop devices.)
+std::string GetBootScratchDevice() {
+    // Note: fs_mgr_is_dsu_running() always returns false in recovery or fastbootd.
+    if (fs_mgr_is_dsu_running()) {
+        return GetDsuScratchDevice();
+    }
+
+    auto& dm = DeviceMapper::Instance();
+
+    // If there is a scratch partition allocated in /data or on super, we
+    // automatically prioritize that over super_other or system_other.
+    // Some devices, for example, have a write-protected eMMC and the
+    // super partition cannot be used even if it exists.
+    std::string device;
+    auto partition_name = android::base::Basename(kScratchMountPoint);
+    if (dm.GetState(partition_name) != DmDeviceState::INVALID &&
+        dm.GetDmDevicePathByName(partition_name, &device)) {
+        return device;
+    }
+
+    return "";
+}
+
 void TeardownAllOverlayForMountPoint(const std::string& mount_point) {
     if (!OverlayfsTeardownAllowed()) {
         return;
diff --git a/fs_mgr/fs_mgr_overlayfs_control.h b/fs_mgr/fs_mgr_overlayfs_control.h
index b1751015844f..3516c462d432 100644
--- a/fs_mgr/fs_mgr_overlayfs_control.h
+++ b/fs_mgr/fs_mgr_overlayfs_control.h
@@ -38,5 +38,7 @@ namespace fs_mgr {
 
 void CleanupOldScratchFiles();
 
+std::string GetBootScratchDevice();
+
 }  // namespace fs_mgr
 }  // namespace android
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index e0b6721adcbb..e1684366b245 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -42,15 +42,14 @@
 #include <fs_mgr/file_wait.h>
 #include <fs_mgr_overlayfs.h>
 #include <fstab/fstab.h>
-#include <libdm/dm.h>
 #include <libgsi/libgsi.h>
 #include <storage_literals/storage_literals.h>
 
+#include "fs_mgr_overlayfs_control.h"
 #include "fs_mgr_overlayfs_mount.h"
 #include "fs_mgr_priv.h"
 
 using namespace std::literals;
-using namespace android::dm;
 using namespace android::fs_mgr;
 using namespace android::storage_literals;
 
@@ -593,45 +592,6 @@ bool MountScratch(const std::string& device_path, bool readonly) {
     return true;
 }
 
-// Note: The scratch partition of DSU is managed by gsid, and should be initialized during
-// first-stage-mount. Just check if the DM device for DSU scratch partition is created or not.
-static std::string GetDsuScratchDevice() {
-    auto& dm = DeviceMapper::Instance();
-    std::string device;
-    if (dm.GetState(android::gsi::kDsuScratch) != DmDeviceState::INVALID &&
-        dm.GetDmDevicePathByName(android::gsi::kDsuScratch, &device)) {
-        return device;
-    }
-    return "";
-}
-
-// This returns the scratch device that was detected during early boot (first-
-// stage init). If the device was created later, for example during setup for
-// the adb remount command, it can return an empty string since it does not
-// query ImageManager. (Note that ImageManager in first-stage init will always
-// use device-mapper, since /data is not available to use loop devices.)
-static std::string GetBootScratchDevice() {
-    // Note: fs_mgr_is_dsu_running() always returns false in recovery or fastbootd.
-    if (fs_mgr_is_dsu_running()) {
-        return GetDsuScratchDevice();
-    }
-
-    auto& dm = DeviceMapper::Instance();
-
-    // If there is a scratch partition allocated in /data or on super, we
-    // automatically prioritize that over super_other or system_other.
-    // Some devices, for example, have a write-protected eMMC and the
-    // super partition cannot be used even if it exists.
-    std::string device;
-    auto partition_name = android::base::Basename(kScratchMountPoint);
-    if (dm.GetState(partition_name) != DmDeviceState::INVALID &&
-        dm.GetDmDevicePathByName(partition_name, &device)) {
-        return device;
-    }
-
-    return "";
-}
-
 // NOTE: OverlayfsSetupAllowed() must be "stricter" than OverlayfsTeardownAllowed().
 // Setup is allowed only if teardown is also allowed.
 bool OverlayfsSetupAllowed(bool verbose) {

From 3a22c9e16e4dc17bd457a92271670429230c0d9f Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Fri, 24 Nov 2023 12:20:03 +0800
Subject: [PATCH 0578/1487] fs_mgr_overlayfs: MapScratchPartitionIfNeeded
 always tries to create scratch

Simplify the logic of MapScratchPartitionIfNeeded to just map the
scratch partition unconditionally. If there is a "scratch" logical
partition available, we just assume it must be needed later to
facilitate overlayfs.

Going through the fstab & fs_mgr_overlayfs_candidate_list to determine
if overlayfs is needed or not might be inaccurate as the fstab passed into
MapScratchPartitionIfNeeded is incomplete (it includes only the
"first_stage_mount" entries). So the scratch device might not get created
even though there are some "late mount" partitions that need the scratch
device to facilitate overlayfs.

Bug: 306124139
Test: adb-remount-test
Change-Id: I8590750e822219dec3d7d3c8648e9c9a5a32f68c
---
 fs_mgr/fs_mgr_overlayfs_control.cpp | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_control.cpp b/fs_mgr/fs_mgr_overlayfs_control.cpp
index 9be236d1e78c..33fb0807111b 100644
--- a/fs_mgr/fs_mgr_overlayfs_control.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_control.cpp
@@ -854,21 +854,6 @@ void MapScratchPartitionIfNeeded(Fstab* fstab,
         return;
     }
 
-    bool want_scratch = false;
-    for (const auto& entry : fs_mgr_overlayfs_candidate_list(*fstab)) {
-        if (fs_mgr_is_verity_enabled(entry)) {
-            continue;
-        }
-        if (fs_mgr_overlayfs_already_mounted(fs_mgr_mount_point(entry.mount_point))) {
-            continue;
-        }
-        want_scratch = true;
-        break;
-    }
-    if (!want_scratch) {
-        return;
-    }
-
     if (ScratchIsOnData()) {
         if (auto images = IImageManager::Open("remount", 0ms)) {
             images->MapAllImages(init);

From fad8b7a1309c3abde121e9a4022a31342bbd2673 Mon Sep 17 00:00:00 2001
From: Christopher Fore <csfore@posteo.net>
Date: Mon, 20 Nov 2023 15:19:12 -0500
Subject: [PATCH 0579/1487] fs_mgr: IWYU include <algorithm> for std::sort

GCC 14 starts to no longer include <algorithm> by default, resulting in
it needing to be explicitly declared.

Test: Recompiled with GCC 14 and succeeded

Change-Id: Ifc5dd58b7476ba728ae604cd2924cb68fbcab701
Signed-off-by: Christopher Fore <csfore@posteo.net>
---
 fs_mgr/liblp/super_layout_builder.cpp | 2 ++
 fs_mgr/liblp/utility.cpp              | 1 +
 2 files changed, 3 insertions(+)

diff --git a/fs_mgr/liblp/super_layout_builder.cpp b/fs_mgr/liblp/super_layout_builder.cpp
index 5349e41a9a69..fd7416bb2e8e 100644
--- a/fs_mgr/liblp/super_layout_builder.cpp
+++ b/fs_mgr/liblp/super_layout_builder.cpp
@@ -17,6 +17,8 @@
 
 #include <liblp/liblp.h>
 
+#include <algorithm>
+
 #include "images.h"
 #include "utility.h"
 #include "writer.h"
diff --git a/fs_mgr/liblp/utility.cpp b/fs_mgr/liblp/utility.cpp
index d8e171b108e1..70c7b799aec3 100644
--- a/fs_mgr/liblp/utility.cpp
+++ b/fs_mgr/liblp/utility.cpp
@@ -25,6 +25,7 @@
 #include <sys/ioctl.h>
 #endif
 
+#include <algorithm>
 #include <map>
 #include <string>
 #include <vector>

From a43b96c157d61f1d25b9a20cdd59eb77519175c7 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Wed, 15 Nov 2023 07:47:05 -0800
Subject: [PATCH 0580/1487] libprocessgroup: Stop services that have been
 migrated to another v2 cgroup

CL 2828279 doesn't do what it's description says that it does. Making
Service::Stop() work for processes that have been migrated to another v2
cgroup requires changing DoKillProcessGroupOnce(). Hence this CL that
removes the early return statements from DoKillProcessGroupOnce().

Bug: 308900853
Change-Id: Ib798555feeb95a786a619c3d7013c7d5829b01ad
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 libprocessgroup/processgroup.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 76868bbd2d51..f594f7f66354 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -378,8 +378,11 @@ static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid,
         fd.reset(fopen(path.c_str(), "re"));
         if (!fd) {
             if (errno == ENOENT) {
-                // This happens when process is already dead
-                return 0;
+                // This happens when the process is already dead or if, as the result of a bug, it
+                // has been migrated to another cgroup. An example of a bug that can cause migration
+                // to another cgroup is using the JoinCgroup action with a cgroup controller that
+                // has been activated in the v2 cgroup hierarchy.
+                goto kill;
             }
             PLOG(WARNING) << __func__ << " failed to open process cgroup uid " << uid << " pid "
                           << initialPid;
@@ -418,6 +421,7 @@ static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid,
         }
     }
 
+kill:
     // Kill all process groups.
     for (const auto pgid : pgids) {
         LOG(VERBOSE) << "Killing process group " << -pgid << " in uid " << uid

From 86a2ae28e655ebdd3d9b1f6235fdd7db035a35f1 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Tue, 14 Nov 2023 16:13:50 -0800
Subject: [PATCH 0581/1487] service_test: Test stopping services after
 migration to another cgroup

The root cause of "After OTA, device is not responding" is that
Service::Stop() did not stop services that had been migrated to another
v2 cgroup. Add a unit test for that scenario.

Bug: 308900853
Change-Id: I590fde90e31326290c2c8ce8fce51e94b215a979
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 init/service_test.cpp | 86 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)

diff --git a/init/service_test.cpp b/init/service_test.cpp
index 87a2ce524d7d..c81b0077f894 100644
--- a/init/service_test.cpp
+++ b/init/service_test.cpp
@@ -17,18 +17,45 @@
 #include "service.h"
 
 #include <algorithm>
+#include <fstream>
 #include <memory>
 #include <type_traits>
 #include <vector>
 
 #include <gtest/gtest.h>
 
+#include <android-base/file.h>
+#include <android-base/stringprintf.h>
+#include <android-base/strings.h>
+#include <selinux/selinux.h>
+#include <sys/signalfd.h>
 #include "lmkd_service.h"
+#include "reboot.h"
+#include "service.h"
+#include "service_list.h"
+#include "service_parser.h"
 #include "util.h"
 
+using ::android::base::ReadFileToString;
+using ::android::base::StringPrintf;
+using ::android::base::StringReplace;
+using ::android::base::unique_fd;
+using ::android::base::WriteStringToFd;
+using ::android::base::WriteStringToFile;
+
 namespace android {
 namespace init {
 
+static std::string GetSecurityContext() {
+    char* ctx;
+    if (getcon(&ctx) == -1) {
+        ADD_FAILURE() << "Failed to call getcon : " << strerror(errno);
+    }
+    std::string result{ctx};
+    freecon(ctx);
+    return result;
+}
+
 TEST(service, pod_initialized) {
     constexpr auto memory_size = sizeof(Service);
     alignas(alignof(Service)) unsigned char old_memory[memory_size];
@@ -190,5 +217,64 @@ TEST(service, make_temporary_oneshot_service_with_just_command_no_dash) {
     Test_make_temporary_oneshot_service(false, false, false, false, false);
 }
 
+// Returns the path in the v2 cgroup hierarchy for a given process in the format /uid_%d/pid_%d.
+static std::string CgroupPath(pid_t pid) {
+    std::string cgroup_path = StringPrintf("/proc/%d/cgroup", pid);
+    std::ifstream is(cgroup_path, std::ios::in);
+    std::string line;
+    while (std::getline(is, line)) {
+        if (line.substr(0, 3) == "0::") {
+            return line.substr(3);
+        }
+    }
+    return {};
+}
+
+class ServiceStopTest : public testing::TestWithParam<bool> {};
+
+// Before November 2023, processes that were migrated to another v2 cgroup were ignored by
+// Service::Stop() if their uid_%d/pid_%d cgroup directory got removed. This test, if run with the
+// parameter set to 'true', verifies that such services are stopped.
+TEST_P(ServiceStopTest, stop) {
+    static constexpr std::string_view kServiceName = "ServiceA";
+    static constexpr std::string_view kScriptTemplate = R"init(
+service $name /system/bin/yes
+    user shell
+    group shell
+    seclabel $selabel
+)init";
+
+    std::string script = StringReplace(StringReplace(kScriptTemplate, "$name", kServiceName, false),
+                                       "$selabel", GetSecurityContext(), false);
+    ServiceList& service_list = ServiceList::GetInstance();
+    Parser parser;
+    parser.AddSectionParser("service",
+                            std::make_unique<ServiceParser>(&service_list, nullptr, std::nullopt));
+
+    TemporaryFile tf;
+    ASSERT_GE(tf.fd, 0);
+    ASSERT_TRUE(WriteStringToFd(script, tf.fd));
+    ASSERT_TRUE(parser.ParseConfig(tf.path));
+
+    Service* const service = ServiceList::GetInstance().FindService(kServiceName);
+    ASSERT_NE(service, nullptr);
+    ASSERT_RESULT_OK(service->Start());
+    ASSERT_TRUE(service->IsRunning());
+    if (GetParam()) {
+        const pid_t pid = service->pid();
+        const std::string cgroup_path = CgroupPath(pid);
+        EXPECT_NE(cgroup_path, "");
+        EXPECT_NE(cgroup_path, "/");
+        const std::string pid_str = std::to_string(pid);
+        EXPECT_TRUE(WriteStringToFile(pid_str, "/sys/fs/cgroup/cgroup.procs"));
+        EXPECT_EQ(CgroupPath(pid), "/");
+        EXPECT_EQ(rmdir(("/sys/fs/cgroup" + cgroup_path).c_str()), 0);
+    }
+    EXPECT_EQ(0, StopServicesAndLogViolations({service->name()}, 10s, /*terminate=*/true));
+    ServiceList::GetInstance().RemoveService(*service);
+}
+
+INSTANTIATE_TEST_SUITE_P(service, ServiceStopTest, testing::Values(false, true));
+
 }  // namespace init
 }  // namespace android

From 5d7c35ce205f1b4afadd6a1725c0b5e03962a97c Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers@google.com>
Date: Wed, 22 Nov 2023 18:22:27 +0000
Subject: [PATCH 0582/1487] init: remove session keyring workaround for old
 kernels

The android-4.14-stable and later kernels support the
FS_IOC_ADD_ENCRYPTION_KEY and FS_IOC_REMOVE_ENCRYPTION_KEY ioctls.  This
has superseded the old way of adding fscrypt keys to the kernel, which
was to use the add_key() syscall to add keys to the "session" keyring.
On kernels that support the ioctls, Android doesn't use the obsolete
way.  Since upgrading even just to Android 14 requires at minimum a
android-4.14-stable kernel (according to
https://source.android.com/docs/core/architecture/kernel/android-common#compatibility-matrix),
there is no need to support the obsolete way anymore.

Therefore, this commit removes the code from init that created a keyring
named "fscrypt" in the session keyring.  It also removes the code that
created the session keyring itself, since the only reason that Android
even created a session keyring was just to hold the "fscrypt" keyring.

Flag: N/A for the following reasons:
      - Removing obsolete code, which is fairly safe
      - Very early code, so runtime flag cannot be used
      - Even a build-time flag cannot be used, since init needs
        recovery_available, which aconfig libraries do not support

Bug: 311736104
Test: Build and boot Cuttlefish
Change-Id: Id9a184c68cf16d5c4b1d889444cf637c95a91413
---
 init/Android.bp                  |  1 -
 init/builtins.cpp                |  3 ---
 init/fscrypt_init_extensions.cpp | 16 ----------------
 init/fscrypt_init_extensions.h   |  1 -
 init/fuzzer/Android.bp           |  1 -
 init/init.cpp                    |  6 ------
 6 files changed, 28 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index e5512e62652c..a781d8bb99da 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -188,7 +188,6 @@ libinit_cc_defaults {
         "libfs_mgr",
         "libgsi",
         "libhidl-gen-utils",
-        "libkeyutils",
         "liblog",
         "liblogwrap",
         "liblp",
diff --git a/init/builtins.cpp b/init/builtins.cpp
index a95a4a315b64..606ea8c0aacf 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -592,9 +592,6 @@ static Result<void> queue_fs_event(int code) {
     } else if (code == FS_MGR_MNTALL_DEV_FILE_ENCRYPTED ||
                code == FS_MGR_MNTALL_DEV_IS_METADATA_ENCRYPTED ||
                code == FS_MGR_MNTALL_DEV_NEEDS_METADATA_ENCRYPTION) {
-        if (!FscryptInstallKeyring()) {
-            return Error() << "FscryptInstallKeyring() failed";
-        }
         SetProperty("ro.crypto.state", "encrypted");
 
         // Although encrypted, vold has already set the device up, so we do not need to
diff --git a/init/fscrypt_init_extensions.cpp b/init/fscrypt_init_extensions.cpp
index fbd818957a22..6a561e54cc69 100644
--- a/init/fscrypt_init_extensions.cpp
+++ b/init/fscrypt_init_extensions.cpp
@@ -34,28 +34,12 @@
 #include <cutils/properties.h>
 #include <cutils/sockets.h>
 #include <fscrypt/fscrypt.h>
-#include <keyutils.h>
 #include <logwrap/logwrap.h>
 
 #define TAG "fscrypt"
 
 using namespace android::fscrypt;
 
-bool FscryptInstallKeyring() {
-    if (keyctl_search(KEY_SPEC_SESSION_KEYRING, "keyring", "fscrypt", 0) != -1) {
-        LOG(INFO) << "Keyring is already created";
-        return true;
-    }
-    key_serial_t device_keyring = add_key("keyring", "fscrypt", 0, 0, KEY_SPEC_SESSION_KEYRING);
-
-    if (device_keyring == -1) {
-        PLOG(ERROR) << "Failed to create keyring";
-        return false;
-    }
-    LOG(INFO) << "Keyring created with id " << device_keyring << " in process " << getpid();
-    return true;
-}
-
 // TODO(b/139378601): use a single central implementation of this.
 static void delete_dir_contents(const std::string& dir) {
     char* const paths[2] = {const_cast<char*>(dir.c_str()), nullptr};
diff --git a/init/fscrypt_init_extensions.h b/init/fscrypt_init_extensions.h
index d357bb2fd82b..5e0269a3b096 100644
--- a/init/fscrypt_init_extensions.h
+++ b/init/fscrypt_init_extensions.h
@@ -25,6 +25,5 @@ enum class FscryptAction {
     kDeleteIfNecessary,
 };
 
-bool FscryptInstallKeyring();
 bool FscryptSetDirectoryPolicy(const std::string& ref_basename, FscryptAction action,
                                const std::string& dir);
diff --git a/init/fuzzer/Android.bp b/init/fuzzer/Android.bp
index 856ca8cf5737..9916246d4fc6 100644
--- a/init/fuzzer/Android.bp
+++ b/init/fuzzer/Android.bp
@@ -32,7 +32,6 @@ cc_defaults {
         "libbase",
         "libfs_mgr",
         "libhidl-gen-utils",
-        "libkeyutils",
         "liblog",
         "libprocessgroup",
         "libselinux",
diff --git a/init/init.cpp b/init/init.cpp
index aeccd669692e..19e909fcb5aa 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -54,7 +54,6 @@
 #include <android-base/thread_annotations.h>
 #include <fs_avb/fs_avb.h>
 #include <fs_mgr_vendor_overlay.h>
-#include <keyutils.h>
 #include <libavb/libavb.h>
 #include <libgsi/libgsi.h>
 #include <libsnapshot/snapshot.h>
@@ -971,11 +970,6 @@ int SecondStageMain(int argc, char** argv) {
                    << " to /proc/1/oom_score_adj: " << result.error();
     }
 
-    // Set up a session keyring that all processes will have access to. It
-    // will hold things like FBE encryption keys. No process should override
-    // its session keyring.
-    keyctl_get_keyring_ID(KEY_SPEC_SESSION_KEYRING, 1);
-
     // Indicate that booting is in progress to background fw loaders, etc.
     close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000));
 

From 862f049d178e6158e62fb80ec3cacccf0fe3966b Mon Sep 17 00:00:00 2001
From: Kai Sky <dqksky@gmail.com>
Date: Fri, 24 Nov 2023 14:20:20 +0000
Subject: [PATCH 0583/1487] Looper: Fixed compile error when enabling
 DEBUG_CALLBACKS

When enabling DEBUG_CALLBACKS , compiler complains
for the undeclared identifier 'fd'.
Fix by removing undeclared objects.

Change-Id: I751a9ef9d8843350105acd6a30645f897050ffa4
---
 libutils/Android.bp | 1 +
 libutils/Looper.cpp | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/libutils/Android.bp b/libutils/Android.bp
index 4d4294b9bf2e..85a0fd209b5e 100644
--- a/libutils/Android.bp
+++ b/libutils/Android.bp
@@ -203,6 +203,7 @@ cc_library {
     defaults: ["libutils_impl_defaults"],
 
     cflags: [
+        "-DDEBUG_CALLBACKS=1",
         "-DDEBUG_POLL_AND_WAKE=1",
         "-DDEBUG_REFS=1",
         "-DDEBUG_TOKENIZER=1",
diff --git a/libutils/Looper.cpp b/libutils/Looper.cpp
index 402e43cc6a58..576c61dc6c93 100644
--- a/libutils/Looper.cpp
+++ b/libutils/Looper.cpp
@@ -534,7 +534,7 @@ int Looper::removeFd(int fd) {
 
 int Looper::removeSequenceNumberLocked(SequenceNumber seq) {
 #if DEBUG_CALLBACKS
-    ALOGD("%p ~ removeFd - fd=%d, seq=%u", this, fd, seq);
+    ALOGD("%p ~ removeFd - seq=%" PRIu64, this, seq);
 #endif
 
     const auto& request_it = mRequests.find(seq);

From 1ccb347e87a9647f9ecf026e4207e9617cf9aca3 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Tue, 28 Nov 2023 11:13:55 -0800
Subject: [PATCH 0584/1487] Turn CowOperationType into an enum

There's a bug previsouly where we compare return value of
GetCowOpSourceInfoData() with CowOperationType. Such bugs are possible
because cow operation enums are weakly typed integers. Turn
CowOperationType into strongly typed enum to prevent such bugs.

Test: th
Bug: 304602386
Change-Id: If6941a4740c374ed066cf0aee9e52f4df05a9b38
---
 .../include/libsnapshot/cow_format.h          | 36 ++++++++++++-------
 .../libsnapshot_cow/cow_format.cpp            |  2 +-
 .../libsnapshot/libsnapshot_cow/writer_v2.cpp |  2 +-
 .../libsnapshot/libsnapshot_cow/writer_v2.h   |  2 +-
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp |  2 +-
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |  2 +-
 .../dm-snapshot-merge/snapuserd_worker.cpp    |  3 +-
 .../user-space-merge/read_worker.cpp          |  3 +-
 8 files changed, 33 insertions(+), 19 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 5e5546d44017..debe87eb18eb 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -16,6 +16,7 @@
 
 #include <stdint.h>
 
+#include <limits>
 #include <optional>
 #include <string_view>
 
@@ -119,10 +120,30 @@ struct CowHeaderV3 : public CowHeader {
     uint32_t compression_algorithm;
 } __attribute__((packed));
 
+enum class CowOperationType : uint8_t {
+    kCowCopyOp = 1,
+    kCowReplaceOp = 2,
+    kCowZeroOp = 3,
+    kCowLabelOp = 4,
+    kCowClusterOp = 5,
+    kCowXorOp = 6,
+    kCowSequenceOp = 7,
+    kCowFooterOp = std::numeric_limits<uint8_t>::max(),
+};
+
+static constexpr CowOperationType kCowCopyOp = CowOperationType::kCowCopyOp;
+static constexpr CowOperationType kCowReplaceOp = CowOperationType::kCowReplaceOp;
+static constexpr CowOperationType kCowZeroOp = CowOperationType::kCowZeroOp;
+static constexpr CowOperationType kCowLabelOp = CowOperationType::kCowLabelOp;
+static constexpr CowOperationType kCowClusterOp = CowOperationType::kCowClusterOp;
+static constexpr CowOperationType kCowXorOp = CowOperationType::kCowXorOp;
+static constexpr CowOperationType kCowSequenceOp = CowOperationType::kCowSequenceOp;
+static constexpr CowOperationType kCowFooterOp = CowOperationType::kCowFooterOp;
+
 // This structure is the same size of a normal Operation, but is repurposed for the footer.
 struct CowFooterOperation {
     // The operation code (always kCowFooterOp).
-    uint8_t type;
+    CowOperationType type;
 
     // If this operation reads from the data section of the COW, this contains
     // the compression type of that data (see constants below).
@@ -141,7 +162,7 @@ struct CowFooterOperation {
 // V2 version of COW. On disk format for older devices
 struct CowOperationV2 {
     // The operation code (see the constants and structures below).
-    uint8_t type;
+    CowOperationType type;
 
     // If this operation reads from the data section of the COW, this contains
     // the compression type of that data (see constants below).
@@ -176,7 +197,7 @@ struct CowOperationV2 {
 // The on disk format of cow (currently ==  CowOperation)
 struct CowOperationV3 {
     // The operation code (see the constants and structures below).
-    uint8_t type;
+    CowOperationType type;
 
     // If this operation reads from the data section of the COW, this contains
     // the length.
@@ -201,15 +222,6 @@ struct CowOperationV3 {
 
 static_assert(sizeof(CowOperationV2) == sizeof(CowFooterOperation));
 
-static constexpr uint8_t kCowCopyOp = 1;
-static constexpr uint8_t kCowReplaceOp = 2;
-static constexpr uint8_t kCowZeroOp = 3;
-static constexpr uint8_t kCowLabelOp = 4;
-static constexpr uint8_t kCowClusterOp = 5;
-static constexpr uint8_t kCowXorOp = 6;
-static constexpr uint8_t kCowSequenceOp = 7;
-static constexpr uint8_t kCowFooterOp = -1;
-
 enum CowCompressionAlgorithm : uint8_t {
     kCowCompressNone = 0,
     kCowCompressGz = 1,
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
index 937065d7d34d..4afd02685bf4 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
@@ -30,7 +30,7 @@ namespace snapshot {
 
 using android::base::unique_fd;
 
-std::ostream& EmitCowTypeString(std::ostream& os, uint8_t cow_type) {
+std::ostream& EmitCowTypeString(std::ostream& os, CowOperationType cow_type) {
     switch (cow_type) {
         case kCowCopyOp:
             return os << "kCowCopyOp";
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index 37324c767835..f9a4e479ebed 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -369,7 +369,7 @@ bool CowWriterV2::CompressBlocks(size_t num_blocks, const void* data) {
 }
 
 bool CowWriterV2::EmitBlocks(uint64_t new_block_start, const void* data, size_t size,
-                             uint64_t old_block, uint16_t offset, uint8_t type) {
+                             uint64_t old_block, uint16_t offset, CowOperationType type) {
     CHECK(!merge_in_progress_);
     const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
index 24170ebbdc33..50e635ffdbd3 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
@@ -42,7 +42,7 @@ class CowWriterV2 : public CowWriterBase {
     bool EmitCluster();
     bool EmitClusterIfNeeded();
     bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
-                    uint16_t offset, uint8_t type);
+                    uint16_t offset, CowOperationType type);
     void SetupHeaders();
     void SetupWriteOptions();
     bool ParseOptions();
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index b36c6f3cfe7e..767f3d5896fe 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -230,7 +230,7 @@ bool CowWriterV3::EmitXorBlocks(uint32_t new_block_start, const void* data, size
 }
 
 bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t size,
-                             uint64_t old_block, uint16_t offset, uint8_t type) {
+                             uint64_t old_block, uint16_t offset, CowOperationType type) {
     const size_t num_blocks = (size / header_.block_size);
     for (size_t i = 0; i < num_blocks; i++) {
         const uint8_t* const iter =
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 3dfc33cea032..340218fd2440 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -46,7 +46,7 @@ class CowWriterV3 : public CowWriterBase {
     bool OpenForAppend(uint64_t label);
     bool WriteOperation(const CowOperationV3& op, const void* data = nullptr, size_t size = 0);
     bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
-                    uint16_t offset, uint8_t type);
+                    uint16_t offset, CowOperationType type);
     bool CompressBlocks(size_t num_blocks, const void* data);
 
   private:
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
index 571b352385a0..b24844df61a6 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
@@ -191,7 +191,8 @@ bool WorkerThread::ProcessCowOp(const CowOperation* cow_op) {
         }
 
         default: {
-            SNAP_LOG(ERROR) << "Unsupported operation-type found: " << cow_op->type;
+            SNAP_LOG(ERROR) << "Unsupported operation-type found: "
+                            << static_cast<uint8_t>(cow_op->type);
         }
     }
     return false;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index 5cb13e8bcd43..906316eec21c 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -183,7 +183,8 @@ bool ReadWorker::ProcessCowOp(const CowOperation* cow_op, void* buffer) {
         }
 
         default: {
-            SNAP_LOG(ERROR) << "Unknown operation-type found: " << cow_op->type;
+            SNAP_LOG(ERROR) << "Unknown operation-type found: "
+                            << static_cast<uint8_t>(cow_op->type);
         }
     }
     return false;

From 38cb94d32affa11bb4d4bb6abead8e0821c72580 Mon Sep 17 00:00:00 2001
From: Yu-Ting Tseng <yutingtseng@google.com>
Date: Tue, 21 Nov 2023 09:32:33 -0800
Subject: [PATCH 0585/1487] Add AID_UPROBESTATS and set up its config dir.

Test: m, flash and reboot
Bug: 296108553
Change-Id: Ied5e688db8e93874ad66610c4d98c39d892d268b
---
 libcutils/include/private/android_filesystem_config.h | 1 +
 rootdir/init.rc                                       | 1 +
 2 files changed, 2 insertions(+)

diff --git a/libcutils/include/private/android_filesystem_config.h b/libcutils/include/private/android_filesystem_config.h
index 1e035bbcac72..8c6e54866f4e 100644
--- a/libcutils/include/private/android_filesystem_config.h
+++ b/libcutils/include/private/android_filesystem_config.h
@@ -141,6 +141,7 @@
 #define AID_SDK_SANDBOX 1090      /* SDK sandbox virtual UID */
 #define AID_SECURITY_LOG_WRITER 1091 /* write to security log */
 #define AID_PRNG_SEEDER 1092         /* PRNG seeder daemon */
+#define AID_UPROBESTATS 1093         /* uid for uprobestats */
 /* Changes to this file must be made in AOSP, *not* in internal branches. */
 
 #define AID_SHELL 2000 /* adb and debug shell user */
diff --git a/rootdir/init.rc b/rootdir/init.rc
index fb6473666d7c..b4550581680e 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -808,6 +808,7 @@ on post-fs-data
     mkdir /data/misc/apexdata 0711 root root
     mkdir /data/misc/apexrollback 0700 root root
     mkdir /data/misc/appcompat/ 0700 system system
+    mkdir /data/misc/uprobestats-configs/ 0777 uprobestats uprobestats
     mkdir /data/misc/snapshotctl_log 0755 root root
     # create location to store pre-reboot information
     mkdir /data/misc/prereboot 0700 system system

From b78d0e2856c5401d77839f95d9ae7d829abfa010 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 29 Nov 2023 11:24:28 -0800
Subject: [PATCH 0586/1487] snapshotctl: fsync after writing every 1MB buffer

Sync writes after every 1MB instead of flushing at the end.

Bug: 299011882
Test: Boot device off snapshots
Change-Id: If91168ec92c2b2995bdf296ea1c7d4c261b12411
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshotctl.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index ebaca2dbe92a..0396a55d67a8 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -227,8 +227,12 @@ bool MapSnapshots::WriteSnapshotPatch(std::string cow_device, std::string patch)
         if (file_offset >= dev_sz) {
             break;
         }
+
+        if (fsync(cfd.get()) < 0) {
+            PLOG(ERROR) << "Fsync failed at offset: " << file_offset << " size: " << to_read;
+            return false;
+        }
     }
-    fsync(cfd.get());
     return true;
 }
 

From 3d37da29e7f7664f2663b79125012d19866beafe Mon Sep 17 00:00:00 2001
From: Owner Cleanup Bot
 <swarming-tasks@owners-cleanup-prod.google.com.iam.gserviceaccount.com>
Date: Thu, 30 Nov 2023 16:37:50 +0000
Subject: [PATCH 0587/1487] Remove marcone@google.com from trusty/OWNERS

This suggested change is automatically generated based on group
memberships and affiliations.
If this change is unnecessary or in error, vote CR -1 and the bot
will abandon it. Vote CR +1/2 to approve this change.

See the owner's recent activity for context:
https://android-review.googlesource.com/q/marcone@google.com

To report an issue, file a bug in the Infra>Codereview component.

Change-Id: Ia8f5d261cbfc7328c7dffa0bdf92a5732ba3eee8
---
 trusty/OWNERS | 1 -
 1 file changed, 1 deletion(-)

diff --git a/trusty/OWNERS b/trusty/OWNERS
index bf1691275b67..40167925c0d6 100644
--- a/trusty/OWNERS
+++ b/trusty/OWNERS
@@ -2,7 +2,6 @@ armellel@google.com
 arve@android.com
 danielangell@google.com
 gmar@google.com
-marcone@google.com
 mikemcternan@google.com
 mmaurer@google.com
 ncbray@google.com

From fb3e64ab42da59dbf09a9505b616e29d822ad38e Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Thu, 30 Nov 2023 09:58:31 -0800
Subject: [PATCH 0588/1487] service_test: Only run the ServiceStopTest as root

Despite 'require_root: true' in Android.bp for CtsInitTestCases, it can
happen that this test is run without root privileges. If that happens,
skip the ServiceStopTest.

Bug: 313551148
Change-Id: I45f29369915a1f61e08ffd9bf5601a83a147597c
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 init/service_test.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/init/service_test.cpp b/init/service_test.cpp
index c81b0077f894..a3590b5367b9 100644
--- a/init/service_test.cpp
+++ b/init/service_test.cpp
@@ -236,6 +236,11 @@ class ServiceStopTest : public testing::TestWithParam<bool> {};
 // Service::Stop() if their uid_%d/pid_%d cgroup directory got removed. This test, if run with the
 // parameter set to 'true', verifies that such services are stopped.
 TEST_P(ServiceStopTest, stop) {
+    if (getuid() != 0) {
+        GTEST_SKIP() << "Must be run as root.";
+        return;
+    }
+
     static constexpr std::string_view kServiceName = "ServiceA";
     static constexpr std::string_view kScriptTemplate = R"init(
 service $name /system/bin/yes

From 9bba87244d6bbf46e776834d0917b2dd1143f31d Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Thu, 28 Sep 2023 15:18:56 -0700
Subject: [PATCH 0589/1487] task_profiles.json: Set io.prio.class

Provide an additional way to request the block layer to prioritize
foreground I/O over background I/O. This patch prepares for tests with
the mq-deadline I/O scheduler. While CFQ and BFQ support a "weight"
cgroup attribute, the mq-deadline scheduler does not. The mq-deadline
I/O scheduler only supports the I/O priority class for differentiating
I/O priorities.

The io.prio.class attribute is declared optional since this attribute
only exists if CONFIG_BLK_CGROUP_IOPRIO != n in the kernel
configuration.

Bug: 186902601
Change-Id: Iee1004cd0996e32245aff2b51772ef40178e024f
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 libprocessgroup/profiles/task_profiles.json | 41 +++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 2c08b0b31564..f2ef316e2e7f 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -91,6 +91,11 @@
       "Name": "CfqWeight",
       "Controller": "io",
       "File": "io.weight"
+    },
+    {
+      "Name": "IoPrioClass",
+      "Controller": "io",
+      "File": "io.prio.class"
     }
   ],
 
@@ -479,6 +484,15 @@
             "Value": "200",
             "Optional": "true"
           }
+        },
+        {
+          "Name": "SetAttribute",
+          "Params":
+          {
+            "Name": "IoPrioClass",
+            "Value": "restrict-to-be",
+            "Optional": "true"
+          }
         }
       ]
     },
@@ -511,6 +525,15 @@
             "Value": "1000",
             "Optional": "true"
           }
+        },
+        {
+          "Name": "SetAttribute",
+          "Params":
+          {
+            "Name": "IoPrioClass",
+            "Value": "restrict-to-be",
+            "Optional": "true"
+          }
         }
       ]
     },
@@ -543,6 +566,15 @@
             "Value": "1000",
             "Optional": "true"
           }
+        },
+        {
+          "Name": "SetAttribute",
+          "Params":
+          {
+            "Name": "IoPrioClass",
+            "Value": "promote-to-rt",
+            "Optional": "true"
+          }
         }
       ]
     },
@@ -575,6 +607,15 @@
             "Value": "1000",
             "Optional": "true"
           }
+        },
+        {
+          "Name": "SetAttribute",
+          "Params":
+          {
+            "Name": "IoPrioClass",
+            "Value": "promote-to-rt",
+            "Optional": "true"
+          }
         }
       ]
     },

From 3bcfa9c0398bc55311e9c9a15312e31be938b8bd Mon Sep 17 00:00:00 2001
From: Lucas Henneman <henneman@google.com>
Date: Fri, 1 Dec 2023 20:17:42 +0000
Subject: [PATCH 0590/1487] TEST_MAPPING: fix syntax of TODO tag

Bug: 279009697
Test: git diff
Change-Id: I7133bc0abe6634193b0fb006f5cd77ed2dc05844
Signed-off-by: Lucas Henneman <henneman@google.com>
---
 fs_mgr/TEST_MAPPING | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index 324f50ae9677..edecd7c1523d 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -25,7 +25,7 @@
     {
       "name": "vab_legacy_tests"
     },
-    // TODO: b/279009697
+    // TODO(b/279009697):
     //{"name": "vabc_legacy_tests"},
     {
       "name": "cow_api_test"
@@ -47,7 +47,7 @@
     {
       "name": "vab_legacy_tests"
     },
-    // TODO: b/279009697
+    // TODO(b/279009697):
     //{"name": "vabc_legacy_tests"}
     {
       "name": "snapuserd_test"

From 2bf1da5d2c1ec19ad9f1f74976b65a28401daf00 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Tue, 28 Nov 2023 11:13:55 -0800
Subject: [PATCH 0591/1487] Shove CowOperation type into source_info

We can shove type into source info to save 8 bits in per cow operation.
We only need 4 bits inside of source_info to enumerate all the types of
Cow Operation. Since CowOperationV3 is not used on disk(just yet) , we
can make format changes.

This CL is mechanical:
    1. Remove tye .type field from CowOperation struct
    2. Add a type() getter method to CowOperation struct
    3. Replace all existing usage of `type` member with the new getter

No functional changes, just refactorings.

Test: th
Bug: 304602386
Bug: 313962438

Change-Id: I85d89c71fc6afede12ea299a4a3e3b2184ea2d8b
---
 .../include/libsnapshot/cow_format.h          |  39 ++++--
 .../libsnapshot_cow/cow_format.cpp            |  23 ++--
 .../libsnapshot_cow/cow_reader.cpp            |  16 +--
 .../libsnapshot_cow/inspect_cow.cpp           |  14 +-
 .../libsnapshot/libsnapshot_cow/parser_v2.cpp |   6 +-
 .../libsnapshot/libsnapshot_cow/parser_v3.cpp |   2 +-
 .../libsnapshot_cow/snapshot_reader.cpp       |  10 +-
 .../libsnapshot/libsnapshot_cow/test_v2.cpp   | 130 +++++++++---------
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   |  38 ++---
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp |  20 ++-
 .../snapuserd/dm-snapshot-merge/snapuserd.cpp |   8 +-
 .../dm-snapshot-merge/snapuserd_readahead.cpp |  10 +-
 .../dm-snapshot-merge/snapuserd_worker.cpp    |   4 +-
 .../user-space-merge/merge_worker.cpp         |   4 +-
 .../user-space-merge/read_worker.cpp          |   8 +-
 .../user-space-merge/snapuserd_core.cpp       |   8 +-
 .../user-space-merge/snapuserd_readahead.cpp  |   4 +-
 17 files changed, 179 insertions(+), 165 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index debe87eb18eb..1a7ec6195245 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -19,6 +19,7 @@
 #include <limits>
 #include <optional>
 #include <string_view>
+#include <type_traits>
 
 namespace android {
 namespace snapshot {
@@ -194,11 +195,12 @@ struct CowOperationV2 {
     uint64_t source;
 } __attribute__((packed));
 
+static constexpr uint64_t kCowOpSourceInfoDataMask = (1ULL << 48) - 1;
+static constexpr uint64_t kCowOpSourceInfoTypeBit = 60;
+static constexpr uint64_t kCowOpSourceInfoTypeNumBits = 4;
+static constexpr uint64_t kCowOpSourceInfoTypeMask = (1ULL << kCowOpSourceInfoTypeNumBits) - 1;
 // The on disk format of cow (currently ==  CowOperation)
 struct CowOperationV3 {
-    // The operation code (see the constants and structures below).
-    CowOperationType type;
-
     // If this operation reads from the data section of the COW, this contains
     // the length.
     uint16_t data_length;
@@ -206,6 +208,10 @@ struct CowOperationV3 {
     // The block of data in the new image that this operation modifies.
     uint32_t new_block;
 
+    // source_info with have the following layout
+    // |---4 bits ---| ---12 bits---| --- 48 bits ---|
+    // |--- type --- | -- unused -- | --- source --- |
+    //
     // The value of |source| depends on the operation code.
     //
     // CopyOp: a 32-bit block location in the source image.
@@ -217,9 +223,26 @@ struct CowOperationV3 {
     // For ops other than Label:
     //  Bits 47-62 are reserved and must be zero.
     // A block is compressed if it’s data is < block_sz
-    uint64_t source_info;
+    uint64_t source_info_;
+    constexpr uint64_t source() const { return source_info_ & kCowOpSourceInfoDataMask; }
+    constexpr void set_source(uint64_t source) {
+        source_info_ |= source & kCowOpSourceInfoDataMask;
+    }
+    constexpr CowOperationType type() const {
+        // this is a mask to grab the first 4 bits of a 64 bit integer
+        const auto type = (source_info_ >> kCowOpSourceInfoTypeBit) & kCowOpSourceInfoTypeMask;
+        return static_cast<CowOperationType>(type);
+    }
+    constexpr void set_type(CowOperationType type) {
+        source_info_ |= (static_cast<uint64_t>(type) & kCowOpSourceInfoTypeMask)
+                        << kCowOpSourceInfoTypeBit;
+    }
 } __attribute__((packed));
 
+// Ensure that getters/setters added to CowOperationV3 does not increases size
+// of CowOperationV3 struct(no virtual method tables added).
+static_assert(std::is_trivially_copyable_v<CowOperationV3>);
+static_assert(std::is_standard_layout_v<CowOperationV3>);
 static_assert(sizeof(CowOperationV2) == sizeof(CowFooterOperation));
 
 enum CowCompressionAlgorithm : uint8_t {
@@ -238,12 +261,6 @@ static constexpr uint8_t kCowReadAheadNotStarted = 0;
 static constexpr uint8_t kCowReadAheadInProgress = 1;
 static constexpr uint8_t kCowReadAheadDone = 2;
 
-static constexpr uint64_t kCowOpSourceInfoDataMask = (1ULL << 48) - 1;
-
-static inline uint64_t GetCowOpSourceInfoData(const CowOperation& op) {
-    return op.source_info & kCowOpSourceInfoDataMask;
-}
-
 static constexpr off_t GetSequenceOffset(const CowHeaderV3& header) {
     return header.prefix.header_size + header.buffer_size;
 }
@@ -284,7 +301,7 @@ static constexpr uint64_t BUFFER_REGION_DEFAULT_SIZE = (1ULL << 21);
 
 std::ostream& operator<<(std::ostream& os, CowOperationV2 const& arg);
 
-std::ostream& operator<<(std::ostream& os, CowOperation const& arg);
+std::ostream& operator<<(std::ostream& os, CowOperationV3 const& arg);
 
 std::ostream& operator<<(std::ostream& os, ResumePoint const& arg);
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
index 4afd02685bf4..2c4d40fcb305 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
@@ -80,22 +80,21 @@ std::ostream& operator<<(std::ostream& os, CowOperationV2 const& op) {
     return os;
 }
 
-std::ostream& operator<<(std::ostream& os, CowOperation const& op) {
+std::ostream& operator<<(std::ostream& os, CowOperationV3 const& op) {
     os << "CowOperation(";
-    EmitCowTypeString(os, op.type);
-    if (op.type == kCowReplaceOp || op.type == kCowXorOp || op.type == kCowSequenceOp) {
+    EmitCowTypeString(os, op.type());
+    if (op.type() == kCowReplaceOp || op.type() == kCowXorOp || op.type() == kCowSequenceOp) {
         os << ", data_length:" << op.data_length;
     }
-    if (op.type != kCowClusterOp && op.type != kCowSequenceOp && op.type != kCowLabelOp) {
+    if (op.type() != kCowClusterOp && op.type() != kCowSequenceOp && op.type() != kCowLabelOp) {
         os << ", new_block:" << op.new_block;
     }
-    if (op.type == kCowXorOp || op.type == kCowReplaceOp || op.type == kCowCopyOp) {
-        os << ", source:" << (op.source_info & kCowOpSourceInfoDataMask);
-    } else if (op.type == kCowClusterOp) {
-        os << ", cluster_data:" << (op.source_info & kCowOpSourceInfoDataMask);
-    } else {
-        os << ", label:0x" << android::base::StringPrintf("%" PRIx64, op.source_info);
+    if (op.type() == kCowXorOp || op.type() == kCowReplaceOp || op.type() == kCowCopyOp) {
+        os << ", source:" << op.source();
+    } else if (op.type() == kCowClusterOp) {
+        os << ", cluster_data:" << op.source();
     }
+    // V3 op stores resume points in header, so CowOp can never be Label.
     os << ")";
     return os;
 }
@@ -126,7 +125,7 @@ int64_t GetNextDataOffset(const CowOperationV2& op, uint32_t cluster_ops) {
 }
 
 bool IsMetadataOp(const CowOperation& op) {
-    switch (op.type) {
+    switch (op.type()) {
         case kCowLabelOp:
         case kCowClusterOp:
         case kCowFooterOp:
@@ -138,7 +137,7 @@ bool IsMetadataOp(const CowOperation& op) {
 }
 
 bool IsOrderedOp(const CowOperation& op) {
-    switch (op.type) {
+    switch (op.type()) {
         case kCowCopyOp:
         case kCowXorOp:
             return true;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 7b5370cb2fed..1b4a971ca064 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -345,7 +345,7 @@ bool CowReader::GetSequenceDataV2(std::vector<uint32_t>* merge_op_blocks,
     for (size_t i = 0; i < ops_->size(); i++) {
         auto& current_op = ops_->data()[i];
 
-        if (current_op.type == kCowSequenceOp) {
+        if (current_op.type() == kCowSequenceOp) {
             size_t seq_len = current_op.data_length / sizeof(uint32_t);
 
             merge_op_blocks->resize(merge_op_blocks->size() + seq_len);
@@ -637,11 +637,11 @@ std::unique_ptr<ICowOpIter> CowReader::GetMergeOpIter(bool ignore_progress) {
 }
 
 bool CowReader::GetRawBytes(const CowOperation* op, void* buffer, size_t len, size_t* read) {
-    switch (op->type) {
+    switch (op->type()) {
         case kCowSequenceOp:
         case kCowReplaceOp:
         case kCowXorOp:
-            return GetRawBytes(GetCowOpSourceInfoData(*op), buffer, len, read);
+            return GetRawBytes(op->source(), buffer, len, read);
         default:
             LOG(ERROR) << "Cannot get raw bytes of non-data op: " << *op;
             return false;
@@ -730,10 +730,10 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
     }
 
     uint64_t offset;
-    if (op->type == kCowXorOp) {
+    if (op->type() == kCowXorOp) {
         offset = xor_data_loc_->at(op->new_block);
     } else {
-        offset = GetCowOpSourceInfoData(*op);
+        offset = op->source();
     }
     if (!decompressor ||
         ((op->data_length == header_.block_size) && (header_.prefix.major_version == 3))) {
@@ -747,12 +747,12 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
 }
 
 bool CowReader::GetSourceOffset(const CowOperation* op, uint64_t* source_offset) {
-    switch (op->type) {
+    switch (op->type()) {
         case kCowCopyOp:
-            *source_offset = GetCowOpSourceInfoData(*op) * header_.block_size;
+            *source_offset = op->source() * header_.block_size;
             return true;
         case kCowXorOp:
-            *source_offset = GetCowOpSourceInfoData(*op);
+            *source_offset = op->source();
             return true;
         default:
             return false;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
index 993630b04a7c..371885164ef5 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/inspect_cow.cpp
@@ -199,7 +199,7 @@ static bool Inspect(const std::string& path) {
 
         if (!FLAGS_silent && FLAGS_show_ops) std::cout << *op << "\n";
 
-        if ((FLAGS_decompress || extract_to >= 0) && op->type == kCowReplaceOp) {
+        if ((FLAGS_decompress || extract_to >= 0) && op->type() == kCowReplaceOp) {
             if (reader.ReadData(op, buffer.data(), buffer.size()) < 0) {
                 std::cerr << "Failed to decompress for :" << *op << "\n";
                 success = false;
@@ -213,12 +213,12 @@ static bool Inspect(const std::string& path) {
                     return false;
                 }
             }
-        } else if (extract_to >= 0 && !IsMetadataOp(*op) && op->type != kCowZeroOp) {
+        } else if (extract_to >= 0 && !IsMetadataOp(*op) && op->type() != kCowZeroOp) {
             PLOG(ERROR) << "Cannot extract op yet: " << *op;
             return false;
         }
 
-        if (op->type == kCowSequenceOp && FLAGS_show_merge_sequence) {
+        if (op->type() == kCowSequenceOp && FLAGS_show_merge_sequence) {
             size_t read;
             std::vector<uint32_t> merge_op_blocks;
             size_t seq_len = op->data_length / sizeof(uint32_t);
@@ -236,13 +236,13 @@ static bool Inspect(const std::string& path) {
             }
         }
 
-        if (op->type == kCowCopyOp) {
+        if (op->type() == kCowCopyOp) {
             copy_ops++;
-        } else if (op->type == kCowReplaceOp) {
+        } else if (op->type() == kCowReplaceOp) {
             replace_ops++;
-        } else if (op->type == kCowZeroOp) {
+        } else if (op->type() == kCowZeroOp) {
             zero_ops++;
-        } else if (op->type == kCowXorOp) {
+        } else if (op->type() == kCowXorOp) {
             xor_ops++;
         }
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
index 08a43a4884e2..fe977b723251 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
@@ -205,7 +205,7 @@ bool CowParserV2::Translate(TranslatedCowOps* out) {
         const auto& v2_op = v2_ops_->at(i);
 
         auto& new_op = out->ops->at(i);
-        new_op.type = v2_op.type;
+        new_op.set_type(v2_op.type);
         new_op.data_length = v2_op.data_length;
 
         if (v2_op.new_block > std::numeric_limits<uint32_t>::max()) {
@@ -215,7 +215,7 @@ bool CowParserV2::Translate(TranslatedCowOps* out) {
         new_op.new_block = v2_op.new_block;
 
         uint64_t source_info = v2_op.source;
-        if (new_op.type != kCowLabelOp) {
+        if (new_op.type() != kCowLabelOp) {
             source_info &= kCowOpSourceInfoDataMask;
             if (source_info != v2_op.source) {
                 LOG(ERROR) << "Out-of-range source value in COW op: " << v2_op;
@@ -232,7 +232,7 @@ bool CowParserV2::Translate(TranslatedCowOps* out) {
                 return false;
             }
         }
-        new_op.source_info = source_info;
+        new_op.set_source(source_info);
     }
 
     out->header = header_;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
index 8e0f1907d194..ce68b39f8844 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
@@ -112,7 +112,7 @@ bool CowParserV3::ParseOps(borrowed_fd fd, const uint32_t op_index) {
     xor_data_loc_ = std::make_shared<std::unordered_map<uint64_t, uint64_t>>();
 
     for (auto op : *ops_) {
-        if (op.type == kCowXorOp) {
+        if (op.type() == kCowXorOp) {
             xor_data_loc_->insert({op.new_block, data_pos});
         }
         data_pos += op.data_length;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
index a3e40d962ce7..4e90a0f96d31 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
@@ -147,7 +147,7 @@ ssize_t CompressedSnapshotReader::ReadBlock(uint64_t chunk, size_t start_offset,
         op = ops_[chunk];
     }
 
-    if (!op || op->type == kCowCopyOp) {
+    if (!op || op->type() == kCowCopyOp) {
         borrowed_fd fd = GetSourceFd();
         if (fd < 0) {
             // GetSourceFd sets errno.
@@ -169,15 +169,15 @@ ssize_t CompressedSnapshotReader::ReadBlock(uint64_t chunk, size_t start_offset,
             // ReadFullyAtOffset sets errno.
             return -1;
         }
-    } else if (op->type == kCowZeroOp) {
+    } else if (op->type() == kCowZeroOp) {
         memset(buffer, 0, bytes_to_read);
-    } else if (op->type == kCowReplaceOp) {
+    } else if (op->type() == kCowReplaceOp) {
         if (cow_->ReadData(op, buffer, bytes_to_read, start_offset) < bytes_to_read) {
             LOG(ERROR) << "CompressedSnapshotReader failed to read replace op";
             errno = EIO;
             return -1;
         }
-    } else if (op->type == kCowXorOp) {
+    } else if (op->type() == kCowXorOp) {
         borrowed_fd fd = GetSourceFd();
         if (fd < 0) {
             // GetSourceFd sets errno.
@@ -208,7 +208,7 @@ ssize_t CompressedSnapshotReader::ReadBlock(uint64_t chunk, size_t start_offset,
             ((char*)buffer)[i] ^= data[i];
         }
     } else {
-        LOG(ERROR) << "CompressedSnapshotReader unknown op type: " << uint32_t(op->type);
+        LOG(ERROR) << "CompressedSnapshotReader unknown op type: " << uint32_t(op->type());
         errno = EINVAL;
         return -1;
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 2709059dd40f..49d86d81c57e 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -85,10 +85,10 @@ TEST_F(CowTest, CopyContiguous) {
     size_t i = 0;
     while (!iter->AtEnd()) {
         auto op = iter->Get();
-        ASSERT_EQ(op->type, kCowCopyOp);
+        ASSERT_EQ(op->type(), kCowCopyOp);
         ASSERT_EQ(op->data_length, 0);
         ASSERT_EQ(op->new_block, 10 + i);
-        ASSERT_EQ(GetCowOpSourceInfoData(*op), 1000 + i);
+        ASSERT_EQ(op->source(), 1000 + i);
         iter->Next();
         i += 1;
     }
@@ -131,10 +131,10 @@ TEST_F(CowTest, ReadWrite) {
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowCopyOp);
+    ASSERT_EQ(op->type(), kCowCopyOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 10);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 20);
+    ASSERT_EQ(op->source(), 20);
 
     std::string sink(data.size(), '\0');
 
@@ -142,7 +142,7 @@ TEST_F(CowTest, ReadWrite) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->type(), kCowReplaceOp);
     ASSERT_EQ(op->data_length, 4096);
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -153,19 +153,19 @@ TEST_F(CowTest, ReadWrite) {
     op = iter->Get();
 
     // Note: the zero operation gets split into two blocks.
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(op->type(), kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 51);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
+    ASSERT_EQ(op->source(), 0);
 
     iter->Next();
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(op->type(), kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 52);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
+    ASSERT_EQ(op->source(), 0);
 
     iter->Next();
     ASSERT_TRUE(iter->AtEnd());
@@ -206,10 +206,10 @@ TEST_F(CowTest, ReadWriteXor) {
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowCopyOp);
+    ASSERT_EQ(op->type(), kCowCopyOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 10);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 20);
+    ASSERT_EQ(op->source(), 20);
 
     std::string sink(data.size(), '\0');
 
@@ -217,10 +217,10 @@ TEST_F(CowTest, ReadWriteXor) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowXorOp);
+    ASSERT_EQ(op->type(), kCowXorOp);
     ASSERT_EQ(op->data_length, 4096);
     ASSERT_EQ(op->new_block, 50);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 98314);  // 4096 * 24 + 10
+    ASSERT_EQ(op->source(), 98314);  // 4096 * 24 + 10
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data);
 
@@ -229,19 +229,19 @@ TEST_F(CowTest, ReadWriteXor) {
     op = iter->Get();
 
     // Note: the zero operation gets split into two blocks.
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(op->type(), kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 51);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
+    ASSERT_EQ(op->source(), 0);
 
     iter->Next();
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(op->type(), kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 52);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
+    ASSERT_EQ(op->source(), 0);
 
     iter->Next();
     ASSERT_TRUE(iter->AtEnd());
@@ -273,7 +273,7 @@ TEST_F(CowTest, CompressGz) {
 
     std::string sink(data.size(), '\0');
 
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->type(), kCowReplaceOp);
     ASSERT_EQ(op->data_length, 56);  // compressed!
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -325,16 +325,16 @@ TEST_P(CompressionTest, ThreadedBatchWrites) {
     while (!iter->AtEnd()) {
         auto op = iter->Get();
 
-        if (op->type == kCowXorOp) {
+        if (op->type() == kCowXorOp) {
             total_blocks += 1;
             std::string sink(xor_data.size(), '\0');
             ASSERT_EQ(op->new_block, 50);
-            ASSERT_EQ(GetCowOpSourceInfoData(*op), 98314);  // 4096 * 24 + 10
+            ASSERT_EQ(op->source(), 98314);  // 4096 * 24 + 10
             ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
             ASSERT_EQ(sink, xor_data);
         }
 
-        if (op->type == kCowReplaceOp) {
+        if (op->type() == kCowReplaceOp) {
             total_blocks += 1;
             if (op->new_block == 100) {
                 data.resize(options.block_size);
@@ -399,7 +399,7 @@ TEST_P(CompressionTest, NoBatchWrites) {
     while (!iter->AtEnd()) {
         auto op = iter->Get();
 
-        if (op->type == kCowReplaceOp) {
+        if (op->type() == kCowReplaceOp) {
             total_blocks += 1;
             if (op->new_block == 50) {
                 data.resize(options.block_size);
@@ -519,7 +519,7 @@ TEST_F(CowTest, ClusterCompressGz) {
 
     std::string sink(data.size(), '\0');
 
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->type(), kCowReplaceOp);
     ASSERT_EQ(op->data_length, 56);  // compressed!
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -529,7 +529,7 @@ TEST_F(CowTest, ClusterCompressGz) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowClusterOp);
+    ASSERT_EQ(op->type(), kCowClusterOp);
 
     iter->Next();
     ASSERT_FALSE(iter->AtEnd());
@@ -546,7 +546,7 @@ TEST_F(CowTest, ClusterCompressGz) {
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowClusterOp);
+    ASSERT_EQ(op->type(), kCowClusterOp);
 
     iter->Next();
     ASSERT_TRUE(iter->AtEnd());
@@ -580,7 +580,7 @@ TEST_F(CowTest, CompressTwoBlocks) {
     std::string sink(options.block_size, '\0');
 
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->type(), kCowReplaceOp);
     ASSERT_EQ(op->new_block, 51);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
 }
@@ -653,7 +653,7 @@ TEST_F(CowTest, AppendLabelSmall) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->type(), kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data);
 
@@ -663,14 +663,14 @@ TEST_F(CowTest, AppendLabelSmall) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 3);
+    ASSERT_EQ(op->type(), kCowLabelOp);
+    ASSERT_EQ(op->source(), 3);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->type(), kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data2);
 
@@ -716,14 +716,14 @@ TEST_F(CowTest, AppendLabelMissing) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 0);
+    ASSERT_EQ(op->type(), kCowLabelOp);
+    ASSERT_EQ(op->source(), 0);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(op->type(), kCowZeroOp);
 
     iter->Next();
 
@@ -774,8 +774,8 @@ TEST_F(CowTest, AppendExtendedCorrupted) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 5);
+    ASSERT_EQ(op->type(), kCowLabelOp);
+    ASSERT_EQ(op->source(), 5);
 
     iter->Next();
     ASSERT_TRUE(iter->AtEnd());
@@ -825,7 +825,7 @@ TEST_F(CowTest, AppendbyLabel) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->type(), kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data.substr(0, options.block_size));
 
@@ -835,7 +835,7 @@ TEST_F(CowTest, AppendbyLabel) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->type(), kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data.substr(options.block_size, 2 * options.block_size));
 
@@ -843,26 +843,26 @@ TEST_F(CowTest, AppendbyLabel) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 4);
+    ASSERT_EQ(op->type(), kCowLabelOp);
+    ASSERT_EQ(op->source(), 4);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(op->type(), kCowZeroOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(op->type(), kCowZeroOp);
 
     iter->Next();
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 5);
+    ASSERT_EQ(op->type(), kCowLabelOp);
+    ASSERT_EQ(op->source(), 5);
 
     iter->Next();
 
@@ -906,7 +906,7 @@ TEST_F(CowTest, ClusterTest) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->type(), kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data.substr(0, options.block_size));
 
@@ -914,52 +914,52 @@ TEST_F(CowTest, ClusterTest) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 4);
+    ASSERT_EQ(op->type(), kCowLabelOp);
+    ASSERT_EQ(op->source(), 4);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(op->type(), kCowZeroOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowClusterOp);
+    ASSERT_EQ(op->type(), kCowClusterOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(op->type(), kCowZeroOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 5);
+    ASSERT_EQ(op->type(), kCowLabelOp);
+    ASSERT_EQ(op->source(), 5);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowCopyOp);
+    ASSERT_EQ(op->type(), kCowCopyOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowClusterOp);
+    ASSERT_EQ(op->type(), kCowClusterOp);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 6);
+    ASSERT_EQ(op->type(), kCowLabelOp);
+    ASSERT_EQ(op->source(), 6);
 
     iter->Next();
 
@@ -1005,14 +1005,14 @@ TEST_F(CowTest, ClusterAppendTest) {
 
     ASSERT_FALSE(iter->AtEnd());
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowLabelOp);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 50);
+    ASSERT_EQ(op->type(), kCowLabelOp);
+    ASSERT_EQ(op->source(), 50);
 
     iter->Next();
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->type(), kCowReplaceOp);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data2);
 
@@ -1020,7 +1020,7 @@ TEST_F(CowTest, ClusterAppendTest) {
 
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
-    ASSERT_EQ(op->type, kCowClusterOp);
+    ASSERT_EQ(op->type(), kCowClusterOp);
 
     iter->Next();
 
@@ -1117,12 +1117,12 @@ TEST_F(CowTest, ResumeMidCluster) {
         num_in_cluster++;
         max_in_cluster = std::max(max_in_cluster, num_in_cluster);
 
-        if (op->type == kCowReplaceOp) {
+        if (op->type() == kCowReplaceOp) {
             num_replace++;
 
             ASSERT_EQ(op->new_block, num_replace);
             ASSERT_TRUE(CompareDataBlock(&reader, op, "Block " + std::to_string(num_replace)));
-        } else if (op->type == kCowClusterOp) {
+        } else if (op->type() == kCowClusterOp) {
             num_in_cluster = 0;
             num_clusters++;
         }
@@ -1178,12 +1178,12 @@ TEST_F(CowTest, ResumeEndCluster) {
         num_in_cluster++;
         max_in_cluster = std::max(max_in_cluster, num_in_cluster);
 
-        if (op->type == kCowReplaceOp) {
+        if (op->type() == kCowReplaceOp) {
             num_replace++;
 
             ASSERT_EQ(op->new_block, num_replace);
             ASSERT_TRUE(CompareDataBlock(&reader, op, "Block " + std::to_string(num_replace)));
-        } else if (op->type == kCowClusterOp) {
+        } else if (op->type() == kCowClusterOp) {
             num_in_cluster = 0;
             num_clusters++;
         }
@@ -1229,12 +1229,12 @@ TEST_F(CowTest, DeleteMidCluster) {
 
         num_in_cluster++;
         max_in_cluster = std::max(max_in_cluster, num_in_cluster);
-        if (op->type == kCowReplaceOp) {
+        if (op->type() == kCowReplaceOp) {
             num_replace++;
 
             ASSERT_EQ(op->new_block, num_replace);
             ASSERT_TRUE(CompareDataBlock(&reader, op, "Block " + std::to_string(num_replace)));
-        } else if (op->type == kCowClusterOp) {
+        } else if (op->type() == kCowClusterOp) {
             num_in_cluster = 0;
             num_clusters++;
         }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 9ac14482affe..ea34c27fde09 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -128,19 +128,19 @@ TEST_F(CowTestV3, ZeroOp) {
     ASSERT_FALSE(iter->AtEnd());
 
     auto op = iter->Get();
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(op->type(), kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 1);
-    ASSERT_EQ(op->source_info, 0);
+    ASSERT_EQ(op->source(), 0);
 
     iter->Next();
     ASSERT_FALSE(iter->AtEnd());
     op = iter->Get();
 
-    ASSERT_EQ(op->type, kCowZeroOp);
+    ASSERT_EQ(op->type(), kCowZeroOp);
     ASSERT_EQ(op->data_length, 0);
     ASSERT_EQ(op->new_block, 2);
-    ASSERT_EQ(op->source_info, 0);
+    ASSERT_EQ(op->source(), 0);
 }
 
 TEST_F(CowTestV3, ReplaceOp) {
@@ -171,7 +171,7 @@ TEST_F(CowTestV3, ReplaceOp) {
     auto op = iter->Get();
     std::string sink(data.size(), '\0');
 
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->type(), kCowReplaceOp);
     ASSERT_EQ(op->data_length, 4096);
     ASSERT_EQ(op->new_block, 5);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -211,7 +211,7 @@ TEST_F(CowTestV3, ConsecutiveReplaceOp) {
 
     while (!iter->AtEnd()) {
         auto op = iter->Get();
-        ASSERT_EQ(op->type, kCowReplaceOp);
+        ASSERT_EQ(op->type(), kCowReplaceOp);
         ASSERT_EQ(op->data_length, options.block_size);
         ASSERT_EQ(op->new_block, 5 + i);
         ASSERT_TRUE(
@@ -249,10 +249,10 @@ TEST_F(CowTestV3, CopyOp) {
     size_t i = 0;
     while (!iter->AtEnd()) {
         auto op = iter->Get();
-        ASSERT_EQ(op->type, kCowCopyOp);
+        ASSERT_EQ(op->type(), kCowCopyOp);
         ASSERT_EQ(op->data_length, 0);
         ASSERT_EQ(op->new_block, 10 + i);
-        ASSERT_EQ(GetCowOpSourceInfoData(*op), 1000 + i);
+        ASSERT_EQ(op->source(), 1000 + i);
         iter->Next();
         i += 1;
     }
@@ -285,10 +285,10 @@ TEST_F(CowTestV3, XorOp) {
     auto op = iter->Get();
     std::string sink(data.size(), '\0');
 
-    ASSERT_EQ(op->type, kCowXorOp);
+    ASSERT_EQ(op->type(), kCowXorOp);
     ASSERT_EQ(op->data_length, 4096);
     ASSERT_EQ(op->new_block, 50);
-    ASSERT_EQ(GetCowOpSourceInfoData(*op), 98314);  // 4096 * 24 + 10
+    ASSERT_EQ(op->source(), 98314);  // 4096 * 24 + 10
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
     ASSERT_EQ(sink, data);
 }
@@ -325,10 +325,10 @@ TEST_F(CowTestV3, ConsecutiveXorOp) {
 
     while (!iter->AtEnd()) {
         auto op = iter->Get();
-        ASSERT_EQ(op->type, kCowXorOp);
+        ASSERT_EQ(op->type(), kCowXorOp);
         ASSERT_EQ(op->data_length, 4096);
         ASSERT_EQ(op->new_block, 50 + i);
-        ASSERT_EQ(GetCowOpSourceInfoData(*op), 98314 + (i * options.block_size));  // 4096 * 24 + 10
+        ASSERT_EQ(op->source(), 98314 + (i * options.block_size));  // 4096 * 24 + 10
         ASSERT_TRUE(
                 ReadData(reader, op, sink.data() + (i * options.block_size), options.block_size));
         iter->Next();
@@ -378,7 +378,7 @@ TEST_F(CowTestV3, AllOpsWithCompression) {
 
     while (i < 5) {
         auto op = iter->Get();
-        ASSERT_EQ(op->type, kCowZeroOp);
+        ASSERT_EQ(op->type(), kCowZeroOp);
         ASSERT_EQ(op->new_block, 10 + i);
         iter->Next();
         i++;
@@ -386,9 +386,9 @@ TEST_F(CowTestV3, AllOpsWithCompression) {
     i = 0;
     while (i < 5) {
         auto op = iter->Get();
-        ASSERT_EQ(op->type, kCowCopyOp);
+        ASSERT_EQ(op->type(), kCowCopyOp);
         ASSERT_EQ(op->new_block, 15 + i);
-        ASSERT_EQ(GetCowOpSourceInfoData(*op), 3 + i);
+        ASSERT_EQ(op->source(), 3 + i);
         iter->Next();
         i++;
     }
@@ -397,7 +397,7 @@ TEST_F(CowTestV3, AllOpsWithCompression) {
 
     while (i < 5) {
         auto op = iter->Get();
-        ASSERT_EQ(op->type, kCowReplaceOp);
+        ASSERT_EQ(op->type(), kCowReplaceOp);
         ASSERT_EQ(op->new_block, 18 + i);
         ASSERT_TRUE(
                 ReadData(reader, op, sink.data() + (i * options.block_size), options.block_size));
@@ -410,9 +410,9 @@ TEST_F(CowTestV3, AllOpsWithCompression) {
     std::fill(sink.begin(), sink.end(), '\0');
     while (i < 5) {
         auto op = iter->Get();
-        ASSERT_EQ(op->type, kCowXorOp);
+        ASSERT_EQ(op->type(), kCowXorOp);
         ASSERT_EQ(op->new_block, 50 + i);
-        ASSERT_EQ(GetCowOpSourceInfoData(*op), 98314 + (i * options.block_size));  // 4096 * 24 + 10
+        ASSERT_EQ(op->source(), 98314 + (i * options.block_size));  // 4096 * 24 + 10
         ASSERT_TRUE(
                 ReadData(reader, op, sink.data() + (i * options.block_size), options.block_size));
         iter->Next();
@@ -448,7 +448,7 @@ TEST_F(CowTestV3, GzCompression) {
 
     std::string sink(data.size(), '\0');
 
-    ASSERT_EQ(op->type, kCowReplaceOp);
+    ASSERT_EQ(op->type(), kCowReplaceOp);
     ASSERT_EQ(op->data_length, 56);  // compressed!
     ASSERT_EQ(op->new_block, 50);
     ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 767f3d5896fe..5bdc5fd2caaa 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -176,7 +176,7 @@ bool CowWriterV3::OpenForWrite() {
 }
 
 bool CowWriterV3::OpenForAppend(uint64_t label) {
-    CowHeaderV3 header_v3;
+    CowHeaderV3 header_v3{};
     if (!ReadCowHeader(fd_, &header_v3)) {
         LOG(ERROR) << "Couldn't read Cow Header";
         return false;
@@ -208,10 +208,10 @@ bool CowWriterV3::OpenForAppend(uint64_t label) {
 
 bool CowWriterV3::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks) {
     for (size_t i = 0; i < num_blocks; i++) {
-        CowOperationV3 op = {};
-        op.type = kCowCopyOp;
+        CowOperationV3 op{};
+        op.set_type(kCowCopyOp);
         op.new_block = new_block + i;
-        op.source_info = old_block + i;
+        op.set_source(old_block + i);
         if (!WriteOperation(op)) {
             return false;
         }
@@ -239,11 +239,11 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
         CowOperation op = {};
         op.new_block = new_block_start + i;
 
-        op.type = type;
+        op.set_type(type);
         if (type == kCowXorOp) {
-            op.source_info = (old_block + i) * header_.block_size + offset;
+            op.set_source((old_block + i) * header_.block_size + offset);
         } else {
-            op.source_info = next_data_pos_;
+            op.set_source(next_data_pos_);
         }
         std::basic_string<uint8_t> compressed_data;
         const void* out_data = iter;
@@ -273,11 +273,9 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
 
 bool CowWriterV3::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
     for (uint64_t i = 0; i < num_blocks; i++) {
-        CowOperationV3 op;
-        op.type = kCowZeroOp;
-        op.data_length = 0;
+        CowOperationV3 op{};
+        op.set_type(kCowZeroOp);
         op.new_block = new_block_start + i;
-        op.source_info = 0;
         if (!WriteOperation(op)) {
             return false;
         }
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
index 6dc082e86ffa..93bb0b2de617 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
@@ -406,9 +406,9 @@ bool Snapuserd::ReadMetadata() {
             break;
         }
 
-        if (cow_op->type == kCowReplaceOp) {
+        if (cow_op->type() == kCowReplaceOp) {
             replace_ops++;
-        } else if (cow_op->type == kCowZeroOp) {
+        } else if (cow_op->type() == kCowZeroOp) {
             zero_ops++;
         }
 
@@ -508,7 +508,7 @@ bool Snapuserd::ReadMetadata() {
             // the merge of operations are done based on the ops present
             // in the file.
             //===========================================================
-            uint64_t block_source = GetCowOpSourceInfoData(*cow_op);
+            uint64_t block_source = cow_op->source();
             if (prev_id.has_value()) {
                 if (dest_blocks.count(cow_op->new_block) || source_blocks.count(block_source)) {
                     break;
@@ -540,7 +540,7 @@ bool Snapuserd::ReadMetadata() {
             chunk_vec_.push_back(std::make_pair(ChunkToSector(data_chunk_id), cow_op));
             offset += sizeof(struct disk_exception);
             num_ops += 1;
-            if (cow_op->type == kCowCopyOp) {
+            if (cow_op->type() == kCowCopyOp) {
                 copy_ops++;
             }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
index ab0b3094b5fd..f1b9245dc637 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
@@ -172,7 +172,7 @@ ReadAheadThread::ReadAheadThread(const std::string& cow_device, const std::strin
 }
 
 void ReadAheadThread::CheckOverlap(const CowOperation* cow_op) {
-    uint64_t source_block = GetCowOpSourceInfoData(*cow_op);
+    uint64_t source_block = cow_op->source();
     if (dest_blocks_.count(cow_op->new_block) || source_blocks_.count(source_block)) {
         overlap_ = true;
     }
@@ -191,8 +191,8 @@ void ReadAheadThread::PrepareReadAhead(uint64_t* source_offset, int* pending_ops
         // Get the first block with offset
         const CowOperation* cow_op = GetRAOpIter();
         CHECK_NE(cow_op, nullptr);
-        *source_offset = GetCowOpSourceInfoData(*cow_op);
-        if (cow_op->type == kCowCopyOp) {
+        *source_offset = cow_op->source();
+        if (cow_op->type() == kCowCopyOp) {
             *source_offset *= BLOCK_SZ;
         }
         RAIterNext();
@@ -210,8 +210,8 @@ void ReadAheadThread::PrepareReadAhead(uint64_t* source_offset, int* pending_ops
         while (!RAIterDone() && num_ops) {
             const CowOperation* op = GetRAOpIter();
             CHECK_NE(op, nullptr);
-            uint64_t next_offset = GetCowOpSourceInfoData(*op);
-            if (op->type == kCowCopyOp) {
+            uint64_t next_offset = op->source();
+            if (op->type() == kCowCopyOp) {
                 next_offset *= BLOCK_SZ;
             }
             if (next_offset + nr_consecutive * BLOCK_SZ != *source_offset) {
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
index b24844df61a6..1f5d5682a99d 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
@@ -177,7 +177,7 @@ bool WorkerThread::ProcessCowOp(const CowOperation* cow_op) {
         return false;
     }
 
-    switch (cow_op->type) {
+    switch (cow_op->type()) {
         case kCowReplaceOp: {
             return ProcessReplaceOp(cow_op);
         }
@@ -192,7 +192,7 @@ bool WorkerThread::ProcessCowOp(const CowOperation* cow_op) {
 
         default: {
             SNAP_LOG(ERROR) << "Unsupported operation-type found: "
-                            << static_cast<uint8_t>(cow_op->type);
+                            << static_cast<uint8_t>(cow_op->type());
         }
     }
     return false;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index 11b8d7c92f0e..3a566693178f 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -114,13 +114,13 @@ bool MergeWorker::MergeReplaceZeroOps() {
                 SNAP_LOG(ERROR) << "AcquireBuffer failed in MergeReplaceOps";
                 return false;
             }
-            if (cow_op->type == kCowReplaceOp) {
+            if (cow_op->type() == kCowReplaceOp) {
                 if (!reader_->ReadData(cow_op, buffer, BLOCK_SZ)) {
                     SNAP_LOG(ERROR) << "Failed to read COW in merge";
                     return false;
                 }
             } else {
-                CHECK(cow_op->type == kCowZeroOp);
+                CHECK(cow_op->type() == kCowZeroOp);
                 memset(buffer, 0, BLOCK_SZ);
             }
         }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index 906316eec21c..431baf06069b 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -63,7 +63,7 @@ bool ReadWorker::ReadFromSourceDevice(const CowOperation* cow_op, void* buffer)
                     << " Op: " << *cow_op;
     if (!android::base::ReadFullyAtOffset(backing_store_fd_, buffer, BLOCK_SZ, offset)) {
         std::string op;
-        if (cow_op->type == kCowCopyOp)
+        if (cow_op->type() == kCowCopyOp)
             op = "Copy-op";
         else {
             op = "Xor-op";
@@ -133,7 +133,7 @@ bool ReadWorker::ProcessOrderedOp(const CowOperation* cow_op, void* buffer) {
         }
         case MERGE_GROUP_STATE::GROUP_MERGE_PENDING: {
             bool ret;
-            if (cow_op->type == kCowCopyOp) {
+            if (cow_op->type() == kCowCopyOp) {
                 ret = ProcessCopyOp(cow_op, buffer);
             } else {
                 ret = ProcessXorOp(cow_op, buffer);
@@ -167,7 +167,7 @@ bool ReadWorker::ProcessCowOp(const CowOperation* cow_op, void* buffer) {
         return false;
     }
 
-    switch (cow_op->type) {
+    switch (cow_op->type()) {
         case kCowReplaceOp: {
             return ProcessReplaceOp(cow_op, buffer);
         }
@@ -184,7 +184,7 @@ bool ReadWorker::ProcessCowOp(const CowOperation* cow_op, void* buffer) {
 
         default: {
             SNAP_LOG(ERROR) << "Unknown operation-type found: "
-                            << static_cast<uint8_t>(cow_op->type);
+                            << static_cast<uint8_t>(cow_op->type());
         }
     }
     return false;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 950d7719d7ba..9b8c70d32d1d 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -199,13 +199,13 @@ bool SnapshotHandler::ReadMetadata() {
     while (!cowop_iter->AtEnd()) {
         const CowOperation* cow_op = cowop_iter->Get();
 
-        if (cow_op->type == kCowCopyOp) {
+        if (cow_op->type() == kCowCopyOp) {
             copy_ops += 1;
-        } else if (cow_op->type == kCowReplaceOp) {
+        } else if (cow_op->type() == kCowReplaceOp) {
             replace_ops += 1;
-        } else if (cow_op->type == kCowZeroOp) {
+        } else if (cow_op->type() == kCowZeroOp) {
             zero_ops += 1;
-        } else if (cow_op->type == kCowXorOp) {
+        } else if (cow_op->type() == kCowXorOp) {
             xor_ops += 1;
         }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index 998d233d5ad1..034cda163ba3 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -77,7 +77,7 @@ int ReadAhead::PrepareNextReadAhead(uint64_t* source_offset, int* pending_ops,
         SNAP_LOG(ERROR) << "PrepareNextReadAhead operation has no source offset: " << *cow_op;
         return nr_consecutive;
     }
-    if (cow_op->type == kCowXorOp) {
+    if (cow_op->type() == kCowXorOp) {
         xor_op_vec.push_back(cow_op);
     }
 
@@ -106,7 +106,7 @@ int ReadAhead::PrepareNextReadAhead(uint64_t* source_offset, int* pending_ops,
             break;
         }
 
-        if (op->type == kCowXorOp) {
+        if (op->type() == kCowXorOp) {
             xor_op_vec.push_back(op);
         }
 

From 7d526560df250f1636de75cff5d4ff6e0f3a8e3e Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Mon, 4 Dec 2023 09:29:20 -0800
Subject: [PATCH 0592/1487] Allow Cow version v3 to be used

This does not change the default cow version. Currently v2 is still the
default. This CL only enables OEMs to set virtual_ab_cow_version to 3
for testing purposes.

Test: th
Bug: 313962438
Change-Id: I7a328fa32283560a48604ffe02edd2551ac49a83
---
 fs_mgr/libsnapshot/include/libsnapshot/cow_format.h | 2 +-
 fs_mgr/libsnapshot/snapshot.cpp                     | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 1a7ec6195245..717ad2dcb875 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -34,7 +34,7 @@ static constexpr uint32_t kCowVersionMinor = 0;
 static constexpr uint32_t kCowVersionManifest = 2;
 
 static constexpr uint32_t kMinCowVersion = 1;
-static constexpr uint32_t kMaxCowVersion = 2;
+static constexpr uint32_t kMaxCowVersion = 3;
 
 // Normally, this should be kMaxCowVersion. When a new version is under testing
 // it may be the previous value of kMaxCowVersion.
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index e91e3b73cf87..79cebab78973 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -3642,6 +3642,9 @@ std::unique_ptr<ICowWriter> SnapshotManager::OpenCompressedSnapshotWriter(
     cow_options.max_blocks = {status.device_size() / cow_options.block_size};
     cow_options.batch_write = status.batched_writes();
     cow_options.num_compress_threads = status.enable_threading() ? 2 : 0;
+    // TODO(b/313962438) Improve op_count estimate. For now, use number of
+    // blocks as an upper bound.
+    cow_options.op_count_max = status.device_size() / cow_options.block_size;
     // Disable scratch space for vts tests
     if (device()->IsTestDevice()) {
         cow_options.scratch_space = false;

From a8f6ce3344f5750e36da5f6aae441775c2cdd1b0 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 15 Nov 2023 12:59:17 -0800
Subject: [PATCH 0593/1487] libsnapshot: Tune readahead during OTA for source
 and COW block device

Scanning of partitions post OTA leads to memory pressure. Tune
the read-ahead of source and COW block device. This is currently
set to 32KB.

This reduces Inactive(file) and Active(file) usage during entire
duration of boot post OTA.

On Pixel 6: For incremental OTA ~400M. During boot:

                            Without-patch         With-patch    Delta
			    --------------------------------------------
1: Peak Inactive(file):     4469MB                3118MB        ~30%

2: Peak Active(file):       985MB                 712MB         ~27%

No regression observed on boot time.

Additionally, cut down the number of threads to verify the partitions.

Bug: 311233916
Test: Incremental OTA on Pixel 6
Change-Id: I0b842776c36fa089c39c170fa7bf0f246e16636d
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../include/libsnapshot/snapshot.h            |  3 ++
 fs_mgr/libsnapshot/snapshot.cpp               | 46 +++++++++++++++++++
 .../user-space-merge/snapuserd_verify.h       | 23 ++++++++--
 3 files changed, 69 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index 08a79baed097..d102863123f9 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -826,6 +826,9 @@ class SnapshotManager final : public ISnapshotManager {
     bool DeleteDeviceIfExists(const std::string& name,
                               const std::chrono::milliseconds& timeout_ms = {});
 
+    // Set read-ahead size during OTA
+    void SetReadAheadSize(const std::string& entry_block_device, off64_t size_kb);
+
     android::dm::IDeviceMapper& dm_;
     std::unique_ptr<IDeviceInfo> device_;
     std::string metadata_dir_;
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index e91e3b73cf87..81f396ab0049 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -30,6 +30,7 @@
 #include <android-base/logging.h>
 #include <android-base/parseint.h>
 #include <android-base/properties.h>
+#include <android-base/stringprintf.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 #include <cutils/sockets.h>
@@ -82,12 +83,28 @@ using RepeatedPtrField = google::protobuf::RepeatedPtrField<T>;
 using std::chrono::duration_cast;
 using namespace std::chrono_literals;
 using namespace std::string_literals;
+using android::base::Realpath;
+using android::base::StringPrintf;
 
 static constexpr char kBootSnapshotsWithoutSlotSwitch[] =
         "/metadata/ota/snapshot-boot-without-slot-switch";
 static constexpr char kBootIndicatorPath[] = "/metadata/ota/snapshot-boot";
 static constexpr char kRollbackIndicatorPath[] = "/metadata/ota/rollback-indicator";
 static constexpr auto kUpdateStateCheckInterval = 2s;
+/*
+ * The readahead size is set to 32kb so that
+ * there is no significant memory pressure (/proc/pressure/memory) during boot.
+ * After OTA, during boot, partitions are scanned before marking slot as successful.
+ * This scan will trigger readahead both on source and COW block device thereby
+ * leading to Inactive(file) pages to be very high.
+ *
+ * A lower value may help reduce memory pressure further, however, that will
+ * increase the boot time. Thus, for device which don't care about OTA boot
+ * time, they could use O_DIRECT functionality wherein the I/O to the source
+ * block device will be O_DIRECT.
+ */
+static constexpr auto kCowReadAheadSizeKb = 32;
+static constexpr auto kSourceReadAheadSizeKb = 32;
 
 // Note: IImageManager is an incomplete type in the header, so the default
 // destructor doesn't work.
@@ -1748,6 +1765,9 @@ bool SnapshotManager::PerformInitTransition(InitTransition transition,
                 snapuserd_argv->emplace_back(std::move(message));
             }
 
+            SetReadAheadSize(cow_image_device, kCowReadAheadSizeKb);
+            SetReadAheadSize(source_device, kSourceReadAheadSizeKb);
+
             // Do not attempt to connect to the new snapuserd yet, it hasn't
             // been started. We do however want to wait for the misc device
             // to have been created.
@@ -4404,5 +4424,31 @@ bool SnapshotManager::PrepareDeviceToBootWithoutSnapshot() {
     return true;
 }
 
+void SnapshotManager::SetReadAheadSize(const std::string& entry_block_device, off64_t size_kb) {
+    std::string block_device;
+    if (!Realpath(entry_block_device, &block_device)) {
+        PLOG(ERROR) << "Failed to realpath " << entry_block_device;
+        return;
+    }
+
+    static constexpr std::string_view kDevBlockPrefix("/dev/block/");
+    if (!android::base::StartsWith(block_device, kDevBlockPrefix)) {
+        LOG(ERROR) << block_device << " is not a block device";
+        return;
+    }
+
+    std::string block_name = block_device.substr(kDevBlockPrefix.length());
+    std::string sys_partition =
+            android::base::StringPrintf("/sys/class/block/%s/partition", block_name.c_str());
+    struct stat info;
+    if (lstat(sys_partition.c_str(), &info) == 0) {
+        block_name += "/..";
+    }
+    std::string sys_ra = android::base::StringPrintf("/sys/class/block/%s/queue/read_ahead_kb",
+                                                     block_name.c_str());
+    std::string size = std::to_string(size_kb);
+    android::base::WriteStringToFile(size, sys_ra.c_str());
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h
index d07d2f836838..7c990851522e 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h
@@ -48,10 +48,27 @@ class UpdateVerify {
     std::mutex m_lock_;
     std::condition_variable m_cv_;
 
+    /*
+     * Scanning of partitions is an expensive operation both in terms of memory
+     * and CPU usage. The goal here is to scan the partitions fast enough without
+     * significant increase in the boot time.
+     *
+     * Partitions such as system, product which may be huge and may need multiple
+     * threads to speed up the verification process. Using multiple threads for
+     * all partitions may increase CPU usage significantly. Hence, limit that to
+     * 1 thread per partition.
+     *
+     * These numbers were derived by monitoring the memory and CPU pressure
+     * (/proc/pressure/{cpu,memory}; and monitoring the Inactive(file) and
+     * Active(file) pages from /proc/meminfo.
+     *
+     * Additionally, for low memory devices, it is advisible to use O_DIRECT
+     * fucntionality for source block device.
+     */
     int kMinThreadsToVerify = 1;
-    int kMaxThreadsToVerify = 4;
-    uint64_t kThresholdSize = 512_MiB;
-    uint64_t kBlockSizeVerify = 1_MiB;
+    int kMaxThreadsToVerify = 3;
+    uint64_t kThresholdSize = 750_MiB;
+    uint64_t kBlockSizeVerify = 2_MiB;
 
     bool IsBlockAligned(uint64_t read_size) { return ((read_size & (BLOCK_SZ - 1)) == 0); }
     void UpdatePartitionVerificationState(UpdateVerifyState state);

From 52f1c19a1754cf9b83395d42de1c37ebc2eadd14 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 16 Nov 2023 16:15:15 -0800
Subject: [PATCH 0594/1487] Allow direct reads on source device

Allow O_DIRECT reads on source block device.
This will further cut down the Active and Inactive file pages
during partition verification.

On Pixel 6 after incremental OTA - Post OTA reboot:

		Without patch      With patch     Delta
--------------------------------------------------------
Inactive(File):  4992MB             3887MB         ~22%
Active(File):    1465MB             1014MB         ~30%

Boot time however increases from 25 to 30 seconds.

This is not yet enabled. This will be behind a sysprop flag
or for low memory devices and will be enabled later.

Additionally, set the priority of worker threads to normal.
Merge threads priority is reduced. This will help low memory
devices as tested on Pixel watch.

Bug: 311233916
Test: OTA on Pixel 6
Change-Id: Icacdef08d68e28d3062611477703e7cf393a9f10
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../snapuserd/user-space-merge/extractor.cpp  |  4 +-
 .../user-space-merge/handler_manager.cpp      |  9 ++--
 .../user-space-merge/handler_manager.h        |  6 ++-
 .../user-space-merge/merge_worker.cpp         |  2 +-
 .../user-space-merge/read_worker.cpp          | 38 +++++++++++++--
 .../snapuserd/user-space-merge/read_worker.h  |  5 +-
 .../user-space-merge/snapuserd_core.cpp       |  5 +-
 .../user-space-merge/snapuserd_core.h         |  6 +--
 .../user-space-merge/snapuserd_readahead.cpp  |  2 +-
 .../user-space-merge/snapuserd_server.cpp     |  5 +-
 .../user-space-merge/snapuserd_server.h       |  3 +-
 .../user-space-merge/snapuserd_test.cpp       | 46 ++++++++++++++-----
 12 files changed, 97 insertions(+), 34 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.cpp
index c5718d5b76a8..c85331b348c7 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.cpp
@@ -41,7 +41,7 @@ Extractor::Extractor(const std::string& base_path, const std::string& cow_path)
 bool Extractor::Init() {
     auto opener = factory_.CreateTestOpener(control_name_);
     handler_ = std::make_shared<SnapshotHandler>(control_name_, cow_path_, base_path_, base_path_,
-                                                 opener, 1, false, false);
+                                                 opener, 1, false, false, false);
     if (!handler_->InitCowDevice()) {
         return false;
     }
@@ -50,7 +50,7 @@ bool Extractor::Init() {
     }
 
     read_worker_ = std::make_unique<ReadWorker>(cow_path_, base_path_, control_name_, base_path_,
-                                                handler_->GetSharedPtr(), opener);
+                                                handler_->GetSharedPtr(), opener, false);
     if (!read_worker_->Init()) {
         return false;
     }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index ffd7a4b8b6ee..711e70473ac3 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -51,10 +51,11 @@ SnapshotHandlerManager::SnapshotHandlerManager() {
 std::shared_ptr<HandlerThread> SnapshotHandlerManager::AddHandler(
         const std::string& misc_name, const std::string& cow_device_path,
         const std::string& backing_device, const std::string& base_path_merge,
-        std::shared_ptr<IBlockServerOpener> opener, int num_worker_threads, bool use_iouring) {
-    auto snapuserd = std::make_shared<SnapshotHandler>(misc_name, cow_device_path, backing_device,
-                                                       base_path_merge, opener, num_worker_threads,
-                                                       use_iouring, perform_verification_);
+        std::shared_ptr<IBlockServerOpener> opener, int num_worker_threads, bool use_iouring,
+        bool o_direct) {
+    auto snapuserd = std::make_shared<SnapshotHandler>(
+            misc_name, cow_device_path, backing_device, base_path_merge, opener, num_worker_threads,
+            use_iouring, perform_verification_, o_direct);
     if (!snapuserd->InitCowDevice()) {
         LOG(ERROR) << "Failed to initialize Snapuserd";
         return nullptr;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
index ff6ee8f1053f..f23f07eb5e4a 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
@@ -57,7 +57,8 @@ class ISnapshotHandlerManager {
                                                       const std::string& backing_device,
                                                       const std::string& base_path_merge,
                                                       std::shared_ptr<IBlockServerOpener> opener,
-                                                      int num_worker_threads, bool use_iouring) = 0;
+                                                      int num_worker_threads, bool use_iouring,
+                                                      bool o_direct) = 0;
 
     // Start serving requests on a snapshot handler.
     virtual bool StartHandler(const std::string& misc_name) = 0;
@@ -96,7 +97,8 @@ class SnapshotHandlerManager final : public ISnapshotHandlerManager {
                                               const std::string& backing_device,
                                               const std::string& base_path_merge,
                                               std::shared_ptr<IBlockServerOpener> opener,
-                                              int num_worker_threads, bool use_iouring) override;
+                                              int num_worker_threads, bool use_iouring,
+                                              bool o_direct) override;
     bool StartHandler(const std::string& misc_name) override;
     bool DeleteHandler(const std::string& misc_name) override;
     bool InitiateMerge(const std::string& misc_name) override;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index 3a566693178f..bcf9aabe92ad 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -557,7 +557,7 @@ bool MergeWorker::Run() {
         return true;
     }
 
-    if (!SetThreadPriority(kNiceValueForMergeThreads)) {
+    if (!SetThreadPriority(ANDROID_PRIORITY_BACKGROUND)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index 431baf06069b..f1d406534671 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -31,16 +31,19 @@ using android::base::unique_fd;
 void ReadWorker::CloseFds() {
     block_server_ = {};
     backing_store_fd_ = {};
+    backing_store_direct_fd_ = {};
     Worker::CloseFds();
 }
 
 ReadWorker::ReadWorker(const std::string& cow_device, const std::string& backing_device,
                        const std::string& misc_name, const std::string& base_path_merge,
                        std::shared_ptr<SnapshotHandler> snapuserd,
-                       std::shared_ptr<IBlockServerOpener> opener)
+                       std::shared_ptr<IBlockServerOpener> opener, bool direct_read)
     : Worker(cow_device, misc_name, base_path_merge, snapuserd),
       backing_store_device_(backing_device),
-      block_server_opener_(opener) {}
+      direct_read_(direct_read),
+      block_server_opener_(opener),
+      aligned_buffer_(std::unique_ptr<void, decltype(&::free)>(nullptr, &::free)) {}
 
 // Start the replace operation. This will read the
 // internal COW format and if the block is compressed,
@@ -61,6 +64,17 @@ bool ReadWorker::ReadFromSourceDevice(const CowOperation* cow_op, void* buffer)
     }
     SNAP_LOG(DEBUG) << " ReadFromBaseDevice...: new-block: " << cow_op->new_block
                     << " Op: " << *cow_op;
+
+    if (direct_read_ && IsBlockAligned(offset)) {
+        if (!android::base::ReadFullyAtOffset(backing_store_direct_fd_, aligned_buffer_.get(),
+                                              BLOCK_SZ, offset)) {
+            SNAP_PLOG(ERROR) << "O_DIRECT Read failed at offset: " << offset;
+            return false;
+        }
+        std::memcpy(buffer, aligned_buffer_.get(), BLOCK_SZ);
+        return true;
+    }
+
     if (!android::base::ReadFullyAtOffset(backing_store_fd_, buffer, BLOCK_SZ, offset)) {
         std::string op;
         if (cow_op->type() == kCowCopyOp)
@@ -201,6 +215,24 @@ bool ReadWorker::Init() {
         return false;
     }
 
+    if (direct_read_) {
+        backing_store_direct_fd_.reset(open(backing_store_device_.c_str(), O_RDONLY | O_DIRECT));
+        if (backing_store_direct_fd_ < 0) {
+            SNAP_PLOG(ERROR) << "Open Failed with O_DIRECT: " << backing_store_direct_fd_;
+            direct_read_ = false;
+        } else {
+            void* aligned_addr;
+            ssize_t page_size = getpagesize();
+            if (posix_memalign(&aligned_addr, page_size, page_size) < 0) {
+                direct_read_ = false;
+                SNAP_PLOG(ERROR) << "posix_memalign failed "
+                                 << " page_size: " << page_size << " read_sz: " << page_size;
+            } else {
+                aligned_buffer_.reset(aligned_addr);
+            }
+        }
+    }
+
     block_server_ = block_server_opener_->Open(this, PAYLOAD_BUFFER_SZ);
     if (!block_server_) {
         SNAP_PLOG(ERROR) << "Unable to open block server";
@@ -214,7 +246,7 @@ bool ReadWorker::Run() {
 
     pthread_setname_np(pthread_self(), "ReadWorker");
 
-    if (!SetThreadPriority(kNiceValueForMergeThreads)) {
+    if (!SetThreadPriority(ANDROID_PRIORITY_NORMAL)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
index 6dbae812f812..1aff50c08268 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
@@ -28,7 +28,7 @@ class ReadWorker : public Worker, public IBlockServer::Delegate {
     ReadWorker(const std::string& cow_device, const std::string& backing_device,
                const std::string& misc_name, const std::string& base_path_merge,
                std::shared_ptr<SnapshotHandler> snapuserd,
-               std::shared_ptr<IBlockServerOpener> opener);
+               std::shared_ptr<IBlockServerOpener> opener, bool direct_read = false);
 
     bool Run();
     bool Init() override;
@@ -59,11 +59,14 @@ class ReadWorker : public Worker, public IBlockServer::Delegate {
 
     std::string backing_store_device_;
     unique_fd backing_store_fd_;
+    unique_fd backing_store_direct_fd_;
+    bool direct_read_ = false;
 
     std::shared_ptr<IBlockServerOpener> block_server_opener_;
     std::unique_ptr<IBlockServer> block_server_;
 
     std::basic_string<uint8_t> xor_buffer_;
+    std::unique_ptr<void, decltype(&::free)> aligned_buffer_;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 9b8c70d32d1d..05ba047b5463 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -36,7 +36,7 @@ using android::base::unique_fd;
 SnapshotHandler::SnapshotHandler(std::string misc_name, std::string cow_device,
                                  std::string backing_device, std::string base_path_merge,
                                  std::shared_ptr<IBlockServerOpener> opener, int num_worker_threads,
-                                 bool use_iouring, bool perform_verification) {
+                                 bool use_iouring, bool perform_verification, bool o_direct) {
     misc_name_ = std::move(misc_name);
     cow_device_ = std::move(cow_device);
     backing_store_device_ = std::move(backing_device);
@@ -45,13 +45,14 @@ SnapshotHandler::SnapshotHandler(std::string misc_name, std::string cow_device,
     num_worker_threads_ = num_worker_threads;
     is_io_uring_enabled_ = use_iouring;
     perform_verification_ = perform_verification;
+    o_direct_ = o_direct;
 }
 
 bool SnapshotHandler::InitializeWorkers() {
     for (int i = 0; i < num_worker_threads_; i++) {
         auto wt = std::make_unique<ReadWorker>(cow_device_, backing_store_device_, misc_name_,
                                                base_path_merge_, GetSharedPtr(),
-                                               block_server_opener_);
+                                               block_server_opener_, o_direct_);
         if (!wt->Init()) {
             SNAP_LOG(ERROR) << "Thread initialization failed";
             return false;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index fa1e7a0ab8e2..9b7238a5d15c 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -47,6 +47,7 @@
 #include <snapuserd/snapuserd_buffer.h>
 #include <snapuserd/snapuserd_kernel.h>
 #include <storage_literals/storage_literals.h>
+#include <system/thread_defs.h>
 #include "snapuserd_readahead.h"
 #include "snapuserd_verify.h"
 
@@ -62,8 +63,6 @@ static_assert(PAYLOAD_BUFFER_SZ >= BLOCK_SZ);
 
 static constexpr int kNumWorkerThreads = 4;
 
-static constexpr int kNiceValueForMergeThreads = -5;
-
 #define SNAP_LOG(level) LOG(level) << misc_name_ << ": "
 #define SNAP_PLOG(level) PLOG(level) << misc_name_ << ": "
 
@@ -105,7 +104,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
   public:
     SnapshotHandler(std::string misc_name, std::string cow_device, std::string backing_device,
                     std::string base_path_merge, std::shared_ptr<IBlockServerOpener> opener,
-                    int num_workers, bool use_iouring, bool perform_verification);
+                    int num_workers, bool use_iouring, bool perform_verification, bool o_direct);
     bool InitCowDevice();
     bool Start();
 
@@ -247,6 +246,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     bool perform_verification_ = true;
     bool resume_merge_ = false;
     bool merge_complete_ = false;
+    bool o_direct_ = false;
 
     std::unique_ptr<UpdateVerify> update_verify_;
     std::shared_ptr<IBlockServerOpener> block_server_opener_;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index 034cda163ba3..c08c1b19699e 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -778,7 +778,7 @@ bool ReadAhead::RunThread() {
 
     InitializeIouring();
 
-    if (!SetThreadPriority(kNiceValueForMergeThreads)) {
+    if (!SetThreadPriority(ANDROID_PRIORITY_BACKGROUND)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index 6eee3571bb5a..0b881b683e65 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -346,7 +346,8 @@ void UserSnapshotServer::Interrupt() {
 std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string& misc_name,
                                                               const std::string& cow_device_path,
                                                               const std::string& backing_device,
-                                                              const std::string& base_path_merge) {
+                                                              const std::string& base_path_merge,
+                                                              const bool o_direct) {
     // We will need multiple worker threads only during
     // device boot after OTA. For all other purposes,
     // one thread is sufficient. We don't want to consume
@@ -368,7 +369,7 @@ std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string&
     auto opener = block_server_factory_->CreateOpener(misc_name);
 
     return handlers_->AddHandler(misc_name, cow_device_path, backing_device, base_path_merge,
-                                 opener, num_worker_threads, io_uring_enabled_);
+                                 opener, num_worker_threads, io_uring_enabled_, o_direct);
 }
 
 bool UserSnapshotServer::WaitForSocket() {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index 99260713bd95..3013c47fcced 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -86,7 +86,8 @@ class UserSnapshotServer {
     std::shared_ptr<HandlerThread> AddHandler(const std::string& misc_name,
                                               const std::string& cow_device_path,
                                               const std::string& backing_device,
-                                              const std::string& base_path_merge);
+                                              const std::string& base_path_merge,
+                                              bool o_direct = false);
     bool StartHandler(const std::string& misc_name);
 
     void SetTerminating() { terminating_ = true; }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 73c3cbfbb2e2..8ddb0f4235f2 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -59,10 +59,16 @@ using namespace std;
 using testing::AssertionFailure;
 using testing::AssertionResult;
 using testing::AssertionSuccess;
+using ::testing::TestWithParam;
 
-class SnapuserdTestBase : public ::testing::TestWithParam<bool> {
+struct TestParam {
+    bool io_uring;
+    bool o_direct;
+};
+
+class SnapuserdTestBase : public ::testing::TestWithParam<TestParam> {
   protected:
-    void SetUp() override;
+    virtual void SetUp() override;
     void TearDown() override;
     void CreateBaseDevice();
     void CreateCowDevice();
@@ -628,9 +634,10 @@ void SnapuserdTest::InitCowDevice() {
     auto factory = harness_->GetBlockServerFactory();
     auto opener = factory->CreateOpener(system_device_ctrl_name_);
     handlers_->DisableVerification();
-    auto handler =
-            handlers_->AddHandler(system_device_ctrl_name_, cow_system_->path, base_dev_->GetPath(),
-                                  base_dev_->GetPath(), opener, 1, GetParam());
+    const TestParam params = GetParam();
+    auto handler = handlers_->AddHandler(system_device_ctrl_name_, cow_system_->path,
+                                         base_dev_->GetPath(), base_dev_->GetPath(), opener, 1,
+                                         params.io_uring, params.o_direct);
     ASSERT_NE(handler, nullptr);
     ASSERT_NE(handler->snapuserd(), nullptr);
 #ifdef __ANDROID__
@@ -898,9 +905,10 @@ void HandlerTest::SetUp() {
     opener_ = factory_.CreateTestOpener(system_device_ctrl_name_);
     ASSERT_NE(opener_, nullptr);
 
+    const TestParam params = GetParam();
     handler_ = std::make_shared<SnapshotHandler>(system_device_ctrl_name_, cow_system_->path,
                                                  base_dev_->GetPath(), base_dev_->GetPath(),
-                                                 opener_, 1, false, false);
+                                                 opener_, 1, false, false, params.o_direct);
     ASSERT_TRUE(handler_->InitCowDevice());
     ASSERT_TRUE(handler_->InitializeWorkers());
 
@@ -990,14 +998,28 @@ std::vector<bool> GetIoUringConfigs() {
     return {false, true};
 }
 
-std::string IoUringConfigName(const testing::TestParamInfo<SnapuserdTest::ParamType>& info) {
-    return info.param ? "io_uring" : "sync";
+std::vector<TestParam> GetTestConfigs() {
+    std::vector<TestParam> testParams;
+    std::vector<bool> uring_configs = GetIoUringConfigs();
+
+    for (bool config : uring_configs) {
+        TestParam param;
+        param.io_uring = config;
+        param.o_direct = false;
+        testParams.push_back(std::move(param));
+    }
+
+    for (bool config : uring_configs) {
+        TestParam param;
+        param.io_uring = config;
+        param.o_direct = true;
+        testParams.push_back(std::move(param));
+    }
+    return testParams;
 }
 
-INSTANTIATE_TEST_SUITE_P(Io, SnapuserdTest, ::testing::ValuesIn(GetIoUringConfigs()),
-                         IoUringConfigName);
-INSTANTIATE_TEST_SUITE_P(Io, HandlerTest, ::testing::ValuesIn(GetIoUringConfigs()),
-                         IoUringConfigName);
+INSTANTIATE_TEST_SUITE_P(Io, SnapuserdTest, ::testing::ValuesIn(GetTestConfigs()));
+INSTANTIATE_TEST_SUITE_P(Io, HandlerTest, ::testing::ValuesIn(GetTestConfigs()));
 
 }  // namespace snapshot
 }  // namespace android

From e8fcfee409a3d23027fefef540155e41f84c98a6 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Mon, 4 Dec 2023 16:39:15 -0800
Subject: [PATCH 0595/1487] Use scudo_stack_depot_size from process_info

This is a no-op but will be used in upcoming scudo changes that allow to
change the depot size at process startup time, and as such we will no
longer be able to call __scudo_get_stack_depot_size in debuggerd.

We already did the equivalent change for the ring buffer size in
https://r.android.com/q/topic:%22scudo_ring_buffer_size%22

Bug: 309446692
Change-Id: I761a7602c54a1f8f2d0575c5e011820d8dbaab63
---
 debuggerd/crash_dump.cpp                            | 1 +
 debuggerd/handler/debuggerd_handler.cpp             | 1 +
 debuggerd/include/debuggerd/handler.h               | 1 +
 debuggerd/libdebuggerd/include/libdebuggerd/types.h | 1 +
 debuggerd/libdebuggerd/scudo.cpp                    | 2 +-
 debuggerd/protocol.h                                | 1 +
 6 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 3563436ac41d..0899111b2a2a 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -317,6 +317,7 @@ static void ReadCrashInfo(unique_fd& fd, siginfo_t* siginfo,
       process_info->gwp_asan_state = crash_info->data.d.gwp_asan_state;
       process_info->gwp_asan_metadata = crash_info->data.d.gwp_asan_metadata;
       process_info->scudo_stack_depot = crash_info->data.d.scudo_stack_depot;
+      process_info->scudo_stack_depot_size = crash_info->data.d.scudo_stack_depot_size;
       process_info->scudo_region_info = crash_info->data.d.scudo_region_info;
       process_info->scudo_ring_buffer = crash_info->data.d.scudo_ring_buffer;
       process_info->scudo_ring_buffer_size = crash_info->data.d.scudo_ring_buffer_size;
diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index 01365f22fc10..ea07ce235086 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -395,6 +395,7 @@ static int debuggerd_dispatch_pseudothread(void* arg) {
     ASSERT_SAME_OFFSET(scudo_region_info, scudo_region_info);
     ASSERT_SAME_OFFSET(scudo_ring_buffer, scudo_ring_buffer);
     ASSERT_SAME_OFFSET(scudo_ring_buffer_size, scudo_ring_buffer_size);
+    ASSERT_SAME_OFFSET(scudo_stack_depot_size, scudo_stack_depot_size);
     ASSERT_SAME_OFFSET(recoverable_gwp_asan_crash, recoverable_gwp_asan_crash);
 #undef ASSERT_SAME_OFFSET
 
diff --git a/debuggerd/include/debuggerd/handler.h b/debuggerd/include/debuggerd/handler.h
index ebb537236d83..de12fc622be6 100644
--- a/debuggerd/include/debuggerd/handler.h
+++ b/debuggerd/include/debuggerd/handler.h
@@ -44,6 +44,7 @@ struct __attribute__((packed)) debugger_process_info {
   const char* scudo_region_info;
   const char* scudo_ring_buffer;
   size_t scudo_ring_buffer_size;
+  size_t scudo_stack_depot_size;
   bool recoverable_gwp_asan_crash;
 };
 
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/types.h b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
index 5a2a7abad43f..075b12cb0889 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/types.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
@@ -51,6 +51,7 @@ struct ProcessInfo {
   uintptr_t scudo_region_info = 0;
   uintptr_t scudo_ring_buffer = 0;
   size_t scudo_ring_buffer_size = 0;
+  size_t scudo_stack_depot_size = 0;
 
   bool has_fault_address = false;
   uintptr_t untagged_fault_address = 0;
diff --git a/debuggerd/libdebuggerd/scudo.cpp b/debuggerd/libdebuggerd/scudo.cpp
index 837f40612384..c15bbeaca7a0 100644
--- a/debuggerd/libdebuggerd/scudo.cpp
+++ b/debuggerd/libdebuggerd/scudo.cpp
@@ -42,7 +42,7 @@ ScudoCrashData::ScudoCrashData(unwindstack::Memory* process_memory,
   }
 
   auto stack_depot = AllocAndReadFully(process_memory, process_info.scudo_stack_depot,
-                                       __scudo_get_stack_depot_size());
+                                       process_info.scudo_stack_depot_size);
   auto region_info = AllocAndReadFully(process_memory, process_info.scudo_region_info,
                                        __scudo_get_region_info_size());
   std::unique_ptr<char[]> ring_buffer;
diff --git a/debuggerd/protocol.h b/debuggerd/protocol.h
index 212d6dc2827d..793428ae8273 100644
--- a/debuggerd/protocol.h
+++ b/debuggerd/protocol.h
@@ -99,6 +99,7 @@ struct __attribute__((__packed__)) CrashInfoDataDynamic : public CrashInfoDataSt
   uintptr_t scudo_region_info;
   uintptr_t scudo_ring_buffer;
   size_t scudo_ring_buffer_size;
+  size_t scudo_stack_depot_size;
   bool recoverable_gwp_asan_crash;
 };
 

From 4841207b5301dd8110ec844a8e1e7ea64cd2ffef Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Mon, 4 Dec 2023 17:28:41 -0800
Subject: [PATCH 0596/1487] Handle scudo_stack_depot_size = 0

Bug: 309446692
Change-Id: Ic55294316137847041f1e829cb0243aae8926379
---
 debuggerd/libdebuggerd/scudo.cpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/debuggerd/libdebuggerd/scudo.cpp b/debuggerd/libdebuggerd/scudo.cpp
index c15bbeaca7a0..17a1f79e3fb7 100644
--- a/debuggerd/libdebuggerd/scudo.cpp
+++ b/debuggerd/libdebuggerd/scudo.cpp
@@ -41,8 +41,6 @@ ScudoCrashData::ScudoCrashData(unwindstack::Memory* process_memory,
     return;
   }
 
-  auto stack_depot = AllocAndReadFully(process_memory, process_info.scudo_stack_depot,
-                                       process_info.scudo_stack_depot_size);
   auto region_info = AllocAndReadFully(process_memory, process_info.scudo_region_info,
                                        __scudo_get_region_info_size());
   std::unique_ptr<char[]> ring_buffer;
@@ -50,7 +48,12 @@ ScudoCrashData::ScudoCrashData(unwindstack::Memory* process_memory,
     ring_buffer = AllocAndReadFully(process_memory, process_info.scudo_ring_buffer,
                                     process_info.scudo_ring_buffer_size);
   }
-  if (!stack_depot || !region_info) {
+  std::unique_ptr<char[]> stack_depot;
+  if (process_info.scudo_stack_depot_size != 0) {
+    stack_depot = AllocAndReadFully(process_memory, process_info.scudo_stack_depot,
+                                    process_info.scudo_stack_depot_size);
+  }
+  if (!region_info) {
     return;
   }
 

From b8bbc434895698e0846619ccf74b7cc6d66d22bb Mon Sep 17 00:00:00 2001
From: Yi Kong <yikong@google.com>
Date: Tue, 5 Dec 2023 18:35:33 +0900
Subject: [PATCH 0597/1487] Fix -Wunused-variable compiler warning

Test: presubmit
Change-Id: I63b1625decd3dcdb9f405c8825203e04810c282c
---
 fastboot/task.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index 25c5a6e6bb30..0947ff90f850 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -224,7 +224,7 @@ std::unique_ptr<OptimizedFlashSuperTask> OptimizedFlashSuperTask::Initialize(
     auto remove_if_callback = [&](const auto& task) -> bool {
         if (auto flash_task = task->AsFlashTask()) {
             return helper->WillFlash(flash_task->GetPartitionAndSlot());
-        } else if (auto update_super_task = task->AsUpdateSuperTask()) {
+        } else if (task->AsUpdateSuperTask()) {
             return true;
         } else if (auto reboot_task = task->AsRebootTask()) {
             if (reboot_task->GetTarget() == "fastboot") {

From c08a34e3dcb00912f54bf0b23e024471b9366955 Mon Sep 17 00:00:00 2001
From: Siim Sammul <siims@google.com>
Date: Fri, 17 Nov 2023 17:06:15 +0000
Subject: [PATCH 0598/1487] Move tombstone_proto_to_text out of libdebuggerd.

This is done so that we could depend on it elsewhere without needing all the unrelated methods.
Needed for ag/24553347

Bug: 296207744
Test: refactoring build
Change-Id: I7c6733208f3ae63ba9559753a24cffcb8e1b9d1e
---
 debuggerd/Android.bp                          |  39 +++++-
 .../include/libdebuggerd/utility.h            |   2 -
 .../test/tombstone_proto_to_text_test.cpp     | 120 ++++++++++++++++++
 debuggerd/libdebuggerd/test/utility_test.cpp  |  42 ------
 .../libdebuggerd/tombstone_proto_to_text.cpp  |  37 ++++++
 debuggerd/libdebuggerd/utility.cpp            |  36 ------
 debuggerd/proto/Android.bp                    |  14 ++
 debuggerd/proto/jarjar-rules.txt              |   1 +
 8 files changed, 209 insertions(+), 82 deletions(-)
 create mode 100644 debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
 delete mode 100644 debuggerd/libdebuggerd/test/utility_test.cpp
 create mode 100644 debuggerd/proto/jarjar-rules.txt

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 267571b50175..31e284d4cacb 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -186,6 +186,41 @@ cc_library {
     export_include_dirs: ["include"],
 }
 
+cc_library {
+    name: "libdebuggerd_tombstone_proto_to_text",
+    defaults: ["debuggerd_defaults"],
+    ramdisk_available: true,
+    recovery_available: true,
+    vendor_ramdisk_available: true,
+
+    local_include_dirs: ["libdebuggerd/include"],
+    export_include_dirs: ["libdebuggerd/include"],
+
+    srcs: [
+        "libdebuggerd/tombstone_proto_to_text.cpp",
+    ],
+
+    header_libs: [
+        "bionic_libc_platform_headers",
+    ],
+
+    static_libs: [
+        "libbase",
+        "liblog_for_runtime_apex",
+        "libunwindstack",
+    ],
+
+    whole_static_libs: [
+        "libtombstone_proto",
+        "libprotobuf-cpp-lite",
+    ],
+
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.runtime",
+    ],
+}
+
 cc_library_static {
     name: "libdebuggerd",
     defaults: ["debuggerd_defaults"],
@@ -199,7 +234,6 @@ cc_library_static {
         "libdebuggerd/open_files_list.cpp",
         "libdebuggerd/tombstone.cpp",
         "libdebuggerd/tombstone_proto.cpp",
-        "libdebuggerd/tombstone_proto_to_text.cpp",
         "libdebuggerd/utility.cpp",
     ],
 
@@ -225,6 +259,7 @@ cc_library_static {
     ],
 
     whole_static_libs: [
+        "libdebuggerd_tombstone_proto_to_text",
         "libasync_safe",
         "gwp_asan_crash_handler",
         "libtombstone_proto",
@@ -309,7 +344,7 @@ cc_test {
         "libdebuggerd/test/elf_fake.cpp",
         "libdebuggerd/test/log_fake.cpp",
         "libdebuggerd/test/open_files_list_test.cpp",
-        "libdebuggerd/test/utility_test.cpp",
+        "libdebuggerd/test/tombstone_proto_to_text_test.cpp",
     ],
 
     target: {
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/utility.h b/debuggerd/libdebuggerd/include/libdebuggerd/utility.h
index 198de37a6263..26c2cd44a85f 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/utility.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/utility.h
@@ -91,8 +91,6 @@ bool signal_has_si_addr(const siginfo_t*);
 void get_signal_sender(char* buf, size_t n, const siginfo_t*);
 const char* get_signame(const siginfo_t*);
 const char* get_sigcode(const siginfo_t*);
-std::string describe_tagged_addr_ctrl(long ctrl);
-std::string describe_pac_enabled_keys(long keys);
 
 // Number of bytes per MTE granule.
 constexpr size_t kTagGranuleSize = 16;
diff --git a/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
new file mode 100644
index 000000000000..ac92ac064343
--- /dev/null
+++ b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <sys/prctl.h>
+
+#include <string>
+
+#include <android-base/test_utils.h>
+
+#include "libdebuggerd/tombstone.h"
+#include "tombstone.pb.h"
+
+using CallbackType = std::function<void(const std::string& line, bool should_log)>;
+
+class TombstoneProtoToTextTest : public ::testing::Test {
+ public:
+  void SetUp() {
+    tombstone_.reset(new Tombstone);
+
+    tombstone_->set_arch(Architecture::ARM64);
+    tombstone_->set_build_fingerprint("Test fingerprint");
+    tombstone_->set_timestamp("1970-01-01 00:00:00");
+    tombstone_->set_pid(100);
+    tombstone_->set_tid(100);
+    tombstone_->set_uid(0);
+    tombstone_->set_selinux_label("none");
+
+    Signal signal;
+    signal.set_number(SIGSEGV);
+    signal.set_name("SIGSEGV");
+    signal.set_code(0);
+    signal.set_code_name("none");
+
+    *tombstone_->mutable_signal_info() = signal;
+
+    Thread thread;
+    thread.set_id(100);
+    thread.set_name("main");
+    thread.set_tagged_addr_ctrl(0);
+    thread.set_pac_enabled_keys(0);
+
+    auto& threads = *tombstone_->mutable_threads();
+    threads[100] = thread;
+    main_thread_ = &threads[100];
+  }
+
+  void ProtoToString() {
+    text_ = "";
+    EXPECT_TRUE(
+        tombstone_proto_to_text(*tombstone_, [this](const std::string& line, bool should_log) {
+          if (should_log) {
+            text_ += "LOG ";
+          }
+          text_ += line + '\n';
+        }));
+  }
+
+  Thread* main_thread_;
+  std::string text_;
+  std::unique_ptr<Tombstone> tombstone_;
+};
+
+TEST_F(TombstoneProtoToTextTest, tagged_addr_ctrl) {
+  main_thread_->set_tagged_addr_ctrl(0);
+  ProtoToString();
+  EXPECT_MATCH(text_, "LOG tagged_addr_ctrl: 0000000000000000\\n");
+
+  main_thread_->set_tagged_addr_ctrl(PR_TAGGED_ADDR_ENABLE);
+  ProtoToString();
+  EXPECT_MATCH(text_, "LOG tagged_addr_ctrl: 0000000000000001 \\(PR_TAGGED_ADDR_ENABLE\\)\\n");
+
+  main_thread_->set_tagged_addr_ctrl(PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC |
+                                     (0xfffe << PR_MTE_TAG_SHIFT));
+  ProtoToString();
+  EXPECT_MATCH(text_,
+               "LOG tagged_addr_ctrl: 000000000007fff3 \\(PR_TAGGED_ADDR_ENABLE, PR_MTE_TCF_SYNC, "
+               "mask 0xfffe\\)\\n");
+
+  main_thread_->set_tagged_addr_ctrl(0xf0000000 | PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC |
+                                     PR_MTE_TCF_ASYNC | (0xfffe << PR_MTE_TAG_SHIFT));
+  ProtoToString();
+  EXPECT_MATCH(text_,
+               "LOG tagged_addr_ctrl: 00000000f007fff7 \\(PR_TAGGED_ADDR_ENABLE, PR_MTE_TCF_SYNC, "
+               "PR_MTE_TCF_ASYNC, mask 0xfffe, unknown 0xf0000000\\)\\n");
+}
+
+TEST_F(TombstoneProtoToTextTest, pac_enabled_keys) {
+  main_thread_->set_pac_enabled_keys(0);
+  ProtoToString();
+  EXPECT_MATCH(text_, "LOG pac_enabled_keys: 0000000000000000\\n");
+
+  main_thread_->set_pac_enabled_keys(PR_PAC_APIAKEY);
+  ProtoToString();
+  EXPECT_MATCH(text_, "LOG pac_enabled_keys: 0000000000000001 \\(PR_PAC_APIAKEY\\)\\n");
+
+  main_thread_->set_pac_enabled_keys(PR_PAC_APIAKEY | PR_PAC_APDBKEY);
+  ProtoToString();
+  EXPECT_MATCH(text_,
+               "LOG pac_enabled_keys: 0000000000000009 \\(PR_PAC_APIAKEY, PR_PAC_APDBKEY\\)\\n");
+
+  main_thread_->set_pac_enabled_keys(PR_PAC_APIAKEY | PR_PAC_APDBKEY | 0x1000);
+  ProtoToString();
+  EXPECT_MATCH(text_,
+               "LOG pac_enabled_keys: 0000000000001009 \\(PR_PAC_APIAKEY, PR_PAC_APDBKEY, unknown "
+               "0x1000\\)\\n");
+}
diff --git a/debuggerd/libdebuggerd/test/utility_test.cpp b/debuggerd/libdebuggerd/test/utility_test.cpp
deleted file mode 100644
index dad338054859..000000000000
--- a/debuggerd/libdebuggerd/test/utility_test.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gtest/gtest.h>
-#include <sys/prctl.h>
-
-#include "libdebuggerd/utility.h"
-
-TEST(UtilityTest, describe_tagged_addr_ctrl) {
-  EXPECT_EQ("", describe_tagged_addr_ctrl(0));
-  EXPECT_EQ(" (PR_TAGGED_ADDR_ENABLE)", describe_tagged_addr_ctrl(PR_TAGGED_ADDR_ENABLE));
-  EXPECT_EQ(" (PR_TAGGED_ADDR_ENABLE, PR_MTE_TCF_SYNC, mask 0xfffe)",
-            describe_tagged_addr_ctrl(PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC |
-                                      (0xfffe << PR_MTE_TAG_SHIFT)));
-  EXPECT_EQ(
-      " (PR_TAGGED_ADDR_ENABLE, PR_MTE_TCF_SYNC, PR_MTE_TCF_ASYNC, mask 0xfffe, unknown "
-      "0xf0000000)",
-      describe_tagged_addr_ctrl(0xf0000000 | PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC |
-                                PR_MTE_TCF_ASYNC | (0xfffe << PR_MTE_TAG_SHIFT)));
-}
-
-TEST(UtilityTest, describe_pac_enabled_keys) {
-  EXPECT_EQ("", describe_pac_enabled_keys(0));
-  EXPECT_EQ(" (PR_PAC_APIAKEY)", describe_pac_enabled_keys(PR_PAC_APIAKEY));
-  EXPECT_EQ(" (PR_PAC_APIAKEY, PR_PAC_APDBKEY)",
-            describe_pac_enabled_keys(PR_PAC_APIAKEY | PR_PAC_APDBKEY));
-  EXPECT_EQ(" (PR_PAC_APIAKEY, PR_PAC_APDBKEY, unknown 0x1000)",
-            describe_pac_enabled_keys(PR_PAC_APIAKEY | PR_PAC_APDBKEY | 0x1000));
-}
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index e44dc109575d..ad9132087dd8 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -29,6 +29,7 @@
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 #include <bionic/macros.h>
+#include <sys/prctl.h>
 
 #include "tombstone.pb.h"
 
@@ -40,6 +41,42 @@ using android::base::StringPrintf;
 #define CBS(...) CB(false, __VA_ARGS__)
 using CallbackType = std::function<void(const std::string& line, bool should_log)>;
 
+#define DESCRIBE_FLAG(flag) \
+  if (value & flag) {       \
+    desc += ", ";           \
+    desc += #flag;          \
+    value &= ~flag;         \
+  }
+
+static std::string describe_end(long value, std::string& desc) {
+  if (value) {
+    desc += StringPrintf(", unknown 0x%lx", value);
+  }
+  return desc.empty() ? "" : " (" + desc.substr(2) + ")";
+}
+
+static std::string describe_tagged_addr_ctrl(long value) {
+  std::string desc;
+  DESCRIBE_FLAG(PR_TAGGED_ADDR_ENABLE);
+  DESCRIBE_FLAG(PR_MTE_TCF_SYNC);
+  DESCRIBE_FLAG(PR_MTE_TCF_ASYNC);
+  if (value & PR_MTE_TAG_MASK) {
+    desc += StringPrintf(", mask 0x%04lx", (value & PR_MTE_TAG_MASK) >> PR_MTE_TAG_SHIFT);
+    value &= ~PR_MTE_TAG_MASK;
+  }
+  return describe_end(value, desc);
+}
+
+static std::string describe_pac_enabled_keys(long value) {
+  std::string desc;
+  DESCRIBE_FLAG(PR_PAC_APIAKEY);
+  DESCRIBE_FLAG(PR_PAC_APIBKEY);
+  DESCRIBE_FLAG(PR_PAC_APDAKEY);
+  DESCRIBE_FLAG(PR_PAC_APDBKEY);
+  DESCRIBE_FLAG(PR_PAC_APGAKEY);
+  return describe_end(value, desc);
+}
+
 static const char* abi_string(const Tombstone& tombstone) {
   switch (tombstone.arch()) {
     case Architecture::ARM32:
diff --git a/debuggerd/libdebuggerd/utility.cpp b/debuggerd/libdebuggerd/utility.cpp
index 15f09b3419b0..742ac7c2701a 100644
--- a/debuggerd/libdebuggerd/utility.cpp
+++ b/debuggerd/libdebuggerd/utility.cpp
@@ -445,42 +445,6 @@ const char* get_sigcode(const siginfo_t* si) {
   return "?";
 }
 
-#define DESCRIBE_FLAG(flag) \
-  if (value & flag) {       \
-    desc += ", ";           \
-    desc += #flag;          \
-    value &= ~flag;         \
-  }
-
-static std::string describe_end(long value, std::string& desc) {
-  if (value) {
-    desc += StringPrintf(", unknown 0x%lx", value);
-  }
-  return desc.empty() ? "" : " (" + desc.substr(2) + ")";
-}
-
-std::string describe_tagged_addr_ctrl(long value) {
-  std::string desc;
-  DESCRIBE_FLAG(PR_TAGGED_ADDR_ENABLE);
-  DESCRIBE_FLAG(PR_MTE_TCF_SYNC);
-  DESCRIBE_FLAG(PR_MTE_TCF_ASYNC);
-  if (value & PR_MTE_TAG_MASK) {
-    desc += StringPrintf(", mask 0x%04lx", (value & PR_MTE_TAG_MASK) >> PR_MTE_TAG_SHIFT);
-    value &= ~PR_MTE_TAG_MASK;
-  }
-  return describe_end(value, desc);
-}
-
-std::string describe_pac_enabled_keys(long value) {
-  std::string desc;
-  DESCRIBE_FLAG(PR_PAC_APIAKEY);
-  DESCRIBE_FLAG(PR_PAC_APIBKEY);
-  DESCRIBE_FLAG(PR_PAC_APDAKEY);
-  DESCRIBE_FLAG(PR_PAC_APDBKEY);
-  DESCRIBE_FLAG(PR_PAC_APGAKEY);
-  return describe_end(value, desc);
-}
-
 void log_backtrace(log_t* log, unwindstack::AndroidUnwinder* unwinder,
                    unwindstack::AndroidUnwinderData& data, const char* prefix) {
   std::set<std::string> unreadable_elf_files;
diff --git a/debuggerd/proto/Android.bp b/debuggerd/proto/Android.bp
index 804f8055ba60..7be5d61a06ab 100644
--- a/debuggerd/proto/Android.bp
+++ b/debuggerd/proto/Android.bp
@@ -39,3 +39,17 @@ cc_library_static {
     recovery_available: true,
     vendor_ramdisk_available: true,
 }
+
+java_library_static {
+    name: "libtombstone_proto_java",
+    proto: {
+        type: "lite",
+    },
+    srcs: [
+        "tombstone.proto",
+    ],
+    jarjar_rules: "jarjar-rules.txt",
+    sdk_version: "current",
+    static_libs: ["libprotobuf-java-lite"],
+}
+
diff --git a/debuggerd/proto/jarjar-rules.txt b/debuggerd/proto/jarjar-rules.txt
new file mode 100644
index 000000000000..66878a9489c1
--- /dev/null
+++ b/debuggerd/proto/jarjar-rules.txt
@@ -0,0 +1 @@
+rule com.google.protobuf.** com.android.server.os.protobuf.@1

From 12e05312241f9ca0a2d032f962ee6c306a1b1010 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Tue, 5 Dec 2023 10:22:51 -0800
Subject: [PATCH 0599/1487] Fix multiple calls to set_[source/type]

Since currently implementation just does an bitwise or with the
storage unit, multiple calls to set_source would result in overlapping
bits. Fix by first clear the existing storage.

Test: th
Bug: 313962438
Change-Id: Iecfe8dd244c0f65ecd3cacb0404fdc39ef836d97
---
 .../include/libsnapshot/cow_format.h          |  6 +++
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 37 +++++++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 717ad2dcb875..6b3415241fa3 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -226,6 +226,9 @@ struct CowOperationV3 {
     uint64_t source_info_;
     constexpr uint64_t source() const { return source_info_ & kCowOpSourceInfoDataMask; }
     constexpr void set_source(uint64_t source) {
+        // Clear the first 48 bit first
+        source_info_ &= ~kCowOpSourceInfoDataMask;
+        // Set the actual source field
         source_info_ |= source & kCowOpSourceInfoDataMask;
     }
     constexpr CowOperationType type() const {
@@ -234,6 +237,9 @@ struct CowOperationV3 {
         return static_cast<CowOperationType>(type);
     }
     constexpr void set_type(CowOperationType type) {
+        // Clear the top 4 bits first
+        source_info_ &= ((1ULL << kCowOpSourceInfoTypeBit) - 1);
+        // set the actual type bits
         source_info_ |= (static_cast<uint64_t>(type) & kCowOpSourceInfoTypeMask)
                         << kCowOpSourceInfoTypeBit;
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index ea34c27fde09..aceed243c9f6 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -621,5 +621,42 @@ TEST_F(CowTestV3, ResumeSeqOp) {
     ASSERT_EQ(expected_block, 0);
     ASSERT_TRUE(iter->AtEnd());
 }
+
+TEST_F(CowTestV3, SetSourceManyTimes) {
+    CowOperationV3 op{};
+    op.set_source(1);
+    ASSERT_EQ(op.source(), 1);
+    op.set_source(2);
+    ASSERT_EQ(op.source(), 2);
+    op.set_source(4);
+    ASSERT_EQ(op.source(), 4);
+    op.set_source(8);
+    ASSERT_EQ(op.source(), 8);
+}
+
+TEST_F(CowTestV3, SetTypeManyTimes) {
+    CowOperationV3 op{};
+    op.set_type(kCowCopyOp);
+    ASSERT_EQ(op.type(), kCowCopyOp);
+    op.set_type(kCowReplaceOp);
+    ASSERT_EQ(op.type(), kCowReplaceOp);
+    op.set_type(kCowZeroOp);
+    ASSERT_EQ(op.type(), kCowZeroOp);
+    op.set_type(kCowXorOp);
+    ASSERT_EQ(op.type(), kCowXorOp);
+}
+
+TEST_F(CowTestV3, SetTypeSourceInverleave) {
+    CowOperationV3 op{};
+    op.set_type(kCowCopyOp);
+    ASSERT_EQ(op.type(), kCowCopyOp);
+    op.set_source(0x010203040506);
+    ASSERT_EQ(op.source(), 0x010203040506);
+    ASSERT_EQ(op.type(), kCowCopyOp);
+    op.set_type(kCowReplaceOp);
+    ASSERT_EQ(op.source(), 0x010203040506);
+    ASSERT_EQ(op.type(), kCowReplaceOp);
+}
+
 }  // namespace snapshot
 }  // namespace android

From 6757ecd2a3bd9071052d5caf89836001a6f20e56 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Tue, 5 Dec 2023 16:13:36 -0800
Subject: [PATCH 0600/1487] Match upstream API change

Change was done in
https://github.com/llvm/llvm-project/commit/e68c265543722af32821eab2c77565d37079da47

Change-Id: Id1a288dfdb5edb7cb7d639ec4548926cc4085d8c
---
 debuggerd/libdebuggerd/scudo.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/debuggerd/libdebuggerd/scudo.cpp b/debuggerd/libdebuggerd/scudo.cpp
index 837f40612384..ea8dff4d235b 100644
--- a/debuggerd/libdebuggerd/scudo.cpp
+++ b/debuggerd/libdebuggerd/scudo.cpp
@@ -78,7 +78,8 @@ ScudoCrashData::ScudoCrashData(unwindstack::Memory* process_memory,
   }
 
   __scudo_get_error_info(&error_info_, process_info.maybe_tagged_fault_address, stack_depot.get(),
-                         region_info.get(), ring_buffer.get(), memory.get(), memory_tags.get(),
+                         __scudo_get_stack_depot_size(), region_info.get(), ring_buffer.get(),
+                         process_info.scudo_ring_buffer_size, memory.get(), memory_tags.get(),
                          memory_begin, memory_end - memory_begin);
 }
 

From 995dd0385e455e5263e7eead5277eb16e882d89b Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <jaegeuk@google.com>
Date: Tue, 5 Dec 2023 14:22:31 -0800
Subject: [PATCH 0601/1487] Use target path when handling dm-bow

Refactor getting sysfs directory.

Bug: 312817490
Change-Id: Icc12002d3f5a2e24f86ce88e5e602cf7a71b0f84
Signed-off-by: Jaegeuk Kim <jaegeuk@google.com>
---
 fs_mgr/fs_mgr.cpp | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 35c8c639626c..a94a27447f2a 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -1244,17 +1244,27 @@ class CheckpointManager {
 };
 
 std::string fs_mgr_find_bow_device(const std::string& block_device) {
-    if (block_device.substr(0, 5) != "/dev/") {
-        LOG(ERROR) << "Expected block device, got " << block_device;
-        return std::string();
+    // handle symlink such as "/dev/block/mapper/userdata"
+    std::string real_path;
+    if (!android::base::Realpath(block_device, &real_path)) {
+        real_path = block_device;
     }
 
-    std::string sys_dir = std::string("/sys/") + block_device.substr(5);
-
+    struct stat st;
+    if (stat(real_path.c_str(), &st) < 0) {
+        PLOG(ERROR) << "stat failed: " << real_path;
+        return std::string();
+    }
+    if (!S_ISBLK(st.st_mode)) {
+        PLOG(ERROR) << real_path << " is not block device";
+        return std::string();
+    }
+    std::string sys_dir = android::base::StringPrintf("/sys/dev/block/%u:%u", major(st.st_rdev),
+                                                      minor(st.st_rdev));
     for (;;) {
         std::string name;
         if (!android::base::ReadFileToString(sys_dir + "/dm/name", &name)) {
-            PLOG(ERROR) << block_device << " is not dm device";
+            PLOG(ERROR) << real_path << " is not dm device";
             return std::string();
         }
 

From 90f6cb4b2ca7cae0b3546027b39a31b3478623be Mon Sep 17 00:00:00 2001
From: Yi Kong <yikong@google.com>
Date: Wed, 6 Dec 2023 14:07:36 +0900
Subject: [PATCH 0602/1487] Fix -Wunused-variable compiler warning

Test: presubmit
Change-Id: Ia6d0a735c94c7be39994fb9c8ae4d3b65d6f4301
---
 fastboot/task_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fastboot/task_test.cpp b/fastboot/task_test.cpp
index 9cde1a81e9a8..81154c68e111 100644
--- a/fastboot/task_test.cpp
+++ b/fastboot/task_test.cpp
@@ -354,7 +354,7 @@ TEST_F(ParseTest, OptimizedFlashSuperPatternMatchTest) {
                                 const std::vector<std::unique_ptr<Task>>& tasks) {
             bool contains_optimized_task = false;
             for (auto& task : tasks) {
-                if (auto optimized_task = task->AsOptimizedFlashSuperTask()) {
+                if (task->AsOptimizedFlashSuperTask()) {
                     contains_optimized_task = true;
                 }
                 if (auto flash_task = task->AsFlashTask()) {

From d45c50911f989caacc6c46f79ee2e4fd66615c65 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Tue, 5 Dec 2023 15:21:46 -0800
Subject: [PATCH 0603/1487] Fix cow v3 size estimation errors

Current cow size estimation is computed by taking the offset of next
data write. However, during COW size estimation we repeatdly increment
op_count_max. Since data section is placed right after op section,
incrementing  op_count_max has the effect of moving the beginning of
data section. next_data_pos_ is never updated in this process, causing
the final estiamte to be off.

Test: th
Bug: 313962438
Change-Id: I250dff54c470c9c20d6db33d91bac898358dee31
---
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 21 +++++++++++++++----
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp |  7 ++++++-
 2 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index aceed243c9f6..27accdc7bb15 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -15,17 +15,15 @@
 #include <sys/stat.h>
 
 #include <cstdio>
-#include <iostream>
 #include <memory>
-#include <string_view>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include <android-base/unique_fd.h>
 #include <gtest/gtest.h>
+#include <libsnapshot/cow_format.h>
 #include <libsnapshot/cow_reader.h>
 #include <libsnapshot/cow_writer.h>
-#include "cow_decompress.h"
-#include "libsnapshot/cow_format.h"
 #include "writer_v2.h"
 #include "writer_v3.h"
 
@@ -658,5 +656,20 @@ TEST_F(CowTestV3, SetTypeSourceInverleave) {
     ASSERT_EQ(op.type(), kCowReplaceOp);
 }
 
+TEST_F(CowTestV3, CowSizeEstimate) {
+    CowOptions options{};
+    options.compression = "none";
+    auto estimator = android::snapshot::CreateCowEstimator(3, options);
+    ASSERT_TRUE(estimator->AddZeroBlocks(0, 1024 * 1024));
+    const auto cow_size = estimator->GetCowSize();
+    options.op_count_max = 1024 * 1024;
+    options.max_blocks = 1024 * 1024;
+    CowWriterV3 writer(options, GetCowFd());
+    ASSERT_TRUE(writer.Initialize());
+    ASSERT_TRUE(writer.AddZeroBlocks(0, 1024 * 1024));
+
+    ASSERT_LE(writer.GetCowSize(), cow_size);
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 5bdc5fd2caaa..07f6f002f73c 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -327,7 +327,12 @@ bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
 bool CowWriterV3::WriteOperation(const CowOperationV3& op, const void* data, size_t size) {
     if (IsEstimating()) {
         header_.op_count++;
-        header_.op_count_max++;
+        if (header_.op_count > header_.op_count_max) {
+            // If we increment op_count_max, the offset of data section would
+            // change. So need to update |next_data_pos_|
+            next_data_pos_ += (header_.op_count - header_.op_count_max) * sizeof(CowOperationV3);
+            header_.op_count_max = header_.op_count;
+        }
         next_data_pos_ += op.data_length;
         return true;
     }

From 3b5bb3a364f34b91296f324d1917b36cbe8fd7cc Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 31 Oct 2023 16:14:20 +0000
Subject: [PATCH 0604/1487] libprocessgroup: Poll on cgroup.events

In killProcessGroup we currently read cgroup.procs to find processes to
kill, send them kill signals until cgroup.procs is empty, then remove
the cgroup directory. The cgroup cannot be removed until all processes
are dead, otherwise we'll get an EBUSY error from the kernel.

There is a race in the kernel where cgroup.procs can read empty even
though the cgroup is pinned by processes which are still exiting, and
can't be removed yet. [1]

Let's use the populated field of cgroup.events instead of an empty
cgroup.procs file to determine when the cgroup is removable. In
addition to functioning like we expect, this is more efficient because
we can poll on cgroup.events instead of retrying kills and rereading
cgroup.procs every 5ms which should help reduce CPU contention and
cgroup lock contention.

It's still possible that it takes longer for a cgroup to become
unpopulated than our timeout allows, in which case we will fail to
remove the cgroup and leak kernel memory. But this change should help
reduce the probability of that happening.

[1] https://lore.kernel.org/all/CABdmKX3SOXpcK85a7cx3iXrwUj=i1yXqEz9i9zNkx8mB=ZXQ8A@mail.gmail.com/

Bug: 301871933
Change-Id: If7dcfb331f47e06994c9ac85ed08bbcce18cdad7
---
 .../include/processgroup/processgroup.h       |  10 +-
 libprocessgroup/processgroup.cpp              | 293 +++++++++++-------
 2 files changed, 183 insertions(+), 120 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 9107838b8629..ca6868c1b640 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -65,9 +65,8 @@ bool UsePerAppMemcg();
 // should be active again. E.g. Zygote specialization for child process.
 void DropTaskProfilesResourceCaching();
 
-// Return 0 and removes the cgroup if there are no longer any processes in it.
-// Returns -1 in the case of an error occurring or if there are processes still running
-// even after retrying for up to 200ms.
+// Return 0 if all processes were killed and the cgroup was successfully removed.
+// Returns -1 in the case of an error occurring or if there are processes still running.
 int killProcessGroup(uid_t uid, int initialPid, int signal);
 
 // Returns the same as killProcessGroup(), however it does not retry, which means
@@ -76,8 +75,9 @@ int killProcessGroupOnce(uid_t uid, int initialPid, int signal);
 
 // Sends the provided signal to all members of a process group, but does not wait for processes to
 // exit, or for the cgroup to be removed. Callers should also ensure that killProcessGroup is called
-// later to ensure the cgroup is fully removed, otherwise system resources may leak.
-int sendSignalToProcessGroup(uid_t uid, int initialPid, int signal);
+// later to ensure the cgroup is fully removed, otherwise system resources will leak.
+// Returns true if no errors are encountered sending signals, otherwise false.
+bool sendSignalToProcessGroup(uid_t uid, int initialPid, int signal);
 
 int createProcessGroup(uid_t uid, int initialPid, bool memControl = false);
 
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index f594f7f66354..7e27d75440d3 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -22,6 +22,7 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
+#include <poll.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -30,6 +31,7 @@
 #include <unistd.h>
 
 #include <chrono>
+#include <cstring>
 #include <map>
 #include <memory>
 #include <mutex>
@@ -53,7 +55,8 @@ using android::base::WriteStringToFile;
 
 using namespace std::chrono_literals;
 
-#define PROCESSGROUP_CGROUP_PROCS_FILE "/cgroup.procs"
+#define PROCESSGROUP_CGROUP_PROCS_FILE "cgroup.procs"
+#define PROCESSGROUP_CGROUP_EVENTS_FILE "cgroup.events"
 
 bool CgroupsAvailable() {
     static bool cgroups_available = access("/proc/cgroups", F_OK) == 0;
@@ -213,30 +216,21 @@ static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, int pid) {
     return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
 }
 
-static int RemoveCgroup(const char* cgroup, uid_t uid, int pid, unsigned int retries) {
-    int ret = 0;
-    auto uid_pid_path = ConvertUidPidToPath(cgroup, uid, pid);
-
-    while (retries--) {
-        ret = rmdir(uid_pid_path.c_str());
-        // If we get an error 2 'No such file or directory' , that means the
-        // cgroup is already removed, treat it as success and return 0 for
-        // idempotency.
-        if (ret < 0 && errno == ENOENT) {
-            ret = 0;
-        }
-        if (!ret || errno != EBUSY || !retries) break;
-        std::this_thread::sleep_for(5ms);
-    }
+static int RemoveCgroup(const char* cgroup, uid_t uid, int pid) {
+    auto path = ConvertUidPidToPath(cgroup, uid, pid);
+    int ret = TEMP_FAILURE_RETRY(rmdir(path.c_str()));
 
     if (!ret && uid >= AID_ISOLATED_START && uid <= AID_ISOLATED_END) {
         // Isolated UIDs are unlikely to be reused soon after removal,
         // so free up the kernel resources for the UID level cgroup.
-        const auto uid_path = ConvertUidToPath(cgroup, uid);
-        ret = rmdir(uid_path.c_str());
-        if (ret < 0 && errno == ENOENT) {
-            ret = 0;
-        }
+        path = ConvertUidToPath(cgroup, uid);
+        ret = TEMP_FAILURE_RETRY(rmdir(path.c_str()));
+    }
+
+    if (ret < 0 && errno == ENOENT) {
+        // This function is idempoetent, but still warn here.
+        LOG(WARNING) << "RemoveCgroup: " << path << " does not exist.";
+        ret = 0;
     }
 
     return ret;
@@ -360,38 +354,33 @@ static bool MkdirAndChown(const std::string& path, mode_t mode, uid_t uid, gid_t
     return false;
 }
 
-// Returns number of processes killed on success
-// Returns 0 if there are no processes in the process cgroup left to kill
-// Returns -1 on error
-static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid, int signal) {
-    // We separate all of the pids in the cgroup into those pids that are also the leaders of
-    // process groups (stored in the pgids set) and those that are not (stored in the pids set).
-    std::set<pid_t> pgids;
-    pgids.emplace(initialPid);
-    std::set<pid_t> pids;
-    int processes = 0;
-
-    std::unique_ptr<FILE, decltype(&fclose)> fd(nullptr, fclose);
+bool sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
+    std::set<pid_t> pgids, pids;
 
     if (CgroupsAvailable()) {
-        auto path = ConvertUidPidToPath(cgroup, uid, initialPid) + PROCESSGROUP_CGROUP_PROCS_FILE;
-        fd.reset(fopen(path.c_str(), "re"));
-        if (!fd) {
-            if (errno == ENOENT) {
-                // This happens when the process is already dead or if, as the result of a bug, it
-                // has been migrated to another cgroup. An example of a bug that can cause migration
-                // to another cgroup is using the JoinCgroup action with a cgroup controller that
-                // has been activated in the v2 cgroup hierarchy.
-                goto kill;
-            }
-            PLOG(WARNING) << __func__ << " failed to open process cgroup uid " << uid << " pid "
-                          << initialPid;
-            return -1;
+        std::string hierarchy_root_path, cgroup_v2_path;
+        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
+        cgroup_v2_path = ConvertUidPidToPath(hierarchy_root_path.c_str(), uid, initialPid);
+
+        LOG(VERBOSE) << "Using " << PROCESSGROUP_CGROUP_PROCS_FILE << " to signal (" << signal
+                     << ") " << cgroup_v2_path;
+
+        // We separate all of the pids in the cgroup into those pids that are also the leaders of
+        // process groups (stored in the pgids set) and those that are not (stored in the pids set).
+        const auto procsfilepath = cgroup_v2_path + '/' + PROCESSGROUP_CGROUP_PROCS_FILE;
+        std::unique_ptr<FILE, decltype(&fclose)> fp(fopen(procsfilepath.c_str(), "re"), fclose);
+        if (!fp) {
+            // This should only happen if the cgroup has already been removed with a successful call
+            // to killProcessGroup. Callers should only retry sendSignalToProcessGroup or
+            // killProcessGroup calls if they fail without ENOENT.
+            PLOG(ERROR) << "Failed to open " << procsfilepath;
+            kill(-initialPid, signal);
+            return false;
         }
+
         pid_t pid;
         bool file_is_empty = true;
-        while (fscanf(fd.get(), "%d\n", &pid) == 1 && pid >= 0) {
-            processes++;
+        while (fscanf(fp.get(), "%d\n", &pid) == 1 && pid >= 0) {
             file_is_empty = false;
             if (pid == 0) {
                 // Should never happen...  but if it does, trying to kill this
@@ -421,7 +410,8 @@ static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid,
         }
     }
 
-kill:
+    pgids.emplace(initialPid);
+
     // Kill all process groups.
     for (const auto pgid : pgids) {
         LOG(VERBOSE) << "Killing process group " << -pgid << " in uid " << uid
@@ -442,101 +432,174 @@ static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid,
         }
     }
 
-    return (!fd || feof(fd.get())) ? processes : -1;
+    return true;
+}
+
+template <typename T>
+static std::chrono::milliseconds toMillisec(T&& duration) {
+    return std::chrono::duration_cast<std::chrono::milliseconds>(duration);
 }
 
-static int KillProcessGroup(uid_t uid, int initialPid, int signal, int retries) {
-    CHECK_GE(uid, 0);
-    CHECK_GT(initialPid, 0);
+enum class populated_status
+{
+    populated,
+    not_populated,
+    error
+};
 
-    std::string hierarchy_root_path;
-    if (CgroupsAvailable()) {
-        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
+static populated_status cgroupIsPopulated(int events_fd) {
+    const std::string POPULATED_KEY("populated ");
+    const std::string::size_type MAX_EVENTS_FILE_SIZE = 32;
+
+    std::string buf;
+    buf.resize(MAX_EVENTS_FILE_SIZE);
+    ssize_t len = TEMP_FAILURE_RETRY(pread(events_fd, buf.data(), buf.size(), 0));
+    if (len == -1) {
+        PLOG(ERROR) << "Could not read cgroup.events: ";
+        // Potentially ENODEV if the cgroup has been removed since we opened this file, but that
+        // shouldn't have happened yet.
+        return populated_status::error;
     }
-    const char* cgroup = hierarchy_root_path.c_str();
 
-    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+    if (len == 0) {
+        LOG(ERROR) << "cgroup.events EOF";
+        return populated_status::error;
+    }
 
-    int retry = retries;
-    int processes;
-    while ((processes = DoKillProcessGroupOnce(cgroup, uid, initialPid, signal)) > 0) {
-        LOG(VERBOSE) << "Killed " << processes << " processes for processgroup " << initialPid;
-        if (!CgroupsAvailable()) {
-            // makes no sense to retry, because there are no cgroup_procs file
-            processes = 0;  // no remaining processes
-            break;
-        }
-        if (retry > 0) {
-            std::this_thread::sleep_for(5ms);
-            --retry;
-        } else {
-            break;
-        }
+    buf.resize(len);
+
+    const std::string::size_type pos = buf.find(POPULATED_KEY);
+    if (pos == std::string::npos) {
+        LOG(ERROR) << "Could not find populated key in cgroup.events";
+        return populated_status::error;
+    }
+
+    if (pos + POPULATED_KEY.size() + 1 > len) {
+        LOG(ERROR) << "Partial read of cgroup.events";
+        return populated_status::error;
     }
 
-    if (processes < 0) {
-        PLOG(ERROR) << "Error encountered killing process cgroup uid " << uid << " pid "
-                    << initialPid;
+    return buf[pos + POPULATED_KEY.size()] == '1' ?
+        populated_status::populated : populated_status::not_populated;
+}
+
+// The default timeout of 2200ms comes from the default number of retries in a previous
+// implementation of this function. The default retry value was 40 for killing and 400 for cgroup
+// removal with 5ms sleeps between each retry.
+static int KillProcessGroup(
+        uid_t uid, int initialPid, int signal, bool once = false,
+        std::chrono::steady_clock::time_point until = std::chrono::steady_clock::now() + 2200ms) {
+    CHECK_GE(uid, 0);
+    CHECK_GT(initialPid, 0);
+
+    // Always attempt to send a kill signal to at least the initialPid, at least once, regardless of
+    // whether its cgroup exists or not. This should only be necessary if a bug results in the
+    // migration of the targeted process out of its cgroup, which we will also attempt to kill.
+    const bool signal_ret = sendSignalToProcessGroup(uid, initialPid, signal);
+
+    if (!CgroupsAvailable() || !signal_ret) return signal_ret ? 0 : -1;
+
+    std::string hierarchy_root_path;
+    CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
+
+    const std::string cgroup_v2_path =
+            ConvertUidPidToPath(hierarchy_root_path.c_str(), uid, initialPid);
+
+    const std::string eventsfile = cgroup_v2_path + '/' + PROCESSGROUP_CGROUP_EVENTS_FILE;
+    android::base::unique_fd events_fd(open(eventsfile.c_str(), O_RDONLY));
+    if (events_fd.get() == -1) {
+        PLOG(WARNING) << "Error opening " << eventsfile << " for KillProcessGroup";
         return -1;
     }
 
-    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
-    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
+    struct pollfd fds = {
+        .fd = events_fd,
+        .events = POLLPRI,
+    };
+
+    const std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+
+    // The primary reason to loop here is to capture any new forks or migrations that could occur
+    // after we send signals to the original set of processes, but before all of those processes
+    // exit and the cgroup becomes unpopulated, or before we remove the cgroup. We try hard to
+    // ensure this completes successfully to avoid permanent memory leaks, but we still place a
+    // large default upper bound on the amount of time we spend in this loop. The amount of CPU
+    // contention, and the amount of work that needs to be done in do_exit for each process
+    // determines how long this will take.
+    int ret;
+    do {
+        populated_status populated;
+        while ((populated = cgroupIsPopulated(events_fd.get())) == populated_status::populated &&
+               std::chrono::steady_clock::now() < until) {
+
+            sendSignalToProcessGroup(uid, initialPid, signal);
+            if (once) {
+                populated = cgroupIsPopulated(events_fd.get());
+                break;
+            }
+
+            const std::chrono::steady_clock::time_point poll_start =
+                    std::chrono::steady_clock::now();
+
+            if (poll_start < until)
+                ret = TEMP_FAILURE_RETRY(poll(&fds, 1, toMillisec(until - poll_start).count()));
 
-    // We only calculate the number of 'processes' when killing the processes.
-    // In the retries == 0 case, we only kill the processes once and therefore
-    // will not have waited then recalculated how many processes are remaining
-    // after the first signals have been sent.
-    // Logging anything regarding the number of 'processes' here does not make sense.
+            if (ret == -1) {
+                // Fallback to 5ms sleeps if poll fails
+                PLOG(ERROR) << "Poll on " << eventsfile << "failed";
+                const std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
+                if (now < until)
+                    std::this_thread::sleep_for(std::min(5ms, toMillisec(until - now)));
+            }
 
-    if (processes == 0) {
-        if (retries > 0) {
-            LOG(INFO) << "Successfully killed process cgroup uid " << uid << " pid " << initialPid
-                      << " in " << static_cast<int>(ms) << "ms";
+            LOG(VERBOSE) << "Waited "
+                         << toMillisec(std::chrono::steady_clock::now() - poll_start).count()
+                         << " ms for " << eventsfile << " poll";
         }
 
-        if (!CgroupsAvailable()) {
-            // nothing to do here, if cgroups isn't available
-            return 0;
+        const std::chrono::milliseconds kill_duration =
+                toMillisec(std::chrono::steady_clock::now() - start);
+
+        if (populated == populated_status::populated) {
+            LOG(WARNING) << "Still waiting on process(es) to exit for cgroup " << cgroup_v2_path
+                         << " after " << kill_duration.count() << " ms";
+            // We'll still try the cgroup removal below which we expect to log an error.
+        } else if (populated == populated_status::not_populated) {
+            LOG(VERBOSE) << "Killed all processes under cgroup " << cgroup_v2_path
+                         << " after " << kill_duration.count() << " ms";
         }
 
-        // 400 retries correspond to 2 secs max timeout
-        int err = RemoveCgroup(cgroup, uid, initialPid, 400);
+        ret = RemoveCgroup(hierarchy_root_path.c_str(), uid, initialPid);
+        if (ret)
+            PLOG(ERROR) << "Unable to remove cgroup " << cgroup_v2_path;
+        else
+            LOG(INFO) << "Removed cgroup " << cgroup_v2_path;
 
         if (isMemoryCgroupSupported() && UsePerAppMemcg()) {
+            // This per-application memcg v1 case should eventually be removed after migration to
+            // memcg v2.
             std::string memcg_apps_path;
             if (CgroupGetMemcgAppsPath(&memcg_apps_path) &&
-                RemoveCgroup(memcg_apps_path.c_str(), uid, initialPid, 400) < 0) {
-                return -1;
+                (ret = RemoveCgroup(memcg_apps_path.c_str(), uid, initialPid)) < 0) {
+                const auto memcg_v1_cgroup_path =
+                        ConvertUidPidToPath(memcg_apps_path.c_str(), uid, initialPid);
+                PLOG(ERROR) << "Unable to remove memcg v1 cgroup " << memcg_v1_cgroup_path;
             }
         }
 
-        return err;
-    } else {
-        if (retries > 0) {
-            LOG(ERROR) << "Failed to kill process cgroup uid " << uid << " pid " << initialPid
-                       << " in " << static_cast<int>(ms) << "ms, " << processes
-                       << " processes remain";
-        }
-        return -1;
-    }
+        if (once) break;
+        if (std::chrono::steady_clock::now() >= until) break;
+    } while (ret && errno == EBUSY);
+
+    return ret;
 }
 
 int killProcessGroup(uid_t uid, int initialPid, int signal) {
-    return KillProcessGroup(uid, initialPid, signal, 40 /*retries*/);
+    return KillProcessGroup(uid, initialPid, signal);
 }
 
 int killProcessGroupOnce(uid_t uid, int initialPid, int signal) {
-    return KillProcessGroup(uid, initialPid, signal, 0 /*retries*/);
-}
-
-int sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
-    std::string hierarchy_root_path;
-    if (CgroupsAvailable()) {
-        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
-    }
-    const char* cgroup = hierarchy_root_path.c_str();
-    return DoKillProcessGroupOnce(cgroup, uid, initialPid, signal);
+    return KillProcessGroup(uid, initialPid, signal, true);
 }
 
 static int createProcessGroupInternal(uid_t uid, int initialPid, std::string cgroup,
@@ -576,7 +639,7 @@ static int createProcessGroupInternal(uid_t uid, int initialPid, std::string cgr
         return -errno;
     }
 
-    auto uid_pid_procs_file = uid_pid_path + PROCESSGROUP_CGROUP_PROCS_FILE;
+    auto uid_pid_procs_file = uid_pid_path + '/' + PROCESSGROUP_CGROUP_PROCS_FILE;
 
     if (!WriteStringToFile(std::to_string(initialPid), uid_pid_procs_file)) {
         ret = -errno;

From 38b8bb1e4a245de240f0761975e1d156030501fb Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 7 Nov 2023 14:36:46 +0000
Subject: [PATCH 0605/1487] libprocessgroup: Use cgroup.kill

By using cgroup.kill we don't need to read cgroup.procs at all for
SIGKILLs, which is more efficient and should help reduce CPU contention
and cgroup lock contention. Fallback to cgroup.procs if we encounter an
error trying to use cgroup.kill, but if cgroup.kill fails it's likely
that cgroup.procs will too.

Bug: 239829790
Change-Id: I44706faccfb7c4611b512a3642b913f06d30c1dc
---
 libprocessgroup/processgroup.cpp | 46 ++++++++++++++++++++++++++------
 1 file changed, 38 insertions(+), 8 deletions(-)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 7e27d75440d3..4b49d09af474 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -56,6 +56,7 @@ using android::base::WriteStringToFile;
 using namespace std::chrono_literals;
 
 #define PROCESSGROUP_CGROUP_PROCS_FILE "cgroup.procs"
+#define PROCESSGROUP_CGROUP_KILL_FILE "cgroup.kill"
 #define PROCESSGROUP_CGROUP_EVENTS_FILE "cgroup.events"
 
 bool CgroupsAvailable() {
@@ -77,6 +78,29 @@ bool CgroupGetControllerPath(const std::string& cgroup_name, std::string* path)
     return true;
 }
 
+static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
+    return StringPrintf("%s/uid_%u", cgroup, uid);
+}
+
+static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, int pid) {
+    return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
+}
+
+static bool CgroupKillAvailable() {
+    static std::once_flag f;
+    static bool cgroup_kill_available = false;
+    std::call_once(f, []() {
+        std::string cg_kill;
+        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &cg_kill);
+        // cgroup.kill is not on the root cgroup, so check a non-root cgroup that should always
+        // exist
+        cg_kill = ConvertUidToPath(cg_kill.c_str(), AID_ROOT) + '/' + PROCESSGROUP_CGROUP_KILL_FILE;
+        cgroup_kill_available = access(cg_kill.c_str(), F_OK) == 0;
+    });
+
+    return cgroup_kill_available;
+}
+
 static bool CgroupGetMemcgAppsPath(std::string* path) {
     CgroupController controller = CgroupMap::GetInstance().FindController("memory");
 
@@ -208,14 +232,6 @@ bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles) {
                                                        false);
 }
 
-static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
-    return StringPrintf("%s/uid_%u", cgroup, uid);
-}
-
-static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, int pid) {
-    return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
-}
-
 static int RemoveCgroup(const char* cgroup, uid_t uid, int pid) {
     auto path = ConvertUidPidToPath(cgroup, uid, pid);
     int ret = TEMP_FAILURE_RETRY(rmdir(path.c_str()));
@@ -362,6 +378,20 @@ bool sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
         CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
         cgroup_v2_path = ConvertUidPidToPath(hierarchy_root_path.c_str(), uid, initialPid);
 
+        if (signal == SIGKILL && CgroupKillAvailable()) {
+            LOG(VERBOSE) << "Using " << PROCESSGROUP_CGROUP_KILL_FILE << " to SIGKILL "
+                         << cgroup_v2_path;
+            const std::string killfilepath = cgroup_v2_path + '/' + PROCESSGROUP_CGROUP_KILL_FILE;
+            if (WriteStringToFile("1", killfilepath)) {
+                return true;
+            } else {
+                PLOG(ERROR) << "Failed to write 1 to " << killfilepath;
+                // Fallback to cgroup.procs below
+            }
+        }
+
+        // Since cgroup.kill only sends SIGKILLs, we read cgroup.procs to find each process to
+        // signal individually. This is more costly than using cgroup.kill for SIGKILLs.
         LOG(VERBOSE) << "Using " << PROCESSGROUP_CGROUP_PROCS_FILE << " to signal (" << signal
                      << ") " << cgroup_v2_path;
 

From 84e5e6f7511282b981e2eeb0b3b0b358b4891a04 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Wed, 6 Dec 2023 16:37:02 -0800
Subject: [PATCH 0606/1487] Support batch writes for non-compressed ops

This also improves atomicity of ops. If a single Add*Blocks() call
with 100 blocks failed in the middle, partially written blocks would be
discarded, and op count on disk stays unchanged. Previously wew ould
update the op count on disk with partially written blocks, causing
labels to be inaccurate.

Test: th
Bug: 313962438
Change-Id: If175a705f6ec46c1b25c52d0d9f02f01a540ce55
---
 .../libsnapshot_cow/cow_format.cpp            |   1 -
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   |  54 ++++++----
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 102 ++++++++++++------
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |   4 +-
 4 files changed, 104 insertions(+), 57 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
index 2c4d40fcb305..b0eb72354b57 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
@@ -14,7 +14,6 @@
 // limitations under the License.
 //
 
-#include <inttypes.h>
 #include <libsnapshot/cow_format.h>
 #include <sys/types.h>
 #include <unistd.h>
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 27accdc7bb15..44b73446428b 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -97,7 +97,7 @@ TEST_F(CowTestV3, MaxOp) {
     options.op_count_max = 20;
     auto writer = CreateCowWriter(3, options, GetCowFd());
     ASSERT_FALSE(writer->AddZeroBlocks(1, 21));
-    ASSERT_FALSE(writer->AddZeroBlocks(1, 1));
+    ASSERT_TRUE(writer->AddZeroBlocks(1, 20));
     std::string data = "This is some data, believe it";
     data.resize(options.block_size, '\0');
 
@@ -184,7 +184,7 @@ TEST_F(CowTestV3, ConsecutiveReplaceOp) {
     std::string data;
     data.resize(options.block_size * 5);
     for (int i = 0; i < data.size(); i++) {
-        data[i] = char(rand() % 256);
+        data[i] = static_cast<char>('A' + i / options.block_size);
     }
 
     ASSERT_TRUE(writer->AddRawBlocks(5, data.data(), data.size()));
@@ -205,19 +205,20 @@ TEST_F(CowTestV3, ConsecutiveReplaceOp) {
     ASSERT_FALSE(iter->AtEnd());
 
     size_t i = 0;
-    std::string sink(data.size(), '\0');
 
     while (!iter->AtEnd()) {
         auto op = iter->Get();
+        std::string sink(options.block_size, '\0');
         ASSERT_EQ(op->type(), kCowReplaceOp);
         ASSERT_EQ(op->data_length, options.block_size);
         ASSERT_EQ(op->new_block, 5 + i);
-        ASSERT_TRUE(
-                ReadData(reader, op, sink.data() + (i * options.block_size), options.block_size));
+        ASSERT_TRUE(ReadData(reader, op, sink.data(), options.block_size));
+        ASSERT_EQ(std::string_view(sink),
+                  std::string_view(data).substr(i * options.block_size, options.block_size))
+                << " readback data for " << i << "th block does not match";
         iter->Next();
         i++;
     }
-    ASSERT_EQ(sink, data);
 
     ASSERT_EQ(i, 5);
 }
@@ -372,41 +373,33 @@ TEST_F(CowTestV3, AllOpsWithCompression) {
     ASSERT_NE(iter, nullptr);
     ASSERT_FALSE(iter->AtEnd());
 
-    size_t i = 0;
-
-    while (i < 5) {
+    for (size_t i = 0; i < 5; i++) {
         auto op = iter->Get();
         ASSERT_EQ(op->type(), kCowZeroOp);
         ASSERT_EQ(op->new_block, 10 + i);
         iter->Next();
-        i++;
     }
-    i = 0;
-    while (i < 5) {
+    for (size_t i = 0; i < 5; i++) {
         auto op = iter->Get();
         ASSERT_EQ(op->type(), kCowCopyOp);
         ASSERT_EQ(op->new_block, 15 + i);
         ASSERT_EQ(op->source(), 3 + i);
         iter->Next();
-        i++;
     }
-    i = 0;
     std::string sink(data.size(), '\0');
 
-    while (i < 5) {
+    for (size_t i = 0; i < 5; i++) {
         auto op = iter->Get();
         ASSERT_EQ(op->type(), kCowReplaceOp);
         ASSERT_EQ(op->new_block, 18 + i);
-        ASSERT_TRUE(
-                ReadData(reader, op, sink.data() + (i * options.block_size), options.block_size));
+        ASSERT_EQ(reader.ReadData(op, sink.data() + (i * options.block_size), options.block_size),
+                  options.block_size);
         iter->Next();
-        i++;
     }
     ASSERT_EQ(sink, data);
 
-    i = 0;
     std::fill(sink.begin(), sink.end(), '\0');
-    while (i < 5) {
+    for (size_t i = 0; i < 5; i++) {
         auto op = iter->Get();
         ASSERT_EQ(op->type(), kCowXorOp);
         ASSERT_EQ(op->new_block, 50 + i);
@@ -414,7 +407,6 @@ TEST_F(CowTestV3, AllOpsWithCompression) {
         ASSERT_TRUE(
                 ReadData(reader, op, sink.data() + (i * options.block_size), options.block_size));
         iter->Next();
-        i++;
     }
     ASSERT_EQ(sink, data);
 }
@@ -671,5 +663,25 @@ TEST_F(CowTestV3, CowSizeEstimate) {
     ASSERT_LE(writer.GetCowSize(), cow_size);
 }
 
+TEST_F(CowTestV3, CopyOpMany) {
+    CowOptions options;
+    options.op_count_max = 100;
+    CowWriterV3 writer(options, GetCowFd());
+    writer.Initialize();
+    ASSERT_TRUE(writer.AddCopy(100, 50, 50));
+    ASSERT_TRUE(writer.AddCopy(150, 100, 50));
+    ASSERT_TRUE(writer.Finalize());
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(GetCowFd()));
+    auto it = reader.GetOpIter();
+    for (size_t i = 0; i < 100; i++) {
+        ASSERT_FALSE(it->AtEnd()) << " op iterator ended at " << i;
+        const auto op = *it->Get();
+        ASSERT_EQ(op.type(), kCowCopyOp);
+        ASSERT_EQ(op.new_block, 100 + i);
+        it->Next();
+    }
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 07f6f002f73c..4df0e76ec3f5 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -113,7 +113,13 @@ bool CowWriterV3::ParseOptions() {
     }
 
     compression_.algorithm = *algorithm;
-    compressor_ = ICompressor::Create(compression_, header_.block_size);
+    if (compression_.algorithm != kCowCompressNone) {
+        compressor_ = ICompressor::Create(compression_, header_.block_size);
+        if (compressor_ == nullptr) {
+            LOG(ERROR) << "Failed to create compressor for " << compression_.algorithm;
+            return false;
+        }
+    }
     return true;
 }
 
@@ -207,14 +213,15 @@ bool CowWriterV3::OpenForAppend(uint64_t label) {
 }
 
 bool CowWriterV3::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks) {
+    std::vector<CowOperationV3> ops(num_blocks);
     for (size_t i = 0; i < num_blocks; i++) {
-        CowOperationV3 op{};
+        CowOperationV3& op = ops[i];
         op.set_type(kCowCopyOp);
         op.new_block = new_block + i;
         op.set_source(old_block + i);
-        if (!WriteOperation(op)) {
-            return false;
-        }
+    }
+    if (!WriteOperation({ops.data(), ops.size()}, {})) {
+        return false;
     }
 
     return true;
@@ -231,12 +238,37 @@ bool CowWriterV3::EmitXorBlocks(uint32_t new_block_start, const void* data, size
 
 bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t size,
                              uint64_t old_block, uint16_t offset, CowOperationType type) {
+    if (compression_.algorithm != kCowCompressNone && compressor_ == nullptr) {
+        LOG(ERROR) << "Compression algorithm is " << compression_.algorithm
+                   << " but compressor is uninitialized.";
+        return false;
+    }
     const size_t num_blocks = (size / header_.block_size);
+    if (compression_.algorithm == kCowCompressNone) {
+        std::vector<CowOperationV3> ops(num_blocks);
+        for (size_t i = 0; i < num_blocks; i++) {
+            CowOperation& op = ops[i];
+            op.new_block = new_block_start + i;
+
+            op.set_type(type);
+            if (type == kCowXorOp) {
+                op.set_source((old_block + i) * header_.block_size + offset);
+            } else {
+                op.set_source(next_data_pos_ + header_.block_size * i);
+            }
+            op.data_length = header_.block_size;
+        }
+        return WriteOperation({ops.data(), ops.size()},
+                              {reinterpret_cast<const uint8_t*>(data), size});
+    }
+
+    const auto saved_op_count = header_.op_count;
+    const auto saved_data_pos = next_data_pos_;
     for (size_t i = 0; i < num_blocks; i++) {
         const uint8_t* const iter =
                 reinterpret_cast<const uint8_t*>(data) + (header_.block_size * i);
 
-        CowOperation op = {};
+        CowOperation op{};
         op.new_block = new_block_start + i;
 
         op.set_type(type);
@@ -245,25 +277,21 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
         } else {
             op.set_source(next_data_pos_);
         }
-        std::basic_string<uint8_t> compressed_data;
         const void* out_data = iter;
 
         op.data_length = header_.block_size;
 
-        if (compression_.algorithm) {
-            if (!compressor_) {
-                PLOG(ERROR) << "Compressor not initialized";
-                return false;
-            }
-            compressed_data = compressor_->Compress(out_data, header_.block_size);
-            if (compressed_data.size() < op.data_length) {
-                out_data = compressed_data.data();
-                op.data_length = compressed_data.size();
-            }
+        const std::basic_string<uint8_t> compressed_data =
+                compressor_->Compress(out_data, header_.block_size);
+        if (compressed_data.size() < op.data_length) {
+            out_data = compressed_data.data();
+            op.data_length = compressed_data.size();
         }
         if (!WriteOperation(op, out_data, op.data_length)) {
             PLOG(ERROR) << "AddRawBlocks with compression: write failed. new block: "
                         << new_block_start << " compression: " << compression_.algorithm;
+            header_.op_count = saved_op_count;
+            next_data_pos_ = saved_data_pos;
             return false;
         }
     }
@@ -272,13 +300,14 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
 }
 
 bool CowWriterV3::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
+    std::vector<CowOperationV3> ops(num_blocks);
     for (uint64_t i = 0; i < num_blocks; i++) {
-        CowOperationV3 op{};
+        CowOperationV3& op = ops[i];
         op.set_type(kCowZeroOp);
         op.new_block = new_block_start + i;
-        if (!WriteOperation(op)) {
-            return false;
-        }
+    }
+    if (!WriteOperation({ops.data(), ops.size()}, {})) {
+        return false;
     }
     return true;
 }
@@ -324,43 +353,48 @@ bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
     return true;
 }
 
-bool CowWriterV3::WriteOperation(const CowOperationV3& op, const void* data, size_t size) {
+bool CowWriterV3::WriteOperation(std::basic_string_view<CowOperationV3> ops,
+                                 std::basic_string_view<uint8_t> data) {
     if (IsEstimating()) {
-        header_.op_count++;
+        header_.op_count += ops.size();
         if (header_.op_count > header_.op_count_max) {
             // If we increment op_count_max, the offset of data section would
             // change. So need to update |next_data_pos_|
             next_data_pos_ += (header_.op_count - header_.op_count_max) * sizeof(CowOperationV3);
             header_.op_count_max = header_.op_count;
         }
-        next_data_pos_ += op.data_length;
+        next_data_pos_ += data.size();
         return true;
     }
 
-    if (header_.op_count + 1 > header_.op_count_max) {
-        LOG(ERROR) << "Maximum number of ops reached: " << header_.op_count_max;
+    if (header_.op_count + ops.size() > header_.op_count_max) {
+        LOG(ERROR) << "Current op count " << header_.op_count << ", attempting to write "
+                   << ops.size() << " ops will exceed the max of " << header_.op_count_max;
         return false;
     }
 
     const off_t offset = GetOpOffset(header_.op_count, header_);
-    if (!android::base::WriteFullyAtOffset(fd_, &op, sizeof(op), offset)) {
-        PLOG(ERROR) << "write failed for " << op << " at " << offset;
+    if (!android::base::WriteFullyAtOffset(fd_, ops.data(), ops.size() * sizeof(ops[0]), offset)) {
+        PLOG(ERROR) << "Write failed for " << ops.size() << " ops at " << offset;
         return false;
     }
-    if (data && size > 0) {
-        if (!android::base::WriteFullyAtOffset(fd_, data, size, next_data_pos_)) {
-            PLOG(ERROR) << "write failed for data of size: " << size
+    if (!data.empty()) {
+        if (!android::base::WriteFullyAtOffset(fd_, data.data(), data.size(), next_data_pos_)) {
+            PLOG(ERROR) << "write failed for data of size: " << data.size()
                         << " at offset: " << next_data_pos_;
             return false;
         }
     }
-    header_.op_count++;
-    next_data_pos_ += op.data_length;
-    next_op_pos_ += sizeof(CowOperationV3);
+    header_.op_count += ops.size();
+    next_data_pos_ += data.size();
 
     return true;
 }
 
+bool CowWriterV3::WriteOperation(const CowOperationV3& op, const void* data, size_t size) {
+    return WriteOperation({&op, 1}, {reinterpret_cast<const uint8_t*>(data), size});
+}
+
 bool CowWriterV3::Finalize() {
     CHECK_GE(header_.prefix.header_size, sizeof(CowHeaderV3));
     CHECK_LE(header_.prefix.header_size, sizeof(header_));
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 340218fd2440..02b4e611bf6f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -15,6 +15,7 @@
 #pragma once
 
 #include <android-base/logging.h>
+#include <string_view>
 
 #include "writer_base.h"
 
@@ -44,6 +45,8 @@ class CowWriterV3 : public CowWriterBase {
     bool ParseOptions();
     bool OpenForWrite();
     bool OpenForAppend(uint64_t label);
+    bool WriteOperation(std::basic_string_view<CowOperationV3> op,
+                        std::basic_string_view<uint8_t> data);
     bool WriteOperation(const CowOperationV3& op, const void* data = nullptr, size_t size = 0);
     bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
                     uint16_t offset, CowOperationType type);
@@ -59,7 +62,6 @@ class CowWriterV3 : public CowWriterBase {
     // Resume points contain a laebl + cow_op_index.
     std::shared_ptr<std::vector<ResumePoint>> resume_points_;
 
-    uint64_t next_op_pos_ = 0;
     uint64_t next_data_pos_ = 0;
     std::vector<std::basic_string<uint8_t>> compressed_buf_;
 

From 08534b8d0b847ca3c05b036b32517664059cf501 Mon Sep 17 00:00:00 2001
From: Massimo Carli <mcarli@google.com>
Date: Thu, 7 Dec 2023 09:19:24 +0000
Subject: [PATCH 0607/1487] Revert "Calculate ro.vendor.api_level with the new
 vendor API format"

This reverts commit e267e31d73dc67dd617dfe848169bf78e5ac0b42.

Reason for revert: b/315246126

Change-Id: I456858c6f4c528158c0826efcdc1509b701c32f7
---
 init/property_service.cpp | 49 ++++++++++++++++-----------------------
 1 file changed, 20 insertions(+), 29 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index e2cff957ee19..bd743581910b 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -84,7 +84,6 @@ using namespace std::literals;
 
 using android::base::ErrnoError;
 using android::base::Error;
-using android::base::GetIntProperty;
 using android::base::GetProperty;
 using android::base::ParseInt;
 using android::base::ReadFileToString;
@@ -113,7 +112,7 @@ constexpr auto ID_PROP = "ro.build.id";
 constexpr auto LEGACY_ID_PROP = "ro.build.legacy.id";
 constexpr auto VBMETA_DIGEST_PROP = "ro.boot.vbmeta.digest";
 constexpr auto DIGEST_SIZE_USED = 8;
-constexpr auto MAX_VENDOR_API_LEVEL = 1000000;
+constexpr auto API_LEVEL_CURRENT = 10000;
 
 static bool persistent_properties_loaded = false;
 
@@ -1085,16 +1084,15 @@ static void property_initialize_ro_cpu_abilist() {
     }
 }
 
-static int vendor_api_level_of(int sdk_api_level) {
-    if (sdk_api_level < __ANDROID_API_V__) {
-        return sdk_api_level;
-    }
-    // In Android V, vendor API level started with version 202404.
-    // The calculation assumes that the SDK api level bumps once a year.
-    if (sdk_api_level < __ANDROID_API_FUTURE__) {
-        return 202404 + ((sdk_api_level - __ANDROID_API_V__) * 100);
+static int read_api_level_props(const std::vector<std::string>& api_level_props) {
+    int api_level = API_LEVEL_CURRENT;
+    for (const auto& api_level_prop : api_level_props) {
+        api_level = android::base::GetIntProperty(api_level_prop, API_LEVEL_CURRENT);
+        if (api_level != API_LEVEL_CURRENT) {
+            break;
+        }
     }
-    return MAX_VENDOR_API_LEVEL;
+    return api_level;
 }
 
 static void property_initialize_ro_vendor_api_level() {
@@ -1102,27 +1100,20 @@ static void property_initialize_ro_vendor_api_level() {
     // required to support.
     constexpr auto VENDOR_API_LEVEL_PROP = "ro.vendor.api_level";
 
-    auto vendor_api_level = GetIntProperty("ro.board.first_api_level", MAX_VENDOR_API_LEVEL);
-    if (vendor_api_level != MAX_VENDOR_API_LEVEL) {
-        // Update the vendor_api_level with "ro.board.api_level" only if both "ro.board.api_level"
-        // and "ro.board.first_api_level" are defined.
-        vendor_api_level = GetIntProperty("ro.board.api_level", vendor_api_level);
-    }
-
-    auto product_first_api_level =
-            GetIntProperty("ro.product.first_api_level", __ANDROID_API_FUTURE__);
-    if (product_first_api_level == __ANDROID_API_FUTURE__) {
-        // Fallback to "ro.build.version.sdk" if the "ro.product.first_api_level" is not defined.
-        product_first_api_level = GetIntProperty("ro.build.version.sdk", __ANDROID_API_FUTURE__);
-    }
-
-    vendor_api_level = std::min(vendor_api_level_of(product_first_api_level), vendor_api_level);
+    // Api level properties of the board. The order of the properties must be kept.
+    std::vector<std::string> BOARD_API_LEVEL_PROPS = {"ro.board.api_level",
+                                                      "ro.board.first_api_level"};
+    // Api level properties of the device. The order of the properties must be kept.
+    std::vector<std::string> DEVICE_API_LEVEL_PROPS = {"ro.product.first_api_level",
+                                                       "ro.build.version.sdk"};
 
+    int api_level = std::min(read_api_level_props(BOARD_API_LEVEL_PROPS),
+                             read_api_level_props(DEVICE_API_LEVEL_PROPS));
     std::string error;
-    auto res = PropertySetNoSocket(VENDOR_API_LEVEL_PROP, std::to_string(vendor_api_level), &error);
+    auto res = PropertySetNoSocket(VENDOR_API_LEVEL_PROP, std::to_string(api_level), &error);
     if (res != PROP_SUCCESS) {
-        LOG(ERROR) << "Failed to set " << VENDOR_API_LEVEL_PROP << " with " << vendor_api_level
-                   << ": " << error << "(" << res << ")";
+        LOG(ERROR) << "Failed to set " << VENDOR_API_LEVEL_PROP << " with " << api_level << ": "
+                   << error << "(" << res << ")";
     }
 }
 

From b22e5bcf6009b090d5952f1c2960ee2cb109ea3e Mon Sep 17 00:00:00 2001
From: Mike McTernan <mikemcternan@google.com>
Date: Thu, 7 Dec 2023 12:13:18 +0000
Subject: [PATCH 0608/1487] trusty: apploader: fail specifically if app package
 is 0 bytes

Replace assert with check and log message.  Also log more about the request if DMA heap allocation fails.

Bug: 315283243
Test: boot to home
Test: touch x && trusty_apploader x
Change-Id: Ic075809fd2a6b09d9c4e8dff986709c4deae8fb7
---
 trusty/apploader/apploader.cpp | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/trusty/apploader/apploader.cpp b/trusty/apploader/apploader.cpp
index f782d2acb842..0915eab57f9a 100644
--- a/trusty/apploader/apploader.cpp
+++ b/trusty/apploader/apploader.cpp
@@ -107,7 +107,11 @@ static unique_fd read_file(const char* file_name, off64_t* out_file_size) {
         return {};
     }
 
-    assert(st.st_size >= 0);
+    if (st.st_size == 0) {
+        LOG(ERROR) << "Zero length file '" << file_name << "'";
+        return {};
+    }
+
     file_size = st.st_size;
 
     /* The dmabuf size needs to be a multiple of the page size */
@@ -123,7 +127,8 @@ static unique_fd read_file(const char* file_name, off64_t* out_file_size) {
     BufferAllocator alloc;
     unique_fd dmabuf_fd(alloc.Alloc(kDmabufSystemHeapName, file_page_size));
     if (!dmabuf_fd.ok()) {
-        LOG(ERROR) << "Error creating dmabuf: " << dmabuf_fd.get();
+        LOG(ERROR) << "Error creating dmabuf for " << file_page_size
+                   << " bytes: " << dmabuf_fd.get();
         return dmabuf_fd;
     }
 

From 1578cb3c142bbe41bec709dbb352fd88e8a085ba Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Tue, 21 Nov 2023 08:56:06 -0800
Subject: [PATCH 0609/1487] Introduce libutils_binder_sdk

Bug: 285204695
Test: mma in Binder directory
Change-Id: I430b81594167940cb47897e4261ad87c75ac3783
---
 libutils/Android.bp        | 18 +++++++++++++-----
 libutils/binder/Android.bp | 26 ++++++++++++++++++++++++--
 2 files changed, 37 insertions(+), 7 deletions(-)

diff --git a/libutils/Android.bp b/libutils/Android.bp
index 85a0fd209b5e..1c622ff7529d 100644
--- a/libutils/Android.bp
+++ b/libutils/Android.bp
@@ -56,7 +56,7 @@ cc_library_headers {
 }
 
 cc_defaults {
-    name: "libutils_defaults",
+    name: "libutils_defaults_nodeps",
     vendor_available: true,
     product_available: true,
     recovery_available: true,
@@ -69,10 +69,6 @@ cc_defaults {
         "-DANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION",
     ],
 
-    shared_libs: [
-        "libcutils",
-        "liblog",
-    ],
     sanitize: {
         misc_undefined: ["integer"],
     },
@@ -117,6 +113,18 @@ cc_defaults {
     },
 }
 
+cc_defaults {
+    name: "libutils_defaults",
+    defaults: [
+        "libutils_defaults_nodeps",
+    ],
+
+    shared_libs: [
+        "libcutils",
+        "liblog",
+    ],
+}
+
 cc_defaults {
     name: "libutils_impl_defaults",
     defaults: [
diff --git a/libutils/binder/Android.bp b/libutils/binder/Android.bp
index a049f3d805b0..60b0cb62c2bb 100644
--- a/libutils/binder/Android.bp
+++ b/libutils/binder/Android.bp
@@ -3,9 +3,9 @@ package {
 }
 
 cc_defaults {
-    name: "libutils_binder_impl_defaults",
+    name: "libutils_binder_impl_defaults_nodeps",
     defaults: [
-        "libutils_defaults",
+        "libutils_defaults_nodeps",
         "apex-lowest-min-sdk-version",
     ],
     native_bridge_supported: true,
@@ -30,11 +30,33 @@ cc_defaults {
     afdo: true,
 }
 
+cc_defaults {
+    name: "libutils_binder_impl_defaults",
+    defaults: [
+        "libutils_defaults",
+        "libutils_binder_impl_defaults_nodeps",
+    ],
+}
+
 cc_library {
     name: "libutils_binder",
     defaults: ["libutils_binder_impl_defaults"],
 }
 
+cc_library_shared {
+    name: "libutils_binder_sdk",
+    defaults: ["libutils_binder_impl_defaults_nodeps"],
+
+    header_libs: [
+        "liblog_stub",
+    ],
+
+    cflags: [
+        "-DANDROID_LOG_STUB_WEAK_PRINT",
+        "-DANDROID_UTILS_CALLSTACK_ENABLED=0",
+    ],
+}
+
 cc_library {
     name: "libutils_binder_test_compile",
     defaults: ["libutils_binder_impl_defaults"],

From 29192395bc6f8c6697b4d1f2234e68d2a2e2ed42 Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Thu, 7 Dec 2023 22:22:53 +0000
Subject: [PATCH 0610/1487] Revert "Revert "Calculate ro.vendor.api_level with
 the new vendo..."

Revert submission 2863786-trunk_vendor_api_level

Reason for revert: Reland the ro.vendor.api_level update

Reverted changes: /q/submissionid:2863786-trunk_vendor_api_level

Change-Id: I1f380e04f673eb4570e598a6e2013fce6e69213e
---
 init/property_service.cpp | 49 +++++++++++++++++++++++----------------
 1 file changed, 29 insertions(+), 20 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index bd743581910b..e2cff957ee19 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -84,6 +84,7 @@ using namespace std::literals;
 
 using android::base::ErrnoError;
 using android::base::Error;
+using android::base::GetIntProperty;
 using android::base::GetProperty;
 using android::base::ParseInt;
 using android::base::ReadFileToString;
@@ -112,7 +113,7 @@ constexpr auto ID_PROP = "ro.build.id";
 constexpr auto LEGACY_ID_PROP = "ro.build.legacy.id";
 constexpr auto VBMETA_DIGEST_PROP = "ro.boot.vbmeta.digest";
 constexpr auto DIGEST_SIZE_USED = 8;
-constexpr auto API_LEVEL_CURRENT = 10000;
+constexpr auto MAX_VENDOR_API_LEVEL = 1000000;
 
 static bool persistent_properties_loaded = false;
 
@@ -1084,15 +1085,16 @@ static void property_initialize_ro_cpu_abilist() {
     }
 }
 
-static int read_api_level_props(const std::vector<std::string>& api_level_props) {
-    int api_level = API_LEVEL_CURRENT;
-    for (const auto& api_level_prop : api_level_props) {
-        api_level = android::base::GetIntProperty(api_level_prop, API_LEVEL_CURRENT);
-        if (api_level != API_LEVEL_CURRENT) {
-            break;
-        }
+static int vendor_api_level_of(int sdk_api_level) {
+    if (sdk_api_level < __ANDROID_API_V__) {
+        return sdk_api_level;
     }
-    return api_level;
+    // In Android V, vendor API level started with version 202404.
+    // The calculation assumes that the SDK api level bumps once a year.
+    if (sdk_api_level < __ANDROID_API_FUTURE__) {
+        return 202404 + ((sdk_api_level - __ANDROID_API_V__) * 100);
+    }
+    return MAX_VENDOR_API_LEVEL;
 }
 
 static void property_initialize_ro_vendor_api_level() {
@@ -1100,20 +1102,27 @@ static void property_initialize_ro_vendor_api_level() {
     // required to support.
     constexpr auto VENDOR_API_LEVEL_PROP = "ro.vendor.api_level";
 
-    // Api level properties of the board. The order of the properties must be kept.
-    std::vector<std::string> BOARD_API_LEVEL_PROPS = {"ro.board.api_level",
-                                                      "ro.board.first_api_level"};
-    // Api level properties of the device. The order of the properties must be kept.
-    std::vector<std::string> DEVICE_API_LEVEL_PROPS = {"ro.product.first_api_level",
-                                                       "ro.build.version.sdk"};
+    auto vendor_api_level = GetIntProperty("ro.board.first_api_level", MAX_VENDOR_API_LEVEL);
+    if (vendor_api_level != MAX_VENDOR_API_LEVEL) {
+        // Update the vendor_api_level with "ro.board.api_level" only if both "ro.board.api_level"
+        // and "ro.board.first_api_level" are defined.
+        vendor_api_level = GetIntProperty("ro.board.api_level", vendor_api_level);
+    }
+
+    auto product_first_api_level =
+            GetIntProperty("ro.product.first_api_level", __ANDROID_API_FUTURE__);
+    if (product_first_api_level == __ANDROID_API_FUTURE__) {
+        // Fallback to "ro.build.version.sdk" if the "ro.product.first_api_level" is not defined.
+        product_first_api_level = GetIntProperty("ro.build.version.sdk", __ANDROID_API_FUTURE__);
+    }
+
+    vendor_api_level = std::min(vendor_api_level_of(product_first_api_level), vendor_api_level);
 
-    int api_level = std::min(read_api_level_props(BOARD_API_LEVEL_PROPS),
-                             read_api_level_props(DEVICE_API_LEVEL_PROPS));
     std::string error;
-    auto res = PropertySetNoSocket(VENDOR_API_LEVEL_PROP, std::to_string(api_level), &error);
+    auto res = PropertySetNoSocket(VENDOR_API_LEVEL_PROP, std::to_string(vendor_api_level), &error);
     if (res != PROP_SUCCESS) {
-        LOG(ERROR) << "Failed to set " << VENDOR_API_LEVEL_PROP << " with " << api_level << ": "
-                   << error << "(" << res << ")";
+        LOG(ERROR) << "Failed to set " << VENDOR_API_LEVEL_PROP << " with " << vendor_api_level
+                   << ": " << error << "(" << res << ")";
     }
 }
 

From c0ce178640144c5e2149e71b456a117ece855aac Mon Sep 17 00:00:00 2001
From: Android Culprit Assistant
 <boq-android-culprit-assistant@system.gserviceaccount.com>
Date: Fri, 8 Dec 2023 01:48:25 +0000
Subject: [PATCH 0611/1487] Revert "libprocessgroup: Use cgroup.kill"

This revert was created by Android Culprit Assistant. The culprit was identified in the following culprit search session (http://go/aca-get/91da3c52-9b76-498b-bdbd-a9de7d7ff53b).

Change-Id: I459265b9c9117d6006c1223947a202505d24c08f
---
 libprocessgroup/processgroup.cpp | 46 ++++++--------------------------
 1 file changed, 8 insertions(+), 38 deletions(-)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 4b49d09af474..7e27d75440d3 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -56,7 +56,6 @@ using android::base::WriteStringToFile;
 using namespace std::chrono_literals;
 
 #define PROCESSGROUP_CGROUP_PROCS_FILE "cgroup.procs"
-#define PROCESSGROUP_CGROUP_KILL_FILE "cgroup.kill"
 #define PROCESSGROUP_CGROUP_EVENTS_FILE "cgroup.events"
 
 bool CgroupsAvailable() {
@@ -78,29 +77,6 @@ bool CgroupGetControllerPath(const std::string& cgroup_name, std::string* path)
     return true;
 }
 
-static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
-    return StringPrintf("%s/uid_%u", cgroup, uid);
-}
-
-static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, int pid) {
-    return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
-}
-
-static bool CgroupKillAvailable() {
-    static std::once_flag f;
-    static bool cgroup_kill_available = false;
-    std::call_once(f, []() {
-        std::string cg_kill;
-        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &cg_kill);
-        // cgroup.kill is not on the root cgroup, so check a non-root cgroup that should always
-        // exist
-        cg_kill = ConvertUidToPath(cg_kill.c_str(), AID_ROOT) + '/' + PROCESSGROUP_CGROUP_KILL_FILE;
-        cgroup_kill_available = access(cg_kill.c_str(), F_OK) == 0;
-    });
-
-    return cgroup_kill_available;
-}
-
 static bool CgroupGetMemcgAppsPath(std::string* path) {
     CgroupController controller = CgroupMap::GetInstance().FindController("memory");
 
@@ -232,6 +208,14 @@ bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles) {
                                                        false);
 }
 
+static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
+    return StringPrintf("%s/uid_%u", cgroup, uid);
+}
+
+static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, int pid) {
+    return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
+}
+
 static int RemoveCgroup(const char* cgroup, uid_t uid, int pid) {
     auto path = ConvertUidPidToPath(cgroup, uid, pid);
     int ret = TEMP_FAILURE_RETRY(rmdir(path.c_str()));
@@ -378,20 +362,6 @@ bool sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
         CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
         cgroup_v2_path = ConvertUidPidToPath(hierarchy_root_path.c_str(), uid, initialPid);
 
-        if (signal == SIGKILL && CgroupKillAvailable()) {
-            LOG(VERBOSE) << "Using " << PROCESSGROUP_CGROUP_KILL_FILE << " to SIGKILL "
-                         << cgroup_v2_path;
-            const std::string killfilepath = cgroup_v2_path + '/' + PROCESSGROUP_CGROUP_KILL_FILE;
-            if (WriteStringToFile("1", killfilepath)) {
-                return true;
-            } else {
-                PLOG(ERROR) << "Failed to write 1 to " << killfilepath;
-                // Fallback to cgroup.procs below
-            }
-        }
-
-        // Since cgroup.kill only sends SIGKILLs, we read cgroup.procs to find each process to
-        // signal individually. This is more costly than using cgroup.kill for SIGKILLs.
         LOG(VERBOSE) << "Using " << PROCESSGROUP_CGROUP_PROCS_FILE << " to signal (" << signal
                      << ") " << cgroup_v2_path;
 

From a72332f9539f73043fe512346535cf595890d5a8 Mon Sep 17 00:00:00 2001
From: Android Culprit Assistant
 <boq-android-culprit-assistant@system.gserviceaccount.com>
Date: Fri, 8 Dec 2023 01:48:25 +0000
Subject: [PATCH 0612/1487] Revert "libprocessgroup: Poll on cgroup.events"

This revert was created by Android Culprit Assistant. The culprit was identified in the following culprit search session (http://go/aca-get/91da3c52-9b76-498b-bdbd-a9de7d7ff53b).

Change-Id: I996c595bee9acc15aedaf0a912f67fa027f33cd0
---
 .../include/processgroup/processgroup.h       |  10 +-
 libprocessgroup/processgroup.cpp              | 293 +++++++-----------
 2 files changed, 120 insertions(+), 183 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index ca6868c1b640..9107838b8629 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -65,8 +65,9 @@ bool UsePerAppMemcg();
 // should be active again. E.g. Zygote specialization for child process.
 void DropTaskProfilesResourceCaching();
 
-// Return 0 if all processes were killed and the cgroup was successfully removed.
-// Returns -1 in the case of an error occurring or if there are processes still running.
+// Return 0 and removes the cgroup if there are no longer any processes in it.
+// Returns -1 in the case of an error occurring or if there are processes still running
+// even after retrying for up to 200ms.
 int killProcessGroup(uid_t uid, int initialPid, int signal);
 
 // Returns the same as killProcessGroup(), however it does not retry, which means
@@ -75,9 +76,8 @@ int killProcessGroupOnce(uid_t uid, int initialPid, int signal);
 
 // Sends the provided signal to all members of a process group, but does not wait for processes to
 // exit, or for the cgroup to be removed. Callers should also ensure that killProcessGroup is called
-// later to ensure the cgroup is fully removed, otherwise system resources will leak.
-// Returns true if no errors are encountered sending signals, otherwise false.
-bool sendSignalToProcessGroup(uid_t uid, int initialPid, int signal);
+// later to ensure the cgroup is fully removed, otherwise system resources may leak.
+int sendSignalToProcessGroup(uid_t uid, int initialPid, int signal);
 
 int createProcessGroup(uid_t uid, int initialPid, bool memControl = false);
 
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 7e27d75440d3..f594f7f66354 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -22,7 +22,6 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
-#include <poll.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -31,7 +30,6 @@
 #include <unistd.h>
 
 #include <chrono>
-#include <cstring>
 #include <map>
 #include <memory>
 #include <mutex>
@@ -55,8 +53,7 @@ using android::base::WriteStringToFile;
 
 using namespace std::chrono_literals;
 
-#define PROCESSGROUP_CGROUP_PROCS_FILE "cgroup.procs"
-#define PROCESSGROUP_CGROUP_EVENTS_FILE "cgroup.events"
+#define PROCESSGROUP_CGROUP_PROCS_FILE "/cgroup.procs"
 
 bool CgroupsAvailable() {
     static bool cgroups_available = access("/proc/cgroups", F_OK) == 0;
@@ -216,21 +213,30 @@ static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, int pid) {
     return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
 }
 
-static int RemoveCgroup(const char* cgroup, uid_t uid, int pid) {
-    auto path = ConvertUidPidToPath(cgroup, uid, pid);
-    int ret = TEMP_FAILURE_RETRY(rmdir(path.c_str()));
+static int RemoveCgroup(const char* cgroup, uid_t uid, int pid, unsigned int retries) {
+    int ret = 0;
+    auto uid_pid_path = ConvertUidPidToPath(cgroup, uid, pid);
+
+    while (retries--) {
+        ret = rmdir(uid_pid_path.c_str());
+        // If we get an error 2 'No such file or directory' , that means the
+        // cgroup is already removed, treat it as success and return 0 for
+        // idempotency.
+        if (ret < 0 && errno == ENOENT) {
+            ret = 0;
+        }
+        if (!ret || errno != EBUSY || !retries) break;
+        std::this_thread::sleep_for(5ms);
+    }
 
     if (!ret && uid >= AID_ISOLATED_START && uid <= AID_ISOLATED_END) {
         // Isolated UIDs are unlikely to be reused soon after removal,
         // so free up the kernel resources for the UID level cgroup.
-        path = ConvertUidToPath(cgroup, uid);
-        ret = TEMP_FAILURE_RETRY(rmdir(path.c_str()));
-    }
-
-    if (ret < 0 && errno == ENOENT) {
-        // This function is idempoetent, but still warn here.
-        LOG(WARNING) << "RemoveCgroup: " << path << " does not exist.";
-        ret = 0;
+        const auto uid_path = ConvertUidToPath(cgroup, uid);
+        ret = rmdir(uid_path.c_str());
+        if (ret < 0 && errno == ENOENT) {
+            ret = 0;
+        }
     }
 
     return ret;
@@ -354,33 +360,38 @@ static bool MkdirAndChown(const std::string& path, mode_t mode, uid_t uid, gid_t
     return false;
 }
 
-bool sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
-    std::set<pid_t> pgids, pids;
+// Returns number of processes killed on success
+// Returns 0 if there are no processes in the process cgroup left to kill
+// Returns -1 on error
+static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid, int signal) {
+    // We separate all of the pids in the cgroup into those pids that are also the leaders of
+    // process groups (stored in the pgids set) and those that are not (stored in the pids set).
+    std::set<pid_t> pgids;
+    pgids.emplace(initialPid);
+    std::set<pid_t> pids;
+    int processes = 0;
+
+    std::unique_ptr<FILE, decltype(&fclose)> fd(nullptr, fclose);
 
     if (CgroupsAvailable()) {
-        std::string hierarchy_root_path, cgroup_v2_path;
-        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
-        cgroup_v2_path = ConvertUidPidToPath(hierarchy_root_path.c_str(), uid, initialPid);
-
-        LOG(VERBOSE) << "Using " << PROCESSGROUP_CGROUP_PROCS_FILE << " to signal (" << signal
-                     << ") " << cgroup_v2_path;
-
-        // We separate all of the pids in the cgroup into those pids that are also the leaders of
-        // process groups (stored in the pgids set) and those that are not (stored in the pids set).
-        const auto procsfilepath = cgroup_v2_path + '/' + PROCESSGROUP_CGROUP_PROCS_FILE;
-        std::unique_ptr<FILE, decltype(&fclose)> fp(fopen(procsfilepath.c_str(), "re"), fclose);
-        if (!fp) {
-            // This should only happen if the cgroup has already been removed with a successful call
-            // to killProcessGroup. Callers should only retry sendSignalToProcessGroup or
-            // killProcessGroup calls if they fail without ENOENT.
-            PLOG(ERROR) << "Failed to open " << procsfilepath;
-            kill(-initialPid, signal);
-            return false;
+        auto path = ConvertUidPidToPath(cgroup, uid, initialPid) + PROCESSGROUP_CGROUP_PROCS_FILE;
+        fd.reset(fopen(path.c_str(), "re"));
+        if (!fd) {
+            if (errno == ENOENT) {
+                // This happens when the process is already dead or if, as the result of a bug, it
+                // has been migrated to another cgroup. An example of a bug that can cause migration
+                // to another cgroup is using the JoinCgroup action with a cgroup controller that
+                // has been activated in the v2 cgroup hierarchy.
+                goto kill;
+            }
+            PLOG(WARNING) << __func__ << " failed to open process cgroup uid " << uid << " pid "
+                          << initialPid;
+            return -1;
         }
-
         pid_t pid;
         bool file_is_empty = true;
-        while (fscanf(fp.get(), "%d\n", &pid) == 1 && pid >= 0) {
+        while (fscanf(fd.get(), "%d\n", &pid) == 1 && pid >= 0) {
+            processes++;
             file_is_empty = false;
             if (pid == 0) {
                 // Should never happen...  but if it does, trying to kill this
@@ -410,8 +421,7 @@ bool sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
         }
     }
 
-    pgids.emplace(initialPid);
-
+kill:
     // Kill all process groups.
     for (const auto pgid : pgids) {
         LOG(VERBOSE) << "Killing process group " << -pgid << " in uid " << uid
@@ -432,174 +442,101 @@ bool sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
         }
     }
 
-    return true;
-}
-
-template <typename T>
-static std::chrono::milliseconds toMillisec(T&& duration) {
-    return std::chrono::duration_cast<std::chrono::milliseconds>(duration);
-}
-
-enum class populated_status
-{
-    populated,
-    not_populated,
-    error
-};
-
-static populated_status cgroupIsPopulated(int events_fd) {
-    const std::string POPULATED_KEY("populated ");
-    const std::string::size_type MAX_EVENTS_FILE_SIZE = 32;
-
-    std::string buf;
-    buf.resize(MAX_EVENTS_FILE_SIZE);
-    ssize_t len = TEMP_FAILURE_RETRY(pread(events_fd, buf.data(), buf.size(), 0));
-    if (len == -1) {
-        PLOG(ERROR) << "Could not read cgroup.events: ";
-        // Potentially ENODEV if the cgroup has been removed since we opened this file, but that
-        // shouldn't have happened yet.
-        return populated_status::error;
-    }
-
-    if (len == 0) {
-        LOG(ERROR) << "cgroup.events EOF";
-        return populated_status::error;
-    }
-
-    buf.resize(len);
-
-    const std::string::size_type pos = buf.find(POPULATED_KEY);
-    if (pos == std::string::npos) {
-        LOG(ERROR) << "Could not find populated key in cgroup.events";
-        return populated_status::error;
-    }
-
-    if (pos + POPULATED_KEY.size() + 1 > len) {
-        LOG(ERROR) << "Partial read of cgroup.events";
-        return populated_status::error;
-    }
-
-    return buf[pos + POPULATED_KEY.size()] == '1' ?
-        populated_status::populated : populated_status::not_populated;
+    return (!fd || feof(fd.get())) ? processes : -1;
 }
 
-// The default timeout of 2200ms comes from the default number of retries in a previous
-// implementation of this function. The default retry value was 40 for killing and 400 for cgroup
-// removal with 5ms sleeps between each retry.
-static int KillProcessGroup(
-        uid_t uid, int initialPid, int signal, bool once = false,
-        std::chrono::steady_clock::time_point until = std::chrono::steady_clock::now() + 2200ms) {
+static int KillProcessGroup(uid_t uid, int initialPid, int signal, int retries) {
     CHECK_GE(uid, 0);
     CHECK_GT(initialPid, 0);
 
-    // Always attempt to send a kill signal to at least the initialPid, at least once, regardless of
-    // whether its cgroup exists or not. This should only be necessary if a bug results in the
-    // migration of the targeted process out of its cgroup, which we will also attempt to kill.
-    const bool signal_ret = sendSignalToProcessGroup(uid, initialPid, signal);
-
-    if (!CgroupsAvailable() || !signal_ret) return signal_ret ? 0 : -1;
-
     std::string hierarchy_root_path;
-    CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
+    if (CgroupsAvailable()) {
+        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
+    }
+    const char* cgroup = hierarchy_root_path.c_str();
 
-    const std::string cgroup_v2_path =
-            ConvertUidPidToPath(hierarchy_root_path.c_str(), uid, initialPid);
+    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
 
-    const std::string eventsfile = cgroup_v2_path + '/' + PROCESSGROUP_CGROUP_EVENTS_FILE;
-    android::base::unique_fd events_fd(open(eventsfile.c_str(), O_RDONLY));
-    if (events_fd.get() == -1) {
-        PLOG(WARNING) << "Error opening " << eventsfile << " for KillProcessGroup";
-        return -1;
+    int retry = retries;
+    int processes;
+    while ((processes = DoKillProcessGroupOnce(cgroup, uid, initialPid, signal)) > 0) {
+        LOG(VERBOSE) << "Killed " << processes << " processes for processgroup " << initialPid;
+        if (!CgroupsAvailable()) {
+            // makes no sense to retry, because there are no cgroup_procs file
+            processes = 0;  // no remaining processes
+            break;
+        }
+        if (retry > 0) {
+            std::this_thread::sleep_for(5ms);
+            --retry;
+        } else {
+            break;
+        }
     }
 
-    struct pollfd fds = {
-        .fd = events_fd,
-        .events = POLLPRI,
-    };
-
-    const std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
-
-    // The primary reason to loop here is to capture any new forks or migrations that could occur
-    // after we send signals to the original set of processes, but before all of those processes
-    // exit and the cgroup becomes unpopulated, or before we remove the cgroup. We try hard to
-    // ensure this completes successfully to avoid permanent memory leaks, but we still place a
-    // large default upper bound on the amount of time we spend in this loop. The amount of CPU
-    // contention, and the amount of work that needs to be done in do_exit for each process
-    // determines how long this will take.
-    int ret;
-    do {
-        populated_status populated;
-        while ((populated = cgroupIsPopulated(events_fd.get())) == populated_status::populated &&
-               std::chrono::steady_clock::now() < until) {
-
-            sendSignalToProcessGroup(uid, initialPid, signal);
-            if (once) {
-                populated = cgroupIsPopulated(events_fd.get());
-                break;
-            }
-
-            const std::chrono::steady_clock::time_point poll_start =
-                    std::chrono::steady_clock::now();
+    if (processes < 0) {
+        PLOG(ERROR) << "Error encountered killing process cgroup uid " << uid << " pid "
+                    << initialPid;
+        return -1;
+    }
 
-            if (poll_start < until)
-                ret = TEMP_FAILURE_RETRY(poll(&fds, 1, toMillisec(until - poll_start).count()));
+    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
 
-            if (ret == -1) {
-                // Fallback to 5ms sleeps if poll fails
-                PLOG(ERROR) << "Poll on " << eventsfile << "failed";
-                const std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
-                if (now < until)
-                    std::this_thread::sleep_for(std::min(5ms, toMillisec(until - now)));
-            }
+    // We only calculate the number of 'processes' when killing the processes.
+    // In the retries == 0 case, we only kill the processes once and therefore
+    // will not have waited then recalculated how many processes are remaining
+    // after the first signals have been sent.
+    // Logging anything regarding the number of 'processes' here does not make sense.
 
-            LOG(VERBOSE) << "Waited "
-                         << toMillisec(std::chrono::steady_clock::now() - poll_start).count()
-                         << " ms for " << eventsfile << " poll";
+    if (processes == 0) {
+        if (retries > 0) {
+            LOG(INFO) << "Successfully killed process cgroup uid " << uid << " pid " << initialPid
+                      << " in " << static_cast<int>(ms) << "ms";
         }
 
-        const std::chrono::milliseconds kill_duration =
-                toMillisec(std::chrono::steady_clock::now() - start);
-
-        if (populated == populated_status::populated) {
-            LOG(WARNING) << "Still waiting on process(es) to exit for cgroup " << cgroup_v2_path
-                         << " after " << kill_duration.count() << " ms";
-            // We'll still try the cgroup removal below which we expect to log an error.
-        } else if (populated == populated_status::not_populated) {
-            LOG(VERBOSE) << "Killed all processes under cgroup " << cgroup_v2_path
-                         << " after " << kill_duration.count() << " ms";
+        if (!CgroupsAvailable()) {
+            // nothing to do here, if cgroups isn't available
+            return 0;
         }
 
-        ret = RemoveCgroup(hierarchy_root_path.c_str(), uid, initialPid);
-        if (ret)
-            PLOG(ERROR) << "Unable to remove cgroup " << cgroup_v2_path;
-        else
-            LOG(INFO) << "Removed cgroup " << cgroup_v2_path;
+        // 400 retries correspond to 2 secs max timeout
+        int err = RemoveCgroup(cgroup, uid, initialPid, 400);
 
         if (isMemoryCgroupSupported() && UsePerAppMemcg()) {
-            // This per-application memcg v1 case should eventually be removed after migration to
-            // memcg v2.
             std::string memcg_apps_path;
             if (CgroupGetMemcgAppsPath(&memcg_apps_path) &&
-                (ret = RemoveCgroup(memcg_apps_path.c_str(), uid, initialPid)) < 0) {
-                const auto memcg_v1_cgroup_path =
-                        ConvertUidPidToPath(memcg_apps_path.c_str(), uid, initialPid);
-                PLOG(ERROR) << "Unable to remove memcg v1 cgroup " << memcg_v1_cgroup_path;
+                RemoveCgroup(memcg_apps_path.c_str(), uid, initialPid, 400) < 0) {
+                return -1;
             }
         }
 
-        if (once) break;
-        if (std::chrono::steady_clock::now() >= until) break;
-    } while (ret && errno == EBUSY);
-
-    return ret;
+        return err;
+    } else {
+        if (retries > 0) {
+            LOG(ERROR) << "Failed to kill process cgroup uid " << uid << " pid " << initialPid
+                       << " in " << static_cast<int>(ms) << "ms, " << processes
+                       << " processes remain";
+        }
+        return -1;
+    }
 }
 
 int killProcessGroup(uid_t uid, int initialPid, int signal) {
-    return KillProcessGroup(uid, initialPid, signal);
+    return KillProcessGroup(uid, initialPid, signal, 40 /*retries*/);
 }
 
 int killProcessGroupOnce(uid_t uid, int initialPid, int signal) {
-    return KillProcessGroup(uid, initialPid, signal, true);
+    return KillProcessGroup(uid, initialPid, signal, 0 /*retries*/);
+}
+
+int sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
+    std::string hierarchy_root_path;
+    if (CgroupsAvailable()) {
+        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
+    }
+    const char* cgroup = hierarchy_root_path.c_str();
+    return DoKillProcessGroupOnce(cgroup, uid, initialPid, signal);
 }
 
 static int createProcessGroupInternal(uid_t uid, int initialPid, std::string cgroup,
@@ -639,7 +576,7 @@ static int createProcessGroupInternal(uid_t uid, int initialPid, std::string cgr
         return -errno;
     }
 
-    auto uid_pid_procs_file = uid_pid_path + '/' + PROCESSGROUP_CGROUP_PROCS_FILE;
+    auto uid_pid_procs_file = uid_pid_path + PROCESSGROUP_CGROUP_PROCS_FILE;
 
     if (!WriteStringToFile(std::to_string(initialPid), uid_pid_procs_file)) {
         ret = -errno;

From e20438f83b17c42d7468e388c3025a195b5093c1 Mon Sep 17 00:00:00 2001
From: Dmitrii Merkurev <dimorinny@google.com>
Date: Sat, 9 Dec 2023 01:55:20 +0000
Subject: [PATCH 0613/1487] fastboot: fix network connected device status

Bug: 303236495
Change-Id: Iceac3509531af1af65b455b1a3d5f5ab9029fda6
Signed-off-by: Dmitrii Merkurev <dimorinny@google.com>
---
 fastboot/fastboot.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index ac2a20f90c80..1bc7b7513aed 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -402,7 +402,7 @@ static std::unique_ptr<Transport> NetworkDeviceConnected(bool print = false) {
         transport = open_device(device.c_str(), false, false);
 
         if (print) {
-            PrintDevice(device.c_str(), transport ? "offline" : "fastboot");
+            PrintDevice(device.c_str(), transport ? "fastboot" : "offline");
         }
 
         if (transport) {

From 303a54124817c605bf79ceed0caee3858790e14b Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 17 Nov 2023 20:32:13 -0800
Subject: [PATCH 0614/1487] Update storaged to use Health AIDL HAL V3.

Bug: 309792384
Test: m
Change-Id: Ib11dd9b39e5feec864f881118f16dad902813379
---
 storaged/Android.bp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/storaged/Android.bp b/storaged/Android.bp
index fe8c1f3b4e7e..357c0e601ed3 100644
--- a/storaged/Android.bp
+++ b/storaged/Android.bp
@@ -24,7 +24,7 @@ cc_defaults {
     shared_libs: [
         "android.hardware.health@1.0",
         "android.hardware.health@2.0",
-        "android.hardware.health-V2-ndk",
+        "android.hardware.health-V3-ndk",
         "libbase",
         "libbinder",
         "libbinder_ndk",

From d473bcf1ab6cf560d55b1c9c5dd8f7ed2e00cca6 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 17 Nov 2023 20:33:25 -0800
Subject: [PATCH 0615/1487] Update healthd to use Health AIDL HAL V3.

Bug: 309792384
Test: m
Change-Id: Ic92e4d699ee49284fea490d48e963555173033d7
---
 healthd/Android.bp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/healthd/Android.bp b/healthd/Android.bp
index 235303fd32a7..427ac48ba050 100644
--- a/healthd/Android.bp
+++ b/healthd/Android.bp
@@ -76,7 +76,7 @@ cc_library_static {
     defaults: ["libbatterymonitor_defaults"],
     srcs: ["BatteryMonitor.cpp"],
     static_libs: [
-        "android.hardware.health-V2-ndk",
+        "android.hardware.health-V3-ndk",
     ],
     whole_static_libs: [
         // Need to translate HIDL to AIDL to support legacy APIs in
@@ -203,12 +203,12 @@ cc_library_static {
     defaults: ["libhealthd_charger_ui_defaults"],
 
     static_libs: [
-        "android.hardware.health-V2-ndk",
+        "android.hardware.health-V3-ndk",
         "android.hardware.health-translate-ndk",
     ],
 
     export_static_lib_headers: [
-        "android.hardware.health-V2-ndk",
+        "android.hardware.health-V3-ndk",
     ],
 }
 
@@ -280,7 +280,7 @@ cc_defaults {
     static_libs: [
         // common
         "android.hardware.health@1.0-convert",
-        "android.hardware.health-V2-ndk",
+        "android.hardware.health-V3-ndk",
         "libbatterymonitor",
         "libcharger_sysprop",
         "libhealthd_charger_nops",

From 9305c988b3609e54a44460c37bc37952bce94ac5 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 17 Nov 2023 20:40:33 -0800
Subject: [PATCH 0616/1487] Update fastbootd to use Health AIDL HAL V3.

Bug: 309792384
Test: m
Change-Id: I660228c89cf18b46ea6c8165a4a74d20c0a2ac41
---
 fastboot/Android.bp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fastboot/Android.bp b/fastboot/Android.bp
index f85d1dea4427..c0445f359f08 100644
--- a/fastboot/Android.bp
+++ b/fastboot/Android.bp
@@ -170,7 +170,7 @@ cc_binary {
         "android.hardware.fastboot@1.1",
         "android.hardware.fastboot-V1-ndk",
         "android.hardware.health@2.0",
-        "android.hardware.health-V2-ndk",
+        "android.hardware.health-V3-ndk",
         "libasyncio",
         "libbase",
         "libbinder_ndk",

From 2cb36706f40a7afac9159126a97421b37e2ef8dc Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 7 Dec 2023 20:51:08 -0800
Subject: [PATCH 0617/1487] fastboot: Add getvar commands to query battery part
 info.

This adds two commands to test the new v3 Health HAL, to query the
battery serial number (unlocked devices only) and part status.

Bug: 309792384
Test: adb reboot fastboot
      fastboot getvar battery-part-status
      fastboot getvar battery-serial-number
Change-Id: Ie0a14eda06483d047544833124c327fb88ba43a2
---
 fastboot/constants.h          |  2 +
 fastboot/device/commands.cpp  |  2 +
 fastboot/device/variables.cpp | 76 +++++++++++++++++++++++++++++++++++
 fastboot/device/variables.h   |  4 ++
 4 files changed, 84 insertions(+)

diff --git a/fastboot/constants.h b/fastboot/constants.h
index a803307466da..af4d1eb1231d 100644
--- a/fastboot/constants.h
+++ b/fastboot/constants.h
@@ -82,3 +82,5 @@
 #define FB_VAR_TREBLE_ENABLED "treble-enabled"
 #define FB_VAR_MAX_FETCH_SIZE "max-fetch-size"
 #define FB_VAR_DMESG "dmesg"
+#define FB_VAR_BATTERY_SERIAL_NUMBER "battery-serial-number"
+#define FB_VAR_BATTERY_PART_STATUS "battery-part-status"
diff --git a/fastboot/device/commands.cpp b/fastboot/device/commands.cpp
index bd936ae771dc..e522f4d4d3ff 100644
--- a/fastboot/device/commands.cpp
+++ b/fastboot/device/commands.cpp
@@ -147,6 +147,8 @@ const std::unordered_map<std::string, VariableHandlers> kVariableMap = {
         {FB_VAR_SECURITY_PATCH_LEVEL, {GetSecurityPatchLevel, nullptr}},
         {FB_VAR_TREBLE_ENABLED, {GetTrebleEnabled, nullptr}},
         {FB_VAR_MAX_FETCH_SIZE, {GetMaxFetchSize, nullptr}},
+        {FB_VAR_BATTERY_SERIAL_NUMBER, {GetBatterySerialNumber, nullptr}},
+        {FB_VAR_BATTERY_PART_STATUS, {GetBatteryPartStatus, nullptr}},
 };
 
 static bool GetVarAll(FastbootDevice* device) {
diff --git a/fastboot/device/variables.cpp b/fastboot/device/variables.cpp
index 2847e35ab6ad..77210abcbc15 100644
--- a/fastboot/device/variables.cpp
+++ b/fastboot/device/variables.cpp
@@ -570,3 +570,79 @@ bool GetDmesg(FastbootDevice* device) {
 
     return true;
 }
+
+bool GetBatterySerialNumber(FastbootDevice* device, const std::vector<std::string>&,
+                            std::string* message) {
+    auto health_hal = device->health_hal();
+    if (!health_hal) {
+        return false;
+    }
+
+    if (GetDeviceLockStatus()) {
+        return device->WriteFail("Device is locked");
+    }
+
+    *message = "unsupported";
+
+    int32_t version = 0;
+    auto res = health_hal->getInterfaceVersion(&version);
+    if (!res.isOk()) {
+        return device->WriteFail("Unable to query battery data");
+    }
+    if (version >= 3) {
+        using aidl::android::hardware::health::BatteryHealthData;
+
+        BatteryHealthData data;
+        auto res = health_hal->getBatteryHealthData(&data);
+        if (!res.isOk()) {
+            return device->WriteFail("Unable to query battery data");
+        }
+        if (data.batterySerialNumber) {
+            *message = *data.batterySerialNumber;
+        }
+    }
+    return true;
+}
+
+bool GetBatteryPartStatus(FastbootDevice* device, const std::vector<std::string>&,
+                          std::string* message) {
+    auto health_hal = device->health_hal();
+    if (!health_hal) {
+        return false;
+    }
+
+    using aidl::android::hardware::health::BatteryPartStatus;
+
+    BatteryPartStatus status = BatteryPartStatus::UNSUPPORTED;
+
+    int32_t version = 0;
+    auto res = health_hal->getInterfaceVersion(&version);
+    if (!res.isOk()) {
+        return device->WriteFail("Unable to query battery data");
+    }
+    if (version >= 3) {
+        using aidl::android::hardware::health::BatteryHealthData;
+
+        BatteryHealthData data;
+        auto res = health_hal->getBatteryHealthData(&data);
+        if (!res.isOk()) {
+            return device->WriteFail("Unable to query battery data");
+        }
+        status = data.batteryPartStatus;
+    }
+    switch (status) {
+        case BatteryPartStatus::UNSUPPORTED:
+            *message = "unsupported";
+            break;
+        case BatteryPartStatus::ORIGINAL:
+            *message = "original";
+            break;
+        case BatteryPartStatus::REPLACED:
+            *message = "replaced";
+            break;
+        default:
+            *message = "unknown";
+            break;
+    }
+    return true;
+}
diff --git a/fastboot/device/variables.h b/fastboot/device/variables.h
index 9a46786410b9..99d1355ef6b2 100644
--- a/fastboot/device/variables.h
+++ b/fastboot/device/variables.h
@@ -67,6 +67,10 @@ bool GetBatterySoC(FastbootDevice* device, const std::vector<std::string>& args,
                    std::string* message);
 bool GetBatterySoCOk(FastbootDevice* device, const std::vector<std::string>& args,
                      std::string* message);
+bool GetBatterySerialNumber(FastbootDevice* device, const std::vector<std::string>& args,
+                            std::string* message);
+bool GetBatteryPartStatus(FastbootDevice* device, const std::vector<std::string>& args,
+                          std::string* message);
 bool GetSuperPartitionName(FastbootDevice* device, const std::vector<std::string>& args,
                            std::string* message);
 bool GetSnapshotUpdateStatus(FastbootDevice* device, const std::vector<std::string>& args,

From d5ed26a45ab400c44a1eff6fc31be55a82ed8ba9 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 8 Dec 2023 15:12:24 -0800
Subject: [PATCH 0618/1487] healthd: Add support for the new Health HAL v3
 properties.

Add BATTERY_PROP_PART_STATUS support via getProperty.

Add serial number support via a new helper function, since it doesn't
fit neatly into the BatteryProperty structure.

There are no sysfs nodes for this yet, so currently it is stubbed.

Bug: 309792384
Test: fastboot getvar battery-part-status
      fastboot getvar battery-serial-number
Change-Id: I3777e092d4ef26c02a7dd5420c9eaf1ec5aeae92
---
 healthd/BatteryMonitor.cpp               | 14 ++++++++++++++
 healthd/include/healthd/BatteryMonitor.h |  3 +++
 2 files changed, 17 insertions(+)

diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index 0c976322d2cd..efd9907df9d3 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -59,6 +59,7 @@ using aidl::android::hardware::health::BatteryChargingPolicy;
 using aidl::android::hardware::health::BatteryChargingState;
 using aidl::android::hardware::health::BatteryHealth;
 using aidl::android::hardware::health::BatteryHealthData;
+using aidl::android::hardware::health::BatteryPartStatus;
 using aidl::android::hardware::health::BatteryStatus;
 using aidl::android::hardware::health::HealthInfo;
 
@@ -596,6 +597,9 @@ int BatteryMonitor::getBatteryHealthData(int id) {
         if (!mHealthdConfig->batteryStateOfHealthPath.empty())
             return getIntField(mHealthdConfig->batteryStateOfHealthPath);
     }
+    if (id == BATTERY_PROP_PART_STATUS) {
+        return static_cast<int>(BatteryPartStatus::UNSUPPORTED);
+    }
     return 0;
 }
 
@@ -679,6 +683,11 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
         ret = OK;
         break;
 
+    case BATTERY_PROP_PART_STATUS:
+        val->valueInt64 = getBatteryHealthData(BATTERY_PROP_PART_STATUS);
+        ret = OK;
+        break;
+
     default:
         break;
     }
@@ -686,6 +695,11 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) {
     return ret;
 }
 
+status_t BatteryMonitor::getSerialNumber(std::optional<std::string>* out) {
+    *out = std::nullopt;
+    return OK;
+}
+
 void BatteryMonitor::dumpState(int fd) {
     int v;
     char vs[128];
diff --git a/healthd/include/healthd/BatteryMonitor.h b/healthd/include/healthd/BatteryMonitor.h
index e9998ba7a3af..b30458d3cc49 100644
--- a/healthd/include/healthd/BatteryMonitor.h
+++ b/healthd/include/healthd/BatteryMonitor.h
@@ -18,6 +18,7 @@
 #define HEALTHD_BATTERYMONITOR_H
 
 #include <memory>
+#include <optional>
 
 #include <batteryservice/BatteryService.h>
 #include <utils/String8.h>
@@ -86,6 +87,8 @@ class BatteryMonitor {
     int getChargingPolicy();
     int getBatteryHealthData(int id);
 
+    status_t getSerialNumber(std::optional<std::string>* out);
+
     static void logValues(const android::hardware::health::V2_1::HealthInfo& health_info,
                           const struct healthd_config& healthd_config);
 

From 629a26b6c57d3558806f1a8b62300201a44694e4 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 11 Dec 2023 15:25:13 -0800
Subject: [PATCH 0619/1487] healthd: Add handling for "Calibration required"
 battery health.

This string was added to sysfs fairly recently. It indicates that
re-calibration is needed, which we've already added an indicator for via
the INCONSISTENT health status.

Bug: 300585313
Test: m
Change-Id: I9594523e509ad94480ad13f489eee6d1c0a75e7e
---
 healthd/BatteryMonitor.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index efd9907df9d3..b8bb58682a2e 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -220,6 +220,7 @@ BatteryHealth getBatteryHealth(const char* status) {
             {"Warm", BatteryHealth::GOOD},
             {"Cool", BatteryHealth::GOOD},
             {"Hot", BatteryHealth::OVERHEAT},
+            {"Calibration required", BatteryHealth::INCONSISTENT},
             {NULL, BatteryHealth::UNKNOWN},
     };
 

From edd04f1b3864999816b9cb6c7c072dbf58e4789c Mon Sep 17 00:00:00 2001
From: Yi Kong <yikong@google.com>
Date: Tue, 12 Dec 2023 16:35:07 +0900
Subject: [PATCH 0620/1487] Revert "snapuserd: opt out of Global ThinLTO to
 workaround segfault"

This reverts commit 9d0c06d3e203b8bdb6710332dc59f51948788e01.

The failure is fixed by https://r.android.com/2725997. Workaround no
longer needed.

Test: manual
Bug: 208565717
Bug: 295944813
Change-Id: I83638938bf52a4b2b1e72743f892c579622ba9e6
---
 fs_mgr/libsnapshot/snapuserd/Android.bp | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 1b0c5639ee92..6b8e084170b7 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -147,12 +147,6 @@ cc_defaults {
     // snapuserd, which would lead to deadlock if we had to handle page
     // faults for its code pages.
     static_executable: true,
-
-    // Snapuserd segfaults with ThinLTO
-    // http://b/208565717
-    lto: {
-         never: true,
-    },
 }
 
 cc_binary {

From cb3cfc1655f91e495a32ea5b438c77af7c9b3f64 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Mon, 11 Dec 2023 11:14:48 -0800
Subject: [PATCH 0621/1487] Optimize PrepareSnapshotPartitionsForUpdate runtime

During PrepareSnapshotPartitionsForUpdate, we attempt to connect to
snapuserd with a 5s timeout, only to tell snapuserd to shutdown
immediately. If snapuserd isn't running, we will wait-out the whole 5
seconds. Change the logic to return early if socket_connect() calls
return ENOENT, indicating that snapuserd socket isn't used by any
process. This reduces allocateSpaceForPayload() time from 6s to 1s.

Test: th
Bug: 315215541
Change-Id: Ib24d7c63733a896c082ac92aaa88ad52d050a2a5
---
 fs_mgr/libsnapshot/snapshot.cpp               |  4 +--
 .../include/snapuserd/snapuserd_client.h      | 11 +++---
 .../snapuserd/snapuserd_client.cpp            | 36 ++++++++++++++++++-
 init/first_stage_init.cpp                     |  1 +
 init/snapuserd_transition.cpp                 |  1 +
 5 files changed, 45 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index f6a35a8f5dc0..e33bdfff8585 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -3330,7 +3330,7 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
         // Terminate stale daemon if any
         std::unique_ptr<SnapuserdClient> snapuserd_client = std::move(snapuserd_client_);
         if (!snapuserd_client) {
-            snapuserd_client = SnapuserdClient::Connect(kSnapuserdSocket, 5s);
+            snapuserd_client = SnapuserdClient::TryConnect(kSnapuserdSocket, 5s);
         }
         if (snapuserd_client) {
             snapuserd_client->DetachSnapuserd();
@@ -3661,7 +3661,7 @@ std::unique_ptr<ICowWriter> SnapshotManager::OpenCompressedSnapshotWriter(
     cow_options.compression = status.compression_algorithm();
     cow_options.max_blocks = {status.device_size() / cow_options.block_size};
     cow_options.batch_write = status.batched_writes();
-    cow_options.num_compress_threads = status.enable_threading() ? 2 : 0;
+    cow_options.num_compress_threads = status.enable_threading() ? 2 : 1;
     // TODO(b/313962438) Improve op_count estimate. For now, use number of
     // blocks as an upper bound.
     cow_options.op_count_max = status.device_size() / cow_options.block_size;
diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h
index 010beb3f2f2f..ede92dd973b4 100644
--- a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h
@@ -17,11 +17,7 @@
 #include <unistd.h>
 
 #include <chrono>
-#include <cstring>
-#include <iostream>
 #include <string>
-#include <thread>
-#include <vector>
 
 #include <android-base/unique_fd.h>
 
@@ -53,9 +49,14 @@ class SnapuserdClient {
     explicit SnapuserdClient(android::base::unique_fd&& sockfd);
     SnapuserdClient(){};
 
+    // Attempt to connect to snapsuerd, wait for the daemon to start if
+    // connection failed.
     static std::unique_ptr<SnapuserdClient> Connect(const std::string& socket_name,
                                                     std::chrono::milliseconds timeout_ms);
-
+    // Attempt to connect to snapsuerd, but does not wait for the daemon to
+    // start.
+    static std::unique_ptr<SnapuserdClient> TryConnect(const std::string& socket_name,
+                                                       std::chrono::milliseconds timeout_ms);
     bool StopSnapuserd();
 
     // Initializing a snapuserd handler is a three-step process:
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
index 3bed3a4a47dc..789c98071737 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
@@ -27,7 +27,7 @@
 #include <unistd.h>
 
 #include <chrono>
-#include <sstream>
+#include <thread>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
@@ -64,6 +64,40 @@ static inline bool IsRetryErrno() {
     return errno == ECONNREFUSED || errno == EINTR || errno == ENOENT;
 }
 
+std::unique_ptr<SnapuserdClient> SnapuserdClient::TryConnect(const std::string& socket_name,
+                                                             std::chrono::milliseconds timeout_ms) {
+    unique_fd fd;
+    const auto start = std::chrono::steady_clock::now();
+    while (true) {
+        fd.reset(TEMP_FAILURE_RETRY(socket_local_client(
+                socket_name.c_str(), ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM)));
+        if (fd >= 0) {
+            auto client = std::make_unique<SnapuserdClient>(std::move(fd));
+            if (!client->ValidateConnection()) {
+                return nullptr;
+            }
+            return client;
+        }
+        if (errno == ENOENT) {
+            LOG(INFO) << "Daemon socket " << socket_name
+                      << " does not exist, return without waiting.";
+            return nullptr;
+        }
+        if (errno == ECONNREFUSED) {
+            const auto now = std::chrono::steady_clock::now();
+            const auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - start);
+            if (elapsed >= timeout_ms) {
+                LOG(ERROR) << "Timed out connecting to snapuserd socket: " << socket_name;
+                return nullptr;
+            }
+            std::this_thread::sleep_for(10ms);
+        } else {
+            PLOG(ERROR) << "connect failed: " << socket_name;
+            return nullptr;
+        }
+    }
+}
+
 std::unique_ptr<SnapuserdClient> SnapuserdClient::Connect(const std::string& socket_name,
                                                           std::chrono::milliseconds timeout_ms) {
     unique_fd fd;
diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index e48fa155420f..c4d0f758dd2a 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -30,6 +30,7 @@
 #include <chrono>
 #include <filesystem>
 #include <string>
+#include <thread>
 #include <vector>
 
 #include <android-base/chrono_utils.h>
diff --git a/init/snapuserd_transition.cpp b/init/snapuserd_transition.cpp
index 3a9ff5bd713d..3a783434a5e3 100644
--- a/init/snapuserd_transition.cpp
+++ b/init/snapuserd_transition.cpp
@@ -25,6 +25,7 @@
 #include <filesystem>
 #include <string>
 #include <string_view>
+#include <thread>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>

From 4ffbc33b14ad45a225fbca2756891a2db2744c43 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 12 Dec 2023 14:12:49 -0800
Subject: [PATCH 0622/1487] libsnapshot: skip connecting to daemon for legacy
 VAB

There is no need to connect to daemon for legacy VAB.

Bug: 311900089
Test: treehugger - presubmit

Change-Id: I2256cee611431ab2a286730c61092d2c546caf1e
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshot_test.cpp | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 4e6b5e1033bd..c0c3eafa3356 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2362,8 +2362,10 @@ TEST_F(SnapshotUpdateTest, AddPartition) {
     auto init = NewManagerForFirstStageMount("_b");
     ASSERT_NE(init, nullptr);
 
-    ASSERT_TRUE(init->EnsureSnapuserdConnected());
-    init->set_use_first_stage_snapuserd(true);
+    if (snapuserd_required_) {
+        ASSERT_TRUE(init->EnsureSnapuserdConnected());
+        init->set_use_first_stage_snapuserd(true);
+    }
 
     ASSERT_TRUE(init->NeedSnapshotsInFirstStageMount());
     ASSERT_TRUE(init->CreateLogicalAndSnapshotPartitions("super", snapshot_timeout_));
@@ -2374,9 +2376,11 @@ TEST_F(SnapshotUpdateTest, AddPartition) {
         ASSERT_TRUE(IsPartitionUnchanged(name));
     }
 
-    ASSERT_TRUE(init->PerformInitTransition(SnapshotManager::InitTransition::SECOND_STAGE));
-    for (const auto& name : partitions) {
-        ASSERT_TRUE(init->snapuserd_client()->WaitForDeviceDelete(name + "-user-cow-init"));
+    if (snapuserd_required_) {
+        ASSERT_TRUE(init->PerformInitTransition(SnapshotManager::InitTransition::SECOND_STAGE));
+        for (const auto& name : partitions) {
+            ASSERT_TRUE(init->snapuserd_client()->WaitForDeviceDelete(name + "-user-cow-init"));
+        }
     }
 
     // Initiate the merge and wait for it to be completed.

From cdf55585a788d5b7ad4e4804046549c54d5c1791 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Wed, 13 Dec 2023 22:21:16 +0000
Subject: [PATCH 0623/1487] Use correct stack depot size in __scudo_get_error

This is a no-op but will be used in upcoming scudo changes that allow to
change the depot size at process startup time, and as such we will no
longer be able to call __scudo_get_stack_depot_size in debuggerd.

Bug: 309446692
Change-Id: Ib64b9d042b2a2088484ec5e61944c089a1d85314
---
 debuggerd/libdebuggerd/scudo.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/debuggerd/libdebuggerd/scudo.cpp b/debuggerd/libdebuggerd/scudo.cpp
index cff43f8d5ae9..3fa3bd032585 100644
--- a/debuggerd/libdebuggerd/scudo.cpp
+++ b/debuggerd/libdebuggerd/scudo.cpp
@@ -81,7 +81,7 @@ ScudoCrashData::ScudoCrashData(unwindstack::Memory* process_memory,
   }
 
   __scudo_get_error_info(&error_info_, process_info.maybe_tagged_fault_address, stack_depot.get(),
-                         __scudo_get_stack_depot_size(), region_info.get(), ring_buffer.get(),
+                         process_info.scudo_stack_depot_size, region_info.get(), ring_buffer.get(),
                          process_info.scudo_ring_buffer_size, memory.get(), memory_tags.get(),
                          memory_begin, memory_end - memory_begin);
 }

From 557104c85ad553d6360238baac85656071e324b5 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 7 Dec 2023 14:04:02 -0800
Subject: [PATCH 0624/1487] Support batch writes for V3 cow format

Test: th
Bug: 313962438
Change-Id: If3a01ab85a1a649b7476bee2d56b732f04d0509a
---
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 103 +++++++++++-------
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |   5 +-
 2 files changed, 70 insertions(+), 38 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 4df0e76ec3f5..de097f5b061f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -38,6 +38,7 @@
 #include <linux/fs.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
+#include <numeric>
 
 // The info messages here are spammy, but as useful for update_engine. Disable
 // them when running on the host.
@@ -55,7 +56,7 @@ static_assert(sizeof(off_t) == sizeof(uint64_t));
 using android::base::unique_fd;
 
 CowWriterV3::CowWriterV3(const CowOptions& options, unique_fd&& fd)
-    : CowWriterBase(options, std::move(fd)) {
+    : CowWriterBase(options, std::move(fd)), batch_size_(std::max<size_t>(options.cluster_ops, 1)) {
     SetupHeaders();
 }
 
@@ -70,6 +71,9 @@ void CowWriterV3::SetupHeaders() {
     header_.block_size = options_.block_size;
     header_.num_merge_ops = options_.num_merge_ops;
     header_.cluster_ops = 0;
+    if (batch_size_ > 1) {
+        LOG(INFO) << "Batch writes enabled with batch size of " << batch_size_;
+    }
     if (options_.scratch_space) {
         header_.buffer_size = BUFFER_REGION_DEFAULT_SIZE;
     }
@@ -258,40 +262,49 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
             }
             op.data_length = header_.block_size;
         }
-        return WriteOperation({ops.data(), ops.size()},
-                              {reinterpret_cast<const uint8_t*>(data), size});
+        return WriteOperation({ops.data(), ops.size()}, data, size);
     }
 
-    const auto saved_op_count = header_.op_count;
-    const auto saved_data_pos = next_data_pos_;
-    for (size_t i = 0; i < num_blocks; i++) {
-        const uint8_t* const iter =
-                reinterpret_cast<const uint8_t*>(data) + (header_.block_size * i);
-
-        CowOperation op{};
-        op.new_block = new_block_start + i;
+    for (size_t i = 0; i < num_blocks; i += batch_size_) {
+        const auto blocks_to_write = std::min<size_t>(batch_size_, num_blocks - i);
+        std::vector<std::basic_string<uint8_t>> compressed_blocks(blocks_to_write);
+        std::vector<CowOperationV3> ops(blocks_to_write);
+        std::vector<struct iovec> vec(blocks_to_write);
+        size_t compressed_bytes = 0;
+        for (size_t j = 0; j < blocks_to_write; j++) {
+            const uint8_t* const iter =
+                    reinterpret_cast<const uint8_t*>(data) + (header_.block_size * (i + j));
 
-        op.set_type(type);
-        if (type == kCowXorOp) {
-            op.set_source((old_block + i) * header_.block_size + offset);
-        } else {
-            op.set_source(next_data_pos_);
-        }
-        const void* out_data = iter;
+            CowOperation& op = ops[j];
+            op.new_block = new_block_start + i + j;
 
-        op.data_length = header_.block_size;
+            op.set_type(type);
+            if (type == kCowXorOp) {
+                op.set_source((old_block + i + j) * header_.block_size + offset);
+            } else {
+                op.set_source(next_data_pos_ + compressed_bytes);
+            }
 
-        const std::basic_string<uint8_t> compressed_data =
-                compressor_->Compress(out_data, header_.block_size);
-        if (compressed_data.size() < op.data_length) {
-            out_data = compressed_data.data();
-            op.data_length = compressed_data.size();
+            std::basic_string<uint8_t> compressed_data =
+                    compressor_->Compress(iter, header_.block_size);
+            if (compressed_data.empty()) {
+                LOG(ERROR) << "Compression failed during EmitBlocks(" << new_block_start << ", "
+                           << num_blocks << ");";
+                return false;
+            }
+            if (compressed_data.size() >= header_.block_size) {
+                compressed_data.resize(header_.block_size);
+                std::memcpy(compressed_data.data(), iter, header_.block_size);
+            }
+            compressed_blocks[j] = std::move(compressed_data);
+            vec[j] = {.iov_base = compressed_blocks[j].data(),
+                      .iov_len = compressed_blocks[j].size()};
+            op.data_length = vec[j].iov_len;
+            compressed_bytes += op.data_length;
         }
-        if (!WriteOperation(op, out_data, op.data_length)) {
+        if (!WriteOperation({ops.data(), ops.size()}, {vec.data(), vec.size()})) {
             PLOG(ERROR) << "AddRawBlocks with compression: write failed. new block: "
                         << new_block_start << " compression: " << compression_.algorithm;
-            header_.op_count = saved_op_count;
-            next_data_pos_ = saved_data_pos;
             return false;
         }
     }
@@ -299,14 +312,14 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
     return true;
 }
 
-bool CowWriterV3::EmitZeroBlocks(uint64_t new_block_start, uint64_t num_blocks) {
+bool CowWriterV3::EmitZeroBlocks(uint64_t new_block_start, const uint64_t num_blocks) {
     std::vector<CowOperationV3> ops(num_blocks);
-    for (uint64_t i = 0; i < num_blocks; i++) {
-        CowOperationV3& op = ops[i];
+    for (uint64_t i = 0; i < ops.size(); i++) {
+        auto& op = ops[i];
         op.set_type(kCowZeroOp);
         op.new_block = new_block_start + i;
     }
-    if (!WriteOperation({ops.data(), ops.size()}, {})) {
+    if (!WriteOperation({ops.data(), ops.size()})) {
         return false;
     }
     return true;
@@ -353,8 +366,23 @@ bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
     return true;
 }
 
+bool CowWriterV3::WriteOperation(std::basic_string_view<CowOperationV3> op, const void* data,
+                                 size_t size) {
+    struct iovec vec {
+        .iov_len = size
+    };
+    // Dear C++ god, this is effectively a const_cast. I had to do this because
+    // pwritev()'s struct iovec requires a non-const pointer. The input data
+    // will not be modified, as the iovec is only used for a write operation.
+    std::memcpy(&vec.iov_base, &data, sizeof(data));
+    return WriteOperation(op, {&vec, 1});
+}
+
 bool CowWriterV3::WriteOperation(std::basic_string_view<CowOperationV3> ops,
-                                 std::basic_string_view<uint8_t> data) {
+                                 std::basic_string_view<struct iovec> data) {
+    const auto total_data_size =
+            std::transform_reduce(data.begin(), data.end(), 0, std::plus<size_t>{},
+                                  [](const struct iovec& a) { return a.iov_len; });
     if (IsEstimating()) {
         header_.op_count += ops.size();
         if (header_.op_count > header_.op_count_max) {
@@ -363,7 +391,7 @@ bool CowWriterV3::WriteOperation(std::basic_string_view<CowOperationV3> ops,
             next_data_pos_ += (header_.op_count - header_.op_count_max) * sizeof(CowOperationV3);
             header_.op_count_max = header_.op_count;
         }
-        next_data_pos_ += data.size();
+        next_data_pos_ += total_data_size;
         return true;
     }
 
@@ -379,20 +407,21 @@ bool CowWriterV3::WriteOperation(std::basic_string_view<CowOperationV3> ops,
         return false;
     }
     if (!data.empty()) {
-        if (!android::base::WriteFullyAtOffset(fd_, data.data(), data.size(), next_data_pos_)) {
+        const auto ret = pwritev(fd_, data.data(), data.size(), next_data_pos_);
+        if (ret != total_data_size) {
             PLOG(ERROR) << "write failed for data of size: " << data.size()
-                        << " at offset: " << next_data_pos_;
+                        << " at offset: " << next_data_pos_ << " " << ret;
             return false;
         }
     }
     header_.op_count += ops.size();
-    next_data_pos_ += data.size();
+    next_data_pos_ += total_data_size;
 
     return true;
 }
 
 bool CowWriterV3::WriteOperation(const CowOperationV3& op, const void* data, size_t size) {
-    return WriteOperation({&op, 1}, {reinterpret_cast<const uint8_t*>(data), size});
+    return WriteOperation({&op, 1}, data, size);
 }
 
 bool CowWriterV3::Finalize() {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 02b4e611bf6f..93f1d245da81 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -46,7 +46,9 @@ class CowWriterV3 : public CowWriterBase {
     bool OpenForWrite();
     bool OpenForAppend(uint64_t label);
     bool WriteOperation(std::basic_string_view<CowOperationV3> op,
-                        std::basic_string_view<uint8_t> data);
+                        std::basic_string_view<struct iovec> data);
+    bool WriteOperation(std::basic_string_view<CowOperationV3> op, const void* data = nullptr,
+                        size_t size = 0);
     bool WriteOperation(const CowOperationV3& op, const void* data = nullptr, size_t size = 0);
     bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
                     uint16_t offset, CowOperationType type);
@@ -68,6 +70,7 @@ class CowWriterV3 : public CowWriterBase {
     // in the case that we are using one thread for compression, we can store and re-use the same
     // compressor
     int num_compress_threads_ = 1;
+    size_t batch_size_ = 0;
 };
 
 }  // namespace snapshot

From 189d5b645925f5f618c9825872b07a00a4ffb582 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 14 Dec 2023 17:47:24 +0000
Subject: [PATCH 0625/1487] Hang up narayan's janitor overalls.

Test: N/A
Change-Id: I1f0288e77fa9724a6621a08f12f996c19e2e3e9f
---
 janitors/OWNERS | 1 -
 1 file changed, 1 deletion(-)

diff --git a/janitors/OWNERS b/janitors/OWNERS
index d8712019f6ce..a28737ebccc4 100644
--- a/janitors/OWNERS
+++ b/janitors/OWNERS
@@ -3,5 +3,4 @@ ccross@google.com
 cferris@google.com
 dwillemsen@google.com
 enh@google.com
-narayan@google.com
 sadafebrahimi@google.com

From 4928b6ef5799f01552cc9e44a09153308f45f067 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 14 Dec 2023 21:38:23 +0000
Subject: [PATCH 0626/1487] Reapply "libprocessgroup: Poll on cgroup.events"

This reverts commit a72332f9539f73043fe512346535cf595890d5a8.

This change was originally reverted due to a bug in the child commit
which caused process group kills not to occur when using cgroup.kill.
Now that has been fixed, bring back this change with the fixed child.

Bug: 301871933
Change-Id: Ia6c74d9b67a8c88aec4812ac4655646934e0d189
---
 .../include/processgroup/processgroup.h       |  10 +-
 libprocessgroup/processgroup.cpp              | 293 +++++++++++-------
 2 files changed, 183 insertions(+), 120 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 9107838b8629..ca6868c1b640 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -65,9 +65,8 @@ bool UsePerAppMemcg();
 // should be active again. E.g. Zygote specialization for child process.
 void DropTaskProfilesResourceCaching();
 
-// Return 0 and removes the cgroup if there are no longer any processes in it.
-// Returns -1 in the case of an error occurring or if there are processes still running
-// even after retrying for up to 200ms.
+// Return 0 if all processes were killed and the cgroup was successfully removed.
+// Returns -1 in the case of an error occurring or if there are processes still running.
 int killProcessGroup(uid_t uid, int initialPid, int signal);
 
 // Returns the same as killProcessGroup(), however it does not retry, which means
@@ -76,8 +75,9 @@ int killProcessGroupOnce(uid_t uid, int initialPid, int signal);
 
 // Sends the provided signal to all members of a process group, but does not wait for processes to
 // exit, or for the cgroup to be removed. Callers should also ensure that killProcessGroup is called
-// later to ensure the cgroup is fully removed, otherwise system resources may leak.
-int sendSignalToProcessGroup(uid_t uid, int initialPid, int signal);
+// later to ensure the cgroup is fully removed, otherwise system resources will leak.
+// Returns true if no errors are encountered sending signals, otherwise false.
+bool sendSignalToProcessGroup(uid_t uid, int initialPid, int signal);
 
 int createProcessGroup(uid_t uid, int initialPid, bool memControl = false);
 
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index f594f7f66354..7e27d75440d3 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -22,6 +22,7 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
+#include <poll.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -30,6 +31,7 @@
 #include <unistd.h>
 
 #include <chrono>
+#include <cstring>
 #include <map>
 #include <memory>
 #include <mutex>
@@ -53,7 +55,8 @@ using android::base::WriteStringToFile;
 
 using namespace std::chrono_literals;
 
-#define PROCESSGROUP_CGROUP_PROCS_FILE "/cgroup.procs"
+#define PROCESSGROUP_CGROUP_PROCS_FILE "cgroup.procs"
+#define PROCESSGROUP_CGROUP_EVENTS_FILE "cgroup.events"
 
 bool CgroupsAvailable() {
     static bool cgroups_available = access("/proc/cgroups", F_OK) == 0;
@@ -213,30 +216,21 @@ static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, int pid) {
     return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
 }
 
-static int RemoveCgroup(const char* cgroup, uid_t uid, int pid, unsigned int retries) {
-    int ret = 0;
-    auto uid_pid_path = ConvertUidPidToPath(cgroup, uid, pid);
-
-    while (retries--) {
-        ret = rmdir(uid_pid_path.c_str());
-        // If we get an error 2 'No such file or directory' , that means the
-        // cgroup is already removed, treat it as success and return 0 for
-        // idempotency.
-        if (ret < 0 && errno == ENOENT) {
-            ret = 0;
-        }
-        if (!ret || errno != EBUSY || !retries) break;
-        std::this_thread::sleep_for(5ms);
-    }
+static int RemoveCgroup(const char* cgroup, uid_t uid, int pid) {
+    auto path = ConvertUidPidToPath(cgroup, uid, pid);
+    int ret = TEMP_FAILURE_RETRY(rmdir(path.c_str()));
 
     if (!ret && uid >= AID_ISOLATED_START && uid <= AID_ISOLATED_END) {
         // Isolated UIDs are unlikely to be reused soon after removal,
         // so free up the kernel resources for the UID level cgroup.
-        const auto uid_path = ConvertUidToPath(cgroup, uid);
-        ret = rmdir(uid_path.c_str());
-        if (ret < 0 && errno == ENOENT) {
-            ret = 0;
-        }
+        path = ConvertUidToPath(cgroup, uid);
+        ret = TEMP_FAILURE_RETRY(rmdir(path.c_str()));
+    }
+
+    if (ret < 0 && errno == ENOENT) {
+        // This function is idempoetent, but still warn here.
+        LOG(WARNING) << "RemoveCgroup: " << path << " does not exist.";
+        ret = 0;
     }
 
     return ret;
@@ -360,38 +354,33 @@ static bool MkdirAndChown(const std::string& path, mode_t mode, uid_t uid, gid_t
     return false;
 }
 
-// Returns number of processes killed on success
-// Returns 0 if there are no processes in the process cgroup left to kill
-// Returns -1 on error
-static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid, int signal) {
-    // We separate all of the pids in the cgroup into those pids that are also the leaders of
-    // process groups (stored in the pgids set) and those that are not (stored in the pids set).
-    std::set<pid_t> pgids;
-    pgids.emplace(initialPid);
-    std::set<pid_t> pids;
-    int processes = 0;
-
-    std::unique_ptr<FILE, decltype(&fclose)> fd(nullptr, fclose);
+bool sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
+    std::set<pid_t> pgids, pids;
 
     if (CgroupsAvailable()) {
-        auto path = ConvertUidPidToPath(cgroup, uid, initialPid) + PROCESSGROUP_CGROUP_PROCS_FILE;
-        fd.reset(fopen(path.c_str(), "re"));
-        if (!fd) {
-            if (errno == ENOENT) {
-                // This happens when the process is already dead or if, as the result of a bug, it
-                // has been migrated to another cgroup. An example of a bug that can cause migration
-                // to another cgroup is using the JoinCgroup action with a cgroup controller that
-                // has been activated in the v2 cgroup hierarchy.
-                goto kill;
-            }
-            PLOG(WARNING) << __func__ << " failed to open process cgroup uid " << uid << " pid "
-                          << initialPid;
-            return -1;
+        std::string hierarchy_root_path, cgroup_v2_path;
+        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
+        cgroup_v2_path = ConvertUidPidToPath(hierarchy_root_path.c_str(), uid, initialPid);
+
+        LOG(VERBOSE) << "Using " << PROCESSGROUP_CGROUP_PROCS_FILE << " to signal (" << signal
+                     << ") " << cgroup_v2_path;
+
+        // We separate all of the pids in the cgroup into those pids that are also the leaders of
+        // process groups (stored in the pgids set) and those that are not (stored in the pids set).
+        const auto procsfilepath = cgroup_v2_path + '/' + PROCESSGROUP_CGROUP_PROCS_FILE;
+        std::unique_ptr<FILE, decltype(&fclose)> fp(fopen(procsfilepath.c_str(), "re"), fclose);
+        if (!fp) {
+            // This should only happen if the cgroup has already been removed with a successful call
+            // to killProcessGroup. Callers should only retry sendSignalToProcessGroup or
+            // killProcessGroup calls if they fail without ENOENT.
+            PLOG(ERROR) << "Failed to open " << procsfilepath;
+            kill(-initialPid, signal);
+            return false;
         }
+
         pid_t pid;
         bool file_is_empty = true;
-        while (fscanf(fd.get(), "%d\n", &pid) == 1 && pid >= 0) {
-            processes++;
+        while (fscanf(fp.get(), "%d\n", &pid) == 1 && pid >= 0) {
             file_is_empty = false;
             if (pid == 0) {
                 // Should never happen...  but if it does, trying to kill this
@@ -421,7 +410,8 @@ static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid,
         }
     }
 
-kill:
+    pgids.emplace(initialPid);
+
     // Kill all process groups.
     for (const auto pgid : pgids) {
         LOG(VERBOSE) << "Killing process group " << -pgid << " in uid " << uid
@@ -442,101 +432,174 @@ static int DoKillProcessGroupOnce(const char* cgroup, uid_t uid, int initialPid,
         }
     }
 
-    return (!fd || feof(fd.get())) ? processes : -1;
+    return true;
+}
+
+template <typename T>
+static std::chrono::milliseconds toMillisec(T&& duration) {
+    return std::chrono::duration_cast<std::chrono::milliseconds>(duration);
 }
 
-static int KillProcessGroup(uid_t uid, int initialPid, int signal, int retries) {
-    CHECK_GE(uid, 0);
-    CHECK_GT(initialPid, 0);
+enum class populated_status
+{
+    populated,
+    not_populated,
+    error
+};
 
-    std::string hierarchy_root_path;
-    if (CgroupsAvailable()) {
-        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
+static populated_status cgroupIsPopulated(int events_fd) {
+    const std::string POPULATED_KEY("populated ");
+    const std::string::size_type MAX_EVENTS_FILE_SIZE = 32;
+
+    std::string buf;
+    buf.resize(MAX_EVENTS_FILE_SIZE);
+    ssize_t len = TEMP_FAILURE_RETRY(pread(events_fd, buf.data(), buf.size(), 0));
+    if (len == -1) {
+        PLOG(ERROR) << "Could not read cgroup.events: ";
+        // Potentially ENODEV if the cgroup has been removed since we opened this file, but that
+        // shouldn't have happened yet.
+        return populated_status::error;
     }
-    const char* cgroup = hierarchy_root_path.c_str();
 
-    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+    if (len == 0) {
+        LOG(ERROR) << "cgroup.events EOF";
+        return populated_status::error;
+    }
 
-    int retry = retries;
-    int processes;
-    while ((processes = DoKillProcessGroupOnce(cgroup, uid, initialPid, signal)) > 0) {
-        LOG(VERBOSE) << "Killed " << processes << " processes for processgroup " << initialPid;
-        if (!CgroupsAvailable()) {
-            // makes no sense to retry, because there are no cgroup_procs file
-            processes = 0;  // no remaining processes
-            break;
-        }
-        if (retry > 0) {
-            std::this_thread::sleep_for(5ms);
-            --retry;
-        } else {
-            break;
-        }
+    buf.resize(len);
+
+    const std::string::size_type pos = buf.find(POPULATED_KEY);
+    if (pos == std::string::npos) {
+        LOG(ERROR) << "Could not find populated key in cgroup.events";
+        return populated_status::error;
+    }
+
+    if (pos + POPULATED_KEY.size() + 1 > len) {
+        LOG(ERROR) << "Partial read of cgroup.events";
+        return populated_status::error;
     }
 
-    if (processes < 0) {
-        PLOG(ERROR) << "Error encountered killing process cgroup uid " << uid << " pid "
-                    << initialPid;
+    return buf[pos + POPULATED_KEY.size()] == '1' ?
+        populated_status::populated : populated_status::not_populated;
+}
+
+// The default timeout of 2200ms comes from the default number of retries in a previous
+// implementation of this function. The default retry value was 40 for killing and 400 for cgroup
+// removal with 5ms sleeps between each retry.
+static int KillProcessGroup(
+        uid_t uid, int initialPid, int signal, bool once = false,
+        std::chrono::steady_clock::time_point until = std::chrono::steady_clock::now() + 2200ms) {
+    CHECK_GE(uid, 0);
+    CHECK_GT(initialPid, 0);
+
+    // Always attempt to send a kill signal to at least the initialPid, at least once, regardless of
+    // whether its cgroup exists or not. This should only be necessary if a bug results in the
+    // migration of the targeted process out of its cgroup, which we will also attempt to kill.
+    const bool signal_ret = sendSignalToProcessGroup(uid, initialPid, signal);
+
+    if (!CgroupsAvailable() || !signal_ret) return signal_ret ? 0 : -1;
+
+    std::string hierarchy_root_path;
+    CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
+
+    const std::string cgroup_v2_path =
+            ConvertUidPidToPath(hierarchy_root_path.c_str(), uid, initialPid);
+
+    const std::string eventsfile = cgroup_v2_path + '/' + PROCESSGROUP_CGROUP_EVENTS_FILE;
+    android::base::unique_fd events_fd(open(eventsfile.c_str(), O_RDONLY));
+    if (events_fd.get() == -1) {
+        PLOG(WARNING) << "Error opening " << eventsfile << " for KillProcessGroup";
         return -1;
     }
 
-    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
-    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
+    struct pollfd fds = {
+        .fd = events_fd,
+        .events = POLLPRI,
+    };
+
+    const std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+
+    // The primary reason to loop here is to capture any new forks or migrations that could occur
+    // after we send signals to the original set of processes, but before all of those processes
+    // exit and the cgroup becomes unpopulated, or before we remove the cgroup. We try hard to
+    // ensure this completes successfully to avoid permanent memory leaks, but we still place a
+    // large default upper bound on the amount of time we spend in this loop. The amount of CPU
+    // contention, and the amount of work that needs to be done in do_exit for each process
+    // determines how long this will take.
+    int ret;
+    do {
+        populated_status populated;
+        while ((populated = cgroupIsPopulated(events_fd.get())) == populated_status::populated &&
+               std::chrono::steady_clock::now() < until) {
+
+            sendSignalToProcessGroup(uid, initialPid, signal);
+            if (once) {
+                populated = cgroupIsPopulated(events_fd.get());
+                break;
+            }
+
+            const std::chrono::steady_clock::time_point poll_start =
+                    std::chrono::steady_clock::now();
+
+            if (poll_start < until)
+                ret = TEMP_FAILURE_RETRY(poll(&fds, 1, toMillisec(until - poll_start).count()));
 
-    // We only calculate the number of 'processes' when killing the processes.
-    // In the retries == 0 case, we only kill the processes once and therefore
-    // will not have waited then recalculated how many processes are remaining
-    // after the first signals have been sent.
-    // Logging anything regarding the number of 'processes' here does not make sense.
+            if (ret == -1) {
+                // Fallback to 5ms sleeps if poll fails
+                PLOG(ERROR) << "Poll on " << eventsfile << "failed";
+                const std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
+                if (now < until)
+                    std::this_thread::sleep_for(std::min(5ms, toMillisec(until - now)));
+            }
 
-    if (processes == 0) {
-        if (retries > 0) {
-            LOG(INFO) << "Successfully killed process cgroup uid " << uid << " pid " << initialPid
-                      << " in " << static_cast<int>(ms) << "ms";
+            LOG(VERBOSE) << "Waited "
+                         << toMillisec(std::chrono::steady_clock::now() - poll_start).count()
+                         << " ms for " << eventsfile << " poll";
         }
 
-        if (!CgroupsAvailable()) {
-            // nothing to do here, if cgroups isn't available
-            return 0;
+        const std::chrono::milliseconds kill_duration =
+                toMillisec(std::chrono::steady_clock::now() - start);
+
+        if (populated == populated_status::populated) {
+            LOG(WARNING) << "Still waiting on process(es) to exit for cgroup " << cgroup_v2_path
+                         << " after " << kill_duration.count() << " ms";
+            // We'll still try the cgroup removal below which we expect to log an error.
+        } else if (populated == populated_status::not_populated) {
+            LOG(VERBOSE) << "Killed all processes under cgroup " << cgroup_v2_path
+                         << " after " << kill_duration.count() << " ms";
         }
 
-        // 400 retries correspond to 2 secs max timeout
-        int err = RemoveCgroup(cgroup, uid, initialPid, 400);
+        ret = RemoveCgroup(hierarchy_root_path.c_str(), uid, initialPid);
+        if (ret)
+            PLOG(ERROR) << "Unable to remove cgroup " << cgroup_v2_path;
+        else
+            LOG(INFO) << "Removed cgroup " << cgroup_v2_path;
 
         if (isMemoryCgroupSupported() && UsePerAppMemcg()) {
+            // This per-application memcg v1 case should eventually be removed after migration to
+            // memcg v2.
             std::string memcg_apps_path;
             if (CgroupGetMemcgAppsPath(&memcg_apps_path) &&
-                RemoveCgroup(memcg_apps_path.c_str(), uid, initialPid, 400) < 0) {
-                return -1;
+                (ret = RemoveCgroup(memcg_apps_path.c_str(), uid, initialPid)) < 0) {
+                const auto memcg_v1_cgroup_path =
+                        ConvertUidPidToPath(memcg_apps_path.c_str(), uid, initialPid);
+                PLOG(ERROR) << "Unable to remove memcg v1 cgroup " << memcg_v1_cgroup_path;
             }
         }
 
-        return err;
-    } else {
-        if (retries > 0) {
-            LOG(ERROR) << "Failed to kill process cgroup uid " << uid << " pid " << initialPid
-                       << " in " << static_cast<int>(ms) << "ms, " << processes
-                       << " processes remain";
-        }
-        return -1;
-    }
+        if (once) break;
+        if (std::chrono::steady_clock::now() >= until) break;
+    } while (ret && errno == EBUSY);
+
+    return ret;
 }
 
 int killProcessGroup(uid_t uid, int initialPid, int signal) {
-    return KillProcessGroup(uid, initialPid, signal, 40 /*retries*/);
+    return KillProcessGroup(uid, initialPid, signal);
 }
 
 int killProcessGroupOnce(uid_t uid, int initialPid, int signal) {
-    return KillProcessGroup(uid, initialPid, signal, 0 /*retries*/);
-}
-
-int sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
-    std::string hierarchy_root_path;
-    if (CgroupsAvailable()) {
-        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
-    }
-    const char* cgroup = hierarchy_root_path.c_str();
-    return DoKillProcessGroupOnce(cgroup, uid, initialPid, signal);
+    return KillProcessGroup(uid, initialPid, signal, true);
 }
 
 static int createProcessGroupInternal(uid_t uid, int initialPid, std::string cgroup,
@@ -576,7 +639,7 @@ static int createProcessGroupInternal(uid_t uid, int initialPid, std::string cgr
         return -errno;
     }
 
-    auto uid_pid_procs_file = uid_pid_path + PROCESSGROUP_CGROUP_PROCS_FILE;
+    auto uid_pid_procs_file = uid_pid_path + '/' + PROCESSGROUP_CGROUP_PROCS_FILE;
 
     if (!WriteStringToFile(std::to_string(initialPid), uid_pid_procs_file)) {
         ret = -errno;

From a103630b5c9d187a3fa085585da58c4a6745e7bc Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 7 Nov 2023 14:36:46 +0000
Subject: [PATCH 0627/1487] libprocessgroup: Use cgroup.kill

By using cgroup.kill we don't need to read cgroup.procs at all for
SIGKILLs, which is more efficient and should help reduce CPU contention
and cgroup lock contention. Fallback to cgroup.procs if we encounter an
error trying to use cgroup.kill, but if cgroup.kill fails it's likely
that cgroup.procs will too.

Bug: 239829790
Test: atest StagedRollbackTest:com.android.tests.rollback.host.StagedRollbackTest#testNativeWatchdogTriggersRebootlessApexRollback
Change-Id: I9da67efd00af49b7b4b502fb742c1095d5c7b9e9
---
 libprocessgroup/processgroup.cpp | 54 +++++++++++++++++++++++++++-----
 1 file changed, 46 insertions(+), 8 deletions(-)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 7e27d75440d3..3209adf16acd 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -56,6 +56,7 @@ using android::base::WriteStringToFile;
 using namespace std::chrono_literals;
 
 #define PROCESSGROUP_CGROUP_PROCS_FILE "cgroup.procs"
+#define PROCESSGROUP_CGROUP_KILL_FILE "cgroup.kill"
 #define PROCESSGROUP_CGROUP_EVENTS_FILE "cgroup.events"
 
 bool CgroupsAvailable() {
@@ -77,6 +78,29 @@ bool CgroupGetControllerPath(const std::string& cgroup_name, std::string* path)
     return true;
 }
 
+static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
+    return StringPrintf("%s/uid_%u", cgroup, uid);
+}
+
+static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, int pid) {
+    return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
+}
+
+static bool CgroupKillAvailable() {
+    static std::once_flag f;
+    static bool cgroup_kill_available = false;
+    std::call_once(f, []() {
+        std::string cg_kill;
+        CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &cg_kill);
+        // cgroup.kill is not on the root cgroup, so check a non-root cgroup that should always
+        // exist
+        cg_kill = ConvertUidToPath(cg_kill.c_str(), AID_ROOT) + '/' + PROCESSGROUP_CGROUP_KILL_FILE;
+        cgroup_kill_available = access(cg_kill.c_str(), F_OK) == 0;
+    });
+
+    return cgroup_kill_available;
+}
+
 static bool CgroupGetMemcgAppsPath(std::string* path) {
     CgroupController controller = CgroupMap::GetInstance().FindController("memory");
 
@@ -208,14 +232,6 @@ bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles) {
                                                        false);
 }
 
-static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
-    return StringPrintf("%s/uid_%u", cgroup, uid);
-}
-
-static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, int pid) {
-    return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
-}
-
 static int RemoveCgroup(const char* cgroup, uid_t uid, int pid) {
     auto path = ConvertUidPidToPath(cgroup, uid, pid);
     int ret = TEMP_FAILURE_RETRY(rmdir(path.c_str()));
@@ -362,6 +378,28 @@ bool sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
         CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
         cgroup_v2_path = ConvertUidPidToPath(hierarchy_root_path.c_str(), uid, initialPid);
 
+        if (signal == SIGKILL && CgroupKillAvailable()) {
+            LOG(VERBOSE) << "Using " << PROCESSGROUP_CGROUP_KILL_FILE << " to SIGKILL "
+                         << cgroup_v2_path;
+
+            // We need to kill the process group in addition to the cgroup. For normal apps they
+            // should completely overlap, but system_server kills depend on process group kills to
+            // take down apps which are in their own cgroups and not individually targeted.
+            if (kill(-initialPid, signal) == -1 && errno != ESRCH) {
+                PLOG(WARNING) << "kill(" << -initialPid << ", " << signal << ") failed";
+            }
+
+            const std::string killfilepath = cgroup_v2_path + '/' + PROCESSGROUP_CGROUP_KILL_FILE;
+            if (WriteStringToFile("1", killfilepath)) {
+                return true;
+            } else {
+                PLOG(ERROR) << "Failed to write 1 to " << killfilepath;
+                // Fallback to cgroup.procs below
+            }
+        }
+
+        // Since cgroup.kill only sends SIGKILLs, we read cgroup.procs to find each process to
+        // signal individually. This is more costly than using cgroup.kill for SIGKILLs.
         LOG(VERBOSE) << "Using " << PROCESSGROUP_CGROUP_PROCS_FILE << " to signal (" << signal
                      << ") " << cgroup_v2_path;
 

From adb91b0e5979148b4c141b7e966e375615fce62d Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 12 Dec 2023 11:25:40 -0800
Subject: [PATCH 0628/1487] remount: Detect when flashall has happened in the
 bootloader.

This adds a new metadata header flag to the super partition. This flag
is set when "adb remount" is used, and is implicitly cleared when
flashing.

If there is a scratch partition present on /data, we require that the
flag be set in order to proceed using overlays. If not set, scratch is
not mapped in first-stage init, and scratch images are removed later
during startup.

Bug: 297923468
Test: adb remount -R, touch file in out/, sync, flashall
Change-Id: I9cc411a1632101b5fc043193b38db8ffb9c20e7f
---
 fastboot/fastboot.cpp                        |  2 +-
 fastboot/task.cpp                            |  4 +-
 fastboot/task.h                              |  2 +-
 fastboot/task_test.cpp                       |  6 +--
 fs_mgr/fs_mgr_overlayfs_control.cpp          | 46 ++++++++++++++++++++
 fs_mgr/liblp/builder.cpp                     |  9 ++++
 fs_mgr/liblp/include/liblp/builder.h         |  2 +
 fs_mgr/liblp/include/liblp/metadata_format.h |  3 ++
 8 files changed, 67 insertions(+), 7 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 1bc7b7513aed..235d7234fd6e 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1675,7 +1675,7 @@ bool AddResizeTasks(const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>*
     }
     for (size_t i = 0; i < tasks->size(); i++) {
         if (auto flash_task = tasks->at(i)->AsFlashTask()) {
-            if (FlashTask::IsDynamicParitition(fp->source.get(), flash_task)) {
+            if (FlashTask::IsDynamicPartition(fp->source.get(), flash_task)) {
                 if (!loc) {
                     loc = i;
                 }
diff --git a/fastboot/task.cpp b/fastboot/task.cpp
index 0947ff90f850..ea78a01b5832 100644
--- a/fastboot/task.cpp
+++ b/fastboot/task.cpp
@@ -30,7 +30,7 @@ FlashTask::FlashTask(const std::string& slot, const std::string& pname, const st
                      const bool apply_vbmeta, const FlashingPlan* fp)
     : pname_(pname), fname_(fname), slot_(slot), apply_vbmeta_(apply_vbmeta), fp_(fp) {}
 
-bool FlashTask::IsDynamicParitition(const ImageSource* source, const FlashTask* task) {
+bool FlashTask::IsDynamicPartition(const ImageSource* source, const FlashTask* task) {
     std::vector<char> contents;
     if (!source->ReadFile("super_empty.img", &contents)) {
         return false;
@@ -152,7 +152,7 @@ bool OptimizedFlashSuperTask::CanOptimize(const ImageSource* source,
             continue;
         }
         auto flash_task = tasks[i + 2]->AsFlashTask();
-        if (!FlashTask::IsDynamicParitition(source, flash_task)) {
+        if (!FlashTask::IsDynamicPartition(source, flash_task)) {
             continue;
         }
         return true;
diff --git a/fastboot/task.h b/fastboot/task.h
index a98c87419c52..7a713cf2b0ea 100644
--- a/fastboot/task.h
+++ b/fastboot/task.h
@@ -52,7 +52,7 @@ class FlashTask : public Task {
               const bool apply_vbmeta, const FlashingPlan* fp);
     virtual FlashTask* AsFlashTask() override { return this; }
 
-    static bool IsDynamicParitition(const ImageSource* source, const FlashTask* task);
+    static bool IsDynamicPartition(const ImageSource* source, const FlashTask* task);
     void Run() override;
     std::string ToString() const override;
     std::string GetPartition() const { return pname_; }
diff --git a/fastboot/task_test.cpp b/fastboot/task_test.cpp
index 81154c68e111..519d4edd9d2e 100644
--- a/fastboot/task_test.cpp
+++ b/fastboot/task_test.cpp
@@ -233,7 +233,7 @@ TEST_F(ParseTest, CorrectTaskLists) {
             << "size of fastboot-info task list: " << fastboot_info_tasks.size()
             << " size of hardcoded task list: " << hardcoded_tasks.size();
 }
-TEST_F(ParseTest, IsDynamicParitiontest) {
+TEST_F(ParseTest, IsDynamicPartitiontest) {
     if (!get_android_product_out()) {
         GTEST_SKIP();
     }
@@ -258,7 +258,7 @@ TEST_F(ParseTest, IsDynamicParitiontest) {
                 ParseFastbootInfoLine(fp.get(), android::base::Tokenize(test.first, " "));
         auto flash_task = task->AsFlashTask();
         ASSERT_FALSE(flash_task == nullptr);
-        ASSERT_EQ(FlashTask::IsDynamicParitition(fp->source.get(), flash_task), test.second);
+        ASSERT_EQ(FlashTask::IsDynamicPartition(fp->source.get(), flash_task), test.second);
     }
 }
 
@@ -358,7 +358,7 @@ TEST_F(ParseTest, OptimizedFlashSuperPatternMatchTest) {
                     contains_optimized_task = true;
                 }
                 if (auto flash_task = task->AsFlashTask()) {
-                    if (FlashTask::IsDynamicParitition(fp->source.get(), flash_task)) {
+                    if (FlashTask::IsDynamicPartition(fp->source.get(), flash_task)) {
                         return false;
                     }
                 }
diff --git a/fs_mgr/fs_mgr_overlayfs_control.cpp b/fs_mgr/fs_mgr_overlayfs_control.cpp
index 06214ef25579..08ad80caaa2e 100644
--- a/fs_mgr/fs_mgr_overlayfs_control.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_control.cpp
@@ -219,6 +219,35 @@ OverlayfsTeardownResult TeardownDataScratch(IImageManager* images,
     return OverlayfsTeardownResult::Ok;
 }
 
+bool GetOverlaysActiveFlag() {
+    auto slot_number = fs_mgr_overlayfs_slot_number();
+    const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();
+
+    auto metadata = ReadMetadata(super_device, slot_number);
+    if (!metadata) {
+        return false;
+    }
+    return !!(metadata->header.flags & LP_HEADER_FLAG_OVERLAYS_ACTIVE);
+}
+
+bool SetOverlaysActiveFlag(bool flag) {
+    // Mark overlays as active in the partition table, to detect re-flash.
+    auto slot_number = fs_mgr_overlayfs_slot_number();
+    const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();
+    auto builder = MetadataBuilder::New(super_device, slot_number);
+    if (!builder) {
+        LERROR << "open " << super_device << " metadata";
+        return false;
+    }
+    builder->SetOverlaysActiveFlag(flag);
+    auto metadata = builder->Export();
+    if (!metadata || !UpdatePartitionTable(super_device, *metadata.get(), slot_number)) {
+        LERROR << "update super metadata";
+        return false;
+    }
+    return true;
+}
+
 OverlayfsTeardownResult fs_mgr_overlayfs_teardown_scratch(const std::string& overlay,
                                                           bool* change) {
     // umount and delete kScratchMountPoint storage if we have logical partitions
@@ -232,6 +261,10 @@ OverlayfsTeardownResult fs_mgr_overlayfs_teardown_scratch(const std::string& ove
         return OverlayfsTeardownResult::Error;
     }
 
+    // Note: we don't care if SetOverlaysActiveFlag fails, since
+    // the overlays are removed no matter what.
+    SetOverlaysActiveFlag(false);
+
     bool was_mounted = fs_mgr_overlayfs_already_mounted(kScratchMountPoint, false);
     if (was_mounted) {
         fs_mgr_overlayfs_umount_scratch();
@@ -448,6 +481,7 @@ static bool CreateDynamicScratch(std::string* scratch_device, bool* partition_ex
             }
         }
     }
+
     // land the update back on to the partition
     if (changed) {
         auto metadata = builder->Export();
@@ -592,6 +626,12 @@ bool fs_mgr_overlayfs_setup_scratch(const Fstab& fstab) {
         return false;
     }
 
+    if (!SetOverlaysActiveFlag(true)) {
+        LOG(ERROR) << "Failed to update dynamic partition data";
+        fs_mgr_overlayfs_teardown_scratch(kScratchMountPoint, nullptr);
+        return false;
+    }
+
     // If the partition exists, assume first that it can be mounted.
     if (partition_exists) {
         if (MountScratch(scratch_device)) {
@@ -856,6 +896,9 @@ void MapScratchPartitionIfNeeded(Fstab* fstab,
         return;
     }
 
+    if (!GetOverlaysActiveFlag()) {
+        return;
+    }
     if (ScratchIsOnData()) {
         if (auto images = IImageManager::Open("remount", 0ms)) {
             images->MapAllImages(init);
@@ -879,6 +922,9 @@ void CleanupOldScratchFiles() {
     }
     if (auto images = IImageManager::Open("remount", 0ms)) {
         images->RemoveDisabledImages();
+        if (!GetOverlaysActiveFlag()) {
+            fs_mgr_overlayfs_teardown_scratch(kScratchMountPoint, nullptr);
+        }
     }
 }
 
diff --git a/fs_mgr/liblp/builder.cpp b/fs_mgr/liblp/builder.cpp
index 6cb2c5172aac..4e6e97b6758d 100644
--- a/fs_mgr/liblp/builder.cpp
+++ b/fs_mgr/liblp/builder.cpp
@@ -1211,6 +1211,15 @@ void MetadataBuilder::SetVirtualABDeviceFlag() {
     header_.flags |= LP_HEADER_FLAG_VIRTUAL_AB_DEVICE;
 }
 
+void MetadataBuilder::SetOverlaysActiveFlag(bool flag) {
+    RequireExpandedMetadataHeader();
+    if (flag) {
+        header_.flags |= LP_HEADER_FLAG_OVERLAYS_ACTIVE;
+    } else {
+        header_.flags &= ~LP_HEADER_FLAG_OVERLAYS_ACTIVE;
+    }
+}
+
 bool MetadataBuilder::IsABDevice() {
     return !IPropertyFetcher::GetInstance()->GetProperty("ro.boot.slot_suffix", "").empty();
 }
diff --git a/fs_mgr/liblp/include/liblp/builder.h b/fs_mgr/liblp/include/liblp/builder.h
index 54f31bc36f0a..957b96b09c92 100644
--- a/fs_mgr/liblp/include/liblp/builder.h
+++ b/fs_mgr/liblp/include/liblp/builder.h
@@ -346,6 +346,8 @@ class MetadataBuilder {
     void SetAutoSlotSuffixing();
     // Set the LP_HEADER_FLAG_VIRTUAL_AB_DEVICE flag.
     void SetVirtualABDeviceFlag();
+    // Set or unset the LP_HEADER_FLAG_OVERLAYS_ACTIVE flag.
+    void SetOverlaysActiveFlag(bool flag);
 
     bool GetBlockDeviceInfo(const std::string& partition_name, BlockDeviceInfo* info) const;
     bool UpdateBlockDeviceInfo(const std::string& partition_name, const BlockDeviceInfo& info);
diff --git a/fs_mgr/liblp/include/liblp/metadata_format.h b/fs_mgr/liblp/include/liblp/metadata_format.h
index 41d8b0cd5ca8..8d77097ed67b 100644
--- a/fs_mgr/liblp/include/liblp/metadata_format.h
+++ b/fs_mgr/liblp/include/liblp/metadata_format.h
@@ -240,6 +240,9 @@ typedef struct LpMetadataHeader {
  */
 #define LP_HEADER_FLAG_VIRTUAL_AB_DEVICE 0x1
 
+/* This device has overlays activated via "adb remount". */
+#define LP_HEADER_FLAG_OVERLAYS_ACTIVE 0x2
+
 /* This struct defines a logical partition entry, similar to what would be
  * present in a GUID Partition Table.
  */

From 73ac5f184e3ea6273e24315bfe3ba5f0010f4624 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 14 Dec 2023 16:40:23 -0800
Subject: [PATCH 0629/1487] Add op count check before attempting to write
 operations

Test: th
Bug: 313962438
Change-Id: I0e288a42984d737d327236693a6b69c03a7ecc6e
---
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 27 ++++++++++++++++++-
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |  1 +
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index de097f5b061f..a95b442770f9 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -216,7 +216,23 @@ bool CowWriterV3::OpenForAppend(uint64_t label) {
     return true;
 }
 
+bool CowWriterV3::CheckOpCount(size_t op_count) {
+    if (IsEstimating()) {
+        return true;
+    }
+    if (header_.op_count + op_count > header_.op_count_max) {
+        LOG(ERROR) << "Current number of ops on disk: " << header_.op_count
+                   << ", number of ops attempting to write: " << op_count
+                   << ", this will exceed max op count " << header_.op_count_max;
+        return false;
+    }
+    return true;
+}
+
 bool CowWriterV3::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks) {
+    if (!CheckOpCount(num_blocks)) {
+        return false;
+    }
     std::vector<CowOperationV3> ops(num_blocks);
     for (size_t i = 0; i < num_blocks; i++) {
         CowOperationV3& op = ops[i];
@@ -232,11 +248,17 @@ bool CowWriterV3::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_
 }
 
 bool CowWriterV3::EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) {
+    if (!CheckOpCount(size / header_.block_size)) {
+        return false;
+    }
     return EmitBlocks(new_block_start, data, size, 0, 0, kCowReplaceOp);
 }
 
 bool CowWriterV3::EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size,
                                 uint32_t old_block, uint16_t offset) {
+    if (!CheckOpCount(size / header_.block_size)) {
+        return false;
+    }
     return EmitBlocks(new_block_start, data, size, old_block, offset, kCowXorOp);
 }
 
@@ -313,8 +335,11 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
 }
 
 bool CowWriterV3::EmitZeroBlocks(uint64_t new_block_start, const uint64_t num_blocks) {
+    if (!CheckOpCount(num_blocks)) {
+        return false;
+    }
     std::vector<CowOperationV3> ops(num_blocks);
-    for (uint64_t i = 0; i < ops.size(); i++) {
+    for (uint64_t i = 0; i < num_blocks; i++) {
         auto& op = ops[i];
         op.set_type(kCowZeroOp);
         op.new_block = new_block_start + i;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 93f1d245da81..613bbe5fe875 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -53,6 +53,7 @@ class CowWriterV3 : public CowWriterBase {
     bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
                     uint16_t offset, CowOperationType type);
     bool CompressBlocks(size_t num_blocks, const void* data);
+    bool CheckOpCount(size_t op_count);
 
   private:
     CowHeaderV3 header_{};

From cee7fcd0016ef0e983d14256b4c9c63c37dc2ee4 Mon Sep 17 00:00:00 2001
From: Peter Collingbourne <pcc@google.com>
Date: Thu, 14 Dec 2023 14:03:07 -0800
Subject: [PATCH 0630/1487] Mount /tmp as tmpfs.

/tmp is a volatile temporary storage location for the shell user.
As with /data/local/tmp, it is owned by shell:shell and is chmod 771.

Bug: 311263616
Change-Id: Ice0229d937989b097971d9db434d5589ac2da99a
---
 rootdir/Android.mk | 2 +-
 rootdir/init.rc    | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 7deb17324ea9..7444f963fd0c 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -97,7 +97,7 @@ endif
 # create some directories (some are mount points) and symlinks
 LOCAL_POST_INSTALL_CMD := mkdir -p $(addprefix $(TARGET_ROOT_OUT)/, \
     dev proc sys system data data_mirror odm oem acct config storage mnt apex bootstrap-apex debug_ramdisk \
-    linkerconfig second_stage_resources postinstall $(BOARD_ROOT_EXTRA_FOLDERS)); \
+    linkerconfig second_stage_resources postinstall tmp $(BOARD_ROOT_EXTRA_FOLDERS)); \
     ln -sf /system/bin $(TARGET_ROOT_OUT)/bin; \
     ln -sf /system/etc $(TARGET_ROOT_OUT)/etc; \
     ln -sf /data/user_de/0/com.android.shell/files/bugreports $(TARGET_ROOT_OUT)/bugreports; \
diff --git a/rootdir/init.rc b/rootdir/init.rc
index fb6473666d7c..12c46ebfe3dc 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -92,6 +92,12 @@ on early-init
     # checker programs.
     mkdir /dev/fscklogs 0770 root system
 
+    # Create tmpfs for use by the shell user.
+    mount tmpfs tmpfs /tmp
+    restorecon /tmp
+    chown shell shell /tmp
+    chmod 0771 /tmp
+
 on init
     sysclktz 0
 

From c85038b866a1c79d5c046ed257506279bfc6e490 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Fri, 15 Dec 2023 20:12:20 -0800
Subject: [PATCH 0631/1487] Fix EmitSequenceData bug

If sequence data is written and the number of ops reaches the maximum,
op data will corrupt the block data because location of block data is
stale after writing sequence data. Fix by resetting location of block
data after EmitSequenceData()

Test: th
Bug: 313962438
Change-Id: Ib53b81772ba341cdf5c240baaee7c10725a365c3
---
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 25 +++++++++++--------
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 13 ++++++++++
 2 files changed, 28 insertions(+), 10 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 44b73446428b..500f8d08c7de 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -1,10 +1,3 @@
-// Copyright (C) 2023 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,
@@ -15,6 +8,7 @@
 #include <sys/stat.h>
 
 #include <cstdio>
+#include <limits>
 #include <memory>
 
 #include <android-base/file.h>
@@ -513,19 +507,24 @@ TEST_F(CowTestV3, BufferMetadataSyncTest) {
 
 TEST_F(CowTestV3, SequenceTest) {
     CowOptions options;
-    options.op_count_max = std::numeric_limits<uint32_t>::max();
+    constexpr int seq_len = std::numeric_limits<uint16_t>::max() / sizeof(uint32_t) + 1;
+    options.op_count_max = seq_len;
     auto writer = CreateCowWriter(3, options, GetCowFd());
     // sequence data. This just an arbitrary set of integers that specify the merge order. The
     // actual calculation is done by update_engine and passed to writer. All we care about here is
     // writing that data correctly
-    const int seq_len = std::numeric_limits<uint16_t>::max() / sizeof(uint32_t) + 1;
     uint32_t sequence[seq_len];
     for (int i = 0; i < seq_len; i++) {
         sequence[i] = i + 1;
     }
 
     ASSERT_TRUE(writer->AddSequenceData(seq_len, sequence));
-    ASSERT_TRUE(writer->AddZeroBlocks(1, seq_len));
+    ASSERT_TRUE(writer->AddZeroBlocks(1, seq_len - 1));
+    std::vector<uint8_t> data(writer->GetBlockSize());
+    for (size_t i = 0; i < data.size(); i++) {
+        data[i] = static_cast<uint8_t>(i & 0xFF);
+    }
+    ASSERT_TRUE(writer->AddRawBlocks(seq_len, data.data(), data.size()));
     ASSERT_TRUE(writer->Finalize());
 
     ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
@@ -539,6 +538,12 @@ TEST_F(CowTestV3, SequenceTest) {
         const auto& op = iter->Get();
 
         ASSERT_EQ(op->new_block, seq_len - i);
+        if (op->new_block == seq_len) {
+            std::vector<uint8_t> read_back(writer->GetBlockSize());
+            ASSERT_EQ(reader.ReadData(op, read_back.data(), read_back.size()),
+                      static_cast<ssize_t>(read_back.size()));
+            ASSERT_EQ(read_back, data);
+        }
 
         iter->Next();
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index a95b442770f9..c56e22ab96ef 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -382,7 +382,20 @@ bool CowWriterV3::EmitLabel(uint64_t label) {
 
 bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
     // TODO: size sequence buffer based on options
+    if (header_.op_count > 0) {
+        LOG(ERROR)
+                << "There's " << header_.op_count
+                << " operations written to disk. Writing sequence data is only allowed before all "
+                   "operation writes.";
+        return false;
+    }
     header_.sequence_data_count = num_ops;
+    // In COW format v3, data section is placed after op section and sequence
+    // data section. Therefore, changing the sequence data count has the effect
+    // of moving op section and data section. Therefore we need to reset the
+    // value of |next_data_pos|. This is also the reason why writing sequence
+    // data is only allowed if there's no operation written.
+    next_data_pos_ = GetDataOffset(header_);
     if (!android::base::WriteFullyAtOffset(fd_, data, sizeof(data[0]) * num_ops,
                                            GetSequenceOffset(header_))) {
         PLOG(ERROR) << "writing sequence buffer failed";

From 222ffc59197a80b3a92e4755e14a570243b8bcbc Mon Sep 17 00:00:00 2001
From: Chun-Wei Wang <wangchun@google.com>
Date: Fri, 15 Dec 2023 14:40:56 +0800
Subject: [PATCH 0632/1487] Disable DSU in recovery mode

DSU (modifying mounting paths) will cause OTA update
to fail in recovery mode

Bug: 315887685
Test: 1. enter DSU mode
      2. adb reboot recovery
      3. select "Apply update from ADB"
      4. adb sideload some-ota-update.zip
Change-Id: I6aec86893b7f8aa9e34f158269ebe2fd9dd98b33
---
 fs_mgr/libfstab/fstab.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index 32460b17b5e1..443017a2640c 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -716,7 +716,7 @@ bool ReadFstabFromFile(const std::string& path, Fstab* fstab) {
     if (!ReadFstabFromFileCommon(path, fstab)) {
         return false;
     }
-    if (path != kProcMountsPath) {
+    if (path != kProcMountsPath && !InRecovery()) {
         if (!access(android::gsi::kGsiBootedIndicatorFile, F_OK)) {
             std::string dsu_slot;
             if (!android::gsi::GetActiveDsu(&dsu_slot)) {

From 5647c0b738e09d1184a742790933d4e5df1dfc01 Mon Sep 17 00:00:00 2001
From: Mike McTernan <mikemcternan@google.com>
Date: Mon, 18 Dec 2023 11:03:36 +0000
Subject: [PATCH 0633/1487] trusty: storageproxyd: fix logging of freed path
 pointer

Bug: 316859216
Test: build.py
Change-Id: I09557d43cda13e21175ba6fceeb806ec1f9115e1
---
 trusty/storage/proxy/storage.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/trusty/storage/proxy/storage.c b/trusty/storage/proxy/storage.c
index 2299481194ba..8c8edb779e6a 100644
--- a/trusty/storage/proxy/storage.c
+++ b/trusty/storage/proxy/storage.c
@@ -353,7 +353,6 @@ int storage_file_open(struct storage_msg* msg, const void* r, size_t req_len,
     if (open_flags & O_CREAT) {
         sync_parent(path, watcher);
     }
-    free(path);
 
     /* at this point rc contains storage file fd */
     msg->result = STORAGE_NO_ERROR;
@@ -361,6 +360,9 @@ int storage_file_open(struct storage_msg* msg, const void* r, size_t req_len,
     ALOGV("%s: \"%s\": fd = %u: handle = %d\n",
           __func__, path, rc, resp.handle);
 
+    free(path);
+    path = NULL;
+
     /* a backing file has been opened, notify any waiting init steps */
     if (!fs_ready_initialized) {
         rc = property_set(FS_READY_PROPERTY, "1");

From 1752c5f2490354cc6a6e682c1580a8dff07c5aa3 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 18 Dec 2023 13:47:52 -0800
Subject: [PATCH 0634/1487] libsnapshot: Detach the daemon explicitly before
 stopping the service

If the daemon is alive, detach it before explicitly terminating service.

Bug: 316876960
Test: treehugger presubmit tests
Change-Id: I94d9d1a0dab09a6b016f422c7497098abc86add8
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshot_test.cpp | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index c0c3eafa3356..e538d503d736 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2864,15 +2864,23 @@ void SnapshotTestEnvironment::TearDown() {
 }
 
 void KillSnapuserd() {
-    auto status = android::base::GetProperty("init.svc.snapuserd", "stopped");
-    if (status == "stopped") {
-        return;
-    }
-    auto snapuserd_client = SnapuserdClient::Connect(kSnapuserdSocket, 5s);
-    if (!snapuserd_client) {
-        return;
+    // Detach the daemon if it's alive
+    auto snapuserd_client = SnapuserdClient::TryConnect(kSnapuserdSocket, 5s);
+    if (snapuserd_client) {
+        snapuserd_client->DetachSnapuserd();
+    }
+
+    // Now stop the service - Init will send a SIGKILL to the daemon. However,
+    // process state will move from "running" to "stopping". Only after the
+    // process is reaped by init, the service state is moved to "stopped".
+    //
+    // Since the tests involve starting the daemon immediately, wait for the
+    // process to completely stop (aka. wait until init reaps the terminated
+    // process).
+    android::base::SetProperty("ctl.stop", "snapuserd");
+    if (!android::base::WaitForProperty("init.svc.snapuserd", "stopped", 10s)) {
+        LOG(ERROR) << "Timed out waiting for snapuserd to stop.";
     }
-    snapuserd_client->DetachSnapuserd();
 }
 
 }  // namespace snapshot

From 731972b0860c8f5430dfddcd61cd55632f3c1184 Mon Sep 17 00:00:00 2001
From: Hansen Kurli <hkurli@google.com>
Date: Tue, 19 Dec 2023 18:38:27 +0800
Subject: [PATCH 0635/1487] Create directory for /data/misc/connectivityblobdb

Create a new folder for connectivity blobs, to be used by
ConnectivityBlobStore for VPN and WIFI to replace legacy
keystore. System server and Settings app will need permissions
to manage databases in the folder.

Bug: 307903113
Test: build and manual test to confirm folder is created.
Change-Id: I3b558d8d5913e0d3d1efe5cb56d5f7f2e84fd22a
---
 rootdir/init.rc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index fb6473666d7c..88618ebf37d7 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -817,6 +817,8 @@ on post-fs-data
     mkdir /data/misc/odsign 0710 root system
     # directory used for odsign metrics
     mkdir /data/misc/odsign/metrics 0770 root system
+    # directory used for connectivity blob store.
+    mkdir /data/misc/connectivityblobdb 0770 system system
 
     # Directory for VirtualizationService temporary image files.
     # Delete any stale files owned by the old virtualizationservice uid (b/230056726).

From a008c9c1a4ff5f8666fefb57d9ced1c60b81a1a5 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 7 Dec 2023 14:04:02 -0800
Subject: [PATCH 0636/1487] Support batching ops across Add*Blocks() call

Performance of V3 COW writer is now on-par with V2 in both incremental
OTA and full OTA.

Test: th
Bug: 313962438
Change-Id: If56e0fe42367f947c513fc4c93119c3825763cb9
---
 .../include/libsnapshot/cow_format.h          |   4 +-
 .../libsnapshot_cow/cow_format.cpp            |   4 +
 .../libsnapshot/libsnapshot_cow/parser_v3.cpp |   6 +
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   |  10 ++
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 168 ++++++++++--------
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |  13 +-
 6 files changed, 125 insertions(+), 80 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 6b3415241fa3..9401c6626875 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -107,7 +107,7 @@ struct ResumePoint {
 static constexpr uint8_t kNumResumePoints = 4;
 
 struct CowHeaderV3 : public CowHeader {
-    // Number of sequence data stored (each of which is a 32 byte integer)
+    // Number of sequence data stored (each of which is a 32 bit integer)
     uint64_t sequence_data_count;
     // Number of currently written resume points &&
     uint32_t resume_point_count;
@@ -311,6 +311,8 @@ std::ostream& operator<<(std::ostream& os, CowOperationV3 const& arg);
 
 std::ostream& operator<<(std::ostream& os, ResumePoint const& arg);
 
+std::ostream& operator<<(std::ostream& os, CowOperationType cow_type);
+
 int64_t GetNextOpOffset(const CowOperationV2& op, uint32_t cluster_size);
 int64_t GetNextDataOffset(const CowOperationV2& op, uint32_t cluster_size);
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
index b0eb72354b57..8d1786c56046 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
@@ -52,6 +52,10 @@ std::ostream& EmitCowTypeString(std::ostream& os, CowOperationType cow_type) {
     }
 }
 
+std::ostream& operator<<(std::ostream& os, CowOperationType cow_type) {
+    return EmitCowTypeString(os, cow_type);
+}
+
 std::ostream& operator<<(std::ostream& os, CowOperationV2 const& op) {
     os << "CowOperationV2(";
     EmitCowTypeString(os, op.type) << ", ";
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
index ce68b39f8844..036d3351c725 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v3.cpp
@@ -114,6 +114,12 @@ bool CowParserV3::ParseOps(borrowed_fd fd, const uint32_t op_index) {
     for (auto op : *ops_) {
         if (op.type() == kCowXorOp) {
             xor_data_loc_->insert({op.new_block, data_pos});
+        } else if (op.type() == kCowReplaceOp) {
+            if (data_pos != op.source()) {
+                LOG(ERROR) << "Invalid data location for operation " << op
+                           << ", expected: " << data_pos;
+                return false;
+            }
         }
         data_pos += op.data_length;
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 500f8d08c7de..3383a5862240 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -688,5 +688,15 @@ TEST_F(CowTestV3, CopyOpMany) {
     }
 }
 
+TEST_F(CowTestV3, CheckOpCount) {
+    CowOptions options;
+    options.op_count_max = 20;
+    options.batch_write = true;
+    options.cluster_ops = 200;
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+    ASSERT_TRUE(writer->AddZeroBlocks(0, 19));
+    ASSERT_FALSE(writer->AddZeroBlocks(0, 19));
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index c56e22ab96ef..d99e6e6d6a6b 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -71,9 +71,6 @@ void CowWriterV3::SetupHeaders() {
     header_.block_size = options_.block_size;
     header_.num_merge_ops = options_.num_merge_ops;
     header_.cluster_ops = 0;
-    if (batch_size_ > 1) {
-        LOG(INFO) << "Batch writes enabled with batch size of " << batch_size_;
-    }
     if (options_.scratch_space) {
         header_.buffer_size = BUFFER_REGION_DEFAULT_SIZE;
     }
@@ -82,6 +79,7 @@ void CowWriterV3::SetupHeaders() {
     // WIP: not quite sure how some of these are calculated yet, assuming buffer_size is determined
     // during COW size estimation
     header_.sequence_data_count = 0;
+
     header_.resume_point_count = 0;
     header_.resume_point_max = kNumResumePoints;
     header_.op_count = 0;
@@ -123,6 +121,19 @@ bool CowWriterV3::ParseOptions() {
             LOG(ERROR) << "Failed to create compressor for " << compression_.algorithm;
             return false;
         }
+        if (options_.cluster_ops &&
+            (android::base::GetBoolProperty("ro.virtual_ab.batch_writes", false) ||
+             options_.batch_write)) {
+            batch_size_ = std::max<size_t>(options_.cluster_ops, 1);
+            data_vec_.reserve(batch_size_);
+            cached_data_.reserve(batch_size_);
+            cached_ops_.reserve(batch_size_);
+        }
+    }
+    if (batch_size_ > 1) {
+        LOG(INFO) << "Batch writes: enabled with batch size " << batch_size_;
+    } else {
+        LOG(INFO) << "Batch writes: disabled";
     }
     return true;
 }
@@ -220,8 +231,9 @@ bool CowWriterV3::CheckOpCount(size_t op_count) {
     if (IsEstimating()) {
         return true;
     }
-    if (header_.op_count + op_count > header_.op_count_max) {
+    if (header_.op_count + cached_ops_.size() + op_count > header_.op_count_max) {
         LOG(ERROR) << "Current number of ops on disk: " << header_.op_count
+                   << ", number of ops cached in memory: " << cached_ops_.size()
                    << ", number of ops attempting to write: " << op_count
                    << ", this will exceed max op count " << header_.op_count_max;
         return false;
@@ -233,17 +245,18 @@ bool CowWriterV3::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_
     if (!CheckOpCount(num_blocks)) {
         return false;
     }
-    std::vector<CowOperationV3> ops(num_blocks);
     for (size_t i = 0; i < num_blocks; i++) {
-        CowOperationV3& op = ops[i];
+        CowOperationV3& op = cached_ops_.emplace_back();
         op.set_type(kCowCopyOp);
         op.new_block = new_block + i;
         op.set_source(old_block + i);
     }
-    if (!WriteOperation({ops.data(), ops.size()}, {})) {
-        return false;
-    }
 
+    if (NeedsFlush()) {
+        if (!FlushCacheOps()) {
+            return false;
+        }
+    }
     return true;
 }
 
@@ -262,6 +275,13 @@ bool CowWriterV3::EmitXorBlocks(uint32_t new_block_start, const void* data, size
     return EmitBlocks(new_block_start, data, size, old_block, offset, kCowXorOp);
 }
 
+bool CowWriterV3::NeedsFlush() const {
+    // Allow bigger batch sizes for ops without data. A single CowOperationV3
+    // struct uses 14 bytes of memory, even if we cache 200 * 16 ops in memory,
+    // it's only ~44K.
+    return cached_data_.size() >= batch_size_ || cached_ops_.size() >= batch_size_ * 16;
+}
+
 bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t size,
                              uint64_t old_block, uint16_t offset, CowOperationType type) {
     if (compression_.algorithm != kCowCompressNone && compressor_ == nullptr) {
@@ -270,34 +290,18 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
         return false;
     }
     const size_t num_blocks = (size / header_.block_size);
-    if (compression_.algorithm == kCowCompressNone) {
-        std::vector<CowOperationV3> ops(num_blocks);
-        for (size_t i = 0; i < num_blocks; i++) {
-            CowOperation& op = ops[i];
-            op.new_block = new_block_start + i;
 
-            op.set_type(type);
-            if (type == kCowXorOp) {
-                op.set_source((old_block + i) * header_.block_size + offset);
-            } else {
-                op.set_source(next_data_pos_ + header_.block_size * i);
-            }
-            op.data_length = header_.block_size;
-        }
-        return WriteOperation({ops.data(), ops.size()}, data, size);
-    }
-
-    for (size_t i = 0; i < num_blocks; i += batch_size_) {
-        const auto blocks_to_write = std::min<size_t>(batch_size_, num_blocks - i);
-        std::vector<std::basic_string<uint8_t>> compressed_blocks(blocks_to_write);
-        std::vector<CowOperationV3> ops(blocks_to_write);
-        std::vector<struct iovec> vec(blocks_to_write);
+    for (size_t i = 0; i < num_blocks;) {
+        const auto blocks_to_write =
+                std::min<size_t>(batch_size_ - cached_data_.size(), num_blocks - i);
         size_t compressed_bytes = 0;
         for (size_t j = 0; j < blocks_to_write; j++) {
             const uint8_t* const iter =
                     reinterpret_cast<const uint8_t*>(data) + (header_.block_size * (i + j));
 
-            CowOperation& op = ops[j];
+            CowOperation& op = cached_ops_.emplace_back();
+            auto& vec = data_vec_.emplace_back();
+            auto& compressed_data = cached_data_.emplace_back();
             op.new_block = new_block_start + i + j;
 
             op.set_type(type);
@@ -306,29 +310,31 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
             } else {
                 op.set_source(next_data_pos_ + compressed_bytes);
             }
-
-            std::basic_string<uint8_t> compressed_data =
-                    compressor_->Compress(iter, header_.block_size);
-            if (compressed_data.empty()) {
-                LOG(ERROR) << "Compression failed during EmitBlocks(" << new_block_start << ", "
-                           << num_blocks << ");";
-                return false;
+            if (compression_.algorithm == kCowCompressNone) {
+                compressed_data.resize(header_.block_size);
+            } else {
+                compressed_data = compressor_->Compress(iter, header_.block_size);
+                if (compressed_data.empty()) {
+                    LOG(ERROR) << "Compression failed during EmitBlocks(" << new_block_start << ", "
+                               << num_blocks << ");";
+                    return false;
+                }
             }
             if (compressed_data.size() >= header_.block_size) {
                 compressed_data.resize(header_.block_size);
                 std::memcpy(compressed_data.data(), iter, header_.block_size);
             }
-            compressed_blocks[j] = std::move(compressed_data);
-            vec[j] = {.iov_base = compressed_blocks[j].data(),
-                      .iov_len = compressed_blocks[j].size()};
-            op.data_length = vec[j].iov_len;
+            vec = {.iov_base = compressed_data.data(), .iov_len = compressed_data.size()};
+            op.data_length = vec.iov_len;
             compressed_bytes += op.data_length;
         }
-        if (!WriteOperation({ops.data(), ops.size()}, {vec.data(), vec.size()})) {
-            PLOG(ERROR) << "AddRawBlocks with compression: write failed. new block: "
-                        << new_block_start << " compression: " << compression_.algorithm;
+        if (NeedsFlush() && !FlushCacheOps()) {
+            LOG(ERROR) << "EmitBlocks with compression: write failed. new block: "
+                       << new_block_start << " compression: " << compression_.algorithm
+                       << ", op type: " << type;
             return false;
         }
+        i += blocks_to_write;
     }
 
     return true;
@@ -338,14 +344,15 @@ bool CowWriterV3::EmitZeroBlocks(uint64_t new_block_start, const uint64_t num_bl
     if (!CheckOpCount(num_blocks)) {
         return false;
     }
-    std::vector<CowOperationV3> ops(num_blocks);
     for (uint64_t i = 0; i < num_blocks; i++) {
-        auto& op = ops[i];
+        auto& op = cached_ops_.emplace_back();
         op.set_type(kCowZeroOp);
         op.new_block = new_block_start + i;
     }
-    if (!WriteOperation({ops.data(), ops.size()})) {
-        return false;
+    if (NeedsFlush()) {
+        if (!FlushCacheOps()) {
+            return false;
+        }
     }
     return true;
 }
@@ -354,6 +361,10 @@ bool CowWriterV3::EmitLabel(uint64_t label) {
     // remove all labels greater than this current one. we want to avoid the situation of adding
     // in
     // duplicate labels with differing op values
+    if (!FlushCacheOps()) {
+        LOG(ERROR) << "Failed to flush cached ops before emitting label " << label;
+        return false;
+    }
     auto remove_if_callback = [&](const auto& resume_point) -> bool {
         if (resume_point.label >= label) return true;
         return false;
@@ -382,19 +393,14 @@ bool CowWriterV3::EmitLabel(uint64_t label) {
 
 bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
     // TODO: size sequence buffer based on options
-    if (header_.op_count > 0) {
-        LOG(ERROR)
-                << "There's " << header_.op_count
-                << " operations written to disk. Writing sequence data is only allowed before all "
-                   "operation writes.";
+    if (header_.op_count > 0 || !cached_ops_.empty()) {
+        LOG(ERROR) << "There's " << header_.op_count << " operations written to disk and "
+                   << cached_ops_.size()
+                   << " ops cached in memory. Writing sequence data is only allowed before all "
+                      "operation writes.";
         return false;
     }
     header_.sequence_data_count = num_ops;
-    // In COW format v3, data section is placed after op section and sequence
-    // data section. Therefore, changing the sequence data count has the effect
-    // of moving op section and data section. Therefore we need to reset the
-    // value of |next_data_pos|. This is also the reason why writing sequence
-    // data is only allowed if there's no operation written.
     next_data_pos_ = GetDataOffset(header_);
     if (!android::base::WriteFullyAtOffset(fd_, data, sizeof(data[0]) * num_ops,
                                            GetSequenceOffset(header_))) {
@@ -404,16 +410,32 @@ bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
     return true;
 }
 
-bool CowWriterV3::WriteOperation(std::basic_string_view<CowOperationV3> op, const void* data,
-                                 size_t size) {
-    struct iovec vec {
-        .iov_len = size
-    };
-    // Dear C++ god, this is effectively a const_cast. I had to do this because
-    // pwritev()'s struct iovec requires a non-const pointer. The input data
-    // will not be modified, as the iovec is only used for a write operation.
-    std::memcpy(&vec.iov_base, &data, sizeof(data));
-    return WriteOperation(op, {&vec, 1});
+bool CowWriterV3::FlushCacheOps() {
+    if (cached_ops_.empty()) {
+        if (!data_vec_.empty()) {
+            LOG(ERROR) << "Cached ops is empty, but data iovec has size: " << data_vec_.size()
+                       << " this is definitely a bug.";
+            return false;
+        }
+        return true;
+    }
+    size_t bytes_written = 0;
+
+    for (auto& op : cached_ops_) {
+        if (op.type() == kCowReplaceOp) {
+            op.set_source(next_data_pos_ + bytes_written);
+        }
+        bytes_written += op.data_length;
+    }
+    if (!WriteOperation({cached_ops_.data(), cached_ops_.size()},
+                        {data_vec_.data(), data_vec_.size()})) {
+        LOG(ERROR) << "Failed to flush " << cached_ops_.size() << " ops to disk";
+        return false;
+    }
+    cached_ops_.clear();
+    cached_data_.clear();
+    data_vec_.clear();
+    return true;
 }
 
 bool CowWriterV3::WriteOperation(std::basic_string_view<CowOperationV3> ops,
@@ -438,7 +460,6 @@ bool CowWriterV3::WriteOperation(std::basic_string_view<CowOperationV3> ops,
                    << ops.size() << " ops will exceed the max of " << header_.op_count_max;
         return false;
     }
-
     const off_t offset = GetOpOffset(header_.op_count, header_);
     if (!android::base::WriteFullyAtOffset(fd_, ops.data(), ops.size() * sizeof(ops[0]), offset)) {
         PLOG(ERROR) << "Write failed for " << ops.size() << " ops at " << offset;
@@ -458,13 +479,12 @@ bool CowWriterV3::WriteOperation(std::basic_string_view<CowOperationV3> ops,
     return true;
 }
 
-bool CowWriterV3::WriteOperation(const CowOperationV3& op, const void* data, size_t size) {
-    return WriteOperation({&op, 1}, data, size);
-}
-
 bool CowWriterV3::Finalize() {
     CHECK_GE(header_.prefix.header_size, sizeof(CowHeaderV3));
     CHECK_LE(header_.prefix.header_size, sizeof(header_));
+    if (!FlushCacheOps()) {
+        return false;
+    }
     if (!android::base::WriteFullyAtOffset(fd_, &header_, header_.prefix.header_size, 0)) {
         return false;
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 613bbe5fe875..3a7b87789688 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -16,6 +16,7 @@
 
 #include <android-base/logging.h>
 #include <string_view>
+#include <vector>
 
 #include "writer_base.h"
 
@@ -42,20 +43,20 @@ class CowWriterV3 : public CowWriterBase {
 
   private:
     void SetupHeaders();
+    bool NeedsFlush() const;
     bool ParseOptions();
     bool OpenForWrite();
     bool OpenForAppend(uint64_t label);
     bool WriteOperation(std::basic_string_view<CowOperationV3> op,
                         std::basic_string_view<struct iovec> data);
-    bool WriteOperation(std::basic_string_view<CowOperationV3> op, const void* data = nullptr,
-                        size_t size = 0);
-    bool WriteOperation(const CowOperationV3& op, const void* data = nullptr, size_t size = 0);
     bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
                     uint16_t offset, CowOperationType type);
     bool CompressBlocks(size_t num_blocks, const void* data);
     bool CheckOpCount(size_t op_count);
 
   private:
+    bool ReadBackVerification();
+    bool FlushCacheOps();
     CowHeaderV3 header_{};
     CowCompression compression_;
     // in the case that we are using one thread for compression, we can store and re-use the same
@@ -66,12 +67,14 @@ class CowWriterV3 : public CowWriterBase {
     std::shared_ptr<std::vector<ResumePoint>> resume_points_;
 
     uint64_t next_data_pos_ = 0;
-    std::vector<std::basic_string<uint8_t>> compressed_buf_;
 
     // in the case that we are using one thread for compression, we can store and re-use the same
     // compressor
     int num_compress_threads_ = 1;
-    size_t batch_size_ = 0;
+    size_t batch_size_ = 1;
+    std::vector<CowOperationV3> cached_ops_;
+    std::vector<std::basic_string<uint8_t>> cached_data_;
+    std::vector<struct iovec> data_vec_;
 };
 
 }  // namespace snapshot

From 66dc7b7b992fd6084467ac930cc4226836085e5d Mon Sep 17 00:00:00 2001
From: Seungjae Yoo <seungjaeyoo@google.com>
Date: Fri, 15 Dec 2023 15:44:47 +0900
Subject: [PATCH 0637/1487] Support dm-verity with verification based on root
 digest

Currently the only ways to enable dm-verity were relying on its built-in
vbmeta image or containing its public key on standalone vbmeta image.
Merging this change will support enabling dm-verity based on hashtree
descriptor root digest for standalone vbmeta image.

Bug: 285855436
Test: Presubmit
Test: adb shell /apex/com.android.virt/bin/vm run-microdroid --vendor /vendor/etc/avf/microdroid/microdroid_vendor.img
Change-Id: I51eb64cae2ca8b4e97f1c6419b35d45e6f51cacb
---
 fs_mgr/libfs_avb/fs_avb.cpp           | 120 ++++++++++++++++++--------
 fs_mgr/libfstab/fstab.cpp             |   4 +
 fs_mgr/libfstab/include/fstab/fstab.h |   1 +
 init/first_stage_mount.cpp            |  63 +++++++++-----
 4 files changed, 133 insertions(+), 55 deletions(-)

diff --git a/fs_mgr/libfs_avb/fs_avb.cpp b/fs_mgr/libfs_avb/fs_avb.cpp
index fb224230fe4c..be48de6cc835 100644
--- a/fs_mgr/libfs_avb/fs_avb.cpp
+++ b/fs_mgr/libfs_avb/fs_avb.cpp
@@ -288,14 +288,82 @@ static bool IsAvbPermissive() {
     return false;
 }
 
-AvbUniquePtr AvbHandle::LoadAndVerifyVbmeta(const FstabEntry& fstab_entry,
-                                            const std::vector<std::string>& preload_avb_key_blobs) {
+bool IsPublicKeyMatching(const FstabEntry& fstab_entry, const std::string& public_key_data,
+                         const std::vector<std::string>& preload_avb_key_blobs) {
     // At least one of the following should be provided for public key matching.
     if (preload_avb_key_blobs.empty() && fstab_entry.avb_keys.empty()) {
         LERROR << "avb_keys=/path/to/key(s) is missing for " << fstab_entry.mount_point;
-        return nullptr;
+        return false;
+    }
+
+    // Expected key shouldn't be empty.
+    if (public_key_data.empty()) {
+        LERROR << "public key data shouldn't be empty for " << fstab_entry.mount_point;
+        return false;
     }
 
+    // Performs key matching for preload_avb_key_blobs first, if it is present.
+    if (!preload_avb_key_blobs.empty()) {
+        if (std::find(preload_avb_key_blobs.begin(), preload_avb_key_blobs.end(),
+                      public_key_data) != preload_avb_key_blobs.end()) {
+            return true;
+        }
+    }
+
+    // Performs key matching for fstab_entry.avb_keys if necessary.
+    // Note that it is intentional to match both preload_avb_key_blobs and fstab_entry.avb_keys.
+    // Some keys might only be available before init chroots into /system, e.g., /avb/key1
+    // in the first-stage ramdisk, while other keys might only be available after the chroot,
+    // e.g., /system/etc/avb/key2.
+    // fstab_entry.avb_keys might be either a directory containing multiple keys,
+    // or a string indicating multiple keys separated by ':'.
+    std::vector<std::string> allowed_avb_keys;
+    auto list_avb_keys_in_dir = ListFiles(fstab_entry.avb_keys);
+    if (list_avb_keys_in_dir.ok()) {
+        std::sort(list_avb_keys_in_dir->begin(), list_avb_keys_in_dir->end());
+        allowed_avb_keys = *list_avb_keys_in_dir;
+    } else {
+        allowed_avb_keys = Split(fstab_entry.avb_keys, ":");
+    }
+    return ValidatePublicKeyBlob(public_key_data, allowed_avb_keys);
+}
+
+bool IsHashtreeDescriptorRootDigestMatching(const FstabEntry& fstab_entry,
+                                            const std::vector<VBMetaData>& vbmeta_images,
+                                            const std::string& ab_suffix,
+                                            const std::string& ab_other_suffix) {
+    // Read expected value of hashtree descriptor root digest from fstab_entry.
+    std::string root_digest_expected;
+    if (!ReadFileToString(fstab_entry.avb_hashtree_digest, &root_digest_expected)) {
+        LERROR << "Failed to load expected root digest for " << fstab_entry.mount_point;
+        return false;
+    }
+
+    // Read actual hashtree descriptor from vbmeta image.
+    std::string partition_name = DeriveAvbPartitionName(fstab_entry, ab_suffix, ab_other_suffix);
+    if (partition_name.empty()) {
+        LERROR << "Failed to find partition name for " << fstab_entry.mount_point;
+        return false;
+    }
+    std::unique_ptr<FsAvbHashtreeDescriptor> hashtree_descriptor =
+            android::fs_mgr::GetHashtreeDescriptor(partition_name, vbmeta_images);
+    if (!hashtree_descriptor) {
+        LERROR << "Not found hashtree descriptor for " << fstab_entry.mount_point;
+        return false;
+    }
+
+    // Performs hashtree descriptor root digest matching.
+    if (hashtree_descriptor->root_digest != root_digest_expected) {
+        LERROR << "root digest (" << hashtree_descriptor->root_digest
+               << ") is different from expected value (" << root_digest_expected << ")";
+        return false;
+    }
+
+    return true;
+}
+
+AvbUniquePtr AvbHandle::LoadAndVerifyVbmeta(const FstabEntry& fstab_entry,
+                                            const std::vector<std::string>& preload_avb_key_blobs) {
     // Binds allow_verification_error and rollback_protection to device unlock state.
     bool allow_verification_error = IsAvbPermissive();
     bool rollback_protection = !allow_verification_error;
@@ -333,40 +401,24 @@ AvbUniquePtr AvbHandle::LoadAndVerifyVbmeta(const FstabEntry& fstab_entry,
             return nullptr;
     }
 
-    bool public_key_match = false;
-    // Performs key matching for preload_avb_key_blobs first, if it is present.
-    if (!public_key_data.empty() && !preload_avb_key_blobs.empty()) {
-        if (std::find(preload_avb_key_blobs.begin(), preload_avb_key_blobs.end(),
-                      public_key_data) != preload_avb_key_blobs.end()) {
-            public_key_match = true;
-        }
-    }
-    // Performs key matching for fstab_entry.avb_keys if necessary.
-    // Note that it is intentional to match both preload_avb_key_blobs and fstab_entry.avb_keys.
-    // Some keys might only be availble before init chroots into /system, e.g., /avb/key1
-    // in the first-stage ramdisk, while other keys might only be available after the chroot,
-    // e.g., /system/etc/avb/key2.
-    if (!public_key_data.empty() && !public_key_match) {
-        // fstab_entry.avb_keys might be either a directory containing multiple keys,
-        // or a string indicating multiple keys separated by ':'.
-        std::vector<std::string> allowed_avb_keys;
-        auto list_avb_keys_in_dir = ListFiles(fstab_entry.avb_keys);
-        if (list_avb_keys_in_dir.ok()) {
-            std::sort(list_avb_keys_in_dir->begin(), list_avb_keys_in_dir->end());
-            allowed_avb_keys = *list_avb_keys_in_dir;
-        } else {
-            allowed_avb_keys = Split(fstab_entry.avb_keys, ":");
-        }
-        if (ValidatePublicKeyBlob(public_key_data, allowed_avb_keys)) {
-            public_key_match = true;
+    // Verify vbmeta image checking by either public key or hashtree descriptor root digest.
+    if (!preload_avb_key_blobs.empty() || !fstab_entry.avb_keys.empty()) {
+        if (!IsPublicKeyMatching(fstab_entry, public_key_data, preload_avb_key_blobs)) {
+            avb_handle->status_ = AvbHandleStatus::kVerificationError;
+            LWARNING << "Found unknown public key used to sign " << fstab_entry.mount_point;
+            if (!allow_verification_error) {
+                LERROR << "Unknown public key is not allowed";
+                return nullptr;
+            }
         }
-    }
-
-    if (!public_key_match) {
+    } else if (!IsHashtreeDescriptorRootDigestMatching(fstab_entry, avb_handle->vbmeta_images_,
+                                                       avb_handle->slot_suffix_,
+                                                       avb_handle->other_slot_suffix_)) {
         avb_handle->status_ = AvbHandleStatus::kVerificationError;
-        LWARNING << "Found unknown public key used to sign " << fstab_entry.mount_point;
+        LWARNING << "Found unknown hashtree descriptor root digest used on "
+                 << fstab_entry.mount_point;
         if (!allow_verification_error) {
-            LERROR << "Unknown public key is not allowed";
+            LERROR << "Verification based on root digest failed. Vbmeta image is not allowed.";
             return nullptr;
         }
     }
diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index 32460b17b5e1..60ec40f5fee2 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -286,6 +286,10 @@ bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
             }
         } else if (StartsWith(flag, "avb_keys=")) {  // must before the following "avb"
             entry->avb_keys = arg;
+        } else if (StartsWith(flag, "avb_hashtree_digest=")) {
+            // "avb_hashtree_digest" must before the following "avb"
+            // The path where hex-encoded hashtree descriptor root digest is located.
+            entry->avb_hashtree_digest = arg;
         } else if (StartsWith(flag, "avb")) {
             entry->fs_mgr_flags.avb = true;
             entry->vbmeta_partition = arg;
diff --git a/fs_mgr/libfstab/include/fstab/fstab.h b/fs_mgr/libfstab/include/fstab/fstab.h
index 09471f087f6c..5e4019ca17ff 100644
--- a/fs_mgr/libfstab/include/fstab/fstab.h
+++ b/fs_mgr/libfstab/include/fstab/fstab.h
@@ -57,6 +57,7 @@ struct FstabEntry {
     uint64_t zram_backingdev_size = 0;
     std::string avb_keys;
     std::string lowerdir;
+    std::string avb_hashtree_digest;
 
     struct FsMgrFlags {
         bool wait : 1;
diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index d0f68a80c26b..b5292a40768e 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -732,6 +732,15 @@ bool FirstStageMountVBootV2::GetDmVerityDevices(std::set<std::string>* devices)
     return true;
 }
 
+bool IsHashtreeDisabled(const AvbHandle& vbmeta, std::string mount_point) {
+    if (vbmeta.status() == AvbHandleStatus::kHashtreeDisabled ||
+        vbmeta.status() == AvbHandleStatus::kVerificationDisabled) {
+        LOG(ERROR) << "Top-level vbmeta is disabled, skip Hashtree setup for " << mount_point;
+        return true;  // Returns true to mount the partition directly.
+    }
+    return false;
+}
+
 bool FirstStageMountVBootV2::SetUpDmVerity(FstabEntry* fstab_entry) {
     AvbHashtreeResult hashtree_result;
 
@@ -740,34 +749,46 @@ bool FirstStageMountVBootV2::SetUpDmVerity(FstabEntry* fstab_entry) {
     if (!fstab_entry->avb_keys.empty()) {
         if (!InitAvbHandle()) return false;
         // Checks if hashtree should be disabled from the top-level /vbmeta.
-        if (avb_handle_->status() == AvbHandleStatus::kHashtreeDisabled ||
-            avb_handle_->status() == AvbHandleStatus::kVerificationDisabled) {
-            LOG(ERROR) << "Top-level vbmeta is disabled, skip Hashtree setup for "
-                       << fstab_entry->mount_point;
-            return true;  // Returns true to mount the partition directly.
+        if (IsHashtreeDisabled(*avb_handle_, fstab_entry->mount_point)) {
+            return true;
+        }
+        auto avb_standalone_handle = AvbHandle::LoadAndVerifyVbmeta(
+                *fstab_entry, preload_avb_key_blobs_[fstab_entry->avb_keys]);
+        if (!avb_standalone_handle) {
+            LOG(ERROR) << "Failed to load offline vbmeta for " << fstab_entry->mount_point;
+            // Fallbacks to built-in hashtree if fs_mgr_flags.avb is set.
+            if (!fstab_entry->fs_mgr_flags.avb) return false;
+            LOG(INFO) << "Fallback to built-in hashtree for " << fstab_entry->mount_point;
+            hashtree_result =
+                    avb_handle_->SetUpAvbHashtree(fstab_entry, false /* wait_for_verity_dev */);
         } else {
-            auto avb_standalone_handle = AvbHandle::LoadAndVerifyVbmeta(
-                    *fstab_entry, preload_avb_key_blobs_[fstab_entry->avb_keys]);
-            if (!avb_standalone_handle) {
-                LOG(ERROR) << "Failed to load offline vbmeta for " << fstab_entry->mount_point;
-                // Fallbacks to built-in hashtree if fs_mgr_flags.avb is set.
-                if (!fstab_entry->fs_mgr_flags.avb) return false;
-                LOG(INFO) << "Fallback to built-in hashtree for " << fstab_entry->mount_point;
-                hashtree_result =
-                        avb_handle_->SetUpAvbHashtree(fstab_entry, false /* wait_for_verity_dev */);
-            } else {
-                // Sets up hashtree via the standalone handle.
-                if (IsStandaloneImageRollback(*avb_handle_, *avb_standalone_handle, *fstab_entry)) {
-                    return false;
-                }
-                hashtree_result = avb_standalone_handle->SetUpAvbHashtree(
-                        fstab_entry, false /* wait_for_verity_dev */);
+            // Sets up hashtree via the standalone handle.
+            if (IsStandaloneImageRollback(*avb_handle_, *avb_standalone_handle, *fstab_entry)) {
+                return false;
             }
+            hashtree_result = avb_standalone_handle->SetUpAvbHashtree(
+                    fstab_entry, false /* wait_for_verity_dev */);
         }
     } else if (fstab_entry->fs_mgr_flags.avb) {
         if (!InitAvbHandle()) return false;
         hashtree_result =
                 avb_handle_->SetUpAvbHashtree(fstab_entry, false /* wait_for_verity_dev */);
+    } else if (!fstab_entry->avb_hashtree_digest.empty()) {
+        // When fstab_entry has neither avb_keys nor avb flag, try using
+        // avb_hashtree_digest.
+        if (!InitAvbHandle()) return false;
+        // Checks if hashtree should be disabled from the top-level /vbmeta.
+        if (IsHashtreeDisabled(*avb_handle_, fstab_entry->mount_point)) {
+            return true;
+        }
+        auto avb_standalone_handle = AvbHandle::LoadAndVerifyVbmeta(*fstab_entry);
+        if (!avb_standalone_handle) {
+            LOG(ERROR) << "Failed to load vbmeta based on hashtree descriptor root digest for "
+                       << fstab_entry->mount_point;
+            return false;
+        }
+        hashtree_result = avb_standalone_handle->SetUpAvbHashtree(fstab_entry,
+                                                                  false /* wait_for_verity_dev */);
     } else {
         return true;  // No need AVB, returns true to mount the partition directly.
     }

From ebbf9753e9520e9ae6e789b7463eb6d201bd0f07 Mon Sep 17 00:00:00 2001
From: Kiyoung Kim <kiyoungkim@google.com>
Date: Wed, 29 Nov 2023 13:55:54 +0900
Subject: [PATCH 0638/1487] Deprecate android_is_in_vendor_process

android_is_in_vnedor_process previously checked if current process is in
system(-ish) section by trying to open vndk namespace. However, this
would not work once VNDK is deprecated. As there is no clear way to
replace this, and there is few usage on this API, it would be better
deprecated, and be implemented from each module if required.

Bug: 300366609
Test: AOSP CF build and boot succeeded
Change-Id: I70c70efb36199e12d4877ea4ecb39dbf94653551
---
 libvndksupport/include/vndksupport/linker.h | 11 ++---------
 libvndksupport/libvndksupport.map.txt       |  2 +-
 2 files changed, 3 insertions(+), 10 deletions(-)

diff --git a/libvndksupport/include/vndksupport/linker.h b/libvndksupport/include/vndksupport/linker.h
index 5f48c3974851..684513565242 100644
--- a/libvndksupport/include/vndksupport/linker.h
+++ b/libvndksupport/include/vndksupport/linker.h
@@ -20,15 +20,8 @@
 extern "C" {
 #endif
 
-/*
- * Returns whether the current process is a vendor process.
- *
- * Note that this is only checking what process is running and has nothing to
- * do with what namespace the caller is loaded at.  For example, a VNDK-SP
- * library loaded by SP-HAL calling this function may still get a 'false',
- * because it is running in a system process.
- */
-int android_is_in_vendor_process();
+int android_is_in_vendor_process() __attribute__((
+        deprecated("This function would not give exact result if VNDK is deprecated.")));
 
 void* android_load_sphal_library(const char* name, int flag);
 
diff --git a/libvndksupport/libvndksupport.map.txt b/libvndksupport/libvndksupport.map.txt
index 1d94b9dcb59a..fc2502dcb518 100644
--- a/libvndksupport/libvndksupport.map.txt
+++ b/libvndksupport/libvndksupport.map.txt
@@ -1,6 +1,6 @@
 LIBVNDKSUPPORT {
   global:
-    android_is_in_vendor_process; # llndk systemapi
+    android_is_in_vendor_process; # systemapi
     android_load_sphal_library; # llndk systemapi
     android_unload_sphal_library; # llndk systemapi
   local:

From 54db200b21c68d7e487bd1bdc65b431457b13fe1 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Thu, 21 Dec 2023 02:07:34 +0000
Subject: [PATCH 0639/1487] try llndk-deprecate

No implementation required - seems to be ignored rather
than a failure

FIXME: should use vendor version, and be squashed into parent CL?

Bug: 300366609
Test: build
Change-Id: I19fd3871085f435c6ec55ac5e15e4769d7f3e450
---
 libvndksupport/libvndksupport.map.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libvndksupport/libvndksupport.map.txt b/libvndksupport/libvndksupport.map.txt
index fc2502dcb518..325505dde326 100644
--- a/libvndksupport/libvndksupport.map.txt
+++ b/libvndksupport/libvndksupport.map.txt
@@ -1,6 +1,6 @@
 LIBVNDKSUPPORT {
   global:
-    android_is_in_vendor_process; # systemapi
+    android_is_in_vendor_process; # llndk-deprecated=35 systemapi
     android_load_sphal_library; # llndk systemapi
     android_unload_sphal_library; # llndk systemapi
   local:

From f5d8773169bbe355597d2a584560963670c99c70 Mon Sep 17 00:00:00 2001
From: Seungjae Yoo <seungjaeyoo@google.com>
Date: Fri, 22 Dec 2023 10:11:55 +0900
Subject: [PATCH 0640/1487] Small fix: Use const value on IsHashreeDisabled

Bug: N/A
Test: Presubmit
Change-Id: I2167ac6d022c2c8c96febf2fc82eb3bba6fb6541
---
 init/first_stage_mount.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index b5292a40768e..c0b928139a15 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -732,7 +732,7 @@ bool FirstStageMountVBootV2::GetDmVerityDevices(std::set<std::string>* devices)
     return true;
 }
 
-bool IsHashtreeDisabled(const AvbHandle& vbmeta, std::string mount_point) {
+bool IsHashtreeDisabled(const AvbHandle& vbmeta, const std::string& mount_point) {
     if (vbmeta.status() == AvbHandleStatus::kHashtreeDisabled ||
         vbmeta.status() == AvbHandleStatus::kVerificationDisabled) {
         LOG(ERROR) << "Top-level vbmeta is disabled, skip Hashtree setup for " << mount_point;

From ec3ef81fd93bfa62d77bd58fafa0bfa6516f0c97 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oleg=20Pet=C5=A1jonkin?= <petsjonkin@google.com>
Date: Fri, 22 Dec 2023 10:17:25 +0000
Subject: [PATCH 0641/1487] Revert "Small fix: Use const value on
 IsHashreeDisabled"

This reverts commit f5d8773169bbe355597d2a584560963670c99c70.

Reason for revert: Identified as culprit for broken tests: b/317470107

Change-Id: If599c688bb4bbe800270881451fa5ac1f6898aff
---
 init/first_stage_mount.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index c0b928139a15..b5292a40768e 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -732,7 +732,7 @@ bool FirstStageMountVBootV2::GetDmVerityDevices(std::set<std::string>* devices)
     return true;
 }
 
-bool IsHashtreeDisabled(const AvbHandle& vbmeta, const std::string& mount_point) {
+bool IsHashtreeDisabled(const AvbHandle& vbmeta, std::string mount_point) {
     if (vbmeta.status() == AvbHandleStatus::kHashtreeDisabled ||
         vbmeta.status() == AvbHandleStatus::kVerificationDisabled) {
         LOG(ERROR) << "Top-level vbmeta is disabled, skip Hashtree setup for " << mount_point;

From 4c4742f6784ebadf7c3824d8705fd2fcb463510d Mon Sep 17 00:00:00 2001
From: Greg Kaiser <gkaiser@google.com>
Date: Fri, 22 Dec 2023 20:03:05 +0000
Subject: [PATCH 0642/1487] Revert^2 "Small fix: Use const value on
 IsHashreeDisabled"

This reverts commit ec3ef81fd93bfa62d77bd58fafa0bfa6516f0c97.

Reason for revert: b/317470107 is an infrastructure error

Change-Id: If5a022cbfd016d9c55261c67a1a73d81cb336343
---
 init/first_stage_mount.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index b5292a40768e..c0b928139a15 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -732,7 +732,7 @@ bool FirstStageMountVBootV2::GetDmVerityDevices(std::set<std::string>* devices)
     return true;
 }
 
-bool IsHashtreeDisabled(const AvbHandle& vbmeta, std::string mount_point) {
+bool IsHashtreeDisabled(const AvbHandle& vbmeta, const std::string& mount_point) {
     if (vbmeta.status() == AvbHandleStatus::kHashtreeDisabled ||
         vbmeta.status() == AvbHandleStatus::kVerificationDisabled) {
         LOG(ERROR) << "Top-level vbmeta is disabled, skip Hashtree setup for " << mount_point;

From 9c48951d91aa2873d7e236d825b7a6d3f05c6797 Mon Sep 17 00:00:00 2001
From: Chun-Wei Wang <wangchun@google.com>
Date: Tue, 2 Jan 2024 14:59:53 +0800
Subject: [PATCH 0643/1487] Add help text for `fastboot gsi status`

Bug: 298533290
Test: fastboot -h
Change-Id: Icf91a980059aaa8e74e41af4036778fbbfbf1bd2
---
 fastboot/fastboot.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 235d7234fd6e..12a1ddc87571 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -571,7 +571,8 @@ static int show_help() {
             "                            Format a flash partition.\n"
             " set_active SLOT            Set the active slot.\n"
             " oem [COMMAND...]           Execute OEM-specific command.\n"
-            " gsi wipe|disable           Wipe or disable a GSI installation (fastbootd only).\n"
+            " gsi wipe|disable|status    Wipe, disable or show status of a GSI installation\n"
+            "                            (fastbootd only).\n"
             " wipe-super [SUPER_EMPTY]   Wipe the super partition. This will reset it to\n"
             "                            contain an empty set of default dynamic partitions.\n"
             " create-logical-partition NAME SIZE\n"

From 2be4bedea1f493e4843ce9d14a5707b6b60d87b1 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Thu, 21 Dec 2023 00:54:44 +0000
Subject: [PATCH 0644/1487] raise debuggerd_test timeout

Possible solution for b/317286869.

Test: N/A
Change-Id: I93743d596d5b8d7c867253d1aafc709453995fed
---
 debuggerd/debuggerd_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index a6d8226e3f09..8693fdddfba9 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -2236,7 +2236,7 @@ TEST(tombstoned, proto) {
   ASSERT_EQ(0, fstat(text_fd.get(), &text_st));
 
   // Give tombstoned some time to link the files into place.
-  std::this_thread::sleep_for(100ms);
+  std::this_thread::sleep_for(100ms * android::base::HwTimeoutMultiplier());
 
   // Find the tombstone.
   std::optional<std::string> tombstone_file;

From 4793330ad1adef7cc0fa9d1905d0f8d73041921b Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 2 Jan 2024 13:52:12 -0800
Subject: [PATCH 0645/1487] vts_fs_test: Drop restrictions on ext4 userdata.

Bug: 313335353
Test: vts_fs_test
Change-Id: I40be9589f18288ebe2a8569dfaceb9cd2150db85
---
 fs_mgr/tests/vts_fs_test.cpp | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/fs_mgr/tests/vts_fs_test.cpp b/fs_mgr/tests/vts_fs_test.cpp
index 8f152203946c..2f2db0c6c86a 100644
--- a/fs_mgr/tests/vts_fs_test.cpp
+++ b/fs_mgr/tests/vts_fs_test.cpp
@@ -99,12 +99,7 @@ TEST(fs, PartitionTypes) {
     ASSERT_TRUE(android::base::Readlink("/dev/block/by-name/super", &super_bdev));
     ASSERT_TRUE(android::base::Readlink("/dev/block/by-name/userdata", &userdata_bdev));
 
-    std::vector<std::string> must_be_f2fs = {"/data"};
-    if (vsr_level >= __ANDROID_API_U__ &&
-        !DeviceSupportsFeature("android.hardware.type.automotive")) {
-        must_be_f2fs.emplace_back("/metadata");
-    }
-
+    std::vector<std::string> data_fs = {"/data", "/metadata"};
     for (const auto& entry : fstab) {
         std::string parent_bdev = entry.blk_device;
         while (true) {
@@ -139,10 +134,8 @@ TEST(fs, PartitionTypes) {
             EXPECT_NE(std::find(allowed.begin(), allowed.end(), entry.fs_type), allowed.end())
                     << entry.mount_point;
         } else {
-            if (std::find(must_be_f2fs.begin(), must_be_f2fs.end(), entry.mount_point) !=
-                must_be_f2fs.end()) {
-                EXPECT_EQ(entry.fs_type, "f2fs") << entry.mount_point;
-            }
+            std::vector<std::string> allowed = {"ext4", "f2fs"};
+            EXPECT_NE(std::find(allowed.begin(), allowed.end(), entry.fs_type), allowed.end());
         }
     }
 }

From e6bc0264a9b51db8cba1a5889414970d102f4675 Mon Sep 17 00:00:00 2001
From: Spandan Das <spandandas@google.com>
Date: Tue, 2 Jan 2024 22:39:00 +0000
Subject: [PATCH 0646/1487] Make apex availability of libdebuggerd explicit

The availability to runtime apex was done implicitly using a baseline map in
build/soong/apex/apex.go. Make this explicit in Android.bp

Bug: 281077552
Test: m nothing
Change-Id: I365270bc90380211c40294dff145ebc01eb8c14f
---
 debuggerd/Android.bp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 31e284d4cacb..ad1eeb30d421 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -32,9 +32,10 @@ cc_library_headers {
     recovery_available: true,
     vendor_ramdisk_available: true,
     apex_available: [
+        "com.android.runtime",
         "com.android.virt",
         "//apex_available:platform",
-   ],
+    ],
 }
 
 cc_library_shared {
@@ -110,6 +111,9 @@ cc_library_static {
 
     export_header_lib_headers: ["libdebuggerd_common_headers"],
     export_include_dirs: ["include"],
+    apex_available: [
+        "com.android.runtime",
+    ],
 }
 
 // Implementation with a no-op fallback.
@@ -311,6 +315,9 @@ cc_library_static {
             header_libs: ["scudo_headers"],
         },
     },
+    apex_available: [
+        "com.android.runtime",
+    ],
 }
 
 cc_binary {

From 20f50ec9abe307c0ac6fd73c4b0217516cb2a563 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Wed, 3 Jan 2024 02:30:03 +0000
Subject: [PATCH 0647/1487] Avoid sleep in test.

For the tombstoned.proto test, remove arbitrary sleep and add loop
checking for the file being present.

Bug: 317286869

Test: Ran the tests on device and all pass.
Test: Modify the test and force the timeout to verify the timeout logic.
Change-Id: I9b246c8fee83909459d5c42debdb546794070845
---
 debuggerd/debuggerd_test.cpp | 54 ++++++++++++++++++++++--------------
 1 file changed, 33 insertions(+), 21 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 8693fdddfba9..c0522aa9d2e9 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -2221,28 +2221,10 @@ TEST_F(CrasherTest, unreadable_elf) {
   ASSERT_MATCH(result, match_str);
 }
 
-TEST(tombstoned, proto) {
-  const pid_t self = getpid();
-  unique_fd tombstoned_socket, text_fd, proto_fd;
-  ASSERT_TRUE(
-      tombstoned_connect(self, &tombstoned_socket, &text_fd, &proto_fd, kDebuggerdTombstoneProto));
-
-  tombstoned_notify_completion(tombstoned_socket.get());
-
-  ASSERT_NE(-1, text_fd.get());
-  ASSERT_NE(-1, proto_fd.get());
-
-  struct stat text_st;
-  ASSERT_EQ(0, fstat(text_fd.get(), &text_st));
-
-  // Give tombstoned some time to link the files into place.
-  std::this_thread::sleep_for(100ms * android::base::HwTimeoutMultiplier());
-
-  // Find the tombstone.
-  std::optional<std::string> tombstone_file;
+void CheckForTombstone(const struct stat& text_st, std::optional<std::string>& tombstone_file) {
+  static std::regex tombstone_re("tombstone_\\d+");
   std::unique_ptr<DIR, decltype(&closedir)> dir_h(opendir("/data/tombstones"), closedir);
   ASSERT_TRUE(dir_h != nullptr);
-  std::regex tombstone_re("tombstone_\\d+");
   dirent* entry;
   while ((entry = readdir(dir_h.get())) != nullptr) {
     if (!std::regex_match(entry->d_name, tombstone_re)) {
@@ -2260,8 +2242,38 @@ TEST(tombstoned, proto) {
       break;
     }
   }
+}
+
+TEST(tombstoned, proto) {
+  const pid_t self = getpid();
+  unique_fd tombstoned_socket, text_fd, proto_fd;
+  ASSERT_TRUE(
+      tombstoned_connect(self, &tombstoned_socket, &text_fd, &proto_fd, kDebuggerdTombstoneProto));
+
+  tombstoned_notify_completion(tombstoned_socket.get());
+
+  ASSERT_NE(-1, text_fd.get());
+  ASSERT_NE(-1, proto_fd.get());
+
+  struct stat text_st;
+  ASSERT_EQ(0, fstat(text_fd.get(), &text_st));
+
+  std::optional<std::string> tombstone_file;
+  // Allow up to 5 seconds for the tombstone to be written to the system.
+  const auto max_wait_time = std::chrono::seconds(5) * android::base::HwTimeoutMultiplier();
+  const auto start = std::chrono::high_resolution_clock::now();
+  while (true) {
+    std::this_thread::sleep_for(100ms);
+    CheckForTombstone(text_st, tombstone_file);
+    if (tombstone_file) {
+      break;
+    }
+    if (std::chrono::high_resolution_clock::now() - start > max_wait_time) {
+      break;
+    }
+  }
 
-  ASSERT_TRUE(tombstone_file);
+  ASSERT_TRUE(tombstone_file) << "Timed out trying to find tombstone file.";
   std::string proto_path = tombstone_file.value() + ".pb";
 
   struct stat proto_fd_st;

From 680c4a332fd4f7f537f7961ea60c04c4a56de1ba Mon Sep 17 00:00:00 2001
From: Kangping Dong <wgtdkp@google.com>
Date: Wed, 3 Jan 2024 15:16:31 +0800
Subject: [PATCH 0648/1487] Revert "init.rc: create /data/misc/threadnetwork
 folder"

This reverts commit 40e1666fb927717a8f6b60cfbff3c24f4dc65657.

Reason for revert: this directory is for the Thread stack which is
in the Tethering mainline module. Per mainline guideline, the data
should be saved in a APEX specific directory (i.e.
/data/misc/apexdata/com.android.tethering). It's safe to remove this
directory directly given this is a new feature targeting Android V

Bug: 309932508
Test: manually verified that Thread settings file can be written to
      /data/misc/apexdata/com.android.tethering/threadnetwork
Change-Id: I3a7e24b4cdc1c99ca36a22414507538279dd31cd
---
 rootdir/init.rc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 12c46ebfe3dc..a8e867d2356c 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -782,7 +782,6 @@ on post-fs-data
     mkdir /data/misc/vpn 0770 system vpn
     mkdir /data/misc/shared_relro 0771 shared_relro shared_relro
     mkdir /data/misc/systemkeys 0700 system system
-    mkdir /data/misc/threadnetwork 0770 thread_network thread_network
     mkdir /data/misc/wifi 0770 wifi wifi
     mkdir /data/misc/wifi/sockets 0770 wifi wifi
     mkdir /data/misc/wifi/wpa_supplicant 0770 wifi wifi

From 9376b7d8d09ed9aca4d8fd3a7835ec4a68ff906d Mon Sep 17 00:00:00 2001
From: Edward Liaw <edliaw@google.com>
Date: Wed, 3 Jan 2024 18:41:39 +0000
Subject: [PATCH 0649/1487] TEST_MAPPING: don't run vts_libsnapshot_test in
 kernel-presubmit

libsnapshot test is run in an independent configuration from
kernel-presubmit.  When run in kernel-presubmit, it fails because it
creates another daemon on top of the daemon that is already running from
first stage init.

Bug: 316040872
Test: N/A
Change-Id: Ie3381d6db35bb85fbb47326fa49938416d49f2b8
Signed-off-by: Edward Liaw <edliaw@google.com>
---
 fs_mgr/TEST_MAPPING | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index edecd7c1523d..1989a5c9d84e 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -41,9 +41,6 @@
     {
       "name": "liblp_test"
     },
-    {
-      "name": "vts_libsnapshot_test"
-    },
     {
       "name": "vab_legacy_tests"
     },

From d0c3a04cb0d4546d621cd6dd88fe0da83d7f1e59 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 13 Nov 2023 15:56:00 -0800
Subject: [PATCH 0650/1487] libsnapshot: add CowSizeInfo struct

Adding a cow size info struct as writer will now need to know the op buffer
size at the time of initialization. The sequence of events is as follows
(same as estimate_cow_size but putting down here for clarity)

1. ota_from_target_files does dry run to determine cow size + ops buffer
   size
2. data is passed through delta archive manifest
3. snapshot.cpp parses these fields and confgiures cowoptions struct to
   pass to writer initialization
4. cow is initialized with correct sizing. Data is incrementally added
   at the ends of the cow ops buffer (which is why we need to know the
   sizing ahead of time)

Test: ota
Change-Id: I950e5ef82c9bd7e9bd9603b0599c930767ee3f0d
---
 .../include/libsnapshot/cow_writer.h           | 10 +++++++---
 .../include/libsnapshot/mock_cow_writer.h      |  3 +--
 fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp | 18 +++++++++---------
 fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp |  4 ++--
 .../libsnapshot/libsnapshot_cow/writer_v2.cpp  |  8 +++++---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h |  2 +-
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp  |  7 +++++--
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h |  2 +-
 8 files changed, 31 insertions(+), 23 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 5b1e56c442ce..ca0ebe182ef8 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -33,7 +33,10 @@
 
 namespace android {
 namespace snapshot {
-
+struct CowSizeInfo {
+    uint64_t cow_size;
+    uint64_t op_count_max;
+};
 struct CowOptions {
     uint32_t block_size = 4096;
     std::string compression;
@@ -92,8 +95,9 @@ class ICowWriter {
     // to ensure that the correct headers and footers are written.
     virtual bool Finalize() = 0;
 
-    // Return number of bytes the cow image occupies on disk.
-    virtual uint64_t GetCowSize() = 0;
+    // Return number of bytes the cow image occupies on disk + the size of sequence && ops buffer
+    // The latter two fields are used in v3 cow format and left as 0 for v2 cow format
+    virtual CowSizeInfo GetCowSizeInfo() const = 0;
 
     virtual uint32_t GetBlockSize() const = 0;
     virtual std::optional<uint32_t> GetMaxBlocks() const = 0;
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/mock_cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/mock_cow_writer.h
index c58c6542aa21..8491fb00d51e 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/mock_cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/mock_cow_writer.h
@@ -24,8 +24,7 @@ class MockCowWriter : public ICowWriter {
     using FileDescriptor = chromeos_update_engine::FileDescriptor;
 
     MOCK_METHOD(bool, Finalize, (), (override));
-
-    MOCK_METHOD(uint64_t, GetCowSize, (), (override));
+    MOCK_METHOD(CowSizeInfo, GetCowSizeInfo, (), (const, override));
 
     MOCK_METHOD(bool, AddCopy, (uint64_t, uint64_t, uint64_t), (override));
     MOCK_METHOD(bool, AddRawBlocks, (uint64_t, const void*, size_t), (override));
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 49d86d81c57e..1d1d24c99f16 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -601,14 +601,14 @@ TEST_F(CowTest, GetSize) {
     ASSERT_TRUE(writer.AddCopy(10, 20));
     ASSERT_TRUE(writer.AddRawBlocks(50, data.data(), data.size()));
     ASSERT_TRUE(writer.AddZeroBlocks(51, 2));
-    auto size_before = writer.GetCowSize();
+    auto size_before = writer.GetCowSizeInfo().cow_size;
     ASSERT_TRUE(writer.Finalize());
-    auto size_after = writer.GetCowSize();
+    auto size_after = writer.GetCowSizeInfo().cow_size;
     ASSERT_EQ(size_before, size_after);
     struct stat buf;
 
     ASSERT_GE(fstat(cow_->fd, &buf), 0) << strerror(errno);
-    ASSERT_EQ(buf.st_size, writer.GetCowSize());
+    ASSERT_EQ(buf.st_size, writer.GetCowSizeInfo().cow_size);
 }
 
 TEST_F(CowTest, AppendLabelSmall) {
@@ -637,7 +637,7 @@ TEST_F(CowTest, AppendLabelSmall) {
 
     struct stat buf;
     ASSERT_EQ(fstat(cow_->fd, &buf), 0);
-    ASSERT_EQ(buf.st_size, writer->GetCowSize());
+    ASSERT_EQ(buf.st_size, writer->GetCowSizeInfo().cow_size);
 
     // Read back both operations, and label.
     CowReader reader;
@@ -690,7 +690,7 @@ TEST_F(CowTest, AppendLabelMissing) {
     ASSERT_TRUE(writer->AddRawBlocks(50, data.data(), data.size()));
     ASSERT_TRUE(writer->AddLabel(1));
     // Drop the tail end of the last op header, corrupting it.
-    ftruncate(cow_->fd, writer->GetCowSize() - sizeof(CowFooter) - 3);
+    ftruncate(cow_->fd, writer->GetCowSizeInfo().cow_size - sizeof(CowFooter) - 3);
 
     ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
 
@@ -705,7 +705,7 @@ TEST_F(CowTest, AppendLabelMissing) {
 
     struct stat buf;
     ASSERT_EQ(fstat(cow_->fd, &buf), 0);
-    ASSERT_EQ(buf.st_size, writer->GetCowSize());
+    ASSERT_EQ(buf.st_size, writer->GetCowSizeInfo().cow_size);
 
     // Read back both operations.
     CowReader reader;
@@ -763,7 +763,7 @@ TEST_F(CowTest, AppendExtendedCorrupted) {
 
     struct stat buf;
     ASSERT_EQ(fstat(cow_->fd, &buf), 0);
-    ASSERT_EQ(buf.st_size, writer->GetCowSize());
+    ASSERT_EQ(buf.st_size, writer->GetCowSizeInfo().cow_size);
 
     // Read back all valid operations
     CowReader reader;
@@ -812,7 +812,7 @@ TEST_F(CowTest, AppendbyLabel) {
 
     struct stat buf;
     ASSERT_EQ(fstat(cow_->fd, &buf), 0);
-    ASSERT_EQ(buf.st_size, writer->GetCowSize());
+    ASSERT_EQ(buf.st_size, writer->GetCowSizeInfo().cow_size);
 
     // Read back all ops
     CowReader reader;
@@ -989,7 +989,7 @@ TEST_F(CowTest, ClusterAppendTest) {
 
     struct stat buf;
     ASSERT_EQ(fstat(cow_->fd, &buf), 0);
-    ASSERT_EQ(buf.st_size, writer->GetCowSize());
+    ASSERT_EQ(buf.st_size, writer->GetCowSizeInfo().cow_size);
 
     // Read back both operations, plus cluster op at end
     CowReader reader;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 3383a5862240..8cf46f42eeb2 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -658,14 +658,14 @@ TEST_F(CowTestV3, CowSizeEstimate) {
     options.compression = "none";
     auto estimator = android::snapshot::CreateCowEstimator(3, options);
     ASSERT_TRUE(estimator->AddZeroBlocks(0, 1024 * 1024));
-    const auto cow_size = estimator->GetCowSize();
+    const auto cow_size = estimator->GetCowSizeInfo().cow_size;
     options.op_count_max = 1024 * 1024;
     options.max_blocks = 1024 * 1024;
     CowWriterV3 writer(options, GetCowFd());
     ASSERT_TRUE(writer.Initialize());
     ASSERT_TRUE(writer.AddZeroBlocks(0, 1024 * 1024));
 
-    ASSERT_LE(writer.GetCowSize(), cow_size);
+    ASSERT_LE(writer.GetCowSizeInfo().cow_size, cow_size);
 }
 
 TEST_F(CowTestV3, CopyOpMany) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index f9a4e479ebed..75cd1114df42 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -576,12 +576,14 @@ bool CowWriterV2::Finalize() {
     return Sync();
 }
 
-uint64_t CowWriterV2::GetCowSize() {
+CowSizeInfo CowWriterV2::GetCowSizeInfo() const {
+    CowSizeInfo info;
     if (current_data_size_ > 0) {
-        return next_data_pos_ + sizeof(footer_);
+        info.cow_size = next_data_pos_ + sizeof(footer_);
     } else {
-        return next_op_pos_ + sizeof(footer_);
+        info.cow_size = next_op_pos_ + sizeof(footer_);
     }
+    return info;
 }
 
 bool CowWriterV2::GetDataPos(uint64_t* pos) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
index 50e635ffdbd3..05de2ade2e9f 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
@@ -27,7 +27,7 @@ class CowWriterV2 : public CowWriterBase {
 
     bool Initialize(std::optional<uint64_t> label = {}) override;
     bool Finalize() override;
-    uint64_t GetCowSize() override;
+    CowSizeInfo GetCowSizeInfo() const override;
 
   protected:
     virtual bool EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) override;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index d99e6e6d6a6b..824fa39c7366 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -491,8 +491,11 @@ bool CowWriterV3::Finalize() {
     return Sync();
 }
 
-uint64_t CowWriterV3::GetCowSize() {
-    return next_data_pos_;
+CowSizeInfo CowWriterV3::GetCowSizeInfo() const {
+    CowSizeInfo info;
+    info.cow_size = next_data_pos_;
+    info.op_count_max = header_.op_count_max;
+    return info;
 }
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 3a7b87789688..73ac52011384 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -30,7 +30,7 @@ class CowWriterV3 : public CowWriterBase {
 
     bool Initialize(std::optional<uint64_t> label = {}) override;
     bool Finalize() override;
-    uint64_t GetCowSize() override;
+    CowSizeInfo GetCowSizeInfo() const override;
 
   protected:
     virtual bool EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks = 1) override;

From 3f3162c21717003ff6724ab3121da45307ac053e Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Sun, 17 Dec 2023 21:06:47 -0800
Subject: [PATCH 0651/1487] libsnapshot: get options from protobuf fields

Update snapshot.cpp to grab estimate_op_buffer_size &
estimate_sequence_buffer_size from update_engine. Update v3 writer to
use these options to size the buffers appropriately.

we probably don't need the fields for merge metrics yet but will leave
it here for now

Test: th
Bug: 313962438
Change-Id: I08252ff66174de9bafaf8dbe9115d9d049084c4c
---
 fs_mgr/libsnapshot/android/snapshot/snapshot.proto  | 6 ++++++
 fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h | 2 +-
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp    | 1 -
 fs_mgr/libsnapshot/partition_cow_creator.cpp        | 1 +
 fs_mgr/libsnapshot/snapshot.cpp                     | 7 ++++---
 5 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
index fa04c437d773..7e97dc0fbbfd 100644
--- a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
+++ b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
@@ -114,6 +114,9 @@ message SnapshotStatus {
 
     // Enable batching for COW writes
     bool batched_writes = 14;
+
+    // Size of v3 operation buffer. Needs to be determined during writer initialization
+    uint64 estimated_ops_buffer_size = 15;
 }
 
 // Next: 8
@@ -250,4 +253,7 @@ message SnapshotMergeReport {
 
     // Whether this update attempt used io_uring.
     bool iouring_used = 13;
+
+    // Size of v3 operation buffer. Needs to be determined during writer initialization
+    uint64 estimated_op_count_max = 14;
 }
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index ca0ebe182ef8..7df976d85c7b 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -59,7 +59,7 @@ struct CowOptions {
     bool batch_write = false;
 
     // Size of the cow operation buffer; used in v3 only.
-    uint32_t op_count_max = 0;
+    uint64_t op_count_max = 0;
 };
 
 // Interface for writing to a snapuserd COW. All operations are ordered; merges
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 824fa39c7366..bd69ac685724 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -392,7 +392,6 @@ bool CowWriterV3::EmitLabel(uint64_t label) {
 }
 
 bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
-    // TODO: size sequence buffer based on options
     if (header_.op_count > 0 || !cached_ops_.empty()) {
         LOG(ERROR) << "There's " << header_.op_count << " operations written to disk and "
                    << cached_ops_.size()
diff --git a/fs_mgr/libsnapshot/partition_cow_creator.cpp b/fs_mgr/libsnapshot/partition_cow_creator.cpp
index 5bc7e65f7f87..c0d20734e1b3 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator.cpp
+++ b/fs_mgr/libsnapshot/partition_cow_creator.cpp
@@ -217,6 +217,7 @@ std::optional<PartitionCowCreator::Return> PartitionCowCreator::Run() {
 
     if (update && update->has_estimate_cow_size()) {
         ret.snapshot_status.set_estimated_cow_size(update->estimate_cow_size());
+        ret.snapshot_status.set_estimated_ops_buffer_size(update->estimate_op_count_max());
     }
 
     if (ret.snapshot_status.snapshot_size() == 0) {
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index e33bdfff8585..9eb41b2cc836 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -3551,6 +3551,9 @@ Return SnapshotManager::InitializeUpdateSnapshots(
                 options.scratch_space = false;
             }
             options.compression = it->second.compression_algorithm();
+            if (cow_version >= 3) {
+                options.op_count_max = it->second.estimated_ops_buffer_size();
+            }
 
             auto writer = CreateCowWriter(cow_version, options, std::move(fd));
             if (!writer->Finalize()) {
@@ -3662,9 +3665,7 @@ std::unique_ptr<ICowWriter> SnapshotManager::OpenCompressedSnapshotWriter(
     cow_options.max_blocks = {status.device_size() / cow_options.block_size};
     cow_options.batch_write = status.batched_writes();
     cow_options.num_compress_threads = status.enable_threading() ? 2 : 1;
-    // TODO(b/313962438) Improve op_count estimate. For now, use number of
-    // blocks as an upper bound.
-    cow_options.op_count_max = status.device_size() / cow_options.block_size;
+    cow_options.op_count_max = status.estimated_ops_buffer_size();
     // Disable scratch space for vts tests
     if (device()->IsTestDevice()) {
         cow_options.scratch_space = false;

From 070848b9efe606454f0f9e35df43b37c5db3cf1b Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 3 Jan 2024 14:22:54 -0800
Subject: [PATCH 0652/1487] libsnapshot: add check for updating next_data_pos_

Adding a check here to ensure that next_data_pos_ isn't modified since
initialization. After sizing the sequence buffer, this value should be
the initialized value + the size of sequence buffer.

Test: cow_api_test
Change-Id: I9c79041b72544500989860a13ca6c25830d28750
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index bd69ac685724..e736847389f9 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -399,8 +399,14 @@ bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
                       "operation writes.";
         return false;
     }
+
     header_.sequence_data_count = num_ops;
+
+    // Ensure next_data_pos_ is updated as previously initialized + the newly added sequence buffer.
+    CHECK_EQ(next_data_pos_ + header_.sequence_data_count * sizeof(uint32_t),
+             GetDataOffset(header_));
     next_data_pos_ = GetDataOffset(header_);
+
     if (!android::base::WriteFullyAtOffset(fd_, data, sizeof(data[0]) * num_ops,
                                            GetSequenceOffset(header_))) {
         PLOG(ERROR) << "writing sequence buffer failed";

From 2e5cfbc1a41f8a293d8cdeb95cbf9c4e7c6c98f5 Mon Sep 17 00:00:00 2001
From: Spandan Das <spandandas@google.com>
Date: Thu, 4 Jan 2024 01:34:40 +0000
Subject: [PATCH 0653/1487] Make apex availability of libpropertyinfoparser and
 libpropertyinfoparser explicit

The availability to runtime apex was done implicitly using a baseline map in
build/soong/apex/apex.go. Make this explicit in Android.bp

Bug: 281077552
Test: m nothing
Change-Id: Iba1f30ef57c0707189ec79813ef501029135eeba
---
 debuggerd/Android.bp                              | 1 +
 property_service/libpropertyinfoparser/Android.bp | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index ad1eeb30d421..7d20995d7950 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -86,6 +86,7 @@ cc_library_static {
 
     export_header_lib_headers: ["libdebuggerd_common_headers"],
     export_include_dirs: ["tombstoned/include"],
+    apex_available: ["com.android.runtime"],
 }
 
 // Core implementation, linked into libdebuggerd_handler and the dynamic linker.
diff --git a/property_service/libpropertyinfoparser/Android.bp b/property_service/libpropertyinfoparser/Android.bp
index 87646f99d2d0..b4a16d38f6e0 100644
--- a/property_service/libpropertyinfoparser/Android.bp
+++ b/property_service/libpropertyinfoparser/Android.bp
@@ -25,4 +25,8 @@ cc_library_static {
         },
     },
     export_include_dirs: ["include"],
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.runtime",
+    ],
 }

From b86df7687bf028a70481d1a8fdbf50d65f795102 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Fri, 5 Jan 2024 16:47:14 +0800
Subject: [PATCH 0654/1487] remount: remount partitions with noatime

Related change: r.android.com/1110379

noatime reduces the wear and tear on the flash device.

Bug: 313609600
Test: abtd adb-remount-test
Change-Id: Ia42a064f297c25d3463a4ed9094a66236a6c5708
---
 fs_mgr/fs_mgr_remount.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/fs_mgr_remount.cpp b/fs_mgr/fs_mgr_remount.cpp
index 7ba4d2be4f23..733ba2f20ec1 100644
--- a/fs_mgr/fs_mgr_remount.cpp
+++ b/fs_mgr/fs_mgr_remount.cpp
@@ -380,8 +380,8 @@ bool RemountPartition(Fstab& fstab, Fstab& mounts, FstabEntry& entry) {
 
     // Now remount!
     for (const auto& mnt_point : {mount_point, entry.mount_point}) {
-        if (::mount(blk_device.c_str(), mnt_point.c_str(), entry.fs_type.c_str(), MS_REMOUNT,
-                    nullptr) == 0) {
+        if (::mount(blk_device.c_str(), mnt_point.c_str(), entry.fs_type.c_str(),
+                    MS_REMOUNT | MS_NOATIME, nullptr) == 0) {
             LOG(INFO) << "Remounted " << mnt_point << " as RW";
             return true;
         }

From a68aa856247fa0019cde92782b792b23c567d9a9 Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Wed, 3 Jan 2024 16:50:25 +0900
Subject: [PATCH 0655/1487] Provide a new LLNDK for the vendor api level
 handling

The library provides mapping functions between SDK versions and
vendor api levels.

Bug: 315056516
Test: atest libvendorsupport-tests
Change-Id: I4a4eae0456ebf756badcc80f09a2946f741843c5
---
 libvendorsupport/Android.bp                   | 35 +++++++++++++
 libvendorsupport/OWNERS                       |  2 +
 libvendorsupport/TEST_MAPPING                 |  7 +++
 .../include/vendorsupport/api_level.h         | 51 +++++++++++++++++++
 libvendorsupport/libvendorsupport.map.txt     |  7 +++
 libvendorsupport/tests/Android.bp             | 33 ++++++++++++
 libvendorsupport/tests/version_props_test.cpp | 37 ++++++++++++++
 libvendorsupport/version_props.c              | 41 +++++++++++++++
 8 files changed, 213 insertions(+)
 create mode 100644 libvendorsupport/Android.bp
 create mode 100644 libvendorsupport/OWNERS
 create mode 100644 libvendorsupport/TEST_MAPPING
 create mode 100644 libvendorsupport/include/vendorsupport/api_level.h
 create mode 100644 libvendorsupport/libvendorsupport.map.txt
 create mode 100644 libvendorsupport/tests/Android.bp
 create mode 100644 libvendorsupport/tests/version_props_test.cpp
 create mode 100644 libvendorsupport/version_props.c

diff --git a/libvendorsupport/Android.bp b/libvendorsupport/Android.bp
new file mode 100644
index 000000000000..16a4c4c8ae08
--- /dev/null
+++ b/libvendorsupport/Android.bp
@@ -0,0 +1,35 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package {
+    default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+cc_library {
+    name: "libvendorsupport",
+    native_bridge_supported: true,
+    llndk: {
+        symbol_file: "libvendorsupport.map.txt",
+    },
+    srcs: ["version_props.c"],
+    cflags: [
+        "-Wall",
+        "-Werror",
+    ],
+    local_include_dirs: ["include/vendorsupport"],
+    export_include_dirs: ["include"],
+    shared_libs: [
+        "liblog",
+    ],
+}
diff --git a/libvendorsupport/OWNERS b/libvendorsupport/OWNERS
new file mode 100644
index 000000000000..2ab18eba750f
--- /dev/null
+++ b/libvendorsupport/OWNERS
@@ -0,0 +1,2 @@
+jiyong@google.com
+justinyun@google.com
diff --git a/libvendorsupport/TEST_MAPPING b/libvendorsupport/TEST_MAPPING
new file mode 100644
index 000000000000..5bd09ba4e37e
--- /dev/null
+++ b/libvendorsupport/TEST_MAPPING
@@ -0,0 +1,7 @@
+{
+  "postsubmit": [
+    {
+      "name": "libvendorsupport-tests"
+    }
+  ]
+}
diff --git a/libvendorsupport/include/vendorsupport/api_level.h b/libvendorsupport/include/vendorsupport/api_level.h
new file mode 100644
index 000000000000..ba1a6b8874f8
--- /dev/null
+++ b/libvendorsupport/include/vendorsupport/api_level.h
@@ -0,0 +1,51 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <android/api-level.h>
+
+#define __ANDROID_VENDOR_API_MAX__ 1000000
+#define __INVALID_API_LEVEL -1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Find corresponding vendor API level from an SDK API version.
+ *
+ * @details
+ * SDK API versions and vendor API levels are not compatible and not
+ * convertible. However, this function can be used to compare the two versions
+ * to know which one is newer than the other.
+ *
+ * @param sdk_api_level The SDK version int. This must be less than 10000.
+ * @return The corresponding vendor API level of the SDK version. -1 if the SDK
+ * version is invalid or 10000.
+ */
+int vendor_api_level_of(int sdk_api_level);
+
+/**
+ * @brief Find corresponding SDK API version from a vendor API level.
+ *
+ * @param vendor_api_level The vendor API level int.
+ * @return The corresponding SDK API version of the vendor API level. -1 if the
+ * vendor API level is invalid.
+ */
+int sdk_api_level_of(int vendor_api_level);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/libvendorsupport/libvendorsupport.map.txt b/libvendorsupport/libvendorsupport.map.txt
new file mode 100644
index 000000000000..9a23b940f9b6
--- /dev/null
+++ b/libvendorsupport/libvendorsupport.map.txt
@@ -0,0 +1,7 @@
+LIBVENDORSUPPORT {
+  global:
+    vendor_api_level_of; # llndk systemapi
+    sdk_api_level_of; # llndk systemapi
+  local:
+    *;
+};
diff --git a/libvendorsupport/tests/Android.bp b/libvendorsupport/tests/Android.bp
new file mode 100644
index 000000000000..42e3371c9156
--- /dev/null
+++ b/libvendorsupport/tests/Android.bp
@@ -0,0 +1,33 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package {
+    default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+cc_test {
+    name: "libvendorsupport-tests",
+    srcs: [
+        "version_props_test.cpp",
+    ],
+    cflags: [
+        "-Wall",
+        "-Werror",
+    ],
+    shared_libs: [
+        "libvendorsupport",
+    ],
+    test_suites: ["general-tests"],
+}
+
diff --git a/libvendorsupport/tests/version_props_test.cpp b/libvendorsupport/tests/version_props_test.cpp
new file mode 100644
index 000000000000..538a2e26bd5c
--- /dev/null
+++ b/libvendorsupport/tests/version_props_test.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <gtest/gtest.h>
+
+#include <vendorsupport/api_level.h>
+
+using namespace std;
+
+namespace {
+
+TEST(vendorsupport, get_corresponding_vendor_api_level) {
+    ASSERT_EQ(__ANDROID_API_U__, vendor_api_level_of(__ANDROID_API_U__));
+    ASSERT_EQ(202404, vendor_api_level_of(__ANDROID_API_V__));
+    ASSERT_EQ(__INVALID_API_LEVEL, vendor_api_level_of(__ANDROID_API_FUTURE__));
+}
+
+TEST(vendorsupport, get_corresponding_sdk_api_level) {
+    ASSERT_EQ(__ANDROID_API_U__, sdk_api_level_of(__ANDROID_API_U__));
+    ASSERT_EQ(__ANDROID_API_V__, sdk_api_level_of(202404));
+    ASSERT_EQ(__INVALID_API_LEVEL, sdk_api_level_of(__ANDROID_VENDOR_API_MAX__));
+    ASSERT_EQ(__INVALID_API_LEVEL, sdk_api_level_of(35));
+}
+
+}  // namespace
\ No newline at end of file
diff --git a/libvendorsupport/version_props.c b/libvendorsupport/version_props.c
new file mode 100644
index 000000000000..4d0e45ecfd06
--- /dev/null
+++ b/libvendorsupport/version_props.c
@@ -0,0 +1,41 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "api_level.h"
+
+#include <log/log.h>
+
+int vendor_api_level_of(int sdk_api_level) {
+    if (sdk_api_level < __ANDROID_API_V__) {
+        return sdk_api_level;
+    }
+    // In Android V, vendor API level started with version 202404.
+    // The calculation assumes that the SDK api level bumps once a year.
+    if (sdk_api_level < __ANDROID_API_FUTURE__) {
+        return 202404 + ((sdk_api_level - __ANDROID_API_V__) * 100);
+    }
+    ALOGE("The SDK version must be less than 10000: %d", sdk_api_level);
+    return __INVALID_API_LEVEL;
+}
+
+int sdk_api_level_of(int vendor_api_level) {
+    if (vendor_api_level < __ANDROID_API_V__) {
+        return vendor_api_level;
+    }
+    if (vendor_api_level >= 202404 && vendor_api_level < __ANDROID_VENDOR_API_MAX__) {
+        return (vendor_api_level - 202404) / 100 + __ANDROID_API_V__;
+    }
+    ALOGE("Unexpected vendor api level: %d", vendor_api_level);
+    return __INVALID_API_LEVEL;
+}

From 6687cb65a6ad23bd15054803b7dbd807e7f037c5 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Mon, 18 Dec 2023 11:02:18 -0800
Subject: [PATCH 0656/1487] Support multi-threaded compression in COW v3

Performance of COW v3 is now on par with v2 in both multi-threaded and
single threaded configurations. Note, v2 cow writer can cache up to 1024
blocks in memory if multi-threaded compression is enabled(even though
batch size is configured as 200). For a fair comparison, benchmarks are
ran with batch size of 256. For batch size of 256 or greater, v2 and v3
have similar multi-threaded performance.

Test: th
Bug: 313962438
Change-Id: I377c8291689a7a038bb00b09d7371a155e6972e9
---
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 119 +++++++++++++++---
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |   7 +-
 2 files changed, 106 insertions(+), 20 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index e736847389f9..be6b6daa6a7e 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -34,6 +34,7 @@
 #include <zlib.h>
 
 #include <fcntl.h>
+#include <libsnapshot/cow_compress.h>
 #include <libsnapshot_cow/parser_v3.h>
 #include <linux/fs.h>
 #include <sys/ioctl.h>
@@ -55,11 +56,35 @@ static_assert(sizeof(off_t) == sizeof(uint64_t));
 
 using android::base::unique_fd;
 
+// Divide |x| by |y| and round up to the nearest integer.
+constexpr uint64_t DivRoundUp(uint64_t x, uint64_t y) {
+    return (x + y - 1) / y;
+}
+
 CowWriterV3::CowWriterV3(const CowOptions& options, unique_fd&& fd)
     : CowWriterBase(options, std::move(fd)), batch_size_(std::max<size_t>(options.cluster_ops, 1)) {
     SetupHeaders();
 }
 
+void CowWriterV3::InitWorkers() {
+    if (num_compress_threads_ <= 1) {
+        LOG_INFO << "Not creating new threads for compression.";
+        return;
+    }
+    compress_threads_.reserve(num_compress_threads_);
+    compress_threads_.clear();
+    threads_.reserve(num_compress_threads_);
+    threads_.clear();
+    for (size_t i = 0; i < num_compress_threads_; i++) {
+        std::unique_ptr<ICompressor> compressor =
+                ICompressor::Create(compression_, header_.block_size);
+        auto&& wt = compress_threads_.emplace_back(
+                std::make_unique<CompressWorker>(std::move(compressor), header_.block_size));
+        threads_.emplace_back(std::thread([wt = wt.get()]() { wt->RunThread(); }));
+    }
+    LOG(INFO) << num_compress_threads_ << " thread used for compression";
+}
+
 void CowWriterV3::SetupHeaders() {
     header_ = {};
     header_.prefix.magic = kCowMagicNumber;
@@ -135,10 +160,24 @@ bool CowWriterV3::ParseOptions() {
     } else {
         LOG(INFO) << "Batch writes: disabled";
     }
+    if (android::base::GetBoolProperty("ro.virtual_ab.compression.threads", false) &&
+        options_.num_compress_threads) {
+        num_compress_threads_ = options_.num_compress_threads;
+    }
+    InitWorkers();
     return true;
 }
 
-CowWriterV3::~CowWriterV3() {}
+CowWriterV3::~CowWriterV3() {
+    for (const auto& t : compress_threads_) {
+        t->Finalize();
+    }
+    for (auto& t : threads_) {
+        if (t.joinable()) {
+            t.join();
+        }
+    }
+}
 
 bool CowWriterV3::Initialize(std::optional<uint64_t> label) {
     if (!InitFd() || !ParseOptions()) {
@@ -289,19 +328,24 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
                    << " but compressor is uninitialized.";
         return false;
     }
+    const auto bytes = reinterpret_cast<const uint8_t*>(data);
     const size_t num_blocks = (size / header_.block_size);
 
     for (size_t i = 0; i < num_blocks;) {
         const auto blocks_to_write =
                 std::min<size_t>(batch_size_ - cached_data_.size(), num_blocks - i);
         size_t compressed_bytes = 0;
+        auto&& blocks = CompressBlocks(blocks_to_write, bytes + header_.block_size * i);
+        if (blocks.size() != blocks_to_write) {
+            LOG(ERROR) << "Failed to compress blocks " << new_block_start + i << ", "
+                       << blocks_to_write << ", actual number of blocks received from compressor "
+                       << blocks.size();
+            return false;
+        }
         for (size_t j = 0; j < blocks_to_write; j++) {
-            const uint8_t* const iter =
-                    reinterpret_cast<const uint8_t*>(data) + (header_.block_size * (i + j));
-
             CowOperation& op = cached_ops_.emplace_back();
             auto& vec = data_vec_.emplace_back();
-            auto& compressed_data = cached_data_.emplace_back();
+            auto& compressed_data = cached_data_.emplace_back(std::move(blocks[j]));
             op.new_block = new_block_start + i + j;
 
             op.set_type(type);
@@ -310,20 +354,6 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
             } else {
                 op.set_source(next_data_pos_ + compressed_bytes);
             }
-            if (compression_.algorithm == kCowCompressNone) {
-                compressed_data.resize(header_.block_size);
-            } else {
-                compressed_data = compressor_->Compress(iter, header_.block_size);
-                if (compressed_data.empty()) {
-                    LOG(ERROR) << "Compression failed during EmitBlocks(" << new_block_start << ", "
-                               << num_blocks << ");";
-                    return false;
-                }
-            }
-            if (compressed_data.size() >= header_.block_size) {
-                compressed_data.resize(header_.block_size);
-                std::memcpy(compressed_data.data(), iter, header_.block_size);
-            }
             vec = {.iov_base = compressed_data.data(), .iov_len = compressed_data.size()};
             op.data_length = vec.iov_len;
             compressed_bytes += op.data_length;
@@ -443,6 +473,57 @@ bool CowWriterV3::FlushCacheOps() {
     return true;
 }
 
+std::vector<std::basic_string<uint8_t>> CowWriterV3::CompressBlocks(const size_t num_blocks,
+                                                                    const void* data) {
+    const size_t num_threads = (num_blocks == 1) ? 1 : num_compress_threads_;
+    const size_t blocks_per_thread = DivRoundUp(num_blocks, num_threads);
+    std::vector<std::basic_string<uint8_t>> compressed_buf;
+    compressed_buf.clear();
+    const uint8_t* const iter = reinterpret_cast<const uint8_t*>(data);
+    if (compression_.algorithm == kCowCompressNone) {
+        for (size_t i = 0; i < num_blocks; i++) {
+            auto& buf = compressed_buf.emplace_back();
+            buf.resize(header_.block_size);
+            std::memcpy(buf.data(), iter + i * header_.block_size, header_.block_size);
+        }
+        return compressed_buf;
+    }
+    if (num_threads <= 1) {
+        if (!CompressWorker::CompressBlocks(compressor_.get(), header_.block_size, data, num_blocks,
+                                            &compressed_buf)) {
+            return {};
+        }
+    } else {
+        // Submit the blocks per thread. The retrieval of
+        // compressed buffers has to be done in the same order.
+        // We should not poll for completed buffers in a different order as the
+        // buffers are tightly coupled with block ordering.
+        for (size_t i = 0; i < num_threads; i++) {
+            CompressWorker* worker = compress_threads_[i].get();
+            const auto blocks_in_batch =
+                    std::min(num_blocks - i * blocks_per_thread, blocks_per_thread);
+            worker->EnqueueCompressBlocks(iter + i * blocks_per_thread * header_.block_size,
+                                          blocks_in_batch);
+        }
+
+        for (size_t i = 0; i < num_threads; i++) {
+            CompressWorker* worker = compress_threads_[i].get();
+            if (!worker->GetCompressedBuffers(&compressed_buf)) {
+                return {};
+            }
+        }
+    }
+    for (size_t i = 0; i < num_blocks; i++) {
+        auto& block = compressed_buf[i];
+        if (block.size() >= header_.block_size) {
+            block.resize(header_.block_size);
+            std::memcpy(block.data(), iter + header_.block_size * i, header_.block_size);
+        }
+    }
+
+    return compressed_buf;
+}
+
 bool CowWriterV3::WriteOperation(std::basic_string_view<CowOperationV3> ops,
                                  std::basic_string_view<struct iovec> data) {
     const auto total_data_size =
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 73ac52011384..b19af60a34d6 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -16,6 +16,7 @@
 
 #include <android-base/logging.h>
 #include <string_view>
+#include <thread>
 #include <vector>
 
 #include "writer_base.h"
@@ -51,12 +52,14 @@ class CowWriterV3 : public CowWriterBase {
                         std::basic_string_view<struct iovec> data);
     bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
                     uint16_t offset, CowOperationType type);
-    bool CompressBlocks(size_t num_blocks, const void* data);
     bool CheckOpCount(size_t op_count);
 
   private:
+    std::vector<std::basic_string<uint8_t>> CompressBlocks(const size_t num_blocks,
+                                                           const void* data);
     bool ReadBackVerification();
     bool FlushCacheOps();
+    void InitWorkers();
     CowHeaderV3 header_{};
     CowCompression compression_;
     // in the case that we are using one thread for compression, we can store and re-use the same
@@ -75,6 +78,8 @@ class CowWriterV3 : public CowWriterBase {
     std::vector<CowOperationV3> cached_ops_;
     std::vector<std::basic_string<uint8_t>> cached_data_;
     std::vector<struct iovec> data_vec_;
+
+    std::vector<std::thread> threads_;
 };
 
 }  // namespace snapshot

From 5ede70f71419e0896f28eb1e778ac137894b5eda Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 4 Jan 2024 11:10:31 -0800
Subject: [PATCH 0657/1487] Mount /data as readonly before encrypt_inplace

According to aosp/1908136, the current flow is

1. factory reset formatted raw disk.
2. next boot tries to convert it to metadata encryption
2.a mount sda27
2.b umount sda27
2.c encrypt_inplace()
2.d fsck on dm-x
2.e mount dm-x

If there are some write file operations between 2.a and 2.b, encryption
might fail. To mitigate, change the mount in 2.a to readonly if we know
we are going to do encrypt_inplace.

Test: th
Bug: 313962438
Change-Id: I7f4bbd36e1e6c978dde84f5396ffb90bbbdcae87
---
 fs_mgr/fs_mgr.cpp | 29 ++++++++++++++++++++---------
 1 file changed, 20 insertions(+), 9 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index af2b35a2f11e..b0e2d6da4b3a 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -16,7 +16,6 @@
 
 #include "fs_mgr.h"
 
-#include <ctype.h>
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -819,9 +818,13 @@ bool fs_mgr_is_device_unlocked() {
 // __mount(): wrapper around the mount() system call which also
 // sets the underlying block device to read-only if the mount is read-only.
 // See "man 2 mount" for return values.
-static int __mount(const std::string& source, const std::string& target, const FstabEntry& entry) {
+static int __mount(const std::string& source, const std::string& target, const FstabEntry& entry,
+                   bool read_only = false) {
     errno = 0;
     unsigned long mountflags = entry.flags;
+    if (read_only) {
+        mountflags |= MS_RDONLY;
+    }
     int ret = 0;
     int save_errno = 0;
     int gc_allowance = 0;
@@ -915,6 +918,10 @@ static bool fs_match(const std::string& in1, const std::string& in2) {
     return true;
 }
 
+static bool should_use_metadata_encryption(const FstabEntry& entry) {
+    return !entry.metadata_key_dir.empty() && entry.fs_mgr_flags.file_encryption;
+}
+
 // Tries to mount any of the consecutive fstab entries that match
 // the mountpoint of the one given by fstab[start_idx].
 //
@@ -922,8 +929,7 @@ static bool fs_match(const std::string& in1, const std::string& in2) {
 // attempted_idx: On return, will indicate which fstab entry
 //     succeeded. In case of failure, it will be the start_idx.
 // Sets errno to match the 1st mount failure on failure.
-static bool mount_with_alternatives(Fstab& fstab, int start_idx, int* end_idx,
-                                    int* attempted_idx) {
+static bool mount_with_alternatives(Fstab& fstab, int start_idx, int* end_idx, int* attempted_idx) {
     unsigned long i;
     int mount_errno = 0;
     bool mounted = false;
@@ -961,8 +967,15 @@ static bool mount_with_alternatives(Fstab& fstab, int start_idx, int* end_idx,
         }
 
         int retry_count = 2;
+        const auto read_only = should_use_metadata_encryption(fstab[i]);
+        if (read_only) {
+            LOG(INFO) << "Mount point " << fstab[i].blk_device << " @ " << fstab[i].mount_point
+                      << " uses metadata encryption, which means we need to unmount it later and "
+                         "call encryptFstab/encrypt_inplace. To avoid file operations before "
+                         "encryption, we will mount it as read-only first";
+        }
         while (retry_count-- > 0) {
-            if (!__mount(fstab[i].blk_device, fstab[i].mount_point, fstab[i])) {
+            if (!__mount(fstab[i].blk_device, fstab[i].mount_point, fstab[i], read_only)) {
                 *attempted_idx = i;
                 mounted = true;
                 if (i != start_idx) {
@@ -1054,10 +1067,6 @@ static bool TranslateExtLabels(FstabEntry* entry) {
     return false;
 }
 
-static bool should_use_metadata_encryption(const FstabEntry& entry) {
-    return !entry.metadata_key_dir.empty() && entry.fs_mgr_flags.file_encryption;
-}
-
 // Check to see if a mountable volume has encryption requirements
 static int handle_encryptable(const FstabEntry& entry) {
     if (should_use_metadata_encryption(entry)) {
@@ -1978,6 +1987,8 @@ int fs_mgr_do_mount(Fstab* fstab, const std::string& n_name, const std::string&
                 if (retry_count <= 0) break;  // run check_fs only once
                 if (!first_mount_errno) first_mount_errno = errno;
                 mount_errors++;
+                PERROR << "Cannot mount filesystem on " << n_blk_device << " at " << mount_point
+                       << " with fstype " << fstab_entry.fs_type;
                 fs_stat |= FS_STAT_FULL_MOUNT_FAILED;
                 // try again after fsck
                 check_fs(n_blk_device, fstab_entry.fs_type, mount_point, &fs_stat);

From e5b667bd38ba90ff080a685c52b15371eea8a19a Mon Sep 17 00:00:00 2001
From: Hsin-Yi Chen <hsinyichen@google.com>
Date: Mon, 8 Jan 2024 18:49:37 +0800
Subject: [PATCH 0658/1487] Enable header_abi_checker for libutils explicitly

The ABI checking rules for VNDK will be deleted from the main branch.
To keep monitoring the ABI, the check must be enabled explicitly.

Test: m libutils.vendor
Bug: 314010764
Change-Id: I762dec1ed7de014db653663d2917a19df5076fc8
---
 libutils/Android.bp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libutils/Android.bp b/libutils/Android.bp
index 1c622ff7529d..ad5b752e3b1e 100644
--- a/libutils/Android.bp
+++ b/libutils/Android.bp
@@ -191,6 +191,7 @@ cc_library {
     target: {
         product: {
             header_abi_checker: {
+                enabled: true,
                 // AFDO affects weak symbols.
                 diff_flags: ["-allow-adding-removing-weak-symbols"],
                 ref_dump_dirs: ["abi-dumps"],
@@ -198,6 +199,7 @@ cc_library {
         },
         vendor: {
             header_abi_checker: {
+                enabled: true,
                 // AFDO affects weak symbols.
                 diff_flags: ["-allow-adding-removing-weak-symbols"],
                 ref_dump_dirs: ["abi-dumps"],

From 5ff9025ae143b7e3046f9dede1732ebd4619c9e4 Mon Sep 17 00:00:00 2001
From: Nikita Ioffe <ioffe@google.com>
Date: Mon, 8 Jan 2024 11:25:45 +0000
Subject: [PATCH 0659/1487] dm_test.cpp: DeleteDeviceWithTimeout asserts that
 unique path is deleted

Before this patch, DeleteDeviceWithTimeout was checking that the dev
node (i.e. /dev/block/dm-XX) is deleted after the call to DeleteDevice
API. Since ueventd first deletes the symlinks that correspond to a
device and only then deletes this device node, this assertion introduced
a race condition (DeleteDevice API waits for the symlink to be deleted).

This patch changes the DeleteDeviceWithTimeout test to check that unique
path of the device has been deleted.

Bug: 318425605
Test: presubmit
Change-Id: I3fd9de507c75bcf6ac1350fa0b8adfdb5a2e89e8
---
 fs_mgr/libdm/dm_test.cpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libdm/dm_test.cpp b/fs_mgr/libdm/dm_test.cpp
index c522eafae058..a0129c234936 100644
--- a/fs_mgr/libdm/dm_test.cpp
+++ b/fs_mgr/libdm/dm_test.cpp
@@ -580,9 +580,18 @@ TEST_F(DmTest, DeleteDeviceWithTimeout) {
     ASSERT_TRUE(dm.GetDmDevicePathByName("libdm-test-dm-linear", &path));
     ASSERT_EQ(0, access(path.c_str(), F_OK));
 
+    std::string unique_path;
+    ASSERT_TRUE(dm.GetDeviceUniquePath("libdm-test-dm-linear", &unique_path));
+    ASSERT_EQ(0, access(unique_path.c_str(), F_OK));
+
     ASSERT_TRUE(dm.DeleteDevice("libdm-test-dm-linear", 5s));
     ASSERT_EQ(DmDeviceState::INVALID, dm.GetState("libdm-test-dm-linear"));
-    ASSERT_NE(0, access(path.c_str(), F_OK));
+    // Check that unique path of this device has been deleteted.
+    // Previously this test case used to check that dev node (i.e. /dev/block/dm-XX) has been
+    // deleted. However, this introduces a race condition, ueventd will remove the unique symlink
+    // (i.e. /dev/block/mapper/by-uuid/...) **before** removing the device node, while DeleteDevice
+    // API synchronizes on the unique symlink being deleted.
+    ASSERT_NE(0, access(unique_path.c_str(), F_OK));
     ASSERT_EQ(ENOENT, errno);
 }
 

From 442345b734560b08733ef8dec1af1944e92fcedf Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 8 Jan 2024 22:50:04 +0000
Subject: [PATCH 0660/1487] vts_fs_test: Only check /data and /metadata for rw
 partitions.

Some rw /proc/mounts entries are FUSE.

Also, add some diagnostics for failures.

Bug: 318962836
Test: vts_fs_test on Pixel
Change-Id: I85dec8b37f1a061b1eca597aba3887b598b699f5
---
 fs_mgr/tests/vts_fs_test.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/tests/vts_fs_test.cpp b/fs_mgr/tests/vts_fs_test.cpp
index 2f2db0c6c86a..9503072d2a38 100644
--- a/fs_mgr/tests/vts_fs_test.cpp
+++ b/fs_mgr/tests/vts_fs_test.cpp
@@ -133,9 +133,10 @@ TEST(fs, PartitionTypes) {
             std::vector<std::string> allowed = {"erofs", "ext4", "f2fs"};
             EXPECT_NE(std::find(allowed.begin(), allowed.end(), entry.fs_type), allowed.end())
                     << entry.mount_point;
-        } else {
+        } else if (std::find(data_fs.begin(), data_fs.end(), entry.mount_point) != data_fs.end()) {
             std::vector<std::string> allowed = {"ext4", "f2fs"};
-            EXPECT_NE(std::find(allowed.begin(), allowed.end(), entry.fs_type), allowed.end());
+            EXPECT_NE(std::find(allowed.begin(), allowed.end(), entry.fs_type), allowed.end())
+                    << entry.mount_point << ", " << entry.fs_type;
         }
     }
 }

From e57ef38bb2fbf213ec7e23ca659f731ef4b517ab Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Sun, 26 Nov 2023 13:55:56 -0800
Subject: [PATCH 0661/1487] Set taskprofile to snapshot merge thread

Assign CPUSET_SP_BACKGROUND taskprofile to snapshot merge threads.
This will ensure that the threads will not run on big cores.

Additionally, reduce the flushing of data to 1MB after merging REPLACE ops.

No major regression observed on snashot merge time.

On Pixel 6 for incremental OTA of 500M, snapshot merge time increased
from 72 seconds to 76 seconds after this patch.

Bug: 311233916
Test: Full and incremental OTA on Pixel 6 - Verify merge threads not on big cores
Change-Id: I455afdac0b77227869d846d0c4472ea9eb34c41c
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       | 20 +++++++++++++++++++
 .../user-space-merge/merge_worker.cpp         | 10 +++++++---
 .../user-space-merge/snapuserd_readahead.cpp  |  4 ++++
 fs_mgr/libsnapshot/snapuserd/utility.cpp      | 14 +++++++++++++
 fs_mgr/libsnapshot/snapuserd/utility.h        |  4 ++++
 5 files changed, 49 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 6b8e084170b7..bd296a396d79 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -86,10 +86,15 @@ cc_library_static {
         "libext4_utils",
         "libsnapshot_cow",
         "liburing",
+        "libprocessgroup",
+        "libjsoncpp",
+        "libcgrouprc",
+        "libcgrouprc_format",
     ],
     include_dirs: ["bionic/libc/kernel"],
     export_include_dirs: ["include"],
     header_libs: [
+        "libcutils_headers",
         "libstorage_literals_headers",
     ],
     ramdisk_available: true,
@@ -126,6 +131,10 @@ cc_defaults {
         "liblog",
         "libsnapshot_cow",
         "libsnapuserd",
+        "libprocessgroup",
+        "libjsoncpp",
+        "libcgrouprc",
+        "libcgrouprc_format",
         "libsnapuserd_client",
         "libz",
         "liblz4",
@@ -135,6 +144,7 @@ cc_defaults {
     ],
 
     header_libs: [
+        "libcutils_headers",
         "libstorage_literals_headers",
     ],
 
@@ -251,6 +261,10 @@ cc_defaults {
         "libgtest",
         "libsnapshot_cow",
         "libsnapuserd",
+        "libprocessgroup",
+        "libjsoncpp",
+        "libcgrouprc",
+        "libcgrouprc_format",
         "liburing",
         "libz",
     ],
@@ -261,6 +275,7 @@ cc_defaults {
     header_libs: [
         "libstorage_literals_headers",
         "libfiemap_headers",
+        "libcutils_headers",
     ],
     test_options: {
         min_shipping_api_level: 30,
@@ -320,6 +335,10 @@ cc_binary_host {
         "libgflags",
         "libsnapshot_cow",
         "libsnapuserd",
+        "libprocessgroup",
+        "libjsoncpp",
+        "libcgrouprc",
+        "libcgrouprc_format",
         "liburing",
         "libz",
     ],
@@ -330,5 +349,6 @@ cc_binary_host {
     header_libs: [
         "libstorage_literals_headers",
         "libfiemap_headers",
+        "libcutils_headers",
     ],
 }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index bcf9aabe92ad..1e7d0c0a2d44 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -80,16 +80,16 @@ int MergeWorker::PrepareMerge(uint64_t* source_offset, int* pending_ops,
 }
 
 bool MergeWorker::MergeReplaceZeroOps() {
-    // Flush after merging 2MB. Since all ops are independent and there is no
+    // Flush after merging 1MB. Since all ops are independent and there is no
     // dependency between COW ops, we will flush the data and the number
     // of ops merged in COW block device. If there is a crash, we will
     // end up replaying some of the COW ops which were already merged. That is
     // ok.
     //
-    // Although increasing this greater than 2MB may help in improving merge
+    // Although increasing this greater than 1MB may help in improving merge
     // times; however, on devices with low memory, this can be problematic
     // when there are multiple merge threads in parallel.
-    int total_ops_merged_per_commit = (PAYLOAD_BUFFER_SZ / BLOCK_SZ) * 2;
+    int total_ops_merged_per_commit = (PAYLOAD_BUFFER_SZ / BLOCK_SZ);
     int num_ops_merged = 0;
 
     SNAP_LOG(INFO) << "MergeReplaceZeroOps started....";
@@ -561,6 +561,10 @@ bool MergeWorker::Run() {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
+    if (!SetProfiles({"CPUSET_SP_BACKGROUND"})) {
+        SNAP_PLOG(ERROR) << "Failed to assign task profile to Mergeworker thread";
+    }
+
     SNAP_LOG(INFO) << "Merge starting..";
 
     bufsink_.Initialize(PAYLOAD_BUFFER_SZ);
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index c08c1b19699e..2baf20ddde83 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -782,6 +782,10 @@ bool ReadAhead::RunThread() {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
+    if (!SetProfiles({"CPUSET_SP_BACKGROUND"})) {
+        SNAP_PLOG(ERROR) << "Failed to assign task profile to readahead thread";
+    }
+
     SNAP_LOG(INFO) << "ReadAhead processing.";
     while (!RAIterDone()) {
         if (!ReadAheadIOStart()) {
diff --git a/fs_mgr/libsnapshot/snapuserd/utility.cpp b/fs_mgr/libsnapshot/snapuserd/utility.cpp
index fcdb69dd1ae7..684ca3d7ba9b 100644
--- a/fs_mgr/libsnapshot/snapuserd/utility.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/utility.cpp
@@ -19,6 +19,9 @@
 #include <unistd.h>
 
 #include <android-base/file.h>
+#include <processgroup/processgroup.h>
+
+#include <private/android_filesystem_config.h>
 
 namespace android {
 namespace snapshot {
@@ -33,6 +36,17 @@ bool SetThreadPriority([[maybe_unused]] int priority) {
 #endif
 }
 
+bool SetProfiles([[maybe_unused]] std::initializer_list<std::string_view> profiles) {
+#ifdef __ANDROID__
+    if (setgid(AID_SYSTEM)) {
+        return false;
+    }
+    return SetTaskProfiles(gettid(), profiles);
+#else
+    return true;
+#endif
+}
+
 bool KernelSupportsIoUring() {
     struct utsname uts {};
     unsigned int major, minor;
diff --git a/fs_mgr/libsnapshot/snapuserd/utility.h b/fs_mgr/libsnapshot/snapuserd/utility.h
index 255aee195014..c3c3cbae913d 100644
--- a/fs_mgr/libsnapshot/snapuserd/utility.h
+++ b/fs_mgr/libsnapshot/snapuserd/utility.h
@@ -14,10 +14,14 @@
 
 #pragma once
 
+#include <initializer_list>
+#include <string_view>
+
 namespace android {
 namespace snapshot {
 
 bool SetThreadPriority(int priority);
+bool SetProfiles(std::initializer_list<std::string_view> profiles);
 bool KernelSupportsIoUring();
 
 }  // namespace snapshot

From fe52f3946168c858098ad39cc413b4883a36188d Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Tue, 9 Jan 2024 17:21:35 +0800
Subject: [PATCH 0662/1487] adb-remount-test: Only test mounts that are
 remounted by us

Right now we assume all RW mounts (minus /data & special FS) are
remounted by us and we apply the remount/overlayfs related checks
on them unconditionally. This would generate false positives when
a partition was RW but not remounted by us.
The test should instead check mounts that were remounted by us
(transitioned from RO to RW after adb-remount), and ignore
partitions that were already RW before running adb-remount.

Bug: 313609600
Test: adb-remount-test
Change-Id: I94e8a35775271f557790a458781657eb3b24a6f5
---
 fs_mgr/tests/adb-remount-test.sh | 28 ++++++++++++++++++----------
 1 file changed, 18 insertions(+), 10 deletions(-)

diff --git a/fs_mgr/tests/adb-remount-test.sh b/fs_mgr/tests/adb-remount-test.sh
index c87e564c4ce6..7ac7a1642f25 100755
--- a/fs_mgr/tests/adb-remount-test.sh
+++ b/fs_mgr/tests/adb-remount-test.sh
@@ -1233,6 +1233,12 @@ adb_sh grep -qE " (/system|/) [^ ]* rw," /proc/mounts </dev/null &&
 adb_sh grep -q " /vendor [^ ]* rw," /proc/mounts </dev/null &&
   die "/vendor is not RO"
 
+data_device=$(adb_sh awk '$2 == "/data" { print $1; exit }' /proc/mounts)
+RO=$(adb_sh grep " ro," /proc/mounts </dev/null |
+    grep -v "^${data_device}" |
+    skip_administrative_mounts |
+    awk '{ print $1 }')
+
 T=$(adb_date)
 adb remount >&2 ||
   die -t "${T}" "adb remount"
@@ -1241,6 +1247,12 @@ adb_sh grep -qE " (/system|/) [^ ]* rw," /proc/mounts </dev/null ||
 adb_sh grep -q " /vendor [^ ]* rw," /proc/mounts </dev/null ||
   die -t "${T}" "/vendor is not RW"
 
+# Only find mounts that are remounted RO -> RW
+RW=$(adb_sh grep " rw," /proc/mounts </dev/null |
+    grep -v "^${data_device}" |
+    skip_administrative_mounts |
+    grep -E "^($(join_with '|' ${RO})) ")
+
 scratch_on_super=false
 if ${overlayfs_needed}; then
   is_overlayfs_mounted /system ||
@@ -1287,27 +1299,19 @@ if ${overlayfs_needed}; then
     fi
   done
 
-  data_device=$(adb_sh awk '$2 == "/data" { print $1; exit }' /proc/mounts)
   # KISS (we do not support sub-mounts for system partitions currently)
   adb_sh grep "^overlay " /proc/mounts </dev/null |
     grep -vE "^overlay.* /(apex|system|vendor)/[^ ]" |
     grep " overlay ro," &&
     die "expected overlay to be RW after remount"
-  adb_sh grep -v noatime /proc/mounts </dev/null |
-    grep -v "^${data_device}" |
-    skip_administrative_mounts |
-    grep -v ' ro,' &&
-    die "mounts are not noatime"
 
-  D=$(adb_sh grep " rw," /proc/mounts </dev/null |
-      grep -v "^${data_device}" |
-      skip_administrative_mounts |
+  D=$(echo "${RW}" |
       awk '{ print $1 }' |
       sed 's|/dev/root|/|' |
       sort -u)
   if [ -n "${D}" ]; then
     adb_sh df -k ${D} </dev/null |
-      sed -e 's/^Filesystem      /Filesystem (rw) /'
+      sed -e 's/^Filesystem     /Filesystem (rw)/'
   fi >&2
   for d in ${D}; do
     if adb_sh tune2fs -l "${d}" </dev/null 2>&1 | grep -q "Filesystem features:.*shared_blocks" ||
@@ -1319,6 +1323,10 @@ else
   is_overlayfs_mounted && die -t "${T}" "unexpected overlay takeover"
 fi
 
+echo -n "${RW}" |
+  grep -v noatime &&
+  die "mounts (rw) are not noatime"
+
 LOG OK "adb remount RW"
 
 ################################################################################

From d0139b45b8732fe0e610e309373f7f1881bccb42 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Tue, 9 Jan 2024 17:14:07 -0800
Subject: [PATCH 0663/1487] Mark block device as rw before encryptFstab

Some testcases assume that /dev/block/by-name/userdata is writable, but
mount_with_alternatives() will mark block device as RO if mount flag
includes MS_RDONLY. Fix it by marking the block device as RW again.

Test: th
Bug: 319156415
Change-Id: Ic04acd4b6175d3f0aeea88675da44309e8df15e8
---
 fs_mgr/fs_mgr.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index b0e2d6da4b3a..8c0c1efe3ac8 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -1550,6 +1550,7 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                 }
                 encryptable = status;
                 if (status == FS_MGR_MNTALL_DEV_NEEDS_METADATA_ENCRYPTION) {
+                    fs_mgr_set_blk_ro(attempted_entry.blk_device, false);
                     if (!call_vdc({"cryptfs", "encryptFstab", attempted_entry.blk_device,
                                    attempted_entry.mount_point, wiped ? "true" : "false",
                                    attempted_entry.fs_type, attempted_entry.zoned_device},

From dd62ec3288cc3ebcec95cf0c416f115a07a7d2cf Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Tue, 9 Jan 2024 16:46:06 +0800
Subject: [PATCH 0664/1487] fs_mgr_overlayfs: Trim surrounding "@" from the per
 mountpoint scratch dir name

Right now we encode the per mountpoint scratch dir name like this:
  /system -> /mnt/overlay/@system/
  /product/app -> /mnt/overlay/@product@app/

This CL changes it to:
  /system -> /mnt/overlay/system/
  /product/app -> /mnt/overlay/product@app/

This makes it so that the encoded path for top-level mountpoints (like
/system, /vendor) would have the same encoded scratch dir as before
https://r.android.com/2795755 was introduced.
With this change old first-stage-init can handle top-level remounts
correctly. However for mountpoints with '/' in them, their remount
scratch dirs would be encoded with the new format, and old
first-stage-init would ignore and not setup these during boot.

This makes the remount mechanism to function partially when running on
an old ramdisk (first-stage-init) + new system combo.
Normally we expect the init_boot ramdisk to be upgraded alongside
system.img, so this change isn't strictly needed. However there are
cases where we might want to develop new OS features on old vendor
platform, thus this change.

Bug: 306124139
Bug: 243503963
Test: adb-remount-test
Change-Id: I9b43641bb338f11c6c83888880948e4b85af14e1
---
 fs_mgr/fs_mgr_overlayfs_mount.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index e1684366b245..a1ec63b69bcb 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -98,7 +98,12 @@ std::string GetEncodedBaseDirForMountPoint(const std::string& mount_point) {
     if (mount_point.empty() || !android::base::Realpath(mount_point, &normalized_path)) {
         return "";
     }
-    return android::base::StringReplace(normalized_path, "/", "@", true);
+    std::string_view sv(normalized_path);
+    if (sv != "/") {
+        android::base::ConsumePrefix(&sv, "/");
+        android::base::ConsumeSuffix(&sv, "/");
+    }
+    return android::base::StringReplace(sv, "/", "@", true);
 }
 
 static bool fs_mgr_is_dir(const std::string& path) {

From 6bc1bfe1604df4816421ddd8825302f0057605c3 Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Wed, 10 Jan 2024 13:47:02 +0900
Subject: [PATCH 0665/1487] Use libvendorsupport for vendor api level
 calculation

Remove temporary 'vendor_api_level_of' function from init and replace
the function with the same in libvendorsupport.

Bug: 312403948
Test: getprop ro.vendor.api_level
Change-Id: I095353e602397220571e131431e7cbd1b8511fa6
Merged-In: I095353e602397220571e131431e7cbd1b8511fa6
---
 init/Android.bp             |  1 +
 init/property_service.cpp   | 24 +++++++++---------------
 libvendorsupport/Android.bp |  1 +
 3 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index a781d8bb99da..a7278d608e50 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -196,6 +196,7 @@ libinit_cc_defaults {
         "libselinux",
         "libunwindstack",
         "libutils",
+        "libvendorsupport",
     ],
     header_libs: ["bionic_libc_platform_headers"],
     bootstrap: true,
diff --git a/init/property_service.cpp b/init/property_service.cpp
index e2cff957ee19..30ad800364f0 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -63,6 +63,7 @@
 #include <selinux/android.h>
 #include <selinux/label.h>
 #include <selinux/selinux.h>
+#include <vendorsupport/api_level.h>
 
 #include "debug_ramdisk.h"
 #include "epoll.h"
@@ -113,7 +114,6 @@ constexpr auto ID_PROP = "ro.build.id";
 constexpr auto LEGACY_ID_PROP = "ro.build.legacy.id";
 constexpr auto VBMETA_DIGEST_PROP = "ro.boot.vbmeta.digest";
 constexpr auto DIGEST_SIZE_USED = 8;
-constexpr auto MAX_VENDOR_API_LEVEL = 1000000;
 
 static bool persistent_properties_loaded = false;
 
@@ -1085,25 +1085,13 @@ static void property_initialize_ro_cpu_abilist() {
     }
 }
 
-static int vendor_api_level_of(int sdk_api_level) {
-    if (sdk_api_level < __ANDROID_API_V__) {
-        return sdk_api_level;
-    }
-    // In Android V, vendor API level started with version 202404.
-    // The calculation assumes that the SDK api level bumps once a year.
-    if (sdk_api_level < __ANDROID_API_FUTURE__) {
-        return 202404 + ((sdk_api_level - __ANDROID_API_V__) * 100);
-    }
-    return MAX_VENDOR_API_LEVEL;
-}
-
 static void property_initialize_ro_vendor_api_level() {
     // ro.vendor.api_level shows the api_level that the vendor images (vendor, odm, ...) are
     // required to support.
     constexpr auto VENDOR_API_LEVEL_PROP = "ro.vendor.api_level";
 
-    auto vendor_api_level = GetIntProperty("ro.board.first_api_level", MAX_VENDOR_API_LEVEL);
-    if (vendor_api_level != MAX_VENDOR_API_LEVEL) {
+    auto vendor_api_level = GetIntProperty("ro.board.first_api_level", __ANDROID_VENDOR_API_MAX__);
+    if (vendor_api_level != __ANDROID_VENDOR_API_MAX__) {
         // Update the vendor_api_level with "ro.board.api_level" only if both "ro.board.api_level"
         // and "ro.board.first_api_level" are defined.
         vendor_api_level = GetIntProperty("ro.board.api_level", vendor_api_level);
@@ -1118,6 +1106,12 @@ static void property_initialize_ro_vendor_api_level() {
 
     vendor_api_level = std::min(vendor_api_level_of(product_first_api_level), vendor_api_level);
 
+    if (vendor_api_level < 0) {
+        LOG(ERROR) << "Unexpected vendor api level for " << VENDOR_API_LEVEL_PROP << ". Check "
+                   << "ro.product.first_api_level and ro.build.version.sdk.";
+        vendor_api_level = __ANDROID_VENDOR_API_MAX__;
+    }
+
     std::string error;
     auto res = PropertySetNoSocket(VENDOR_API_LEVEL_PROP, std::to_string(vendor_api_level), &error);
     if (res != PROP_SUCCESS) {
diff --git a/libvendorsupport/Android.bp b/libvendorsupport/Android.bp
index 16a4c4c8ae08..b4457b1815aa 100644
--- a/libvendorsupport/Android.bp
+++ b/libvendorsupport/Android.bp
@@ -19,6 +19,7 @@ package {
 cc_library {
     name: "libvendorsupport",
     native_bridge_supported: true,
+    recovery_available: true,
     llndk: {
         symbol_file: "libvendorsupport.map.txt",
     },

From f2810caf7c09b1e6c1e0e0d13343ec4a2bca98cb Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Wed, 10 Jan 2024 13:47:02 +0900
Subject: [PATCH 0666/1487] Use libvendorsupport for vendor api level
 calculation

Remove temporary 'vendor_api_level_of' function from init and replace
the function with the same in libvendorsupport.

Bug: 312403948
Test: getprop ro.vendor.api_level
Ignore-AOSP-First: Avoid merge conflict with ag/23874202
Change-Id: I095353e602397220571e131431e7cbd1b8511fa6
---
 init/Android.bp             |  1 +
 init/property_service.cpp   | 25 ++++++++++---------------
 libvendorsupport/Android.bp |  1 +
 3 files changed, 12 insertions(+), 15 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index a781d8bb99da..a7278d608e50 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -196,6 +196,7 @@ libinit_cc_defaults {
         "libselinux",
         "libunwindstack",
         "libutils",
+        "libvendorsupport",
     ],
     header_libs: ["bionic_libc_platform_headers"],
     bootstrap: true,
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 013924778b8a..61f091094b3a 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -64,6 +64,8 @@
 #include <selinux/android.h>
 #include <selinux/label.h>
 #include <selinux/selinux.h>
+#include <vendorsupport/api_level.h>
+
 #include "debug_ramdisk.h"
 #include "epoll.h"
 #include "init.h"
@@ -113,7 +115,6 @@ constexpr auto ID_PROP = "ro.build.id";
 constexpr auto LEGACY_ID_PROP = "ro.build.legacy.id";
 constexpr auto VBMETA_DIGEST_PROP = "ro.boot.vbmeta.digest";
 constexpr auto DIGEST_SIZE_USED = 8;
-constexpr auto MAX_VENDOR_API_LEVEL = 1000000;
 
 static bool persistent_properties_loaded = false;
 
@@ -1094,25 +1095,13 @@ static void property_initialize_ro_cpu_abilist() {
     }
 }
 
-static int vendor_api_level_of(int sdk_api_level) {
-    if (sdk_api_level < __ANDROID_API_V__) {
-        return sdk_api_level;
-    }
-    // In Android V, vendor API level started with version 202404.
-    // The calculation assumes that the SDK api level bumps once a year.
-    if (sdk_api_level < __ANDROID_API_FUTURE__) {
-        return 202404 + ((sdk_api_level - __ANDROID_API_V__) * 100);
-    }
-    return MAX_VENDOR_API_LEVEL;
-}
-
 static void property_initialize_ro_vendor_api_level() {
     // ro.vendor.api_level shows the api_level that the vendor images (vendor, odm, ...) are
     // required to support.
     constexpr auto VENDOR_API_LEVEL_PROP = "ro.vendor.api_level";
 
-    auto vendor_api_level = GetIntProperty("ro.board.first_api_level", MAX_VENDOR_API_LEVEL);
-    if (vendor_api_level != MAX_VENDOR_API_LEVEL) {
+    auto vendor_api_level = GetIntProperty("ro.board.first_api_level", __ANDROID_VENDOR_API_MAX__);
+    if (vendor_api_level != __ANDROID_VENDOR_API_MAX__) {
         // Update the vendor_api_level with "ro.board.api_level" only if both "ro.board.api_level"
         // and "ro.board.first_api_level" are defined.
         vendor_api_level = GetIntProperty("ro.board.api_level", vendor_api_level);
@@ -1127,6 +1116,12 @@ static void property_initialize_ro_vendor_api_level() {
 
     vendor_api_level = std::min(vendor_api_level_of(product_first_api_level), vendor_api_level);
 
+    if (vendor_api_level < 0) {
+        LOG(ERROR) << "Unexpected vendor api level for " << VENDOR_API_LEVEL_PROP << ". Check "
+                   << "ro.product.first_api_level and ro.build.version.sdk.";
+        vendor_api_level = __ANDROID_VENDOR_API_MAX__;
+    }
+
     std::string error;
     auto res = PropertySetNoSocket(VENDOR_API_LEVEL_PROP, std::to_string(vendor_api_level), &error);
     if (res != PROP_SUCCESS) {
diff --git a/libvendorsupport/Android.bp b/libvendorsupport/Android.bp
index 16a4c4c8ae08..b4457b1815aa 100644
--- a/libvendorsupport/Android.bp
+++ b/libvendorsupport/Android.bp
@@ -19,6 +19,7 @@ package {
 cc_library {
     name: "libvendorsupport",
     native_bridge_supported: true,
+    recovery_available: true,
     llndk: {
         symbol_file: "libvendorsupport.map.txt",
     },

From 8e1c267cdf66c069244c963259704da1eefa438b Mon Sep 17 00:00:00 2001
From: David Drysdale <drysdale@google.com>
Date: Fri, 10 Nov 2023 19:12:18 +0000
Subject: [PATCH 0667/1487] Initial Secretkeeper HAL service for Trusty

Disabled by default; enable with `export SECRETKEEPER_ENABLED=y` before
building.

Also needs the Secretkeeper TA to be present in Trusty; if the TA is
absent, the HAL service will (repeatedly) fail to connect.

Test: build, VtsSecretkeeperTargetTest
Bug: 306364873
Change-Id: I529013395d0e3afbff4a24b663088adce2a23805
---
 trusty/secretkeeper/Android.bp                |  42 ++++++
 ...d.hardware.security.secretkeeper.trusty.rc |   4 +
 ....hardware.security.secretkeeper.trusty.xml |   7 +
 trusty/secretkeeper/src/hal_main.rs           | 141 ++++++++++++++++++
 trusty/trusty-base.mk                         |   8 +
 5 files changed, 202 insertions(+)
 create mode 100644 trusty/secretkeeper/Android.bp
 create mode 100644 trusty/secretkeeper/android.hardware.security.secretkeeper.trusty.rc
 create mode 100644 trusty/secretkeeper/android.hardware.security.secretkeeper.trusty.xml
 create mode 100644 trusty/secretkeeper/src/hal_main.rs

diff --git a/trusty/secretkeeper/Android.bp b/trusty/secretkeeper/Android.bp
new file mode 100644
index 000000000000..84db8c222d3f
--- /dev/null
+++ b/trusty/secretkeeper/Android.bp
@@ -0,0 +1,42 @@
+//
+// Copyright (C) 2022 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.
+
+package {
+    default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+rust_binary {
+    name: "android.hardware.security.secretkeeper.trusty",
+    relative_install_path: "hw",
+    vendor: true,
+    init_rc: ["android.hardware.security.secretkeeper.trusty.rc"],
+    vintf_fragments: ["android.hardware.security.secretkeeper.trusty.xml"],
+    srcs: [
+        "src/hal_main.rs",
+    ],
+    rustlibs: [
+        "libandroid_logger",
+        "libbinder_rs",
+        "libauthgraph_hal",
+        "libtrusty-rs",
+        "liblibc",
+        "liblog_rust",
+        "libsecretkeeper_hal",
+    ],
+    defaults: [
+        "secretkeeper_use_latest_hal_aidl_rust",
+    ],
+    prefer_rlib: true,
+}
diff --git a/trusty/secretkeeper/android.hardware.security.secretkeeper.trusty.rc b/trusty/secretkeeper/android.hardware.security.secretkeeper.trusty.rc
new file mode 100644
index 000000000000..3be03ad80e71
--- /dev/null
+++ b/trusty/secretkeeper/android.hardware.security.secretkeeper.trusty.rc
@@ -0,0 +1,4 @@
+service vendor.secretkeeper.trusty /vendor/bin/hw/android.hardware.security.secretkeeper.trusty
+    class hal
+    user nobody
+    group drmrpc
\ No newline at end of file
diff --git a/trusty/secretkeeper/android.hardware.security.secretkeeper.trusty.xml b/trusty/secretkeeper/android.hardware.security.secretkeeper.trusty.xml
new file mode 100644
index 000000000000..2ac152bf274c
--- /dev/null
+++ b/trusty/secretkeeper/android.hardware.security.secretkeeper.trusty.xml
@@ -0,0 +1,7 @@
+<manifest version="1.0" type="device">
+    <hal format="aidl">
+        <name>android.hardware.security.secretkeeper</name>
+        <version>1</version>
+        <fqname>ISecretkeeper/default</fqname>
+    </hal>
+</manifest>
diff --git a/trusty/secretkeeper/src/hal_main.rs b/trusty/secretkeeper/src/hal_main.rs
new file mode 100644
index 000000000000..9439c369b5f1
--- /dev/null
+++ b/trusty/secretkeeper/src/hal_main.rs
@@ -0,0 +1,141 @@
+//
+// Copyright (C) 2022 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.
+
+//! This module implements the HAL service for Secretkeeper in Trusty.
+use authgraph_hal::{channel::SerializedChannel};
+use secretkeeper_hal::SecretkeeperService;
+use android_hardware_security_secretkeeper::aidl::android::hardware::security::secretkeeper::ISecretkeeper::{
+    ISecretkeeper, BpSecretkeeper,
+};
+use log::{error, info};
+use std::{
+    ffi::CString,
+    panic,
+    sync::{Arc, Mutex},
+};
+use trusty::DEFAULT_DEVICE;
+
+const SK_TIPC_SERVICE_PORT: &str = "com.android.trusty.secretkeeper";
+const AG_TIPC_SERVICE_PORT: &str = "com.android.trusty.secretkeeper.authgraph";
+
+static SERVICE_INSTANCE: &str = "default";
+
+/// Local error type for failures in the HAL service.
+#[derive(Debug, Clone)]
+struct HalServiceError(String);
+
+#[derive(Debug)]
+struct TipcChannel {
+    channel: Arc<Mutex<trusty::TipcChannel>>,
+}
+
+impl TipcChannel {
+    fn new(channel: trusty::TipcChannel) -> Self {
+        Self { channel: Arc::new(Mutex::new(channel)) }
+    }
+}
+
+impl SerializedChannel for TipcChannel {
+    const MAX_SIZE: usize = 4000;
+    fn execute(&self, req_data: &[u8]) -> binder::Result<Vec<u8>> {
+        // Hold lock across both request and response.
+        let mut channel = self.channel.lock().unwrap();
+        channel.send(req_data).map_err(|e| {
+            binder::Status::new_exception(
+                binder::ExceptionCode::TRANSACTION_FAILED,
+                Some(
+                    &CString::new(format!(
+                        "Failed to send the request via tipc channel because of {:?}",
+                        e
+                    ))
+                    .unwrap(),
+                ),
+            )
+        })?;
+        // TODO: cope with fragmentation and reassembly
+        let mut rsp_data = Vec::new();
+        channel.recv(&mut rsp_data).map_err(|e| {
+            binder::Status::new_exception(
+                binder::ExceptionCode::TRANSACTION_FAILED,
+                Some(
+                    &CString::new(format!(
+                        "Failed to receive the response via tipc channel because of {:?}",
+                        e
+                    ))
+                    .unwrap(),
+                ),
+            )
+        })?;
+        Ok(rsp_data)
+    }
+}
+
+fn main() {
+    if let Err(e) = inner_main() {
+        panic!("HAL service failed: {:?}", e);
+    }
+}
+
+fn inner_main() -> Result<(), HalServiceError> {
+    // Initialize Android logging.
+    android_logger::init_once(
+        android_logger::Config::default()
+            .with_tag("secretkeeper-hal-trusty")
+            .with_min_level(log::Level::Info)
+            .with_log_id(android_logger::LogId::System),
+    );
+    // Redirect panic messages to logcat.
+    panic::set_hook(Box::new(|panic_info| {
+        error!("{}", panic_info);
+    }));
+
+    info!("Trusty Secretkeeper HAL service is starting.");
+
+    info!("Starting thread pool now.");
+    binder::ProcessState::start_thread_pool();
+
+    // Create connections to the TA.
+    let ag_connection = trusty::TipcChannel::connect(DEFAULT_DEVICE, AG_TIPC_SERVICE_PORT)
+        .map_err(|e| {
+            HalServiceError(format!(
+                "Failed to connect to Trusty port {AG_TIPC_SERVICE_PORT} because of {:?}.",
+                e
+            ))
+        })?;
+    let ag_tipc_channel = TipcChannel::new(ag_connection);
+
+    let sk_connection = trusty::TipcChannel::connect(DEFAULT_DEVICE, SK_TIPC_SERVICE_PORT)
+        .map_err(|e| {
+            HalServiceError(format!(
+                "Failed to connect to Trusty port {SK_TIPC_SERVICE_PORT} because of {:?}.",
+                e
+            ))
+        })?;
+    let sk_tipc_channel = TipcChannel::new(sk_connection);
+
+    // Register the AIDL service
+    let service = SecretkeeperService::new_as_binder(sk_tipc_channel, ag_tipc_channel);
+    let service_name =
+        format!("{}/{}", <BpSecretkeeper as ISecretkeeper>::get_descriptor(), SERVICE_INSTANCE);
+    binder::add_service(&service_name, service.as_binder()).map_err(|e| {
+        HalServiceError(format!("Failed to register service {} because of {:?}.", service_name, e))
+    })?;
+
+    info!("Successfully registered Secretkeeper HAL service.");
+    info!("Joining thread pool now.");
+    binder::ProcessState::join_thread_pool();
+    info!("Secretkeeper HAL service is terminating."); // should not reach here
+    Ok(())
+}
diff --git a/trusty/trusty-base.mk b/trusty/trusty-base.mk
index 1986c73e92a8..d645c3e40d47 100644
--- a/trusty/trusty-base.mk
+++ b/trusty/trusty-base.mk
@@ -35,8 +35,16 @@ else
     LOCAL_KEYMINT_PRODUCT_PACKAGE := android.hardware.security.keymint-service.trusty
 endif
 
+# TODO(b/306364873): move this to be flag-controlled?
+ifeq ($(SECRETKEEPER_ENABLED),)
+    LOCAL_SECRETKEEPER_PRODUCT_PACKAGE :=
+else
+    LOCAL_SECRETKEEPER_PRODUCT_PACKAGE := android.hardware.security.secretkeeper.trusty
+endif
+
 PRODUCT_PACKAGES += \
 	$(LOCAL_KEYMINT_PRODUCT_PACKAGE) \
+	$(LOCAL_SECRETKEEPER_PRODUCT_PACKAGE) \
 	android.hardware.gatekeeper-service.trusty \
 	trusty_apploader \
 

From 42a3f876ada566e0f03934795e4033bc736f437c Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Thu, 4 Jan 2024 13:51:52 -0800
Subject: [PATCH 0668/1487] trusty: clear fuzzer's extra counters directly

The FuzzerDefs.h APIs are internal to the fuzzer and aren't available
when the fuzzer is built with a custom private libc++, so remove the
ExtraCountersBegin/ExtraCountersEnd assertions and inline the array
clearing.

Bug: 175635923
Bug: 303175229
Bug: 315079422
Test: m libtrusty_fuzz_utils trusty_gatekeeper_fuzzer
Change-Id: I1ca9d9867026ff6f8e494ac6026fb1314caab7d1
---
 trusty/fuzz/Android.bp   |  3 ---
 trusty/fuzz/counters.cpp | 10 +++-------
 2 files changed, 3 insertions(+), 10 deletions(-)

diff --git a/trusty/fuzz/Android.bp b/trusty/fuzz/Android.bp
index 5d0ff7920077..8a93e5ee7663 100644
--- a/trusty/fuzz/Android.bp
+++ b/trusty/fuzz/Android.bp
@@ -41,9 +41,6 @@ cc_library {
         "utils.cpp",
     ],
     export_include_dirs: ["include"],
-    static_libs: [
-        "libFuzzer",
-    ],
     shared_libs: [
         "libtrusty_coverage",
         "libbase",
diff --git a/trusty/fuzz/counters.cpp b/trusty/fuzz/counters.cpp
index 65a3ba6f42a6..e730ec3204e7 100644
--- a/trusty/fuzz/counters.cpp
+++ b/trusty/fuzz/counters.cpp
@@ -16,12 +16,12 @@
 
 #define LOG_TAG "trusty-fuzz-counters"
 
-#include <FuzzerDefs.h>
-
 #include <trusty/fuzz/counters.h>
 
 #include <android-base/logging.h>
+#include <assert.h>
 #include <log/log.h>
+#include <string.h>
 #include <trusty/coverage/coverage.h>
 #include <trusty/coverage/tipc.h>
 
@@ -45,9 +45,6 @@ ExtraCounters::ExtraCounters(coverage::CoverageRecord* record) : record_(record)
         return;
     }
 
-    assert(fuzzer::ExtraCountersBegin());
-    assert(fuzzer::ExtraCountersEnd());
-
     volatile uint8_t* begin = NULL;
     volatile uint8_t* end = NULL;
     record_->GetRawCounts(&begin, &end);
@@ -66,9 +63,8 @@ void ExtraCounters::Reset() {
     if (!record_->IsOpen()) {
         return;
     }
-
     record_->ResetCounts();
-    fuzzer::ClearExtraCounters();
+    memset_explicit(const_cast<uint8_t*>(counters), 0, sizeof(counters));
 }
 
 void ExtraCounters::Flush() {

From 36dfed94765be431157c9f44071ed7f597c5523d Mon Sep 17 00:00:00 2001
From: David Drysdale <drysdale@google.com>
Date: Thu, 11 Jan 2024 10:00:48 +0000
Subject: [PATCH 0669/1487] Secretkeeper: add Trusty fuzzers

Bug: 306364873
Test: initial short run of fuzzers on device, with aosp/2737933 reverted
Change-Id: I00ac6ab2678697d69a71aa3615c580c210772f20
---
 trusty/secretkeeper/Android.bp | 54 ++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/trusty/secretkeeper/Android.bp b/trusty/secretkeeper/Android.bp
index 84db8c222d3f..f6b740a176e0 100644
--- a/trusty/secretkeeper/Android.bp
+++ b/trusty/secretkeeper/Android.bp
@@ -40,3 +40,57 @@ rust_binary {
     ],
     prefer_rlib: true,
 }
+
+cc_defaults {
+    name: "trusty_secretkeeper_fuzz_defaults",
+    srcs: [":trusty_tipc_fuzzer"],
+    fuzz_config: {
+        cc: [
+            "alanstokes@google.com",
+            "drysdale@google.com",
+            "shikhapanwar@google.com",
+        ],
+        componentid: 867125,
+        // TODO: add Secretkeeper hotlist
+        // hotlists: [""],
+    },
+}
+
+cc_fuzz {
+    name: "trusty_secretkeeper_sk_fuzzer",
+    defaults: [
+        "trusty_fuzzer_defaults",
+        "trusty_secretkeeper_fuzz_defaults",
+    ],
+    cflags: [
+        "-DTRUSTY_APP_PORT=\"com.android.trusty.secretkeeper\"",
+        "-DTRUSTY_APP_UUID=\"4582bf12-1f7d-4830-9be5-36e6bd91c2c6\"",
+        "-DTRUSTY_APP_FILENAME=\"secretkeeper_app.syms.elf\"",
+    ],
+}
+
+cc_fuzz {
+    name: "trusty_secretkeeper_ag_fuzzer",
+    defaults: [
+        "trusty_fuzzer_defaults",
+        "trusty_secretkeeper_fuzz_defaults",
+    ],
+    cflags: [
+        "-DTRUSTY_APP_PORT=\"com.android.trusty.secretkeeper.authgraph\"",
+        "-DTRUSTY_APP_UUID=\"4582bf12-1f7d-4830-9be5-36e6bd91c2c6\"",
+        "-DTRUSTY_APP_FILENAME=\"secretkeeper_app.syms.elf\"",
+    ],
+}
+
+cc_fuzz {
+    name: "trusty_secretkeeper_bl_fuzzer",
+    defaults: [
+        "trusty_fuzzer_defaults",
+        "trusty_secretkeeper_fuzz_defaults",
+    ],
+    cflags: [
+        "-DTRUSTY_APP_PORT=\"com.android.trusty.secretkeeper.bootloader\"",
+        "-DTRUSTY_APP_UUID=\"4582bf12-1f7d-4830-9be5-36e6bd91c2c6\"",
+        "-DTRUSTY_APP_FILENAME=\"secretkeeper_app.syms.elf\"",
+    ],
+}

From b1105589b752d9c85769c8265e8f051b95ce8d96 Mon Sep 17 00:00:00 2001
From: David Drysdale <drysdale@google.com>
Date: Fri, 12 Jan 2024 16:21:11 +0000
Subject: [PATCH 0670/1487] Revert "rpc_binder: Change `trusty_tipc_fuzzer` to
 support multiple connections and messages"

This reverts commit 589c8d1e44cff96092c943f22cc10a9c23b81c01.

Reason for revert: fuzzer crashes immediately on line 99 as vector is empty

Change-Id: I5e56a94671a43cd131c250d98f7cfae3c96f34ab
---
 trusty/fuzz/tipc_fuzzer.cpp | 79 +++++++++----------------------------
 1 file changed, 18 insertions(+), 61 deletions(-)

diff --git a/trusty/fuzz/tipc_fuzzer.cpp b/trusty/fuzz/tipc_fuzzer.cpp
index edc2a79a5260..f265cedb698f 100644
--- a/trusty/fuzz/tipc_fuzzer.cpp
+++ b/trusty/fuzz/tipc_fuzzer.cpp
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-#include <android-base/result.h>
-#include <fuzzer/FuzzedDataProvider.h>
 #include <stdlib.h>
 #include <trusty/coverage/coverage.h>
 #include <trusty/coverage/uuid.h>
@@ -25,7 +23,6 @@
 #include <iostream>
 #include <memory>
 
-using android::base::Result;
 using android::trusty::coverage::CoverageRecord;
 using android::trusty::fuzz::ExtraCounters;
 using android::trusty::fuzz::TrustyApp;
@@ -44,14 +41,7 @@ using android::trusty::fuzz::TrustyApp;
 #error "Binary file name must be parameterized using -DTRUSTY_APP_FILENAME."
 #endif
 
-#ifdef TRUSTY_APP_MAX_CONNECTIONS
-constexpr size_t MAX_CONNECTIONS = TRUSTY_APP_MAX_CONNECTIONS;
-#else
-constexpr size_t MAX_CONNECTIONS = 1;
-#endif
-
-static_assert(MAX_CONNECTIONS >= 1);
-
+static TrustyApp kTrustyApp(TIPC_DEV, TRUSTY_APP_PORT);
 static std::unique_ptr<CoverageRecord> record;
 
 extern "C" int LLVMFuzzerInitialize(int* /* argc */, char*** /* argv */) {
@@ -63,8 +53,7 @@ extern "C" int LLVMFuzzerInitialize(int* /* argc */, char*** /* argv */) {
     }
 
     /* Make sure lazy-loaded TAs have started and connected to coverage service. */
-    TrustyApp ta(TIPC_DEV, TRUSTY_APP_PORT);
-    auto ret = ta.Connect();
+    auto ret = kTrustyApp.Connect();
     if (!ret.ok()) {
         std::cerr << ret.error() << std::endl;
         exit(-1);
@@ -84,56 +73,24 @@ extern "C" int LLVMFuzzerInitialize(int* /* argc */, char*** /* argv */) {
     return 0;
 }
 
-Result<void> testOneInput(FuzzedDataProvider& provider) {
-    std::vector<TrustyApp> trustyApps;
-
-    while (provider.remaining_bytes() > 0) {
-        if (trustyApps.size() < MAX_CONNECTIONS && provider.ConsumeBool()) {
-            auto& ta = trustyApps.emplace_back(TIPC_DEV, TRUSTY_APP_PORT);
-            const auto result = ta.Connect();
-            if (!result.ok()) {
-                return result;
-            }
-        } else {
-            const auto i = provider.ConsumeIntegralInRange<size_t>(0, trustyApps.size());
-            std::swap(trustyApps[i], trustyApps.back());
-
-            if (provider.ConsumeBool()) {
-                auto& ta = trustyApps.back();
-
-                const auto data = provider.ConsumeRandomLengthString();
-                auto result = ta.Write(data.data(), data.size());
-                if (!result.ok()) {
-                    return result;
-                }
-
-                std::array<uint8_t, TIPC_MAX_MSG_SIZE> buf;
-                result = ta.Read(buf.data(), buf.size());
-                if (!result.ok()) {
-                    return result;
-                }
-
-                // Reconnect to ensure that the service is still up.
-                ta.Disconnect();
-                result = ta.Connect();
-                if (!result.ok()) {
-                    std::cerr << result.error() << std::endl;
-                    android::trusty::fuzz::Abort();
-                    return result;
-                }
-            } else {
-                trustyApps.pop_back();
-            }
-        }
-    }
-    return {};
-}
-
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+    static uint8_t buf[TIPC_MAX_MSG_SIZE];
+
     ExtraCounters counters(record.get());
     counters.Reset();
 
-    FuzzedDataProvider provider(data, size);
-    const auto result = testOneInput(provider);
-    return result.ok() ? 0 : -1;
+    auto ret = kTrustyApp.Write(data, size);
+    if (ret.ok()) {
+        ret = kTrustyApp.Read(&buf, sizeof(buf));
+    }
+
+    // Reconnect to ensure that the service is still up
+    kTrustyApp.Disconnect();
+    ret = kTrustyApp.Connect();
+    if (!ret.ok()) {
+        std::cerr << ret.error() << std::endl;
+        android::trusty::fuzz::Abort();
+    }
+
+    return ret.ok() ? 0 : -1;
 }

From 42f8cd3bf906e95da7700067fc1cdab09847f9d5 Mon Sep 17 00:00:00 2001
From: Andy Hung <hunga@google.com>
Date: Thu, 11 Jan 2024 18:57:27 -0800
Subject: [PATCH 0671/1487] debuggerd: dump frozen Java processes

Test: stacks <pid>
Test: adb shell debuggerd -b <pid>
Bug: 319754740
Change-Id: Iae230ff34409bee4a325113aed65433292975427
---
 debuggerd/debuggerd.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/debuggerd/debuggerd.cpp b/debuggerd/debuggerd.cpp
index 26726cf89747..0d4b91f75700 100644
--- a/debuggerd/debuggerd.cpp
+++ b/debuggerd/debuggerd.cpp
@@ -91,6 +91,15 @@ int main(int argc, char* argv[]) {
     }
   }
 
+  // unfreeze if pid is frozen.
+  const std::string freeze_file = android::base::StringPrintf(
+      "/sys/fs/cgroup/uid_%d/pid_%d/cgroup.freeze", proc_info.uid, proc_info.pid);
+  if (std::string freeze_status;
+      android::base::ReadFileToString(freeze_file, &freeze_status) && freeze_status[0] == '1') {
+    android::base::WriteStringToFile("0", freeze_file);
+    // we don't restore the frozen state as this is considered a benign change.
+  }
+
   unique_fd output_fd(fcntl(STDOUT_FILENO, F_DUPFD_CLOEXEC, 0));
   if (output_fd.get() == -1) {
     err(1, "failed to fcntl dup stdout");

From 63da53fdded95c9f5ccb7ea7113f6849ada79995 Mon Sep 17 00:00:00 2001
From: youngtaecha <youngtaecha@google.com>
Date: Sat, 13 Jan 2024 14:52:46 +0000
Subject: [PATCH 0672/1487] A new folder to store OTA telephony config update

Bug: 320002105
Test: Build, checked /data/misc/telephonyconfig is system radio

Change-Id: Id8efee15594f372fa6aaf3fe9b9081a3cefe327b
---
 rootdir/init.rc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index a8e867d2356c..0332e0db91b0 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -778,6 +778,7 @@ on post-fs-data
     mkdir /data/misc/apns 0770 system radio
     mkdir /data/misc/emergencynumberdb 0770 system radio
     mkdir /data/misc/network_watchlist 0774 system system
+    mkdir /data/misc/telephonyconfig 0770 system radio
     mkdir /data/misc/textclassifier 0771 system system
     mkdir /data/misc/vpn 0770 system vpn
     mkdir /data/misc/shared_relro 0771 shared_relro shared_relro

From 3ae52c45ce5b9c304fb0cc02859e7e1d5fac3deb Mon Sep 17 00:00:00 2001
From: Raphael Herouart <rherouart@google.com>
Date: Tue, 16 Jan 2024 12:44:53 +0000
Subject: [PATCH 0673/1487] tipc-test: Allow tipc tests to be run as benchmarks

Adding one command line parameter -B to allow tipc test to be run as benchmarks.

Bug: 314130383
Test: /data/nativetest64/vendor/tipc-test/tipc-test -t echo -r 1 -B 100
Change-Id: I5cdd643ce6e9e289033180cff433e45f77206729
---
 trusty/libtrusty/tipc-test/tipc_test.c | 480 ++++++++++++++-----------
 1 file changed, 275 insertions(+), 205 deletions(-)

diff --git a/trusty/libtrusty/tipc-test/tipc_test.c b/trusty/libtrusty/tipc-test/tipc_test.c
index 0f5078753219..dabe118e10ed 100644
--- a/trusty/libtrusty/tipc-test/tipc_test.c
+++ b/trusty/libtrusty/tipc-test/tipc_test.c
@@ -22,8 +22,10 @@
 #include <unistd.h>
 #include <getopt.h>
 #define __USE_GNU
+#include <inttypes.h>
 #include <sys/mman.h>
 #include <sys/uio.h>
+#include <time.h>
 
 #include <BufferAllocator/BufferAllocatorWrapper.h>
 
@@ -31,8 +33,27 @@
 
 #define TIPC_DEFAULT_DEVNAME "/dev/trusty-ipc-dev0"
 
-static const char *dev_name = NULL;
-static const char *test_name = NULL;
+/* clang-format off */
+#define BENCH_RESULT_TPL                                    \
+"{"                                                         \
+"    \"schema_version\": 3,"                                \
+"    \"suite_name\": \"crypto\","                           \
+"    \"bench_name\": \"%s\","                               \
+"    \"results\": ["                                        \
+"        {"                                                 \
+"            \"metric_name\": \"time_micro_sec\","          \
+"            \"min\": \"%" PRId64 "\","                     \
+"            \"max\": \"%" PRId64 "\","                     \
+"            \"avg\": \"%" PRId64 "\","                     \
+"            \"cold\": \"%" PRId64 "\","                    \
+"            \"raw_min\": %" PRId64 ","                     \
+"            \"raw_max\": %" PRId64 ","                     \
+"            \"raw_avg\": %" PRId64 ","                     \
+"            \"raw_cold\": %" PRId64 ""                     \
+"        },"                                                \
+"    ]"                                                     \
+"}"
+/* clang-format on */
 
 static const char *uuid_name = "com.android.ipc-unittest.srv.uuid";
 static const char *echo_name = "com.android.ipc-unittest.srv.echo";
@@ -46,7 +67,7 @@ static const char *main_ctrl_name = "com.android.ipc-unittest.ctrl";
 static const char* receiver_name = "com.android.trusty.memref.receiver";
 static const size_t memref_chunk_size = 4096;
 
-static const char* _sopts = "hsvDS:t:r:m:b:";
+static const char* _sopts = "hsvDS:t:r:m:b:B:";
 /* clang-format off */
 static const struct option _lopts[] =  {
     {"help",    no_argument,       0, 'h'},
@@ -57,6 +78,8 @@ static const struct option _lopts[] =  {
     {"repeat",  required_argument, 0, 'r'},
     {"burst",   required_argument, 0, 'b'},
     {"msgsize", required_argument, 0, 'm'},
+    {"test",    required_argument, 0, 't'},
+    {"bench",   required_argument, 0, 'B'},
     {0, 0, 0, 0}
 };
 /* clang-format on */
@@ -74,6 +97,7 @@ static const char* usage =
         "  -m, --msgsize size    max message size\n"
         "  -v, --variable        variable message size\n"
         "  -s, --silent          silent\n"
+        "  -B, --bench           Run as Benchmark N times\n"
         "\n";
 
 static const char* usage_long =
@@ -96,12 +120,34 @@ static const char* usage_long =
         "   send-fd      - transmit dma_buf to trusty, use as shm\n"
         "\n";
 
-static uint opt_repeat  = 1;
-static uint opt_msgsize = 32;
-static uint opt_msgburst = 32;
-static bool opt_variable = false;
-static bool opt_silent = false;
-static char* srv_name = NULL;
+struct tipc_test_params {
+    uint repeat;
+    uint msgsize;
+    uint msgburst;
+    bool variable;
+    bool silent;
+    uint bench;
+    char* srv_name;
+    char* dev_name;
+    char* test_name;
+};
+typedef int (*tipc_test_func_t)(const struct tipc_test_params*);
+
+struct tipc_test_def {
+    char* test_name;
+    tipc_test_func_t func;
+};
+
+static void init_params(struct tipc_test_params* params) {
+    params->repeat = 1;
+    params->msgsize = 32;
+    params->msgburst = 32;
+    params->variable = false;
+    params->silent = false;
+    params->bench = 0;
+    params->srv_name = NULL;
+    params->test_name = NULL;
+}
 
 static void print_usage_and_exit(const char *prog, int code, bool verbose)
 {
@@ -110,8 +156,7 @@ static void print_usage_and_exit(const char *prog, int code, bool verbose)
     exit(code);
 }
 
-static void parse_options(int argc, char **argv)
-{
+static void parse_options(int argc, char** argv, struct tipc_test_params* params) {
     int c;
     int oidx = 0;
 
@@ -121,35 +166,39 @@ static void parse_options(int argc, char **argv)
 
         switch (c) {
             case 'D':
-                dev_name = strdup(optarg);
+                params->dev_name = strdup(optarg);
                 break;
 
             case 'S':
-                srv_name = strdup(optarg);
+                params->srv_name = strdup(optarg);
                 break;
 
             case 't':
-                test_name = strdup(optarg);
+                params->test_name = strdup(optarg);
                 break;
 
             case 'v':
-                opt_variable = true;
+                params->variable = true;
                 break;
 
             case 'r':
-                opt_repeat = atoi(optarg);
+                params->repeat = atoi(optarg);
                 break;
 
             case 'm':
-                opt_msgsize = atoi(optarg);
+                params->msgsize = atoi(optarg);
                 break;
 
             case 'b':
-                opt_msgburst = atoi(optarg);
+                params->msgburst = atoi(optarg);
                 break;
 
             case 's':
-                opt_silent = true;
+                params->silent = true;
+                break;
+
+            case 'B':
+                params->bench = atoi(optarg);
                 break;
 
             case 'h':
@@ -162,32 +211,31 @@ static void parse_options(int argc, char **argv)
     }
 }
 
-static int connect_test(uint repeat)
-{
+static int connect_test(const struct tipc_test_params* params) {
     uint i;
     int echo_fd;
     int dsink_fd;
     int custom_fd;
 
-    if (!opt_silent) {
-        printf("%s: repeat = %u\n", __func__, repeat);
+    if (!params->silent) {
+        printf("%s: repeat = %u\n", __func__, params->repeat);
     }
 
-    for (i = 0; i < repeat; i++) {
-        if (srv_name) {
-            custom_fd = tipc_connect(dev_name, srv_name);
+    for (i = 0; i < params->repeat; i++) {
+        if (params->srv_name) {
+            custom_fd = tipc_connect(params->dev_name, params->srv_name);
             if (custom_fd < 0) {
-                fprintf(stderr, "Failed to connect to '%s' service\n", srv_name);
+                fprintf(stderr, "Failed to connect to '%s' service\n", params->srv_name);
             }
             if (custom_fd >= 0) {
                 tipc_close(custom_fd);
             }
         } else {
-            echo_fd = tipc_connect(dev_name, echo_name);
+            echo_fd = tipc_connect(params->dev_name, echo_name);
             if (echo_fd < 0) {
                 fprintf(stderr, "Failed to connect to '%s' service\n", "echo");
             }
-            dsink_fd = tipc_connect(dev_name, datasink_name);
+            dsink_fd = tipc_connect(params->dev_name, datasink_name);
             if (dsink_fd < 0) {
                 fprintf(stderr, "Failed to connect to '%s' service\n", "datasink");
             }
@@ -201,79 +249,75 @@ static int connect_test(uint repeat)
         }
     }
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s: done\n", __func__);
     }
 
     return 0;
 }
 
-static int connect_foo(uint repeat)
-{
+static int connect_foo(const struct tipc_test_params* params) {
     uint i;
     int fd;
 
-    if (!opt_silent) {
-        printf("%s: repeat = %u\n", __func__, repeat);
+    if (!params->silent) {
+        printf("%s: repeat = %u\n", __func__, params->repeat);
     }
 
-    for (i = 0; i < repeat; i++) {
-        fd = tipc_connect(dev_name, "foo");
+    for (i = 0; i < params->repeat; i++) {
+        fd = tipc_connect(params->dev_name, "foo");
         if (fd >= 0) {
             fprintf(stderr, "succeeded to connect to '%s' service\n", "foo");
             tipc_close(fd);
         }
     }
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s: done\n", __func__);
     }
 
     return 0;
 }
 
-
-static int closer1_test(uint repeat)
-{
+static int closer1_test(const struct tipc_test_params* params) {
     uint i;
     int fd;
 
-    if (!opt_silent) {
-        printf("%s: repeat = %u\n", __func__, repeat);
+    if (!params->silent) {
+        printf("%s: repeat = %u\n", __func__, params->repeat);
     }
 
-    for (i = 0; i < repeat; i++) {
-        fd = tipc_connect(dev_name, closer1_name);
+    for (i = 0; i < params->repeat; i++) {
+        fd = tipc_connect(params->dev_name, closer1_name);
         if (fd < 0) {
             fprintf(stderr, "Failed to connect to '%s' service\n", "closer1");
             continue;
         }
-        if (!opt_silent) {
+        if (!params->silent) {
             printf("%s: connected\n", __func__);
         }
         tipc_close(fd);
     }
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s: done\n", __func__);
     }
 
     return 0;
 }
 
-static int closer2_test(uint repeat)
-{
+static int closer2_test(const struct tipc_test_params* params) {
     uint i;
     int fd;
 
-    if (!opt_silent) {
-        printf("%s: repeat = %u\n", __func__, repeat);
+    if (!params->silent) {
+        printf("%s: repeat = %u\n", __func__, params->repeat);
     }
 
-    for (i = 0; i < repeat; i++) {
-        fd = tipc_connect(dev_name, closer2_name);
+    for (i = 0; i < params->repeat; i++) {
+        fd = tipc_connect(params->dev_name, closer2_name);
         if (fd < 0) {
-            if (!opt_silent) {
+            if (!params->silent) {
                 printf("failed to connect to '%s' service\n", "closer2");
             }
         } else {
@@ -283,38 +327,37 @@ static int closer2_test(uint repeat)
         }
     }
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s: done\n", __func__);
     }
 
     return 0;
 }
 
-static int closer3_test(uint repeat)
-{
+static int closer3_test(const struct tipc_test_params* params) {
     uint i, j;
     ssize_t rc;
     int fd[4];
     char buf[64];
 
-    if (!opt_silent) {
-        printf("%s: repeat = %u\n", __func__, repeat);
+    if (!params->silent) {
+        printf("%s: repeat = %u\n", __func__, params->repeat);
     }
 
-    for (i = 0; i < repeat; i++) {
+    for (i = 0; i < params->repeat; i++) {
         /* open 4 connections to closer3 service */
         for (j = 0; j < 4; j++) {
-            fd[j] = tipc_connect(dev_name, closer3_name);
+            fd[j] = tipc_connect(params->dev_name, closer3_name);
             if (fd[j] < 0) {
                 fprintf(stderr, "fd[%d]: failed to connect to '%s' service\n", j, "closer3");
             } else {
-                if (!opt_silent) {
+                if (!params->silent) {
                     printf("%s: fd[%d]=%d: connected\n", __func__, j, fd[j]);
                 }
                 memset(buf, i + j, sizeof(buf));
                 rc = write(fd[j], buf, sizeof(buf));
                 if (rc != sizeof(buf)) {
-                    if (!opt_silent) {
+                    if (!params->silent) {
                         printf("%s: fd[%d]=%d: write returned  = %zd\n", __func__, j, fd[j], rc);
                     }
                     perror("closer3_test: write");
@@ -330,7 +373,7 @@ static int closer3_test(uint repeat)
             if (fd[j] < 0) continue;
             rc = write(fd[j], buf, sizeof(buf));
             if (rc != sizeof(buf)) {
-                if (!opt_silent) {
+                if (!params->silent) {
                     printf("%s: fd[%d]=%d: write returned = %zd\n", __func__, j, fd[j], rc);
                 }
                 perror("closer3_test: write");
@@ -345,38 +388,36 @@ static int closer3_test(uint repeat)
         }
     }
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s: done\n", __func__);
     }
 
     return 0;
 }
 
-
-static int echo_test(uint repeat, uint msgsz, bool var)
-{
+static int echo_test(const struct tipc_test_params* params) {
     uint i;
     ssize_t rc;
     size_t msg_len;
     int echo_fd = -1;
-    char tx_buf[msgsz];
-    char rx_buf[msgsz];
+    char tx_buf[params->msgsize];
+    char rx_buf[params->msgsize];
 
-    if (!opt_silent) {
-        printf("%s: repeat %u: msgsz %u: variable %s\n", __func__, repeat, msgsz,
-               var ? "true" : "false");
+    if (!params->silent) {
+        printf("%s: repeat %u: params->msgsize %u: variable %s\n", __func__, params->repeat,
+               params->msgsize, params->variable ? "true" : "false");
     }
 
-    echo_fd = tipc_connect(dev_name, echo_name);
+    echo_fd = tipc_connect(params->dev_name, echo_name);
     if (echo_fd < 0) {
         fprintf(stderr, "Failed to connect to service\n");
         return echo_fd;
     }
 
-    for (i = 0; i < repeat; i++) {
-        msg_len = msgsz;
-        if (opt_variable && msgsz) {
-            msg_len = rand() % msgsz;
+    for (i = 0; i < params->repeat; i++) {
+        msg_len = params->msgsize;
+        if (params->variable && params->msgsize) {
+            msg_len = rand() % params->msgsize;
         }
 
         memset(tx_buf, i + 1, msg_len);
@@ -406,37 +447,37 @@ static int echo_test(uint repeat, uint msgsz, bool var)
 
     tipc_close(echo_fd);
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s: done\n", __func__);
     }
 
     return 0;
 }
 
-static int burst_write_test(uint repeat, uint msgburst, uint msgsz, bool var)
-{
+static int burst_write_test(const struct tipc_test_params* params) {
     int fd;
     uint i, j;
     ssize_t rc;
     size_t msg_len;
-    char tx_buf[msgsz];
+    char tx_buf[params->msgsize];
 
-    if (!opt_silent) {
-        printf("%s: repeat %u: burst %u: msgsz %u: variable %s\n", __func__, repeat, msgburst,
-               msgsz, var ? "true" : "false");
+    if (!params->silent) {
+        printf("%s: repeat %u: burst %u: params->msgsize %u: variable %s\n", __func__,
+               params->repeat, params->msgburst, params->msgsize,
+               params->variable ? "true" : "false");
     }
 
-    for (i = 0; i < repeat; i++) {
-        fd = tipc_connect(dev_name, datasink_name);
+    for (i = 0; i < params->repeat; i++) {
+        fd = tipc_connect(params->dev_name, datasink_name);
         if (fd < 0) {
             fprintf(stderr, "Failed to connect to '%s' service\n", "datasink");
             break;
         }
 
-        for (j = 0; j < msgburst; j++) {
-            msg_len = msgsz;
-            if (var && msgsz) {
-                msg_len = rand() % msgsz;
+        for (j = 0; j < params->msgburst; j++) {
+            msg_len = params->msgsize;
+            if (params->variable && params->msgsize) {
+                msg_len = rand() % params->msgsize;
             }
 
             memset(tx_buf, i + 1, msg_len);
@@ -450,23 +491,21 @@ static int burst_write_test(uint repeat, uint msgburst, uint msgsz, bool var)
         tipc_close(fd);
     }
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s: done\n", __func__);
     }
 
     return 0;
 }
 
-
-static int _wait_for_msg(int fd, uint msgsz, int timeout)
-{
+static int _wait_for_msg(int fd, int timeout, const struct tipc_test_params* params) {
     int rc;
     fd_set rfds;
     uint msgcnt = 0;
-    char rx_buf[msgsz];
+    char rx_buf[params->msgsize];
     struct timeval tv;
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("waiting (%d) for msg\n", timeout);
     }
 
@@ -480,7 +519,7 @@ static int _wait_for_msg(int fd, uint msgsz, int timeout)
         rc = select(fd + 1, &rfds, NULL, NULL, &tv);
 
         if (rc == 0) {
-            if (!opt_silent) {
+            if (!params->silent) {
                 printf("select timedout\n");
             }
             break;
@@ -502,42 +541,40 @@ static int _wait_for_msg(int fd, uint msgsz, int timeout)
         }
     }
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("got %u messages\n", msgcnt);
     }
 
     return 0;
 }
 
-
-static int select_test(uint repeat, uint msgburst, uint msgsz)
-{
+static int select_test(const struct tipc_test_params* params) {
     int fd;
     uint i, j;
     ssize_t rc;
-    char tx_buf[msgsz];
+    char tx_buf[params->msgsize];
 
-    if (!opt_silent) {
-        printf("%s: repeat %u\n", __func__, repeat);
+    if (!params->silent) {
+        printf("%s: repeat %u\n", __func__, params->repeat);
     }
 
-    fd = tipc_connect(dev_name, echo_name);
+    fd = tipc_connect(params->dev_name, echo_name);
     if (fd < 0) {
         fprintf(stderr, "Failed to connect to '%s' service\n", "echo");
         return fd;
     }
 
-    for (i = 0; i < repeat; i++) {
-        _wait_for_msg(fd, msgsz, 1);
+    for (i = 0; i < params->repeat; i++) {
+        _wait_for_msg(fd, 1, params);
 
-        if (!opt_silent) {
-            printf("sending burst: %u msg\n", msgburst);
+        if (!params->silent) {
+            printf("sending burst: %u msg\n", params->msgburst);
         }
 
-        for (j = 0; j < msgburst; j++) {
-            memset(tx_buf, i + j, msgsz);
-            rc = write(fd, tx_buf, msgsz);
-            if ((size_t)rc != msgsz) {
+        for (j = 0; j < params->msgburst; j++) {
+            memset(tx_buf, i + j, params->msgsize);
+            rc = write(fd, tx_buf, params->msgsize);
+            if ((size_t)rc != params->msgsize) {
                 perror("burst_test: write");
                 break;
             }
@@ -546,37 +583,36 @@ static int select_test(uint repeat, uint msgburst, uint msgsz)
 
     tipc_close(fd);
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s: done\n", __func__);
     }
 
     return 0;
 }
 
-static int blocked_read_test(uint repeat)
-{
+static int blocked_read_test(const struct tipc_test_params* params) {
     int fd;
     uint i;
     ssize_t rc;
     char rx_buf[512];
 
-    if (!opt_silent) {
-        printf("%s: repeat %u\n", __func__, repeat);
+    if (!params->silent) {
+        printf("%s: repeat %u\n", __func__, params->repeat);
     }
 
-    fd = tipc_connect(dev_name, echo_name);
+    fd = tipc_connect(params->dev_name, echo_name);
     if (fd < 0) {
         fprintf(stderr, "Failed to connect to '%s' service\n", "echo");
         return fd;
     }
 
-    for (i = 0; i < repeat; i++) {
+    for (i = 0; i < params->repeat; i++) {
         rc = read(fd, rx_buf, sizeof(rx_buf));
         if (rc < 0) {
             perror("select_test: read");
             break;
         } else {
-            if (!opt_silent) {
+            if (!params->silent) {
                 printf("got %zd bytes\n", rc);
             }
         }
@@ -584,15 +620,14 @@ static int blocked_read_test(uint repeat)
 
     tipc_close(fd);
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s: done\n", __func__);
     }
 
     return 0;
 }
 
-static int ta2ta_ipc_test(void)
-{
+static int ta2ta_ipc_test(const struct tipc_test_params* params) {
     enum test_message_header {
         TEST_PASSED = 0,
         TEST_FAILED = 1,
@@ -604,11 +639,11 @@ static int ta2ta_ipc_test(void)
     int ret;
     unsigned char rx_buf[256];
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s:\n", __func__);
     }
 
-    fd = tipc_connect(dev_name, main_ctrl_name);
+    fd = tipc_connect(params->dev_name, main_ctrl_name);
     if (fd < 0) {
         fprintf(stderr, "Failed to connect to '%s' service\n", "main_ctrl");
         return fd;
@@ -658,13 +693,12 @@ static void print_uuid(const char *dev, uuid_t *uuid)
            uuid->clock_seq_and_node[7]);
 }
 
-static int dev_uuid_test(void)
-{
+static int dev_uuid_test(const struct tipc_test_params* params) {
     int fd;
     ssize_t rc;
     uuid_t uuid;
 
-    fd = tipc_connect(dev_name, uuid_name);
+    fd = tipc_connect(params->dev_name, uuid_name);
     if (fd < 0) {
         fprintf(stderr, "Failed to connect to '%s' service\n", "uuid");
         return fd;
@@ -677,7 +711,7 @@ static int dev_uuid_test(void)
     } else if (rc != sizeof(uuid)) {
         fprintf(stderr, "unexpected uuid size (%d vs. %d)\n", (int)rc, (int)sizeof(uuid));
     } else {
-        print_uuid(dev_name, &uuid);
+        print_uuid(params->dev_name, &uuid);
     }
 
     tipc_close(fd);
@@ -685,61 +719,58 @@ static int dev_uuid_test(void)
     return 0;
 }
 
-static int ta_access_test(void)
-{
+static int ta_access_test(const struct tipc_test_params* params) {
     int fd;
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s:\n", __func__);
     }
 
-    fd = tipc_connect(dev_name, ta_only_name);
+    fd = tipc_connect(params->dev_name, ta_only_name);
     if (fd >= 0) {
         fprintf(stderr, "Succeed to connect to '%s' service\n", "ta_only");
         tipc_close(fd);
     }
 
-    fd = tipc_connect(dev_name, ns_only_name);
+    fd = tipc_connect(params->dev_name, ns_only_name);
     if (fd < 0) {
         fprintf(stderr, "Failed to connect to '%s' service\n", "ns_only");
         return fd;
     }
     tipc_close(fd);
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s: done\n", __func__);
     }
 
     return 0;
 }
 
-
-static int writev_test(uint repeat, uint msgsz, bool var)
-{
+static int writev_test(const struct tipc_test_params* params) {
     uint i;
     ssize_t rc;
     size_t msg_len;
     int echo_fd = -1;
-    char tx0_buf[msgsz];
-    char tx1_buf[msgsz];
-    char rx_buf[msgsz];
+    char tx0_buf[params->msgsize];
+    char tx1_buf[params->msgsize];
+    char rx_buf[params->msgsize];
     struct iovec iovs[2] = {{tx0_buf, 0}, {tx1_buf, 0}};
 
-    if (!opt_silent) {
-        printf("%s: repeat %u: msgsz %u: variable %s\n", __func__, repeat, msgsz,
-               var ? "true" : "false");
+    if (!params->silent) {
+        printf("%s: repeat %u: params->msgsize %u: variable %s\n", __func__, params->repeat,
+               params->msgsize, params->variable ? "true" : "false");
     }
 
-    echo_fd = tipc_connect(dev_name, echo_name);
+    echo_fd = tipc_connect(params->dev_name, echo_name);
     if (echo_fd < 0) {
         fprintf(stderr, "Failed to connect to service\n");
         return echo_fd;
     }
 
-    for (i = 0; i < repeat; i++) {
-        msg_len = msgsz;
-        if (opt_variable && msgsz) {
-            msg_len = rand() % msgsz;
+    for (i = 0; i < params->repeat; i++) {
+        msg_len = params->msgsize;
+        if (params->variable && params->msgsize) {
+            msg_len = rand() % params->msgsize;
         }
 
         iovs[0].iov_len = msg_len / 3;
@@ -786,39 +817,38 @@ static int writev_test(uint repeat, uint msgsz, bool var)
 
     tipc_close(echo_fd);
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s: done\n", __func__);
     }
 
     return 0;
 }
 
-static int readv_test(uint repeat, uint msgsz, bool var)
-{
+static int readv_test(const struct tipc_test_params* params) {
     uint i;
     ssize_t rc;
     size_t msg_len;
     int echo_fd = -1;
-    char tx_buf[msgsz];
-    char rx0_buf[msgsz];
-    char rx1_buf[msgsz];
+    char tx_buf[params->msgsize];
+    char rx0_buf[params->msgsize];
+    char rx1_buf[params->msgsize];
     struct iovec iovs[2] = {{rx0_buf, 0}, {rx1_buf, 0}};
 
-    if (!opt_silent) {
-        printf("%s: repeat %u: msgsz %u: variable %s\n", __func__, repeat, msgsz,
-               var ? "true" : "false");
+    if (!params->silent) {
+        printf("%s: repeat %u: params->msgsize %u: variable %s\n", __func__, params->repeat,
+               params->msgsize, params->variable ? "true" : "false");
     }
 
-    echo_fd = tipc_connect(dev_name, echo_name);
+    echo_fd = tipc_connect(params->dev_name, echo_name);
     if (echo_fd < 0) {
         fprintf(stderr, "Failed to connect to service\n");
         return echo_fd;
     }
 
-    for (i = 0; i < repeat; i++) {
-        msg_len = msgsz;
-        if (opt_variable && msgsz) {
-            msg_len = rand() % msgsz;
+    for (i = 0; i < params->repeat; i++) {
+        msg_len = params->msgsize;
+        if (params->variable && params->msgsize) {
+            msg_len = rand() % params->msgsize;
         }
 
         iovs[0].iov_len = msg_len / 3;
@@ -865,14 +895,14 @@ static int readv_test(uint repeat, uint msgsz, bool var)
 
     tipc_close(echo_fd);
 
-    if (!opt_silent) {
+    if (!params->silent) {
         printf("%s: done\n", __func__);
     }
 
     return 0;
 }
 
-static int send_fd_test(void) {
+static int send_fd_test(const struct tipc_test_params* params) {
     int ret;
     int dma_buf = -1;
     int fd = -1;
@@ -881,7 +911,7 @@ static int send_fd_test(void) {
 
     const size_t num_chunks = 10;
 
-    fd = tipc_connect(dev_name, receiver_name);
+    fd = tipc_connect(params->dev_name, receiver_name);
     if (fd < 0) {
         fprintf(stderr, "Failed to connect to test support TA - is it missing?\n");
         ret = -1;
@@ -948,6 +978,73 @@ static int send_fd_test(void) {
     return ret;
 }
 
+uint64_t get_time_us(void) {
+    struct timespec spec;
+
+    clock_gettime(CLOCK_MONOTONIC, &spec);
+    return spec.tv_sec * 1000000 + spec.tv_nsec / 1000;
+}
+
+static const struct tipc_test_def tipc_tests[] = {
+        {"connect", connect_test},
+        {"connect_foo", connect_foo},
+        {"burst_write", burst_write_test},
+        {"select", select_test},
+        {"blocked_read", blocked_read_test},
+        {"closer1", closer1_test},
+        {"closer2", closer2_test},
+        {"closer3", closer3_test},
+        {"echo", echo_test},
+        {"ta2ta-ipc", ta2ta_ipc_test},
+        {"dev-uuid", dev_uuid_test},
+        {"ta-access", ta_access_test},
+        {"writev", writev_test},
+        {"readv", readv_test},
+        {"send-fd", send_fd_test},
+};
+
+tipc_test_func_t get_test_function(const struct tipc_test_params* params) {
+    for (size_t i = 0; i < sizeof(tipc_tests) / sizeof(tipc_tests[0]); i++) {
+        if (strcmp(params->test_name, tipc_tests[i].test_name) == 0) {
+            return tipc_tests[i].func;
+        }
+    }
+    fprintf(stderr, "Unrecognized test name '%s'\n", params->test_name);
+    exit(1);
+}
+
+static int run_as_bench(const struct tipc_test_params* params) {
+    int rc = 0;
+    int64_t min = INT64_MAX;
+    int64_t max = 0;
+    int64_t avg = 0;
+    int64_t cold = 0;
+
+    uint64_t start;
+    uint64_t end;
+
+    tipc_test_func_t test = get_test_function(params);
+
+    for (size_t i = 0; (i < params->bench + 1) && rc == 0; ++i) {
+        start = get_time_us();
+        rc |= test(params);
+        end = get_time_us();
+        int64_t t = end - start;
+
+        if (i == 0) {
+            cold = t;
+        } else {
+            min = (t < min) ? t : min;
+            max = (t > max) ? t : max;
+            avg += t;
+        }
+    }
+    avg /= params->bench;
+
+    fprintf(stderr, BENCH_RESULT_TPL, params->test_name, min, max, avg, cold, min, max, avg, cold);
+    return rc;
+}
+
 int main(int argc, char **argv)
 {
     int rc = 0;
@@ -955,52 +1052,25 @@ int main(int argc, char **argv)
     if (argc <= 1) {
         print_usage_and_exit(argv[0], EXIT_FAILURE, false);
     }
+    struct tipc_test_params params;
+    init_params(&params);
+    parse_options(argc, argv, &params);
 
-    parse_options(argc, argv);
-
-    if (!dev_name) {
-        dev_name = TIPC_DEFAULT_DEVNAME;
+    if (!params.dev_name) {
+        params.dev_name = TIPC_DEFAULT_DEVNAME;
     }
 
-    if (!test_name) {
+    if (!params.test_name) {
         fprintf(stderr, "need a Test to run\n");
         print_usage_and_exit(argv[0], EXIT_FAILURE, true);
     }
 
-    if (strcmp(test_name, "connect") == 0) {
-        rc = connect_test(opt_repeat);
-    } else if (strcmp(test_name, "connect_foo") == 0) {
-        rc = connect_foo(opt_repeat);
-    } else if (strcmp(test_name, "burst_write") == 0) {
-        rc = burst_write_test(opt_repeat, opt_msgburst, opt_msgsize, opt_variable);
-    } else if (strcmp(test_name, "select") == 0) {
-        rc = select_test(opt_repeat, opt_msgburst, opt_msgsize);
-    } else if (strcmp(test_name, "blocked_read") == 0) {
-        rc = blocked_read_test(opt_repeat);
-    } else if (strcmp(test_name, "closer1") == 0) {
-        rc = closer1_test(opt_repeat);
-    } else if (strcmp(test_name, "closer2") == 0) {
-        rc = closer2_test(opt_repeat);
-    } else if (strcmp(test_name, "closer3") == 0) {
-        rc = closer3_test(opt_repeat);
-    } else if (strcmp(test_name, "echo") == 0) {
-        rc = echo_test(opt_repeat, opt_msgsize, opt_variable);
-    } else if (strcmp(test_name, "ta2ta-ipc") == 0) {
-        rc = ta2ta_ipc_test();
-    } else if (strcmp(test_name, "dev-uuid") == 0) {
-        rc = dev_uuid_test();
-    } else if (strcmp(test_name, "ta-access") == 0) {
-        rc = ta_access_test();
-    } else if (strcmp(test_name, "writev") == 0) {
-        rc = writev_test(opt_repeat, opt_msgsize, opt_variable);
-    } else if (strcmp(test_name, "readv") == 0) {
-        rc = readv_test(opt_repeat, opt_msgsize, opt_variable);
-    } else if (strcmp(test_name, "send-fd") == 0) {
-        rc = send_fd_test();
+    if (params.bench > 0) {
+        rc = run_as_bench(&params);
+        params.bench = 0;
     } else {
-        fprintf(stderr, "Unrecognized test name '%s'\n", test_name);
-        print_usage_and_exit(argv[0], EXIT_FAILURE, true);
+        tipc_test_func_t test = get_test_function(&params);
+        rc = test(&params);
     }
-
     return rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
 }

From d7f09657617cd26734729bf8bc24b9a7829a544d Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 17 Jan 2024 16:45:13 -0800
Subject: [PATCH 0674/1487] libfiemap: Disable loop mapping code.

On devices without metadata encryption, we use loop devices rather than
device-mapper + dm-linear + FIEMAP. Devices without metadata encryption
should not exist, since libfiemap was introduced with Android R, which
requires metadata encryption.

It is possible to retrofit an Android Q device with Virtual A/B, which
is what Pixel 4 did. However those devices can only upgrade to
Android T, and they had metadata encryption anyway.

If there are any Android Q devices that retrofitted Virtual A/B in R,
didn't have metadata encryption, and need to upgrade all the way to V,
then we can recommend they make WrapUserdataIfNeeded() unconditional.

Bug: N/A
Test: fiemap_image_test, vts_libsnapshot_test
Change-Id: I7be0507527b967166676c8b136b8758f5e69ba6b
---
 fs_mgr/libfiemap/image_manager.cpp | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/fs_mgr/libfiemap/image_manager.cpp b/fs_mgr/libfiemap/image_manager.cpp
index c416f4df44af..a5da6e3429c9 100644
--- a/fs_mgr/libfiemap/image_manager.cpp
+++ b/fs_mgr/libfiemap/image_manager.cpp
@@ -531,11 +531,16 @@ bool ImageManager::MapImageDevice(const std::string& name,
     // If there is no intermediate device-mapper node, then partitions cannot be
     // opened writable due to sepolicy and exclusivity of having a mounted
     // filesystem. This should only happen on devices with no encryption, or
-    // devices with FBE and no metadata encryption. For these cases it suffices
-    // to perform normal file writes to /data/gsi (which is unencrypted).
+    // devices with FBE and no metadata encryption. For these cases we COULD
+    // perform normal writes to /data/gsi (which is unencrypted), but given that
+    // metadata encryption has been mandated since Android R, we don't actually
+    // support or test this.
     //
-    // Note: this is not gated on DeviceInfo, because the recovery-specific path
-    // must only be used in actual recovery.
+    // So, we validate here that /data is backed by device-mapper. This code
+    // isn't needed in recovery since there is no /data.
+    //
+    // If this logic sticks for a release, we can remove MapWithLoopDevice, as
+    // well as WrapUserdataIfNeeded in fs_mgr.
     std::string block_device;
     bool can_use_devicemapper;
     if (!FiemapWriter::GetBlockDeviceForFile(image_header, &block_device, &can_use_devicemapper)) {
@@ -543,20 +548,15 @@ bool ImageManager::MapImageDevice(const std::string& name,
         return false;
     }
 
-    if (can_use_devicemapper) {
-        if (!MapWithDmLinear(*partition_opener_.get(), name, timeout_ms, path)) {
-            return false;
-        }
-    } else if (!MapWithLoopDevice(name, timeout_ms, path)) {
+    if (!can_use_devicemapper) {
+        LOG(ERROR) << "Cannot map image: /data must be mounted on top of device-mapper.";
         return false;
     }
-#else
-    // In recovery, we can *only* use device-mapper, since partitions aren't
-    // mounted. That also means we cannot call GetBlockDeviceForFile.
+#endif
+
     if (!MapWithDmLinear(*partition_opener_.get(), name, timeout_ms, path)) {
         return false;
     }
-#endif
 
     // Set a property so we remember this is mapped.
     auto prop_name = GetStatusPropertyName(name);

From c4db546a218dc3fa88d86fc03d3139549b293908 Mon Sep 17 00:00:00 2001
From: Spandan Das <spandandas@google.com>
Date: Sat, 20 Jan 2024 20:12:03 +0000
Subject: [PATCH 0675/1487] Add libz to static libs of libutils_test

libz is no longer statically linked into libunwindstatck, so needs to be
added explicitly to the static libs of this test

Bug: 281077552
Test: presubmits
Change-Id: Ia04b63cb8dfd5e80536a188a35d036dd3e4fd775
---
 libutils/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libutils/Android.bp b/libutils/Android.bp
index ad5b752e3b1e..e22c909a86de 100644
--- a/libutils/Android.bp
+++ b/libutils/Android.bp
@@ -366,6 +366,7 @@ cc_test {
                 "libunwindstack_no_dex",
                 "libutils",
                 "libutilscallstack",
+                "libz",
             ],
         },
     },

From 236c7060cd5c743bbe844afd25ae78d98de1889b Mon Sep 17 00:00:00 2001
From: Kangping Dong <wgtdkp@google.com>
Date: Mon, 22 Jan 2024 01:10:15 +0800
Subject: [PATCH 0676/1487] [Thread] create dir /dev/socket/ot-daemon

ot-daemon may use multiple unix sockets so create a dir for it.

Bug: 320451788
Test: verified that ot-daemon can create socket
/dev/socket/ot-daemon/thread-wpan.sock

Change-Id: I43ccb11ed664cf0d59fc02e2efc721ed7284e2a0
---
 rootdir/init.rc | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 6b783fa19ff8..768e0ff843f1 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -109,6 +109,9 @@ on init
     symlink /proc/self/fd/1 /dev/stdout
     symlink /proc/self/fd/2 /dev/stderr
 
+    # Create socket dir for ot-daemon
+    mkdir /dev/socket/ot-daemon 0770 thread_network thread_network
+
     # Create energy-aware scheduler tuning nodes
     mkdir /dev/stune/foreground
     mkdir /dev/stune/background

From 794a952642317f7da1be2ea69e6865c55ea37be6 Mon Sep 17 00:00:00 2001
From: Luca Stefani <luca.stefani.ge1@gmail.com>
Date: Mon, 22 Jan 2024 18:45:26 +0100
Subject: [PATCH 0677/1487] Replace lazy_static with once_cell

Using lazy_static is now discouraged as unmaintained
and once_cell is the recommended replacement.

On top of that a similar implementation found in
once_cell is being tracked for inclusion under the
`lazy_cell` feature gate [0]

[0] https://github.com/rust-lang/rust/issues/109736

Test: m
Change-Id: I21d343a38dbd25bb2d13f239f7fa3a2d7f20323e
---
 libstats/pull_rust/Android.bp    | 2 +-
 libstats/pull_rust/stats_pull.rs | 7 +++----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/libstats/pull_rust/Android.bp b/libstats/pull_rust/Android.bp
index 4609e6bc4a81..69020267dffe 100644
--- a/libstats/pull_rust/Android.bp
+++ b/libstats/pull_rust/Android.bp
@@ -60,8 +60,8 @@ rust_library {
     crate_name: "statspull_rust",
     srcs: ["stats_pull.rs"],
     rustlibs: [
-        "liblazy_static",
         "liblog_rust",
+        "libonce_cell",
         "libstatslog_rust_header",
         "libstatspull_bindgen",
     ],
diff --git a/libstats/pull_rust/stats_pull.rs b/libstats/pull_rust/stats_pull.rs
index d188b5fb5838..b2bebcc4edaa 100644
--- a/libstats/pull_rust/stats_pull.rs
+++ b/libstats/pull_rust/stats_pull.rs
@@ -14,7 +14,7 @@
 
 //! A Rust interface for the StatsD pull API.
 
-use lazy_static::lazy_static;
+use once_cell::sync::Lazy;
 use statslog_rust_header::{Atoms, Stat, StatsError};
 use statspull_bindgen::*;
 use std::collections::HashMap;
@@ -107,9 +107,8 @@ impl Default for Metadata {
     }
 }
 
-lazy_static! {
-    static ref COOKIES: Mutex<HashMap<i32, fn() -> StatsPullResult>> = Mutex::new(HashMap::new());
-}
+static COOKIES: Lazy<Mutex<HashMap<i32, fn() -> StatsPullResult>>> =
+    Lazy::new(|| Mutex::new(HashMap::new()));
 
 /// # Safety
 ///

From 7171c676c09b378f94cc5b1485d6213fb176c8f3 Mon Sep 17 00:00:00 2001
From: David Drysdale <drysdale@google.com>
Date: Mon, 22 Jan 2024 15:03:14 +0000
Subject: [PATCH 0678/1487] Secretkeeper HAL: support large messages

The TIPC channel between HAL service and TA has a max message size of
around 4K. Cope with larger messages by using fragmentation and
reassembly for all messages.

Test: VtsSecretkeeperTargetTest
Change-Id: I18cc9a9f6e6b90ab66bc3bcf1972e1a5c5112c89
---
 trusty/secretkeeper/Android.bp      |  5 ++-
 trusty/secretkeeper/src/hal_main.rs | 66 ++++++++++++++++-------------
 2 files changed, 40 insertions(+), 31 deletions(-)

diff --git a/trusty/secretkeeper/Android.bp b/trusty/secretkeeper/Android.bp
index f6b740a176e0..6523edaf6942 100644
--- a/trusty/secretkeeper/Android.bp
+++ b/trusty/secretkeeper/Android.bp
@@ -28,12 +28,13 @@ rust_binary {
     ],
     rustlibs: [
         "libandroid_logger",
-        "libbinder_rs",
         "libauthgraph_hal",
-        "libtrusty-rs",
+        "libauthgraph_wire",
+        "libbinder_rs",
         "liblibc",
         "liblog_rust",
         "libsecretkeeper_hal",
+        "libtrusty-rs",
     ],
     defaults: [
         "secretkeeper_use_latest_hal_aidl_rust",
diff --git a/trusty/secretkeeper/src/hal_main.rs b/trusty/secretkeeper/src/hal_main.rs
index 9439c369b5f1..1dc697dfee54 100644
--- a/trusty/secretkeeper/src/hal_main.rs
+++ b/trusty/secretkeeper/src/hal_main.rs
@@ -14,7 +14,8 @@
 // limitations under the License.
 
 //! This module implements the HAL service for Secretkeeper in Trusty.
-use authgraph_hal::{channel::SerializedChannel};
+use authgraph_hal::channel::SerializedChannel;
+use authgraph_wire::fragmentation::{Fragmenter, Reassembler};
 use secretkeeper_hal::SecretkeeperService;
 use android_hardware_security_secretkeeper::aidl::android::hardware::security::secretkeeper::ISecretkeeper::{
     ISecretkeeper, BpSecretkeeper,
@@ -22,6 +23,7 @@ use android_hardware_security_secretkeeper::aidl::android::hardware::security::s
 use log::{error, info};
 use std::{
     ffi::CString,
+    fmt::Debug,
     panic,
     sync::{Arc, Mutex},
 };
@@ -29,6 +31,7 @@ use trusty::DEFAULT_DEVICE;
 
 const SK_TIPC_SERVICE_PORT: &str = "com.android.trusty.secretkeeper";
 const AG_TIPC_SERVICE_PORT: &str = "com.android.trusty.secretkeeper.authgraph";
+const TIPC_MAX_SIZE: usize = 4000;
 
 static SERVICE_INSTANCE: &str = "default";
 
@@ -47,38 +50,43 @@ impl TipcChannel {
     }
 }
 
+fn binderr<E: Debug>(msg: &str, e: E) -> binder::Status {
+    binder::Status::new_exception(
+        binder::ExceptionCode::TRANSACTION_FAILED,
+        Some(&CString::new(format!("Failed to {msg} via tipc channel: {e:?}",)).unwrap()),
+    )
+}
+
 impl SerializedChannel for TipcChannel {
-    const MAX_SIZE: usize = 4000;
+    // No maximum size for messages passed to `execute()` because it performs fragmentation
+    // and reassembly internally.
+    const MAX_SIZE: usize = usize::MAX;
+
     fn execute(&self, req_data: &[u8]) -> binder::Result<Vec<u8>> {
         // Hold lock across both request and response.
         let mut channel = self.channel.lock().unwrap();
-        channel.send(req_data).map_err(|e| {
-            binder::Status::new_exception(
-                binder::ExceptionCode::TRANSACTION_FAILED,
-                Some(
-                    &CString::new(format!(
-                        "Failed to send the request via tipc channel because of {:?}",
-                        e
-                    ))
-                    .unwrap(),
-                ),
-            )
-        })?;
-        // TODO: cope with fragmentation and reassembly
-        let mut rsp_data = Vec::new();
-        channel.recv(&mut rsp_data).map_err(|e| {
-            binder::Status::new_exception(
-                binder::ExceptionCode::TRANSACTION_FAILED,
-                Some(
-                    &CString::new(format!(
-                        "Failed to receive the response via tipc channel because of {:?}",
-                        e
-                    ))
-                    .unwrap(),
-                ),
-            )
-        })?;
-        Ok(rsp_data)
+        let mut pending_rsp = Reassembler::default();
+
+        // Break request message into fragments to send.
+        for req_frag in Fragmenter::new(req_data, TIPC_MAX_SIZE) {
+            channel.send(&req_frag).map_err(|e| binderr("send request", e))?;
+
+            // Every request gets a response.
+            let mut rsp_frag = Vec::new();
+            channel.recv(&mut rsp_frag).map_err(|e| binderr("receive response", e))?;
+
+            if let Some(full_rsp) = pending_rsp.accumulate(&rsp_frag) {
+                return Ok(full_rsp.to_vec());
+            }
+        }
+        // There may be additional response fragments to receive.
+        loop {
+            let mut rsp_frag = Vec::new();
+            channel.recv(&mut rsp_frag).map_err(|e| binderr("receive response", e))?;
+            if let Some(full_rsp) = pending_rsp.accumulate(&rsp_frag) {
+                return Ok(full_rsp.to_vec());
+            }
+        }
     }
 }
 

From 34a09861af5f2fc81aed1be36ac187926f540718 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Sat, 20 Jan 2024 00:20:17 +0000
Subject: [PATCH 0679/1487] libutils: Looper add 'repoll'

To help cases where kernel drivers do not
implement poll events correctly.

Bug: 316829336
Test: boot

Change-Id: Ibad16a8e8e061a5be8cede7e8680c3095d6e6f32
---
 libutils/Looper.cpp                           |   24 +
 .../arm64/source-based/libutils.so.lsdump     | 3567 ++++++++++++++---
 .../arm_arm64/source-based/libutils.so.lsdump | 3319 ++++++++++++---
 libutils/include/utils/Looper.h               |   12 +
 4 files changed, 5840 insertions(+), 1082 deletions(-)

diff --git a/libutils/Looper.cpp b/libutils/Looper.cpp
index 576c61dc6c93..7700c9030b91 100644
--- a/libutils/Looper.cpp
+++ b/libutils/Looper.cpp
@@ -532,6 +532,30 @@ int Looper::removeFd(int fd) {
     return removeSequenceNumberLocked(it->second);
 }
 
+int Looper::repoll(int fd) {
+    AutoMutex _l(mLock);
+    const auto& it = mSequenceNumberByFd.find(fd);
+    if (it == mSequenceNumberByFd.end()) {
+        return 0;
+    }
+
+    const auto& request_it = mRequests.find(it->second);
+    if (request_it == mRequests.end()) {
+        return 0;
+    }
+    const auto& [seq, request] = *request_it;
+
+    LOG_ALWAYS_FATAL_IF(
+            fd != request.fd,
+            "Looper has inconsistent data structure. When looking up FD %d found FD %d.", fd,
+            request_it->second.fd);
+
+    epoll_event eventItem = createEpollEvent(request.getEpollEvents(), seq);
+    if (epoll_ctl(mEpollFd.get(), EPOLL_CTL_MOD, fd, &eventItem) == -1) return 0;
+
+    return 1;  // success
+}
+
 int Looper::removeSequenceNumberLocked(SequenceNumber seq) {
 #if DEBUG_CALLBACKS
     ALOGD("%p ~ removeFd - seq=%" PRIu64, this, seq);
diff --git a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
index 8881b44eb181..82ddca8f5d87 100644
--- a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
@@ -16,7 +16,7 @@
    "referenced_type" : "_ZTIDs",
    "self_type" : "_ZTIA1_Ds",
    "size" : 2,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 1,
@@ -46,6 +46,7 @@
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
   {
+   "is_of_unknown_bound" : true,
    "linker_set_key" : "_ZTIA_f",
    "name" : "float[]",
    "referenced_type" : "_ZTIf",
@@ -490,6 +491,18 @@
   {
    "name" : "_ZN7android27add_sysprop_change_callbackEPFvvEi"
   },
+  {
+   "binding" : "weak",
+   "name" : "_ZN7android2spINS_14LooperCallbackEE5clearEv"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZN7android2spINS_6LooperEEaSEOS2_"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZN7android2spINS_6ThreadEE5clearEv"
+  },
   {
    "name" : "_ZN7android30get_report_sysprop_change_funcEv"
   },
@@ -544,6 +557,9 @@
   {
    "name" : "_ZN7android6Looper6awokenEv"
   },
+  {
+   "name" : "_ZN7android6Looper6repollEi"
+  },
   {
    "name" : "_ZN7android6Looper7pollAllEiPiS1_PPv"
   },
@@ -1214,6 +1230,14 @@
    "binding" : "weak",
    "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeImN7android6Looper7RequestEEENS_22__unordered_map_hasherImS5_NS_4hashImEELb1EEENS_21__unordered_map_equalImS5_NS_8equal_toImEELb1EEENS_9allocatorIS5_EEE25__emplace_unique_key_argsImJRKmRS4_EEENS_4pairINS_15__hash_iteratorIPNS_11__hash_nodeIS5_PvEEEEbEERKT_DpOT0_"
   },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeImN7android6Looper7RequestEEENS_22__unordered_map_hasherImS5_NS_4hashImEELb1EEENS_21__unordered_map_equalImS5_NS_8equal_toImEELb1EEENS_9allocatorIS5_EEE4findImEENS_15__hash_iteratorIPNS_11__hash_nodeIS5_PvEEEERKT_"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeImN7android6Looper7RequestEEENS_22__unordered_map_hasherImS5_NS_4hashImEELb1EEENS_21__unordered_map_equalImS5_NS_8equal_toImEELb1EEENS_9allocatorIS5_EEE5eraseENS_21__hash_const_iteratorIPNS_11__hash_nodeIS5_PvEEEE"
+  },
   {
    "binding" : "weak",
    "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeImN7android6Looper7RequestEEENS_22__unordered_map_hasherImS5_NS_4hashImEELb1EEENS_21__unordered_map_equalImS5_NS_8equal_toImEELb1EEENS_9allocatorIS5_EEE6rehashEm"
@@ -1411,6 +1435,10 @@
   },
   {
    "name" : "_ZTVN7android9FdPrinterE"
+  },
+  {
+   "binding" : "weak",
+   "name" : "__llvm_fs_discriminator__"
   }
  ],
  "enum_types" :
@@ -2246,6 +2274,23 @@
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.1.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 13,
+     "name" : "HAL_COLOR_MODE_DISPLAY_BT2020"
+    }
+   ],
+   "linker_set_key" : "_ZTI25android_color_mode_v1_2_t",
+   "name" : "android_color_mode_v1_2_t",
+   "referenced_type" : "_ZTI25android_color_mode_v1_2_t",
+   "self_type" : "_ZTI25android_color_mode_v1_2_t",
+   "size" : 4,
+   "source_file" : "system/core/libsystem/include/system/graphics-base-v1.2.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -2485,6 +2530,31 @@
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::VectorImpl::HAS_TRIVIAL_CTOR"
+    },
+    {
+     "enum_field_value" : 2,
+     "name" : "android::VectorImpl::HAS_TRIVIAL_DTOR"
+    },
+    {
+     "enum_field_value" : 4,
+     "name" : "android::VectorImpl::HAS_TRIVIAL_COPY"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE",
+   "name" : "android::VectorImpl::(unnamed)",
+   "referenced_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -2629,6 +2699,99 @@
    "source_file" : "system/core/libutils/include/utils/Errors.h",
    "underlying_type" : "_ZTIi"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 0,
+     "name" : "android::OK"
+    },
+    {
+     "enum_field_value" : 0,
+     "name" : "android::NO_ERROR"
+    },
+    {
+     "enum_field_value" : -2147483648,
+     "name" : "android::UNKNOWN_ERROR"
+    },
+    {
+     "enum_field_value" : -12,
+     "name" : "android::NO_MEMORY"
+    },
+    {
+     "enum_field_value" : -38,
+     "name" : "android::INVALID_OPERATION"
+    },
+    {
+     "enum_field_value" : -22,
+     "name" : "android::BAD_VALUE"
+    },
+    {
+     "enum_field_value" : -2147483647,
+     "name" : "android::BAD_TYPE"
+    },
+    {
+     "enum_field_value" : -2,
+     "name" : "android::NAME_NOT_FOUND"
+    },
+    {
+     "enum_field_value" : -1,
+     "name" : "android::PERMISSION_DENIED"
+    },
+    {
+     "enum_field_value" : -19,
+     "name" : "android::NO_INIT"
+    },
+    {
+     "enum_field_value" : -17,
+     "name" : "android::ALREADY_EXISTS"
+    },
+    {
+     "enum_field_value" : -32,
+     "name" : "android::DEAD_OBJECT"
+    },
+    {
+     "enum_field_value" : -2147483646,
+     "name" : "android::FAILED_TRANSACTION"
+    },
+    {
+     "enum_field_value" : -75,
+     "name" : "android::BAD_INDEX"
+    },
+    {
+     "enum_field_value" : -61,
+     "name" : "android::NOT_ENOUGH_DATA"
+    },
+    {
+     "enum_field_value" : -11,
+     "name" : "android::WOULD_BLOCK"
+    },
+    {
+     "enum_field_value" : -110,
+     "name" : "android::TIMED_OUT"
+    },
+    {
+     "enum_field_value" : -74,
+     "name" : "android::UNKNOWN_TRANSACTION"
+    },
+    {
+     "enum_field_value" : -2147483641,
+     "name" : "android::FDS_NOT_ALLOWED"
+    },
+    {
+     "enum_field_value" : -2147483640,
+     "name" : "android::UNEXPECTED_NULL"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android15$ALREADY_EXISTSE",
+   "name" : "android::(unnamed)",
+   "referenced_type" : "_ZTIN7android15$ALREADY_EXISTSE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/Errors.sdump",
+   "self_type" : "_ZTIN7android15$ALREADY_EXISTSE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/Errors.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/Errors.h",
+   "underlying_type" : "_ZTIi"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -2758,6 +2921,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<bool>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIbE6$valueE",
+   "name" : "android::trait_trivial_copy<bool>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -2775,6 +2955,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<char>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcE6$valueE",
+   "name" : "android::trait_trivial_copy<char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -2798,15 +2995,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<float>::value"
+     "name" : "android::trait_trivial_copy<double>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
-   "name" : "android::trait_trivial_copy<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
+   "name" : "android::trait_trivial_copy<double>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -2815,13 +3012,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<unsigned char>::value"
+     "name" : "android::trait_trivial_copy<float>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
-   "name" : "android::trait_trivial_copy<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
+   "name" : "android::trait_trivial_copy<float>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2832,15 +3029,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<int>::value"
+     "name" : "android::trait_trivial_copy<float>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
-   "name" : "android::trait_trivial_copy<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
+   "name" : "android::trait_trivial_copy<float>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -2849,13 +3046,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<unsigned int>::value"
+     "name" : "android::trait_trivial_copy<unsigned char>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
-   "name" : "android::trait_trivial_copy<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2866,15 +3063,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<long>::value"
+     "name" : "android::trait_trivial_copy<unsigned char>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
-   "name" : "android::trait_trivial_copy<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -2883,13 +3080,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<unsigned long>::value"
+     "name" : "android::trait_trivial_copy<int>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
-   "name" : "android::trait_trivial_copy<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
+   "name" : "android::trait_trivial_copy<int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2900,15 +3097,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<short>::value"
+     "name" : "android::trait_trivial_copy<int>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
-   "name" : "android::trait_trivial_copy<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
+   "name" : "android::trait_trivial_copy<int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -2917,13 +3114,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<unsigned short>::value"
+     "name" : "android::trait_trivial_copy<unsigned int>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
-   "name" : "android::trait_trivial_copy<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2934,15 +3131,185 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<void>::value"
+     "name" : "android::trait_trivial_copy<unsigned int>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
-   "name" : "android::trait_trivial_copy<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
+   "name" : "android::trait_trivial_copy<long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
+   "name" : "android::trait_trivial_copy<long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<unsigned long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<unsigned long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
+   "name" : "android::trait_trivial_copy<short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
+   "name" : "android::trait_trivial_copy<short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<unsigned short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<unsigned short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<void>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
+   "name" : "android::trait_trivial_copy<void>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<void>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
+   "name" : "android::trait_trivial_copy<void>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -2962,6 +3329,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxE6$valueE",
+   "name" : "android::trait_trivial_copy<long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -2979,6 +3363,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<unsigned long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3039,10 +3440,486 @@
      "name" : "android::trait_trivial_ctor<bool>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
-   "name" : "android::trait_trivial_ctor<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
+   "name" : "android::trait_trivial_ctor<bool>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<bool>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
+   "name" : "android::trait_trivial_ctor<bool>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<char>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
+   "name" : "android::trait_trivial_ctor<char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<char>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
+   "name" : "android::trait_trivial_ctor<char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<double>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
+   "name" : "android::trait_trivial_ctor<double>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<double>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
+   "name" : "android::trait_trivial_ctor<double>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<float>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
+   "name" : "android::trait_trivial_ctor<float>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<float>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
+   "name" : "android::trait_trivial_ctor<float>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned char>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned char>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
+   "name" : "android::trait_trivial_ctor<int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
+   "name" : "android::trait_trivial_ctor<int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
+   "name" : "android::trait_trivial_ctor<long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
+   "name" : "android::trait_trivial_ctor<long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
+   "name" : "android::trait_trivial_ctor<short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
+   "name" : "android::trait_trivial_ctor<short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<void>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
+   "name" : "android::trait_trivial_ctor<void>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<void>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
+   "name" : "android::trait_trivial_ctor<void>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
+   "name" : "android::trait_trivial_ctor<long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
+   "name" : "android::trait_trivial_ctor<long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 0,
+     "name" : "android::trait_trivial_dtor<android::sysprop_change_callback_info>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEE6$valueE",
+   "name" : "android::trait_trivial_dtor<android::sysprop_change_callback_info>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3052,14 +3929,14 @@
    "enum_fields" :
    [
     {
-     "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<char>::value"
+     "enum_field_value" : 0,
+     "name" : "android::trait_trivial_dtor<android::Looper::MessageEnvelope>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
-   "name" : "android::trait_trivial_ctor<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEE6$valueE",
+   "name" : "android::trait_trivial_dtor<android::Looper::MessageEnvelope>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3069,14 +3946,14 @@
    "enum_fields" :
    [
     {
-     "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<double>::value"
+     "enum_field_value" : 0,
+     "name" : "android::trait_trivial_dtor<android::Looper::Response>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
-   "name" : "android::trait_trivial_ctor<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEE6$valueE",
+   "name" : "android::trait_trivial_dtor<android::Looper::Response>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3087,13 +3964,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<float>::value"
+     "name" : "android::trait_trivial_dtor<bool>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
-   "name" : "android::trait_trivial_ctor<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
+   "name" : "android::trait_trivial_dtor<bool>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3104,15 +3981,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<unsigned char>::value"
+     "name" : "android::trait_trivial_dtor<bool>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
-   "name" : "android::trait_trivial_ctor<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
+   "name" : "android::trait_trivial_dtor<bool>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3121,13 +3998,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<int>::value"
+     "name" : "android::trait_trivial_dtor<char>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
-   "name" : "android::trait_trivial_ctor<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
+   "name" : "android::trait_trivial_dtor<char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3138,15 +4015,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<unsigned int>::value"
+     "name" : "android::trait_trivial_dtor<char>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
-   "name" : "android::trait_trivial_ctor<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
+   "name" : "android::trait_trivial_dtor<char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3155,13 +4032,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<long>::value"
+     "name" : "android::trait_trivial_dtor<double>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
-   "name" : "android::trait_trivial_ctor<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
+   "name" : "android::trait_trivial_dtor<double>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3172,15 +4049,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<unsigned long>::value"
+     "name" : "android::trait_trivial_dtor<double>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
-   "name" : "android::trait_trivial_ctor<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
+   "name" : "android::trait_trivial_dtor<double>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3189,13 +4066,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<short>::value"
+     "name" : "android::trait_trivial_dtor<float>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
-   "name" : "android::trait_trivial_ctor<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
+   "name" : "android::trait_trivial_dtor<float>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3206,15 +4083,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<unsigned short>::value"
+     "name" : "android::trait_trivial_dtor<float>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
-   "name" : "android::trait_trivial_ctor<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
+   "name" : "android::trait_trivial_dtor<float>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3223,13 +4100,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<void>::value"
+     "name" : "android::trait_trivial_dtor<unsigned char>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
-   "name" : "android::trait_trivial_ctor<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3240,15 +4117,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<long long>::value"
+     "name" : "android::trait_trivial_dtor<unsigned char>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
-   "name" : "android::trait_trivial_ctor<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3257,13 +4134,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<unsigned long long>::value"
+     "name" : "android::trait_trivial_dtor<int>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
-   "name" : "android::trait_trivial_ctor<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
+   "name" : "android::trait_trivial_dtor<int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3273,16 +4150,16 @@
    "enum_fields" :
    [
     {
-     "enum_field_value" : 0,
-     "name" : "android::trait_trivial_dtor<android::sysprop_change_callback_info>::value"
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<int>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEE6$valueE",
-   "name" : "android::trait_trivial_dtor<android::sysprop_change_callback_info>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
+   "name" : "android::trait_trivial_dtor<int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3290,14 +4167,14 @@
    "enum_fields" :
    [
     {
-     "enum_field_value" : 0,
-     "name" : "android::trait_trivial_dtor<android::Looper::MessageEnvelope>::value"
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<unsigned int>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEE6$valueE",
-   "name" : "android::trait_trivial_dtor<android::Looper::MessageEnvelope>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3307,16 +4184,16 @@
    "enum_fields" :
    [
     {
-     "enum_field_value" : 0,
-     "name" : "android::trait_trivial_dtor<android::Looper::Response>::value"
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<unsigned int>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEE6$valueE",
-   "name" : "android::trait_trivial_dtor<android::Looper::Response>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3325,13 +4202,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_dtor<bool>::value"
+     "name" : "android::trait_trivial_dtor<long>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
-   "name" : "android::trait_trivial_dtor<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
+   "name" : "android::trait_trivial_dtor<long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3342,15 +4219,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_dtor<char>::value"
+     "name" : "android::trait_trivial_dtor<long>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
-   "name" : "android::trait_trivial_dtor<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
+   "name" : "android::trait_trivial_dtor<long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3359,13 +4236,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_dtor<double>::value"
+     "name" : "android::trait_trivial_dtor<unsigned long>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
-   "name" : "android::trait_trivial_dtor<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3376,15 +4253,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_dtor<float>::value"
+     "name" : "android::trait_trivial_dtor<unsigned long>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
-   "name" : "android::trait_trivial_dtor<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3393,13 +4270,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_dtor<unsigned char>::value"
+     "name" : "android::trait_trivial_dtor<short>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
-   "name" : "android::trait_trivial_dtor<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
+   "name" : "android::trait_trivial_dtor<short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3410,15 +4287,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_dtor<int>::value"
+     "name" : "android::trait_trivial_dtor<short>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
-   "name" : "android::trait_trivial_dtor<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
+   "name" : "android::trait_trivial_dtor<short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3427,13 +4304,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_dtor<unsigned int>::value"
+     "name" : "android::trait_trivial_dtor<unsigned short>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
-   "name" : "android::trait_trivial_dtor<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3444,15 +4321,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_dtor<long>::value"
+     "name" : "android::trait_trivial_dtor<unsigned short>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
-   "name" : "android::trait_trivial_dtor<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3461,13 +4338,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_dtor<unsigned long>::value"
+     "name" : "android::trait_trivial_dtor<void>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
-   "name" : "android::trait_trivial_dtor<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
+   "name" : "android::trait_trivial_dtor<void>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3478,15 +4355,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_dtor<short>::value"
+     "name" : "android::trait_trivial_dtor<void>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
-   "name" : "android::trait_trivial_dtor<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
+   "name" : "android::trait_trivial_dtor<void>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3495,13 +4372,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_dtor<unsigned short>::value"
+     "name" : "android::trait_trivial_dtor<long long>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
-   "name" : "android::trait_trivial_dtor<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
+   "name" : "android::trait_trivial_dtor<long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3512,15 +4389,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_dtor<void>::value"
+     "name" : "android::trait_trivial_dtor<long long>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
-   "name" : "android::trait_trivial_dtor<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
+   "name" : "android::trait_trivial_dtor<long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3529,13 +4406,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_dtor<long long>::value"
+     "name" : "android::trait_trivial_dtor<unsigned long long>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
-   "name" : "android::trait_trivial_dtor<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3551,10 +4428,10 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3625,6 +4502,23 @@
    "source_file" : "system/core/libutils/include/utils/String8.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<android::String8>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE",
+   "name" : "android::trait_trivial_move<android::String8>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3639,7 +4533,7 @@
    "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EE6$valueE",
    "self_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EE6$valueE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String16.h",
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3659,6 +4553,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<bool>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIbE6$valueE",
+   "name" : "android::trait_trivial_move<bool>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3676,6 +4587,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<char>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcE6$valueE",
+   "name" : "android::trait_trivial_move<char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3693,6 +4621,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<double>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdE6$valueE",
+   "name" : "android::trait_trivial_move<double>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3710,6 +4655,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<float>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfE6$valueE",
+   "name" : "android::trait_trivial_move<float>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3727,6 +4689,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<unsigned char>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhE6$valueE",
+   "name" : "android::trait_trivial_move<unsigned char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3744,6 +4723,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiE6$valueE",
+   "name" : "android::trait_trivial_move<int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3761,6 +4757,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<unsigned int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjE6$valueE",
+   "name" : "android::trait_trivial_move<unsigned int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3778,6 +4791,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlE6$valueE",
+   "name" : "android::trait_trivial_move<long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3795,6 +4825,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<unsigned long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveImE6$valueE",
+   "name" : "android::trait_trivial_move<unsigned long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3812,6 +4859,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsE6$valueE",
+   "name" : "android::trait_trivial_move<short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3829,6 +4893,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<unsigned short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveItE6$valueE",
+   "name" : "android::trait_trivial_move<unsigned short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3846,6 +4927,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<void>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvE6$valueE",
+   "name" : "android::trait_trivial_move<void>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3863,6 +4961,40 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxE6$valueE",
+   "name" : "android::trait_trivial_move<long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<unsigned long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
+   "name" : "android::trait_trivial_move<unsigned long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3874,10 +5006,10 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
    "name" : "android::trait_trivial_move<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -4151,6 +5283,24 @@
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "access" : "protected",
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::RefBase::FIRST_INC_STRONG"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
+   "name" : "android::RefBase::(unnamed)",
+   "referenced_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "access" : "protected",
    "alignment" : 4,
@@ -4177,6 +5327,32 @@
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "access" : "protected",
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 0,
+     "name" : "android::RefBase::OBJECT_LIFETIME_STRONG"
+    },
+    {
+     "enum_field_value" : 1,
+     "name" : "android::RefBase::OBJECT_LIFETIME_WEAK"
+    },
+    {
+     "enum_field_value" : 1,
+     "name" : "android::RefBase::OBJECT_LIFETIME_MASK"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE",
+   "name" : "android::RefBase::(unnamed)",
+   "referenced_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -4286,7 +5462,7 @@
    "referenced_type" : "_ZTIFiPKvS0_E",
    "return_type" : "_ZTIi",
    "self_type" : "_ZTIFiPKvS0_E",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -4307,7 +5483,7 @@
    "referenced_type" : "_ZTIFiPKvS0_PvE",
    "return_type" : "_ZTIi",
    "self_type" : "_ZTIFiPKvS0_PvE",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -4463,7 +5639,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::setCapacity",
@@ -4479,7 +5655,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::appendVector",
@@ -4495,7 +5671,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::editArrayImpl",
@@ -4508,7 +5684,7 @@
     }
    ],
    "return_type" : "_ZTIPv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::finish_vector",
@@ -4521,7 +5697,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::insertArrayAt",
@@ -4543,7 +5719,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::removeItemsAt",
@@ -4563,7 +5739,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::insertVectorAt",
@@ -4582,7 +5758,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "access" : "protected",
@@ -4596,7 +5772,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::editItemLocation",
@@ -4612,7 +5788,7 @@
     }
    ],
    "return_type" : "_ZTIPv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::add",
@@ -4628,7 +5804,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::add",
@@ -4641,7 +5817,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::pop",
@@ -4654,7 +5830,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::push",
@@ -4670,7 +5846,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::push",
@@ -4683,7 +5859,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::sort",
@@ -4699,7 +5875,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::sort",
@@ -4718,7 +5894,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "access" : "private",
@@ -4738,7 +5914,7 @@
     }
    ],
    "return_type" : "_ZTIPv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::clear",
@@ -4751,7 +5927,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::resize",
@@ -4767,7 +5943,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "access" : "private",
@@ -4787,7 +5963,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::insertAt",
@@ -4810,7 +5986,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::insertAt",
@@ -4830,7 +6006,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::replaceAt",
@@ -4849,7 +6025,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::replaceAt",
@@ -4865,7 +6041,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::VectorImpl",
@@ -4881,7 +6057,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::VectorImpl",
@@ -4900,7 +6076,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::~VectorImpl",
@@ -4913,7 +6089,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::~VectorImpl",
@@ -4926,7 +6102,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::~VectorImpl",
@@ -4939,7 +6115,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::operator=",
@@ -4955,7 +6131,7 @@
     }
    ],
    "return_type" : "_ZTIRN7android10VectorImplE",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::uptimeNanos",
@@ -5256,7 +6432,7 @@
     }
    ],
    "return_type" : "_ZTINSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE",
-   "source_file" : "system/core/libutils/include/utils/Errors.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Errors.h"
   },
   {
    "function_name" : "android::elapsedRealtime",
@@ -5278,7 +6454,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::merge",
@@ -5294,7 +6470,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::merge",
@@ -5310,7 +6486,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::remove",
@@ -5326,7 +6502,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::SortedVectorImpl",
@@ -5342,7 +6518,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::SortedVectorImpl",
@@ -5361,7 +6537,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::~SortedVectorImpl",
@@ -5374,7 +6550,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::~SortedVectorImpl",
@@ -5387,7 +6563,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::~SortedVectorImpl",
@@ -5400,7 +6576,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::operator=",
@@ -5416,7 +6592,7 @@
     }
    ],
    "return_type" : "_ZTIRN7android16SortedVectorImplE",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::JenkinsHashWhiten",
@@ -5679,6 +6855,48 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/misc.h"
   },
+  {
+   "function_name" : "android::sp<android::LooperCallback>::clear",
+   "linker_set_key" : "_ZN7android2spINS_14LooperCallbackEE5clearEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android2spINS_14LooperCallbackEEE"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
+  },
+  {
+   "function_name" : "android::sp<android::Looper>::operator=",
+   "linker_set_key" : "_ZN7android2spINS_6LooperEEaSEOS2_",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android2spINS_6LooperEEE"
+    },
+    {
+     "referenced_type" : "_ZTION7android2spINS_6LooperEEE"
+    }
+   ],
+   "return_type" : "_ZTIRN7android2spINS_6LooperEEE",
+   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
+  },
+  {
+   "function_name" : "android::sp<android::Thread>::clear",
+   "linker_set_key" : "_ZN7android2spINS_6ThreadEE5clearEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android2spINS_6ThreadEEE"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
+  },
   {
    "function_name" : "android::LightRefBase_reportIncStrongRequireStrongFailed",
    "linker_set_key" : "_ZN7android47LightRefBase_reportIncStrongRequireStrongFailedEPKv",
@@ -5955,6 +7173,22 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
+  {
+   "function_name" : "android::Looper::repoll",
+   "linker_set_key" : "_ZN7android6Looper6repollEi",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android6LooperE"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libutils/include/utils/Looper.h"
+  },
   {
    "function_name" : "android::Looper::pollAll",
    "linker_set_key" : "_ZN7android6Looper7pollAllEiPiS1_PPv",
@@ -6493,11 +7727,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "private",
@@ -6513,7 +7747,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "private",
@@ -6522,7 +7756,7 @@
    "parameters" :
    [
     {
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -6532,7 +7766,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "private",
@@ -6541,7 +7775,7 @@
    "parameters" :
    [
     {
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -6551,7 +7785,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::attemptIncWeak",
@@ -6560,14 +7794,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::attemptIncStrong",
@@ -6576,14 +7810,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::incWeakRequireWeak",
@@ -6592,14 +7826,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::decWeak",
@@ -6608,14 +7842,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::incWeak",
@@ -6624,14 +7858,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::trackMe",
@@ -6640,7 +7874,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIb"
@@ -6650,7 +7884,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6660,14 +7894,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6677,14 +7911,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6694,14 +7928,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIi"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6711,7 +7945,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIj"
@@ -6721,7 +7955,7 @@
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6731,11 +7965,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6745,11 +7979,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6759,11 +7993,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6773,11 +8007,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6787,11 +8021,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::String8::lockBuffer",
@@ -6800,14 +8034,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIm"
     }
    ],
    "return_type" : "_ZTIPc",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "access" : "private",
@@ -6817,7 +8051,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -6827,7 +8061,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::appendFormat",
@@ -6836,14 +8070,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::unlockBuffer",
@@ -6852,14 +8086,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIm"
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::unlockBuffer",
@@ -6868,11 +8102,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::appendFormatV",
@@ -6881,7 +8115,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -6891,7 +8125,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::clear",
@@ -6900,11 +8134,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::setTo",
@@ -6913,7 +8147,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -6923,7 +8157,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::setTo",
@@ -6932,7 +8166,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -6942,7 +8176,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::setTo",
@@ -6951,14 +8185,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::setTo",
@@ -6967,7 +8201,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -6977,7 +8211,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::setTo",
@@ -6986,14 +8220,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::append",
@@ -7002,14 +8236,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::append",
@@ -7018,7 +8252,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -7028,7 +8262,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::append",
@@ -7037,14 +8271,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::format",
@@ -7055,8 +8289,8 @@
      "referenced_type" : "_ZTIPKc"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::formatV",
@@ -7070,8 +8304,8 @@
      "referenced_type" : "_ZTISt9__va_list"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::toLower",
@@ -7080,11 +8314,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::removeAll",
@@ -7093,14 +8327,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7109,14 +8343,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7125,7 +8359,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -7135,7 +8369,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7144,14 +8378,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7160,7 +8394,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -7170,7 +8404,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7179,14 +8413,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7195,7 +8429,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -7205,7 +8439,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7214,14 +8448,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIRKN7android8String16E"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7230,14 +8464,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7246,11 +8480,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7259,14 +8493,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7275,7 +8509,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -7285,7 +8519,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7294,14 +8528,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7310,7 +8544,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -7320,7 +8554,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7329,14 +8563,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7345,7 +8579,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -7355,7 +8589,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7364,14 +8598,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIRKN7android8String16E"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7380,14 +8614,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7396,11 +8630,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::~String8",
@@ -7409,11 +8643,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::~String8",
@@ -7422,11 +8656,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "access" : "private",
@@ -7443,7 +8677,7 @@
     }
    ],
    "return_type" : "_ZTIPv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::replaceAll",
@@ -7462,7 +8696,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -7478,7 +8712,7 @@
     }
    ],
    "return_type" : "_ZTIPDs",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -7494,7 +8728,7 @@
     }
    ],
    "return_type" : "_ZTIPDs",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -7508,7 +8742,7 @@
     }
    ],
    "return_type" : "_ZTIPv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -7521,7 +8755,7 @@
     }
    ],
    "return_type" : "_ZTIPv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::setTo",
@@ -7537,7 +8771,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::setTo",
@@ -7556,7 +8790,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::setTo",
@@ -7572,7 +8806,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::setTo",
@@ -7595,7 +8829,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::append",
@@ -7614,7 +8848,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::append",
@@ -7630,7 +8864,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::insert",
@@ -7649,7 +8883,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::insert",
@@ -7671,7 +8905,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -7685,7 +8919,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -7699,7 +8933,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7715,7 +8949,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7731,7 +8965,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7750,7 +8984,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7766,7 +9000,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7785,7 +9019,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7797,11 +9031,11 @@
      "referenced_type" : "_ZTIPN7android8String16E"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7817,7 +9051,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7840,7 +9074,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7853,7 +9087,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7869,7 +9103,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7885,7 +9119,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7904,7 +9138,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7920,7 +9154,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7939,7 +9173,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7951,11 +9185,11 @@
      "referenced_type" : "_ZTIPN7android8String16E"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7971,7 +9205,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7994,7 +9228,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -8007,7 +9241,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::~String16",
@@ -8020,7 +9254,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::~String16",
@@ -8033,7 +9267,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::operator=",
@@ -8049,7 +9283,7 @@
     }
    ],
    "return_type" : "_ZTIRN7android8String16E",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::FdPrinter::printLine",
@@ -8363,14 +9597,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android10VectorImplE"
+     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIm"
     }
    ],
    "return_type" : "_ZTIPKv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::capacity",
@@ -8379,11 +9613,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android10VectorImplE"
+     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIm",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "access" : "protected",
@@ -8393,11 +9627,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android10VectorImplE"
+     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIm",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "access" : "private",
@@ -8418,7 +9652,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::indexOf",
@@ -8434,7 +9668,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::orderOf",
@@ -8450,7 +9684,7 @@
     }
    ],
    "return_type" : "_ZTIm",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::Looper::getAllowNonCallbacks",
@@ -8934,14 +10168,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
-   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::getWeakRefs",
@@ -8950,11 +10184,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
-   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::getWeakCount",
@@ -8967,7 +10201,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::refBase",
@@ -8979,8 +10213,8 @@
      "referenced_type" : "_ZTIPKN7android7RefBase12weakref_typeE"
     }
    ],
-   "return_type" : "_ZTIPN7android7RefBaseE",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "return_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::printRefs",
@@ -8993,7 +10227,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::forceIncStrong",
@@ -9002,14 +10236,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::getStrongCount",
@@ -9018,11 +10252,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::incStrongRequireStrong",
@@ -9031,14 +10265,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::decStrong",
@@ -9047,14 +10281,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::incStrong",
@@ -9063,14 +10297,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "private",
@@ -9080,11 +10314,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "access" : "private",
@@ -9094,11 +10328,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::find",
@@ -9107,7 +10341,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -9118,7 +10352,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::length",
@@ -9127,11 +10361,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIm",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String16::startsWith",
@@ -9147,7 +10381,7 @@
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::startsWith",
@@ -9163,7 +10397,7 @@
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::isStaticString",
@@ -9176,7 +10410,7 @@
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -9190,7 +10424,7 @@
     }
    ],
    "return_type" : "_ZTIm",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::size",
@@ -9203,7 +10437,7 @@
     }
    ],
    "return_type" : "_ZTIm",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::contains",
@@ -9219,7 +10453,7 @@
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::findLast",
@@ -9235,7 +10469,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::findFirst",
@@ -9251,7 +10485,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::StopWatch::elapsedTime",
@@ -9444,7 +10678,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "strlen16",
@@ -9456,7 +10690,7 @@
     }
    ],
    "return_type" : "_ZTIm",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "strncmp16",
@@ -9474,7 +10708,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "strnlen16",
@@ -9489,7 +10723,7 @@
     }
    ],
    "return_type" : "_ZTIm",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "strstr16",
@@ -9504,7 +10738,7 @@
     }
    ],
    "return_type" : "_ZTIPDs",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "strzcmp16",
@@ -9525,7 +10759,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "systemTime",
@@ -9574,7 +10808,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf16_to_utf8_length",
@@ -9589,7 +10823,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf32_from_utf8_at",
@@ -9610,7 +10844,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf32_to_utf8",
@@ -9631,7 +10865,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf32_to_utf8_length",
@@ -9646,7 +10880,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf8_to_utf16",
@@ -9667,7 +10901,7 @@
     }
    ],
    "return_type" : "_ZTIPDs",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf8_to_utf16_length",
@@ -9686,7 +10920,7 @@
     }
    ],
    "return_type" : "_ZTIl",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf8_to_utf16_no_null_terminator",
@@ -9707,7 +10941,7 @@
     }
    ],
    "return_type" : "_ZTIPDs",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   }
  ],
  "global_vars" :
@@ -9729,16 +10963,16 @@
    "referenced_type" : "_ZTIA1_KDs",
    "self_type" : "_ZTIRA1_KDs",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIRKN7android10VectorImplE",
    "name" : "const android::VectorImpl &",
-   "referenced_type" : "_ZTIKN7android10VectorImplE",
+   "referenced_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIRKN7android10VectorImplE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 8,
@@ -9747,7 +10981,7 @@
    "referenced_type" : "_ZTIKN7android16ReferenceRenamerE",
    "self_type" : "_ZTIRKN7android16ReferenceRenamerE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "alignment" : 8,
@@ -9756,7 +10990,7 @@
    "referenced_type" : "_ZTIKN7android16SortedVectorImplE",
    "self_type" : "_ZTIRKN7android16SortedVectorImplE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 8,
@@ -9866,6 +11100,15 @@
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIRKN7android7String8E",
+   "name" : "const android::String8 &",
+   "referenced_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
+  },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIRKN7android8String1610StaticDataILm1EEE",
@@ -9873,7 +11116,7 @@
    "referenced_type" : "_ZTIKN7android8String1610StaticDataILm1EEE",
    "self_type" : "_ZTIRKN7android8String1610StaticDataILm1EEE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -9882,7 +11125,7 @@
    "referenced_type" : "_ZTIKN7android8String16E",
    "self_type" : "_ZTIRKN7android8String16E",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -9987,19 +11230,19 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIRN7android10VectorImplE",
    "name" : "android::VectorImpl &",
-   "referenced_type" : "_ZTIN7android10VectorImplE",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIRN7android10VectorImplE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIRN7android16SortedVectorImplE",
    "name" : "android::SortedVectorImpl &",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIRN7android16SortedVectorImplE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 8,
@@ -10109,6 +11352,15 @@
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIRN7android7String8E",
+   "name" : "android::String8 &",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIRN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
+  },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIRN7android8String16E",
@@ -10116,7 +11368,7 @@
    "referenced_type" : "_ZTIN7android8String16E",
    "self_type" : "_ZTIRN7android8String16E",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -10200,7 +11452,7 @@
    "referenced_type" : "_ZTIDs",
    "self_type" : "_ZTIPDs",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -10218,7 +11470,7 @@
    "referenced_type" : "_ZTIFiPKvS0_E",
    "self_type" : "_ZTIPFiPKvS0_E",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 8,
@@ -10227,7 +11479,7 @@
    "referenced_type" : "_ZTIFiPKvS0_PvE",
    "self_type" : "_ZTIPFiPKvS0_PvE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 8,
@@ -10281,7 +11533,7 @@
    "referenced_type" : "_ZTIKDi",
    "self_type" : "_ZTIPKDi",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "alignment" : 8,
@@ -10290,7 +11542,7 @@
    "referenced_type" : "_ZTIKDs",
    "self_type" : "_ZTIPKDs",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -10301,6 +11553,15 @@
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
   },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPKN7android10VectorImplE",
+   "name" : "const android::VectorImpl *",
+   "referenced_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
+  },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIPKN7android12LightRefBaseINS_12NativeHandleEEE",
@@ -10326,7 +11587,7 @@
    "referenced_type" : "_ZTIKN7android16SortedVectorImplE",
    "self_type" : "_ZTIPKN7android16SortedVectorImplE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 8,
@@ -10488,7 +11749,7 @@
    "referenced_type" : "_ZTIKN7android6VectorINS_7String8EEE",
    "self_type" : "_ZTIPKN7android6VectorINS_7String8EEE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Vector.h"
   },
   {
    "alignment" : 8,
@@ -10506,7 +11767,7 @@
    "referenced_type" : "_ZTIKN7android7RefBase12weakref_typeE",
    "self_type" : "_ZTIPKN7android7RefBase12weakref_typeE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "alignment" : 8,
@@ -10517,6 +11778,15 @@
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPKN7android7RefBaseE",
+   "name" : "const android::RefBase *",
+   "referenced_type" : "_ZTIKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIPKN7android7String8E",
@@ -10528,21 +11798,21 @@
   },
   {
    "alignment" : 8,
-   "linker_set_key" : "_ZTIPKN7android8String16E",
-   "name" : "const android::String16 *",
-   "referenced_type" : "_ZTIKN7android8String16E",
-   "self_type" : "_ZTIPKN7android8String16E",
+   "linker_set_key" : "_ZTIPKN7android7String8E",
+   "name" : "const android::String8 *",
+   "referenced_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "alignment" : 8,
-   "linker_set_key" : "_ZTIPKN7android9CallStackE",
-   "name" : "const android::CallStack *",
-   "referenced_type" : "_ZTIKN7android9CallStackE",
-   "self_type" : "_ZTIPKN7android9CallStackE",
+   "linker_set_key" : "_ZTIPKN7android8String16E",
+   "name" : "const android::String16 *",
+   "referenced_type" : "_ZTIKN7android8String16E",
+   "self_type" : "_ZTIPKN7android8String16E",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/CallStack.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -10611,10 +11881,10 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIPN7android10VectorImplE",
    "name" : "android::VectorImpl *",
-   "referenced_type" : "_ZTIN7android10VectorImplE",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIPN7android10VectorImplE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 8,
@@ -10677,7 +11947,7 @@
    "referenced_type" : "_ZTIN7android14StaticString16ILm1EEE",
    "self_type" : "_ZTIPN7android14StaticString16ILm1EEE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -10697,14 +11967,23 @@
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPN7android16ReferenceRenamerE",
+   "name" : "android::ReferenceRenamer *",
+   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIPN7android16SortedVectorImplE",
    "name" : "android::SortedVectorImpl *",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIPN7android16SortedVectorImplE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 8,
@@ -10724,6 +12003,15 @@
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPN7android19VirtualLightRefBaseE",
+   "name" : "android::VirtualLightRefBase *",
+   "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/LightRefBase.h"
+  },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIPN7android20SimpleLooperCallbackE",
@@ -10947,7 +12235,7 @@
    "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE",
    "self_type" : "_ZTIPN7android6VectorINS_7String8EEE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Vector.h"
   },
   {
    "alignment" : 8,
@@ -10994,6 +12282,15 @@
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPN7android7RefBase12weakref_typeE",
+   "name" : "android::RefBase::weakref_type *",
+   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIPN7android7RefBaseE",
@@ -11003,6 +12300,15 @@
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPN7android7RefBaseE",
+   "name" : "android::RefBase *",
+   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIPN7android7String8E",
@@ -11012,6 +12318,15 @@
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIPN7android7String8E",
+   "name" : "android::String8 *",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
+  },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIPN7android8String1610StaticDataILm1EEE",
@@ -11019,7 +12334,7 @@
    "referenced_type" : "_ZTIN7android8String1610StaticDataILm1EEE",
    "self_type" : "_ZTIPN7android8String1610StaticDataILm1EEE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -11028,25 +12343,7 @@
    "referenced_type" : "_ZTIN7android8String16E",
    "self_type" : "_ZTIPN7android8String16E",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
-  },
-  {
-   "alignment" : 8,
-   "linker_set_key" : "_ZTIPN7android9CallStack12StackDeleterE",
-   "name" : "android::CallStack::StackDeleter *",
-   "referenced_type" : "_ZTIN7android9CallStack12StackDeleterE",
-   "self_type" : "_ZTIPN7android9CallStack12StackDeleterE",
-   "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/CallStack.h"
-  },
-  {
-   "alignment" : 8,
-   "linker_set_key" : "_ZTIPN7android9CallStackE",
-   "name" : "android::CallStack *",
-   "referenced_type" : "_ZTIN7android9CallStackE",
-   "self_type" : "_ZTIPN7android9CallStackE",
-   "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/CallStack.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -11136,7 +12433,7 @@
    "referenced_type" : "_ZTIm",
    "self_type" : "_ZTIPm",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "alignment" : 8,
@@ -11158,7 +12455,7 @@
    "referenced_type" : "_ZTIA1_Ds",
    "self_type" : "_ZTIA1_KDs",
    "size" : 2,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -11188,7 +12485,7 @@
    "referenced_type" : "_ZTIDi",
    "self_type" : "_ZTIKDi",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "alignment" : 2,
@@ -11198,7 +12495,17 @@
    "referenced_type" : "_ZTIDs",
    "self_type" : "_ZTIKDs",
    "size" : 2,
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
+  },
+  {
+   "alignment" : 8,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIKN7android10VectorImplE",
+   "name" : "const android::VectorImpl",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 40,
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 8,
@@ -11235,20 +12542,20 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android16ReferenceRenamerE",
    "name" : "const android::ReferenceRenamer",
-   "referenced_type" : "_ZTIN7android16ReferenceRenamerE",
+   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIKN7android16ReferenceRenamerE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "alignment" : 8,
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android16SortedVectorImplE",
    "name" : "const android::SortedVectorImpl",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIKN7android16SortedVectorImplE",
    "size" : 40,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 8,
@@ -11438,7 +12745,7 @@
    "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE",
    "self_type" : "_ZTIKN7android6VectorINS_7String8EEE",
    "size" : 40,
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Vector.h"
   },
   {
    "alignment" : 8,
@@ -11465,10 +12772,20 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android7RefBase12weakref_typeE",
    "name" : "const android::RefBase::weakref_type",
-   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE",
+   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIKN7android7RefBase12weakref_typeE",
    "size" : 1,
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
+  {
+   "alignment" : 8,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIKN7android7RefBaseE",
+   "name" : "const android::RefBase",
+   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 16,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "alignment" : 8,
@@ -11480,6 +12797,16 @@
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 8,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIKN7android7String8E",
+   "name" : "const android::String8",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
+  },
   {
    "alignment" : 8,
    "is_const" : true,
@@ -11498,7 +12825,7 @@
    "referenced_type" : "_ZTIN7android8String1610StaticDataILm1EEE",
    "self_type" : "_ZTIKN7android8String1610StaticDataILm1EEE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -11508,17 +12835,7 @@
    "referenced_type" : "_ZTIN7android8String16E",
    "self_type" : "_ZTIKN7android8String16E",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
-   "alignment" : 8,
-   "is_const" : true,
-   "linker_set_key" : "_ZTIKN7android9CallStackE",
-   "name" : "const android::CallStack",
-   "referenced_type" : "_ZTIN7android9CallStackE",
-   "self_type" : "_ZTIKN7android9CallStackE",
-   "size" : 40,
-   "source_file" : "system/core/libutils/include/utils/CallStack.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -12243,6 +13560,85 @@
     }
    ]
   },
+  {
+   "alignment" : 8,
+   "fields" :
+   [
+    {
+     "access" : "private",
+     "field_name" : "mStorage",
+     "field_offset" : 64,
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "access" : "private",
+     "field_name" : "mCount",
+     "field_offset" : 128,
+     "referenced_type" : "_ZTIm"
+    },
+    {
+     "access" : "private",
+     "field_name" : "mFlags",
+     "field_offset" : 192,
+     "referenced_type" : "_ZTIKj"
+    },
+    {
+     "access" : "private",
+     "field_name" : "mItemSize",
+     "field_offset" : 256,
+     "referenced_type" : "_ZTIKm"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android10VectorImplE",
+   "name" : "android::VectorImpl",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 40,
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h",
+   "vtable_components" :
+   [
+    {
+     "kind" : "offset_to_top"
+    },
+    {
+     "kind" : "rtti",
+     "mangled_component_name" : "_ZTIN7android10VectorImplE"
+    },
+    {
+     "kind" : "complete_dtor_pointer",
+     "mangled_component_name" : "_ZN7android10VectorImplD1Ev"
+    },
+    {
+     "kind" : "deleting_dtor_pointer",
+     "mangled_component_name" : "_ZN7android10VectorImplD0Ev"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl12do_constructEPvm"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl10do_destroyEPvm"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl7do_copyEPvPKvm"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl8do_splatEPvPKvm"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl15do_move_forwardEPvPKvm"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl16do_move_backwardEPvPKvm"
+    }
+   ]
+  },
   {
    "alignment" : 8,
    "fields" :
@@ -12305,6 +13701,28 @@
     "_ZTIN7android19VirtualLightRefBaseE"
    ]
   },
+  {
+   "alignment" : 4,
+   "fields" :
+   [
+    {
+     "access" : "private",
+     "field_name" : "mCount",
+     "referenced_type" : "_ZTINSt3__16atomicIiEE"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE",
+   "name" : "android::LightRefBase<android::VirtualLightRefBase>",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/LightRefBase.h",
+   "template_args" :
+   [
+    "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+   ]
+  },
   {
    "alignment" : 8,
    "base_specifiers" :
@@ -12614,6 +14032,16 @@
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android14ReferenceMoverE",
+   "name" : "android::ReferenceMover",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android14ReferenceMoverE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android14ReferenceMoverE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
   {
    "alignment" : 8,
    "base_specifiers" :
@@ -12637,7 +14065,7 @@
    "referenced_type" : "_ZTIN7android14StaticString16ILm1EEE",
    "self_type" : "_ZTIN7android14StaticString16ILm1EEE",
    "size" : 16,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -12682,15 +14110,39 @@
      "mangled_component_name" : "_ZN7android14String8Printer9printLineEPKc"
     },
     {
-     "mangled_component_name" : "_ZN7android7Printer15printFormatLineEPKcz"
+     "mangled_component_name" : "_ZN7android7Printer15printFormatLineEPKcz"
+    },
+    {
+     "kind" : "complete_dtor_pointer",
+     "mangled_component_name" : "_ZN7android14String8PrinterD1Ev"
+    },
+    {
+     "kind" : "deleting_dtor_pointer",
+     "mangled_component_name" : "_ZN7android14String8PrinterD0Ev"
+    }
+   ]
+  },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIN7android16ReferenceRenamerE",
+   "name" : "android::ReferenceRenamer",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android16ReferenceRenamerE",
+   "self_type" : "_ZTIN7android16ReferenceRenamerE",
+   "size" : 8,
+   "source_file" : "system/core/libutils/include/utils/RefBase.h",
+   "vtable_components" :
+   [
+    {
+     "kind" : "offset_to_top"
     },
     {
-     "kind" : "complete_dtor_pointer",
-     "mangled_component_name" : "_ZN7android14String8PrinterD1Ev"
+     "kind" : "rtti",
+     "mangled_component_name" : "_ZTIN7android16ReferenceRenamerE"
     },
     {
-     "kind" : "deleting_dtor_pointer",
-     "mangled_component_name" : "_ZN7android14String8PrinterD0Ev"
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android16ReferenceRenamerclEm"
     }
    ]
   },
@@ -12699,10 +14151,10 @@
    "linker_set_key" : "_ZTIN7android16ReferenceRenamerE",
    "name" : "android::ReferenceRenamer",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android16ReferenceRenamerE",
-   "self_type" : "_ZTIN7android16ReferenceRenamerE",
+   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/RefBase.h",
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
    "vtable_components" :
    [
     {
@@ -12780,6 +14232,68 @@
     }
    ]
   },
+  {
+   "alignment" : 8,
+   "base_specifiers" :
+   [
+    {
+     "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android16SortedVectorImplE",
+   "name" : "android::SortedVectorImpl",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 40,
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h",
+   "vtable_components" :
+   [
+    {
+     "kind" : "offset_to_top"
+    },
+    {
+     "kind" : "rtti",
+     "mangled_component_name" : "_ZTIN7android16SortedVectorImplE"
+    },
+    {
+     "kind" : "complete_dtor_pointer",
+     "mangled_component_name" : "_ZN7android16SortedVectorImplD1Ev"
+    },
+    {
+     "kind" : "deleting_dtor_pointer",
+     "mangled_component_name" : "_ZN7android16SortedVectorImplD0Ev"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl12do_constructEPvm"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl10do_destroyEPvm"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl7do_copyEPvPKvm"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl8do_splatEPvPKvm"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl15do_move_forwardEPvPKvm"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl16do_move_backwardEPvPKvm"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android16SortedVectorImpl10do_compareEPKvS2_"
+    }
+   ]
+  },
   {
    "alignment" : 1,
    "base_specifiers" :
@@ -12983,6 +14497,19 @@
     "_ZTIb"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIbEE",
+   "name" : "android::trait_trivial_copy<bool>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIb"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcEE",
@@ -12996,6 +14523,19 @@
     "_ZTIc"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcEE",
+   "name" : "android::trait_trivial_copy<char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIc"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdEE",
@@ -13009,6 +14549,19 @@
     "_ZTId"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdEE",
+   "name" : "android::trait_trivial_copy<double>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTId"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfEE",
@@ -13022,6 +14575,19 @@
     "_ZTIf"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfEE",
+   "name" : "android::trait_trivial_copy<float>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIf"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhEE",
@@ -13035,6 +14601,19 @@
     "_ZTIh"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhEE",
+   "name" : "android::trait_trivial_copy<unsigned char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIh"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiEE",
@@ -13048,6 +14627,19 @@
     "_ZTIi"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiEE",
+   "name" : "android::trait_trivial_copy<int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIi"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjEE",
@@ -13061,6 +14653,19 @@
     "_ZTIj"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjEE",
+   "name" : "android::trait_trivial_copy<unsigned int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIj"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlEE",
@@ -13074,6 +14679,19 @@
     "_ZTIl"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlEE",
+   "name" : "android::trait_trivial_copy<long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIl"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyImEE",
@@ -13087,6 +14705,19 @@
     "_ZTIm"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyImEE",
+   "name" : "android::trait_trivial_copy<unsigned long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIm"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsEE",
@@ -13100,6 +14731,19 @@
     "_ZTIs"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsEE",
+   "name" : "android::trait_trivial_copy<short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIs"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyItEE",
@@ -13113,6 +14757,19 @@
     "_ZTIt"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyItEE",
+   "name" : "android::trait_trivial_copy<unsigned short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIt"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvEE",
@@ -13126,6 +14783,19 @@
     "_ZTIv"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvEE",
+   "name" : "android::trait_trivial_copy<void>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIv"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxEE",
@@ -13139,6 +14809,19 @@
     "_ZTIx"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxEE",
+   "name" : "android::trait_trivial_copy<long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIx"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyEE",
@@ -13152,6 +14835,19 @@
     "_ZTIy"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyEE",
+   "name" : "android::trait_trivial_copy<unsigned long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIy"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEEE",
@@ -13204,6 +14900,19 @@
     "_ZTIb"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbEE",
+   "name" : "android::trait_trivial_ctor<bool>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIb"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcEE",
@@ -13217,6 +14926,19 @@
     "_ZTIc"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcEE",
+   "name" : "android::trait_trivial_ctor<char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIc"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdEE",
@@ -13227,17 +14949,43 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
    [
-    "_ZTId"
+    "_ZTId"
+   ]
+  },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdEE",
+   "name" : "android::trait_trivial_ctor<double>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTId"
+   ]
+  },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfEE",
+   "name" : "android::trait_trivial_ctor<float>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfEE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIfEE",
+   "size" : 1,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIf"
    ]
   },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfEE",
    "name" : "android::trait_trivial_ctor<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIfEE",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
    [
     "_ZTIf"
@@ -13256,6 +15004,19 @@
     "_ZTIh"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhEE",
+   "name" : "android::trait_trivial_ctor<unsigned char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIh"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiEE",
@@ -13269,6 +15030,19 @@
     "_ZTIi"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiEE",
+   "name" : "android::trait_trivial_ctor<int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIi"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjEE",
@@ -13282,6 +15056,19 @@
     "_ZTIj"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjEE",
+   "name" : "android::trait_trivial_ctor<unsigned int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIj"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlEE",
@@ -13295,6 +15082,19 @@
     "_ZTIl"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlEE",
+   "name" : "android::trait_trivial_ctor<long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIl"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImEE",
@@ -13308,6 +15108,19 @@
     "_ZTIm"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImEE",
+   "name" : "android::trait_trivial_ctor<unsigned long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIm"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsEE",
@@ -13321,6 +15134,19 @@
     "_ZTIs"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsEE",
+   "name" : "android::trait_trivial_ctor<short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIs"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItEE",
@@ -13334,6 +15160,19 @@
     "_ZTIt"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItEE",
+   "name" : "android::trait_trivial_ctor<unsigned short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIt"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvEE",
@@ -13347,6 +15186,19 @@
     "_ZTIv"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvEE",
+   "name" : "android::trait_trivial_ctor<void>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIv"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxEE",
@@ -13360,6 +15212,19 @@
     "_ZTIx"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxEE",
+   "name" : "android::trait_trivial_ctor<long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIx"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyEE",
@@ -13373,6 +15238,19 @@
     "_ZTIy"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyEE",
+   "name" : "android::trait_trivial_ctor<unsigned long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIy"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEEE",
@@ -13425,6 +15303,19 @@
     "_ZTIb"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbEE",
+   "name" : "android::trait_trivial_dtor<bool>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIb"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcEE",
@@ -13438,6 +15329,19 @@
     "_ZTIc"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcEE",
+   "name" : "android::trait_trivial_dtor<char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIc"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdEE",
@@ -13451,6 +15355,19 @@
     "_ZTId"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdEE",
+   "name" : "android::trait_trivial_dtor<double>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTId"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfEE",
@@ -13464,6 +15381,19 @@
     "_ZTIf"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfEE",
+   "name" : "android::trait_trivial_dtor<float>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIf"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhEE",
@@ -13477,6 +15407,19 @@
     "_ZTIh"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhEE",
+   "name" : "android::trait_trivial_dtor<unsigned char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIh"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiEE",
@@ -13490,6 +15433,19 @@
     "_ZTIi"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiEE",
+   "name" : "android::trait_trivial_dtor<int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIi"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjEE",
@@ -13503,6 +15459,19 @@
     "_ZTIj"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjEE",
+   "name" : "android::trait_trivial_dtor<unsigned int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIj"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlEE",
@@ -13516,6 +15485,19 @@
     "_ZTIl"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlEE",
+   "name" : "android::trait_trivial_dtor<long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIl"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImEE",
@@ -13529,6 +15511,19 @@
     "_ZTIm"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImEE",
+   "name" : "android::trait_trivial_dtor<unsigned long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIm"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsEE",
@@ -13542,6 +15537,19 @@
     "_ZTIs"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsEE",
+   "name" : "android::trait_trivial_dtor<short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIs"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItEE",
@@ -13555,6 +15563,19 @@
     "_ZTIt"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItEE",
+   "name" : "android::trait_trivial_dtor<unsigned short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIt"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvEE",
@@ -13568,6 +15589,19 @@
     "_ZTIv"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvEE",
+   "name" : "android::trait_trivial_dtor<void>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIv"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxEE",
@@ -13581,6 +15615,19 @@
     "_ZTIx"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxEE",
+   "name" : "android::trait_trivial_dtor<long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIx"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyEE",
@@ -13594,6 +15641,19 @@
     "_ZTIy"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyEE",
+   "name" : "android::trait_trivial_dtor<unsigned long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIy"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEEE",
@@ -13646,6 +15706,19 @@
     "_ZTIN7android7String8E"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE",
+   "name" : "android::trait_trivial_move<android::String8>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h",
+   "template_args" :
+   [
+    "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_8String16EEE",
@@ -13653,7 +15726,7 @@
    "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EEE",
    "self_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EEE",
    "size" : 1,
-   "source_file" : "system/core/libutils/include/utils/String16.h",
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h",
    "template_args" :
    [
     "_ZTIN7android8String16E"
@@ -13672,6 +15745,19 @@
     "_ZTIb"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIbEE",
+   "name" : "android::trait_trivial_move<bool>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIb"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcEE",
@@ -13685,6 +15771,19 @@
     "_ZTIc"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcEE",
+   "name" : "android::trait_trivial_move<char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIc"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdEE",
@@ -13698,6 +15797,19 @@
     "_ZTId"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdEE",
+   "name" : "android::trait_trivial_move<double>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTId"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfEE",
@@ -13711,6 +15823,19 @@
     "_ZTIf"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfEE",
+   "name" : "android::trait_trivial_move<float>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIf"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhEE",
@@ -13724,6 +15849,19 @@
     "_ZTIh"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhEE",
+   "name" : "android::trait_trivial_move<unsigned char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIh"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiEE",
@@ -13737,6 +15875,19 @@
     "_ZTIi"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiEE",
+   "name" : "android::trait_trivial_move<int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIi"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjEE",
@@ -13750,6 +15901,19 @@
     "_ZTIj"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjEE",
+   "name" : "android::trait_trivial_move<unsigned int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIj"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlEE",
@@ -13763,6 +15927,19 @@
     "_ZTIl"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlEE",
+   "name" : "android::trait_trivial_move<long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIl"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveImEE",
@@ -13776,6 +15953,19 @@
     "_ZTIm"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveImEE",
+   "name" : "android::trait_trivial_move<unsigned long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIm"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsEE",
@@ -13789,6 +15979,19 @@
     "_ZTIs"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsEE",
+   "name" : "android::trait_trivial_move<short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIs"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveItEE",
@@ -13802,6 +16005,19 @@
     "_ZTIt"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveItEE",
+   "name" : "android::trait_trivial_move<unsigned short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIt"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvEE",
@@ -13815,6 +16031,19 @@
     "_ZTIv"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvEE",
+   "name" : "android::trait_trivial_move<void>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIv"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxEE",
@@ -13828,6 +16057,19 @@
     "_ZTIx"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxEE",
+   "name" : "android::trait_trivial_move<long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIx"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyEE",
@@ -13841,6 +16083,19 @@
     "_ZTIy"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyEE",
+   "name" : "android::trait_trivial_move<unsigned long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIy"
+   ]
+  },
   {
    "alignment" : 8,
    "base_specifiers" :
@@ -13875,6 +16130,40 @@
     }
    ]
   },
+  {
+   "alignment" : 8,
+   "base_specifiers" :
+   [
+    {
+     "referenced_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android19VirtualLightRefBaseE",
+   "name" : "android::VirtualLightRefBase",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 16,
+   "source_file" : "system/core/libutils/binder/include/utils/LightRefBase.h",
+   "vtable_components" :
+   [
+    {
+     "kind" : "offset_to_top"
+    },
+    {
+     "kind" : "rtti",
+     "mangled_component_name" : "_ZTIN7android19VirtualLightRefBaseE"
+    },
+    {
+     "kind" : "complete_dtor_pointer",
+     "mangled_component_name" : "_ZN7android19VirtualLightRefBaseD1Ev"
+    },
+    {
+     "kind" : "deleting_dtor_pointer",
+     "mangled_component_name" : "_ZN7android19VirtualLightRefBaseD0Ev"
+    }
+   ]
+  },
   {
    "alignment" : 8,
    "base_specifiers" :
@@ -14849,7 +17138,7 @@
    [
     {
      "access" : "private",
-     "referenced_type" : "_ZTIN7android10VectorImplE"
+     "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "linker_set_key" : "_ZTIN7android6VectorINS_7String8EEE",
@@ -14858,10 +17147,10 @@
    "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE",
    "self_type" : "_ZTIN7android6VectorINS_7String8EEE",
    "size" : 40,
-   "source_file" : "system/core/libutils/include/utils/Vector.h",
+   "source_file" : "system/core/libutils/binder/include/utils/Vector.h",
    "template_args" :
    [
-    "_ZTIN7android7String8E"
+    "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
    ],
    "vtable_components" :
    [
@@ -15048,6 +17337,16 @@
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android7RefBase12weakref_typeE",
+   "name" : "android::RefBase::weakref_type",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
   {
    "alignment" : 8,
    "fields" :
@@ -15097,6 +17396,55 @@
     }
    ]
   },
+  {
+   "alignment" : 8,
+   "fields" :
+   [
+    {
+     "access" : "private",
+     "field_name" : "mRefs",
+     "field_offset" : 64,
+     "referenced_type" : "_ZTIKPN7android7RefBase12weakref_implE"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android7RefBaseE",
+   "name" : "android::RefBase",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 16,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
+   "vtable_components" :
+   [
+    {
+     "kind" : "offset_to_top"
+    },
+    {
+     "kind" : "rtti",
+     "mangled_component_name" : "_ZTIN7android7RefBaseE"
+    },
+    {
+     "kind" : "complete_dtor_pointer",
+     "mangled_component_name" : "_ZN7android7RefBaseD1Ev"
+    },
+    {
+     "kind" : "deleting_dtor_pointer",
+     "mangled_component_name" : "_ZN7android7RefBaseD0Ev"
+    },
+    {
+     "mangled_component_name" : "_ZN7android7RefBase10onFirstRefEv"
+    },
+    {
+     "mangled_component_name" : "_ZN7android7RefBase15onLastStrongRefEPKv"
+    },
+    {
+     "mangled_component_name" : "_ZN7android7RefBase20onIncStrongAttemptedEjPKv"
+    },
+    {
+     "mangled_component_name" : "_ZN7android7RefBase13onLastWeakRefEPKv"
+    }
+   ]
+  },
   {
    "alignment" : 8,
    "fields" :
@@ -15115,6 +17463,24 @@
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "alignment" : 8,
+   "fields" :
+   [
+    {
+     "access" : "private",
+     "field_name" : "mString",
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android7String8E",
+   "name" : "android::String8",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
+  },
   {
    "alignment" : 4,
    "fields" :
@@ -15134,7 +17500,7 @@
    "referenced_type" : "_ZTIN7android8String1610StaticDataILm1EEE",
    "self_type" : "_ZTIN7android8String1610StaticDataILm1EEE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -15152,34 +17518,7 @@
    "referenced_type" : "_ZTIN7android8String16E",
    "self_type" : "_ZTIN7android8String16E",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
-  },
-  {
-   "alignment" : 1,
-   "linker_set_key" : "_ZTIN7android9CallStack12StackDeleterE",
-   "name" : "android::CallStack::StackDeleter",
-   "referenced_type" : "_ZTIN7android9CallStack12StackDeleterE",
-   "self_type" : "_ZTIN7android9CallStack12StackDeleterE",
-   "size" : 1,
-   "source_file" : "system/core/libutils/include/utils/CallStack.h"
-  },
-  {
-   "alignment" : 8,
-   "fields" :
-   [
-    {
-     "access" : "private",
-     "field_name" : "mFrameLines",
-     "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE"
-    }
-   ],
-   "linker_set_key" : "_ZTIN7android9CallStackE",
-   "name" : "android::CallStack",
-   "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android9CallStackE",
-   "self_type" : "_ZTIN7android9CallStackE",
-   "size" : 40,
-   "source_file" : "system/core/libutils/include/utils/CallStack.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -15445,7 +17784,7 @@
    "referenced_type" : "_ZTIN7android8String16E",
    "self_type" : "_ZTION7android8String16E",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   }
  ]
 }
diff --git a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
index e8236ea5b6af..dfc1ab581af6 100644
--- a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
@@ -16,7 +16,7 @@
    "referenced_type" : "_ZTIDs",
    "self_type" : "_ZTIA1_Ds",
    "size" : 2,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 1,
@@ -46,6 +46,7 @@
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
   {
+   "is_of_unknown_bound" : true,
    "linker_set_key" : "_ZTIA_f",
    "name" : "float[]",
    "referenced_type" : "_ZTIf",
@@ -490,6 +491,22 @@
   {
    "name" : "_ZN7android27add_sysprop_change_callbackEPFvvEi"
   },
+  {
+   "binding" : "weak",
+   "name" : "_ZN7android2spINS_14LooperCallbackEE5clearEv"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZN7android2spINS_6LooperEEaSEOS2_"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZN7android2spINS_6ThreadEE5clearEv"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZN7android2spINS_6ThreadEEaSEOS2_"
+  },
   {
    "name" : "_ZN7android30get_report_sysprop_change_funcEv"
   },
@@ -544,6 +561,9 @@
   {
    "name" : "_ZN7android6Looper6awokenEv"
   },
+  {
+   "name" : "_ZN7android6Looper6repollEi"
+  },
   {
    "name" : "_ZN7android6Looper7pollAllEiPiS1_PPv"
   },
@@ -1194,6 +1214,14 @@
    "binding" : "weak",
    "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE25__emplace_unique_key_argsIiJRiRKyEEENS_4pairINS_15__hash_iteratorIPNS_11__hash_nodeIS2_PvEEEEbEERKT_DpOT0_"
   },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE4findIiEENS_15__hash_iteratorIPNS_11__hash_nodeIS2_PvEEEERKT_"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE5eraseENS_21__hash_const_iteratorIPNS_11__hash_nodeIS2_PvEEEE"
+  },
   {
    "binding" : "weak",
    "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE6rehashEj"
@@ -1206,10 +1234,30 @@
    "binding" : "weak",
    "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE8__rehashEj"
   },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEED2Ev"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE14__erase_uniqueIyEEjRKT_"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE17__deallocate_nodeEPNS_16__hash_node_baseIPNS_11__hash_nodeIS5_PvEEEE"
+  },
   {
    "binding" : "weak",
    "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE25__emplace_unique_key_argsIyJRKyRS4_EEENS_4pairINS_15__hash_iteratorIPNS_11__hash_nodeIS5_PvEEEEbEERKT_DpOT0_"
   },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE4findIyEENS_15__hash_iteratorIPNS_11__hash_nodeIS5_PvEEEERKT_"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE5eraseENS_21__hash_const_iteratorIPNS_11__hash_nodeIS5_PvEEEE"
+  },
   {
    "binding" : "weak",
    "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE6rehashEj"
@@ -1222,6 +1270,10 @@
    "binding" : "weak",
    "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE8__rehashEj"
   },
+  {
+   "binding" : "weak",
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEED2Ev"
+  },
   {
    "name" : "_ZTv0_n12_N7android14LooperCallbackD0Ev"
   },
@@ -1407,6 +1459,10 @@
   },
   {
    "name" : "_ZTVN7android9FdPrinterE"
+  },
+  {
+   "binding" : "weak",
+   "name" : "__llvm_fs_discriminator__"
   }
  ],
  "enum_types" :
@@ -2242,6 +2298,23 @@
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.1.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 13,
+     "name" : "HAL_COLOR_MODE_DISPLAY_BT2020"
+    }
+   ],
+   "linker_set_key" : "_ZTI25android_color_mode_v1_2_t",
+   "name" : "android_color_mode_v1_2_t",
+   "referenced_type" : "_ZTI25android_color_mode_v1_2_t",
+   "self_type" : "_ZTI25android_color_mode_v1_2_t",
+   "size" : 4,
+   "source_file" : "system/core/libsystem/include/system/graphics-base-v1.2.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -2481,6 +2554,31 @@
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::VectorImpl::HAS_TRIVIAL_CTOR"
+    },
+    {
+     "enum_field_value" : 2,
+     "name" : "android::VectorImpl::HAS_TRIVIAL_DTOR"
+    },
+    {
+     "enum_field_value" : 4,
+     "name" : "android::VectorImpl::HAS_TRIVIAL_COPY"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE",
+   "name" : "android::VectorImpl::(unnamed)",
+   "referenced_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -2625,6 +2723,99 @@
    "source_file" : "system/core/libutils/include/utils/Errors.h",
    "underlying_type" : "_ZTIi"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 0,
+     "name" : "android::OK"
+    },
+    {
+     "enum_field_value" : 0,
+     "name" : "android::NO_ERROR"
+    },
+    {
+     "enum_field_value" : -2147483648,
+     "name" : "android::UNKNOWN_ERROR"
+    },
+    {
+     "enum_field_value" : -12,
+     "name" : "android::NO_MEMORY"
+    },
+    {
+     "enum_field_value" : -38,
+     "name" : "android::INVALID_OPERATION"
+    },
+    {
+     "enum_field_value" : -22,
+     "name" : "android::BAD_VALUE"
+    },
+    {
+     "enum_field_value" : -2147483647,
+     "name" : "android::BAD_TYPE"
+    },
+    {
+     "enum_field_value" : -2,
+     "name" : "android::NAME_NOT_FOUND"
+    },
+    {
+     "enum_field_value" : -1,
+     "name" : "android::PERMISSION_DENIED"
+    },
+    {
+     "enum_field_value" : -19,
+     "name" : "android::NO_INIT"
+    },
+    {
+     "enum_field_value" : -17,
+     "name" : "android::ALREADY_EXISTS"
+    },
+    {
+     "enum_field_value" : -32,
+     "name" : "android::DEAD_OBJECT"
+    },
+    {
+     "enum_field_value" : -2147483646,
+     "name" : "android::FAILED_TRANSACTION"
+    },
+    {
+     "enum_field_value" : -75,
+     "name" : "android::BAD_INDEX"
+    },
+    {
+     "enum_field_value" : -61,
+     "name" : "android::NOT_ENOUGH_DATA"
+    },
+    {
+     "enum_field_value" : -11,
+     "name" : "android::WOULD_BLOCK"
+    },
+    {
+     "enum_field_value" : -110,
+     "name" : "android::TIMED_OUT"
+    },
+    {
+     "enum_field_value" : -74,
+     "name" : "android::UNKNOWN_TRANSACTION"
+    },
+    {
+     "enum_field_value" : -2147483641,
+     "name" : "android::FDS_NOT_ALLOWED"
+    },
+    {
+     "enum_field_value" : -2147483640,
+     "name" : "android::UNEXPECTED_NULL"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android15$ALREADY_EXISTSE",
+   "name" : "android::(unnamed)",
+   "referenced_type" : "_ZTIN7android15$ALREADY_EXISTSE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/Errors.sdump",
+   "self_type" : "_ZTIN7android15$ALREADY_EXISTSE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/Errors.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/Errors.h",
+   "underlying_type" : "_ZTIi"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -2754,6 +2945,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<bool>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIbE6$valueE",
+   "name" : "android::trait_trivial_copy<bool>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -2777,15 +2985,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<double>::value"
+     "name" : "android::trait_trivial_copy<char>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
-   "name" : "android::trait_trivial_copy<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcE6$valueE",
+   "name" : "android::trait_trivial_copy<char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -2794,13 +3002,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<float>::value"
+     "name" : "android::trait_trivial_copy<double>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
-   "name" : "android::trait_trivial_copy<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
+   "name" : "android::trait_trivial_copy<double>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2811,15 +3019,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<unsigned char>::value"
+     "name" : "android::trait_trivial_copy<double>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
-   "name" : "android::trait_trivial_copy<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
+   "name" : "android::trait_trivial_copy<double>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -2828,13 +3036,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<int>::value"
+     "name" : "android::trait_trivial_copy<float>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
-   "name" : "android::trait_trivial_copy<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
+   "name" : "android::trait_trivial_copy<float>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2845,15 +3053,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<unsigned int>::value"
+     "name" : "android::trait_trivial_copy<float>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
-   "name" : "android::trait_trivial_copy<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
+   "name" : "android::trait_trivial_copy<float>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -2862,13 +3070,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<long>::value"
+     "name" : "android::trait_trivial_copy<unsigned char>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
-   "name" : "android::trait_trivial_copy<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2879,15 +3087,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<unsigned long>::value"
+     "name" : "android::trait_trivial_copy<unsigned char>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
-   "name" : "android::trait_trivial_copy<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -2896,13 +3104,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<short>::value"
+     "name" : "android::trait_trivial_copy<int>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
-   "name" : "android::trait_trivial_copy<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
+   "name" : "android::trait_trivial_copy<int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2913,7 +3121,160 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_copy<unsigned short>::value"
+     "name" : "android::trait_trivial_copy<int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
+   "name" : "android::trait_trivial_copy<int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<unsigned int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<unsigned int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
+   "name" : "android::trait_trivial_copy<long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
+   "name" : "android::trait_trivial_copy<long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<unsigned long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<unsigned long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
+   "name" : "android::trait_trivial_copy<short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
+   "name" : "android::trait_trivial_copy<short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<unsigned short>::value"
     }
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
@@ -2924,6 +3285,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<unsigned short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -2941,6 +3319,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<void>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
+   "name" : "android::trait_trivial_copy<void>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -2958,6 +3353,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxE6$valueE",
+   "name" : "android::trait_trivial_copy<long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -2975,6 +3387,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_copy<unsigned long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyE6$valueE",
+   "name" : "android::trait_trivial_copy<unsigned long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3043,6 +3472,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<bool>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
+   "name" : "android::trait_trivial_ctor<bool>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3060,6 +3506,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<char>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
+   "name" : "android::trait_trivial_ctor<char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3077,6 +3540,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<double>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
+   "name" : "android::trait_trivial_ctor<double>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3094,6 +3574,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<float>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
+   "name" : "android::trait_trivial_ctor<float>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3111,6 +3608,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned char>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3134,15 +3648,117 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<unsigned int>::value"
+     "name" : "android::trait_trivial_ctor<int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
+   "name" : "android::trait_trivial_ctor<int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
+   "name" : "android::trait_trivial_ctor<long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
+   "name" : "android::trait_trivial_ctor<long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned long>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
-   "name" : "android::trait_trivial_ctor<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3151,13 +3767,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<long>::value"
+     "name" : "android::trait_trivial_ctor<short>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
-   "name" : "android::trait_trivial_ctor<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
+   "name" : "android::trait_trivial_ctor<short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3168,15 +3784,15 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<unsigned long>::value"
+     "name" : "android::trait_trivial_ctor<short>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
-   "name" : "android::trait_trivial_ctor<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
+   "name" : "android::trait_trivial_ctor<short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3185,13 +3801,13 @@
    [
     {
      "enum_field_value" : 1,
-     "name" : "android::trait_trivial_ctor<short>::value"
+     "name" : "android::trait_trivial_ctor<unsigned short>::value"
     }
    ],
-   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
-   "name" : "android::trait_trivial_ctor<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3207,10 +3823,10 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3230,6 +3846,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<void>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
+   "name" : "android::trait_trivial_ctor<void>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3247,6 +3880,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
+   "name" : "android::trait_trivial_ctor<long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3264,6 +3914,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_ctor<unsigned long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
+   "name" : "android::trait_trivial_ctor<unsigned long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3332,6 +3999,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<bool>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
+   "name" : "android::trait_trivial_dtor<bool>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3349,6 +4033,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<char>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
+   "name" : "android::trait_trivial_dtor<char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3366,6 +4067,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<double>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
+   "name" : "android::trait_trivial_dtor<double>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3383,6 +4101,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<float>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
+   "name" : "android::trait_trivial_dtor<float>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3400,6 +4135,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<unsigned char>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3417,6 +4169,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
+   "name" : "android::trait_trivial_dtor<int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3434,6 +4203,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<unsigned int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3451,6 +4237,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
+   "name" : "android::trait_trivial_dtor<long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3468,6 +4271,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<unsigned long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3485,6 +4305,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
+   "name" : "android::trait_trivial_dtor<short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3502,6 +4339,40 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<unsigned short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<void>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
+   "name" : "android::trait_trivial_dtor<void>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3513,10 +4384,10 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
    "name" : "android::trait_trivial_dtor<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3536,6 +4407,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
+   "name" : "android::trait_trivial_dtor<long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3553,6 +4441,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_dtor<unsigned long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
+   "name" : "android::trait_trivial_dtor<unsigned long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3621,6 +4526,23 @@
    "source_file" : "system/core/libutils/include/utils/String8.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<android::String8>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE",
+   "name" : "android::trait_trivial_move<android::String8>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3635,7 +4557,7 @@
    "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EE6$valueE",
    "self_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EE6$valueE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String16.h",
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -3655,6 +4577,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<bool>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIbE6$valueE",
+   "name" : "android::trait_trivial_move<bool>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3672,6 +4611,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<char>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcE6$valueE",
+   "name" : "android::trait_trivial_move<char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3689,6 +4645,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<double>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdE6$valueE",
+   "name" : "android::trait_trivial_move<double>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3706,6 +4679,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<float>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfE6$valueE",
+   "name" : "android::trait_trivial_move<float>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3723,6 +4713,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<unsigned char>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhE6$valueE",
+   "name" : "android::trait_trivial_move<unsigned char>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3740,6 +4747,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiE6$valueE",
+   "name" : "android::trait_trivial_move<int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3757,6 +4781,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<unsigned int>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjE6$valueE",
+   "name" : "android::trait_trivial_move<unsigned int>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3774,6 +4815,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlE6$valueE",
+   "name" : "android::trait_trivial_move<long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3791,6 +4849,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<unsigned long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveImE6$valueE",
+   "name" : "android::trait_trivial_move<unsigned long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3808,6 +4883,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsE6$valueE",
+   "name" : "android::trait_trivial_move<short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3825,6 +4917,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<unsigned short>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveItE6$valueE",
+   "name" : "android::trait_trivial_move<unsigned short>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3842,6 +4951,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<void>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvE6$valueE",
+   "name" : "android::trait_trivial_move<void>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3859,6 +4985,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxE6$valueE",
+   "name" : "android::trait_trivial_move<long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -3876,6 +5019,23 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::trait_trivial_move<unsigned long long>::value"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
+   "name" : "android::trait_trivial_move<unsigned long long>::(unnamed)",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -4126,7 +5286,25 @@
    "referenced_type" : "_ZTIN7android7FileMap9MapAdviceE",
    "self_type" : "_ZTIN7android7FileMap9MapAdviceE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/FileMap.h",
+   "source_file" : "system/core/libutils/include/utils/FileMap.h",
+   "underlying_type" : "_ZTIj"
+  },
+  {
+   "access" : "protected",
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 1,
+     "name" : "android::RefBase::FIRST_INC_STRONG"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
+   "name" : "android::RefBase::(unnamed)",
+   "referenced_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
+   "self_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -4141,10 +5319,10 @@
    ],
    "linker_set_key" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
    "name" : "android::RefBase::(unnamed)",
-   "referenced_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
-   "self_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
+   "referenced_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/RefBase.h",
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
    "underlying_type" : "_ZTIj"
   },
   {
@@ -4173,6 +5351,32 @@
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "underlying_type" : "_ZTIj"
   },
+  {
+   "access" : "protected",
+   "alignment" : 4,
+   "enum_fields" :
+   [
+    {
+     "enum_field_value" : 0,
+     "name" : "android::RefBase::OBJECT_LIFETIME_STRONG"
+    },
+    {
+     "enum_field_value" : 1,
+     "name" : "android::RefBase::OBJECT_LIFETIME_WEAK"
+    },
+    {
+     "enum_field_value" : 1,
+     "name" : "android::RefBase::OBJECT_LIFETIME_MASK"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE",
+   "name" : "android::RefBase::(unnamed)",
+   "referenced_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
+   "underlying_type" : "_ZTIj"
+  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -4282,7 +5486,7 @@
    "referenced_type" : "_ZTIFiPKvS0_E",
    "return_type" : "_ZTIi",
    "self_type" : "_ZTIFiPKvS0_E",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -4303,7 +5507,7 @@
    "referenced_type" : "_ZTIFiPKvS0_PvE",
    "return_type" : "_ZTIi",
    "self_type" : "_ZTIFiPKvS0_PvE",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -4459,7 +5663,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::setCapacity",
@@ -4475,7 +5679,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::appendVector",
@@ -4491,7 +5695,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::editArrayImpl",
@@ -4504,7 +5708,7 @@
     }
    ],
    "return_type" : "_ZTIPv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::finish_vector",
@@ -4517,7 +5721,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::insertArrayAt",
@@ -4539,7 +5743,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::removeItemsAt",
@@ -4559,7 +5763,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::insertVectorAt",
@@ -4578,7 +5782,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "access" : "protected",
@@ -4592,7 +5796,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::editItemLocation",
@@ -4608,7 +5812,7 @@
     }
    ],
    "return_type" : "_ZTIPv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::add",
@@ -4624,7 +5828,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::add",
@@ -4637,7 +5841,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::pop",
@@ -4650,7 +5854,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::push",
@@ -4666,7 +5870,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::push",
@@ -4679,7 +5883,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::sort",
@@ -4695,7 +5899,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::sort",
@@ -4714,7 +5918,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "access" : "private",
@@ -4734,7 +5938,7 @@
     }
    ],
    "return_type" : "_ZTIPv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::clear",
@@ -4747,7 +5951,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::resize",
@@ -4763,7 +5967,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "access" : "private",
@@ -4783,7 +5987,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::insertAt",
@@ -4806,7 +6010,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::insertAt",
@@ -4826,7 +6030,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::replaceAt",
@@ -4845,7 +6049,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::replaceAt",
@@ -4861,7 +6065,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::VectorImpl",
@@ -4877,7 +6081,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::VectorImpl",
@@ -4896,7 +6100,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::~VectorImpl",
@@ -4909,7 +6113,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::~VectorImpl",
@@ -4922,7 +6126,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::~VectorImpl",
@@ -4935,7 +6139,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::operator=",
@@ -4951,7 +6155,7 @@
     }
    ],
    "return_type" : "_ZTIRN7android10VectorImplE",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::uptimeNanos",
@@ -5252,7 +6456,7 @@
     }
    ],
    "return_type" : "_ZTINSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE",
-   "source_file" : "system/core/libutils/include/utils/Errors.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Errors.h"
   },
   {
    "function_name" : "android::elapsedRealtime",
@@ -5274,7 +6478,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::merge",
@@ -5290,7 +6494,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::merge",
@@ -5306,7 +6510,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::remove",
@@ -5322,7 +6526,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::SortedVectorImpl",
@@ -5338,7 +6542,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::SortedVectorImpl",
@@ -5357,7 +6561,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::~SortedVectorImpl",
@@ -5370,7 +6574,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::~SortedVectorImpl",
@@ -5383,7 +6587,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::~SortedVectorImpl",
@@ -5396,7 +6600,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::operator=",
@@ -5412,7 +6616,7 @@
     }
    ],
    "return_type" : "_ZTIRN7android16SortedVectorImplE",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::JenkinsHashWhiten",
@@ -5675,6 +6879,64 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/misc.h"
   },
+  {
+   "function_name" : "android::sp<android::LooperCallback>::clear",
+   "linker_set_key" : "_ZN7android2spINS_14LooperCallbackEE5clearEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android2spINS_14LooperCallbackEEE"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
+  },
+  {
+   "function_name" : "android::sp<android::Looper>::operator=",
+   "linker_set_key" : "_ZN7android2spINS_6LooperEEaSEOS2_",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android2spINS_6LooperEEE"
+    },
+    {
+     "referenced_type" : "_ZTION7android2spINS_6LooperEEE"
+    }
+   ],
+   "return_type" : "_ZTIRN7android2spINS_6LooperEEE",
+   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
+  },
+  {
+   "function_name" : "android::sp<android::Thread>::clear",
+   "linker_set_key" : "_ZN7android2spINS_6ThreadEE5clearEv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android2spINS_6ThreadEEE"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
+  },
+  {
+   "function_name" : "android::sp<android::Thread>::operator=",
+   "linker_set_key" : "_ZN7android2spINS_6ThreadEEaSEOS2_",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android2spINS_6ThreadEEE"
+    },
+    {
+     "referenced_type" : "_ZTION7android2spINS_6ThreadEEE"
+    }
+   ],
+   "return_type" : "_ZTIRN7android2spINS_6ThreadEEE",
+   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
+  },
   {
    "function_name" : "android::LightRefBase_reportIncStrongRequireStrongFailed",
    "linker_set_key" : "_ZN7android47LightRefBase_reportIncStrongRequireStrongFailedEPKv",
@@ -5951,6 +7213,22 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
+  {
+   "function_name" : "android::Looper::repoll",
+   "linker_set_key" : "_ZN7android6Looper6repollEi",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android6LooperE"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libutils/include/utils/Looper.h"
+  },
   {
    "function_name" : "android::Looper::pollAll",
    "linker_set_key" : "_ZN7android6Looper7pollAllEiPiS1_PPv",
@@ -6489,11 +7767,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "private",
@@ -6509,7 +7787,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "private",
@@ -6518,7 +7796,7 @@
    "parameters" :
    [
     {
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -6528,7 +7806,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "private",
@@ -6537,7 +7815,7 @@
    "parameters" :
    [
     {
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -6547,7 +7825,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::attemptIncWeak",
@@ -6556,14 +7834,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::attemptIncStrong",
@@ -6572,14 +7850,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::incWeakRequireWeak",
@@ -6588,14 +7866,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::decWeak",
@@ -6604,14 +7882,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::incWeak",
@@ -6620,14 +7898,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::trackMe",
@@ -6636,7 +7914,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIb"
@@ -6646,7 +7924,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6656,14 +7934,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6673,14 +7951,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6690,14 +7968,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIi"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6707,7 +7985,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIj"
@@ -6717,7 +7995,7 @@
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6727,11 +8005,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6741,11 +8019,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6755,11 +8033,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6769,11 +8047,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "protected",
@@ -6783,11 +8061,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::String8::lockBuffer",
@@ -6796,14 +8074,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIj"
     }
    ],
    "return_type" : "_ZTIPc",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "access" : "private",
@@ -6813,7 +8091,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -6823,7 +8101,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::appendFormat",
@@ -6832,14 +8110,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::unlockBuffer",
@@ -6848,14 +8126,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIj"
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::unlockBuffer",
@@ -6864,11 +8142,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::appendFormatV",
@@ -6877,7 +8155,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -6887,7 +8165,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::clear",
@@ -6896,11 +8174,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::setTo",
@@ -6909,7 +8187,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -6919,7 +8197,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::setTo",
@@ -6928,7 +8206,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -6938,7 +8216,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::setTo",
@@ -6947,14 +8225,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::setTo",
@@ -6963,7 +8241,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -6973,7 +8251,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::setTo",
@@ -6982,14 +8260,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::append",
@@ -6998,14 +8276,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::append",
@@ -7014,7 +8292,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -7024,7 +8302,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::append",
@@ -7033,14 +8311,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::format",
@@ -7051,8 +8329,8 @@
      "referenced_type" : "_ZTIPKc"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::formatV",
@@ -7066,8 +8344,8 @@
      "referenced_type" : "_ZTISt9__va_list"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::toLower",
@@ -7076,11 +8354,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::removeAll",
@@ -7089,14 +8367,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7105,14 +8383,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7121,7 +8399,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -7131,7 +8409,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7140,14 +8418,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7156,7 +8434,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -7166,7 +8444,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7175,14 +8453,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7191,7 +8469,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -7201,7 +8479,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7210,14 +8488,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIRKN7android8String16E"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7226,14 +8504,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7242,11 +8520,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7255,14 +8533,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7271,7 +8549,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -7281,7 +8559,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7290,14 +8568,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7306,7 +8584,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -7316,7 +8594,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7325,14 +8603,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7341,7 +8619,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -7351,7 +8629,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7360,14 +8638,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIRKN7android8String16E"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7376,14 +8654,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::String8",
@@ -7392,11 +8670,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::~String8",
@@ -7405,11 +8683,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::~String8",
@@ -7418,11 +8696,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "access" : "private",
@@ -7439,7 +8717,7 @@
     }
    ],
    "return_type" : "_ZTIPv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::replaceAll",
@@ -7458,7 +8736,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -7474,7 +8752,7 @@
     }
    ],
    "return_type" : "_ZTIPDs",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -7490,7 +8768,7 @@
     }
    ],
    "return_type" : "_ZTIPDs",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -7504,7 +8782,7 @@
     }
    ],
    "return_type" : "_ZTIPv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -7517,7 +8795,7 @@
     }
    ],
    "return_type" : "_ZTIPv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::setTo",
@@ -7533,7 +8811,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::setTo",
@@ -7552,7 +8830,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::setTo",
@@ -7568,7 +8846,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::setTo",
@@ -7591,7 +8869,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::append",
@@ -7610,7 +8888,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::append",
@@ -7626,7 +8904,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::insert",
@@ -7645,7 +8923,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::insert",
@@ -7667,7 +8945,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -7681,7 +8959,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -7695,7 +8973,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7711,7 +8989,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7727,7 +9005,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7746,7 +9024,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7762,7 +9040,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7781,7 +9059,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7793,11 +9071,11 @@
      "referenced_type" : "_ZTIPN7android8String16E"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7813,7 +9091,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7836,7 +9114,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7849,7 +9127,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7865,7 +9143,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7881,7 +9159,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7900,7 +9178,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7916,7 +9194,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7935,7 +9213,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7947,11 +9225,11 @@
      "referenced_type" : "_ZTIPN7android8String16E"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7967,7 +9245,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -7990,7 +9268,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::String16",
@@ -8003,7 +9281,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::~String16",
@@ -8016,7 +9294,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::~String16",
@@ -8029,7 +9307,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::operator=",
@@ -8045,7 +9323,7 @@
     }
    ],
    "return_type" : "_ZTIRN7android8String16E",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::FdPrinter::printLine",
@@ -8359,14 +9637,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android10VectorImplE"
+     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIj"
     }
    ],
    "return_type" : "_ZTIPKv",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::VectorImpl::capacity",
@@ -8375,11 +9653,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android10VectorImplE"
+     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIj",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "access" : "protected",
@@ -8389,11 +9667,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android10VectorImplE"
+     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIj",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "access" : "private",
@@ -8414,7 +9692,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::indexOf",
@@ -8430,7 +9708,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::SortedVectorImpl::orderOf",
@@ -8446,7 +9724,7 @@
     }
    ],
    "return_type" : "_ZTIj",
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "function_name" : "android::Looper::getAllowNonCallbacks",
@@ -8930,14 +10208,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
-   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::getWeakRefs",
@@ -8946,11 +10224,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
-   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::getWeakCount",
@@ -8963,7 +10241,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::refBase",
@@ -8975,8 +10253,8 @@
      "referenced_type" : "_ZTIPKN7android7RefBase12weakref_typeE"
     }
    ],
-   "return_type" : "_ZTIPN7android7RefBaseE",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "return_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::weakref_type::printRefs",
@@ -8989,7 +10267,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::forceIncStrong",
@@ -8998,14 +10276,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::getStrongCount",
@@ -9014,11 +10292,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::incStrongRequireStrong",
@@ -9027,14 +10305,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::decStrong",
@@ -9043,14 +10321,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "function_name" : "android::RefBase::incStrong",
@@ -9059,14 +10337,14 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "access" : "private",
@@ -9076,11 +10354,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "access" : "private",
@@ -9090,11 +10368,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::find",
@@ -9103,7 +10381,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -9114,7 +10392,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String8::length",
@@ -9123,11 +10401,11 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIj",
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "function_name" : "android::String16::startsWith",
@@ -9143,7 +10421,7 @@
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::startsWith",
@@ -9159,7 +10437,7 @@
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::isStaticString",
@@ -9172,7 +10450,7 @@
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "access" : "private",
@@ -9186,7 +10464,7 @@
     }
    ],
    "return_type" : "_ZTIj",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::size",
@@ -9199,7 +10477,7 @@
     }
    ],
    "return_type" : "_ZTIj",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::contains",
@@ -9215,7 +10493,7 @@
     }
    ],
    "return_type" : "_ZTIb",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::findLast",
@@ -9231,7 +10509,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::String16::findFirst",
@@ -9247,7 +10525,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "function_name" : "android::StopWatch::elapsedTime",
@@ -9440,7 +10718,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "strlen16",
@@ -9452,7 +10730,7 @@
     }
    ],
    "return_type" : "_ZTIj",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "strncmp16",
@@ -9470,7 +10748,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "strnlen16",
@@ -9485,7 +10763,7 @@
     }
    ],
    "return_type" : "_ZTIj",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "strstr16",
@@ -9500,7 +10778,7 @@
     }
    ],
    "return_type" : "_ZTIPDs",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "strzcmp16",
@@ -9521,7 +10799,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "systemTime",
@@ -9570,7 +10848,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf16_to_utf8_length",
@@ -9585,7 +10863,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf32_from_utf8_at",
@@ -9606,7 +10884,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf32_to_utf8",
@@ -9627,7 +10905,7 @@
     }
    ],
    "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf32_to_utf8_length",
@@ -9642,7 +10920,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf8_to_utf16",
@@ -9663,7 +10941,7 @@
     }
    ],
    "return_type" : "_ZTIPDs",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf8_to_utf16_length",
@@ -9682,7 +10960,7 @@
     }
    ],
    "return_type" : "_ZTIi",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "function_name" : "utf8_to_utf16_no_null_terminator",
@@ -9703,7 +10981,7 @@
     }
    ],
    "return_type" : "_ZTIPDs",
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   }
  ],
  "global_vars" :
@@ -9725,16 +11003,16 @@
    "referenced_type" : "_ZTIA1_KDs",
    "self_type" : "_ZTIRA1_KDs",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIRKN7android10VectorImplE",
    "name" : "const android::VectorImpl &",
-   "referenced_type" : "_ZTIKN7android10VectorImplE",
+   "referenced_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIRKN7android10VectorImplE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -9743,7 +11021,7 @@
    "referenced_type" : "_ZTIKN7android16ReferenceRenamerE",
    "self_type" : "_ZTIRKN7android16ReferenceRenamerE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "alignment" : 4,
@@ -9752,7 +11030,7 @@
    "referenced_type" : "_ZTIKN7android16SortedVectorImplE",
    "self_type" : "_ZTIRKN7android16SortedVectorImplE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -9862,6 +11140,15 @@
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIRKN7android7String8E",
+   "name" : "const android::String8 &",
+   "referenced_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
+  },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIRKN7android8String1610StaticDataILj1EEE",
@@ -9869,7 +11156,7 @@
    "referenced_type" : "_ZTIKN7android8String1610StaticDataILj1EEE",
    "self_type" : "_ZTIRKN7android8String1610StaticDataILj1EEE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -9878,7 +11165,7 @@
    "referenced_type" : "_ZTIKN7android8String16E",
    "self_type" : "_ZTIRKN7android8String16E",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -9983,19 +11270,19 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIRN7android10VectorImplE",
    "name" : "android::VectorImpl &",
-   "referenced_type" : "_ZTIN7android10VectorImplE",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIRN7android10VectorImplE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIRN7android16SortedVectorImplE",
    "name" : "android::SortedVectorImpl &",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIRN7android16SortedVectorImplE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -10105,6 +11392,15 @@
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIRN7android7String8E",
+   "name" : "android::String8 &",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIRN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
+  },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIRN7android8String16E",
@@ -10112,7 +11408,7 @@
    "referenced_type" : "_ZTIN7android8String16E",
    "self_type" : "_ZTIRN7android8String16E",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -10196,7 +11492,7 @@
    "referenced_type" : "_ZTIDs",
    "self_type" : "_ZTIPDs",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -10214,7 +11510,7 @@
    "referenced_type" : "_ZTIFiPKvS0_E",
    "self_type" : "_ZTIPFiPKvS0_E",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -10223,7 +11519,7 @@
    "referenced_type" : "_ZTIFiPKvS0_PvE",
    "self_type" : "_ZTIPFiPKvS0_PvE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -10277,7 +11573,7 @@
    "referenced_type" : "_ZTIKDi",
    "self_type" : "_ZTIPKDi",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "alignment" : 4,
@@ -10286,7 +11582,7 @@
    "referenced_type" : "_ZTIKDs",
    "self_type" : "_ZTIPKDs",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -10297,6 +11593,15 @@
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
   },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPKN7android10VectorImplE",
+   "name" : "const android::VectorImpl *",
+   "referenced_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
+  },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIPKN7android12LightRefBaseINS_12NativeHandleEEE",
@@ -10322,7 +11627,7 @@
    "referenced_type" : "_ZTIKN7android16SortedVectorImplE",
    "self_type" : "_ZTIPKN7android16SortedVectorImplE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -10484,7 +11789,7 @@
    "referenced_type" : "_ZTIKN7android6VectorINS_7String8EEE",
    "self_type" : "_ZTIPKN7android6VectorINS_7String8EEE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Vector.h"
   },
   {
    "alignment" : 4,
@@ -10502,7 +11807,7 @@
    "referenced_type" : "_ZTIKN7android7RefBase12weakref_typeE",
    "self_type" : "_ZTIPKN7android7RefBase12weakref_typeE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "alignment" : 4,
@@ -10513,6 +11818,15 @@
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPKN7android7RefBaseE",
+   "name" : "const android::RefBase *",
+   "referenced_type" : "_ZTIKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIPKN7android7String8E",
@@ -10524,21 +11838,21 @@
   },
   {
    "alignment" : 4,
-   "linker_set_key" : "_ZTIPKN7android8String16E",
-   "name" : "const android::String16 *",
-   "referenced_type" : "_ZTIKN7android8String16E",
-   "self_type" : "_ZTIPKN7android8String16E",
+   "linker_set_key" : "_ZTIPKN7android7String8E",
+   "name" : "const android::String8 *",
+   "referenced_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "alignment" : 4,
-   "linker_set_key" : "_ZTIPKN7android9CallStackE",
-   "name" : "const android::CallStack *",
-   "referenced_type" : "_ZTIKN7android9CallStackE",
-   "self_type" : "_ZTIPKN7android9CallStackE",
+   "linker_set_key" : "_ZTIPKN7android8String16E",
+   "name" : "const android::String16 *",
+   "referenced_type" : "_ZTIKN7android8String16E",
+   "self_type" : "_ZTIPKN7android8String16E",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/CallStack.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -10607,10 +11921,10 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIPN7android10VectorImplE",
    "name" : "android::VectorImpl *",
-   "referenced_type" : "_ZTIN7android10VectorImplE",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIPN7android10VectorImplE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -10673,7 +11987,7 @@
    "referenced_type" : "_ZTIN7android14StaticString16ILj1EEE",
    "self_type" : "_ZTIPN7android14StaticString16ILj1EEE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -10693,14 +12007,23 @@
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPN7android16ReferenceRenamerE",
+   "name" : "android::ReferenceRenamer *",
+   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIPN7android16SortedVectorImplE",
    "name" : "android::SortedVectorImpl *",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIPN7android16SortedVectorImplE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -10720,6 +12043,15 @@
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPN7android19VirtualLightRefBaseE",
+   "name" : "android::VirtualLightRefBase *",
+   "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/LightRefBase.h"
+  },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIPN7android20SimpleLooperCallbackE",
@@ -10943,7 +12275,7 @@
    "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE",
    "self_type" : "_ZTIPN7android6VectorINS_7String8EEE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Vector.h"
   },
   {
    "alignment" : 4,
@@ -10990,6 +12322,15 @@
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPN7android7RefBase12weakref_typeE",
+   "name" : "android::RefBase::weakref_type *",
+   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIPN7android7RefBaseE",
@@ -10999,6 +12340,15 @@
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPN7android7RefBaseE",
+   "name" : "android::RefBase *",
+   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIPN7android7String8E",
@@ -11008,6 +12358,15 @@
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIPN7android7String8E",
+   "name" : "android::String8 *",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
+  },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIPN7android8String1610StaticDataILj1EEE",
@@ -11015,7 +12374,7 @@
    "referenced_type" : "_ZTIN7android8String1610StaticDataILj1EEE",
    "self_type" : "_ZTIPN7android8String1610StaticDataILj1EEE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -11024,25 +12383,7 @@
    "referenced_type" : "_ZTIN7android8String16E",
    "self_type" : "_ZTIPN7android8String16E",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
-  },
-  {
-   "alignment" : 4,
-   "linker_set_key" : "_ZTIPN7android9CallStack12StackDeleterE",
-   "name" : "android::CallStack::StackDeleter *",
-   "referenced_type" : "_ZTIN7android9CallStack12StackDeleterE",
-   "self_type" : "_ZTIPN7android9CallStack12StackDeleterE",
-   "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/CallStack.h"
-  },
-  {
-   "alignment" : 4,
-   "linker_set_key" : "_ZTIPN7android9CallStackE",
-   "name" : "android::CallStack *",
-   "referenced_type" : "_ZTIN7android9CallStackE",
-   "self_type" : "_ZTIPN7android9CallStackE",
-   "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/CallStack.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -11132,7 +12473,7 @@
    "referenced_type" : "_ZTIj",
    "self_type" : "_ZTIPj",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/Unicode.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
   {
    "alignment" : 4,
@@ -11154,7 +12495,7 @@
    "referenced_type" : "_ZTIA1_Ds",
    "self_type" : "_ZTIA1_KDs",
    "size" : 2,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -11184,7 +12525,7 @@
    "referenced_type" : "_ZTIDi",
    "self_type" : "_ZTIKDi",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
    "alignment" : 2,
@@ -11194,7 +12535,17 @@
    "referenced_type" : "_ZTIDs",
    "self_type" : "_ZTIKDs",
    "size" : 2,
-   "source_file" : "system/core/libutils/include/utils/String8.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
+  },
+  {
+   "alignment" : 4,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIKN7android10VectorImplE",
+   "name" : "const android::VectorImpl",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 20,
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -11231,20 +12582,20 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android16ReferenceRenamerE",
    "name" : "const android::ReferenceRenamer",
-   "referenced_type" : "_ZTIN7android16ReferenceRenamerE",
+   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIKN7android16ReferenceRenamerE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "alignment" : 4,
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android16SortedVectorImplE",
    "name" : "const android::SortedVectorImpl",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIKN7android16SortedVectorImplE",
    "size" : 20,
-   "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
    "alignment" : 4,
@@ -11434,7 +12785,7 @@
    "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE",
    "self_type" : "_ZTIKN7android6VectorINS_7String8EEE",
    "size" : 20,
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
+   "source_file" : "system/core/libutils/binder/include/utils/Vector.h"
   },
   {
    "alignment" : 8,
@@ -11461,10 +12812,20 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android7RefBase12weakref_typeE",
    "name" : "const android::RefBase::weakref_type",
-   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE",
+   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "self_type" : "_ZTIKN7android7RefBase12weakref_typeE",
    "size" : 1,
-   "source_file" : "system/core/libutils/include/utils/RefBase.h"
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
+  {
+   "alignment" : 4,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIKN7android7RefBaseE",
+   "name" : "const android::RefBase",
+   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
    "alignment" : 4,
@@ -11476,6 +12837,16 @@
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 4,
+   "is_const" : true,
+   "linker_set_key" : "_ZTIKN7android7String8E",
+   "name" : "const android::String8",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
+  },
   {
    "alignment" : 4,
    "is_const" : true,
@@ -11494,7 +12865,7 @@
    "referenced_type" : "_ZTIN7android8String1610StaticDataILj1EEE",
    "self_type" : "_ZTIKN7android8String1610StaticDataILj1EEE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -11504,17 +12875,7 @@
    "referenced_type" : "_ZTIN7android8String16E",
    "self_type" : "_ZTIKN7android8String16E",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String8.h"
-  },
-  {
-   "alignment" : 4,
-   "is_const" : true,
-   "linker_set_key" : "_ZTIKN7android9CallStackE",
-   "name" : "const android::CallStack",
-   "referenced_type" : "_ZTIN7android9CallStackE",
-   "self_type" : "_ZTIKN7android9CallStackE",
-   "size" : 20,
-   "source_file" : "system/core/libutils/include/utils/CallStack.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 8,
@@ -12239,6 +13600,85 @@
     }
    ]
   },
+  {
+   "alignment" : 4,
+   "fields" :
+   [
+    {
+     "access" : "private",
+     "field_name" : "mStorage",
+     "field_offset" : 32,
+     "referenced_type" : "_ZTIPv"
+    },
+    {
+     "access" : "private",
+     "field_name" : "mCount",
+     "field_offset" : 64,
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "access" : "private",
+     "field_name" : "mFlags",
+     "field_offset" : 96,
+     "referenced_type" : "_ZTIKj"
+    },
+    {
+     "access" : "private",
+     "field_name" : "mItemSize",
+     "field_offset" : 128,
+     "referenced_type" : "_ZTIKj"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android10VectorImplE",
+   "name" : "android::VectorImpl",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 20,
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h",
+   "vtable_components" :
+   [
+    {
+     "kind" : "offset_to_top"
+    },
+    {
+     "kind" : "rtti",
+     "mangled_component_name" : "_ZTIN7android10VectorImplE"
+    },
+    {
+     "kind" : "complete_dtor_pointer",
+     "mangled_component_name" : "_ZN7android10VectorImplD1Ev"
+    },
+    {
+     "kind" : "deleting_dtor_pointer",
+     "mangled_component_name" : "_ZN7android10VectorImplD0Ev"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl12do_constructEPvj"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl10do_destroyEPvj"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl7do_copyEPvPKvj"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl8do_splatEPvPKvj"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl15do_move_forwardEPvPKvj"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl16do_move_backwardEPvPKvj"
+    }
+   ]
+  },
   {
    "alignment" : 8,
    "fields" :
@@ -12301,6 +13741,28 @@
     "_ZTIN7android19VirtualLightRefBaseE"
    ]
   },
+  {
+   "alignment" : 4,
+   "fields" :
+   [
+    {
+     "access" : "private",
+     "field_name" : "mCount",
+     "referenced_type" : "_ZTINSt3__16atomicIiEE"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE",
+   "name" : "android::LightRefBase<android::VirtualLightRefBase>",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/LightRefBase.h",
+   "template_args" :
+   [
+    "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+   ]
+  },
   {
    "alignment" : 4,
    "base_specifiers" :
@@ -12610,6 +14072,16 @@
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android14ReferenceMoverE",
+   "name" : "android::ReferenceMover",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android14ReferenceMoverE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android14ReferenceMoverE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
   {
    "alignment" : 4,
    "base_specifiers" :
@@ -12633,7 +14105,7 @@
    "referenced_type" : "_ZTIN7android14StaticString16ILj1EEE",
    "self_type" : "_ZTIN7android14StaticString16ILj1EEE",
    "size" : 12,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -12678,15 +14150,39 @@
      "mangled_component_name" : "_ZN7android14String8Printer9printLineEPKc"
     },
     {
-     "mangled_component_name" : "_ZN7android7Printer15printFormatLineEPKcz"
+     "mangled_component_name" : "_ZN7android7Printer15printFormatLineEPKcz"
+    },
+    {
+     "kind" : "complete_dtor_pointer",
+     "mangled_component_name" : "_ZN7android14String8PrinterD1Ev"
+    },
+    {
+     "kind" : "deleting_dtor_pointer",
+     "mangled_component_name" : "_ZN7android14String8PrinterD0Ev"
+    }
+   ]
+  },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIN7android16ReferenceRenamerE",
+   "name" : "android::ReferenceRenamer",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android16ReferenceRenamerE",
+   "self_type" : "_ZTIN7android16ReferenceRenamerE",
+   "size" : 4,
+   "source_file" : "system/core/libutils/include/utils/RefBase.h",
+   "vtable_components" :
+   [
+    {
+     "kind" : "offset_to_top"
     },
     {
-     "kind" : "complete_dtor_pointer",
-     "mangled_component_name" : "_ZN7android14String8PrinterD1Ev"
+     "kind" : "rtti",
+     "mangled_component_name" : "_ZTIN7android16ReferenceRenamerE"
     },
     {
-     "kind" : "deleting_dtor_pointer",
-     "mangled_component_name" : "_ZN7android14String8PrinterD0Ev"
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android16ReferenceRenamerclEj"
     }
    ]
   },
@@ -12695,10 +14191,10 @@
    "linker_set_key" : "_ZTIN7android16ReferenceRenamerE",
    "name" : "android::ReferenceRenamer",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android16ReferenceRenamerE",
-   "self_type" : "_ZTIN7android16ReferenceRenamerE",
+   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/RefBase.h",
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
    "vtable_components" :
    [
     {
@@ -12776,6 +14272,68 @@
     }
    ]
   },
+  {
+   "alignment" : 4,
+   "base_specifiers" :
+   [
+    {
+     "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android16SortedVectorImplE",
+   "name" : "android::SortedVectorImpl",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 20,
+   "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h",
+   "vtable_components" :
+   [
+    {
+     "kind" : "offset_to_top"
+    },
+    {
+     "kind" : "rtti",
+     "mangled_component_name" : "_ZTIN7android16SortedVectorImplE"
+    },
+    {
+     "kind" : "complete_dtor_pointer",
+     "mangled_component_name" : "_ZN7android16SortedVectorImplD1Ev"
+    },
+    {
+     "kind" : "deleting_dtor_pointer",
+     "mangled_component_name" : "_ZN7android16SortedVectorImplD0Ev"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl12do_constructEPvj"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl10do_destroyEPvj"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl7do_copyEPvPKvj"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl8do_splatEPvPKvj"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl15do_move_forwardEPvPKvj"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android10VectorImpl16do_move_backwardEPvPKvj"
+    },
+    {
+     "is_pure" : true,
+     "mangled_component_name" : "_ZNK7android16SortedVectorImpl10do_compareEPKvS2_"
+    }
+   ]
+  },
   {
    "alignment" : 1,
    "base_specifiers" :
@@ -12979,6 +14537,19 @@
     "_ZTIb"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIbEE",
+   "name" : "android::trait_trivial_copy<bool>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIb"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcEE",
@@ -12992,6 +14563,19 @@
     "_ZTIc"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcEE",
+   "name" : "android::trait_trivial_copy<char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIc"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdEE",
@@ -13005,6 +14589,19 @@
     "_ZTId"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdEE",
+   "name" : "android::trait_trivial_copy<double>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTId"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfEE",
@@ -13018,6 +14615,19 @@
     "_ZTIf"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfEE",
+   "name" : "android::trait_trivial_copy<float>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIf"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhEE",
@@ -13031,6 +14641,19 @@
     "_ZTIh"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhEE",
+   "name" : "android::trait_trivial_copy<unsigned char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIh"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiEE",
@@ -13044,6 +14667,19 @@
     "_ZTIi"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiEE",
+   "name" : "android::trait_trivial_copy<int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIi"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjEE",
@@ -13057,6 +14693,19 @@
     "_ZTIj"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjEE",
+   "name" : "android::trait_trivial_copy<unsigned int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIj"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlEE",
@@ -13070,6 +14719,19 @@
     "_ZTIl"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlEE",
+   "name" : "android::trait_trivial_copy<long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIl"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyImEE",
@@ -13083,6 +14745,19 @@
     "_ZTIm"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyImEE",
+   "name" : "android::trait_trivial_copy<unsigned long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIm"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsEE",
@@ -13096,6 +14771,19 @@
     "_ZTIs"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsEE",
+   "name" : "android::trait_trivial_copy<short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIs"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyItEE",
@@ -13109,6 +14797,19 @@
     "_ZTIt"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyItEE",
+   "name" : "android::trait_trivial_copy<unsigned short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIt"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvEE",
@@ -13122,6 +14823,19 @@
     "_ZTIv"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvEE",
+   "name" : "android::trait_trivial_copy<void>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIv"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxEE",
@@ -13135,6 +14849,19 @@
     "_ZTIx"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxEE",
+   "name" : "android::trait_trivial_copy<long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIx"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyEE",
@@ -13148,6 +14875,19 @@
     "_ZTIy"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyEE",
+   "name" : "android::trait_trivial_copy<unsigned long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_copyIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIy"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEEE",
@@ -13200,6 +14940,19 @@
     "_ZTIb"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbEE",
+   "name" : "android::trait_trivial_ctor<bool>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIb"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcEE",
@@ -13213,6 +14966,19 @@
     "_ZTIc"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcEE",
+   "name" : "android::trait_trivial_ctor<char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIc"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdEE",
@@ -13223,17 +14989,43 @@
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
    [
-    "_ZTId"
+    "_ZTId"
+   ]
+  },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdEE",
+   "name" : "android::trait_trivial_ctor<double>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTId"
+   ]
+  },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfEE",
+   "name" : "android::trait_trivial_ctor<float>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfEE",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIfEE",
+   "size" : 1,
+   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIf"
    ]
   },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfEE",
    "name" : "android::trait_trivial_ctor<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIfEE",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
-   "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
    [
     "_ZTIf"
@@ -13252,6 +15044,19 @@
     "_ZTIh"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhEE",
+   "name" : "android::trait_trivial_ctor<unsigned char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIh"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiEE",
@@ -13265,6 +15070,19 @@
     "_ZTIi"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiEE",
+   "name" : "android::trait_trivial_ctor<int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIi"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjEE",
@@ -13278,6 +15096,19 @@
     "_ZTIj"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjEE",
+   "name" : "android::trait_trivial_ctor<unsigned int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIj"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlEE",
@@ -13291,6 +15122,19 @@
     "_ZTIl"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlEE",
+   "name" : "android::trait_trivial_ctor<long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIl"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImEE",
@@ -13304,6 +15148,19 @@
     "_ZTIm"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImEE",
+   "name" : "android::trait_trivial_ctor<unsigned long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIm"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsEE",
@@ -13317,6 +15174,19 @@
     "_ZTIs"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsEE",
+   "name" : "android::trait_trivial_ctor<short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIs"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItEE",
@@ -13330,6 +15200,19 @@
     "_ZTIt"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItEE",
+   "name" : "android::trait_trivial_ctor<unsigned short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIt"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvEE",
@@ -13343,6 +15226,19 @@
     "_ZTIv"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvEE",
+   "name" : "android::trait_trivial_ctor<void>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIv"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxEE",
@@ -13356,6 +15252,19 @@
     "_ZTIx"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxEE",
+   "name" : "android::trait_trivial_ctor<long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIx"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyEE",
@@ -13369,6 +15278,19 @@
     "_ZTIy"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyEE",
+   "name" : "android::trait_trivial_ctor<unsigned long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIy"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEEE",
@@ -13421,6 +15343,19 @@
     "_ZTIb"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbEE",
+   "name" : "android::trait_trivial_dtor<bool>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIb"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcEE",
@@ -13434,6 +15369,19 @@
     "_ZTIc"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcEE",
+   "name" : "android::trait_trivial_dtor<char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIc"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdEE",
@@ -13447,6 +15395,19 @@
     "_ZTId"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdEE",
+   "name" : "android::trait_trivial_dtor<double>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTId"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfEE",
@@ -13460,6 +15421,19 @@
     "_ZTIf"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfEE",
+   "name" : "android::trait_trivial_dtor<float>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIf"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhEE",
@@ -13473,6 +15447,19 @@
     "_ZTIh"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhEE",
+   "name" : "android::trait_trivial_dtor<unsigned char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIh"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiEE",
@@ -13486,6 +15473,19 @@
     "_ZTIi"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiEE",
+   "name" : "android::trait_trivial_dtor<int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIi"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjEE",
@@ -13499,6 +15499,19 @@
     "_ZTIj"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjEE",
+   "name" : "android::trait_trivial_dtor<unsigned int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIj"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlEE",
@@ -13512,6 +15525,19 @@
     "_ZTIl"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlEE",
+   "name" : "android::trait_trivial_dtor<long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIl"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImEE",
@@ -13525,6 +15551,19 @@
     "_ZTIm"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImEE",
+   "name" : "android::trait_trivial_dtor<unsigned long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIm"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsEE",
@@ -13538,6 +15577,19 @@
     "_ZTIs"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsEE",
+   "name" : "android::trait_trivial_dtor<short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIs"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItEE",
@@ -13551,6 +15603,19 @@
     "_ZTIt"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItEE",
+   "name" : "android::trait_trivial_dtor<unsigned short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIt"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvEE",
@@ -13564,6 +15629,19 @@
     "_ZTIv"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvEE",
+   "name" : "android::trait_trivial_dtor<void>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIv"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxEE",
@@ -13577,6 +15655,19 @@
     "_ZTIx"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxEE",
+   "name" : "android::trait_trivial_dtor<long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIx"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyEE",
@@ -13590,6 +15681,19 @@
     "_ZTIy"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyEE",
+   "name" : "android::trait_trivial_dtor<unsigned long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIy"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEEE",
@@ -13642,6 +15746,19 @@
     "_ZTIN7android7String8E"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE",
+   "name" : "android::trait_trivial_move<android::String8>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h",
+   "template_args" :
+   [
+    "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_8String16EEE",
@@ -13649,7 +15766,7 @@
    "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EEE",
    "self_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EEE",
    "size" : 1,
-   "source_file" : "system/core/libutils/include/utils/String16.h",
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h",
    "template_args" :
    [
     "_ZTIN7android8String16E"
@@ -13668,6 +15785,19 @@
     "_ZTIb"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIbEE",
+   "name" : "android::trait_trivial_move<bool>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIb"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcEE",
@@ -13681,6 +15811,19 @@
     "_ZTIc"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcEE",
+   "name" : "android::trait_trivial_move<char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIc"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdEE",
@@ -13694,6 +15837,19 @@
     "_ZTId"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdEE",
+   "name" : "android::trait_trivial_move<double>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTId"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfEE",
@@ -13707,6 +15863,19 @@
     "_ZTIf"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfEE",
+   "name" : "android::trait_trivial_move<float>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIf"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhEE",
@@ -13720,6 +15889,19 @@
     "_ZTIh"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhEE",
+   "name" : "android::trait_trivial_move<unsigned char>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIh"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiEE",
@@ -13733,6 +15915,19 @@
     "_ZTIi"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiEE",
+   "name" : "android::trait_trivial_move<int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIi"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjEE",
@@ -13746,6 +15941,19 @@
     "_ZTIj"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjEE",
+   "name" : "android::trait_trivial_move<unsigned int>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIj"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlEE",
@@ -13759,6 +15967,19 @@
     "_ZTIl"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlEE",
+   "name" : "android::trait_trivial_move<long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIl"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveImEE",
@@ -13772,6 +15993,19 @@
     "_ZTIm"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveImEE",
+   "name" : "android::trait_trivial_move<unsigned long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIm"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsEE",
@@ -13785,6 +16019,19 @@
     "_ZTIs"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsEE",
+   "name" : "android::trait_trivial_move<short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIs"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveItEE",
@@ -13798,6 +16045,19 @@
     "_ZTIt"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveItEE",
+   "name" : "android::trait_trivial_move<unsigned short>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIt"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvEE",
@@ -13811,6 +16071,19 @@
     "_ZTIv"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvEE",
+   "name" : "android::trait_trivial_move<void>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIv"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxEE",
@@ -13824,6 +16097,19 @@
     "_ZTIx"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxEE",
+   "name" : "android::trait_trivial_move<long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIx"
+   ]
+  },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyEE",
@@ -13837,6 +16123,19 @@
     "_ZTIy"
    ]
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyEE",
+   "name" : "android::trait_trivial_move<unsigned long long>",
+   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
+   "template_args" :
+   [
+    "_ZTIy"
+   ]
+  },
   {
    "alignment" : 4,
    "base_specifiers" :
@@ -13871,6 +16170,40 @@
     }
    ]
   },
+  {
+   "alignment" : 4,
+   "base_specifiers" :
+   [
+    {
+     "referenced_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android19VirtualLightRefBaseE",
+   "name" : "android::VirtualLightRefBase",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/LightRefBase.h",
+   "vtable_components" :
+   [
+    {
+     "kind" : "offset_to_top"
+    },
+    {
+     "kind" : "rtti",
+     "mangled_component_name" : "_ZTIN7android19VirtualLightRefBaseE"
+    },
+    {
+     "kind" : "complete_dtor_pointer",
+     "mangled_component_name" : "_ZN7android19VirtualLightRefBaseD1Ev"
+    },
+    {
+     "kind" : "deleting_dtor_pointer",
+     "mangled_component_name" : "_ZN7android19VirtualLightRefBaseD0Ev"
+    }
+   ]
+  },
   {
    "alignment" : 4,
    "base_specifiers" :
@@ -14845,7 +17178,7 @@
    [
     {
      "access" : "private",
-     "referenced_type" : "_ZTIN7android10VectorImplE"
+     "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "linker_set_key" : "_ZTIN7android6VectorINS_7String8EEE",
@@ -14854,10 +17187,10 @@
    "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE",
    "self_type" : "_ZTIN7android6VectorINS_7String8EEE",
    "size" : 20,
-   "source_file" : "system/core/libutils/include/utils/Vector.h",
+   "source_file" : "system/core/libutils/binder/include/utils/Vector.h",
    "template_args" :
    [
-    "_ZTIN7android7String8E"
+    "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
    ],
    "vtable_components" :
    [
@@ -15044,6 +17377,16 @@
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
+  {
+   "alignment" : 1,
+   "linker_set_key" : "_ZTIN7android7RefBase12weakref_typeE",
+   "name" : "android::RefBase::weakref_type",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 1,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
+  },
   {
    "alignment" : 4,
    "fields" :
@@ -15093,6 +17436,55 @@
     }
    ]
   },
+  {
+   "alignment" : 4,
+   "fields" :
+   [
+    {
+     "access" : "private",
+     "field_name" : "mRefs",
+     "field_offset" : 32,
+     "referenced_type" : "_ZTIKPN7android7RefBase12weakref_implE"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android7RefBaseE",
+   "name" : "android::RefBase",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 8,
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
+   "vtable_components" :
+   [
+    {
+     "kind" : "offset_to_top"
+    },
+    {
+     "kind" : "rtti",
+     "mangled_component_name" : "_ZTIN7android7RefBaseE"
+    },
+    {
+     "kind" : "complete_dtor_pointer",
+     "mangled_component_name" : "_ZN7android7RefBaseD1Ev"
+    },
+    {
+     "kind" : "deleting_dtor_pointer",
+     "mangled_component_name" : "_ZN7android7RefBaseD0Ev"
+    },
+    {
+     "mangled_component_name" : "_ZN7android7RefBase10onFirstRefEv"
+    },
+    {
+     "mangled_component_name" : "_ZN7android7RefBase15onLastStrongRefEPKv"
+    },
+    {
+     "mangled_component_name" : "_ZN7android7RefBase20onIncStrongAttemptedEjPKv"
+    },
+    {
+     "mangled_component_name" : "_ZN7android7RefBase13onLastWeakRefEPKv"
+    }
+   ]
+  },
   {
    "alignment" : 4,
    "fields" :
@@ -15111,6 +17503,24 @@
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
+  {
+   "alignment" : 4,
+   "fields" :
+   [
+    {
+     "access" : "private",
+     "field_name" : "mString",
+     "referenced_type" : "_ZTIPKc"
+    }
+   ],
+   "linker_set_key" : "_ZTIN7android7String8E",
+   "name" : "android::String8",
+   "record_kind" : "class",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "size" : 4,
+   "source_file" : "system/core/libutils/binder/include/utils/String8.h"
+  },
   {
    "alignment" : 4,
    "fields" :
@@ -15130,7 +17540,7 @@
    "referenced_type" : "_ZTIN7android8String1610StaticDataILj1EEE",
    "self_type" : "_ZTIN7android8String1610StaticDataILj1EEE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -15148,34 +17558,7 @@
    "referenced_type" : "_ZTIN7android8String16E",
    "self_type" : "_ZTIN7android8String16E",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
-  },
-  {
-   "alignment" : 1,
-   "linker_set_key" : "_ZTIN7android9CallStack12StackDeleterE",
-   "name" : "android::CallStack::StackDeleter",
-   "referenced_type" : "_ZTIN7android9CallStack12StackDeleterE",
-   "self_type" : "_ZTIN7android9CallStack12StackDeleterE",
-   "size" : 1,
-   "source_file" : "system/core/libutils/include/utils/CallStack.h"
-  },
-  {
-   "alignment" : 4,
-   "fields" :
-   [
-    {
-     "access" : "private",
-     "field_name" : "mFrameLines",
-     "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE"
-    }
-   ],
-   "linker_set_key" : "_ZTIN7android9CallStackE",
-   "name" : "android::CallStack",
-   "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android9CallStackE",
-   "self_type" : "_ZTIN7android9CallStackE",
-   "size" : 20,
-   "source_file" : "system/core/libutils/include/utils/CallStack.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
   {
    "alignment" : 4,
@@ -15441,7 +17824,7 @@
    "referenced_type" : "_ZTIN7android8String16E",
    "self_type" : "_ZTION7android8String16E",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/String16.h"
+   "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   }
  ]
 }
diff --git a/libutils/include/utils/Looper.h b/libutils/include/utils/Looper.h
index b387d68c6152..41c5536f4d33 100644
--- a/libutils/include/utils/Looper.h
+++ b/libutils/include/utils/Looper.h
@@ -344,6 +344,18 @@ class Looper : public RefBase {
      */
     int removeFd(int fd);
 
+    /**
+     * Tell the kernel to check for the same events we're already checking for
+     * with this FD. This is to be used when there is a kernel driver bug where
+     * the kernel does not properly mark itself as having new data available, in
+     * order to force "fd_op->poll()" to be called. You probably don't want to
+     * use this in general, and you shouldn't use it unless there is a plan to
+     * fix the kernel. See also b/296817256.
+     *
+     * Returns 1 if successfully repolled, 0 if not.
+     */
+    int repoll(int fd);
+
     /**
      * Enqueues a message to be processed by the specified handler.
      *

From 7e5925ef02309f85ece04087cf6f7d6048efeee2 Mon Sep 17 00:00:00 2001
From: Edward Liaw <edliaw@google.com>
Date: Wed, 1 Feb 2023 03:01:23 +0000
Subject: [PATCH 0680/1487] sched_policy_test: set_sched_policy also set the
 cpuset policy as fallback

get_sched_policy uses the cpuset policy as fallback if the cpu cgroup
is not recognized.  Pixel is currently not using the cpu cgroup for
background policy due to b/208895940.

Bug: 265852986
Bug: 287704782
Test: atest libcutils_test:libcutils_test.SchedPolicy#set_sched_policy -- --abi arm64-v8a
Signed-off-by: Edward Liaw <edliaw@google.com>
(cherry picked from https://android-review.googlesource.com/q/commit:d5ffbdfc56a7c2510a3f1bdca9fd714f30a19434)
Merged-In: Ia77ace7513c48b1a14290c6ecc0222b46d6bf927
Change-Id: Ia77ace7513c48b1a14290c6ecc0222b46d6bf927
---
 libcutils/sched_policy_test.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libcutils/sched_policy_test.cpp b/libcutils/sched_policy_test.cpp
index b9e28321b02b..50bd6d0b8794 100644
--- a/libcutils/sched_policy_test.cpp
+++ b/libcutils/sched_policy_test.cpp
@@ -75,9 +75,11 @@ TEST(SchedPolicy, set_sched_policy) {
     }
 
     ASSERT_EQ(0, set_sched_policy(0, SP_BACKGROUND));
+    ASSERT_EQ(0, set_cpuset_policy(0, SP_BACKGROUND));
     AssertPolicy(SP_BACKGROUND);
 
     ASSERT_EQ(0, set_sched_policy(0, SP_FOREGROUND));
+    ASSERT_EQ(0, set_cpuset_policy(0, SP_FOREGROUND));
     AssertPolicy(SP_FOREGROUND);
 }
 

From 78eca9b78c93d16a1e3b034a479a22818bf18f85 Mon Sep 17 00:00:00 2001
From: Edward Liaw <edliaw@google.com>
Date: Wed, 1 Feb 2023 03:01:23 +0000
Subject: [PATCH 0681/1487] sched_policy_test: set_sched_policy also set the
 cpuset policy as fallback

get_sched_policy uses the cpuset policy as fallback if the cpu cgroup
is not recognized.  Pixel is currently not using the cpu cgroup for
background policy due to b/208895940.

Bug: 265852986
Bug: 287704782
Test: atest libcutils_test:libcutils_test.SchedPolicy#set_sched_policy -- --abi arm64-v8a
Signed-off-by: Edward Liaw <edliaw@google.com>
(cherry picked from https://android-review.googlesource.com/q/commit:d5ffbdfc56a7c2510a3f1bdca9fd714f30a19434)
Merged-In: Ia77ace7513c48b1a14290c6ecc0222b46d6bf927
Change-Id: Ia77ace7513c48b1a14290c6ecc0222b46d6bf927
---
 libcutils/sched_policy_test.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libcutils/sched_policy_test.cpp b/libcutils/sched_policy_test.cpp
index b9e28321b02b..50bd6d0b8794 100644
--- a/libcutils/sched_policy_test.cpp
+++ b/libcutils/sched_policy_test.cpp
@@ -75,9 +75,11 @@ TEST(SchedPolicy, set_sched_policy) {
     }
 
     ASSERT_EQ(0, set_sched_policy(0, SP_BACKGROUND));
+    ASSERT_EQ(0, set_cpuset_policy(0, SP_BACKGROUND));
     AssertPolicy(SP_BACKGROUND);
 
     ASSERT_EQ(0, set_sched_policy(0, SP_FOREGROUND));
+    ASSERT_EQ(0, set_cpuset_policy(0, SP_FOREGROUND));
     AssertPolicy(SP_FOREGROUND);
 }
 

From a757eb856e254147d481a0ce4d68065acbb33de2 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Wed, 24 Jan 2024 22:45:26 +0000
Subject: [PATCH 0682/1487] libprocessgroup: Use uid_t consistently for UIDs

Found with -Wsign-conversion.

Test: m
Change-Id: I302ce3c2ffdd533fe45e98c5c7edbb442db46ae4
---
 libprocessgroup/include/processgroup/processgroup.h | 2 +-
 libprocessgroup/processgroup.cpp                    | 2 +-
 libprocessgroup/task_profiles.cpp                   | 2 +-
 libprocessgroup/task_profiles.h                     | 4 ++--
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index ca6868c1b640..8f4c764e7746 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -95,7 +95,7 @@ bool getAttributePathForTask(const std::string& attr_name, int tid, std::string*
 
 // Check if a profile can be applied without failing.
 // Returns true if it can be applied without failing, false otherwise
-bool isProfileValidForProcess(const std::string& profile_name, int uid, int pid);
+bool isProfileValidForProcess(const std::string& profile_name, uid_t uid, int pid);
 
 #endif // __ANDROID_VNDK__
 
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 3209adf16acd..42d415a495b3 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -747,7 +747,7 @@ bool getAttributePathForTask(const std::string& attr_name, int tid, std::string*
     return CgroupGetAttributePathForTask(attr_name, tid, path);
 }
 
-bool isProfileValidForProcess(const std::string& profile_name, int uid, int pid) {
+bool isProfileValidForProcess(const std::string& profile_name, uid_t uid, int pid) {
     const TaskProfile* tp = TaskProfiles::GetInstance().GetProfile(profile_name);
 
     if (tp == nullptr) {
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index d5bd47cb2a6a..eaafa5eb66f7 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -489,7 +489,7 @@ WriteFileAction::WriteFileAction(const std::string& task_path, const std::string
 }
 
 bool WriteFileAction::WriteValueToFile(const std::string& value_, ResourceCacheType cache_type,
-                                       int uid, int pid, bool logfailures) const {
+                                       uid_t uid, int pid, bool logfailures) const {
     std::string value(value_);
 
     value = StringReplace(value, "<uid>", std::to_string(uid), true);
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index 16ffe6350a3f..25e3a02efb09 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -184,8 +184,8 @@ class WriteFileAction : public ProfileAction {
     android::base::unique_fd fd_[ProfileAction::RCT_COUNT];
     mutable std::mutex fd_mutex_;
 
-    bool WriteValueToFile(const std::string& value, ResourceCacheType cache_type, int uid, int pid,
-                          bool logfailures) const;
+    bool WriteValueToFile(const std::string& value, ResourceCacheType cache_type, uid_t uid,
+                          int pid, bool logfailures) const;
     CacheUseResult UseCachedFd(ResourceCacheType cache_type, const std::string& value) const;
 };
 

From d6fb2259f6bdd34b1bc18f92501368f8b86e2b18 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Wed, 24 Jan 2024 23:42:39 +0000
Subject: [PATCH 0683/1487] libprocessgroup: Use pid_t consistently for PIDs

Test: m
Change-Id: Ibcef6b73a8fd3088c88b822a6b33d005595488b2
---
 .../include/processgroup/processgroup.h       | 16 ++++++-------
 libprocessgroup/processgroup.cpp              | 24 +++++++++----------
 libprocessgroup/task_profiles.cpp             |  4 ++--
 libprocessgroup/task_profiles.h               |  2 +-
 4 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 8f4c764e7746..c20586d41a46 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -67,25 +67,25 @@ void DropTaskProfilesResourceCaching();
 
 // Return 0 if all processes were killed and the cgroup was successfully removed.
 // Returns -1 in the case of an error occurring or if there are processes still running.
-int killProcessGroup(uid_t uid, int initialPid, int signal);
+int killProcessGroup(uid_t uid, pid_t initialPid, int signal);
 
 // Returns the same as killProcessGroup(), however it does not retry, which means
 // that it only returns 0 in the case that the cgroup exists and it contains no processes.
-int killProcessGroupOnce(uid_t uid, int initialPid, int signal);
+int killProcessGroupOnce(uid_t uid, pid_t initialPid, int signal);
 
 // Sends the provided signal to all members of a process group, but does not wait for processes to
 // exit, or for the cgroup to be removed. Callers should also ensure that killProcessGroup is called
 // later to ensure the cgroup is fully removed, otherwise system resources will leak.
 // Returns true if no errors are encountered sending signals, otherwise false.
-bool sendSignalToProcessGroup(uid_t uid, int initialPid, int signal);
+bool sendSignalToProcessGroup(uid_t uid, pid_t initialPid, int signal);
 
-int createProcessGroup(uid_t uid, int initialPid, bool memControl = false);
+int createProcessGroup(uid_t uid, pid_t initialPid, bool memControl = false);
 
 // Set various properties of a process group. For these functions to work, the process group must
 // have been created by passing memControl=true to createProcessGroup.
-bool setProcessGroupSwappiness(uid_t uid, int initialPid, int swappiness);
-bool setProcessGroupSoftLimit(uid_t uid, int initialPid, int64_t softLimitInBytes);
-bool setProcessGroupLimit(uid_t uid, int initialPid, int64_t limitInBytes);
+bool setProcessGroupSwappiness(uid_t uid, pid_t initialPid, int swappiness);
+bool setProcessGroupSoftLimit(uid_t uid, pid_t initialPid, int64_t softLimitInBytes);
+bool setProcessGroupLimit(uid_t uid, pid_t initialPid, int64_t limitInBytes);
 
 void removeAllEmptyProcessGroups(void);
 
@@ -95,7 +95,7 @@ bool getAttributePathForTask(const std::string& attr_name, int tid, std::string*
 
 // Check if a profile can be applied without failing.
 // Returns true if it can be applied without failing, false otherwise
-bool isProfileValidForProcess(const std::string& profile_name, uid_t uid, int pid);
+bool isProfileValidForProcess(const std::string& profile_name, uid_t uid, pid_t pid);
 
 #endif // __ANDROID_VNDK__
 
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 42d415a495b3..facfb5e8c8ce 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -82,7 +82,7 @@ static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
     return StringPrintf("%s/uid_%u", cgroup, uid);
 }
 
-static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, int pid) {
+static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, pid_t pid) {
     return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
 }
 
@@ -232,7 +232,7 @@ bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles) {
                                                        false);
 }
 
-static int RemoveCgroup(const char* cgroup, uid_t uid, int pid) {
+static int RemoveCgroup(const char* cgroup, uid_t uid, pid_t pid) {
     auto path = ConvertUidPidToPath(cgroup, uid, pid);
     int ret = TEMP_FAILURE_RETRY(rmdir(path.c_str()));
 
@@ -370,7 +370,7 @@ static bool MkdirAndChown(const std::string& path, mode_t mode, uid_t uid, gid_t
     return false;
 }
 
-bool sendSignalToProcessGroup(uid_t uid, int initialPid, int signal) {
+bool sendSignalToProcessGroup(uid_t uid, pid_t initialPid, int signal) {
     std::set<pid_t> pgids, pids;
 
     if (CgroupsAvailable()) {
@@ -525,7 +525,7 @@ static populated_status cgroupIsPopulated(int events_fd) {
 // implementation of this function. The default retry value was 40 for killing and 400 for cgroup
 // removal with 5ms sleeps between each retry.
 static int KillProcessGroup(
-        uid_t uid, int initialPid, int signal, bool once = false,
+        uid_t uid, pid_t initialPid, int signal, bool once = false,
         std::chrono::steady_clock::time_point until = std::chrono::steady_clock::now() + 2200ms) {
     CHECK_GE(uid, 0);
     CHECK_GT(initialPid, 0);
@@ -632,15 +632,15 @@ static int KillProcessGroup(
     return ret;
 }
 
-int killProcessGroup(uid_t uid, int initialPid, int signal) {
+int killProcessGroup(uid_t uid, pid_t initialPid, int signal) {
     return KillProcessGroup(uid, initialPid, signal);
 }
 
-int killProcessGroupOnce(uid_t uid, int initialPid, int signal) {
+int killProcessGroupOnce(uid_t uid, pid_t initialPid, int signal) {
     return KillProcessGroup(uid, initialPid, signal, true);
 }
 
-static int createProcessGroupInternal(uid_t uid, int initialPid, std::string cgroup,
+static int createProcessGroupInternal(uid_t uid, pid_t initialPid, std::string cgroup,
                                       bool activate_controllers) {
     auto uid_path = ConvertUidToPath(cgroup.c_str(), uid);
 
@@ -687,7 +687,7 @@ static int createProcessGroupInternal(uid_t uid, int initialPid, std::string cgr
     return ret;
 }
 
-int createProcessGroup(uid_t uid, int initialPid, bool memControl) {
+int createProcessGroup(uid_t uid, pid_t initialPid, bool memControl) {
     CHECK_GE(uid, 0);
     CHECK_GT(initialPid, 0);
 
@@ -731,15 +731,15 @@ static bool SetProcessGroupValue(int tid, const std::string& attr_name, int64_t
     return true;
 }
 
-bool setProcessGroupSwappiness(uid_t, int pid, int swappiness) {
+bool setProcessGroupSwappiness(uid_t, pid_t pid, int swappiness) {
     return SetProcessGroupValue(pid, "MemSwappiness", swappiness);
 }
 
-bool setProcessGroupSoftLimit(uid_t, int pid, int64_t soft_limit_in_bytes) {
+bool setProcessGroupSoftLimit(uid_t, pid_t pid, int64_t soft_limit_in_bytes) {
     return SetProcessGroupValue(pid, "MemSoftLimit", soft_limit_in_bytes);
 }
 
-bool setProcessGroupLimit(uid_t, int pid, int64_t limit_in_bytes) {
+bool setProcessGroupLimit(uid_t, pid_t pid, int64_t limit_in_bytes) {
     return SetProcessGroupValue(pid, "MemLimit", limit_in_bytes);
 }
 
@@ -747,7 +747,7 @@ bool getAttributePathForTask(const std::string& attr_name, int tid, std::string*
     return CgroupGetAttributePathForTask(attr_name, tid, path);
 }
 
-bool isProfileValidForProcess(const std::string& profile_name, uid_t uid, int pid) {
+bool isProfileValidForProcess(const std::string& profile_name, uid_t uid, pid_t pid) {
     const TaskProfile* tp = TaskProfiles::GetInstance().GetProfile(profile_name);
 
     if (tp == nullptr) {
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index eaafa5eb66f7..05927cb52cc0 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -489,7 +489,7 @@ WriteFileAction::WriteFileAction(const std::string& task_path, const std::string
 }
 
 bool WriteFileAction::WriteValueToFile(const std::string& value_, ResourceCacheType cache_type,
-                                       uid_t uid, int pid, bool logfailures) const {
+                                       uid_t uid, pid_t pid, bool logfailures) const {
     std::string value(value_);
 
     value = StringReplace(value, "<uid>", std::to_string(uid), true);
@@ -564,7 +564,7 @@ bool WriteFileAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
     DIR* d;
     struct dirent* de;
     char proc_path[255];
-    int t_pid;
+    pid_t t_pid;
 
     sprintf(proc_path, "/proc/%d/task", pid);
     if (!(d = opendir(proc_path))) {
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index 25e3a02efb09..a6ce93615e7d 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -185,7 +185,7 @@ class WriteFileAction : public ProfileAction {
     mutable std::mutex fd_mutex_;
 
     bool WriteValueToFile(const std::string& value, ResourceCacheType cache_type, uid_t uid,
-                          int pid, bool logfailures) const;
+                          pid_t pid, bool logfailures) const;
     CacheUseResult UseCachedFd(ResourceCacheType cache_type, const std::string& value) const;
 };
 

From 1c007996b35f59482b1e7e1393f5238bee65171d Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 25 Jan 2024 16:29:54 +0000
Subject: [PATCH 0684/1487] libprocessgroup: Use pid_t consistently for TIDs

Test: m
Change-Id: I6e95870e6c5855bfe03be3be8f7a8884147bc15d
---
 libprocessgroup/cgroup_map.cpp                |  2 +-
 libprocessgroup/cgroup_map.h                  |  3 +-
 .../include/processgroup/processgroup.h       | 11 +++---
 libprocessgroup/processgroup.cpp              | 13 ++++---
 libprocessgroup/sched_policy.cpp              |  8 ++--
 libprocessgroup/task_profiles.cpp             | 30 +++++++--------
 libprocessgroup/task_profiles.h               | 38 +++++++++----------
 7 files changed, 54 insertions(+), 51 deletions(-)

diff --git a/libprocessgroup/cgroup_map.cpp b/libprocessgroup/cgroup_map.cpp
index ce7f10b0024f..c8ae2161ad3e 100644
--- a/libprocessgroup/cgroup_map.cpp
+++ b/libprocessgroup/cgroup_map.cpp
@@ -104,7 +104,7 @@ std::string CgroupController::GetProcsFilePath(const std::string& rel_path, uid_
     return proc_path.append(CGROUP_PROCS_FILE);
 }
 
-bool CgroupController::GetTaskGroup(int tid, std::string* group) const {
+bool CgroupController::GetTaskGroup(pid_t tid, std::string* group) const {
     std::string file_name = StringPrintf("/proc/%d/cgroup", tid);
     std::string content;
     if (!android::base::ReadFileToString(file_name, &content)) {
diff --git a/libprocessgroup/cgroup_map.h b/libprocessgroup/cgroup_map.h
index 5cdf8b28c06c..5c6d3e21c468 100644
--- a/libprocessgroup/cgroup_map.h
+++ b/libprocessgroup/cgroup_map.h
@@ -43,7 +43,8 @@ class CgroupController {
 
     std::string GetTasksFilePath(const std::string& path) const;
     std::string GetProcsFilePath(const std::string& path, uid_t uid, pid_t pid) const;
-    bool GetTaskGroup(int tid, std::string* group) const;
+    bool GetTaskGroup(pid_t tid, std::string* group) const;
+
   private:
     enum ControllerState {
         UNKNOWN = 0,
diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index c20586d41a46..ffffeb48b0c1 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -33,19 +33,20 @@ bool CgroupsAvailable();
 bool CgroupGetControllerPath(const std::string& cgroup_name, std::string* path);
 bool CgroupGetControllerFromPath(const std::string& path, std::string* cgroup_name);
 bool CgroupGetAttributePath(const std::string& attr_name, std::string* path);
-bool CgroupGetAttributePathForTask(const std::string& attr_name, int tid, std::string* path);
+bool CgroupGetAttributePathForTask(const std::string& attr_name, pid_t tid, std::string* path);
 
-bool SetTaskProfiles(int tid, const std::vector<std::string>& profiles, bool use_fd_cache = false);
+bool SetTaskProfiles(pid_t tid, const std::vector<std::string>& profiles,
+                     bool use_fd_cache = false);
 bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles);
 bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles);
 
 __END_DECLS
 
-bool SetTaskProfiles(int tid, std::initializer_list<std::string_view> profiles,
+bool SetTaskProfiles(pid_t tid, std::initializer_list<std::string_view> profiles,
                      bool use_fd_cache = false);
 bool SetProcessProfiles(uid_t uid, pid_t pid, std::initializer_list<std::string_view> profiles);
 #if _LIBCPP_STD_VER > 17
-bool SetTaskProfiles(int tid, std::span<const std::string_view> profiles,
+bool SetTaskProfiles(pid_t tid, std::span<const std::string_view> profiles,
                      bool use_fd_cache = false);
 bool SetProcessProfiles(uid_t uid, pid_t pid, std::span<const std::string_view> profiles);
 #endif
@@ -91,7 +92,7 @@ void removeAllEmptyProcessGroups(void);
 
 // Provides the path for an attribute in a specific process group
 // Returns false in case of error, true in case of success
-bool getAttributePathForTask(const std::string& attr_name, int tid, std::string* path);
+bool getAttributePathForTask(const std::string& attr_name, pid_t tid, std::string* path);
 
 // Check if a profile can be applied without failing.
 // Returns true if it can be applied without failing, false otherwise
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index facfb5e8c8ce..94d950209e5f 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -147,7 +147,7 @@ bool CgroupGetAttributePath(const std::string& attr_name, std::string* path) {
     return true;
 }
 
-bool CgroupGetAttributePathForTask(const std::string& attr_name, int tid, std::string* path) {
+bool CgroupGetAttributePathForTask(const std::string& attr_name, pid_t tid, std::string* path) {
     const TaskProfiles& tp = TaskProfiles::GetInstance();
     const IProfileAttribute* attr = tp.GetAttribute(attr_name);
 
@@ -198,17 +198,18 @@ bool SetProcessProfilesCached(uid_t uid, pid_t pid, const std::vector<std::strin
             uid, pid, std::span<const std::string>(profiles), true);
 }
 
-bool SetTaskProfiles(int tid, const std::vector<std::string>& profiles, bool use_fd_cache) {
+bool SetTaskProfiles(pid_t tid, const std::vector<std::string>& profiles, bool use_fd_cache) {
     return TaskProfiles::GetInstance().SetTaskProfiles(tid, std::span<const std::string>(profiles),
                                                        use_fd_cache);
 }
 
-bool SetTaskProfiles(int tid, std::initializer_list<std::string_view> profiles, bool use_fd_cache) {
+bool SetTaskProfiles(pid_t tid, std::initializer_list<std::string_view> profiles,
+                     bool use_fd_cache) {
     return TaskProfiles::GetInstance().SetTaskProfiles(
             tid, std::span<const std::string_view>(profiles), use_fd_cache);
 }
 
-bool SetTaskProfiles(int tid, std::span<const std::string_view> profiles, bool use_fd_cache) {
+bool SetTaskProfiles(pid_t tid, std::span<const std::string_view> profiles, bool use_fd_cache) {
     return TaskProfiles::GetInstance().SetTaskProfiles(tid, profiles, use_fd_cache);
 }
 
@@ -712,7 +713,7 @@ int createProcessGroup(uid_t uid, pid_t initialPid, bool memControl) {
     return createProcessGroupInternal(uid, initialPid, cgroup, true);
 }
 
-static bool SetProcessGroupValue(int tid, const std::string& attr_name, int64_t value) {
+static bool SetProcessGroupValue(pid_t tid, const std::string& attr_name, int64_t value) {
     if (!isMemoryCgroupSupported()) {
         LOG(ERROR) << "Memcg is not mounted.";
         return false;
@@ -743,7 +744,7 @@ bool setProcessGroupLimit(uid_t, pid_t pid, int64_t limit_in_bytes) {
     return SetProcessGroupValue(pid, "MemLimit", limit_in_bytes);
 }
 
-bool getAttributePathForTask(const std::string& attr_name, int tid, std::string* path) {
+bool getAttributePathForTask(const std::string& attr_name, pid_t tid, std::string* path) {
     return CgroupGetAttributePathForTask(attr_name, tid, path);
 }
 
diff --git a/libprocessgroup/sched_policy.cpp b/libprocessgroup/sched_policy.cpp
index 169b1d3e0ac3..1005b1e3e6d3 100644
--- a/libprocessgroup/sched_policy.cpp
+++ b/libprocessgroup/sched_policy.cpp
@@ -38,7 +38,7 @@ static inline SchedPolicy _policy(SchedPolicy p) {
 
 #if defined(__ANDROID__)
 
-int set_cpuset_policy(int tid, SchedPolicy policy) {
+int set_cpuset_policy(pid_t tid, SchedPolicy policy) {
     if (tid == 0) {
         tid = GetThreadId();
     }
@@ -64,7 +64,7 @@ int set_cpuset_policy(int tid, SchedPolicy policy) {
     return 0;
 }
 
-int set_sched_policy(int tid, SchedPolicy policy) {
+int set_sched_policy(pid_t tid, SchedPolicy policy) {
     if (tid == 0) {
         tid = GetThreadId();
     }
@@ -154,7 +154,7 @@ bool schedboost_enabled() {
     return enabled;
 }
 
-static int getCGroupSubsys(int tid, const char* subsys, std::string& subgroup) {
+static int getCGroupSubsys(pid_t tid, const char* subsys, std::string& subgroup) {
     auto controller = CgroupMap::GetInstance().FindController(subsys);
 
     if (!controller.IsUsable()) return -1;
@@ -185,7 +185,7 @@ static int get_sched_policy_from_group(const std::string& group, SchedPolicy* po
     return 0;
 }
 
-int get_sched_policy(int tid, SchedPolicy* policy) {
+int get_sched_policy(pid_t tid, SchedPolicy* policy) {
     if (tid == 0) {
         tid = GetThreadId();
     }
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 05927cb52cc0..2353cf18a987 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -136,7 +136,7 @@ bool ProfileAttribute::GetPathForProcess(uid_t uid, pid_t pid, std::string* path
     return GetPathForTask(pid, path);
 }
 
-bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
+bool ProfileAttribute::GetPathForTask(pid_t tid, std::string* path) const {
     std::string subgroup;
     if (!controller()->GetTaskGroup(tid, &subgroup)) {
         return false;
@@ -179,13 +179,13 @@ bool SetClampsAction::ExecuteForTask(int) const {
 // To avoid issues in sdk_mac build
 #if defined(__ANDROID__)
 
-bool SetTimerSlackAction::IsTimerSlackSupported(int tid) {
+bool SetTimerSlackAction::IsTimerSlackSupported(pid_t tid) {
     auto file = StringPrintf("/proc/%d/timerslack_ns", tid);
 
     return (access(file.c_str(), W_OK) == 0);
 }
 
-bool SetTimerSlackAction::ExecuteForTask(int tid) const {
+bool SetTimerSlackAction::ExecuteForTask(pid_t tid) const {
     static bool sys_supports_timerslack = IsTimerSlackSupported(tid);
 
     // v4.6+ kernels support the /proc/<tid>/timerslack_ns interface.
@@ -250,7 +250,7 @@ bool SetAttributeAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
     return WriteValueToFile(path);
 }
 
-bool SetAttributeAction::ExecuteForTask(int tid) const {
+bool SetAttributeAction::ExecuteForTask(pid_t tid) const {
     std::string path;
 
     if (!attribute_->GetPathForTask(tid, &path)) {
@@ -288,7 +288,7 @@ bool SetAttributeAction::IsValidForProcess(uid_t, pid_t pid) const {
     return IsValidForTask(pid);
 }
 
-bool SetAttributeAction::IsValidForTask(int tid) const {
+bool SetAttributeAction::IsValidForTask(pid_t tid) const {
     std::string path;
 
     if (!attribute_->GetPathForTask(tid, &path)) {
@@ -316,7 +316,7 @@ SetCgroupAction::SetCgroupAction(const CgroupController& c, const std::string& p
     FdCacheHelper::Init(controller_.GetProcsFilePath(path_, 0, 0), fd_[ProfileAction::RCT_PROCESS]);
 }
 
-bool SetCgroupAction::AddTidToCgroup(int tid, int fd, ResourceCacheType cache_type) const {
+bool SetCgroupAction::AddTidToCgroup(pid_t tid, int fd, ResourceCacheType cache_type) const {
     if (tid <= 0) {
         return true;
     }
@@ -401,7 +401,7 @@ bool SetCgroupAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
     return true;
 }
 
-bool SetCgroupAction::ExecuteForTask(int tid) const {
+bool SetCgroupAction::ExecuteForTask(pid_t tid) const {
     CacheUseResult result = UseCachedFd(ProfileAction::RCT_TASK, tid);
     if (result != ProfileAction::UNUSED) {
         return result == ProfileAction::SUCCESS;
@@ -590,7 +590,7 @@ bool WriteFileAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
     return true;
 }
 
-bool WriteFileAction::ExecuteForTask(int tid) const {
+bool WriteFileAction::ExecuteForTask(pid_t tid) const {
     return WriteValueToFile(value_, ProfileAction::RCT_TASK, getuid(), tid, logfailures_);
 }
 
@@ -655,7 +655,7 @@ bool ApplyProfileAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
     return true;
 }
 
-bool ApplyProfileAction::ExecuteForTask(int tid) const {
+bool ApplyProfileAction::ExecuteForTask(pid_t tid) const {
     for (const auto& profile : profiles_) {
         profile->ExecuteForTask(tid);
     }
@@ -683,7 +683,7 @@ bool ApplyProfileAction::IsValidForProcess(uid_t uid, pid_t pid) const {
     return true;
 }
 
-bool ApplyProfileAction::IsValidForTask(int tid) const {
+bool ApplyProfileAction::IsValidForTask(pid_t tid) const {
     for (const auto& profile : profiles_) {
         if (!profile->IsValidForTask(tid)) {
             return false;
@@ -707,7 +707,7 @@ bool TaskProfile::ExecuteForProcess(uid_t uid, pid_t pid) const {
     return true;
 }
 
-bool TaskProfile::ExecuteForTask(int tid) const {
+bool TaskProfile::ExecuteForTask(pid_t tid) const {
     if (tid == 0) {
         tid = GetThreadId();
     }
@@ -761,7 +761,7 @@ bool TaskProfile::IsValidForProcess(uid_t uid, pid_t pid) const {
     return true;
 }
 
-bool TaskProfile::IsValidForTask(int tid) const {
+bool TaskProfile::IsValidForTask(pid_t tid) const {
     for (const auto& element : elements_) {
         if (!element->IsValidForTask(tid)) return false;
     }
@@ -1043,7 +1043,7 @@ bool TaskProfiles::SetProcessProfiles(uid_t uid, pid_t pid, std::span<const T> p
 }
 
 template <typename T>
-bool TaskProfiles::SetTaskProfiles(int tid, std::span<const T> profiles, bool use_fd_cache) {
+bool TaskProfiles::SetTaskProfiles(pid_t tid, std::span<const T> profiles, bool use_fd_cache) {
     bool success = true;
     for (const auto& name : profiles) {
         TaskProfile* profile = GetProfile(name);
@@ -1069,9 +1069,9 @@ template bool TaskProfiles::SetProcessProfiles(uid_t uid, pid_t pid,
 template bool TaskProfiles::SetProcessProfiles(uid_t uid, pid_t pid,
                                                std::span<const std::string_view> profiles,
                                                bool use_fd_cache);
-template bool TaskProfiles::SetTaskProfiles(int tid, std::span<const std::string> profiles,
+template bool TaskProfiles::SetTaskProfiles(pid_t tid, std::span<const std::string> profiles,
                                             bool use_fd_cache);
-template bool TaskProfiles::SetTaskProfiles(int tid, std::span<const std::string_view> profiles,
+template bool TaskProfiles::SetTaskProfiles(pid_t tid, std::span<const std::string_view> profiles,
                                             bool use_fd_cache);
 template bool TaskProfiles::SetUserProfiles(uid_t uid, std::span<const std::string> profiles,
                                             bool use_fd_cache);
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index a6ce93615e7d..2fa1931770eb 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -37,7 +37,7 @@ class IProfileAttribute {
     virtual const CgroupController* controller() const = 0;
     virtual const std::string& file_name() const = 0;
     virtual bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const = 0;
-    virtual bool GetPathForTask(int tid, std::string* path) const = 0;
+    virtual bool GetPathForTask(pid_t tid, std::string* path) const = 0;
     virtual bool GetPathForUID(uid_t uid, std::string* path) const = 0;
 };
 
@@ -57,7 +57,7 @@ class ProfileAttribute : public IProfileAttribute {
                const std::string& file_v2_name) override;
 
     bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const override;
-    bool GetPathForTask(int tid, std::string* path) const override;
+    bool GetPathForTask(pid_t tid, std::string* path) const override;
     bool GetPathForUID(uid_t uid, std::string* path) const override;
 
   private:
@@ -83,7 +83,7 @@ class ProfileAction {
     virtual void EnableResourceCaching(ResourceCacheType) {}
     virtual void DropResourceCaching(ResourceCacheType) {}
     virtual bool IsValidForProcess(uid_t uid, pid_t pid) const { return false; }
-    virtual bool IsValidForTask(int tid) const { return false; }
+    virtual bool IsValidForTask(pid_t tid) const { return false; }
 
   protected:
     enum CacheUseResult { SUCCESS, FAIL, UNUSED };
@@ -96,7 +96,7 @@ class SetClampsAction : public ProfileAction {
 
     const char* Name() const override { return "SetClamps"; }
     bool ExecuteForProcess(uid_t uid, pid_t pid) const override;
-    bool ExecuteForTask(int tid) const override;
+    bool ExecuteForTask(pid_t tid) const override;
 
   protected:
     int boost_;
@@ -108,14 +108,14 @@ class SetTimerSlackAction : public ProfileAction {
     SetTimerSlackAction(unsigned long slack) noexcept : slack_(slack) {}
 
     const char* Name() const override { return "SetTimerSlack"; }
-    bool ExecuteForTask(int tid) const override;
+    bool ExecuteForTask(pid_t tid) const override;
     bool IsValidForProcess(uid_t uid, pid_t pid) const override { return true; }
-    bool IsValidForTask(int tid) const override { return true; }
+    bool IsValidForTask(pid_t tid) const override { return true; }
 
   private:
     unsigned long slack_;
 
-    static bool IsTimerSlackSupported(int tid);
+    static bool IsTimerSlackSupported(pid_t tid);
 };
 
 // Set attribute profile element
@@ -126,10 +126,10 @@ class SetAttributeAction : public ProfileAction {
 
     const char* Name() const override { return "SetAttribute"; }
     bool ExecuteForProcess(uid_t uid, pid_t pid) const override;
-    bool ExecuteForTask(int tid) const override;
+    bool ExecuteForTask(pid_t tid) const override;
     bool ExecuteForUID(uid_t uid) const override;
     bool IsValidForProcess(uid_t uid, pid_t pid) const override;
-    bool IsValidForTask(int tid) const override;
+    bool IsValidForTask(pid_t tid) const override;
 
   private:
     const IProfileAttribute* attribute_;
@@ -146,11 +146,11 @@ class SetCgroupAction : public ProfileAction {
 
     const char* Name() const override { return "SetCgroup"; }
     bool ExecuteForProcess(uid_t uid, pid_t pid) const override;
-    bool ExecuteForTask(int tid) const override;
+    bool ExecuteForTask(pid_t tid) const override;
     void EnableResourceCaching(ResourceCacheType cache_type) override;
     void DropResourceCaching(ResourceCacheType cache_type) override;
     bool IsValidForProcess(uid_t uid, pid_t pid) const override;
-    bool IsValidForTask(int tid) const override;
+    bool IsValidForTask(pid_t tid) const override;
 
     const CgroupController* controller() const { return &controller_; }
 
@@ -160,7 +160,7 @@ class SetCgroupAction : public ProfileAction {
     android::base::unique_fd fd_[ProfileAction::RCT_COUNT];
     mutable std::mutex fd_mutex_;
 
-    bool AddTidToCgroup(int tid, int fd, ResourceCacheType cache_type) const;
+    bool AddTidToCgroup(pid_t tid, int fd, ResourceCacheType cache_type) const;
     CacheUseResult UseCachedFd(ResourceCacheType cache_type, int id) const;
 };
 
@@ -172,11 +172,11 @@ class WriteFileAction : public ProfileAction {
 
     const char* Name() const override { return "WriteFile"; }
     bool ExecuteForProcess(uid_t uid, pid_t pid) const override;
-    bool ExecuteForTask(int tid) const override;
+    bool ExecuteForTask(pid_t tid) const override;
     void EnableResourceCaching(ResourceCacheType cache_type) override;
     void DropResourceCaching(ResourceCacheType cache_type) override;
     bool IsValidForProcess(uid_t uid, pid_t pid) const override;
-    bool IsValidForTask(int tid) const override;
+    bool IsValidForTask(pid_t tid) const override;
 
   private:
     std::string task_path_, proc_path_, value_;
@@ -198,12 +198,12 @@ class TaskProfile {
     void MoveTo(TaskProfile* profile);
 
     bool ExecuteForProcess(uid_t uid, pid_t pid) const;
-    bool ExecuteForTask(int tid) const;
+    bool ExecuteForTask(pid_t tid) const;
     bool ExecuteForUID(uid_t uid) const;
     void EnableResourceCaching(ProfileAction::ResourceCacheType cache_type);
     void DropResourceCaching(ProfileAction::ResourceCacheType cache_type);
     bool IsValidForProcess(uid_t uid, pid_t pid) const;
-    bool IsValidForTask(int tid) const;
+    bool IsValidForTask(pid_t tid) const;
 
   private:
     const std::string name_;
@@ -219,11 +219,11 @@ class ApplyProfileAction : public ProfileAction {
 
     const char* Name() const override { return "ApplyProfileAction"; }
     bool ExecuteForProcess(uid_t uid, pid_t pid) const override;
-    bool ExecuteForTask(int tid) const override;
+    bool ExecuteForTask(pid_t tid) const override;
     void EnableResourceCaching(ProfileAction::ResourceCacheType cache_type) override;
     void DropResourceCaching(ProfileAction::ResourceCacheType cache_type) override;
     bool IsValidForProcess(uid_t uid, pid_t pid) const override;
-    bool IsValidForTask(int tid) const override;
+    bool IsValidForTask(pid_t tid) const override;
 
   private:
     std::vector<std::shared_ptr<TaskProfile>> profiles_;
@@ -240,7 +240,7 @@ class TaskProfiles {
     template <typename T>
     bool SetProcessProfiles(uid_t uid, pid_t pid, std::span<const T> profiles, bool use_fd_cache);
     template <typename T>
-    bool SetTaskProfiles(int tid, std::span<const T> profiles, bool use_fd_cache);
+    bool SetTaskProfiles(pid_t tid, std::span<const T> profiles, bool use_fd_cache);
     template <typename T>
     bool SetUserProfiles(uid_t uid, std::span<const T> profiles, bool use_fd_cache);
 

From 9e38fe5299375f87aac4c3a33dc0a5a47c3859ee Mon Sep 17 00:00:00 2001
From: Randall Huang <huangrandall@google.com>
Date: Fri, 26 Jan 2024 03:51:53 +0000
Subject: [PATCH 0685/1487] Revert "task_profiles.json: Set io.prio.class"

This reverts commit 9bba87244d6bbf46e776834d0917b2dd1143f31d.

Reason for revert: b/314861914

Change-Id: I566c4fa98e4d1bd8701086c2b5e34802ee0a89fb
---
 libprocessgroup/profiles/task_profiles.json | 41 ---------------------
 1 file changed, 41 deletions(-)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index f2ef316e2e7f..2c08b0b31564 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -91,11 +91,6 @@
       "Name": "CfqWeight",
       "Controller": "io",
       "File": "io.weight"
-    },
-    {
-      "Name": "IoPrioClass",
-      "Controller": "io",
-      "File": "io.prio.class"
     }
   ],
 
@@ -484,15 +479,6 @@
             "Value": "200",
             "Optional": "true"
           }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "IoPrioClass",
-            "Value": "restrict-to-be",
-            "Optional": "true"
-          }
         }
       ]
     },
@@ -525,15 +511,6 @@
             "Value": "1000",
             "Optional": "true"
           }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "IoPrioClass",
-            "Value": "restrict-to-be",
-            "Optional": "true"
-          }
         }
       ]
     },
@@ -566,15 +543,6 @@
             "Value": "1000",
             "Optional": "true"
           }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "IoPrioClass",
-            "Value": "promote-to-rt",
-            "Optional": "true"
-          }
         }
       ]
     },
@@ -607,15 +575,6 @@
             "Value": "1000",
             "Optional": "true"
           }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "IoPrioClass",
-            "Value": "promote-to-rt",
-            "Optional": "true"
-          }
         }
       ]
     },

From d0ce4ca33cd5b1a48a3ef7f8b6da39e5498421c5 Mon Sep 17 00:00:00 2001
From: Randall Huang <huangrandall@google.com>
Date: Fri, 26 Jan 2024 03:48:12 +0000
Subject: [PATCH 0686/1487] Revert "Migrate the blkio controller to the v2
 cgroup hierarchy"

This reverts commit f99ca8aeb1d20218663911ec3d1ea12b2ee9fd05.

Reason for revert: b/2768906

Change-Id: I9ce259a2c96e9f8dd8c7598204c35922b56f7a0a
---
 libprocessgroup/profiles/cgroups.json       |  13 ++-
 libprocessgroup/profiles/task_profiles.json | 115 ++------------------
 rootdir/init.rc                             |  20 ++++
 3 files changed, 39 insertions(+), 109 deletions(-)

diff --git a/libprocessgroup/profiles/cgroups.json b/libprocessgroup/profiles/cgroups.json
index d013ec858c1b..3e4393df2078 100644
--- a/libprocessgroup/profiles/cgroups.json
+++ b/libprocessgroup/profiles/cgroups.json
@@ -1,5 +1,12 @@
 {
   "Cgroups": [
+    {
+      "Controller": "blkio",
+      "Path": "/dev/blkio",
+      "Mode": "0775",
+      "UID": "system",
+      "GID": "system"
+    },
     {
       "Controller": "cpu",
       "Path": "/dev/cpuctl",
@@ -32,12 +39,6 @@
       {
         "Controller": "freezer",
         "Path": "."
-      },
-      {
-        "Controller": "io",
-        "Path": ".",
-        "NeedsActivation": true,
-        "Optional": true
       }
     ]
   }
diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 2c08b0b31564..1fc66ba10a64 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -76,21 +76,6 @@
       "Name": "FreezerState",
       "Controller": "freezer",
       "File": "cgroup.freeze"
-    },
-    {
-      "Name": "BfqWeight",
-      "Controller": "io",
-      "File": "io.bfq.weight"
-    },
-    {
-      "Name": "CfqGroupIdle",
-      "Controller": "io",
-      "File": "io.group_idle"
-    },
-    {
-      "Name": "CfqWeight",
-      "Controller": "io",
-      "File": "io.weight"
     }
   ],
 
@@ -454,30 +439,11 @@
       "Name": "LowIoPriority",
       "Actions": [
         {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "BfqWeight",
-            "Value": "10",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "CfqGroupIdle",
-            "Value": "0",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
+          "Name": "JoinCgroup",
           "Params":
           {
-            "Name": "CfqWeight",
-            "Value": "200",
-            "Optional": "true"
+            "Controller": "blkio",
+            "Path": "background"
           }
         }
       ]
@@ -486,30 +452,11 @@
       "Name": "NormalIoPriority",
       "Actions": [
         {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "BfqWeight",
-            "Value": "100",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "CfqGroupIdle",
-            "Value": "0",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
+          "Name": "JoinCgroup",
           "Params":
           {
-            "Name": "CfqWeight",
-            "Value": "1000",
-            "Optional": "true"
+            "Controller": "blkio",
+            "Path": ""
           }
         }
       ]
@@ -518,30 +465,11 @@
       "Name": "HighIoPriority",
       "Actions": [
         {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "BfqWeight",
-            "Value": "100",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "CfqGroupIdle",
-            "Value": "0",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
+          "Name": "JoinCgroup",
           "Params":
           {
-            "Name": "CfqWeight",
-            "Value": "1000",
-            "Optional": "true"
+            "Controller": "blkio",
+            "Path": ""
           }
         }
       ]
@@ -550,30 +478,11 @@
       "Name": "MaxIoPriority",
       "Actions": [
         {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "BfqWeight",
-            "Value": "100",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "CfqGroupIdle",
-            "Value": "0",
-            "Optional": "true"
-          }
-        },
-        {
-          "Name": "SetAttribute",
+          "Name": "JoinCgroup",
           "Params":
           {
-            "Name": "CfqWeight",
-            "Value": "1000",
-            "Optional": "true"
+            "Controller": "blkio",
+            "Path": ""
           }
         }
       ]
diff --git a/rootdir/init.rc b/rootdir/init.rc
index fb6473666d7c..317f80908350 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -219,6 +219,26 @@ on init
     write /dev/stune/nnapi-hal/schedtune.boost 1
     write /dev/stune/nnapi-hal/schedtune.prefer_idle 1
 
+    # Create blkio group and apply initial settings.
+    # This feature needs kernel to support it, and the
+    # device's init.rc must actually set the correct values.
+    mkdir /dev/blkio/background
+    chown system system /dev/blkio
+    chown system system /dev/blkio/background
+    chown system system /dev/blkio/tasks
+    chown system system /dev/blkio/background/tasks
+    chown system system /dev/blkio/cgroup.procs
+    chown system system /dev/blkio/background/cgroup.procs
+    chmod 0664 /dev/blkio/tasks
+    chmod 0664 /dev/blkio/background/tasks
+    chmod 0664 /dev/blkio/cgroup.procs
+    chmod 0664 /dev/blkio/background/cgroup.procs
+    write /dev/blkio/blkio.weight 1000
+    write /dev/blkio/background/blkio.weight 200
+    write /dev/blkio/background/blkio.bfq.weight 10
+    write /dev/blkio/blkio.group_idle 0
+    write /dev/blkio/background/blkio.group_idle 0
+
     restorecon_recursive /mnt
 
     mount configfs none /config nodev noexec nosuid

From bbb9690935278752df21c2650d73ba9234ecce62 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Thu, 25 Jan 2024 17:24:31 +0800
Subject: [PATCH 0687/1487] remount: Auto remount option (-R) also tries to
 gain root

When doing an auto remount & reboot command and is running as the SHELL
uid, just try to gain root on behalf of the user and retry the remount
command.
If "gain root" failed, then print the message to tell the user to run
"adb root" and retry.

Bug: 322285923
Test: adb unroot && adb remount -vR
Test: adb unroot && adb shell remount -vR
Change-Id: If8e04dc602573c73178c108ef4944f0a985b590e
---
 fs_mgr/fs_mgr_remount.cpp | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/fs_mgr_remount.cpp b/fs_mgr/fs_mgr_remount.cpp
index 733ba2f20ec1..79c0b6df03ae 100644
--- a/fs_mgr/fs_mgr_remount.cpp
+++ b/fs_mgr/fs_mgr_remount.cpp
@@ -42,6 +42,7 @@
 #include <fstab/fstab.h>
 #include <libavb_user/libavb_user.h>
 #include <libgsi/libgsid.h>
+#include <private/android_filesystem_config.h>
 
 #include "fs_mgr_overlayfs_control.h"
 #include "fs_mgr_overlayfs_mount.h"
@@ -608,7 +609,19 @@ int main(int argc, char* argv[]) {
     }
 
     // Make sure we are root.
-    if (::getuid() != 0) {
+    if (const auto uid = ::getuid(); uid != AID_ROOT) {
+        // If requesting auto reboot, also try to auto gain root.
+        if (auto_reboot && uid == AID_SHELL && access("/system/xbin/su", F_OK) == 0) {
+            std::vector<char*> args{const_cast<char*>("/system/xbin/su"),
+                                    const_cast<char*>("root")};
+            for (int i = 0; i < argc; ++i) {
+                args.push_back(argv[i]);
+            }
+            args.push_back(nullptr);
+            LOG(INFO) << "Attempting to gain root with \"su root\"";
+            execv(args[0], args.data());
+            PLOG(ERROR) << "Failed to execute \"su root\"";
+        }
         LOG(ERROR) << "Not running as root. Try \"adb root\" first.";
         return EXIT_FAILURE;
     }

From 903f8e07ff0e0efcab1df49e4ec804c98a2d1353 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 29 Jan 2024 13:57:09 -0800
Subject: [PATCH 0688/1487] libsnapshot: v3 structural changes

Changes to structure of v3 header + operation needed for variable block
size. Seperating this CL from the variable block size one so we can get
v3 enabled on cuttlefish

the op count type changes are so that op count matches the type of
max_blocks. Max_blocks is used when op buffer size is not set -> we
default to upper bound of one operation per block in the partition.

Test: th
Bug: 307452468
Change-Id: I1a2581763a4fd6be5d5795f7e4781023e9984256
---
 fs_mgr/libsnapshot/include/libsnapshot/cow_format.h | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 9401c6626875..d410c14ee01f 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -101,7 +101,7 @@ struct ResumePoint {
     // monotonically increasing value used by update_engine
     uint64_t label;
     // Index of last CowOperation guaranteed to be resumable
-    uint32_t op_index;
+    uint64_t op_index;
 } __attribute__((packed));
 
 static constexpr uint8_t kNumResumePoints = 4;
@@ -115,10 +115,12 @@ struct CowHeaderV3 : public CowHeader {
     uint32_t resume_point_max;
     // Number of CowOperationV3 structs in the operation buffer, currently and total
     // region size.
-    uint32_t op_count;
-    uint32_t op_count_max;
+    uint64_t op_count;
+    uint64_t op_count_max;
     // Compression Algorithm
     uint32_t compression_algorithm;
+    // Max compression size supported
+    uint32_t max_compression_size;
 } __attribute__((packed));
 
 enum class CowOperationType : uint8_t {
@@ -203,7 +205,7 @@ static constexpr uint64_t kCowOpSourceInfoTypeMask = (1ULL << kCowOpSourceInfoTy
 struct CowOperationV3 {
     // If this operation reads from the data section of the COW, this contains
     // the length.
-    uint16_t data_length;
+    uint32_t data_length;
 
     // The block of data in the new image that this operation modifies.
     uint32_t new_block;

From d84857fcfc45595af1a561eb381fb4b0247afebd Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 9 Jan 2024 15:46:17 -0800
Subject: [PATCH 0689/1487] libsnapshot: remove op count check

With variable block size compression being added, the number of ops
written cannot be calculated directly as easily since one op can cover
the data for multiple ops previously. We can get rid of this check for
XOR and Raw blocks as
within WriteOperation() we already make a check to see if we are
exceeding op_count_max limit.

We still need to keep this check for EmitZeroBlocks and EmitCopyBlocks
since the number of operations is determined ahead of time in those
function calls. Without this check in place, the ops will be added to
cached ops and return true when ops cannot be written.
with this change, v3 cow ota now works on cuttlefish with support for
variable block size compression.

Test: th
Change-Id: Ia55f152f5deb67a9022d0feff112345e72741dd3
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index be6b6daa6a7e..0e131970e2a5 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -300,17 +300,11 @@ bool CowWriterV3::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_
 }
 
 bool CowWriterV3::EmitRawBlocks(uint64_t new_block_start, const void* data, size_t size) {
-    if (!CheckOpCount(size / header_.block_size)) {
-        return false;
-    }
     return EmitBlocks(new_block_start, data, size, 0, 0, kCowReplaceOp);
 }
 
 bool CowWriterV3::EmitXorBlocks(uint32_t new_block_start, const void* data, size_t size,
                                 uint32_t old_block, uint16_t offset) {
-    if (!CheckOpCount(size / header_.block_size)) {
-        return false;
-    }
     return EmitBlocks(new_block_start, data, size, old_block, offset, kCowXorOp);
 }
 
@@ -330,7 +324,9 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
     }
     const auto bytes = reinterpret_cast<const uint8_t*>(data);
     const size_t num_blocks = (size / header_.block_size);
-
+    if (!CheckOpCount(num_blocks)) {
+        return false;
+    }
     for (size_t i = 0; i < num_blocks;) {
         const auto blocks_to_write =
                 std::min<size_t>(batch_size_ - cached_data_.size(), num_blocks - i);

From 75070b37e280dd76c0f00d5bf2a8eb96053b1483 Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Tue, 30 Jan 2024 10:17:37 +0900
Subject: [PATCH 0690/1487] Drop CtsInitTestCases from cts

The test is not eligible for CTS. Reasons:

1. The init behavior does not directly affect app compat. App interact
   with init only for the property service and that part is covered by
the Bionic test already.

2. This test doesn't run against the init binary installed on the
   device. libinit where most of the init functionalities are
implemented is statically linked to this test binary. In other words,
this test is closer to a unit test for init.

3. This test is not compatible with Trunk stable where test and DUT are
   built in different branches. The test depends on several (private)
libraries like libbase and libutils. Since the interfaces of the
libraries may have changed in the main branch, the test binary built
from the old test-dev branch may break.

This change does not remove the test. The test will still run as a unit
test during pre/post submit.

I didn't drop the `Cts` prefix from the name, because that requires
broader changes.

Bug: 320800872
Test: N/A
Change-Id: I1402c08b79b57ad6daa7948fe37f14fbbe36f1d6
---
 init/Android.bp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/Android.bp b/init/Android.bp
index a781d8bb99da..091dd7b1b47b 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -474,6 +474,7 @@ phony {
 // ------------------------------------------------------------------------------
 
 cc_test {
+    // Note: This is NOT a CTS test. See b/320800872
     name: "CtsInitTestCases",
     defaults: ["init_defaults"],
     require_root: true,
@@ -506,7 +507,6 @@ cc_test {
     ],
 
     test_suites: [
-        "cts",
         "device-tests",
     ],
 }

From 073133811e800075f7fe7e53d118cbe09939b60d Mon Sep 17 00:00:00 2001
From: David Drysdale <drysdale@google.com>
Date: Tue, 30 Jan 2024 16:46:45 +0000
Subject: [PATCH 0691/1487] Secretkeeper: require SECRETKEEPER_ENABLED=true

Make the makefile safer by requiring a specific value for the
environment variable that turns on Secretkeeper

Bug: 306364873
Test: TreeHugger
Change-Id: Ic5bb5e7411a19941f58ec8c973104c1e53f3834f
---
 trusty/trusty-base.mk | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/trusty/trusty-base.mk b/trusty/trusty-base.mk
index d645c3e40d47..5aa4392c5528 100644
--- a/trusty/trusty-base.mk
+++ b/trusty/trusty-base.mk
@@ -36,10 +36,10 @@ else
 endif
 
 # TODO(b/306364873): move this to be flag-controlled?
-ifeq ($(SECRETKEEPER_ENABLED),)
-    LOCAL_SECRETKEEPER_PRODUCT_PACKAGE :=
-else
+ifeq ($(SECRETKEEPER_ENABLED),true)
     LOCAL_SECRETKEEPER_PRODUCT_PACKAGE := android.hardware.security.secretkeeper.trusty
+else
+    LOCAL_SECRETKEEPER_PRODUCT_PACKAGE :=
 endif
 
 PRODUCT_PACKAGES += \

From 2c82c81f12e64ffa074e504e63d74a6370d2a924 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 9 Jan 2024 14:42:55 -0800
Subject: [PATCH 0692/1487] libsnapshot: use compression_factor in ota

Parse manifest compression_factor and set CowOptions appropriately. This
allows v3 writer to use compression factor in OTA. Updating some
comments about supported compression algorithms

Test: th
Change-Id: I88f254087e536d9e5925064f85317f0acce280ee
---
 fs_mgr/libsnapshot/android/snapshot/snapshot.proto  | 5 ++++-
 fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h | 3 +++
 fs_mgr/libsnapshot/partition_cow_creator.h          | 1 +
 fs_mgr/libsnapshot/snapshot.cpp                     | 7 +++++++
 4 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
index 7e97dc0fbbfd..f2f7fc1cd212 100644
--- a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
+++ b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
@@ -103,7 +103,7 @@ message SnapshotStatus {
     // The old partition size (if none existed, this will be zero).
     uint64 old_partition_size = 10;
 
-    // Compression algorithm (none, gz, or brotli).
+    // Compression algorithm (none, gz, lz4, zstd, or brotli).
     string compression_algorithm = 11;
 
     // Estimated COW size from OTA manifest.
@@ -117,6 +117,9 @@ message SnapshotStatus {
 
     // Size of v3 operation buffer. Needs to be determined during writer initialization
     uint64 estimated_ops_buffer_size = 15;
+
+    // Max bytes to be compressed at once (4k, 8k, 16k, 32k, 64k, 128k)
+    uint64 compression_factor = 16;
 }
 
 // Next: 8
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 7df976d85c7b..3bcee21a31b1 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -60,6 +60,9 @@ struct CowOptions {
 
     // Size of the cow operation buffer; used in v3 only.
     uint64_t op_count_max = 0;
+
+    // Compression factor
+    uint64_t compression_factor = 4096;
 };
 
 // Interface for writing to a snapuserd COW. All operations are ordered; merges
diff --git a/fs_mgr/libsnapshot/partition_cow_creator.h b/fs_mgr/libsnapshot/partition_cow_creator.h
index bd5c8cb2e370..cbd664fef062 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator.h
+++ b/fs_mgr/libsnapshot/partition_cow_creator.h
@@ -59,6 +59,7 @@ struct PartitionCowCreator {
     // True if snapuserd COWs are enabled.
     bool using_snapuserd = false;
     std::string compression_algorithm;
+    uint64_t compression_factor;
 
     // True if multi-threaded compression should be enabled
     bool enable_threading;
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 9eb41b2cc836..c12a9e223b87 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -420,6 +420,7 @@ bool SnapshotManager::CreateSnapshot(LockedFile* lock, PartitionCowCreator* cow_
     status->set_metadata_sectors(0);
     status->set_using_snapuserd(cow_creator->using_snapuserd);
     status->set_compression_algorithm(cow_creator->compression_algorithm);
+    status->set_compression_factor(cow_creator->compression_factor);
     if (cow_creator->enable_threading) {
         status->set_enable_threading(cow_creator->enable_threading);
     }
@@ -3233,8 +3234,10 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
     }
 
     std::string compression_algorithm;
+    uint64_t compression_factor{};
     if (using_snapuserd) {
         compression_algorithm = dap_metadata.vabc_compression_param();
+        compression_factor = dap_metadata.compression_factor();
         if (compression_algorithm.empty()) {
             // Older OTAs don't set an explicit compression type, so default to gz.
             compression_algorithm = "gz";
@@ -3251,7 +3254,9 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
             .extra_extents = {},
             .using_snapuserd = using_snapuserd,
             .compression_algorithm = compression_algorithm,
+            .compression_factor = compression_factor,
     };
+
     if (dap_metadata.vabc_feature_set().has_threaded()) {
         cow_creator.enable_threading = dap_metadata.vabc_feature_set().threaded();
     }
@@ -3666,6 +3671,7 @@ std::unique_ptr<ICowWriter> SnapshotManager::OpenCompressedSnapshotWriter(
     cow_options.batch_write = status.batched_writes();
     cow_options.num_compress_threads = status.enable_threading() ? 2 : 1;
     cow_options.op_count_max = status.estimated_ops_buffer_size();
+    cow_options.compression_factor = status.compression_factor();
     // Disable scratch space for vts tests
     if (device()->IsTestDevice()) {
         cow_options.scratch_space = false;
@@ -3793,6 +3799,7 @@ bool SnapshotManager::Dump(std::ostream& os) {
         ss << "    allocated sectors: " << status.sectors_allocated() << std::endl;
         ss << "    metadata sectors: " << status.metadata_sectors() << std::endl;
         ss << "    compression: " << status.compression_algorithm() << std::endl;
+        ss << "    compression factor: " << status.compression_factor() << std::endl;
         ss << "    merge phase: " << DecideMergePhase(status) << std::endl;
     }
     os << ss.rdbuf();

From 2aed5a5e4c438defcaf3e916fcce798b1436e247 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 4 Jan 2024 14:12:57 -0800
Subject: [PATCH 0693/1487] libsnapshot: op_count_max default to max blocks

In the case that op_count_max is read in as zero, we should use the
upper bound of max blocks as the estimation. One case in which this
error can happen is if a v2 cow estimator is used, we should still be
able to run an OTA if we upper bound our ops buffer size estimation.

Test: th
Change-Id: I97ca66368d6631bf43c8911ed66f99c9e8096e2d
---
 fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp   |  1 +
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp | 12 ++++++++++++
 fs_mgr/libsnapshot/snapshot.cpp                  | 16 ++++++++--------
 3 files changed, 21 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 8cf46f42eeb2..de602138debc 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -72,6 +72,7 @@ TEST_F(CowTestV3, CowHeaderV2Test) {
 
 TEST_F(CowTestV3, Header) {
     CowOptions options;
+    options.op_count_max = 15;
     auto writer = CreateCowWriter(3, options, GetCowFd());
     ASSERT_TRUE(writer->Finalize());
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 0e131970e2a5..051b2fb8a83b 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -129,6 +129,18 @@ bool CowWriterV3::ParseOptions() {
     header_.compression_algorithm = *algorithm;
     header_.op_count_max = options_.op_count_max;
 
+    if (!IsEstimating() && header_.op_count_max == 0) {
+        if (!options_.max_blocks.has_value()) {
+            LOG(ERROR) << "can't size op buffer size since op_count_max is 0 and max_blocks is not "
+                          "set.";
+            return false;
+        }
+        LOG(INFO) << "op count max is read in as 0. Setting to "
+                     "num blocks in partition "
+                  << options_.max_blocks.value();
+        header_.op_count_max = options_.max_blocks.value();
+    }
+
     if (parts.size() > 1) {
         if (!android::base::ParseUint(parts[1], &compression_.compression_level)) {
             LOG(ERROR) << "failed to parse compression level invalid type: " << parts[1];
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index c12a9e223b87..9ce00e5f8e1b 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -1142,8 +1142,8 @@ auto SnapshotManager::CheckMergeState(const std::function<bool()>& before_cancel
     return result;
 }
 
-auto SnapshotManager::CheckMergeState(LockedFile* lock, const std::function<bool()>& before_cancel)
-        -> MergeResult {
+auto SnapshotManager::CheckMergeState(LockedFile* lock,
+                                      const std::function<bool()>& before_cancel) -> MergeResult {
     SnapshotUpdateStatus update_status = ReadSnapshotUpdateStatus(lock);
     switch (update_status.state()) {
         case UpdateState::None:
@@ -1218,8 +1218,8 @@ auto SnapshotManager::CheckMergeState(LockedFile* lock, const std::function<bool
                 wrong_phase = true;
                 break;
             default:
-                LOG(ERROR) << "Unknown merge status for \"" << snapshot << "\": "
-                           << "\"" << result.state << "\"";
+                LOG(ERROR) << "Unknown merge status for \"" << snapshot << "\": " << "\""
+                           << result.state << "\"";
                 if (failure_code == MergeFailureCode::Ok) {
                     failure_code = MergeFailureCode::UnexpectedMergeState;
                 }
@@ -2797,8 +2797,8 @@ bool SnapshotManager::UnmapAllSnapshots(LockedFile* lock) {
     return true;
 }
 
-auto SnapshotManager::OpenFile(const std::string& file, int lock_flags)
-        -> std::unique_ptr<LockedFile> {
+auto SnapshotManager::OpenFile(const std::string& file,
+                               int lock_flags) -> std::unique_ptr<LockedFile> {
     unique_fd fd(open(file.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
     if (fd < 0) {
         PLOG(ERROR) << "Open failed: " << file;
@@ -3558,6 +3558,7 @@ Return SnapshotManager::InitializeUpdateSnapshots(
             options.compression = it->second.compression_algorithm();
             if (cow_version >= 3) {
                 options.op_count_max = it->second.estimated_ops_buffer_size();
+                options.max_blocks = {it->second.device_size() / options.block_size};
             }
 
             auto writer = CreateCowWriter(cow_version, options, std::move(fd));
@@ -4343,8 +4344,7 @@ bool SnapshotManager::DeleteDeviceIfExists(const std::string& name,
         }
     }
 
-    LOG(ERROR) << "Device-mapper device " << name << "(" << full_path << ")"
-               << " still in use."
+    LOG(ERROR) << "Device-mapper device " << name << "(" << full_path << ")" << " still in use."
                << "  Probably a file descriptor was leaked or held open, or a loop device is"
                << " attached.";
     return false;

From 6ca4d66a052d0376cee114b8c0d90dded1e45ad4 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 9 Jan 2024 17:07:05 -0800
Subject: [PATCH 0694/1487] libsnapshot: update type

num_compress_threads should be unsigned integer as it can never be
negative.

Test: th
Change-Id: Ic0456ac717483300fa9cbd55eba5cdd0156207a7
---
 .../libsnapshot/include/libsnapshot/cow_writer.h  |  2 +-
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp  |  2 +-
 fs_mgr/libsnapshot/snapshot.cpp                   | 15 ++++++++-------
 3 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 3bcee21a31b1..0194ffd7b692 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -53,7 +53,7 @@ struct CowOptions {
     uint64_t num_merge_ops = 0;
 
     // Number of threads for compression
-    int num_compress_threads = 0;
+    uint16_t num_compress_threads = 0;
 
     // Batch write cluster ops
     bool batch_write = false;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 051b2fb8a83b..61124df8ca02 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -114,7 +114,7 @@ void CowWriterV3::SetupHeaders() {
 }
 
 bool CowWriterV3::ParseOptions() {
-    num_compress_threads_ = std::max(options_.num_compress_threads, 1);
+    num_compress_threads_ = std::max(int(options_.num_compress_threads), 1);
     auto parts = android::base::Split(options_.compression, ",");
     if (parts.size() > 2) {
         LOG(ERROR) << "failed to parse compression parameters: invalid argument count: "
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 9ce00e5f8e1b..ba5fb8824d53 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -1142,8 +1142,8 @@ auto SnapshotManager::CheckMergeState(const std::function<bool()>& before_cancel
     return result;
 }
 
-auto SnapshotManager::CheckMergeState(LockedFile* lock,
-                                      const std::function<bool()>& before_cancel) -> MergeResult {
+auto SnapshotManager::CheckMergeState(LockedFile* lock, const std::function<bool()>& before_cancel)
+        -> MergeResult {
     SnapshotUpdateStatus update_status = ReadSnapshotUpdateStatus(lock);
     switch (update_status.state()) {
         case UpdateState::None:
@@ -1218,8 +1218,8 @@ auto SnapshotManager::CheckMergeState(LockedFile* lock,
                 wrong_phase = true;
                 break;
             default:
-                LOG(ERROR) << "Unknown merge status for \"" << snapshot << "\": " << "\""
-                           << result.state << "\"";
+                LOG(ERROR) << "Unknown merge status for \"" << snapshot << "\": "
+                           << "\"" << result.state << "\"";
                 if (failure_code == MergeFailureCode::Ok) {
                     failure_code = MergeFailureCode::UnexpectedMergeState;
                 }
@@ -2797,8 +2797,8 @@ bool SnapshotManager::UnmapAllSnapshots(LockedFile* lock) {
     return true;
 }
 
-auto SnapshotManager::OpenFile(const std::string& file,
-                               int lock_flags) -> std::unique_ptr<LockedFile> {
+auto SnapshotManager::OpenFile(const std::string& file, int lock_flags)
+        -> std::unique_ptr<LockedFile> {
     unique_fd fd(open(file.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
     if (fd < 0) {
         PLOG(ERROR) << "Open failed: " << file;
@@ -4344,7 +4344,8 @@ bool SnapshotManager::DeleteDeviceIfExists(const std::string& name,
         }
     }
 
-    LOG(ERROR) << "Device-mapper device " << name << "(" << full_path << ")" << " still in use."
+    LOG(ERROR) << "Device-mapper device " << name << "(" << full_path << ")"
+               << " still in use."
                << "  Probably a file descriptor was leaked or held open, or a loop device is"
                << " attached.";
     return false;

From bcce91603bdb11660f439130cd2cb28c85ffe888 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 30 Jan 2024 21:30:48 -0800
Subject: [PATCH 0695/1487] libsnapshot: set header max_compression

Intermediate CL needed before variable block size can land. Since v3 is
enabled on cuttlefish, the base build needs to write the
compression_factor in order for reader to properly parse. Otherwise
we'll fail OTA test

Test: th
Change-Id: Ia353aae8e668858851073f09308909ae70d7854e
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 61124df8ca02..251b24e6aca6 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -110,6 +110,7 @@ void CowWriterV3::SetupHeaders() {
     header_.op_count = 0;
     header_.op_count_max = 0;
     header_.compression_algorithm = kCowCompressNone;
+    header_.max_compression_size = options_.compression_factor;
     return;
 }
 

From 59fa486703047b4139eb13b4bda5ec320cd7e85f Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 3 Jan 2024 23:24:19 -0800
Subject: [PATCH 0696/1487] libsnapshot_cow: Support multi-block compression

This patch supports compression for bigger block size.

3 bits [57-59] in the COW Operation "source_info_" field is used to store
the compression factor. Supported compression factors are power of 2
viz: 4k, 8k, 16k, 32k, 64k, 128k, 256k.

Only REPLACE operations will have the bigger block size support for now.
This can be extended to other operations later.

The write path in EmitBlocks() has the core logic wherein consecutive
sequence of REPLACE ops are compressed based on the compression factor
settings. Thus, for a 64k compression factor, there will be just one
COW operation which encodes all the 16 operation and the entire 64k
block is compressed in one shot.

NOTE: There is no read I/O path support in this patch. Subsequent patch
will have the read support.

Performance data (with read I/O path support in subsequent patch):

go/variable-block-vabc-perf covers detail performance runs
on Pixel 6 for full and incremental OTA.

TL;DR:

Performance of a full OTA (All numbers are compared against 4k block
size)
=======================================
Snapshot-size:

~10-11% decrease in snapshot-size (disk-space) for zstd with 256k block
size.

~8% decrease in snapshot-size (disk-space) for lz4

Install time:

~13% decrease in OTA install time for zstd with 256k block size.

Snapshot-merge:

~50% decrease in snapshot-merge time with 256k block size for zstd

Post OTA boot-time:

~10.5 decrease in boot time for 64k block size for zstd

In-memory footprint for COW operations:

~80% decrease in memory footprint for 256k block size. (58MB -> 9.2MB)

============================================

For more improvements, further tuning of zstd/lz4 is
required primariy the compression levels, zstd compression window,
performance of gz with compression levels.

Bug: 319309466

Test: cow_api test covering all the supported block sizes for v3 writer.

On Pixel 6:

=======================================
COW Writer V3:

for OTA in full, incremental OTA
   for block_size in 4k, 16k, 32k, 64k, 128k, 256k
       for compression_algo in lz4, zstd, gz, none
          install OTA, reboot, verify merge
=======================================
COW Writer V2:

for OTA in full, incremental OTA
   for block_size in 4k
      for compression_algo in lz4, zstd, gz, none
          install OTA, reboot, verity merge

=====================================
Change-Id: I96201f1609582aa9d44d8085852e284b0c4a426d
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/Android.bp                 |  46 ++-
 .../include/libsnapshot/cow_format.h          |  37 ++-
 .../include/libsnapshot/cow_writer.h          |  10 +-
 .../libsnapshot_cow/cow_compress.cpp          |  36 +--
 .../libsnapshot_cow/cow_format.cpp            |   7 +
 .../libsnapshot_cow/cow_reader.cpp            |  16 +-
 .../libsnapshot/libsnapshot_cow/parser_v2.cpp |   2 +
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 192 +++++++++++-
 .../libsnapshot/libsnapshot_cow/writer_v2.cpp |   4 +-
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 295 +++++++++++++-----
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |  39 ++-
 11 files changed, 566 insertions(+), 118 deletions(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index a8a7716aa436..5ceaf287ab76 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -108,7 +108,7 @@ cc_library_static {
     ],
     srcs: [":libsnapshot_sources"],
     static_libs: [
-        "libfs_mgr_binder"
+        "libfs_mgr_binder",
     ],
 }
 
@@ -128,12 +128,12 @@ cc_library {
     static_libs: [
         "libc++fs",
         "libsnapshot_cow",
-    ]
+    ],
 }
 
 cc_library_static {
     name: "libsnapshot_init",
-    native_coverage : true,
+    native_coverage: true,
     defaults: ["libsnapshot_defaults"],
     srcs: [":libsnapshot_sources"],
     ramdisk_available: true,
@@ -204,6 +204,10 @@ cc_library_static {
         "libsnapshot_cow/writer_v2.cpp",
         "libsnapshot_cow/writer_v3.cpp",
     ],
+
+    header_libs: [
+        "libstorage_literals_headers",
+    ],
     export_include_dirs: ["include"],
     host_supported: true,
     recovery_available: true,
@@ -243,7 +247,10 @@ cc_library_static {
 
 cc_defaults {
     name: "libsnapshot_test_defaults",
-    defaults: ["libsnapshot_defaults", "libsnapshot_cow_defaults"],
+    defaults: [
+        "libsnapshot_defaults",
+        "libsnapshot_cow_defaults",
+    ],
     srcs: [
         "partition_cow_creator_test.cpp",
         "snapshot_metadata_updater_test.cpp",
@@ -283,10 +290,13 @@ cc_defaults {
 
 cc_test {
     name: "vts_libsnapshot_test",
-    defaults: ["libsnapshot_test_defaults", "libsnapshot_hal_deps"],
+    defaults: [
+        "libsnapshot_test_defaults",
+        "libsnapshot_hal_deps",
+    ],
     test_suites: [
         "vts",
-        "device-tests"
+        "device-tests",
     ],
     test_options: {
         min_shipping_api_level: 30,
@@ -295,12 +305,15 @@ cc_test {
 
 cc_test {
     name: "vab_legacy_tests",
-    defaults: ["libsnapshot_test_defaults", "libsnapshot_hal_deps"],
+    defaults: [
+        "libsnapshot_test_defaults",
+        "libsnapshot_hal_deps",
+    ],
     cppflags: [
         "-DLIBSNAPSHOT_TEST_VAB_LEGACY",
     ],
     test_suites: [
-        "device-tests"
+        "device-tests",
     ],
     test_options: {
         // Legacy VAB launched in Android R.
@@ -310,12 +323,15 @@ cc_test {
 
 cc_test {
     name: "vabc_legacy_tests",
-    defaults: ["libsnapshot_test_defaults", "libsnapshot_hal_deps"],
+    defaults: [
+        "libsnapshot_test_defaults",
+        "libsnapshot_hal_deps",
+    ],
     cppflags: [
         "-DLIBSNAPSHOT_TEST_VABC_LEGACY",
     ],
     test_suites: [
-        "device-tests"
+        "device-tests",
     ],
     test_options: {
         // Legacy VABC launched in Android S.
@@ -343,7 +359,10 @@ cc_test {
 
 cc_binary {
     name: "snapshotctl",
-    defaults: ["libsnapshot_cow_defaults", "libsnapshot_hal_deps"],
+    defaults: [
+        "libsnapshot_cow_defaults",
+        "libsnapshot_hal_deps",
+    ],
     srcs: [
         "snapshotctl.cpp",
     ],
@@ -412,8 +431,11 @@ cc_test {
         "libgtest",
         "libsnapshot_cow",
     ],
+    header_libs: [
+        "libstorage_literals_headers",
+    ],
     test_suites: [
-        "device-tests"
+        "device-tests",
     ],
     test_options: {
         min_shipping_api_level: 30,
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index d410c14ee01f..8f6223434c79 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -201,6 +201,12 @@ static constexpr uint64_t kCowOpSourceInfoDataMask = (1ULL << 48) - 1;
 static constexpr uint64_t kCowOpSourceInfoTypeBit = 60;
 static constexpr uint64_t kCowOpSourceInfoTypeNumBits = 4;
 static constexpr uint64_t kCowOpSourceInfoTypeMask = (1ULL << kCowOpSourceInfoTypeNumBits) - 1;
+
+static constexpr uint64_t kCowOpSourceInfoCompressionBit = 57;
+static constexpr uint64_t kCowOpSourceInfoCompressionNumBits = 3;
+static constexpr uint64_t kCowOpSourceInfoCompressionMask =
+        ((1ULL << kCowOpSourceInfoCompressionNumBits) - 1);
+
 // The on disk format of cow (currently ==  CowOperation)
 struct CowOperationV3 {
     // If this operation reads from the data section of the COW, this contains
@@ -211,8 +217,8 @@ struct CowOperationV3 {
     uint32_t new_block;
 
     // source_info with have the following layout
-    // |---4 bits ---| ---12 bits---| --- 48 bits ---|
-    // |--- type --- | -- unused -- | --- source --- |
+    // |--- 4 bits -- | --------- 3 bits ------ | --- 9 bits --- | --- 48 bits ---|
+    // |--- type ---  | -- compression factor --| --- unused --- | --- source --- |
     //
     // The value of |source| depends on the operation code.
     //
@@ -225,6 +231,17 @@ struct CowOperationV3 {
     // For ops other than Label:
     //  Bits 47-62 are reserved and must be zero.
     // A block is compressed if it’s data is < block_sz
+    //
+    // Bits [57-59] represents the compression factor.
+    //
+    //       Compression - factor
+    // ==========================
+    // 000 -  4k
+    // 001 -  8k
+    // 010 -  16k
+    // ...
+    // 110 -  256k
+    //
     uint64_t source_info_;
     constexpr uint64_t source() const { return source_info_ & kCowOpSourceInfoDataMask; }
     constexpr void set_source(uint64_t source) {
@@ -245,6 +262,20 @@ struct CowOperationV3 {
         source_info_ |= (static_cast<uint64_t>(type) & kCowOpSourceInfoTypeMask)
                         << kCowOpSourceInfoTypeBit;
     }
+    constexpr void set_compression_bits(uint8_t compression_factor) {
+        // Clear the 3 bits from bit 57 - [57-59]
+        source_info_ &= ~(kCowOpSourceInfoCompressionMask << kCowOpSourceInfoCompressionBit);
+        // Set the actual compression factor
+        source_info_ |=
+                (static_cast<uint64_t>(compression_factor) & kCowOpSourceInfoCompressionMask)
+                << kCowOpSourceInfoCompressionBit;
+    }
+    constexpr uint8_t compression_bits() const {
+        // Grab the 3 bits from [57-59]
+        const auto compression_factor =
+                (source_info_ >> kCowOpSourceInfoCompressionBit) & kCowOpSourceInfoCompressionMask;
+        return static_cast<uint8_t>(compression_factor);
+    }
 } __attribute__((packed));
 
 // Ensure that getters/setters added to CowOperationV3 does not increases size
@@ -326,5 +357,7 @@ bool IsOrderedOp(const CowOperation& op);
 // Convert compression name to internal value.
 std::optional<CowCompressionAlgorithm> CompressionAlgorithmFromString(std::string_view name);
 
+// Return block size used for compression
+size_t CowOpCompressionSize(const CowOperation* op, size_t block_size);
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 0194ffd7b692..89699dceed9d 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -119,9 +119,9 @@ class ICowWriter {
 
 class CompressWorker {
   public:
-    CompressWorker(std::unique_ptr<ICompressor>&& compressor, uint32_t block_size);
+    CompressWorker(std::unique_ptr<ICompressor>&& compressor);
     bool RunThread();
-    void EnqueueCompressBlocks(const void* buffer, size_t num_blocks);
+    void EnqueueCompressBlocks(const void* buffer, size_t block_size, size_t num_blocks);
     bool GetCompressedBuffers(std::vector<std::basic_string<uint8_t>>* compressed_buf);
     void Finalize();
     static uint32_t GetDefaultCompressionLevel(CowCompressionAlgorithm compression);
@@ -134,20 +134,22 @@ class CompressWorker {
     struct CompressWork {
         const void* buffer;
         size_t num_blocks;
+        size_t block_size;
         bool compression_status = false;
         std::vector<std::basic_string<uint8_t>> compressed_data;
     };
 
     std::unique_ptr<ICompressor> compressor_;
-    uint32_t block_size_;
 
     std::queue<CompressWork> work_queue_;
     std::queue<CompressWork> compressed_queue_;
     std::mutex lock_;
     std::condition_variable cv_;
     bool stopped_ = false;
+    size_t total_submitted_ = 0;
+    size_t total_processed_ = 0;
 
-    bool CompressBlocks(const void* buffer, size_t num_blocks,
+    bool CompressBlocks(const void* buffer, size_t num_blocks, size_t block_size,
                         std::vector<std::basic_string<uint8_t>>* compressed_data);
 };
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
index abc7d336f40c..c7a5f05d4fb4 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
@@ -208,9 +208,9 @@ class ZstdCompressor final : public ICompressor {
     std::unique_ptr<ZSTD_CCtx, decltype(&ZSTD_freeCCtx)> zstd_context_;
 };
 
-bool CompressWorker::CompressBlocks(const void* buffer, size_t num_blocks,
+bool CompressWorker::CompressBlocks(const void* buffer, size_t num_blocks, size_t block_size,
                                     std::vector<std::basic_string<uint8_t>>* compressed_data) {
-    return CompressBlocks(compressor_.get(), block_size_, buffer, num_blocks, compressed_data);
+    return CompressBlocks(compressor_.get(), block_size, buffer, num_blocks, compressed_data);
 }
 
 bool CompressWorker::CompressBlocks(ICompressor* compressor, size_t block_size, const void* buffer,
@@ -254,7 +254,8 @@ bool CompressWorker::RunThread() {
         }
 
         // Compress blocks
-        bool ret = CompressBlocks(blocks.buffer, blocks.num_blocks, &blocks.compressed_data);
+        bool ret = CompressBlocks(blocks.buffer, blocks.num_blocks, blocks.block_size,
+                                  &blocks.compressed_data);
         blocks.compression_status = ret;
         {
             std::lock_guard<std::mutex> lock(lock_);
@@ -273,35 +274,31 @@ bool CompressWorker::RunThread() {
     return true;
 }
 
-void CompressWorker::EnqueueCompressBlocks(const void* buffer, size_t num_blocks) {
+void CompressWorker::EnqueueCompressBlocks(const void* buffer, size_t block_size,
+                                           size_t num_blocks) {
     {
         std::lock_guard<std::mutex> lock(lock_);
 
         CompressWork blocks = {};
         blocks.buffer = buffer;
+        blocks.block_size = block_size;
         blocks.num_blocks = num_blocks;
         work_queue_.push(std::move(blocks));
+        total_submitted_ += 1;
     }
     cv_.notify_all();
 }
 
 bool CompressWorker::GetCompressedBuffers(std::vector<std::basic_string<uint8_t>>* compressed_buf) {
-    {
+    while (true) {
         std::unique_lock<std::mutex> lock(lock_);
-        while (compressed_queue_.empty() && !stopped_) {
+        while ((total_submitted_ != total_processed_) && compressed_queue_.empty() && !stopped_) {
             cv_.wait(lock);
         }
-
-        if (stopped_) {
-            return true;
-        }
-    }
-
-    {
-        std::lock_guard<std::mutex> lock(lock_);
         while (compressed_queue_.size() > 0) {
             CompressWork blocks = std::move(compressed_queue_.front());
             compressed_queue_.pop();
+            total_processed_ += 1;
 
             if (blocks.compression_status) {
                 compressed_buf->insert(compressed_buf->end(),
@@ -312,9 +309,12 @@ bool CompressWorker::GetCompressedBuffers(std::vector<std::basic_string<uint8_t>
                 return false;
             }
         }
+        if ((total_submitted_ == total_processed_) || stopped_) {
+            total_submitted_ = 0;
+            total_processed_ = 0;
+            return true;
+        }
     }
-
-    return true;
 }
 
 std::unique_ptr<ICompressor> ICompressor::Brotli(uint32_t compression_level,
@@ -344,8 +344,8 @@ void CompressWorker::Finalize() {
     cv_.notify_all();
 }
 
-CompressWorker::CompressWorker(std::unique_ptr<ICompressor>&& compressor, uint32_t block_size)
-    : compressor_(std::move(compressor)), block_size_(block_size) {}
+CompressWorker::CompressWorker(std::unique_ptr<ICompressor>&& compressor)
+    : compressor_(std::move(compressor)) {}
 
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
index 8d1786c56046..4e1c6668c6a6 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
@@ -21,6 +21,7 @@
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
 #include <libsnapshot/cow_format.h>
+#include <storage_literals/storage_literals.h>
 #include "writer_v2.h"
 #include "writer_v3.h"
 
@@ -28,6 +29,7 @@ namespace android {
 namespace snapshot {
 
 using android::base::unique_fd;
+using namespace android::storage_literals;
 
 std::ostream& EmitCowTypeString(std::ostream& os, CowOperationType cow_type) {
     switch (cow_type) {
@@ -174,5 +176,10 @@ std::unique_ptr<ICowWriter> CreateCowEstimator(uint32_t version, const CowOption
     return CreateCowWriter(version, options, unique_fd{-1}, std::nullopt);
 }
 
+size_t CowOpCompressionSize(const CowOperation* op, size_t block_size) {
+    uint8_t compression_bits = op->compression_bits();
+    return (block_size << compression_bits);
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 1b4a971ca064..d6a03ca75ade 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -26,6 +26,7 @@
 #include <android-base/logging.h>
 #include <libsnapshot/cow_format.h>
 #include <libsnapshot/cow_reader.h>
+#include <storage_literals/storage_literals.h>
 #include <zlib.h>
 
 #include "cow_decompress.h"
@@ -35,6 +36,8 @@
 namespace android {
 namespace snapshot {
 
+using namespace android::storage_literals;
+
 bool ReadCowHeader(android::base::borrowed_fd fd, CowHeaderV3* header) {
     if (lseek(fd.get(), 0, SEEK_SET) < 0) {
         PLOG(ERROR) << "lseek header failed";
@@ -705,6 +708,11 @@ uint8_t CowReader::GetCompressionType() {
 ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_size,
                             size_t ignore_bytes) {
     std::unique_ptr<IDecompressor> decompressor;
+    const size_t op_buf_size = CowOpCompressionSize(op, header_.block_size);
+    if (!op_buf_size) {
+        LOG(ERROR) << "Compression size is zero. op: " << *op;
+        return -1;
+    }
     switch (GetCompressionType()) {
         case kCowCompressNone:
             break;
@@ -715,12 +723,12 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
             decompressor = IDecompressor::Brotli();
             break;
         case kCowCompressZstd:
-            if (header_.block_size != op->data_length) {
+            if (op_buf_size != op->data_length) {
                 decompressor = IDecompressor::Zstd();
             }
             break;
         case kCowCompressLz4:
-            if (header_.block_size != op->data_length) {
+            if (op_buf_size != op->data_length) {
                 decompressor = IDecompressor::Lz4();
             }
             break;
@@ -736,14 +744,14 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_
         offset = op->source();
     }
     if (!decompressor ||
-        ((op->data_length == header_.block_size) && (header_.prefix.major_version == 3))) {
+        ((op->data_length == op_buf_size) && (header_.prefix.major_version == 3))) {
         CowDataStream stream(this, offset + ignore_bytes, op->data_length - ignore_bytes);
         return stream.ReadFully(buffer, buffer_size);
     }
 
     CowDataStream stream(this, offset, op->data_length);
     decompressor->set_stream(&stream);
-    return decompressor->Decompress(buffer, buffer_size, header_.block_size, ignore_bytes);
+    return decompressor->Decompress(buffer, buffer_size, op_buf_size, ignore_bytes);
 }
 
 bool CowReader::GetSourceOffset(const CowOperation* op, uint64_t* source_offset) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
index fe977b723251..a35b61404ce7 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/parser_v2.cpp
@@ -206,6 +206,8 @@ bool CowParserV2::Translate(TranslatedCowOps* out) {
 
         auto& new_op = out->ops->at(i);
         new_op.set_type(v2_op.type);
+        // v2 ops always have 4k compression
+        new_op.set_compression_bits(0);
         new_op.data_length = v2_op.data_length;
 
         if (v2_op.new_block > std::numeric_limits<uint32_t>::max()) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index de602138debc..3c5b394be1e1 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -18,6 +18,7 @@
 #include <libsnapshot/cow_format.h>
 #include <libsnapshot/cow_reader.h>
 #include <libsnapshot/cow_writer.h>
+#include <storage_literals/storage_literals.h>
 #include "writer_v2.h"
 #include "writer_v3.h"
 
@@ -29,6 +30,9 @@ using testing::AssertionSuccess;
 namespace android {
 namespace snapshot {
 
+using namespace android::storage_literals;
+using ::testing::TestWithParam;
+
 class CowTestV3 : public ::testing::Test {
   protected:
     virtual void SetUp() override {
@@ -484,14 +488,14 @@ TEST_F(CowTestV3, BufferMetadataSyncTest) {
     ASSERT_TRUE(reader.Parse(cow_->fd));
 
     auto header = reader.header_v3();
-    ASSERT_EQ(header.sequence_data_count, 0);
+    ASSERT_EQ(header.sequence_data_count, static_cast<uint64_t>(0));
     ASSERT_EQ(header.resume_point_count, 0);
     ASSERT_EQ(header.resume_point_max, 4);
 
     writer->AddLabel(0);
     ASSERT_TRUE(reader.Parse(cow_->fd));
     header = reader.header_v3();
-    ASSERT_EQ(header.sequence_data_count, 0);
+    ASSERT_EQ(header.sequence_data_count, static_cast<uint64_t>(0));
     ASSERT_EQ(header.resume_point_count, 1);
     ASSERT_EQ(header.resume_point_max, 4);
 
@@ -699,5 +703,189 @@ TEST_F(CowTestV3, CheckOpCount) {
     ASSERT_FALSE(writer->AddZeroBlocks(0, 19));
 }
 
+struct TestParam {
+    std::string compression;
+    int block_size;
+    int num_threads;
+    size_t cluster_ops;
+};
+
+class VariableBlockTest : public ::testing::TestWithParam<TestParam> {
+  protected:
+    virtual void SetUp() override {
+        cow_ = std::make_unique<TemporaryFile>();
+        ASSERT_GE(cow_->fd, 0) << strerror(errno);
+    }
+
+    virtual void TearDown() override { cow_ = nullptr; }
+
+    unique_fd GetCowFd() { return unique_fd{dup(cow_->fd)}; }
+
+    std::unique_ptr<TemporaryFile> cow_;
+};
+
+// Helper to check read sizes.
+static inline void ReadBlockData(CowReader& reader, const CowOperation* op, void* buffer,
+                                 size_t size) {
+    size_t block_size = CowOpCompressionSize(op, 4096);
+    std::string data(block_size, '\0');
+    size_t value = reader.ReadData(op, data.data(), block_size);
+    ASSERT_TRUE(value == block_size);
+    std::memcpy(buffer, data.data(), size);
+}
+
+TEST_P(VariableBlockTest, VariableBlockCompressionTest) {
+    const TestParam params = GetParam();
+
+    CowOptions options;
+    options.op_count_max = 100000;
+    options.compression = params.compression;
+    options.num_compress_threads = params.num_threads;
+    options.batch_write = true;
+    options.compression_factor = params.block_size;
+    options.cluster_ops = params.cluster_ops;
+
+    CowWriterV3 writer(options, GetCowFd());
+
+    ASSERT_TRUE(writer.Initialize());
+
+    std::string xor_data = "This is test data-1. Testing xor";
+    xor_data.resize(options.block_size, '\0');
+    ASSERT_TRUE(writer.AddXorBlocks(50, xor_data.data(), xor_data.size(), 24, 10));
+
+    // Large number of blocks
+    std::string data = "This is test data-2. Testing replace ops";
+    data.resize(options.block_size * 2048, '\0');
+    ASSERT_TRUE(writer.AddRawBlocks(100, data.data(), data.size()));
+
+    std::string data2 = "This is test data-3. Testing replace ops";
+    data2.resize(options.block_size * 259, '\0');
+    ASSERT_TRUE(writer.AddRawBlocks(6000, data2.data(), data2.size()));
+
+    // Test data size is smaller than block size
+
+    // 4k block
+    std::string data3 = "This is test data-4. Testing replace ops";
+    data3.resize(options.block_size, '\0');
+    ASSERT_TRUE(writer.AddRawBlocks(9000, data3.data(), data3.size()));
+
+    // 8k block
+    std::string data4;
+    data4.resize(options.block_size * 2, '\0');
+    for (size_t i = 0; i < data4.size(); i++) {
+        data4[i] = static_cast<char>('A' + i / options.block_size);
+    }
+    ASSERT_TRUE(writer.AddRawBlocks(10000, data4.data(), data4.size()));
+
+    // 16k block
+    std::string data5;
+    data.resize(options.block_size * 4, '\0');
+    for (int i = 0; i < data5.size(); i++) {
+        data5[i] = static_cast<char>('C' + i / options.block_size);
+    }
+    ASSERT_TRUE(writer.AddRawBlocks(11000, data5.data(), data5.size()));
+
+    // 64k Random buffer which cannot be compressed
+    unique_fd rnd_fd(open("/dev/random", O_RDONLY));
+    ASSERT_GE(rnd_fd, 0);
+    std::string random_buffer;
+    random_buffer.resize(65536, '\0');
+    ASSERT_EQ(android::base::ReadFullyAtOffset(rnd_fd, random_buffer.data(), 65536, 0), true);
+    ASSERT_TRUE(writer.AddRawBlocks(12000, random_buffer.data(), 65536));
+
+    ASSERT_TRUE(writer.Finalize());
+
+    ASSERT_EQ(lseek(cow_->fd, 0, SEEK_SET), 0);
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    auto iter = reader.GetOpIter();
+    ASSERT_NE(iter, nullptr);
+
+    while (!iter->AtEnd()) {
+        auto op = iter->Get();
+
+        if (op->type() == kCowXorOp) {
+            std::string sink(xor_data.size(), '\0');
+            ASSERT_EQ(op->new_block, 50);
+            ASSERT_EQ(op->source(), 98314);  // 4096 * 24 + 10
+            ReadBlockData(reader, op, sink.data(), sink.size());
+            ASSERT_EQ(sink, xor_data);
+        }
+        if (op->type() == kCowReplaceOp) {
+            if (op->new_block == 100) {
+                data.resize(options.block_size);
+                std::string sink(data.size(), '\0');
+                ReadBlockData(reader, op, sink.data(), sink.size());
+                ASSERT_EQ(sink.size(), data.size());
+                ASSERT_EQ(sink, data);
+            }
+            if (op->new_block == 6000) {
+                data2.resize(options.block_size);
+                std::string sink(data2.size(), '\0');
+                ReadBlockData(reader, op, sink.data(), sink.size());
+                ASSERT_EQ(sink, data2);
+            }
+            if (op->new_block == 9000) {
+                std::string sink(data3.size(), '\0');
+                ReadBlockData(reader, op, sink.data(), sink.size());
+                ASSERT_EQ(sink, data3);
+            }
+            if (op->new_block == 10000) {
+                data4.resize(options.block_size);
+                std::string sink(options.block_size, '\0');
+                ReadBlockData(reader, op, sink.data(), sink.size());
+                ASSERT_EQ(sink, data4);
+            }
+            if (op->new_block == 11000) {
+                data5.resize(options.block_size);
+                std::string sink(options.block_size, '\0');
+                ReadBlockData(reader, op, sink.data(), sink.size());
+                ASSERT_EQ(sink, data5);
+            }
+            if (op->new_block == 12000) {
+                random_buffer.resize(options.block_size);
+                std::string sink(options.block_size, '\0');
+                ReadBlockData(reader, op, sink.data(), sink.size());
+                ASSERT_EQ(sink, random_buffer);
+            }
+        }
+
+        iter->Next();
+    }
+}
+
+std::vector<TestParam> GetTestConfigs() {
+    std::vector<TestParam> testParams;
+
+    std::vector<int> block_sizes = {4_KiB, 8_KiB, 16_KiB, 32_KiB, 64_KiB, 128_KiB, 256_KiB};
+    std::vector<std::string> compression_algo = {"none", "lz4", "zstd", "gz"};
+    std::vector<int> threads = {1, 2};
+    // This will also test batch size
+    std::vector<size_t> cluster_ops = {1, 256};
+
+    // This should test 112 combination
+    for (auto block : block_sizes) {
+        for (auto compression : compression_algo) {
+            for (auto thread : threads) {
+                for (auto cluster : cluster_ops) {
+                    TestParam param;
+                    param.block_size = block;
+                    param.compression = compression;
+                    param.num_threads = thread;
+                    param.cluster_ops = cluster;
+                    testParams.push_back(std::move(param));
+                }
+            }
+        }
+    }
+
+    return testParams;
+}
+
+INSTANTIATE_TEST_SUITE_P(CompressorsWithVariableBlocks, VariableBlockTest,
+                         ::testing::ValuesIn(GetTestConfigs()));
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index 75cd1114df42..d0864e0a3b69 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -185,7 +185,7 @@ void CowWriterV2::InitWorkers() {
     for (int i = 0; i < num_compress_threads_; i++) {
         std::unique_ptr<ICompressor> compressor =
                 ICompressor::Create(compression_, header_.block_size);
-        auto wt = std::make_unique<CompressWorker>(std::move(compressor), header_.block_size);
+        auto wt = std::make_unique<CompressWorker>(std::move(compressor));
         threads_.emplace_back(std::async(std::launch::async, &CompressWorker::RunThread, wt.get()));
         compress_threads_.push_back(std::move(wt));
     }
@@ -353,7 +353,7 @@ bool CowWriterV2::CompressBlocks(size_t num_blocks, const void* data) {
         if (i == num_threads - 1) {
             num_blocks_per_thread = num_blocks;
         }
-        worker->EnqueueCompressBlocks(iter, num_blocks_per_thread);
+        worker->EnqueueCompressBlocks(iter, header_.block_size, num_blocks_per_thread);
         iter += (num_blocks_per_thread * header_.block_size);
         num_blocks -= num_blocks_per_thread;
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 251b24e6aca6..c92460a7c699 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -37,6 +37,7 @@
 #include <libsnapshot/cow_compress.h>
 #include <libsnapshot_cow/parser_v3.h>
 #include <linux/fs.h>
+#include <storage_literals/storage_literals.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
 #include <numeric>
@@ -54,6 +55,7 @@ namespace snapshot {
 
 static_assert(sizeof(off_t) == sizeof(uint64_t));
 
+using namespace android::storage_literals;
 using android::base::unique_fd;
 
 // Divide |x| by |y| and round up to the nearest integer.
@@ -77,9 +79,9 @@ void CowWriterV3::InitWorkers() {
     threads_.clear();
     for (size_t i = 0; i < num_compress_threads_; i++) {
         std::unique_ptr<ICompressor> compressor =
-                ICompressor::Create(compression_, header_.block_size);
+                ICompressor::Create(compression_, header_.max_compression_size);
         auto&& wt = compress_threads_.emplace_back(
-                std::make_unique<CompressWorker>(std::move(compressor), header_.block_size));
+                std::make_unique<CompressWorker>(std::move(compressor)));
         threads_.emplace_back(std::thread([wt = wt.get()]() { wt->RunThread(); }));
     }
     LOG(INFO) << num_compress_threads_ << " thread used for compression";
@@ -111,10 +113,15 @@ void CowWriterV3::SetupHeaders() {
     header_.op_count_max = 0;
     header_.compression_algorithm = kCowCompressNone;
     header_.max_compression_size = options_.compression_factor;
-    return;
 }
 
 bool CowWriterV3::ParseOptions() {
+    if (!header_.max_compression_size || !IsBlockAligned(header_.max_compression_size)) {
+        LOG(ERROR) << "Invalid compression factor: " << header_.max_compression_size;
+        return false;
+    }
+
+    LOG(INFO) << "Compression factor: " << header_.max_compression_size;
     num_compress_threads_ = std::max(int(options_.num_compress_threads), 1);
     auto parts = android::base::Split(options_.compression, ",");
     if (parts.size() > 2) {
@@ -154,20 +161,22 @@ bool CowWriterV3::ParseOptions() {
 
     compression_.algorithm = *algorithm;
     if (compression_.algorithm != kCowCompressNone) {
-        compressor_ = ICompressor::Create(compression_, header_.block_size);
+        compressor_ = ICompressor::Create(compression_, header_.max_compression_size);
         if (compressor_ == nullptr) {
             LOG(ERROR) << "Failed to create compressor for " << compression_.algorithm;
             return false;
         }
-        if (options_.cluster_ops &&
-            (android::base::GetBoolProperty("ro.virtual_ab.batch_writes", false) ||
-             options_.batch_write)) {
-            batch_size_ = std::max<size_t>(options_.cluster_ops, 1);
-            data_vec_.reserve(batch_size_);
-            cached_data_.reserve(batch_size_);
-            cached_ops_.reserve(batch_size_);
-        }
     }
+
+    if (options_.cluster_ops &&
+        (android::base::GetBoolProperty("ro.virtual_ab.batch_writes", false) ||
+         options_.batch_write)) {
+        batch_size_ = std::max<size_t>(options_.cluster_ops, 1);
+        data_vec_.reserve(batch_size_);
+        cached_data_.reserve(batch_size_);
+        cached_ops_.reserve(batch_size_);
+    }
+
     if (batch_size_ > 1) {
         LOG(INFO) << "Batch writes: enabled with batch size " << batch_size_;
     } else {
@@ -178,6 +187,7 @@ bool CowWriterV3::ParseOptions() {
         num_compress_threads_ = options_.num_compress_threads;
     }
     InitWorkers();
+
     return true;
 }
 
@@ -206,6 +216,14 @@ bool CowWriterV3::Initialize(std::optional<uint64_t> label) {
         }
     }
 
+    // TODO: b/322279333
+    // Set compression factor to 4k during estimation.
+    // Once COW estimator is ready to support variable
+    // block size, this check has to be removed.
+    if (IsEstimating()) {
+        header_.max_compression_size = header_.block_size;
+    }
+
     return true;
 }
 
@@ -328,6 +346,46 @@ bool CowWriterV3::NeedsFlush() const {
     return cached_data_.size() >= batch_size_ || cached_ops_.size() >= batch_size_ * 16;
 }
 
+bool CowWriterV3::ConstructCowOpCompressedBuffers(uint64_t new_block_start, const void* data,
+                                                  uint64_t old_block, uint16_t offset,
+                                                  CowOperationType type, size_t blocks_to_write) {
+    size_t compressed_bytes = 0;
+    auto&& blocks = CompressBlocks(blocks_to_write, data, type);
+    if (blocks.empty()) {
+        LOG(ERROR) << "Failed to compress blocks " << new_block_start << ", " << blocks_to_write
+                   << ", actual number of blocks received from compressor " << blocks.size();
+        return false;
+    }
+    size_t blocks_written = 0;
+    for (size_t blk_index = 0; blk_index < blocks.size(); blk_index++) {
+        CowOperation& op = cached_ops_.emplace_back();
+        auto& vec = data_vec_.emplace_back();
+        CompressedBuffer buffer = std::move(blocks[blk_index]);
+        auto& compressed_data = cached_data_.emplace_back(std::move(buffer.compressed_data));
+        op.new_block = new_block_start + blocks_written;
+
+        op.set_type(type);
+        op.set_compression_bits(std::log2(buffer.compression_factor / header_.block_size));
+
+        if (type == kCowXorOp) {
+            op.set_source((old_block + blocks_written) * header_.block_size + offset);
+        } else {
+            op.set_source(next_data_pos_ + compressed_bytes);
+        }
+
+        vec = {.iov_base = compressed_data.data(), .iov_len = compressed_data.size()};
+        op.data_length = vec.iov_len;
+        compressed_bytes += op.data_length;
+        blocks_written += (buffer.compression_factor / header_.block_size);
+    }
+    if (blocks_written != blocks_to_write) {
+        LOG(ERROR) << "Total compressed blocks: " << blocks_written
+                   << " Expected: " << blocks_to_write;
+        return false;
+    }
+    return true;
+}
+
 bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t size,
                              uint64_t old_block, uint16_t offset, CowOperationType type) {
     if (compression_.algorithm != kCowCompressNone && compressor_ == nullptr) {
@@ -341,38 +399,21 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
         return false;
     }
     for (size_t i = 0; i < num_blocks;) {
-        const auto blocks_to_write =
+        const size_t blocks_to_write =
                 std::min<size_t>(batch_size_ - cached_data_.size(), num_blocks - i);
-        size_t compressed_bytes = 0;
-        auto&& blocks = CompressBlocks(blocks_to_write, bytes + header_.block_size * i);
-        if (blocks.size() != blocks_to_write) {
-            LOG(ERROR) << "Failed to compress blocks " << new_block_start + i << ", "
-                       << blocks_to_write << ", actual number of blocks received from compressor "
-                       << blocks.size();
+
+        if (!ConstructCowOpCompressedBuffers(new_block_start + i, bytes + header_.block_size * i,
+                                             old_block + i, offset, type, blocks_to_write)) {
             return false;
         }
-        for (size_t j = 0; j < blocks_to_write; j++) {
-            CowOperation& op = cached_ops_.emplace_back();
-            auto& vec = data_vec_.emplace_back();
-            auto& compressed_data = cached_data_.emplace_back(std::move(blocks[j]));
-            op.new_block = new_block_start + i + j;
-
-            op.set_type(type);
-            if (type == kCowXorOp) {
-                op.set_source((old_block + i + j) * header_.block_size + offset);
-            } else {
-                op.set_source(next_data_pos_ + compressed_bytes);
-            }
-            vec = {.iov_base = compressed_data.data(), .iov_len = compressed_data.size()};
-            op.data_length = vec.iov_len;
-            compressed_bytes += op.data_length;
-        }
+
         if (NeedsFlush() && !FlushCacheOps()) {
             LOG(ERROR) << "EmitBlocks with compression: write failed. new block: "
                        << new_block_start << " compression: " << compression_.algorithm
                        << ", op type: " << type;
             return false;
         }
+
         i += blocks_to_write;
     }
 
@@ -482,55 +523,165 @@ bool CowWriterV3::FlushCacheOps() {
     return true;
 }
 
-std::vector<std::basic_string<uint8_t>> CowWriterV3::CompressBlocks(const size_t num_blocks,
-                                                                    const void* data) {
-    const size_t num_threads = (num_blocks == 1) ? 1 : num_compress_threads_;
-    const size_t blocks_per_thread = DivRoundUp(num_blocks, num_threads);
-    std::vector<std::basic_string<uint8_t>> compressed_buf;
-    compressed_buf.clear();
-    const uint8_t* const iter = reinterpret_cast<const uint8_t*>(data);
-    if (compression_.algorithm == kCowCompressNone) {
-        for (size_t i = 0; i < num_blocks; i++) {
-            auto& buf = compressed_buf.emplace_back();
-            buf.resize(header_.block_size);
-            std::memcpy(buf.data(), iter + i * header_.block_size, header_.block_size);
+size_t CowWriterV3::GetCompressionFactor(const size_t blocks_to_compress,
+                                         CowOperationType type) const {
+    // For XOR ops, we don't support bigger block size compression yet.
+    // For bigger block size support, snapshot-merge also has to changed. We
+    // aren't there yet; hence, just stick to 4k for now until
+    // snapshot-merge is ready for XOR operation.
+    if (type == kCowXorOp) {
+        return header_.block_size;
+    }
+
+    size_t compression_factor = header_.max_compression_size;
+    while (compression_factor > header_.block_size) {
+        size_t num_blocks = compression_factor / header_.block_size;
+        if (blocks_to_compress >= num_blocks) {
+            return compression_factor;
         }
-        return compressed_buf;
+        compression_factor >>= 1;
     }
-    if (num_threads <= 1) {
-        if (!CompressWorker::CompressBlocks(compressor_.get(), header_.block_size, data, num_blocks,
-                                            &compressed_buf)) {
+    return header_.block_size;
+}
+
+std::vector<CowWriterV3::CompressedBuffer> CowWriterV3::ProcessBlocksWithNoCompression(
+        const size_t num_blocks, const void* data, CowOperationType type) {
+    size_t blocks_to_compress = num_blocks;
+    const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
+    std::vector<CompressedBuffer> compressed_vec;
+
+    while (blocks_to_compress) {
+        CompressedBuffer buffer;
+
+        const size_t compression_factor = GetCompressionFactor(blocks_to_compress, type);
+        size_t num_blocks = compression_factor / header_.block_size;
+
+        buffer.compression_factor = compression_factor;
+        buffer.compressed_data.resize(compression_factor);
+
+        // No compression. Just copy the data as-is.
+        std::memcpy(buffer.compressed_data.data(), iter, compression_factor);
+
+        compressed_vec.push_back(std::move(buffer));
+        blocks_to_compress -= num_blocks;
+        iter += compression_factor;
+    }
+    return compressed_vec;
+}
+
+std::vector<CowWriterV3::CompressedBuffer> CowWriterV3::ProcessBlocksWithCompression(
+        const size_t num_blocks, const void* data, CowOperationType type) {
+    size_t blocks_to_compress = num_blocks;
+    const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
+    std::vector<CompressedBuffer> compressed_vec;
+
+    while (blocks_to_compress) {
+        CompressedBuffer buffer;
+
+        const size_t compression_factor = GetCompressionFactor(blocks_to_compress, type);
+        size_t num_blocks = compression_factor / header_.block_size;
+
+        buffer.compression_factor = compression_factor;
+        // Compress the blocks
+        buffer.compressed_data = compressor_->Compress(iter, compression_factor);
+        if (buffer.compressed_data.empty()) {
+            PLOG(ERROR) << "Compression failed";
             return {};
         }
-    } else {
-        // Submit the blocks per thread. The retrieval of
-        // compressed buffers has to be done in the same order.
-        // We should not poll for completed buffers in a different order as the
-        // buffers are tightly coupled with block ordering.
-        for (size_t i = 0; i < num_threads; i++) {
-            CompressWorker* worker = compress_threads_[i].get();
-            const auto blocks_in_batch =
-                    std::min(num_blocks - i * blocks_per_thread, blocks_per_thread);
-            worker->EnqueueCompressBlocks(iter + i * blocks_per_thread * header_.block_size,
-                                          blocks_in_batch);
+
+        // Check if the buffer was indeed compressed
+        if (buffer.compressed_data.size() >= compression_factor) {
+            buffer.compressed_data.resize(compression_factor);
+            std::memcpy(buffer.compressed_data.data(), iter, compression_factor);
         }
 
-        for (size_t i = 0; i < num_threads; i++) {
-            CompressWorker* worker = compress_threads_[i].get();
-            if (!worker->GetCompressedBuffers(&compressed_buf)) {
-                return {};
-            }
+        compressed_vec.push_back(std::move(buffer));
+        blocks_to_compress -= num_blocks;
+        iter += compression_factor;
+    }
+    return compressed_vec;
+}
+
+std::vector<CowWriterV3::CompressedBuffer> CowWriterV3::ProcessBlocksWithThreadedCompression(
+        const size_t num_blocks, const void* data, CowOperationType type) {
+    const size_t num_threads = num_compress_threads_;
+    const size_t blocks_per_thread = DivRoundUp(num_blocks, num_threads);
+    const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
+
+    std::vector<CompressedBuffer> compressed_vec;
+    // Submit the blocks per thread. The retrieval of
+    // compressed buffers has to be done in the same order.
+    // We should not poll for completed buffers in a different order as the
+    // buffers are tightly coupled with block ordering.
+    for (size_t i = 0; i < num_threads; i++) {
+        CompressWorker* worker = compress_threads_[i].get();
+        auto blocks_in_batch = std::min(num_blocks - i * blocks_per_thread, blocks_per_thread);
+        // Enqueue the blocks to be compressed for each thread.
+        while (blocks_in_batch) {
+            CompressedBuffer buffer;
+
+            const size_t compression_factor = GetCompressionFactor(blocks_in_batch, type);
+            size_t num_blocks = compression_factor / header_.block_size;
+
+            buffer.compression_factor = compression_factor;
+            worker->EnqueueCompressBlocks(iter, compression_factor, 1);
+            compressed_vec.push_back(std::move(buffer));
+            blocks_in_batch -= num_blocks;
+            iter += compression_factor;
         }
     }
-    for (size_t i = 0; i < num_blocks; i++) {
+
+    // Fetch compressed buffers from the threads
+    std::vector<std::basic_string<uint8_t>> compressed_buf;
+    compressed_buf.clear();
+    for (size_t i = 0; i < num_threads; i++) {
+        CompressWorker* worker = compress_threads_[i].get();
+        if (!worker->GetCompressedBuffers(&compressed_buf)) {
+            return {};
+        }
+    }
+
+    if (compressed_vec.size() != compressed_buf.size()) {
+        LOG(ERROR) << "Compressed buffer size: " << compressed_buf.size()
+                   << " - Expected: " << compressed_vec.size();
+        return {};
+    }
+
+    iter = reinterpret_cast<const uint8_t*>(data);
+    // Walk through all the compressed buffers
+    for (size_t i = 0; i < compressed_buf.size(); i++) {
+        auto& buffer = compressed_vec[i];
         auto& block = compressed_buf[i];
-        if (block.size() >= header_.block_size) {
-            block.resize(header_.block_size);
-            std::memcpy(block.data(), iter + header_.block_size * i, header_.block_size);
+        size_t block_size = buffer.compression_factor;
+        // Check if the blocks was indeed compressed
+        if (block.size() >= block_size) {
+            buffer.compressed_data.resize(block_size);
+            std::memcpy(buffer.compressed_data.data(), iter, block_size);
+        } else {
+            // Compressed block
+            buffer.compressed_data.resize(block.size());
+            std::memcpy(buffer.compressed_data.data(), block.data(), block.size());
         }
+        iter += block_size;
+    }
+    return compressed_vec;
+}
+
+std::vector<CowWriterV3::CompressedBuffer> CowWriterV3::CompressBlocks(const size_t num_blocks,
+                                                                       const void* data,
+                                                                       CowOperationType type) {
+    if (compression_.algorithm == kCowCompressNone) {
+        return ProcessBlocksWithNoCompression(num_blocks, data, type);
+    }
+
+    const size_t num_threads = (num_blocks == 1) ? 1 : num_compress_threads_;
+
+    // If no threads are required, just compress the blocks inline.
+    if (num_threads <= 1) {
+        return ProcessBlocksWithCompression(num_blocks, data, type);
     }
 
-    return compressed_buf;
+    return ProcessBlocksWithThreadedCompression(num_blocks, data, type);
 }
 
 bool CowWriterV3::WriteOperation(std::basic_string_view<CowOperationV3> ops,
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index b19af60a34d6..4915e9c080c7 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -19,11 +19,15 @@
 #include <thread>
 #include <vector>
 
+#include <libsnapshot/cow_format.h>
+#include <storage_literals/storage_literals.h>
 #include "writer_base.h"
 
 namespace android {
 namespace snapshot {
 
+using namespace android::storage_literals;
+
 class CowWriterV3 : public CowWriterBase {
   public:
     explicit CowWriterV3(const CowOptions& options, android::base::unique_fd&& fd);
@@ -43,6 +47,10 @@ class CowWriterV3 : public CowWriterBase {
     virtual bool EmitSequenceData(size_t num_ops, const uint32_t* data) override;
 
   private:
+    struct CompressedBuffer {
+        size_t compression_factor;
+        std::basic_string<uint8_t> compressed_data;
+    };
     void SetupHeaders();
     bool NeedsFlush() const;
     bool ParseOptions();
@@ -52,11 +60,38 @@ class CowWriterV3 : public CowWriterBase {
                         std::basic_string_view<struct iovec> data);
     bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
                     uint16_t offset, CowOperationType type);
+    bool ConstructCowOpCompressedBuffers(uint64_t new_block_start, const void* data,
+                                         uint64_t old_block, uint16_t offset, CowOperationType type,
+                                         size_t blocks_to_write);
     bool CheckOpCount(size_t op_count);
 
   private:
-    std::vector<std::basic_string<uint8_t>> CompressBlocks(const size_t num_blocks,
-                                                           const void* data);
+    std::vector<CompressedBuffer> ProcessBlocksWithNoCompression(const size_t num_blocks,
+                                                                 const void* data,
+                                                                 CowOperationType type);
+    std::vector<CompressedBuffer> ProcessBlocksWithCompression(const size_t num_blocks,
+                                                               const void* data,
+                                                               CowOperationType type);
+    std::vector<CompressedBuffer> ProcessBlocksWithThreadedCompression(const size_t num_blocks,
+                                                                       const void* data,
+                                                                       CowOperationType type);
+    std::vector<CompressedBuffer> CompressBlocks(const size_t num_blocks, const void* data,
+                                                 CowOperationType type);
+    size_t GetCompressionFactor(const size_t blocks_to_compress, CowOperationType type) const;
+
+    constexpr bool IsBlockAligned(const size_t size) {
+        // These are the only block size supported. Block size beyond 256k
+        // may impact random read performance post OTA boot.
+        const size_t values[] = {4_KiB, 8_KiB, 16_KiB, 32_KiB, 64_KiB, 128_KiB, 256_KiB};
+
+        auto it = std::lower_bound(std::begin(values), std::end(values), size);
+
+        if (it != std::end(values) && *it == size) {
+            return true;
+        }
+        return false;
+    }
+
     bool ReadBackVerification();
     bool FlushCacheOps();
     void InitWorkers();

From 3ea911bc06385b0a158bbdeae54d812c69a9398e Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 8 Jan 2024 23:40:09 +0000
Subject: [PATCH 0697/1487] snapuserd: Add I/O path support for variable block
 size

The flow of I/O path is as follows:

1: When there is a I/O request for a given sector, we first
check the in-memory COW operation mapping for that sector.

2: If the mapping of sector to COW operation is found, then the
existing I/O path will work seamlessly. Even if the COW operation
encodes multiple blocks, we will discard the remaining data.

3: If the mapping of sector to COW operation is not found:
    a: Find the previous COW operation as the vector has sorted sectors.

    b: If the previous COW operation is a REPLACE op:
        i: Check if the current sector is encoded in the previous COW
	operations compressed block.

	ii: If the sector falls within the range of compressed blocks,
	retrieve the block offset.

	iii: De-compress the COW operation based on the compression
	factor.

	iv: memcpy the data based on the block offset.

	v: cache the COW operation pointer as subsequent I/O requests
	are sequential and can just be a memcpy at the correct offset.
    c: If the previous COW operation is not a REPLACE op or if the
       requested sector does not fall within the compression factor
       of the previous COW operation, then fallback and read the data
       from base device.

Snapshot-merge:

During merge of REPLACE ops, read the entire op in one shot, de-compress
multiple blocks and write all the blocks in one shot.

Performance:

go/variable-block-vabc-perf covers detail performance runs
on Pixel 6 for full and incremental OTA.

Bug: 319309466

Test: snapuserd_test covers all the I/O path with various block sizes.
About 252 cases with all combinations and tunables.

[==========] 252 tests from 4 test suites ran. (702565 ms total)
[  PASSED  ] 252 tests.

On Pixel 6:

=======================================
COW Writer V3:

for i in full, incremental OTA
   for j in 4k, 16k, 32k, 64k, 128, 256k
      for k in lz4, zstd, gz
	 install OTA, reboot, verify merge
=======================================
COW Writer V2:

for i in full, incremental OTA
  for j in 4k
    for k in lz4, zstd, gz
      install OTA, reboot, verity merge

=====================================

Change-Id: I4c3b5c3efa0d09677568b4396cc53db0e74e7c99
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../include/libsnapshot/cow_format.h          |   4 +
 .../include/libsnapshot/cow_reader.h          |   3 +
 .../libsnapshot_cow/cow_compress.cpp          |   2 +-
 .../libsnapshot_cow/cow_format.cpp            |  26 +
 .../libsnapshot_cow/cow_reader.cpp            |  15 +
 .../libsnapshot_cow/snapshot_reader.cpp       |  28 +-
 .../user-space-merge/merge_worker.cpp         |  47 +-
 .../user-space-merge/read_worker.cpp          | 174 +++++-
 .../snapuserd/user-space-merge/read_worker.h  |   7 +-
 .../user-space-merge/snapuserd_test.cpp       | 507 +++++++++++++++++-
 10 files changed, 774 insertions(+), 39 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 8f6223434c79..6865b194490d 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -359,5 +359,9 @@ std::optional<CowCompressionAlgorithm> CompressionAlgorithmFromString(std::strin
 
 // Return block size used for compression
 size_t CowOpCompressionSize(const CowOperation* op, size_t block_size);
+
+// Return the relative offset of the I/O block which the CowOperation
+// multi-block compression
+bool GetBlockOffset(const CowOperation* op, uint64_t io_block, size_t block_size, off_t* offset);
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index bf4c79f176e3..3f49c69a8a0e 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -162,6 +162,9 @@ class CowReader final : public ICowReader {
     // Creates a clone of the current CowReader without the file handlers
     std::unique_ptr<CowReader> CloneCowReader();
 
+    // Get the max compression size
+    uint32_t GetMaxCompressionSize();
+
     void UpdateMergeOpsCompleted(int num_merge_ops) { header_.num_merge_ops += num_merge_ops; }
 
   private:
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
index c7a5f05d4fb4..577cdbd96c25 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
@@ -223,7 +223,7 @@ bool CompressWorker::CompressBlocks(ICompressor* compressor, size_t block_size,
             PLOG(ERROR) << "CompressBlocks: Compression failed";
             return false;
         }
-        if (data.size() > std::numeric_limits<uint16_t>::max()) {
+        if (data.size() > std::numeric_limits<uint32_t>::max()) {
             LOG(ERROR) << "Compressed block is too large: " << data.size();
             return false;
         }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
index 4e1c6668c6a6..19014c0691c2 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_format.cpp
@@ -181,5 +181,31 @@ size_t CowOpCompressionSize(const CowOperation* op, size_t block_size) {
     return (block_size << compression_bits);
 }
 
+bool GetBlockOffset(const CowOperation* op, uint64_t io_block, size_t block_size, off_t* offset) {
+    const uint64_t new_block = op->new_block;
+
+    if (op->type() != kCowReplaceOp || io_block < new_block) {
+        LOG(VERBOSE) << "Invalid IO request for block: " << io_block
+                     << " CowOperation: new_block: " << new_block;
+        return false;
+    }
+
+    // Get the actual compression size
+    const size_t compression_size = CowOpCompressionSize(op, block_size);
+    // Find the number of blocks spanned
+    const size_t num_blocks = compression_size / block_size;
+    // Find the distance of the I/O block which this
+    // CowOperation encompasses
+    const size_t block_distance = io_block - new_block;
+    // Check if this block is within this range;
+    // if so, return the relative offset
+    if (block_distance < num_blocks) {
+        *offset = block_distance * block_size;
+        return true;
+    }
+
+    return false;
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index d6a03ca75ade..651649948133 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -164,6 +164,21 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
     return PrepMergeOps();
 }
 
+uint32_t CowReader::GetMaxCompressionSize() {
+    switch (header_.prefix.major_version) {
+        case 1:
+        case 2:
+            // Old versions supports only 4KB compression.
+            return header_.block_size;
+            ;
+        case 3:
+            return header_.max_compression_size;
+        default:
+            LOG(ERROR) << "Unknown version: " << header_.prefix.major_version;
+            return 0;
+    }
+}
+
 //
 // This sets up the data needed for MergeOpIter. MergeOpIter presents
 // data in the order we intend to merge in.
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
index 4e90a0f96d31..12073fc3e76d 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader.cpp
@@ -42,10 +42,21 @@ CompressedSnapshotReader::CompressedSnapshotReader(std::unique_ptr<ICowReader>&&
             op_iter_->Next();
             continue;
         }
+
+        size_t num_blocks = 1;
+        if (op->type() == kCowReplaceOp) {
+            num_blocks = (CowOpCompressionSize(op, block_size_) / block_size_);
+        }
         if (op->new_block >= ops_.size()) {
-            ops_.resize(op->new_block + 1, nullptr);
+            ops_.resize(op->new_block + num_blocks, nullptr);
+        }
+
+        size_t vec_index = op->new_block;
+        while (num_blocks) {
+            ops_[vec_index] = op;
+            num_blocks -= 1;
+            vec_index += 1;
         }
-        ops_[op->new_block] = op;
         op_iter_->Next();
     }
 }
@@ -172,11 +183,20 @@ ssize_t CompressedSnapshotReader::ReadBlock(uint64_t chunk, size_t start_offset,
     } else if (op->type() == kCowZeroOp) {
         memset(buffer, 0, bytes_to_read);
     } else if (op->type() == kCowReplaceOp) {
-        if (cow_->ReadData(op, buffer, bytes_to_read, start_offset) < bytes_to_read) {
-            LOG(ERROR) << "CompressedSnapshotReader failed to read replace op";
+        size_t buffer_size = CowOpCompressionSize(op, block_size_);
+        uint8_t temp_buffer[buffer_size];
+        if (cow_->ReadData(op, temp_buffer, buffer_size, 0) < buffer_size) {
+            LOG(ERROR) << "CompressedSnapshotReader failed to read replace op: buffer_size: "
+                       << buffer_size << "start_offset: " << start_offset;
             errno = EIO;
             return -1;
         }
+        off_t block_offset{};
+        if (!GetBlockOffset(op, chunk, block_size_, &block_offset)) {
+            LOG(ERROR) << "GetBlockOffset failed";
+            return -1;
+        }
+        std::memcpy(buffer, (char*)temp_buffer + block_offset + start_offset, bytes_to_read);
     } else if (op->type() == kCowXorOp) {
         borrowed_fd fd = GetSourceFd();
         if (fd < 0) {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index 1e7d0c0a2d44..bd7eaca747d6 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -13,10 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "merge_worker.h"
 
+#include <libsnapshot/cow_format.h>
 #include <pthread.h>
 
+#include "merge_worker.h"
 #include "snapuserd_core.h"
 #include "utility.h"
 
@@ -37,6 +38,7 @@ int MergeWorker::PrepareMerge(uint64_t* source_offset, int* pending_ops,
     int num_ops = *pending_ops;
     int nr_consecutive = 0;
     bool checkOrderedOp = (replace_zero_vec == nullptr);
+    size_t num_blocks = 1;
 
     do {
         if (!cowop_iter_->AtEnd() && num_ops) {
@@ -48,11 +50,15 @@ int MergeWorker::PrepareMerge(uint64_t* source_offset, int* pending_ops,
             *source_offset = cow_op->new_block * BLOCK_SZ;
             if (!checkOrderedOp) {
                 replace_zero_vec->push_back(cow_op);
+                if (cow_op->type() == kCowReplaceOp) {
+                    // Get the number of blocks this op has compressed
+                    num_blocks = (CowOpCompressionSize(cow_op, BLOCK_SZ) / BLOCK_SZ);
+                }
             }
 
             cowop_iter_->Next();
-            num_ops -= 1;
-            nr_consecutive = 1;
+            num_ops -= num_blocks;
+            nr_consecutive = num_blocks;
 
             while (!cowop_iter_->AtEnd() && num_ops) {
                 const CowOperation* op = cowop_iter_->Get();
@@ -66,11 +72,20 @@ int MergeWorker::PrepareMerge(uint64_t* source_offset, int* pending_ops,
                 }
 
                 if (!checkOrderedOp) {
+                    if (op->type() == kCowReplaceOp) {
+                        num_blocks = (CowOpCompressionSize(op, BLOCK_SZ) / BLOCK_SZ);
+                        if (num_ops < num_blocks) {
+                            break;
+                        }
+                    } else {
+                        // zero op
+                        num_blocks = 1;
+                    }
                     replace_zero_vec->push_back(op);
                 }
 
-                nr_consecutive += 1;
-                num_ops -= 1;
+                nr_consecutive += num_blocks;
+                num_ops -= num_blocks;
                 cowop_iter_->Next();
             }
         }
@@ -108,18 +123,24 @@ bool MergeWorker::MergeReplaceZeroOps() {
 
         for (size_t i = 0; i < replace_zero_vec.size(); i++) {
             const CowOperation* cow_op = replace_zero_vec[i];
-
-            void* buffer = bufsink_.AcquireBuffer(BLOCK_SZ);
-            if (!buffer) {
-                SNAP_LOG(ERROR) << "AcquireBuffer failed in MergeReplaceOps";
-                return false;
-            }
             if (cow_op->type() == kCowReplaceOp) {
-                if (!reader_->ReadData(cow_op, buffer, BLOCK_SZ)) {
+                size_t buffer_size = CowOpCompressionSize(cow_op, BLOCK_SZ);
+                void* buffer = bufsink_.AcquireBuffer(buffer_size);
+                if (!buffer) {
+                    SNAP_LOG(ERROR) << "AcquireBuffer failed in MergeReplaceOps";
+                    return false;
+                }
+                // Read the entire compressed buffer spanning multiple blocks
+                if (!reader_->ReadData(cow_op, buffer, buffer_size)) {
                     SNAP_LOG(ERROR) << "Failed to read COW in merge";
                     return false;
                 }
             } else {
+                void* buffer = bufsink_.AcquireBuffer(BLOCK_SZ);
+                if (!buffer) {
+                    SNAP_LOG(ERROR) << "AcquireBuffer failed in MergeReplaceOps";
+                    return false;
+                }
                 CHECK(cow_op->type() == kCowZeroOp);
                 memset(buffer, 0, BLOCK_SZ);
             }
@@ -137,7 +158,7 @@ bool MergeWorker::MergeReplaceZeroOps() {
             return false;
         }
 
-        num_ops_merged += linear_blocks;
+        num_ops_merged += replace_zero_vec.size();
 
         if (num_ops_merged >= total_ops_merged_per_commit) {
             // Flush the data
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index f1d406534671..d40b6d11d92d 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include "read_worker.h"
-
+#include <libsnapshot/cow_format.h>
 #include <pthread.h>
 
+#include "read_worker.h"
 #include "snapuserd_core.h"
 #include "utility.h"
 
@@ -48,9 +48,10 @@ ReadWorker::ReadWorker(const std::string& cow_device, const std::string& backing
 // Start the replace operation. This will read the
 // internal COW format and if the block is compressed,
 // it will be de-compressed.
-bool ReadWorker::ProcessReplaceOp(const CowOperation* cow_op, void* buffer) {
-    if (!reader_->ReadData(cow_op, buffer, BLOCK_SZ)) {
-        SNAP_LOG(ERROR) << "ProcessReplaceOp failed for block " << cow_op->new_block;
+bool ReadWorker::ProcessReplaceOp(const CowOperation* cow_op, void* buffer, size_t buffer_size) {
+    if (!reader_->ReadData(cow_op, buffer, buffer_size)) {
+        SNAP_LOG(ERROR) << "ProcessReplaceOp failed for block " << cow_op->new_block
+                        << " buffer_size: " << buffer_size;
         return false;
     }
     return true;
@@ -183,7 +184,13 @@ bool ReadWorker::ProcessCowOp(const CowOperation* cow_op, void* buffer) {
 
     switch (cow_op->type()) {
         case kCowReplaceOp: {
-            return ProcessReplaceOp(cow_op, buffer);
+            size_t buffer_size = CowOpCompressionSize(cow_op, BLOCK_SZ);
+            uint8_t chunk[buffer_size];
+            if (!ProcessReplaceOp(cow_op, chunk, buffer_size)) {
+                return false;
+            }
+            std::memcpy(buffer, chunk, BLOCK_SZ);
+            return true;
         }
 
         case kCowZeroOp: {
@@ -209,6 +216,13 @@ bool ReadWorker::Init() {
         return false;
     }
 
+    const size_t compression_factor = reader_->GetMaxCompressionSize();
+    if (!compression_factor) {
+        SNAP_LOG(ERROR) << "Compression factor is set to 0 which is invalid.";
+        return false;
+    }
+    decompressed_buffer_ = std::make_unique<uint8_t[]>(compression_factor);
+
     backing_store_fd_.reset(open(backing_store_device_.c_str(), O_RDONLY));
     if (backing_store_fd_ < 0) {
         SNAP_PLOG(ERROR) << "Open Failed: " << backing_store_device_;
@@ -276,6 +290,20 @@ bool ReadWorker::ReadDataFromBaseDevice(sector_t sector, void* buffer, size_t re
     return true;
 }
 
+bool ReadWorker::GetCowOpBlockOffset(const CowOperation* cow_op, uint64_t io_block,
+                                     off_t* block_offset) {
+    // If this is a replace op, get the block offset of this I/O
+    // block. Multi-block compression is supported only for
+    // Replace ops.
+    //
+    // Note: This can be extended when we support COPY and XOR ops down the
+    // line as the blocks are mostly contiguous.
+    if (cow_op && cow_op->type() == kCowReplaceOp) {
+        return GetBlockOffset(cow_op, io_block, BLOCK_SZ, block_offset);
+    }
+    return false;
+}
+
 bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
     size_t remaining_size = sz;
     std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
@@ -286,7 +314,7 @@ bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
         size_t read_size = std::min(PAYLOAD_BUFFER_SZ, remaining_size);
 
         size_t total_bytes_read = 0;
-
+        const CowOperation* prev_op = nullptr;
         while (read_size) {
             // We need to check every 4k block to verify if it is
             // present in the mapping.
@@ -294,7 +322,7 @@ bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
 
             auto it = std::lower_bound(chunk_vec.begin(), chunk_vec.end(),
                                        std::make_pair(sector, nullptr), SnapshotHandler::compare);
-            bool not_found = (it == chunk_vec.end() || it->first != sector);
+            const bool sector_not_found = (it == chunk_vec.end() || it->first != sector);
 
             void* buffer = block_server_->GetResponseBuffer(BLOCK_SZ, size);
             if (!buffer) {
@@ -302,15 +330,88 @@ bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
                 return false;
             }
 
-            if (not_found) {
-                // Block not found in map - which means this block was not
-                // changed as per the OTA. Just route the I/O to the base
-                // device.
-                if (!ReadDataFromBaseDevice(sector, buffer, size)) {
-                    SNAP_LOG(ERROR) << "ReadDataFromBaseDevice failed";
-                    return false;
+            if (sector_not_found) {
+                // Find the 4k block
+                uint64_t io_block = SectorToChunk(sector);
+                // Get the previous iterator. Since the vector is sorted, the
+                // lookup of this sector can fall in a range of blocks if
+                // CowOperation has compressed multiple blocks.
+                if (it != chunk_vec.begin()) {
+                    std::advance(it, -1);
                 }
 
+                bool is_mapping_present = true;
+
+                // Vector itself is empty. This can happen if the block was not
+                // changed per the OTA or if the merge was already complete but
+                // snapshot table was not yet collapsed.
+                if (it == chunk_vec.end()) {
+                    is_mapping_present = false;
+                }
+
+                const CowOperation* cow_op = nullptr;
+                // Relative offset within the compressed multiple blocks
+                off_t block_offset = 0;
+                if (is_mapping_present) {
+                    // Get the nearest operation found in the vector
+                    cow_op = it->second;
+                    is_mapping_present = GetCowOpBlockOffset(cow_op, io_block, &block_offset);
+                }
+
+                // Thus, we have a case wherein sector was not found in the sorted
+                // vector; however, we indeed have a mapping of this sector
+                // embedded in one of the CowOperation which spans multiple
+                // block size.
+                if (is_mapping_present) {
+                    // block_offset = 0 would mean that the CowOperation should
+                    // already be in the sorted vector. Hence, lookup should
+                    // have already found it. If not, this is a bug.
+                    if (block_offset == 0) {
+                        SNAP_LOG(ERROR)
+                                << "GetBlockOffset returned offset 0 for io_block: " << io_block;
+                        return false;
+                    }
+
+                    // Get the CowOperation actual compression size
+                    size_t compression_size = CowOpCompressionSize(cow_op, BLOCK_SZ);
+                    // Offset cannot be greater than the compression size
+                    if (block_offset > compression_size) {
+                        SNAP_LOG(ERROR) << "Invalid I/O block found. io_block: " << io_block
+                                        << " CowOperation-new-block: " << cow_op->new_block
+                                        << " compression-size: " << compression_size;
+                        return false;
+                    }
+
+                    // Cached copy of the previous iteration. Just retrieve the
+                    // data
+                    if (prev_op && prev_op->new_block == cow_op->new_block) {
+                        std::memcpy(buffer, (char*)decompressed_buffer_.get() + block_offset, size);
+                    } else {
+                        // Get the data from the disk based on the compression
+                        // size
+                        if (!ProcessReplaceOp(cow_op, decompressed_buffer_.get(),
+                                              compression_size)) {
+                            return false;
+                        }
+                        // Copy the data from the decompressed buffer relative
+                        // to the i/o block offset.
+                        std::memcpy(buffer, (char*)decompressed_buffer_.get() + block_offset, size);
+                        // Cache this CowOperation pointer for successive I/O
+                        // operation. Since the request is sequential and the
+                        // block is already decompressed, subsequest I/O blocks
+                        // can fetch the data directly from this decompressed
+                        // buffer.
+                        prev_op = cow_op;
+                    }
+                } else {
+                    // Block not found in map - which means this block was not
+                    // changed as per the OTA. Just route the I/O to the base
+                    // device.
+                    if (!ReadDataFromBaseDevice(sector, buffer, size)) {
+                        SNAP_LOG(ERROR) << "ReadDataFromBaseDevice failed";
+                        return false;
+                    }
+                }
                 ret = size;
             } else {
                 // We found the sector in mapping. Check the type of COW OP and
@@ -341,12 +442,50 @@ bool ReadWorker::ReadAlignedSector(sector_t sector, size_t sz) {
     return true;
 }
 
+bool ReadWorker::IsMappingPresent(const CowOperation* cow_op, loff_t requested_offset,
+                                  loff_t cow_op_offset) {
+    const bool replace_op = (cow_op->type() == kCowReplaceOp);
+    if (replace_op) {
+        size_t max_compressed_size = CowOpCompressionSize(cow_op, BLOCK_SZ);
+        if ((requested_offset >= cow_op_offset) &&
+            (requested_offset < (cow_op_offset + max_compressed_size))) {
+            return true;
+        }
+    }
+    return false;
+}
+
 int ReadWorker::ReadUnalignedSector(
         sector_t sector, size_t size,
         std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it) {
     SNAP_LOG(DEBUG) << "ReadUnalignedSector: sector " << sector << " size: " << size
                     << " Aligned sector: " << it->first;
 
+    loff_t requested_offset = sector << SECTOR_SHIFT;
+    loff_t final_offset = (it->first) << SECTOR_SHIFT;
+
+    const CowOperation* cow_op = it->second;
+    if (IsMappingPresent(cow_op, requested_offset, final_offset)) {
+        size_t buffer_size = CowOpCompressionSize(cow_op, BLOCK_SZ);
+        uint8_t chunk[buffer_size];
+        // Read the entire decompressed buffer based on the block-size
+        if (!ProcessReplaceOp(cow_op, chunk, buffer_size)) {
+            return -1;
+        }
+        size_t skip_offset = (requested_offset - final_offset);
+        size_t write_sz = std::min(size, buffer_size - skip_offset);
+
+        auto buffer =
+                reinterpret_cast<uint8_t*>(block_server_->GetResponseBuffer(BLOCK_SZ, write_sz));
+        if (!buffer) {
+            SNAP_LOG(ERROR) << "ReadUnalignedSector failed to allocate buffer";
+            return -1;
+        }
+
+        std::memcpy(buffer, (char*)chunk + skip_offset, write_sz);
+        return write_sz;
+    }
+
     int num_sectors_skip = sector - it->first;
     size_t skip_size = num_sectors_skip << SECTOR_SHIFT;
     size_t write_size = std::min(size, BLOCK_SZ - skip_size);
@@ -445,8 +584,11 @@ bool ReadWorker::ReadUnalignedSector(sector_t sector, size_t size) {
 
     size_t remaining_size = size;
     int ret = 0;
+
+    const CowOperation* cow_op = it->second;
     if (!merge_complete && (requested_offset >= final_offset) &&
-        (requested_offset - final_offset) < BLOCK_SZ) {
+        (((requested_offset - final_offset) < BLOCK_SZ) ||
+         IsMappingPresent(cow_op, requested_offset, final_offset))) {
         // Read the partial un-aligned data
         ret = ReadUnalignedSector(sector, remaining_size, it);
         if (ret < 0) {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
index 1aff50c08268..43e896a9a95c 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
@@ -44,9 +44,12 @@ class ReadWorker : public Worker, public IBlockServer::Delegate {
     bool ProcessXorOp(const CowOperation* cow_op, void* buffer);
     bool ProcessOrderedOp(const CowOperation* cow_op, void* buffer);
     bool ProcessCopyOp(const CowOperation* cow_op, void* buffer);
-    bool ProcessReplaceOp(const CowOperation* cow_op, void* buffer);
+    bool ProcessReplaceOp(const CowOperation* cow_op, void* buffer, size_t buffer_size);
     bool ProcessZeroOp(void* buffer);
 
+    bool IsMappingPresent(const CowOperation* cow_op, loff_t requested_offset,
+                          loff_t cow_op_offset);
+    bool GetCowOpBlockOffset(const CowOperation* cow_op, uint64_t io_block, off_t* block_offset);
     bool ReadAlignedSector(sector_t sector, size_t sz);
     bool ReadUnalignedSector(sector_t sector, size_t size);
     int ReadUnalignedSector(sector_t sector, size_t size,
@@ -56,6 +59,7 @@ class ReadWorker : public Worker, public IBlockServer::Delegate {
 
     constexpr bool IsBlockAligned(size_t size) { return ((size & (BLOCK_SZ - 1)) == 0); }
     constexpr sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
+    constexpr chunk_t SectorToChunk(sector_t sector) { return sector >> CHUNK_SHIFT; }
 
     std::string backing_store_device_;
     unique_fd backing_store_fd_;
@@ -67,6 +71,7 @@ class ReadWorker : public Worker, public IBlockServer::Delegate {
 
     std::basic_string<uint8_t> xor_buffer_;
     std::unique_ptr<void, decltype(&::free)> aligned_buffer_;
+    std::unique_ptr<uint8_t[]> decompressed_buffer_;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 8ddb0f4235f2..76b44b48b2b1 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -64,6 +64,9 @@ using ::testing::TestWithParam;
 struct TestParam {
     bool io_uring;
     bool o_direct;
+    std::string compression;
+    int block_size;
+    int num_threads;
 };
 
 class SnapuserdTestBase : public ::testing::TestWithParam<TestParam> {
@@ -74,6 +77,7 @@ class SnapuserdTestBase : public ::testing::TestWithParam<TestParam> {
     void CreateCowDevice();
     void SetDeviceControlName();
     std::unique_ptr<ICowWriter> CreateCowDeviceInternal();
+    std::unique_ptr<ICowWriter> CreateV3Cow();
 
     std::unique_ptr<ITestHarness> harness_;
     size_t size_ = 10_MiB;
@@ -133,6 +137,24 @@ std::unique_ptr<ICowWriter> SnapuserdTestBase::CreateCowDeviceInternal() {
     return CreateCowWriter(kDefaultCowVersion, options, std::move(fd));
 }
 
+std::unique_ptr<ICowWriter> SnapuserdTestBase::CreateV3Cow() {
+    const TestParam params = GetParam();
+
+    CowOptions options;
+    options.op_count_max = 100000;
+    options.compression = params.compression;
+    options.num_compress_threads = params.num_threads;
+    options.batch_write = true;
+    options.compression_factor = params.block_size;
+
+    cow_system_ = std::make_unique<TemporaryFile>();
+
+    unique_fd fd(cow_system_->fd);
+    cow_system_->fd = -1;
+
+    return CreateCowWriter(3, options, std::move(fd));
+}
+
 void SnapuserdTestBase::CreateCowDevice() {
     unique_fd rnd_fd;
     loff_t offset = 0;
@@ -236,6 +258,7 @@ class SnapuserdTest : public SnapuserdTestBase {
     void SetupOrderedOpsInverted();
     void SetupCopyOverlap_1();
     void SetupCopyOverlap_2();
+    void SetupDeviceForPassthrough();
     bool Merge();
     void ValidateMerge();
     void ReadSnapshotDeviceAndValidate();
@@ -258,6 +281,9 @@ class SnapuserdTest : public SnapuserdTestBase {
 
     void SimulateDaemonRestart();
 
+    void CreateCowDeviceWithNoBlockChanges();
+    void ValidateDeviceWithNoBlockChanges();
+
     void CreateCowDeviceOrderedOps();
     void CreateCowDeviceOrderedOpsInverted();
     void CreateCowDeviceWithCopyOverlap_1();
@@ -307,6 +333,12 @@ void SnapuserdTest::SetupOrderedOps() {
     ASSERT_NO_FATAL_FAILURE(SetupDaemon());
 }
 
+void SnapuserdTest::SetupDeviceForPassthrough() {
+    ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
+    ASSERT_NO_FATAL_FAILURE(CreateCowDeviceWithNoBlockChanges());
+    ASSERT_NO_FATAL_FAILURE(SetupDaemon());
+}
+
 void SnapuserdTest::SetupOrderedOpsInverted() {
     ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
     ASSERT_NO_FATAL_FAILURE(CreateCowDeviceOrderedOpsInverted());
@@ -480,6 +512,47 @@ void SnapuserdTest::CreateCowDeviceWithCopyOverlap_2() {
     }
 }
 
+void SnapuserdTest::CreateCowDeviceWithNoBlockChanges() {
+    auto writer = CreateCowDeviceInternal();
+    ASSERT_NE(writer, nullptr);
+
+    std::unique_ptr<uint8_t[]> buffer = std::make_unique<uint8_t[]>(BLOCK_SZ);
+    std::memset(buffer.get(), 'A', BLOCK_SZ);
+
+    // This test focusses on not changing all the blocks thereby validating
+    // the pass-through I/O
+
+    // Replace the first block
+    ASSERT_TRUE(writer->AddRawBlocks(1, buffer.get(), BLOCK_SZ));
+
+    // Set zero block of Block 3
+    ASSERT_TRUE(writer->AddZeroBlocks(3, 1));
+
+    ASSERT_TRUE(writer->Finalize());
+    orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
+
+    // Read the entire base device
+    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), total_base_size_, 0),
+              true);
+
+    off_t offset = BLOCK_SZ;
+    std::memcpy(orig_buffer_.get() + offset, buffer.get(), BLOCK_SZ);
+    offset = 3 * BLOCK_SZ;
+    std::memset(orig_buffer_.get() + offset, 0, BLOCK_SZ);
+}
+
+void SnapuserdTest::ValidateDeviceWithNoBlockChanges() {
+    unique_fd fd(open(dmuser_dev_->GetPath().c_str(), O_RDONLY));
+    ASSERT_GE(fd, 0);
+    std::unique_ptr<uint8_t[]> snapshot_buffer = std::make_unique<uint8_t[]>(size_);
+    std::memset(snapshot_buffer.get(), 'B', size_);
+
+    // All the I/O request should be a pass through to base device except for
+    // Block 1 and Block 3.
+    ASSERT_EQ(ReadFullyAtOffset(fd, snapshot_buffer.get(), size_, 0), true);
+    ASSERT_EQ(memcmp(snapshot_buffer.get(), orig_buffer_.get(), size_), 0);
+}
+
 void SnapuserdTest::CreateCowDeviceWithCopyOverlap_1() {
     auto writer = CreateCowDeviceInternal();
     ASSERT_NE(writer, nullptr);
@@ -781,6 +854,20 @@ void SnapuserdTest::MergeInterrupt() {
     ASSERT_TRUE(Merge());
 }
 
+TEST_P(SnapuserdTest, Snapshot_Passthrough) {
+    if (!harness_->HasUserDevice()) {
+        GTEST_SKIP() << "Skipping snapshot read; not supported";
+    }
+    ASSERT_NO_FATAL_FAILURE(SetupDeviceForPassthrough());
+    // I/O before merge
+    ASSERT_NO_FATAL_FAILURE(ValidateDeviceWithNoBlockChanges());
+    ASSERT_TRUE(Merge());
+    ValidateMerge();
+    // I/O after merge - daemon should read directly
+    // from base device
+    ASSERT_NO_FATAL_FAILURE(ValidateDeviceWithNoBlockChanges());
+}
+
 TEST_P(SnapuserdTest, Snapshot_IO_TEST) {
     if (!harness_->HasUserDevice()) {
         GTEST_SKIP() << "Skipping snapshot read; not supported";
@@ -853,7 +940,7 @@ TEST_P(SnapuserdTest, Snapshot_COPY_Overlap_Merge_Resume_IO_Validate_TEST) {
         GTEST_SKIP() << "Skipping snapshot read; not supported";
     }
     ASSERT_NO_FATAL_FAILURE(SetupCopyOverlap_2());
-    ASSERT_NO_FATAL_FAILURE(MergeInterruptAndValidate(2));
+    ASSERT_NO_FATAL_FAILURE(MergeInterruptFixed(300));
     ValidateMerge();
 }
 
@@ -881,11 +968,243 @@ TEST_P(SnapuserdTest, Snapshot_Merge_Crash_Random_Inverted) {
     ValidateMerge();
 }
 
+class SnapuserdVariableBlockSizeTest : public SnapuserdTest {
+  public:
+    void SetupCowV3ForVariableBlockSize();
+    void ReadSnapshotWithVariableBlockSize();
+
+  protected:
+    void SetUp() override;
+    void TearDown() override;
+
+    void CreateV3CowDeviceForVariableBlockSize();
+};
+
+void SnapuserdVariableBlockSizeTest::SetupCowV3ForVariableBlockSize() {
+    ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
+    ASSERT_NO_FATAL_FAILURE(CreateV3CowDeviceForVariableBlockSize());
+    ASSERT_NO_FATAL_FAILURE(SetupDaemon());
+}
+
+void SnapuserdVariableBlockSizeTest::CreateV3CowDeviceForVariableBlockSize() {
+    auto writer = CreateV3Cow();
+
+    size_t total_data_to_write = size_;
+
+    size_t total_blocks_to_write = total_data_to_write / BLOCK_SZ;
+    size_t num_blocks_per_op = total_blocks_to_write / 4;
+    size_t source_block = 0;
+
+    size_t seq_len = num_blocks_per_op;
+    uint32_t sequence[seq_len];
+    size_t xor_block_start = seq_len * 3;
+    for (size_t i = 0; i < seq_len; i++) {
+        sequence[i] = xor_block_start + i;
+    }
+    ASSERT_TRUE(writer->AddSequenceData(seq_len, sequence));
+
+    size_t total_replace_blocks = num_blocks_per_op;
+    // Write some data which can be compressed
+    std::string data;
+    data.resize(total_replace_blocks * BLOCK_SZ, '\0');
+    for (size_t i = 0; i < data.size(); i++) {
+        data[i] = static_cast<char>('A' + i / BLOCK_SZ);
+    }
+    // REPLACE ops
+    ASSERT_TRUE(writer->AddRawBlocks(source_block, data.data(), data.size()));
+
+    total_blocks_to_write -= total_replace_blocks;
+    source_block = source_block + total_replace_blocks;
+
+    // ZERO ops
+    size_t total_zero_blocks = total_blocks_to_write / 3;
+    ASSERT_TRUE(writer->AddZeroBlocks(source_block, total_zero_blocks));
+
+    total_blocks_to_write -= total_zero_blocks;
+    source_block = source_block + total_zero_blocks;
+
+    // Generate some random data wherein few blocks cannot be compressed.
+    // This is to test the I/O path for those blocks which aren't compressed.
+    size_t total_random_data_blocks = total_blocks_to_write / 2;
+    unique_fd rnd_fd(open("/dev/random", O_RDONLY));
+
+    ASSERT_GE(rnd_fd, 0);
+    std::string random_buffer;
+    random_buffer.resize(total_random_data_blocks * BLOCK_SZ, '\0');
+    ASSERT_EQ(
+            android::base::ReadFullyAtOffset(rnd_fd, random_buffer.data(), random_buffer.size(), 0),
+            true);
+    // REPLACE ops
+    ASSERT_TRUE(writer->AddRawBlocks(source_block, random_buffer.data(), random_buffer.size()));
+
+    total_blocks_to_write -= total_random_data_blocks;
+    source_block = source_block + total_random_data_blocks;
+
+    // XOR ops will always be 4k blocks
+    std::string xor_buffer;
+    xor_buffer.resize(total_blocks_to_write * BLOCK_SZ, '\0');
+    for (size_t i = 0; i < xor_buffer.size(); i++) {
+        xor_buffer[i] = static_cast<char>('C' + i / BLOCK_SZ);
+    }
+    size_t xor_offset = 21;
+    std::string source_buffer;
+    source_buffer.resize(total_blocks_to_write * BLOCK_SZ, '\0');
+    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, source_buffer.data(), source_buffer.size(),
+                                               size_ + xor_offset),
+              true);
+    for (size_t i = 0; i < xor_buffer.size(); i++) {
+        xor_buffer[i] ^= source_buffer[i];
+    }
+
+    ASSERT_EQ(xor_block_start, source_block);
+
+    ASSERT_TRUE(writer->AddXorBlocks(source_block, xor_buffer.data(), xor_buffer.size(),
+                                     (size_ / BLOCK_SZ), xor_offset));
+    // Flush operations
+    ASSERT_TRUE(writer->Finalize());
+
+    // Construct the buffer required for validation
+    orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
+
+    // Read the entire base device
+    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), total_base_size_, 0),
+              true);
+
+    // REPLACE ops which are compressed
+    std::memcpy(orig_buffer_.get(), data.data(), data.size());
+    size_t offset = data.size();
+
+    // ZERO ops
+    std::string zero_buffer(total_zero_blocks * BLOCK_SZ, 0);
+    std::memcpy((char*)orig_buffer_.get() + offset, (void*)zero_buffer.c_str(), zero_buffer.size());
+    offset += zero_buffer.size();
+
+    // REPLACE ops - Random buffers which aren't compressed
+    std::memcpy((char*)orig_buffer_.get() + offset, random_buffer.c_str(), random_buffer.size());
+    offset += random_buffer.size();
+
+    // XOR Ops which default to 4k block size compression irrespective of
+    // compression factor
+    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, (char*)orig_buffer_.get() + offset,
+                                               xor_buffer.size(), size_ + xor_offset),
+              true);
+    for (size_t i = 0; i < xor_buffer.size(); i++) {
+        orig_buffer_.get()[offset + i] = (uint8_t)(orig_buffer_.get()[offset + i] ^ xor_buffer[i]);
+    }
+}
+
+void SnapuserdVariableBlockSizeTest::ReadSnapshotWithVariableBlockSize() {
+    unique_fd fd(open(dmuser_dev_->GetPath().c_str(), O_RDONLY | O_DIRECT));
+    ASSERT_GE(fd, 0);
+
+    void* addr;
+    ssize_t page_size = getpagesize();
+    ASSERT_EQ(posix_memalign(&addr, page_size, size_), 0);
+    std::unique_ptr<void, decltype(&::free)> snapshot_buffer(addr, ::free);
+
+    const TestParam params = GetParam();
+
+    // Issue I/O request with various block sizes
+    size_t num_blocks = size_ / params.block_size;
+    off_t offset = 0;
+    for (size_t i = 0; i < num_blocks; i++) {
+        ASSERT_EQ(ReadFullyAtOffset(fd, (char*)snapshot_buffer.get() + offset, params.block_size,
+                                    offset),
+                  true);
+        offset += params.block_size;
+    }
+    // Validate buffer
+    ASSERT_EQ(memcmp(snapshot_buffer.get(), orig_buffer_.get(), size_), 0);
+
+    // Reset the buffer
+    std::memset(snapshot_buffer.get(), 0, size_);
+
+    // Read one full chunk in a single shot and re-validate.
+    ASSERT_EQ(ReadFullyAtOffset(fd, snapshot_buffer.get(), size_, 0), true);
+    ASSERT_EQ(memcmp(snapshot_buffer.get(), orig_buffer_.get(), size_), 0);
+
+    // Reset the buffer
+    std::memset(snapshot_buffer.get(), 0, size_);
+
+    // Buffered I/O test
+    fd.reset(open(dmuser_dev_->GetPath().c_str(), O_RDONLY));
+    ASSERT_GE(fd, 0);
+
+    // Try not to cache
+    posix_fadvise(fd.get(), 0, size_, POSIX_FADV_DONTNEED);
+
+    size_t num_blocks_per_op = (size_ / BLOCK_SZ) / 4;
+    offset = num_blocks_per_op * BLOCK_SZ;
+    size_t read_size = 1019;  // bytes
+    offset -= 111;
+
+    // Issue a un-aligned read which crosses the boundary between a REPLACE block and a ZERO
+    // block.
+    ASSERT_EQ(ReadFullyAtOffset(fd, snapshot_buffer.get(), read_size, offset), true);
+
+    // Validate the data
+    ASSERT_EQ(std::memcmp(snapshot_buffer.get(), (char*)orig_buffer_.get() + offset, read_size), 0);
+
+    offset = (num_blocks_per_op * 3) * BLOCK_SZ;
+    offset -= (BLOCK_SZ - 119);
+    read_size = 8111;
+
+    // Issue an un-aligned read which crosses the boundary between a REPLACE block of random
+    // un-compressed data and a XOR block
+    ASSERT_EQ(ReadFullyAtOffset(fd, snapshot_buffer.get(), read_size, offset), true);
+
+    // Validate the data
+    ASSERT_EQ(std::memcmp(snapshot_buffer.get(), (char*)orig_buffer_.get() + offset, read_size), 0);
+
+    // Reset the buffer
+    std::memset(snapshot_buffer.get(), 0, size_);
+
+    // Read just one byte at an odd offset which is a REPLACE op
+    offset = 19;
+    read_size = 1;
+    ASSERT_EQ(ReadFullyAtOffset(fd, snapshot_buffer.get(), read_size, offset), true);
+    // Validate the data
+    ASSERT_EQ(std::memcmp(snapshot_buffer.get(), (char*)orig_buffer_.get() + offset, read_size), 0);
+
+    // Reset the buffer
+    std::memset(snapshot_buffer.get(), 0, size_);
+
+    // Read a block which has no mapping to a COW operation. This read should be
+    // a pass-through to the underlying base device.
+    offset = size_ + 9342;
+    read_size = 30;
+    ASSERT_EQ(ReadFullyAtOffset(fd, snapshot_buffer.get(), read_size, offset), true);
+    // Validate the data
+    ASSERT_EQ(std::memcmp(snapshot_buffer.get(), (char*)orig_buffer_.get() + offset, read_size), 0);
+}
+
+void SnapuserdVariableBlockSizeTest::SetUp() {
+    ASSERT_NO_FATAL_FAILURE(SnapuserdTest::SetUp());
+}
+
+void SnapuserdVariableBlockSizeTest::TearDown() {
+    SnapuserdTest::TearDown();
+}
+
+TEST_P(SnapuserdVariableBlockSizeTest, Snapshot_Test_Variable_Block_Size) {
+    if (!harness_->HasUserDevice()) {
+        GTEST_SKIP() << "Skipping snapshot read; not supported";
+    }
+    ASSERT_NO_FATAL_FAILURE(SetupCowV3ForVariableBlockSize());
+    ASSERT_NO_FATAL_FAILURE(ReadSnapshotWithVariableBlockSize());
+    ASSERT_TRUE(StartMerge());
+    CheckMergeCompletion();
+    ValidateMerge();
+    ASSERT_NO_FATAL_FAILURE(ReadSnapshotWithVariableBlockSize());
+}
+
 class HandlerTest : public SnapuserdTestBase {
   protected:
     void SetUp() override;
     void TearDown() override;
 
+    void SetUpV2Cow();
+    void InitializeDevice();
     AssertionResult ReadSectors(sector_t sector, uint64_t size, void* buffer);
 
     TestBlockServerFactory factory_;
@@ -896,10 +1215,11 @@ class HandlerTest : public SnapuserdTestBase {
     std::future<bool> handler_thread_;
 };
 
-void HandlerTest::SetUp() {
-    ASSERT_NO_FATAL_FAILURE(SnapuserdTestBase::SetUp());
-    ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
+void HandlerTest::SetUpV2Cow() {
     ASSERT_NO_FATAL_FAILURE(CreateCowDevice());
+}
+
+void HandlerTest::InitializeDevice() {
     ASSERT_NO_FATAL_FAILURE(SetDeviceControlName());
 
     opener_ = factory_.CreateTestOpener(system_device_ctrl_name_);
@@ -921,6 +1241,13 @@ void HandlerTest::SetUp() {
     handler_thread_ = std::async(std::launch::async, &SnapshotHandler::Start, handler_.get());
 }
 
+void HandlerTest::SetUp() {
+    ASSERT_NO_FATAL_FAILURE(SnapuserdTestBase::SetUp());
+    ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
+    ASSERT_NO_FATAL_FAILURE(SetUpV2Cow());
+    ASSERT_NO_FATAL_FAILURE(InitializeDevice());
+}
+
 void HandlerTest::TearDown() {
     ASSERT_TRUE(factory_.DeleteQueue(system_device_ctrl_name_));
     ASSERT_TRUE(handler_thread_.get());
@@ -986,6 +1313,147 @@ TEST_P(HandlerTest, ReadUnalignedSize) {
     ASSERT_EQ(memcmp(snapuserd_buffer.get(), orig_buffer_.get(), SECTOR_SIZE), 0);
 }
 
+class HandlerTestV3 : public HandlerTest {
+  public:
+    void ReadSnapshotWithVariableBlockSize();
+
+  protected:
+    void SetUp() override;
+    void TearDown() override;
+    void SetUpV3Cow();
+};
+
+void HandlerTestV3::SetUp() {
+    ASSERT_NO_FATAL_FAILURE(SnapuserdTestBase::SetUp());
+    ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
+    ASSERT_NO_FATAL_FAILURE(SetUpV3Cow());
+    ASSERT_NO_FATAL_FAILURE(InitializeDevice());
+}
+
+void HandlerTestV3::TearDown() {
+    ASSERT_NO_FATAL_FAILURE(HandlerTest::TearDown());
+}
+
+void HandlerTestV3::SetUpV3Cow() {
+    auto writer = CreateV3Cow();
+
+    size_t total_data_to_write = size_;
+
+    size_t total_blocks_to_write = total_data_to_write / BLOCK_SZ;
+    size_t num_blocks_per_op = total_blocks_to_write / 4;
+    size_t source_block = 0;
+
+    size_t total_replace_blocks = num_blocks_per_op;
+    // Write some data which can be compressed
+    std::string data;
+    data.resize(total_replace_blocks * BLOCK_SZ, '\0');
+    for (size_t i = 0; i < data.size(); i++) {
+        data[i] = static_cast<char>('A' + i / BLOCK_SZ);
+    }
+    // REPLACE ops
+    ASSERT_TRUE(writer->AddRawBlocks(source_block, data.data(), data.size()));
+
+    total_blocks_to_write -= total_replace_blocks;
+    source_block = source_block + total_replace_blocks;
+
+    // ZERO ops
+    size_t total_zero_blocks = total_blocks_to_write / 3;
+    ASSERT_TRUE(writer->AddZeroBlocks(source_block, total_zero_blocks));
+
+    total_blocks_to_write -= total_zero_blocks;
+    source_block = source_block + total_zero_blocks;
+
+    // Generate some random data wherein few blocks cannot be compressed.
+    // This is to test the I/O path for those blocks which aren't compressed.
+    size_t total_random_data_blocks = total_blocks_to_write;
+    unique_fd rnd_fd(open("/dev/random", O_RDONLY));
+
+    ASSERT_GE(rnd_fd, 0);
+    std::string random_buffer;
+    random_buffer.resize(total_random_data_blocks * BLOCK_SZ, '\0');
+    ASSERT_EQ(
+            android::base::ReadFullyAtOffset(rnd_fd, random_buffer.data(), random_buffer.size(), 0),
+            true);
+    // REPLACE ops
+    ASSERT_TRUE(writer->AddRawBlocks(source_block, random_buffer.data(), random_buffer.size()));
+    // Flush operations
+    ASSERT_TRUE(writer->Finalize());
+
+    // Construct the buffer required for validation
+    orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
+
+    // Read the entire base device
+    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), total_base_size_, 0),
+              true);
+
+    // REPLACE ops which are compressed
+    std::memcpy(orig_buffer_.get(), data.data(), data.size());
+    size_t offset = data.size();
+
+    // ZERO ops
+    std::string zero_buffer(total_zero_blocks * BLOCK_SZ, 0);
+    std::memcpy((char*)orig_buffer_.get() + offset, (void*)zero_buffer.c_str(), zero_buffer.size());
+    offset += zero_buffer.size();
+
+    // REPLACE ops - Random buffers which aren't compressed
+    std::memcpy((char*)orig_buffer_.get() + offset, random_buffer.c_str(), random_buffer.size());
+}
+
+TEST_P(HandlerTestV3, Read) {
+    std::unique_ptr<uint8_t[]> snapuserd_buffer = std::make_unique<uint8_t[]>(size_);
+
+    size_t read_size = SECTOR_SIZE;
+    off_t offset = 0;
+    // Read the first sector
+    ASSERT_TRUE(ReadSectors(1, read_size, snapuserd_buffer.get()));
+    // Validate the data
+    ASSERT_EQ(std::memcmp(snapuserd_buffer.get(), orig_buffer_.get(), read_size), 0);
+
+    // Read the second block at offset 7680 (Sector 15). This will map to the
+    // first COW operation for variable block size
+    offset += (((BLOCK_SZ * 2) - SECTOR_SIZE));
+    read_size = BLOCK_SZ;  // Span across two REPLACE ops
+    ASSERT_TRUE(ReadSectors(offset / SECTOR_SIZE, read_size, snapuserd_buffer.get()));
+    // Validate the data
+    ASSERT_EQ(std::memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + offset, read_size),
+              0);
+
+    // Fill some other data since we are going to read zero blocks
+    std::memset(snapuserd_buffer.get(), 'Z', size_);
+
+    size_t num_blocks_per_op = (size_ / BLOCK_SZ) / 4;
+    offset = num_blocks_per_op * BLOCK_SZ;
+    // Issue read spanning between a REPLACE op and ZERO ops. The starting point
+    // is the last REPLACE op at sector 5118
+    offset -= (SECTOR_SIZE * 2);
+    // This will make sure it falls back to aligned reads after reading the
+    // first unaligned block
+    read_size = BLOCK_SZ * 6;
+    ASSERT_TRUE(ReadSectors(offset / SECTOR_SIZE, read_size, snapuserd_buffer.get()));
+    // Validate the data
+    ASSERT_EQ(std::memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + offset, read_size),
+              0);
+
+    // Issue I/O request at the last block. The first chunk of (SECTOR_SIZE * 2)
+    // will be from REPLACE op which has random buffers
+    offset = (size_ - (SECTOR_SIZE * 2));
+    // Request will span beyond the COW mapping, thereby fetching data from base
+    // device.
+    read_size = BLOCK_SZ * 8;
+    ASSERT_TRUE(ReadSectors(offset / SECTOR_SIZE, read_size, snapuserd_buffer.get()));
+    // Validate the data
+    ASSERT_EQ(std::memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + offset, read_size),
+              0);
+
+    // Issue I/O request which are not mapped to any COW operations
+    offset = (size_ + (SECTOR_SIZE * 3));
+    read_size = BLOCK_SZ * 3;
+    ASSERT_TRUE(ReadSectors(offset / SECTOR_SIZE, read_size, snapuserd_buffer.get()));
+    // Validate the data
+    ASSERT_EQ(std::memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + offset, read_size),
+              0);
+}
+
 std::vector<bool> GetIoUringConfigs() {
 #if __ANDROID__
     if (!android::base::GetBoolProperty("ro.virtual_ab.io_uring.enabled", false)) {
@@ -1018,6 +1486,37 @@ std::vector<TestParam> GetTestConfigs() {
     return testParams;
 }
 
+std::vector<TestParam> GetVariableBlockTestConfigs() {
+    std::vector<TestParam> testParams;
+
+    std::vector<int> block_sizes = {4096, 8192, 16384, 32768, 65536, 131072};
+    std::vector<std::string> compression_algo = {"none", "lz4", "zstd", "gz"};
+    std::vector<int> threads = {1, 2};
+    std::vector<bool> uring_configs = GetIoUringConfigs();
+
+    // This should test 96 combination and validates the I/O path
+    for (auto block : block_sizes) {
+        for (auto compression : compression_algo) {
+            for (auto thread : threads) {
+                for (auto io_uring : uring_configs) {
+                    TestParam param;
+                    param.block_size = block;
+                    param.compression = compression;
+                    param.num_threads = thread;
+                    param.io_uring = io_uring;
+                    param.o_direct = false;
+                    testParams.push_back(std::move(param));
+                }
+            }
+        }
+    }
+
+    return testParams;
+}
+
+INSTANTIATE_TEST_SUITE_P(Io, SnapuserdVariableBlockSizeTest,
+                         ::testing::ValuesIn(GetVariableBlockTestConfigs()));
+INSTANTIATE_TEST_SUITE_P(Io, HandlerTestV3, ::testing::ValuesIn(GetVariableBlockTestConfigs()));
 INSTANTIATE_TEST_SUITE_P(Io, SnapuserdTest, ::testing::ValuesIn(GetTestConfigs()));
 INSTANTIATE_TEST_SUITE_P(Io, HandlerTest, ::testing::ValuesIn(GetTestConfigs()));
 

From b56e4743f602b8a1d95e8b0dfeb0f82e17a25417 Mon Sep 17 00:00:00 2001
From: Devin Moore <devinmoore@google.com>
Date: Wed, 31 Jan 2024 17:32:25 +0000
Subject: [PATCH 0698/1487] Change debuggerd client param from pid to tid

Change the header param to be `tid` and remove a local `pid` variable
to use `tid` instead.

Test: m
Bug: 316970771
Change-Id: I53c13081d72f46446ac6e85df77a160ef4f50c05
---
 debuggerd/client/debuggerd_client.cpp | 13 ++++++-------
 debuggerd/include/debuggerd/client.h  |  2 +-
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/debuggerd/client/debuggerd_client.cpp b/debuggerd/client/debuggerd_client.cpp
index bd1e91d3459d..af1bb8181f4b 100644
--- a/debuggerd/client/debuggerd_client.cpp
+++ b/debuggerd/client/debuggerd_client.cpp
@@ -116,7 +116,6 @@ static std::string get_wchan_data(int fd, pid_t pid) {
 
 bool debuggerd_trigger_dump(pid_t tid, DebuggerdDumpType dump_type, unsigned int timeout_ms,
                             unique_fd output_fd) {
-  pid_t pid = tid;
   if (dump_type == kDebuggerdJavaBacktrace) {
     // Java dumps always get sent to the tgid, so we need to resolve our tid to a tgid.
     android::procinfo::ProcessInfo procinfo;
@@ -125,10 +124,10 @@ bool debuggerd_trigger_dump(pid_t tid, DebuggerdDumpType dump_type, unsigned int
       log_error(output_fd, 0, "failed to get process info: %s", error.c_str());
       return false;
     }
-    pid = procinfo.pid;
+    tid = procinfo.pid;
   }
 
-  LOG(INFO) << TAG "started dumping process " << pid;
+  LOG(INFO) << TAG "started dumping process " << tid;
 
   // Rather than try to deal with poll() all the way through the flow, we update
   // the socket timeout between each step (and only use poll() during the final
@@ -172,7 +171,7 @@ bool debuggerd_trigger_dump(pid_t tid, DebuggerdDumpType dump_type, unsigned int
 
   InterceptRequest req = {
       .dump_type = dump_type,
-      .pid = pid,
+      .pid = tid,
   };
 
   // Create an intermediate pipe to pass to the other end.
@@ -235,8 +234,8 @@ bool debuggerd_trigger_dump(pid_t tid, DebuggerdDumpType dump_type, unsigned int
   // Send the signal.
   const int signal = (dump_type == kDebuggerdJavaBacktrace) ? SIGQUIT : BIONIC_SIGNAL_DEBUGGER;
   sigval val = {.sival_int = (dump_type == kDebuggerdNativeBacktrace) ? 1 : 0};
-  if (sigqueue(pid, signal, val) != 0) {
-    log_error(output_fd, errno, "failed to send signal to pid %d", pid);
+  if (sigqueue(tid, signal, val) != 0) {
+    log_error(output_fd, errno, "failed to send signal to pid %d", tid);
     return false;
   }
 
@@ -299,7 +298,7 @@ bool debuggerd_trigger_dump(pid_t tid, DebuggerdDumpType dump_type, unsigned int
     }
   }
 
-  LOG(INFO) << TAG "done dumping process " << pid;
+  LOG(INFO) << TAG "done dumping process " << tid;
 
   return true;
 }
diff --git a/debuggerd/include/debuggerd/client.h b/debuggerd/include/debuggerd/client.h
index b7284b08ecff..e7401cc4e2b3 100644
--- a/debuggerd/include/debuggerd/client.h
+++ b/debuggerd/include/debuggerd/client.h
@@ -26,7 +26,7 @@
 
 // Trigger a dump of specified process to output_fd.
 // output_fd is consumed, timeout of 0 will wait forever.
-bool debuggerd_trigger_dump(pid_t pid, enum DebuggerdDumpType dump_type, unsigned int timeout_ms,
+bool debuggerd_trigger_dump(pid_t tid, enum DebuggerdDumpType dump_type, unsigned int timeout_ms,
                             android::base::unique_fd output_fd);
 
 int dump_backtrace_to_file(pid_t tid, enum DebuggerdDumpType dump_type, int output_fd);

From 0cf102b70348a79c0b38f7d1a6b70a25ae90db83 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Thu, 1 Feb 2024 10:46:04 -0800
Subject: [PATCH 0699/1487] Restore I/O priority support

CL aosp/2929791 removed I/O priority support to prepare for a clean
revert of the CL that migrates the blkio controller from the v1 to the
v2 cgroup hierarchy. Since there was no other reason to revert the I/O
priority CL, restore I/O priority support.

Bug: 186902601
Change-Id: I1a4053140ab55973878bfeacfb546da3c601a895
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 rootdir/init.rc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 4c07c83fe78f..0646d14a1236 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -247,6 +247,7 @@ on init
     write /dev/blkio/background/blkio.bfq.weight 10
     write /dev/blkio/blkio.group_idle 0
     write /dev/blkio/background/blkio.group_idle 0
+    write /dev/blkio/background/blkio.prio.class restrict-to-be
 
     restorecon_recursive /mnt
 

From 374c43e9b7cc2c2a2e26a3ba088679f03f680437 Mon Sep 17 00:00:00 2001
From: Kenn Frankel <kfrankel@google.com>
Date: Thu, 1 Feb 2024 11:48:38 -0800
Subject: [PATCH 0700/1487] Update libstatssocket_lazy to support StringArray

Bug: 281162849
Test: LibstatssocketLazyTest

Change-Id: I917589e92db045f96daa9b191fadac50b01704c8
---
 libstats/socket_lazy/libstatssocket_lazy.cpp            | 9 ++++++++-
 libstats/socket_lazy/tests/libstatssocket_lazy_test.cpp | 3 ++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/libstats/socket_lazy/libstatssocket_lazy.cpp b/libstats/socket_lazy/libstatssocket_lazy.cpp
index dd93eebf0f16..fe94ef2d86f2 100644
--- a/libstats/socket_lazy/libstatssocket_lazy.cpp
+++ b/libstats/socket_lazy/libstatssocket_lazy.cpp
@@ -45,6 +45,7 @@ enum MethodIndex {
     k_AStatsEvent_writeBool,
     k_AStatsEvent_writeByteArray,
     k_AStatsEvent_writeString,
+    k_AStatsEvent_writeStringArray,
     k_AStatsEvent_writeAttributionChain,
     k_AStatsEvent_addBoolAnnotation,
     k_AStatsEvent_addInt32Annotation,
@@ -104,6 +105,7 @@ static void InitializeOnce() {
     BIND_SYMBOL(AStatsEvent_writeBool);
     BIND_SYMBOL(AStatsEvent_writeByteArray);
     BIND_SYMBOL(AStatsEvent_writeString);
+    BIND_SYMBOL(AStatsEvent_writeStringArray);
     BIND_SYMBOL(AStatsEvent_writeAttributionChain);
     BIND_SYMBOL(AStatsEvent_addBoolAnnotation);
     BIND_SYMBOL(AStatsEvent_addInt32Annotation);
@@ -179,6 +181,11 @@ void AStatsEvent_writeString(AStatsEvent* event, const char* value) {
     INVOKE_METHOD(AStatsEvent_writeString, event, value);
 }
 
+void AStatsEvent_writeStringArray(AStatsEvent* event, const char* const* elements,
+                                  size_t numElements) {
+    INVOKE_METHOD(AStatsEvent_writeStringArray, event, elements, numElements);
+}
+
 void AStatsEvent_writeAttributionChain(AStatsEvent* event, const uint32_t* uids,
                                        const char* const* tags, uint8_t numNodes) {
     INVOKE_METHOD(AStatsEvent_writeAttributionChain, event, uids, tags, numNodes);
@@ -198,4 +205,4 @@ void AStatsEvent_addInt32Annotation(AStatsEvent* event, uint8_t annotationId, in
 
 void AStatsSocket_close() {
     INVOKE_METHOD(AStatsSocket_close);
-}
\ No newline at end of file
+}
diff --git a/libstats/socket_lazy/tests/libstatssocket_lazy_test.cpp b/libstats/socket_lazy/tests/libstatssocket_lazy_test.cpp
index fe1359860885..3de6cd76253c 100644
--- a/libstats/socket_lazy/tests/libstatssocket_lazy_test.cpp
+++ b/libstats/socket_lazy/tests/libstatssocket_lazy_test.cpp
@@ -47,6 +47,7 @@ TEST_F(LibstatssocketLazyTest, NoLibstatssocketForStatsEvent) {
     EXPECT_DEATH(AStatsEvent_writeBool(event, false), kLoadFailed);
     EXPECT_DEATH(AStatsEvent_writeByteArray(event, NULL, 0), kLoadFailed);
     EXPECT_DEATH(AStatsEvent_writeString(event, NULL), kLoadFailed);
+    EXPECT_DEATH(AStatsEvent_writeStringArray(event, NULL, 0), kLoadFailed);
     EXPECT_DEATH(AStatsEvent_writeAttributionChain(event, NULL, NULL, 0), kLoadFailed);
 
     EXPECT_DEATH(AStatsEvent_addBoolAnnotation(event, 0, false), kLoadFailed);
@@ -55,4 +56,4 @@ TEST_F(LibstatssocketLazyTest, NoLibstatssocketForStatsEvent) {
 
 TEST_F(LibstatssocketLazyTest, NoLibstatssocketForStatsSocket) {
     EXPECT_DEATH(AStatsSocket_close(), kLoadFailed);
-}
\ No newline at end of file
+}

From 851c9c825fc417ad7df865da262b9249e4ca9649 Mon Sep 17 00:00:00 2001
From: David Dai <davidai@google.com>
Date: Thu, 1 Feb 2024 14:50:50 -0800
Subject: [PATCH 0701/1487] Add AID for Virtual Machines

Add a new AID for Virtual Machines so we can grant
capabilities such as CAP_SYS_NICE.

Bug: 322197421
Test: Build and boots, and verified capabilities

Change-Id: Ie893ba8ed6956a554bccfbd00e4e6fe9212ea77d
Signed-off-by: David Dai <davidai@google.com>
---
 libcutils/include/private/android_filesystem_config.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libcutils/include/private/android_filesystem_config.h b/libcutils/include/private/android_filesystem_config.h
index 8c6e54866f4e..ea61cc2a7407 100644
--- a/libcutils/include/private/android_filesystem_config.h
+++ b/libcutils/include/private/android_filesystem_config.h
@@ -170,6 +170,7 @@
 #define AID_WAKELOCK 3010     /* Allow system wakelock read/write access */
 #define AID_UHID 3011         /* Allow read/write to /dev/uhid node */
 #define AID_READTRACEFS 3012  /* Allow tracefs read */
+#define AID_VIRTUALMACHINE 3013 /* Allows VMs to tune for performance*/
 
 /* The range 5000-5999 is also reserved for vendor partition. */
 #define AID_OEM_RESERVED_2_START 5000

From 56aedd555188e618db420a1e150fe37624a61b0f Mon Sep 17 00:00:00 2001
From: Jeff Vander Stoep <jeffv@google.com>
Date: Tue, 6 Feb 2024 12:32:36 +0100
Subject: [PATCH 0702/1487] Replace use of deprecated logging functions

This is needed to upgrade the android_logger crate from 0.12.0
to 0.13.3.

with_max_level provides the same functionality as with_min_level.
The renaming is admittedly confusing, but the new name is accurate
and it makes sense that they deprecated and then removed the
previously poorly named with_min_level.

See crate documentation [1] and code [2].

[1]: https://docs.rs/android_logger/0.12.0/android_logger/struct.Config.html#method.with_min_level
[2]: https://docs.rs/android_logger/0.12.0/src/android_logger/lib.rs.html#227

Bug: 322718401
Test: build and run CF with the change.
Test: m aosp_cf_x86_64_phone
Change-Id: Ib4fbd486267d30e74e886139846950b066848d43
---
 trusty/keymint/src/keymint_hal_main.rs | 4 ++--
 trusty/secretkeeper/src/hal_main.rs    | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/trusty/keymint/src/keymint_hal_main.rs b/trusty/keymint/src/keymint_hal_main.rs
index cfa859f6315b..eda986a4568d 100644
--- a/trusty/keymint/src/keymint_hal_main.rs
+++ b/trusty/keymint/src/keymint_hal_main.rs
@@ -92,8 +92,8 @@ fn inner_main() -> Result<(), HalServiceError> {
     android_logger::init_once(
         android_logger::Config::default()
             .with_tag("keymint-hal-trusty")
-            .with_min_level(log::Level::Info)
-            .with_log_id(android_logger::LogId::System),
+            .with_max_level(log::LevelFilter::Info)
+            .with_log_buffer(android_logger::LogId::System),
     );
     // Redirect panic messages to logcat.
     panic::set_hook(Box::new(|panic_info| {
diff --git a/trusty/secretkeeper/src/hal_main.rs b/trusty/secretkeeper/src/hal_main.rs
index 1dc697dfee54..df304931dc4b 100644
--- a/trusty/secretkeeper/src/hal_main.rs
+++ b/trusty/secretkeeper/src/hal_main.rs
@@ -101,8 +101,8 @@ fn inner_main() -> Result<(), HalServiceError> {
     android_logger::init_once(
         android_logger::Config::default()
             .with_tag("secretkeeper-hal-trusty")
-            .with_min_level(log::Level::Info)
-            .with_log_id(android_logger::LogId::System),
+            .with_max_level(log::LevelFilter::Info)
+            .with_log_buffer(android_logger::LogId::System),
     );
     // Redirect panic messages to logcat.
     panic::set_hook(Box::new(|panic_info| {

From bf2d6dd7d40e1b52986753277c9ef9a2f33abd22 Mon Sep 17 00:00:00 2001
From: Mitch Phillips <mitchp@google.com>
Date: Tue, 6 Feb 2024 15:18:04 +0100
Subject: [PATCH 0703/1487] Update debuggerd for stack MTE.

Two things need changing for debuggerd_test to pass.

 1. The seccomp policy needs to allow for PROT_MTE (0x20) in both
    mprotect() and mmap(). Stack MTE processes do a mprotect()/mmap() of
    the stack when launching a process.
 2. The fault address and stack pointer need to be untagged when trying
    to figure out the stack overflow cause.

Bug: 320448268
Bug: 292478827
Test: atest debuggerd_test --iterations=10
Change-Id: I56471c32ca40edffbb61b7547bdf2b85a6eb1ff7
---
 debuggerd/libdebuggerd/tombstone_proto.cpp       | 5 +++++
 debuggerd/seccomp_policy/crash_dump.arm64.policy | 4 ++--
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index 744bfabf5afb..ca2551011348 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -94,6 +94,11 @@ static Architecture get_arch() {
 
 static std::optional<std::string> get_stack_overflow_cause(uint64_t fault_addr, uint64_t sp,
                                                            unwindstack::Maps* maps) {
+  // Under stack MTE the stack pointer and/or the fault address can be tagged.
+  // In order to calculate deltas between them, strip off the tags off both
+  // addresses.
+  fault_addr = untag_address(fault_addr);
+  sp = untag_address(sp);
   static constexpr uint64_t kMaxDifferenceBytes = 256;
   uint64_t difference;
   if (sp >= fault_addr) {
diff --git a/debuggerd/seccomp_policy/crash_dump.arm64.policy b/debuggerd/seccomp_policy/crash_dump.arm64.policy
index adf87380e4bf..c5d10d66b8ca 100644
--- a/debuggerd/seccomp_policy/crash_dump.arm64.policy
+++ b/debuggerd/seccomp_policy/crash_dump.arm64.policy
@@ -28,11 +28,11 @@ rt_sigaction: 1
 rt_tgsigqueueinfo: 1
 prctl: arg0 == PR_GET_NO_NEW_PRIVS || arg0 == 0x53564d41 || arg0 == PR_PAC_RESET_KEYS || arg0 == 56 || arg0 == 61
 madvise: 1
-mprotect: arg2 in 0x1|0x2
+mprotect: arg2 in 0x1|0x2|0x20
 munmap: 1
 getuid: 1
 fstat: 1
-mmap: arg2 in 0x1|0x2
+mmap: arg2 in 0x1|0x2|0x20
 geteuid: 1
 getgid: 1
 getegid: 1

From 8635c016db451dd36533a8708eea0bf4f68c001e Mon Sep 17 00:00:00 2001
From: Peter Collingbourne <pcc@google.com>
Date: Mon, 5 Feb 2024 14:59:44 -0800
Subject: [PATCH 0704/1487] fastboot: Use asynchronous operations to send data

The fastboot command currently uses USBDEVFS_BULK to transfer data
(including image data) to the target. On the kernel side it looks
like this:

1. Allocate a contiguous memory region and copy the user data into
   the memory region (which may involve accessing storage).
2. Instruct the driver to start a DMA operation.
3. Wait for the DMA to finish.

This is suboptimal because it misses out on a pipelining
opportunity. We could be doing 3 for the current operation in parallel
with 1 for the next operation, so that the next DMA is ready to go
as soon as the current DMA finishes.

The kernel supports asynchronous operations on usbdevfs file
descriptors (USBDEVFS_SUBMITURB and USBDEVFS_REAPURB), so we can
implement this like so:

1. Submit URB 0
2. Submit URB 1
3. Wait for URB 0
4. Submit URB 2
5. Wait for URB 1
and so on.

That is what this CL implements. On my machine it increases transfer
speed from 125 MB/s to 160 MB/s using a USB 3.0 connection to the
target (Pixel 8).

Bug: 324107907
Change-Id: I20db7ea14af85db48f6494091c8279ef7a21033d
---
 fastboot/usb_linux.cpp | 80 ++++++++++++++++++++++++++++++++++--------
 1 file changed, 65 insertions(+), 15 deletions(-)

diff --git a/fastboot/usb_linux.cpp b/fastboot/usb_linux.cpp
index 37bb304ea127..b7fd5ed33479 100644
--- a/fastboot/usb_linux.cpp
+++ b/fastboot/usb_linux.cpp
@@ -404,34 +404,84 @@ ssize_t LinuxUsbTransport::Write(const void* _data, size_t len)
 {
     unsigned char *data = (unsigned char*) _data;
     unsigned count = 0;
-    struct usbdevfs_bulktransfer bulk;
-    int n;
+    struct usbdevfs_urb urb[2] = {};
+    bool pending[2] = {};
 
     if (handle_->ep_out == 0 || handle_->desc == -1) {
         return -1;
     }
 
-    do {
-        int xfer;
-        xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
+    auto submit_urb = [&](size_t i) {
+        int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
 
-        bulk.ep = handle_->ep_out;
-        bulk.len = xfer;
-        bulk.data = data;
-        bulk.timeout = ms_timeout_;
+        urb[i].type = USBDEVFS_URB_TYPE_BULK;
+        urb[i].endpoint = handle_->ep_out;
+        urb[i].buffer_length = xfer;
+        urb[i].buffer = data;
+        urb[i].usercontext = (void *)i;
 
-        n = ioctl(handle_->desc, USBDEVFS_BULK, &bulk);
-        if(n != xfer) {
-            DBG("ERROR: n = %d, errno = %d (%s)\n",
-                n, errno, strerror(errno));
-            return -1;
+        int n = ioctl(handle_->desc, USBDEVFS_SUBMITURB, &urb[i]);
+        if (n != 0) {
+            DBG("ioctl(USBDEVFS_SUBMITURB) failed\n");
+            return false;
         }
 
+        pending[i] = true;
         count += xfer;
         len -= xfer;
         data += xfer;
-    } while(len > 0);
 
+        return true;
+    };
+
+    auto reap_urb = [&](size_t i) {
+        while (pending[i]) {
+            struct usbdevfs_urb *urbp;
+            int res = ioctl(handle_->desc, USBDEVFS_REAPURB, &urbp);
+            if (res != 0) {
+                DBG("ioctl(USBDEVFS_REAPURB) failed\n");
+                return false;
+            }
+            size_t done = (size_t)urbp->usercontext;
+            if (done >= 2 || !pending[done]) {
+                DBG("unexpected urb\n");
+                return false;
+            }
+            if (urbp->status != 0 || urbp->actual_length != urbp->buffer_length) {
+                DBG("urb returned error\n");
+                return false;
+            }
+            pending[done] = false;
+        }
+        return true;
+    };
+
+    if (!submit_urb(0)) {
+        return -1;
+    }
+    while (len > 0) {
+        if (!submit_urb(1)) {
+            return -1;
+        }
+        if (!reap_urb(0)) {
+            return -1;
+        }
+        if (len <= 0) {
+            if (!reap_urb(1)) {
+                return -1;
+            }
+            return count;
+        }
+        if (!submit_urb(0)) {
+            return -1;
+        }
+        if (!reap_urb(1)) {
+            return -1;
+        }
+    }
+    if (!reap_urb(0)) {
+        return -1;
+    }
     return count;
 }
 

From fa544b551b2466d64d65103cb0518b81eda7535e Mon Sep 17 00:00:00 2001
From: Zheng Pan <zhengpan@google.com>
Date: Tue, 30 Jan 2024 15:43:21 -0800
Subject: [PATCH 0705/1487] bootstat: Remove long key press check

Current check is kind of device specfic and causes false positive.

Bug: 320829712
Test: Trigger long key press and check boot reason
Change-Id: I5b2b8307f16eecd05513bfa51494da174fc839bd
---
 bootstat/bootstat.cpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/bootstat/bootstat.cpp b/bootstat/bootstat.cpp
index 2d55e5a5550c..85a9935e426b 100644
--- a/bootstat/bootstat.cpp
+++ b/bootstat/bootstat.cpp
@@ -1079,12 +1079,7 @@ std::string BootReasonStrToReason(const std::string& boot_reason) {
       }
 
       // Check for kernel panics, allowed to override reboot command.
-      if (!addKernelPanicSubReason(console, ret) &&
-          // check for long-press power down
-          ((console.rfind("Power held for ") != std::string::npos) ||
-           (console.rfind("charger: [") != std::string::npos))) {
-        ret = "cold";
-      }
+      (void)addKernelPanicSubReason(console, ret);
     }
 
     // TODO: use the HAL to get battery level (http://b/77725702).

From 6225d6f3eb5204d39d88c093778b41ca326e81d3 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 7 Feb 2024 18:27:47 +0000
Subject: [PATCH 0706/1487] We don't need __STDC_FORMAT_MACROS any more.

Test: treehugger
Change-Id: Iada8b959f61bfa55b61d2ed4b345801ed9cea0c6
---
 libutils/StopWatch.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/libutils/StopWatch.cpp b/libutils/StopWatch.cpp
index c88d60fc0562..c91cd5cd70fc 100644
--- a/libutils/StopWatch.cpp
+++ b/libutils/StopWatch.cpp
@@ -18,10 +18,6 @@
 
 #include <utils/StopWatch.h>
 
-/* for PRId64 */
-#ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS 1
-#endif
 #include <inttypes.h>
 
 #include <log/log.h>

From 1c5911fade98c14bdda106f93d81701c9f34cda7 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 7 Feb 2024 22:22:13 +0000
Subject: [PATCH 0707/1487] Remove unused addKernelPanicSubReason() return
 value.

The only caller that was looking at the return value just stopped.

Test: treehugger
Change-Id: Icf2508e8e1ee4969918eadeb580f70236ba53496
---
 bootstat/bootstat.cpp | 82 +++++++++++++++++++++----------------------
 1 file changed, 40 insertions(+), 42 deletions(-)

diff --git a/bootstat/bootstat.cpp b/bootstat/bootstat.cpp
index 85a9935e426b..d402bf17bdf2 100644
--- a/bootstat/bootstat.cpp
+++ b/bootstat/bootstat.cpp
@@ -830,7 +830,7 @@ std::string getSubreason(const std::string& content, size_t pos, bool quoted) {
   return subReason;
 }
 
-bool addKernelPanicSubReason(const pstoreConsole& console, std::string& ret) {
+void addKernelPanicSubReason(const pstoreConsole& console, std::string& ret) {
   // Check for kernel panic types to refine information
   if ((console.rfind("SysRq : Trigger a crash") != std::string::npos) ||
       (console.rfind("PC is at sysrq_handle_crash+") != std::string::npos)) {
@@ -842,63 +842,61 @@ bool addKernelPanicSubReason(const pstoreConsole& console, std::string& ret) {
     if (pos != std::string::npos) {
       ret += "," + getSubreason(console, pos + strlen(sysrqSubreason), /* quoted */ true);
     }
-    return true;
+    return;
   }
   if (console.rfind("Unable to handle kernel NULL pointer dereference at virtual address") !=
       std::string::npos) {
     ret = "kernel_panic,null";
-    return true;
+    return;
   }
   if (console.rfind("Kernel BUG at ") != std::string::npos) {
     ret = "kernel_panic,bug";
-    return true;
+    return;
   }
 
   std::string panic("Kernel panic - not syncing: ");
   auto pos = console.rfind(panic);
-  if (pos != std::string::npos) {
-    static const std::vector<std::pair<const std::string, const std::string>> panicReasons = {
-        {"Out of memory", "oom"},
-        {"out of memory", "oom"},
-        {"Oh boy, that early out of memory", "oom"},  // omg
-        {"BUG!", "bug"},
-        {"hung_task: blocked tasks", "hung"},
-        {"audit: ", "audit"},
-        {"scheduling while atomic", "atomic"},
-        {"Attempted to kill init!", "init"},
-        {"Requested init", "init"},
-        {"No working init", "init"},
-        {"Could not decompress init", "init"},
-        {"RCU Stall", "hung,rcu"},
-        {"stack-protector", "stack"},
-        {"kernel stack overflow", "stack"},
-        {"Corrupt kernel stack", "stack"},
-        {"low stack detected", "stack"},
-        {"corrupted stack end", "stack"},
-        {"subsys-restart: Resetting the SoC - modem crashed.", "modem"},
-        {"subsys-restart: Resetting the SoC - adsp crashed.", "adsp"},
-        {"subsys-restart: Resetting the SoC - dsps crashed.", "dsps"},
-        {"subsys-restart: Resetting the SoC - wcnss crashed.", "wcnss"},
-    };
+  if (pos == std::string::npos) return;
+
+  static const std::vector<std::pair<const std::string, const std::string>> panicReasons = {
+      {"Out of memory", "oom"},
+      {"out of memory", "oom"},
+      {"Oh boy, that early out of memory", "oom"},  // omg
+      {"BUG!", "bug"},
+      {"hung_task: blocked tasks", "hung"},
+      {"audit: ", "audit"},
+      {"scheduling while atomic", "atomic"},
+      {"Attempted to kill init!", "init"},
+      {"Requested init", "init"},
+      {"No working init", "init"},
+      {"Could not decompress init", "init"},
+      {"RCU Stall", "hung,rcu"},
+      {"stack-protector", "stack"},
+      {"kernel stack overflow", "stack"},
+      {"Corrupt kernel stack", "stack"},
+      {"low stack detected", "stack"},
+      {"corrupted stack end", "stack"},
+      {"subsys-restart: Resetting the SoC - modem crashed.", "modem"},
+      {"subsys-restart: Resetting the SoC - adsp crashed.", "adsp"},
+      {"subsys-restart: Resetting the SoC - dsps crashed.", "dsps"},
+      {"subsys-restart: Resetting the SoC - wcnss crashed.", "wcnss"},
+  };
 
-    ret = "kernel_panic";
-    for (auto& s : panicReasons) {
-      if (console.find(panic + s.first, pos) != std::string::npos) {
-        ret += "," + s.second;
-        return true;
-      }
-    }
-    auto reason = getSubreason(console, pos + panic.length(), /* newline */ false);
-    if (reason.length() > 3) {
-      ret += "," + reason;
+  ret = "kernel_panic";
+  for (auto& s : panicReasons) {
+    if (console.find(panic + s.first, pos) != std::string::npos) {
+      ret += "," + s.second;
+      return;
     }
-    return true;
   }
-  return false;
+  auto reason = getSubreason(console, pos + panic.length(), /* newline */ false);
+  if (reason.length() > 3) {
+    ret += "," + reason;
+  }
 }
 
-bool addKernelPanicSubReason(const std::string& content, std::string& ret) {
-  return addKernelPanicSubReason(pstoreConsole(content), ret);
+void addKernelPanicSubReason(const std::string& content, std::string& ret) {
+  addKernelPanicSubReason(pstoreConsole(content), ret);
 }
 
 const char system_reboot_reason_property[] = "sys.boot.reason";

From aeccbb8f3a4f2a7256a6308b0216dcb88b4bff8c Mon Sep 17 00:00:00 2001
From: Neill Kapron <nkapron@google.com>
Date: Wed, 7 Feb 2024 23:35:09 +0000
Subject: [PATCH 0708/1487] healthd: BatteryMonitor: doLogValues: reduce log
 level to debug

This is log spam and fills the kernel log. Reduce log level from warning
to debug.

Test: manual
Bug: 36785118
Change-Id: I70fc3a0d796cb1a984705236fe7527e266a69a03
Signed-off-by: Neill Kapron <nkapron@google.com>
---
 healthd/BatteryMonitor.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index b8bb58682a2e..fbdf5fed1ef1 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -530,7 +530,7 @@ static void doLogValues(const HealthInfo& props, const struct healthd_config& he
              props.chargerAcOnline ? "a" : "", props.chargerUsbOnline ? "u" : "",
              props.chargerWirelessOnline ? "w" : "", props.chargerDockOnline ? "d" : "");
 
-    KLOG_WARNING(LOG_TAG, "%s\n", dmesgline);
+    KLOG_DEBUG(LOG_TAG, "%s\n", dmesgline);
 }
 
 void BatteryMonitor::logValues(const HealthInfo_2_1& health_info,

From 28f4807dd3f0c1e9ddaf517122c97fe84e6ff1b8 Mon Sep 17 00:00:00 2001
From: Matt Schulte <matsch@google.com>
Date: Wed, 7 Feb 2024 16:24:26 -0800
Subject: [PATCH 0709/1487] fastboot: Remove '\n' from interface name on linux

If the device provides an interface string, we should remove the newline
from the read file that is added from by the linux kernel.

Bug: 324320178
Test: Ran the same command with my local changes vs not

```
bash$ ./fastboot devices -l
5f42ad5ad259c90cf14ea222791b6aaa fastboot usb:7-3

bash$ fastboot devices -l
5f42ad5ad259c90cf14ea222791b6aaa fastboot
 usb:7-3
```

Change-Id: Ida3316fdba8e35f0c66784f83455a4d82e90ba1c
---
 fastboot/usb_linux.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/fastboot/usb_linux.cpp b/fastboot/usb_linux.cpp
index b7fd5ed33479..72e326a78942 100644
--- a/fastboot/usb_linux.cpp
+++ b/fastboot/usb_linux.cpp
@@ -269,6 +269,9 @@ static int filter_usb_device(char* sysfs_name,
         auto path = android::base::StringPrintf("/sys/bus/usb/devices/%s/%s:1.%d/interface",
                                                 sysfs_name, sysfs_name, ifc->bInterfaceNumber);
         if (android::base::ReadFileToString(path, &interface)) {
+            if (!interface.empty() && interface.back() == '\n') {
+                interface.pop_back();
+            }
             snprintf(info.interface, sizeof(info.interface), "%s", interface.c_str());
         }
 

From cc1bf34ba613b05afaf53c5a68634513fcc024f6 Mon Sep 17 00:00:00 2001
From: Peter Collingbourne <pcc@google.com>
Date: Wed, 7 Feb 2024 16:55:49 -0800
Subject: [PATCH 0710/1487] fastboot: Use clock_gettime(CLOCK_MONOTONIC) in
 now()

If the system time changes during the execution of fastboot we might
see some strange output such as:

Sending sparse 'super' 4/20 (254972 KB)            OKAY [-516.263s]

Fix it by changing now() to use clock_gettime(CLOCK_MONOTONIC).
I confirmed that all callers of now() are using it for relative time
and not time since the epoch.

Change-Id: Ic3e9442c2ab21dfb076bfed88915085a183754b0
---
 fastboot/util.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/fastboot/util.cpp b/fastboot/util.cpp
index e03012a058aa..5966aead6a1b 100644
--- a/fastboot/util.cpp
+++ b/fastboot/util.cpp
@@ -31,7 +31,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
-#include <sys/time.h>
+#include <time.h>
 
 #include <android-base/parseint.h>
 #include <android-base/strings.h>
@@ -43,9 +43,9 @@ using android::base::borrowed_fd;
 static bool g_verbose = false;
 
 double now() {
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    return (double)tv.tv_sec + (double)tv.tv_usec / 1000000;
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return (double)ts.tv_sec + (double)ts.tv_nsec / 1000000000;
 }
 
 void die(const char* fmt, ...) {

From c902df07b07b790d4975ed24360844b7969ea7ea Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 8 Feb 2024 00:05:12 +0000
Subject: [PATCH 0711/1487] Add test mapping

Bug: 315371696
Change-Id: If8448e703cc5accde11bcdccf7585ef6779f59b0
---
 libprocessgroup/TEST_MAPPING | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 libprocessgroup/TEST_MAPPING

diff --git a/libprocessgroup/TEST_MAPPING b/libprocessgroup/TEST_MAPPING
new file mode 100644
index 000000000000..29a9ff05094a
--- /dev/null
+++ b/libprocessgroup/TEST_MAPPING
@@ -0,0 +1,7 @@
+{
+  "postsubmit": [
+    {
+      "name": "StagedRollbackTest"
+    }
+  ]
+}

From abb472c238468e7ec7f0c8b8041af2bf725c0f73 Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Thu, 8 Feb 2024 22:48:03 -0800
Subject: [PATCH 0712/1487] libsnapshot: replace non-character
 basic_string[_view]<T>

In newer versions of libc++, std::char_traits<T> is no longer defined
for non-character types, and a result, std::basic_string<T> and
std::basic_string_view<T> are also no longer defined for non-character
types. See
https://discourse.llvm.org/t/deprecating-std-string-t-for-non-character-t/66779.

Replace them with std::vector<T> and std::span<const T>.

Bug: 175635923
Test: m MODULES-IN-system-core-fs_mgr
Test: /data/nativetest64/cow_api_test/cow_api_test
Change-Id: Ife2e87833ced43ff24e5765998cb6993e4f9b4c0
---
 .../include/libsnapshot/cow_compress.h        |  4 ++--
 .../include/libsnapshot/cow_writer.h          |  8 +++----
 .../libsnapshot_cow/cow_compress.cpp          | 23 ++++++++++---------
 .../libsnapshot/libsnapshot_cow/test_v2.cpp   | 10 ++++----
 .../libsnapshot/libsnapshot_cow/writer_v2.h   |  4 ++--
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp |  9 ++++----
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |  8 +++----
 .../snapuserd/user-space-merge/read_worker.h  |  2 +-
 fs_mgr/libsnapshot/tools/cow_benchmark.cpp    |  6 ++---
 9 files changed, 38 insertions(+), 36 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
index 8191d616e831..ac0424567674 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include <memory>
+#include <vector>
 #include "libsnapshot/cow_format.h"
 
 namespace android {
@@ -40,8 +41,7 @@ class ICompressor {
 
     uint32_t GetCompressionLevel() const { return compression_level_; }
     uint32_t GetBlockSize() const { return block_size_; }
-    [[nodiscard]] virtual std::basic_string<uint8_t> Compress(const void* data,
-                                                              size_t length) const = 0;
+    [[nodiscard]] virtual std::vector<uint8_t> Compress(const void* data, size_t length) const = 0;
 
   private:
     uint32_t compression_level_;
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 89699dceed9d..651083f3efbc 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -122,13 +122,13 @@ class CompressWorker {
     CompressWorker(std::unique_ptr<ICompressor>&& compressor);
     bool RunThread();
     void EnqueueCompressBlocks(const void* buffer, size_t block_size, size_t num_blocks);
-    bool GetCompressedBuffers(std::vector<std::basic_string<uint8_t>>* compressed_buf);
+    bool GetCompressedBuffers(std::vector<std::vector<uint8_t>>* compressed_buf);
     void Finalize();
     static uint32_t GetDefaultCompressionLevel(CowCompressionAlgorithm compression);
 
     static bool CompressBlocks(ICompressor* compressor, size_t block_size, const void* buffer,
                                size_t num_blocks,
-                               std::vector<std::basic_string<uint8_t>>* compressed_data);
+                               std::vector<std::vector<uint8_t>>* compressed_data);
 
   private:
     struct CompressWork {
@@ -136,7 +136,7 @@ class CompressWorker {
         size_t num_blocks;
         size_t block_size;
         bool compression_status = false;
-        std::vector<std::basic_string<uint8_t>> compressed_data;
+        std::vector<std::vector<uint8_t>> compressed_data;
     };
 
     std::unique_ptr<ICompressor> compressor_;
@@ -150,7 +150,7 @@ class CompressWorker {
     size_t total_processed_ = 0;
 
     bool CompressBlocks(const void* buffer, size_t num_blocks, size_t block_size,
-                        std::vector<std::basic_string<uint8_t>>* compressed_data);
+                        std::vector<std::vector<uint8_t>>* compressed_data);
 };
 
 // Create an ICowWriter not backed by any file. This is useful for estimating
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
index 577cdbd96c25..0205f5086344 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
@@ -20,6 +20,7 @@
 #include <limits>
 #include <memory>
 #include <queue>
+#include <vector>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
@@ -103,9 +104,9 @@ class GzCompressor final : public ICompressor {
     GzCompressor(uint32_t compression_level, const uint32_t block_size)
         : ICompressor(compression_level, block_size){};
 
-    std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
+    std::vector<uint8_t> Compress(const void* data, size_t length) const override {
         const auto bound = compressBound(length);
-        std::basic_string<uint8_t> buffer(bound, '\0');
+        std::vector<uint8_t> buffer(bound, '\0');
 
         uLongf dest_len = bound;
         auto rv = compress2(buffer.data(), &dest_len, reinterpret_cast<const Bytef*>(data), length,
@@ -124,13 +125,13 @@ class Lz4Compressor final : public ICompressor {
     Lz4Compressor(uint32_t compression_level, const uint32_t block_size)
         : ICompressor(compression_level, block_size){};
 
-    std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
+    std::vector<uint8_t> Compress(const void* data, size_t length) const override {
         const auto bound = LZ4_compressBound(length);
         if (!bound) {
             LOG(ERROR) << "LZ4_compressBound returned 0";
             return {};
         }
-        std::basic_string<uint8_t> buffer(bound, '\0');
+        std::vector<uint8_t> buffer(bound, '\0');
 
         const auto compressed_size =
                 LZ4_compress_default(static_cast<const char*>(data),
@@ -156,13 +157,13 @@ class BrotliCompressor final : public ICompressor {
     BrotliCompressor(uint32_t compression_level, const uint32_t block_size)
         : ICompressor(compression_level, block_size){};
 
-    std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
+    std::vector<uint8_t> Compress(const void* data, size_t length) const override {
         const auto bound = BrotliEncoderMaxCompressedSize(length);
         if (!bound) {
             LOG(ERROR) << "BrotliEncoderMaxCompressedSize returned 0";
             return {};
         }
-        std::basic_string<uint8_t> buffer(bound, '\0');
+        std::vector<uint8_t> buffer(bound, '\0');
 
         size_t encoded_size = bound;
         auto rv = BrotliEncoderCompress(
@@ -186,8 +187,8 @@ class ZstdCompressor final : public ICompressor {
         ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_windowLog, log2(GetBlockSize()));
     };
 
-    std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
-        std::basic_string<uint8_t> buffer(ZSTD_compressBound(length), '\0');
+    std::vector<uint8_t> Compress(const void* data, size_t length) const override {
+        std::vector<uint8_t> buffer(ZSTD_compressBound(length), '\0');
         const auto compressed_size =
                 ZSTD_compress2(zstd_context_.get(), buffer.data(), buffer.size(), data, length);
         if (compressed_size <= 0) {
@@ -209,13 +210,13 @@ class ZstdCompressor final : public ICompressor {
 };
 
 bool CompressWorker::CompressBlocks(const void* buffer, size_t num_blocks, size_t block_size,
-                                    std::vector<std::basic_string<uint8_t>>* compressed_data) {
+                                    std::vector<std::vector<uint8_t>>* compressed_data) {
     return CompressBlocks(compressor_.get(), block_size, buffer, num_blocks, compressed_data);
 }
 
 bool CompressWorker::CompressBlocks(ICompressor* compressor, size_t block_size, const void* buffer,
                                     size_t num_blocks,
-                                    std::vector<std::basic_string<uint8_t>>* compressed_data) {
+                                    std::vector<std::vector<uint8_t>>* compressed_data) {
     const uint8_t* iter = reinterpret_cast<const uint8_t*>(buffer);
     while (num_blocks) {
         auto data = compressor->Compress(iter, block_size);
@@ -289,7 +290,7 @@ void CompressWorker::EnqueueCompressBlocks(const void* buffer, size_t block_size
     cv_.notify_all();
 }
 
-bool CompressWorker::GetCompressedBuffers(std::vector<std::basic_string<uint8_t>>* compressed_buf) {
+bool CompressWorker::GetCompressedBuffers(std::vector<std::vector<uint8_t>>* compressed_buf) {
     while (true) {
         std::unique_lock<std::mutex> lock(lock_);
         while ((total_submitted_ != total_processed_) && compressed_queue_.empty() && !stopped_) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index 1d1d24c99f16..ce80cd705305 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -18,6 +18,7 @@
 #include <iostream>
 #include <memory>
 #include <string_view>
+#include <vector>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
@@ -429,7 +430,7 @@ TEST_P(CompressionTest, NoBatchWrites) {
 template <typename T>
 class HorribleStream : public IByteStream {
   public:
-    HorribleStream(const std::basic_string<T>& input) : input_(input) {}
+    HorribleStream(const std::vector<T>& input) : input_(input) {}
 
     ssize_t Read(void* buffer, size_t length) override {
         if (pos_ >= input_.size()) {
@@ -444,16 +445,17 @@ class HorribleStream : public IByteStream {
     size_t Size() const override { return input_.size(); }
 
   private:
-    std::basic_string<T> input_;
+    std::vector<T> input_;
     size_t pos_ = 0;
 };
 
 TEST(HorribleStream, ReadFully) {
-    std::string expected = "this is some data";
+    std::string expected_str = "this is some data";
+    std::vector<char> expected{expected_str.begin(), expected_str.end()};
 
     HorribleStream<char> stream(expected);
 
-    std::string buffer(expected.size(), '\0');
+    std::vector<char> buffer(expected.size(), '\0');
     ASSERT_TRUE(stream.ReadFully(buffer.data(), buffer.size()));
     ASSERT_EQ(buffer, expected);
 }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
index 05de2ade2e9f..6a37aa7fd7b9 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.h
@@ -81,8 +81,8 @@ class CowWriterV2 : public CowWriterBase {
     int num_compress_threads_ = 1;
     std::vector<std::unique_ptr<CompressWorker>> compress_threads_;
     std::vector<std::future<bool>> threads_;
-    std::vector<std::basic_string<uint8_t>> compressed_buf_;
-    std::vector<std::basic_string<uint8_t>>::iterator buf_iter_;
+    std::vector<std::vector<uint8_t>> compressed_buf_;
+    std::vector<std::vector<uint8_t>>::iterator buf_iter_;
 
     std::vector<std::unique_ptr<CowOperationV2>> opbuffer_vec_;
     std::vector<std::unique_ptr<uint8_t[]>> databuffer_vec_;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index c92460a7c699..22e6f2cbcbe7 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -512,8 +512,7 @@ bool CowWriterV3::FlushCacheOps() {
         }
         bytes_written += op.data_length;
     }
-    if (!WriteOperation({cached_ops_.data(), cached_ops_.size()},
-                        {data_vec_.data(), data_vec_.size()})) {
+    if (!WriteOperation(cached_ops_, data_vec_)) {
         LOG(ERROR) << "Failed to flush " << cached_ops_.size() << " ops to disk";
         return false;
     }
@@ -632,7 +631,7 @@ std::vector<CowWriterV3::CompressedBuffer> CowWriterV3::ProcessBlocksWithThreade
     }
 
     // Fetch compressed buffers from the threads
-    std::vector<std::basic_string<uint8_t>> compressed_buf;
+    std::vector<std::vector<uint8_t>> compressed_buf;
     compressed_buf.clear();
     for (size_t i = 0; i < num_threads; i++) {
         CompressWorker* worker = compress_threads_[i].get();
@@ -684,8 +683,8 @@ std::vector<CowWriterV3::CompressedBuffer> CowWriterV3::CompressBlocks(const siz
     return ProcessBlocksWithThreadedCompression(num_blocks, data, type);
 }
 
-bool CowWriterV3::WriteOperation(std::basic_string_view<CowOperationV3> ops,
-                                 std::basic_string_view<struct iovec> data) {
+bool CowWriterV3::WriteOperation(std::span<const CowOperationV3> ops,
+                                 std::span<const struct iovec> data) {
     const auto total_data_size =
             std::transform_reduce(data.begin(), data.end(), 0, std::plus<size_t>{},
                                   [](const struct iovec& a) { return a.iov_len; });
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 4915e9c080c7..48eb67bcceb4 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -15,6 +15,7 @@
 #pragma once
 
 #include <android-base/logging.h>
+#include <span>
 #include <string_view>
 #include <thread>
 #include <vector>
@@ -49,15 +50,14 @@ class CowWriterV3 : public CowWriterBase {
   private:
     struct CompressedBuffer {
         size_t compression_factor;
-        std::basic_string<uint8_t> compressed_data;
+        std::vector<uint8_t> compressed_data;
     };
     void SetupHeaders();
     bool NeedsFlush() const;
     bool ParseOptions();
     bool OpenForWrite();
     bool OpenForAppend(uint64_t label);
-    bool WriteOperation(std::basic_string_view<CowOperationV3> op,
-                        std::basic_string_view<struct iovec> data);
+    bool WriteOperation(std::span<const CowOperationV3> op, std::span<const struct iovec> data);
     bool EmitBlocks(uint64_t new_block_start, const void* data, size_t size, uint64_t old_block,
                     uint16_t offset, CowOperationType type);
     bool ConstructCowOpCompressedBuffers(uint64_t new_block_start, const void* data,
@@ -111,7 +111,7 @@ class CowWriterV3 : public CowWriterBase {
     int num_compress_threads_ = 1;
     size_t batch_size_ = 1;
     std::vector<CowOperationV3> cached_ops_;
-    std::vector<std::basic_string<uint8_t>> cached_data_;
+    std::vector<std::vector<uint8_t>> cached_data_;
     std::vector<struct iovec> data_vec_;
 
     std::vector<std::thread> threads_;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
index 43e896a9a95c..04b2736e9843 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
@@ -69,7 +69,7 @@ class ReadWorker : public Worker, public IBlockServer::Delegate {
     std::shared_ptr<IBlockServerOpener> block_server_opener_;
     std::unique_ptr<IBlockServer> block_server_;
 
-    std::basic_string<uint8_t> xor_buffer_;
+    std::vector<uint8_t> xor_buffer_;
     std::unique_ptr<void, decltype(&::free)> aligned_buffer_;
     std::unique_ptr<uint8_t[]> decompressed_buffer_;
 };
diff --git a/fs_mgr/libsnapshot/tools/cow_benchmark.cpp b/fs_mgr/libsnapshot/tools/cow_benchmark.cpp
index 4d5e346c4cd4..fb463c816749 100644
--- a/fs_mgr/libsnapshot/tools/cow_benchmark.cpp
+++ b/fs_mgr/libsnapshot/tools/cow_benchmark.cpp
@@ -78,7 +78,7 @@ void OneShotCompressionTest() {
 
     for (size_t i = 0; i < compressors.size(); i++) {
         const auto start = std::chrono::steady_clock::now();
-        std::basic_string<uint8_t> compressed_data =
+        std::vector<uint8_t> compressed_data =
                 compressors[i]->Compress(buffer.data(), buffer.size());
         const auto end = std::chrono::steady_clock::now();
         const auto latency =
@@ -141,13 +141,13 @@ void IncrementalCompressionTest() {
     std::vector<std::pair<double, std::string>> ratios;
 
     for (size_t i = 0; i < compressors.size(); i++) {
-        std::vector<std::basic_string<uint8_t>> compressed_data_vec;
+        std::vector<std::vector<uint8_t>> compressed_data_vec;
         int num_blocks = buffer.size() / BLOCK_SZ;
         const uint8_t* iter = reinterpret_cast<const uint8_t*>(buffer.data());
 
         const auto start = std::chrono::steady_clock::now();
         while (num_blocks > 0) {
-            std::basic_string<uint8_t> compressed_data = compressors[i]->Compress(iter, BLOCK_SZ);
+            std::vector<uint8_t> compressed_data = compressors[i]->Compress(iter, BLOCK_SZ);
             compressed_data_vec.emplace_back(compressed_data);
             num_blocks--;
             iter += BLOCK_SZ;

From 29cd07132da2f5182a0d8ee1327c7175efbf019d Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 9 Feb 2024 16:40:02 +0000
Subject: [PATCH 0713/1487] Remove obsolete __STDC_LIMIT_MACROS references.

None of our libcs need this any more.

Test: treehugger
Change-Id: I8a942ad6b3860633a6d722bd237a7c75482499eb
---
 libutils/binder/SharedBuffer_test.cpp | 2 --
 libutils/binder/String8.cpp           | 4 +---
 libutils/binder/Vector_test.cpp       | 1 -
 3 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/libutils/binder/SharedBuffer_test.cpp b/libutils/binder/SharedBuffer_test.cpp
index 1d6317ff7718..26702b037100 100644
--- a/libutils/binder/SharedBuffer_test.cpp
+++ b/libutils/binder/SharedBuffer_test.cpp
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-#define __STDC_LIMIT_MACROS
-
 #include <gtest/gtest.h>
 
 #include <memory>
diff --git a/libutils/binder/String8.cpp b/libutils/binder/String8.cpp
index 749bfcbb510d..1de9e8b17362 100644
--- a/libutils/binder/String8.cpp
+++ b/libutils/binder/String8.cpp
@@ -14,15 +14,13 @@
  * limitations under the License.
  */
 
-#define __STDC_LIMIT_MACROS
-#include <stdint.h>
-
 #include <utils/String8.h>
 
 #include <log/log.h>
 #include <utils/String16.h>
 
 #include <ctype.h>
+#include <stdint.h>
 
 #include <limits>
 #include <string>
diff --git a/libutils/binder/Vector_test.cpp b/libutils/binder/Vector_test.cpp
index 6d90eaa9e47b..312dcf688d21 100644
--- a/libutils/binder/Vector_test.cpp
+++ b/libutils/binder/Vector_test.cpp
@@ -16,7 +16,6 @@
 
 #define LOG_TAG "Vector_test"
 
-#define __STDC_LIMIT_MACROS
 #include <stdint.h>
 #include <unistd.h>
 

From e5bc36900eb9f7704a022c8f476377ff5295d3c7 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 7 Feb 2024 06:29:48 +0000
Subject: [PATCH 0714/1487] create_snapshot: Enable v3 writer + variable block
 size

1: Move to v3 COW writer

2: Enable variable block size. Default compression set to lz4
with compression factor 64KiB

3: Prepare merge sequence so that device can initiate the merge

4: Verify the merge order

Bug: 319309466

Test: On Pixel 6

This was tested on live builds where the actual builds/testing
is done on CI.

Patch-Create+Apply = Create the snapshot patches between two
builds and apply them to the device

Branch(main)            Patch-Creation+Apply  Snapshot-size
=============================================================
Build-1 -> Build-2      14 seconds            160MB

Build-2 -> Build-3      21 seconds            331MB

Build-3 -> Build-4      30 seconds            375MB

Build X -> Build X      3 seconds             8MB

Change-Id: I96437032de029d89de62ba11fe37d9287b0a4071
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../libsnapshot_cow/create_cow.cpp            | 190 ++++++++++++++++--
 1 file changed, 169 insertions(+), 21 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
index efb1035c2524..5497b7232944 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
@@ -71,6 +71,8 @@ class CreateSnapshot {
 
     const int kNumThreads = 6;
     const size_t kBlockSizeToRead = 1_MiB;
+    const size_t compression_factor_ = 64_KiB;
+    size_t replace_ops_ = 0, copy_ops_ = 0, zero_ops_ = 0, in_place_ops_ = 0;
 
     std::unordered_map<std::string, int> source_block_hash_;
     std::mutex source_block_hash_lock_;
@@ -81,7 +83,12 @@ class CreateSnapshot {
     std::unique_ptr<uint8_t[]> zblock_;
 
     std::string compression_ = "lz4";
-    unique_fd fd_;
+    unique_fd cow_fd_;
+    unique_fd target_fd_;
+
+    std::vector<uint64_t> zero_blocks_;
+    std::vector<uint64_t> replace_blocks_;
+    std::unordered_map<uint64_t, uint64_t> copy_blocks_;
 
     const int BLOCK_SZ = 4_KiB;
     void SHA256(const void* data, size_t length, uint8_t out[32]);
@@ -93,7 +100,14 @@ class CreateSnapshot {
     bool FindSourceBlockHash();
     bool PrepareParse(std::string& parsing_file, const bool createSnapshot);
     bool ParsePartition();
-    bool WriteSnapshot(const void* buffer, uint64_t block, std::string& block_hash);
+    void PrepareMergeBlock(const void* buffer, uint64_t block, std::string& block_hash);
+    bool WriteV3Snapshots();
+    size_t PrepareWrite(size_t* pending_ops, size_t start_index);
+
+    bool CreateSnapshotWriter();
+    bool WriteOrderedSnapshots();
+    bool WriteNonOrderedSnapshots();
+    bool VerifyMergeOrder();
 };
 
 void CreateSnapshotLogger(android::base::LogId, android::base::LogSeverity severity, const char*,
@@ -118,21 +132,19 @@ bool CreateSnapshot::PrepareParse(std::string& parsing_file, const bool createSn
     create_snapshot_patch_ = createSnapshot;
 
     if (createSnapshot) {
-        fd_.reset(open(patch_file_.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666));
-        if (fd_ < 0) {
+        cow_fd_.reset(open(patch_file_.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666));
+        if (cow_fd_ < 0) {
             PLOG(ERROR) << "Failed to open the snapshot-patch file: " << patch_file_;
             return false;
         }
 
+        target_fd_.reset((open(parsing_file_.c_str(), O_RDONLY)));
+        if (target_fd_ < 0) {
+            LOG(ERROR) << "open failed: " << parsing_file_;
+            return false;
+        }
         zblock_ = std::make_unique<uint8_t[]>(BLOCK_SZ);
         std::memset(zblock_.get(), 0, BLOCK_SZ);
-
-        CowOptions options;
-        options.compression = compression_;
-        options.num_compress_threads = 2;
-        options.batch_write = true;
-        options.cluster_ops = 600;
-        writer_ = CreateCowWriter(2, options, std::move(fd_));
     }
     return true;
 }
@@ -187,19 +199,158 @@ std::string CreateSnapshot::ToHexString(const uint8_t* buf, size_t len) {
     return out;
 }
 
-bool CreateSnapshot::WriteSnapshot(const void* buffer, uint64_t block, std::string& block_hash) {
+void CreateSnapshot::PrepareMergeBlock(const void* buffer, uint64_t block,
+                                       std::string& block_hash) {
     if (std::memcmp(zblock_.get(), buffer, BLOCK_SZ) == 0) {
         std::lock_guard<std::mutex> lock(write_lock_);
-        return writer_->AddZeroBlocks(block, 1);
+        zero_blocks_.push_back(block);
+        return;
     }
 
     auto iter = source_block_hash_.find(block_hash);
     if (iter != source_block_hash_.end()) {
         std::lock_guard<std::mutex> lock(write_lock_);
-        return writer_->AddCopy(block, iter->second, 1);
+        // In-place copy is skipped
+        if (block != iter->second) {
+            copy_blocks_[block] = iter->second;
+        } else {
+            in_place_ops_ += 1;
+        }
+        return;
     }
     std::lock_guard<std::mutex> lock(write_lock_);
-    return writer_->AddRawBlocks(block, buffer, BLOCK_SZ);
+    replace_blocks_.push_back(block);
+}
+
+size_t CreateSnapshot::PrepareWrite(size_t* pending_ops, size_t start_index) {
+    size_t num_ops = *pending_ops;
+    uint64_t start_block = replace_blocks_[start_index];
+    size_t nr_consecutive = 1;
+    num_ops -= 1;
+    while (num_ops) {
+        uint64_t next_block = replace_blocks_[start_index + nr_consecutive];
+        if (next_block != start_block + nr_consecutive) {
+            break;
+        }
+        nr_consecutive += 1;
+        num_ops -= 1;
+    }
+    return nr_consecutive;
+}
+
+bool CreateSnapshot::CreateSnapshotWriter() {
+    uint64_t dev_sz = lseek(target_fd_.get(), 0, SEEK_END);
+    CowOptions options;
+    options.compression = compression_;
+    options.num_compress_threads = 2;
+    options.batch_write = true;
+    options.cluster_ops = 600;
+    options.compression_factor = compression_factor_;
+    options.max_blocks = {dev_sz / options.block_size};
+    writer_ = CreateCowWriter(3, options, std::move(cow_fd_));
+    return true;
+}
+
+bool CreateSnapshot::WriteNonOrderedSnapshots() {
+    zero_ops_ = zero_blocks_.size();
+    for (auto it = zero_blocks_.begin(); it != zero_blocks_.end(); it++) {
+        if (!writer_->AddZeroBlocks(*it, 1)) {
+            return false;
+        }
+    }
+    std::string buffer(compression_factor_, '\0');
+
+    replace_ops_ = replace_blocks_.size();
+    size_t blocks_to_compress = replace_blocks_.size();
+    size_t num_ops = 0;
+    size_t block_index = 0;
+    while (blocks_to_compress) {
+        num_ops = std::min((compression_factor_ / BLOCK_SZ), blocks_to_compress);
+        auto linear_blocks = PrepareWrite(&num_ops, block_index);
+        if (!android::base::ReadFullyAtOffset(target_fd_.get(), buffer.data(),
+                                              (linear_blocks * BLOCK_SZ),
+                                              replace_blocks_[block_index] * BLOCK_SZ)) {
+            LOG(ERROR) << "Failed to read at offset: " << replace_blocks_[block_index] * BLOCK_SZ
+                       << " size: " << linear_blocks * BLOCK_SZ;
+            return false;
+        }
+        if (!writer_->AddRawBlocks(replace_blocks_[block_index], buffer.data(),
+                                   linear_blocks * BLOCK_SZ)) {
+            LOG(ERROR) << "AddRawBlocks failed";
+            return false;
+        }
+
+        block_index += linear_blocks;
+        blocks_to_compress -= linear_blocks;
+    }
+    if (!writer_->Finalize()) {
+        return false;
+    }
+    return true;
+}
+
+bool CreateSnapshot::WriteOrderedSnapshots() {
+    std::unordered_map<uint64_t, uint64_t> overwritten_blocks;
+    std::vector<std::pair<uint64_t, uint64_t>> merge_sequence;
+    for (auto it = copy_blocks_.begin(); it != copy_blocks_.end(); it++) {
+        if (overwritten_blocks.count(it->second)) {
+            replace_blocks_.push_back(it->first);
+            continue;
+        }
+        overwritten_blocks[it->first] = it->second;
+        merge_sequence.emplace_back(std::make_pair(it->first, it->second));
+    }
+    // Sort the blocks so that if the blocks are contiguous, it would help
+    // compress multiple blocks in one shot based on the compression factor.
+    std::sort(replace_blocks_.begin(), replace_blocks_.end());
+
+    copy_ops_ = merge_sequence.size();
+    for (auto it = merge_sequence.begin(); it != merge_sequence.end(); it++) {
+        if (!writer_->AddCopy(it->first, it->second, 1)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool CreateSnapshot::VerifyMergeOrder() {
+    unique_fd read_fd;
+    read_fd.reset(open(patch_file_.c_str(), O_RDONLY));
+    if (read_fd < 0) {
+        PLOG(ERROR) << "Failed to open the snapshot-patch file: " << patch_file_;
+        return false;
+    }
+    CowReader reader;
+    if (!reader.Parse(read_fd)) {
+        LOG(ERROR) << "Parse failed";
+        return false;
+    }
+
+    if (!reader.VerifyMergeOps()) {
+        LOG(ERROR) << "MergeOps Order is wrong";
+        return false;
+    }
+    return true;
+}
+
+bool CreateSnapshot::WriteV3Snapshots() {
+    if (!CreateSnapshotWriter()) {
+        return false;
+    }
+    if (!WriteOrderedSnapshots()) {
+        return false;
+    }
+    if (!WriteNonOrderedSnapshots()) {
+        return false;
+    }
+    if (!VerifyMergeOrder()) {
+        return false;
+    }
+
+    LOG(INFO) << "In-place: " << in_place_ops_ << " Zero: " << zero_ops_
+              << " Replace: " << replace_ops_ << " copy: " << copy_ops_;
+    return true;
 }
 
 bool CreateSnapshot::ReadBlocks(off_t offset, const int skip_blocks, const uint64_t dev_sz) {
@@ -241,10 +392,7 @@ bool CreateSnapshot::ReadBlocks(off_t offset, const int skip_blocks, const uint6
             std::string hash = ToHexString(checksum, sizeof(checksum));
 
             if (create_snapshot_patch_) {
-                if (!WriteSnapshot(bufptr, blkindex, hash)) {
-                    LOG(ERROR) << "WriteSnapshot failed for block: " << blkindex;
-                    return false;
-                }
+                PrepareMergeBlock(bufptr, blkindex, hash);
             } else {
                 std::lock_guard<std::mutex> lock(source_block_hash_lock_);
                 {
@@ -306,8 +454,8 @@ bool CreateSnapshot::ParsePartition() {
         ret = t.get() && ret;
     }
 
-    if (ret && create_snapshot_patch_ && !writer_->Finalize()) {
-        LOG(ERROR) << "Finzalize failed";
+    if (ret && create_snapshot_patch_ && !WriteV3Snapshots()) {
+        LOG(ERROR) << "Snapshot Write failed";
         return false;
     }
 

From 914ccc56648299b41859f77b9512814c4557e255 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pierre-Cl=C3=A9ment=20Tosi?= <ptosi@google.com>
Date: Mon, 12 Feb 2024 16:00:44 +0000
Subject: [PATCH 0715/1487] first_stage_console: Address compiler warning

Re-order the fields in the declaration to address the following

  ISO C++ requires field designators to be specified in declaration order;
  field 'sigaction::(anonymous union at bionic/libc/include/bits/signal_types.h:76:20)'
  will be initialized after field 'sa_flags' [-Wreorder-init-list]

Test: TH
Change-Id: I3f1d4739f1677aad50d4f07361aa264da43bdd13
---
 init/first_stage_console.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/init/first_stage_console.cpp b/init/first_stage_console.cpp
index 67cac19144c1..c6c3008ce470 100644
--- a/init/first_stage_console.cpp
+++ b/init/first_stage_console.cpp
@@ -86,7 +86,9 @@ namespace init {
 void StartConsole(const std::string& cmdline) {
     bool console = KernelConsolePresent(cmdline);
     // Use a simple sigchld handler -- first_stage_console doesn't need to track or log zombies
-    const struct sigaction chld_act { .sa_handler = SIG_DFL, .sa_flags = SA_NOCLDWAIT };
+    const struct sigaction chld_act {
+        .sa_flags = SA_NOCLDWAIT, .sa_handler = SIG_DFL
+    };
 
     sigaction(SIGCHLD, &chld_act, nullptr);
     pid_t pid = fork();

From f425428c2d5bec2647324af892b36f7e3454133a Mon Sep 17 00:00:00 2001
From: Snehal <snehalreddy@google.com>
Date: Tue, 13 Feb 2024 17:57:15 +0000
Subject: [PATCH 0716/1487] Sync tipc.h with one from trusty

Bug: 325069766

Test: Android boot and crasher test

Change-Id: I36244cfb698a81be79c204eb019e1a59b90d2e6c
---
 trusty/metrics/include/trusty/metrics/tipc.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/trusty/metrics/include/trusty/metrics/tipc.h b/trusty/metrics/include/trusty/metrics/tipc.h
index 66d08768452a..b29628ea1e28 100644
--- a/trusty/metrics/include/trusty/metrics/tipc.h
+++ b/trusty/metrics/include/trusty/metrics/tipc.h
@@ -91,9 +91,12 @@ struct metrics_resp {
  * struct metrics_report_crash_req - arguments of %METRICS_CMD_REPORT_CRASH
  *                                   requests
  * @app_id_len: length of app ID that follows this structure
+ * @crash_reason: architecture-specific code representing the reason for the
+ *                crash
  */
 struct metrics_report_crash_req {
     uint32_t app_id_len;
+    uint32_t crash_reason;
 } __attribute__((__packed__));
 
 #define METRICS_MAX_APP_ID_LEN 256

From 61d9e2ab8da3334bcc4a6d4c4eb63dbecccf5e6a Mon Sep 17 00:00:00 2001
From: Dennis Shen <dzshen@google.com>
Date: Tue, 13 Feb 2024 03:24:08 +0000
Subject: [PATCH 0717/1487] init.rc: create /metadata/aconfig,
 /metadata/aconfig/flags and /metadta/aconfig/boot dirs

Create aconfig dirs on /metadata to store aconfig storage related files.

Under /metadata/aconfig we will store the following pb files:

1, aconfig_storage_location.pb, store the location of the storage files for
each container.

2, aconfig_flag_persistent_overrides.pb, store the local flag value overrides.

Under /metadata/aconfig/flags we will store flag value and info files
for each container, this include:

1, <container_name>.val flag value file
2, <container_name>.info flag info file

Under /metadata/aconfig/boot we will store read only flag value files
copied from /metadata/aconfig/flags at boot. These read only files are
used to serve flag read queries.

Bug: 312444587
Test: m
Change-Id: I8ae06e56fc9b9e8c0b06f86e3deb4219d7f49660
---
 rootdir/init.rc | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 0646d14a1236..f3b2d0379245 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -640,6 +640,11 @@ on post-fs
     restorecon_recursive /metadata/apex
 
     mkdir /metadata/staged-install 0770 root system
+
+    mkdir /metadata/aconfig 0750 root system
+    mkdir /metadata/aconfig/flags 0750 root system
+    mkdir /metadata/aconfig/boot 0754 root system
+
 on late-fs
     # Ensure that tracefs has the correct permissions.
     # This does not work correctly if it is called in post-fs.

From f791b99628903d285bc352dca7242f6d18c69d1c Mon Sep 17 00:00:00 2001
From: Vilas Bhat <vilasbhat@google.com>
Date: Tue, 13 Feb 2024 16:43:09 +0000
Subject: [PATCH 0718/1487] ashmem: Remove hardcoded PAGE_SIZE usage in
 ashmem_test

Bug: 323061793
Test: atest libcutils_test
Change-Id: I8defd5225859b52a1b96a638d418188b328a23bc
---
 libcutils/ashmem_test.cpp | 82 +++++++++++++++++++++------------------
 1 file changed, 44 insertions(+), 38 deletions(-)

diff --git a/libcutils/ashmem_test.cpp b/libcutils/ashmem_test.cpp
index d158427dcbcc..571b41000fa2 100644
--- a/libcutils/ashmem_test.cpp
+++ b/libcutils/ashmem_test.cpp
@@ -22,6 +22,8 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <vector>
+
 #include <android-base/macros.h>
 #include <android-base/unique_fd.h>
 #include <cutils/ashmem.h>
@@ -61,16 +63,16 @@ void TestProtIs(const unique_fd& fd, int prot) {
     EXPECT_EQ(prot, ioctl(fd, ASHMEM_GET_PROT_MASK));
 }
 
-void FillData(uint8_t* data, size_t dataLen) {
-    for (size_t i = 0; i < dataLen; i++) {
+void FillData(std::vector<uint8_t>& data) {
+    for (size_t i = 0; i < data.size(); i++) {
         data[i] = i & 0xFF;
     }
 }
 
 TEST(AshmemTest, BasicTest) {
-    constexpr size_t size = PAGE_SIZE;
-    uint8_t data[size];
-    FillData(data, size);
+    const size_t size = getpagesize();
+    std::vector<uint8_t> data(size);
+    FillData(data);
 
     unique_fd fd;
     ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
@@ -78,21 +80,21 @@ TEST(AshmemTest, BasicTest) {
     void* region1 = nullptr;
     ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ | PROT_WRITE, &region1));
 
-    memcpy(region1, &data, size);
-    ASSERT_EQ(0, memcmp(region1, &data, size));
+    memcpy(region1, data.data(), size);
+    ASSERT_EQ(0, memcmp(region1, data.data(), size));
 
     EXPECT_EQ(0, munmap(region1, size));
 
     void *region2;
     ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ, &region2));
-    ASSERT_EQ(0, memcmp(region2, &data, size));
+    ASSERT_EQ(0, memcmp(region2, data.data(), size));
     EXPECT_EQ(0, munmap(region2, size));
 }
 
 TEST(AshmemTest, ForkTest) {
-    constexpr size_t size = PAGE_SIZE;
-    uint8_t data[size];
-    FillData(data, size);
+    const size_t size = getpagesize();
+    std::vector<uint8_t> data(size);
+    FillData(data);
 
     unique_fd fd;
     ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
@@ -100,8 +102,8 @@ TEST(AshmemTest, ForkTest) {
     void* region1 = nullptr;
     ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ | PROT_WRITE, &region1));
 
-    memcpy(region1, &data, size);
-    ASSERT_EQ(0, memcmp(region1, &data, size));
+    memcpy(region1, data.data(), size);
+    ASSERT_EQ(0, memcmp(region1, data.data(), size));
     EXPECT_EQ(0, munmap(region1, size));
 
     ASSERT_EXIT(
@@ -113,7 +115,7 @@ TEST(AshmemTest, ForkTest) {
             if (region2 == MAP_FAILED) {
                 _exit(1);
             }
-            if (memcmp(region2, &data, size) != 0) {
+            if (memcmp(region2, data.data(), size) != 0) {
                 _exit(2);
             }
             memset(region2, 0, size);
@@ -122,10 +124,10 @@ TEST(AshmemTest, ForkTest) {
         },
         ::testing::ExitedWithCode(0), "");
 
-    memset(&data, 0, size);
+    memset(data.data(), 0, size);
     void *region2;
     ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ | PROT_WRITE, &region2));
-    ASSERT_EQ(0, memcmp(region2, &data, size));
+    ASSERT_EQ(0, memcmp(region2, data.data(), size));
     EXPECT_EQ(0, munmap(region2, size));
 }
 
@@ -134,18 +136,19 @@ TEST(AshmemTest, FileOperationsTest) {
     void* region = nullptr;
 
     // Allocate a 4-page buffer, but leave page-sized holes on either side
-    constexpr size_t size = PAGE_SIZE * 4;
-    constexpr size_t dataSize = PAGE_SIZE * 2;
-    constexpr size_t holeSize = PAGE_SIZE;
+    const size_t pageSize = getpagesize();
+    const size_t size = pageSize * 4;
+    const size_t dataSize = pageSize * 2;
+    const size_t holeSize = pageSize;
     ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
     ASSERT_NO_FATAL_FAILURE(TestMmap(fd, dataSize, PROT_READ | PROT_WRITE, &region, holeSize));
 
-    uint8_t data[dataSize];
-    FillData(data, dataSize);
-    memcpy(region, data, dataSize);
+    std::vector<uint8_t> data(dataSize);
+    FillData(data);
+    memcpy(region, data.data(), dataSize);
 
-    constexpr off_t dataStart = holeSize;
-    constexpr off_t dataEnd = dataStart + dataSize;
+    const off_t dataStart = holeSize;
+    const off_t dataEnd = dataStart + dataSize;
 
     // The sequence of seeks below looks something like this:
     //
@@ -163,9 +166,12 @@ TEST(AshmemTest, FileOperationsTest) {
         // Expected lseek() return value
         off_t ret;
     } seeks[] = {
-        {99, SEEK_SET, 99},         {dataStart, SEEK_CUR, dataStart + 99},
-        {0, SEEK_DATA, dataStart},  {dataStart, SEEK_HOLE, dataEnd},
-        {-99, SEEK_END, size - 99}, {-dataStart, SEEK_CUR, dataEnd - 99},
+            {99, SEEK_SET, 99},
+            {dataStart, SEEK_CUR, dataStart + 99},
+            {0, SEEK_DATA, dataStart},
+            {dataStart, SEEK_HOLE, dataEnd},
+            {-99, SEEK_END, static_cast<off_t>(size) - 99},
+            {-dataStart, SEEK_CUR, dataEnd - 99},
     };
     for (const auto& cfg : seeks) {
         errno = 0;
@@ -180,7 +186,7 @@ TEST(AshmemTest, FileOperationsTest) {
             uint8_t buf[readSize];
 
             ASSERT_EQ(readSize, TEMP_FAILURE_RETRY(read(fd, buf, readSize)));
-            EXPECT_EQ(0, memcmp(buf, data + dataOff, readSize));
+            EXPECT_EQ(0, memcmp(buf, &data[dataOff], readSize));
         }
     }
 
@@ -189,7 +195,7 @@ TEST(AshmemTest, FileOperationsTest) {
 
 TEST(AshmemTest, ProtTest) {
     unique_fd fd;
-    constexpr size_t size = PAGE_SIZE;
+    const size_t size = getpagesize();
     void *region;
 
     ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ));
@@ -217,7 +223,7 @@ TEST(AshmemTest, ProtTest) {
 
 TEST(AshmemTest, ForkProtTest) {
     unique_fd fd;
-    constexpr size_t size = PAGE_SIZE;
+    const size_t size = getpagesize();
 
     int protFlags[] = { PROT_READ, PROT_WRITE };
     for (size_t i = 0; i < arraysize(protFlags); i++) {
@@ -238,9 +244,9 @@ TEST(AshmemTest, ForkProtTest) {
 }
 
 TEST(AshmemTest, ForkMultiRegionTest) {
-    constexpr size_t size = PAGE_SIZE;
-    uint8_t data[size];
-    FillData(data, size);
+    const size_t size = getpagesize();
+    std::vector<uint8_t> data(size);
+    FillData(data);
 
     constexpr int nRegions = 16;
     unique_fd fd[nRegions];
@@ -248,8 +254,8 @@ TEST(AshmemTest, ForkMultiRegionTest) {
         ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd[i], PROT_READ | PROT_WRITE));
         void* region = nullptr;
         ASSERT_NO_FATAL_FAILURE(TestMmap(fd[i], size, PROT_READ | PROT_WRITE, &region));
-        memcpy(region, &data, size);
-        ASSERT_EQ(0, memcmp(region, &data, size));
+        memcpy(region, data.data(), size);
+        ASSERT_EQ(0, memcmp(region, data.data(), size));
         EXPECT_EQ(0, munmap(region, size));
     }
 
@@ -262,7 +268,7 @@ TEST(AshmemTest, ForkMultiRegionTest) {
             if (region == MAP_FAILED) {
                 _exit(1);
             }
-            if (memcmp(region, &data, size) != 0) {
+            if (memcmp(region, data.data(), size) != 0) {
                 munmap(region, size);
                 _exit(2);
             }
@@ -272,11 +278,11 @@ TEST(AshmemTest, ForkMultiRegionTest) {
         _exit(0);
     }, ::testing::ExitedWithCode(0), "");
 
-    memset(&data, 0, size);
+    memset(data.data(), 0, size);
     for (int i = 0; i < nRegions; i++) {
         void *region;
         ASSERT_NO_FATAL_FAILURE(TestMmap(fd[i], size, PROT_READ | PROT_WRITE, &region));
-        ASSERT_EQ(0, memcmp(region, &data, size));
+        ASSERT_EQ(0, memcmp(region, data.data(), size));
         EXPECT_EQ(0, munmap(region, size));
     }
 }

From 5fa6663458c8acd36b5bbcb861589809055dfef0 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Wed, 7 Feb 2024 16:42:23 -0800
Subject: [PATCH 0719/1487] Read data set by android_add_crash_detail into
 tombstone.

Bug: 155462331
Bug: 309446525
Change-Id: I6d01aafca48e0e5e8cbd5ae87add6aec0c429503
---
 debuggerd/crash_dump.cpp                      |   1 +
 debuggerd/debuggerd_test.cpp                  | 181 ++++++++++++++++++
 debuggerd/handler/debuggerd_handler.cpp       |   1 +
 debuggerd/include/debuggerd/handler.h         |   3 +
 .../libdebuggerd/include/libdebuggerd/types.h |   1 +
 .../test/tombstone_proto_to_text_test.cpp     |  16 ++
 debuggerd/libdebuggerd/tombstone_proto.cpp    |  44 ++++-
 .../libdebuggerd/tombstone_proto_to_text.cpp  |  29 +++
 debuggerd/proto/tombstone.proto               |   8 +-
 debuggerd/protocol.h                          |   1 +
 10 files changed, 283 insertions(+), 2 deletions(-)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 0899111b2a2a..a23a26925d4d 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -322,6 +322,7 @@ static void ReadCrashInfo(unique_fd& fd, siginfo_t* siginfo,
       process_info->scudo_ring_buffer = crash_info->data.d.scudo_ring_buffer;
       process_info->scudo_ring_buffer_size = crash_info->data.d.scudo_ring_buffer_size;
       *recoverable_gwp_asan_crash = crash_info->data.d.recoverable_gwp_asan_crash;
+      process_info->crash_detail_page = crash_info->data.d.crash_detail_page;
       FALLTHROUGH_INTENDED;
     case 1:
     case 2:
diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index c0522aa9d2e9..a308ffbc91ec 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -939,6 +939,187 @@ TEST_F(CrasherTest, abort_message) {
   ASSERT_MATCH(result, R"(Abort message: 'x{4045}')");
 }
 
+static char g_crash_detail_value_changes[] = "crash_detail_value";
+static char g_crash_detail_value[] = "crash_detail_value";
+static char g_crash_detail_value2[] = "crash_detail_value2";
+
+inline crash_detail_t* _Nullable android_register_crash_detail_strs(const char* _Nonnull name,
+                                                                    const char* _Nonnull data) {
+  return android_register_crash_detail(name, strlen(name), data, strlen(data));
+}
+
+TEST_F(CrasherTest, crash_detail_single) {
+  int intercept_result;
+  unique_fd output_fd;
+  StartProcess([]() {
+    android_register_crash_detail_strs("CRASH_DETAIL_NAME", g_crash_detail_value);
+    abort();
+  });
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  FinishIntercept(&intercept_result);
+
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME: 'crash_detail_value')");
+}
+
+TEST_F(CrasherTest, crash_detail_single_byte_name) {
+  int intercept_result;
+  unique_fd output_fd;
+  StartProcess([]() {
+    android_register_crash_detail_strs("CRASH_DETAIL_NAME\1", g_crash_detail_value);
+    abort();
+  });
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  FinishIntercept(&intercept_result);
+
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME\\1: 'crash_detail_value')");
+}
+
+
+TEST_F(CrasherTest, crash_detail_single_bytes) {
+  int intercept_result;
+  unique_fd output_fd;
+  StartProcess([]() {
+    android_register_crash_detail("CRASH_DETAIL_NAME", strlen("CRASH_DETAIL_NAME"), "\1",
+                                  sizeof("\1"));
+    abort();
+  });
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  FinishIntercept(&intercept_result);
+
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME: '\\1\\0')");
+}
+
+TEST_F(CrasherTest, crash_detail_mixed) {
+  int intercept_result;
+  unique_fd output_fd;
+  StartProcess([]() {
+    const char data[] = "helloworld\1\255\3";
+    android_register_crash_detail_strs("CRASH_DETAIL_NAME", data);
+    abort();
+  });
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  FinishIntercept(&intercept_result);
+
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME: 'helloworld\\1\\255\\3')");
+}
+
+TEST_F(CrasherTest, crash_detail_many) {
+  int intercept_result;
+  unique_fd output_fd;
+  StartProcess([]() {
+    for (int i = 0; i < 1000; ++i) {
+      std::string name = "CRASH_DETAIL_NAME" + std::to_string(i);
+      std::string value = "CRASH_DETAIL_VALUE" + std::to_string(i);
+      auto* h = android_register_crash_detail_strs(name.data(), value.data());
+      android_unregister_crash_detail(h);
+    }
+
+    android_register_crash_detail_strs("FINAL_NAME", "FINAL_VALUE");
+    android_register_crash_detail_strs("FINAL_NAME2", "FINAL_VALUE2");
+    abort();
+  });
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  FinishIntercept(&intercept_result);
+
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_NOT_MATCH(result, "CRASH_DETAIL_NAME");
+  ASSERT_NOT_MATCH(result, "CRASH_DETAIL_VALUE");
+  ASSERT_MATCH(result, R"(FINAL_NAME: 'FINAL_VALUE')");
+  ASSERT_MATCH(result, R"(FINAL_NAME2: 'FINAL_VALUE2')");
+}
+
+TEST_F(CrasherTest, crash_detail_single_changes) {
+  int intercept_result;
+  unique_fd output_fd;
+  StartProcess([]() {
+    android_register_crash_detail_strs("CRASH_DETAIL_NAME", g_crash_detail_value_changes);
+    g_crash_detail_value_changes[0] = 'C';
+    abort();
+  });
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  FinishIntercept(&intercept_result);
+
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME: 'Crash_detail_value')");
+}
+
+TEST_F(CrasherTest, crash_detail_multiple) {
+  int intercept_result;
+  unique_fd output_fd;
+  StartProcess([]() {
+    android_register_crash_detail_strs("CRASH_DETAIL_NAME", g_crash_detail_value);
+    android_register_crash_detail_strs("CRASH_DETAIL_NAME2", g_crash_detail_value2);
+    abort();
+  });
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  FinishIntercept(&intercept_result);
+
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME: 'crash_detail_value')");
+  ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME2: 'crash_detail_value2')");
+}
+
+TEST_F(CrasherTest, crash_detail_remove) {
+  int intercept_result;
+  unique_fd output_fd;
+  StartProcess([]() {
+    auto* detail1 = android_register_crash_detail_strs("CRASH_DETAIL_NAME", g_crash_detail_value);
+    android_unregister_crash_detail(detail1);
+    android_register_crash_detail_strs("CRASH_DETAIL_NAME2", g_crash_detail_value2);
+    abort();
+  });
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  FinishIntercept(&intercept_result);
+
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_NOT_MATCH(result, R"(CRASH_DETAIL_NAME: 'crash_detail_value')");
+  ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME2: 'crash_detail_value2')");
+}
+
 TEST_F(CrasherTest, abort_message_newline_trimmed) {
   int intercept_result;
   unique_fd output_fd;
diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index ea07ce235086..141723b037ad 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -397,6 +397,7 @@ static int debuggerd_dispatch_pseudothread(void* arg) {
     ASSERT_SAME_OFFSET(scudo_ring_buffer_size, scudo_ring_buffer_size);
     ASSERT_SAME_OFFSET(scudo_stack_depot_size, scudo_stack_depot_size);
     ASSERT_SAME_OFFSET(recoverable_gwp_asan_crash, recoverable_gwp_asan_crash);
+    ASSERT_SAME_OFFSET(crash_detail_page, crash_detail_page);
 #undef ASSERT_SAME_OFFSET
 
     iovs[3] = {.iov_base = &thread_info->process_info,
diff --git a/debuggerd/include/debuggerd/handler.h b/debuggerd/include/debuggerd/handler.h
index de12fc622be6..c18cf6e7a89c 100644
--- a/debuggerd/include/debuggerd/handler.h
+++ b/debuggerd/include/debuggerd/handler.h
@@ -33,6 +33,8 @@ struct AllocatorState;
 struct AllocationMetadata;
 };  // namespace gwp_asan
 
+struct crash_detail_page_t;
+
 // When updating this data structure, CrashInfoDataDynamic and the code in
 // ReadCrashInfo() must also be updated.
 struct __attribute__((packed)) debugger_process_info {
@@ -46,6 +48,7 @@ struct __attribute__((packed)) debugger_process_info {
   size_t scudo_ring_buffer_size;
   size_t scudo_stack_depot_size;
   bool recoverable_gwp_asan_crash;
+  struct crash_detail_page_t* crash_detail_page;
 };
 
 // GWP-ASan calbacks to support the recoverable mode. Separate from the
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/types.h b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
index 075b12cb0889..4d69658e2cbd 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/types.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
@@ -56,4 +56,5 @@ struct ProcessInfo {
   bool has_fault_address = false;
   uintptr_t untagged_fault_address = 0;
   uintptr_t maybe_tagged_fault_address = 0;
+  uintptr_t crash_detail_page = 0;
 };
diff --git a/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
index ac92ac064343..a4c08a4503bb 100644
--- a/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
+++ b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
@@ -118,3 +118,19 @@ TEST_F(TombstoneProtoToTextTest, pac_enabled_keys) {
                "LOG pac_enabled_keys: 0000000000001009 \\(PR_PAC_APIAKEY, PR_PAC_APDBKEY, unknown "
                "0x1000\\)\\n");
 }
+
+TEST_F(TombstoneProtoToTextTest, crash_detail_string) {
+  auto* crash_detail = tombstone_->add_crash_details();
+  crash_detail->set_name("CRASH_DETAIL_NAME");
+  crash_detail->set_data("crash_detail_value");
+  ProtoToString();
+  EXPECT_MATCH(text_, "(CRASH_DETAIL_NAME: 'crash_detail_value')");
+}
+
+TEST_F(TombstoneProtoToTextTest, crash_detail_bytes) {
+  auto* crash_detail = tombstone_->add_crash_details();
+  crash_detail->set_name("CRASH_DETAIL_NAME");
+  crash_detail->set_data("helloworld\1\255\3");
+  ProtoToString();
+  EXPECT_MATCH(text_, R"(CRASH_DETAIL_NAME: 'helloworld\\1\\255\\3')");
+}
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index 744bfabf5afb..d014fa38b1e7 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -48,8 +48,10 @@
 #include <android-base/unique_fd.h>
 
 #include <android/log.h>
+#include <android/set_abort_message.h>
 #include <bionic/macros.h>
 #include <bionic/reserved_signals.h>
+#include <bionic/set_abort_message_internal.h>
 #include <log/log.h>
 #include <log/log_read.h>
 #include <log/logprint.h>
@@ -251,6 +253,46 @@ static void dump_probable_cause(Tombstone* tombstone, unwindstack::AndroidUnwind
   }
 }
 
+static void dump_crash_details(Tombstone* tombstone,
+                               std::shared_ptr<unwindstack::Memory>& process_memory,
+                               const ProcessInfo& process_info) {
+  uintptr_t address = process_info.crash_detail_page;
+  while (address) {
+    struct crash_detail_page_t page;
+    if (!process_memory->ReadFully(address, &page, sizeof(page))) {
+      async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG, "failed to read crash detail page: %m");
+      break;
+    }
+    if (page.used > kNumCrashDetails) {
+      async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG, "crash detail: page corrupted");
+      break;
+    }
+    for (size_t i = 0; i < page.used; ++i) {
+      const crash_detail_t& crash_detail = page.crash_details[i];
+      if (!crash_detail.data) {
+        continue;
+      }
+      std::string name(crash_detail.name_size, '\0');
+      if (!process_memory->ReadFully(reinterpret_cast<uintptr_t>(crash_detail.name), name.data(),
+                                     crash_detail.name_size)) {
+        async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG, "crash detail: failed to read name: %m");
+        continue;
+      }
+      std::string data(crash_detail.data_size, '\0');
+      if (!process_memory->ReadFully(reinterpret_cast<uintptr_t>(crash_detail.data), data.data(),
+                                     crash_detail.data_size)) {
+        async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG,
+                              "crash detail: failed to read data for %s: %m", name.c_str());
+        continue;
+      }
+      auto* proto_detail = tombstone->add_crash_details();
+      proto_detail->set_name(name);
+      proto_detail->set_data(data);
+    }
+    address = reinterpret_cast<uintptr_t>(page.prev);
+  }
+}
+
 static void dump_abort_message(Tombstone* tombstone,
                                std::shared_ptr<unwindstack::Memory>& process_memory,
                                const ProcessInfo& process_info) {
@@ -698,7 +740,7 @@ void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder*
   *result.mutable_signal_info() = sig;
 
   dump_abort_message(&result, unwinder->GetProcessMemory(), process_info);
-
+  dump_crash_details(&result, unwinder->GetProcessMemory(), process_info);
   // Dump the main thread, but save the memory around the registers.
   dump_thread(&result, unwinder, main_thread, /* memory_dump */ true);
 
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index ad9132087dd8..cefa2d62e64a 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -18,7 +18,9 @@
 
 #include <inttypes.h>
 
+#include <charconv>
 #include <functional>
+#include <limits>
 #include <set>
 #include <string>
 #include <unordered_set>
@@ -425,6 +427,27 @@ static void print_memory_maps(CallbackType callback, const Tombstone& tombstone)
   }
 }
 
+static std::string oct_encode(const std::string& data) {
+  std::string oct_encoded;
+  oct_encoded.reserve(data.size());
+
+  // N.B. the unsigned here is very important, otherwise e.g. \255 would render as
+  // \-123 (and overflow our buffer).
+  for (unsigned char c : data) {
+    if (isprint(c)) {
+      oct_encoded += c;
+    } else {
+      std::string oct_digits("\\\0\0\0", 4);
+      // char is encodable in 3 oct digits
+      static_assert(std::numeric_limits<unsigned char>::max() <= 8 * 8 * 8);
+      auto [ptr, ec] = std::to_chars(oct_digits.data() + 1, oct_digits.data() + 4, c, 8);
+      oct_digits.resize(ptr - oct_digits.data());
+      oct_encoded += oct_digits;
+    }
+  }
+  return oct_encoded;
+}
+
 static void print_main_thread(CallbackType callback, const Tombstone& tombstone,
                               const Thread& thread) {
   print_thread_header(callback, tombstone, thread, true);
@@ -468,6 +491,12 @@ static void print_main_thread(CallbackType callback, const Tombstone& tombstone,
     CBL("Abort message: '%s'", tombstone.abort_message().c_str());
   }
 
+  for (const auto& crash_detail : tombstone.crash_details()) {
+    std::string oct_encoded_name = oct_encode(crash_detail.name());
+    std::string oct_encoded_data = oct_encode(crash_detail.data());
+    CBL("Extra crash detail: %s: '%s'", oct_encoded_name.c_str(), oct_encoded_data.c_str());
+  }
+
   print_thread_registers(callback, tombstone, thread, true);
   if (is_async_mte_crash) {
     CBL("Note: This crash is a delayed async MTE crash. Memory corruption has occurred");
diff --git a/debuggerd/proto/tombstone.proto b/debuggerd/proto/tombstone.proto
index 49865a2bb75f..214cbfb46bee 100644
--- a/debuggerd/proto/tombstone.proto
+++ b/debuggerd/proto/tombstone.proto
@@ -15,6 +15,11 @@ option java_outer_classname = "TombstoneProtos";
 // NOTE TO OEMS:
 // If you add custom fields to this proto, do not use numbers in the reserved range.
 
+message CrashDetail {
+  bytes name = 1;
+  bytes data = 2;
+}
+
 message Tombstone {
   Architecture arch = 1;
   string build_fingerprint = 2;
@@ -33,6 +38,7 @@ message Tombstone {
 
   Signal signal_info = 10;
   string abort_message = 14;
+  repeated CrashDetail crash_details = 21;
   repeated Cause causes = 15;
 
   map<uint32, Thread> threads = 16;
@@ -40,7 +46,7 @@ message Tombstone {
   repeated LogBuffer log_buffers = 18;
   repeated FD open_fds = 19;
 
-  reserved 21 to 999;
+  reserved 22 to 999;
 }
 
 enum Architecture {
diff --git a/debuggerd/protocol.h b/debuggerd/protocol.h
index 793428ae8273..d3fc15edcaa4 100644
--- a/debuggerd/protocol.h
+++ b/debuggerd/protocol.h
@@ -101,6 +101,7 @@ struct __attribute__((__packed__)) CrashInfoDataDynamic : public CrashInfoDataSt
   size_t scudo_ring_buffer_size;
   size_t scudo_stack_depot_size;
   bool recoverable_gwp_asan_crash;
+  uintptr_t crash_detail_page;
 };
 
 struct __attribute__((__packed__)) CrashInfo {

From 593b19b5ce1831ef1dbec6a556e62e903394a1db Mon Sep 17 00:00:00 2001
From: Serdar Kocdemir <kocdemir@google.com>
Date: Wed, 14 Feb 2024 13:53:13 +0000
Subject: [PATCH 0720/1487] Check if ALWAYS_INLINE is already defined

Fixes build errors when using callstack library in gfxstream
project, where the definition is already made.

Test: build
Change-Id: I80d4038160725b5dc70f9af93d338aca66a2f0d5
---
 libutils/include/utils/CallStack.h | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/libutils/include/utils/CallStack.h b/libutils/include/utils/CallStack.h
index fe4d4f564960..54d559b80b6b 100644
--- a/libutils/include/utils/CallStack.h
+++ b/libutils/include/utils/CallStack.h
@@ -37,7 +37,9 @@
 # endif // !WEAKS_AVAILABLE
 #endif // CALLSTACK_WEAK predefined
 
-#define ALWAYS_INLINE __attribute__((always_inline))
+#ifndef CALLSTACK_ALWAYS_INLINE
+#define CALLSTACK_ALWAYS_INLINE __attribute__((always_inline))
+#endif  // CALLSTACK_ALWAYS_INLINE predefined
 
 namespace android {
 
@@ -102,7 +104,7 @@ class CallStack {
 
     // Return current call stack if possible, nullptr otherwise.
 #ifdef WEAKS_AVAILABLE
-    static CallStackUPtr ALWAYS_INLINE getCurrent(int32_t ignoreDepth = 1) {
+    static CallStackUPtr CALLSTACK_ALWAYS_INLINE getCurrent(int32_t ignoreDepth = 1) {
         if (reinterpret_cast<uintptr_t>(getCurrentInternal) == 0) {
             ALOGW("CallStack::getCurrentInternal not linked, returning null");
             return CallStackUPtr(nullptr);
@@ -111,14 +113,15 @@ class CallStack {
         }
     }
 #else // !WEAKS_AVAILABLE
-    static CallStackUPtr ALWAYS_INLINE getCurrent(int32_t = 1) {
+    static CallStackUPtr CALLSTACK_ALWAYS_INLINE getCurrent(int32_t = 1) {
         return CallStackUPtr(nullptr);
     }
 #endif // !WEAKS_AVAILABLE
 
 #ifdef WEAKS_AVAILABLE
-    static void ALWAYS_INLINE logStack(const char* logtag, CallStack* stack = getCurrent().get(),
-                                       android_LogPriority priority = ANDROID_LOG_DEBUG) {
+    static void CALLSTACK_ALWAYS_INLINE logStack(const char* logtag,
+                                                 CallStack* stack = getCurrent().get(),
+                                                 android_LogPriority priority = ANDROID_LOG_DEBUG) {
         if (reinterpret_cast<uintptr_t>(logStackInternal) != 0 && stack != nullptr) {
             logStackInternal(logtag, stack, priority);
         } else {
@@ -127,15 +130,16 @@ class CallStack {
     }
 
 #else
-    static void ALWAYS_INLINE logStack(const char* logtag, CallStack* = getCurrent().get(),
-                                       android_LogPriority = ANDROID_LOG_DEBUG) {
+    static void CALLSTACK_ALWAYS_INLINE logStack(const char* logtag,
+                                                 CallStack* = getCurrent().get(),
+                                                 android_LogPriority = ANDROID_LOG_DEBUG) {
         ALOG(LOG_WARN, logtag, "CallStack::logStackInternal not linked");
     }
 #endif // !WEAKS_AVAILABLE
 
 #ifdef WEAKS_AVAILABLE
-    static String8 ALWAYS_INLINE stackToString(const char* prefix = nullptr,
-                                               const CallStack* stack = getCurrent().get()) {
+    static String8 CALLSTACK_ALWAYS_INLINE
+    stackToString(const char* prefix = nullptr, const CallStack* stack = getCurrent().get()) {
         if (reinterpret_cast<uintptr_t>(stackToStringInternal) != 0 && stack != nullptr) {
             return stackToStringInternal(prefix, stack);
         } else {
@@ -143,8 +147,8 @@ class CallStack {
         }
     }
 #else // !WEAKS_AVAILABLE
-    static String8 ALWAYS_INLINE stackToString(const char* prefix = nullptr,
-                                               const CallStack* = getCurrent().get()) {
+    static String8 CALLSTACK_ALWAYS_INLINE stackToString(const char* prefix = nullptr,
+                                                         const CallStack* = getCurrent().get()) {
         return String8::format("%s<CallStack package not linked>", (prefix ? prefix : ""));
     }
 #endif // !WEAKS_AVAILABLE
@@ -165,4 +169,6 @@ class CallStack {
 
 }  // namespace android
 
+#undef CALLSTACK_ALWAYS_INLINE
+
 #endif // ANDROID_CALLSTACK_H

From aced3aa5c64322c19817e61706f3f9dc6b5aee25 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Tue, 13 Feb 2024 13:44:50 -0800
Subject: [PATCH 0721/1487] Add tests for
 android_replace_crash_detail_[name|data]

Bug: 155462331
Change-Id: I1ca4ae6d700dfbaf0bc4e511da0788edd969fca3
---
 debuggerd/debuggerd_test.cpp | 46 ++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index a308ffbc91ec..194676aa4c13 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -967,6 +967,52 @@ TEST_F(CrasherTest, crash_detail_single) {
   ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME: 'crash_detail_value')");
 }
 
+TEST_F(CrasherTest, crash_detail_replace_data) {
+  int intercept_result;
+  unique_fd output_fd;
+  StartProcess([]() {
+    auto *cd = android_register_crash_detail_strs("CRASH_DETAIL_NAME", "original_data");
+    android_replace_crash_detail_data(cd, "new_data", strlen("new_data"));
+    abort();
+  });
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  FinishIntercept(&intercept_result);
+
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_MATCH(result, R"(CRASH_DETAIL_NAME: 'new_data')");
+  // Ensure the old one no longer shows up, i.e. that we actually replaced
+  // it, not added a new one.
+  ASSERT_NOT_MATCH(result, R"(CRASH_DETAIL_NAME: 'original_data')");
+}
+
+TEST_F(CrasherTest, crash_detail_replace_name) {
+  int intercept_result;
+  unique_fd output_fd;
+  StartProcess([]() {
+    auto *cd = android_register_crash_detail_strs("old_name", g_crash_detail_value);
+    android_replace_crash_detail_name(cd, "new_name", strlen("new_name"));
+    abort();
+  });
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  FinishIntercept(&intercept_result);
+
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_MATCH(result, R"(new_name: 'crash_detail_value')");
+  // Ensure the old one no longer shows up, i.e. that we actually replaced
+  // it, not added a new one.
+  ASSERT_NOT_MATCH(result, R"(old_name: 'crash_detail_value')");
+}
+
 TEST_F(CrasherTest, crash_detail_single_byte_name) {
   int intercept_result;
   unique_fd output_fd;

From 920d95b1c8abf8b35c9f063d6d72e71cd42150e2 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Wed, 14 Feb 2024 12:57:09 -0800
Subject: [PATCH 0722/1487] use new location of crash_detail API

Bug: 155462331
Change-Id: I862f91368d421363adbbf002fe3c7d446c437b03
---
 debuggerd/debuggerd_test.cpp               | 13 +++++++------
 debuggerd/libdebuggerd/tombstone_proto.cpp |  2 +-
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 194676aa4c13..f396b1de89ed 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -37,6 +37,7 @@
 #include <string>
 #include <thread>
 
+#include <android/crash_detail.h>
 #include <android/dlext.h>
 #include <android/fdsan.h>
 #include <android/set_abort_message.h>
@@ -945,7 +946,7 @@ static char g_crash_detail_value2[] = "crash_detail_value2";
 
 inline crash_detail_t* _Nullable android_register_crash_detail_strs(const char* _Nonnull name,
                                                                     const char* _Nonnull data) {
-  return android_register_crash_detail(name, strlen(name), data, strlen(data));
+  return android_crash_detail_register(name, strlen(name), data, strlen(data));
 }
 
 TEST_F(CrasherTest, crash_detail_single) {
@@ -972,7 +973,7 @@ TEST_F(CrasherTest, crash_detail_replace_data) {
   unique_fd output_fd;
   StartProcess([]() {
     auto *cd = android_register_crash_detail_strs("CRASH_DETAIL_NAME", "original_data");
-    android_replace_crash_detail_data(cd, "new_data", strlen("new_data"));
+    android_crash_detail_replace_data(cd, "new_data", strlen("new_data"));
     abort();
   });
   StartIntercept(&output_fd);
@@ -995,7 +996,7 @@ TEST_F(CrasherTest, crash_detail_replace_name) {
   unique_fd output_fd;
   StartProcess([]() {
     auto *cd = android_register_crash_detail_strs("old_name", g_crash_detail_value);
-    android_replace_crash_detail_name(cd, "new_name", strlen("new_name"));
+    android_crash_detail_replace_name(cd, "new_name", strlen("new_name"));
     abort();
   });
   StartIntercept(&output_fd);
@@ -1037,7 +1038,7 @@ TEST_F(CrasherTest, crash_detail_single_bytes) {
   int intercept_result;
   unique_fd output_fd;
   StartProcess([]() {
-    android_register_crash_detail("CRASH_DETAIL_NAME", strlen("CRASH_DETAIL_NAME"), "\1",
+    android_crash_detail_register("CRASH_DETAIL_NAME", strlen("CRASH_DETAIL_NAME"), "\1",
                                   sizeof("\1"));
     abort();
   });
@@ -1081,7 +1082,7 @@ TEST_F(CrasherTest, crash_detail_many) {
       std::string name = "CRASH_DETAIL_NAME" + std::to_string(i);
       std::string value = "CRASH_DETAIL_VALUE" + std::to_string(i);
       auto* h = android_register_crash_detail_strs(name.data(), value.data());
-      android_unregister_crash_detail(h);
+      android_crash_detail_unregister(h);
     }
 
     android_register_crash_detail_strs("FINAL_NAME", "FINAL_VALUE");
@@ -1149,7 +1150,7 @@ TEST_F(CrasherTest, crash_detail_remove) {
   unique_fd output_fd;
   StartProcess([]() {
     auto* detail1 = android_register_crash_detail_strs("CRASH_DETAIL_NAME", g_crash_detail_value);
-    android_unregister_crash_detail(detail1);
+    android_crash_detail_unregister(detail1);
     android_register_crash_detail_strs("CRASH_DETAIL_NAME2", g_crash_detail_value2);
     abort();
   });
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index d014fa38b1e7..4fe4403d9e5d 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -51,7 +51,7 @@
 #include <android/set_abort_message.h>
 #include <bionic/macros.h>
 #include <bionic/reserved_signals.h>
-#include <bionic/set_abort_message_internal.h>
+#include <bionic/crash_detail_internal.h>
 #include <log/log.h>
 #include <log/log_read.h>
 #include <log/logprint.h>

From ab8cc2f7f3f536072b6c1502f8f69db04102f800 Mon Sep 17 00:00:00 2001
From: Peter Collingbourne <pcc@google.com>
Date: Tue, 13 Feb 2024 15:40:37 -0800
Subject: [PATCH 0723/1487] fastboot: Increase maximum usbfs bulk size for
 writes to 256KiB

With a device capable of saturating the bus at SuperSpeed+,
the next bottleneck is the fixed (size-independent) overhead of
the usbfs ioctl() system calls, which includes entering/exiting
the kernel, allocating/deallocating a contiguous buffer for DMA,
configuring/deconfiguring the IOMMU and issuing the DMA to the HC. In
order to saturate the bus from the host software perspective, we must
reach the schedule() call in reap_as() before the next interrupt from
the HC indicating the completion of the URB.

In my experimental setup, with an SS+ capable host and device
and 16 KiB URBs, we reach the schedule() call in 25us, but the
URB is serviced in an estimated 16us, so we lose roughly a third
of the bandwidth. Increasing the URB size to 64KiB there are
65us between interrupts and 55us until schedule(). This means
we usually reach schedule() in time but not always, so we lose a
bit of bandwidth. Increasing it again to 128KiB and we have 128us
between interrupts and 65us until schedule(), so we're now comfortably
saturating the bus. In order to account for differences between hosts,
this CL uses a doubled maximum of 256KiB.

With larger allocation sizes we now risk contiguous allocation
failures, so I implemented a fallback where we try smaller sizes if
a larger one fails.

With this CL download speeds on my hosts are now around 980 MB/s over
SS+ and 440 MB/s over SS.

Bug: 325128548
Change-Id: Ie5ad480c73f2f71a50ce7f75ffb4aaa93ded2f0b
---
 fastboot/usb_linux.cpp | 58 +++++++++++++++++++++++++++---------------
 1 file changed, 38 insertions(+), 20 deletions(-)

diff --git a/fastboot/usb_linux.cpp b/fastboot/usb_linux.cpp
index b7fd5ed33479..2d23e076912c 100644
--- a/fastboot/usb_linux.cpp
+++ b/fastboot/usb_linux.cpp
@@ -83,7 +83,18 @@ using namespace std::chrono_literals;
 // be reliable.
 // 256KiB seems to work, but 1MiB bulk transfers lock up my z620 with a 3.13
 // kernel.
-#define MAX_USBFS_BULK_SIZE (16 * 1024)
+// 128KiB was experimentally found to be enough to saturate the bus at
+// SuperSpeed+, so we first try double that for writes. If the operation fails
+// due to a lack of contiguous regions (or an ancient kernel), try smaller sizes
+// until we find one that works (see LinuxUsbTransport::Write). Reads are less
+// performance critical so for now just use a known good size.
+#define MAX_USBFS_BULK_WRITE_SIZE (256 * 1024)
+#define MAX_USBFS_BULK_READ_SIZE (16 * 1024)
+
+// This size should pretty much always work (it's compatible with pre-3.3
+// kernels and it's what we used to use historically), so if it doesn't work
+// something has gone badly wrong.
+#define MIN_USBFS_BULK_WRITE_SIZE (16 * 1024)
 
 struct usb_handle
 {
@@ -108,6 +119,7 @@ class LinuxUsbTransport : public UsbTransport {
   private:
     std::unique_ptr<usb_handle> handle_;
     const uint32_t ms_timeout_;
+    size_t max_usbfs_bulk_write_size_ = MAX_USBFS_BULK_WRITE_SIZE;
 
     DISALLOW_COPY_AND_ASSIGN(LinuxUsbTransport);
 };
@@ -412,26 +424,32 @@ ssize_t LinuxUsbTransport::Write(const void* _data, size_t len)
     }
 
     auto submit_urb = [&](size_t i) {
-        int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
-
-        urb[i].type = USBDEVFS_URB_TYPE_BULK;
-        urb[i].endpoint = handle_->ep_out;
-        urb[i].buffer_length = xfer;
-        urb[i].buffer = data;
-        urb[i].usercontext = (void *)i;
-
-        int n = ioctl(handle_->desc, USBDEVFS_SUBMITURB, &urb[i]);
-        if (n != 0) {
-            DBG("ioctl(USBDEVFS_SUBMITURB) failed\n");
-            return false;
-        }
+        while (true) {
+            int xfer = (len > max_usbfs_bulk_write_size_) ? max_usbfs_bulk_write_size_ : len;
+
+            urb[i].type = USBDEVFS_URB_TYPE_BULK;
+            urb[i].endpoint = handle_->ep_out;
+            urb[i].buffer_length = xfer;
+            urb[i].buffer = data;
+            urb[i].usercontext = (void *)i;
+
+            int n = ioctl(handle_->desc, USBDEVFS_SUBMITURB, &urb[i]);
+            if (n != 0) {
+                if (errno == ENOMEM && max_usbfs_bulk_write_size_ > MIN_USBFS_BULK_WRITE_SIZE) {
+                    max_usbfs_bulk_write_size_ /= 2;
+                    continue;
+                }
+                DBG("ioctl(USBDEVFS_SUBMITURB) failed\n");
+                return false;
+            }
 
-        pending[i] = true;
-        count += xfer;
-        len -= xfer;
-        data += xfer;
+            pending[i] = true;
+            count += xfer;
+            len -= xfer;
+            data += xfer;
 
-        return true;
+            return true;
+        }
     };
 
     auto reap_urb = [&](size_t i) {
@@ -497,7 +515,7 @@ ssize_t LinuxUsbTransport::Read(void* _data, size_t len)
     }
 
     while (len > 0) {
-        int xfer = (len > MAX_USBFS_BULK_SIZE) ? MAX_USBFS_BULK_SIZE : len;
+        int xfer = (len > MAX_USBFS_BULK_READ_SIZE) ? MAX_USBFS_BULK_READ_SIZE : len;
 
         bulk.ep = handle_->ep_in;
         bulk.len = xfer;

From f08aeded81b56d0fdd23b1c102ed5a1871f3bc06 Mon Sep 17 00:00:00 2001
From: AleX Pelosi <apelosi@google.com>
Date: Thu, 15 Feb 2024 18:42:11 +0000
Subject: [PATCH 0724/1487] Revert "healthd: BatteryMonitor: doLogValues:
 reduce log level to debug"

This reverts commit aeccbb8f3a4f2a7256a6308b0216dcb88b4bff8c.

Reason for revert: needed for debug and investigations of battery and charging issues. The tooling depends on these lines (and have been for years). You should have these lines only on SOC changes and in the presence of a serious problem. Please do not remove logging without consulting with the BMS SW team first.

Change-Id: Ife0079a7e0c1499b22e843429832b019139c0d89
---
 healthd/BatteryMonitor.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index fbdf5fed1ef1..b8bb58682a2e 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -530,7 +530,7 @@ static void doLogValues(const HealthInfo& props, const struct healthd_config& he
              props.chargerAcOnline ? "a" : "", props.chargerUsbOnline ? "u" : "",
              props.chargerWirelessOnline ? "w" : "", props.chargerDockOnline ? "d" : "");
 
-    KLOG_DEBUG(LOG_TAG, "%s\n", dmesgline);
+    KLOG_WARNING(LOG_TAG, "%s\n", dmesgline);
 }
 
 void BatteryMonitor::logValues(const HealthInfo_2_1& health_info,

From 39e8be43ebbbd0f25df59688db2290650bbfb27c Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Fri, 16 Feb 2024 17:23:34 +0900
Subject: [PATCH 0725/1487] Add check_builtins to libinit_host

This requires a bit of refactoring: moving things around.

libinit_host is used by host_apex_verifier which needs check_builtins as
well.

Bug: 325565247
Test: atest host-apex-verifier
Test: m out/target/product/vsoc_x86_64/host_init_verifier_output.txt
Change-Id: Ifed54dd2149afbab2bf63f7e42c410c2354895fc
---
 init/Android.bp             |  6 ++----
 init/check_builtins.cpp     | 25 ++++++++++++++++++++++++-
 init/check_builtins.h       |  7 +++++++
 init/host_init_verifier.cpp | 22 +++-------------------
 init/host_init_verifier.h   | 27 ---------------------------
 5 files changed, 36 insertions(+), 51 deletions(-)
 delete mode 100644 init/host_init_verifier.h

diff --git a/init/Android.bp b/init/Android.bp
index 181de2e52c9d..2d16f60c91a0 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -88,7 +88,6 @@ init_device_sources = [
 init_host_sources = [
     "check_builtins.cpp",
     "host_import_parser.cpp",
-    "host_init_verifier.cpp",
 ]
 
 soong_config_module_type {
@@ -321,7 +320,6 @@ cc_binary {
     visibility: ["//packages/modules/Virtualization/microdroid"],
 }
 
-
 soong_config_module_type {
     name: "init_first_stage_cc_defaults",
     module_type: "cc_defaults",
@@ -614,13 +612,13 @@ cc_defaults {
 cc_binary {
     name: "host_init_verifier",
     defaults: ["init_host_defaults"],
-    srcs: init_common_sources + init_host_sources,
+    srcs: ["host_init_verifier.cpp"] + init_common_sources + init_host_sources,
 }
 
 cc_library_host_static {
     name: "libinit_host",
     defaults: ["init_host_defaults"],
-    srcs: init_common_sources,
+    srcs: init_common_sources + init_host_sources,
     export_include_dirs: ["."],
     proto: {
         export_proto_headers: true,
diff --git a/init/check_builtins.cpp b/init/check_builtins.cpp
index 461ed2255e5b..97254580cd27 100644
--- a/init/check_builtins.cpp
+++ b/init/check_builtins.cpp
@@ -28,9 +28,9 @@
 #include <android-base/parsedouble.h>
 #include <android-base/parseint.h>
 #include <android-base/strings.h>
+#include <property_info_parser/property_info_parser.h>
 
 #include "builtin_arguments.h"
-#include "host_init_verifier.h"
 #include "interface_utils.h"
 #include "property_type.h"
 #include "rlimit_parser.h"
@@ -39,6 +39,9 @@
 
 using android::base::ParseInt;
 using android::base::StartsWith;
+using android::properties::BuildTrie;
+using android::properties::PropertyInfoArea;
+using android::properties::PropertyInfoEntry;
 
 #define ReturnIfAnyArgsEmpty()     \
     for (const auto& arg : args) { \
@@ -50,6 +53,26 @@ using android::base::StartsWith;
 namespace android {
 namespace init {
 
+const PropertyInfoArea* property_info_area;
+
+Result<void> InitializeHostPropertyInfoArea(const std::vector<PropertyInfoEntry>& property_infos) {
+    static std::string serialized_contexts;
+    std::string trie_error;
+    if (!BuildTrie(property_infos, "u:object_r:default_prop:s0", "string", &serialized_contexts,
+                   &trie_error)) {
+        return Error() << "Unable to serialize property contexts: " << trie_error;
+    }
+
+    property_info_area = reinterpret_cast<const PropertyInfoArea*>(serialized_contexts.c_str());
+    return {};
+}
+
+static Result<void> check_stub(const BuiltinArguments& args) {
+    return {};
+}
+
+#include "generated_stub_builtin_function_map.h"
+
 Result<void> check_chown(const BuiltinArguments& args) {
     if (!args[1].empty()) {
         auto uid = DecodeUid(args[1]);
diff --git a/init/check_builtins.h b/init/check_builtins.h
index dc1b752e7435..9b00a7c39ed0 100644
--- a/init/check_builtins.h
+++ b/init/check_builtins.h
@@ -19,6 +19,10 @@
 #include "builtin_arguments.h"
 #include "result.h"
 
+#include <vector>
+
+#include <property_info_serializer/property_info_serializer.h>
+
 namespace android {
 namespace init {
 
@@ -43,5 +47,8 @@ Result<void> check_umount_all(const BuiltinArguments& args);
 Result<void> check_wait(const BuiltinArguments& args);
 Result<void> check_wait_for_prop(const BuiltinArguments& args);
 
+Result<void> InitializeHostPropertyInfoArea(
+        const std::vector<properties::PropertyInfoEntry>& property_infos);
+
 }  // namespace init
 }  // namespace android
diff --git a/init/host_init_verifier.cpp b/init/host_init_verifier.cpp
index 662185c44745..f746ab954e3a 100644
--- a/init/host_init_verifier.cpp
+++ b/init/host_init_verifier.cpp
@@ -14,8 +14,6 @@
 // limitations under the License.
 //
 
-#include "host_init_verifier.h"
-
 #include <errno.h>
 #include <getopt.h>
 #include <pwd.h>
@@ -36,6 +34,7 @@
 #include <android-base/strings.h>
 #include <generated_android_ids.h>
 #include <hidl/metadata.h>
+#include <property_info_parser/property_info_parser.h>
 #include <property_info_serializer/property_info_serializer.h>
 
 #include "action.h"
@@ -57,9 +56,7 @@ using android::base::EndsWith;
 using android::base::ParseInt;
 using android::base::ReadFileToString;
 using android::base::Split;
-using android::properties::BuildTrie;
 using android::properties::ParsePropertyInfoFile;
-using android::properties::PropertyInfoArea;
 using android::properties::PropertyInfoEntry;
 
 static std::vector<std::string> passwd_files;
@@ -148,12 +145,6 @@ passwd* getpwnam(const char* login) {  // NOLINT: implementing bad function.
 namespace android {
 namespace init {
 
-static Result<void> check_stub(const BuiltinArguments& args) {
-    return {};
-}
-
-#include "generated_stub_builtin_function_map.h"
-
 void PrintUsage() {
     fprintf(stdout, R"(usage: host_init_verifier [options]
 
@@ -196,8 +187,6 @@ Result<InterfaceInheritanceHierarchyMap> ReadInterfaceInheritanceHierarchy() {
     return result;
 }
 
-const PropertyInfoArea* property_info_area;
-
 void HandlePropertyContexts(const std::string& filename,
                             std::vector<PropertyInfoEntry>* property_infos) {
     auto file_contents = std::string();
@@ -288,16 +277,11 @@ int main(int argc, char** argv) {
     }
     SetKnownInterfaces(*interface_inheritance_hierarchy_map);
 
-    std::string serialized_contexts;
-    std::string trie_error;
-    if (!BuildTrie(property_infos, "u:object_r:default_prop:s0", "string", &serialized_contexts,
-                   &trie_error)) {
-        LOG(ERROR) << "Unable to serialize property contexts: " << trie_error;
+    if (auto result = InitializeHostPropertyInfoArea(property_infos); !result.ok()) {
+        LOG(ERROR) << result.error();
         return EXIT_FAILURE;
     }
 
-    property_info_area = reinterpret_cast<const PropertyInfoArea*>(serialized_contexts.c_str());
-
     if (!partition_map.empty()) {
         std::vector<std::string> vendor_prefixes;
         for (const auto& partition : {"vendor", "odm"}) {
diff --git a/init/host_init_verifier.h b/init/host_init_verifier.h
deleted file mode 100644
index 5d24f2a9b201..000000000000
--- a/init/host_init_verifier.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <property_info_parser/property_info_parser.h>
-
-namespace android {
-namespace init {
-
-extern const android::properties::PropertyInfoArea* property_info_area;
-
-}  // namespace init
-}  // namespace android

From 8ce23dc44ea588329961bd1cd760f8d5380f2988 Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Thu, 15 Feb 2024 15:46:59 +0900
Subject: [PATCH 0726/1487] Rename functions in libvendorsupport

Follow platform naming conventions for an LLNDK library.

Bug: 325093550
Test: atest libvendorsupport-tests
Change-Id: Id93f7e66a47ae9250191f9827a76ce819e8f6f88
---
 init/property_service.cpp                     |  3 ++-
 .../include/vendorsupport/api_level.h         | 22 +++++++----------
 libvendorsupport/libvendorsupport.map.txt     |  4 ++--
 libvendorsupport/tests/version_props_test.cpp | 18 +++++++-------
 libvendorsupport/version_props.c              | 24 +++++++++----------
 5 files changed, 34 insertions(+), 37 deletions(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index 30ad800364f0..bc4ef424ba85 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1104,7 +1104,8 @@ static void property_initialize_ro_vendor_api_level() {
         product_first_api_level = GetIntProperty("ro.build.version.sdk", __ANDROID_API_FUTURE__);
     }
 
-    vendor_api_level = std::min(vendor_api_level_of(product_first_api_level), vendor_api_level);
+    vendor_api_level =
+            std::min(AVendorSupport_getVendorApiLevelOf(product_first_api_level), vendor_api_level);
 
     if (vendor_api_level < 0) {
         LOG(ERROR) << "Unexpected vendor api level for " << VENDOR_API_LEVEL_PROP << ". Check "
diff --git a/libvendorsupport/include/vendorsupport/api_level.h b/libvendorsupport/include/vendorsupport/api_level.h
index ba1a6b8874f8..d365075e0431 100644
--- a/libvendorsupport/include/vendorsupport/api_level.h
+++ b/libvendorsupport/include/vendorsupport/api_level.h
@@ -14,38 +14,34 @@
 
 #pragma once
 
-#include <android/api-level.h>
+#include <sys/cdefs.h>
+
+__BEGIN_DECLS
 
 #define __ANDROID_VENDOR_API_MAX__ 1000000
 #define __INVALID_API_LEVEL -1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /**
  * @brief Find corresponding vendor API level from an SDK API version.
  *
  * @details
  * SDK API versions and vendor API levels are not compatible and not
- * convertible. However, this function can be used to compare the two versions
+ * exchangeable. However, this function can be used to compare the two versions
  * to know which one is newer than the other.
  *
- * @param sdk_api_level The SDK version int. This must be less than 10000.
+ * @param sdkApiLevel The SDK version int. This must be less than 10000.
  * @return The corresponding vendor API level of the SDK version. -1 if the SDK
  * version is invalid or 10000.
  */
-int vendor_api_level_of(int sdk_api_level);
+int AVendorSupport_getVendorApiLevelOf(int sdkApiLevel);
 
 /**
  * @brief Find corresponding SDK API version from a vendor API level.
  *
- * @param vendor_api_level The vendor API level int.
+ * @param vendorApiLevel The vendor API level int.
  * @return The corresponding SDK API version of the vendor API level. -1 if the
  * vendor API level is invalid.
  */
-int sdk_api_level_of(int vendor_api_level);
+int AVendorSupport_getSdkApiLevelOf(int vendorApiLevel);
 
-#ifdef __cplusplus
-}
-#endif
+__END_DECLS
diff --git a/libvendorsupport/libvendorsupport.map.txt b/libvendorsupport/libvendorsupport.map.txt
index 9a23b940f9b6..d99c834e9a2b 100644
--- a/libvendorsupport/libvendorsupport.map.txt
+++ b/libvendorsupport/libvendorsupport.map.txt
@@ -1,7 +1,7 @@
 LIBVENDORSUPPORT {
   global:
-    vendor_api_level_of; # llndk systemapi
-    sdk_api_level_of; # llndk systemapi
+    AVendorSupport_getVendorApiLevelOf; # llndk systemapi
+    AVendorSupport_getSdkApiLevelOf; # llndk systemapi
   local:
     *;
 };
diff --git a/libvendorsupport/tests/version_props_test.cpp b/libvendorsupport/tests/version_props_test.cpp
index 538a2e26bd5c..ad54c8895f73 100644
--- a/libvendorsupport/tests/version_props_test.cpp
+++ b/libvendorsupport/tests/version_props_test.cpp
@@ -21,17 +21,17 @@ using namespace std;
 
 namespace {
 
-TEST(vendorsupport, get_corresponding_vendor_api_level) {
-    ASSERT_EQ(__ANDROID_API_U__, vendor_api_level_of(__ANDROID_API_U__));
-    ASSERT_EQ(202404, vendor_api_level_of(__ANDROID_API_V__));
-    ASSERT_EQ(__INVALID_API_LEVEL, vendor_api_level_of(__ANDROID_API_FUTURE__));
+TEST(VendorSupport, GetCorrespondingVendorApiLevel) {
+    ASSERT_EQ(__ANDROID_API_U__, AVendorSupport_getVendorApiLevelOf(__ANDROID_API_U__));
+    ASSERT_EQ(202404, AVendorSupport_getVendorApiLevelOf(__ANDROID_API_V__));
+    ASSERT_EQ(__INVALID_API_LEVEL, AVendorSupport_getVendorApiLevelOf(__ANDROID_API_FUTURE__));
 }
 
-TEST(vendorsupport, get_corresponding_sdk_api_level) {
-    ASSERT_EQ(__ANDROID_API_U__, sdk_api_level_of(__ANDROID_API_U__));
-    ASSERT_EQ(__ANDROID_API_V__, sdk_api_level_of(202404));
-    ASSERT_EQ(__INVALID_API_LEVEL, sdk_api_level_of(__ANDROID_VENDOR_API_MAX__));
-    ASSERT_EQ(__INVALID_API_LEVEL, sdk_api_level_of(35));
+TEST(VendorSupport, GetCorrespondingSdkApiLevel) {
+    ASSERT_EQ(__ANDROID_API_U__, AVendorSupport_getSdkApiLevelOf(__ANDROID_API_U__));
+    ASSERT_EQ(__ANDROID_API_V__, AVendorSupport_getSdkApiLevelOf(202404));
+    ASSERT_EQ(__INVALID_API_LEVEL, AVendorSupport_getSdkApiLevelOf(__ANDROID_VENDOR_API_MAX__));
+    ASSERT_EQ(__INVALID_API_LEVEL, AVendorSupport_getSdkApiLevelOf(35));
 }
 
 }  // namespace
\ No newline at end of file
diff --git a/libvendorsupport/version_props.c b/libvendorsupport/version_props.c
index 4d0e45ecfd06..835828c0ac82 100644
--- a/libvendorsupport/version_props.c
+++ b/libvendorsupport/version_props.c
@@ -16,26 +16,26 @@
 
 #include <log/log.h>
 
-int vendor_api_level_of(int sdk_api_level) {
-    if (sdk_api_level < __ANDROID_API_V__) {
-        return sdk_api_level;
+int AVendorSupport_getVendorApiLevelOf(int sdkApiLevel) {
+    if (sdkApiLevel < __ANDROID_API_V__) {
+        return sdkApiLevel;
     }
     // In Android V, vendor API level started with version 202404.
     // The calculation assumes that the SDK api level bumps once a year.
-    if (sdk_api_level < __ANDROID_API_FUTURE__) {
-        return 202404 + ((sdk_api_level - __ANDROID_API_V__) * 100);
+    if (sdkApiLevel < __ANDROID_API_FUTURE__) {
+        return 202404 + ((sdkApiLevel - __ANDROID_API_V__) * 100);
     }
-    ALOGE("The SDK version must be less than 10000: %d", sdk_api_level);
+    ALOGE("The SDK version must be less than 10000: %d", sdkApiLevel);
     return __INVALID_API_LEVEL;
 }
 
-int sdk_api_level_of(int vendor_api_level) {
-    if (vendor_api_level < __ANDROID_API_V__) {
-        return vendor_api_level;
+int AVendorSupport_getSdkApiLevelOf(int vendorApiLevel) {
+    if (vendorApiLevel < __ANDROID_API_V__) {
+        return vendorApiLevel;
     }
-    if (vendor_api_level >= 202404 && vendor_api_level < __ANDROID_VENDOR_API_MAX__) {
-        return (vendor_api_level - 202404) / 100 + __ANDROID_API_V__;
+    if (vendorApiLevel >= 202404 && vendorApiLevel < __ANDROID_VENDOR_API_MAX__) {
+        return (vendorApiLevel - 202404) / 100 + __ANDROID_API_V__;
     }
-    ALOGE("Unexpected vendor api level: %d", vendor_api_level);
+    ALOGE("Unexpected vendor api level: %d", vendorApiLevel);
     return __INVALID_API_LEVEL;
 }

From 0335dac70df8d0d793faada8dad8d42ea40fb0be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pierre-Cl=C3=A9ment=20Tosi?= <ptosi@google.com>
Date: Mon, 12 Feb 2024 15:02:02 +0000
Subject: [PATCH 0727/1487] first_stage_console: Fix execv() child error path

If the /first_stage.sh is not present on the system, the child process
which attempted to execv() ends up returning from the function along
with its parent, which can be seen in early logs e.g.

[   10.747576][   T51] init: Attempting to run /first_stage.sh...
[   10.757371][   T52] init: unable to execv /first_stage.sh, returned -1 errno 2
[   10.767527][   T52] init: unable to execv, returned -1 errno 2
                      [...]
[   10.789189][   T51] init: unable to execv, returned -1 errno 2

where both T51 and T52 end up executing the "rest" of StartConsole().

Instead, terminate the child if its execv() failed.

Test: run first_stage_init
Change-Id: I20bc0aeae627761a60fb2b55bae39871ad506f69
---
 init/first_stage_console.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/init/first_stage_console.cpp b/init/first_stage_console.cpp
index c6c3008ce470..00767648361a 100644
--- a/init/first_stage_console.cpp
+++ b/init/first_stage_console.cpp
@@ -78,6 +78,7 @@ static void RunScript() {
     const char* args[] = {path, "/first_stage.sh", nullptr};
     int rv = execv(path, const_cast<char**>(args));
     LOG(ERROR) << "unable to execv /first_stage.sh, returned " << rv << " errno " << errno;
+    _exit(127);
 }
 
 namespace android {

From b1d92c65082181d28f7396727f393855438b9ad5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pierre-Cl=C3=A9ment=20Tosi?= <ptosi@google.com>
Date: Mon, 12 Feb 2024 15:39:52 +0000
Subject: [PATCH 0728/1487] first_stage_console: Fix waitpid() as SA_NOCLDWAIT

From wait(2):

  POSIX.1-2001 specifies that if [...] the SA_NOCLDWAIT flag is set for
  SIGCHLD, then children that terminate do not become zombies and a call
  to [...] waitpid() will block until all children have terminated, and
  then fail with errno set to ECHILD.

As we call sigaction(SIGCHLD, { SIG_DFL, SA_NOCLDWAIT }), running

  pid_t w = waitpid(pid, &status, 0);
  LOG(INFO) << "..." << status << " " << w << " " << errno;

shows that the calls consistently return (status=0, w=-1, errno=ECHILD).

Therefore, clarify the parent code by prefering wait(2) over waitpid(2),
as SA_NOCLDWAIT makes the kernel ignore the passed PID, and stop logging
the irrelevant status, to avoid confusion when the logs say the exit
status was 0 but the child actually returned an error.

Test: run first_stage_console
Change-Id: I54df888e38b947e206e374ad28ebb044c70c6640
---
 init/first_stage_console.cpp | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/init/first_stage_console.cpp b/init/first_stage_console.cpp
index 00767648361a..cb8caabd2888 100644
--- a/init/first_stage_console.cpp
+++ b/init/first_stage_console.cpp
@@ -69,9 +69,8 @@ static void RunScript() {
     LOG(INFO) << "Attempting to run /first_stage.sh...";
     pid_t pid = fork();
     if (pid != 0) {
-        int status;
-        waitpid(pid, &status, 0);
-        LOG(INFO) << "/first_stage.sh exited with status " << status;
+        wait(NULL);
+        LOG(INFO) << "/first_stage.sh exited";
         return;
     }
     const char* path = "/system/bin/sh";
@@ -94,9 +93,8 @@ void StartConsole(const std::string& cmdline) {
     sigaction(SIGCHLD, &chld_act, nullptr);
     pid_t pid = fork();
     if (pid != 0) {
-        int status;
-        waitpid(pid, &status, 0);
-        LOG(ERROR) << "console shell exited with status " << status;
+        wait(NULL);
+        LOG(ERROR) << "console shell exited";
         return;
     }
 

From b6b2afb6b3679275fc2876f0832996be35b75139 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pierre-Cl=C3=A9ment=20Tosi?= <ptosi@google.com>
Date: Mon, 12 Feb 2024 17:13:54 +0000
Subject: [PATCH 0729/1487] first_stage_console: Refactor RunScript()

Introduce SpawnImage() as a reusable single-argument wrapper around
posix_spawn(), to avoid having to manually manage the child process.

Note that Bionic currently doesn't return the errno from the child's
exec() call to the caller in the parent process, which may temporarily
hide errors such as ENOENT in first_stage_console until Bionic improves.

Also, this introduces a subtle change in behavior as the first_stage.sh
script is now passed directly to the loader, which will only properly
invoke the Shell if the file contains the right shebang.

Inline the call to RunScript() to hopefully make it simpler for readers
to track the lifetime of the various processes on different code paths.

Test: run first_stage_init
Change-Id: Ifaab2be032b2080a039209295d0b5a3759764ea7
---
 init/first_stage_console.cpp | 41 ++++++++++++++++++++----------------
 1 file changed, 23 insertions(+), 18 deletions(-)

diff --git a/init/first_stage_console.cpp b/init/first_stage_console.cpp
index cb8caabd2888..f6f93299b9f2 100644
--- a/init/first_stage_console.cpp
+++ b/init/first_stage_console.cpp
@@ -16,6 +16,7 @@
 
 #include "first_stage_console.h"
 
+#include <spawn.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <sys/sysmacros.h>
@@ -65,19 +66,20 @@ static bool SetupConsole() {
     return true;
 }
 
-static void RunScript() {
-    LOG(INFO) << "Attempting to run /first_stage.sh...";
-    pid_t pid = fork();
-    if (pid != 0) {
-        wait(NULL);
-        LOG(INFO) << "/first_stage.sh exited";
-        return;
-    }
-    const char* path = "/system/bin/sh";
-    const char* args[] = {path, "/first_stage.sh", nullptr};
-    int rv = execv(path, const_cast<char**>(args));
-    LOG(ERROR) << "unable to execv /first_stage.sh, returned " << rv << " errno " << errno;
-    _exit(127);
+static pid_t SpawnImage(const char* file) {
+    const char* argv[] = {file, NULL};
+    const char* envp[] = {NULL};
+
+    char* const* argvp = const_cast<char* const*>(argv);
+    char* const* envpp = const_cast<char* const*>(envp);
+
+    pid_t pid;
+    errno = posix_spawn(&pid, argv[0], NULL, NULL, argvp, envpp);
+    if (!errno) return pid;
+
+    PLOG(ERROR) << "Failed to spawn '" << file << "'";
+
+    return (pid_t)0;
 }
 
 namespace android {
@@ -99,12 +101,15 @@ void StartConsole(const std::string& cmdline) {
     }
 
     if (console) console = SetupConsole();
-    RunScript();
+
+    LOG(INFO) << "Attempting to run /first_stage.sh...";
+    if (SpawnImage("/first_stage.sh")) {
+        wait(NULL);
+        LOG(INFO) << "/first_stage.sh exited";
+    }
+
     if (console) {
-        const char* path = "/system/bin/sh";
-        const char* args[] = {path, nullptr};
-        int rv = execv(path, const_cast<char**>(args));
-        LOG(ERROR) << "unable to execv, returned " << rv << " errno " << errno;
+        if (SpawnImage("/system/bin/sh")) wait(NULL);
     }
     _exit(127);
 }

From f28e2841410f29051987b069ad51306ee738ea91 Mon Sep 17 00:00:00 2001
From: David Drysdale <drysdale@google.com>
Date: Wed, 21 Feb 2024 13:50:12 +0000
Subject: [PATCH 0730/1487] Drop TODO for flag enablement

Flag control for enabling Secretkeeper is done in the device-specific
makefiles, triggering whether they set SECRETKEEPER_ENABLED:=true

Test: none, comment change
Change-Id: I399d1840519864687aca6c53697317d449eed325
---
 trusty/trusty-base.mk | 1 -
 1 file changed, 1 deletion(-)

diff --git a/trusty/trusty-base.mk b/trusty/trusty-base.mk
index 5aa4392c5528..b21eca6df824 100644
--- a/trusty/trusty-base.mk
+++ b/trusty/trusty-base.mk
@@ -35,7 +35,6 @@ else
     LOCAL_KEYMINT_PRODUCT_PACKAGE := android.hardware.security.keymint-service.trusty
 endif
 
-# TODO(b/306364873): move this to be flag-controlled?
 ifeq ($(SECRETKEEPER_ENABLED),true)
     LOCAL_SECRETKEEPER_PRODUCT_PACKAGE := android.hardware.security.secretkeeper.trusty
 else

From dccf1b6e39d60675bc3a4518b50692a72d0abebe Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 8 Feb 2024 12:35:33 -0800
Subject: [PATCH 0731/1487] libsnapshot: update opcountcheck

Since variable block compresses blocks and there is no longer a 1:1
mapping between ops to blocks, we need to update this check in
EmitBlocks to the actual number of compressed blocks written.

Since single threaded + multi threaded + no compression invoke different
code paths. Ensure that that blocks written are still equivalent to
blocks.size(). Adding two test cases to cover these situations.

Test: th
Change-Id: If81eccf74333292a114268862dde0fe49681ef35
---
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 34 +++++++++++++++++++
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp |  6 ++--
 2 files changed, 37 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 3c5b394be1e1..2021348411ff 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -109,6 +109,40 @@ TEST_F(CowTestV3, MaxOp) {
     ASSERT_EQ(reader.header_v3().op_count, 20);
 }
 
+TEST_F(CowTestV3, MaxOpSingleThreadCompression) {
+    CowOptions options;
+    options.op_count_max = 20;
+    options.num_compress_threads = 1;
+    options.compression_factor = 4096 * 8;
+    options.compression = "lz4";
+
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+    ASSERT_TRUE(writer->AddZeroBlocks(1, 20));
+    std::string data = "This is some data, believe it";
+    data.resize(options.block_size, '\0');
+
+    ASSERT_FALSE(writer->AddRawBlocks(5, data.data(), data.size()));
+
+    ASSERT_TRUE(writer->Finalize());
+}
+
+TEST_F(CowTestV3, MaxOpMultiThreadCompression) {
+    CowOptions options;
+    options.op_count_max = 20;
+    options.num_compress_threads = 2;
+    options.compression_factor = 4096 * 8;
+    options.compression = "lz4";
+
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+    ASSERT_TRUE(writer->AddZeroBlocks(1, 20));
+    std::string data = "This is some data, believe it";
+    data.resize(options.block_size, '\0');
+
+    ASSERT_FALSE(writer->AddRawBlocks(5, data.data(), data.size()));
+
+    ASSERT_TRUE(writer->Finalize());
+}
+
 TEST_F(CowTestV3, ZeroOp) {
     CowOptions options;
     options.op_count_max = 20;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 22e6f2cbcbe7..1e3fee74875d 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -356,6 +356,9 @@ bool CowWriterV3::ConstructCowOpCompressedBuffers(uint64_t new_block_start, cons
                    << ", actual number of blocks received from compressor " << blocks.size();
         return false;
     }
+    if (!CheckOpCount(blocks.size())) {
+        return false;
+    }
     size_t blocks_written = 0;
     for (size_t blk_index = 0; blk_index < blocks.size(); blk_index++) {
         CowOperation& op = cached_ops_.emplace_back();
@@ -395,9 +398,6 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
     }
     const auto bytes = reinterpret_cast<const uint8_t*>(data);
     const size_t num_blocks = (size / header_.block_size);
-    if (!CheckOpCount(num_blocks)) {
-        return false;
-    }
     for (size_t i = 0; i < num_blocks;) {
         const size_t blocks_to_write =
                 std::min<size_t>(batch_size_ - cached_data_.size(), num_blocks - i);

From 25de579429a574b199cefa3428617f6c0d76d673 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 21 Feb 2024 10:04:56 -0800
Subject: [PATCH 0732/1487] libsnapshot: log compression algorithm

Log the compression algorithm and compression factor used during OTA for easier debugging

Test: th
Change-Id: Ic50989d7e233983d6299163fc647eb739a0b7cb2
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp | 1 -
 fs_mgr/libsnapshot/snapshot.cpp                  | 2 ++
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 1e3fee74875d..30c5135a2c92 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -121,7 +121,6 @@ bool CowWriterV3::ParseOptions() {
         return false;
     }
 
-    LOG(INFO) << "Compression factor: " << header_.max_compression_size;
     num_compress_threads_ = std::max(int(options_.num_compress_threads), 1);
     auto parts = android::base::Split(options_.compression, ",");
     if (parts.size() > 2) {
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index ba5fb8824d53..cbe8285472c8 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -3242,6 +3242,8 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
             // Older OTAs don't set an explicit compression type, so default to gz.
             compression_algorithm = "gz";
         }
+        LOG(INFO) << "using compression algorithm: " << compression_algorithm
+                   << ", max compressible block size: " << compression_factor;
     }
 
     PartitionCowCreator cow_creator{

From 5dd72ac4960f089d9750d388c8bb0e9a7170426e Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Tue, 30 Jan 2024 10:17:37 +0900
Subject: [PATCH 0733/1487] Drop CtsInitTestCases from cts

The test is not eligible for CTS. Reasons:

1. The init behavior does not directly affect app compat. App interact
   with init only for the property service and that part is covered by
the Bionic test already.

2. This test doesn't run against the init binary installed on the
   device. libinit where most of the init functionalities are
implemented is statically linked to this test binary. In other words,
this test is closer to a unit test for init.

3. This test is not compatible with Trunk stable where test and DUT are
   built in different branches. The test depends on several (private)
libraries like libbase and libutils. Since the interfaces of the
libraries may have changed in the main branch, the test binary built
from the old test-dev branch may break.

This change does not remove the test. The test will still run as a unit
test during pre/post submit.

I didn't drop the `Cts` prefix from the name, because that requires
broader changes.

Bug: 320800872
Test: N/A
Change-Id: I1402c08b79b57ad6daa7948fe37f14fbbe36f1d6
(cherry picked from commit 75070b37e280dd76c0f00d5bf2a8eb96053b1483)
---
 init/Android.bp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/Android.bp b/init/Android.bp
index 7b529033a968..cf4ccc4beb1f 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -450,6 +450,7 @@ phony {
 // ------------------------------------------------------------------------------
 
 cc_test {
+    // Note: This is NOT a CTS test. See b/320800872
     name: "CtsInitTestCases",
     defaults: ["init_defaults"],
     require_root: true,
@@ -482,7 +483,6 @@ cc_test {
     ],
 
     test_suites: [
-        "cts",
         "device-tests",
     ],
 }

From f90de49e0eacd14db3915a3099f3baaffd9b4e58 Mon Sep 17 00:00:00 2001
From: Kalesh Singh <kaleshsingh@google.com>
Date: Wed, 14 Feb 2024 17:03:01 -0800
Subject: [PATCH 0734/1487] init: snapuserd: Fix ranges for mlock()

It cannot be assumed that file mappings in /proc/<pid>/maps will be
completely backed by the underlying file. [1]

Use MappedFileSize() to deduce the correct ranges for the mlock()
calls when locking system pages in the OTA path.

While at it also clean up the some unreachable code (mlockall()),
and improve error logging.

[1] SIGBUS at https://man7.org/linux/man-pages/man2/mmap.2.html#RETURN_VALUE

Test: Incremental OTA
Bug: 324952273
Change-Id: Ia2ab150e1b8de8c638f5b1acc1de83deb7ac5cff
Signed-off-by: Kalesh Singh <kaleshsingh@google.com>
---
 init/snapuserd_transition.cpp | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/init/snapuserd_transition.cpp b/init/snapuserd_transition.cpp
index 3a783434a5e3..dea7af97b9fd 100644
--- a/init/snapuserd_transition.cpp
+++ b/init/snapuserd_transition.cpp
@@ -195,22 +195,20 @@ static void LockAllSystemPages() {
             return;
         }
         auto start = reinterpret_cast<const void*>(map.start);
-        auto len = map.end - map.start;
+        uint64_t len = android::procinfo::MappedFileSize(map);
         if (!len) {
             return;
         }
+
         if (mlock(start, len) < 0) {
-            LOG(ERROR) << "mlock failed, " << start << " for " << len << " bytes.";
+            PLOG(ERROR) << "\"" << map.name << "\": mlock(" << start << ", " << len
+                        << ") failed: pgoff = " << map.pgoff;
             ok = false;
         }
     };
 
     if (!android::procinfo::ReadProcessMaps(getpid(), callback) || !ok) {
-        LOG(FATAL) << "Could not process /proc/" << getpid() << "/maps file for init, "
-                   << "falling back to mlockall().";
-        if (mlockall(MCL_CURRENT) < 0) {
-            LOG(FATAL) << "mlockall failed";
-        }
+        LOG(FATAL) << "Could not process /proc/" << getpid() << "/maps file for init";
     }
 }
 

From 071880f5cbc2a051f99cd61226f4b63ebcb6997d Mon Sep 17 00:00:00 2001
From: Andy Hung <hunga@google.com>
Date: Wed, 21 Feb 2024 17:56:48 -0800
Subject: [PATCH 0735/1487] RefBase: update sp and wp to allow constinit

A constexpr ctor is useful for static initialization.
We also modernize the unit test for static variable best practices.

Test: atest libutils_binder_test
Change-Id: If42c0939fb1a2dcb8eb101ed0e10051f67e2150d
---
 libutils/binder/RefBase_test.cpp              | 8 ++++----
 libutils/binder/include/utils/RefBase.h       | 2 +-
 libutils/binder/include/utils/StrongPointer.h | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/libutils/binder/RefBase_test.cpp b/libutils/binder/RefBase_test.cpp
index d6755980508e..65d40a2a1823 100644
--- a/libutils/binder/RefBase_test.cpp
+++ b/libutils/binder/RefBase_test.cpp
@@ -300,8 +300,8 @@ class Bar : public RefBase {
     std::atomic<int>* mDeleteCount;
 };
 
-static sp<Bar> buffer;
-static std::atomic<bool> bufferFull(false);
+[[clang::no_destroy]] static constinit sp<Bar> buffer;
+static constinit std::atomic<bool> bufferFull(false);
 
 // Wait until bufferFull has value val.
 static inline void waitFor(bool val) {
@@ -380,8 +380,8 @@ TEST(RefBase, RacingDestructors) {
     }  // Otherwise this is slow and probably pointless on a uniprocessor.
 }
 
-static wp<Bar> wpBuffer;
-static std::atomic<bool> wpBufferFull(false);
+[[clang::no_destroy]] static constinit wp<Bar> wpBuffer;
+static constinit std::atomic<bool> wpBufferFull(false);
 
 // Wait until wpBufferFull has value val.
 static inline void wpWaitFor(bool val) {
diff --git a/libutils/binder/include/utils/RefBase.h b/libutils/binder/include/utils/RefBase.h
index 5e3fa7d13c8a..f03e1be0a7da 100644
--- a/libutils/binder/include/utils/RefBase.h
+++ b/libutils/binder/include/utils/RefBase.h
@@ -404,7 +404,7 @@ class wp
 public:
     typedef typename RefBase::weakref_type weakref_type;
 
-    inline wp() : m_ptr(nullptr), m_refs(nullptr) { }
+    inline constexpr wp() : m_ptr(nullptr), m_refs(nullptr) { }
 
     // if nullptr, returns nullptr
     //
diff --git a/libutils/binder/include/utils/StrongPointer.h b/libutils/binder/include/utils/StrongPointer.h
index 43c00c95a4c2..fb9b8e899bb4 100644
--- a/libutils/binder/include/utils/StrongPointer.h
+++ b/libutils/binder/include/utils/StrongPointer.h
@@ -30,7 +30,7 @@ template<typename T> class wp;
 template<typename T>
 class sp {
 public:
-    inline sp() : m_ptr(nullptr) { }
+    inline constexpr sp() : m_ptr(nullptr) { }
 
     // The old way of using sp<> was like this. This is bad because it relies
     // on implicit conversion to sp<>, which we would like to remove (if an

From 43de4ef22da3f49a82bd10f1e1899da1d1e4dd8b Mon Sep 17 00:00:00 2001
From: Ed Tsai <ed.tsai@mediatek.com>
Date: Fri, 19 Jan 2024 08:13:12 +0800
Subject: [PATCH 0736/1487] Support for striped in libdm

Add dm stripe in dmctl framework to support stripe on two block devices.

Bug: 321628121
Change-Id: I2f326f19f7ccff1ee03598743022fb702b3e8d6a
Signed-off-by: Ed Tsai <ed.tsai@mediatek.com>
---
 fs_mgr/libdm/dm_target.cpp             |  4 ++++
 fs_mgr/libdm/dm_test.cpp               |  7 +++++++
 fs_mgr/libdm/include/libdm/dm_target.h | 18 ++++++++++++++++++
 fs_mgr/tools/dmctl.cpp                 | 15 +++++++++++++++
 4 files changed, 44 insertions(+)

diff --git a/fs_mgr/libdm/dm_target.cpp b/fs_mgr/libdm/dm_target.cpp
index 90d91a00c470..1f6bd1a21464 100644
--- a/fs_mgr/libdm/dm_target.cpp
+++ b/fs_mgr/libdm/dm_target.cpp
@@ -61,6 +61,10 @@ std::string DmTargetLinear::GetParameterString() const {
     return block_device_ + " " + std::to_string(physical_sector_);
 }
 
+std::string DmTargetStripe::GetParameterString() const {
+    return "2 " + std::to_string(chunksize) + " " + block_device0_ + " 0 " + block_device1_ + " 0";
+}
+
 DmTargetVerity::DmTargetVerity(uint64_t start, uint64_t length, uint32_t version,
                                const std::string& block_device, const std::string& hash_device,
                                uint32_t data_block_size, uint32_t hash_block_size,
diff --git a/fs_mgr/libdm/dm_test.cpp b/fs_mgr/libdm/dm_test.cpp
index a0129c234936..d043be63bd3b 100644
--- a/fs_mgr/libdm/dm_test.cpp
+++ b/fs_mgr/libdm/dm_test.cpp
@@ -181,6 +181,13 @@ TEST_F(DmTest, DmSuspendResume) {
     ASSERT_EQ(dm.GetState(dev.name()), DmDeviceState::ACTIVE);
 }
 
+TEST_F(DmTest, StripeArgs) {
+    DmTargetStripe target(0, 4096, 1024, "/dev/loop0", "/dev/loop1");
+    ASSERT_EQ(target.name(), "striped");
+    ASSERT_TRUE(target.Valid());
+    ASSERT_EQ(target.GetParameterString(), "2 1024 /dev/loop0 0 /dev/loop1 0");
+}
+
 TEST_F(DmTest, DmVerityArgsAvb2) {
     std::string device = "/dev/block/platform/soc/1da4000.ufshc/by-name/vendor_a";
     std::string algorithm = "sha1";
diff --git a/fs_mgr/libdm/include/libdm/dm_target.h b/fs_mgr/libdm/include/libdm/dm_target.h
index 09fe20012ece..97f3c134ef6d 100644
--- a/fs_mgr/libdm/include/libdm/dm_target.h
+++ b/fs_mgr/libdm/include/libdm/dm_target.h
@@ -116,6 +116,24 @@ class DmTargetLinear final : public DmTarget {
     uint64_t physical_sector_;
 };
 
+class DmTargetStripe final : public DmTarget {
+  public:
+    DmTargetStripe(uint64_t start, uint64_t length, uint64_t chunksize,
+                   const std::string& block_device0, const std::string& block_device1)
+        : DmTarget(start, length),
+          chunksize(chunksize),
+          block_device0_(block_device0),
+          block_device1_(block_device1) {}
+
+    std::string name() const override { return "striped"; }
+    std::string GetParameterString() const override;
+
+  private:
+    uint64_t chunksize;
+    std::string block_device0_;
+    std::string block_device1_;
+};
+
 class DmTargetVerity final : public DmTarget {
   public:
     DmTargetVerity(uint64_t start, uint64_t length, uint32_t version,
diff --git a/fs_mgr/tools/dmctl.cpp b/fs_mgr/tools/dmctl.cpp
index 7273087b3b11..9dc8c2426af6 100644
--- a/fs_mgr/tools/dmctl.cpp
+++ b/fs_mgr/tools/dmctl.cpp
@@ -115,6 +115,21 @@ class TargetParser final {
             std::string block_device = NextArg();
             return std::make_unique<DmTargetAndroidVerity>(start_sector, num_sectors, keyid,
                                                            block_device);
+        } else if (target_type == "striped") {
+            if (!HasArgs(3)) {
+                std::cerr << "Expected \"striped\" <block_device0> <block_device1> <chunksize>"
+                          << std::endl;
+                return nullptr;
+            }
+            std::string block_device0 = NextArg();
+            std::string block_device1 = NextArg();
+            uint64_t chunk_size;
+            if (!android::base::ParseUint(NextArg(), &chunk_size)) {
+                std::cerr << "Expected start sector, got: " << PreviousArg() << std::endl;
+                return nullptr;
+            }
+            return std::make_unique<DmTargetStripe>(start_sector, num_sectors, chunk_size,
+                                                    block_device0, block_device1);
         } else if (target_type == "bow") {
             if (!HasArgs(1)) {
                 std::cerr << "Expected \"bow\" <block_device>" << std::endl;

From 3e662d3c7f2bb6ead2862315a00f2a1c5b239dfa Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Thu, 22 Feb 2024 16:14:27 -0800
Subject: [PATCH 0737/1487] Fix up the debuggerd policy files.

A few files were changed without using the generate script. Modify
the original policy file and generate all of the policy files
properly.

Test: Verify the generated files are the same as before.
Change-Id: Ic6979c06c5d290b3047c8307e86ec1e78a242d44
---
 debuggerd/seccomp_policy/crash_dump.policy.def | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/debuggerd/seccomp_policy/crash_dump.policy.def b/debuggerd/seccomp_policy/crash_dump.policy.def
index 972a575457b5..dc751da6be5f 100644
--- a/debuggerd/seccomp_policy/crash_dump.policy.def
+++ b/debuggerd/seccomp_policy/crash_dump.policy.def
@@ -25,8 +25,8 @@ getdents64: 1
 faccessat: 1
 recvmsg: 1
 recvfrom: 1
-sysinfo: 1
 setsockopt: 1
+sysinfo: 1
 
 process_vm_readv: 1
 
@@ -53,20 +53,29 @@ prctl: arg0 == PR_GET_NO_NEW_PRIVS || arg0 == PR_SET_VMA
 
 #if 0
 libminijail on vendor partitions older than P does not have constants from <sys/mman.h>.
-Define the values of PROT_READ and PROT_WRITE ourselves to maintain backwards compatibility.
+Define values for PROT_READ, PROT_WRITE and PROT_MTE ourselves to maintain backwards compatibility.
 #else
 #define PROT_READ 0x1
 #define PROT_WRITE 0x2
+#define PROT_MTE 0x20
 #endif
 
 madvise: 1
+#if defined(__aarch64__)
+mprotect: arg2 in PROT_READ|PROT_WRITE|PROT_MTE
+#else
 mprotect: arg2 in PROT_READ|PROT_WRITE
+#endif
 munmap: 1
 
 #if defined(__LP64__)
 getuid: 1
 fstat: 1
+#if defined(__aarch64__)
+mmap: arg2 in PROT_READ|PROT_WRITE|PROT_MTE
+#else
 mmap: arg2 in PROT_READ|PROT_WRITE
+#endif
 #else
 getuid32: 1
 fstat64: 1

From fdc642643d25a4d67e5a04ae8ad4b0528a8c3835 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 23 Feb 2024 00:46:16 +0000
Subject: [PATCH 0738/1487] Reduce <CallStack.h> namespace pollution.

Use the CALLSTACK_ prefix uniformly, and undefine all the macros
at the end of the file.

Change-Id: Ie5f92bb8cb8b3753082b1c1145696a1e0409e04d
---
 libutils/include/utils/CallStack.h | 37 +++++++++++++++---------------
 1 file changed, 18 insertions(+), 19 deletions(-)

diff --git a/libutils/include/utils/CallStack.h b/libutils/include/utils/CallStack.h
index 54d559b80b6b..0239b682e94c 100644
--- a/libutils/include/utils/CallStack.h
+++ b/libutils/include/utils/CallStack.h
@@ -14,8 +14,7 @@
  * limitations under the License.
  */
 
-#ifndef ANDROID_CALLSTACK_H
-#define ANDROID_CALLSTACK_H
+#pragma once
 
 #include <memory>
 
@@ -27,14 +26,14 @@
 #include <sys/types.h>
 
 #if !defined(__APPLE__) && !defined(_WIN32)
-# define WEAKS_AVAILABLE 1
+# define CALLSTACK_WEAKS_AVAILABLE 1
 #endif
 #ifndef CALLSTACK_WEAK
-# ifdef WEAKS_AVAILABLE
+# ifdef CALLSTACK_WEAKS_AVAILABLE
 #   define CALLSTACK_WEAK __attribute__((weak))
-# else // !WEAKS_AVAILABLE
+# else // !CALLSTACK_WEAKS_AVAILABLE
 #   define CALLSTACK_WEAK
-# endif // !WEAKS_AVAILABLE
+# endif // !CALLSTACK_WEAKS_AVAILABLE
 #endif // CALLSTACK_WEAK predefined
 
 #ifndef CALLSTACK_ALWAYS_INLINE
@@ -91,7 +90,7 @@ class CallStack {
     //
     // DO NOT USE THESE. They will disappear.
     struct StackDeleter {
-#ifdef WEAKS_AVAILABLE
+#ifdef CALLSTACK_WEAKS_AVAILABLE
         void operator()(CallStack* stack) {
             deleteStack(stack);
         }
@@ -103,7 +102,7 @@ class CallStack {
     typedef std::unique_ptr<CallStack, StackDeleter> CallStackUPtr;
 
     // Return current call stack if possible, nullptr otherwise.
-#ifdef WEAKS_AVAILABLE
+#ifdef CALLSTACK_WEAKS_AVAILABLE
     static CallStackUPtr CALLSTACK_ALWAYS_INLINE getCurrent(int32_t ignoreDepth = 1) {
         if (reinterpret_cast<uintptr_t>(getCurrentInternal) == 0) {
             ALOGW("CallStack::getCurrentInternal not linked, returning null");
@@ -112,13 +111,13 @@ class CallStack {
             return getCurrentInternal(ignoreDepth);
         }
     }
-#else // !WEAKS_AVAILABLE
+#else // !CALLSTACK_WEAKS_AVAILABLE
     static CallStackUPtr CALLSTACK_ALWAYS_INLINE getCurrent(int32_t = 1) {
         return CallStackUPtr(nullptr);
     }
-#endif // !WEAKS_AVAILABLE
+#endif // !CALLSTACK_WEAKS_AVAILABLE
 
-#ifdef WEAKS_AVAILABLE
+#ifdef CALLSTACK_WEAKS_AVAILABLE
     static void CALLSTACK_ALWAYS_INLINE logStack(const char* logtag,
                                                  CallStack* stack = getCurrent().get(),
                                                  android_LogPriority priority = ANDROID_LOG_DEBUG) {
@@ -135,9 +134,9 @@ class CallStack {
                                                  android_LogPriority = ANDROID_LOG_DEBUG) {
         ALOG(LOG_WARN, logtag, "CallStack::logStackInternal not linked");
     }
-#endif // !WEAKS_AVAILABLE
+#endif // !CALLSTACK_WEAKS_AVAILABLE
 
-#ifdef WEAKS_AVAILABLE
+#ifdef CALLSTACK_WEAKS_AVAILABLE
     static String8 CALLSTACK_ALWAYS_INLINE
     stackToString(const char* prefix = nullptr, const CallStack* stack = getCurrent().get()) {
         if (reinterpret_cast<uintptr_t>(stackToStringInternal) != 0 && stack != nullptr) {
@@ -146,15 +145,15 @@ class CallStack {
             return String8::format("%s<CallStack package not linked>", (prefix ? prefix : ""));
         }
     }
-#else // !WEAKS_AVAILABLE
+#else // !CALLSTACK_WEAKS_AVAILABLE
     static String8 CALLSTACK_ALWAYS_INLINE stackToString(const char* prefix = nullptr,
                                                          const CallStack* = getCurrent().get()) {
         return String8::format("%s<CallStack package not linked>", (prefix ? prefix : ""));
     }
-#endif // !WEAKS_AVAILABLE
+#endif // !CALLSTACK_WEAKS_AVAILABLE
 
   private:
-#ifdef WEAKS_AVAILABLE
+#ifdef CALLSTACK_WEAKS_AVAILABLE
     static CallStackUPtr CALLSTACK_WEAK getCurrentInternal(int32_t ignoreDepth);
     static void CALLSTACK_WEAK logStackInternal(const char* logtag, const CallStack* stack,
                                                 android_LogPriority priority);
@@ -162,13 +161,13 @@ class CallStack {
     // The deleter is only invoked on non-null pointers. Hence it will never be
     // invoked if CallStack is not linked.
     static void CALLSTACK_WEAK deleteStack(CallStack* stack);
-#endif // WEAKS_AVAILABLE
+#endif // CALLSTACK_WEAKS_AVAILABLE
 
     Vector<String8> mFrameLines;
 };
 
 }  // namespace android
 
+#undef CALLSTACK_WEAKS_AVAILABLE
+#undef CALLSTACK_WEAK
 #undef CALLSTACK_ALWAYS_INLINE
-
-#endif // ANDROID_CALLSTACK_H

From bee3f962fce9415214c52f79d5b92efcd5f20f25 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 12 Feb 2024 16:19:37 -0800
Subject: [PATCH 0739/1487] libsnapshot: stride compression

Alternate dispatching blocks between threads rather than splitting the
data beforehand and then sending to threads in order to ensure that
single threading + multithreading chunks data at the same locations.
Without this change, the resulting op count + data section of the cow
will differ between --enable-threading && --disable-threading at
runtime, which is a result we don't want

Test: th
Change-Id: I3ed8add0552745a281fce2aa7f1d1d32eb547e63
---
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 52 +++++++++++--------
 1 file changed, 29 insertions(+), 23 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 30c5135a2c92..de2e528339a2 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -603,41 +603,47 @@ std::vector<CowWriterV3::CompressedBuffer> CowWriterV3::ProcessBlocksWithCompres
 std::vector<CowWriterV3::CompressedBuffer> CowWriterV3::ProcessBlocksWithThreadedCompression(
         const size_t num_blocks, const void* data, CowOperationType type) {
     const size_t num_threads = num_compress_threads_;
-    const size_t blocks_per_thread = DivRoundUp(num_blocks, num_threads);
     const uint8_t* iter = reinterpret_cast<const uint8_t*>(data);
 
+    // We will alternate which thread to send compress work to. E.g. alternate between T1 and T2
+    // until all blocks are processed
     std::vector<CompressedBuffer> compressed_vec;
-    // Submit the blocks per thread. The retrieval of
-    // compressed buffers has to be done in the same order.
-    // We should not poll for completed buffers in a different order as the
-    // buffers are tightly coupled with block ordering.
-    for (size_t i = 0; i < num_threads; i++) {
-        CompressWorker* worker = compress_threads_[i].get();
-        auto blocks_in_batch = std::min(num_blocks - i * blocks_per_thread, blocks_per_thread);
-        // Enqueue the blocks to be compressed for each thread.
-        while (blocks_in_batch) {
-            CompressedBuffer buffer;
-
-            const size_t compression_factor = GetCompressionFactor(blocks_in_batch, type);
-            size_t num_blocks = compression_factor / header_.block_size;
-
-            buffer.compression_factor = compression_factor;
-            worker->EnqueueCompressBlocks(iter, compression_factor, 1);
-            compressed_vec.push_back(std::move(buffer));
-            blocks_in_batch -= num_blocks;
-            iter += compression_factor;
-        }
+    int iteration = 0;
+    int blocks_to_compress = static_cast<int>(num_blocks);
+    while (blocks_to_compress) {
+        CompressedBuffer buffer;
+        CompressWorker* worker = compress_threads_[iteration % num_threads].get();
+
+        const size_t compression_factor = GetCompressionFactor(blocks_to_compress, type);
+        size_t num_blocks = compression_factor / header_.block_size;
+
+        worker->EnqueueCompressBlocks(iter, compression_factor, 1);
+        buffer.compression_factor = compression_factor;
+        compressed_vec.push_back(std::move(buffer));
+
+        iteration++;
+        iter += compression_factor;
+        blocks_to_compress -= num_blocks;
     }
 
-    // Fetch compressed buffers from the threads
     std::vector<std::vector<uint8_t>> compressed_buf;
+    std::vector<std::vector<std::vector<uint8_t>>> worker_buffers(num_threads);
     compressed_buf.clear();
     for (size_t i = 0; i < num_threads; i++) {
         CompressWorker* worker = compress_threads_[i].get();
-        if (!worker->GetCompressedBuffers(&compressed_buf)) {
+        if (!worker->GetCompressedBuffers(&worker_buffers[i])) {
             return {};
         }
     }
+    // compressed_vec | CB 1 | CB 2 | CB 3 | CB 4 | <-compressed buffers
+    //                   t1     t2     t1     t2    <- processed by these threads
+    // Ordering is important here. We need to retrieve the compressed data in the same order we
+    // processed it and assume that that we submit data beginning with the first thread and then
+    // round robin the consecutive data calls. We need to Fetch compressed buffers from the threads
+    // via the same ordering
+    for (size_t i = 0; i < compressed_vec.size(); i++) {
+        compressed_buf.emplace_back(worker_buffers[i % num_threads][i / num_threads]);
+    }
 
     if (compressed_vec.size() != compressed_buf.size()) {
         LOG(ERROR) << "Compressed buffer size: " << compressed_buf.size()

From 23e9289e69bd235627e822a210f821324666ad71 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Fri, 23 Feb 2024 22:16:01 +0000
Subject: [PATCH 0740/1487] minor doc improvement for tombstone fd code

Change-Id: I8037d9dd5a6c0e86e853d001ccedc472ce61d107
---
 debuggerd/tombstoned/tombstoned.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/debuggerd/tombstoned/tombstoned.cpp b/debuggerd/tombstoned/tombstoned.cpp
index cf7904f81980..e79035f516db 100644
--- a/debuggerd/tombstoned/tombstoned.cpp
+++ b/debuggerd/tombstoned/tombstoned.cpp
@@ -417,6 +417,7 @@ static bool rename_tombstone_fd(borrowed_fd fd, borrowed_fd dirfd, const std::st
     return false;
   }
 
+  // This fd is created inside of dirfd in CrashQueue::create_temporary_file.
   std::string fd_path = StringPrintf("/proc/self/fd/%d", fd.get());
   rc = linkat(AT_FDCWD, fd_path.c_str(), dirfd.get(), path.c_str(), AT_SYMLINK_FOLLOW);
   if (rc != 0) {

From 69d574c612f8e42c2028e21faa203ce3fc856d30 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Fri, 23 Feb 2024 14:20:47 -0800
Subject: [PATCH 0741/1487] libsnapshot: Fetch device size from header

Now that V3 is enabled, relax the header version check.
For V3, header op_count_max contains the information of the device size.

Bug: 299011882
Test: snapshotctl map-snapshots on Pixel with V3 format

Change-Id: Ia1cb20b24857136a742e20408ee95e56e98b256a
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshot.cpp | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index cbe8285472c8..e6c4de6234c1 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -508,8 +508,6 @@ bool SnapshotManager::MapDmUserCow(LockedFile* lock, const std::string& name,
         // When snapshots are on current slot, we determine the size
         // of block device based on the number of COW operations. We cannot
         // use base device as it will be from older image.
-        size_t num_ops = 0;
-        uint64_t dev_sz = 0;
         unique_fd fd(open(cow_file.c_str(), O_RDONLY | O_CLOEXEC));
         if (fd < 0) {
             PLOG(ERROR) << "Failed to open " << cow_file;
@@ -522,13 +520,18 @@ bool SnapshotManager::MapDmUserCow(LockedFile* lock, const std::string& name,
             return false;
         }
 
+        uint64_t dev_sz = 0;
         const auto& header = reader.GetHeader();
-        if (header.prefix.major_version > 2) {
-            LOG(ERROR) << "COW format not supported";
-            return false;
+        if (header.prefix.major_version == 2) {
+            const size_t num_ops = reader.get_num_total_data_ops();
+            dev_sz = (num_ops * header.block_size);
+        } else {
+            // create_snapshot will skip in-place copy ops. Hence, fetch this
+            // information directly from v3 header.
+            const auto& v3_header = reader.header_v3();
+            dev_sz = v3_header.op_count_max * v3_header.block_size;
         }
-        num_ops = reader.get_num_total_data_ops();
-        dev_sz = (num_ops * header.block_size);
+
         base_sectors = dev_sz >> 9;
     } else {
         // For userspace snapshots, the size of the base device is taken as the

From 877d1f6694bf2fbb78cc1722ed4555a8a555dd74 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Fri, 23 Feb 2024 12:54:27 -0800
Subject: [PATCH 0742/1487] Make tombstones 664.

They are still restricted by SELinux, and apps still cannot open them
because they don't have `open` SELinux permission.

Bug: 312740614
Change-Id: I83b7e6ed39f5af64f161af3b3e8e33af0d125b20
---
 debuggerd/tombstoned/tombstoned.cpp | 5 +++++
 rootdir/init.rc                     | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/debuggerd/tombstoned/tombstoned.cpp b/debuggerd/tombstoned/tombstoned.cpp
index cf7904f81980..5a36a74601a7 100644
--- a/debuggerd/tombstoned/tombstoned.cpp
+++ b/debuggerd/tombstoned/tombstoned.cpp
@@ -156,6 +156,11 @@ class CrashQueue {
 
       result.temporary_path = std::move(tmp_filename);
     }
+    // We need to fchmodat after creating to avoid getting the umask applied.
+    std::string fd_path = StringPrintf("/proc/self/fd/%d", result.fd.get());
+    if (fchmodat(dir_fd_, fd_path.c_str(), 0664, 0) != 0) {
+      PLOG(ERROR) << "Failed to make tombstone world-readable";
+    }
 
     return std::move(result);
   }
diff --git a/rootdir/init.rc b/rootdir/init.rc
index f3b2d0379245..3c367f969077 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -709,7 +709,7 @@ on post-fs-data
 
     # Start tombstoned early to be able to store tombstones.
     mkdir /data/anr 0775 system system encryption=Require
-    mkdir /data/tombstones 0771 system system encryption=Require
+    mkdir /data/tombstones 0775 system system encryption=Require
     mkdir /data/vendor/tombstones 0771 root root
     mkdir /data/vendor/tombstones/wifi 0771 wifi wifi
     start tombstoned

From 18407b787026fdf7a03c7b2d31fd6956ad5ab45c Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Sat, 24 Feb 2024 09:16:35 +0900
Subject: [PATCH 0743/1487] init: move generated_android_ids to
 host_init_verifier

It's used only by host_init_verifier. This is to remove the unnecessary
dependency from clients of init_host_defaults.

Bug: 326509378
Test: mmma system/core/init
Change-Id: I983fbfe616f0bcb87940c934e19f614d3bf51030
---
 init/Android.bp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/init/Android.bp b/init/Android.bp
index 2d16f60c91a0..c3abefe14955 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -597,7 +597,6 @@ cc_defaults {
     },
     generated_headers: [
         "generated_stub_builtin_function_map",
-        "generated_android_ids",
     ],
     target: {
         android: {
@@ -613,6 +612,9 @@ cc_binary {
     name: "host_init_verifier",
     defaults: ["init_host_defaults"],
     srcs: ["host_init_verifier.cpp"] + init_common_sources + init_host_sources,
+    generated_headers: [
+        "generated_android_ids",
+    ],
 }
 
 cc_library_host_static {

From 2bf7db3de0b4d3c1583cdef7387d5fbbd0d5aff9 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Mon, 26 Feb 2024 13:29:20 -0800
Subject: [PATCH 0744/1487] Format all of the blueprint files.

I'm tired of seeing the bpfmt warning, so fix this for all debuggerd
blueprint files.

Test: Compiles
Change-Id: I3b25365a7272aebe9cbac28455cf8b9b86b04c6e
---
 debuggerd/Android.bp                        | 14 ++++++-----
 debuggerd/crasher/Android.bp                |  2 +-
 debuggerd/proto/Android.bp                  |  1 -
 debuggerd/rust/tombstoned_client/Android.bp |  2 +-
 debuggerd/test_permissive_mte/Android.bp    | 26 +++++++++++++--------
 5 files changed, 26 insertions(+), 19 deletions(-)

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 7d20995d7950..439218d4d2fb 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -21,8 +21,11 @@ cc_defaults {
     local_include_dirs: ["include"],
     product_variables: {
         debuggable: {
-            cflags: ["-UANDROID_DEBUGGABLE", "-DANDROID_DEBUGGABLE=1"],
-        }
+            cflags: [
+                "-UANDROID_DEBUGGABLE",
+                "-DANDROID_DEBUGGABLE=1",
+            ],
+        },
     },
 }
 
@@ -256,7 +259,7 @@ cc_library_static {
     ],
 
     static_libs: [
-        "libdexfile_support",  // libunwindstack dependency
+        "libdexfile_support", // libunwindstack dependency
         "libunwindstack",
         "liblzma",
         "libbase",
@@ -299,7 +302,7 @@ cc_library_static {
         },
         android: {
             runtime_libs: [
-                "libdexfile",           // libdexfile_support dependency
+                "libdexfile", // libdexfile_support dependency
             ],
         },
     },
@@ -494,7 +497,7 @@ cc_defaults {
 
     header_libs: [
         "bionic_libc_platform_headers",
-        "libdebuggerd_common_headers"
+        "libdebuggerd_common_headers",
     ],
 
     static_libs: [
@@ -552,7 +555,6 @@ prebuilt_etc {
     },
 }
 
-
 // This installs the "other" architecture (so 32-bit on 64-bit device).
 prebuilt_etc {
     name: "crash_dump.policy_other",
diff --git a/debuggerd/crasher/Android.bp b/debuggerd/crasher/Android.bp
index fe1689c71763..4c6a400a1d7b 100644
--- a/debuggerd/crasher/Android.bp
+++ b/debuggerd/crasher/Android.bp
@@ -15,7 +15,7 @@ cc_defaults {
         "-fstack-protector-all",
         "-Wno-date-time",
     ],
-    tidy: false,  // crasher.cpp tests many memory access errors
+    tidy: false, // crasher.cpp tests many memory access errors
     srcs: ["crasher.cpp"],
     arch: {
         arm: {
diff --git a/debuggerd/proto/Android.bp b/debuggerd/proto/Android.bp
index 7be5d61a06ab..7b9e780ccf0c 100644
--- a/debuggerd/proto/Android.bp
+++ b/debuggerd/proto/Android.bp
@@ -52,4 +52,3 @@ java_library_static {
     sdk_version: "current",
     static_libs: ["libprotobuf-java-lite"],
 }
-
diff --git a/debuggerd/rust/tombstoned_client/Android.bp b/debuggerd/rust/tombstoned_client/Android.bp
index 2007f39343c6..bf19bb779eff 100644
--- a/debuggerd/rust/tombstoned_client/Android.bp
+++ b/debuggerd/rust/tombstoned_client/Android.bp
@@ -8,7 +8,7 @@ cc_library_static {
         "wrapper.cpp",
     ],
     generated_sources: [
-        "libtombstoned_client_rust_bridge_code"
+        "libtombstoned_client_rust_bridge_code",
     ],
     header_libs: [
         "libbase_headers",
diff --git a/debuggerd/test_permissive_mte/Android.bp b/debuggerd/test_permissive_mte/Android.bp
index d3f7520649a3..0ad32439d6ba 100644
--- a/debuggerd/test_permissive_mte/Android.bp
+++ b/debuggerd/test_permissive_mte/Android.bp
@@ -17,22 +17,28 @@ package {
 }
 
 cc_binary {
-  name: "mte_crash",
-  tidy: false,
-  srcs: ["mte_crash.cpp"],
-  sanitize: {
-    memtag_heap: true,
-    diag: {
-      memtag_heap: true,
+    name: "mte_crash",
+    tidy: false,
+    srcs: ["mte_crash.cpp"],
+    sanitize: {
+        memtag_heap: true,
+        diag: {
+            memtag_heap: true,
+        },
     },
-  },
 }
 
 java_test_host {
     name: "permissive_mte_test",
     libs: ["tradefed"],
-    static_libs: ["frameworks-base-hostutils", "cts-install-lib-host"],
-    srcs:  ["src/**/PermissiveMteTest.java", ":libtombstone_proto-src"],
+    static_libs: [
+        "frameworks-base-hostutils",
+        "cts-install-lib-host",
+    ],
+    srcs: [
+        "src/**/PermissiveMteTest.java",
+        ":libtombstone_proto-src",
+    ],
     data: [":mte_crash"],
     test_config: "AndroidTest.xml",
     test_suites: ["general-tests"],

From f3e89b8db4605039a936833461b27b312027f88c Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Fri, 23 Feb 2024 17:48:22 +0900
Subject: [PATCH 0745/1487] Define __INTRODUCED_IN_LLNDK

Symbols with __INTRODUCED_IN_LLNDK are available for LLNDK only if
the vendor api level set by the RELEASE_BOARD_API_LEVEL is equal to
or newer than the target vendor api level in __INTRODUCED_IN_LLNDK.

This works only for the vendor variants at the same time ignoring
__INTRODUCED_IN annotation for the vendor variants. On the other
hand, __INTRODUCED_IN_LLNDK will be ignored from non-vendor variants.

Bug: 302113279
Test: build
Change-Id: I5317a73dbc73095f8d5d95131ca4d9ed39df6be1
---
 libvendorsupport/Android.bp                   | 18 +++++++
 .../include_llndk/android/llndk-versioning.h  | 48 +++++++++++++++++++
 2 files changed, 66 insertions(+)
 create mode 100644 libvendorsupport/include_llndk/android/llndk-versioning.h

diff --git a/libvendorsupport/Android.bp b/libvendorsupport/Android.bp
index b4457b1815aa..74e3f0044672 100644
--- a/libvendorsupport/Android.bp
+++ b/libvendorsupport/Android.bp
@@ -34,3 +34,21 @@ cc_library {
         "liblog",
     ],
 }
+
+cc_library_headers {
+    name: "libvendorsupport_llndk_headers",
+    host_supported: true,
+    vendor_available: true,
+    recovery_available: true,
+    ramdisk_available: true,
+    vendor_ramdisk_available: true,
+    native_bridge_supported: true,
+
+    export_include_dirs: ["include_llndk"],
+    llndk: {
+        llndk_headers: true,
+    },
+
+    system_shared_libs: [],
+    stl: "none",
+}
diff --git a/libvendorsupport/include_llndk/android/llndk-versioning.h b/libvendorsupport/include_llndk/android/llndk-versioning.h
new file mode 100644
index 000000000000..7c408c940b85
--- /dev/null
+++ b/libvendorsupport/include_llndk/android/llndk-versioning.h
@@ -0,0 +1,48 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <sys/cdefs.h>
+
+__BEGIN_DECLS
+
+#if defined(__ANDROID_VENDOR__)
+
+// LLNDK (https://source.android.com/docs/core/architecture/vndk/build-system#ll-ndk) is similar to
+// NDK, but uses its own versioning of YYYYMM format for vendor builds. The LLNDK symbols are
+// enabled when the vendor api level is equal to or newer than the ro.board.api_level.
+#define __INTRODUCED_IN_LLNDK(vendor_api_level)                                             \
+    _Pragma("clang diagnostic push") _Pragma("clang diagnostic ignored \"-Wgcc-compat\"")   \
+            __attribute__((enable_if(                                                       \
+                    __ANDROID_VENDOR_API__ >= vendor_api_level,                             \
+                    "available in vendor API level " #vendor_api_level " that "             \
+                    "is newer than the current vendor API level. Guard the API "            \
+                    "call with '#if (__ANDROID_VENDOR_API__ >= " #vendor_api_level ")'."))) \
+            _Pragma("clang diagnostic pop")
+
+// For the vendor libraries, __INTRODUCED_IN must be ignored because they are only for NDKs but not
+// for LLNDKs.
+#undef __INTRODUCED_IN
+#define __INTRODUCED_IN(x)
+
+#else  // __ANDROID_VENDOR__
+
+// For non-vendor libraries, __INTRODUCED_IN_LLNDK must be ignored because it must not change
+// symbols of NDK or the system side of the treble boundary.
+#define __INTRODUCED_IN_LLNDK(vendor_api_level)
+
+#endif  // __ANDROID_VENDOR__
+
+__END_DECLS

From 2768cf6ea248443729b1e9023044f66ca2b47168 Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Tue, 27 Feb 2024 18:43:34 +0900
Subject: [PATCH 0746/1487] Make libvendorsupport_llndk_headers available to
 APEXes

libvendorsupport_llndk_headers provide libvendorsupport_llndk_headers
macro that can be used in any libraries including APEXes.

Bug: 302113279
Test: TH
Change-Id: I8fc7879a378a3711ae7264c9a2d8b0955895147f
---
 libvendorsupport/Android.bp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/libvendorsupport/Android.bp b/libvendorsupport/Android.bp
index 74e3f0044672..e87959ec4e57 100644
--- a/libvendorsupport/Android.bp
+++ b/libvendorsupport/Android.bp
@@ -49,6 +49,17 @@ cc_library_headers {
         llndk_headers: true,
     },
 
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    min_sdk_version: "apex_inherit",
+
     system_shared_libs: [],
     stl: "none",
+
+    // This header library is used for libc and must be available to any sdk
+    // versions.
+    // Setting sdk_version to the lowest version allows the dependencies.
+    sdk_version: "1",
 }

From aa1d18a59bdbcc36a4a133ae9faea4997612b232 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 26 Feb 2024 22:18:21 +0000
Subject: [PATCH 0747/1487] Remove support for Linux before 3.11 (without
 O_TMPFILE).

We don't support kernels that old any more.

Test: treehugger
Change-Id: Ia664de6921901dec54644cff9f51e8514258e257
---
 debuggerd/tombstoned/tombstoned.cpp | 27 ++-------------------------
 1 file changed, 2 insertions(+), 25 deletions(-)

diff --git a/debuggerd/tombstoned/tombstoned.cpp b/debuggerd/tombstoned/tombstoned.cpp
index 98eb003e3806..e2a67a2f7068 100644
--- a/debuggerd/tombstoned/tombstoned.cpp
+++ b/debuggerd/tombstoned/tombstoned.cpp
@@ -61,7 +61,6 @@ enum CrashStatus {
 
 struct CrashArtifact {
   unique_fd fd;
-  std::optional<std::string> temporary_path;
 
   static CrashArtifact devnull() {
     CrashArtifact result;
@@ -145,17 +144,9 @@ class CrashQueue {
     std::optional<std::string> path;
     result.fd.reset(openat(dir_fd_, ".", O_WRONLY | O_APPEND | O_TMPFILE | O_CLOEXEC, 0660));
     if (result.fd == -1) {
-      // We might not have O_TMPFILE. Try creating with an arbitrary filename instead.
-      static size_t counter = 0;
-      std::string tmp_filename = StringPrintf(".temporary%zu", counter++);
-      result.fd.reset(openat(dir_fd_, tmp_filename.c_str(),
-                             O_WRONLY | O_APPEND | O_CREAT | O_TRUNC | O_CLOEXEC, 0660));
-      if (result.fd == -1) {
-        PLOG(FATAL) << "failed to create temporary tombstone in " << dir_path_;
-      }
-
-      result.temporary_path = std::move(tmp_filename);
+      PLOG(FATAL) << "failed to create temporary tombstone in " << dir_path_;
     }
+
     // We need to fchmodat after creating to avoid getting the umask applied.
     std::string fd_path = StringPrintf("/proc/self/fd/%d", result.fd.get());
     if (fchmodat(dir_fd_, fd_path.c_str(), 0664, 0) != 0) {
@@ -477,20 +468,6 @@ static void crash_completed(borrowed_fd sockfd, std::unique_ptr<Crash> crash) {
       rename_tombstone_fd(crash->output.proto->fd, queue->dir_fd(), *paths.proto);
     }
   }
-
-  // If we don't have O_TMPFILE, we need to clean up after ourselves.
-  if (crash->output.text.temporary_path) {
-    rc = unlinkat(queue->dir_fd().get(), crash->output.text.temporary_path->c_str(), 0);
-    if (rc != 0) {
-      PLOG(ERROR) << "failed to unlink temporary tombstone at " << paths.text;
-    }
-  }
-  if (crash->output.proto && crash->output.proto->temporary_path) {
-    rc = unlinkat(queue->dir_fd().get(), crash->output.proto->temporary_path->c_str(), 0);
-    if (rc != 0) {
-      PLOG(ERROR) << "failed to unlink temporary proto tombstone";
-    }
-  }
 }
 
 static void crash_completed_cb(evutil_socket_t sockfd, short ev, void* arg) {

From 77337c2975f38d837615fc93fb40f92b0cae085f Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 7 Feb 2024 06:43:57 +0000
Subject: [PATCH 0748/1487] snapshotctl: Add apply-update option

$snapshotctl apply-update <directory containing snapshot patches>

This command is equivalent to applying incremental-ota but
bypasses all of the update-engine subsystem. Snapshot-patches
which are created on the host will be used directly and
will be written to the COW block devices.

No change to any of the libsnapshot or the I/O path logic.

Once the snapshot patches are applied, device is ready
to reboot as if an OTA update is applied.

Once the device reboots, snapshot merge will be initiated
as usual.

This will help test the changes to libsnapshot + init + snapuserd
extremely quick.

Incremental flashing becomes quite simple in the CI workflow.

Here are numbers tested on live builds where the actual builds/testing
is done on CI.

Patch-Create+Apply = Create the snapshot patches between two
builds and apply them to the device

Branch(main)     Patch-Creation+Apply Merge        Snapshot-size
=================================================================
Build-1 -> Build-2  14 seconds        40 seconds   160MB

Build-2 -> Build-3  21 seconds        26 seconds   331MB

Build-3 -> Build-4  30 seconds        45 seconds   375MB

Build-X -> Build-X  3 seconds	       4 seconds   8MB

Bug: 319309466
Test: On Pixel 6, incremental builds

Change-Id: I271b2cb5df4abde91571ec70ce06f926a1d01694
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshotctl.cpp | 221 ++++++++++++++++++++++++++++-
 1 file changed, 215 insertions(+), 6 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 0396a55d67a8..06eff8144b61 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -15,6 +15,7 @@
 //
 
 #include <sysexits.h>
+#include <unistd.h>
 
 #include <chrono>
 #include <filesystem>
@@ -79,7 +80,11 @@ int Usage() {
                  "  revert-snapshots\n"
                  "    Prepares devices to boot without snapshots on next boot.\n"
                  "    This does not delete the snapshot. It only removes the indicators\n"
-                 "    so that first stage init will not mount from snapshots.\n";
+                 "    so that first stage init will not mount from snapshots.\n"
+                 "  apply-update\n"
+                 "    Apply the incremental OTA update wherein the snapshots are\n"
+                 "    directly written to COW block device. This will bypass update-engine\n"
+                 "    and the device will be ready to boot from the target build.\n";
     return EX_USAGE;
 }
 
@@ -96,14 +101,22 @@ class MapSnapshots {
     bool DeleteSnapshots();
     bool CleanupSnapshot() { return sm_->PrepareDeviceToBootWithoutSnapshot(); }
     bool BeginUpdate();
+    bool ApplyUpdate();
 
   private:
     std::optional<std::string> GetCowImagePath(std::string& name);
+    bool PrepareUpdate();
     bool WriteSnapshotPatch(std::string cow_device, std::string patch);
+    std::string GetGroupName(const android::fs_mgr::LpMetadata& pt,
+                             const std::string& partiton_name);
     std::unique_ptr<SnapshotManager::LockedFile> lock_;
     std::unique_ptr<SnapshotManager> sm_;
     std::vector<std::future<bool>> threads_;
     std::string snapshot_dir_path_;
+    std::unordered_map<std::string, chromeos_update_engine::DynamicPartitionGroup*> group_map_;
+
+    std::vector<std::string> patchfiles_;
+    chromeos_update_engine::DeltaArchiveManifest manifest_;
 };
 
 MapSnapshots::MapSnapshots(std::string path) {
@@ -115,6 +128,178 @@ MapSnapshots::MapSnapshots(std::string path) {
     snapshot_dir_path_ = path + "/";
 }
 
+std::string MapSnapshots::GetGroupName(const android::fs_mgr::LpMetadata& pt,
+                                       const std::string& partition_name) {
+    std::string group_name;
+    for (const auto& partition : pt.partitions) {
+        std::string name = android::fs_mgr::GetPartitionName(partition);
+        auto suffix = android::fs_mgr::GetPartitionSlotSuffix(name);
+        std::string pname = name.substr(0, name.size() - suffix.size());
+        if (pname == partition_name) {
+            std::string group_name =
+                    android::fs_mgr::GetPartitionGroupName(pt.groups[partition.group_index]);
+            return group_name.substr(0, group_name.size() - suffix.size());
+        }
+    }
+    return "";
+}
+
+bool MapSnapshots::PrepareUpdate() {
+    auto source_slot = fs_mgr_get_slot_suffix();
+    auto source_slot_number = SlotNumberForSlotSuffix(source_slot);
+    auto super_source = fs_mgr_get_super_partition_name(source_slot_number);
+
+    // Get current partition information.
+    PartitionOpener opener;
+    auto source_metadata = ReadMetadata(opener, super_source, source_slot_number);
+    if (!source_metadata) {
+        LOG(ERROR) << "Could not read source partition metadata.\n";
+        return false;
+    }
+
+    auto dap = manifest_.mutable_dynamic_partition_metadata();
+    dap->set_snapshot_enabled(true);
+    dap->set_vabc_enabled(true);
+    dap->set_vabc_compression_param("lz4");
+    dap->set_cow_version(3);
+
+    for (const auto& entry : std::filesystem::directory_iterator(snapshot_dir_path_)) {
+        if (android::base::EndsWith(entry.path().generic_string(), ".patch")) {
+            patchfiles_.push_back(android::base::Basename(entry.path().generic_string()));
+        }
+    }
+
+    for (auto& patchfile : patchfiles_) {
+        std::string parsing_file = snapshot_dir_path_ + patchfile;
+        android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(parsing_file.c_str(), O_RDONLY)));
+        if (fd < 0) {
+            LOG(ERROR) << "Failed to open file: " << parsing_file;
+            return false;
+        }
+        uint64_t dev_sz = lseek(fd.get(), 0, SEEK_END);
+        if (!dev_sz) {
+            LOG(ERROR) << "Could not determine block device size: " << parsing_file;
+            return false;
+        }
+
+        const int block_sz = 4_KiB;
+        dev_sz += block_sz - 1;
+        dev_sz &= ~(block_sz - 1);
+
+        auto npos = patchfile.rfind(".patch");
+        auto partition_name = patchfile.substr(0, npos);
+
+        chromeos_update_engine::DynamicPartitionGroup* group = nullptr;
+        std::string group_name = GetGroupName(*source_metadata.get(), partition_name);
+        if (group_map_.find(group_name) != group_map_.end()) {
+            group = group_map_[group_name];
+        } else {
+            group = dap->add_groups();
+            group->set_name(group_name);
+            group_map_[group_name] = group;
+        }
+        group->add_partition_names(partition_name);
+
+        auto pu = manifest_.mutable_partitions()->Add();
+        pu->set_partition_name(partition_name);
+        pu->set_estimate_cow_size(dev_sz);
+
+        CowReader reader;
+        if (!reader.Parse(fd)) {
+            LOG(ERROR) << "COW reader parse failed";
+            return false;
+        }
+
+        uint64_t new_device_size = 0;
+        const auto& header = reader.GetHeader();
+        if (header.prefix.major_version == 2) {
+            size_t num_ops = reader.get_num_total_data_ops();
+            new_device_size = (num_ops * header.block_size);
+        } else {
+            const auto& v3_header = reader.header_v3();
+            new_device_size = v3_header.op_count_max * v3_header.block_size;
+        }
+
+        LOG(INFO) << "Partition: " << partition_name << " Group_name: " << group_name
+                  << " size: " << new_device_size << " COW-size: " << dev_sz;
+        pu->mutable_new_partition_info()->set_size(new_device_size);
+    }
+    return true;
+}
+
+bool MapSnapshots::ApplyUpdate() {
+    if (!PrepareUpdate()) {
+        LOG(ERROR) << "PrepareUpdate failed";
+        return false;
+    }
+    if (!sm_->BeginUpdate()) {
+        LOG(ERROR) << "BeginUpdate failed";
+        return false;
+    }
+    if (!sm_->CreateUpdateSnapshots(manifest_)) {
+        LOG(ERROR) << "Could not apply snapshots";
+        return false;
+    }
+
+    LOG(INFO) << "CreateUpdateSnapshots success";
+    if (!sm_->MapAllSnapshots(10s)) {
+        LOG(ERROR) << "MapAllSnapshots failed";
+        return false;
+    }
+
+    LOG(INFO) << "MapAllSnapshots success";
+
+    auto& dm = android::dm::DeviceMapper::Instance();
+    auto target_slot = fs_mgr_get_other_slot_suffix();
+    for (auto& patchfile : patchfiles_) {
+        auto npos = patchfile.rfind(".patch");
+        auto partition_name = patchfile.substr(0, npos) + target_slot;
+        auto cow_device = partition_name + "-cow";
+        std::string cow_path;
+        if (!dm.GetDmDevicePathByName(cow_device, &cow_path)) {
+            LOG(ERROR) << "Failed to cow path";
+            return false;
+        }
+        threads_.emplace_back(std::async(std::launch::async, &MapSnapshots::WriteSnapshotPatch,
+                                         this, cow_path, patchfile));
+    }
+
+    bool ret = true;
+    for (auto& t : threads_) {
+        ret = t.get() && ret;
+    }
+    if (!ret) {
+        LOG(ERROR) << "Snapshot writes failed";
+        return false;
+    }
+    if (!sm_->UnmapAllSnapshots()) {
+        LOG(ERROR) << "UnmapAllSnapshots failed";
+        return false;
+    }
+
+    LOG(INFO) << "Pre-created snapshots successfully copied";
+    // All snapshots have been written.
+    if (!sm_->FinishedSnapshotWrites(false /* wipe */)) {
+        LOG(ERROR) << "Could not finalize snapshot writes.\n";
+        return false;
+    }
+
+    auto hal = hal::BootControlClient::WaitForService();
+    if (!hal) {
+        LOG(ERROR) << "Could not find IBootControl HAL.\n";
+        return false;
+    }
+    auto target_slot_number = SlotNumberForSlotSuffix(target_slot);
+    auto cr = hal->SetActiveBootSlot(target_slot_number);
+    if (!cr.IsOk()) {
+        LOG(ERROR) << "Could not set active boot slot: " << cr.errMsg;
+        return false;
+    }
+
+    LOG(INFO) << "ApplyUpdate success";
+    return true;
+}
+
 bool MapSnapshots::BeginUpdate() {
     lock_ = sm_->LockExclusive();
     std::vector<std::string> snapshots;
@@ -227,11 +412,10 @@ bool MapSnapshots::WriteSnapshotPatch(std::string cow_device, std::string patch)
         if (file_offset >= dev_sz) {
             break;
         }
-
-        if (fsync(cfd.get()) < 0) {
-            PLOG(ERROR) << "Fsync failed at offset: " << file_offset << " size: " << to_read;
-            return false;
-        }
+    }
+    if (fsync(cfd.get()) < 0) {
+        PLOG(ERROR) << "Fsync failed";
+        return false;
     }
     return true;
 }
@@ -367,6 +551,30 @@ bool DeletePrecreatedSnapshots(int, char** argv) {
     return snapshot.DeleteSnapshots();
 }
 
+bool ApplyUpdate(int argc, char** argv) {
+    android::base::InitLogging(argv, &android::base::KernelLogger);
+
+    // Make sure we are root.
+    if (::getuid() != 0) {
+        LOG(ERROR) << "Not running as root. Try \"adb root\" first.";
+        return EXIT_FAILURE;
+    }
+
+    if (argc < 3) {
+        std::cerr << " apply-update <directory location where snapshot patches are present>"
+                     "    Apply the snapshots to the COW block device\n";
+        return false;
+    }
+
+    std::string path = std::string(argv[2]);
+    MapSnapshots cow(path);
+    if (!cow.ApplyUpdate()) {
+        return false;
+    }
+    LOG(INFO) << "Apply update success. Please reboot the device";
+    return true;
+}
+
 bool MapPrecreatedSnapshots(int argc, char** argv) {
     android::base::InitLogging(argv, &android::base::KernelLogger);
 
@@ -554,6 +762,7 @@ static std::map<std::string, std::function<bool(int, char**)>> kCmdMap = {
         {"test-blank-ota", TestOtaHandler},
 #endif
         {"unmap", UnmapCmdHandler},
+        {"apply-update", ApplyUpdate},
         {"map-snapshots", MapPrecreatedSnapshots},
         {"unmap-snapshots", UnMapPrecreatedSnapshots},
         {"delete-snapshots", DeletePrecreatedSnapshots},

From 1af72609318a8776c51d9094d63b4325e243f62d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rapha=C3=ABl=20H=C3=A9rouart?= <rherouart@google.com>
Date: Wed, 28 Feb 2024 10:12:05 +0000
Subject: [PATCH 0749/1487] Revert "snapshotctl: Add apply-update option"

This reverts commit 77337c2975f38d837615fc93fb40f92b0cae085f.

Reason for revert: b/327325747

Change-Id: I6796717774d28a7c306e19dd448c3c830f3fd550
---
 fs_mgr/libsnapshot/snapshotctl.cpp | 221 +----------------------------
 1 file changed, 6 insertions(+), 215 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 06eff8144b61..0396a55d67a8 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -15,7 +15,6 @@
 //
 
 #include <sysexits.h>
-#include <unistd.h>
 
 #include <chrono>
 #include <filesystem>
@@ -80,11 +79,7 @@ int Usage() {
                  "  revert-snapshots\n"
                  "    Prepares devices to boot without snapshots on next boot.\n"
                  "    This does not delete the snapshot. It only removes the indicators\n"
-                 "    so that first stage init will not mount from snapshots.\n"
-                 "  apply-update\n"
-                 "    Apply the incremental OTA update wherein the snapshots are\n"
-                 "    directly written to COW block device. This will bypass update-engine\n"
-                 "    and the device will be ready to boot from the target build.\n";
+                 "    so that first stage init will not mount from snapshots.\n";
     return EX_USAGE;
 }
 
@@ -101,22 +96,14 @@ class MapSnapshots {
     bool DeleteSnapshots();
     bool CleanupSnapshot() { return sm_->PrepareDeviceToBootWithoutSnapshot(); }
     bool BeginUpdate();
-    bool ApplyUpdate();
 
   private:
     std::optional<std::string> GetCowImagePath(std::string& name);
-    bool PrepareUpdate();
     bool WriteSnapshotPatch(std::string cow_device, std::string patch);
-    std::string GetGroupName(const android::fs_mgr::LpMetadata& pt,
-                             const std::string& partiton_name);
     std::unique_ptr<SnapshotManager::LockedFile> lock_;
     std::unique_ptr<SnapshotManager> sm_;
     std::vector<std::future<bool>> threads_;
     std::string snapshot_dir_path_;
-    std::unordered_map<std::string, chromeos_update_engine::DynamicPartitionGroup*> group_map_;
-
-    std::vector<std::string> patchfiles_;
-    chromeos_update_engine::DeltaArchiveManifest manifest_;
 };
 
 MapSnapshots::MapSnapshots(std::string path) {
@@ -128,178 +115,6 @@ MapSnapshots::MapSnapshots(std::string path) {
     snapshot_dir_path_ = path + "/";
 }
 
-std::string MapSnapshots::GetGroupName(const android::fs_mgr::LpMetadata& pt,
-                                       const std::string& partition_name) {
-    std::string group_name;
-    for (const auto& partition : pt.partitions) {
-        std::string name = android::fs_mgr::GetPartitionName(partition);
-        auto suffix = android::fs_mgr::GetPartitionSlotSuffix(name);
-        std::string pname = name.substr(0, name.size() - suffix.size());
-        if (pname == partition_name) {
-            std::string group_name =
-                    android::fs_mgr::GetPartitionGroupName(pt.groups[partition.group_index]);
-            return group_name.substr(0, group_name.size() - suffix.size());
-        }
-    }
-    return "";
-}
-
-bool MapSnapshots::PrepareUpdate() {
-    auto source_slot = fs_mgr_get_slot_suffix();
-    auto source_slot_number = SlotNumberForSlotSuffix(source_slot);
-    auto super_source = fs_mgr_get_super_partition_name(source_slot_number);
-
-    // Get current partition information.
-    PartitionOpener opener;
-    auto source_metadata = ReadMetadata(opener, super_source, source_slot_number);
-    if (!source_metadata) {
-        LOG(ERROR) << "Could not read source partition metadata.\n";
-        return false;
-    }
-
-    auto dap = manifest_.mutable_dynamic_partition_metadata();
-    dap->set_snapshot_enabled(true);
-    dap->set_vabc_enabled(true);
-    dap->set_vabc_compression_param("lz4");
-    dap->set_cow_version(3);
-
-    for (const auto& entry : std::filesystem::directory_iterator(snapshot_dir_path_)) {
-        if (android::base::EndsWith(entry.path().generic_string(), ".patch")) {
-            patchfiles_.push_back(android::base::Basename(entry.path().generic_string()));
-        }
-    }
-
-    for (auto& patchfile : patchfiles_) {
-        std::string parsing_file = snapshot_dir_path_ + patchfile;
-        android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(parsing_file.c_str(), O_RDONLY)));
-        if (fd < 0) {
-            LOG(ERROR) << "Failed to open file: " << parsing_file;
-            return false;
-        }
-        uint64_t dev_sz = lseek(fd.get(), 0, SEEK_END);
-        if (!dev_sz) {
-            LOG(ERROR) << "Could not determine block device size: " << parsing_file;
-            return false;
-        }
-
-        const int block_sz = 4_KiB;
-        dev_sz += block_sz - 1;
-        dev_sz &= ~(block_sz - 1);
-
-        auto npos = patchfile.rfind(".patch");
-        auto partition_name = patchfile.substr(0, npos);
-
-        chromeos_update_engine::DynamicPartitionGroup* group = nullptr;
-        std::string group_name = GetGroupName(*source_metadata.get(), partition_name);
-        if (group_map_.find(group_name) != group_map_.end()) {
-            group = group_map_[group_name];
-        } else {
-            group = dap->add_groups();
-            group->set_name(group_name);
-            group_map_[group_name] = group;
-        }
-        group->add_partition_names(partition_name);
-
-        auto pu = manifest_.mutable_partitions()->Add();
-        pu->set_partition_name(partition_name);
-        pu->set_estimate_cow_size(dev_sz);
-
-        CowReader reader;
-        if (!reader.Parse(fd)) {
-            LOG(ERROR) << "COW reader parse failed";
-            return false;
-        }
-
-        uint64_t new_device_size = 0;
-        const auto& header = reader.GetHeader();
-        if (header.prefix.major_version == 2) {
-            size_t num_ops = reader.get_num_total_data_ops();
-            new_device_size = (num_ops * header.block_size);
-        } else {
-            const auto& v3_header = reader.header_v3();
-            new_device_size = v3_header.op_count_max * v3_header.block_size;
-        }
-
-        LOG(INFO) << "Partition: " << partition_name << " Group_name: " << group_name
-                  << " size: " << new_device_size << " COW-size: " << dev_sz;
-        pu->mutable_new_partition_info()->set_size(new_device_size);
-    }
-    return true;
-}
-
-bool MapSnapshots::ApplyUpdate() {
-    if (!PrepareUpdate()) {
-        LOG(ERROR) << "PrepareUpdate failed";
-        return false;
-    }
-    if (!sm_->BeginUpdate()) {
-        LOG(ERROR) << "BeginUpdate failed";
-        return false;
-    }
-    if (!sm_->CreateUpdateSnapshots(manifest_)) {
-        LOG(ERROR) << "Could not apply snapshots";
-        return false;
-    }
-
-    LOG(INFO) << "CreateUpdateSnapshots success";
-    if (!sm_->MapAllSnapshots(10s)) {
-        LOG(ERROR) << "MapAllSnapshots failed";
-        return false;
-    }
-
-    LOG(INFO) << "MapAllSnapshots success";
-
-    auto& dm = android::dm::DeviceMapper::Instance();
-    auto target_slot = fs_mgr_get_other_slot_suffix();
-    for (auto& patchfile : patchfiles_) {
-        auto npos = patchfile.rfind(".patch");
-        auto partition_name = patchfile.substr(0, npos) + target_slot;
-        auto cow_device = partition_name + "-cow";
-        std::string cow_path;
-        if (!dm.GetDmDevicePathByName(cow_device, &cow_path)) {
-            LOG(ERROR) << "Failed to cow path";
-            return false;
-        }
-        threads_.emplace_back(std::async(std::launch::async, &MapSnapshots::WriteSnapshotPatch,
-                                         this, cow_path, patchfile));
-    }
-
-    bool ret = true;
-    for (auto& t : threads_) {
-        ret = t.get() && ret;
-    }
-    if (!ret) {
-        LOG(ERROR) << "Snapshot writes failed";
-        return false;
-    }
-    if (!sm_->UnmapAllSnapshots()) {
-        LOG(ERROR) << "UnmapAllSnapshots failed";
-        return false;
-    }
-
-    LOG(INFO) << "Pre-created snapshots successfully copied";
-    // All snapshots have been written.
-    if (!sm_->FinishedSnapshotWrites(false /* wipe */)) {
-        LOG(ERROR) << "Could not finalize snapshot writes.\n";
-        return false;
-    }
-
-    auto hal = hal::BootControlClient::WaitForService();
-    if (!hal) {
-        LOG(ERROR) << "Could not find IBootControl HAL.\n";
-        return false;
-    }
-    auto target_slot_number = SlotNumberForSlotSuffix(target_slot);
-    auto cr = hal->SetActiveBootSlot(target_slot_number);
-    if (!cr.IsOk()) {
-        LOG(ERROR) << "Could not set active boot slot: " << cr.errMsg;
-        return false;
-    }
-
-    LOG(INFO) << "ApplyUpdate success";
-    return true;
-}
-
 bool MapSnapshots::BeginUpdate() {
     lock_ = sm_->LockExclusive();
     std::vector<std::string> snapshots;
@@ -412,10 +227,11 @@ bool MapSnapshots::WriteSnapshotPatch(std::string cow_device, std::string patch)
         if (file_offset >= dev_sz) {
             break;
         }
-    }
-    if (fsync(cfd.get()) < 0) {
-        PLOG(ERROR) << "Fsync failed";
-        return false;
+
+        if (fsync(cfd.get()) < 0) {
+            PLOG(ERROR) << "Fsync failed at offset: " << file_offset << " size: " << to_read;
+            return false;
+        }
     }
     return true;
 }
@@ -551,30 +367,6 @@ bool DeletePrecreatedSnapshots(int, char** argv) {
     return snapshot.DeleteSnapshots();
 }
 
-bool ApplyUpdate(int argc, char** argv) {
-    android::base::InitLogging(argv, &android::base::KernelLogger);
-
-    // Make sure we are root.
-    if (::getuid() != 0) {
-        LOG(ERROR) << "Not running as root. Try \"adb root\" first.";
-        return EXIT_FAILURE;
-    }
-
-    if (argc < 3) {
-        std::cerr << " apply-update <directory location where snapshot patches are present>"
-                     "    Apply the snapshots to the COW block device\n";
-        return false;
-    }
-
-    std::string path = std::string(argv[2]);
-    MapSnapshots cow(path);
-    if (!cow.ApplyUpdate()) {
-        return false;
-    }
-    LOG(INFO) << "Apply update success. Please reboot the device";
-    return true;
-}
-
 bool MapPrecreatedSnapshots(int argc, char** argv) {
     android::base::InitLogging(argv, &android::base::KernelLogger);
 
@@ -762,7 +554,6 @@ static std::map<std::string, std::function<bool(int, char**)>> kCmdMap = {
         {"test-blank-ota", TestOtaHandler},
 #endif
         {"unmap", UnmapCmdHandler},
-        {"apply-update", ApplyUpdate},
         {"map-snapshots", MapPrecreatedSnapshots},
         {"unmap-snapshots", UnMapPrecreatedSnapshots},
         {"delete-snapshots", DeletePrecreatedSnapshots},

From d059478ee1bddcb2d36c1ba4c881f9d6e379936f Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Wed, 28 Feb 2024 11:12:11 -0800
Subject: [PATCH 0750/1487] Add TEST_MAPPING for debuggerd CTS

Change-Id: I3bba97e7a0a2b053c6d5577496efa2dca29035d4
---
 debuggerd/TEST_MAPPING | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/debuggerd/TEST_MAPPING b/debuggerd/TEST_MAPPING
index 8633cb866dbe..61d71550ca2e 100644
--- a/debuggerd/TEST_MAPPING
+++ b/debuggerd/TEST_MAPPING
@@ -14,5 +14,10 @@
     {
       "name": "debuggerd_test"
     }
+  ],
+  "postsubmit": [
+    {
+      "name": "CtsCrashDetailHostTestCases"
+    }
   ]
 }

From cac1cf3ae98f9e0a008be52fcefa5321f7e4d2f7 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 28 Feb 2024 11:18:45 -0800
Subject: [PATCH 0751/1487] Reapply "snapshotctl: Add apply-update option"

This reverts commit 1af72609318a8776c51d9094d63b4325e243f62d.

Fix: Allow BootControlClient.h to be used in -user builds

Bug: 319309466
Test: Build on -user branch
Change-Id: I93e95e35b29a98816b2f33fe9fa6859655934cd5
---
 fs_mgr/libsnapshot/snapshotctl.cpp | 223 +++++++++++++++++++++++++++--
 1 file changed, 215 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 0396a55d67a8..50e9f4823375 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -15,6 +15,7 @@
 //
 
 #include <sysexits.h>
+#include <unistd.h>
 
 #include <chrono>
 #include <filesystem>
@@ -46,9 +47,7 @@
 
 #include "partition_cow_creator.h"
 
-#ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
 #include <BootControlClient.h>
-#endif
 
 using namespace std::chrono_literals;
 using namespace std::string_literals;
@@ -79,7 +78,11 @@ int Usage() {
                  "  revert-snapshots\n"
                  "    Prepares devices to boot without snapshots on next boot.\n"
                  "    This does not delete the snapshot. It only removes the indicators\n"
-                 "    so that first stage init will not mount from snapshots.\n";
+                 "    so that first stage init will not mount from snapshots.\n"
+                 "  apply-update\n"
+                 "    Apply the incremental OTA update wherein the snapshots are\n"
+                 "    directly written to COW block device. This will bypass update-engine\n"
+                 "    and the device will be ready to boot from the target build.\n";
     return EX_USAGE;
 }
 
@@ -96,14 +99,22 @@ class MapSnapshots {
     bool DeleteSnapshots();
     bool CleanupSnapshot() { return sm_->PrepareDeviceToBootWithoutSnapshot(); }
     bool BeginUpdate();
+    bool ApplyUpdate();
 
   private:
     std::optional<std::string> GetCowImagePath(std::string& name);
+    bool PrepareUpdate();
     bool WriteSnapshotPatch(std::string cow_device, std::string patch);
+    std::string GetGroupName(const android::fs_mgr::LpMetadata& pt,
+                             const std::string& partiton_name);
     std::unique_ptr<SnapshotManager::LockedFile> lock_;
     std::unique_ptr<SnapshotManager> sm_;
     std::vector<std::future<bool>> threads_;
     std::string snapshot_dir_path_;
+    std::unordered_map<std::string, chromeos_update_engine::DynamicPartitionGroup*> group_map_;
+
+    std::vector<std::string> patchfiles_;
+    chromeos_update_engine::DeltaArchiveManifest manifest_;
 };
 
 MapSnapshots::MapSnapshots(std::string path) {
@@ -115,6 +126,178 @@ MapSnapshots::MapSnapshots(std::string path) {
     snapshot_dir_path_ = path + "/";
 }
 
+std::string MapSnapshots::GetGroupName(const android::fs_mgr::LpMetadata& pt,
+                                       const std::string& partition_name) {
+    std::string group_name;
+    for (const auto& partition : pt.partitions) {
+        std::string name = android::fs_mgr::GetPartitionName(partition);
+        auto suffix = android::fs_mgr::GetPartitionSlotSuffix(name);
+        std::string pname = name.substr(0, name.size() - suffix.size());
+        if (pname == partition_name) {
+            std::string group_name =
+                    android::fs_mgr::GetPartitionGroupName(pt.groups[partition.group_index]);
+            return group_name.substr(0, group_name.size() - suffix.size());
+        }
+    }
+    return "";
+}
+
+bool MapSnapshots::PrepareUpdate() {
+    auto source_slot = fs_mgr_get_slot_suffix();
+    auto source_slot_number = SlotNumberForSlotSuffix(source_slot);
+    auto super_source = fs_mgr_get_super_partition_name(source_slot_number);
+
+    // Get current partition information.
+    PartitionOpener opener;
+    auto source_metadata = ReadMetadata(opener, super_source, source_slot_number);
+    if (!source_metadata) {
+        LOG(ERROR) << "Could not read source partition metadata.\n";
+        return false;
+    }
+
+    auto dap = manifest_.mutable_dynamic_partition_metadata();
+    dap->set_snapshot_enabled(true);
+    dap->set_vabc_enabled(true);
+    dap->set_vabc_compression_param("lz4");
+    dap->set_cow_version(3);
+
+    for (const auto& entry : std::filesystem::directory_iterator(snapshot_dir_path_)) {
+        if (android::base::EndsWith(entry.path().generic_string(), ".patch")) {
+            patchfiles_.push_back(android::base::Basename(entry.path().generic_string()));
+        }
+    }
+
+    for (auto& patchfile : patchfiles_) {
+        std::string parsing_file = snapshot_dir_path_ + patchfile;
+        android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(parsing_file.c_str(), O_RDONLY)));
+        if (fd < 0) {
+            LOG(ERROR) << "Failed to open file: " << parsing_file;
+            return false;
+        }
+        uint64_t dev_sz = lseek(fd.get(), 0, SEEK_END);
+        if (!dev_sz) {
+            LOG(ERROR) << "Could not determine block device size: " << parsing_file;
+            return false;
+        }
+
+        const int block_sz = 4_KiB;
+        dev_sz += block_sz - 1;
+        dev_sz &= ~(block_sz - 1);
+
+        auto npos = patchfile.rfind(".patch");
+        auto partition_name = patchfile.substr(0, npos);
+
+        chromeos_update_engine::DynamicPartitionGroup* group = nullptr;
+        std::string group_name = GetGroupName(*source_metadata.get(), partition_name);
+        if (group_map_.find(group_name) != group_map_.end()) {
+            group = group_map_[group_name];
+        } else {
+            group = dap->add_groups();
+            group->set_name(group_name);
+            group_map_[group_name] = group;
+        }
+        group->add_partition_names(partition_name);
+
+        auto pu = manifest_.mutable_partitions()->Add();
+        pu->set_partition_name(partition_name);
+        pu->set_estimate_cow_size(dev_sz);
+
+        CowReader reader;
+        if (!reader.Parse(fd)) {
+            LOG(ERROR) << "COW reader parse failed";
+            return false;
+        }
+
+        uint64_t new_device_size = 0;
+        const auto& header = reader.GetHeader();
+        if (header.prefix.major_version == 2) {
+            size_t num_ops = reader.get_num_total_data_ops();
+            new_device_size = (num_ops * header.block_size);
+        } else {
+            const auto& v3_header = reader.header_v3();
+            new_device_size = v3_header.op_count_max * v3_header.block_size;
+        }
+
+        LOG(INFO) << "Partition: " << partition_name << " Group_name: " << group_name
+                  << " size: " << new_device_size << " COW-size: " << dev_sz;
+        pu->mutable_new_partition_info()->set_size(new_device_size);
+    }
+    return true;
+}
+
+bool MapSnapshots::ApplyUpdate() {
+    if (!PrepareUpdate()) {
+        LOG(ERROR) << "PrepareUpdate failed";
+        return false;
+    }
+    if (!sm_->BeginUpdate()) {
+        LOG(ERROR) << "BeginUpdate failed";
+        return false;
+    }
+    if (!sm_->CreateUpdateSnapshots(manifest_)) {
+        LOG(ERROR) << "Could not apply snapshots";
+        return false;
+    }
+
+    LOG(INFO) << "CreateUpdateSnapshots success";
+    if (!sm_->MapAllSnapshots(10s)) {
+        LOG(ERROR) << "MapAllSnapshots failed";
+        return false;
+    }
+
+    LOG(INFO) << "MapAllSnapshots success";
+
+    auto& dm = android::dm::DeviceMapper::Instance();
+    auto target_slot = fs_mgr_get_other_slot_suffix();
+    for (auto& patchfile : patchfiles_) {
+        auto npos = patchfile.rfind(".patch");
+        auto partition_name = patchfile.substr(0, npos) + target_slot;
+        auto cow_device = partition_name + "-cow";
+        std::string cow_path;
+        if (!dm.GetDmDevicePathByName(cow_device, &cow_path)) {
+            LOG(ERROR) << "Failed to cow path";
+            return false;
+        }
+        threads_.emplace_back(std::async(std::launch::async, &MapSnapshots::WriteSnapshotPatch,
+                                         this, cow_path, patchfile));
+    }
+
+    bool ret = true;
+    for (auto& t : threads_) {
+        ret = t.get() && ret;
+    }
+    if (!ret) {
+        LOG(ERROR) << "Snapshot writes failed";
+        return false;
+    }
+    if (!sm_->UnmapAllSnapshots()) {
+        LOG(ERROR) << "UnmapAllSnapshots failed";
+        return false;
+    }
+
+    LOG(INFO) << "Pre-created snapshots successfully copied";
+    // All snapshots have been written.
+    if (!sm_->FinishedSnapshotWrites(false /* wipe */)) {
+        LOG(ERROR) << "Could not finalize snapshot writes.\n";
+        return false;
+    }
+
+    auto hal = hal::BootControlClient::WaitForService();
+    if (!hal) {
+        LOG(ERROR) << "Could not find IBootControl HAL.\n";
+        return false;
+    }
+    auto target_slot_number = SlotNumberForSlotSuffix(target_slot);
+    auto cr = hal->SetActiveBootSlot(target_slot_number);
+    if (!cr.IsOk()) {
+        LOG(ERROR) << "Could not set active boot slot: " << cr.errMsg;
+        return false;
+    }
+
+    LOG(INFO) << "ApplyUpdate success";
+    return true;
+}
+
 bool MapSnapshots::BeginUpdate() {
     lock_ = sm_->LockExclusive();
     std::vector<std::string> snapshots;
@@ -227,11 +410,10 @@ bool MapSnapshots::WriteSnapshotPatch(std::string cow_device, std::string patch)
         if (file_offset >= dev_sz) {
             break;
         }
-
-        if (fsync(cfd.get()) < 0) {
-            PLOG(ERROR) << "Fsync failed at offset: " << file_offset << " size: " << to_read;
-            return false;
-        }
+    }
+    if (fsync(cfd.get()) < 0) {
+        PLOG(ERROR) << "Fsync failed";
+        return false;
     }
     return true;
 }
@@ -367,6 +549,30 @@ bool DeletePrecreatedSnapshots(int, char** argv) {
     return snapshot.DeleteSnapshots();
 }
 
+bool ApplyUpdate(int argc, char** argv) {
+    android::base::InitLogging(argv, &android::base::KernelLogger);
+
+    // Make sure we are root.
+    if (::getuid() != 0) {
+        LOG(ERROR) << "Not running as root. Try \"adb root\" first.";
+        return EXIT_FAILURE;
+    }
+
+    if (argc < 3) {
+        std::cerr << " apply-update <directory location where snapshot patches are present>"
+                     "    Apply the snapshots to the COW block device\n";
+        return false;
+    }
+
+    std::string path = std::string(argv[2]);
+    MapSnapshots cow(path);
+    if (!cow.ApplyUpdate()) {
+        return false;
+    }
+    LOG(INFO) << "Apply update success. Please reboot the device";
+    return true;
+}
+
 bool MapPrecreatedSnapshots(int argc, char** argv) {
     android::base::InitLogging(argv, &android::base::KernelLogger);
 
@@ -554,6 +760,7 @@ static std::map<std::string, std::function<bool(int, char**)>> kCmdMap = {
         {"test-blank-ota", TestOtaHandler},
 #endif
         {"unmap", UnmapCmdHandler},
+        {"apply-update", ApplyUpdate},
         {"map-snapshots", MapPrecreatedSnapshots},
         {"unmap-snapshots", UnMapPrecreatedSnapshots},
         {"delete-snapshots", DeletePrecreatedSnapshots},

From 6884e27d8ef029b9e3bd82b271301266f6ffa701 Mon Sep 17 00:00:00 2001
From: Dennis Shen <dzshen@google.com>
Date: Wed, 28 Feb 2024 21:20:35 +0000
Subject: [PATCH 0752/1487] aconfig_storage: fix aconfig storage dir
 permissions

Bug: b/312444587
Test: m and launch AVD
Change-Id: I8db6bf8ffde40c9266e17d818d1e88d7e095a93e
---
 rootdir/init.rc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index f3b2d0379245..164d41158090 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -641,9 +641,9 @@ on post-fs
 
     mkdir /metadata/staged-install 0770 root system
 
-    mkdir /metadata/aconfig 0750 root system
-    mkdir /metadata/aconfig/flags 0750 root system
-    mkdir /metadata/aconfig/boot 0754 root system
+    mkdir /metadata/aconfig 0775 root system
+    mkdir /metadata/aconfig/flags 0770 root system
+    mkdir /metadata/aconfig/boot 0775 root system
 
 on late-fs
     # Ensure that tracefs has the correct permissions.

From 2f298bcb21a273fcfd862a7c48f285f4918ac6e9 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Thu, 29 Feb 2024 19:41:24 +0800
Subject: [PATCH 0753/1487] adb-remount-test: Adb shell command could return 0
 or 255 if device is disconnected

Background: aosp/I25f740bd222263fcb3c501def38977db6af1e0d9

Bug: 327552188
Test: abtd
Change-Id: Ida33bfa00887e8ac358e057fc37fd45095ccc26b
---
 fs_mgr/tests/adb-remount-test.sh | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/tests/adb-remount-test.sh b/fs_mgr/tests/adb-remount-test.sh
index 7ac7a1642f25..526c761d3654 100755
--- a/fs_mgr/tests/adb-remount-test.sh
+++ b/fs_mgr/tests/adb-remount-test.sh
@@ -1081,7 +1081,9 @@ LOG OK "no overlay present before setup"
 LOG RUN "Testing adb disable-verity -R"
 
 T=$(adb_date)
-adb_su disable-verity -R >&2 ||
+adb_su disable-verity -R >&2
+err=${?}
+[[ ${err} -eq 0 || ${err} -eq 255 ]] ||
   die -t "${T}" "disable-verity -R failed"
 sleep 2
 adb_wait "${ADB_WAIT}" ||
@@ -1192,7 +1194,9 @@ LOG OK "adb remount from scratch"
 LOG RUN "Testing adb remount -R"
 
 T=$(adb_date)
-adb_su remount -R </dev/null >&2 ||
+adb_su remount -R </dev/null >&2
+err=${?}
+[[ ${err} -eq 0 || ${err} -eq 255 ]] ||
   die -t "${T}" "adb remount -R failed"
 sleep 2
 adb_wait "${ADB_WAIT}" ||

From aa4883448533e06459f4bc13d95b5df80783e93a Mon Sep 17 00:00:00 2001
From: Oluwarotimi Adesina <oadesina@google.com>
Date: Thu, 29 Feb 2024 15:10:09 +0000
Subject: [PATCH 0754/1487] Revert "Add TEST_MAPPING for debuggerd CTS"

This reverts commit d059478ee1bddcb2d36c1ba4c881f9d6e379936f.

Reason for revert: Potential culprit for b/327525776- verifying through ABTD before revert submission. This is part of the standard investigation process, and does not mean your CL will be reverted.

Change-Id: I4b713aa46b2869a677a210cfce6ae880366b045e
---
 debuggerd/TEST_MAPPING | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/debuggerd/TEST_MAPPING b/debuggerd/TEST_MAPPING
index 61d71550ca2e..8633cb866dbe 100644
--- a/debuggerd/TEST_MAPPING
+++ b/debuggerd/TEST_MAPPING
@@ -14,10 +14,5 @@
     {
       "name": "debuggerd_test"
     }
-  ],
-  "postsubmit": [
-    {
-      "name": "CtsCrashDetailHostTestCases"
-    }
   ]
 }

From 699f27913f372829714e0cf672c0fb7edc6966a4 Mon Sep 17 00:00:00 2001
From: Jiakai Zhang <jiakaiz@google.com>
Date: Thu, 29 Feb 2024 17:29:18 +0000
Subject: [PATCH 0755/1487] Create /mnt/pre_reboot_dexopt on init for
 Pre-reboot Dexopt.

Bug: 311377497
Test: manual - Boot the device and see the directory.
Change-Id: I083e0dc3c8d16839122a42fc3d00cdcac07a5cb8
---
 rootdir/init.rc | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 8a2ed9fac101..1e0fa9a82ff0 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -303,6 +303,9 @@ on init
     mkdir /mnt/runtime/full 0755 root root
     mkdir /mnt/runtime/full/self 0755 root root
 
+    # For Pre-reboot Dexopt
+    mkdir /mnt/pre_reboot_dexopt 0755 artd artd
+
     # Symlink to keep legacy apps working in multi-user world
     symlink /storage/self/primary /mnt/sdcard
     symlink /mnt/user/0/primary /mnt/runtime/default/self/primary

From b9f2361dd97a08022ebcdc1798f69d50bc83a171 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 29 Feb 2024 13:58:46 -0800
Subject: [PATCH 0756/1487] snapshotctl: Build few commands only for
 userdebug/eng builds

Bug: 319309466
Test: Build on -user and -userdebug targets
Change-Id: I2a668193972495769ecedbb687f561ed7345ffbc
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshotctl.cpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 50e9f4823375..d1e1f0773bf0 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -47,7 +47,9 @@
 
 #include "partition_cow_creator.h"
 
+#ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
 #include <BootControlClient.h>
+#endif
 
 using namespace std::chrono_literals;
 using namespace std::string_literals;
@@ -89,6 +91,7 @@ int Usage() {
 namespace android {
 namespace snapshot {
 
+#ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
 class MapSnapshots {
   public:
     MapSnapshots(std::string path = "");
@@ -459,6 +462,7 @@ bool MapSnapshots::DeleteSnapshots() {
     }
     return true;
 }
+#endif
 
 bool DumpCmdHandler(int /*argc*/, char** argv) {
     android::base::InitLogging(argv, &android::base::StderrLogger);
@@ -482,6 +486,7 @@ bool MergeCmdHandler(int /*argc*/, char** argv) {
     return false;
 }
 
+#ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
 bool GetVerityPartitions(std::vector<std::string>& partitions) {
     auto& dm = android::dm::DeviceMapper::Instance();
     auto dm_block_devices = dm.FindDmPartitions();
@@ -634,7 +639,6 @@ bool MapPrecreatedSnapshots(int argc, char** argv) {
     return cow.FinishSnapshotWrites();
 }
 
-#ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
 bool CreateTestUpdate(SnapshotManager* sm) {
     chromeos_update_engine::DeltaArchiveManifest manifest;
 
@@ -758,13 +762,13 @@ static std::map<std::string, std::function<bool(int, char**)>> kCmdMap = {
         {"map", MapCmdHandler},
 #ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
         {"test-blank-ota", TestOtaHandler},
-#endif
-        {"unmap", UnmapCmdHandler},
         {"apply-update", ApplyUpdate},
         {"map-snapshots", MapPrecreatedSnapshots},
         {"unmap-snapshots", UnMapPrecreatedSnapshots},
         {"delete-snapshots", DeletePrecreatedSnapshots},
         {"revert-snapshots", RemovePrecreatedSnapshots},
+#endif
+        {"unmap", UnmapCmdHandler},
         // clang-format on
 };
 

From 98522c0e2df6e06e91753621f61e8edd13200f3f Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 29 Feb 2024 14:29:10 -0800
Subject: [PATCH 0757/1487] Add annotations to VTS tests

This helps reviewers understand which VTS requirement these test are
covering

Bug: 302208814
Test: th
Change-Id: I52712d9888b73fc7a9f8eeeb035a3303618efd69
---
 fs_mgr/libsnapshot/partition_cow_creator_test.cpp | 1 +
 fs_mgr/libsnapshot/snapshot_test.cpp              | 1 +
 fs_mgr/libsnapshot/vts_ota_config_test.cpp        | 1 +
 3 files changed, 3 insertions(+)

diff --git a/fs_mgr/libsnapshot/partition_cow_creator_test.cpp b/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
index cf26a163649c..a4a2c1a681fc 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
+++ b/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
@@ -39,6 +39,7 @@ using ::testing::Truly;
 namespace android {
 namespace snapshot {
 
+// @VsrTest = 3.7.6
 class PartitionCowCreatorTest : public ::testing::Test {
   public:
     void SetUp() override {
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index e538d503d736..47e6ce963b08 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -104,6 +104,7 @@ std::string fake_super;
 
 void MountMetadata();
 
+// @VsrTest = 3.7.6
 class SnapshotTest : public ::testing::Test {
   public:
     SnapshotTest() : dm_(DeviceMapper::Instance()) {}
diff --git a/fs_mgr/libsnapshot/vts_ota_config_test.cpp b/fs_mgr/libsnapshot/vts_ota_config_test.cpp
index d387eb32d1db..b5618c478680 100755
--- a/fs_mgr/libsnapshot/vts_ota_config_test.cpp
+++ b/fs_mgr/libsnapshot/vts_ota_config_test.cpp
@@ -21,6 +21,7 @@ static int GetVsrLevel() {
     return android::base::GetIntProperty("ro.vendor.api_level", -1);
 }
 
+// @VsrTest = 3.7.6
 TEST(VAB, Enabled) {
     if (!android::base::GetBoolProperty("ro.build.ab_update", false) && (GetVsrLevel() < __ANDROID_API_T__)) {
         GTEST_SKIP();

From bc227038c05e0fd36543537795c4c1201c603f38 Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Thu, 29 Feb 2024 14:40:57 -0800
Subject: [PATCH 0758/1487] debuggerd_test: fix invalid regexs

    \(fault address prefixed with --->)

should be

    \(fault address prefixed with --->\)

Test: debuggerd_test
Bug: 175635923
Bug: 327668317
Change-Id: I03bf8969e9818956ae79b916ab852efaf4f2f78a
---
 debuggerd/debuggerd_test.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index f396b1de89ed..5cc2b3aef6e0 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -2647,7 +2647,7 @@ TEST_F(CrasherTest, fault_address_after_last_map) {
   match_str += format_full_pointer(crash_uptr);
   ASSERT_MATCH(result, match_str);
 
-  ASSERT_MATCH(result, R"(\nmemory map \(.*\): \(fault address prefixed with --->)\n)");
+  ASSERT_MATCH(result, R"(\nmemory map \(.*\): \(fault address prefixed with --->\)\n)");
 
   // Verifies that the fault address error message is at the end of the
   // maps section. To do this, the check below looks for the start of the
@@ -2699,7 +2699,7 @@ TEST_F(CrasherTest, fault_address_between_maps) {
   match_str += format_full_pointer(reinterpret_cast<uintptr_t>(middle_ptr));
   ASSERT_MATCH(result, match_str);
 
-  ASSERT_MATCH(result, R"(\nmemory map \(.*\): \(fault address prefixed with --->)\n)");
+  ASSERT_MATCH(result, R"(\nmemory map \(.*\): \(fault address prefixed with --->\)\n)");
 
   match_str = android::base::StringPrintf(
       R"(    %s.*\n--->Fault address falls at %s between mapped regions\n    %s)",
@@ -2737,7 +2737,7 @@ TEST_F(CrasherTest, fault_address_in_map) {
   match_str += format_full_pointer(reinterpret_cast<uintptr_t>(ptr));
   ASSERT_MATCH(result, match_str);
 
-  ASSERT_MATCH(result, R"(\nmemory map \(.*\): \(fault address prefixed with --->)\n)");
+  ASSERT_MATCH(result, R"(\nmemory map \(.*\): \(fault address prefixed with --->\)\n)");
 
   match_str = android::base::StringPrintf(R"(\n--->%s.*\n)", format_pointer(ptr).c_str());
   ASSERT_MATCH(result, match_str);

From 06053405e9ee4c62e687d3cc49e4c8814632670f Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 29 Feb 2024 22:59:20 +0000
Subject: [PATCH 0759/1487] Use _Fork().

POSIX issue 8 has a standard way to avoid pthread_atfork() handlers.

Change-Id: I801c55dc3fb9e14cc03f854992d60872c5468ab5
---
 debuggerd/handler/debuggerd_handler.cpp | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index 141723b037ad..595f373885c2 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -275,10 +275,6 @@ static void raise_caps() {
   }
 }
 
-static pid_t __fork() {
-  return clone(nullptr, nullptr, 0, nullptr);
-}
-
 // Double-clone, with CLONE_FILES to share the file descriptor table for kcmp validation.
 // Returns 0 in the orphaned child, the pid of the orphan in the original process, or -1 on failure.
 static void create_vm_process() {
@@ -426,7 +422,7 @@ static int debuggerd_dispatch_pseudothread(void* arg) {
   }
 
   // Don't use fork(2) to avoid calling pthread_atfork handlers.
-  pid_t crash_dump_pid = __fork();
+  pid_t crash_dump_pid = _Fork();
   if (crash_dump_pid == -1) {
     async_safe_format_log(ANDROID_LOG_FATAL, "libc",
                           "failed to fork in debuggerd signal handler: %s", strerror(errno));

From b7e994174430c01ea99b079efa182feff9f840a5 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Fri, 1 Mar 2024 01:52:23 +0000
Subject: [PATCH 0760/1487] Revert^2 "Add TEST_MAPPING for debuggerd CTS"

This reverts commit aa4883448533e06459f4bc13d95b5df80783e93a.

Reason for revert: fixed in https://r.android.com/2985051

Change-Id: I76a53df9fb585d90778019e74472ad294963a91c
---
 debuggerd/TEST_MAPPING | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/debuggerd/TEST_MAPPING b/debuggerd/TEST_MAPPING
index 8633cb866dbe..61d71550ca2e 100644
--- a/debuggerd/TEST_MAPPING
+++ b/debuggerd/TEST_MAPPING
@@ -14,5 +14,10 @@
     {
       "name": "debuggerd_test"
     }
+  ],
+  "postsubmit": [
+    {
+      "name": "CtsCrashDetailHostTestCases"
+    }
   ]
 }

From e6462f91c2de269e06346cf7a736c9ec3061e00b Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Wed, 28 Feb 2024 11:12:11 -0800
Subject: [PATCH 0761/1487] Add test for invalid setjmp in MTE

BYPASS_INCLUSIVE_LANGUAGE_REASON=man is for manpage

Test: atest debuggerd_test
Change-Id: I774095b79baadb4f692f4b97b47df80e635e3a1c
---
 debuggerd/Android.bp         |  5 ++++
 debuggerd/debuggerd_test.cpp | 50 ++++++++++++++++++++++++++++++++++++
 2 files changed, 55 insertions(+)

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 439218d4d2fb..235fdfddede4 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -371,6 +371,11 @@ cc_test {
         },
     },
 
+    sanitize: {
+        memtag_heap: true,
+        memtag_stack: true,
+    },
+
     shared_libs: [
         "libbase",
         "libcutils",
diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 5cc2b3aef6e0..3135d9e50335 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -21,6 +21,7 @@
 #include <linux/prctl.h>
 #include <malloc.h>
 #include <pthread.h>
+#include <setjmp.h>
 #include <stdlib.h>
 #include <sys/capability.h>
 #include <sys/mman.h>
@@ -601,6 +602,55 @@ TEST_P(SizeParamCrasherTest, mte_underflow) {
 #endif
 }
 
+__attribute__((noinline)) void mte_illegal_setjmp_helper(jmp_buf& jump_buf) {
+  // Because the detection of illegal setjmp is done relative to the SP in setjmp,
+  // we need to make sure this stack frame is bigger than the one of setjmp.
+  // TODO(fmayer): fix that bug and remove the workaround.
+  volatile char buf[1024];
+  buf[0] = '1';
+  setjmp(jump_buf);
+}
+
+TEST_F(CrasherTest, mte_illegal_setjmp) {
+  // This setjmp is illegal because it jumps back into a function that already returned.
+  // Quoting man 3 setjmp:
+  //     If the function which called setjmp() returns before longjmp() is
+  //     called, the behavior is undefined.  Some kind of subtle or
+  //     unsubtle chaos is sure to result.
+  // https://man7.org/linux/man-pages/man3/longjmp.3.html
+#if defined(__aarch64__)
+  if (!mte_supported()) {
+    GTEST_SKIP() << "Requires MTE";
+  }
+
+  int intercept_result;
+  unique_fd output_fd;
+  StartProcess([&]() {
+    SetTagCheckingLevelSync();
+    jmp_buf jump_buf;
+    mte_illegal_setjmp_helper(jump_buf);
+    longjmp(jump_buf, 1);
+  });
+
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  FinishIntercept(&intercept_result);
+
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+
+  // In our test-case, we have a NEGATIVE stack adjustment, which is being
+  // interpreted as unsigned integer, and thus is "too large".
+  // TODO(fmayer): fix the error message for this
+  ASSERT_MATCH(result, R"(memtag_handle_longjmp: stack adjustment too large)");
+#else
+  GTEST_SKIP() << "Requires aarch64";
+#endif
+}
+
 TEST_F(CrasherTest, mte_async) {
 #if defined(__aarch64__)
   if (!mte_supported()) {

From 80dca7ba59d440966bb49ebdaf900ff128e10817 Mon Sep 17 00:00:00 2001
From: Hsin-Yi Chen <hsinyichen@google.com>
Date: Tue, 5 Mar 2024 12:47:35 +0800
Subject: [PATCH 0762/1487] Annotate LLNDK functions in non-vendor libraries

The ABI tool analyzes the source code of LLNDK libraries. It compiles
the source with the flags for core variants where __INTRODUCED_IN_LLNDK
does not version the API. To expose the version information to the ABI
tool, __INTRODUCED_IN_LLNDK is defined as an "annotate" attribute in
core variants.

Test: make
Bug: 314010764
Change-Id: I798a397f0e7567ca54db5e4aff4235933ebd3943
---
 libvendorsupport/include_llndk/android/llndk-versioning.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/libvendorsupport/include_llndk/android/llndk-versioning.h b/libvendorsupport/include_llndk/android/llndk-versioning.h
index 7c408c940b85..b375a2fa7093 100644
--- a/libvendorsupport/include_llndk/android/llndk-versioning.h
+++ b/libvendorsupport/include_llndk/android/llndk-versioning.h
@@ -40,8 +40,10 @@ __BEGIN_DECLS
 #else  // __ANDROID_VENDOR__
 
 // For non-vendor libraries, __INTRODUCED_IN_LLNDK must be ignored because it must not change
-// symbols of NDK or the system side of the treble boundary.
-#define __INTRODUCED_IN_LLNDK(vendor_api_level)
+// symbols of NDK or the system side of the treble boundary. It leaves a no-op annotation for ABI
+// analysis.
+#define __INTRODUCED_IN_LLNDK(vendor_api_level) \
+    __attribute__((annotate("introduced_in_llndk=" #vendor_api_level)))
 
 #endif  // __ANDROID_VENDOR__
 

From 4058ba29b54c91f9d7ce7c33ee8b11360ab5be8d Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Wed, 28 Feb 2024 21:03:41 +0900
Subject: [PATCH 0763/1487] Skip initializing ro.vendor.api_level if already
 defined

Devices may predefine ro.vendor.api_level. Skip calculating the value
if the ro.vendor.api_level is already defined.

Bug: 326164316
Test: getprop ro.vendor.api_level
Change-Id: Ic9fd2a0eef6ba9345f98a5cb1eb790080e19ca19
---
 init/property_service.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index bc4ef424ba85..9249d58db721 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1090,6 +1090,12 @@ static void property_initialize_ro_vendor_api_level() {
     // required to support.
     constexpr auto VENDOR_API_LEVEL_PROP = "ro.vendor.api_level";
 
+    if (__system_property_find(VENDOR_API_LEVEL_PROP) != nullptr) {
+        // The device already have ro.vendor.api_level in its vendor/build.prop.
+        // Skip initializing the ro.vendor.api_level property.
+        return;
+    }
+
     auto vendor_api_level = GetIntProperty("ro.board.first_api_level", __ANDROID_VENDOR_API_MAX__);
     if (vendor_api_level != __ANDROID_VENDOR_API_MAX__) {
         // Update the vendor_api_level with "ro.board.api_level" only if both "ro.board.api_level"

From dfd84433ddcccb0710bde2f4987ab89f3b334674 Mon Sep 17 00:00:00 2001
From: Snehal <snehalreddy@google.com>
Date: Wed, 28 Feb 2024 18:08:09 +0000
Subject: [PATCH 0764/1487] [Metrics] Add helper data structures to parse
 metrics messages

Bug: 323508669

Change-Id: Ic4716dd47168481b6aa780f55d9db1208623b61d
---
 trusty/metrics/include/trusty/metrics/tipc.h | 79 +++++++++++++++++---
 trusty/metrics/metrics.cpp                   | 26 ++-----
 2 files changed, 76 insertions(+), 29 deletions(-)

diff --git a/trusty/metrics/include/trusty/metrics/tipc.h b/trusty/metrics/include/trusty/metrics/tipc.h
index b29628ea1e28..e2cf57b8f8d6 100644
--- a/trusty/metrics/include/trusty/metrics/tipc.h
+++ b/trusty/metrics/include/trusty/metrics/tipc.h
@@ -39,14 +39,17 @@
  * repository. They must be kept in sync.
  */
 
-#define METRICS_PORT "com.android.trusty.metrics"
+#define METRICS_PORT "com.android.trusty.metrics.consumer"
+
+#define UUID_STR_SIZE (37)
 
 /**
  * enum metrics_cmd - command identifiers for metrics interface
- * @METRICS_CMD_RESP_BIT:          message is a response
- * @METRICS_CMD_REQ_SHIFT:         number of bits used by @METRICS_CMD_RESP_BIT
- * @METRICS_CMD_REPORT_EVENT_DROP: report gaps in the event stream
- * @METRICS_CMD_REPORT_CRASH:      report an app crash event
+ * @METRICS_CMD_RESP_BIT:             message is a response
+ * @METRICS_CMD_REQ_SHIFT:            number of bits used by @METRICS_CMD_RESP_BIT
+ * @METRICS_CMD_REPORT_EVENT_DROP:    report gaps in the event stream
+ * @METRICS_CMD_REPORT_CRASH:         report an app crash event
+ * @METRICS_CMD_REPORT_STORAGE_ERROR: report trusty storage error
  */
 enum metrics_cmd {
     METRICS_CMD_RESP_BIT = 1,
@@ -54,6 +57,7 @@ enum metrics_cmd {
 
     METRICS_CMD_REPORT_EVENT_DROP = (1 << METRICS_CMD_REQ_SHIFT),
     METRICS_CMD_REPORT_CRASH = (2 << METRICS_CMD_REQ_SHIFT),
+    METRICS_CMD_REPORT_STORAGE_ERROR = (3 << METRICS_CMD_REQ_SHIFT),
 };
 
 /**
@@ -90,17 +94,70 @@ struct metrics_resp {
 /**
  * struct metrics_report_crash_req - arguments of %METRICS_CMD_REPORT_CRASH
  *                                   requests
- * @app_id_len: length of app ID that follows this structure
+ * @app_id: uuid of the app that crashed
  * @crash_reason: architecture-specific code representing the reason for the
  *                crash
  */
 struct metrics_report_crash_req {
-    uint32_t app_id_len;
+    char app_id[UUID_STR_SIZE];
     uint32_t crash_reason;
 } __attribute__((__packed__));
 
-#define METRICS_MAX_APP_ID_LEN 256
+enum TrustyStorageErrorType {
+  TRUSTY_STORAGE_ERROR_UNKNOWN = 0,
+  TRUSTY_STORAGE_ERROR_SUPERBLOCK_INVALID = 1,
+  TRUSTY_STORAGE_ERROR_BLOCK_MAC_MISMATCH = 2,
+  TRUSTY_STORAGE_ERROR_BLOCK_HEADER_INVALID = 3,
+  TRUSTY_STORAGE_ERROR_RPMB_COUNTER_MISMATCH = 4,
+  TRUSTY_STORAGE_ERROR_RPMB_COUNTER_MISMATCH_RECOVERED = 5,
+  TRUSTY_STORAGE_ERROR_RPMB_COUNTER_READ_FAILURE = 6,
+  TRUSTY_STORAGE_ERROR_RPMB_MAC_MISMATCH = 7,
+  TRUSTY_STORAGE_ERROR_RPMB_ADDR_MISMATCH = 8,
+  TRUSTY_STORAGE_ERROR_RPMB_FAILURE_RESPONSE = 9,
+  TRUSTY_STORAGE_ERROR_RPMB_UNKNOWN = 10,
+  TRUSTY_STORAGE_ERROR_RPMB_SCSI_ERROR = 11,
+  TRUSTY_STORAGE_ERROR_IO_ERROR = 12,
+  TRUSTY_STORAGE_ERROR_PROXY_COMMUNICATION_FAILURE = 13,
+};
+
+enum TrustyFileSystem {
+  TRUSTY_FS_UNKNOWN = 0,
+  TRUSTY_FS_TP = 1,
+  TRUSTY_FS_TD = 2,
+  TRUSTY_FS_TDP = 3,
+  TRUSTY_FS_TDEA = 4,
+  TRUSTY_FS_NSP = 5,
+};
+
+enum TrustyBlockType {
+  TRUSTY_BLOCKTYPE_UNKNOWN = 0,
+  TRUSTY_BLOCKTYPE_FILES_ROOT = 1,
+  TRUSTY_BLOCKTYPE_FREE_ROOT = 2,
+  TRUSTY_BLOCKTYPE_FILES_INTERNAL = 3,
+  TRUSTY_BLOCKTYPE_FREE_INTERNAL = 4,
+  TRUSTY_BLOCKTYPE_FILE_ENTRY = 5,
+  TRUSTY_BLOCKTYPE_FILE_BLOCK_MAP = 6,
+  TRUSTY_BLOCKTYPE_FILE_DATA = 7,
+  TRUSTY_BLOCKTYPE_CHECKPOINT_ROOT = 8,
+  TRUSTY_BLOCKTYPE_CHECKPOINT_FILES_ROOT = 9,
+  TRUSTY_BLOCKTYPE_CHECKPOINT_FREE_ROOT = 10,
+};
+
+struct metrics_report_storage_error_req {
+    enum TrustyStorageErrorType error;
+    char app_id[UUID_STR_SIZE];
+    char client_app_id[UUID_STR_SIZE];
+    uint32_t write;
+    enum TrustyFileSystem file_system;
+    uint64_t file_path_hash;
+    enum TrustyBlockType block_type;
+    uint64_t repair_counter;
+} __attribute__((__packed__));
 
-#define METRICS_MAX_MSG_SIZE                                                \
-    (sizeof(struct metrics_req) + sizeof(struct metrics_report_crash_req) + \
-     METRICS_MAX_APP_ID_LEN)
+struct metrics_msg {
+    struct metrics_req req;
+    union {
+        struct metrics_report_crash_req crash_args;
+        struct metrics_report_storage_error_req storage_args;
+    };
+} __attribute__((__packed__));
\ No newline at end of file
diff --git a/trusty/metrics/metrics.cpp b/trusty/metrics/metrics.cpp
index 3ac128af0fa0..d2f0b0acf073 100644
--- a/trusty/metrics/metrics.cpp
+++ b/trusty/metrics/metrics.cpp
@@ -78,9 +78,8 @@ Result<void> TrustyMetrics::HandleEvent() {
         return Error() << "connection to Metrics TA has not been initialized yet";
     }
 
-    uint8_t msg[METRICS_MAX_MSG_SIZE];
-
-    auto rc = read(metrics_fd_, msg, sizeof(msg));
+    struct metrics_msg metrics_msg;
+    int rc = read(metrics_fd_, &metrics_msg, sizeof(metrics_msg));
     if (rc < 0) {
         return ErrnoError() << "failed to read metrics message";
     }
@@ -89,23 +88,14 @@ Result<void> TrustyMetrics::HandleEvent() {
     if (msg_len < sizeof(metrics_req)) {
         return Error() << "message too small: " << rc;
     }
-    auto req = reinterpret_cast<metrics_req*>(msg);
-    size_t offset = sizeof(metrics_req);
+    uint32_t cmd = metrics_msg.req.cmd;
     uint32_t status = METRICS_NO_ERROR;
 
-    switch (req->cmd) {
+    switch (cmd) {
         case METRICS_CMD_REPORT_CRASH: {
-            if (msg_len < offset + sizeof(metrics_report_crash_req)) {
-                return Error() << "message too small: " << rc;
-            }
-            auto crash_args = reinterpret_cast<metrics_report_crash_req*>(msg + offset);
-            offset += sizeof(metrics_report_crash_req);
-
-            if (msg_len < offset + crash_args->app_id_len) {
-                return Error() << "message too small: " << rc;
-            }
-            auto app_id_ptr = reinterpret_cast<char*>(msg + offset);
-            std::string app_id(app_id_ptr, crash_args->app_id_len);
+            struct metrics_report_crash_req crash_args = metrics_msg.crash_args;
+            auto app_id_ptr = crash_args.app_id;
+            std::string app_id(app_id_ptr, UUID_STR_SIZE);
 
             HandleCrash(app_id);
             break;
@@ -121,7 +111,7 @@ Result<void> TrustyMetrics::HandleEvent() {
     }
 
     metrics_resp resp = {
-            .cmd = req->cmd | METRICS_CMD_RESP_BIT,
+            .cmd = cmd | METRICS_CMD_RESP_BIT,
             .status = status,
     };
 

From d1e4c263c42691ff72e52ce9fe368d88fa778e2d Mon Sep 17 00:00:00 2001
From: Michael Hoisie <hoisie@google.com>
Date: Wed, 6 Mar 2024 17:22:45 +0000
Subject: [PATCH 0765/1487] Remove the redundant libcutils_sockets_test

'sockets_test.cpp' also runs as part of libcutils_test and
libcutils_static_test, so it is redundant to have it be a separate
target.

Test: libcutils_test
Test: libcutils_static_test
Bug: 317884162
Change-Id: Ib2c2f74feb79d1436ca67ae9aca18d3eb7acf5a0
---
 libcutils/Android.bp | 26 ++++----------------------
 1 file changed, 4 insertions(+), 22 deletions(-)

diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index 8ae7d9e5922f..b7752d902a71 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -116,27 +116,6 @@ cc_library {
     },
 }
 
-cc_test {
-    name: "libcutils_sockets_test",
-    test_suites: ["device-tests"],
-    static_libs: ["libbase", "libcutils_sockets"],
-    cflags: [
-        "-Wall",
-        "-Wextra",
-        "-Werror",
-    ],
-
-    srcs: ["sockets_test.cpp"],
-    target: {
-        android: {
-            srcs: [
-                "android_get_control_file_test.cpp",
-                "android_get_control_socket_test.cpp",
-            ],
-        },
-    },
-}
-
 // some files must not be compiled when building against Mingw
 // they correspond to features not used by our host development tools
 // which are also hard or even impossible to port to native Win32
@@ -347,7 +326,10 @@ cc_test {
 
 cc_test {
     name: "KernelLibcutilsTest",
-    test_suites: ["general-tests", "vts"],
+    test_suites: [
+        "general-tests",
+        "vts",
+    ],
     defaults: ["libcutils_test_static_defaults"],
     test_config: "KernelLibcutilsTest.xml",
 }

From 2d3658a42111d44bd1fc386381de5ed0541ee291 Mon Sep 17 00:00:00 2001
From: Will McVicker <willmcvicker@google.com>
Date: Thu, 7 Mar 2024 11:13:47 -0800
Subject: [PATCH 0766/1487] libmodprobe: Make IsBlocklisted() public

This allows tools like modprobe to check if a module is blocklisted.

Test: verified lsmod on pixel 6
Bug: 324018983
Change-Id: I5d5278ab056e58a4ee103db94b573928cbeb5c5f
---
 libmodprobe/include/modprobe/modprobe.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libmodprobe/include/modprobe/modprobe.h b/libmodprobe/include/modprobe/modprobe.h
index 5d79d6ab6644..d7a90c488f08 100644
--- a/libmodprobe/include/modprobe/modprobe.h
+++ b/libmodprobe/include/modprobe/modprobe.h
@@ -41,6 +41,7 @@ class Modprobe {
                             std::vector<std::string>* post_dependencies);
     void ResetModuleCount() { module_count_ = 0; }
     int GetModuleCount() { return module_count_; }
+    bool IsBlocklisted(const std::string& module_name);
 
   private:
     std::string MakeCanonical(const std::string& module_path);
@@ -52,7 +53,6 @@ class Modprobe {
     void AddOption(const std::string& module_name, const std::string& option_name,
                    const std::string& value);
     std::string GetKernelCmdline();
-    bool IsBlocklisted(const std::string& module_name);
 
     bool ParseDepCallback(const std::string& base_path, const std::vector<std::string>& args);
     bool ParseAliasCallback(const std::vector<std::string>& args);

From b9dead1a751abe93348059ee2465006a0240d05a Mon Sep 17 00:00:00 2001
From: Will McVicker <willmcvicker@google.com>
Date: Thu, 7 Mar 2024 11:15:37 -0800
Subject: [PATCH 0767/1487] toolbox/modprobe: Fix failure due to blocklist

When a module is blocklisted, LoadWithAliases() will return an error
indicating the module failed to load. When the blocklist is requested
(via the -b parameter), let's not return an error if a blocklisted
module fails to load.

Test: verified lsmod on pixel 6
Bug: 324018983
Change-Id: I68f7d46bf9fd99e4b4e51ef92ea71686907f1125
---
 toolbox/modprobe.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index 17d4e319b6b5..56cf140e1531 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -257,6 +257,7 @@ extern "C" int modprobe_main(int argc, char** argv) {
         switch (mode) {
             case AddModulesMode:
                 if (!m.LoadWithAliases(module, true, module_parameters)) {
+                    if (m.IsBlocklisted(module)) continue;
                     PLOG(ERROR) << "Failed to load module " << module;
                     rv = EXIT_FAILURE;
                 }

From 1fef1b1359f36d4e7a7e6b0f97f37e6f88409b3e Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Wed, 6 Mar 2024 16:53:30 -0800
Subject: [PATCH 0768/1487] Update test for more accurate memtag_handle_longjmp

Change-Id: Ie5482d343c37ee8cf57a8ce105a0c8a363e5761e
---
 debuggerd/debuggerd_test.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 3135d9e50335..526e2ca347ad 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -603,11 +603,10 @@ TEST_P(SizeParamCrasherTest, mte_underflow) {
 }
 
 __attribute__((noinline)) void mte_illegal_setjmp_helper(jmp_buf& jump_buf) {
-  // Because the detection of illegal setjmp is done relative to the SP in setjmp,
-  // we need to make sure this stack frame is bigger than the one of setjmp.
-  // TODO(fmayer): fix that bug and remove the workaround.
-  volatile char buf[1024];
-  buf[0] = '1';
+  // This frame is at least 8 bytes for storing and restoring the LR before the
+  // setjmp below. So this can never get an empty stack frame, even if we omit
+  // the frame pointer. So, the SP of this is always less (numerically) than the
+  // calling function frame.
   setjmp(jump_buf);
 }
 

From 22ddb0aec5fd7a4e448de8098297df0004076737 Mon Sep 17 00:00:00 2001
From: Jiakai Zhang <jiakaiz@google.com>
Date: Fri, 8 Mar 2024 18:49:41 +0000
Subject: [PATCH 0769/1487] Allow other processes to run snapshotctl through
 init.

Running snapshotctl involves talking to gsid, which requires the UID to
be 0. To allow other processes to run snapshotctl without running as the
root user, this change adds system properties "sys.snapshotctl.map" and
"sys.snapshotctl.unmap" that proxy snapshotctl calls.

Bug: 311377497
Test: adb shell setprop sys.snapshotctl.map requested
Test: adb shell setprop sys.snapshotctl.unmap requested
Change-Id: Ia29dde30021a94511b8e699c2c8f3816b851bf5c
---
 rootdir/init.rc | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 1e0fa9a82ff0..bf34a9e66a89 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1361,3 +1361,16 @@ on property:persist.device_config.mglru_native.lru_gen_config=core_and_nonleaf_y
   write /sys/kernel/mm/lru_gen/enabled 5
 on property:persist.device_config.mglru_native.lru_gen_config=all
   write /sys/kernel/mm/lru_gen/enabled 7
+
+# Allow other processes to run `snapshotctl` through `init`. This requires
+# `set_prop` permission on `snapshotctl_prop`.
+on property:sys.snapshotctl.map=requested
+    # "root" is needed to talk to gsid and pass its check on uid.
+    # "system" is needed to write to "/dev/socket/snapuserd" to talk to
+    # snapuserd.
+    exec - root root system -- /system/bin/snapshotctl map
+    setprop sys.snapshotctl.map "finished"
+
+on property:sys.snapshotctl.unmap=requested
+    exec - root root system -- /system/bin/snapshotctl unmap
+    setprop sys.snapshotctl.unmap "finished"

From 6480d875b58de23804067972c681599197040c4c Mon Sep 17 00:00:00 2001
From: Jiakai Zhang <jiakaiz@google.com>
Date: Fri, 8 Mar 2024 18:54:35 +0000
Subject: [PATCH 0770/1487] Make snapshotctl also log to logd.

Since http://r.android.com/2994274, snapshotctl can be run by init.
Therefore, we need it to log to logd for better debuggability.

Bug: 311377497
Test: adb shell setprop sys.snapshotctl.map requested
Test: adb shell setprop sys.snapshotctl.unmap requested
Change-Id: I287ecf77d45fb9e6c44bea36e14d2624029afea5
---
 fs_mgr/libsnapshot/snapshotctl.cpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 50e9f4823375..5d3f96cf952d 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -52,6 +52,9 @@
 using namespace std::chrono_literals;
 using namespace std::string_literals;
 using namespace android::storage_literals;
+using android::base::LogdLogger;
+using android::base::StderrLogger;
+using android::base::TeeLogger;
 using android::fs_mgr::CreateLogicalPartitionParams;
 using android::fs_mgr::FindPartition;
 using android::fs_mgr::GetPartitionSize;
@@ -461,23 +464,23 @@ bool MapSnapshots::DeleteSnapshots() {
 }
 
 bool DumpCmdHandler(int /*argc*/, char** argv) {
-    android::base::InitLogging(argv, &android::base::StderrLogger);
+    android::base::InitLogging(argv, TeeLogger(LogdLogger(), &StderrLogger));
     return SnapshotManager::New()->Dump(std::cout);
 }
 
 bool MapCmdHandler(int, char** argv) {
-    android::base::InitLogging(argv, &android::base::StderrLogger);
+    android::base::InitLogging(argv, TeeLogger(LogdLogger(), &StderrLogger));
     using namespace std::chrono_literals;
     return SnapshotManager::New()->MapAllSnapshots(5000ms);
 }
 
 bool UnmapCmdHandler(int, char** argv) {
-    android::base::InitLogging(argv, &android::base::StderrLogger);
+    android::base::InitLogging(argv, TeeLogger(LogdLogger(), &StderrLogger));
     return SnapshotManager::New()->UnmapAllSnapshots();
 }
 
 bool MergeCmdHandler(int /*argc*/, char** argv) {
-    android::base::InitLogging(argv, &android::base::StderrLogger);
+    android::base::InitLogging(argv, TeeLogger(LogdLogger(), &StderrLogger));
     LOG(WARNING) << "Deprecated. Call update_engine_client --merge instead.";
     return false;
 }

From f8292344cd802f81411b78ef2a2a73cab58d2d21 Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Sun, 10 Mar 2024 10:16:42 +0900
Subject: [PATCH 0771/1487] Define macros for LLNDK versioning

__INTRODUCED_IN_LLNDK(vendor_api_level) is for the LLNDK APIs
introduced in the vendor_api_level. It is ignored for non-vendor
modules.

API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) is used as a
statement for 'if' to guard the API callers. For example:

if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
  new_api_for_V_and_202404();
} else {
  fallback_function();
}

Bug: 302113279
Test: build trunk-staging and next configurations
Change-Id: I60d40655b1f8afdfa5c69b2ac4be2205f8057bea
---
 .../include_llndk/android/llndk-versioning.h  | 21 ++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/libvendorsupport/include_llndk/android/llndk-versioning.h b/libvendorsupport/include_llndk/android/llndk-versioning.h
index b375a2fa7093..b5001491df2e 100644
--- a/libvendorsupport/include_llndk/android/llndk-versioning.h
+++ b/libvendorsupport/include_llndk/android/llndk-versioning.h
@@ -32,18 +32,25 @@ __BEGIN_DECLS
                     "call with '#if (__ANDROID_VENDOR_API__ >= " #vendor_api_level ")'."))) \
             _Pragma("clang diagnostic pop")
 
-// For the vendor libraries, __INTRODUCED_IN must be ignored because they are only for NDKs but not
-// for LLNDKs.
-#undef __INTRODUCED_IN
-#define __INTRODUCED_IN(x)
+// Use this macro as an `if` statement to call an API that are available to both NDK and LLNDK.
+// This returns true for the vendor modules if the vendor_api_level is less than or equal to the
+// ro.board.api_level.
+#define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
+    constexpr(__ANDROID_VENDOR_API__ >= vendor_api_level)
 
 #else  // __ANDROID_VENDOR__
 
-// For non-vendor libraries, __INTRODUCED_IN_LLNDK must be ignored because it must not change
-// symbols of NDK or the system side of the treble boundary. It leaves a no-op annotation for ABI
-// analysis.
+// __INTRODUCED_IN_LLNDK is for LLNDK only but not for NDK. Ignore this for non-vendor modules.
+// It leaves a no-op annotation for ABI analysis.
+#if !defined(__INTRODUCED_IN_LLNDK)
 #define __INTRODUCED_IN_LLNDK(vendor_api_level) \
     __attribute__((annotate("introduced_in_llndk=" #vendor_api_level)))
+#endif
+
+// For non-vendor modules, API_LEVEL_AT_LEAST is replaced with __builtin_available(sdk_api_level) to
+// guard the API for __INTRODUCED_IN.
+#define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
+    (__builtin_available(android sdk_api_level, *))
 
 #endif  // __ANDROID_VENDOR__
 

From b46e5e6d0bb12cecc96a768ef7d88af437126596 Mon Sep 17 00:00:00 2001
From: Veena Arvind <aveena@google.com>
Date: Thu, 7 Mar 2024 22:55:28 +0000
Subject: [PATCH 0772/1487] Scan for quiescent in sub reason and details

Bug: 326526460
Test: manual (b/320369923#comment19)
Change-Id: I702841bf1afa6a04318b8233eb6ddb89c46b7ad5
---
 init/reboot.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/init/reboot.cpp b/init/reboot.cpp
index 1a26c4d3ccae..150f8f40e23c 100644
--- a/init/reboot.cpp
+++ b/init/reboot.cpp
@@ -1083,7 +1083,8 @@ void HandlePowerctlMessage(const std::string& command) {
                         return;
                     }
                 }
-            } else if (reboot_target == "quiescent") {
+            } else if (std::find(cmd_params.begin(), cmd_params.end(), "quiescent")
+                    != cmd_params.end()) { // Quiescent can be either subreason or details.
                 bootloader_message boot = {};
                 if (std::string err; !read_bootloader_message(&boot, &err)) {
                     LOG(ERROR) << "Failed to read bootloader message: " << err;

From 7f3fe0aaf286fa150878e7222593db2b38701ce1 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Mon, 11 Mar 2024 16:14:47 -0700
Subject: [PATCH 0773/1487] Make foreground and background I/O priority
 different

The default I/O priority is "best effort" so the combination of "none"
and "restrict-to-be" is not sufficient to make foreground and background
I/O priorities different. This CL makes sure that foreground and
background I/O priorities are different.

As one can see, this CL has the intended effect in Cuttlefish:
$ adb -s 0.0.0.0:6520 shell 'cd /dev/blkio && grep -aH . blkio.prio.class background/blkio.prio.class'
blkio.prio.class:promote-to-rt
background/blkio.prio.class:restrict-to-be

Bug: 186902601
Change-Id: I24d30d360280d8c398684b0b5e88635f658ff870
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 rootdir/init.rc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index bf34a9e66a89..ec203f91bfea 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -247,6 +247,7 @@ on init
     write /dev/blkio/background/blkio.bfq.weight 10
     write /dev/blkio/blkio.group_idle 0
     write /dev/blkio/background/blkio.group_idle 0
+    write /dev/blkio/blkio.prio.class promote-to-rt
     write /dev/blkio/background/blkio.prio.class restrict-to-be
 
     restorecon_recursive /mnt

From 2384e8abfe2fb6be64bd3670f4d3bef2e039db3f Mon Sep 17 00:00:00 2001
From: Nikita Ioffe <ioffe@google.com>
Date: Tue, 12 Mar 2024 15:34:11 +0000
Subject: [PATCH 0774/1487] Mount /microdroid_resources as tmpfs

This will be used to store the new dice chain generated during
first_stage_init phase in case Microdroid VM is launched with
microdroid vendor partition.

Bug: 287593065
Test: atest MicrodroidTests
Test: start Microdroid VM & check microdroid_resources exists
Change-Id: I40677376bfed14d813ad51c78db6109b2d76d1d1
---
 init/Android.bp           | 7 ++++++-
 init/first_stage_init.cpp | 8 +++++++-
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index c3abefe14955..419948454af0 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -162,6 +162,7 @@ libinit_cc_defaults {
     },
     static_libs: [
         "libavb",
+        "libavf_cc_flags",
         "libbootloader_message",
         "libc++fs",
         "libcgrouprc_format",
@@ -359,6 +360,7 @@ init_first_stage_cc_defaults {
     static_libs: [
         "libc++fs",
         "libfs_avb",
+        "libavf_cc_flags",
         "libfs_mgr",
         "libfec",
         "libfec_rs",
@@ -459,7 +461,10 @@ cc_binary {
 
 cc_binary {
     name: "init_first_stage.microdroid",
-    defaults: ["init_first_stage_defaults"],
+    defaults: [
+        "avf_build_flags_cc",
+        "init_first_stage_defaults"
+    ],
     cflags: ["-DMICRODROID=1"],
     installable: false,
 }
diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index c4d0f758dd2a..356aaa091ae7 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -37,6 +37,7 @@
 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
+#include <android/avf_cc_flags.h>
 #include <modprobe/modprobe.h>
 #include <private/android_filesystem_config.h>
 
@@ -385,7 +386,12 @@ int FirstStageMain(int argc, char** argv) {
     // /second_stage_resources is used to preserve files from first to second
     // stage init
     CHECKCALL(mount("tmpfs", kSecondStageRes, "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
-                    "mode=0755,uid=0,gid=0"))
+                    "mode=0755,uid=0,gid=0"));
+
+    if (IsMicrodroid() && android::virtualization::IsOpenDiceChangesFlagEnabled()) {
+        CHECKCALL(mount("tmpfs", "/microdroid_resources", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
+                        "mode=0750,uid=0,gid=0"));
+    }
 #undef CHECKCALL
 
     SetStdioToDevNull(argv);

From fe7b83faeaeabe3a445c81a92e1fa22537d36d7e Mon Sep 17 00:00:00 2001
From: Nikita Ioffe <ioffe@google.com>
Date: Mon, 4 Mar 2024 14:59:49 +0000
Subject: [PATCH 0775/1487] Move ForkExecveAndWaitForCompletion to util.h

In the follow up patch this function will also be used in
first_stage_init.

Bug: 287593065
Test: m
Change-Id: Id805f8523596c26ed262d89aa652b27184b612c1
---
 init/selinux.cpp | 91 -----------------------------------------------
 init/util.cpp    | 92 ++++++++++++++++++++++++++++++++++++++++++++++++
 init/util.h      |  5 +++
 3 files changed, 97 insertions(+), 91 deletions(-)

diff --git a/init/selinux.cpp b/init/selinux.cpp
index 1f211ddfa189..e191b60c00b7 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -111,97 +111,6 @@ bool IsEnforcing() {
     return true;
 }
 
-// Forks, executes the provided program in the child, and waits for the completion in the parent.
-// Child's stderr is captured and logged using LOG(ERROR).
-bool ForkExecveAndWaitForCompletion(const char* filename, char* const argv[]) {
-    // Create a pipe used for redirecting child process's output.
-    // * pipe_fds[0] is the FD the parent will use for reading.
-    // * pipe_fds[1] is the FD the child will use for writing.
-    int pipe_fds[2];
-    if (pipe(pipe_fds) == -1) {
-        PLOG(ERROR) << "Failed to create pipe";
-        return false;
-    }
-
-    pid_t child_pid = fork();
-    if (child_pid == -1) {
-        PLOG(ERROR) << "Failed to fork for " << filename;
-        return false;
-    }
-
-    if (child_pid == 0) {
-        // fork succeeded -- this is executing in the child process
-
-        // Close the pipe FD not used by this process
-        close(pipe_fds[0]);
-
-        // Redirect stderr to the pipe FD provided by the parent
-        if (TEMP_FAILURE_RETRY(dup2(pipe_fds[1], STDERR_FILENO)) == -1) {
-            PLOG(ERROR) << "Failed to redirect stderr of " << filename;
-            _exit(127);
-            return false;
-        }
-        close(pipe_fds[1]);
-
-        if (execv(filename, argv) == -1) {
-            PLOG(ERROR) << "Failed to execve " << filename;
-            return false;
-        }
-        // Unreachable because execve will have succeeded and replaced this code
-        // with child process's code.
-        _exit(127);
-        return false;
-    } else {
-        // fork succeeded -- this is executing in the original/parent process
-
-        // Close the pipe FD not used by this process
-        close(pipe_fds[1]);
-
-        // Log the redirected output of the child process.
-        // It's unfortunate that there's no standard way to obtain an istream for a file descriptor.
-        // As a result, we're buffering all output and logging it in one go at the end of the
-        // invocation, instead of logging it as it comes in.
-        const int child_out_fd = pipe_fds[0];
-        std::string child_output;
-        if (!android::base::ReadFdToString(child_out_fd, &child_output)) {
-            PLOG(ERROR) << "Failed to capture full output of " << filename;
-        }
-        close(child_out_fd);
-        if (!child_output.empty()) {
-            // Log captured output, line by line, because LOG expects to be invoked for each line
-            std::istringstream in(child_output);
-            std::string line;
-            while (std::getline(in, line)) {
-                LOG(ERROR) << filename << ": " << line;
-            }
-        }
-
-        // Wait for child to terminate
-        int status;
-        if (TEMP_FAILURE_RETRY(waitpid(child_pid, &status, 0)) != child_pid) {
-            PLOG(ERROR) << "Failed to wait for " << filename;
-            return false;
-        }
-
-        if (WIFEXITED(status)) {
-            int status_code = WEXITSTATUS(status);
-            if (status_code == 0) {
-                return true;
-            } else {
-                LOG(ERROR) << filename << " exited with status " << status_code;
-            }
-        } else if (WIFSIGNALED(status)) {
-            LOG(ERROR) << filename << " killed by signal " << WTERMSIG(status);
-        } else if (WIFSTOPPED(status)) {
-            LOG(ERROR) << filename << " stopped by signal " << WSTOPSIG(status);
-        } else {
-            LOG(ERROR) << "waitpid for " << filename << " returned unexpected status: " << status;
-        }
-
-        return false;
-    }
-}
-
 bool ReadFirstLine(const char* file, std::string* line) {
     line->clear();
 
diff --git a/init/util.cpp b/init/util.cpp
index e760a5969f5a..e5efc7da61bc 100644
--- a/init/util.cpp
+++ b/init/util.cpp
@@ -27,6 +27,7 @@
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/un.h>
+#include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
 
@@ -747,5 +748,96 @@ std::vector<std::string> FilterVersionedConfigs(const std::vector<std::string>&
     return filtered_configs;
 }
 
+// Forks, executes the provided program in the child, and waits for the completion in the parent.
+// Child's stderr is captured and logged using LOG(ERROR).
+bool ForkExecveAndWaitForCompletion(const char* filename, char* const argv[]) {
+    // Create a pipe used for redirecting child process's output.
+    // * pipe_fds[0] is the FD the parent will use for reading.
+    // * pipe_fds[1] is the FD the child will use for writing.
+    int pipe_fds[2];
+    if (pipe(pipe_fds) == -1) {
+        PLOG(ERROR) << "Failed to create pipe";
+        return false;
+    }
+
+    pid_t child_pid = fork();
+    if (child_pid == -1) {
+        PLOG(ERROR) << "Failed to fork for " << filename;
+        return false;
+    }
+
+    if (child_pid == 0) {
+        // fork succeeded -- this is executing in the child process
+
+        // Close the pipe FD not used by this process
+        close(pipe_fds[0]);
+
+        // Redirect stderr to the pipe FD provided by the parent
+        if (TEMP_FAILURE_RETRY(dup2(pipe_fds[1], STDERR_FILENO)) == -1) {
+            PLOG(ERROR) << "Failed to redirect stderr of " << filename;
+            _exit(127);
+            return false;
+        }
+        close(pipe_fds[1]);
+
+        if (execv(filename, argv) == -1) {
+            PLOG(ERROR) << "Failed to execve " << filename;
+            return false;
+        }
+        // Unreachable because execve will have succeeded and replaced this code
+        // with child process's code.
+        _exit(127);
+        return false;
+    } else {
+        // fork succeeded -- this is executing in the original/parent process
+
+        // Close the pipe FD not used by this process
+        close(pipe_fds[1]);
+
+        // Log the redirected output of the child process.
+        // It's unfortunate that there's no standard way to obtain an istream for a file descriptor.
+        // As a result, we're buffering all output and logging it in one go at the end of the
+        // invocation, instead of logging it as it comes in.
+        const int child_out_fd = pipe_fds[0];
+        std::string child_output;
+        if (!android::base::ReadFdToString(child_out_fd, &child_output)) {
+            PLOG(ERROR) << "Failed to capture full output of " << filename;
+        }
+        close(child_out_fd);
+        if (!child_output.empty()) {
+            // Log captured output, line by line, because LOG expects to be invoked for each line
+            std::istringstream in(child_output);
+            std::string line;
+            while (std::getline(in, line)) {
+                LOG(ERROR) << filename << ": " << line;
+            }
+        }
+
+        // Wait for child to terminate
+        int status;
+        if (TEMP_FAILURE_RETRY(waitpid(child_pid, &status, 0)) != child_pid) {
+            PLOG(ERROR) << "Failed to wait for " << filename;
+            return false;
+        }
+
+        if (WIFEXITED(status)) {
+            int status_code = WEXITSTATUS(status);
+            if (status_code == 0) {
+                return true;
+            } else {
+                LOG(ERROR) << filename << " exited with status " << status_code;
+            }
+        } else if (WIFSIGNALED(status)) {
+            LOG(ERROR) << filename << " killed by signal " << WTERMSIG(status);
+        } else if (WIFSTOPPED(status)) {
+            LOG(ERROR) << filename << " stopped by signal " << WSTOPSIG(status);
+        } else {
+            LOG(ERROR) << "waitpid for " << filename << " returned unexpected status: " << status;
+        }
+
+        return false;
+    }
+}
+
 }  // namespace init
 }  // namespace android
diff --git a/init/util.h b/init/util.h
index 2d021827165f..aa24123dfc9f 100644
--- a/init/util.h
+++ b/init/util.h
@@ -117,5 +117,10 @@ std::string GetApexNameFromFileName(const std::string& path);
 // (.rc == .0rc for ranking purposes)
 std::vector<std::string> FilterVersionedConfigs(const std::vector<std::string>& configs,
                                                   int active_sdk);
+
+// Forks, executes the provided program in the child, and waits for the completion in the parent.
+// Child's stderr is captured and logged using LOG(ERROR).
+bool ForkExecveAndWaitForCompletion(const char* filename, char* const argv[]);
+
 }  // namespace init
 }  // namespace android

From 1e114e677b7196c0b48502f5f53fa32ae76a8a0a Mon Sep 17 00:00:00 2001
From: Nikita Ioffe <ioffe@google.com>
Date: Tue, 5 Mar 2024 00:23:31 +0000
Subject: [PATCH 0776/1487] Add a step to derive microdroid vendor dice node

The derivation happens in the derive_microdroid_vendor_dice_node binary
which first_stage_init forks and execvs.

Since the derivation requires talking to the dice driver, its
initialisation is also moved to the first stage init.

The derivation happens before the microdroid vendor partition is
verified & mounted. This should be safe because the first_stage_init
will fail the boot if the verification of the microdroid vendor
partition fails.

Bug: 287593065
Test: run microdroid with and without vendor partition
Test: atest MicrodroidTests
Change-Id: I0d83772eb98a56c315617e66ec64bd03639cfde6
---
 init/Android.bp                |  2 +-
 init/block_dev_initializer.cpp | 18 ++++++++----
 init/block_dev_initializer.h   |  3 ++
 init/first_stage_mount.cpp     | 54 ++++++++++++++++++++++++++++++++++
 4 files changed, 71 insertions(+), 6 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index 419948454af0..12ca15ae346b 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -463,7 +463,7 @@ cc_binary {
     name: "init_first_stage.microdroid",
     defaults: [
         "avf_build_flags_cc",
-        "init_first_stage_defaults"
+        "init_first_stage_defaults",
     ],
     cflags: ["-DMICRODROID=1"],
     installable: false,
diff --git a/init/block_dev_initializer.cpp b/init/block_dev_initializer.cpp
index 05e00edfda22..a686d05131c7 100644
--- a/init/block_dev_initializer.cpp
+++ b/init/block_dev_initializer.cpp
@@ -132,11 +132,19 @@ bool BlockDevInitializer::InitDevices(std::set<std::string> devices) {
 bool BlockDevInitializer::InitDmDevice(const std::string& device) {
     const std::string device_name(basename(device.c_str()));
     const std::string syspath = "/sys/block/" + device_name;
+    return InitDevice(syspath, device_name);
+}
+
+bool BlockDevInitializer::InitPlatformDevice(const std::string& dev_name) {
+    return InitDevice("/sys/devices/platform", dev_name);
+}
+
+bool BlockDevInitializer::InitDevice(const std::string& syspath, const std::string& device_name) {
     bool found = false;
 
-    auto uevent_callback = [&device_name, &device, this, &found](const Uevent& uevent) {
+    auto uevent_callback = [&device_name, this, &found](const Uevent& uevent) {
         if (uevent.device_name == device_name) {
-            LOG(VERBOSE) << "Creating device-mapper device : " << device;
+            LOG(VERBOSE) << "Creating device : " << device_name;
             device_handler_->HandleUevent(uevent);
             found = true;
             return ListenerAction::kStop;
@@ -146,13 +154,13 @@ bool BlockDevInitializer::InitDmDevice(const std::string& device) {
 
     uevent_listener_.RegenerateUeventsForPath(syspath, uevent_callback);
     if (!found) {
-        LOG(INFO) << "dm device '" << device << "' not found in /sys, waiting for its uevent";
+        LOG(INFO) << "device '" << device_name << "' not found in /sys, waiting for its uevent";
         Timer t;
         uevent_listener_.Poll(uevent_callback, 10s);
-        LOG(INFO) << "wait for dm device '" << device << "' returned after " << t;
+        LOG(INFO) << "wait for device '" << device_name << "' returned after " << t;
     }
     if (!found) {
-        LOG(ERROR) << "dm device '" << device << "' not found after polling timeout";
+        LOG(ERROR) << "device '" << device_name << "' not found after polling timeout";
         return false;
     }
     return true;
diff --git a/init/block_dev_initializer.h b/init/block_dev_initializer.h
index ec39ce084d10..d5b1f6006449 100644
--- a/init/block_dev_initializer.h
+++ b/init/block_dev_initializer.h
@@ -24,6 +24,7 @@
 namespace android {
 namespace init {
 
+// TODO: should this be renamed to FirstStageDevInitialize?
 class BlockDevInitializer final {
   public:
     BlockDevInitializer();
@@ -32,11 +33,13 @@ class BlockDevInitializer final {
     bool InitDmUser(const std::string& name);
     bool InitDevices(std::set<std::string> devices);
     bool InitDmDevice(const std::string& device);
+    bool InitPlatformDevice(const std::string& device);
 
   private:
     ListenerAction HandleUevent(const Uevent& uevent, std::set<std::string>* devices);
 
     bool InitMiscDevice(const std::string& name);
+    bool InitDevice(const std::string& syspath, const std::string& device);
 
     std::unique_ptr<DeviceHandler> device_handler_;
     UeventListener uevent_listener_;
diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index c0b928139a15..836d536c9a6e 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -16,6 +16,7 @@
 
 #include "first_stage_mount.h"
 
+#include <signal.h>
 #include <stdlib.h>
 #include <sys/mount.h>
 #include <unistd.h>
@@ -33,6 +34,7 @@
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
+#include <android/avf_cc_flags.h>
 #include <fs_avb/fs_avb.h>
 #include <fs_mgr.h>
 #include <fs_mgr_dm_linear.h>
@@ -272,6 +274,11 @@ bool FirstStageMountVBootV2::DoFirstStageMount() {
     return true;
 }
 
+// TODO: should this be in a library in packages/modules/Virtualization first_stage_init links?
+static bool IsMicrodroidStrictBoot() {
+    return access("/proc/device-tree/chosen/avf,strict-boot", F_OK) == 0;
+}
+
 bool FirstStageMountVBootV2::InitDevices() {
     std::set<std::string> devices;
     GetSuperDeviceName(&devices);
@@ -283,6 +290,14 @@ bool FirstStageMountVBootV2::InitDevices() {
         return false;
     }
 
+    if (IsMicrodroid() && android::virtualization::IsOpenDiceChangesFlagEnabled()) {
+        if (IsMicrodroidStrictBoot()) {
+            if (!block_dev_init_.InitPlatformDevice("open-dice0")) {
+                return false;
+            }
+        }
+    }
+
     if (IsDmLinearEnabled()) {
         auto super_symlink = "/dev/block/by-name/"s + super_partition_name_;
         if (!android::base::Realpath(super_symlink, &super_path_)) {
@@ -527,9 +542,48 @@ bool FirstStageMountVBootV2::TrySwitchSystemAsRoot() {
     return true;
 }
 
+static bool MaybeDeriveMicrodroidVendorDiceNode(Fstab* fstab) {
+    std::optional<std::string> microdroid_vendor_block_dev;
+    for (auto entry = fstab->begin(); entry != fstab->end(); entry++) {
+        if (entry->mount_point == "/vendor") {
+            microdroid_vendor_block_dev.emplace(entry->blk_device);
+            break;
+        }
+    }
+    if (!microdroid_vendor_block_dev.has_value()) {
+        LOG(VERBOSE) << "No microdroid vendor partition to mount";
+        return true;
+    }
+    // clang-format off
+    const std::array<const char*, 7> args = {
+        "/system/bin/derive_microdroid_vendor_dice_node",
+                "--dice-driver", "/dev/open-dice0",
+                "--microdroid-vendor-disk-image", microdroid_vendor_block_dev->data(),
+                "--output", "/microdroid_resources/dice_chain.raw",
+    };
+    // clang-format-on
+    // ForkExecveAndWaitForCompletion calls waitpid to wait for the fork-ed process to finish.
+    // The first_stage_console adds SA_NOCLDWAIT flag to the SIGCHLD handler, which means that
+    // waitpid will always return -ECHLD. Here we re-register a default handler, so that waitpid
+    // works.
+    LOG(INFO) << "Deriving dice node for microdroid vendor partition";
+    signal(SIGCHLD, SIG_DFL);
+    if (!ForkExecveAndWaitForCompletion(args[0], (char**)args.data())) {
+        LOG(ERROR) << "Failed to derive microdroid vendor dice node";
+        return false;
+    }
+    return true;
+}
+
 bool FirstStageMountVBootV2::MountPartitions() {
     if (!TrySwitchSystemAsRoot()) return false;
 
+    if (IsMicrodroid() && android::virtualization::IsOpenDiceChangesFlagEnabled()) {
+        if (!MaybeDeriveMicrodroidVendorDiceNode(&fstab_)) {
+            return false;
+        }
+    }
+
     if (!SkipMountingPartitions(&fstab_, true /* verbose */)) return false;
 
     for (auto current = fstab_.begin(); current != fstab_.end();) {

From 07afcabf67c4311e08309263c842ca94ccbbe5ee Mon Sep 17 00:00:00 2001
From: Dennis Shen <dzshen@google.com>
Date: Wed, 13 Mar 2024 19:16:29 +0000
Subject: [PATCH 0777/1487] start aconfig storage daemon

Bug: b/312444587
Test: m and launch AVD
Change-Id: I92946fc4ec2100d995300c58ef6045ae5b40f13a
---
 rootdir/init.rc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 164d41158090..2b29e7d25514 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -644,6 +644,7 @@ on post-fs
     mkdir /metadata/aconfig 0775 root system
     mkdir /metadata/aconfig/flags 0770 root system
     mkdir /metadata/aconfig/boot 0775 root system
+    exec_start aconfigd
 
 on late-fs
     # Ensure that tracefs has the correct permissions.

From da960a134122668a36ac6f740e5405e858cd3641 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 8 Feb 2024 10:52:18 -0800
Subject: [PATCH 0778/1487] libsnapshot: remove temporary solution

Remove temporary estimation solution (using 4k to overestimate the cow).
With the updated estimation logic, we should be able to accurately
estimate the cow size with variable block sized compression

Bug: 322279333
Test: th
Change-Id: I199970048605a8d21d3791614ad88ca61662e1a3
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index de2e528339a2..765da9b4411a 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -214,15 +214,6 @@ bool CowWriterV3::Initialize(std::optional<uint64_t> label) {
             return false;
         }
     }
-
-    // TODO: b/322279333
-    // Set compression factor to 4k during estimation.
-    // Once COW estimator is ready to support variable
-    // block size, this check has to be removed.
-    if (IsEstimating()) {
-        header_.max_compression_size = header_.block_size;
-    }
-
     return true;
 }
 

From 9ce8219f525c0d71451c6185ac91dc8404d51449 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 21 Feb 2024 13:04:39 -0800
Subject: [PATCH 0779/1487] libsnapshot: fix warnings

Fix unused header warning

Test: th
Change-Id: I5c9f22f3f74d6ca44e738e1dc8e9fe146749857f
---
 fs_mgr/libsnapshot/snapshot.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index e6c4de6234c1..1738f7ebdfb4 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -24,7 +24,6 @@
 #include <filesystem>
 #include <optional>
 #include <thread>
-#include <unordered_set>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
@@ -46,7 +45,6 @@
 #include <android/snapshot/snapshot.pb.h>
 #include <libsnapshot/snapshot_stats.h>
 #include "device_info.h"
-#include "libsnapshot_cow/parser_v2.h"
 #include "partition_cow_creator.h"
 #include "snapshot_metadata_updater.h"
 #include "utility.h"
@@ -3246,7 +3244,7 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
             compression_algorithm = "gz";
         }
         LOG(INFO) << "using compression algorithm: " << compression_algorithm
-                   << ", max compressible block size: " << compression_factor;
+                  << ", max compressible block size: " << compression_factor;
     }
 
     PartitionCowCreator cow_creator{

From 3652004432183f32b6e8a778bf0f6dddc8da8879 Mon Sep 17 00:00:00 2001
From: Jeongik Cha <jeongik@google.com>
Date: Wed, 24 Jan 2024 16:33:43 +0900
Subject: [PATCH 0780/1487] Declare init.*.rc modules in Android.bp

Bug: 322088967
Test: build
Change-Id: Idd8cc0a9fdbcda1d8129056efc0afadc663b955b
---
 rootdir/Android.bp | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index c8a3cd61cf28..6a3484e20253 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -71,3 +71,33 @@ prebuilt_root {
     src: "adb_debug.prop",
     debug_ramdisk: true,
 }
+
+prebuilt_etc {
+    name: "init.zygote64.rc",
+    src: "init.zygote64.rc",
+    sub_dir: "init/hw",
+}
+
+prebuilt_etc {
+    name: "init.zygote32.rc",
+    src: "init.zygote32.rc",
+    sub_dir: "init/hw",
+}
+
+prebuilt_etc {
+    name: "init.zygote64_32.rc",
+    src: "init.zygote64_32.rc",
+    sub_dir: "init/hw",
+}
+
+prebuilt_etc {
+    name: "init.usb.rc",
+    src: "init.usb.rc",
+    sub_dir: "init/hw",
+}
+
+prebuilt_etc {
+    name: "init.usb.configfs.rc",
+    src: "init.usb.configfs.rc",
+    sub_dir: "init/hw",
+}

From eaf7d77e7e36f6afd706d87775ac88db38485e0f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Krzysztof=20Kosi=C5=84ski?= <krzysio@google.com>
Date: Fri, 15 Mar 2024 06:43:54 +0000
Subject: [PATCH 0781/1487] Add missing header.

Protobuf 22.x no longer includes <unordered_map>, so it has to
be included explicitly.

Bug: 329747255
Test: presubmit
Change-Id: Icd5055e242e4f58029caf80cbb321222c612a9d0
---
 init/persistent_properties.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/init/persistent_properties.cpp b/init/persistent_properties.cpp
index 6f8a4de93d3c..59e57b95f620 100644
--- a/init/persistent_properties.cpp
+++ b/init/persistent_properties.cpp
@@ -23,6 +23,7 @@
 #include <sys/types.h>
 
 #include <memory>
+#include <unordered_map>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>

From ad8cf52c4c2b60250d52f1b0b90648fdf407dff4 Mon Sep 17 00:00:00 2001
From: Kiyoung Kim <kiyoungkim@google.com>
Date: Mon, 11 Mar 2024 13:04:38 +0900
Subject: [PATCH 0782/1487] Remove VNDK definition(s)

As of VNDK deprecation, any libraries that defines vndk is no longer
valid anymore. This change removes all VNDK definition(s) from modules
which was VNDK. Any former VNDK-SP libraries will be marked as double-loadable,
so it can keep be able to be referenced by LLNDK libraries.

Bug: 328994089
Test: AOSP CF build succeeded
Change-Id: I1662f16e5e446bb28167b0bb278cd63997267d2a
---
 libcrypto_utils/Android.bp |  3 ---
 libcutils/Android.bp       |  5 +----
 libnetutils/Android.bp     |  3 ---
 libprocessgroup/Android.bp |  5 +----
 libsysutils/Android.bp     |  3 ---
 libusbhost/Android.bp      |  3 ---
 libutils/Android.bp        | 10 ++--------
 7 files changed, 4 insertions(+), 28 deletions(-)

diff --git a/libcrypto_utils/Android.bp b/libcrypto_utils/Android.bp
index 2559137d9b19..b2af06c97df6 100644
--- a/libcrypto_utils/Android.bp
+++ b/libcrypto_utils/Android.bp
@@ -24,9 +24,6 @@ cc_library {
     ramdisk_available: true,
     vendor_ramdisk_available: true,
     recovery_available: true,
-    vndk: {
-        enabled: true,
-    },
     host_supported: true,
     srcs: [
         "android_pubkey.cpp",
diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index b7752d902a71..e2975813ced1 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -129,10 +129,7 @@ libcutils_nonwindows_sources = [
 cc_library {
     name: "libcutils",
     defaults: ["libcutils_defaults"],
-    vndk: {
-        enabled: true,
-        support_system_process: true,
-    },
+    double_loadable: true,
     srcs: [
         "config_utils.cpp",
         "iosched_policy.cpp",
diff --git a/libnetutils/Android.bp b/libnetutils/Android.bp
index 02bd2e3dcc5d..0bca6620948a 100644
--- a/libnetutils/Android.bp
+++ b/libnetutils/Android.bp
@@ -18,9 +18,6 @@ license {
 cc_library_shared {
     name: "libnetutils",
     vendor_available: true,
-    vndk: {
-        enabled: true,
-    },
 
     srcs: [
         "dhcpclient.c",
diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index c6a073789ba8..a52fb6720c16 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -53,10 +53,7 @@ cc_library {
     recovery_available: true,
     vendor_available: true,
     product_available: true,
-    vndk: {
-        enabled: true,
-        support_system_process: true,
-    },
+    double_loadable: true,
     shared_libs: [
         "libbase",
         "libcgrouprc",
diff --git a/libsysutils/Android.bp b/libsysutils/Android.bp
index 1b41a6b177cf..842db4033b61 100644
--- a/libsysutils/Android.bp
+++ b/libsysutils/Android.bp
@@ -5,9 +5,6 @@ package {
 cc_library {
     name: "libsysutils",
     vendor_available: true,
-    vndk: {
-        enabled: true,
-    },
 
     srcs: [
         "src/SocketListener.cpp",
diff --git a/libusbhost/Android.bp b/libusbhost/Android.bp
index 9ae73d0d81aa..f8a73ad18be4 100644
--- a/libusbhost/Android.bp
+++ b/libusbhost/Android.bp
@@ -21,9 +21,6 @@ package {
 cc_library {
     name: "libusbhost",
     vendor_available: true,
-    vndk: {
-        enabled: true,
-    },
     host_supported: true,
     srcs: ["usbhost.c"],
     cflags: ["-Werror"],
diff --git a/libutils/Android.bp b/libutils/Android.bp
index ad5b752e3b1e..6c0df6f7597c 100644
--- a/libutils/Android.bp
+++ b/libutils/Android.bp
@@ -183,10 +183,7 @@ cc_library {
     name: "libutils",
     defaults: ["libutils_impl_defaults"],
 
-    vndk: {
-        enabled: true,
-        support_system_process: true,
-    },
+    double_loadable: true,
 
     target: {
         product: {
@@ -228,10 +225,7 @@ cc_library {
     // TODO(b/153609531): remove when no longer needed.
     native_bridge_supported: true,
     min_sdk_version: "29",
-    vndk: {
-        enabled: true,
-        support_system_process: true,
-    },
+    double_loadable: true,
 
     header_libs: [
         "libbase_headers",

From 47f9182e49355b0c1ea708b7ac8facd7ae1e027f Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Fri, 15 Mar 2024 22:51:59 +0900
Subject: [PATCH 0783/1487] Remove bionic dependency from llndk-versioning.h

llndk-versioning.h only defines macros for LLNDK versioning.
Remove unused bionic header.

Bug: 302113279
Test: lunch cf_x86_64-trunk_staging-userdebug && m && m cts
Change-Id: I8d3ebbd765a223a2241e1a0bc95c84d726bacb9d
---
 .../include_llndk/android/llndk-versioning.h             | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/libvendorsupport/include_llndk/android/llndk-versioning.h b/libvendorsupport/include_llndk/android/llndk-versioning.h
index b5001491df2e..8ae56d4c5362 100644
--- a/libvendorsupport/include_llndk/android/llndk-versioning.h
+++ b/libvendorsupport/include_llndk/android/llndk-versioning.h
@@ -14,10 +14,9 @@
 
 #pragma once
 
-#include <sys/cdefs.h>
-
-__BEGIN_DECLS
-
+/* As a vendor default header included in all vendor modules, this header MUST NOT include other
+ * header files or any declarations. Only macros are allowed.
+ */
 #if defined(__ANDROID_VENDOR__)
 
 // LLNDK (https://source.android.com/docs/core/architecture/vndk/build-system#ll-ndk) is similar to
@@ -53,5 +52,3 @@ __BEGIN_DECLS
     (__builtin_available(android sdk_api_level, *))
 
 #endif  // __ANDROID_VENDOR__
-
-__END_DECLS

From 71179955f7e077a5515480033e00e8a8da0ee78a Mon Sep 17 00:00:00 2001
From: Android Culprit Assistant
 <boq-android-culprit-assistant@system.gserviceaccount.com>
Date: Fri, 15 Mar 2024 19:06:14 +0000
Subject: [PATCH 0784/1487] Revert "start aconfig storage daemon"

This revert was created by Android Culprit Assistant. The culprit was identified in the following culprit search session (http://go/aca-get/2def2bc9-4177-4451-930d-96612adf7d95).

Change-Id: I232a36309883bff892fff5a5d43fd1432d7f1c6e
---
 rootdir/init.rc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 2b29e7d25514..164d41158090 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -644,7 +644,6 @@ on post-fs
     mkdir /metadata/aconfig 0775 root system
     mkdir /metadata/aconfig/flags 0770 root system
     mkdir /metadata/aconfig/boot 0775 root system
-    exec_start aconfigd
 
 on late-fs
     # Ensure that tracefs has the correct permissions.

From 7c4beee9f9ea17fb896ebcdd4789c60ccfb17fab Mon Sep 17 00:00:00 2001
From: Michael Hoisie <hoisie@google.com>
Date: Fri, 12 Jan 2024 19:18:19 +0000
Subject: [PATCH 0785/1487] Add support for ashmem-host for host Windows

Migrate to tmpfile and fileno for temp file operations. These calls are
supported on MinGW, and the temp files are automatically cleaned up.

A Windows variant of ashmem-host is needed to support CursorWindows on
host Windows.

In Windows, it is not possible to unlink an open file, so the nlink
check in ashmem_validate_stat must be made Unix-only.

Test: SQLiteDatabaseTest in Google3
Test: libcutils_test_static on Windows

Bug: 317884162
Change-Id: I7fc0f1f49406b01549b7f4d7e138cb3e4d79be72
---
 libcutils/Android.bp           | 37 +++++++++++---------
 libcutils/ashmem-host.cpp      | 55 ++++++++++++++++++-----------
 libcutils/ashmem_base_test.cpp | 63 ++++++++++++++++++++++++++++++++++
 libcutils/ashmem_test.cpp      | 22 ------------
 libcutils/sockets_test.cpp     |  2 --
 5 files changed, 118 insertions(+), 61 deletions(-)
 create mode 100644 libcutils/ashmem_base_test.cpp

diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index b7752d902a71..862af841c2f5 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -156,23 +156,18 @@ cc_library {
                 "fs_config.cpp",
             ],
         },
-        not_windows: {
-            srcs: libcutils_nonwindows_sources + [
-                "ashmem-host.cpp",
+        host: {
+            srcs: [
                 "trace-host.cpp",
+                "ashmem-host.cpp",
             ],
         },
+        not_windows: {
+            srcs: libcutils_nonwindows_sources,
+        },
         windows: {
-            host_ldlibs: ["-lws2_32"],
-
-            srcs: [
-                "trace-host.cpp",
-            ],
-
             enabled: true,
-            cflags: [
-                "-D_GNU_SOURCE",
-            ],
+            host_ldlibs: ["-lws2_32"],
         },
         android: {
             sanitize: {
@@ -241,6 +236,7 @@ cc_library {
 cc_defaults {
     name: "libcutils_test_default",
     srcs: [
+        "ashmem_base_test.cpp",
         "native_handle_test.cpp",
         "properties_test.cpp",
         "sockets_test.cpp",
@@ -299,20 +295,26 @@ cc_test {
 cc_defaults {
     name: "libcutils_test_static_defaults",
     defaults: ["libcutils_test_default"],
-    static_libs: [
-        "libc",
-        "libcgrouprc_format",
-    ] + test_libraries + always_static_test_libraries,
     stl: "libc++_static",
     require_root: true,
 
     target: {
         android: {
             static_executable: true,
+            static_libs: [
+                "libcgrouprc_format",
+            ] + test_libraries + always_static_test_libraries,
+        },
+        not_windows: {
+            static_libs: test_libraries + always_static_test_libraries,
         },
         windows: {
+            static_libs: [
+                "libbase",
+                "libcutils",
+                "libcutils_sockets",
+            ],
             host_ldlibs: ["-lws2_32"],
-
             enabled: true,
         },
     },
@@ -320,6 +322,7 @@ cc_defaults {
 
 cc_test {
     name: "libcutils_test_static",
+    host_supported: true,
     test_suites: ["device-tests"],
     defaults: ["libcutils_test_static_defaults"],
 }
diff --git a/libcutils/ashmem-host.cpp b/libcutils/ashmem-host.cpp
index 2ba1eb0c37ba..9003b76c9acf 100644
--- a/libcutils/ashmem-host.cpp
+++ b/libcutils/ashmem-host.cpp
@@ -17,10 +17,13 @@
 #include <cutils/ashmem.h>
 
 /*
- * Implementation of the user-space ashmem API for the simulator, which lacks
- * an ashmem-enabled kernel. See ashmem-dev.c for the real ashmem-based version.
+ * Implementation of the user-space ashmem API for the simulator, which lacks an
+ * ashmem-enabled kernel. See ashmem-dev.c for the real ashmem-based version.  A
+ * disk-backed temp file is the best option that is consistently supported
+ * across all host platforms.
  */
 
+#include <android-base/unique_fd.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
@@ -31,8 +34,10 @@
 #include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
-
 #include <utils/Compat.h>
+#include <memory>
+
+using android::base::unique_fd;
 
 static bool ashmem_validate_stat(int fd, struct stat* buf) {
     int result = fstat(fd, buf);
@@ -40,15 +45,20 @@ static bool ashmem_validate_stat(int fd, struct stat* buf) {
         return false;
     }
 
-    /*
-     * Check if this is an "ashmem" region.
-     * TODO: This is very hacky, and can easily break.
-     * We need some reliable indicator.
-     */
-    if (!(buf->st_nlink == 0 && S_ISREG(buf->st_mode))) {
+    // Check if this is an ashmem region. Since there's no such thing on the host,
+    // we can't actually implement that. Check that it's at least a regular file.
+    if (!S_ISREG(buf->st_mode)) {
         errno = ENOTTY;
         return false;
     }
+    // In Win32, unlike Unix, the temp file is not unlinked immediately after
+    // creation.
+#if !defined(_WIN32)
+    if (buf->st_nlink != 0) {
+        errno = ENOTTY;
+        return false;
+    }
+#endif
     return true;
 }
 
@@ -58,19 +68,24 @@ int ashmem_valid(int fd) {
 }
 
 int ashmem_create_region(const char* /*ignored*/, size_t size) {
-    char pattern[PATH_MAX];
-    snprintf(pattern, sizeof(pattern), "/tmp/android-ashmem-%d-XXXXXXXXX", getpid());
-    int fd = mkstemp(pattern);
-    if (fd == -1) return -1;
-
-    unlink(pattern);
+    // Files returned by tmpfile are automatically removed.
+    std::unique_ptr<FILE, decltype(&fclose)> tmp(tmpfile(), &fclose);
 
-    if (TEMP_FAILURE_RETRY(ftruncate(fd, size)) == -1) {
-      close(fd);
-      return -1;
+    if (!tmp) {
+        return -1;
     }
-
-    return fd;
+    int fd = fileno(tmp.get());
+    if (fd == -1) {
+        return -1;
+    }
+    unique_fd dupfd = unique_fd(dup(fd));
+    if (dupfd == -1) {
+        return -1;
+    }
+    if (TEMP_FAILURE_RETRY(ftruncate(dupfd, size)) == -1) {
+        return -1;
+    }
+    return dupfd.release();
 }
 
 int ashmem_set_prot_region(int /*fd*/, int /*prot*/) {
diff --git a/libcutils/ashmem_base_test.cpp b/libcutils/ashmem_base_test.cpp
new file mode 100644
index 000000000000..c9b14e58335e
--- /dev/null
+++ b/libcutils/ashmem_base_test.cpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <unistd.h>
+
+#include <android-base/mapped_file.h>
+#include <android-base/unique_fd.h>
+#include <cutils/ashmem.h>
+
+/*
+ * Tests in AshmemBaseTest are designed to run on Android as well as host
+ * platforms (Linux, Mac, Windows).
+ */
+
+#if defined(_WIN32)
+static inline size_t getpagesize() {
+    return 4096;
+}
+#endif
+
+using android::base::unique_fd;
+
+TEST(AshmemBaseTest, BasicTest) {
+    const size_t size = getpagesize();
+    std::vector<uint8_t> data(size);
+    std::generate(data.begin(), data.end(), [n = 0]() mutable { return n++ & 0xFF; });
+
+    unique_fd fd = unique_fd(ashmem_create_region(nullptr, size));
+    ASSERT_TRUE(fd >= 0);
+    ASSERT_TRUE(ashmem_valid(fd));
+    ASSERT_EQ(size, static_cast<size_t>(ashmem_get_size_region(fd)));
+
+    std::unique_ptr<android::base::MappedFile> mapped =
+            android::base::MappedFile::FromFd(fd, 0, size, PROT_READ | PROT_WRITE);
+    EXPECT_TRUE(mapped.get() != nullptr);
+    void* region1 = mapped->data();
+    EXPECT_TRUE(region1 != nullptr);
+
+    memcpy(region1, data.data(), size);
+    ASSERT_EQ(0, memcmp(region1, data.data(), size));
+
+    std::unique_ptr<android::base::MappedFile> mapped2 =
+            android::base::MappedFile::FromFd(fd, 0, size, PROT_READ | PROT_WRITE);
+    EXPECT_TRUE(mapped2.get() != nullptr);
+    void* region2 = mapped2->data();
+    EXPECT_TRUE(region2 != nullptr);
+    ASSERT_EQ(0, memcmp(region2, data.data(), size));
+}
diff --git a/libcutils/ashmem_test.cpp b/libcutils/ashmem_test.cpp
index 571b41000fa2..ccbb8c97760f 100644
--- a/libcutils/ashmem_test.cpp
+++ b/libcutils/ashmem_test.cpp
@@ -69,28 +69,6 @@ void FillData(std::vector<uint8_t>& data) {
     }
 }
 
-TEST(AshmemTest, BasicTest) {
-    const size_t size = getpagesize();
-    std::vector<uint8_t> data(size);
-    FillData(data);
-
-    unique_fd fd;
-    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
-
-    void* region1 = nullptr;
-    ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ | PROT_WRITE, &region1));
-
-    memcpy(region1, data.data(), size);
-    ASSERT_EQ(0, memcmp(region1, data.data(), size));
-
-    EXPECT_EQ(0, munmap(region1, size));
-
-    void *region2;
-    ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ, &region2));
-    ASSERT_EQ(0, memcmp(region2, data.data(), size));
-    EXPECT_EQ(0, munmap(region2, size));
-}
-
 TEST(AshmemTest, ForkTest) {
     const size_t size = getpagesize();
     std::vector<uint8_t> data(size);
diff --git a/libcutils/sockets_test.cpp b/libcutils/sockets_test.cpp
index 1fa40bc6a8ee..f6f9c3628830 100644
--- a/libcutils/sockets_test.cpp
+++ b/libcutils/sockets_test.cpp
@@ -19,8 +19,6 @@
 // should be the case for loopback communication, but is not guaranteed.
 
 #include <string.h>
-#include <sys/socket.h>
-#include <sys/types.h>
 #include <time.h>
 
 #include <cutils/sockets.h>

From 7d400f9d8c22ae08358d4f05282b9dcec52d91b0 Mon Sep 17 00:00:00 2001
From: Will McVicker <willmcvicker@google.com>
Date: Thu, 7 Mar 2024 11:18:41 -0800
Subject: [PATCH 0786/1487] toolbox/modprobe: Use libmodprobe to load modules
 from FILE

When a file is provided (via --all=FILE), let's use libmodprobe to load
the modules. This let's us use the logic in libmodprobe to parse the
provided modules load file -- FILE. The functional differences include:

 - Removes the FILE parsing logic in modprobe.
 - Returns early if FILE doesn't exist.
 - Adds Dirname(FILE) to mod_dirs which means libmodprobe will parse the
   modules.* files inside Dirname(FILE). Previously, modprobe would only
   parse the modules.* files in the mod_dirs passed in by `-d DIR`. If
   no directories were provided, we would fallback to the default
   /lib/modules path. This patch removes the mod_dirs.empty() fallback
   path when --all=FILE is used. It's unlikely anyone uses `--all=FILE`
   without `-d DIR` unless FILE is inside the fallback path --
   /lib/modules.

Test: verified lsmod on pixel 6
Bug: 324018983
Change-Id: I8d241832f2a1f18d14207e3e3777e015c1ddb25f
---
 toolbox/modprobe.cpp | 36 ++++++++++++++++++++++++------------
 1 file changed, 24 insertions(+), 12 deletions(-)

diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index 56cf140e1531..45dd9b8c18d9 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -112,6 +112,7 @@ extern "C" int modprobe_main(int argc, char** argv) {
     android::base::SetMinimumLogSeverity(android::base::INFO);
 
     std::vector<std::string> modules;
+    std::string modules_load_file;
     std::string module_parameters;
     std::string mods;
     std::vector<std::string> mod_dirs;
@@ -119,7 +120,7 @@ extern "C" int modprobe_main(int argc, char** argv) {
     bool blocklist = false;
     int rv = EXIT_SUCCESS;
 
-    int opt;
+    int opt, fd;
     int option_index = 0;
     // NB: We have non-standard short options -l and -D to make it easier for
     // OEMs to transition from toybox.
@@ -144,16 +145,19 @@ extern "C" int modprobe_main(int argc, char** argv) {
                 // is supported here by default, ignore flag if no argument.
                 check_mode();
                 if (optarg == NULL) break;
-                if (!android::base::ReadFileToString(optarg, &mods)) {
+
+                // Since libmodprobe doesn't fail when the modules load file
+                // doesn't exist, let's check that here so that we don't
+                // silently fail.
+                fd = open(optarg, O_RDONLY | O_CLOEXEC | O_BINARY);
+                if (fd == -1) {
                     PLOG(ERROR) << "Failed to open " << optarg;
-                    rv = EXIT_FAILURE;
-                }
-                for (auto mod : android::base::Split(stripComments(mods), "\n")) {
-                    mod = android::base::Trim(mod);
-                    if (mod == "") continue;
-                    if (std::find(modules.begin(), modules.end(), mod) != modules.end()) continue;
-                    modules.emplace_back(mod);
+                    return EXIT_FAILURE;
                 }
+                close(fd);
+
+                mod_dirs.emplace_back(android::base::Dirname(optarg));
+                modules_load_file = android::base::Basename(optarg);
                 break;
             case 'b':
                 blocklist = true;
@@ -233,25 +237,33 @@ extern "C" int modprobe_main(int argc, char** argv) {
     LOG(DEBUG) << "mode is " << mode;
     LOG(DEBUG) << "mod_dirs is: " << android::base::Join(mod_dirs, " ");
     LOG(DEBUG) << "modules is: " << android::base::Join(modules, " ");
+    LOG(DEBUG) << "modules load file is: " << modules_load_file;
     LOG(DEBUG) << "module parameters is: " << android::base::Join(module_parameters, " ");
 
     if (modules.empty()) {
         if (mode == ListModulesMode) {
             // emulate toybox modprobe list with no pattern (list all)
             modules.emplace_back("*");
-        } else {
+        } else if (modules_load_file.empty()) {
             LOG(ERROR) << "No modules given.";
             print_usage();
             return EXIT_FAILURE;
         }
     }
-    if (parameter_count && modules.size() > 1) {
+    if (parameter_count && (modules.size() > 1 || !modules_load_file.empty())) {
         LOG(ERROR) << "Only one module may be loaded when specifying module parameters.";
         print_usage();
         return EXIT_FAILURE;
     }
 
-    Modprobe m(mod_dirs, "modules.load", blocklist);
+    Modprobe m(mod_dirs, modules_load_file.empty() ? "modules.load" : modules_load_file, blocklist);
+    if (mode == AddModulesMode && !modules_load_file.empty()) {
+        if (!m.LoadListedModules(false)) {
+            PLOG(ERROR) << "Failed to load all the modules from " << modules_load_file;
+            return EXIT_FAILURE;
+        }
+        /* Fall-through to load modules provided on the command line (if any)*/
+    }
 
     for (const auto& module : modules) {
         switch (mode) {

From 9459f7c09c7756d2328a5aa953137a9d8614acae Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <jaegeuk@google.com>
Date: Tue, 12 Mar 2024 19:27:13 -0700
Subject: [PATCH 0787/1487] dmctl: add report of IMA

This adds an option "ima" in dmctl.

$ dmctl ima product-verity
Targets in the device-mapper table for product-verity:
0-7463768: verity, target_name=verity,target_version=1.9.0,hash_failed=V,verity_version=1,data_device_name=254:4,hash_device_name=254:4,verity_algorithm=sha256,root_digest=d7af9fcb04d184219ba5477b97bb2bbc89fd23a46e03d1dea31d674cc4934769,salt=19d4f2345adfc8b7cc22a3c2f21dd413e5020fc7920a08a33f46f3c61492dfcc,ignore_zero_blocks=y,check_at_most_once=n,verity_mode=restart_on_corruption;

Change-Id: I057970b6c786b3f9a394b4919f5f5115b27cbc08
Signed-off-by: Jaegeuk Kim <jaegeuk@google.com>
---
 fs_mgr/libdm/dm.cpp                                 |  7 +++++++
 fs_mgr/libdm/include/libdm/dm.h                     |  7 +++++++
 .../include_test/libsnapshot/test_helpers.h         |  3 +++
 fs_mgr/tools/dmctl.cpp                              | 13 +++++++++++++
 4 files changed, 30 insertions(+)

diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index e261aa3012f2..fee67fdfadad 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -39,6 +39,9 @@
 #ifndef DM_DEFERRED_REMOVE
 #define DM_DEFERRED_REMOVE (1 << 17)
 #endif
+#ifndef DM_IMA_MEASUREMENT_FLAG
+#define DM_IMA_MEASUREMENT_FLAG (1 << 19)
+#endif
 
 namespace android {
 namespace dm {
@@ -540,6 +543,10 @@ bool DeviceMapper::GetTableStatus(const std::string& name, std::vector<TargetInf
     return GetTable(name, 0, table);
 }
 
+bool DeviceMapper::GetTableStatusIma(const std::string& name, std::vector<TargetInfo>* table) {
+    return GetTable(name, DM_IMA_MEASUREMENT_FLAG, table);
+}
+
 bool DeviceMapper::GetTableInfo(const std::string& name, std::vector<TargetInfo>* table) {
     return GetTable(name, DM_STATUS_TABLE_FLAG, table);
 }
diff --git a/fs_mgr/libdm/include/libdm/dm.h b/fs_mgr/libdm/include/libdm/dm.h
index 22c475f1ed84..fa976535ba8d 100644
--- a/fs_mgr/libdm/include/libdm/dm.h
+++ b/fs_mgr/libdm/include/libdm/dm.h
@@ -78,6 +78,7 @@ class IDeviceMapper {
     virtual bool LoadTable(const std::string& name, const DmTable& table) = 0;
     virtual bool GetTableInfo(const std::string& name, std::vector<TargetInfo>* table) = 0;
     virtual bool GetTableStatus(const std::string& name, std::vector<TargetInfo>* table) = 0;
+    virtual bool GetTableStatusIma(const std::string& name, std::vector<TargetInfo>* table) = 0;
     virtual bool GetDmDevicePathByName(const std::string& name, std::string* path) = 0;
     virtual bool GetDeviceString(const std::string& name, std::string* dev) = 0;
     virtual bool DeleteDeviceIfExists(const std::string& name) = 0;
@@ -267,6 +268,12 @@ class DeviceMapper final : public IDeviceMapper {
     // false.
     bool GetTableStatus(const std::string& name, std::vector<TargetInfo>* table) override;
 
+    // Query the status of a table, given a device name. The output vector will
+    // contain IMA TargetInfo for each target in the table. If the device does
+    // not exist, or there were too many targets, the call will fail and return
+    // false.
+    bool GetTableStatusIma(const std::string& name, std::vector<TargetInfo>* table) override;
+
     // Identical to GetTableStatus, except also retrives the active table for the device
     // mapper device from the kernel.
     bool GetTableInfo(const std::string& name, std::vector<TargetInfo>* table) override;
diff --git a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
index 5e9f049d178a..90813fe79e69 100644
--- a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
+++ b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
@@ -155,6 +155,9 @@ class DeviceMapperWrapper : public android::dm::IDeviceMapper {
     virtual bool GetTableStatus(const std::string& name, std::vector<TargetInfo>* table) {
         return impl_.GetTableStatus(name, table);
     }
+    virtual bool GetTableStatusIma(const std::string& name, std::vector<TargetInfo>* table) {
+        return impl_.GetTableStatusIma(name, table);
+    }
     virtual bool GetDmDevicePathByName(const std::string& name, std::string* path) {
         return impl_.GetDmDevicePathByName(name, path);
     }
diff --git a/fs_mgr/tools/dmctl.cpp b/fs_mgr/tools/dmctl.cpp
index 7273087b3b11..5d5c65029011 100644
--- a/fs_mgr/tools/dmctl.cpp
+++ b/fs_mgr/tools/dmctl.cpp
@@ -52,6 +52,7 @@ static int Usage(void) {
     std::cerr << "  list <devices | targets> [-v]" << std::endl;
     std::cerr << "  getpath <dm-name>" << std::endl;
     std::cerr << "  getuuid <dm-name>" << std::endl;
+    std::cerr << "  ima <dm-name>" << std::endl;
     std::cerr << "  info <dm-name>" << std::endl;
     std::cerr << "  replace <dm-name> <targets...>" << std::endl;
     std::cerr << "  status <dm-name>" << std::endl;
@@ -493,7 +494,14 @@ static int DumpTable(const std::string& mode, int argc, char** argv) {
                       << std::endl;
             return -EINVAL;
         }
+    } else if (mode == "ima") {
+        if (!dm.GetTableStatusIma(argv[0], &table)) {
+            std::cerr << "Could not query table status of device \"" << argv[0] << "\"."
+                      << std::endl;
+            return -EINVAL;
+        }
     }
+
     std::cout << "Targets in the device-mapper table for " << argv[0] << ":" << std::endl;
     for (const auto& target : table) {
         std::cout << target.spec.sector_start << "-"
@@ -515,6 +523,10 @@ static int StatusCmdHandler(int argc, char** argv) {
     return DumpTable("status", argc, argv);
 }
 
+static int ImaCmdHandler(int argc, char** argv) {
+    return DumpTable("ima", argc, argv);
+}
+
 static int ResumeCmdHandler(int argc, char** argv) {
     if (argc != 1) {
         std::cerr << "Invalid arguments, see \'dmctl help\'" << std::endl;
@@ -555,6 +567,7 @@ static std::map<std::string, std::function<int(int, char**)>> cmdmap = {
         {"info", InfoCmdHandler},
         {"table", TableCmdHandler},
         {"status", StatusCmdHandler},
+        {"ima", ImaCmdHandler},
         {"resume", ResumeCmdHandler},
         {"suspend", SuspendCmdHandler},
         // clang-format on

From c8dc7ffd5e38f8b59ed2040b2b72c870eecbcccf Mon Sep 17 00:00:00 2001
From: Junki Min <joonki.min@samsung.com>
Date: Mon, 18 Mar 2024 17:35:26 +0900
Subject: [PATCH 0788/1487] toolbox/libmodprobe: add toolbox to vendor_ramdisk

toolbox and libmodprobe are required for module loading before
first stage init begin.

BUG: 329807942
Signed-off-by: Junki Min <joonki.min@samsung.com>
Change-Id: Icf04888e602b012758ebf353ed8e4aff2585fd07
---
 libmodprobe/Android.bp | 1 +
 toolbox/Android.bp     | 1 +
 2 files changed, 2 insertions(+)

diff --git a/libmodprobe/Android.bp b/libmodprobe/Android.bp
index 1d94a96fb572..12906cc39e33 100644
--- a/libmodprobe/Android.bp
+++ b/libmodprobe/Android.bp
@@ -10,6 +10,7 @@ cc_library_static {
     vendor_available: true,
     ramdisk_available: true,
     recovery_available: true,
+    vendor_ramdisk_available: true,
     host_supported: true,
     srcs: [
         "libmodprobe.cpp",
diff --git a/toolbox/Android.bp b/toolbox/Android.bp
index 8594ec403502..120cc6e16113 100644
--- a/toolbox/Android.bp
+++ b/toolbox/Android.bp
@@ -69,6 +69,7 @@ cc_binary {
     name: "toolbox",
     defaults: ["toolbox_binary_defaults"],
     recovery_available: true,
+    vendor_ramdisk_available: true,
 }
 
 cc_binary {

From e95d7810416ca17a3644134ff7252b88d40e8411 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Mon, 18 Mar 2024 17:15:57 -0700
Subject: [PATCH 0789/1487] Do not chmod ANRs

The code was only meant for native tombstones. It might be a good idea
to make ANRs also readable by shell / adb, but in that case we have to
do more changes to make sure all files in /data/anr are. We can revert
if we implement that

Test: m
Bug: 329827513
Change-Id: Ic98c452ca500fe766a70173bef4ac1ea57438989
---
 debuggerd/tombstoned/tombstoned.cpp | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/debuggerd/tombstoned/tombstoned.cpp b/debuggerd/tombstoned/tombstoned.cpp
index e2a67a2f7068..75ae9f8a6521 100644
--- a/debuggerd/tombstoned/tombstoned.cpp
+++ b/debuggerd/tombstoned/tombstoned.cpp
@@ -96,7 +96,7 @@ struct Crash {
 class CrashQueue {
  public:
   CrashQueue(const std::string& dir_path, const std::string& file_name_prefix, size_t max_artifacts,
-             size_t max_concurrent_dumps, bool supports_proto)
+             size_t max_concurrent_dumps, bool supports_proto, bool world_readable)
       : file_name_prefix_(file_name_prefix),
         dir_path_(dir_path),
         dir_fd_(open(dir_path.c_str(), O_DIRECTORY | O_RDONLY | O_CLOEXEC)),
@@ -104,7 +104,8 @@ class CrashQueue {
         next_artifact_(0),
         max_concurrent_dumps_(max_concurrent_dumps),
         num_concurrent_dumps_(0),
-        supports_proto_(supports_proto) {
+        supports_proto_(supports_proto),
+        world_readable_(world_readable) {
     if (dir_fd_ == -1) {
       PLOG(FATAL) << "failed to open directory: " << dir_path;
     }
@@ -127,14 +128,16 @@ class CrashQueue {
   static CrashQueue* for_tombstones() {
     static CrashQueue queue("/data/tombstones", "tombstone_" /* file_name_prefix */,
                             GetIntProperty("tombstoned.max_tombstone_count", 32),
-                            1 /* max_concurrent_dumps */, true /* supports_proto */);
+                            1 /* max_concurrent_dumps */, true /* supports_proto */,
+                            true /* world_readable */);
     return &queue;
   }
 
   static CrashQueue* for_anrs() {
     static CrashQueue queue("/data/anr", "trace_" /* file_name_prefix */,
                             GetIntProperty("tombstoned.max_anr_count", 64),
-                            4 /* max_concurrent_dumps */, false /* supports_proto */);
+                            4 /* max_concurrent_dumps */, false /* supports_proto */,
+                            false /* world_readable */);
     return &queue;
   }
 
@@ -147,10 +150,12 @@ class CrashQueue {
       PLOG(FATAL) << "failed to create temporary tombstone in " << dir_path_;
     }
 
-    // We need to fchmodat after creating to avoid getting the umask applied.
-    std::string fd_path = StringPrintf("/proc/self/fd/%d", result.fd.get());
-    if (fchmodat(dir_fd_, fd_path.c_str(), 0664, 0) != 0) {
-      PLOG(ERROR) << "Failed to make tombstone world-readable";
+    if (world_readable_) {
+      // We need to fchmodat after creating to avoid getting the umask applied.
+      std::string fd_path = StringPrintf("/proc/self/fd/%d", result.fd.get());
+      if (fchmodat(dir_fd_, fd_path.c_str(), 0664, 0) != 0) {
+        PLOG(ERROR) << "Failed to make tombstone world-readable";
+      }
     }
 
     return std::move(result);
@@ -262,6 +267,7 @@ class CrashQueue {
   size_t num_concurrent_dumps_;
 
   bool supports_proto_;
+  bool world_readable_;
 
   std::deque<std::unique_ptr<Crash>> queued_requests_;
 

From 8e6ab87328e1a10c4c4ecb7036e2022968ca8326 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 14 Mar 2024 12:49:03 -0700
Subject: [PATCH 0790/1487] libsnapshot: reserve 16x space for ops

We have updated logic for v3 cow we should allow non-data ops to be
cached at 16x the amount of data ops. Changing the reserve size to match
this.

Test: th
Change-Id: I825ffef4e1a2ce4eb5c105d266bf95cb3d776ed9
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp | 5 +++--
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h   | 3 +++
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index de2e528339a2..ea1da4b53b01 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -173,7 +173,7 @@ bool CowWriterV3::ParseOptions() {
         batch_size_ = std::max<size_t>(options_.cluster_ops, 1);
         data_vec_.reserve(batch_size_);
         cached_data_.reserve(batch_size_);
-        cached_ops_.reserve(batch_size_);
+        cached_ops_.reserve(batch_size_ * kNonDataOpBufferSize);
     }
 
     if (batch_size_ > 1) {
@@ -342,7 +342,8 @@ bool CowWriterV3::NeedsFlush() const {
     // Allow bigger batch sizes for ops without data. A single CowOperationV3
     // struct uses 14 bytes of memory, even if we cache 200 * 16 ops in memory,
     // it's only ~44K.
-    return cached_data_.size() >= batch_size_ || cached_ops_.size() >= batch_size_ * 16;
+    return cached_data_.size() >= batch_size_ ||
+           cached_ops_.size() >= batch_size_ * kNonDataOpBufferSize;
 }
 
 bool CowWriterV3::ConstructCowOpCompressedBuffers(uint64_t new_block_start, const void* data,
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 48eb67bcceb4..e2dc69813c5b 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -28,6 +28,9 @@ namespace android {
 namespace snapshot {
 
 using namespace android::storage_literals;
+// This is a multiple on top of the number of data ops that can be stored in our cache at once. This
+// is added so that we can cache more non-data ops as it takes up less space.
+static constexpr uint32_t kNonDataOpBufferSize = 16;
 
 class CowWriterV3 : public CowWriterBase {
   public:

From 0fb8da9a05545cba746e09ffcb8ddcdbf45d0e37 Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Tue, 19 Mar 2024 16:36:08 +0900
Subject: [PATCH 0791/1487] Avoid duplicated definition in llndk-versioning.h

Non-vendor modules may define llndk versioning macros manually. Avoid
redefining the macros if they are already defined outside of
llndk-versioning.h header.

Bug: 302113279
Test: m && m cts

Change-Id: Ibf984f2f2eed3594c824f2e97e17f2698e0515dd
---
 libvendorsupport/include_llndk/android/llndk-versioning.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libvendorsupport/include_llndk/android/llndk-versioning.h b/libvendorsupport/include_llndk/android/llndk-versioning.h
index 8ae56d4c5362..58cd18db66cb 100644
--- a/libvendorsupport/include_llndk/android/llndk-versioning.h
+++ b/libvendorsupport/include_llndk/android/llndk-versioning.h
@@ -48,7 +48,9 @@
 
 // For non-vendor modules, API_LEVEL_AT_LEAST is replaced with __builtin_available(sdk_api_level) to
 // guard the API for __INTRODUCED_IN.
+#if !defined(API_LEVEL_AT_LEAST)
 #define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
     (__builtin_available(android sdk_api_level, *))
+#endif
 
 #endif  // __ANDROID_VENDOR__

From 553c9d4fb6709a23c1d3625400cad95e83d1cb75 Mon Sep 17 00:00:00 2001
From: Harsh Abichandani <harsh.abichandani@ittiam.com>
Date: Mon, 11 Mar 2024 14:02:55 +0530
Subject: [PATCH 0792/1487] liblp_builder_fuzzer: Bug Fix

Updated FuzzedDataProvider value ranges to avoid Abort due to division by zero.

exec/s: 14786
Test: ./liblp_builder_fuzzer clusterfuzz-testcase-minimized-liblp_builder_fuzzer-5371251289292800
Bug: 328948968

Change-Id: I2568bd104b5fb09744baf42ffca6aabd24797b12
---
 fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp | 21 +++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp b/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
index 7f09ac828f79..162c9fc34c29 100644
--- a/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
+++ b/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
@@ -28,7 +28,7 @@ static constexpr uint64_t kValidBlockSize = 4096 * 50;
 static constexpr uint64_t kBlockDeviceInfoSize = 1024 * 1024;
 static constexpr uint64_t kValidBlockDeviceInfoSize = 8_GiB;
 static constexpr uint64_t kValidMaxGroupSize = 40960;
-static constexpr uint64_t kMinBlockDevValue = 0;
+static constexpr uint64_t kMinBlockDevValue = 1;
 static constexpr uint64_t kMaxBlockDevValue = 100000;
 static constexpr uint64_t kMinSectorValue = 1;
 static constexpr uint64_t kMaxSectorValue = 1000000;
@@ -149,12 +149,16 @@ void BuilderFuzzer::selectRandomBuilder(int32_t randomBuilder, string superBlock
 
 void BuilderFuzzer::setupBuilder(string superBlockDeviceName) {
     uint64_t blockDeviceInfoSize =
-            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint64_t>() : kValidBlockDeviceInfoSize;
+            mFdp.ConsumeBool()
+                    ? mFdp.ConsumeIntegralInRange<uint64_t>(kMinBlockDevValue, kMaxBlockDevValue)
+                    : kValidBlockDeviceInfoSize;
     uint32_t alignment = mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>() : kValidAlignment;
     uint32_t alignmentOffset =
             mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>() : kValidAlignmentOffset;
-    uint32_t logicalBlockSize =
-            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>() : kValidLogicalBlockSize;
+    uint32_t logicalBlockSize = mFdp.ConsumeBool() ? mFdp.ConsumeIntegralInRange<uint32_t>(
+                                                             kMinBlockDevValue, kMaxBlockDevValue)
+                                                   : kValidLogicalBlockSize;
+
     BlockDeviceInfo super(superBlockDeviceName, blockDeviceInfoSize, alignment, alignmentOffset,
                           logicalBlockSize);
     mBlockDevices.push_back(super);
@@ -176,13 +180,16 @@ void BuilderFuzzer::setupBuilder(string superBlockDeviceName) {
             mFdp.ConsumeBool() ? kDeviceInfoName : mFdp.ConsumeRandomLengthString(kMaxBytes);
     BlockDeviceInfo changePartitionDeviceInfo(
             changePartitionDeviceInfoName,
-            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint64_t>() : kBlockDeviceInfoSize /* size */,
+            mFdp.ConsumeBool()
+                    ? mFdp.ConsumeIntegralInRange<uint64_t>(kMinBlockDevValue, kMaxBlockDevValue)
+                    : kBlockDeviceInfoSize /* size */,
             mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>()
                                : kZeroAlignmentOffset /* alignment */,
             mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>()
                                : kZeroAlignmentOffset /* alignment_offset */,
-            mFdp.ConsumeBool() ? mFdp.ConsumeIntegral<uint32_t>()
-                               : kValidLogicalBlockSize /* logical_block_size */);
+            mFdp.ConsumeBool()
+                    ? mFdp.ConsumeIntegralInRange<uint32_t>(kMinBlockDevValue, kMaxBlockDevValue)
+                    : kValidLogicalBlockSize);
     mBlockDevices.push_back(changePartitionDeviceInfo);
 }
 

From 31407917f8e6c36d8f930a3136fe8a3dd00e4fc9 Mon Sep 17 00:00:00 2001
From: Mitch Phillips <mitchp@google.com>
Date: Thu, 14 Mar 2024 14:18:47 +0100
Subject: [PATCH 0793/1487] [MTE] Implement permissive (recoverable) MTE for
 apps

Extends the recoverable native crash handling support to also allow for
MTE crashes to be recovered from in apps. Backs onto the existing
GWP-ASan recoverable handling.

At least for system/core, I've renamed the (now) generic "recoverable
crash" variables to remove the notion of GWP-ASan.

Permissive MTE should no longer crash an app, and crashes are still
visible in the AppExitInfo API and tombstones.

Test: atest CtsTaggingHostTestCases
Bug: 328793166
Change-Id: I4c6ffa85af0e0d9b72d0ccd606bb6e1ca464cfff
---
 debuggerd/crash_dump.cpp                | 24 +++----
 debuggerd/handler/debuggerd_handler.cpp | 95 ++++++++++++++++---------
 debuggerd/include/debuggerd/handler.h   |  2 +-
 debuggerd/protocol.h                    |  2 +-
 4 files changed, 73 insertions(+), 50 deletions(-)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index a23a26925d4d..203b4855b3b0 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -143,7 +143,7 @@ static bool ptrace_interrupt(pid_t tid, int* received_signal) {
 }
 
 static bool activity_manager_notify(pid_t pid, int signal, const std::string& amfd_data,
-                                    bool recoverable_gwp_asan_crash) {
+                                    bool recoverable_crash) {
   ATRACE_CALL();
   android::base::unique_fd amfd(socket_local_client(
       "/data/system/ndebugsocket", ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM));
@@ -169,7 +169,7 @@ static bool activity_manager_notify(pid_t pid, int signal, const std::string& am
   // Activity Manager protocol:
   //  - 32-bit network-byte-order: pid
   //  - 32-bit network-byte-order: signal number
-  //  - byte: recoverable_gwp_asan_crash
+  //  - byte: recoverable_crash
   //  - bytes: raw text of the dump
   //  - null terminator
 
@@ -185,10 +185,9 @@ static bool activity_manager_notify(pid_t pid, int signal, const std::string& am
     return false;
   }
 
-  uint8_t recoverable_gwp_asan_crash_byte = recoverable_gwp_asan_crash ? 1 : 0;
-  if (!android::base::WriteFully(amfd, &recoverable_gwp_asan_crash_byte,
-                                 sizeof(recoverable_gwp_asan_crash_byte))) {
-    PLOG(ERROR) << "AM recoverable_gwp_asan_crash_byte write failed";
+  uint8_t recoverable_crash_byte = recoverable_crash ? 1 : 0;
+  if (!android::base::WriteFully(amfd, &recoverable_crash_byte, sizeof(recoverable_crash_byte))) {
+    PLOG(ERROR) << "AM recoverable_crash_byte write failed";
     return false;
   }
 
@@ -280,11 +279,11 @@ static void ParseArgs(int argc, char** argv, pid_t* pseudothread_tid, DebuggerdD
 
 static void ReadCrashInfo(unique_fd& fd, siginfo_t* siginfo,
                           std::unique_ptr<unwindstack::Regs>* regs, ProcessInfo* process_info,
-                          bool* recoverable_gwp_asan_crash) {
+                          bool* recoverable_crash) {
   std::aligned_storage<sizeof(CrashInfo) + 1, alignof(CrashInfo)>::type buf;
   CrashInfo* crash_info = reinterpret_cast<CrashInfo*>(&buf);
   ssize_t rc = TEMP_FAILURE_RETRY(read(fd.get(), &buf, sizeof(buf)));
-  *recoverable_gwp_asan_crash = false;
+  *recoverable_crash = false;
   if (rc == -1) {
     PLOG(FATAL) << "failed to read target ucontext";
   } else {
@@ -321,7 +320,7 @@ static void ReadCrashInfo(unique_fd& fd, siginfo_t* siginfo,
       process_info->scudo_region_info = crash_info->data.d.scudo_region_info;
       process_info->scudo_ring_buffer = crash_info->data.d.scudo_ring_buffer;
       process_info->scudo_ring_buffer_size = crash_info->data.d.scudo_ring_buffer_size;
-      *recoverable_gwp_asan_crash = crash_info->data.d.recoverable_gwp_asan_crash;
+      *recoverable_crash = crash_info->data.d.recoverable_crash;
       process_info->crash_detail_page = crash_info->data.d.crash_detail_page;
       FALLTHROUGH_INTENDED;
     case 1:
@@ -487,7 +486,7 @@ int main(int argc, char** argv) {
   std::map<pid_t, ThreadInfo> thread_info;
   siginfo_t siginfo;
   std::string error;
-  bool recoverable_gwp_asan_crash = false;
+  bool recoverable_crash = false;
 
   {
     ATRACE_NAME("ptrace");
@@ -539,8 +538,7 @@ int main(int argc, char** argv) {
 
       if (thread == g_target_thread) {
         // Read the thread's registers along with the rest of the crash info out of the pipe.
-        ReadCrashInfo(input_pipe, &siginfo, &info.registers, &process_info,
-                      &recoverable_gwp_asan_crash);
+        ReadCrashInfo(input_pipe, &siginfo, &info.registers, &process_info, &recoverable_crash);
         info.siginfo = &siginfo;
         info.signo = info.siginfo->si_signo;
 
@@ -670,7 +668,7 @@ int main(int argc, char** argv) {
   if (fatal_signal) {
     // Don't try to notify ActivityManager if it just crashed, or we might hang until timeout.
     if (thread_info[target_process].thread_name != "system_server") {
-      activity_manager_notify(target_process, signo, amfd_data, recoverable_gwp_asan_crash);
+      activity_manager_notify(target_process, signo, amfd_data, recoverable_crash);
     }
   }
 
diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index 141723b037ad..ba5ad3f363c4 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -396,7 +396,7 @@ static int debuggerd_dispatch_pseudothread(void* arg) {
     ASSERT_SAME_OFFSET(scudo_ring_buffer, scudo_ring_buffer);
     ASSERT_SAME_OFFSET(scudo_ring_buffer_size, scudo_ring_buffer_size);
     ASSERT_SAME_OFFSET(scudo_stack_depot_size, scudo_stack_depot_size);
-    ASSERT_SAME_OFFSET(recoverable_gwp_asan_crash, recoverable_gwp_asan_crash);
+    ASSERT_SAME_OFFSET(recoverable_crash, recoverable_crash);
     ASSERT_SAME_OFFSET(crash_detail_page, crash_detail_page);
 #undef ASSERT_SAME_OFFSET
 
@@ -573,6 +573,7 @@ static void debuggerd_signal_handler(int signal_number, siginfo_t* info, void* c
   }
 
   gwp_asan_callbacks_t gwp_asan_callbacks = {};
+  bool recoverable_gwp_asan_crash = false;
   if (g_callbacks.get_gwp_asan_callbacks != nullptr) {
     // GWP-ASan catches use-after-free and heap-buffer-overflow by using PROT_NONE
     // guard pages, which lead to SEGV. Normally, debuggerd prints a bug report
@@ -587,10 +588,30 @@ static void debuggerd_signal_handler(int signal_number, siginfo_t* info, void* c
         gwp_asan_callbacks.debuggerd_gwp_asan_post_crash_report &&
         gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery(info->si_addr)) {
       gwp_asan_callbacks.debuggerd_gwp_asan_pre_crash_report(info->si_addr);
-      process_info.recoverable_gwp_asan_crash = true;
+      recoverable_gwp_asan_crash = true;
+      process_info.recoverable_crash = true;
     }
   }
 
+  if (info->si_signo == SIGSEGV &&
+      (info->si_code == SEGV_MTESERR || info->si_code == SEGV_MTEAERR) && is_permissive_mte()) {
+    process_info.recoverable_crash = true;
+    // If we are in permissive MTE mode, we do not crash, but instead disable MTE on this thread,
+    // and then let the failing instruction be retried. The second time should work (except
+    // if there is another non-MTE fault).
+    int tagged_addr_ctrl = prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0);
+    if (tagged_addr_ctrl < 0) {
+      fatal_errno("failed to PR_GET_TAGGED_ADDR_CTRL");
+    }
+    tagged_addr_ctrl = (tagged_addr_ctrl & ~PR_MTE_TCF_MASK) | PR_MTE_TCF_NONE;
+    if (prctl(PR_SET_TAGGED_ADDR_CTRL, tagged_addr_ctrl, 0, 0, 0) < 0) {
+      fatal_errno("failed to PR_SET_TAGGED_ADDR_CTRL");
+    }
+    async_safe_format_log(ANDROID_LOG_ERROR, "libc",
+                          "MTE ERROR DETECTED BUT RUNNING IN PERMISSIVE MODE. CONTINUING.");
+    pthread_mutex_unlock(&crash_mutex);
+  }
+
   // If sival_int is ~0, it means that the fallback handler has been called
   // once before and this function is being called again to dump the stack
   // of a specific thread. It is possible that the prctl call might return 1,
@@ -602,7 +623,7 @@ static void debuggerd_signal_handler(int signal_number, siginfo_t* info, void* c
     // you can only set NO_NEW_PRIVS to 1, and the effect should be at worst a single missing
     // ANR trace.
     debuggerd_fallback_handler(info, ucontext, process_info.abort_msg);
-    if (no_new_privs && process_info.recoverable_gwp_asan_crash) {
+    if (no_new_privs && recoverable_gwp_asan_crash) {
       gwp_asan_callbacks.debuggerd_gwp_asan_post_crash_report(info->si_addr);
       return;
     }
@@ -679,29 +700,14 @@ static void debuggerd_signal_handler(int signal_number, siginfo_t* info, void* c
     // If the signal is fatal, don't unlock the mutex to prevent other crashing threads from
     // starting to dump right before our death.
     pthread_mutex_unlock(&crash_mutex);
-  } else if (process_info.recoverable_gwp_asan_crash) {
-    gwp_asan_callbacks.debuggerd_gwp_asan_post_crash_report(info->si_addr);
+  } else if (process_info.recoverable_crash) {
+    if (recoverable_gwp_asan_crash) {
+      gwp_asan_callbacks.debuggerd_gwp_asan_post_crash_report(info->si_addr);
+    }
     pthread_mutex_unlock(&crash_mutex);
   }
 #ifdef __aarch64__
-  else if (info->si_signo == SIGSEGV &&
-           (info->si_code == SEGV_MTESERR || info->si_code == SEGV_MTEAERR) &&
-           is_permissive_mte()) {
-    // If we are in permissive MTE mode, we do not crash, but instead disable MTE on this thread,
-    // and then let the failing instruction be retried. The second time should work (except
-    // if there is another non-MTE fault).
-    int tagged_addr_ctrl = prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0);
-    if (tagged_addr_ctrl < 0) {
-      fatal_errno("failed to PR_GET_TAGGED_ADDR_CTRL");
-    }
-    tagged_addr_ctrl = (tagged_addr_ctrl & ~PR_MTE_TCF_MASK) | PR_MTE_TCF_NONE;
-    if (prctl(PR_SET_TAGGED_ADDR_CTRL, tagged_addr_ctrl, 0, 0, 0) < 0) {
-      fatal_errno("failed to PR_SET_TAGGED_ADDR_CTRL");
-    }
-    async_safe_format_log(ANDROID_LOG_ERROR, "libc",
-                          "MTE ERROR DETECTED BUT RUNNING IN PERMISSIVE MODE. CONTINUING.");
-    pthread_mutex_unlock(&crash_mutex);
-  } else if (info->si_signo == SIGSEGV && info->si_code == SEGV_MTEAERR && getppid() == 1) {
+  else if (info->si_signo == SIGSEGV && info->si_code == SEGV_MTEAERR && getppid() == 1) {
     // Back channel to init (see system/core/init/service.cpp) to signal that
     // this process crashed due to an ASYNC MTE fault and should be considered
     // for upgrade to SYNC mode. We are re-using the ART profiler signal, which
@@ -761,18 +767,7 @@ void debuggerd_init(debuggerd_callbacks_t* callbacks) {
   debuggerd_register_handlers(&action);
 }
 
-// When debuggerd's signal handler is the first handler called, it's great at
-// handling the recoverable GWP-ASan mode. For apps, sigchain (from libart) is
-// always the first signal handler, and so the following function is what
-// sigchain must call before processing the signal. This allows for processing
-// of a potentially recoverable GWP-ASan crash. If the signal requires GWP-ASan
-// recovery, then dump a report (via the regular debuggerd hanndler), and patch
-// up the allocator, and allow the process to continue (indicated by returning
-// 'true'). If the crash has nothing to do with GWP-ASan, or recovery isn't
-// possible, return 'false'.
-bool debuggerd_handle_signal(int signal_number, siginfo_t* info, void* context) {
-  if (signal_number != SIGSEGV || !signal_has_si_addr(info)) return false;
-
+bool debuggerd_handle_gwp_asan_signal(int signal_number, siginfo_t* info, void* context) {
   if (g_callbacks.get_gwp_asan_callbacks == nullptr) return false;
   gwp_asan_callbacks_t gwp_asan_callbacks = g_callbacks.get_gwp_asan_callbacks();
   if (gwp_asan_callbacks.debuggerd_needs_gwp_asan_recovery == nullptr ||
@@ -810,3 +805,33 @@ bool debuggerd_handle_signal(int signal_number, siginfo_t* info, void* context)
   pthread_mutex_unlock(&first_crash_mutex);
   return true;
 }
+
+// When debuggerd's signal handler is the first handler called, it's great at
+// handling the recoverable GWP-ASan and permissive MTE modes. For apps,
+// sigchain (from libart) is always the first signal handler, and so the
+// following function is what sigchain must call before processing the signal.
+// This allows for processing of a potentially recoverable GWP-ASan or MTE
+// crash. If the signal requires recovery, then dump a report (via the regular
+// debuggerd hanndler), and patch up the allocator (in the case of GWP-ASan) or
+// disable MTE on the thread, and allow the process to continue (indicated by
+// returning 'true'). If the crash has nothing to do with GWP-ASan/MTE, or
+// recovery isn't possible, return 'false'.
+bool debuggerd_handle_signal(int signal_number, siginfo_t* info, void* context) {
+  if (signal_number != SIGSEGV) return false;
+  if (info->si_code == SEGV_MTEAERR || info->si_code == SEGV_MTESERR) {
+    if (!is_permissive_mte()) return false;
+    // Because permissive MTE disables MTE for the entire thread, we're less
+    // worried about getting a whole bunch of crashes in a row. ActivityManager
+    // doesn't like multiple native crashes for an app in a short period of time
+    // (see the comment about recoverable GWP-ASan in
+    // `debuggerd_handle_gwp_asan_signal`), but that shouldn't happen if MTE is
+    // disabled for the entire thread. This might need to be changed if there's
+    // some low-hanging bug that happens across multiple threads in quick
+    // succession.
+    debuggerd_signal_handler(signal_number, info, context);
+    return true;
+  }
+
+  if (!signal_has_si_addr(info)) return false;
+  return debuggerd_handle_gwp_asan_signal(signal_number, info, context);
+}
diff --git a/debuggerd/include/debuggerd/handler.h b/debuggerd/include/debuggerd/handler.h
index c18cf6e7a89c..954f049a6f55 100644
--- a/debuggerd/include/debuggerd/handler.h
+++ b/debuggerd/include/debuggerd/handler.h
@@ -47,7 +47,7 @@ struct __attribute__((packed)) debugger_process_info {
   const char* scudo_ring_buffer;
   size_t scudo_ring_buffer_size;
   size_t scudo_stack_depot_size;
-  bool recoverable_gwp_asan_crash;
+  bool recoverable_crash;
   struct crash_detail_page_t* crash_detail_page;
 };
 
diff --git a/debuggerd/protocol.h b/debuggerd/protocol.h
index d3fc15edcaa4..9af7377df802 100644
--- a/debuggerd/protocol.h
+++ b/debuggerd/protocol.h
@@ -100,7 +100,7 @@ struct __attribute__((__packed__)) CrashInfoDataDynamic : public CrashInfoDataSt
   uintptr_t scudo_ring_buffer;
   size_t scudo_ring_buffer_size;
   size_t scudo_stack_depot_size;
-  bool recoverable_gwp_asan_crash;
+  bool recoverable_crash;
   uintptr_t crash_detail_page;
 };
 

From 294ba38082a673c64651b393b0cf80979c6d26a4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= <arve@android.com>
Date: Mon, 9 Oct 2023 16:03:13 -0700
Subject: [PATCH 0794/1487] trusty: rpmb_dev: Use socket from init and update
 init script

Stop creating a socket on a persistent filesystem and use a socket
created by init in /dev/socket/ instead.

Many init script changes to make rpmb_dev.rc usable on cuttlefish.

Test: Build and run aosp_cf_x86_64_phone_trusty_vm-trunk_staging-userdebug
Bug: 309007107
Change-Id: Idc830211b3298d25bbb310dcb7489dd89fe5afc6
---
 trusty/utils/rpmb_dev/Android.bp  |  1 +
 trusty/utils/rpmb_dev/rpmb_dev.c  | 27 ++++++++++++++-----------
 trusty/utils/rpmb_dev/rpmb_dev.rc | 33 ++++++++++++++++++-------------
 3 files changed, 36 insertions(+), 25 deletions(-)

diff --git a/trusty/utils/rpmb_dev/Android.bp b/trusty/utils/rpmb_dev/Android.bp
index a2700876a254..5e9caafeef11 100644
--- a/trusty/utils/rpmb_dev/Android.bp
+++ b/trusty/utils/rpmb_dev/Android.bp
@@ -24,6 +24,7 @@ cc_binary {
     ],
     shared_libs: [
         "libc",
+        "libcutils",
         "liblog",
         "libcrypto",
     ],
diff --git a/trusty/utils/rpmb_dev/rpmb_dev.c b/trusty/utils/rpmb_dev/rpmb_dev.c
index 0a9e6a13f59f..cee3037de103 100644
--- a/trusty/utils/rpmb_dev/rpmb_dev.c
+++ b/trusty/utils/rpmb_dev/rpmb_dev.c
@@ -19,6 +19,7 @@
 #include "rpmb_protocol.h"
 
 #include <assert.h>
+#include <cutils/sockets.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <getopt.h>
@@ -613,20 +614,24 @@ int main(int argc, char** argv) {
         return EXIT_FAILURE;
     }
 
-    cmdres_sock = socket(AF_UNIX, SOCK_STREAM, 0);
+    cmdres_sock = android_get_control_socket(socket_path);
     if (cmdres_sock < 0) {
-        ALOGE("rpmb_dev: Failed to create command/response socket: %s\n", strerror(errno));
-        return EXIT_FAILURE;
-    }
+        ALOGW("android_get_control_socket(%s) failed, fall back to create it\n", socket_path);
+        cmdres_sock = socket(AF_UNIX, SOCK_STREAM, 0);
+        if (cmdres_sock < 0) {
+            ALOGE("rpmb_dev: Failed to create command/response socket: %s\n", strerror(errno));
+            return EXIT_FAILURE;
+        }
 
-    cmdres_sockaddr.sun_family = AF_UNIX;
-    strncpy(cmdres_sockaddr.sun_path, socket_path, sizeof(cmdres_sockaddr.sun_path));
+        cmdres_sockaddr.sun_family = AF_UNIX;
+        strncpy(cmdres_sockaddr.sun_path, socket_path, sizeof(cmdres_sockaddr.sun_path));
 
-    ret = bind(cmdres_sock, (struct sockaddr*)&cmdres_sockaddr, sizeof(struct sockaddr_un));
-    if (ret < 0) {
-        ALOGE("rpmb_dev: Failed to bind command/response socket: %s: %s\n", socket_path,
-              strerror(errno));
-        return EXIT_FAILURE;
+        ret = bind(cmdres_sock, (struct sockaddr*)&cmdres_sockaddr, sizeof(struct sockaddr_un));
+        if (ret < 0) {
+            ALOGE("rpmb_dev: Failed to bind command/response socket: %s: %s\n", socket_path,
+                  strerror(errno));
+            return EXIT_FAILURE;
+        }
     }
 
     ret = listen(cmdres_sock, 1);
diff --git a/trusty/utils/rpmb_dev/rpmb_dev.rc b/trusty/utils/rpmb_dev/rpmb_dev.rc
index 9e203b89c407..33ec0f2c2ef0 100644
--- a/trusty/utils/rpmb_dev/rpmb_dev.rc
+++ b/trusty/utils/rpmb_dev/rpmb_dev.rc
@@ -1,29 +1,34 @@
 # RPMB Mock
-on post-fs-data
-    mkdir /data/vendor/ss
-    chown root system /data/vendor/ss
-    chmod 0770 /data/vendor/ss
-    rm /data/vendor/ss/rpmb_sock
-    start rpmb_mock_init
+on post-fs
+    mkdir /mnt/vendor/persist/ss 0770 root system
+    exec_start rpmb_mock_init
     start rpmb_mock
 
+on post-fs-data
+    mkdir /data/vendor/ss 0770 root system
+    symlink /mnt/vendor/persist/ss /data/vendor/ss/persist
+    chown root system /data/vendor/ss/persist
+    chmod 0770 /data/vendor/ss/persist
+
     # Storage proxy
-    start storageproxyd
+    restart storageproxyd
 
-service storageproxyd /vendor/bin/storageproxyd -d /dev/trusty-ipc-dev0 \
-        -r /data/vendor/ss/rpmb_sock -p /data/vendor/ss -t sock
-    class main
-    disabled
-    user root
+service storageproxyd /vendor/bin/storageproxyd -d ${ro.hardware.trusty_ipc_dev:-/dev/trusty-ipc-dev0} \
+        -r /dev/socket/rpmb_mock -p /data/vendor/ss -t sock
+    class early_hal
+    user system
+    group system
 
-service rpmb_mock_init /vendor/bin/rpmb_dev --dev /data/vendor/ss/RPMB_DATA --init --size 2048
+service rpmb_mock_init /vendor/bin/rpmb_dev --dev /mnt/vendor/persist/ss/RPMB_DATA --init --size 2048
     disabled
     user system
     group system
     oneshot
 
-service rpmb_mock /vendor/bin/rpmb_dev --dev /data/vendor/ss/RPMB_DATA --sock /data/vendor/ss/rpmb_sock
+service rpmb_mock /vendor/bin/rpmb_dev --dev /mnt/vendor/persist/ss/RPMB_DATA \
+                          --sock rpmb_mock
     class main
     disabled
     user system
     group system
+    socket rpmb_mock stream 660 system system

From 9e17d3a032a9568b2bdb66166388da9838ec01be Mon Sep 17 00:00:00 2001
From: Dennis Shen <dzshen@google.com>
Date: Wed, 20 Mar 2024 16:33:28 +0000
Subject: [PATCH 0795/1487] turn on aconfigd in init

Bug: b/312444587
Test: avd
Change-Id: Ibc88b57f88f924318d54ae81c70fd8da1fc1b437
---
 rootdir/init.rc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index ec203f91bfea..a2a2f36627e0 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -648,6 +648,8 @@ on post-fs
     mkdir /metadata/aconfig 0775 root system
     mkdir /metadata/aconfig/flags 0770 root system
     mkdir /metadata/aconfig/boot 0775 root system
+    exec_start aconfigd-init
+    start aconfigd
 
 on late-fs
     # Ensure that tracefs has the correct permissions.

From 25eabc44f582b9e854119a05f85b3009f9edadcf Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Sun, 17 Mar 2024 23:45:21 -0700
Subject: [PATCH 0796/1487] libsnapshot: Prepare removal of legacy snapshot

During OTA install, when vendor partition is on Android S, add a new flag in SnapshotUpdateStatus file to indicate that we need to support dm-snapshot based snapshot process. This will be used only during post OTA reboot.

The primary change here is the OTA install path. Earlier, dm-snapshot based approach was used; with this change, since both "snapuserd" and "update-engine" resides on system partition, OTA installation will use the userspace snapshot approach.

To maintain backward compatibility, the new flag "legacy_snapuserd" is used only after OTA reboot. This flag will make sure that update-engine will take the dm-snapshot based approach post reboot and for the entire duration of snapshot-merge.

Additionally, during first-stage init if the vendor is on Android S, then "snapuserd" binary will continue to work based off dm-snapshot as none of this change will impact the mount process.

Bug: 304829384
Test: OTA on Pixel
th - OTA from Android S to TOT with vendor on S
Change-Id: Idd9a60b09417cee141b2810e2d4b35e91c845a5c
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../android/snapshot/snapshot.proto           |  3 +
 .../include/libsnapshot/snapshot.h            |  4 +
 fs_mgr/libsnapshot/snapshot.cpp               | 76 +++++++++++++++++--
 fs_mgr/libsnapshot/utility.cpp                | 17 +++--
 fs_mgr/libsnapshot/utility.h                  |  1 +
 5 files changed, 88 insertions(+), 13 deletions(-)

diff --git a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
index f2f7fc1cd212..076a918fe421 100644
--- a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
+++ b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
@@ -212,6 +212,9 @@ message SnapshotUpdateStatus {
 
     // io_uring support
     bool io_uring_enabled = 10;
+
+    // legacy dm-snapshot based snapuserd
+    bool legacy_snapuserd = 11;
 }
 
 // Next: 10
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index d102863123f9..3ccc3dbf4fbd 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -829,6 +829,9 @@ class SnapshotManager final : public ISnapshotManager {
     // Set read-ahead size during OTA
     void SetReadAheadSize(const std::string& entry_block_device, off64_t size_kb);
 
+    // Returns true post OTA reboot if legacy snapuserd is required
+    bool IsLegacySnapuserdPostReboot();
+
     android::dm::IDeviceMapper& dm_;
     std::unique_ptr<IDeviceInfo> device_;
     std::string metadata_dir_;
@@ -839,6 +842,7 @@ class SnapshotManager final : public ISnapshotManager {
     std::unique_ptr<SnapuserdClient> snapuserd_client_;
     std::unique_ptr<LpMetadata> old_partition_metadata_;
     std::optional<bool> is_snapshot_userspace_;
+    std::optional<bool> is_legacy_snapuserd_;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index e6c4de6234c1..b4892b4a1a6d 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -265,7 +265,6 @@ std::string SnapshotManager::ReadUpdateSourceSlotSuffix() {
     auto boot_file = GetSnapshotBootIndicatorPath();
     std::string contents;
     if (!android::base::ReadFileToString(boot_file, &contents)) {
-        PLOG(WARNING) << "Cannot read " << boot_file;
         return {};
     }
     return contents;
@@ -2118,6 +2117,53 @@ bool SnapshotManager::UpdateUsesIouring(LockedFile* lock) {
     return update_status.io_uring_enabled();
 }
 
+/*
+ * Please see b/304829384 for more details.
+ *
+ * In Android S, we use dm-snapshot for mounting snapshots and snapshot-merge
+ * process. If the vendor partition continues to be on Android S, then
+ * "snapuserd" binary in first stage ramdisk will be from vendor partition.
+ * Thus, we need to maintain backward compatibility.
+ *
+ * Now, We take a two step approach to maintain the backward compatibility:
+ *
+ * 1: During OTA installation, we will continue to use "user-space" snapshots
+ * for OTA installation as both update-engine and snapuserd binary will be from system partition.
+ * However, during installation, we mark "legacy_snapuserd" in
+ * SnapshotUpdateStatus file to mark that this is a path to support backward compatibility.
+ * Thus, this function will return "false" during OTA installation.
+ *
+ * 2: Post OTA reboot, there are two key steps:
+ *    a: During first stage init, "init" and "snapuserd" could be from vendor
+ *    partition. This could be from Android S. Thus, the snapshot mount path
+ *    will be based off dm-snapshot.
+ *
+ *    b: Post selinux transition, "init" and "update-engine" will be "system"
+ *    partition. Now, since the snapshots are mounted off dm-snapshot,
+ *    update-engine interaction with "snapuserd" should work based off
+ *    dm-snapshots.
+ *
+ *    TL;DR: update-engine will use the "system" snapuserd for installing new
+ *    updates (this is safe as there is no "vendor" snapuserd running during
+ *    installation). Post reboot, update-engine will use the legacy path when
+ *    communicating with "vendor" snapuserd that was started in first-stage
+ *    init. Hence, this function checks:
+ *         i: Are we in post OTA reboot
+ *         ii: Is the Vendor from Android 12
+ *         iii: If both (i) and (ii) are true, then use the dm-snapshot based
+ *         approach.
+ *
+ */
+bool SnapshotManager::IsLegacySnapuserdPostReboot() {
+    if (is_legacy_snapuserd_.has_value() && is_legacy_snapuserd_.value() == true) {
+        auto slot = GetCurrentSlot();
+        if (slot == Slot::Target) {
+            return true;
+        }
+    }
+    return false;
+}
+
 bool SnapshotManager::UpdateUsesUserSnapshots() {
     // This and the following function is constantly
     // invoked during snapshot merge. We want to avoid
@@ -2129,7 +2175,12 @@ bool SnapshotManager::UpdateUsesUserSnapshots() {
     // during merge phase. Hence, once we know that
     // the value is read from disk the very first time,
     // it is safe to read successive checks from memory.
+
     if (is_snapshot_userspace_.has_value()) {
+        // Check if legacy snapuserd is running post OTA reboot
+        if (IsLegacySnapuserdPostReboot()) {
+            return false;
+        }
         return is_snapshot_userspace_.value();
     }
 
@@ -2140,13 +2191,16 @@ bool SnapshotManager::UpdateUsesUserSnapshots() {
 }
 
 bool SnapshotManager::UpdateUsesUserSnapshots(LockedFile* lock) {
-    // See UpdateUsesUserSnapshots()
-    if (is_snapshot_userspace_.has_value()) {
-        return is_snapshot_userspace_.value();
+    if (!is_snapshot_userspace_.has_value()) {
+        SnapshotUpdateStatus update_status = ReadSnapshotUpdateStatus(lock);
+        is_snapshot_userspace_ = update_status.userspace_snapshots();
+        is_legacy_snapuserd_ = update_status.legacy_snapuserd();
+    }
+
+    if (IsLegacySnapuserdPostReboot()) {
+        return false;
     }
 
-    SnapshotUpdateStatus update_status = ReadSnapshotUpdateStatus(lock);
-    is_snapshot_userspace_ = update_status.userspace_snapshots();
     return is_snapshot_userspace_.value();
 }
 
@@ -3210,6 +3264,8 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
     // Deduce supported features.
     bool userspace_snapshots = CanUseUserspaceSnapshots();
     bool legacy_compression = GetLegacyCompressionEnabledProperty();
+    bool is_legacy_snapuserd = IsVendorFromAndroid12();
+
     if (!vabc_disable_reason.empty()) {
         if (userspace_snapshots) {
             LOG(INFO) << "Userspace snapshots disabled: " << vabc_disable_reason;
@@ -3219,6 +3275,7 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
         }
         userspace_snapshots = false;
         legacy_compression = false;
+        is_legacy_snapuserd = false;
     }
 
     if (legacy_compression || userspace_snapshots) {
@@ -3231,6 +3288,8 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
         }
     }
 
+    LOG(INFO) << "userspace snapshots: " << userspace_snapshots
+              << " legacy_snapuserd: " << legacy_compression;
     const bool using_snapuserd = userspace_snapshots || legacy_compression;
     if (!using_snapuserd) {
         LOG(INFO) << "Using legacy Virtual A/B (dm-snapshot)";
@@ -3328,6 +3387,10 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
             status.set_io_uring_enabled(true);
             LOG(INFO) << "io_uring for snapshots enabled";
         }
+
+        if (is_legacy_snapuserd) {
+            status.set_legacy_snapuserd(true);
+        }
     } else if (legacy_compression) {
         LOG(INFO) << "Virtual A/B using legacy snapuserd";
     } else {
@@ -3335,6 +3398,7 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
     }
 
     is_snapshot_userspace_.emplace(userspace_snapshots);
+    is_legacy_snapuserd_.emplace(is_legacy_snapuserd);
 
     if (!device()->IsTestDevice() && using_snapuserd) {
         // Terminate stale daemon if any
diff --git a/fs_mgr/libsnapshot/utility.cpp b/fs_mgr/libsnapshot/utility.cpp
index 1ffa89cba23a..fe2d95c644cd 100644
--- a/fs_mgr/libsnapshot/utility.cpp
+++ b/fs_mgr/libsnapshot/utility.cpp
@@ -230,11 +230,7 @@ bool GetUserspaceSnapshotsEnabledProperty() {
     return fetcher->GetBoolProperty("ro.virtual_ab.userspace.snapshots.enabled", false);
 }
 
-bool CanUseUserspaceSnapshots() {
-    if (!GetUserspaceSnapshotsEnabledProperty()) {
-        return false;
-    }
-
+bool IsVendorFromAndroid12() {
     auto fetcher = IPropertyFetcher::GetInstance();
 
     const std::string UNKNOWN = "unknown";
@@ -243,8 +239,15 @@ bool CanUseUserspaceSnapshots() {
 
     // No user-space snapshots if vendor partition is on Android 12
     if (vendor_release.find("12") != std::string::npos) {
-        LOG(INFO) << "Userspace snapshots disabled as vendor partition is on Android: "
-                  << vendor_release;
+        return true;
+    }
+
+    return false;
+}
+
+bool CanUseUserspaceSnapshots() {
+    if (!GetUserspaceSnapshotsEnabledProperty()) {
+        LOG(INFO) << "Virtual A/B - Userspace snapshots disabled";
         return false;
     }
 
diff --git a/fs_mgr/libsnapshot/utility.h b/fs_mgr/libsnapshot/utility.h
index 370f3c4fc6e8..f956a05449ac 100644
--- a/fs_mgr/libsnapshot/utility.h
+++ b/fs_mgr/libsnapshot/utility.h
@@ -136,6 +136,7 @@ bool GetXorCompressionEnabledProperty();
 
 bool CanUseUserspaceSnapshots();
 bool IsDmSnapshotTestingEnabled();
+bool IsVendorFromAndroid12();
 
 // Swap the suffix of a partition name.
 std::string GetOtherPartitionName(const std::string& name);

From 10233e2fc41480f0f0b4d5476ac503b829738a92 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 18 Mar 2024 10:11:07 -0700
Subject: [PATCH 0797/1487] snapuserd: Remove legacy dm-snapshot based snapshot
 and snapshot-merge

Clean up all the legacy dm-snapshot based approach.

This will continue to maintain backward compatibility with vendor
partition on Android S.

Bug: 304829384
Test: OTA on Pixel
th - OTA from Android S to TOT with vendor on S
Change-Id: Id9263be881dd1a06923cd0ace007f1c027e6969d
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/Android.bp                 |   18 -
 fs_mgr/libsnapshot/snapshot_test.cpp          |   16 +-
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   43 -
 .../dm-snapshot-merge/cow_snapuserd_test.cpp  | 1238 -----------------
 .../snapuserd/dm-snapshot-merge/snapuserd.cpp |  870 ------------
 .../snapuserd/dm-snapshot-merge/snapuserd.h   |  332 -----
 .../dm-snapshot-merge/snapuserd_readahead.cpp |  482 -------
 .../dm-snapshot-merge/snapuserd_server.cpp    |  559 --------
 .../dm-snapshot-merge/snapuserd_server.h      |  149 --
 .../dm-snapshot-merge/snapuserd_worker.cpp    |  869 ------------
 .../snapuserd/snapuserd_daemon.cpp            |   67 +-
 .../libsnapshot/snapuserd/snapuserd_daemon.h  |    4 -
 12 files changed, 6 insertions(+), 4641 deletions(-)
 delete mode 100644 fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/cow_snapuserd_test.cpp
 delete mode 100644 fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
 delete mode 100644 fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.h
 delete mode 100644 fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
 delete mode 100644 fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.cpp
 delete mode 100644 fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.h
 delete mode 100644 fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 5ceaf287ab76..914b4a63f115 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -321,24 +321,6 @@ cc_test {
     },
 }
 
-cc_test {
-    name: "vabc_legacy_tests",
-    defaults: [
-        "libsnapshot_test_defaults",
-        "libsnapshot_hal_deps",
-    ],
-    cppflags: [
-        "-DLIBSNAPSHOT_TEST_VABC_LEGACY",
-    ],
-    test_suites: [
-        "device-tests",
-    ],
-    test_options: {
-        // Legacy VABC launched in Android S.
-        min_shipping_api_level: 31,
-    },
-}
-
 cc_test {
     name: "vts_ota_config_test",
     srcs: [
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 47e6ce963b08..8d0c898c7721 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -56,14 +56,12 @@
 
 #if defined(LIBSNAPSHOT_TEST_VAB_LEGACY)
 #define DEFAULT_MODE "vab-legacy"
-#elif defined(LIBSNAPSHOT_TEST_VABC_LEGACY)
-#define DEFAULT_MODE "vabc-legacy"
 #else
 #define DEFAULT_MODE ""
 #endif
 
 DEFINE_string(force_mode, DEFAULT_MODE,
-              "Force testing older modes (vab-legacy, vabc-legacy) ignoring device config.");
+              "Force testing older modes (vab-legacy) ignoring device config.");
 DEFINE_string(force_iouring_disable, "",
               "Force testing mode (iouring_disabled) - disable io_uring");
 DEFINE_string(compression_method, "gz", "Default compression algorithm.");
@@ -140,17 +138,10 @@ class SnapshotTest : public ::testing::Test {
     void SetupProperties() {
         std::unordered_map<std::string, std::string> properties;
 
-        ASSERT_TRUE(android::base::SetProperty("snapuserd.test.dm.snapshots", "0"))
-                << "Failed to disable property: virtual_ab.userspace.snapshots.enabled";
         ASSERT_TRUE(android::base::SetProperty("snapuserd.test.io_uring.force_disable", "0"))
                 << "Failed to set property: snapuserd.test.io_uring.disabled";
 
-        if (FLAGS_force_mode == "vabc-legacy") {
-            ASSERT_TRUE(android::base::SetProperty("snapuserd.test.dm.snapshots", "1"))
-                    << "Failed to disable property: virtual_ab.userspace.snapshots.enabled";
-            properties["ro.virtual_ab.compression.enabled"] = "true";
-            properties["ro.virtual_ab.userspace.snapshots.enabled"] = "false";
-        } else if (FLAGS_force_mode == "vab-legacy") {
+        if (FLAGS_force_mode == "vab-legacy") {
             properties["ro.virtual_ab.compression.enabled"] = "false";
             properties["ro.virtual_ab.userspace.snapshots.enabled"] = "false";
         }
@@ -2894,7 +2885,7 @@ int main(int argc, char** argv) {
 
     android::base::SetProperty("ctl.stop", "snapuserd");
 
-    std::unordered_set<std::string> modes = {"", "vab-legacy", "vabc-legacy"};
+    std::unordered_set<std::string> modes = {"", "vab-legacy"};
     if (modes.count(FLAGS_force_mode) == 0) {
         std::cerr << "Unexpected force_config argument\n";
         return 1;
@@ -2905,7 +2896,6 @@ int main(int argc, char** argv) {
 
     int ret = RUN_ALL_TESTS();
 
-    android::base::SetProperty("snapuserd.test.dm.snapshots", "0");
     android::base::SetProperty("snapuserd.test.io_uring.force_disable", "0");
 
     android::snapshot::KillSnapuserd();
diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index bd296a396d79..649309de1d67 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -59,9 +59,6 @@ cc_library_static {
     ],
     local_include_dirs: ["include/"],
     srcs: [
-        "dm-snapshot-merge/snapuserd.cpp",
-        "dm-snapshot-merge/snapuserd_readahead.cpp",
-        "dm-snapshot-merge/snapuserd_worker.cpp",
         "dm_user_block_server.cpp",
         "snapuserd_buffer.cpp",
         "user-space-merge/handler_manager.cpp",
@@ -109,7 +106,6 @@ cc_defaults {
         "fs_mgr_defaults",
     ],
     srcs: [
-        "dm-snapshot-merge/snapuserd_server.cpp",
         "snapuserd_daemon.cpp",
         "user-space-merge/snapuserd_server.cpp",
     ],
@@ -190,45 +186,6 @@ cc_binary {
     symlinks: ["snapuserd"],
 }
 
-cc_test {
-    name: "snapuserd_test_legacy",
-    defaults: [
-        "fs_mgr_defaults",
-        "libsnapshot_cow_defaults",
-    ],
-    srcs: [
-        "dm-snapshot-merge/cow_snapuserd_test.cpp",
-        "dm-snapshot-merge/snapuserd.cpp",
-        "dm-snapshot-merge/snapuserd_worker.cpp",
-        "snapuserd_buffer.cpp",
-    ],
-    shared_libs: [
-        "libbase",
-        "liblog",
-    ],
-    static_libs: [
-        "libbrotli",
-        "libgtest",
-        "libsnapshot_cow",
-        "libsnapuserd_client",
-        "libcutils_sockets",
-        "libz",
-        "libdm",
-        "libext2_uuid",
-        "libext4_utils",
-        "libfs_mgr_file_wait",
-    ],
-    header_libs: [
-        "libstorage_literals_headers",
-        "libfiemap_headers",
-    ],
-    test_options: {
-        min_shipping_api_level: 30,
-    },
-    auto_gen_config: true,
-    require_root: false,
-}
-
 cc_defaults {
     name: "snapuserd_test_defaults",
     defaults: [
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/cow_snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/cow_snapuserd_test.cpp
deleted file mode 100644
index 737c480a8b48..000000000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/cow_snapuserd_test.cpp
+++ /dev/null
@@ -1,1238 +0,0 @@
-// Copyright (C) 2018 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <fcntl.h>
-#include <linux/fs.h>
-#include <linux/memfd.h>
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <sys/syscall.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <chrono>
-#include <iostream>
-#include <memory>
-#include <string_view>
-
-#include <android-base/file.h>
-#include <android-base/unique_fd.h>
-#include <fs_mgr/file_wait.h>
-#include <gtest/gtest.h>
-#include <libdm/dm.h>
-#include <libdm/loop_control.h>
-#include <libsnapshot/cow_writer.h>
-#include <snapuserd/snapuserd_buffer.h>
-#include <snapuserd/snapuserd_client.h>
-#include <storage_literals/storage_literals.h>
-
-#include "snapuserd.h"
-
-namespace android {
-namespace snapshot {
-
-using namespace android::storage_literals;
-using android::base::unique_fd;
-using LoopDevice = android::dm::LoopDevice;
-using namespace std::chrono_literals;
-using namespace android::dm;
-using namespace std;
-
-static constexpr char kSnapuserdSocketTest[] = "snapuserdTest";
-
-class TempDevice {
-  public:
-    TempDevice(const std::string& name, const DmTable& table)
-        : dm_(DeviceMapper::Instance()), name_(name), valid_(false) {
-        valid_ = dm_.CreateDevice(name, table, &path_, std::chrono::seconds(5));
-    }
-    TempDevice(TempDevice&& other) noexcept
-        : dm_(other.dm_), name_(other.name_), path_(other.path_), valid_(other.valid_) {
-        other.valid_ = false;
-    }
-    ~TempDevice() {
-        if (valid_) {
-            dm_.DeleteDevice(name_);
-        }
-    }
-    bool Destroy() {
-        if (!valid_) {
-            return false;
-        }
-        valid_ = false;
-        return dm_.DeleteDevice(name_);
-    }
-    const std::string& path() const { return path_; }
-    const std::string& name() const { return name_; }
-    bool valid() const { return valid_; }
-
-    TempDevice(const TempDevice&) = delete;
-    TempDevice& operator=(const TempDevice&) = delete;
-
-    TempDevice& operator=(TempDevice&& other) noexcept {
-        name_ = other.name_;
-        valid_ = other.valid_;
-        other.valid_ = false;
-        return *this;
-    }
-
-  private:
-    DeviceMapper& dm_;
-    std::string name_;
-    std::string path_;
-    bool valid_;
-};
-
-class CowSnapuserdTest final {
-  public:
-    bool Setup();
-    bool SetupOrderedOps();
-    bool SetupOrderedOpsInverted();
-    bool SetupCopyOverlap_1();
-    bool SetupCopyOverlap_2();
-    bool Merge();
-    void ValidateMerge();
-    void ReadSnapshotDeviceAndValidate();
-    void Shutdown();
-    void MergeInterrupt();
-    void MergeInterruptFixed(int duration);
-    void MergeInterruptRandomly(int max_duration);
-    void ReadDmUserBlockWithoutDaemon();
-    void ReadLastBlock();
-
-    std::string snapshot_dev() const { return snapshot_dev_->path(); }
-
-    static const uint64_t kSectorSize = 512;
-
-  private:
-    void SetupImpl();
-
-    void MergeImpl();
-    void SimulateDaemonRestart();
-    void StartMerge();
-
-    std::unique_ptr<ICowWriter> CreateCowDeviceInternal();
-    void CreateCowDevice();
-    void CreateCowDeviceOrderedOps();
-    void CreateCowDeviceOrderedOpsInverted();
-    void CreateCowDeviceWithCopyOverlap_1();
-    void CreateCowDeviceWithCopyOverlap_2();
-    bool SetupDaemon();
-    void CreateBaseDevice();
-    void InitCowDevice();
-    void SetDeviceControlName();
-    void InitDaemon();
-    void CreateDmUserDevice();
-    void StartSnapuserdDaemon();
-    void CreateSnapshotDevice();
-
-    unique_ptr<LoopDevice> base_loop_;
-    unique_ptr<TempDevice> dmuser_dev_;
-    unique_ptr<TempDevice> snapshot_dev_;
-
-    std::string system_device_ctrl_name_;
-    std::string system_device_name_;
-
-    unique_fd base_fd_;
-    std::unique_ptr<TemporaryFile> cow_system_;
-    std::unique_ptr<SnapuserdClient> client_;
-    std::unique_ptr<uint8_t[]> orig_buffer_;
-    std::unique_ptr<uint8_t[]> merged_buffer_;
-    bool setup_ok_ = false;
-    bool merge_ok_ = false;
-    size_t size_ = 50_MiB;
-    int cow_num_sectors_;
-    int total_base_size_;
-};
-
-class CowSnapuserdMetadataTest final {
-  public:
-    void Setup();
-    void SetupPartialArea();
-    void ValidateMetadata();
-    void ValidatePartialFilledArea();
-
-  private:
-    void InitMetadata();
-    std::unique_ptr<ICowWriter> CreateCowDeviceInternal();
-    void CreateCowDevice();
-    void CreateCowPartialFilledArea();
-
-    std::unique_ptr<Snapuserd> snapuserd_;
-    std::unique_ptr<TemporaryFile> cow_system_;
-    size_t size_ = 1_MiB;
-};
-
-static unique_fd CreateTempFile(const std::string& name, size_t size) {
-    unique_fd fd(syscall(__NR_memfd_create, name.c_str(), MFD_ALLOW_SEALING));
-    if (fd < 0) {
-        return {};
-    }
-    if (size) {
-        if (ftruncate(fd, size) < 0) {
-            perror("ftruncate");
-            return {};
-        }
-        if (fcntl(fd, F_ADD_SEALS, F_SEAL_GROW | F_SEAL_SHRINK) < 0) {
-            perror("fcntl");
-            return {};
-        }
-    }
-    return fd;
-}
-
-void CowSnapuserdTest::Shutdown() {
-    ASSERT_TRUE(snapshot_dev_->Destroy());
-    ASSERT_TRUE(dmuser_dev_->Destroy());
-
-    auto misc_device = "/dev/dm-user/" + system_device_ctrl_name_;
-    ASSERT_TRUE(client_->WaitForDeviceDelete(system_device_ctrl_name_));
-    ASSERT_TRUE(android::fs_mgr::WaitForFileDeleted(misc_device, 10s));
-    ASSERT_TRUE(client_->DetachSnapuserd());
-}
-
-bool CowSnapuserdTest::Setup() {
-    SetupImpl();
-    return setup_ok_;
-}
-
-bool CowSnapuserdTest::SetupOrderedOps() {
-    CreateBaseDevice();
-    CreateCowDeviceOrderedOps();
-    return SetupDaemon();
-}
-
-bool CowSnapuserdTest::SetupOrderedOpsInverted() {
-    CreateBaseDevice();
-    CreateCowDeviceOrderedOpsInverted();
-    return SetupDaemon();
-}
-
-bool CowSnapuserdTest::SetupCopyOverlap_1() {
-    CreateBaseDevice();
-    CreateCowDeviceWithCopyOverlap_1();
-    return SetupDaemon();
-}
-
-bool CowSnapuserdTest::SetupCopyOverlap_2() {
-    CreateBaseDevice();
-    CreateCowDeviceWithCopyOverlap_2();
-    return SetupDaemon();
-}
-
-bool CowSnapuserdTest::SetupDaemon() {
-    SetDeviceControlName();
-
-    StartSnapuserdDaemon();
-    InitCowDevice();
-
-    CreateDmUserDevice();
-    InitDaemon();
-
-    CreateSnapshotDevice();
-    setup_ok_ = true;
-
-    return setup_ok_;
-}
-
-void CowSnapuserdTest::StartSnapuserdDaemon() {
-    pid_t pid = fork();
-    ASSERT_GE(pid, 0);
-    if (pid == 0) {
-        std::string arg0 = "/system/bin/snapuserd";
-        std::string arg1 = "-socket="s + kSnapuserdSocketTest;
-        char* const argv[] = {arg0.data(), arg1.data(), nullptr};
-        ASSERT_GE(execv(arg0.c_str(), argv), 0);
-    } else {
-        client_ = SnapuserdClient::Connect(kSnapuserdSocketTest, 10s);
-        ASSERT_NE(client_, nullptr);
-    }
-}
-
-std::unique_ptr<ICowWriter> CowSnapuserdTest::CreateCowDeviceInternal() {
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
-
-    CowOptions options;
-    options.compression = "gz";
-
-    unique_fd fd(cow_system_->fd);
-    cow_system_->fd = -1;
-
-    return CreateCowWriter(kDefaultCowVersion, options, std::move(fd));
-}
-
-void CowSnapuserdTest::ReadLastBlock() {
-    unique_fd rnd_fd;
-    total_base_size_ = BLOCK_SZ * 2;
-
-    base_fd_ = CreateTempFile("base_device", total_base_size_);
-    ASSERT_GE(base_fd_, 0);
-
-    rnd_fd.reset(open("/dev/random", O_RDONLY));
-    ASSERT_TRUE(rnd_fd > 0);
-
-    std::unique_ptr<uint8_t[]> random_buffer = std::make_unique<uint8_t[]>(BLOCK_SZ);
-
-    for (size_t j = 0; j < ((total_base_size_) / BLOCK_SZ); j++) {
-        ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer.get(), BLOCK_SZ, 0), true);
-        ASSERT_EQ(android::base::WriteFully(base_fd_, random_buffer.get(), BLOCK_SZ), true);
-    }
-
-    ASSERT_EQ(lseek(base_fd_, 0, SEEK_SET), 0);
-
-    base_loop_ = std::make_unique<LoopDevice>(base_fd_, 10s);
-    ASSERT_TRUE(base_loop_->valid());
-
-    std::unique_ptr<uint8_t[]> random_buffer_1_ = std::make_unique<uint8_t[]>(total_base_size_);
-    loff_t offset = 0;
-
-    // Fill random data
-    for (size_t j = 0; j < (total_base_size_ / BLOCK_SZ); j++) {
-        ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer_1_.get() + offset, BLOCK_SZ, 0),
-                  true);
-
-        offset += BLOCK_SZ;
-    }
-
-    auto writer = CreateCowDeviceInternal();
-    ASSERT_NE(writer, nullptr);
-
-    ASSERT_TRUE(writer->AddRawBlocks(0, random_buffer_1_.get(), BLOCK_SZ));
-    ASSERT_TRUE(writer->AddRawBlocks(1, (char*)random_buffer_1_.get() + BLOCK_SZ, BLOCK_SZ));
-
-    ASSERT_TRUE(writer->Finalize());
-
-    SetDeviceControlName();
-
-    StartSnapuserdDaemon();
-    InitCowDevice();
-
-    CreateDmUserDevice();
-    InitDaemon();
-
-    CreateSnapshotDevice();
-
-    unique_fd snapshot_fd(open(snapshot_dev_->path().c_str(), O_RDONLY));
-    ASSERT_TRUE(snapshot_fd > 0);
-
-    std::unique_ptr<uint8_t[]> snapuserd_buffer = std::make_unique<uint8_t[]>(BLOCK_SZ);
-
-    offset = 7680;
-    ASSERT_EQ(ReadFullyAtOffset(snapshot_fd, snapuserd_buffer.get(), 512, offset), true);
-    ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)random_buffer_1_.get() + offset, 512), 0);
-}
-
-void CowSnapuserdTest::CreateBaseDevice() {
-    unique_fd rnd_fd;
-
-    total_base_size_ = (size_ * 5);
-    base_fd_ = CreateTempFile("base_device", total_base_size_);
-    ASSERT_GE(base_fd_, 0);
-
-    rnd_fd.reset(open("/dev/random", O_RDONLY));
-    ASSERT_TRUE(rnd_fd > 0);
-
-    std::unique_ptr<uint8_t[]> random_buffer = std::make_unique<uint8_t[]>(1_MiB);
-
-    for (size_t j = 0; j < ((total_base_size_) / 1_MiB); j++) {
-        ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer.get(), 1_MiB, 0), true);
-        ASSERT_EQ(android::base::WriteFully(base_fd_, random_buffer.get(), 1_MiB), true);
-    }
-
-    ASSERT_EQ(lseek(base_fd_, 0, SEEK_SET), 0);
-
-    base_loop_ = std::make_unique<LoopDevice>(base_fd_, 10s);
-    ASSERT_TRUE(base_loop_->valid());
-}
-
-void CowSnapuserdTest::ReadSnapshotDeviceAndValidate() {
-    unique_fd snapshot_fd(open(snapshot_dev_->path().c_str(), O_RDONLY));
-    ASSERT_TRUE(snapshot_fd > 0);
-
-    std::unique_ptr<uint8_t[]> snapuserd_buffer = std::make_unique<uint8_t[]>(size_);
-
-    // COPY
-    loff_t offset = 0;
-    ASSERT_EQ(ReadFullyAtOffset(snapshot_fd, snapuserd_buffer.get(), size_, offset), true);
-    ASSERT_EQ(memcmp(snapuserd_buffer.get(), orig_buffer_.get(), size_), 0);
-
-    // REPLACE
-    offset += size_;
-    ASSERT_EQ(ReadFullyAtOffset(snapshot_fd, snapuserd_buffer.get(), size_, offset), true);
-    ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + size_, size_), 0);
-
-    // ZERO
-    offset += size_;
-    ASSERT_EQ(ReadFullyAtOffset(snapshot_fd, snapuserd_buffer.get(), size_, offset), true);
-    ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + (size_ * 2), size_), 0);
-
-    // REPLACE
-    offset += size_;
-    ASSERT_EQ(ReadFullyAtOffset(snapshot_fd, snapuserd_buffer.get(), size_, offset), true);
-    ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + (size_ * 3), size_), 0);
-
-    // XOR
-    offset += size_;
-    ASSERT_EQ(ReadFullyAtOffset(snapshot_fd, snapuserd_buffer.get(), size_, offset), true);
-    ASSERT_EQ(memcmp(snapuserd_buffer.get(), (char*)orig_buffer_.get() + (size_ * 4), size_), 0);
-}
-
-void CowSnapuserdTest::CreateCowDeviceWithCopyOverlap_2() {
-    auto writer = CreateCowDeviceInternal();
-    ASSERT_NE(writer, nullptr);
-
-    size_t num_blocks = size_ / writer->GetBlockSize();
-    size_t x = num_blocks;
-    size_t blk_src_copy = 0;
-
-    // Create overlapping copy operations
-    while (1) {
-        ASSERT_TRUE(writer->AddCopy(blk_src_copy, blk_src_copy + 1));
-        x -= 1;
-        if (x == 1) {
-            break;
-        }
-        blk_src_copy += 1;
-    }
-
-    // Flush operations
-    ASSERT_TRUE(writer->Finalize());
-
-    // Construct the buffer required for validation
-    orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
-
-    // Read the entire base device
-    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), total_base_size_, 0),
-              true);
-
-    // Merged operations required for validation
-    int block_size = 4096;
-    x = num_blocks;
-    loff_t src_offset = block_size;
-    loff_t dest_offset = 0;
-
-    while (1) {
-        memmove((char*)orig_buffer_.get() + dest_offset, (char*)orig_buffer_.get() + src_offset,
-                block_size);
-        x -= 1;
-        if (x == 1) {
-            break;
-        }
-        src_offset += block_size;
-        dest_offset += block_size;
-    }
-}
-
-void CowSnapuserdTest::CreateCowDeviceWithCopyOverlap_1() {
-    auto writer = CreateCowDeviceInternal();
-    ASSERT_NE(writer, nullptr);
-
-    size_t num_blocks = size_ / writer->GetBlockSize();
-    size_t x = num_blocks;
-    size_t blk_src_copy = num_blocks - 1;
-
-    // Create overlapping copy operations
-    while (1) {
-        ASSERT_TRUE(writer->AddCopy(blk_src_copy + 1, blk_src_copy));
-        x -= 1;
-        if (x == 0) {
-            ASSERT_EQ(blk_src_copy, 0);
-            break;
-        }
-        blk_src_copy -= 1;
-    }
-
-    // Flush operations
-    ASSERT_TRUE(writer->Finalize());
-
-    // Construct the buffer required for validation
-    orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
-
-    // Read the entire base device
-    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), total_base_size_, 0),
-              true);
-
-    // Merged operations
-    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), writer->GetBlockSize(),
-                                               0),
-              true);
-    ASSERT_EQ(android::base::ReadFullyAtOffset(
-                      base_fd_, (char*)orig_buffer_.get() + writer->GetBlockSize(), size_, 0),
-              true);
-}
-
-void CowSnapuserdTest::CreateCowDeviceOrderedOpsInverted() {
-    unique_fd rnd_fd;
-    loff_t offset = 0;
-
-    auto writer = CreateCowDeviceInternal();
-    ASSERT_NE(writer, nullptr);
-
-    rnd_fd.reset(open("/dev/random", O_RDONLY));
-    ASSERT_TRUE(rnd_fd > 0);
-
-    std::unique_ptr<uint8_t[]> random_buffer_1_ = std::make_unique<uint8_t[]>(size_);
-
-    // Fill random data
-    for (size_t j = 0; j < (size_ / 1_MiB); j++) {
-        ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer_1_.get() + offset, 1_MiB, 0),
-                  true);
-
-        offset += 1_MiB;
-    }
-
-    size_t num_blocks = size_ / writer->GetBlockSize();
-    size_t blk_end_copy = num_blocks * 3;
-    size_t source_blk = num_blocks - 1;
-    size_t blk_src_copy = blk_end_copy - 1;
-    uint16_t xor_offset = 5;
-
-    size_t x = num_blocks;
-    while (1) {
-        ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
-        x -= 1;
-        if (x == 0) {
-            break;
-        }
-        source_blk -= 1;
-        blk_src_copy -= 1;
-    }
-
-    for (size_t i = num_blocks; i > 0; i--) {
-        ASSERT_TRUE(writer->AddXorBlocks(
-                num_blocks + i - 1, &random_buffer_1_.get()[writer->GetBlockSize() * (i - 1)],
-                writer->GetBlockSize(), 2 * num_blocks + i - 1, xor_offset));
-    }
-    // Flush operations
-    ASSERT_TRUE(writer->Finalize());
-    // Construct the buffer required for validation
-    orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
-    // Read the entire base device
-    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), total_base_size_, 0),
-              true);
-    // Merged Buffer
-    memmove(orig_buffer_.get(), (char*)orig_buffer_.get() + 2 * size_, size_);
-    memmove(orig_buffer_.get() + size_, (char*)orig_buffer_.get() + 2 * size_ + xor_offset, size_);
-    for (int i = 0; i < size_; i++) {
-        orig_buffer_.get()[size_ + i] ^= random_buffer_1_.get()[i];
-    }
-}
-
-void CowSnapuserdTest::CreateCowDeviceOrderedOps() {
-    unique_fd rnd_fd;
-    loff_t offset = 0;
-
-    auto writer = CreateCowDeviceInternal();
-    ASSERT_NE(writer, nullptr);
-
-    rnd_fd.reset(open("/dev/random", O_RDONLY));
-    ASSERT_TRUE(rnd_fd > 0);
-
-    std::unique_ptr<uint8_t[]> random_buffer_1_ = std::make_unique<uint8_t[]>(size_);
-
-    // Fill random data
-    for (size_t j = 0; j < (size_ / 1_MiB); j++) {
-        ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer_1_.get() + offset, 1_MiB, 0),
-                  true);
-
-        offset += 1_MiB;
-    }
-    memset(random_buffer_1_.get(), 0, size_);
-
-    size_t num_blocks = size_ / writer->GetBlockSize();
-    size_t x = num_blocks;
-    size_t source_blk = 0;
-    size_t blk_src_copy = 2 * num_blocks;
-    uint16_t xor_offset = 5;
-
-    while (1) {
-        ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
-
-        x -= 1;
-        if (x == 0) {
-            break;
-        }
-        source_blk += 1;
-        blk_src_copy += 1;
-    }
-
-    ASSERT_TRUE(writer->AddXorBlocks(num_blocks, random_buffer_1_.get(), size_, 2 * num_blocks,
-                                     xor_offset));
-    // Flush operations
-    ASSERT_TRUE(writer->Finalize());
-    // Construct the buffer required for validation
-    orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
-    // Read the entire base device
-    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), total_base_size_, 0),
-              true);
-    // Merged Buffer
-    memmove(orig_buffer_.get(), (char*)orig_buffer_.get() + 2 * size_, size_);
-    memmove(orig_buffer_.get() + size_, (char*)orig_buffer_.get() + 2 * size_ + xor_offset, size_);
-    for (int i = 0; i < size_; i++) {
-        orig_buffer_.get()[size_ + i] ^= random_buffer_1_.get()[i];
-    }
-}
-
-void CowSnapuserdTest::CreateCowDevice() {
-    unique_fd rnd_fd;
-    loff_t offset = 0;
-
-    auto writer = CreateCowDeviceInternal();
-    ASSERT_NE(writer, nullptr);
-
-    rnd_fd.reset(open("/dev/random", O_RDONLY));
-    ASSERT_TRUE(rnd_fd > 0);
-
-    std::unique_ptr<uint8_t[]> random_buffer_1_ = std::make_unique<uint8_t[]>(size_);
-
-    // Fill random data
-    for (size_t j = 0; j < (size_ / 1_MiB); j++) {
-        ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer_1_.get() + offset, 1_MiB, 0),
-                  true);
-
-        offset += 1_MiB;
-    }
-
-    size_t num_blocks = size_ / writer->GetBlockSize();
-    size_t blk_end_copy = num_blocks * 2;
-    size_t source_blk = num_blocks - 1;
-    size_t blk_src_copy = blk_end_copy - 1;
-
-    uint32_t sequence[num_blocks * 2];
-    // Sequence for Copy ops
-    for (int i = 0; i < num_blocks; i++) {
-        sequence[i] = num_blocks - 1 - i;
-    }
-    // Sequence for Xor ops
-    for (int i = 0; i < num_blocks; i++) {
-        sequence[num_blocks + i] = 5 * num_blocks - 1 - i;
-    }
-    ASSERT_TRUE(writer->AddSequenceData(2 * num_blocks, sequence));
-
-    size_t x = num_blocks;
-    while (1) {
-        ASSERT_TRUE(writer->AddCopy(source_blk, blk_src_copy));
-        x -= 1;
-        if (x == 0) {
-            break;
-        }
-        source_blk -= 1;
-        blk_src_copy -= 1;
-    }
-
-    source_blk = num_blocks;
-    blk_src_copy = blk_end_copy;
-
-    ASSERT_TRUE(writer->AddRawBlocks(source_blk, random_buffer_1_.get(), size_));
-
-    size_t blk_zero_copy_start = source_blk + num_blocks;
-    size_t blk_zero_copy_end = blk_zero_copy_start + num_blocks;
-
-    ASSERT_TRUE(writer->AddZeroBlocks(blk_zero_copy_start, num_blocks));
-
-    size_t blk_random2_replace_start = blk_zero_copy_end;
-
-    ASSERT_TRUE(writer->AddRawBlocks(blk_random2_replace_start, random_buffer_1_.get(), size_));
-
-    size_t blk_xor_start = blk_random2_replace_start + num_blocks;
-    size_t xor_offset = BLOCK_SZ / 2;
-    ASSERT_TRUE(writer->AddXorBlocks(blk_xor_start, random_buffer_1_.get(), size_, num_blocks,
-                                     xor_offset));
-
-    // Flush operations
-    ASSERT_TRUE(writer->Finalize());
-    // Construct the buffer required for validation
-    orig_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
-    std::string zero_buffer(size_, 0);
-    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, orig_buffer_.get(), size_, size_), true);
-    memcpy((char*)orig_buffer_.get() + size_, random_buffer_1_.get(), size_);
-    memcpy((char*)orig_buffer_.get() + (size_ * 2), (void*)zero_buffer.c_str(), size_);
-    memcpy((char*)orig_buffer_.get() + (size_ * 3), random_buffer_1_.get(), size_);
-    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, &orig_buffer_.get()[size_ * 4], size_,
-                                               size_ + xor_offset),
-              true);
-    for (int i = 0; i < size_; i++) {
-        orig_buffer_.get()[(size_ * 4) + i] =
-                (uint8_t)(orig_buffer_.get()[(size_ * 4) + i] ^ random_buffer_1_.get()[i]);
-    }
-}
-
-void CowSnapuserdTest::InitCowDevice() {
-    cow_num_sectors_ = client_->InitDmUserCow(system_device_ctrl_name_, cow_system_->path,
-                                              base_loop_->device());
-    ASSERT_NE(cow_num_sectors_, 0);
-}
-
-void CowSnapuserdTest::SetDeviceControlName() {
-    system_device_name_.clear();
-    system_device_ctrl_name_.clear();
-
-    std::string str(cow_system_->path);
-    std::size_t found = str.find_last_of("/\\");
-    ASSERT_NE(found, std::string::npos);
-    system_device_name_ = str.substr(found + 1);
-
-    system_device_ctrl_name_ = system_device_name_ + "-ctrl";
-}
-
-void CowSnapuserdTest::CreateDmUserDevice() {
-    DmTable dmuser_table;
-    ASSERT_TRUE(dmuser_table.AddTarget(
-            std::make_unique<DmTargetUser>(0, cow_num_sectors_, system_device_ctrl_name_)));
-    ASSERT_TRUE(dmuser_table.valid());
-
-    dmuser_dev_ = std::make_unique<TempDevice>(system_device_name_, dmuser_table);
-    ASSERT_TRUE(dmuser_dev_->valid());
-    ASSERT_FALSE(dmuser_dev_->path().empty());
-
-    auto misc_device = "/dev/dm-user/" + system_device_ctrl_name_;
-    ASSERT_TRUE(android::fs_mgr::WaitForFile(misc_device, 10s));
-}
-
-void CowSnapuserdTest::ReadDmUserBlockWithoutDaemon() {
-    DmTable dmuser_table;
-    std::string dm_user_name = "dm-test-device";
-    unique_fd fd;
-
-    // Create a dm-user block device
-    ASSERT_TRUE(dmuser_table.AddTarget(std::make_unique<DmTargetUser>(0, 123456, dm_user_name)));
-    ASSERT_TRUE(dmuser_table.valid());
-
-    dmuser_dev_ = std::make_unique<TempDevice>(dm_user_name, dmuser_table);
-    ASSERT_TRUE(dmuser_dev_->valid());
-    ASSERT_FALSE(dmuser_dev_->path().empty());
-
-    fd.reset(open(dmuser_dev_->path().c_str(), O_RDONLY));
-    ASSERT_GE(fd, 0);
-
-    std::unique_ptr<uint8_t[]> buffer = std::make_unique<uint8_t[]>(1_MiB);
-
-    loff_t offset = 0;
-    // Every IO should fail as there is no daemon to process the IO
-    for (size_t j = 0; j < 10; j++) {
-        ASSERT_EQ(ReadFullyAtOffset(fd, (char*)buffer.get() + offset, BLOCK_SZ, offset), false);
-
-        offset += BLOCK_SZ;
-    }
-
-    fd = {};
-    ASSERT_TRUE(dmuser_dev_->Destroy());
-}
-
-void CowSnapuserdTest::InitDaemon() {
-    bool ok = client_->AttachDmUser(system_device_ctrl_name_);
-    ASSERT_TRUE(ok);
-}
-
-void CowSnapuserdTest::CreateSnapshotDevice() {
-    DmTable snap_table;
-    ASSERT_TRUE(snap_table.AddTarget(std::make_unique<DmTargetSnapshot>(
-            0, total_base_size_ / kSectorSize, base_loop_->device(), dmuser_dev_->path(),
-            SnapshotStorageMode::Persistent, 8)));
-    ASSERT_TRUE(snap_table.valid());
-
-    snap_table.set_readonly(true);
-
-    snapshot_dev_ = std::make_unique<TempDevice>("cowsnapuserd-test-dm-snapshot", snap_table);
-    ASSERT_TRUE(snapshot_dev_->valid());
-    ASSERT_FALSE(snapshot_dev_->path().empty());
-}
-
-void CowSnapuserdTest::SetupImpl() {
-    CreateBaseDevice();
-    CreateCowDevice();
-
-    SetDeviceControlName();
-
-    StartSnapuserdDaemon();
-    InitCowDevice();
-
-    CreateDmUserDevice();
-    InitDaemon();
-
-    CreateSnapshotDevice();
-    setup_ok_ = true;
-}
-
-bool CowSnapuserdTest::Merge() {
-    MergeImpl();
-    return merge_ok_;
-}
-
-void CowSnapuserdTest::StartMerge() {
-    DmTable merge_table;
-    ASSERT_TRUE(merge_table.AddTarget(std::make_unique<DmTargetSnapshot>(
-            0, total_base_size_ / kSectorSize, base_loop_->device(), dmuser_dev_->path(),
-            SnapshotStorageMode::Merge, 8)));
-    ASSERT_TRUE(merge_table.valid());
-    ASSERT_EQ(total_base_size_ / kSectorSize, merge_table.num_sectors());
-
-    DeviceMapper& dm = DeviceMapper::Instance();
-    ASSERT_TRUE(dm.LoadTableAndActivate("cowsnapuserd-test-dm-snapshot", merge_table));
-}
-
-void CowSnapuserdTest::MergeImpl() {
-    StartMerge();
-    DeviceMapper& dm = DeviceMapper::Instance();
-
-    while (true) {
-        vector<DeviceMapper::TargetInfo> status;
-        ASSERT_TRUE(dm.GetTableStatus("cowsnapuserd-test-dm-snapshot", &status));
-        ASSERT_EQ(status.size(), 1);
-        ASSERT_EQ(strncmp(status[0].spec.target_type, "snapshot-merge", strlen("snapshot-merge")),
-                  0);
-
-        DmTargetSnapshot::Status merge_status;
-        ASSERT_TRUE(DmTargetSnapshot::ParseStatusText(status[0].data, &merge_status));
-        ASSERT_TRUE(merge_status.error.empty());
-        if (merge_status.sectors_allocated == merge_status.metadata_sectors) {
-            break;
-        }
-
-        std::this_thread::sleep_for(250ms);
-    }
-
-    merge_ok_ = true;
-}
-
-void CowSnapuserdTest::ValidateMerge() {
-    merged_buffer_ = std::make_unique<uint8_t[]>(total_base_size_);
-    ASSERT_EQ(android::base::ReadFullyAtOffset(base_fd_, merged_buffer_.get(), total_base_size_, 0),
-              true);
-    ASSERT_EQ(memcmp(merged_buffer_.get(), orig_buffer_.get(), total_base_size_), 0);
-}
-
-void CowSnapuserdTest::SimulateDaemonRestart() {
-    Shutdown();
-    std::this_thread::sleep_for(500ms);
-    SetDeviceControlName();
-    StartSnapuserdDaemon();
-    InitCowDevice();
-    CreateDmUserDevice();
-    InitDaemon();
-    CreateSnapshotDevice();
-}
-
-void CowSnapuserdTest::MergeInterruptRandomly(int max_duration) {
-    std::srand(std::time(nullptr));
-    StartMerge();
-
-    for (int i = 0; i < 20; i++) {
-        int duration = std::rand() % max_duration;
-        std::this_thread::sleep_for(std::chrono::milliseconds(duration));
-        SimulateDaemonRestart();
-        StartMerge();
-    }
-
-    SimulateDaemonRestart();
-    ASSERT_TRUE(Merge());
-}
-
-void CowSnapuserdTest::MergeInterruptFixed(int duration) {
-    StartMerge();
-
-    for (int i = 0; i < 25; i++) {
-        std::this_thread::sleep_for(std::chrono::milliseconds(duration));
-        SimulateDaemonRestart();
-        StartMerge();
-    }
-
-    SimulateDaemonRestart();
-    ASSERT_TRUE(Merge());
-}
-
-void CowSnapuserdTest::MergeInterrupt() {
-    // Interrupt merge at various intervals
-    StartMerge();
-    std::this_thread::sleep_for(250ms);
-    SimulateDaemonRestart();
-
-    StartMerge();
-    std::this_thread::sleep_for(250ms);
-    SimulateDaemonRestart();
-
-    StartMerge();
-    std::this_thread::sleep_for(150ms);
-    SimulateDaemonRestart();
-
-    StartMerge();
-    std::this_thread::sleep_for(100ms);
-    SimulateDaemonRestart();
-
-    StartMerge();
-    std::this_thread::sleep_for(800ms);
-    SimulateDaemonRestart();
-
-    StartMerge();
-    std::this_thread::sleep_for(600ms);
-    SimulateDaemonRestart();
-
-    ASSERT_TRUE(Merge());
-}
-
-std::unique_ptr<ICowWriter> CowSnapuserdMetadataTest::CreateCowDeviceInternal() {
-    std::string path = android::base::GetExecutableDirectory();
-    cow_system_ = std::make_unique<TemporaryFile>(path);
-
-    CowOptions options;
-    options.compression = "gz";
-
-    unique_fd fd(cow_system_->fd);
-    cow_system_->fd = -1;
-
-    return CreateCowWriter(kDefaultCowVersion, options, std::move(fd));
-}
-
-void CowSnapuserdMetadataTest::CreateCowPartialFilledArea() {
-    auto writer = CreateCowDeviceInternal();
-    ASSERT_NE(writer, nullptr);
-
-    // Area 0 is completely filled with 256 exceptions
-    for (int i = 0; i < 256; i++) {
-        ASSERT_TRUE(writer->AddCopy(i, 256 + i));
-    }
-
-    // Area 1 is partially filled with 2 copy ops and 10 zero ops
-    ASSERT_TRUE(writer->AddCopy(500, 1000));
-    ASSERT_TRUE(writer->AddCopy(501, 1001));
-
-    ASSERT_TRUE(writer->AddZeroBlocks(300, 10));
-
-    // Flush operations
-    ASSERT_TRUE(writer->Finalize());
-}
-
-void CowSnapuserdMetadataTest::ValidatePartialFilledArea() {
-    int area_sz = snapuserd_->GetMetadataAreaSize();
-
-    ASSERT_EQ(area_sz, 2);
-
-    // Verify the partially filled area
-    void* buffer = snapuserd_->GetExceptionBuffer(1);
-    loff_t offset = 0;
-    struct disk_exception* de;
-    for (int i = 11; i >= 0; i--) {
-        de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-        ASSERT_EQ(de->old_chunk, i);
-        offset += sizeof(struct disk_exception);
-    }
-
-    de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-    ASSERT_EQ(de->old_chunk, 0);
-    ASSERT_EQ(de->new_chunk, 0);
-}
-
-void CowSnapuserdMetadataTest::SetupPartialArea() {
-    CreateCowPartialFilledArea();
-    InitMetadata();
-}
-
-void CowSnapuserdMetadataTest::CreateCowDevice() {
-    unique_fd rnd_fd;
-    loff_t offset = 0;
-
-    auto writer = CreateCowDeviceInternal();
-    ASSERT_NE(writer, nullptr);
-
-    rnd_fd.reset(open("/dev/random", O_RDONLY));
-    ASSERT_TRUE(rnd_fd > 0);
-
-    std::unique_ptr<uint8_t[]> random_buffer_1_ = std::make_unique<uint8_t[]>(size_);
-
-    // Fill random data
-    for (size_t j = 0; j < (size_ / 1_MiB); j++) {
-        ASSERT_EQ(ReadFullyAtOffset(rnd_fd, (char*)random_buffer_1_.get() + offset, 1_MiB, 0),
-                  true);
-
-        offset += 1_MiB;
-    }
-
-    size_t num_blocks = size_ / writer->GetBlockSize();
-
-    // Overlapping region. This has to be split
-    // into two batch operations
-    ASSERT_TRUE(writer->AddCopy(23, 20));
-    ASSERT_TRUE(writer->AddCopy(22, 19));
-    ASSERT_TRUE(writer->AddCopy(21, 18));
-    ASSERT_TRUE(writer->AddCopy(20, 17));
-    ASSERT_TRUE(writer->AddCopy(19, 16));
-    ASSERT_TRUE(writer->AddCopy(18, 15));
-
-    // Contiguous region but blocks in ascending order
-    // Daemon has to ensure that these blocks are merged
-    // in a batch
-    ASSERT_TRUE(writer->AddCopy(50, 75));
-    ASSERT_TRUE(writer->AddCopy(51, 76));
-    ASSERT_TRUE(writer->AddCopy(52, 77));
-    ASSERT_TRUE(writer->AddCopy(53, 78));
-
-    // Dis-contiguous region
-    ASSERT_TRUE(writer->AddCopy(110, 130));
-    ASSERT_TRUE(writer->AddCopy(105, 125));
-    ASSERT_TRUE(writer->AddCopy(100, 120));
-
-    // Overlap
-    ASSERT_TRUE(writer->AddCopy(25, 30));
-    ASSERT_TRUE(writer->AddCopy(30, 31));
-
-    size_t source_blk = num_blocks;
-
-    ASSERT_TRUE(writer->AddRawBlocks(source_blk, random_buffer_1_.get(), size_));
-
-    size_t blk_zero_copy_start = source_blk + num_blocks;
-
-    ASSERT_TRUE(writer->AddZeroBlocks(blk_zero_copy_start, num_blocks));
-
-    // Flush operations
-    ASSERT_TRUE(writer->Finalize());
-}
-
-void CowSnapuserdMetadataTest::InitMetadata() {
-    snapuserd_ = std::make_unique<Snapuserd>("", cow_system_->path, "");
-    ASSERT_TRUE(snapuserd_->InitCowDevice());
-}
-
-void CowSnapuserdMetadataTest::Setup() {
-    CreateCowDevice();
-    InitMetadata();
-}
-
-void CowSnapuserdMetadataTest::ValidateMetadata() {
-    int area_sz = snapuserd_->GetMetadataAreaSize();
-    ASSERT_EQ(area_sz, 3);
-
-    size_t old_chunk;
-    size_t new_chunk;
-
-    for (int i = 0; i < area_sz; i++) {
-        void* buffer = snapuserd_->GetExceptionBuffer(i);
-        loff_t offset = 0;
-        if (i == 0) {
-            old_chunk = 256;
-            new_chunk = 2;
-        } else if (i == 1) {
-            old_chunk = 512;
-            new_chunk = 259;
-        }
-        for (int j = 0; j < 256; j++) {
-            struct disk_exception* de =
-                    reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-
-            if (i != 2) {
-                ASSERT_EQ(de->old_chunk, old_chunk);
-                ASSERT_EQ(de->new_chunk, new_chunk);
-                old_chunk += 1;
-                new_chunk += 1;
-            } else {
-                break;
-            }
-            offset += sizeof(struct disk_exception);
-        }
-
-        if (i == 2) {
-            // The first 5 copy operation is not batch merged
-            // as the sequence is discontiguous
-            struct disk_exception* de =
-                    reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 30);
-            ASSERT_EQ(de->new_chunk, 518);
-            offset += sizeof(struct disk_exception);
-
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 25);
-            ASSERT_EQ(de->new_chunk, 520);
-            offset += sizeof(struct disk_exception);
-
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 100);
-            ASSERT_EQ(de->new_chunk, 521);
-            offset += sizeof(struct disk_exception);
-
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 105);
-            ASSERT_EQ(de->new_chunk, 522);
-            offset += sizeof(struct disk_exception);
-
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 110);
-            ASSERT_EQ(de->new_chunk, 523);
-            offset += sizeof(struct disk_exception);
-
-            // The next 4 operations are batch merged as
-            // both old and new chunk are contiguous
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 53);
-            ASSERT_EQ(de->new_chunk, 524);
-            offset += sizeof(struct disk_exception);
-
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 52);
-            ASSERT_EQ(de->new_chunk, 525);
-            offset += sizeof(struct disk_exception);
-
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 51);
-            ASSERT_EQ(de->new_chunk, 526);
-            offset += sizeof(struct disk_exception);
-
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 50);
-            ASSERT_EQ(de->new_chunk, 527);
-            offset += sizeof(struct disk_exception);
-
-            // This is handling overlap operation with
-            // two batch merge operations.
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 18);
-            ASSERT_EQ(de->new_chunk, 528);
-            offset += sizeof(struct disk_exception);
-
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 19);
-            ASSERT_EQ(de->new_chunk, 529);
-            offset += sizeof(struct disk_exception);
-
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 20);
-            ASSERT_EQ(de->new_chunk, 530);
-            offset += sizeof(struct disk_exception);
-
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 21);
-            ASSERT_EQ(de->new_chunk, 532);
-            offset += sizeof(struct disk_exception);
-
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 22);
-            ASSERT_EQ(de->new_chunk, 533);
-            offset += sizeof(struct disk_exception);
-
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 23);
-            ASSERT_EQ(de->new_chunk, 534);
-            offset += sizeof(struct disk_exception);
-
-            // End of metadata
-            de = reinterpret_cast<struct disk_exception*>((char*)buffer + offset);
-            ASSERT_EQ(de->old_chunk, 0);
-            ASSERT_EQ(de->new_chunk, 0);
-            offset += sizeof(struct disk_exception);
-        }
-    }
-}
-
-TEST(Snapuserd_Test, Snapshot_Metadata) {
-    CowSnapuserdMetadataTest harness;
-    harness.Setup();
-    harness.ValidateMetadata();
-}
-
-TEST(Snapuserd_Test, Snapshot_Metadata_Overlap) {
-    CowSnapuserdMetadataTest harness;
-    harness.SetupPartialArea();
-    harness.ValidatePartialFilledArea();
-}
-
-TEST(Snapuserd_Test, Snapshot_Merge_Resume) {
-    CowSnapuserdTest harness;
-    ASSERT_TRUE(harness.Setup());
-    harness.MergeInterrupt();
-    harness.ValidateMerge();
-    harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_IO_TEST) {
-    CowSnapuserdTest harness;
-    ASSERT_TRUE(harness.Setup());
-    harness.ReadSnapshotDeviceAndValidate();
-    ASSERT_TRUE(harness.Merge());
-    harness.ValidateMerge();
-    harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_END_IO_TEST) {
-    CowSnapuserdTest harness;
-    harness.ReadLastBlock();
-    harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_COPY_Overlap_TEST_1) {
-    CowSnapuserdTest harness;
-    ASSERT_TRUE(harness.SetupCopyOverlap_1());
-    ASSERT_TRUE(harness.Merge());
-    harness.ValidateMerge();
-    harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_COPY_Overlap_TEST_2) {
-    CowSnapuserdTest harness;
-    ASSERT_TRUE(harness.SetupCopyOverlap_2());
-    ASSERT_TRUE(harness.Merge());
-    harness.ValidateMerge();
-    harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_COPY_Overlap_Merge_Resume_TEST) {
-    CowSnapuserdTest harness;
-    ASSERT_TRUE(harness.SetupCopyOverlap_1());
-    harness.MergeInterrupt();
-    harness.ValidateMerge();
-    harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, ReadDmUserBlockWithoutDaemon) {
-    CowSnapuserdTest harness;
-    harness.ReadDmUserBlockWithoutDaemon();
-}
-
-TEST(Snapuserd_Test, Snapshot_Merge_Crash_Fixed_Ordered) {
-    CowSnapuserdTest harness;
-    ASSERT_TRUE(harness.SetupOrderedOps());
-    harness.MergeInterruptFixed(300);
-    harness.ValidateMerge();
-    harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_Merge_Crash_Random_Ordered) {
-    CowSnapuserdTest harness;
-    ASSERT_TRUE(harness.SetupOrderedOps());
-    harness.MergeInterruptRandomly(500);
-    harness.ValidateMerge();
-    harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_Merge_Crash_Fixed_Inverted) {
-    CowSnapuserdTest harness;
-    ASSERT_TRUE(harness.SetupOrderedOpsInverted());
-    harness.MergeInterruptFixed(50);
-    harness.ValidateMerge();
-    harness.Shutdown();
-}
-
-TEST(Snapuserd_Test, Snapshot_Merge_Crash_Random_Inverted) {
-    CowSnapuserdTest harness;
-    ASSERT_TRUE(harness.SetupOrderedOpsInverted());
-    harness.MergeInterruptRandomly(50);
-    harness.ValidateMerge();
-    harness.Shutdown();
-}
-
-}  // namespace snapshot
-}  // namespace android
-
-int main(int argc, char** argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-    return RUN_ALL_TESTS();
-}
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
deleted file mode 100644
index 93bb0b2de617..000000000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp
+++ /dev/null
@@ -1,870 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "snapuserd.h"
-
-#include <dirent.h>
-#include <fcntl.h>
-#include <linux/fs.h>
-#include <unistd.h>
-#include <algorithm>
-
-#include <csignal>
-#include <optional>
-#include <set>
-
-#include <android-base/file.h>
-#include <android-base/logging.h>
-#include <android-base/parseint.h>
-#include <android-base/properties.h>
-#include <android-base/strings.h>
-#include <android-base/unique_fd.h>
-#include <snapuserd/snapuserd_client.h>
-
-namespace android {
-namespace snapshot {
-
-using namespace android;
-using namespace android::dm;
-using android::base::unique_fd;
-
-#define SNAP_LOG(level) LOG(level) << misc_name_ << ": "
-#define SNAP_PLOG(level) PLOG(level) << misc_name_ << ": "
-
-Snapuserd::Snapuserd(const std::string& misc_name, const std::string& cow_device,
-                     const std::string& backing_device) {
-    misc_name_ = misc_name;
-    cow_device_ = cow_device;
-    backing_store_device_ = backing_device;
-    control_device_ = "/dev/dm-user/" + misc_name;
-}
-
-bool Snapuserd::InitializeWorkers() {
-    for (int i = 0; i < NUM_THREADS_PER_PARTITION; i++) {
-        std::unique_ptr<WorkerThread> wt = std::make_unique<WorkerThread>(
-                cow_device_, backing_store_device_, control_device_, misc_name_, GetSharedPtr());
-
-        worker_threads_.push_back(std::move(wt));
-    }
-
-    read_ahead_thread_ = std::make_unique<ReadAheadThread>(cow_device_, backing_store_device_,
-                                                           misc_name_, GetSharedPtr());
-    return true;
-}
-
-std::unique_ptr<CowReader> Snapuserd::CloneReaderForWorker() {
-    return reader_->CloneCowReader();
-}
-
-bool Snapuserd::CommitMerge(int num_merge_ops) {
-    struct CowHeader* ch = reinterpret_cast<struct CowHeader*>(mapped_addr_);
-    ch->num_merge_ops += num_merge_ops;
-
-    if (read_ahead_feature_ && read_ahead_ops_.size() > 0) {
-        struct BufferState* ra_state = GetBufferState();
-        ra_state->read_ahead_state = kCowReadAheadInProgress;
-    }
-
-    int ret = msync(mapped_addr_, BLOCK_SZ, MS_SYNC);
-    if (ret < 0) {
-        SNAP_PLOG(ERROR) << "msync header failed: " << ret;
-        return false;
-    }
-
-    merge_initiated_ = true;
-
-    return true;
-}
-
-void Snapuserd::PrepareReadAhead() {
-    if (!read_ahead_feature_) {
-        return;
-    }
-
-    struct BufferState* ra_state = GetBufferState();
-    // Check if the data has to be re-constructed from COW device
-    if (ra_state->read_ahead_state == kCowReadAheadDone) {
-        populate_data_from_cow_ = true;
-    } else {
-        populate_data_from_cow_ = false;
-    }
-
-    StartReadAhead();
-}
-
-bool Snapuserd::GetRABuffer(std::unique_lock<std::mutex>* lock, uint64_t block, void* buffer) {
-    if (!lock->owns_lock()) {
-        SNAP_LOG(ERROR) << "GetRABuffer - Lock not held";
-        return false;
-    }
-    std::unordered_map<uint64_t, void*>::iterator it = read_ahead_buffer_map_.find(block);
-
-    // This will be true only for IO's generated as part of reading a root
-    // filesystem. IO's related to merge should always be in read-ahead cache.
-    if (it == read_ahead_buffer_map_.end()) {
-        return false;
-    }
-
-    // Theoretically, we can send the data back from the read-ahead buffer
-    // all the way to the kernel without memcpy. However, if the IO is
-    // un-aligned, the wrapper function will need to touch the read-ahead
-    // buffers and transitions will be bit more complicated.
-    memcpy(buffer, it->second, BLOCK_SZ);
-    return true;
-}
-
-// ========== State transition functions for read-ahead operations ===========
-
-bool Snapuserd::GetReadAheadPopulatedBuffer(uint64_t block, void* buffer) {
-    if (!read_ahead_feature_) {
-        return false;
-    }
-
-    {
-        std::unique_lock<std::mutex> lock(lock_);
-        if (io_state_ == READ_AHEAD_IO_TRANSITION::READ_AHEAD_FAILURE) {
-            return false;
-        }
-
-        if (io_state_ == READ_AHEAD_IO_TRANSITION::IO_IN_PROGRESS) {
-            return GetRABuffer(&lock, block, buffer);
-        }
-    }
-
-    {
-        // Read-ahead thread IO is in-progress. Wait for it to complete
-        std::unique_lock<std::mutex> lock(lock_);
-        while (!(io_state_ == READ_AHEAD_IO_TRANSITION::READ_AHEAD_FAILURE ||
-                 io_state_ == READ_AHEAD_IO_TRANSITION::IO_IN_PROGRESS)) {
-            cv.wait(lock);
-        }
-
-        return GetRABuffer(&lock, block, buffer);
-    }
-}
-
-// This is invoked by read-ahead thread waiting for merge IO's
-// to complete
-bool Snapuserd::WaitForMergeToComplete() {
-    {
-        std::unique_lock<std::mutex> lock(lock_);
-        while (!(io_state_ == READ_AHEAD_IO_TRANSITION::READ_AHEAD_BEGIN ||
-                 io_state_ == READ_AHEAD_IO_TRANSITION::IO_TERMINATED)) {
-            cv.wait(lock);
-        }
-
-        if (io_state_ == READ_AHEAD_IO_TRANSITION::IO_TERMINATED) {
-            return false;
-        }
-
-        io_state_ = READ_AHEAD_IO_TRANSITION::READ_AHEAD_IN_PROGRESS;
-        return true;
-    }
-}
-
-// This is invoked during the launch of worker threads. We wait
-// for read-ahead thread to by fully up before worker threads
-// are launched; else we will have a race between worker threads
-// and read-ahead thread specifically during re-construction.
-bool Snapuserd::WaitForReadAheadToStart() {
-    {
-        std::unique_lock<std::mutex> lock(lock_);
-        while (!(io_state_ == READ_AHEAD_IO_TRANSITION::IO_IN_PROGRESS ||
-                 io_state_ == READ_AHEAD_IO_TRANSITION::READ_AHEAD_FAILURE)) {
-            cv.wait(lock);
-        }
-
-        if (io_state_ == READ_AHEAD_IO_TRANSITION::READ_AHEAD_FAILURE) {
-            return false;
-        }
-
-        return true;
-    }
-}
-
-// Invoked by worker threads when a sequence of merge operation
-// is complete notifying read-ahead thread to make forward
-// progress.
-void Snapuserd::StartReadAhead() {
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        io_state_ = READ_AHEAD_IO_TRANSITION::READ_AHEAD_BEGIN;
-    }
-
-    cv.notify_one();
-}
-
-void Snapuserd::MergeCompleted() {
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        io_state_ = READ_AHEAD_IO_TRANSITION::IO_TERMINATED;
-    }
-
-    cv.notify_one();
-}
-
-bool Snapuserd::ReadAheadIOCompleted(bool sync) {
-    if (sync) {
-        // Flush the entire buffer region
-        int ret = msync(mapped_addr_, total_mapped_addr_length_, MS_SYNC);
-        if (ret < 0) {
-            PLOG(ERROR) << "msync failed after ReadAheadIOCompleted: " << ret;
-            return false;
-        }
-
-        // Metadata and data are synced. Now, update the state.
-        // We need to update the state after flushing data; if there is a crash
-        // when read-ahead IO is in progress, the state of data in the COW file
-        // is unknown. kCowReadAheadDone acts as a checkpoint wherein the data
-        // in the scratch space is good and during next reboot, read-ahead thread
-        // can safely re-construct the data.
-        struct BufferState* ra_state = GetBufferState();
-        ra_state->read_ahead_state = kCowReadAheadDone;
-
-        ret = msync(mapped_addr_, BLOCK_SZ, MS_SYNC);
-        if (ret < 0) {
-            PLOG(ERROR) << "msync failed to flush Readahead completion state...";
-            return false;
-        }
-    }
-
-    // Notify the worker threads
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        io_state_ = READ_AHEAD_IO_TRANSITION::IO_IN_PROGRESS;
-    }
-
-    cv.notify_all();
-    return true;
-}
-
-void Snapuserd::ReadAheadIOFailed() {
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        io_state_ = READ_AHEAD_IO_TRANSITION::READ_AHEAD_FAILURE;
-    }
-
-    cv.notify_all();
-}
-
-//========== End of state transition functions ====================
-
-bool Snapuserd::IsChunkIdMetadata(chunk_t chunk) {
-    uint32_t stride = exceptions_per_area_ + 1;
-    lldiv_t divresult = lldiv(chunk, stride);
-
-    return (divresult.rem == NUM_SNAPSHOT_HDR_CHUNKS);
-}
-
-// Find the next free chunk-id to be assigned. Check if the next free
-// chunk-id represents a metadata page. If so, skip it.
-chunk_t Snapuserd::GetNextAllocatableChunkId(chunk_t chunk) {
-    chunk_t next_chunk = chunk + 1;
-
-    if (IsChunkIdMetadata(next_chunk)) {
-        next_chunk += 1;
-    }
-    return next_chunk;
-}
-
-void Snapuserd::CheckMergeCompletionStatus() {
-    if (!merge_initiated_) {
-        SNAP_LOG(INFO) << "Merge was not initiated. Total-data-ops: "
-                       << reader_->get_num_total_data_ops();
-        return;
-    }
-
-    struct CowHeader* ch = reinterpret_cast<struct CowHeader*>(mapped_addr_);
-
-    SNAP_LOG(INFO) << "Merge-status: Total-Merged-ops: " << ch->num_merge_ops
-                   << " Total-data-ops: " << reader_->get_num_total_data_ops();
-}
-
-/*
- * Read the metadata from COW device and
- * construct the metadata as required by the kernel.
- *
- * Please see design on kernel COW format
- *
- * 1: Read the metadata from internal COW device
- * 2: There are 3 COW operations:
- *     a: Replace op
- *     b: Copy op
- *     c: Zero op
- * 3: For each of the 3 operations, op->new_block
- *    represents the block number in the base device
- *    for which one of the 3 operations have to be applied.
- *    This represents the old_chunk in the kernel COW format
- * 4: We need to assign new_chunk for a corresponding old_chunk
- * 5: The algorithm is similar to how kernel assigns chunk number
- *    while creating exceptions. However, there are few cases
- *    which needs to be addressed here:
- *      a: During merge process, kernel scans the metadata page
- *      from backwards when merge is initiated. Since, we need
- *      to make sure that the merge ordering follows our COW format,
- *      we read the COW operation from backwards and populate the
- *      metadata so that when kernel starts the merging from backwards,
- *      those ops correspond to the beginning of our COW format.
- *      b: Kernel can merge successive operations if the two chunk IDs
- *      are contiguous. This can be problematic when there is a crash
- *      during merge; specifically when the merge operation has dependency.
- *      These dependencies can only happen during copy operations.
- *
- *      To avoid this problem, we make sure overlap copy operations
- *      are not batch merged.
- * 6: Use a monotonically increasing chunk number to assign the
- *    new_chunk
- * 7: Each chunk-id represents either
- *        a: Metadata page or
- *        b: Data page
- * 8: Chunk-id representing a data page is stored in a map.
- * 9: Chunk-id representing a metadata page is converted into a vector
- *    index. We store this in vector as kernel requests metadata during
- *    two stage:
- *       a: When initial dm-snapshot device is created, kernel requests
- *          all the metadata and stores it in its internal data-structures.
- *       b: During merge, kernel once again requests the same metadata
- *          once-again.
- *    In both these cases, a quick lookup based on chunk-id is done.
- * 10: When chunk number is incremented, we need to make sure that
- *    if the chunk is representing a metadata page and skip.
- * 11: Each 4k page will contain 256 disk exceptions. We call this
- *    exceptions_per_area_
- * 12: Kernel will stop issuing metadata IO request when new-chunk ID is 0.
- */
-bool Snapuserd::ReadMetadata() {
-    reader_ = std::make_unique<CowReader>();
-    CowOptions options;
-    bool metadata_found = false;
-    int replace_ops = 0, zero_ops = 0, copy_ops = 0;
-
-    SNAP_LOG(DEBUG) << "ReadMetadata: Parsing cow file";
-
-    if (!reader_->Parse(cow_fd_)) {
-        SNAP_LOG(ERROR) << "Failed to parse";
-        return false;
-    }
-
-    const auto& header = reader_->GetHeader();
-    if (!(header.block_size == BLOCK_SZ)) {
-        SNAP_LOG(ERROR) << "Invalid header block size found: " << header.block_size;
-        return false;
-    }
-
-    SNAP_LOG(DEBUG) << "Merge-ops: " << header.num_merge_ops;
-
-    if (!MmapMetadata()) {
-        SNAP_LOG(ERROR) << "mmap failed";
-        return false;
-    }
-
-    // Initialize the iterator for reading metadata
-    std::unique_ptr<ICowOpIter> cowop_rm_iter = reader_->GetRevMergeOpIter();
-
-    exceptions_per_area_ = (CHUNK_SIZE << SECTOR_SHIFT) / sizeof(struct disk_exception);
-
-    // Start from chunk number 2. Chunk 0 represents header and chunk 1
-    // represents first metadata page.
-    chunk_t data_chunk_id = NUM_SNAPSHOT_HDR_CHUNKS + 1;
-    size_t num_ops = 0;
-
-    loff_t offset = 0;
-    std::unique_ptr<uint8_t[]> de_ptr =
-            std::make_unique<uint8_t[]>(exceptions_per_area_ * sizeof(struct disk_exception));
-
-    // This memset is important. Kernel will stop issuing IO when new-chunk ID
-    // is 0. When Area is not filled completely with all 256 exceptions,
-    // this memset will ensure that metadata read is completed.
-    memset(de_ptr.get(), 0, (exceptions_per_area_ * sizeof(struct disk_exception)));
-
-    while (!cowop_rm_iter->AtEnd()) {
-        const CowOperation* cow_op = cowop_rm_iter->Get();
-        struct disk_exception* de =
-                reinterpret_cast<struct disk_exception*>((char*)de_ptr.get() + offset);
-
-        metadata_found = true;
-        // This loop will handle all the replace and zero ops.
-        // We will handle the copy ops later as it requires special
-        // handling of assigning chunk-id's. Furthermore, we make
-        // sure that replace/zero and copy ops are not batch merged; hence,
-        // the bump in the chunk_id before break of this loop
-        if (IsOrderedOp(*cow_op)) {
-            data_chunk_id = GetNextAllocatableChunkId(data_chunk_id);
-            break;
-        }
-
-        if (cow_op->type() == kCowReplaceOp) {
-            replace_ops++;
-        } else if (cow_op->type() == kCowZeroOp) {
-            zero_ops++;
-        }
-
-        // Construct the disk-exception
-        de->old_chunk = cow_op->new_block;
-        de->new_chunk = data_chunk_id;
-
-        // Store operation pointer.
-        chunk_vec_.push_back(std::make_pair(ChunkToSector(data_chunk_id), cow_op));
-        num_ops += 1;
-        offset += sizeof(struct disk_exception);
-        cowop_rm_iter->Next();
-
-        SNAP_LOG(DEBUG) << num_ops << ":"
-                        << " Old-chunk: " << de->old_chunk << " New-chunk: " << de->new_chunk;
-
-        if (num_ops == exceptions_per_area_) {
-            // Store it in vector at the right index. This maps the chunk-id to
-            // vector index.
-            vec_.push_back(std::move(de_ptr));
-            offset = 0;
-            num_ops = 0;
-
-            // Create buffer for next area
-            de_ptr = std::make_unique<uint8_t[]>(exceptions_per_area_ *
-                                                 sizeof(struct disk_exception));
-            memset(de_ptr.get(), 0, (exceptions_per_area_ * sizeof(struct disk_exception)));
-
-            if (cowop_rm_iter->AtEnd()) {
-                vec_.push_back(std::move(de_ptr));
-            }
-        }
-
-        data_chunk_id = GetNextAllocatableChunkId(data_chunk_id);
-    }
-
-    int num_ra_ops_per_iter = ((GetBufferDataSize()) / BLOCK_SZ);
-    std::optional<chunk_t> prev_id = {};
-    std::vector<const CowOperation*> vec;
-    std::set<uint64_t> dest_blocks;
-    std::set<uint64_t> source_blocks;
-    size_t pending_ordered_ops = exceptions_per_area_ - num_ops;
-    uint64_t total_ordered_ops = reader_->get_num_ordered_ops_to_merge();
-
-    SNAP_LOG(DEBUG) << " Processing copy-ops at Area: " << vec_.size()
-                    << " Number of replace/zero ops completed in this area: " << num_ops
-                    << " Pending copy ops for this area: " << pending_ordered_ops;
-
-    while (!cowop_rm_iter->AtEnd()) {
-        do {
-            const CowOperation* cow_op = cowop_rm_iter->Get();
-
-            // We have two cases specific cases:
-            //
-            // =====================================================
-            // Case 1: Overlapping copy regions
-            //
-            // Ex:
-            //
-            // Source -> Destination
-            //
-            // 1: 15 -> 18
-            // 2: 16 -> 19
-            // 3: 17 -> 20
-            // 4: 18 -> 21
-            // 5: 19 -> 22
-            // 6: 20 -> 23
-            //
-            // We have 6 copy operations to be executed in OTA and there is a overlap. Update-engine
-            // will write to COW file as follows:
-            //
-            // Op-1: 20 -> 23
-            // Op-2: 19 -> 22
-            // Op-3: 18 -> 21
-            // Op-4: 17 -> 20
-            // Op-5: 16 -> 19
-            // Op-6: 15 -> 18
-            //
-            // Note that the blocks numbers are contiguous. Hence, all 6 copy
-            // operations can be batch merged. However, that will be
-            // problematic if we have a crash as block 20, 19, 18 would have
-            // been overwritten and hence subsequent recovery may end up with
-            // a silent data corruption when op-1, op-2 and op-3 are
-            // re-executed.
-            //
-            // To address the above problem, read-ahead thread will
-            // read all the 6 source blocks, cache them in the scratch
-            // space of the COW file. During merge, read-ahead
-            // thread will serve the blocks from the read-ahead cache.
-            // If there is a crash during merge; on subsequent reboot,
-            // read-ahead thread will recover the data from the
-            // scratch space and re-construct it thereby there
-            // is no loss of data.
-            //
-            // Note that we will follow the same order of COW operations
-            // as present in the COW file. This will make sure that
-            // the merge of operations are done based on the ops present
-            // in the file.
-            //===========================================================
-            uint64_t block_source = cow_op->source();
-            if (prev_id.has_value()) {
-                if (dest_blocks.count(cow_op->new_block) || source_blocks.count(block_source)) {
-                    break;
-                }
-            }
-            metadata_found = true;
-            pending_ordered_ops -= 1;
-            vec.push_back(cow_op);
-            dest_blocks.insert(block_source);
-            source_blocks.insert(cow_op->new_block);
-            prev_id = cow_op->new_block;
-            cowop_rm_iter->Next();
-        } while (!cowop_rm_iter->AtEnd() && pending_ordered_ops);
-
-        data_chunk_id = GetNextAllocatableChunkId(data_chunk_id);
-        SNAP_LOG(DEBUG) << "Batch Merge copy-ops of size: " << vec.size()
-                        << " Area: " << vec_.size() << " Area offset: " << offset
-                        << " Pending-ordered-ops in this area: " << pending_ordered_ops;
-
-        for (size_t i = 0; i < vec.size(); i++) {
-            struct disk_exception* de =
-                    reinterpret_cast<struct disk_exception*>((char*)de_ptr.get() + offset);
-            const CowOperation* cow_op = vec[i];
-
-            de->old_chunk = cow_op->new_block;
-            de->new_chunk = data_chunk_id;
-
-            // Store operation pointer.
-            chunk_vec_.push_back(std::make_pair(ChunkToSector(data_chunk_id), cow_op));
-            offset += sizeof(struct disk_exception);
-            num_ops += 1;
-            if (cow_op->type() == kCowCopyOp) {
-                copy_ops++;
-            }
-
-            if (read_ahead_feature_) {
-                read_ahead_ops_.push_back(cow_op);
-            }
-
-            SNAP_LOG(DEBUG) << num_ops << ":"
-                            << " Ordered-op: "
-                            << " Old-chunk: " << de->old_chunk << " New-chunk: " << de->new_chunk;
-
-            if (num_ops == exceptions_per_area_) {
-                // Store it in vector at the right index. This maps the chunk-id to
-                // vector index.
-                vec_.push_back(std::move(de_ptr));
-                num_ops = 0;
-                offset = 0;
-
-                // Create buffer for next area
-                de_ptr = std::make_unique<uint8_t[]>(exceptions_per_area_ *
-                                                     sizeof(struct disk_exception));
-                memset(de_ptr.get(), 0, (exceptions_per_area_ * sizeof(struct disk_exception)));
-
-                if (cowop_rm_iter->AtEnd()) {
-                    vec_.push_back(std::move(de_ptr));
-                    SNAP_LOG(DEBUG) << "ReadMetadata() completed; Number of Areas: " << vec_.size();
-                }
-
-                if (!(pending_ordered_ops == 0)) {
-                    SNAP_LOG(ERROR) << "Invalid pending_ordered_ops: expected: 0 found: "
-                                    << pending_ordered_ops;
-                    return false;
-                }
-                pending_ordered_ops = exceptions_per_area_;
-            }
-
-            data_chunk_id = GetNextAllocatableChunkId(data_chunk_id);
-            total_ordered_ops -= 1;
-            /*
-             * Split the number of ops based on the size of read-ahead buffer
-             * region. We need to ensure that kernel doesn't issue IO on blocks
-             * which are not read by the read-ahead thread.
-             */
-            if (read_ahead_feature_ && (total_ordered_ops % num_ra_ops_per_iter == 0)) {
-                data_chunk_id = GetNextAllocatableChunkId(data_chunk_id);
-            }
-        }
-        vec.clear();
-        dest_blocks.clear();
-        source_blocks.clear();
-        prev_id.reset();
-    }
-
-    // Partially filled area or there is no metadata
-    // If there is no metadata, fill with zero so that kernel
-    // is aware that merge is completed.
-    if (num_ops || !metadata_found) {
-        vec_.push_back(std::move(de_ptr));
-        SNAP_LOG(DEBUG) << "ReadMetadata() completed. Partially filled area num_ops: " << num_ops
-                        << "Areas : " << vec_.size();
-    }
-
-    chunk_vec_.shrink_to_fit();
-    vec_.shrink_to_fit();
-    read_ahead_ops_.shrink_to_fit();
-
-    // Sort the vector based on sectors as we need this during un-aligned access
-    std::sort(chunk_vec_.begin(), chunk_vec_.end(), compare);
-
-    SNAP_LOG(INFO) << "ReadMetadata completed. Final-chunk-id: " << data_chunk_id
-                   << " Num Sector: " << ChunkToSector(data_chunk_id)
-                   << " Replace-ops: " << replace_ops << " Zero-ops: " << zero_ops
-                   << " Copy-ops: " << copy_ops << " Areas: " << vec_.size()
-                   << " Num-ops-merged: " << header.num_merge_ops
-                   << " Total-data-ops: " << reader_->get_num_total_data_ops();
-
-    // Total number of sectors required for creating dm-user device
-    num_sectors_ = ChunkToSector(data_chunk_id);
-    merge_initiated_ = false;
-    PrepareReadAhead();
-
-    return true;
-}
-
-bool Snapuserd::MmapMetadata() {
-    const auto& header = reader_->GetHeader();
-
-    if (header.prefix.major_version >= 2 && header.buffer_size > 0) {
-        total_mapped_addr_length_ = header.prefix.header_size + BUFFER_REGION_DEFAULT_SIZE;
-        read_ahead_feature_ = true;
-    } else {
-        // mmap the first 4k page - older COW format
-        total_mapped_addr_length_ = BLOCK_SZ;
-        read_ahead_feature_ = false;
-    }
-
-    mapped_addr_ = mmap(NULL, total_mapped_addr_length_, PROT_READ | PROT_WRITE, MAP_SHARED,
-                        cow_fd_.get(), 0);
-    if (mapped_addr_ == MAP_FAILED) {
-        SNAP_LOG(ERROR) << "mmap metadata failed";
-        return false;
-    }
-
-    return true;
-}
-
-void Snapuserd::UnmapBufferRegion() {
-    int ret = munmap(mapped_addr_, total_mapped_addr_length_);
-    if (ret < 0) {
-        SNAP_PLOG(ERROR) << "munmap failed";
-    }
-}
-
-void MyLogger(android::base::LogId, android::base::LogSeverity severity, const char*, const char*,
-              unsigned int, const char* message) {
-    if (severity == android::base::ERROR) {
-        fprintf(stderr, "%s\n", message);
-    } else {
-        fprintf(stdout, "%s\n", message);
-    }
-}
-
-bool Snapuserd::InitCowDevice() {
-    cow_fd_.reset(open(cow_device_.c_str(), O_RDWR));
-    if (cow_fd_ < 0) {
-        SNAP_PLOG(ERROR) << "Open Failed: " << cow_device_;
-        return false;
-    }
-
-    return ReadMetadata();
-}
-
-void Snapuserd::ReadBlocksToCache(const std::string& dm_block_device,
-                                  const std::string& partition_name, off_t offset, size_t size) {
-    android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(dm_block_device.c_str(), O_RDONLY)));
-    if (fd.get() == -1) {
-        SNAP_PLOG(ERROR) << "Error reading " << dm_block_device
-                         << " partition-name: " << partition_name;
-        return;
-    }
-
-    size_t remain = size;
-    off_t file_offset = offset;
-    // We pick 4M I/O size based on the fact that the current
-    // update_verifier has a similar I/O size.
-    size_t read_sz = 1024 * BLOCK_SZ;
-    std::vector<uint8_t> buf(read_sz);
-
-    while (remain > 0) {
-        size_t to_read = std::min(remain, read_sz);
-
-        if (!android::base::ReadFullyAtOffset(fd.get(), buf.data(), to_read, file_offset)) {
-            SNAP_PLOG(ERROR) << "Failed to read block from block device: " << dm_block_device
-                             << " at offset: " << file_offset
-                             << " partition-name: " << partition_name << " total-size: " << size
-                             << " remain_size: " << remain;
-            return;
-        }
-
-        file_offset += to_read;
-        remain -= to_read;
-    }
-
-    SNAP_LOG(INFO) << "Finished reading block-device: " << dm_block_device
-                   << " partition: " << partition_name << " size: " << size
-                   << " offset: " << offset;
-}
-
-void Snapuserd::ReadBlocks(const std::string& partition_name, const std::string& dm_block_device) {
-    SNAP_LOG(DEBUG) << "Reading partition: " << partition_name
-                    << " Block-Device: " << dm_block_device;
-
-    uint64_t dev_sz = 0;
-
-    unique_fd fd(TEMP_FAILURE_RETRY(open(dm_block_device.c_str(), O_RDONLY | O_CLOEXEC)));
-    if (fd < 0) {
-        SNAP_LOG(ERROR) << "Cannot open block device";
-        return;
-    }
-
-    dev_sz = get_block_device_size(fd.get());
-    if (!dev_sz) {
-        SNAP_PLOG(ERROR) << "Could not determine block device size: " << dm_block_device;
-        return;
-    }
-
-    int num_threads = 2;
-    size_t num_blocks = dev_sz >> BLOCK_SHIFT;
-    size_t num_blocks_per_thread = num_blocks / num_threads;
-    size_t read_sz_per_thread = num_blocks_per_thread << BLOCK_SHIFT;
-    off_t offset = 0;
-
-    for (int i = 0; i < num_threads; i++) {
-        (void)std::async(std::launch::async, &Snapuserd::ReadBlocksToCache, this, dm_block_device,
-                         partition_name, offset, read_sz_per_thread);
-
-        offset += read_sz_per_thread;
-    }
-}
-
-/*
- * Entry point to launch threads
- */
-bool Snapuserd::Start() {
-    std::vector<std::future<bool>> threads;
-    std::future<bool> ra_thread;
-    bool rathread = (read_ahead_feature_ && (read_ahead_ops_.size() > 0));
-
-    // Start the read-ahead thread and wait
-    // for it as the data has to be re-constructed
-    // from COW device.
-    if (rathread) {
-        ra_thread = std::async(std::launch::async, &ReadAheadThread::RunThread,
-                               read_ahead_thread_.get());
-        if (!WaitForReadAheadToStart()) {
-            SNAP_LOG(ERROR) << "Failed to start Read-ahead thread...";
-            return false;
-        }
-
-        SNAP_LOG(INFO) << "Read-ahead thread started...";
-    }
-
-    // Launch worker threads
-    for (int i = 0; i < worker_threads_.size(); i++) {
-        threads.emplace_back(
-                std::async(std::launch::async, &WorkerThread::RunThread, worker_threads_[i].get()));
-    }
-
-    bool second_stage_init = true;
-
-    // We don't want to read the blocks during first stage init.
-    if (android::base::EndsWith(misc_name_, "-init") || is_socket_present_) {
-        second_stage_init = false;
-    }
-
-    if (second_stage_init) {
-        SNAP_LOG(INFO) << "Reading blocks to cache....";
-        auto& dm = DeviceMapper::Instance();
-        auto dm_block_devices = dm.FindDmPartitions();
-        if (dm_block_devices.empty()) {
-            SNAP_LOG(ERROR) << "No dm-enabled block device is found.";
-        } else {
-            auto parts = android::base::Split(misc_name_, "-");
-            std::string partition_name = parts[0];
-
-            const char* suffix_b = "_b";
-            const char* suffix_a = "_a";
-
-            partition_name.erase(partition_name.find_last_not_of(suffix_b) + 1);
-            partition_name.erase(partition_name.find_last_not_of(suffix_a) + 1);
-
-            if (dm_block_devices.find(partition_name) == dm_block_devices.end()) {
-                SNAP_LOG(ERROR) << "Failed to find dm block device for " << partition_name;
-            } else {
-                ReadBlocks(partition_name, dm_block_devices.at(partition_name));
-            }
-        }
-    } else {
-        SNAP_LOG(INFO) << "Not reading block device into cache";
-    }
-
-    bool ret = true;
-    for (auto& t : threads) {
-        ret = t.get() && ret;
-    }
-
-    if (rathread) {
-        // Notify the read-ahead thread that all worker threads
-        // are done. We need this explicit notification when
-        // there is an IO failure or there was a switch
-        // of dm-user table; thus, forcing the read-ahead
-        // thread to wake up.
-        MergeCompleted();
-        ret = ret && ra_thread.get();
-    }
-
-    return ret;
-}
-
-uint64_t Snapuserd::GetBufferMetadataOffset() {
-    const auto& header = reader_->GetHeader();
-
-    size_t size = header.prefix.header_size + sizeof(BufferState);
-    return size;
-}
-
-/*
- * Metadata for read-ahead is 16 bytes. For a 2 MB region, we will
- * end up with 8k (2 PAGE) worth of metadata. Thus, a 2MB buffer
- * region is split into:
- *
- * 1: 8k metadata
- *
- */
-size_t Snapuserd::GetBufferMetadataSize() {
-    const auto& header = reader_->GetHeader();
-
-    size_t metadata_bytes = (header.buffer_size * sizeof(struct ScratchMetadata)) / BLOCK_SZ;
-    return metadata_bytes;
-}
-
-size_t Snapuserd::GetBufferDataOffset() {
-    const auto& header = reader_->GetHeader();
-
-    return (header.prefix.header_size + GetBufferMetadataSize());
-}
-
-/*
- * (2MB - 8K = 2088960 bytes) will be the buffer region to hold the data.
- */
-size_t Snapuserd::GetBufferDataSize() {
-    const auto& header = reader_->GetHeader();
-
-    size_t size = header.buffer_size - GetBufferMetadataSize();
-    return size;
-}
-
-struct BufferState* Snapuserd::GetBufferState() {
-    const auto& header = reader_->GetHeader();
-
-    struct BufferState* ra_state =
-            reinterpret_cast<struct BufferState*>((char*)mapped_addr_ + header.prefix.header_size);
-    return ra_state;
-}
-
-}  // namespace snapshot
-}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.h b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.h
deleted file mode 100644
index beb600483776..000000000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.h
+++ /dev/null
@@ -1,332 +0,0 @@
-// Copyright (C) 2020 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <linux/types.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <sys/mman.h>
-
-#include <bitset>
-#include <condition_variable>
-#include <csignal>
-#include <cstring>
-#include <future>
-#include <iostream>
-#include <limits>
-#include <map>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include <android-base/file.h>
-#include <android-base/logging.h>
-#include <android-base/stringprintf.h>
-#include <android-base/unique_fd.h>
-#include <ext4_utils/ext4_utils.h>
-#include <libdm/dm.h>
-#include <libsnapshot/cow_reader.h>
-#include <libsnapshot/cow_writer.h>
-#include <snapuserd/snapuserd_buffer.h>
-#include <snapuserd/snapuserd_kernel.h>
-
-namespace android {
-namespace snapshot {
-
-using android::base::unique_fd;
-using namespace std::chrono_literals;
-
-static constexpr size_t PAYLOAD_SIZE = (1UL << 20);
-static_assert(PAYLOAD_SIZE >= BLOCK_SZ);
-
-/*
- * With 4 threads, we get optimal performance
- * when update_verifier reads the partition during
- * boot.
- */
-static constexpr int NUM_THREADS_PER_PARTITION = 4;
-
-/*
- * State transitions between worker threads and read-ahead
- * threads.
- *
- * READ_AHEAD_BEGIN: Worker threads initiates the read-ahead
- *                   thread to begin reading the copy operations
- *                   for each bounded region.
- *
- * READ_AHEAD_IN_PROGRESS: When read ahead thread is in-flight
- *                         and reading the copy operations.
- *
- * IO_IN_PROGRESS: Merge operation is in-progress by worker threads.
- *
- * IO_TERMINATED: When all the worker threads are done, request the
- *                read-ahead thread to terminate
- *
- * READ_AHEAD_FAILURE: If there are any IO failures when read-ahead
- *                     thread is reading from COW device.
- *
- * The transition of each states is described in snapuserd_readahead.cpp
- */
-enum class READ_AHEAD_IO_TRANSITION {
-    READ_AHEAD_BEGIN,
-    READ_AHEAD_IN_PROGRESS,
-    IO_IN_PROGRESS,
-    IO_TERMINATED,
-    READ_AHEAD_FAILURE,
-};
-
-class Snapuserd;
-
-class ReadAheadThread {
-  public:
-    ReadAheadThread(const std::string& cow_device, const std::string& backing_device,
-                    const std::string& misc_name, std::shared_ptr<Snapuserd> snapuserd);
-    bool RunThread();
-
-  private:
-    void InitializeRAIter();
-    bool RAIterDone();
-    void RAIterNext();
-    const CowOperation* GetRAOpIter();
-    void InitializeBuffer();
-
-    bool InitializeFds();
-    void CloseFds() {
-        cow_fd_ = {};
-        backing_store_fd_ = {};
-    }
-
-    bool ReadAheadIOStart();
-    void PrepareReadAhead(uint64_t* source_offset, int* pending_ops, std::vector<uint64_t>& blocks);
-    bool ReconstructDataFromCow();
-    void CheckOverlap(const CowOperation* cow_op);
-
-    void* read_ahead_buffer_;
-    void* metadata_buffer_;
-    std::vector<const CowOperation*>::reverse_iterator read_ahead_iter_;
-    std::string cow_device_;
-    std::string backing_store_device_;
-    std::string misc_name_;
-
-    unique_fd cow_fd_;
-    unique_fd backing_store_fd_;
-
-    std::shared_ptr<Snapuserd> snapuserd_;
-
-    std::unordered_set<uint64_t> dest_blocks_;
-    std::unordered_set<uint64_t> source_blocks_;
-    bool overlap_;
-};
-
-class WorkerThread {
-  public:
-    WorkerThread(const std::string& cow_device, const std::string& backing_device,
-                 const std::string& control_device, const std::string& misc_name,
-                 std::shared_ptr<Snapuserd> snapuserd);
-    bool RunThread();
-
-  private:
-    // Initialization
-    void InitializeBufsink();
-    bool InitializeFds();
-    bool InitReader();
-    void CloseFds() {
-        ctrl_fd_ = {};
-        backing_store_fd_ = {};
-    }
-
-    // Functions interacting with dm-user
-    bool ReadDmUserHeader();
-    bool DmuserReadRequest();
-    bool DmuserWriteRequest();
-    bool ReadDmUserPayload(void* buffer, size_t size);
-    bool WriteDmUserPayload(size_t size, bool header_response);
-
-    bool ReadDiskExceptions(chunk_t chunk, size_t size);
-    bool ZerofillDiskExceptions(size_t read_size);
-    void ConstructKernelCowHeader();
-
-    // IO Path
-    bool ProcessIORequest();
-    int ReadData(sector_t sector, size_t size);
-    int ReadUnalignedSector(sector_t sector, size_t size,
-                            std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it);
-
-    // Processing COW operations
-    bool ProcessCowOp(const CowOperation* cow_op);
-    bool ProcessReplaceOp(const CowOperation* cow_op);
-    // Handles Copy
-    bool ProcessCopyOp(const CowOperation* cow_op);
-    bool ProcessZeroOp();
-
-    bool ReadFromBaseDevice(const CowOperation* cow_op);
-    bool GetReadAheadPopulatedBuffer(const CowOperation* cow_op);
-
-    // Merge related functions
-    bool ProcessMergeComplete(chunk_t chunk, void* buffer);
-    loff_t GetMergeStartOffset(void* merged_buffer, void* unmerged_buffer,
-                               int* unmerged_exceptions);
-
-    int GetNumberOfMergedOps(void* merged_buffer, void* unmerged_buffer, loff_t offset,
-                             int unmerged_exceptions, bool* copy_op, bool* commit);
-
-    sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
-    chunk_t SectorToChunk(sector_t sector) { return sector >> CHUNK_SHIFT; }
-
-    std::unique_ptr<CowReader> reader_;
-    BufferSink bufsink_;
-
-    std::string cow_device_;
-    std::string backing_store_device_;
-    std::string control_device_;
-    std::string misc_name_;
-
-    unique_fd cow_fd_;
-    unique_fd backing_store_fd_;
-    unique_fd ctrl_fd_;
-
-    std::shared_ptr<Snapuserd> snapuserd_;
-    uint32_t exceptions_per_area_;
-};
-
-class Snapuserd : public std::enable_shared_from_this<Snapuserd> {
-  public:
-    Snapuserd(const std::string& misc_name, const std::string& cow_device,
-              const std::string& backing_device);
-    bool InitCowDevice();
-    bool Start();
-    const std::string& GetControlDevicePath() { return control_device_; }
-    const std::string& GetMiscName() { return misc_name_; }
-    uint64_t GetNumSectors() { return num_sectors_; }
-    bool IsAttached() const { return attached_; }
-    void AttachControlDevice() { attached_ = true; }
-
-    void CheckMergeCompletionStatus();
-    bool CommitMerge(int num_merge_ops);
-
-    void CloseFds() { cow_fd_ = {}; }
-    void FreeResources() {
-        worker_threads_.clear();
-        read_ahead_thread_ = nullptr;
-    }
-    size_t GetMetadataAreaSize() { return vec_.size(); }
-    void* GetExceptionBuffer(size_t i) { return vec_[i].get(); }
-
-    bool InitializeWorkers();
-    std::unique_ptr<CowReader> CloneReaderForWorker();
-    std::shared_ptr<Snapuserd> GetSharedPtr() { return shared_from_this(); }
-
-    std::vector<std::pair<sector_t, const CowOperation*>>& GetChunkVec() { return chunk_vec_; }
-    const std::vector<std::unique_ptr<uint8_t[]>>& GetMetadataVec() const { return vec_; }
-
-    static bool compare(std::pair<sector_t, const CowOperation*> p1,
-                        std::pair<sector_t, const CowOperation*> p2) {
-        return p1.first < p2.first;
-    }
-
-    void UnmapBufferRegion();
-    bool MmapMetadata();
-
-    // Read-ahead related functions
-    std::vector<const CowOperation*>& GetReadAheadOpsVec() { return read_ahead_ops_; }
-    std::unordered_map<uint64_t, void*>& GetReadAheadMap() { return read_ahead_buffer_map_; }
-    void* GetMappedAddr() { return mapped_addr_; }
-    bool IsReadAheadFeaturePresent() { return read_ahead_feature_; }
-    void PrepareReadAhead();
-    void StartReadAhead();
-    void MergeCompleted();
-    bool ReadAheadIOCompleted(bool sync);
-    void ReadAheadIOFailed();
-    bool WaitForMergeToComplete();
-    bool GetReadAheadPopulatedBuffer(uint64_t block, void* buffer);
-    bool ReconstructDataFromCow() { return populate_data_from_cow_; }
-    void ReconstructDataFromCowFinish() { populate_data_from_cow_ = false; }
-    bool WaitForReadAheadToStart();
-
-    uint64_t GetBufferMetadataOffset();
-    size_t GetBufferMetadataSize();
-    size_t GetBufferDataOffset();
-    size_t GetBufferDataSize();
-
-    // Final block to be merged in a given read-ahead buffer region
-    void SetFinalBlockMerged(uint64_t x) { final_block_merged_ = x; }
-    uint64_t GetFinalBlockMerged() { return final_block_merged_; }
-    // Total number of blocks to be merged in a given read-ahead buffer region
-    void SetTotalRaBlocksMerged(int x) { total_ra_blocks_merged_ = x; }
-    int GetTotalRaBlocksMerged() { return total_ra_blocks_merged_; }
-    void SetSocketPresent(bool socket) { is_socket_present_ = socket; }
-
-  private:
-    bool IsChunkIdMetadata(chunk_t chunk);
-    chunk_t GetNextAllocatableChunkId(chunk_t chunk_id);
-
-    bool GetRABuffer(std::unique_lock<std::mutex>* lock, uint64_t block, void* buffer);
-    bool ReadMetadata();
-    sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
-    chunk_t SectorToChunk(sector_t sector) { return sector >> CHUNK_SHIFT; }
-    bool IsBlockAligned(int read_size) { return ((read_size & (BLOCK_SZ - 1)) == 0); }
-    struct BufferState* GetBufferState();
-
-    void ReadBlocks(const std::string& partition_name, const std::string& dm_block_device);
-    void ReadBlocksToCache(const std::string& dm_block_device, const std::string& partition_name,
-                           off_t offset, size_t size);
-
-    std::string cow_device_;
-    std::string backing_store_device_;
-    std::string control_device_;
-    std::string misc_name_;
-
-    unique_fd cow_fd_;
-
-    uint32_t exceptions_per_area_;
-    uint64_t num_sectors_;
-
-    std::unique_ptr<CowReader> reader_;
-
-    // Vector of disk exception which is a
-    // mapping of old-chunk to new-chunk
-    std::vector<std::unique_ptr<uint8_t[]>> vec_;
-
-    // chunk_vec stores the pseudo mapping of sector
-    // to COW operations.
-    std::vector<std::pair<sector_t, const CowOperation*>> chunk_vec_;
-
-    std::mutex lock_;
-    std::condition_variable cv;
-
-    void* mapped_addr_;
-    size_t total_mapped_addr_length_;
-
-    std::vector<std::unique_ptr<WorkerThread>> worker_threads_;
-    // Read-ahead related
-    std::unordered_map<uint64_t, void*> read_ahead_buffer_map_;
-    std::vector<const CowOperation*> read_ahead_ops_;
-    bool populate_data_from_cow_ = false;
-    bool read_ahead_feature_;
-    uint64_t final_block_merged_;
-    int total_ra_blocks_merged_ = 0;
-    READ_AHEAD_IO_TRANSITION io_state_;
-    std::unique_ptr<ReadAheadThread> read_ahead_thread_;
-
-    bool merge_initiated_ = false;
-    bool attached_ = false;
-    bool is_socket_present_;
-};
-
-}  // namespace snapshot
-}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
deleted file mode 100644
index f1b9245dc637..000000000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_readahead.cpp
+++ /dev/null
@@ -1,482 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "snapuserd.h"
-
-#include <csignal>
-#include <optional>
-#include <set>
-
-#include <snapuserd/snapuserd_client.h>
-
-namespace android {
-namespace snapshot {
-
-using namespace android;
-using namespace android::dm;
-using android::base::unique_fd;
-
-#define SNAP_LOG(level) LOG(level) << misc_name_ << ": "
-#define SNAP_PLOG(level) PLOG(level) << misc_name_ << ": "
-
-/*
- * Merging a copy operation involves the following flow:
- *
- * 1: dm-snapshot layer requests merge for a 4k block. dm-user sends the request
- *    to the daemon
- * 2: daemon reads the source block
- * 3: daemon copies the source data
- * 4: IO completion sent back to dm-user (a switch from user space to kernel)
- * 5: dm-snapshot merges the data to base device
- * 6: dm-snapshot sends the merge-completion IO to dm-user
- * 7: dm-user re-directs the merge completion IO to daemon (one more switch)
- * 8: daemon updates the COW file about the completed merge request (a write syscall) and followed
- * by a fysnc. 9: Send the IO completion back to dm-user
- *
- * The above sequence is a significant overhead especially when merging one 4k
- * block at a time.
- *
- * Read-ahead layer will optimize the above path by reading the data from base
- * device in the background so that merging thread can retrieve the data from
- * the read-ahead cache. Additionally, syncing of merged data is deferred to
- * read-ahead thread threadby the IO path is not bottlenecked.
- *
- * We create a scratch space of 2MB to store the read-ahead data in the COW
- * device.
- *
- *      +-----------------------+
- *      |     Header (fixed)    |
- *      +-----------------------+
- *      |    Scratch space      |  <-- 2MB
- *      +-----------------------+
- *
- *      Scratch space is as follows:
- *
- *      +-----------------------+
- *      |       Metadata        | <- 4k page
- *      +-----------------------+
- *      |       Metadata        | <- 4k page
- *      +-----------------------+
- *      |                       |
- *      |    Read-ahead data    |
- *      |                       |
- *      +-----------------------+
- *
- * State transitions and communication between read-ahead thread and worker
- * thread during merge:
- * =====================================================================
- *
- *   Worker Threads                                 Read-Ahead thread
- *   ------------------------------------------------------------------
- *
- *      |
- *      |
- *  --> -----------------READ_AHEAD_BEGIN------------->|
- *  |   |                                              | READ_AHEAD_IN_PROGRESS
- *  |  WAIT                                            |
- *  |   |                                              |
- *  |   |<-----------------IO_IN_PROGRESS---------------
- *  |   |                                              |
- *  |   | IO_IN_PRGRESS                               WAIT
- *  |   |                                              |
- *  |<--|                                              |
- *      |                                              |
- *      ------------------IO_TERMINATED--------------->|
- *                                                     END
- *
- *
- * ===================================================================
- *
- * Example:
- *
- * We have 6 copy operations to be executed in OTA and there is a overlap. Update-engine
- * will write to COW file as follows:
- *
- * Op-1: 20 -> 23
- * Op-2: 19 -> 22
- * Op-3: 18 -> 21
- * Op-4: 17 -> 20
- * Op-5: 16 -> 19
- * Op-6: 15 -> 18
- *
- * Read-ahead thread will read all the 6 source blocks and store the data in the
- * scratch space. Metadata will contain the destination block numbers. Thus,
- * scratch space will look something like this:
- *
- * +--------------+
- * | Block   23   |
- * | offset - 1   |
- * +--------------+
- * | Block   22   |
- * | offset - 2   |
- * +--------------+
- * | Block   21   |
- * | offset - 3   |
- * +--------------+
- *    ...
- *    ...
- * +--------------+
- * | Data-Block 20| <-- offset - 1
- * +--------------+
- * | Data-Block 19| <-- offset - 2
- * +--------------+
- * | Data-Block 18| <-- offset - 3
- * +--------------+
- *     ...
- *     ...
- *
- * ====================================================================
- * IO Path:
- *
- * Read-ahead will serve the data to worker threads during merge only
- * after metadata and data are persisted to the scratch space. Worker
- * threads during merge will always retrieve the data from cache; if the
- * cache is not populated, it will wait for the read-ahead thread to finish.
- * Furthermore, the number of operations merged will by synced to the header
- * only when all the blocks in the read-ahead cache are merged. In the above
- * case, when all 6 operations are merged, COW Header is updated with
- * num_merge_ops = 6.
- *
- * Merge resume after crash:
- *
- * Let's say we have a crash after 5 operations are merged. i.e. after
- * Op-5: 16->19 is completed but before the Op-6 is merged. Thus, COW Header
- * num_merge_ops will be 0 as the all the ops were not merged yet. During next
- * reboot, read-ahead thread will re-construct the data in-memory from the
- * scratch space; when merge resumes, Op-1 will be re-exectued. However,
- * data will be served from read-ahead cache safely even though, block 20
- * was over-written by Op-4.
- *
- */
-
-ReadAheadThread::ReadAheadThread(const std::string& cow_device, const std::string& backing_device,
-                                 const std::string& misc_name,
-                                 std::shared_ptr<Snapuserd> snapuserd) {
-    cow_device_ = cow_device;
-    backing_store_device_ = backing_device;
-    misc_name_ = misc_name;
-    snapuserd_ = snapuserd;
-}
-
-void ReadAheadThread::CheckOverlap(const CowOperation* cow_op) {
-    uint64_t source_block = cow_op->source();
-    if (dest_blocks_.count(cow_op->new_block) || source_blocks_.count(source_block)) {
-        overlap_ = true;
-    }
-
-    dest_blocks_.insert(source_block);
-    source_blocks_.insert(cow_op->new_block);
-}
-
-void ReadAheadThread::PrepareReadAhead(uint64_t* source_offset, int* pending_ops,
-                                       std::vector<uint64_t>& blocks) {
-    int num_ops = *pending_ops;
-    int nr_consecutive = 0;
-    CHECK_NE(source_offset, nullptr);
-
-    if (!RAIterDone() && num_ops) {
-        // Get the first block with offset
-        const CowOperation* cow_op = GetRAOpIter();
-        CHECK_NE(cow_op, nullptr);
-        *source_offset = cow_op->source();
-        if (cow_op->type() == kCowCopyOp) {
-            *source_offset *= BLOCK_SZ;
-        }
-        RAIterNext();
-        num_ops -= 1;
-        nr_consecutive = 1;
-        blocks.push_back(cow_op->new_block);
-
-        if (!overlap_) {
-            CheckOverlap(cow_op);
-        }
-
-        /*
-         * Find number of consecutive blocks working backwards.
-         */
-        while (!RAIterDone() && num_ops) {
-            const CowOperation* op = GetRAOpIter();
-            CHECK_NE(op, nullptr);
-            uint64_t next_offset = op->source();
-            if (op->type() == kCowCopyOp) {
-                next_offset *= BLOCK_SZ;
-            }
-            if (next_offset + nr_consecutive * BLOCK_SZ != *source_offset) {
-                break;
-            }
-            nr_consecutive += 1;
-            num_ops -= 1;
-            blocks.push_back(op->new_block);
-            RAIterNext();
-
-            if (!overlap_) {
-                CheckOverlap(op);
-            }
-        }
-    }
-}
-
-bool ReadAheadThread::ReconstructDataFromCow() {
-    std::unordered_map<uint64_t, void*>& read_ahead_buffer_map = snapuserd_->GetReadAheadMap();
-    read_ahead_buffer_map.clear();
-    loff_t metadata_offset = 0;
-    loff_t start_data_offset = snapuserd_->GetBufferDataOffset();
-    int num_ops = 0;
-    int total_blocks_merged = 0;
-
-    // This memcpy is important as metadata_buffer_ will be an unaligned address and will fault
-    // on 32-bit systems
-    std::unique_ptr<uint8_t[]> metadata_buffer =
-            std::make_unique<uint8_t[]>(snapuserd_->GetBufferMetadataSize());
-    memcpy(metadata_buffer.get(), metadata_buffer_, snapuserd_->GetBufferMetadataSize());
-
-    while (true) {
-        struct ScratchMetadata* bm = reinterpret_cast<struct ScratchMetadata*>(
-                (char*)metadata_buffer.get() + metadata_offset);
-
-        // Done reading metadata
-        if (bm->new_block == 0 && bm->file_offset == 0) {
-            break;
-        }
-
-        loff_t buffer_offset = bm->file_offset - start_data_offset;
-        void* bufptr = static_cast<void*>((char*)read_ahead_buffer_ + buffer_offset);
-        read_ahead_buffer_map[bm->new_block] = bufptr;
-        num_ops += 1;
-        total_blocks_merged += 1;
-
-        metadata_offset += sizeof(struct ScratchMetadata);
-    }
-
-    // We are done re-constructing the mapping; however, we need to make sure
-    // all the COW operations to-be merged are present in the re-constructed
-    // mapping.
-    while (!RAIterDone()) {
-        const CowOperation* op = GetRAOpIter();
-        if (read_ahead_buffer_map.find(op->new_block) != read_ahead_buffer_map.end()) {
-            num_ops -= 1;
-            snapuserd_->SetFinalBlockMerged(op->new_block);
-            RAIterNext();
-        } else {
-            // Verify that we have covered all the ops which were re-constructed
-            // from COW device - These are the ops which are being
-            // re-constructed after crash.
-            if (!(num_ops == 0)) {
-                SNAP_LOG(ERROR) << "ReconstructDataFromCow failed. Not all ops recoverd "
-                                << " Pending ops: " << num_ops;
-                snapuserd_->ReadAheadIOFailed();
-                return false;
-            }
-            break;
-        }
-    }
-
-    snapuserd_->SetTotalRaBlocksMerged(total_blocks_merged);
-
-    snapuserd_->ReconstructDataFromCowFinish();
-
-    if (!snapuserd_->ReadAheadIOCompleted(true)) {
-        SNAP_LOG(ERROR) << "ReadAheadIOCompleted failed...";
-        snapuserd_->ReadAheadIOFailed();
-        return false;
-    }
-
-    SNAP_LOG(INFO) << "ReconstructDataFromCow success";
-    return true;
-}
-
-bool ReadAheadThread::ReadAheadIOStart() {
-    // Check if the data has to be constructed from the COW file.
-    // This will be true only once during boot up after a crash
-    // during merge.
-    if (snapuserd_->ReconstructDataFromCow()) {
-        return ReconstructDataFromCow();
-    }
-
-    std::unordered_map<uint64_t, void*>& read_ahead_buffer_map = snapuserd_->GetReadAheadMap();
-    read_ahead_buffer_map.clear();
-
-    int num_ops = (snapuserd_->GetBufferDataSize()) / BLOCK_SZ;
-    loff_t metadata_offset = 0;
-
-    struct ScratchMetadata* bm =
-            reinterpret_cast<struct ScratchMetadata*>((char*)metadata_buffer_ + metadata_offset);
-
-    bm->new_block = 0;
-    bm->file_offset = 0;
-
-    std::vector<uint64_t> blocks;
-
-    loff_t buffer_offset = 0;
-    loff_t offset = 0;
-    loff_t file_offset = snapuserd_->GetBufferDataOffset();
-    int total_blocks_merged = 0;
-    overlap_ = false;
-    dest_blocks_.clear();
-    source_blocks_.clear();
-
-    while (true) {
-        uint64_t source_offset;
-        int linear_blocks;
-
-        PrepareReadAhead(&source_offset, &num_ops, blocks);
-        linear_blocks = blocks.size();
-        if (linear_blocks == 0) {
-            // No more blocks to read
-            SNAP_LOG(DEBUG) << " Read-ahead completed....";
-            break;
-        }
-
-        // Get the first block in the consecutive set of blocks
-        source_offset = source_offset - (linear_blocks - 1) * BLOCK_SZ;
-        size_t io_size = (linear_blocks * BLOCK_SZ);
-        num_ops -= linear_blocks;
-        total_blocks_merged += linear_blocks;
-
-        // Mark the block number as the one which will
-        // be the final block to be merged in this entire region.
-        // Read-ahead thread will get
-        // notified when this block is merged to make
-        // forward progress
-        snapuserd_->SetFinalBlockMerged(blocks.back());
-
-        while (linear_blocks) {
-            uint64_t new_block = blocks.back();
-            blocks.pop_back();
-            // Assign the mapping
-            void* bufptr = static_cast<void*>((char*)read_ahead_buffer_ + offset);
-            read_ahead_buffer_map[new_block] = bufptr;
-            offset += BLOCK_SZ;
-
-            bm = reinterpret_cast<struct ScratchMetadata*>((char*)metadata_buffer_ +
-                                                           metadata_offset);
-            bm->new_block = new_block;
-            bm->file_offset = file_offset;
-
-            metadata_offset += sizeof(struct ScratchMetadata);
-            file_offset += BLOCK_SZ;
-
-            linear_blocks -= 1;
-        }
-
-        // Read from the base device consecutive set of blocks in one shot
-        if (!android::base::ReadFullyAtOffset(backing_store_fd_,
-                                              (char*)read_ahead_buffer_ + buffer_offset, io_size,
-                                              source_offset)) {
-            SNAP_PLOG(ERROR) << "Ordered-op failed. Read from backing store: "
-                             << backing_store_device_ << "at block :" << source_offset / BLOCK_SZ
-                             << " offset :" << source_offset % BLOCK_SZ
-                             << " buffer_offset : " << buffer_offset << " io_size : " << io_size
-                             << " buf-addr : " << read_ahead_buffer_;
-
-            snapuserd_->ReadAheadIOFailed();
-            return false;
-        }
-
-        // This is important - explicitly set the contents to zero. This is used
-        // when re-constructing the data after crash. This indicates end of
-        // reading metadata contents when re-constructing the data
-        bm = reinterpret_cast<struct ScratchMetadata*>((char*)metadata_buffer_ + metadata_offset);
-        bm->new_block = 0;
-        bm->file_offset = 0;
-
-        buffer_offset += io_size;
-    }
-
-    snapuserd_->SetTotalRaBlocksMerged(total_blocks_merged);
-
-    // Flush the data only if we have a overlapping blocks in the region
-    if (!snapuserd_->ReadAheadIOCompleted(overlap_)) {
-        SNAP_LOG(ERROR) << "ReadAheadIOCompleted failed...";
-        snapuserd_->ReadAheadIOFailed();
-        return false;
-    }
-
-    return true;
-}
-
-bool ReadAheadThread::RunThread() {
-    if (!InitializeFds()) {
-        return false;
-    }
-
-    InitializeRAIter();
-    InitializeBuffer();
-
-    while (!RAIterDone()) {
-        if (!ReadAheadIOStart()) {
-            return false;
-        }
-
-        bool status = snapuserd_->WaitForMergeToComplete();
-
-        if (status && !snapuserd_->CommitMerge(snapuserd_->GetTotalRaBlocksMerged())) {
-            return false;
-        }
-
-        if (!status) break;
-    }
-
-    CloseFds();
-    SNAP_LOG(INFO) << " ReadAhead thread terminating....";
-    return true;
-}
-
-// Initialization
-bool ReadAheadThread::InitializeFds() {
-    backing_store_fd_.reset(open(backing_store_device_.c_str(), O_RDONLY));
-    if (backing_store_fd_ < 0) {
-        SNAP_PLOG(ERROR) << "Open Failed: " << backing_store_device_;
-        return false;
-    }
-
-    cow_fd_.reset(open(cow_device_.c_str(), O_RDWR));
-    if (cow_fd_ < 0) {
-        SNAP_PLOG(ERROR) << "Open Failed: " << cow_device_;
-        return false;
-    }
-
-    return true;
-}
-
-void ReadAheadThread::InitializeRAIter() {
-    std::vector<const CowOperation*>& read_ahead_ops = snapuserd_->GetReadAheadOpsVec();
-    read_ahead_iter_ = read_ahead_ops.rbegin();
-}
-
-bool ReadAheadThread::RAIterDone() {
-    std::vector<const CowOperation*>& read_ahead_ops = snapuserd_->GetReadAheadOpsVec();
-    return read_ahead_iter_ == read_ahead_ops.rend();
-}
-
-void ReadAheadThread::RAIterNext() {
-    read_ahead_iter_++;
-}
-
-const CowOperation* ReadAheadThread::GetRAOpIter() {
-    return *read_ahead_iter_;
-}
-
-void ReadAheadThread::InitializeBuffer() {
-    void* mapped_addr = snapuserd_->GetMappedAddr();
-    // Map the scratch space region into memory
-    metadata_buffer_ =
-            static_cast<void*>((char*)mapped_addr + snapuserd_->GetBufferMetadataOffset());
-    read_ahead_buffer_ = static_cast<void*>((char*)mapped_addr + snapuserd_->GetBufferDataOffset());
-}
-
-}  // namespace snapshot
-}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.cpp
deleted file mode 100644
index 577b09d1e10c..000000000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.cpp
+++ /dev/null
@@ -1,559 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <arpa/inet.h>
-#include <cutils/sockets.h>
-#include <errno.h>
-#include <netinet/in.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <android-base/cmsg.h>
-#include <android-base/logging.h>
-#include <android-base/properties.h>
-#include <android-base/scopeguard.h>
-#include <fs_mgr/file_wait.h>
-#include <snapuserd/snapuserd_client.h>
-
-#include "snapuserd_server.h"
-
-#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
-#include <sys/_system_properties.h>
-
-namespace android {
-namespace snapshot {
-
-using namespace std::string_literals;
-
-using android::base::borrowed_fd;
-using android::base::unique_fd;
-
-DaemonOperations SnapuserdServer::Resolveop(std::string& input) {
-    if (input == "init") return DaemonOperations::INIT;
-    if (input == "start") return DaemonOperations::START;
-    if (input == "stop") return DaemonOperations::STOP;
-    if (input == "query") return DaemonOperations::QUERY;
-    if (input == "delete") return DaemonOperations::DELETE;
-    if (input == "detach") return DaemonOperations::DETACH;
-    if (input == "supports") return DaemonOperations::SUPPORTS;
-
-    return DaemonOperations::INVALID;
-}
-
-SnapuserdServer::~SnapuserdServer() {
-    // Close any client sockets that were added via AcceptClient().
-    for (size_t i = 1; i < watched_fds_.size(); i++) {
-        close(watched_fds_[i].fd);
-    }
-}
-
-std::string SnapuserdServer::GetDaemonStatus() {
-    std::string msg = "";
-
-    if (IsTerminating())
-        msg = "passive";
-    else
-        msg = "active";
-
-    return msg;
-}
-
-void SnapuserdServer::Parsemsg(std::string const& msg, const char delim,
-                               std::vector<std::string>& out) {
-    std::stringstream ss(msg);
-    std::string s;
-
-    while (std::getline(ss, s, delim)) {
-        out.push_back(s);
-    }
-}
-
-void SnapuserdServer::ShutdownThreads() {
-    StopThreads();
-    JoinAllThreads();
-}
-
-DmUserHandler::DmUserHandler(std::shared_ptr<Snapuserd> snapuserd)
-    : snapuserd_(snapuserd), misc_name_(snapuserd_->GetMiscName()) {}
-
-bool SnapuserdServer::Sendmsg(android::base::borrowed_fd fd, const std::string& msg) {
-    ssize_t ret = TEMP_FAILURE_RETRY(send(fd.get(), msg.data(), msg.size(), MSG_NOSIGNAL));
-    if (ret < 0) {
-        PLOG(ERROR) << "Snapuserd:server: send() failed";
-        return false;
-    }
-
-    if (ret < msg.size()) {
-        LOG(ERROR) << "Partial send; expected " << msg.size() << " bytes, sent " << ret;
-        return false;
-    }
-    return true;
-}
-
-bool SnapuserdServer::Recv(android::base::borrowed_fd fd, std::string* data) {
-    char msg[MAX_PACKET_SIZE];
-    ssize_t rv = TEMP_FAILURE_RETRY(recv(fd.get(), msg, sizeof(msg), 0));
-    if (rv < 0) {
-        PLOG(ERROR) << "recv failed";
-        return false;
-    }
-    *data = std::string(msg, rv);
-    return true;
-}
-
-bool SnapuserdServer::Receivemsg(android::base::borrowed_fd fd, const std::string& str) {
-    const char delim = ',';
-
-    std::vector<std::string> out;
-    Parsemsg(str, delim, out);
-    DaemonOperations op = Resolveop(out[0]);
-
-    switch (op) {
-        case DaemonOperations::INIT: {
-            // Message format:
-            // init,<misc_name>,<cow_device_path>,<backing_device>
-            //
-            // Reads the metadata and send the number of sectors
-            if (out.size() != 4) {
-                LOG(ERROR) << "Malformed init message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-
-            auto handler = AddHandler(out[1], out[2], out[3]);
-            if (!handler) {
-                return Sendmsg(fd, "fail");
-            }
-
-            auto retval = "success," + std::to_string(handler->snapuserd()->GetNumSectors());
-            return Sendmsg(fd, retval);
-        }
-        case DaemonOperations::START: {
-            // Message format:
-            // start,<misc_name>
-            //
-            // Start the new thread which binds to dm-user misc device
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed start message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-
-            std::lock_guard<std::mutex> lock(lock_);
-            auto iter = FindHandler(&lock, out[1]);
-            if (iter == dm_users_.end()) {
-                LOG(ERROR) << "Could not find handler: " << out[1];
-                return Sendmsg(fd, "fail");
-            }
-            if (!(*iter)->snapuserd() || (*iter)->snapuserd()->IsAttached()) {
-                LOG(ERROR) << "Tried to re-attach control device: " << out[1];
-                return Sendmsg(fd, "fail");
-            }
-            if (!StartHandler(*iter)) {
-                return Sendmsg(fd, "fail");
-            }
-            return Sendmsg(fd, "success");
-        }
-        case DaemonOperations::STOP: {
-            // Message format: stop
-            //
-            // Stop all the threads gracefully and then shutdown the
-            // main thread
-            SetTerminating();
-            ShutdownThreads();
-            return true;
-        }
-        case DaemonOperations::QUERY: {
-            // Message format: query
-            //
-            // As part of transition, Second stage daemon will be
-            // created before terminating the first stage daemon. Hence,
-            // for a brief period client may have to distiguish between
-            // first stage daemon and second stage daemon.
-            //
-            // Second stage daemon is marked as active and hence will
-            // be ready to receive control message.
-            return Sendmsg(fd, GetDaemonStatus());
-        }
-        case DaemonOperations::DELETE: {
-            // Message format:
-            // delete,<misc_name>
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed delete message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (!RemoveAndJoinHandler(out[1])) {
-                return Sendmsg(fd, "fail");
-            }
-            return Sendmsg(fd, "success");
-        }
-        case DaemonOperations::DETACH: {
-            terminating_ = true;
-            return true;
-        }
-        case DaemonOperations::SUPPORTS: {
-            if (out.size() != 2) {
-                LOG(ERROR) << "Malformed supports message, " << out.size() << " parts";
-                return Sendmsg(fd, "fail");
-            }
-            if (out[1] == "second_stage_socket_handoff") {
-                return Sendmsg(fd, "success");
-            }
-            return Sendmsg(fd, "fail");
-        }
-        default: {
-            LOG(ERROR) << "Received unknown message type from client";
-            Sendmsg(fd, "fail");
-            return false;
-        }
-    }
-}
-
-void SnapuserdServer::RunThread(std::shared_ptr<DmUserHandler> handler) {
-    LOG(INFO) << "Entering thread for handler: " << handler->misc_name();
-
-    handler->snapuserd()->SetSocketPresent(is_socket_present_);
-    if (!handler->snapuserd()->Start()) {
-        LOG(ERROR) << " Failed to launch all worker threads";
-    }
-
-    handler->snapuserd()->CloseFds();
-    handler->snapuserd()->CheckMergeCompletionStatus();
-    handler->snapuserd()->UnmapBufferRegion();
-
-    auto misc_name = handler->misc_name();
-    LOG(INFO) << "Handler thread about to exit: " << misc_name;
-
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        auto iter = FindHandler(&lock, handler->misc_name());
-        if (iter == dm_users_.end()) {
-            // RemoveAndJoinHandler() already removed us from the list, and is
-            // now waiting on a join(), so just return. Additionally, release
-            // all the resources held by snapuserd object which are shared
-            // by worker threads. This should be done when the last reference
-            // of "handler" is released; but we will explicitly release here
-            // to make sure snapuserd object is freed as it is the biggest
-            // consumer of memory in the daemon.
-            handler->FreeResources();
-            LOG(INFO) << "Exiting handler thread to allow for join: " << misc_name;
-            return;
-        }
-
-        LOG(INFO) << "Exiting handler thread and freeing resources: " << misc_name;
-
-        if (handler->snapuserd()->IsAttached()) {
-            handler->thread().detach();
-        }
-
-        // Important: free resources within the lock. This ensures that if
-        // WaitForDelete() is called, the handler is either in the list, or
-        // it's not and its resources are guaranteed to be freed.
-        handler->FreeResources();
-    }
-}
-
-bool SnapuserdServer::Start(const std::string& socketname) {
-    bool start_listening = true;
-
-    sockfd_.reset(android_get_control_socket(socketname.c_str()));
-    if (sockfd_ < 0) {
-        sockfd_.reset(socket_local_server(socketname.c_str(), ANDROID_SOCKET_NAMESPACE_RESERVED,
-                                          SOCK_STREAM));
-        if (sockfd_ < 0) {
-            PLOG(ERROR) << "Failed to create server socket " << socketname;
-            return false;
-        }
-        start_listening = false;
-    }
-    return StartWithSocket(start_listening);
-}
-
-bool SnapuserdServer::StartWithSocket(bool start_listening) {
-    if (start_listening && listen(sockfd_.get(), 4) < 0) {
-        PLOG(ERROR) << "listen socket failed";
-        return false;
-    }
-
-    AddWatchedFd(sockfd_, POLLIN);
-    is_socket_present_ = true;
-
-    // If started in first-stage init, the property service won't be online.
-    if (access("/dev/socket/property_service", F_OK) == 0) {
-        if (!android::base::SetProperty("snapuserd.ready", "true")) {
-            LOG(ERROR) << "Failed to set snapuserd.ready property";
-            return false;
-        }
-    }
-
-    LOG(DEBUG) << "Snapuserd server now accepting connections";
-    return true;
-}
-
-bool SnapuserdServer::Run() {
-    LOG(INFO) << "Now listening on snapuserd socket";
-
-    while (!IsTerminating()) {
-        int rv = TEMP_FAILURE_RETRY(poll(watched_fds_.data(), watched_fds_.size(), -1));
-        if (rv < 0) {
-            PLOG(ERROR) << "poll failed";
-            return false;
-        }
-        if (!rv) {
-            continue;
-        }
-
-        if (watched_fds_[0].revents) {
-            AcceptClient();
-        }
-
-        auto iter = watched_fds_.begin() + 1;
-        while (iter != watched_fds_.end()) {
-            if (iter->revents && !HandleClient(iter->fd, iter->revents)) {
-                close(iter->fd);
-                iter = watched_fds_.erase(iter);
-            } else {
-                iter++;
-            }
-        }
-    }
-
-    JoinAllThreads();
-    return true;
-}
-
-void SnapuserdServer::JoinAllThreads() {
-    // Acquire the thread list within the lock.
-    std::vector<std::shared_ptr<DmUserHandler>> dm_users;
-    {
-        std::lock_guard<std::mutex> guard(lock_);
-        dm_users = std::move(dm_users_);
-    }
-
-    for (auto& client : dm_users) {
-        auto& th = client->thread();
-
-        if (th.joinable()) th.join();
-    }
-}
-
-void SnapuserdServer::AddWatchedFd(android::base::borrowed_fd fd, int events) {
-    struct pollfd p = {};
-    p.fd = fd.get();
-    p.events = events;
-    watched_fds_.emplace_back(std::move(p));
-}
-
-void SnapuserdServer::AcceptClient() {
-    int fd = TEMP_FAILURE_RETRY(accept4(sockfd_.get(), nullptr, nullptr, SOCK_CLOEXEC));
-    if (fd < 0) {
-        PLOG(ERROR) << "accept4 failed";
-        return;
-    }
-
-    AddWatchedFd(fd, POLLIN);
-}
-
-bool SnapuserdServer::HandleClient(android::base::borrowed_fd fd, int revents) {
-    if (revents & POLLHUP) {
-        LOG(DEBUG) << "Snapuserd client disconnected";
-        return false;
-    }
-
-    std::string str;
-    if (!Recv(fd, &str)) {
-        return false;
-    }
-    if (!Receivemsg(fd, str)) {
-        LOG(ERROR) << "Encountered error handling client message, revents: " << revents;
-        return false;
-    }
-    return true;
-}
-
-void SnapuserdServer::Interrupt() {
-    // Force close the socket so poll() fails.
-    sockfd_ = {};
-    SetTerminating();
-}
-
-std::shared_ptr<DmUserHandler> SnapuserdServer::AddHandler(const std::string& misc_name,
-                                                           const std::string& cow_device_path,
-                                                           const std::string& backing_device) {
-    auto snapuserd = std::make_shared<Snapuserd>(misc_name, cow_device_path, backing_device);
-    if (!snapuserd->InitCowDevice()) {
-        LOG(ERROR) << "Failed to initialize Snapuserd";
-        return nullptr;
-    }
-
-    if (!snapuserd->InitializeWorkers()) {
-        LOG(ERROR) << "Failed to initialize workers";
-        return nullptr;
-    }
-
-    auto handler = std::make_shared<DmUserHandler>(snapuserd);
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-        if (FindHandler(&lock, misc_name) != dm_users_.end()) {
-            LOG(ERROR) << "Handler already exists: " << misc_name;
-            return nullptr;
-        }
-        dm_users_.push_back(handler);
-    }
-    return handler;
-}
-
-bool SnapuserdServer::StartHandler(const std::shared_ptr<DmUserHandler>& handler) {
-    if (handler->snapuserd()->IsAttached()) {
-        LOG(ERROR) << "Handler already attached";
-        return false;
-    }
-
-    handler->snapuserd()->AttachControlDevice();
-
-    handler->thread() = std::thread(std::bind(&SnapuserdServer::RunThread, this, handler));
-    return true;
-}
-
-auto SnapuserdServer::FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
-                                  const std::string& misc_name) -> HandlerList::iterator {
-    CHECK(proof_of_lock);
-
-    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
-        if ((*iter)->misc_name() == misc_name) {
-            return iter;
-        }
-    }
-    return dm_users_.end();
-}
-
-bool SnapuserdServer::RemoveAndJoinHandler(const std::string& misc_name) {
-    std::shared_ptr<DmUserHandler> handler;
-    {
-        std::lock_guard<std::mutex> lock(lock_);
-
-        auto iter = FindHandler(&lock, misc_name);
-        if (iter == dm_users_.end()) {
-            // Client already deleted.
-            return true;
-        }
-        handler = std::move(*iter);
-        dm_users_.erase(iter);
-    }
-
-    auto& th = handler->thread();
-    if (th.joinable()) {
-        th.join();
-    }
-    return true;
-}
-
-bool SnapuserdServer::WaitForSocket() {
-    auto scope_guard = android::base::make_scope_guard([this]() -> void { JoinAllThreads(); });
-
-    auto socket_path = ANDROID_SOCKET_DIR "/"s + kSnapuserdSocketProxy;
-
-    if (!android::fs_mgr::WaitForFile(socket_path, std::chrono::milliseconds::max())) {
-        LOG(ERROR)
-                << "Failed to wait for proxy socket, second-stage snapuserd will fail to connect";
-        return false;
-    }
-
-    // We must re-initialize property service access, since we launched before
-    // second-stage init.
-    __system_properties_init();
-
-    if (!android::base::WaitForProperty("snapuserd.proxy_ready", "true")) {
-        LOG(ERROR)
-                << "Failed to wait for proxy property, second-stage snapuserd will fail to connect";
-        return false;
-    }
-
-    unique_fd fd(socket_local_client(kSnapuserdSocketProxy, ANDROID_SOCKET_NAMESPACE_RESERVED,
-                                     SOCK_SEQPACKET));
-    if (fd < 0) {
-        PLOG(ERROR) << "Failed to connect to socket proxy";
-        return false;
-    }
-
-    char code[1];
-    std::vector<unique_fd> fds;
-    ssize_t rv = android::base::ReceiveFileDescriptorVector(fd, code, sizeof(code), 1, &fds);
-    if (rv < 0) {
-        PLOG(ERROR) << "Failed to receive server socket over proxy";
-        return false;
-    }
-    if (fds.empty()) {
-        LOG(ERROR) << "Expected at least one file descriptor from proxy";
-        return false;
-    }
-
-    // We don't care if the ACK is received.
-    code[0] = 'a';
-    if (TEMP_FAILURE_RETRY(send(fd, code, sizeof(code), MSG_NOSIGNAL)) < 0) {
-        PLOG(ERROR) << "Failed to send ACK to proxy";
-        return false;
-    }
-
-    sockfd_ = std::move(fds[0]);
-    if (!StartWithSocket(true)) {
-        return false;
-    }
-    return Run();
-}
-
-bool SnapuserdServer::RunForSocketHandoff() {
-    unique_fd proxy_fd(android_get_control_socket(kSnapuserdSocketProxy));
-    if (proxy_fd < 0) {
-        PLOG(FATAL) << "Proxy could not get android control socket " << kSnapuserdSocketProxy;
-    }
-    borrowed_fd server_fd(android_get_control_socket(kSnapuserdSocket));
-    if (server_fd < 0) {
-        PLOG(FATAL) << "Proxy could not get android control socket " << kSnapuserdSocket;
-    }
-
-    if (listen(proxy_fd.get(), 4) < 0) {
-        PLOG(FATAL) << "Proxy listen socket failed";
-    }
-
-    if (!android::base::SetProperty("snapuserd.proxy_ready", "true")) {
-        LOG(FATAL) << "Proxy failed to set ready property";
-    }
-
-    unique_fd client_fd(
-            TEMP_FAILURE_RETRY(accept4(proxy_fd.get(), nullptr, nullptr, SOCK_CLOEXEC)));
-    if (client_fd < 0) {
-        PLOG(FATAL) << "Proxy accept failed";
-    }
-
-    char code[1] = {'a'};
-    std::vector<int> fds = {server_fd.get()};
-    ssize_t rv = android::base::SendFileDescriptorVector(client_fd, code, sizeof(code), fds);
-    if (rv < 0) {
-        PLOG(FATAL) << "Proxy could not send file descriptor to snapuserd";
-    }
-    // Wait for an ACK - results don't matter, we just don't want to risk closing
-    // the proxy socket too early.
-    if (recv(client_fd, code, sizeof(code), 0) < 0) {
-        PLOG(FATAL) << "Proxy could not receive terminating code from snapuserd";
-    }
-    return true;
-}
-
-}  // namespace snapshot
-}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.h
deleted file mode 100644
index 3b6ff1583679..000000000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_server.h
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright (C) 2020 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <poll.h>
-
-#include <cstdio>
-#include <cstring>
-#include <functional>
-#include <future>
-#include <iostream>
-#include <mutex>
-#include <sstream>
-#include <string>
-#include <thread>
-#include <vector>
-
-#include <android-base/unique_fd.h>
-#include "snapuserd.h"
-
-namespace android {
-namespace snapshot {
-
-static constexpr uint32_t MAX_PACKET_SIZE = 512;
-
-enum class DaemonOperations {
-    INIT,
-    START,
-    QUERY,
-    STOP,
-    DELETE,
-    DETACH,
-    SUPPORTS,
-    INVALID,
-};
-
-class DmUserHandler {
-  public:
-    explicit DmUserHandler(std::shared_ptr<Snapuserd> snapuserd);
-
-    void FreeResources() {
-        // Each worker thread holds a reference to snapuserd.
-        // Clear them so that all the resources
-        // held by snapuserd is released
-        if (snapuserd_) {
-            snapuserd_->FreeResources();
-            snapuserd_ = nullptr;
-        }
-    }
-    const std::shared_ptr<Snapuserd>& snapuserd() const { return snapuserd_; }
-    std::thread& thread() { return thread_; }
-
-    const std::string& misc_name() const { return misc_name_; }
-
-  private:
-    std::thread thread_;
-    std::shared_ptr<Snapuserd> snapuserd_;
-    std::string misc_name_;
-};
-
-class Stoppable {
-    std::promise<void> exitSignal_;
-    std::future<void> futureObj_;
-
-  public:
-    Stoppable() : futureObj_(exitSignal_.get_future()) {}
-
-    virtual ~Stoppable() {}
-
-    bool StopRequested() {
-        // checks if value in future object is available
-        if (futureObj_.wait_for(std::chrono::milliseconds(0)) == std::future_status::timeout) {
-            return false;
-        }
-        return true;
-    }
-    // Request the thread to stop by setting value in promise object
-    void StopThreads() { exitSignal_.set_value(); }
-};
-
-class SnapuserdServer : public Stoppable {
-  private:
-    android::base::unique_fd sockfd_;
-    bool terminating_;
-    volatile bool received_socket_signal_ = false;
-    std::vector<struct pollfd> watched_fds_;
-    bool is_socket_present_ = false;
-
-    std::mutex lock_;
-
-    using HandlerList = std::vector<std::shared_ptr<DmUserHandler>>;
-    HandlerList dm_users_;
-
-    void AddWatchedFd(android::base::borrowed_fd fd, int events);
-    void AcceptClient();
-    bool HandleClient(android::base::borrowed_fd fd, int revents);
-    bool Recv(android::base::borrowed_fd fd, std::string* data);
-    bool Sendmsg(android::base::borrowed_fd fd, const std::string& msg);
-    bool Receivemsg(android::base::borrowed_fd fd, const std::string& str);
-
-    void ShutdownThreads();
-    bool RemoveAndJoinHandler(const std::string& control_device);
-    DaemonOperations Resolveop(std::string& input);
-    std::string GetDaemonStatus();
-    void Parsemsg(std::string const& msg, const char delim, std::vector<std::string>& out);
-
-    bool IsTerminating() { return terminating_; }
-
-    void RunThread(std::shared_ptr<DmUserHandler> handler);
-    void JoinAllThreads();
-    bool StartWithSocket(bool start_listening);
-
-    // Find a DmUserHandler within a lock.
-    HandlerList::iterator FindHandler(std::lock_guard<std::mutex>* proof_of_lock,
-                                      const std::string& misc_name);
-
-  public:
-    SnapuserdServer() { terminating_ = false; }
-    ~SnapuserdServer();
-
-    bool Start(const std::string& socketname);
-    bool Run();
-    void Interrupt();
-    bool RunForSocketHandoff();
-    bool WaitForSocket();
-
-    std::shared_ptr<DmUserHandler> AddHandler(const std::string& misc_name,
-                                              const std::string& cow_device_path,
-                                              const std::string& backing_device);
-    bool StartHandler(const std::shared_ptr<DmUserHandler>& handler);
-
-    void SetTerminating() { terminating_ = true; }
-    void ReceivedSocketSignal() { received_socket_signal_ = true; }
-};
-
-}  // namespace snapshot
-}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp b/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
deleted file mode 100644
index 1f5d5682a99d..000000000000
--- a/fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd_worker.cpp
+++ /dev/null
@@ -1,869 +0,0 @@
-/*
- * Copyright (C) 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "snapuserd.h"
-
-#include <csignal>
-#include <optional>
-#include <set>
-
-#include <snapuserd/snapuserd_client.h>
-
-namespace android {
-namespace snapshot {
-
-using namespace android;
-using namespace android::dm;
-using android::base::unique_fd;
-
-#define SNAP_LOG(level) LOG(level) << misc_name_ << ": "
-#define SNAP_PLOG(level) PLOG(level) << misc_name_ << ": "
-
-WorkerThread::WorkerThread(const std::string& cow_device, const std::string& backing_device,
-                           const std::string& control_device, const std::string& misc_name,
-                           std::shared_ptr<Snapuserd> snapuserd) {
-    cow_device_ = cow_device;
-    backing_store_device_ = backing_device;
-    control_device_ = control_device;
-    misc_name_ = misc_name;
-    snapuserd_ = snapuserd;
-    exceptions_per_area_ = (CHUNK_SIZE << SECTOR_SHIFT) / sizeof(struct disk_exception);
-}
-
-bool WorkerThread::InitializeFds() {
-    backing_store_fd_.reset(open(backing_store_device_.c_str(), O_RDONLY));
-    if (backing_store_fd_ < 0) {
-        SNAP_PLOG(ERROR) << "Open Failed: " << backing_store_device_;
-        return false;
-    }
-
-    cow_fd_.reset(open(cow_device_.c_str(), O_RDWR));
-    if (cow_fd_ < 0) {
-        SNAP_PLOG(ERROR) << "Open Failed: " << cow_device_;
-        return false;
-    }
-
-    ctrl_fd_.reset(open(control_device_.c_str(), O_RDWR));
-    if (ctrl_fd_ < 0) {
-        SNAP_PLOG(ERROR) << "Unable to open " << control_device_;
-        return false;
-    }
-
-    return true;
-}
-
-bool WorkerThread::InitReader() {
-    reader_ = snapuserd_->CloneReaderForWorker();
-
-    if (!reader_->InitForMerge(std::move(cow_fd_))) {
-        return false;
-    }
-    return true;
-}
-
-// Construct kernel COW header in memory
-// This header will be in sector 0. The IO
-// request will always be 4k. After constructing
-// the header, zero out the remaining block.
-void WorkerThread::ConstructKernelCowHeader() {
-    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
-
-    memset(buffer, 0, BLOCK_SZ);
-
-    struct disk_header* dh = reinterpret_cast<struct disk_header*>(buffer);
-
-    dh->magic = SNAP_MAGIC;
-    dh->valid = SNAPSHOT_VALID;
-    dh->version = SNAPSHOT_DISK_VERSION;
-    dh->chunk_size = CHUNK_SIZE;
-}
-
-// Start the replace operation. This will read the
-// internal COW format and if the block is compressed,
-// it will be de-compressed.
-bool WorkerThread::ProcessReplaceOp(const CowOperation* cow_op) {
-    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
-    if (!buffer) {
-        SNAP_LOG(ERROR) << "No space in buffer sink";
-        return false;
-    }
-    ssize_t rv = reader_->ReadData(cow_op, buffer, BLOCK_SZ);
-    if (rv != BLOCK_SZ) {
-        SNAP_LOG(ERROR) << "ProcessReplaceOp failed for block " << cow_op->new_block
-                        << ", return = " << rv << ", COW operation = " << *cow_op;
-        return false;
-    }
-    return true;
-}
-
-bool WorkerThread::ReadFromBaseDevice(const CowOperation* cow_op) {
-    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
-    if (buffer == nullptr) {
-        SNAP_LOG(ERROR) << "ReadFromBaseDevice: Failed to get payload buffer";
-        return false;
-    }
-    uint64_t offset;
-    if (!reader_->GetSourceOffset(cow_op, &offset)) {
-        SNAP_LOG(ERROR) << "ReadFromBaseDevice: Failed to get source offset";
-        return false;
-    }
-    SNAP_LOG(DEBUG) << " ReadFromBaseDevice...: new-block: " << cow_op->new_block
-                    << " Source: " << offset;
-    if (!android::base::ReadFullyAtOffset(backing_store_fd_, buffer, BLOCK_SZ, offset)) {
-        SNAP_PLOG(ERROR) << "Copy op failed. Read from backing store: " << backing_store_device_
-                         << "at block :" << offset / BLOCK_SZ << " offset:" << offset % BLOCK_SZ;
-        return false;
-    }
-
-    return true;
-}
-
-bool WorkerThread::GetReadAheadPopulatedBuffer(const CowOperation* cow_op) {
-    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
-    if (buffer == nullptr) {
-        SNAP_LOG(ERROR) << "GetReadAheadPopulatedBuffer: Failed to get payload buffer";
-        return false;
-    }
-
-    if (!snapuserd_->GetReadAheadPopulatedBuffer(cow_op->new_block, buffer)) {
-        return false;
-    }
-
-    return true;
-}
-
-// Start the copy operation. This will read the backing
-// block device which is represented by cow_op->source.
-bool WorkerThread::ProcessCopyOp(const CowOperation* cow_op) {
-    if (!GetReadAheadPopulatedBuffer(cow_op)) {
-        SNAP_LOG(DEBUG) << " GetReadAheadPopulatedBuffer failed..."
-                        << " new_block: " << cow_op->new_block;
-        if (!ReadFromBaseDevice(cow_op)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool WorkerThread::ProcessZeroOp() {
-    // Zero out the entire block
-    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);
-    if (buffer == nullptr) {
-        SNAP_LOG(ERROR) << "ProcessZeroOp: Failed to get payload buffer";
-        return false;
-    }
-
-    memset(buffer, 0, BLOCK_SZ);
-    return true;
-}
-
-bool WorkerThread::ProcessCowOp(const CowOperation* cow_op) {
-    if (cow_op == nullptr) {
-        SNAP_LOG(ERROR) << "ProcessCowOp: Invalid cow_op";
-        return false;
-    }
-
-    switch (cow_op->type()) {
-        case kCowReplaceOp: {
-            return ProcessReplaceOp(cow_op);
-        }
-
-        case kCowZeroOp: {
-            return ProcessZeroOp();
-        }
-
-        case kCowCopyOp: {
-            return ProcessCopyOp(cow_op);
-        }
-
-        default: {
-            SNAP_LOG(ERROR) << "Unsupported operation-type found: "
-                            << static_cast<uint8_t>(cow_op->type());
-        }
-    }
-    return false;
-}
-
-int WorkerThread::ReadUnalignedSector(
-        sector_t sector, size_t size,
-        std::vector<std::pair<sector_t, const CowOperation*>>::iterator& it) {
-    size_t skip_sector_size = 0;
-
-    SNAP_LOG(DEBUG) << "ReadUnalignedSector: sector " << sector << " size: " << size
-                    << " Aligned sector: " << it->first;
-
-    if (!ProcessCowOp(it->second)) {
-        SNAP_LOG(ERROR) << "ReadUnalignedSector: " << sector << " failed of size: " << size
-                        << " Aligned sector: " << it->first;
-        return -1;
-    }
-
-    int num_sectors_skip = sector - it->first;
-
-    if (num_sectors_skip > 0) {
-        skip_sector_size = num_sectors_skip << SECTOR_SHIFT;
-        char* buffer = reinterpret_cast<char*>(bufsink_.GetBufPtr());
-        struct dm_user_message* msg = (struct dm_user_message*)(&(buffer[0]));
-
-        if (skip_sector_size == BLOCK_SZ) {
-            SNAP_LOG(ERROR) << "Invalid un-aligned IO request at sector: " << sector
-                            << " Base-sector: " << it->first;
-            return -1;
-        }
-
-        memmove(msg->payload.buf, (char*)msg->payload.buf + skip_sector_size,
-                (BLOCK_SZ - skip_sector_size));
-    }
-
-    bufsink_.ResetBufferOffset();
-    return std::min(size, (BLOCK_SZ - skip_sector_size));
-}
-
-/*
- * Read the data for a given COW Operation.
- *
- * Kernel can issue IO at a sector granularity.
- * Hence, an IO may end up with reading partial
- * data from a COW operation or we may also
- * end up with interspersed request between
- * two COW operations.
- *
- */
-int WorkerThread::ReadData(sector_t sector, size_t size) {
-    std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
-    std::vector<std::pair<sector_t, const CowOperation*>>::iterator it;
-    /*
-     * chunk_map stores COW operation at 4k granularity.
-     * If the requested IO with the sector falls on the 4k
-     * boundary, then we can read the COW op directly without
-     * any issue.
-     *
-     * However, if the requested sector is not 4K aligned,
-     * then we will have the find the nearest COW operation
-     * and chop the 4K block to fetch the requested sector.
-     */
-    it = std::lower_bound(chunk_vec.begin(), chunk_vec.end(), std::make_pair(sector, nullptr),
-                          Snapuserd::compare);
-
-    bool read_end_of_device = false;
-    if (it == chunk_vec.end()) {
-        // |-------|-------|-------|
-        // 0       1       2       3
-        //
-        // Block 0 - op 1
-        // Block 1 - op 2
-        // Block 2 - op 3
-        //
-        // chunk_vec will have block 0, 1, 2 which maps to relavant COW ops.
-        //
-        // Each block is 4k bytes. Thus, the last block will span 8 sectors
-        // ranging till block 3 (However, block 3 won't be in chunk_vec as
-        // it doesn't have any mapping to COW ops. Now, if we get an I/O request for a sector
-        // spanning between block 2 and block 3, we need to step back
-        // and get hold of the last element.
-        //
-        // Additionally, dm-snapshot makes sure that I/O request beyond block 3
-        // will not be routed to the daemon. Hence, it is safe to assume that
-        // if a sector is not available in the chunk_vec, the I/O falls in the
-        // end of region.
-        it = std::prev(chunk_vec.end());
-        read_end_of_device = true;
-    }
-
-    // We didn't find the required sector; hence find the previous sector
-    // as lower_bound will gives us the value greater than
-    // the requested sector
-    if (it->first != sector) {
-        if (it != chunk_vec.begin() && !read_end_of_device) {
-            --it;
-        }
-
-        /*
-         * If the IO is spanned between two COW operations,
-         * split the IO into two parts:
-         *
-         * 1: Read the first part from the single COW op
-         * 2: Read the second part from the next COW op.
-         *
-         * Ex: Let's say we have a 1024 Bytes IO request.
-         *
-         * 0       COW OP-1  4096     COW OP-2  8192
-         * |******************|*******************|
-         *              |*****|*****|
-         *           3584           4608
-         *              <- 1024B - >
-         *
-         * We have two COW operations which are 4k blocks.
-         * The IO is requested for 1024 Bytes which are spanned
-         * between two COW operations. We will split this IO
-         * into two parts:
-         *
-         * 1: IO of size 512B from offset 3584 bytes (COW OP-1)
-         * 2: IO of size 512B from offset 4096 bytes (COW OP-2)
-         */
-        return ReadUnalignedSector(sector, size, it);
-    }
-
-    int num_ops = DIV_ROUND_UP(size, BLOCK_SZ);
-    sector_t read_sector = sector;
-    while (num_ops) {
-        // We have to make sure that the reads are
-        // sequential; there shouldn't be a data
-        // request merged with a metadata IO.
-        if (it->first != read_sector) {
-            SNAP_LOG(ERROR) << "Invalid IO request: read_sector: " << read_sector
-                            << " cow-op sector: " << it->first;
-            return -1;
-        } else if (!ProcessCowOp(it->second)) {
-            return -1;
-        }
-        num_ops -= 1;
-        read_sector += (BLOCK_SZ >> SECTOR_SHIFT);
-
-        it++;
-
-        if (it == chunk_vec.end() && num_ops) {
-            SNAP_LOG(ERROR) << "Invalid IO request at sector " << sector
-                            << " COW ops completed; pending read-request: " << num_ops;
-            return -1;
-        }
-        // Update the buffer offset
-        bufsink_.UpdateBufferOffset(BLOCK_SZ);
-    }
-
-    // Reset the buffer offset
-    bufsink_.ResetBufferOffset();
-    return size;
-}
-
-/*
- * dm-snap does prefetch reads while reading disk-exceptions.
- * By default, prefetch value is set to 12; this means that
- * dm-snap will issue 12 areas wherein each area is a 4k page
- * of disk-exceptions.
- *
- * If during prefetch, if the chunk-id seen is beyond the
- * actual number of metadata page, fill the buffer with zero.
- * When dm-snap starts parsing the buffer, it will stop
- * reading metadata page once the buffer content is zero.
- */
-bool WorkerThread::ZerofillDiskExceptions(size_t read_size) {
-    size_t size = exceptions_per_area_ * sizeof(struct disk_exception);
-
-    if (read_size > size) {
-        return false;
-    }
-
-    void* buffer = bufsink_.GetPayloadBuffer(size);
-    if (buffer == nullptr) {
-        SNAP_LOG(ERROR) << "ZerofillDiskExceptions: Failed to get payload buffer";
-        return false;
-    }
-
-    memset(buffer, 0, size);
-    return true;
-}
-
-/*
- * A disk exception is a simple mapping of old_chunk to new_chunk.
- * When dm-snapshot device is created, kernel requests these mapping.
- *
- * Each disk exception is of size 16 bytes. Thus a single 4k page can
- * have:
- *
- * exceptions_per_area_ = 4096/16 = 256. This entire 4k page
- * is considered a metadata page and it is represented by chunk ID.
- *
- * Convert the chunk ID to index into the vector which gives us
- * the metadata page.
- */
-bool WorkerThread::ReadDiskExceptions(chunk_t chunk, size_t read_size) {
-    uint32_t stride = exceptions_per_area_ + 1;
-    size_t size;
-    const std::vector<std::unique_ptr<uint8_t[]>>& vec = snapuserd_->GetMetadataVec();
-
-    // ChunkID to vector index
-    lldiv_t divresult = lldiv(chunk, stride);
-
-    if (divresult.quot < vec.size()) {
-        size = exceptions_per_area_ * sizeof(struct disk_exception);
-
-        if (read_size != size) {
-            SNAP_LOG(ERROR) << "ReadDiskExceptions: read_size: " << read_size
-                            << " does not match with size: " << size;
-            return false;
-        }
-
-        void* buffer = bufsink_.GetPayloadBuffer(size);
-        if (buffer == nullptr) {
-            SNAP_LOG(ERROR) << "ReadDiskExceptions: Failed to get payload buffer of size: " << size;
-            return false;
-        }
-
-        memcpy(buffer, vec[divresult.quot].get(), size);
-    } else {
-        return ZerofillDiskExceptions(read_size);
-    }
-
-    return true;
-}
-
-loff_t WorkerThread::GetMergeStartOffset(void* merged_buffer, void* unmerged_buffer,
-                                         int* unmerged_exceptions) {
-    loff_t offset = 0;
-    *unmerged_exceptions = 0;
-
-    while (*unmerged_exceptions <= exceptions_per_area_) {
-        struct disk_exception* merged_de =
-                reinterpret_cast<struct disk_exception*>((char*)merged_buffer + offset);
-        struct disk_exception* cow_de =
-                reinterpret_cast<struct disk_exception*>((char*)unmerged_buffer + offset);
-
-        // Unmerged op by the kernel
-        if (merged_de->old_chunk != 0 || merged_de->new_chunk != 0) {
-            if (!(merged_de->old_chunk == cow_de->old_chunk)) {
-                SNAP_LOG(ERROR) << "GetMergeStartOffset: merged_de->old_chunk: "
-                                << merged_de->old_chunk
-                                << "cow_de->old_chunk: " << cow_de->old_chunk;
-                return -1;
-            }
-
-            if (!(merged_de->new_chunk == cow_de->new_chunk)) {
-                SNAP_LOG(ERROR) << "GetMergeStartOffset: merged_de->new_chunk: "
-                                << merged_de->new_chunk
-                                << "cow_de->new_chunk: " << cow_de->new_chunk;
-                return -1;
-            }
-
-            offset += sizeof(struct disk_exception);
-            *unmerged_exceptions += 1;
-            continue;
-        }
-
-        break;
-    }
-
-    SNAP_LOG(DEBUG) << "Unmerged_Exceptions: " << *unmerged_exceptions << " Offset: " << offset;
-    return offset;
-}
-
-int WorkerThread::GetNumberOfMergedOps(void* merged_buffer, void* unmerged_buffer, loff_t offset,
-                                       int unmerged_exceptions, bool* ordered_op, bool* commit) {
-    int merged_ops_cur_iter = 0;
-    std::unordered_map<uint64_t, void*>& read_ahead_buffer_map = snapuserd_->GetReadAheadMap();
-    *ordered_op = false;
-    std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
-
-    // Find the operations which are merged in this cycle.
-    while ((unmerged_exceptions + merged_ops_cur_iter) < exceptions_per_area_) {
-        struct disk_exception* merged_de =
-                reinterpret_cast<struct disk_exception*>((char*)merged_buffer + offset);
-        struct disk_exception* cow_de =
-                reinterpret_cast<struct disk_exception*>((char*)unmerged_buffer + offset);
-
-        if (!(merged_de->new_chunk == 0)) {
-            SNAP_LOG(ERROR) << "GetNumberOfMergedOps: Invalid new-chunk: " << merged_de->new_chunk;
-            return -1;
-        }
-
-        if (!(merged_de->old_chunk == 0)) {
-            SNAP_LOG(ERROR) << "GetNumberOfMergedOps: Invalid old-chunk: " << merged_de->old_chunk;
-            return -1;
-        }
-
-        if (cow_de->new_chunk != 0) {
-            merged_ops_cur_iter += 1;
-            offset += sizeof(struct disk_exception);
-            auto it = std::lower_bound(chunk_vec.begin(), chunk_vec.end(),
-                                       std::make_pair(ChunkToSector(cow_de->new_chunk), nullptr),
-                                       Snapuserd::compare);
-
-            if (!(it != chunk_vec.end())) {
-                SNAP_LOG(ERROR) << "Sector not found: " << ChunkToSector(cow_de->new_chunk);
-                return -1;
-            }
-
-            if (!(it->first == ChunkToSector(cow_de->new_chunk))) {
-                SNAP_LOG(ERROR) << "Invalid sector: " << ChunkToSector(cow_de->new_chunk);
-                return -1;
-            }
-            const CowOperation* cow_op = it->second;
-
-            if (snapuserd_->IsReadAheadFeaturePresent() && IsOrderedOp(*cow_op)) {
-                *ordered_op = true;
-                // Every single ordered operation has to come from read-ahead
-                // cache.
-                if (read_ahead_buffer_map.find(cow_op->new_block) == read_ahead_buffer_map.end()) {
-                    SNAP_LOG(ERROR)
-                            << " Block: " << cow_op->new_block << " not found in read-ahead cache"
-                            << " Op: " << *cow_op;
-                    return -1;
-                }
-                // If this is a final block merged in the read-ahead buffer
-                // region, notify the read-ahead thread to make forward
-                // progress
-                if (cow_op->new_block == snapuserd_->GetFinalBlockMerged()) {
-                    *commit = true;
-                }
-            }
-
-            // zero out to indicate that operation is merged.
-            cow_de->old_chunk = 0;
-            cow_de->new_chunk = 0;
-        } else if (cow_de->old_chunk == 0) {
-            // Already merged op in previous iteration or
-            // This could also represent a partially filled area.
-            //
-            // If the op was merged in previous cycle, we don't have
-            // to count them.
-            break;
-        } else {
-            SNAP_LOG(ERROR) << "Error in merge operation. Found invalid metadata: "
-                            << " merged_de-old-chunk: " << merged_de->old_chunk
-                            << " merged_de-new-chunk: " << merged_de->new_chunk
-                            << " cow_de-old-chunk: " << cow_de->old_chunk
-                            << " cow_de-new-chunk: " << cow_de->new_chunk
-                            << " unmerged_exceptions: " << unmerged_exceptions
-                            << " merged_ops_cur_iter: " << merged_ops_cur_iter
-                            << " offset: " << offset;
-            return -1;
-        }
-    }
-    return merged_ops_cur_iter;
-}
-
-bool WorkerThread::ProcessMergeComplete(chunk_t chunk, void* buffer) {
-    uint32_t stride = exceptions_per_area_ + 1;
-    const std::vector<std::unique_ptr<uint8_t[]>>& vec = snapuserd_->GetMetadataVec();
-    bool ordered_op = false;
-    bool commit = false;
-
-    // ChunkID to vector index
-    lldiv_t divresult = lldiv(chunk, stride);
-
-    if (!(divresult.quot < vec.size())) {
-        SNAP_LOG(ERROR) << "ProcessMergeComplete: Invalid chunk: " << chunk
-                        << " Metadata-Index: " << divresult.quot << " Area-size: " << vec.size();
-        return false;
-    }
-
-    SNAP_LOG(DEBUG) << "ProcessMergeComplete: chunk: " << chunk
-                    << " Metadata-Index: " << divresult.quot;
-
-    int unmerged_exceptions = 0;
-    loff_t offset = GetMergeStartOffset(buffer, vec[divresult.quot].get(), &unmerged_exceptions);
-
-    if (offset < 0) {
-        SNAP_LOG(ERROR) << "GetMergeStartOffset failed: unmerged_exceptions: "
-                        << unmerged_exceptions;
-        return false;
-    }
-
-    int merged_ops_cur_iter = GetNumberOfMergedOps(buffer, vec[divresult.quot].get(), offset,
-                                                   unmerged_exceptions, &ordered_op, &commit);
-
-    // There should be at least one operation merged in this cycle
-    if (!(merged_ops_cur_iter > 0)) {
-        SNAP_LOG(ERROR) << "Merge operation failed: " << merged_ops_cur_iter;
-        return false;
-    }
-
-    if (ordered_op) {
-        if (commit) {
-            // Push the flushing logic to read-ahead thread so that merge thread
-            // can make forward progress. Sync will happen in the background
-            snapuserd_->StartReadAhead();
-        }
-    } else {
-        // Non-copy ops and all ops in older COW format
-        if (!snapuserd_->CommitMerge(merged_ops_cur_iter)) {
-            SNAP_LOG(ERROR) << "CommitMerge failed...";
-            return false;
-        }
-    }
-
-    SNAP_LOG(DEBUG) << "Merge success: " << merged_ops_cur_iter << "chunk: " << chunk;
-    return true;
-}
-
-// Read Header from dm-user misc device. This gives
-// us the sector number for which IO is issued by dm-snapshot device
-bool WorkerThread::ReadDmUserHeader() {
-    if (!android::base::ReadFully(ctrl_fd_, bufsink_.GetBufPtr(), sizeof(struct dm_user_header))) {
-        if (errno != ENOTBLK) {
-            SNAP_PLOG(ERROR) << "Control-read failed";
-        }
-
-        return false;
-    }
-
-    return true;
-}
-
-// Send the payload/data back to dm-user misc device.
-bool WorkerThread::WriteDmUserPayload(size_t size, bool header_response) {
-    size_t payload_size = size;
-    void* buf = bufsink_.GetPayloadBufPtr();
-    if (header_response) {
-        payload_size += sizeof(struct dm_user_header);
-        buf = bufsink_.GetBufPtr();
-    }
-
-    if (!android::base::WriteFully(ctrl_fd_, buf, payload_size)) {
-        SNAP_PLOG(ERROR) << "Write to dm-user failed size: " << payload_size;
-        return false;
-    }
-
-    return true;
-}
-
-bool WorkerThread::ReadDmUserPayload(void* buffer, size_t size) {
-    if (!android::base::ReadFully(ctrl_fd_, buffer, size)) {
-        SNAP_PLOG(ERROR) << "ReadDmUserPayload failed size: " << size;
-        return false;
-    }
-
-    return true;
-}
-
-bool WorkerThread::DmuserWriteRequest() {
-    struct dm_user_header* header = bufsink_.GetHeaderPtr();
-
-    // device mapper has the capability to allow
-    // targets to flush the cache when writes are completed. This
-    // is controlled by each target by a flag "flush_supported".
-    // This flag is set by dm-user. When flush is supported,
-    // a number of zero-length bio's will be submitted to
-    // the target for the purpose of flushing cache. It is the
-    // responsibility of the target driver - which is dm-user in this
-    // case, to remap these bio's to the underlying device. Since,
-    // there is no underlying device for dm-user, this zero length
-    // bio's gets routed to daemon.
-    //
-    // Flush operations are generated post merge by dm-snap by having
-    // REQ_PREFLUSH flag set. Snapuser daemon doesn't have anything
-    // to flush per se; hence, just respond back with a success message.
-    if (header->sector == 0) {
-        if (!(header->len == 0)) {
-            SNAP_LOG(ERROR) << "Invalid header length received from sector 0: " << header->len;
-            header->type = DM_USER_RESP_ERROR;
-        } else {
-            header->type = DM_USER_RESP_SUCCESS;
-        }
-
-        if (!WriteDmUserPayload(0, true)) {
-            return false;
-        }
-        return true;
-    }
-
-    std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
-    size_t remaining_size = header->len;
-    size_t read_size = std::min(PAYLOAD_SIZE, remaining_size);
-
-    chunk_t chunk = SectorToChunk(header->sector);
-    auto it = std::lower_bound(chunk_vec.begin(), chunk_vec.end(),
-                               std::make_pair(header->sector, nullptr), Snapuserd::compare);
-
-    bool not_found = (it == chunk_vec.end() || it->first != header->sector);
-
-    if (not_found) {
-        void* buffer = bufsink_.GetPayloadBuffer(read_size);
-        if (buffer == nullptr) {
-            SNAP_LOG(ERROR) << "DmuserWriteRequest: Failed to get payload buffer of size: "
-                            << read_size;
-            header->type = DM_USER_RESP_ERROR;
-        } else {
-            header->type = DM_USER_RESP_SUCCESS;
-
-            if (!ReadDmUserPayload(buffer, read_size)) {
-                SNAP_LOG(ERROR) << "ReadDmUserPayload failed for chunk id: " << chunk
-                                << "Sector: " << header->sector;
-                header->type = DM_USER_RESP_ERROR;
-            }
-
-            if (header->type == DM_USER_RESP_SUCCESS && !ProcessMergeComplete(chunk, buffer)) {
-                SNAP_LOG(ERROR) << "ProcessMergeComplete failed for chunk id: " << chunk
-                                << "Sector: " << header->sector;
-                header->type = DM_USER_RESP_ERROR;
-            }
-        }
-    } else {
-        SNAP_LOG(ERROR) << "DmuserWriteRequest: Invalid sector received: header->sector";
-        header->type = DM_USER_RESP_ERROR;
-    }
-
-    if (!WriteDmUserPayload(0, true)) {
-        return false;
-    }
-
-    return true;
-}
-
-bool WorkerThread::DmuserReadRequest() {
-    struct dm_user_header* header = bufsink_.GetHeaderPtr();
-    size_t remaining_size = header->len;
-    loff_t offset = 0;
-    sector_t sector = header->sector;
-    std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();
-    bool header_response = true;
-    do {
-        size_t read_size = std::min(PAYLOAD_SIZE, remaining_size);
-
-        int ret = read_size;
-        header->type = DM_USER_RESP_SUCCESS;
-        chunk_t chunk = SectorToChunk(header->sector);
-
-        // Request to sector 0 is always for kernel
-        // representation of COW header. This IO should be only
-        // once during dm-snapshot device creation. We should
-        // never see multiple IO requests. Additionally this IO
-        // will always be a single 4k.
-        if (header->sector == 0) {
-            if (read_size == BLOCK_SZ) {
-                ConstructKernelCowHeader();
-                SNAP_LOG(DEBUG) << "Kernel header constructed";
-            } else {
-                SNAP_LOG(ERROR) << "Invalid read_size: " << read_size << " for sector 0";
-                header->type = DM_USER_RESP_ERROR;
-            }
-        } else {
-            auto it = std::lower_bound(chunk_vec.begin(), chunk_vec.end(),
-                                       std::make_pair(header->sector, nullptr), Snapuserd::compare);
-            bool not_found = (it == chunk_vec.end() || it->first != header->sector);
-            if (!offset && (read_size == BLOCK_SZ) && not_found) {
-                if (!ReadDiskExceptions(chunk, read_size)) {
-                    SNAP_LOG(ERROR) << "ReadDiskExceptions failed for chunk id: " << chunk
-                                    << "Sector: " << header->sector;
-                    header->type = DM_USER_RESP_ERROR;
-                } else {
-                    SNAP_LOG(DEBUG) << "ReadDiskExceptions success for chunk id: " << chunk
-                                    << "Sector: " << header->sector;
-                }
-            } else {
-                chunk_t num_sectors_read = (offset >> SECTOR_SHIFT);
-
-                ret = ReadData(sector + num_sectors_read, read_size);
-                if (ret < 0) {
-                    SNAP_LOG(ERROR) << "ReadData failed for chunk id: " << chunk
-                                    << " Sector: " << (sector + num_sectors_read)
-                                    << " size: " << read_size << " header-len: " << header->len;
-                    header->type = DM_USER_RESP_ERROR;
-                } else {
-                    SNAP_LOG(DEBUG) << "ReadData success for chunk id: " << chunk
-                                    << "Sector: " << header->sector;
-                }
-            }
-        }
-
-        // Just return the header if it is an error
-        if (header->type == DM_USER_RESP_ERROR) {
-            SNAP_LOG(ERROR) << "IO read request failed...";
-            ret = 0;
-        }
-
-        if (!header_response) {
-            CHECK(header->type == DM_USER_RESP_SUCCESS)
-                    << " failed for sector: " << sector << " header->len: " << header->len
-                    << " remaining_size: " << remaining_size;
-        }
-
-        // Daemon will not be terminated if there is any error. We will
-        // just send the error back to dm-user.
-        if (!WriteDmUserPayload(ret, header_response)) {
-            return false;
-        }
-
-        if (header->type == DM_USER_RESP_ERROR) {
-            break;
-        }
-
-        remaining_size -= ret;
-        offset += ret;
-        header_response = false;
-    } while (remaining_size > 0);
-
-    return true;
-}
-
-void WorkerThread::InitializeBufsink() {
-    // Allocate the buffer which is used to communicate between
-    // daemon and dm-user. The buffer comprises of header and a fixed payload.
-    // If the dm-user requests a big IO, the IO will be broken into chunks
-    // of PAYLOAD_SIZE.
-    size_t buf_size = sizeof(struct dm_user_header) + PAYLOAD_SIZE;
-    bufsink_.Initialize(buf_size);
-}
-
-bool WorkerThread::RunThread() {
-    InitializeBufsink();
-
-    if (!InitializeFds()) {
-        return false;
-    }
-
-    if (!InitReader()) {
-        return false;
-    }
-
-    // Start serving IO
-    while (true) {
-        if (!ProcessIORequest()) {
-            break;
-        }
-    }
-
-    CloseFds();
-    reader_->CloseCowFd();
-
-    return true;
-}
-
-bool WorkerThread::ProcessIORequest() {
-    struct dm_user_header* header = bufsink_.GetHeaderPtr();
-
-    if (!ReadDmUserHeader()) {
-        return false;
-    }
-
-    SNAP_LOG(DEBUG) << "Daemon: msg->seq: " << std::dec << header->seq;
-    SNAP_LOG(DEBUG) << "Daemon: msg->len: " << std::dec << header->len;
-    SNAP_LOG(DEBUG) << "Daemon: msg->sector: " << std::dec << header->sector;
-    SNAP_LOG(DEBUG) << "Daemon: msg->type: " << std::dec << header->type;
-    SNAP_LOG(DEBUG) << "Daemon: msg->flags: " << std::dec << header->flags;
-
-    switch (header->type) {
-        case DM_USER_REQ_MAP_READ: {
-            if (!DmuserReadRequest()) {
-                return false;
-            }
-            break;
-        }
-
-        case DM_USER_REQ_MAP_WRITE: {
-            if (!DmuserWriteRequest()) {
-                return false;
-            }
-            break;
-        }
-    }
-
-    return true;
-}
-
-}  // namespace snapshot
-}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
index 36dad3343d3e..e28dd472cee6 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
@@ -34,24 +34,9 @@ namespace android {
 namespace snapshot {
 
 bool Daemon::IsUserspaceSnapshotsEnabled() {
-    const std::string UNKNOWN = "unknown";
-    const std::string vendor_release =
-            android::base::GetProperty("ro.vendor.build.version.release_or_codename", UNKNOWN);
-
-    // No user-space snapshots if vendor partition is on Android 12
-    if (vendor_release.find("12") != std::string::npos) {
-        LOG(INFO) << "Userspace snapshots disabled as vendor partition is on Android: "
-                  << vendor_release;
-        return false;
-    }
-
     return android::base::GetBoolProperty("ro.virtual_ab.userspace.snapshots.enabled", false);
 }
 
-bool Daemon::IsDmSnapshotTestingEnabled() {
-    return android::base::GetBoolProperty("snapuserd.test.dm.snapshots", false);
-}
-
 bool Daemon::StartDaemon(int argc, char** argv) {
     int arg_start = gflags::ParseCommandLineFlags(&argc, &argv, true);
 
@@ -65,16 +50,16 @@ bool Daemon::StartDaemon(int argc, char** argv) {
     // stage init and hence use the command line flags to get the information.
     bool user_snapshots = FLAGS_user_snapshot;
     if (!user_snapshots) {
-        user_snapshots = (!IsDmSnapshotTestingEnabled() && IsUserspaceSnapshotsEnabled());
+        user_snapshots = IsUserspaceSnapshotsEnabled();
     }
 
     if (user_snapshots) {
         LOG(INFO) << "Starting daemon for user-space snapshots.....";
         return StartServerForUserspaceSnapshots(arg_start, argc, argv);
     } else {
-        LOG(INFO) << "Starting daemon for dm-snapshots.....";
-        return StartServerForDmSnapshot(arg_start, argc, argv);
+        LOG(ERROR) << "Userspace snapshots not enabled. No support for legacy snapshots";
     }
+    return false;
 }
 
 bool Daemon::StartServerForUserspaceSnapshots(int arg_start, int argc, char** argv) {
@@ -130,48 +115,6 @@ bool Daemon::StartServerForUserspaceSnapshots(int arg_start, int argc, char** ar
     return user_server_.WaitForSocket();
 }
 
-bool Daemon::StartServerForDmSnapshot(int arg_start, int argc, char** argv) {
-    sigfillset(&signal_mask_);
-    sigdelset(&signal_mask_, SIGINT);
-    sigdelset(&signal_mask_, SIGTERM);
-    sigdelset(&signal_mask_, SIGUSR1);
-
-    // Masking signals here ensure that after this point, we won't handle INT/TERM
-    // until after we call into ppoll()
-    signal(SIGINT, Daemon::SignalHandler);
-    signal(SIGTERM, Daemon::SignalHandler);
-    signal(SIGPIPE, Daemon::SignalHandler);
-    signal(SIGUSR1, Daemon::SignalHandler);
-
-    MaskAllSignalsExceptIntAndTerm();
-
-    if (FLAGS_socket_handoff) {
-        return server_.RunForSocketHandoff();
-    }
-    if (!FLAGS_no_socket) {
-        if (!server_.Start(FLAGS_socket)) {
-            return false;
-        }
-        return server_.Run();
-    }
-
-    for (int i = arg_start; i < argc; i++) {
-        auto parts = android::base::Split(argv[i], ",");
-        if (parts.size() != 3) {
-            LOG(ERROR) << "Malformed message, expected three sub-arguments.";
-            return false;
-        }
-        auto handler = server_.AddHandler(parts[0], parts[1], parts[2]);
-        if (!handler || !server_.StartHandler(handler)) {
-            return false;
-        }
-    }
-
-    // Skip the accept() call to avoid spurious log spam. The server will still
-    // run until all handlers have completed.
-    return server_.WaitForSocket();
-}
-
 void Daemon::MaskAllSignalsExceptIntAndTerm() {
     sigset_t signal_mask;
     sigfillset(&signal_mask);
@@ -198,16 +141,12 @@ void Daemon::Interrupt() {
     // and verify it through a temp variable.
     if (user_server_.IsServerRunning()) {
         user_server_.Interrupt();
-    } else {
-        server_.Interrupt();
     }
 }
 
 void Daemon::ReceivedSocketSignal() {
     if (user_server_.IsServerRunning()) {
         user_server_.ReceivedSocketSignal();
-    } else {
-        server_.ReceivedSocketSignal();
     }
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.h b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.h
index cf3b917e5f77..303e394a8410 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.h
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.h
@@ -19,7 +19,6 @@
 #include <string>
 #include <vector>
 
-#include "dm-snapshot-merge/snapuserd_server.h"
 #include "user-space-merge/snapuserd_server.h"
 
 namespace android {
@@ -36,12 +35,10 @@ class Daemon {
         return instance;
     }
 
-    bool StartServerForDmSnapshot(int arg_start, int argc, char** argv);
     bool StartServerForUserspaceSnapshots(int arg_start, int argc, char** argv);
     void Interrupt();
     void ReceivedSocketSignal();
     bool IsUserspaceSnapshotsEnabled();
-    bool IsDmSnapshotTestingEnabled();
     bool StartDaemon(int argc, char** argv);
 
   private:
@@ -51,7 +48,6 @@ class Daemon {
     Daemon(Daemon const&) = delete;
     void operator=(Daemon const&) = delete;
 
-    SnapuserdServer server_;
     UserSnapshotServer user_server_;
     void MaskAllSignalsExceptIntAndTerm();
     void MaskAllSignals();

From 92b7d837b904f8c1eb43741d8c96495448ea880c Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 13 Mar 2024 13:15:05 -0700
Subject: [PATCH 0798/1487] snapuserd_test: check writer != nullptr

Cow Writer used to fail with ENOSPC during initialization.

Try temporaryFile creation with path set to current working directory.

Bug: 328879200
Test: th, snapuserd_test
Change-Id: I7b3833967952c74142f1d5a35cb8d94dd6d894fc
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../snapuserd/user-space-merge/snapuserd_test.cpp         | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 76b44b48b2b1..d05df82550c4 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -126,7 +126,8 @@ void SnapuserdTestBase::CreateBaseDevice() {
 }
 
 std::unique_ptr<ICowWriter> SnapuserdTestBase::CreateCowDeviceInternal() {
-    cow_system_ = std::make_unique<TemporaryFile>();
+    std::string path = android::base::GetExecutableDirectory();
+    cow_system_ = std::make_unique<TemporaryFile>(path);
 
     CowOptions options;
     options.compression = "gz";
@@ -147,7 +148,8 @@ std::unique_ptr<ICowWriter> SnapuserdTestBase::CreateV3Cow() {
     options.batch_write = true;
     options.compression_factor = params.block_size;
 
-    cow_system_ = std::make_unique<TemporaryFile>();
+    std::string path = android::base::GetExecutableDirectory();
+    cow_system_ = std::make_unique<TemporaryFile>(path);
 
     unique_fd fd(cow_system_->fd);
     cow_system_->fd = -1;
@@ -989,6 +991,7 @@ void SnapuserdVariableBlockSizeTest::SetupCowV3ForVariableBlockSize() {
 void SnapuserdVariableBlockSizeTest::CreateV3CowDeviceForVariableBlockSize() {
     auto writer = CreateV3Cow();
 
+    ASSERT_NE(writer, nullptr);
     size_t total_data_to_write = size_;
 
     size_t total_blocks_to_write = total_data_to_write / BLOCK_SZ;
@@ -1337,6 +1340,7 @@ void HandlerTestV3::TearDown() {
 void HandlerTestV3::SetUpV3Cow() {
     auto writer = CreateV3Cow();
 
+    ASSERT_NE(writer, nullptr);
     size_t total_data_to_write = size_;
 
     size_t total_blocks_to_write = total_data_to_write / BLOCK_SZ;

From c60d2fc5665d7438bafc89e7f8008a338baff61e Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 14 Mar 2024 16:21:46 -0700
Subject: [PATCH 0799/1487] libsnapshot: chunk iov writes

Currently if our iov that we are trying to write is greater than 1024
our write will fail with error "INVALID ARGUMENT". This is because
pwritev() system call takes a max input size of IOV_MAX (which is device
dependant).

With our increased cache size of 1mb or maybe even more (or if user
configures batch size to be large), our write size could be greater than
IOV_MAX, and will fail with an unhelpful error. We should chunk these
writes to ensure they succeed.

Bug: 322279333
Test: cow_api_test + manual testing with large iov write sizes
Change-Id: Ia1fb53cbfc743cfcdfc7256ff9df075ad0c2dd38
---
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 20 ++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index ea1da4b53b01..8cc9964bfc41 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -717,13 +717,27 @@ bool CowWriterV3::WriteOperation(std::span<const CowOperationV3> ops,
         return false;
     }
     if (!data.empty()) {
-        const auto ret = pwritev(fd_, data.data(), data.size(), next_data_pos_);
-        if (ret != total_data_size) {
+        int total_written = 0;
+        int i = 0;
+        while (i < data.size()) {
+            int chunk = std::min(static_cast<int>(data.size() - i), IOV_MAX);
+
+            const auto ret = pwritev(fd_, data.data() + i, chunk, next_data_pos_ + total_written);
+            if (ret < 0) {
+                PLOG(ERROR) << "write failed chunk size of: " << chunk
+                            << " at offset: " << next_data_pos_ + total_written << " " << errno;
+                return false;
+            }
+            total_written += ret;
+            i += chunk;
+        }
+        if (total_written != total_data_size) {
             PLOG(ERROR) << "write failed for data of size: " << data.size()
-                        << " at offset: " << next_data_pos_ << " " << ret;
+                        << " at offset: " << next_data_pos_ << " " << errno;
             return false;
         }
     }
+
     header_.op_count += ops.size();
     next_data_pos_ += total_data_size;
 

From 7285c0d1bbc55a94e48cff7dfbb90eec305ce6cf Mon Sep 17 00:00:00 2001
From: Peter Collingbourne <pcc@google.com>
Date: Thu, 21 Mar 2024 16:56:07 -0700
Subject: [PATCH 0800/1487] tombstoned: Rename proto tombstone before text
 tombstone.

Because the log message "Tombstone written to: $NAME" is written
before renaming the proto tombstone, it is possible that a tool that
automatically downloads new proto tombstones by watching for this
log message will fail to download the tombstone. For the tool that
I am developing, this occurs < 0.1% of the time. Fix the issue by
renaming the proto tombstone first.

Bug: 328531087
Change-Id: I5b751585f2fce897ca7eb76c0466a0c33a93d851
---
 debuggerd/tombstoned/tombstoned.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/debuggerd/tombstoned/tombstoned.cpp b/debuggerd/tombstoned/tombstoned.cpp
index 75ae9f8a6521..fa67d46e61b1 100644
--- a/debuggerd/tombstoned/tombstoned.cpp
+++ b/debuggerd/tombstoned/tombstoned.cpp
@@ -456,6 +456,14 @@ static void crash_completed(borrowed_fd sockfd, std::unique_ptr<Crash> crash) {
 
   CrashArtifactPaths paths = queue->get_next_artifact_paths();
 
+  if (crash->output.proto && crash->output.proto->fd != -1) {
+    if (!paths.proto) {
+      LOG(ERROR) << "missing path for proto tombstone";
+    } else {
+      rename_tombstone_fd(crash->output.proto->fd, queue->dir_fd(), *paths.proto);
+    }
+  }
+
   if (rename_tombstone_fd(crash->output.text.fd, queue->dir_fd(), paths.text)) {
     if (crash->crash_type == kDebuggerdJavaBacktrace) {
       LOG(ERROR) << "Traces for pid " << crash->crash_pid << " written to: " << paths.text;
@@ -466,14 +474,6 @@ static void crash_completed(borrowed_fd sockfd, std::unique_ptr<Crash> crash) {
       LOG(ERROR) << "Tombstone written to: " << paths.text;
     }
   }
-
-  if (crash->output.proto && crash->output.proto->fd != -1) {
-    if (!paths.proto) {
-      LOG(ERROR) << "missing path for proto tombstone";
-    } else {
-      rename_tombstone_fd(crash->output.proto->fd, queue->dir_fd(), *paths.proto);
-    }
-  }
 }
 
 static void crash_completed_cb(evutil_socket_t sockfd, short ev, void* arg) {

From d7efbea407a2ba2cbe0aa3c0cc0a4df072de849b Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 18 Mar 2024 15:42:33 -0700
Subject: [PATCH 0801/1487] cow_api_test: big replace op

With the modified cache system we might be processing big replace ops at
once. Our old tests didn't catch a case where a big replace op was
chunked into seperate batch writes.

Test: cow_api_test
Change-Id: I3bc80a2f9ed3e4c73dd9f74d9affaba79d49e4d2
---
 .../libsnapshot/libsnapshot_cow/test_v3.cpp   | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
index 2021348411ff..4456b269ca9d 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v3.cpp
@@ -209,6 +209,48 @@ TEST_F(CowTestV3, ReplaceOp) {
     ASSERT_EQ(sink, data);
 }
 
+TEST_F(CowTestV3, BigReplaceOp) {
+    CowOptions options;
+    options.op_count_max = 10000;
+    options.batch_write = true;
+    options.cluster_ops = 2048;
+
+    auto writer = CreateCowWriter(3, options, GetCowFd());
+    std::string data = "This is some data, believe it";
+    data.resize(options.block_size * 4096, '\0');
+    for (int i = 0; i < data.size(); i++) {
+        data[i] = static_cast<char>('A' + i / options.block_size);
+    }
+    ASSERT_TRUE(writer->AddRawBlocks(5, data.data(), data.size()));
+    ASSERT_TRUE(writer->Finalize());
+
+    CowReader reader;
+    ASSERT_TRUE(reader.Parse(cow_->fd));
+
+    const auto& header = reader.header_v3();
+    ASSERT_EQ(header.op_count, 4096);
+
+    auto iter = reader.GetOpIter();
+    ASSERT_NE(iter, nullptr);
+    ASSERT_FALSE(iter->AtEnd());
+
+    size_t i = 0;
+
+    while (!iter->AtEnd()) {
+        auto op = iter->Get();
+        std::string sink(options.block_size, '\0');
+        ASSERT_EQ(op->type(), kCowReplaceOp);
+        ASSERT_EQ(op->data_length, options.block_size);
+        ASSERT_EQ(op->new_block, 5 + i);
+        ASSERT_TRUE(ReadData(reader, op, sink.data(), options.block_size));
+        ASSERT_EQ(std::string_view(sink),
+                  std::string_view(data).substr(i * options.block_size, options.block_size))
+                << " readback data for " << i << "th block does not match";
+        iter->Next();
+        i++;
+    }
+}
+
 TEST_F(CowTestV3, ConsecutiveReplaceOp) {
     CowOptions options;
     options.op_count_max = 20;

From 5e8e488c13cbff9e0a305ce7c22fd6a13aabb886 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 13 Mar 2024 14:02:14 -0700
Subject: [PATCH 0802/1487] libsnapshot: Cache Ops correctly

Change the meaning of batch_size_. Previously, a batch size of 200 meant
200 compressed data ops. With variable block size, each compressed data
op can be up to 256k uncompressed size -> batch size meaning should be
changed to 200 blocks of block size.

With this being said, the default batch size can be increased to 4mb to
better accomodate variable block size

The way we calculate the number of blocks to compress at once also
needs to be changed. Since there's no way of determining the comperssed
data size ahead of time, allow overwriting the cache by batch_size_ and
then flushing the cache as needed

Bug: 322279333
Test: Ota on pixel and measuring system image cow
Change-Id: Ie8e08d109dc5c3b4f5f36a740bbbcd37362a7ab3
---
 .../include/libsnapshot/cow_writer.h          |  2 +-
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp | 37 ++++++++++++-------
 .../libsnapshot/libsnapshot_cow/writer_v3.h   |  2 +-
 3 files changed, 25 insertions(+), 16 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
index 651083f3efbc..2c6eefbb7dd2 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h
@@ -45,7 +45,7 @@ struct CowOptions {
     std::optional<uint64_t> max_blocks;
 
     // Number of CowOperations in a cluster. 0 for no clustering. Cannot be 1.
-    uint32_t cluster_ops = 200;
+    uint32_t cluster_ops = 1024;
 
     bool scratch_space = true;
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 8cc9964bfc41..23f3c48b0617 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -310,6 +310,14 @@ bool CowWriterV3::CheckOpCount(size_t op_count) {
     return true;
 }
 
+size_t CowWriterV3::CachedDataSize() const {
+    size_t size = 0;
+    for (const auto& i : cached_data_) {
+        size += i.size();
+    }
+    return size;
+}
+
 bool CowWriterV3::EmitCopy(uint64_t new_block, uint64_t old_block, uint64_t num_blocks) {
     if (!CheckOpCount(num_blocks)) {
         return false;
@@ -342,7 +350,7 @@ bool CowWriterV3::NeedsFlush() const {
     // Allow bigger batch sizes for ops without data. A single CowOperationV3
     // struct uses 14 bytes of memory, even if we cache 200 * 16 ops in memory,
     // it's only ~44K.
-    return cached_data_.size() >= batch_size_ ||
+    return CachedDataSize() >= batch_size_ * header_.block_size ||
            cached_ops_.size() >= batch_size_ * kNonDataOpBufferSize;
 }
 
@@ -397,13 +405,13 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
         return false;
     }
     const auto bytes = reinterpret_cast<const uint8_t*>(data);
-    const size_t num_blocks = (size / header_.block_size);
-    for (size_t i = 0; i < num_blocks;) {
-        const size_t blocks_to_write =
-                std::min<size_t>(batch_size_ - cached_data_.size(), num_blocks - i);
-
-        if (!ConstructCowOpCompressedBuffers(new_block_start + i, bytes + header_.block_size * i,
-                                             old_block + i, offset, type, blocks_to_write)) {
+    size_t num_blocks = (size / header_.block_size);
+    size_t total_written = 0;
+    while (total_written < num_blocks) {
+        size_t chunk = std::min(num_blocks - total_written, batch_size_);
+        if (!ConstructCowOpCompressedBuffers(new_block_start + total_written,
+                                             bytes + header_.block_size * total_written,
+                                             old_block + total_written, offset, type, chunk)) {
             return false;
         }
 
@@ -413,8 +421,7 @@ bool CowWriterV3::EmitBlocks(uint64_t new_block_start, const void* data, size_t
                        << ", op type: " << type;
             return false;
         }
-
-        i += blocks_to_write;
+        total_written += chunk;
     }
 
     return true;
@@ -482,7 +489,8 @@ bool CowWriterV3::EmitSequenceData(size_t num_ops, const uint32_t* data) {
 
     header_.sequence_data_count = num_ops;
 
-    // Ensure next_data_pos_ is updated as previously initialized + the newly added sequence buffer.
+    // Ensure next_data_pos_ is updated as previously initialized + the newly added sequence
+    // buffer.
     CHECK_EQ(next_data_pos_ + header_.sequence_data_count * sizeof(uint32_t),
              GetDataOffset(header_));
     next_data_pos_ = GetDataOffset(header_);
@@ -640,8 +648,8 @@ std::vector<CowWriterV3::CompressedBuffer> CowWriterV3::ProcessBlocksWithThreade
     //                   t1     t2     t1     t2    <- processed by these threads
     // Ordering is important here. We need to retrieve the compressed data in the same order we
     // processed it and assume that that we submit data beginning with the first thread and then
-    // round robin the consecutive data calls. We need to Fetch compressed buffers from the threads
-    // via the same ordering
+    // round robin the consecutive data calls. We need to Fetch compressed buffers from the
+    // threads via the same ordering
     for (size_t i = 0; i < compressed_vec.size(); i++) {
         compressed_buf.emplace_back(worker_buffers[i % num_threads][i / num_threads]);
     }
@@ -733,7 +741,8 @@ bool CowWriterV3::WriteOperation(std::span<const CowOperationV3> ops,
         }
         if (total_written != total_data_size) {
             PLOG(ERROR) << "write failed for data of size: " << data.size()
-                        << " at offset: " << next_data_pos_ << " " << errno;
+                        << " at offset: " << next_data_pos_ << " " << errno
+                        << ", only wrote: " << total_written;
             return false;
         }
     }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index e2dc69813c5b..871ed273fc89 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -94,7 +94,7 @@ class CowWriterV3 : public CowWriterBase {
         }
         return false;
     }
-
+    size_t CachedDataSize() const;
     bool ReadBackVerification();
     bool FlushCacheOps();
     void InitWorkers();

From 6d7e83fb420395f80b48351395d456c7d6d33da8 Mon Sep 17 00:00:00 2001
From: Jeongik Cha <jeongik@google.com>
Date: Tue, 12 Mar 2024 19:35:15 +0900
Subject: [PATCH 0803/1487] Add //visibility:any_system_partition

system image which is declared in Android.bp should include the module.

Bug: 321000103
Test: m nothing
Change-Id: I6e9d8fa4c1051211ff9ff80c7dfa4a8ee5cbd732
---
 init/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/init/Android.bp b/init/Android.bp
index 12ca15ae346b..d4b7fabd0bb7 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -310,6 +310,7 @@ cc_binary {
     name: "init_second_stage",
     defaults: ["init_second_stage_defaults"],
     static_libs: ["libinit"],
+    visibility: ["//visibility:any_system_partition"],
 }
 
 cc_binary {

From 7199051aaf0ddfa2849650933119307327d8669c Mon Sep 17 00:00:00 2001
From: Chris Sarbora <tophyr@gmail.com>
Date: Fri, 22 Mar 2024 09:32:02 -0500
Subject: [PATCH 0804/1487] Wait for disconnect when rebooting to userspace FB

Wait for the device to disconnect when rebooting to userspace fastboot.
This is a particular problem for USB-over-IP devices, which must tunnel
the USB commands over a relatively-slow network and thus will not
disconnect as quickly as local ones.

Only currently effective for Linux hosts, since LinuxUsbTransport is the
only transport that implements WaitForDisconnect().

Test Plan:
provision with a usbip-attached device, see flash succeed

Change-Id: Ia8903dfa6e40755377870fbeaef9162934f992a0
---
 fastboot/fastboot.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 12a1ddc87571..6b9e493ebdab 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1547,9 +1547,14 @@ bool is_userspace_fastboot() {
 
 void reboot_to_userspace_fastboot() {
     fb->RebootTo("fastboot");
+    if (fb->WaitForDisconnect() != fastboot::SUCCESS) {
+        die("Error waiting for USB disconnect.");
+    }
     fb->set_transport(nullptr);
 
-    // Give the current connection time to close.
+    // Not all platforms support WaitForDisconnect. There also isn't a great way to tell whether
+    // or not WaitForDisconnect is supported. So, just wait a bit extra for everyone, in order to
+    // make sure that the device has had time to initiate its reboot and disconnect itself.
     std::this_thread::sleep_for(std::chrono::seconds(1));
 
     fb->set_transport(open_device());

From 35d5c94bb064f5f93bb8090cf39c20c842ea0fbe Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 25 Mar 2024 11:32:27 -0700
Subject: [PATCH 0805/1487] libsnapshot: Enable snapshots during OTA install
 for S vendor

ro.virtual_ab.userspace.snapshots.enabled is a vendor property which isn't present in Android S. Hence, during OTA install with S vendor, userspace_snapshots is disabled.

However, both update_engine and snapuserd are already on the system partition during install. Hence, forcefully enable userspace_snapshots if this is a path of legacy dm-snapshots with Vendor on Android S.


Bug: 331156940
Test: OTA tests on treehugger, pixel OTA
Change-Id: I3d1c03493d83e670e37df088d4b676c4aa1dc720
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshot.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index b4892b4a1a6d..6d344bd5eb92 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -3288,8 +3288,11 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
         }
     }
 
-    LOG(INFO) << "userspace snapshots: " << userspace_snapshots
-              << " legacy_snapuserd: " << legacy_compression;
+    if (!userspace_snapshots && is_legacy_snapuserd && legacy_compression) {
+        userspace_snapshots = true;
+        LOG(INFO) << "Vendor from Android 12. Enabling userspace snapshot for OTA install";
+    }
+
     const bool using_snapuserd = userspace_snapshots || legacy_compression;
     if (!using_snapuserd) {
         LOG(INFO) << "Using legacy Virtual A/B (dm-snapshot)";
@@ -3389,6 +3392,7 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
         }
 
         if (is_legacy_snapuserd) {
+            LOG(INFO) << "Setting legacy_snapuserd to true";
             status.set_legacy_snapuserd(true);
         }
     } else if (legacy_compression) {

From c375878b8e5befc194008a03ade95163724b0171 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 25 Mar 2024 18:35:04 -0700
Subject: [PATCH 0806/1487] snapuserd: Use snapshots during install

If on Androd 12, continue to use snapshots

Bug: 304829384
Test: OTA on Pixel
Change-Id: I94890c308e7f297b695ddbd71659ebb1cf4d278c
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
index e28dd472cee6..0ebe543df3bf 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
@@ -34,6 +34,21 @@ namespace android {
 namespace snapshot {
 
 bool Daemon::IsUserspaceSnapshotsEnabled() {
+    const std::string UNKNOWN = "unknown";
+    const std::string vendor_release =
+            android::base::GetProperty("ro.vendor.build.version.release_or_codename", UNKNOWN);
+
+    // If the vendor is on Android S, install process will forcefully take the
+    // userspace snapshots path.
+    //
+    // We will not reach here post OTA reboot as the binary will be from vendor
+    // ramdisk which is on Android S.
+    if (vendor_release.find("12") != std::string::npos) {
+        LOG(INFO) << "Userspace snapshots enabled as vendor partition is on Android: "
+                  << vendor_release;
+        return true;
+    }
+
     return android::base::GetBoolProperty("ro.virtual_ab.userspace.snapshots.enabled", false);
 }
 

From d28f45772fe9ce2bf16013fa19c53de0e1021cac Mon Sep 17 00:00:00 2001
From: Nikita Ioffe <ioffe@google.com>
Date: Tue, 26 Mar 2024 18:04:21 +0000
Subject: [PATCH 0807/1487] Remove check that only allows microdroid vendor
 partition on debuggable VMs

The microdroid vendor partition is now verified during Microdroid boot,
so no need for this check.

Bug: 287593065
Test: AVF presubmit
Change-Id: I84811f818ef1140f1fe93d9da5f9ee61341e75dd
---
 init/first_stage_init.cpp | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index 356aaa091ae7..bfe636bbfb37 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -408,18 +408,6 @@ int FirstStageMain(int argc, char** argv) {
 
     LOG(INFO) << "init first stage started!";
 
-    // We only allow /vendor partition in debuggable Microdrod until it is verified during boot.
-    // TODO(b/285855436): remove this check.
-    if (IsMicrodroid()) {
-        bool mount_vendor =
-                cmdline.find("androidboot.microdroid.mount_vendor=1") != std::string::npos;
-        bool debuggable =
-                bootconfig.find("androidboot.microdroid.debuggable = \"1\"") != std::string::npos;
-        if (mount_vendor && !debuggable) {
-            LOG(FATAL) << "Attempted to mount /vendor partition for non-debuggable Microdroid VM";
-        }
-    }
-
     auto old_root_dir = std::unique_ptr<DIR, decltype(&closedir)>{opendir("/"), closedir};
     if (!old_root_dir) {
         PLOG(ERROR) << "Could not opendir(\"/\"), not freeing ramdisk";

From b0cf1d2370ae86dce2d6a2595aae476bd32b31b1 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 26 Mar 2024 18:33:58 -0700
Subject: [PATCH 0808/1487] libsnapshot: Propagate legacy_snapuserd status
 during WriteUpdateState

Bug: 304829384
Test: OTA on Pixel
Change-Id: I841612c111148523d13166051512314d6fa1986f
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshot.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 6d344bd5eb92..de91bd2c620b 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -3018,6 +3018,7 @@ bool SnapshotManager::WriteUpdateState(LockedFile* lock, UpdateState state,
         status.set_merge_phase(old_status.merge_phase());
         status.set_userspace_snapshots(old_status.userspace_snapshots());
         status.set_io_uring_enabled(old_status.io_uring_enabled());
+        status.set_legacy_snapuserd(old_status.legacy_snapuserd());
     }
     return WriteSnapshotUpdateStatus(lock, status);
 }

From a2aa83c5a5433a6d081cbd9e7ce8305f98df5ea3 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 27 Mar 2024 06:55:10 -0700
Subject: [PATCH 0809/1487] libsnapshot: don't kill the daemon for legacy vab
 snapshots

If partitions are mounted off the daemon, there is no need
to kill if the tests are being run for legacy vab snapshots.

This also removes vabc_legacy_test as it is no longer required.

Bug: 331053511
Test: vab_legacy_test, vts_libsnapshot_test on Pixel - No flake observed
with 10 iterations
Change-Id: Ie8b29fef77948d23d920c19d816376290cf2fed9
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/TEST_MAPPING                  |  4 ----
 fs_mgr/libsnapshot/snapshot_test.cpp | 18 +++++++++++++-----
 2 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index 1989a5c9d84e..32e8b88e1833 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -25,8 +25,6 @@
     {
       "name": "vab_legacy_tests"
     },
-    // TODO(b/279009697):
-    //{"name": "vabc_legacy_tests"},
     {
       "name": "cow_api_test"
     },
@@ -44,8 +42,6 @@
     {
       "name": "vab_legacy_tests"
     },
-    // TODO(b/279009697):
-    //{"name": "vabc_legacy_tests"}
     {
       "name": "snapuserd_test"
     }
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 8d0c898c7721..80dad17cc274 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2883,7 +2883,16 @@ int main(int argc, char** argv) {
     ::testing::AddGlobalTestEnvironment(new ::android::snapshot::SnapshotTestEnvironment());
     gflags::ParseCommandLineFlags(&argc, &argv, false);
 
-    android::base::SetProperty("ctl.stop", "snapuserd");
+    bool vab_legacy = false;
+    if (FLAGS_force_mode == "vab-legacy") {
+        vab_legacy = true;
+    }
+
+    if (!vab_legacy) {
+        // This is necessary if the configuration we're testing doesn't match the device.
+        android::base::SetProperty("ctl.stop", "snapuserd");
+        android::snapshot::KillSnapuserd();
+    }
 
     std::unordered_set<std::string> modes = {"", "vab-legacy"};
     if (modes.count(FLAGS_force_mode) == 0) {
@@ -2891,13 +2900,12 @@ int main(int argc, char** argv) {
         return 1;
     }
 
-    // This is necessary if the configuration we're testing doesn't match the device.
-    android::snapshot::KillSnapuserd();
-
     int ret = RUN_ALL_TESTS();
 
     android::base::SetProperty("snapuserd.test.io_uring.force_disable", "0");
 
-    android::snapshot::KillSnapuserd();
+    if (!vab_legacy) {
+        android::snapshot::KillSnapuserd();
+    }
     return ret;
 }

From bcaeacc6862be57f72ba1c51427214136c2e06df Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Wed, 27 Mar 2024 16:17:50 -0700
Subject: [PATCH 0810/1487] Enable weak functions properly.

There is a check for WEAKS_AVAILABLE that is never set. Change this so
so it is available everywhere except apple/windows.

Add new test to verify that on Android the logStackInternal function is
defined.

Bug: 331489939

Test: All unit tests pass.
Change-Id: Ie982eba30ae421931a62718d39ff1f0c282453db
---
 libutils/CallStack.cpp      |  5 +++--
 libutils/CallStack_test.cpp | 41 +++++++++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+), 2 deletions(-)

diff --git a/libutils/CallStack.cpp b/libutils/CallStack.cpp
index fe827eb0e208..029f4a76e87b 100644
--- a/libutils/CallStack.cpp
+++ b/libutils/CallStack.cpp
@@ -89,7 +89,8 @@ void CallStack::print(Printer& printer) const {
 // The following four functions may be used via weak symbol references from libutils.
 // Clients assume that if any of these symbols are available, then deleteStack() is.
 
-#ifdef WEAKS_AVAILABLE
+// Apple and Windows does not support this, so only compile on other platforms.
+#if !defined(__APPLE__) && !defined(_WIN32)
 
 CallStack::CallStackUPtr CallStack::getCurrentInternal(int ignoreDepth) {
     CallStack::CallStackUPtr stack(new CallStack());
@@ -110,6 +111,6 @@ void CallStack::deleteStack(CallStack* stack) {
     delete stack;
 }
 
-#endif // WEAKS_AVAILABLE
+#endif  // !defined(__APPLE__) && !defined(_WIN32)
 
 }; // namespace android
diff --git a/libutils/CallStack_test.cpp b/libutils/CallStack_test.cpp
index 2cfaf6127e2b..7afc2c33390f 100644
--- a/libutils/CallStack_test.cpp
+++ b/libutils/CallStack_test.cpp
@@ -18,10 +18,16 @@
 
 #include <thread>
 
+#include <android-base/test_utils.h>
 #include <android-base/threads.h>
 #include <gtest/gtest.h>
 #include <utils/CallStack.h>
 
+#if defined(__ANDROID__)
+#include <log/log.h>
+#include <log/log_read.h>
+#endif
+
 __attribute__((__noinline__)) extern "C" void CurrentCaller(android::String8& backtrace) {
     android::CallStack cs;
     cs.update();
@@ -61,3 +67,38 @@ TEST(CallStackTest, thread_backtrace) {
 
     ASSERT_NE(-1, cs.toString().find("(ThreadBusyWait")) << "Full backtrace:\n" << cs.toString();
 }
+
+#if defined(__ANDROID__)
+TEST(CallStackTest, log_stack) {
+    android::CallStack::logStack("callstack_test");
+    auto logger_list = android_logger_list_open(android_name_to_log_id("main"),
+                                                ANDROID_LOG_NONBLOCK, 1000, getpid());
+    ASSERT_NE(nullptr, logger_list);
+    std::string log;
+    while (true) {
+        log_msg log_msg;
+        auto ret = android_logger_list_read(logger_list, &log_msg);
+        if (ret == -EAGAIN) {
+            break;
+        }
+        ASSERT_GT(ret, 0);
+        if (log_msg.msg() == nullptr) {
+            continue;
+        }
+        // First get the tag.
+        char* msg = &log_msg.msg()[1];
+        if (std::string(msg) != "callstack_test") {
+            continue;
+        }
+        // Now move past the tag.
+        msg = &msg[strlen(msg) + 1];
+        log += msg;
+        log += '\n';
+    }
+    ASSERT_NE("", log) << "No messages found in the log from the test.";
+    // Look for a backtrace line such as:
+    //   #00 pc 00000000000536e4  libutils_test (testing::Test::Run()+436)
+    ASSERT_MATCH(log, "#\\d+ pc \\d+");
+    android_logger_list_close(logger_list);
+}
+#endif

From 37c3ed70c0701a24703efeb425806a10f8d17088 Mon Sep 17 00:00:00 2001
From: Kiyoung Kim <kiyoungkim@google.com>
Date: Thu, 28 Mar 2024 11:19:03 +0900
Subject: [PATCH 0811/1487] Remove unused VNDK-related function

This change is to clean up VNDK-related code from build. The function
append_vndk_version is not in use.

Bug: 330100430
Test: aosp_cf_x86_64_phone build succeeded
Change-Id: I691093aaedb7f6630cc32145dcaf7d36403bcf90
---
 rootdir/Android.mk | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 7444f963fd0c..593bb1e349e8 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -223,13 +223,6 @@ $(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/init.environ.rc.in
 	$(hide) sed -i -e 's?%EXPORT_GLOBAL_HWASAN_OPTIONS%?$(EXPORT_GLOBAL_HWASAN_OPTIONS)?g' $@
 	$(hide) sed -i -e 's?%EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE%?$(EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE)?g' $@
 
-# Append PLATFORM_VNDK_VERSION to base name.
-define append_vndk_version
-$(strip \
-  $(basename $(1)).$(PLATFORM_VNDK_VERSION)$(suffix $(1)) \
-)
-endef
-
 #######################################
 # sanitizer.libraries.txt
 include $(CLEAR_VARS)

From ec799183c8be97835a62339ef25e10c5c63f6f62 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 28 Mar 2024 09:51:52 -0700
Subject: [PATCH 0812/1487] init: Remove legacy virtual-ab support

Bug: 304829384
Test: OTA on Pixel
Change-Id: I8463a1cc102379daa41fdade6820222a5e3bdd86
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 init/first_stage_mount.cpp    |  5 +++--
 init/snapuserd_transition.cpp | 23 +++++++----------------
 init/snapuserd_transition.h   |  7 +------
 3 files changed, 11 insertions(+), 24 deletions(-)

diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index 836d536c9a6e..ae216c66404d 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -396,9 +396,10 @@ bool FirstStageMountVBootV2::CreateSnapshotPartitions(SnapshotManager* sm) {
     use_snapuserd_ = sm->IsSnapuserdRequired();
     if (use_snapuserd_) {
         if (sm->UpdateUsesUserSnapshots()) {
-            LaunchFirstStageSnapuserd(SnapshotDriver::DM_USER);
+            LaunchFirstStageSnapuserd();
         } else {
-            LaunchFirstStageSnapuserd(SnapshotDriver::DM_SNAPSHOT);
+            LOG(FATAL) << "legacy virtual-ab is no longer supported";
+            return false;
         }
     }
 
diff --git a/init/snapuserd_transition.cpp b/init/snapuserd_transition.cpp
index dea7af97b9fd..9e3ff4175e08 100644
--- a/init/snapuserd_transition.cpp
+++ b/init/snapuserd_transition.cpp
@@ -62,7 +62,7 @@ static constexpr char kSnapuserdFirstStageInfoVar[] = "FIRST_STAGE_SNAPUSERD_INF
 static constexpr char kSnapuserdLabel[] = "u:object_r:snapuserd_exec:s0";
 static constexpr char kSnapuserdSocketLabel[] = "u:object_r:snapuserd_socket:s0";
 
-void LaunchFirstStageSnapuserd(SnapshotDriver driver) {
+void LaunchFirstStageSnapuserd() {
     SocketDescriptor socket_desc;
     socket_desc.name = android::snapshot::kSnapuserdSocket;
     socket_desc.type = SOCK_STREAM;
@@ -85,22 +85,13 @@ void LaunchFirstStageSnapuserd(SnapshotDriver driver) {
     if (pid == 0) {
         socket->Publish();
 
-        if (driver == SnapshotDriver::DM_USER) {
-            char arg0[] = "/system/bin/snapuserd";
-            char arg1[] = "-user_snapshot";
-            char* const argv[] = {arg0, arg1, nullptr};
-            if (execv(arg0, argv) < 0) {
-                PLOG(FATAL) << "Cannot launch snapuserd; execv failed";
-            }
-            _exit(127);
-        } else {
-            char arg0[] = "/system/bin/snapuserd";
-            char* const argv[] = {arg0, nullptr};
-            if (execv(arg0, argv) < 0) {
-                PLOG(FATAL) << "Cannot launch snapuserd; execv failed";
-            }
-            _exit(127);
+        char arg0[] = "/system/bin/snapuserd";
+        char arg1[] = "-user_snapshot";
+        char* const argv[] = {arg0, arg1, nullptr};
+        if (execv(arg0, argv) < 0) {
+            PLOG(FATAL) << "Cannot launch snapuserd; execv failed";
         }
+        _exit(127);
     }
 
     auto client = SnapuserdClient::Connect(android::snapshot::kSnapuserdSocket, 10s);
diff --git a/init/snapuserd_transition.h b/init/snapuserd_transition.h
index 557d10587aaa..e86e8daa18fb 100644
--- a/init/snapuserd_transition.h
+++ b/init/snapuserd_transition.h
@@ -29,13 +29,8 @@
 namespace android {
 namespace init {
 
-enum class SnapshotDriver {
-    DM_SNAPSHOT,
-    DM_USER,
-};
-
 // Fork and exec a new copy of snapuserd.
-void LaunchFirstStageSnapuserd(SnapshotDriver driver);
+void LaunchFirstStageSnapuserd();
 
 class SnapuserdSelinuxHelper final {
     using SnapshotManager = android::snapshot::SnapshotManager;

From e336b9219c206318f866398df09b9216b281761c Mon Sep 17 00:00:00 2001
From: Devin Moore <devinmoore@google.com>
Date: Thu, 28 Mar 2024 21:05:13 +0000
Subject: [PATCH 0813/1487] init_kill_services_test: don't always try to kill
 hwservicemanager

When HIDL is not supported, hwservicemanager will not be running and may
not even be installed on the device.

Ignore-AOSP-First: Disabling HIDL internally first. Will cherry-pick
these test CLs after.

Test: init_kill_services_test
Bug: 218588089
Change-Id: Iae41e35e4669dd62c99ab9f138fc419be2f5fa29
---
 init/test_kill_services/Android.bp                  | 5 ++++-
 init/test_kill_services/init_kill_services_test.cpp | 5 +++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/init/test_kill_services/Android.bp b/init/test_kill_services/Android.bp
index 37361a813c57..ada87d804941 100644
--- a/init/test_kill_services/Android.bp
+++ b/init/test_kill_services/Android.bp
@@ -10,7 +10,10 @@ package {
 cc_test {
     name: "init_kill_services_test",
     srcs: ["init_kill_services_test.cpp"],
-    shared_libs: ["libbase"],
+    shared_libs: [
+        "libbase",
+        "libhidlbase",
+    ],
     test_suites: ["general-tests"],
 
     // TODO(b/153565474): switch back to auto-generation
diff --git a/init/test_kill_services/init_kill_services_test.cpp b/init/test_kill_services/init_kill_services_test.cpp
index 510ad8aee898..3af92bb55ff6 100644
--- a/init/test_kill_services/init_kill_services_test.cpp
+++ b/init/test_kill_services/init_kill_services_test.cpp
@@ -18,15 +18,20 @@
 
 #include <android-base/logging.h>
 #include <android-base/properties.h>
+#include <hidl/ServiceManagement.h>
 
 #include <iostream>
 
 using ::android::base::GetProperty;
 using ::android::base::SetProperty;
 using ::android::base::WaitForProperty;
+using ::android::hardware::isHidlSupported;
 using std::literals::chrono_literals::operator""s;
 
 void ExpectKillingServiceRecovers(const std::string& service_name) {
+    if (!isHidlSupported() && service_name == "hwservicemanager") {
+        GTEST_SKIP() << "No HIDL support on device so hwservicemanager will not be running";
+    }
     LOG(INFO) << "before we say hi to " << service_name << ", I can't have apexd around!";
 
     // b/280514080 - servicemanager will restart apexd, and apexd will restart the

From a5521b0d9f53412454448f07c5bfaeb83a8bae84 Mon Sep 17 00:00:00 2001
From: Devin Moore <devinmoore@google.com>
Date: Thu, 28 Mar 2024 21:05:13 +0000
Subject: [PATCH 0814/1487] init_kill_services_test: don't always try to kill
 hwservicemanager

When HIDL is not supported, hwservicemanager will not be running and may
not even be installed on the device.

Ignore-AOSP-First: Disabling HIDL internally first. Will cherry-pick
these test CLs after.

Test: init_kill_services_test
Bug: 218588089
Change-Id: Iae41e35e4669dd62c99ab9f138fc419be2f5fa29
---
 init/test_kill_services/Android.bp                  | 5 ++++-
 init/test_kill_services/init_kill_services_test.cpp | 5 +++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/init/test_kill_services/Android.bp b/init/test_kill_services/Android.bp
index 37361a813c57..ada87d804941 100644
--- a/init/test_kill_services/Android.bp
+++ b/init/test_kill_services/Android.bp
@@ -10,7 +10,10 @@ package {
 cc_test {
     name: "init_kill_services_test",
     srcs: ["init_kill_services_test.cpp"],
-    shared_libs: ["libbase"],
+    shared_libs: [
+        "libbase",
+        "libhidlbase",
+    ],
     test_suites: ["general-tests"],
 
     // TODO(b/153565474): switch back to auto-generation
diff --git a/init/test_kill_services/init_kill_services_test.cpp b/init/test_kill_services/init_kill_services_test.cpp
index 510ad8aee898..3af92bb55ff6 100644
--- a/init/test_kill_services/init_kill_services_test.cpp
+++ b/init/test_kill_services/init_kill_services_test.cpp
@@ -18,15 +18,20 @@
 
 #include <android-base/logging.h>
 #include <android-base/properties.h>
+#include <hidl/ServiceManagement.h>
 
 #include <iostream>
 
 using ::android::base::GetProperty;
 using ::android::base::SetProperty;
 using ::android::base::WaitForProperty;
+using ::android::hardware::isHidlSupported;
 using std::literals::chrono_literals::operator""s;
 
 void ExpectKillingServiceRecovers(const std::string& service_name) {
+    if (!isHidlSupported() && service_name == "hwservicemanager") {
+        GTEST_SKIP() << "No HIDL support on device so hwservicemanager will not be running";
+    }
     LOG(INFO) << "before we say hi to " << service_name << ", I can't have apexd around!";
 
     // b/280514080 - servicemanager will restart apexd, and apexd will restart the

From 65f2a496329871e51deec0c0d9cd881d16293db9 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Fri, 29 Mar 2024 11:49:36 -0700
Subject: [PATCH 0815/1487] vts_fs_test: Annotate fs type test for VSR.

Bug: 302209455
Test: N/A
Change-Id: I5be7472b9d68072bb1400479187e7aee10beb0c7
---
 fs_mgr/tests/vts_fs_test.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs_mgr/tests/vts_fs_test.cpp b/fs_mgr/tests/vts_fs_test.cpp
index 9503072d2a38..f55cadb2403a 100644
--- a/fs_mgr/tests/vts_fs_test.cpp
+++ b/fs_mgr/tests/vts_fs_test.cpp
@@ -74,6 +74,7 @@ TEST(fs, ErofsSupported) {
     ASSERT_EQ(access("/sys/fs/erofs", F_OK), 0);
 }
 
+// @VsrTest = 3.7.10
 TEST(fs, PartitionTypes) {
     // Requirements only apply to Android 13+, 5.10+ devices.
     int vsr_level = GetVsrLevel();

From 0919e1bc0073a73bea32a448b1f6159e457071f2 Mon Sep 17 00:00:00 2001
From: Peter Collingbourne <pcc@google.com>
Date: Tue, 27 Feb 2024 19:37:41 -0800
Subject: [PATCH 0816/1487] adb: Do not use fs_config unless we are root (try
 2).

This enables fs_config for /data when pushing files as root. Also,
without this, adb push to /tmp fails as the shell user.

When pushing to a directory that does not have an explicit fs_config,
such as /data/local/tmp or /tmp, use the original file mode.

Bug: 171233429
Bug: 311263616
Change-Id: Ied805bc3912ea0b4e1691127b5032aef632f85fd
---
 .../arm64/source-based/libcutils.so.lsdump    | 64 +++++++++++++++++++
 .../source-based/libcutils.so.lsdump          | 64 +++++++++++++++++++
 libcutils/fs_config.cpp                       | 45 +++++++++----
 libcutils/include/private/fs_config.h         | 33 +++++++---
 4 files changed, 182 insertions(+), 24 deletions(-)

diff --git a/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump b/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
index 333e61c181fa..67c7514a6547 100644
--- a/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
+++ b/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
@@ -289,6 +289,9 @@
   {
    "name" : "fs_write_atomic_int"
   },
+  {
+   "name" : "get_fs_config"
+  },
   {
    "name" : "hashmapCreate"
   },
@@ -1273,6 +1276,27 @@
    "return_type" : "_ZTIi",
    "source_file" : "system/core/libcutils/include/cutils/fs.h"
   },
+  {
+   "function_name" : "get_fs_config",
+   "linker_set_key" : "get_fs_config",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIb"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIP9fs_config"
+    }
+   ],
+   "return_type" : "_ZTIb",
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
+  },
   {
    "function_name" : "hashmapCreate",
    "linker_set_key" : "hashmapCreate",
@@ -2390,6 +2414,15 @@
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIP9fs_config",
+   "name" : "fs_config *",
+   "referenced_type" : "_ZTI9fs_config",
+   "self_type" : "_ZTIP9fs_config",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
+  },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIP9str_parms",
@@ -2684,6 +2717,37 @@
    "self_type" : "_ZTI5cnode",
    "size" : 40,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "alignment" : 8,
+   "fields" :
+   [
+    {
+     "field_name" : "uid",
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "field_name" : "gid",
+     "field_offset" : 32,
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "field_name" : "mode",
+     "field_offset" : 64,
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "field_name" : "capabilities",
+     "field_offset" : 128,
+     "referenced_type" : "_ZTIm"
+    }
+   ],
+   "linker_set_key" : "_ZTI9fs_config",
+   "name" : "fs_config",
+   "referenced_type" : "_ZTI9fs_config",
+   "self_type" : "_ZTI9fs_config",
+   "size" : 24,
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
   }
  ],
  "rvalue_reference_types" : []
diff --git a/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump b/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
index f612fb9420a4..f75240c04074 100644
--- a/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
+++ b/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
@@ -299,6 +299,9 @@
   {
    "name" : "fs_write_atomic_int"
   },
+  {
+   "name" : "get_fs_config"
+  },
   {
    "name" : "hashmapCreate"
   },
@@ -1283,6 +1286,27 @@
    "return_type" : "_ZTIi",
    "source_file" : "system/core/libcutils/include/cutils/fs.h"
   },
+  {
+   "function_name" : "get_fs_config",
+   "linker_set_key" : "get_fs_config",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIb"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIP9fs_config"
+    }
+   ],
+   "return_type" : "_ZTIb",
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
+  },
   {
    "function_name" : "hashmapCreate",
    "linker_set_key" : "hashmapCreate",
@@ -2400,6 +2424,15 @@
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIP9fs_config",
+   "name" : "fs_config *",
+   "referenced_type" : "_ZTI9fs_config",
+   "self_type" : "_ZTIP9fs_config",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
+  },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIP9str_parms",
@@ -2694,6 +2727,37 @@
    "self_type" : "_ZTI5cnode",
    "size" : 20,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "alignment" : 8,
+   "fields" :
+   [
+    {
+     "field_name" : "uid",
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "field_name" : "gid",
+     "field_offset" : 32,
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "field_name" : "mode",
+     "field_offset" : 64,
+     "referenced_type" : "_ZTIt"
+    },
+    {
+     "field_name" : "capabilities",
+     "field_offset" : 128,
+     "referenced_type" : "_ZTIy"
+    }
+   ],
+   "linker_set_key" : "_ZTI9fs_config",
+   "name" : "fs_config",
+   "referenced_type" : "_ZTI9fs_config",
+   "self_type" : "_ZTI9fs_config",
+   "size" : 24,
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
   }
  ],
  "rvalue_reference_types" : []
diff --git a/libcutils/fs_config.cpp b/libcutils/fs_config.cpp
index 919be2ff2a0b..756ff8ebc076 100644
--- a/libcutils/fs_config.cpp
+++ b/libcutils/fs_config.cpp
@@ -91,7 +91,7 @@ static const struct fs_path_config android_dirs[] = {
     { 00751, AID_ROOT,         AID_SHELL,        0, "vendor/bin" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "vendor/apex/*/bin" },
     { 00755, AID_ROOT,         AID_SHELL,        0, "vendor" },
-    { 00755, AID_ROOT,         AID_ROOT,         0, 0 },
+    {},
         // clang-format on
 };
 #ifndef __ANDROID_VNDK__
@@ -228,7 +228,7 @@ static const struct fs_path_config android_files[] = {
     { 00755, AID_ROOT,      AID_SHELL,     0, "vendor/bin/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "vendor/apex/*bin/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "vendor/xbin/*" },
-    { 00644, AID_ROOT,      AID_ROOT,      0, 0 },
+    {},
         // clang-format on
 };
 #ifndef __ANDROID_VNDK__
@@ -318,8 +318,8 @@ static bool fs_config_cmp(bool dir, const char* prefix, size_t len, const char*
 auto __for_testing_only__fs_config_cmp = fs_config_cmp;
 #endif
 
-void fs_config(const char* path, int dir, const char* target_out_path, unsigned* uid, unsigned* gid,
-               unsigned* mode, uint64_t* capabilities) {
+bool get_fs_config(const char* path, bool dir, const char* target_out_path,
+                   struct fs_config* fs_conf) {
     const struct fs_path_config* pc;
     size_t which, plen;
 
@@ -362,11 +362,11 @@ void fs_config(const char* path, int dir, const char* target_out_path, unsigned*
             if (fs_config_cmp(dir, prefix, len, path, plen)) {
                 free(prefix);
                 close(fd);
-                *uid = header.uid;
-                *gid = header.gid;
-                *mode = (*mode & (~07777)) | header.mode;
-                *capabilities = header.capabilities;
-                return;
+                fs_conf->uid = header.uid;
+                fs_conf->gid = header.gid;
+                fs_conf->mode = header.mode;
+                fs_conf->capabilities = header.capabilities;
+                return true;
             }
             free(prefix);
         }
@@ -375,11 +375,28 @@ void fs_config(const char* path, int dir, const char* target_out_path, unsigned*
 
     for (pc = dir ? android_dirs : android_files; pc->prefix; pc++) {
         if (fs_config_cmp(dir, pc->prefix, strlen(pc->prefix), path, plen)) {
-            break;
+            fs_conf->uid = pc->uid;
+            fs_conf->gid = pc->gid;
+            fs_conf->mode = pc->mode;
+            fs_conf->capabilities = pc->capabilities;
+            return true;
         }
     }
-    *uid = pc->uid;
-    *gid = pc->gid;
-    *mode = (*mode & (~07777)) | pc->mode;
-    *capabilities = pc->capabilities;
+    return false;
+}
+
+void fs_config(const char* path, int dir, const char* target_out_path, unsigned* uid, unsigned* gid,
+               unsigned* mode, uint64_t* capabilities) {
+    struct fs_config conf;
+    if (get_fs_config(path, dir, target_out_path, &conf)) {
+        *uid = conf.uid;
+        *gid = conf.gid;
+        *mode = (*mode & S_IFMT) | conf.mode;
+        *capabilities = conf.capabilities;
+    } else {
+        *uid = AID_ROOT;
+        *gid = AID_ROOT;
+        *mode = (*mode & S_IFMT) | (dir ? 0755 : 0644);
+        *capabilities = 0;
+    }
 }
diff --git a/libcutils/include/private/fs_config.h b/libcutils/include/private/fs_config.h
index 45f46e5494da..9a727bc58179 100644
--- a/libcutils/include/private/fs_config.h
+++ b/libcutils/include/private/fs_config.h
@@ -21,8 +21,11 @@
 
 #pragma once
 
+#include <fcntl.h>
+#include <stdbool.h>
 #include <stdint.h>
 #include <sys/cdefs.h>
+#include <unistd.h>
 
 #include <linux/capability.h>
 
@@ -30,17 +33,27 @@
 
 __BEGIN_DECLS
 
-/*
- * Used in:
- *  build/tools/fs_config/fs_config.c
- *  build/tools/fs_get_stats/fs_get_stats.c
- *  system/extras/ext4_utils/make_ext4fs_main.c
- *  external/squashfs-tools/squashfs-tools/android.c
- *  system/core/cpio/mkbootfs.c
- *  system/core/adb/file_sync_service.cpp
- *  system/extras/ext4_utils/canned_fs_config.c
- */
+/* This API is deprecated. New users should call get_fs_config. */
 void fs_config(const char* path, int dir, const char* target_out_path, unsigned* uid, unsigned* gid,
                unsigned* mode, uint64_t* capabilities);
 
+struct fs_config {
+  uid_t uid;
+  gid_t gid;
+  mode_t mode;
+  uint64_t capabilities;
+};
+
+/*
+ * If a file system configuration was found for the specified path, store it to *conf.
+ * Returns whether a file system configuration was found.
+ *
+ * dir: Whether path refers to a directory.
+ * target_out_path: Path to the base directory to read the file system configuration from, or a null
+ * pointer to use the root directory as the base. Host code should pass $ANDROID_PRODUCT_OUT or
+ * equivalent, and device code should pass a null pointer.
+ */
+bool get_fs_config(const char* path, bool dir, const char* target_out_path,
+                   struct fs_config* conf);
+
 __END_DECLS

From e2fbaed97b29621fe7707814a23b7e7296baaf3a Mon Sep 17 00:00:00 2001
From: Weilin Wu <wlogsky@google.com>
Date: Mon, 1 Apr 2024 06:16:30 +0000
Subject: [PATCH 0817/1487] Revert "adb: Do not use fs_config unless we are
 root (try 2)."

Revert submission 3001420-main-Ied805bc3912ea0b4e1691127b5032aef632f85fd

Reason for revert: DroidMonitor: Potential culprit for Bug 331999499 - verifying through ABTD before revert submission. This is part of the standard investigation process, and does not mean your CL will be reverted.

Reverted changes: /q/submissionid:3001420-main-Ied805bc3912ea0b4e1691127b5032aef632f85fd

Change-Id: Ibe525a6fd6c01b1f58c67c086306607c4f4d20db
---
 .../arm64/source-based/libcutils.so.lsdump    | 64 -------------------
 .../source-based/libcutils.so.lsdump          | 64 -------------------
 libcutils/fs_config.cpp                       | 45 ++++---------
 libcutils/include/private/fs_config.h         | 33 +++-------
 4 files changed, 24 insertions(+), 182 deletions(-)

diff --git a/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump b/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
index 67c7514a6547..333e61c181fa 100644
--- a/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
+++ b/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
@@ -289,9 +289,6 @@
   {
    "name" : "fs_write_atomic_int"
   },
-  {
-   "name" : "get_fs_config"
-  },
   {
    "name" : "hashmapCreate"
   },
@@ -1276,27 +1273,6 @@
    "return_type" : "_ZTIi",
    "source_file" : "system/core/libcutils/include/cutils/fs.h"
   },
-  {
-   "function_name" : "get_fs_config",
-   "linker_set_key" : "get_fs_config",
-   "parameters" :
-   [
-    {
-     "referenced_type" : "_ZTIPKc"
-    },
-    {
-     "referenced_type" : "_ZTIb"
-    },
-    {
-     "referenced_type" : "_ZTIPKc"
-    },
-    {
-     "referenced_type" : "_ZTIP9fs_config"
-    }
-   ],
-   "return_type" : "_ZTIb",
-   "source_file" : "system/core/libcutils/include/private/fs_config.h"
-  },
   {
    "function_name" : "hashmapCreate",
    "linker_set_key" : "hashmapCreate",
@@ -2414,15 +2390,6 @@
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
-  {
-   "alignment" : 8,
-   "linker_set_key" : "_ZTIP9fs_config",
-   "name" : "fs_config *",
-   "referenced_type" : "_ZTI9fs_config",
-   "self_type" : "_ZTIP9fs_config",
-   "size" : 8,
-   "source_file" : "system/core/libcutils/include/private/fs_config.h"
-  },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIP9str_parms",
@@ -2717,37 +2684,6 @@
    "self_type" : "_ZTI5cnode",
    "size" : 40,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
-  },
-  {
-   "alignment" : 8,
-   "fields" :
-   [
-    {
-     "field_name" : "uid",
-     "referenced_type" : "_ZTIj"
-    },
-    {
-     "field_name" : "gid",
-     "field_offset" : 32,
-     "referenced_type" : "_ZTIj"
-    },
-    {
-     "field_name" : "mode",
-     "field_offset" : 64,
-     "referenced_type" : "_ZTIj"
-    },
-    {
-     "field_name" : "capabilities",
-     "field_offset" : 128,
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "linker_set_key" : "_ZTI9fs_config",
-   "name" : "fs_config",
-   "referenced_type" : "_ZTI9fs_config",
-   "self_type" : "_ZTI9fs_config",
-   "size" : 24,
-   "source_file" : "system/core/libcutils/include/private/fs_config.h"
   }
  ],
  "rvalue_reference_types" : []
diff --git a/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump b/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
index f75240c04074..f612fb9420a4 100644
--- a/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
+++ b/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
@@ -299,9 +299,6 @@
   {
    "name" : "fs_write_atomic_int"
   },
-  {
-   "name" : "get_fs_config"
-  },
   {
    "name" : "hashmapCreate"
   },
@@ -1286,27 +1283,6 @@
    "return_type" : "_ZTIi",
    "source_file" : "system/core/libcutils/include/cutils/fs.h"
   },
-  {
-   "function_name" : "get_fs_config",
-   "linker_set_key" : "get_fs_config",
-   "parameters" :
-   [
-    {
-     "referenced_type" : "_ZTIPKc"
-    },
-    {
-     "referenced_type" : "_ZTIb"
-    },
-    {
-     "referenced_type" : "_ZTIPKc"
-    },
-    {
-     "referenced_type" : "_ZTIP9fs_config"
-    }
-   ],
-   "return_type" : "_ZTIb",
-   "source_file" : "system/core/libcutils/include/private/fs_config.h"
-  },
   {
    "function_name" : "hashmapCreate",
    "linker_set_key" : "hashmapCreate",
@@ -2424,15 +2400,6 @@
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
-  {
-   "alignment" : 4,
-   "linker_set_key" : "_ZTIP9fs_config",
-   "name" : "fs_config *",
-   "referenced_type" : "_ZTI9fs_config",
-   "self_type" : "_ZTIP9fs_config",
-   "size" : 4,
-   "source_file" : "system/core/libcutils/include/private/fs_config.h"
-  },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIP9str_parms",
@@ -2727,37 +2694,6 @@
    "self_type" : "_ZTI5cnode",
    "size" : 20,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
-  },
-  {
-   "alignment" : 8,
-   "fields" :
-   [
-    {
-     "field_name" : "uid",
-     "referenced_type" : "_ZTIj"
-    },
-    {
-     "field_name" : "gid",
-     "field_offset" : 32,
-     "referenced_type" : "_ZTIj"
-    },
-    {
-     "field_name" : "mode",
-     "field_offset" : 64,
-     "referenced_type" : "_ZTIt"
-    },
-    {
-     "field_name" : "capabilities",
-     "field_offset" : 128,
-     "referenced_type" : "_ZTIy"
-    }
-   ],
-   "linker_set_key" : "_ZTI9fs_config",
-   "name" : "fs_config",
-   "referenced_type" : "_ZTI9fs_config",
-   "self_type" : "_ZTI9fs_config",
-   "size" : 24,
-   "source_file" : "system/core/libcutils/include/private/fs_config.h"
   }
  ],
  "rvalue_reference_types" : []
diff --git a/libcutils/fs_config.cpp b/libcutils/fs_config.cpp
index 756ff8ebc076..919be2ff2a0b 100644
--- a/libcutils/fs_config.cpp
+++ b/libcutils/fs_config.cpp
@@ -91,7 +91,7 @@ static const struct fs_path_config android_dirs[] = {
     { 00751, AID_ROOT,         AID_SHELL,        0, "vendor/bin" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "vendor/apex/*/bin" },
     { 00755, AID_ROOT,         AID_SHELL,        0, "vendor" },
-    {},
+    { 00755, AID_ROOT,         AID_ROOT,         0, 0 },
         // clang-format on
 };
 #ifndef __ANDROID_VNDK__
@@ -228,7 +228,7 @@ static const struct fs_path_config android_files[] = {
     { 00755, AID_ROOT,      AID_SHELL,     0, "vendor/bin/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "vendor/apex/*bin/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "vendor/xbin/*" },
-    {},
+    { 00644, AID_ROOT,      AID_ROOT,      0, 0 },
         // clang-format on
 };
 #ifndef __ANDROID_VNDK__
@@ -318,8 +318,8 @@ static bool fs_config_cmp(bool dir, const char* prefix, size_t len, const char*
 auto __for_testing_only__fs_config_cmp = fs_config_cmp;
 #endif
 
-bool get_fs_config(const char* path, bool dir, const char* target_out_path,
-                   struct fs_config* fs_conf) {
+void fs_config(const char* path, int dir, const char* target_out_path, unsigned* uid, unsigned* gid,
+               unsigned* mode, uint64_t* capabilities) {
     const struct fs_path_config* pc;
     size_t which, plen;
 
@@ -362,11 +362,11 @@ bool get_fs_config(const char* path, bool dir, const char* target_out_path,
             if (fs_config_cmp(dir, prefix, len, path, plen)) {
                 free(prefix);
                 close(fd);
-                fs_conf->uid = header.uid;
-                fs_conf->gid = header.gid;
-                fs_conf->mode = header.mode;
-                fs_conf->capabilities = header.capabilities;
-                return true;
+                *uid = header.uid;
+                *gid = header.gid;
+                *mode = (*mode & (~07777)) | header.mode;
+                *capabilities = header.capabilities;
+                return;
             }
             free(prefix);
         }
@@ -375,28 +375,11 @@ bool get_fs_config(const char* path, bool dir, const char* target_out_path,
 
     for (pc = dir ? android_dirs : android_files; pc->prefix; pc++) {
         if (fs_config_cmp(dir, pc->prefix, strlen(pc->prefix), path, plen)) {
-            fs_conf->uid = pc->uid;
-            fs_conf->gid = pc->gid;
-            fs_conf->mode = pc->mode;
-            fs_conf->capabilities = pc->capabilities;
-            return true;
+            break;
         }
     }
-    return false;
-}
-
-void fs_config(const char* path, int dir, const char* target_out_path, unsigned* uid, unsigned* gid,
-               unsigned* mode, uint64_t* capabilities) {
-    struct fs_config conf;
-    if (get_fs_config(path, dir, target_out_path, &conf)) {
-        *uid = conf.uid;
-        *gid = conf.gid;
-        *mode = (*mode & S_IFMT) | conf.mode;
-        *capabilities = conf.capabilities;
-    } else {
-        *uid = AID_ROOT;
-        *gid = AID_ROOT;
-        *mode = (*mode & S_IFMT) | (dir ? 0755 : 0644);
-        *capabilities = 0;
-    }
+    *uid = pc->uid;
+    *gid = pc->gid;
+    *mode = (*mode & (~07777)) | pc->mode;
+    *capabilities = pc->capabilities;
 }
diff --git a/libcutils/include/private/fs_config.h b/libcutils/include/private/fs_config.h
index 9a727bc58179..45f46e5494da 100644
--- a/libcutils/include/private/fs_config.h
+++ b/libcutils/include/private/fs_config.h
@@ -21,11 +21,8 @@
 
 #pragma once
 
-#include <fcntl.h>
-#include <stdbool.h>
 #include <stdint.h>
 #include <sys/cdefs.h>
-#include <unistd.h>
 
 #include <linux/capability.h>
 
@@ -33,27 +30,17 @@
 
 __BEGIN_DECLS
 
-/* This API is deprecated. New users should call get_fs_config. */
-void fs_config(const char* path, int dir, const char* target_out_path, unsigned* uid, unsigned* gid,
-               unsigned* mode, uint64_t* capabilities);
-
-struct fs_config {
-  uid_t uid;
-  gid_t gid;
-  mode_t mode;
-  uint64_t capabilities;
-};
-
 /*
- * If a file system configuration was found for the specified path, store it to *conf.
- * Returns whether a file system configuration was found.
- *
- * dir: Whether path refers to a directory.
- * target_out_path: Path to the base directory to read the file system configuration from, or a null
- * pointer to use the root directory as the base. Host code should pass $ANDROID_PRODUCT_OUT or
- * equivalent, and device code should pass a null pointer.
+ * Used in:
+ *  build/tools/fs_config/fs_config.c
+ *  build/tools/fs_get_stats/fs_get_stats.c
+ *  system/extras/ext4_utils/make_ext4fs_main.c
+ *  external/squashfs-tools/squashfs-tools/android.c
+ *  system/core/cpio/mkbootfs.c
+ *  system/core/adb/file_sync_service.cpp
+ *  system/extras/ext4_utils/canned_fs_config.c
  */
-bool get_fs_config(const char* path, bool dir, const char* target_out_path,
-                   struct fs_config* conf);
+void fs_config(const char* path, int dir, const char* target_out_path, unsigned* uid, unsigned* gid,
+               unsigned* mode, uint64_t* capabilities);
 
 __END_DECLS

From 4a57c8f4f278ba8a1cbff0d372a91d663b6383f4 Mon Sep 17 00:00:00 2001
From: Peter Collingbourne <pcc@google.com>
Date: Tue, 27 Feb 2024 19:37:41 -0800
Subject: [PATCH 0818/1487] adb: Do not use fs_config unless we are root (try
 3).

This enables fs_config for /data when pushing files as root. Also,
without this, adb push to /tmp fails as the shell user.

When pushing to a directory that does not have an explicit
fs_config, such as /data/local/tmp or /tmp, use the original
file mode. Because adb copies u permissions into g and o
(and in general because the umask on the host may have
made these files world writable), this requires adding more
fs_config entries to cover directories that may contain dex files
i.e. /{odm,product,system,system_ext,vendor}/{framework,app,priv-app}
to avoid hitting a SecurityException caused by writable dex files, e.g.

04-01 21:22:16.980 10110  4815  4815 E AndroidRuntime: FATAL EXCEPTION: main
04-01 21:22:16.980 10110  4815  4815 E AndroidRuntime: Process: android.test.app.system_priv, PID: 4815
04-01 21:22:16.980 10110  4815  4815 E AndroidRuntime: java.lang.SecurityException: Writable dex file '/system/priv-app/loadlibrarytest_system_priv_app/loadlibrarytest_system_priv_app.apk' is not allowed.
04-01 21:22:16.980 10110  4815  4815 E AndroidRuntime:  at dalvik.system.DexFile.openDexFileNative(Native Method)
04-01 21:22:16.980 10110  4815  4815 E AndroidRuntime:  at dalvik.system.DexFile.openDexFile(DexFile.java:406)

Bug: 171233429
Bug: 311263616
Change-Id: I18f70095c793d08a25ff59e1851f6dc7648ce4dc
---
 .../arm64/source-based/libcutils.so.lsdump    | 64 +++++++++++++++++++
 .../source-based/libcutils.so.lsdump          | 64 +++++++++++++++++++
 libcutils/fs_config.cpp                       | 60 +++++++++++++----
 libcutils/include/private/fs_config.h         | 33 +++++++---
 4 files changed, 197 insertions(+), 24 deletions(-)

diff --git a/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump b/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
index 333e61c181fa..67c7514a6547 100644
--- a/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
+++ b/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
@@ -289,6 +289,9 @@
   {
    "name" : "fs_write_atomic_int"
   },
+  {
+   "name" : "get_fs_config"
+  },
   {
    "name" : "hashmapCreate"
   },
@@ -1273,6 +1276,27 @@
    "return_type" : "_ZTIi",
    "source_file" : "system/core/libcutils/include/cutils/fs.h"
   },
+  {
+   "function_name" : "get_fs_config",
+   "linker_set_key" : "get_fs_config",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIb"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIP9fs_config"
+    }
+   ],
+   "return_type" : "_ZTIb",
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
+  },
   {
    "function_name" : "hashmapCreate",
    "linker_set_key" : "hashmapCreate",
@@ -2390,6 +2414,15 @@
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
+  {
+   "alignment" : 8,
+   "linker_set_key" : "_ZTIP9fs_config",
+   "name" : "fs_config *",
+   "referenced_type" : "_ZTI9fs_config",
+   "self_type" : "_ZTIP9fs_config",
+   "size" : 8,
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
+  },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIP9str_parms",
@@ -2684,6 +2717,37 @@
    "self_type" : "_ZTI5cnode",
    "size" : 40,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "alignment" : 8,
+   "fields" :
+   [
+    {
+     "field_name" : "uid",
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "field_name" : "gid",
+     "field_offset" : 32,
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "field_name" : "mode",
+     "field_offset" : 64,
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "field_name" : "capabilities",
+     "field_offset" : 128,
+     "referenced_type" : "_ZTIm"
+    }
+   ],
+   "linker_set_key" : "_ZTI9fs_config",
+   "name" : "fs_config",
+   "referenced_type" : "_ZTI9fs_config",
+   "self_type" : "_ZTI9fs_config",
+   "size" : 24,
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
   }
  ],
  "rvalue_reference_types" : []
diff --git a/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump b/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
index f612fb9420a4..f75240c04074 100644
--- a/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
+++ b/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
@@ -299,6 +299,9 @@
   {
    "name" : "fs_write_atomic_int"
   },
+  {
+   "name" : "get_fs_config"
+  },
   {
    "name" : "hashmapCreate"
   },
@@ -1283,6 +1286,27 @@
    "return_type" : "_ZTIi",
    "source_file" : "system/core/libcutils/include/cutils/fs.h"
   },
+  {
+   "function_name" : "get_fs_config",
+   "linker_set_key" : "get_fs_config",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIb"
+    },
+    {
+     "referenced_type" : "_ZTIPKc"
+    },
+    {
+     "referenced_type" : "_ZTIP9fs_config"
+    }
+   ],
+   "return_type" : "_ZTIb",
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
+  },
   {
    "function_name" : "hashmapCreate",
    "linker_set_key" : "hashmapCreate",
@@ -2400,6 +2424,15 @@
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
+  {
+   "alignment" : 4,
+   "linker_set_key" : "_ZTIP9fs_config",
+   "name" : "fs_config *",
+   "referenced_type" : "_ZTI9fs_config",
+   "self_type" : "_ZTIP9fs_config",
+   "size" : 4,
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
+  },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIP9str_parms",
@@ -2694,6 +2727,37 @@
    "self_type" : "_ZTI5cnode",
    "size" : 20,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
+  },
+  {
+   "alignment" : 8,
+   "fields" :
+   [
+    {
+     "field_name" : "uid",
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "field_name" : "gid",
+     "field_offset" : 32,
+     "referenced_type" : "_ZTIj"
+    },
+    {
+     "field_name" : "mode",
+     "field_offset" : 64,
+     "referenced_type" : "_ZTIt"
+    },
+    {
+     "field_name" : "capabilities",
+     "field_offset" : 128,
+     "referenced_type" : "_ZTIy"
+    }
+   ],
+   "linker_set_key" : "_ZTI9fs_config",
+   "name" : "fs_config",
+   "referenced_type" : "_ZTI9fs_config",
+   "self_type" : "_ZTI9fs_config",
+   "size" : 24,
+   "source_file" : "system/core/libcutils/include/private/fs_config.h"
   }
  ],
  "rvalue_reference_types" : []
diff --git a/libcutils/fs_config.cpp b/libcutils/fs_config.cpp
index 919be2ff2a0b..5efe2098bac8 100644
--- a/libcutils/fs_config.cpp
+++ b/libcutils/fs_config.cpp
@@ -91,7 +91,7 @@ static const struct fs_path_config android_dirs[] = {
     { 00751, AID_ROOT,         AID_SHELL,        0, "vendor/bin" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "vendor/apex/*/bin" },
     { 00755, AID_ROOT,         AID_SHELL,        0, "vendor" },
-    { 00755, AID_ROOT,         AID_ROOT,         0, 0 },
+    {},
         // clang-format on
 };
 #ifndef __ANDROID_VNDK__
@@ -218,17 +218,32 @@ static const struct fs_path_config android_files[] = {
     { 00640, AID_ROOT,      AID_SHELL,     0, "fstab.*" },
     { 00750, AID_ROOT,      AID_SHELL,     0, "init*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "odm/bin/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "odm/framework/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "odm/app/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "odm/priv-app/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "product/bin/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "product/apex/*bin/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "product/framework/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "product/app/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "product/priv-app/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "system/bin/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "system/xbin/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "system/apex/*/bin/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "system/framework/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "system/app/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "system/priv-app/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "system_ext/bin/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "system_ext/apex/*/bin/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "system_ext/framework/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "system_ext/app/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "system_ext/priv-app/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "vendor/bin/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "vendor/apex/*bin/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "vendor/xbin/*" },
-    { 00644, AID_ROOT,      AID_ROOT,      0, 0 },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "vendor/framework/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "vendor/app/*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "vendor/priv-app/*" },
+    {},
         // clang-format on
 };
 #ifndef __ANDROID_VNDK__
@@ -318,8 +333,8 @@ static bool fs_config_cmp(bool dir, const char* prefix, size_t len, const char*
 auto __for_testing_only__fs_config_cmp = fs_config_cmp;
 #endif
 
-void fs_config(const char* path, int dir, const char* target_out_path, unsigned* uid, unsigned* gid,
-               unsigned* mode, uint64_t* capabilities) {
+bool get_fs_config(const char* path, bool dir, const char* target_out_path,
+                   struct fs_config* fs_conf) {
     const struct fs_path_config* pc;
     size_t which, plen;
 
@@ -362,11 +377,11 @@ void fs_config(const char* path, int dir, const char* target_out_path, unsigned*
             if (fs_config_cmp(dir, prefix, len, path, plen)) {
                 free(prefix);
                 close(fd);
-                *uid = header.uid;
-                *gid = header.gid;
-                *mode = (*mode & (~07777)) | header.mode;
-                *capabilities = header.capabilities;
-                return;
+                fs_conf->uid = header.uid;
+                fs_conf->gid = header.gid;
+                fs_conf->mode = header.mode;
+                fs_conf->capabilities = header.capabilities;
+                return true;
             }
             free(prefix);
         }
@@ -375,11 +390,28 @@ void fs_config(const char* path, int dir, const char* target_out_path, unsigned*
 
     for (pc = dir ? android_dirs : android_files; pc->prefix; pc++) {
         if (fs_config_cmp(dir, pc->prefix, strlen(pc->prefix), path, plen)) {
-            break;
+            fs_conf->uid = pc->uid;
+            fs_conf->gid = pc->gid;
+            fs_conf->mode = pc->mode;
+            fs_conf->capabilities = pc->capabilities;
+            return true;
         }
     }
-    *uid = pc->uid;
-    *gid = pc->gid;
-    *mode = (*mode & (~07777)) | pc->mode;
-    *capabilities = pc->capabilities;
+    return false;
+}
+
+void fs_config(const char* path, int dir, const char* target_out_path, unsigned* uid, unsigned* gid,
+               unsigned* mode, uint64_t* capabilities) {
+    struct fs_config conf;
+    if (get_fs_config(path, dir, target_out_path, &conf)) {
+        *uid = conf.uid;
+        *gid = conf.gid;
+        *mode = (*mode & S_IFMT) | conf.mode;
+        *capabilities = conf.capabilities;
+    } else {
+        *uid = AID_ROOT;
+        *gid = AID_ROOT;
+        *mode = (*mode & S_IFMT) | (dir ? 0755 : 0644);
+        *capabilities = 0;
+    }
 }
diff --git a/libcutils/include/private/fs_config.h b/libcutils/include/private/fs_config.h
index 45f46e5494da..9a727bc58179 100644
--- a/libcutils/include/private/fs_config.h
+++ b/libcutils/include/private/fs_config.h
@@ -21,8 +21,11 @@
 
 #pragma once
 
+#include <fcntl.h>
+#include <stdbool.h>
 #include <stdint.h>
 #include <sys/cdefs.h>
+#include <unistd.h>
 
 #include <linux/capability.h>
 
@@ -30,17 +33,27 @@
 
 __BEGIN_DECLS
 
-/*
- * Used in:
- *  build/tools/fs_config/fs_config.c
- *  build/tools/fs_get_stats/fs_get_stats.c
- *  system/extras/ext4_utils/make_ext4fs_main.c
- *  external/squashfs-tools/squashfs-tools/android.c
- *  system/core/cpio/mkbootfs.c
- *  system/core/adb/file_sync_service.cpp
- *  system/extras/ext4_utils/canned_fs_config.c
- */
+/* This API is deprecated. New users should call get_fs_config. */
 void fs_config(const char* path, int dir, const char* target_out_path, unsigned* uid, unsigned* gid,
                unsigned* mode, uint64_t* capabilities);
 
+struct fs_config {
+  uid_t uid;
+  gid_t gid;
+  mode_t mode;
+  uint64_t capabilities;
+};
+
+/*
+ * If a file system configuration was found for the specified path, store it to *conf.
+ * Returns whether a file system configuration was found.
+ *
+ * dir: Whether path refers to a directory.
+ * target_out_path: Path to the base directory to read the file system configuration from, or a null
+ * pointer to use the root directory as the base. Host code should pass $ANDROID_PRODUCT_OUT or
+ * equivalent, and device code should pass a null pointer.
+ */
+bool get_fs_config(const char* path, bool dir, const char* target_out_path,
+                   struct fs_config* conf);
+
 __END_DECLS

From 65430f8de60c8b9f90a2e5e30da6d36f03e5860c Mon Sep 17 00:00:00 2001
From: Oliver Nguyen <olivernguyen@google.com>
Date: Mon, 1 Apr 2024 15:35:28 -0700
Subject: [PATCH 0819/1487] Move native coverage output directory.

Native coverage will be written to /data/local/tmp instead of
/data/misc/trace, allowing coverage tests to run on non-coverage builds.

Test: atest libunwindstack_unit_test --experimental-coverage
Test: m droid && acloud create --local-image
Bug: 332390317
Change-Id: I5840cef04a6e0dc3c749c53121176e1ea42029a0
---
 rootdir/Android.mk | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 593bb1e349e8..0d5abbff4d62 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -85,9 +85,9 @@ endif
 EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS :=
 ifeq ($(CLANG_COVERAGE),true)
   ifeq ($(CLANG_COVERAGE_CONTINUOUS_MODE),true)
-    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang%c-%20m.profraw
+    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/local/tmp/clang%c-%20m.profraw
   else
-    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang-%20m.profraw
+    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/local/tmp/clang-%20m.profraw
   endif
 endif
 

From 91d82fb635e124d68d984e581d1f952f49b2ff61 Mon Sep 17 00:00:00 2001
From: Jeongik Cha <jeongik@google.com>
Date: Tue, 2 Apr 2024 12:52:53 +0900
Subject: [PATCH 0820/1487] Add libEGL, libGLESv2 into provideLibs

which are dlopen'ed from librutabaga_gfx from com.android.virt

Bug: 325929966
Test: check if crosvm display works
Change-Id: I7245286ed646dc3287ad3c4df6e7c021b1dd439e
---
 rootdir/etc/linker.config.json | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/rootdir/etc/linker.config.json b/rootdir/etc/linker.config.json
index d72ac66813dd..61af6e94242b 100644
--- a/rootdir/etc/linker.config.json
+++ b/rootdir/etc/linker.config.json
@@ -32,6 +32,8 @@
   ],
   "provideLibs": [
     "libaptX_encoder.so",
-    "libaptXHD_encoder.so"
+    "libaptXHD_encoder.so",
+    "libEGL.so",
+    "libGLESv2.so"
   ]
 }

From 0f42bd4a83f1d120c15c36f57d8f2a3eebf95349 Mon Sep 17 00:00:00 2001
From: Charisee <chiw@google.com>
Date: Tue, 2 Apr 2024 03:44:31 +0000
Subject: [PATCH 0821/1487] Update needed for Rust v1.77.0

error: field `0` is never read
  --> system/core/trusty/keymint/src/keymint_hal_main.rs:40:24
   |
40 | struct HalServiceError(String);
   |        --------------- ^^^^^^
   |        |
   |        field in this struct
   |
   = note: `HalServiceError` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis
   = note: `-D dead-code` implied by `-D warnings`
   = help: to override `-D warnings` add `#[allow(dead_code)]`
help: consider changing the field to be of unit type to suppress this warning while preserving the field numbering, or remove the field
   |
40 | struct HalServiceError(());
   |                        ~~


Bug: http://b/330185853
Test: ./test_compiler.py --prebuilt-path dist/rust-dev.tar.xz  --target aosp_cf_x86_64_phone --image

Change-Id: I79fb9019ba00900508aead414de80edd51f3fa2e
---
 trusty/keymint/src/keymint_hal_main.rs | 2 +-
 trusty/secretkeeper/src/hal_main.rs    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/trusty/keymint/src/keymint_hal_main.rs b/trusty/keymint/src/keymint_hal_main.rs
index eda986a4568d..ef0c598fe4d1 100644
--- a/trusty/keymint/src/keymint_hal_main.rs
+++ b/trusty/keymint/src/keymint_hal_main.rs
@@ -82,7 +82,7 @@ impl SerializedChannel for TipcChannel {
 }
 
 fn main() {
-    if let Err(e) = inner_main() {
+    if let Err(HalServiceError(e)) = inner_main() {
         panic!("HAL service failed: {:?}", e);
     }
 }
diff --git a/trusty/secretkeeper/src/hal_main.rs b/trusty/secretkeeper/src/hal_main.rs
index df304931dc4b..b31db13df53f 100644
--- a/trusty/secretkeeper/src/hal_main.rs
+++ b/trusty/secretkeeper/src/hal_main.rs
@@ -91,7 +91,7 @@ impl SerializedChannel for TipcChannel {
 }
 
 fn main() {
-    if let Err(e) = inner_main() {
+    if let Err(HalServiceError(e)) = inner_main() {
         panic!("HAL service failed: {:?}", e);
     }
 }

From 916ed66659ee2778906a81aa6fc681e2e82d8785 Mon Sep 17 00:00:00 2001
From: Satish Yalla <satishy@google.com>
Date: Tue, 2 Apr 2024 06:45:44 +0000
Subject: [PATCH 0822/1487] Revert "init_kill_services_test: don't always try
 to kill hwserv..."

Revert submission 26722372-nomo_hidl

Reason for revert: <Reason for revert: Potential culprit for b/332395670- verifying through ABTD before revert submission. This is part of the standard investigation process, and does not mean your CL will be reverted.>

Reverted changes: /q/submissionid:26722372-nomo_hidl

Change-Id: I6fe936e3c27f528020b36def91c541f37e638b98
---
 init/test_kill_services/Android.bp                  | 5 +----
 init/test_kill_services/init_kill_services_test.cpp | 5 -----
 2 files changed, 1 insertion(+), 9 deletions(-)

diff --git a/init/test_kill_services/Android.bp b/init/test_kill_services/Android.bp
index ada87d804941..37361a813c57 100644
--- a/init/test_kill_services/Android.bp
+++ b/init/test_kill_services/Android.bp
@@ -10,10 +10,7 @@ package {
 cc_test {
     name: "init_kill_services_test",
     srcs: ["init_kill_services_test.cpp"],
-    shared_libs: [
-        "libbase",
-        "libhidlbase",
-    ],
+    shared_libs: ["libbase"],
     test_suites: ["general-tests"],
 
     // TODO(b/153565474): switch back to auto-generation
diff --git a/init/test_kill_services/init_kill_services_test.cpp b/init/test_kill_services/init_kill_services_test.cpp
index 3af92bb55ff6..510ad8aee898 100644
--- a/init/test_kill_services/init_kill_services_test.cpp
+++ b/init/test_kill_services/init_kill_services_test.cpp
@@ -18,20 +18,15 @@
 
 #include <android-base/logging.h>
 #include <android-base/properties.h>
-#include <hidl/ServiceManagement.h>
 
 #include <iostream>
 
 using ::android::base::GetProperty;
 using ::android::base::SetProperty;
 using ::android::base::WaitForProperty;
-using ::android::hardware::isHidlSupported;
 using std::literals::chrono_literals::operator""s;
 
 void ExpectKillingServiceRecovers(const std::string& service_name) {
-    if (!isHidlSupported() && service_name == "hwservicemanager") {
-        GTEST_SKIP() << "No HIDL support on device so hwservicemanager will not be running";
-    }
     LOG(INFO) << "before we say hi to " << service_name << ", I can't have apexd around!";
 
     // b/280514080 - servicemanager will restart apexd, and apexd will restart the

From d4bd799fcc5798ae6489f5ccbc64cb1668fb4f5d Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 2 Apr 2024 14:19:15 +0000
Subject: [PATCH 0823/1487] linker.config.json: remove libpac.so.

The bug in the TODO was fixed 5 years ago, so this should be
obsolete?

Change-Id: I636adccb9852170a00ea171dd96e2f176bf70489
---
 rootdir/etc/linker.config.json | 2 --
 1 file changed, 2 deletions(-)

diff --git a/rootdir/etc/linker.config.json b/rootdir/etc/linker.config.json
index 61af6e94242b..8b3542f3252d 100644
--- a/rootdir/etc/linker.config.json
+++ b/rootdir/etc/linker.config.json
@@ -9,8 +9,6 @@
     "libnativehelper.so",
     "libnativeloader.so",
     "libsigchain.so",
-    // TODO(b/122876336): Remove libpac.so once it's migrated to Webview
-    "libpac.so",
     // TODO(b/120786417 or b/134659294): libicuuc.so
     // and libicui18n.so are kept for app compat.
     "libicui18n.so",

From 2f814176ea5fd93b2890d060466e7c61949847d7 Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Tue, 2 Apr 2024 13:56:47 +0900
Subject: [PATCH 0824/1487] Add dm-thin support

thin-pool and thin targets are supported via DmTargetThinPool and
DmTargetThin. DM_TARGET_MSG is also added via a new method
SendMessage() because it's used to create a thin volumn.

dmctl is extended to support thin-pool and thin targets.

TODO: thin-pool target constructor can accept feature arguments.

Bug: 327081431
Test: atest libdm_test (CF with dm-thin enabled kernel)
Change-Id: I4c51c668bfe1489b959f6d03c205a5e2e63d9a1d
---
 fs_mgr/libdm/Android.bp                |  3 ++
 fs_mgr/libdm/dm.cpp                    | 20 +++++++++
 fs_mgr/libdm/dm_target.cpp             | 38 ++++++++++++++++
 fs_mgr/libdm/dm_test.cpp               | 41 ++++++++++++++++++
 fs_mgr/libdm/include/libdm/dm.h        |  3 ++
 fs_mgr/libdm/include/libdm/dm_target.h | 29 +++++++++++++
 fs_mgr/tools/dmctl.cpp                 | 60 ++++++++++++++++++++++++++
 7 files changed, 194 insertions(+)

diff --git a/fs_mgr/libdm/Android.bp b/fs_mgr/libdm/Android.bp
index 5cc0346faf9d..c3ca758aea7f 100644
--- a/fs_mgr/libdm/Android.bp
+++ b/fs_mgr/libdm/Android.bp
@@ -71,6 +71,9 @@ cc_defaults {
         "libbase",
         "liblog",
     ],
+    header_libs: [
+        "libstorage_literals_headers",
+    ],
     srcs: [":libdm_test_srcs"],
     auto_gen_config: true,
     require_root: true,
diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index fee67fdfadad..a9633226f3dd 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -769,5 +769,25 @@ bool DeviceMapper::CreatePlaceholderDevice(const std::string& name) {
     return true;
 }
 
+bool DeviceMapper::SendMessage(const std::string& name, uint64_t sector,
+                               const std::string& message) {
+    std::string ioctl_buffer(sizeof(struct dm_ioctl) + sizeof(struct dm_target_msg), 0);
+    ioctl_buffer += message;
+    ioctl_buffer.push_back('\0');
+
+    struct dm_ioctl* io = reinterpret_cast<struct dm_ioctl*>(&ioctl_buffer[0]);
+    InitIo(io, name);
+    io->data_size = ioctl_buffer.size();
+    io->data_start = sizeof(struct dm_ioctl);
+    struct dm_target_msg* msg =
+            reinterpret_cast<struct dm_target_msg*>(&ioctl_buffer[sizeof(struct dm_ioctl)]);
+    msg->sector = sector;
+    if (ioctl(fd_, DM_TARGET_MSG, io)) {
+        PLOG(ERROR) << "DM_TARGET_MSG failed";
+        return false;
+    }
+    return true;
+}
+
 }  // namespace dm
 }  // namespace android
diff --git a/fs_mgr/libdm/dm_target.cpp b/fs_mgr/libdm/dm_target.cpp
index 1f6bd1a21464..b5cc9aa8727f 100644
--- a/fs_mgr/libdm/dm_target.cpp
+++ b/fs_mgr/libdm/dm_target.cpp
@@ -298,5 +298,43 @@ std::string DmTargetUser::GetParameterString() const {
     return android::base::Join(argv, " ");
 }
 
+DmTargetThinPool::DmTargetThinPool(uint64_t start, uint64_t length, const std::string& metadata_dev,
+                                   const std::string& data_dev, uint64_t data_block_size,
+                                   uint64_t low_water_mark)
+    : DmTarget(start, length),
+      metadata_dev_(metadata_dev),
+      data_dev_(data_dev),
+      data_block_size_(data_block_size),
+      low_water_mark_(low_water_mark) {}
+
+std::string DmTargetThinPool::GetParameterString() const {
+    std::vector<std::string> args{
+            metadata_dev_,
+            data_dev_,
+            std::to_string(data_block_size_),
+            std::to_string(low_water_mark_),
+    };
+    return android::base::Join(args, " ");
+}
+
+bool DmTargetThinPool::Valid() const {
+    // data_block_size: must be between 128 (64KB) and 2097152 (1GB) and a multiple of 128 (64KB)
+    if (data_block_size_ < 128 || data_block_size_ > 2097152) return false;
+    if (data_block_size_ % 128) return false;
+    return true;
+}
+
+DmTargetThin::DmTargetThin(uint64_t start, uint64_t length, const std::string& pool_dev,
+                           uint64_t dev_id)
+    : DmTarget(start, length), pool_dev_(pool_dev), dev_id_(dev_id) {}
+
+std::string DmTargetThin::GetParameterString() const {
+    std::vector<std::string> args{
+            pool_dev_,
+            std::to_string(dev_id_),
+    };
+    return android::base::Join(args, " ");
+}
+
 }  // namespace dm
 }  // namespace android
diff --git a/fs_mgr/libdm/dm_test.cpp b/fs_mgr/libdm/dm_test.cpp
index d043be63bd3b..b890f471503b 100644
--- a/fs_mgr/libdm/dm_test.cpp
+++ b/fs_mgr/libdm/dm_test.cpp
@@ -37,12 +37,14 @@
 #include <gtest/gtest.h>
 #include <libdm/dm.h>
 #include <libdm/loop_control.h>
+#include <storage_literals/storage_literals.h>
 #include "test_util.h"
 #include "utility.h"
 
 using namespace std;
 using namespace std::chrono_literals;
 using namespace android::dm;
+using namespace android::storage_literals;
 using android::base::make_scope_guard;
 using android::base::unique_fd;
 
@@ -773,3 +775,42 @@ TEST_F(DmTest, GetNameAndUuid) {
     ASSERT_EQ(name, test_name_);
     ASSERT_FALSE(uuid.empty());
 }
+
+TEST_F(DmTest, ThinProvisioning) {
+    if (!DeviceMapper::Instance().GetTargetByName("thin-pool", nullptr)) GTEST_SKIP();
+
+    constexpr uint64_t MetaSize = 2_MiB;
+    constexpr uint64_t DataSize = 64_MiB;
+    constexpr uint64_t ThinSize = 1_TiB;
+
+    // Prepare two loop devices for meta and data devices.
+    TemporaryFile meta;
+    ASSERT_GE(meta.fd, 0);
+    ASSERT_EQ(0, ftruncate64(meta.fd, MetaSize));
+    TemporaryFile data;
+    ASSERT_GE(data.fd, 0);
+    ASSERT_EQ(0, ftruncate64(data.fd, DataSize));
+
+    LoopDevice loop_meta(meta.fd, 10s);
+    ASSERT_TRUE(loop_meta.valid());
+    LoopDevice loop_data(data.fd, 10s);
+    ASSERT_TRUE(loop_data.valid());
+
+    // Create a thin-pool
+    DmTable poolTable;
+    poolTable.Emplace<DmTargetThinPool>(0, DataSize / kSectorSize, loop_meta.device(),
+                                        loop_data.device(), 128, 0);
+    TempDevice pool("pool", poolTable);
+    ASSERT_TRUE(pool.valid());
+
+    // Create a thin volume
+    uint64_t thin_volume_id = 0;
+    ASSERT_TRUE(DeviceMapper::Instance().SendMessage(
+            "pool", 0, "create_thin " + std::to_string(thin_volume_id)));
+
+    // Use a thin volume to create a 1T device
+    DmTable thinTable;
+    thinTable.Emplace<DmTargetThin>(0, ThinSize / kSectorSize, pool.path(), thin_volume_id);
+    TempDevice thin("thin", thinTable);
+    ASSERT_TRUE(thin.valid());
+}
diff --git a/fs_mgr/libdm/include/libdm/dm.h b/fs_mgr/libdm/include/libdm/dm.h
index fa976535ba8d..43d84f9681d9 100644
--- a/fs_mgr/libdm/include/libdm/dm.h
+++ b/fs_mgr/libdm/include/libdm/dm.h
@@ -307,6 +307,9 @@ class DeviceMapper final : public IDeviceMapper {
 
     bool GetDeviceNameAndUuid(dev_t dev, std::string* name, std::string* uuid);
 
+    // Send |message| to target, pointed by |name| and |sector|. Use 0 if |sector| is not needed.
+    bool SendMessage(const std::string& name, uint64_t sector, const std::string& message);
+
   private:
     // Maximum possible device mapper targets registered in the kernel.
     // This is only used to read the list of targets from kernel so we allocate
diff --git a/fs_mgr/libdm/include/libdm/dm_target.h b/fs_mgr/libdm/include/libdm/dm_target.h
index 97f3c134ef6d..c49fc5ec829e 100644
--- a/fs_mgr/libdm/include/libdm/dm_target.h
+++ b/fs_mgr/libdm/include/libdm/dm_target.h
@@ -349,6 +349,35 @@ class DmTargetError final : public DmTarget {
     std::string GetParameterString() const override { return ""; }
 };
 
+class DmTargetThinPool final : public DmTarget {
+  public:
+    DmTargetThinPool(uint64_t start, uint64_t length, const std::string& metadata_dev,
+                     const std::string& data_dev, uint64_t data_block_size,
+                     uint64_t low_water_mark);
+
+    std::string name() const override { return "thin-pool"; }
+    std::string GetParameterString() const override;
+    bool Valid() const override;
+
+  private:
+    std::string metadata_dev_;
+    std::string data_dev_;
+    uint64_t data_block_size_;
+    uint64_t low_water_mark_;
+};
+
+class DmTargetThin final : public DmTarget {
+  public:
+    DmTargetThin(uint64_t start, uint64_t length, const std::string& pool_dev, uint64_t dev_id);
+
+    std::string name() const override { return "thin"; }
+    std::string GetParameterString() const override;
+
+  private:
+    std::string pool_dev_;
+    uint64_t dev_id_;
+};
+
 }  // namespace dm
 }  // namespace android
 
diff --git a/fs_mgr/tools/dmctl.cpp b/fs_mgr/tools/dmctl.cpp
index f843821188fa..00f8038e199e 100644
--- a/fs_mgr/tools/dmctl.cpp
+++ b/fs_mgr/tools/dmctl.cpp
@@ -50,6 +50,7 @@ static int Usage(void) {
     std::cerr << "  create <dm-name> [-ro] <targets...>" << std::endl;
     std::cerr << "  delete <dm-name>" << std::endl;
     std::cerr << "  list <devices | targets> [-v]" << std::endl;
+    std::cerr << "  message <dm-name> <sector> <message>" << std::endl;
     std::cerr << "  getpath <dm-name>" << std::endl;
     std::cerr << "  getuuid <dm-name>" << std::endl;
     std::cerr << "  ima <dm-name>" << std::endl;
@@ -203,6 +204,46 @@ class TargetParser final {
             return std::make_unique<DmTargetUser>(start_sector, num_sectors, control_device);
         } else if (target_type == "error") {
             return std::make_unique<DmTargetError>(start_sector, num_sectors);
+        } else if (target_type == "thin-pool") {
+            if (!HasArgs(4)) {
+                std::cerr << "Expected \"thin-pool\" <metadata dev> <data dev> <data block size> "
+                             "<low water mark> <feature args>"
+                          << std::endl;
+                return nullptr;
+            }
+
+            std::string metadata_dev = NextArg();
+            std::string data_dev = NextArg();
+            std::string data_block_size_str = NextArg();
+            std::string low_water_mark_str = NextArg();
+
+            uint64_t data_block_size;
+            if (!android::base::ParseUint(data_block_size_str, &data_block_size)) {
+                std::cerr << "Data block size must be an unsigned integer.\n";
+                return nullptr;
+            }
+            uint64_t low_water_mark;
+            if (!android::base::ParseUint(low_water_mark_str, &low_water_mark)) {
+                std::cerr << "Low water mark must be an unsigned integer.\n";
+                return nullptr;
+            }
+            return std::make_unique<DmTargetThinPool>(start_sector, num_sectors, metadata_dev,
+                                                      data_dev, data_block_size, low_water_mark);
+        } else if (target_type == "thin") {
+            if (!HasArgs(2)) {
+                std::cerr << "Expected \"thin\" <pool dev> <dev id>" << std::endl;
+                return nullptr;
+            }
+
+            std::string pool_dev = NextArg();
+            std::string dev_id_str = NextArg();
+
+            uint64_t dev_id;
+            if (!android::base::ParseUint(dev_id_str, &dev_id)) {
+                std::cerr << "Dev id must be an unsigned integer.\n";
+                return nullptr;
+            }
+            return std::make_unique<DmTargetThin>(start_sector, num_sectors, pool_dev, dev_id);
         } else {
             std::cerr << "Unrecognized target type: " << target_type << std::endl;
             return nullptr;
@@ -417,6 +458,24 @@ static int DmListCmdHandler(int argc, char** argv) {
     return -EINVAL;
 }
 
+static int DmMessageCmdHandler(int argc, char** argv) {
+    if (argc != 3) {
+        std::cerr << "Usage: dmctl message <name> <sector> <message>" << std::endl;
+        return -EINVAL;
+    }
+    uint64_t sector;
+    if (!android::base::ParseUint(argv[1], &sector)) {
+        std::cerr << "Invalid argument for sector: " << argv[1] << std::endl;
+        return -EINVAL;
+    }
+    DeviceMapper& dm = DeviceMapper::Instance();
+    if (!dm.SendMessage(argv[0], sector, argv[2])) {
+        std::cerr << "Could not send message to " << argv[0] << std::endl;
+        return -EINVAL;
+    }
+    return 0;
+}
+
 static int HelpCmdHandler(int /* argc */, char** /* argv */) {
     Usage();
     return 0;
@@ -576,6 +635,7 @@ static std::map<std::string, std::function<int(int, char**)>> cmdmap = {
         {"delete", DmDeleteCmdHandler},
         {"replace", DmReplaceCmdHandler},
         {"list", DmListCmdHandler},
+        {"message", DmMessageCmdHandler},
         {"help", HelpCmdHandler},
         {"getpath", GetPathCmdHandler},
         {"getuuid", GetUuidCmdHandler},

From 1d928ca80b8a620374d9e21f17aba96664febef0 Mon Sep 17 00:00:00 2001
From: Shrinidhi Hegde <shrinidhihegde@google.com>
Date: Thu, 28 Mar 2024 20:07:58 +0000
Subject: [PATCH 0825/1487] Update native watchdog to be triggered after 20
 restarts instead of 4.

The native watchdog performs a complete reboot on 5 system server
restarts even before packageWatchdog/RescueParty can perform any of the
mitigations. Increasing the thrsehold at which native watchdog kicks in
to 20 instad of 4.

Test: manual
Bug: 291137901
Change-Id: I9166f6555020e8bf26cc86994b13c53745a9934b
---
 init/service.cpp | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/init/service.cpp b/init/service.cpp
index eb24dd593733..9ffab2618a5e 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -352,14 +352,19 @@ void Service::Reap(const siginfo_t& siginfo) {
     }
 #endif
 
-    // If we crash > 4 times in 'fatal_crash_window_' minutes or before boot_completed,
+    // If we crash > 20 times in 'fatal_crash_window_' minutes or before boot_completed,
     // reboot into bootloader or set crashing property
+    // Wait for 20 crashes so RescueParty has a chance to perform the
+    // mitigations. RescueParty finishes all its mitigations at 15 system_server
+    // restarts. If it is still crashing after all rescue party mitigations,
+    // reboot into bootloader.
+    constexpr int crash_count_threshold = 20;
     boot_clock::time_point now = boot_clock::now();
     if (((flags_ & SVC_CRITICAL) || is_process_updatable) && !(flags_ & SVC_RESTART) &&
         !was_last_exit_ok_) {
         bool boot_completed = GetBoolProperty("sys.boot_completed", false);
         if (now < time_crashed_ + fatal_crash_window_ || !boot_completed) {
-            if (++crash_count_ > 4) {
+            if (++crash_count_ > crash_count_threshold) {
                 auto exit_reason = boot_completed ?
                     "in " + std::to_string(fatal_crash_window_.count()) + " minutes" :
                     "before boot completed";

From dbb87ec8a7fc8863fef3af35e0558cf006b5fe92 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 3 Apr 2024 16:44:22 +0000
Subject: [PATCH 0826/1487] Fix typo in comment.

Change-Id: I1d7e061cf7578d88987d16aa1684d94967af09f7
---
 debuggerd/handler/debuggerd_handler.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index 25031bff631e..e26746b607f5 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -108,7 +108,7 @@ static bool is_permissive_mte() {
                            "persist.device_config.memory_safety_native.permissive.process.%s",
                            getprogname());
   // DO NOT REPLACE this with GetBoolProperty. That uses std::string which allocates, so it is
-  // not async-safe (and this functiong gets used in a signal handler).
+  // not async-safe, and this function gets used in a signal handler.
   return property_parse_bool("persist.sys.mte.permissive") ||
          property_parse_bool("persist.device_config.memory_safety_native.permissive.default") ||
          property_parse_bool(process_sysprop_name) ||

From feb7e0ea9727a6b7847e26a1b017066f7ddc9031 Mon Sep 17 00:00:00 2001
From: Nikita Ioffe <ioffe@google.com>
Date: Thu, 28 Mar 2024 00:32:36 +0000
Subject: [PATCH 0827/1487] Restorecon /microdroid_resources in setup_selinux

The main reason for running restorecon of /microdroid_resources during
the setup_selinux stage is to avoid granting init some weird permissions
like `allow init tmpfs:file relabelfrom;`.

Instead we add such permissions to kernel domain in which setup_selinux
runs. This feels better since kernel domain already has similar
permissions like `allow kernel rootfs:file relabelfrom;`.

Bug: 287593065
Test: run microdroid vm with vendor partition
Change-Id: I82ef5499392e90f53655f7582e887d0b6cb3a5f0
---
 init/Android.bp  | 10 ++++++++--
 init/selinux.cpp | 10 ++++++++++
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index d4b7fabd0bb7..ff82f7f1849b 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -255,7 +255,10 @@ cc_library_static {
 
 cc_library_static {
     name: "libinit.microdroid",
-    defaults: ["libinit_defaults"],
+    defaults: [
+        "avf_build_flags_cc",
+        "libinit_defaults",
+    ],
     cflags: ["-DMICRODROID=1"],
 }
 
@@ -315,7 +318,10 @@ cc_binary {
 
 cc_binary {
     name: "init_second_stage.microdroid",
-    defaults: ["init_second_stage_defaults"],
+    defaults: [
+        "avf_build_flags_cc",
+        "init_second_stage_defaults",
+    ],
     static_libs: ["libinit.microdroid"],
     cflags: ["-DMICRODROID=1"],
     installable: false,
diff --git a/init/selinux.cpp b/init/selinux.cpp
index e191b60c00b7..c2d9b8d286f6 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -66,6 +66,7 @@
 #include <android-base/result.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
+#include <android/avf_cc_flags.h>
 #include <fs_avb/fs_avb.h>
 #include <fs_mgr.h>
 #include <libgsi/libgsi.h>
@@ -702,6 +703,15 @@ int SetupSelinux(char** argv) {
 
     SelinuxSetEnforcement();
 
+    if (IsMicrodroid() && android::virtualization::IsOpenDiceChangesFlagEnabled()) {
+        // We run restorecon of /microdroid_resources while we are still in kernel context to avoid
+        // granting init `tmpfs:file relabelfrom` capability.
+        const int flags = SELINUX_ANDROID_RESTORECON_RECURSE;
+        if (selinux_android_restorecon("/microdroid_resources", flags) == -1) {
+            PLOG(FATAL) << "restorecon of /microdroid_resources failed";
+        }
+    }
+
     // We're in the kernel domain and want to transition to the init domain.  File systems that
     // store SELabels in their xattrs, such as ext4 do not need an explicit restorecon here,
     // but other file systems do.  In particular, this is needed for ramdisks such as the

From 2f8efe00af7ae33fede46d84e1eb0bf8b02614a8 Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Thu, 4 Apr 2024 22:14:27 +0900
Subject: [PATCH 0828/1487] skip nop persistent property writes

Bug: 332611029
Test: TH
Change-Id: I0f6ca09c781964d1eb432a770c50e7216f043b4f
---
 init/persistent_properties.cpp      |  3 +++
 init/persistent_properties_test.cpp | 28 ++++++++++++++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/init/persistent_properties.cpp b/init/persistent_properties.cpp
index 59e57b95f620..1d17e3c106d2 100644
--- a/init/persistent_properties.cpp
+++ b/init/persistent_properties.cpp
@@ -236,6 +236,9 @@ void WritePersistentProperty(const std::string& name, const std::string& value)
                            persistent_properties->mutable_properties()->end(),
                            [&name](const auto& record) { return record.name() == name; });
     if (it != persistent_properties->mutable_properties()->end()) {
+        if (it->value() == value) {
+            return;
+        }
         it->set_name(name);
         it->set_value(value);
     } else {
diff --git a/init/persistent_properties_test.cpp b/init/persistent_properties_test.cpp
index 576305081d52..97865d7b4d93 100644
--- a/init/persistent_properties_test.cpp
+++ b/init/persistent_properties_test.cpp
@@ -17,6 +17,9 @@
 #include "persistent_properties.h"
 
 #include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #include <vector>
 
@@ -155,6 +158,31 @@ TEST(persistent_properties, UpdatePropertyBadParse) {
     EXPECT_FALSE(it == read_back_properties.properties().end());
 }
 
+TEST(persistent_properties, NopUpdateDoesntWriteFile) {
+    TemporaryFile tf;
+    ASSERT_TRUE(tf.fd != -1);
+    persistent_property_filename = tf.path;
+
+    auto last_modified = [&tf]() -> time_t {
+        struct stat buf;
+        EXPECT_EQ(fstat(tf.fd, &buf), 0);
+        return buf.st_mtime;
+    };
+
+    std::vector<std::pair<std::string, std::string>> persistent_properties = {
+            {"persist.sys.locale", "en-US"},
+            {"persist.sys.timezone", "America/Los_Angeles"},
+    };
+    ASSERT_RESULT_OK(
+            WritePersistentPropertyFile(VectorToPersistentProperties(persistent_properties)));
+
+    time_t t = last_modified();
+    sleep(2);
+    WritePersistentProperty("persist.sys.locale", "en-US");
+    // Ensure that the file was not modified
+    ASSERT_EQ(last_modified(), t);
+}
+
 TEST(persistent_properties, RejectNonPersistProperty) {
     TemporaryFile tf;
     ASSERT_TRUE(tf.fd != -1);

From b8f9475fd7185341377492355c27bcde4157c50a Mon Sep 17 00:00:00 2001
From: Harry Cutts <hcutts@google.com>
Date: Thu, 4 Apr 2024 15:13:50 +0000
Subject: [PATCH 0829/1487] getevent: add Framework Input team as owners

Bug: 245989146
Test: Treehugger
Change-Id: I286c6947e59013afe816b949b51f081bbfe5924e
---
 toolbox/OWNERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/toolbox/OWNERS b/toolbox/OWNERS
index 5e2c5813ffa0..898ddce5f005 100644
--- a/toolbox/OWNERS
+++ b/toolbox/OWNERS
@@ -1,2 +1,3 @@
 include platform/system/core:/janitors/OWNERS
 per-file modprobe.c=willmcvicker@google.com,dvander@google.com
+per-file getevent.c=file:platform/frameworks/base:/INPUT_OWNERS

From 08686936b5cc986e576736275ce786792eecd72a Mon Sep 17 00:00:00 2001
From: Harry Cutts <hcutts@google.com>
Date: Thu, 4 Apr 2024 14:59:04 +0000
Subject: [PATCH 0830/1487] getevent: print error message when failing to get
 event

For some reason we weren't saying what the error was here, which could
be useful. Also change the failure message slightly to distinguish
between failing to get inotify and evdev events.

Bug: 245989146
Test: m toolbox
Change-Id: I456aa53d008043ea2549024002f9b88ea8d2d2cf
---
 toolbox/getevent.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/toolbox/getevent.c b/toolbox/getevent.c
index f65bb20b5806..7b896e9eca3e 100644
--- a/toolbox/getevent.c
+++ b/toolbox/getevent.c
@@ -441,7 +441,7 @@ static int read_notify(const char *dirname, int nfd, int print_flags)
     if(res < (int)sizeof(*event)) {
         if(errno == EINTR)
             return 0;
-        fprintf(stderr, "could not get event, %s\n", strerror(errno));
+        fprintf(stderr, "could not get inotify events, %s\n", strerror(errno));
         return 1;
     }
     //printf("got %d bytes of event information\n", res);
@@ -664,7 +664,7 @@ int getevent_main(int argc, char *argv[])
                 if(ufds[i].revents & POLLIN) {
                     res = read(ufds[i].fd, &event, sizeof(event));
                     if(res < (int)sizeof(event)) {
-                        fprintf(stderr, "could not get event\n");
+                        fprintf(stderr, "could not get evdev event, %s\n", strerror(errno));
                         return 1;
                     }
                     if(get_time) {

From 867f0ada9a7d9f1b381063b32c040327e5598f86 Mon Sep 17 00:00:00 2001
From: Michael Bestas <mkbestas@gmail.com>
Date: Thu, 4 Apr 2024 18:48:47 +0300
Subject: [PATCH 0831/1487] init: Remove encryption=DeleteIfNecessary from
 /data/misc/bootanim

/data/misc already sets encryption=Require and this causes certain
devices not being able to boot with the following error:

init: Failed to set encryption policy of /data/misc/bootanim to
    a5a40d896b46d8c6 v1 modes 127/4 flags 0x0: The directory already
    has a different encryption policy.
init: Setting a5a40d896b46d8c6 policy on /data/misc/bootanim failed!
init: Setting policy failed, deleting: /data/misc/bootanim
init: Failed to set encryption policy of /data/misc/bootanim to
    a5a40d896b46d8c6 v1 modes 127/4 flags 0x0: The directory already
    has a different encryption policy.
init: Setting a5a40d896b46d8c6 policy on /data/misc/bootanim failed!
init: Rebooting into recovery
init: Got shutdown_command 'reboot,recovery' Calling
    HandlePowerctlMessage()

Test: m; fastboot flashall, observe device boots successfully
Change-Id: I86a2b2b8fe8e438ca405a0e901739d11550d3ebd
---
 rootdir/init.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index d4cd4b834a80..fb411b7d6d63 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1031,7 +1031,7 @@ on post-fs-data
     perform_apex_config
 
     # Create directories for boot animation.
-    mkdir /data/misc/bootanim 0755 system system encryption=DeleteIfNecessary
+    mkdir /data/misc/bootanim 0755 system system
 
     exec_start derive_sdk
 

From ae5ce6f7c37be4c526f963b6f72e23717751a0c3 Mon Sep 17 00:00:00 2001
From: Shrinidhi Hegde <shrinidhihegde@google.com>
Date: Thu, 4 Apr 2024 19:19:04 +0000
Subject: [PATCH 0832/1487] Revert "Update native watchdog to be triggered
 after 20 restarts instead of 4."

This reverts commit 1d928ca80b8a620374d9e21f17aba96664febef0.

Reason for revert: Breaks Host side CTS test https://android-build.corp.google.com/test_investigate/?referrer=buganizer&regressionId=manual-dcf4b8bc69179f9a6bc4ce097a552d84-1712255116&testResultId=TR13229242143019813&invocationId=I86200010262612788

Change-Id: I2627a0c5f5b8d9a19b6a43f678facc64ffa6c189
---
 init/service.cpp | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/init/service.cpp b/init/service.cpp
index 9ffab2618a5e..eb24dd593733 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -352,19 +352,14 @@ void Service::Reap(const siginfo_t& siginfo) {
     }
 #endif
 
-    // If we crash > 20 times in 'fatal_crash_window_' minutes or before boot_completed,
+    // If we crash > 4 times in 'fatal_crash_window_' minutes or before boot_completed,
     // reboot into bootloader or set crashing property
-    // Wait for 20 crashes so RescueParty has a chance to perform the
-    // mitigations. RescueParty finishes all its mitigations at 15 system_server
-    // restarts. If it is still crashing after all rescue party mitigations,
-    // reboot into bootloader.
-    constexpr int crash_count_threshold = 20;
     boot_clock::time_point now = boot_clock::now();
     if (((flags_ & SVC_CRITICAL) || is_process_updatable) && !(flags_ & SVC_RESTART) &&
         !was_last_exit_ok_) {
         bool boot_completed = GetBoolProperty("sys.boot_completed", false);
         if (now < time_crashed_ + fatal_crash_window_ || !boot_completed) {
-            if (++crash_count_ > crash_count_threshold) {
+            if (++crash_count_ > 4) {
                 auto exit_reason = boot_completed ?
                     "in " + std::to_string(fatal_crash_window_.count()) + " minutes" :
                     "before boot completed";

From 3e4159a22eb6e3b80d6b03dc01cd7abdec55de48 Mon Sep 17 00:00:00 2001
From: Luca Stefani <luca@osomprivacy.com>
Date: Fri, 5 Apr 2024 10:22:34 +0200
Subject: [PATCH 0833/1487] firmware_handler: Print full FW path before loading

As of now ueventd only prints the firmware name
requested by the uevent, but in case the device
has multiple firmware going by the same name it's
more interesting to know what file ends up actually
being used for the firmware request.

Test: m, check logcat
Change-Id: Ia90d387f09789d8e8b337a1a178144fad553d37b
---
 init/firmware_handler.cpp | 6 ++++--
 init/firmware_handler.h   | 2 +-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/init/firmware_handler.cpp b/init/firmware_handler.cpp
index 3c012feb58c5..01957eff06f8 100644
--- a/init/firmware_handler.cpp
+++ b/init/firmware_handler.cpp
@@ -264,8 +264,9 @@ std::string FirmwareHandler::GetFirmwarePath(const Uevent& uevent) const {
     return uevent.firmware;
 }
 
-void FirmwareHandler::ProcessFirmwareEvent(const std::string& root,
+void FirmwareHandler::ProcessFirmwareEvent(const std::string& path,
                                            const std::string& firmware) const {
+    std::string root = "/sys" + path;
     std::string loading = root + "/loading";
     std::string data = root + "/data";
 
@@ -296,6 +297,7 @@ void FirmwareHandler::ProcessFirmwareEvent(const std::string& root,
                                                     ", fstat failed: " + strerror(errno));
             return false;
         }
+        LOG(INFO) << "found " << file << " for " << path;
         LoadFirmware(firmware, root, fw_fd.get(), sb.st_size, loading_fd.get(), data_fd.get());
         return true;
     };
@@ -362,7 +364,7 @@ void FirmwareHandler::HandleUevent(const Uevent& uevent) {
     if (pid == 0) {
         Timer t;
         auto firmware = GetFirmwarePath(uevent);
-        ProcessFirmwareEvent("/sys" + uevent.path, firmware);
+        ProcessFirmwareEvent(uevent.path, firmware);
         LOG(INFO) << "loading " << uevent.path << " took " << t;
         _exit(EXIT_SUCCESS);
     }
diff --git a/init/firmware_handler.h b/init/firmware_handler.h
index d2f7347cec63..fceb392db5bd 100644
--- a/init/firmware_handler.h
+++ b/init/firmware_handler.h
@@ -57,7 +57,7 @@ class FirmwareHandler : public UeventHandler {
     Result<std::string> RunExternalHandler(const std::string& handler, uid_t uid, gid_t gid,
                                            const Uevent& uevent) const;
     std::string GetFirmwarePath(const Uevent& uevent) const;
-    void ProcessFirmwareEvent(const std::string& root, const std::string& firmware) const;
+    void ProcessFirmwareEvent(const std::string& path, const std::string& firmware) const;
     bool ForEachFirmwareDirectory(std::function<bool(const std::string&)> handler) const;
 
     std::vector<std::string> firmware_directories_;

From 4f3a4cbc5ee037c553b473c67b1c9167ed7a724f Mon Sep 17 00:00:00 2001
From: Raphael Herouart <rherouart@google.com>
Date: Fri, 5 Apr 2024 11:50:42 +0000
Subject: [PATCH 0834/1487] lib/trusty: tipc-test suite name is incorrect in
 JSON output

tipc-test suite should be tipc not crypto

Bug: 314130383
Test: /data/nativetest64/vendor/tipc-test/tipc-test -t echo -r 1 -B 100
Change-Id: Icc0921a032f8b784f4797f43b6180136777f422f
---
 trusty/libtrusty/tipc-test/tipc_test.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/libtrusty/tipc-test/tipc_test.c b/trusty/libtrusty/tipc-test/tipc_test.c
index dabe118e10ed..1eac9cfb9937 100644
--- a/trusty/libtrusty/tipc-test/tipc_test.c
+++ b/trusty/libtrusty/tipc-test/tipc_test.c
@@ -37,7 +37,7 @@
 #define BENCH_RESULT_TPL                                    \
 "{"                                                         \
 "    \"schema_version\": 3,"                                \
-"    \"suite_name\": \"crypto\","                           \
+"    \"suite_name\": \"tipc\","                           \
 "    \"bench_name\": \"%s\","                               \
 "    \"results\": ["                                        \
 "        {"                                                 \

From b238b90a79aca2954ffc842b1e97e39eee343f11 Mon Sep 17 00:00:00 2001
From: Raphael Herouart <rherouart@google.com>
Date: Mon, 8 Apr 2024 09:13:46 +0000
Subject: [PATCH 0835/1487] lib/trusty: tipc-test should not print results to
 error stream

tipc-test results cannot be parsed in the CI because they output to
error stream

Bug: 314130383
Test: /data/nativetest64/vendor/tipc-test/tipc-test -t echo -r 1 -B 100
Change-Id: I2d6506fd69af06338041035526ca759884719c7b
---
 trusty/libtrusty/tipc-test/tipc_test.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/libtrusty/tipc-test/tipc_test.c b/trusty/libtrusty/tipc-test/tipc_test.c
index 1eac9cfb9937..3cf0c05f939c 100644
--- a/trusty/libtrusty/tipc-test/tipc_test.c
+++ b/trusty/libtrusty/tipc-test/tipc_test.c
@@ -1041,7 +1041,7 @@ static int run_as_bench(const struct tipc_test_params* params) {
     }
     avg /= params->bench;
 
-    fprintf(stderr, BENCH_RESULT_TPL, params->test_name, min, max, avg, cold, min, max, avg, cold);
+    printf(BENCH_RESULT_TPL, params->test_name, min, max, avg, cold, min, max, avg, cold);
     return rc;
 }
 

From 44eb705480fe7b134d6178746d5430ced247bc74 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Wed, 27 Mar 2024 23:40:43 +0000
Subject: [PATCH 0836/1487] Fix unused params and remove unneeded cflags

We already get -Wall and -Werror from the build system, and we do not
want/need -Wexit-time-destructors since it prevents local statics with
non-trivial destructors.

Test: m
Change-Id: I8283bf223404d6c253861d3888c1b720c099386e
---
 libprocessgroup/Android.bp             | 6 ------
 libprocessgroup/task_profiles.h        | 8 ++++----
 libprocessgroup/task_profiles_test.cpp | 7 +++----
 3 files changed, 7 insertions(+), 14 deletions(-)

diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index c6a073789ba8..ca2e0ec7f711 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -5,12 +5,6 @@ package {
 cc_defaults {
     name: "libprocessgroup_defaults",
     cpp_std: "gnu++20",
-    cflags: [
-        "-Wall",
-        "-Werror",
-        "-Wexit-time-destructors",
-        "-Wno-unused-parameter",
-    ],
 }
 
 cc_library_headers {
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index 2fa1931770eb..428447106553 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -82,8 +82,8 @@ class ProfileAction {
 
     virtual void EnableResourceCaching(ResourceCacheType) {}
     virtual void DropResourceCaching(ResourceCacheType) {}
-    virtual bool IsValidForProcess(uid_t uid, pid_t pid) const { return false; }
-    virtual bool IsValidForTask(pid_t tid) const { return false; }
+    virtual bool IsValidForProcess(uid_t, pid_t) const { return false; }
+    virtual bool IsValidForTask(pid_t) const { return false; }
 
   protected:
     enum CacheUseResult { SUCCESS, FAIL, UNUSED };
@@ -109,8 +109,8 @@ class SetTimerSlackAction : public ProfileAction {
 
     const char* Name() const override { return "SetTimerSlack"; }
     bool ExecuteForTask(pid_t tid) const override;
-    bool IsValidForProcess(uid_t uid, pid_t pid) const override { return true; }
-    bool IsValidForTask(pid_t tid) const override { return true; }
+    bool IsValidForProcess(uid_t, pid_t) const override { return true; }
+    bool IsValidForTask(pid_t) const override { return true; }
 
   private:
     unsigned long slack_;
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index b17e695e562b..d19da2b548bc 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -102,8 +102,7 @@ class ProfileAttributeMock : public IProfileAttribute {
   public:
     ProfileAttributeMock(const std::string& file_name) : file_name_(file_name) {}
     ~ProfileAttributeMock() override = default;
-    void Reset(const CgroupController& controller, const std::string& file_name,
-               const std::string& file_v2_name) override {
+    void Reset(const CgroupController&, const std::string&, const std::string&) override {
         CHECK(false);
     }
     const CgroupController* controller() const override {
@@ -111,10 +110,10 @@ class ProfileAttributeMock : public IProfileAttribute {
         return {};
     }
     const std::string& file_name() const override { return file_name_; }
-    bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const override {
+    bool GetPathForProcess(uid_t, pid_t pid, std::string* path) const override {
         return GetPathForTask(pid, path);
     }
-    bool GetPathForTask(int tid, std::string* path) const override {
+    bool GetPathForTask(int, std::string* path) const override {
 #ifdef __ANDROID__
         CHECK(CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, path));
         CHECK_GT(path->length(), 0);

From d1e048f95618b6fb7f66c81e1c650482d95cd452 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 28 Mar 2024 00:33:44 +0000
Subject: [PATCH 0837/1487] Use ConvertUid{Pid}ToPath for all path generation

Consolidate into a single implementation.

Test: m
Change-Id: I0fc52db2d4b2973a74bad24c0a5f77384a559cee
---
 libprocessgroup/processgroup.cpp  |  8 --------
 libprocessgroup/task_profiles.cpp | 18 ++++++++++++++----
 libprocessgroup/task_profiles.h   |  3 +++
 3 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 94d950209e5f..8df2805d914b 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -78,14 +78,6 @@ bool CgroupGetControllerPath(const std::string& cgroup_name, std::string* path)
     return true;
 }
 
-static std::string ConvertUidToPath(const char* cgroup, uid_t uid) {
-    return StringPrintf("%s/uid_%u", cgroup, uid);
-}
-
-static std::string ConvertUidPidToPath(const char* cgroup, uid_t uid, pid_t pid) {
-    return StringPrintf("%s/uid_%u/pid_%d", cgroup, uid, pid);
-}
-
 static bool CgroupKillAvailable() {
     static std::once_flag f;
     static bool cgroup_kill_available = false;
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 2353cf18a987..c376a0fe6206 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -126,11 +126,19 @@ void ProfileAttribute::Reset(const CgroupController& controller, const std::stri
     file_v2_name_ = file_v2_name;
 }
 
+std::string ConvertUidToPath(const char* root_cgroup_path, uid_t uid) {
+    return StringPrintf("%s/uid_%u", root_cgroup_path, uid);
+}
+
+std::string ConvertUidPidToPath(const char* root_cgroup_path, uid_t uid, pid_t pid) {
+    const std::string uid_path = ConvertUidToPath(root_cgroup_path, uid);
+    return StringPrintf("%s/pid_%d", uid_path.c_str(), pid);
+}
+
 bool ProfileAttribute::GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const {
     if (controller()->version() == 2) {
-        // all cgroup v2 attributes use the same process group hierarchy
-        *path = StringPrintf("%s/uid_%u/pid_%d/%s", controller()->path(), uid, pid,
-                             file_name().c_str());
+        const std::string cgroup_path = ConvertUidPidToPath(controller()->path(), uid, pid);
+        *path = cgroup_path + "/" + file_name();
         return true;
     }
     return GetPathForTask(pid, path);
@@ -155,12 +163,14 @@ bool ProfileAttribute::GetPathForTask(pid_t tid, std::string* path) const {
     return true;
 }
 
+// NOTE: This function is for cgroup v2 only
 bool ProfileAttribute::GetPathForUID(uid_t uid, std::string* path) const {
     if (path == nullptr) {
         return true;
     }
 
-    *path = StringPrintf("%s/uid_%u/%s", controller()->path(), uid, file_name().c_str());
+    const std::string cgroup_path = ConvertUidToPath(controller()->path(), uid);
+    *path = cgroup_path + "/" + file_name();
     return true;
 }
 
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index 428447106553..7e3c50d9fe35 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -252,3 +252,6 @@ class TaskProfiles {
     std::map<std::string, std::shared_ptr<TaskProfile>, std::less<>> profiles_;
     std::map<std::string, std::unique_ptr<IProfileAttribute>, std::less<>> attributes_;
 };
+
+std::string ConvertUidToPath(const char* root_cgroup_path, uid_t uid);
+std::string ConvertUidPidToPath(const char* root_cgroup_path, uid_t uid, pid_t pid);

From f8901767e63636d1fa884255cf9bfe0c7ab368b9 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 5 Mar 2024 21:55:15 +0000
Subject: [PATCH 0838/1487] Add build flag to force memcg to the v2 cgroup
 hierarchy

This flag prevents memcg from being mounted as a v1 hierarchy, even if
cgroups.json specifies it should be mounted as v1. It will activate
memcg in the v2 hierarchy even if cgroups.json does not specify that it
should be activated in the v2 hierarchy.

The cgroup_disable=memory kernel command line argument will still
prevent memcg from being activated, as this forced memcg controller
is marked as optional.

Bug: 327480673
Change-Id: Iad2491dd0c1576156ee2346928d041d85af890f0
---
 libprocessgroup/Android.bp                 | 27 ++++++--
 libprocessgroup/build_flags.h              | 29 +++++++++
 libprocessgroup/setup/Android.bp           |  5 +-
 libprocessgroup/setup/cgroup_map_write.cpp | 76 +++++++++++++++++++++-
 4 files changed, 126 insertions(+), 11 deletions(-)
 create mode 100644 libprocessgroup/build_flags.h

diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index ca2e0ec7f711..f529ad76d7ee 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -2,9 +2,28 @@ package {
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
-cc_defaults {
-    name: "libprocessgroup_defaults",
+soong_config_module_type {
+    name: "libprocessgroup_flag_aware_cc_defaults",
+    module_type: "cc_defaults",
+    config_namespace: "ANDROID",
+    bool_variables: [
+        "memcg_v2_force_enabled",
+    ],
+    properties: [
+        "cflags",
+    ],
+}
+
+libprocessgroup_flag_aware_cc_defaults {
+    name: "libprocessgroup_build_flags_cc",
     cpp_std: "gnu++20",
+    soong_config_variables: {
+        memcg_v2_force_enabled: {
+            cflags: [
+                "-DMEMCG_V2_FORCE_ENABLED=true",
+            ],
+        },
+    },
 }
 
 cc_library_headers {
@@ -67,7 +86,7 @@ cc_library {
     export_header_lib_headers: [
         "libprocessgroup_headers",
     ],
-    defaults: ["libprocessgroup_defaults"],
+    defaults: ["libprocessgroup_build_flags_cc"],
     apex_available: [
         "//apex_available:platform",
         "//apex_available:anyapex",
@@ -78,7 +97,7 @@ cc_library {
 cc_test {
     name: "task_profiles_test",
     host_supported: true,
-    defaults: ["libprocessgroup_defaults"],
+    defaults: ["libprocessgroup_build_flags_cc"],
     srcs: [
         "task_profiles_test.cpp",
     ],
diff --git a/libprocessgroup/build_flags.h b/libprocessgroup/build_flags.h
new file mode 100644
index 000000000000..69fa76e1b016
--- /dev/null
+++ b/libprocessgroup/build_flags.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#ifndef MEMCG_V2_FORCE_ENABLED
+#define MEMCG_V2_FORCE_ENABLED false
+#endif
+
+namespace android::libprocessgroup_flags {
+
+inline consteval bool force_memcg_v2() {
+    return MEMCG_V2_FORCE_ENABLED;
+}
+
+}  // namespace android::libprocessgroup_flags
diff --git a/libprocessgroup/setup/Android.bp b/libprocessgroup/setup/Android.bp
index ea6c2470616a..1e0783ab03f3 100644
--- a/libprocessgroup/setup/Android.bp
+++ b/libprocessgroup/setup/Android.bp
@@ -41,8 +41,5 @@ cc_library_shared {
     export_header_lib_headers: [
         "libprocessgroup_headers",
     ],
-    cflags: [
-        "-Wall",
-        "-Werror",
-    ],
+    defaults: ["libprocessgroup_build_flags_cc"],
 }
diff --git a/libprocessgroup/setup/cgroup_map_write.cpp b/libprocessgroup/setup/cgroup_map_write.cpp
index 4e44c91befe0..a9fd0e58b043 100644
--- a/libprocessgroup/setup/cgroup_map_write.cpp
+++ b/libprocessgroup/setup/cgroup_map_write.cpp
@@ -29,7 +29,7 @@
 #include <time.h>
 #include <unistd.h>
 
-#include <regex>
+#include <optional>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
@@ -43,6 +43,7 @@
 #include <processgroup/processgroup.h>
 #include <processgroup/setup.h>
 
+#include "../build_flags.h"
 #include "cgroup_descriptor.h"
 
 using android::base::GetUintProperty;
@@ -57,6 +58,8 @@ static constexpr const char* CGROUPS_DESC_VENDOR_FILE = "/vendor/etc/cgroups.jso
 
 static constexpr const char* TEMPLATE_CGROUPS_DESC_API_FILE = "/etc/task_profiles/cgroups_%u.json";
 
+static const std::string CGROUP_V2_ROOT_DEFAULT = "/sys/fs/cgroup";
+
 static bool ChangeDirModeAndOwner(const std::string& path, mode_t mode, const std::string& uid,
                                   const std::string& gid, bool permissive_mode = false) {
     uid_t pw_uid = -1;
@@ -182,6 +185,8 @@ static void MergeCgroupToDescriptors(std::map<std::string, CgroupDescriptor>* de
     }
 }
 
+static const bool force_memcg_v2 = android::libprocessgroup_flags::force_memcg_v2();
+
 static bool ReadDescriptorsFromFile(const std::string& file_name,
                                     std::map<std::string, CgroupDescriptor>* descriptors) {
     std::vector<CgroupDescriptor> result;
@@ -205,22 +210,41 @@ static bool ReadDescriptorsFromFile(const std::string& file_name,
         const Json::Value& cgroups = root["Cgroups"];
         for (Json::Value::ArrayIndex i = 0; i < cgroups.size(); ++i) {
             std::string name = cgroups[i]["Controller"].asString();
+
+            if (force_memcg_v2 && name == "memory") continue;
+
             MergeCgroupToDescriptors(descriptors, cgroups[i], name, "", 1);
         }
     }
 
+    bool memcgv2_present = false;
+    std::string root_path;
     if (root.isMember("Cgroups2")) {
         const Json::Value& cgroups2 = root["Cgroups2"];
-        std::string root_path = cgroups2["Path"].asString();
+        root_path = cgroups2["Path"].asString();
         MergeCgroupToDescriptors(descriptors, cgroups2, CGROUPV2_HIERARCHY_NAME, "", 2);
 
         const Json::Value& childGroups = cgroups2["Controllers"];
         for (Json::Value::ArrayIndex i = 0; i < childGroups.size(); ++i) {
             std::string name = childGroups[i]["Controller"].asString();
+
+            if (force_memcg_v2 && name == "memory") memcgv2_present = true;
+
             MergeCgroupToDescriptors(descriptors, childGroups[i], name, root_path, 2);
         }
     }
 
+    if (force_memcg_v2 && !memcgv2_present) {
+        LOG(INFO) << "Forcing memcg to v2 hierarchy";
+        Json::Value memcgv2;
+        memcgv2["Controller"] = "memory";
+        memcgv2["NeedsActivation"] = true;
+        memcgv2["Path"] = ".";
+        memcgv2["Optional"] = true;  // In case of cgroup_disabled=memory, so we can still boot
+        MergeCgroupToDescriptors(descriptors, memcgv2, "memory",
+                                 root_path.empty() ? CGROUP_V2_ROOT_DEFAULT : root_path, 2);
+    }
+
     return true;
 }
 
@@ -308,7 +332,8 @@ static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
 
         if (!base::WriteStringToFile(str, path)) {
             if (IsOptionalController(controller)) {
-                PLOG(INFO) << "Failed to activate optional controller " << controller->name();
+                PLOG(INFO) << "Failed to activate optional controller " << controller->name()
+                           << " at " << path;
                 return true;
             }
             PLOG(ERROR) << "Failed to activate controller " << controller->name();
@@ -424,6 +449,40 @@ void CgroupDescriptor::set_mounted(bool mounted) {
 }  // namespace cgrouprc
 }  // namespace android
 
+static std::optional<bool> MGLRUDisabled() {
+    const std::string file_name = "/sys/kernel/mm/lru_gen/enabled";
+    std::string content;
+    if (!android::base::ReadFileToString(file_name, &content)) {
+        PLOG(ERROR) << "Failed to read MGLRU state from " << file_name;
+        return {};
+    }
+
+    return content == "0x0000";
+}
+
+static std::optional<bool> MEMCGDisabled(
+        const std::map<std::string, android::cgrouprc::CgroupDescriptor>& descriptors) {
+    std::string cgroup_v2_root = android::cgrouprc::CGROUP_V2_ROOT_DEFAULT;
+    const auto it = descriptors.find(CGROUPV2_HIERARCHY_NAME);
+    if (it == descriptors.end()) {
+        LOG(WARNING) << "No Cgroups2 path found in cgroups.json. Vendor has modified Android, and "
+                     << "kernel memory use will be higher than intended.";
+    } else if (it->second.controller()->path() != cgroup_v2_root) {
+        cgroup_v2_root = it->second.controller()->path();
+    }
+
+    const std::string file_name = cgroup_v2_root + "/cgroup.controllers";
+    std::string content;
+    if (!android::base::ReadFileToString(file_name, &content)) {
+        PLOG(ERROR) << "Failed to read cgroup controllers from " << file_name;
+        return {};
+    }
+
+    // If we've forced memcg to v2 and it's not available, then it could only have been disabled
+    // on the kernel command line (GKI sets CONFIG_MEMCG).
+    return content.find("memory") == std::string::npos;
+}
+
 bool CgroupSetup() {
     using namespace android::cgrouprc;
 
@@ -457,6 +516,17 @@ bool CgroupSetup() {
         }
     }
 
+    if (force_memcg_v2) {
+        if (MGLRUDisabled().value_or(false)) {
+            LOG(WARNING) << "Memcg forced to v2 hierarchy with MGLRU disabled! "
+                         << "Global reclaim performance will suffer.";
+        }
+        if (MEMCGDisabled(descriptors).value_or(false)) {
+            LOG(WARNING) << "Memcg forced to v2 hierarchy while memcg is disabled by kernel "
+                         << "command line!";
+        }
+    }
+
     // mkdir <CGROUPS_RC_DIR> 0711 system system
     if (!Mkdir(android::base::Dirname(CGROUPS_RC_PATH), 0711, "system", "system")) {
         LOG(ERROR) << "Failed to create directory for " << CGROUPS_RC_PATH << " file";

From 1cfa2c4111f563c12b292bd066f651ddc8d1c0c7 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Mon, 8 Apr 2024 21:14:32 +0000
Subject: [PATCH 0839/1487] Add build flag to split the cgroup v2 hierarchy
 into apps/system

This flag adds "apps" and "system" cgroups underneath the v2 hierarchy
root. Cgroups with UIDs < 10000 (AID_APP_START) will be placed
under "system" and others will be placed under "apps". UIDs under 10000
are reserved for core Android subsystems. This allows us to
apply different cgroup controls collectively to system processes and
normal applications.

Bug: 327480673
Change-Id: I40837dee27a59691f81fef48e66a86c5eacda892
---
 libprocessgroup/Android.bp                 |  6 +++
 libprocessgroup/build_flags.h              |  8 ++++
 libprocessgroup/setup/cgroup_map_write.cpp | 51 ++++++++++++++++++++++
 libprocessgroup/task_profiles.cpp          | 12 +++++
 4 files changed, 77 insertions(+)

diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index f529ad76d7ee..bb855d58cb81 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -8,6 +8,7 @@ soong_config_module_type {
     config_namespace: "ANDROID",
     bool_variables: [
         "memcg_v2_force_enabled",
+        "cgroup_v2_sys_app_isolation",
     ],
     properties: [
         "cflags",
@@ -23,6 +24,11 @@ libprocessgroup_flag_aware_cc_defaults {
                 "-DMEMCG_V2_FORCE_ENABLED=true",
             ],
         },
+        cgroup_v2_sys_app_isolation: {
+            cflags: [
+                "-DCGROUP_V2_SYS_APP_ISOLATION=true",
+            ],
+        },
     },
 }
 
diff --git a/libprocessgroup/build_flags.h b/libprocessgroup/build_flags.h
index 69fa76e1b016..bc3e7dff178f 100644
--- a/libprocessgroup/build_flags.h
+++ b/libprocessgroup/build_flags.h
@@ -20,10 +20,18 @@
 #define MEMCG_V2_FORCE_ENABLED false
 #endif
 
+#ifndef CGROUP_V2_SYS_APP_ISOLATION
+#define CGROUP_V2_SYS_APP_ISOLATION false
+#endif
+
 namespace android::libprocessgroup_flags {
 
 inline consteval bool force_memcg_v2() {
     return MEMCG_V2_FORCE_ENABLED;
 }
 
+inline consteval bool cgroup_v2_sys_app_isolation() {
+    return CGROUP_V2_SYS_APP_ISOLATION;
+}
+
 }  // namespace android::libprocessgroup_flags
diff --git a/libprocessgroup/setup/cgroup_map_write.cpp b/libprocessgroup/setup/cgroup_map_write.cpp
index a9fd0e58b043..1b26fbcc67a1 100644
--- a/libprocessgroup/setup/cgroup_map_write.cpp
+++ b/libprocessgroup/setup/cgroup_map_write.cpp
@@ -483,6 +483,42 @@ static std::optional<bool> MEMCGDisabled(
     return content.find("memory") == std::string::npos;
 }
 
+static bool CreateV2SubHierarchy(
+        const std::string& path,
+        const std::map<std::string, android::cgrouprc::CgroupDescriptor>& descriptors) {
+    using namespace android::cgrouprc;
+
+    const auto cgv2_iter = descriptors.find(CGROUPV2_HIERARCHY_NAME);
+    if (cgv2_iter == descriptors.end()) return false;
+    const android::cgrouprc::CgroupDescriptor cgv2_descriptor = cgv2_iter->second;
+
+    if (!Mkdir(path, cgv2_descriptor.mode(), cgv2_descriptor.uid(), cgv2_descriptor.gid())) {
+        PLOG(ERROR) << "Failed to create directory for " << path;
+        return false;
+    }
+
+    // Activate all v2 controllers in path so they can be activated in
+    // children as they are created.
+    for (const auto& [name, descriptor] : descriptors) {
+        const format::CgroupController* controller = descriptor.controller();
+        std::uint32_t flags = controller->flags();
+        if (controller->version() == 2 && name != CGROUPV2_HIERARCHY_NAME &&
+            flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION) {
+            std::string str("+");
+            str += controller->name();
+            if (!android::base::WriteStringToFile(str, path + "/cgroup.subtree_control")) {
+                if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
+                    PLOG(WARNING) << "Activation of cgroup controller " << str << " failed in path "
+                                  << path;
+                } else {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+
 bool CgroupSetup() {
     using namespace android::cgrouprc;
 
@@ -527,6 +563,21 @@ bool CgroupSetup() {
         }
     }
 
+    // System / app isolation.
+    // This really belongs in early-init in init.rc, but we cannot use the flag there.
+    if (android::libprocessgroup_flags::cgroup_v2_sys_app_isolation()) {
+        const auto it = descriptors.find(CGROUPV2_HIERARCHY_NAME);
+        const std::string cgroup_v2_root = (it == descriptors.end())
+                                                   ? CGROUP_V2_ROOT_DEFAULT
+                                                   : it->second.controller()->path();
+
+        LOG(INFO) << "Using system/app isolation under: " << cgroup_v2_root;
+        if (!CreateV2SubHierarchy(cgroup_v2_root + "/apps", descriptors) ||
+            !CreateV2SubHierarchy(cgroup_v2_root + "/system", descriptors)) {
+            return false;
+        }
+    }
+
     // mkdir <CGROUPS_RC_DIR> 0711 system system
     if (!Mkdir(android::base::Dirname(CGROUPS_RC_PATH), 0711, "system", "system")) {
         LOG(ERROR) << "Failed to create directory for " << CGROUPS_RC_PATH << " file";
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index c376a0fe6206..0c2252b17df4 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -33,6 +33,8 @@
 #include <json/reader.h>
 #include <json/value.h>
 
+#include <build_flags.h>
+
 // To avoid issues in sdk_mac build
 #if defined(__ANDROID__)
 #include <sys/prctl.h>
@@ -126,7 +128,17 @@ void ProfileAttribute::Reset(const CgroupController& controller, const std::stri
     file_v2_name_ = file_v2_name;
 }
 
+static bool isSystemApp(uid_t uid) {
+    return uid < AID_APP_START;
+}
+
 std::string ConvertUidToPath(const char* root_cgroup_path, uid_t uid) {
+    if (android::libprocessgroup_flags::cgroup_v2_sys_app_isolation()) {
+        if (isSystemApp(uid))
+            return StringPrintf("%s/system/uid_%u", root_cgroup_path, uid);
+        else
+            return StringPrintf("%s/apps/uid_%u", root_cgroup_path, uid);
+    }
     return StringPrintf("%s/uid_%u", root_cgroup_path, uid);
 }
 

From a2f5335b8404619c36b70c645ffb86e018670325 Mon Sep 17 00:00:00 2001
From: Mitch Phillips <mitchp@google.com>
Date: Tue, 9 Apr 2024 15:59:12 +0200
Subject: [PATCH 0840/1487] [GWP-ASan] [debuggerd] Change test to handle
 default recoverable

Test: atest debuggerd_test
Bug: N/A
Change-Id: I01d79b0058c5c2b5ff0697be69b252728d46a82e
---
 debuggerd/debuggerd_test.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 526e2ca347ad..3e650c4b8593 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -1874,8 +1874,8 @@ TEST_P(GwpAsanCrasherTest, run_gwp_asan_test) {
   StartProcess([&recoverable]() {
     const char* env[] = {"GWP_ASAN_SAMPLE_RATE=1", "GWP_ASAN_PROCESS_SAMPLING=1",
                          "GWP_ASAN_MAX_ALLOCS=40000", nullptr, nullptr};
-    if (recoverable) {
-      env[3] = "GWP_ASAN_RECOVERABLE=true";
+    if (!recoverable) {
+      env[3] = "GWP_ASAN_RECOVERABLE=false";
     }
     std::string test_name = ::testing::UnitTest::GetInstance()->current_test_info()->name();
     test_name = std::regex_replace(test_name, std::regex("run_gwp_asan_test"),

From fb6957c645f68f9ec20809be5b043ac23bc0d32a Mon Sep 17 00:00:00 2001
From: Akshata Kadam <akshata.jadhav@ittiam.com>
Date: Wed, 10 Apr 2024 11:28:10 +0530
Subject: [PATCH 0841/1487] Updated 'cc' field of fuzz_config in Android.bp
 file

corrected cc field in fuzz_config

Bug: 306435930
Test: Build fastboot_fuzzer

Change-Id: I487838914e515619a4acb68331b9c9c7b2030173
---
 fastboot/fuzzer/Android.bp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/fastboot/fuzzer/Android.bp b/fastboot/fuzzer/Android.bp
index a89807082499..59533fad50ac 100644
--- a/fastboot/fuzzer/Android.bp
+++ b/fastboot/fuzzer/Android.bp
@@ -55,7 +55,10 @@ cc_fuzz {
     ],
     fuzz_config: {
         cc: [
-            "android-media-fuzzing-reports@google.com",
+            "dvander@google.com",
+            "elsk@google.com",
+            "enh@google.com",
+            "zhangkelvin@google.com",
         ],
         componentid: 533764,
         hotlists: [

From 7443b82ce7cde1fe6dae0580a9649753e125bab8 Mon Sep 17 00:00:00 2001
From: Ted Bauer <tedbauer@google.com>
Date: Fri, 5 Apr 2024 13:52:03 +0000
Subject: [PATCH 0842/1487] Create new file for test_mission_1 marker file

Test: m
Bug: 328444881
Change-Id: I4329fa161922f3dda2e3d7c9a5231f56ac716fac
---
 rootdir/init.rc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index d4cd4b834a80..9c402dd260ab 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -648,6 +648,8 @@ on post-fs
     mkdir /metadata/aconfig 0775 root system
     mkdir /metadata/aconfig/flags 0770 root system
     mkdir /metadata/aconfig/boot 0775 root system
+
+    mkdir /metadata/aconfig_test_missions 0775 root system
     exec_start aconfigd-init
     start aconfigd
 

From 3785e7b1f715406d944322fcae8ee313d3217d4b Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 14 Aug 2023 17:13:06 -0700
Subject: [PATCH 0843/1487] support negative zstd compression levels

Zstd compression goes all the way down to -7. zstd compression level -3
gives around the same compression ratio as lz4 level=3. Need further
testing to see performance comparison

Test: ota_from_target_files, update_device.py
Change-Id: Ic082b31aa8af938f80be628c73667e02353835f0
---
 .../include/libsnapshot/cow_compress.h        | 24 +++++++++--------
 .../include/libsnapshot/cow_format.h          |  2 +-
 .../libsnapshot_cow/cow_compress.cpp          | 26 ++++++++++---------
 .../libsnapshot/libsnapshot_cow/writer_v2.cpp |  2 +-
 .../libsnapshot/libsnapshot_cow/writer_v3.cpp |  2 +-
 5 files changed, 30 insertions(+), 26 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
index ac0424567674..21dc6667a5df 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
@@ -17,7 +17,6 @@
 #pragma once
 
 #include <memory>
-#include <vector>
 #include "libsnapshot/cow_format.h"
 
 namespace android {
@@ -25,27 +24,30 @@ namespace snapshot {
 
 class ICompressor {
   public:
-    explicit ICompressor(uint32_t compression_level, uint32_t block_size)
+    explicit ICompressor(const int32_t compression_level, const uint32_t block_size)
         : compression_level_(compression_level), block_size_(block_size) {}
 
     virtual ~ICompressor() {}
     // Factory methods for compression methods.
-    static std::unique_ptr<ICompressor> Gz(uint32_t compression_level, const int32_t block_size);
-    static std::unique_ptr<ICompressor> Brotli(uint32_t compression_level,
-                                               const int32_t block_size);
-    static std::unique_ptr<ICompressor> Lz4(uint32_t compression_level, const int32_t block_size);
-    static std::unique_ptr<ICompressor> Zstd(uint32_t compression_level, const int32_t block_size);
+    static std::unique_ptr<ICompressor> Gz(const int32_t compression_level,
+                                           const uint32_t block_size);
+    static std::unique_ptr<ICompressor> Brotli(const int32_t compression_level,
+                                               const uint32_t block_size);
+    static std::unique_ptr<ICompressor> Lz4(const int32_t compression_level,
+                                            const uint32_t block_size);
+    static std::unique_ptr<ICompressor> Zstd(const int32_t compression_level,
+                                             const uint32_t block_size);
 
     static std::unique_ptr<ICompressor> Create(CowCompression compression,
-                                               const int32_t block_size);
+                                               const uint32_t block_size);
 
-    uint32_t GetCompressionLevel() const { return compression_level_; }
+    int32_t GetCompressionLevel() const { return compression_level_; }
     uint32_t GetBlockSize() const { return block_size_; }
     [[nodiscard]] virtual std::vector<uint8_t> Compress(const void* data, size_t length) const = 0;
 
   private:
-    uint32_t compression_level_;
-    uint32_t block_size_;
+    const int32_t compression_level_;
+    const uint32_t block_size_;
 };
 }  // namespace snapshot
 }  // namespace android
\ No newline at end of file
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 6865b194490d..6a7153dcb2a9 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -293,7 +293,7 @@ enum CowCompressionAlgorithm : uint8_t {
 };
 struct CowCompression {
     CowCompressionAlgorithm algorithm = kCowCompressNone;
-    uint32_t compression_level = 0;
+    int32_t compression_level = 0;
 };
 
 static constexpr uint8_t kCowReadAheadNotStarted = 0;
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
index 0205f5086344..bff5257794ac 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
@@ -17,6 +17,7 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <cstdint>
 #include <limits>
 #include <memory>
 #include <queue>
@@ -57,7 +58,7 @@ std::optional<CowCompressionAlgorithm> CompressionAlgorithmFromString(std::strin
 }
 
 std::unique_ptr<ICompressor> ICompressor::Create(CowCompression compression,
-                                                 const int32_t block_size) {
+                                                 const uint32_t block_size) {
     switch (compression.algorithm) {
         case kCowCompressLz4:
             return ICompressor::Lz4(compression.compression_level, block_size);
@@ -101,7 +102,7 @@ uint32_t CompressWorker::GetDefaultCompressionLevel(CowCompressionAlgorithm comp
 
 class GzCompressor final : public ICompressor {
   public:
-    GzCompressor(uint32_t compression_level, const uint32_t block_size)
+    GzCompressor(int32_t compression_level, const uint32_t block_size)
         : ICompressor(compression_level, block_size){};
 
     std::vector<uint8_t> Compress(const void* data, size_t length) const override {
@@ -122,7 +123,7 @@ class GzCompressor final : public ICompressor {
 
 class Lz4Compressor final : public ICompressor {
   public:
-    Lz4Compressor(uint32_t compression_level, const uint32_t block_size)
+    Lz4Compressor(int32_t compression_level, const uint32_t block_size)
         : ICompressor(compression_level, block_size){};
 
     std::vector<uint8_t> Compress(const void* data, size_t length) const override {
@@ -154,7 +155,7 @@ class Lz4Compressor final : public ICompressor {
 
 class BrotliCompressor final : public ICompressor {
   public:
-    BrotliCompressor(uint32_t compression_level, const uint32_t block_size)
+    BrotliCompressor(int32_t compression_level, const uint32_t block_size)
         : ICompressor(compression_level, block_size){};
 
     std::vector<uint8_t> Compress(const void* data, size_t length) const override {
@@ -180,7 +181,7 @@ class BrotliCompressor final : public ICompressor {
 
 class ZstdCompressor final : public ICompressor {
   public:
-    ZstdCompressor(uint32_t compression_level, const uint32_t block_size)
+    ZstdCompressor(int32_t compression_level, const uint32_t block_size)
         : ICompressor(compression_level, block_size),
           zstd_context_(ZSTD_createCCtx(), ZSTD_freeCCtx) {
         ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_compressionLevel, compression_level);
@@ -318,22 +319,23 @@ bool CompressWorker::GetCompressedBuffers(std::vector<std::vector<uint8_t>>* com
     }
 }
 
-std::unique_ptr<ICompressor> ICompressor::Brotli(uint32_t compression_level,
-                                                 const int32_t block_size) {
+std::unique_ptr<ICompressor> ICompressor::Brotli(const int32_t compression_level,
+                                                 const uint32_t block_size) {
     return std::make_unique<BrotliCompressor>(compression_level, block_size);
 }
 
-std::unique_ptr<ICompressor> ICompressor::Gz(uint32_t compression_level, const int32_t block_size) {
+std::unique_ptr<ICompressor> ICompressor::Gz(const int32_t compression_level,
+                                             const uint32_t block_size) {
     return std::make_unique<GzCompressor>(compression_level, block_size);
 }
 
-std::unique_ptr<ICompressor> ICompressor::Lz4(uint32_t compression_level,
-                                              const int32_t block_size) {
+std::unique_ptr<ICompressor> ICompressor::Lz4(const int32_t compression_level,
+                                              const uint32_t block_size) {
     return std::make_unique<Lz4Compressor>(compression_level, block_size);
 }
 
-std::unique_ptr<ICompressor> ICompressor::Zstd(uint32_t compression_level,
-                                               const int32_t block_size) {
+std::unique_ptr<ICompressor> ICompressor::Zstd(const int32_t compression_level,
+                                               const uint32_t block_size) {
     return std::make_unique<ZstdCompressor>(compression_level, block_size);
 }
 
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
index d0864e0a3b69..0993dbaef401 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
@@ -134,7 +134,7 @@ bool CowWriterV2::ParseOptions() {
         return false;
     }
     if (parts.size() > 1) {
-        if (!android::base::ParseUint(parts[1], &compression_.compression_level)) {
+        if (!android::base::ParseInt(parts[1], &compression_.compression_level)) {
             LOG(ERROR) << "failed to parse compression level invalid type: " << parts[1];
             return false;
         }
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 73deafb05529..95398e4b9d46 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -149,7 +149,7 @@ bool CowWriterV3::ParseOptions() {
     }
 
     if (parts.size() > 1) {
-        if (!android::base::ParseUint(parts[1], &compression_.compression_level)) {
+        if (!android::base::ParseInt(parts[1], &compression_.compression_level)) {
             LOG(ERROR) << "failed to parse compression level invalid type: " << parts[1];
             return false;
         }

From 92164903212ddd72362ebb2f310fa86abff606d6 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Wed, 10 Apr 2024 20:24:56 +0000
Subject: [PATCH 0844/1487] Temporarily disable mte_illegal_setjump

Change-Id: I39a770196a79488160b50d7de4c3baa39dd1c57e
---
 debuggerd/Android.bp         | 1 -
 debuggerd/debuggerd_test.cpp | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 235fdfddede4..2529516da626 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -373,7 +373,6 @@ cc_test {
 
     sanitize: {
         memtag_heap: true,
-        memtag_stack: true,
     },
 
     shared_libs: [
diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 3e650c4b8593..7c52e6e50de9 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -610,7 +610,7 @@ __attribute__((noinline)) void mte_illegal_setjmp_helper(jmp_buf& jump_buf) {
   setjmp(jump_buf);
 }
 
-TEST_F(CrasherTest, mte_illegal_setjmp) {
+TEST_F(CrasherTest, DISABLED_mte_illegal_setjmp) {
   // This setjmp is illegal because it jumps back into a function that already returned.
   // Quoting man 3 setjmp:
   //     If the function which called setjmp() returns before longjmp() is

From 541f850372064958bb956c5290216e5931fb5912 Mon Sep 17 00:00:00 2001
From: Akshata Kadam <akshata.jadhav@ittiam.com>
Date: Thu, 11 Apr 2024 14:26:17 +0530
Subject: [PATCH 0845/1487] Updated fuzz_config in Android.bp file

Added new fields in fuzz_config like - componentid,
description, vector, service_privilege, users, fuzzed_code_usage, etc.

Bug: 306435930
Test: Build libutils_fuzz_callstack

Change-Id: I826d75ab01eb0a4d2b363681d4f5a3a4578bbc99
---
 libutils/Android.bp | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/libutils/Android.bp b/libutils/Android.bp
index ad5b752e3b1e..17411871ca50 100644
--- a/libutils/Android.bp
+++ b/libutils/Android.bp
@@ -109,7 +109,7 @@ cc_defaults {
         },
     },
     fuzz_config: {
-       cc: ["smoreland@google.com"],
+        cc: ["smoreland@google.com"],
     },
 }
 
@@ -273,6 +273,17 @@ cc_defaults {
         "libbase",
         "liblog",
     ],
+    fuzz_config: {
+        cc: [
+            "smoreland@google.com",
+        ],
+        componentid: 128577,
+        description: "The fuzzer targets the APIs of libutils",
+        vector: "local_no_privileges_required",
+        service_privilege: "privileged",
+        users: "multi_user",
+        fuzzed_code_usage: "shipped",
+    },
 }
 
 cc_fuzz {

From ab9b68384052d8b9b35e1e96274fb66827081d7e Mon Sep 17 00:00:00 2001
From: Shrinidhi Hegde <shrinidhihegde@google.com>
Date: Tue, 9 Apr 2024 15:33:21 +0000
Subject: [PATCH 0846/1487] Throttle reboot from native watchdog

Found out that increasing the threshold to 20 crashes pushes the file
system based rollbacks as well. So introducing a throttling behaviour
instead. Now native watchdog performs reboot with ramdump at 5 restarts.
After that packageWatchdog/ RescueParty takes over to perform other
mitigations. Ram dump + reboot will not be performed more than once
in 24hrs.

Test: manual
Bug: 291137901
Change-Id: Ia192411dad94e8e25c26f700d2fe7f94d41439b8
---
 init/service.cpp | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/init/service.cpp b/init/service.cpp
index eb24dd593733..31308a0363a0 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -355,20 +355,35 @@ void Service::Reap(const siginfo_t& siginfo) {
     // If we crash > 4 times in 'fatal_crash_window_' minutes or before boot_completed,
     // reboot into bootloader or set crashing property
     boot_clock::time_point now = boot_clock::now();
+    constexpr const char native_watchdog_reboot_time[] = "persist.init.svc.last_fatal_reboot_epoch";
+    uint64_t throttle_window =
+            std::chrono::duration_cast<std::chrono::seconds>(std::chrono::hours(24)).count();
     if (((flags_ & SVC_CRITICAL) || is_process_updatable) && !(flags_ & SVC_RESTART) &&
         !was_last_exit_ok_) {
         bool boot_completed = GetBoolProperty("sys.boot_completed", false);
         if (now < time_crashed_ + fatal_crash_window_ || !boot_completed) {
             if (++crash_count_ > 4) {
-                auto exit_reason = boot_completed ?
-                    "in " + std::to_string(fatal_crash_window_.count()) + " minutes" :
-                    "before boot completed";
+                auto exit_reason =
+                        boot_completed
+                                ? "in " + std::to_string(fatal_crash_window_.count()) + " minutes"
+                                : "before boot completed";
                 if (flags_ & SVC_CRITICAL) {
                     if (!GetBoolProperty("init.svc_debug.no_fatal." + name_, false)) {
-                        // Aborts into `fatal_reboot_target_'.
-                        SetFatalRebootTarget(fatal_reboot_target_);
-                        LOG(FATAL) << "critical process '" << name_ << "' exited 4 times "
-                                   << exit_reason;
+                        uint64_t epoch_time =
+                                std::chrono::duration_cast<std::chrono::seconds>(
+                                        std::chrono::system_clock::now().time_since_epoch())
+                                        .count();
+                        // Do not reboot again If it was already initiated in the last 24hrs
+                        if (epoch_time - GetIntProperty(native_watchdog_reboot_time, 0) >
+                            throttle_window) {
+                            SetProperty(native_watchdog_reboot_time, std::to_string(epoch_time));
+                            // Aborts into `fatal_reboot_target_'.
+                            SetFatalRebootTarget(fatal_reboot_target_);
+                            LOG(FATAL) << "critical process '" << name_ << "' exited 4 times "
+                                       << exit_reason;
+                        } else {
+                            LOG(INFO) << "Reboot already performed in last 24hrs because of crash.";
+                        }
                     }
                 } else {
                     LOG(ERROR) << "process with updatable components '" << name_

From dcce9e044a3f62302558d7414797db5110ef0786 Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Fri, 12 Apr 2024 13:04:14 +0900
Subject: [PATCH 0847/1487] Do not disable LLNDK symbols in header files

Compiler still requires the LLNDK symbols even if they are removed
when compiling. Still the unavailable symbols break the build in
linking if called with wrong api level.

Bug: 333973388
Bug: 320347314
Test: TH
Change-Id: I79cb921cf6f2789e97f11b88cddf7ca1325998a5
---
 .../include_llndk/android/llndk-versioning.h  | 31 ++++++-------------
 1 file changed, 10 insertions(+), 21 deletions(-)

diff --git a/libvendorsupport/include_llndk/android/llndk-versioning.h b/libvendorsupport/include_llndk/android/llndk-versioning.h
index 58cd18db66cb..cf82fb71259a 100644
--- a/libvendorsupport/include_llndk/android/llndk-versioning.h
+++ b/libvendorsupport/include_llndk/android/llndk-versioning.h
@@ -14,22 +14,18 @@
 
 #pragma once
 
-/* As a vendor default header included in all vendor modules, this header MUST NOT include other
- * header files or any declarations. Only macros are allowed.
- */
-#if defined(__ANDROID_VENDOR__)
-
 // LLNDK (https://source.android.com/docs/core/architecture/vndk/build-system#ll-ndk) is similar to
 // NDK, but uses its own versioning of YYYYMM format for vendor builds. The LLNDK symbols are
-// enabled when the vendor api level is equal to or newer than the ro.board.api_level.
-#define __INTRODUCED_IN_LLNDK(vendor_api_level)                                             \
-    _Pragma("clang diagnostic push") _Pragma("clang diagnostic ignored \"-Wgcc-compat\"")   \
-            __attribute__((enable_if(                                                       \
-                    __ANDROID_VENDOR_API__ >= vendor_api_level,                             \
-                    "available in vendor API level " #vendor_api_level " that "             \
-                    "is newer than the current vendor API level. Guard the API "            \
-                    "call with '#if (__ANDROID_VENDOR_API__ >= " #vendor_api_level ")'."))) \
-            _Pragma("clang diagnostic pop")
+// enabled when the vendor api level is equal to or newer than the ro.board.api_level. These symbols
+// must be annotated in map.txt files with the `# llndk=YYYYMM` annotation. They also must be marked
+// with `__INTRODUCED_IN_LLNDK(YYYYMM)` in the header files. It leaves a no-op annotation for ABI
+// analysis.
+#if !defined(__INTRODUCED_IN_LLNDK)
+#define __INTRODUCED_IN_LLNDK(vendor_api_level) \
+    __attribute__((annotate("introduced_in_llndk=" #vendor_api_level)))
+#endif
+
+#if defined(__ANDROID_VENDOR__)
 
 // Use this macro as an `if` statement to call an API that are available to both NDK and LLNDK.
 // This returns true for the vendor modules if the vendor_api_level is less than or equal to the
@@ -39,13 +35,6 @@
 
 #else  // __ANDROID_VENDOR__
 
-// __INTRODUCED_IN_LLNDK is for LLNDK only but not for NDK. Ignore this for non-vendor modules.
-// It leaves a no-op annotation for ABI analysis.
-#if !defined(__INTRODUCED_IN_LLNDK)
-#define __INTRODUCED_IN_LLNDK(vendor_api_level) \
-    __attribute__((annotate("introduced_in_llndk=" #vendor_api_level)))
-#endif
-
 // For non-vendor modules, API_LEVEL_AT_LEAST is replaced with __builtin_available(sdk_api_level) to
 // guard the API for __INTRODUCED_IN.
 #if !defined(API_LEVEL_AT_LEAST)

From 636234bebf4de92d721e360194e404a565b960e2 Mon Sep 17 00:00:00 2001
From: Donnie Pollitz <donpollitz@google.com>
Date: Wed, 6 Mar 2024 15:55:23 +0100
Subject: [PATCH 0848/1487] storageproxyd: Add arguments for storage mapping
 and max file

Background:
* -f = Allows mapping files in the format `-f file:backing_file`.  This
  can be used for mapping secure storage files like `0` and `persist/0`
  to block devices.  Storageproxyd will handle creating the appropriate
  symlinks in the root datapath
* -m = Allows specifying the the max size constraint for file backed storages.
  The constraint is chosen by giving a file, this allows for passing a
  block device for which a max file size can be queried.  File based
  storages will be constrained to that size as well.

Bug: 324989972
Test: File sizes are restricted as specified, and mappings are created
Change-Id: I8ff550afafbd372288daa9e27c4db3451948b25d
Signed-off-by: Donnie Pollitz <donpollitz@google.com>
---
 trusty/storage/proxy/proxy.c   |  73 ++++++++-
 trusty/storage/proxy/storage.c | 287 +++++++++++++++++++++++++++++----
 trusty/storage/proxy/storage.h |  11 +-
 3 files changed, 340 insertions(+), 31 deletions(-)

diff --git a/trusty/storage/proxy/proxy.c b/trusty/storage/proxy/proxy.c
index 67e935e39324..6cb72d59765f 100644
--- a/trusty/storage/proxy/proxy.c
+++ b/trusty/storage/proxy/proxy.c
@@ -41,9 +41,13 @@ static const char* ss_data_root;
 static const char* trusty_devname;
 static const char* rpmb_devname;
 static const char* ss_srv_name = STORAGE_DISK_PROXY_PORT;
+static const char* max_file_size_from;
 
 static enum dev_type dev_type = MMC_RPMB;
 
+/* List head for storage mapping, elements added at init, and never removed */
+static struct storage_mapping_node* storage_mapping_head;
+
 static enum dev_type parse_dev_type(const char* dev_type_name) {
     if (!strcmp(dev_type_name, "mmc")) {
         return MMC_RPMB;
@@ -58,17 +62,61 @@ static enum dev_type parse_dev_type(const char* dev_type_name) {
     }
 }
 
-static const char* _sopts = "hp:d:r:t:";
+static int parse_and_append_file_mapping(const char* file_mapping) {
+    if (file_mapping == NULL) {
+        ALOGE("Provided file mapping is null\n");
+        return -1;
+    }
+    char* file_mapping_dup = strdup(file_mapping);
+    if (file_mapping_dup == NULL) {
+        ALOGE("Couldn't duplicate string: %s\n", file_mapping);
+        return -1;
+    }
+    const char* file_name = strtok(file_mapping_dup, ":");
+    if (file_name == NULL) {
+        ALOGE("No file name found\n");
+        return -1;
+    }
+    const char* backing_storage = strtok(NULL, ":");
+    if (backing_storage == NULL) {
+        ALOGE("No backing storage found\n");
+        return -1;
+    }
+
+    struct storage_mapping_node* new_node = malloc(sizeof(struct storage_mapping_node));
+    if (new_node == NULL) {
+        ALOGE("Couldn't allocate additional storage_mapping_node\n");
+        return -1;
+    }
+    *new_node = (struct storage_mapping_node){.file_name = file_name,
+                                              .backing_storage = backing_storage,
+                                              .next = storage_mapping_head,
+                                              .fd = -1};
+    storage_mapping_head = new_node;
+    return 0;
+}
+
+static const char* _sopts = "hp:d:r:t:m:f:";
 static const struct option _lopts[] = {{"help", no_argument, NULL, 'h'},
                                        {"trusty_dev", required_argument, NULL, 'd'},
                                        {"data_path", required_argument, NULL, 'p'},
                                        {"rpmb_dev", required_argument, NULL, 'r'},
                                        {"dev_type", required_argument, NULL, 't'},
+                                       {"max_file_size_from", required_argument, NULL, 'm'},
+                                       {"file_storage_mapping", required_argument, NULL, 'f'},
                                        {0, 0, 0, 0}};
 
 static void show_usage_and_exit(int code) {
-    ALOGE("usage: storageproxyd -d <trusty_dev> -p <data_path> -r <rpmb_dev> -t <dev_type>\n");
+    ALOGE("usage: storageproxyd -d <trusty_dev> -p <data_path> -r <rpmb_dev> -t <dev_type>  [-m "
+          "<file>] [-f <file>:<mapping>]\n");
     ALOGE("Available dev types: mmc, virt\n");
+    ALOGE("-f = Maps secure storage files like `0` and `persist/0`\n"
+          "to block devices.  Storageproxyd will handle creating the\n"
+          "appropriate symlinks in the root datapath.\n");
+    ALOGE("-m = Specifies the max size constraint for file backed storages.\n"
+          "The constraint is chosen by giving a file, this allows for passing a\n"
+          "block device for which a max file size can be queried.  File based\n"
+          "storages will be constrained to that size as well.\n");
     exit(code);
 }
 
@@ -187,6 +235,7 @@ static int proxy_loop(void) {
 static void parse_args(int argc, char* argv[]) {
     int opt;
     int oidx = 0;
+    int rc = 0;
 
     while ((opt = getopt_long(argc, argv, _sopts, _lopts, &oidx)) != -1) {
         switch (opt) {
@@ -210,6 +259,18 @@ static void parse_args(int argc, char* argv[]) {
                 }
                 break;
 
+            case 'f':
+                rc = parse_and_append_file_mapping(optarg);
+                if (rc < 0) {
+                    ALOGE("Failed to parse file mapping: %s\n", optarg);
+                    show_usage_and_exit(EXIT_FAILURE);
+                }
+                break;
+
+            case 'm':
+                max_file_size_from = strdup(optarg);
+                break;
+
             default:
                 ALOGE("unrecognized option (%c):\n", opt);
                 show_usage_and_exit(EXIT_FAILURE);
@@ -225,6 +286,12 @@ static void parse_args(int argc, char* argv[]) {
     ALOGI("storage data root: %s\n", ss_data_root);
     ALOGI("trusty dev: %s\n", trusty_devname);
     ALOGI("rpmb dev: %s\n", rpmb_devname);
+    ALOGI("File Mappings: \n");
+    const struct storage_mapping_node* curr = storage_mapping_head;
+    for (; curr != NULL; curr = curr->next) {
+        ALOGI("\t%s -> %s\n", curr->file_name, curr->backing_storage);
+    }
+    ALOGI("max file size from: %s\n", max_file_size_from ? max_file_size_from : "(unset)");
 }
 
 int main(int argc, char* argv[]) {
@@ -252,7 +319,7 @@ int main(int argc, char* argv[]) {
     ABinderProcess_startThreadPool();
 
     /* initialize secure storage directory */
-    rc = storage_init(ss_data_root);
+    rc = storage_init(ss_data_root, storage_mapping_head, max_file_size_from);
     if (rc < 0) return EXIT_FAILURE;
 
     /* open rpmb device */
diff --git a/trusty/storage/proxy/storage.c b/trusty/storage/proxy/storage.c
index 8c8edb779e6a..1dab93d9c6a6 100644
--- a/trusty/storage/proxy/storage.c
+++ b/trusty/storage/proxy/storage.c
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <assert.h>
 #include <cutils/properties.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -39,16 +40,20 @@
 #define ALTERNATE_DATA_DIR "alternate/"
 
 /* Maximum file size for filesystem backed storage (i.e. not block dev backed storage) */
-#define MAX_FILE_SIZE (0x10000000000)
+static size_t max_file_size = 0x10000000000;
 
 enum sync_state {
     SS_UNUSED = -1,
-    SS_CLEAN =  0,
-    SS_DIRTY =  1,
+    SS_CLEAN = 0,
+    SS_DIRTY = 1,
+    SS_CLEAN_NEED_SYMLINK = 2,
 };
 
 static const char *ssdir_name;
 
+/* List head for storage mapping, elements added at init, and never removed */
+static struct storage_mapping_node* storage_mapping_head;
+
 /*
  * Property set to 1 after we have opened a file under ssdir_name. The backing
  * files for both TD and TDP are currently located under /data/vendor/ss and can
@@ -75,24 +80,103 @@ static struct {
    uint8_t data[MAX_READ_SIZE];
 }  read_rsp;
 
-static uint32_t insert_fd(int open_flags, int fd)
-{
+static uint32_t insert_fd(int open_flags, int fd, struct storage_mapping_node* node) {
     uint32_t handle = fd;
 
     if (handle < FD_TBL_SIZE) {
-            fd_state[fd] = SS_CLEAN; /* fd clean */
-            if (open_flags & O_TRUNC) {
-                fd_state[fd] = SS_DIRTY;  /* set fd dirty */
-            }
+        fd_state[fd] = SS_CLEAN; /* fd clean */
+        if (open_flags & O_TRUNC) {
+            assert(node == NULL);
+            fd_state[fd] = SS_DIRTY; /* set fd dirty */
+        }
+
+        if (node != NULL) {
+            fd_state[fd] = SS_CLEAN_NEED_SYMLINK;
+        }
     } else {
             ALOGW("%s: untracked fd %u\n", __func__, fd);
             if (open_flags & (O_TRUNC | O_CREAT)) {
                 fs_state = SS_DIRTY;
             }
     }
+
+    if (node != NULL) {
+        node->fd = fd;
+    }
+
     return handle;
 }
 
+static void clear_fd_symlink_status(uint32_t handle, struct storage_mapping_node* entry) {
+    /* Always clear FD, in case fd is not in FD_TBL */
+    entry->fd = -1;
+
+    if (handle >= FD_TBL_SIZE) {
+        ALOGE("%s: untracked fd=%u\n", __func__, handle);
+        return;
+    }
+
+    if (fd_state[handle] == SS_CLEAN_NEED_SYMLINK) {
+        fd_state[handle] = SS_CLEAN;
+    }
+}
+
+static struct storage_mapping_node* get_pending_symlink_mapping(uint32_t handle) {
+    /* Fast lookup failure, is it in FD TBL */
+    if (handle < FD_TBL_SIZE && fd_state[handle] != SS_CLEAN_NEED_SYMLINK) {
+        return NULL;
+    }
+
+    /* Go find our mapping */
+    struct storage_mapping_node* curr = storage_mapping_head;
+    for (; curr != NULL; curr = curr->next) {
+        if (curr->fd == handle) {
+            return curr;
+        }
+    }
+
+    /* Safety check: state inconsistent if we get here with handle inside table range */
+    assert(handle >= FD_TBL_SIZE);
+
+    return NULL;
+};
+
+static int possibly_symlink_and_clear_mapping(uint32_t handle) {
+    struct storage_mapping_node* entry = get_pending_symlink_mapping(handle);
+    if (entry == NULL) {
+        /* No mappings pending */
+        return 0;
+    }
+
+    /* Create full path */
+    char* path = NULL;
+    int rc = asprintf(&path, "%s/%s", ssdir_name, entry->file_name);
+    if (rc < 0) {
+        ALOGE("%s: asprintf failed\n", __func__);
+        return -1;
+    }
+
+    /* Try and setup the symlinking */
+    ALOGI("Creating symlink %s->%s\n", path, entry->backing_storage);
+    rc = symlink(entry->backing_storage, path);
+    if (rc < 0) {
+        ALOGE("%s: error symlinking %s->%s (%s)\n", __func__, path, entry->backing_storage,
+              strerror(errno));
+        free(path);
+        return rc;
+    }
+    free(path);
+
+    clear_fd_symlink_status(handle, entry);
+
+    return rc;
+}
+
+static bool is_pending_symlink(uint32_t handle) {
+    struct storage_mapping_node* entry = get_pending_symlink_mapping(handle);
+    return entry != NULL;
+}
+
 static int lookup_fd(uint32_t handle, bool dirty)
 {
     if (dirty) {
@@ -107,6 +191,12 @@ static int lookup_fd(uint32_t handle, bool dirty)
 
 static int remove_fd(uint32_t handle)
 {
+    /* Cleanup fd in symlink mapping if it exists */
+    struct storage_mapping_node* entry = get_pending_symlink_mapping(handle);
+    if (entry != NULL) {
+        entry->fd = -1;
+    }
+
     if (handle < FD_TBL_SIZE) {
         fd_state[handle] = SS_UNUSED; /* set to uninstalled */
     }
@@ -247,11 +337,73 @@ static void sync_parent(const char* path, struct watcher* watcher) {
     watch_progress(watcher, "done syncing parent");
 }
 
+static struct storage_mapping_node* get_storage_mapping_entry(const char* source) {
+    struct storage_mapping_node* curr = storage_mapping_head;
+    for (; curr != NULL; curr = curr->next) {
+        if (!strcmp(source, curr->file_name)) {
+            ALOGI("Found backing file %s for %s\n", curr->backing_storage, source);
+            return curr;
+        }
+    }
+    return NULL;
+}
+
+static bool is_backing_storage_mapped(const char* source) {
+    const struct storage_mapping_node* curr = storage_mapping_head;
+    for (; curr != NULL; curr = curr->next) {
+        if (!strcmp(source, curr->backing_storage)) {
+            ALOGI("Backed storage mapping exists for %s\n", curr->backing_storage);
+            return true;
+        }
+    }
+    return false;
+}
+
+/* Attempts to open a backed file, if mapped, without creating the symlink. Symlink will be created
+ * later on the first write.  This allows us to continue reporting zero read sizes until the first
+ * write. */
+static int open_possibly_mapped_file(const char* short_path, const char* full_path, int open_flags,
+                                     struct storage_mapping_node** entry) {
+    /* See if mapping exists, report upstream if there is no mapping. */
+    struct storage_mapping_node* mapping_entry = get_storage_mapping_entry(short_path);
+    if (mapping_entry == NULL) {
+        return TEMP_FAILURE_RETRY(open(full_path, open_flags, S_IRUSR | S_IWUSR));
+    }
+
+    /* Check for existence of root path, we don't allow mappings during early boot */
+    struct stat buf = {0};
+    if (stat(ssdir_name, &buf) != 0) {
+        ALOGW("Root path not accessible yet, refuse to open mappings for now.\n");
+        return -1;
+    }
+
+    /* We don't support exclusive opening of mapped files */
+    if (open_flags & O_EXCL) {
+        ALOGE("Requesting exclusive open on backed storage isn't supported: %s\n", full_path);
+        return -1;
+    }
+
+    /* Try and open mapping file */
+    open_flags &= ~(O_CREAT | O_EXCL);
+    ALOGI("%s Attempting to open mapped file: %s\n", __func__, mapping_entry->backing_storage);
+    int fd =
+            TEMP_FAILURE_RETRY(open(mapping_entry->backing_storage, open_flags, S_IRUSR | S_IWUSR));
+    if (fd < 0) {
+        ALOGE("%s Failed to open mapping file: %s\n", __func__, mapping_entry->backing_storage);
+        return -1;
+    }
+
+    /* Let caller know which entry we used for opening */
+    *entry = mapping_entry;
+    return fd;
+}
+
 int storage_file_open(struct storage_msg* msg, const void* r, size_t req_len,
                       struct watcher* watcher) {
     char* path = NULL;
     const struct storage_file_open_req *req = r;
     struct storage_file_open_resp resp = {0};
+    struct storage_mapping_node* mapping_entry = NULL;
 
     if (req_len < sizeof(*req)) {
         ALOGE("%s: invalid request length (%zd < %zd)\n",
@@ -321,14 +473,18 @@ int storage_file_open(struct storage_msg* msg, const void* r, size_t req_len,
         if (req->flags & STORAGE_FILE_OPEN_CREATE_EXCLUSIVE) {
             /* create exclusive */
             open_flags |= O_CREAT | O_EXCL;
-            rc = TEMP_FAILURE_RETRY(open(path, open_flags, S_IRUSR | S_IWUSR));
+
+            /* Look for and attempt opening a mapping, else just do normal open. */
+            rc = open_possibly_mapped_file(req->name, path, open_flags, &mapping_entry);
         } else {
             /* try open first */
             rc = TEMP_FAILURE_RETRY(open(path, open_flags, S_IRUSR | S_IWUSR));
             if (rc == -1 && errno == ENOENT) {
                 /* then try open with O_CREATE */
                 open_flags |= O_CREAT;
-                rc = TEMP_FAILURE_RETRY(open(path, open_flags, S_IRUSR | S_IWUSR));
+
+                /* Look for and attempt opening a mapping, else just do normal open. */
+                rc = open_possibly_mapped_file(req->name, path, open_flags, &mapping_entry);
             }
 
         }
@@ -356,7 +512,7 @@ int storage_file_open(struct storage_msg* msg, const void* r, size_t req_len,
 
     /* at this point rc contains storage file fd */
     msg->result = STORAGE_NO_ERROR;
-    resp.handle = insert_fd(open_flags, rc);
+    resp.handle = insert_fd(open_flags, rc, mapping_entry);
     ALOGV("%s: \"%s\": fd = %u: handle = %d\n",
           __func__, path, rc, resp.handle);
 
@@ -433,6 +589,14 @@ int storage_file_write(struct storage_msg* msg, const void* r, size_t req_len,
         goto err_response;
     }
 
+    /* Handle any delayed symlinking for this handle if any */
+    rc = possibly_symlink_and_clear_mapping(req->handle);
+    if (rc < 0) {
+        ALOGE("Failed to symlink storage\n");
+        msg->result = STORAGE_ERR_GENERIC;
+        goto err_response;
+    }
+
     int fd = lookup_fd(req->handle, true);
     watch_progress(watcher, "writing");
     if (write_with_retry(fd, &req->data[0], req_len - sizeof(*req),
@@ -479,6 +643,14 @@ int storage_file_read(struct storage_msg* msg, const void* r, size_t req_len,
         goto err_response;
     }
 
+    /* If this handle has a delayed symlink we should report 0 size reads until first write occurs
+     */
+    if (is_pending_symlink(req->handle)) {
+        ALOGI("Pending symlink: Forcing read result 0.\n");
+        msg->result = STORAGE_NO_ERROR;
+        return ipc_respond(msg, &read_rsp, sizeof(read_rsp.hdr));
+    }
+
     int fd = lookup_fd(req->handle, false);
     watch_progress(watcher, "reading");
     ssize_t read_res = read_with_retry(fd, read_rsp.hdr.data, req->size,
@@ -592,7 +764,7 @@ int storage_file_get_max_size(struct storage_msg* msg, const void* r, size_t req
             goto err_response;
         }
     } else {
-        max_size = MAX_FILE_SIZE;
+        max_size = max_file_size;
     }
 
     resp.max_size = max_size;
@@ -603,17 +775,78 @@ int storage_file_get_max_size(struct storage_msg* msg, const void* r, size_t req
     return ipc_respond(msg, NULL, 0);
 }
 
-int storage_init(const char *dirname)
-{
+int determine_max_file_size(const char* max_file_size_from) {
+    /* Use default if none passed in */
+    if (max_file_size_from == NULL) {
+        ALOGI("No max file source given, continuing to use default: 0x%lx\n", max_file_size);
+        return 0;
+    }
+
+    /* Check that max_file_size_from is part of our mapping list. */
+    if (!is_backing_storage_mapped(max_file_size_from)) {
+        ALOGE("%s: file doesn't match mapped storages (filename=%s)\n", __func__,
+              max_file_size_from);
+        return -1;
+    }
+
+    ALOGI("Using %s to determine max file size.\n", max_file_size_from);
+
+    /* Error if max file size source not found, possible misconfig. */
+    struct stat buf = {0};
+    int rc = stat(max_file_size_from, &buf);
+    if (rc < 0) {
+        ALOGE("%s: error stat'ing file (filename=%s): %s\n", __func__, max_file_size_from,
+              strerror(errno));
+        return -1;
+    }
+
+    /* Currently only support block device as max file size source */
+    if ((buf.st_mode & S_IFMT) != S_IFBLK) {
+        ALOGE("Unsupported max file size source type: %d\n", buf.st_mode);
+        return -1;
+    }
+
+    ALOGI("%s is a block device, determining block device size\n", max_file_size_from);
+    uint64_t max_size = 0;
+    int fd = TEMP_FAILURE_RETRY(open(max_file_size_from, O_RDONLY | O_NONBLOCK));
+    if (fd < 0) {
+        ALOGE("%s: failed to open backing file %s for ioctl: %s\n", __func__, max_file_size_from,
+              strerror(errno));
+        return -1;
+    }
+    rc = ioctl(fd, BLKGETSIZE64, &max_size);
+    if (rc < 0) {
+        ALOGE("%s: error calling ioctl on file (fd=%d): %s\n", __func__, fd, strerror(errno));
+        close(fd);
+        return -1;
+    }
+    close(fd);
+    max_file_size = max_size;
+
+    ALOGI("Using 0x%lx as max file size\n", max_file_size);
+    return 0;
+}
+
+int storage_init(const char* dirname, struct storage_mapping_node* mappings,
+                 const char* max_file_size_from) {
     /* If there is an active DSU image, use the alternate fs mode. */
     alternate_mode = is_gsi_running();
 
     fs_state = SS_CLEAN;
     for (uint i = 0; i < FD_TBL_SIZE; i++) {
-        fd_state[i] = SS_UNUSED;  /* uninstalled */
+        fd_state[i] = SS_UNUSED; /* uninstalled */
     }
 
     ssdir_name = dirname;
+
+    storage_mapping_head = mappings;
+
+    /* Set the max file size based on incoming configuration */
+    int rc = determine_max_file_size(max_file_size_from);
+    if (rc < 0) {
+        return rc;
+    }
+
     return 0;
 }
 
@@ -623,17 +856,17 @@ int storage_sync_checkpoint(struct watcher* watcher) {
     watch_progress(watcher, "sync fd table");
     /* sync fd table and reset it to clean state first */
     for (uint fd = 0; fd < FD_TBL_SIZE; fd++) {
-         if (fd_state[fd] == SS_DIRTY) {
-             if (fs_state == SS_CLEAN) {
-                 /* need to sync individual fd */
-                 rc = fsync(fd);
-                 if (rc < 0) {
-                     ALOGE("fsync for fd=%d failed: %s\n", fd, strerror(errno));
-                     return rc;
-                 }
-             }
-             fd_state[fd] = SS_CLEAN; /* set to clean */
-         }
+        if (fd_state[fd] == SS_DIRTY) {
+            if (fs_state == SS_CLEAN) {
+                /* need to sync individual fd */
+                rc = fsync(fd);
+                if (rc < 0) {
+                    ALOGE("fsync for fd=%d failed: %s\n", fd, strerror(errno));
+                    return rc;
+                }
+            }
+            fd_state[fd] = SS_CLEAN; /* set to clean */
+        }
     }
 
     /* check if we need to sync all filesystems */
diff --git a/trusty/storage/proxy/storage.h b/trusty/storage/proxy/storage.h
index f29fdf2e8047..6dbfe3706076 100644
--- a/trusty/storage/proxy/storage.h
+++ b/trusty/storage/proxy/storage.h
@@ -21,6 +21,14 @@
 /* Defined in watchdog.h */
 struct watcher;
 
+/* Is used for managing alternate backing storage, generally will be a block device. */
+struct storage_mapping_node {
+    struct storage_mapping_node* next;
+    const char* file_name;
+    const char* backing_storage;
+    int fd;
+};
+
 int storage_file_delete(struct storage_msg* msg, const void* req, size_t req_len,
                         struct watcher* watcher);
 
@@ -45,6 +53,7 @@ int storage_file_set_size(struct storage_msg* msg, const void* req, size_t req_l
 int storage_file_get_max_size(struct storage_msg* msg, const void* req, size_t req_len,
                               struct watcher* watcher);
 
-int storage_init(const char* dirname);
+int storage_init(const char* dirname, struct storage_mapping_node* head,
+                 const char* max_file_size_from);
 
 int storage_sync_checkpoint(struct watcher* watcher);

From 12c64a758663cfecce7f71fcad960d94b4e04e58 Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Wed, 17 Apr 2024 14:15:49 +0900
Subject: [PATCH 0849/1487] Don't install Android-only dependencies to
 microdroid

init_second_stage_defaults provides properties that are common to both
Android's init and Microdroid's init. Before this CL, it included
target.product.required and target.recovery.required properties. The
required dependencies were Android-specific; the dependencies included
Android-only init.rc. Microdroid has its own init.rc (microdroid_init_rc
module).

This was problematic but so far it didn't cause an issue because those
Android-only dependencies were not installed to Microdroid due to a bug
in the build system.

As we fix the build system bug, the Android-only dependencies started
get installed to Microdroid, effectively overriding the Microdroid-only
init.rc file. This made Microdroid fail to boot.

Fixing this issue by moving the Android-only dependencies out of the
defaults module and putting them on the Android's init.

In addition to that, this CL removes the recovery variant for the
Microdroid's init because it's not used.

Bug: N/A
Test: run AVF tests
Change-Id: I09748f1123125cac74ce54fd5c360c9a3ba2f996
---
 init/Android.bp | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index ff82f7f1849b..6d63e41e2164 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -259,6 +259,7 @@ cc_library_static {
         "avf_build_flags_cc",
         "libinit_defaults",
     ],
+    recovery_available: false,
     cflags: ["-DMICRODROID=1"],
 }
 
@@ -276,6 +277,13 @@ cc_defaults {
     defaults: ["init_defaults"],
     srcs: ["main.cpp"],
     symlinks: ["ueventd"],
+}
+
+cc_binary {
+    name: "init_second_stage",
+    defaults: ["init_second_stage_defaults"],
+    static_libs: ["libinit"],
+    visibility: ["//visibility:any_system_partition"],
     target: {
         platform: {
             required: [
@@ -309,19 +317,13 @@ cc_defaults {
     },
 }
 
-cc_binary {
-    name: "init_second_stage",
-    defaults: ["init_second_stage_defaults"],
-    static_libs: ["libinit"],
-    visibility: ["//visibility:any_system_partition"],
-}
-
 cc_binary {
     name: "init_second_stage.microdroid",
     defaults: [
         "avf_build_flags_cc",
         "init_second_stage_defaults",
     ],
+    recovery_available: false,
     static_libs: ["libinit.microdroid"],
     cflags: ["-DMICRODROID=1"],
     installable: false,

From 8005cfa7e4abb2c07a3e4ba13b123a847b1ba728 Mon Sep 17 00:00:00 2001
From: David Drysdale <drysdale@google.com>
Date: Wed, 17 Apr 2024 16:27:49 +0100
Subject: [PATCH 0850/1487] Warn that reboot might be needed after setting IDs

Test: compile
Change-Id: Iac93f6a60df7e1a9f89183deabb37e0efc16df91
---
 trusty/keymaster/set_attestation_ids/set_attestation_ids.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/trusty/keymaster/set_attestation_ids/set_attestation_ids.cpp b/trusty/keymaster/set_attestation_ids/set_attestation_ids.cpp
index 6b8f90fa46b2..dec64e19b95e 100644
--- a/trusty/keymaster/set_attestation_ids/set_attestation_ids.cpp
+++ b/trusty/keymaster/set_attestation_ids/set_attestation_ids.cpp
@@ -247,6 +247,7 @@ int main(int argc, char** argv) {
         return EXIT_FAILURE;
     } else {
         printf("done\n");
+        printf("\nNOTE: device reboot may be required before changes take effect.\n");
         return EXIT_SUCCESS;
     }
 }

From f1ddc62db32b6ec02f8662de26b0ed86b4a05cd7 Mon Sep 17 00:00:00 2001
From: Inseob Kim <inseob@google.com>
Date: Wed, 17 Apr 2024 18:30:19 +0900
Subject: [PATCH 0851/1487] Build etc/hosts with Soong

Bug: 335369205
Test: build
Change-Id: I3a33e80dc751ddce874fe1345594e6dc5f27b36c
---
 rootdir/Android.bp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 6a3484e20253..9a64310f9937 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -101,3 +101,9 @@ prebuilt_etc {
     src: "init.usb.configfs.rc",
     sub_dir: "init/hw",
 }
+
+prebuilt_etc {
+    name: "etc_hosts",
+    src: "etc/hosts",
+    filename: "hosts",
+}

From fa5cf6884a9507e9b78a11c9c439a2500a75b83a Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 18 Apr 2024 06:15:29 -0700
Subject: [PATCH 0852/1487] snapshotctl: Check for cow path when allocated from
 /data

If the COW device is allocated only from /data, then
the COW device name will end with -cow-img. Hence, check
that path as well.

Bug: 335552315
Test: snapshotctl apply-update
Change-Id: Id3c5cf8afd77994da117de41bb98a226b350f8e4
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshotctl.cpp | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 192e1d67a855..0158d4d9cea1 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -110,6 +110,7 @@ class MapSnapshots {
   private:
     std::optional<std::string> GetCowImagePath(std::string& name);
     bool PrepareUpdate();
+    bool GetCowDevicePath(std::string partition_name, std::string* cow_path);
     bool WriteSnapshotPatch(std::string cow_device, std::string patch);
     std::string GetGroupName(const android::fs_mgr::LpMetadata& pt,
                              const std::string& partiton_name);
@@ -231,6 +232,23 @@ bool MapSnapshots::PrepareUpdate() {
     return true;
 }
 
+bool MapSnapshots::GetCowDevicePath(std::string partition_name, std::string* cow_path) {
+    auto& dm = android::dm::DeviceMapper::Instance();
+    std::string cow_device = partition_name + "-cow";
+    if (dm.GetDmDevicePathByName(cow_device, cow_path)) {
+        return true;
+    }
+
+    LOG(INFO) << "Failed to find cow path: " << cow_device << " Checking the device for -img path";
+    // If the COW device exists only on /data
+    cow_device = partition_name + "-cow-img";
+    if (!dm.GetDmDevicePathByName(cow_device, cow_path)) {
+        LOG(ERROR) << "Failed to cow path: " << cow_device;
+        return false;
+    }
+    return true;
+}
+
 bool MapSnapshots::ApplyUpdate() {
     if (!PrepareUpdate()) {
         LOG(ERROR) << "PrepareUpdate failed";
@@ -253,15 +271,13 @@ bool MapSnapshots::ApplyUpdate() {
 
     LOG(INFO) << "MapAllSnapshots success";
 
-    auto& dm = android::dm::DeviceMapper::Instance();
     auto target_slot = fs_mgr_get_other_slot_suffix();
     for (auto& patchfile : patchfiles_) {
         auto npos = patchfile.rfind(".patch");
         auto partition_name = patchfile.substr(0, npos) + target_slot;
-        auto cow_device = partition_name + "-cow";
         std::string cow_path;
-        if (!dm.GetDmDevicePathByName(cow_device, &cow_path)) {
-            LOG(ERROR) << "Failed to cow path";
+        if (!GetCowDevicePath(partition_name, &cow_path)) {
+            LOG(ERROR) << "Failed to find cow path";
             return false;
         }
         threads_.emplace_back(std::async(std::launch::async, &MapSnapshots::WriteSnapshotPatch,

From 29e30f25b4f1efd639182eff8b9e7c5a49cf0ae6 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 18 Apr 2024 16:00:11 +0000
Subject: [PATCH 0853/1487] Revert "libprocessgroup: Check validity of uid and
 pid arguments"

This reverts commit 5a3c3f7ccff322a5383fa8a1b6450480cf7fbab9.

Don't SIGABRT for invalid requests.

Bug: 333261173
Change-Id: If22244753b43529ed17c315b3732af371827e774
---
 libprocessgroup/processgroup.cpp | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 94d950209e5f..7c555708e002 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -528,8 +528,14 @@ static populated_status cgroupIsPopulated(int events_fd) {
 static int KillProcessGroup(
         uid_t uid, pid_t initialPid, int signal, bool once = false,
         std::chrono::steady_clock::time_point until = std::chrono::steady_clock::now() + 2200ms) {
-    CHECK_GE(uid, 0);
-    CHECK_GT(initialPid, 0);
+    if (uid < 0) {
+        LOG(ERROR) << __func__ << ": invalid UID " << uid;
+        return -1;
+    }
+    if (initialPid <= 0) {
+        LOG(ERROR) << __func__ << ": invalid PID " << initialPid;
+        return -1;
+    }
 
     // Always attempt to send a kill signal to at least the initialPid, at least once, regardless of
     // whether its cgroup exists or not. This should only be necessary if a bug results in the
@@ -689,9 +695,6 @@ static int createProcessGroupInternal(uid_t uid, pid_t initialPid, std::string c
 }
 
 int createProcessGroup(uid_t uid, pid_t initialPid, bool memControl) {
-    CHECK_GE(uid, 0);
-    CHECK_GT(initialPid, 0);
-
     if (memControl && !UsePerAppMemcg()) {
         LOG(ERROR) << "service memory controls are used without per-process memory cgroup support";
         return -EINVAL;

From 7d9d171e4ed5121c249a724898c96f7fba8ac760 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 18 Apr 2024 16:05:56 +0000
Subject: [PATCH 0854/1487] libprocessgroup: Check validity of uid and pid
 arguments for createProcessGroup

killProcessGroup already checks for validity of the uid and pid input
arguments. Also add this checking to createProcessGroup.

Bug: 333261173
Change-Id: Ie74b9c2716978cb5eb434af12e27945e29af876e
---
 libprocessgroup/processgroup.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 7c555708e002..44d8e441de9e 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -695,6 +695,15 @@ static int createProcessGroupInternal(uid_t uid, pid_t initialPid, std::string c
 }
 
 int createProcessGroup(uid_t uid, pid_t initialPid, bool memControl) {
+    if (uid < 0) {
+        LOG(ERROR) << __func__ << ": invalid UID " << uid;
+        return -1;
+    }
+    if (initialPid <= 0) {
+        LOG(ERROR) << __func__ << ": invalid PID " << initialPid;
+        return -1;
+    }
+
     if (memControl && !UsePerAppMemcg()) {
         LOG(ERROR) << "service memory controls are used without per-process memory cgroup support";
         return -EINVAL;

From 4113b658a87d9fdb2031831d62fa852556ea922a Mon Sep 17 00:00:00 2001
From: Inseob Kim <inseob@google.com>
Date: Fri, 19 Apr 2024 16:17:14 +0900
Subject: [PATCH 0855/1487] Build init-debug.rc with Soong

Bug: 335369205
Test: build and compare
Change-Id: Idb6105e8527e3a2b4f0517b31be3fa8b78826880
---
 rootdir/Android.bp |  6 ++++++
 rootdir/Android.mk | 13 -------------
 2 files changed, 6 insertions(+), 13 deletions(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 9a64310f9937..06227c31804b 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -107,3 +107,9 @@ prebuilt_etc {
     src: "etc/hosts",
     filename: "hosts",
 }
+
+prebuilt_etc {
+    name: "init-debug.rc",
+    src: "init-debug.rc",
+    sub_dir: "init",
+}
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 593bb1e349e8..fb91b58883b1 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -2,19 +2,6 @@ LOCAL_PATH:= $(call my-dir)
 
 $(eval $(call declare-1p-copy-files,system/core/rootdir,))
 
-#######################################
-# init-debug.rc
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := init-debug.rc
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_SRC_FILES := $(LOCAL_MODULE)
-LOCAL_MODULE_CLASS := ETC
-LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/init
-
-include $(BUILD_PREBUILT)
-
 #######################################
 # asan.options
 ifneq ($(filter address,$(SANITIZE_TARGET)),)

From 885bd1c8d60b3fb1091b7738ee529a988720f139 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 14 Mar 2024 14:35:43 -0700
Subject: [PATCH 0856/1487] libsnapshot: remove hard coded cow version

Remove hard coded global variables referencing cow version in
libsnapshot. This value should stem from the build system, or set
individually in test cases.

Bug: 307452468
Test: th
Change-Id: I3d536246008acca92cd93e77886e5f7d17a131e0
---
 fs_mgr/libsnapshot/include/libsnapshot/cow_format.h         | 6 ------
 fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader_test.cpp | 2 +-
 .../snapuserd/user-space-merge/snapuserd_test.cpp           | 2 +-
 3 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 6a7153dcb2a9..991e17cbbe0a 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -31,15 +31,9 @@ static constexpr uint64_t kCowMagicNumber = 0x436f77634f572121ULL;
 static constexpr uint32_t kCowVersionMajor = 2;
 static constexpr uint32_t kCowVersionMinor = 0;
 
-static constexpr uint32_t kCowVersionManifest = 2;
-
 static constexpr uint32_t kMinCowVersion = 1;
 static constexpr uint32_t kMaxCowVersion = 3;
 
-// Normally, this should be kMaxCowVersion. When a new version is under testing
-// it may be the previous value of kMaxCowVersion.
-static constexpr uint32_t kDefaultCowVersion = 2;
-
 // This header appears as the first sequence of bytes in the COW. All fields
 // in the layout are little-endian encoded. The on-disk layout is:
 //
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader_test.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader_test.cpp
index 10cb06d7eeea..f00f236ceac9 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader_test.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/snapshot_reader_test.cpp
@@ -184,7 +184,7 @@ TEST_F(OfflineSnapshotTest, CompressedSnapshot) {
     unique_fd cow_fd(dup(cow_->fd));
     ASSERT_GE(cow_fd, 0);
 
-    auto writer = CreateCowWriter(kDefaultCowVersion, options, std::move(cow_fd));
+    auto writer = CreateCowWriter(2, options, std::move(cow_fd));
     ASSERT_NO_FATAL_FAILURE(WriteCow(writer.get()));
     ASSERT_NO_FATAL_FAILURE(TestReads(writer.get()));
 }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index d05df82550c4..56f7b5911012 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -135,7 +135,7 @@ std::unique_ptr<ICowWriter> SnapuserdTestBase::CreateCowDeviceInternal() {
     unique_fd fd(cow_system_->fd);
     cow_system_->fd = -1;
 
-    return CreateCowWriter(kDefaultCowVersion, options, std::move(fd));
+    return CreateCowWriter(2, options, std::move(fd));
 }
 
 std::unique_ptr<ICowWriter> SnapuserdTestBase::CreateV3Cow() {

From 32677ae8f3c93d29ac9ed94be26f8368c0dec0da Mon Sep 17 00:00:00 2001
From: Nate Myren <ntmyren@google.com>
Date: Fri, 19 Apr 2024 19:07:52 +0000
Subject: [PATCH 0857/1487] Only write appcompat properties if flag is defined

Only writes the appcompat properties if the
WRITE_APPCOMPAT_OVERRIDE_SYSTEM_PROPERTIES cflag is defined

Fixes: 331307495
Test: manual
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:f04f6bae4314e01111045ba231010ba7067477a0)
Merged-In: Ie99b5027a9704c0f4f7fe4d3a6a6cf49f4bb8176
Change-Id: Ie99b5027a9704c0f4f7fe4d3a6a6cf49f4bb8176
---
 init/Android.bp           | 4 ++++
 init/property_service.cpp | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/init/Android.bp b/init/Android.bp
index 6d63e41e2164..c4e74d068b0d 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -96,6 +96,7 @@ soong_config_module_type {
     config_namespace: "ANDROID",
     bool_variables: [
         "PRODUCT_INSTALL_DEBUG_POLICY_TO_SYSTEM_EXT",
+        "release_write_appcompat_override_system_properties",
     ],
     properties: [
         "cflags",
@@ -159,6 +160,9 @@ libinit_cc_defaults {
                 "-DINSTALL_DEBUG_POLICY_TO_SYSTEM_EXT=1",
             ],
         },
+        release_write_appcompat_override_system_properties: {
+            cflags: ["-DWRITE_APPCOMPAT_OVERRIDE_SYSTEM_PROPERTIES"],
+        }
     },
     static_libs: [
         "libavb",
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 58a0a7faa05d..5a1b63b2e49a 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1308,12 +1308,14 @@ void CreateSerializedPropertyInfo() {
     }
     selinux_android_restorecon(PROP_TREE_FILE, 0);
 
+#ifdef WRITE_APPCOMPAT_OVERRIDE_SYSTEM_PROPERTIES
     mkdir(APPCOMPAT_OVERRIDE_PROP_FOLDERNAME, S_IRWXU | S_IXGRP | S_IXOTH);
     if (!WriteStringToFile(serialized_contexts, APPCOMPAT_OVERRIDE_PROP_TREE_FILE, 0444, 0, 0,
                            false)) {
         PLOG(ERROR) << "Unable to write appcompat override property infos to file";
     }
     selinux_android_restorecon(APPCOMPAT_OVERRIDE_PROP_TREE_FILE, 0);
+#endif
 }
 
 static void ExportKernelBootProps() {

From e873e1d31b1e43e9c3b95a5e40fec905a0dc78dc Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Sat, 20 Apr 2024 10:11:46 +0900
Subject: [PATCH 0858/1487] Null terminate the std::array given to execve

std::array<T, N> takes exactly N * sizeof(T) bytes, leaving no room for
the null terminator.

Bug: 335047945
Test: re-run the GSI test
Change-Id: Ic3aca5f409021c78a7eb965c5ed610e6a51e42cb
---
 init/first_stage_mount.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index ae216c66404d..5d3a2735489f 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -556,11 +556,11 @@ static bool MaybeDeriveMicrodroidVendorDiceNode(Fstab* fstab) {
         return true;
     }
     // clang-format off
-    const std::array<const char*, 7> args = {
+    const std::array<const char*, 8> args = {
         "/system/bin/derive_microdroid_vendor_dice_node",
                 "--dice-driver", "/dev/open-dice0",
                 "--microdroid-vendor-disk-image", microdroid_vendor_block_dev->data(),
-                "--output", "/microdroid_resources/dice_chain.raw",
+                "--output", "/microdroid_resources/dice_chain.raw", nullptr,
     };
     // clang-format-on
     // ForkExecveAndWaitForCompletion calls waitpid to wait for the fork-ed process to finish.

From 8b29034b89569d900ca21137eefd7edae601f9ee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= <maze@google.com>
Date: Sat, 20 Apr 2024 06:57:37 +0000
Subject: [PATCH 0859/1487] init.rc: remove xt_qtaguid configuration
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

which has been fully replaced by eBpf
(started in android P, finished in android S)

Test: TreeHugger
Signed-off-by: Maciej Żenczykowski <maze@google.com>
Change-Id: Ie38e54600a9bb01c7ecdde63d9a9256bed047f41
---
 rootdir/init.rc | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 1af46c1bd785..1888ba4911f7 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -425,16 +425,6 @@ on init
     chown system system /proc/pressure/memory
     chmod 0664 /proc/pressure/memory
 
-    # qtaguid will limit access to specific data based on group memberships.
-    #   net_bw_acct grants impersonation of socket owners.
-    #   net_bw_stats grants access to other apps' detailed tagged-socket stats.
-    chown root net_bw_acct /proc/net/xt_qtaguid/ctrl
-    chown root net_bw_stats /proc/net/xt_qtaguid/stats
-
-    # Allow everybody to read the xt_qtaguid resource tracking misc dev.
-    # This is needed by any process that uses socket tagging.
-    chmod 0644 /dev/xt_qtaguid
-
     mount bpf bpf /sys/fs/bpf nodev noexec nosuid
 
     # pstore/ramoops previous console log

From a95be37d2cd3a126483ccd96e4162df8ff9ee1af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= <maze@google.com>
Date: Sat, 20 Apr 2024 07:06:23 +0000
Subject: [PATCH 0860/1487] init.rc: remove 4.9/4.14 support
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

U requires 4.14+
V requires 4.19+

as such this is no longer useful

Test: TreeHugger
Signed-off-by: Maciej Żenczykowski <maze@google.com>
Change-Id: I39d01cc16897c6c9174cf074e27c888bc758f1cc
---
 rootdir/init.rc | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 1af46c1bd785..02cfca5e44d2 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -666,10 +666,6 @@ on late-fs
     exec -- /system/bin/fsverity_init --load-verified-keys
 
 # Only enable the bootreceiver tracing instance for kernels 5.10 and above.
-on late-fs && property:ro.kernel.version=4.9
-    setprop bootreceiver.enable 0
-on late-fs && property:ro.kernel.version=4.14
-    setprop bootreceiver.enable 0
 on late-fs && property:ro.kernel.version=4.19
     setprop bootreceiver.enable 0
 on late-fs && property:ro.kernel.version=5.4

From 2c6b83f4d26d370f0a42701a6160720f4b1223e4 Mon Sep 17 00:00:00 2001
From: "sanga1.lee" <sanga1.lee@lge.com>
Date: Mon, 22 Apr 2024 15:45:46 +0900
Subject: [PATCH 0861/1487] setprop: check if not setprop value but setprop
 name starts with "ro."

When setting property with setprop, a property name which starts with
"ro." could be set no matter how long the value name is.

Change-Id: Ia035ef009952db08ae8a6d4a2b8b9567d86124fc
---
 toolbox/setprop.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/toolbox/setprop.cpp b/toolbox/setprop.cpp
index acf8c3e61289..91edf459126f 100644
--- a/toolbox/setprop.cpp
+++ b/toolbox/setprop.cpp
@@ -58,7 +58,7 @@ extern "C" int setprop_main(int argc, char** argv) {
         }
     }
 
-    if (value.size() >= PROP_VALUE_MAX && !StartsWith(value, "ro.")) {
+    if (value.size() >= PROP_VALUE_MAX && !StartsWith(name, "ro.")) {
         std::cerr << "Value '" << value << "' is too long, " << value.size()
                   << " bytes vs a max of " << PROP_VALUE_MAX << std::endl;
         return EXIT_FAILURE;

From 4f75b6699c847b69dac0b0ab340b9782ea8064ef Mon Sep 17 00:00:00 2001
From: Donnie Pollitz <donpollitz@google.com>
Date: Mon, 22 Apr 2024 22:22:14 +0200
Subject: [PATCH 0862/1487] storageproxyd: Fix x86 builds

Background:
* printf format specifiers and size_t literal were invalid.

Bug: 324989972
Test: Builds
Change-Id: I408cfe0d41fb6850d5dcfe9963bb88be48f4a0c6
Signed-off-by: Donnie Pollitz <donpollitz@google.com>
---
 trusty/storage/proxy/storage.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/trusty/storage/proxy/storage.c b/trusty/storage/proxy/storage.c
index 1dab93d9c6a6..6d0c616715c1 100644
--- a/trusty/storage/proxy/storage.c
+++ b/trusty/storage/proxy/storage.c
@@ -40,7 +40,7 @@
 #define ALTERNATE_DATA_DIR "alternate/"
 
 /* Maximum file size for filesystem backed storage (i.e. not block dev backed storage) */
-static size_t max_file_size = 0x10000000000;
+static uint64_t max_file_size = 0x10000000000;
 
 enum sync_state {
     SS_UNUSED = -1,
@@ -778,7 +778,8 @@ int storage_file_get_max_size(struct storage_msg* msg, const void* r, size_t req
 int determine_max_file_size(const char* max_file_size_from) {
     /* Use default if none passed in */
     if (max_file_size_from == NULL) {
-        ALOGI("No max file source given, continuing to use default: 0x%lx\n", max_file_size);
+        ALOGI("No max file source given, continuing to use default: 0x%" PRIx64 "\n",
+              max_file_size);
         return 0;
     }
 
@@ -823,7 +824,7 @@ int determine_max_file_size(const char* max_file_size_from) {
     close(fd);
     max_file_size = max_size;
 
-    ALOGI("Using 0x%lx as max file size\n", max_file_size);
+    ALOGI("Using 0x%" PRIx64 " as max file size\n", max_file_size);
     return 0;
 }
 

From f885d551c2c8b03392ddcdf8c0fbdabcbc01e5b7 Mon Sep 17 00:00:00 2001
From: Ellen Arteca <emarteca@google.com>
Date: Tue, 9 Jan 2024 21:54:43 +0000
Subject: [PATCH 0863/1487] Create and support isolation for /data/storage_area

Creating the directory /data/storage_area (which will store each user's directory
of app directories of storage areas) on startup, and adding this directory
/data/storage_area to the tmpfs mirror so it can be protected by app data isolation
in zygote.

Bug: 325121608
Test: atest StorageAreaTest
Change-Id: Ia938e89fd8b794dbcbb844b01b790db7c0a62319
---
 rootdir/init.rc | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index e3896b1b27fd..6a7c499ed3df 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -958,6 +958,10 @@ on post-fs-data
     mkdir /data/vendor_ce 0551 root root encryption=None
     mkdir /data/vendor_de 0551 root root encryption=None
 
+    # Similar to the top-level CE and DE directories, /data/storage_area must
+    # itself be unencrypted, since it contains encrypted directories.
+    mkdir /data/storage_area 0551 root root encryption=None
+
     # Set the casefold flag on /data/media.  For upgrades, a restorecon can be
     # needed first to relabel the directory from media_rw_data_file.
     restorecon /data/media
@@ -971,8 +975,12 @@ on post-fs-data
     mkdir /data_mirror/data_de 0700 root root
     mkdir /data_mirror/misc_ce 0700 root root
     mkdir /data_mirror/misc_de 0700 root root
+    mkdir /data_mirror/storage_area 0700 root root
 
     # Create CE and DE data directory for default volume
+    # Not needed for storage_area directory, since this is
+    # not supported for non-default volumes and the path
+    # does not include the volume ID
     mkdir /data_mirror/data_ce/null 0700 root root
     mkdir /data_mirror/data_de/null 0700 root root
     mkdir /data_mirror/misc_ce/null 0700 root root
@@ -987,6 +995,9 @@ on post-fs-data
     mount none /data/misc_ce /data_mirror/misc_ce/null bind rec
     mount none /data/misc_de /data_mirror/misc_de/null bind rec
 
+    # Also bind mount for the storage area directory (minus the volume ID)
+    mount none /data/storage_area /data_mirror/storage_area bind rec
+
     # Create mirror directory for jit profiles
     mkdir /data_mirror/cur_profiles 0700 root root
     mount none /data/misc/profiles/cur /data_mirror/cur_profiles bind rec
@@ -1327,6 +1338,8 @@ on userspace-reboot-fs-remount
   umount /data_mirror/data_ce/null/0
   umount /data_mirror/data_ce/null
   umount /data_mirror/data_de/null
+  umount /data_mirror/storage_area/0
+  umount /data_mirror/storage_area
   umount /data_mirror/cur_profiles
   umount /data_mirror/ref_profiles
   umount /data_mirror

From 2d45331a9e7de22f0892a42b67afcfcd10bd9005 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Mon, 22 Apr 2024 23:43:59 +0000
Subject: [PATCH 0864/1487] Avoid confusing `main_thread` name

It is not in fact the main thread of the process, but the thread that crashed

Change-Id: I3af6d0ffc6c0617526a9cbeb36b2a3286aaeb6f6
---
 debuggerd/libdebuggerd/tombstone_proto.cpp | 56 +++++++++++-----------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index 74f9a8c63045..4cde986104c5 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -203,7 +203,7 @@ void set_human_readable_cause(Cause* cause, uint64_t fault_addr) {
 }
 
 static void dump_probable_cause(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
-                                const ProcessInfo& process_info, const ThreadInfo& main_thread) {
+                                const ProcessInfo& process_info, const ThreadInfo& target_thread) {
 #if defined(USE_SCUDO)
   ScudoCrashData scudo_crash_data(unwinder->GetProcessMemory().get(), process_info);
   if (scudo_crash_data.CrashIsMine()) {
@@ -213,13 +213,13 @@ static void dump_probable_cause(Tombstone* tombstone, unwindstack::AndroidUnwind
 #endif
 
   GwpAsanCrashData gwp_asan_crash_data(unwinder->GetProcessMemory().get(), process_info,
-                                       main_thread);
+                                       target_thread);
   if (gwp_asan_crash_data.CrashIsMine()) {
     gwp_asan_crash_data.AddCauseProtos(tombstone, unwinder);
     return;
   }
 
-  const siginfo *si = main_thread.siginfo;
+  const siginfo *si = target_thread.siginfo;
   auto fault_addr = reinterpret_cast<uint64_t>(si->si_addr);
   unwindstack::Maps* maps = unwinder->GetMaps();
 
@@ -238,14 +238,14 @@ static void dump_probable_cause(Tombstone* tombstone, unwindstack::AndroidUnwind
     } else if (fault_addr == 0xffff0f60) {
       cause = "call to kuser_cmpxchg64";
     } else {
-      cause = get_stack_overflow_cause(fault_addr, main_thread.registers->sp(), maps);
+      cause = get_stack_overflow_cause(fault_addr, target_thread.registers->sp(), maps);
     }
   } else if (si->si_signo == SIGSEGV && si->si_code == SEGV_ACCERR) {
     auto map_info = maps->Find(fault_addr);
     if (map_info != nullptr && map_info->flags() == PROT_EXEC) {
       cause = "execute-only (no-read) memory access error; likely due to data in .text.";
     } else {
-      cause = get_stack_overflow_cause(fault_addr, main_thread.registers->sp(), maps);
+      cause = get_stack_overflow_cause(fault_addr, target_thread.registers->sp(), maps);
     }
   } else if (si->si_signo == SIGSYS && si->si_code == SYS_SECCOMP) {
     cause = StringPrintf("seccomp prevented call to disallowed %s system call %d", ABI_STRING,
@@ -685,7 +685,7 @@ static void dump_tags_around_fault_addr(Signal* signal, const Tombstone& tombsto
 }
 
 void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
-                             const std::map<pid_t, ThreadInfo>& threads, pid_t target_thread,
+                             const std::map<pid_t, ThreadInfo>& threads, pid_t target_tid,
                              const ProcessInfo& process_info, const OpenFilesList* open_files) {
   Tombstone result;
 
@@ -694,19 +694,19 @@ void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder*
   result.set_revision(android::base::GetProperty("ro.revision", "unknown"));
   result.set_timestamp(get_timestamp());
 
-  const ThreadInfo& main_thread = threads.at(target_thread);
-  result.set_pid(main_thread.pid);
-  result.set_tid(main_thread.tid);
-  result.set_uid(main_thread.uid);
-  result.set_selinux_label(main_thread.selinux_label);
+  const ThreadInfo& target_thread = threads.at(target_tid);
+  result.set_pid(target_thread.pid);
+  result.set_tid(target_thread.tid);
+  result.set_uid(target_thread.uid);
+  result.set_selinux_label(target_thread.selinux_label);
   // The main thread must have a valid siginfo.
-  CHECK(main_thread.siginfo != nullptr);
+  CHECK(target_thread.siginfo != nullptr);
 
   struct sysinfo si;
   sysinfo(&si);
   android::procinfo::ProcessInfo proc_info;
   std::string error;
-  if (android::procinfo::GetProcessInfo(main_thread.pid, &proc_info, &error)) {
+  if (android::procinfo::GetProcessInfo(target_thread.pid, &proc_info, &error)) {
     uint64_t starttime = proc_info.starttime / sysconf(_SC_CLK_TCK);
     result.set_process_uptime(si.uptime - starttime);
   } else {
@@ -715,24 +715,24 @@ void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder*
   }
 
   auto cmd_line = result.mutable_command_line();
-  for (const auto& arg : main_thread.command_line) {
+  for (const auto& arg : target_thread.command_line) {
     *cmd_line->Add() = arg;
   }
 
-  if (!main_thread.siginfo) {
+  if (!target_thread.siginfo) {
     async_safe_fatal("siginfo missing");
   }
 
   Signal sig;
-  sig.set_number(main_thread.signo);
-  sig.set_name(get_signame(main_thread.siginfo));
-  sig.set_code(main_thread.siginfo->si_code);
-  sig.set_code_name(get_sigcode(main_thread.siginfo));
+  sig.set_number(target_thread.signo);
+  sig.set_name(get_signame(target_thread.siginfo));
+  sig.set_code(target_thread.siginfo->si_code);
+  sig.set_code_name(get_sigcode(target_thread.siginfo));
 
-  if (signal_has_sender(main_thread.siginfo, main_thread.pid)) {
+  if (signal_has_sender(target_thread.siginfo, target_thread.pid)) {
     sig.set_has_sender(true);
-    sig.set_sender_uid(main_thread.siginfo->si_uid);
-    sig.set_sender_pid(main_thread.siginfo->si_pid);
+    sig.set_sender_uid(target_thread.siginfo->si_uid);
+    sig.set_sender_pid(target_thread.siginfo->si_pid);
   }
 
   if (process_info.has_fault_address) {
@@ -746,28 +746,28 @@ void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder*
 
   dump_abort_message(&result, unwinder->GetProcessMemory(), process_info);
   dump_crash_details(&result, unwinder->GetProcessMemory(), process_info);
-  // Dump the main thread, but save the memory around the registers.
-  dump_thread(&result, unwinder, main_thread, /* memory_dump */ true);
+  // Dump the target thread, but save the memory around the registers.
+  dump_thread(&result, unwinder, target_thread, /* memory_dump */ true);
 
   for (const auto& [tid, thread_info] : threads) {
-    if (tid != target_thread) {
+    if (tid != target_tid) {
       dump_thread(&result, unwinder, thread_info);
     }
   }
 
-  dump_probable_cause(&result, unwinder, process_info, main_thread);
+  dump_probable_cause(&result, unwinder, process_info, target_thread);
 
   dump_mappings(&result, unwinder->GetMaps(), unwinder->GetProcessMemory());
 
   // Only dump logs on debuggable devices.
   if (android::base::GetBoolProperty("ro.debuggable", false)) {
     // Get the thread that corresponds to the main pid of the process.
-    const ThreadInfo& thread = threads.at(main_thread.pid);
+    const ThreadInfo& thread = threads.at(target_thread.pid);
 
     // Do not attempt to dump logs of the logd process because the gathering
     // of logs can hang until a timeout occurs.
     if (thread.thread_name != "logd") {
-      dump_logcat(&result, main_thread.pid);
+      dump_logcat(&result, target_thread.pid);
     }
   }
 

From 1db2d481eab6bba6ccbf853e46cea990c1600930 Mon Sep 17 00:00:00 2001
From: Chungkai Mei <chungkai@google.com>
Date: Thu, 11 Apr 2024 08:49:06 +0000
Subject: [PATCH 0865/1487] libmodprobe: remove dummy parameters for kernel

we consume load_sequential only in libmodprobe, so remove this parameter
before sending them into kernel layer

Bug: 332435366
Test: Built and boot husky targets
Change-Id: I37e63723d3c8d4fd8ca1fda682b344a721b9a637
Signed-off-by: Chungkai Mei <chungkai@google.com>
---
 libmodprobe/libmodprobe.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index 5023c7902ad8..1a40da1226ef 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -484,7 +484,11 @@ bool Modprobe::LoadModulesParallel(int num_threads) {
                 return false;
             }
 
-            if (module_options_[cnd_last].find("load_sequential=1") != std::string::npos) {
+            std::string str = "load_sequential=1";
+            auto it = module_options_[cnd_last].find(str);
+            if (it != std::string::npos) {
+                module_options_[cnd_last].erase(it, it + str.size());
+
                 if (!LoadWithAliases(cnd_last, true)) {
                     return false;
                 }

From 455fe568b4b3907b4aad8ece0a167b0d1d209082 Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Mon, 22 Apr 2024 22:00:38 -0700
Subject: [PATCH 0866/1487] sysutils: add missing <vector> include

Upgrading to clang-r522817's new libc++ requires that <vector> be
included here.

Bug: 333165689
Test: treehugger
Flag: EXEMPT, fix build error
Change-Id: Ib9a072ddb39477b98c79879da6354557695ba350
---
 libsysutils/include/sysutils/SocketListener.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libsysutils/include/sysutils/SocketListener.h b/libsysutils/include/sysutils/SocketListener.h
index 67a691a04df2..a7fd09e8fcb2 100644
--- a/libsysutils/include/sysutils/SocketListener.h
+++ b/libsysutils/include/sysutils/SocketListener.h
@@ -19,6 +19,7 @@
 #include <pthread.h>
 
 #include <unordered_map>
+#include <vector>
 
 #include <sysutils/SocketClient.h>
 #include "SocketClientCommand.h"

From 6cdee65b8b13760535c52c482a318d6e62b4bcda Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Wed, 24 Apr 2024 14:17:20 -0700
Subject: [PATCH 0867/1487] Allow querying for fstab for a mount point with
 fstype

Test: th
Bug: 293313353
Change-Id: I8e12c465d0a3e886fcfa0cebf546b145b785c220
---
 fs_mgr/libfstab/fstab.cpp             | 8 ++++++++
 fs_mgr/libfstab/include/fstab/fstab.h | 3 +++
 2 files changed, 11 insertions(+)

diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index 6fa22fee5336..6273ee2e8653 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -849,6 +849,14 @@ std::vector<FstabEntry*> GetEntriesForMountPoint(Fstab* fstab, const std::string
                             [&path](const FstabEntry& entry) { return entry.mount_point == path; });
 }
 
+FstabEntry* GetEntryForMountPoint(Fstab* fstab, const std::string_view path,
+                                  const std::string_view fstype) {
+    auto&& vec = GetEntriesByPred(fstab, [&path, fstype](const FstabEntry& entry) {
+        return entry.mount_point == path && entry.fs_type == fstype;
+    });
+    return vec.empty() ? nullptr : vec.front();
+}
+
 std::vector<const FstabEntry*> GetEntriesForMountPoint(const Fstab* fstab,
                                                        const std::string& path) {
     return GetEntriesByPred(fstab,
diff --git a/fs_mgr/libfstab/include/fstab/fstab.h b/fs_mgr/libfstab/include/fstab/fstab.h
index 5e4019ca17ff..dea723831f8c 100644
--- a/fs_mgr/libfstab/include/fstab/fstab.h
+++ b/fs_mgr/libfstab/include/fstab/fstab.h
@@ -108,6 +108,9 @@ std::vector<FstabEntry*> GetEntriesForMountPoint(Fstab* fstab, const std::string
 FstabEntry* GetEntryForMountPoint(Fstab* fstab, const std::string& path);
 const FstabEntry* GetEntryForMountPoint(const Fstab* fstab, const std::string& path);
 
+FstabEntry* GetEntryForMountPoint(Fstab* fstab, const std::string_view path,
+                                  const std::string_view fstype);
+
 // This method builds DSU fstab entries and transfer the fstab.
 //
 // fstab points to the unmodified fstab.

From ffdb017e7d0141d09d67c735913196a8dc166671 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Fri, 19 Apr 2024 17:57:01 -0700
Subject: [PATCH 0868/1487] Load modules from _16K dir when running on 16K
 kernel

Test: th
Bug: 293313353
Change-Id: Ie58e57174545e4def5ebc33ac29f1adb12bf06a6
---
 toolbox/modprobe.cpp | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index 45dd9b8c18d9..b0e76ea81bdc 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -15,6 +15,7 @@
  */
 
 #include <ctype.h>
+#include <fcntl.h>
 #include <getopt.h>
 #include <stdlib.h>
 
@@ -27,6 +28,7 @@
 #include <modprobe/modprobe.h>
 
 #include <sys/utsname.h>
+#include <unistd.h>
 
 namespace {
 
@@ -105,6 +107,11 @@ static int KernelVersionNameFilter(const dirent* de) {
     return 0;
 }
 
+std::string GetPageSizeSuffix() {
+    static const size_t page_size = sysconf(_SC_PAGE_SIZE);
+    return android::base::StringPrintf("_%zuk", page_size / 1024);
+}
+
 }  // anonymous namespace
 
 extern "C" int modprobe_main(int argc, char** argv) {
@@ -233,6 +240,19 @@ extern "C" int modprobe_main(int argc, char** argv) {
         // Allow modules to be directly inside /lib/modules
         mod_dirs.emplace_back(LIB_MODULES_PREFIX);
     }
+    if (getpagesize() != 4096) {
+        struct utsname uts {};
+        if (uname(&uts)) {
+            PLOG(FATAL) << "Failed to get kernel version";
+        }
+        const auto module_dir = android::base::StringPrintf("/lib/modules/%s%s", uts.release,
+                                                            GetPageSizeSuffix().c_str());
+        struct stat st {};
+        if (stat(module_dir.c_str(), &st) == 0 && S_ISDIR(st.st_mode)) {
+            mod_dirs.clear();
+            mod_dirs.emplace_back(module_dir);
+        }
+    }
 
     LOG(DEBUG) << "mode is " << mode;
     LOG(DEBUG) << "mod_dirs is: " << android::base::Join(mod_dirs, " ");

From b479666e3c9c96c93a53c334c9cd881106b3bda2 Mon Sep 17 00:00:00 2001
From: "A. Cody Schuffelen" <schuffelen@google.com>
Date: Tue, 23 Apr 2024 18:59:00 -0700
Subject: [PATCH 0869/1487] ueventd: Add `devname sys_name` to `subsystem`,
 pulling device names from sysfs

This change introduces a new mode to `subsystem.devname` in `ueventd.rc`
configuration files, which sets the file name to the contents of
`/sys/DEVNAME/name`.

The objective of this change is to help Cuttlefish distinguish between
console devices, which are only different in uevents by initialization
order. Cuttlefish currently relies on `/dev/hvc##` devices which are
created for non-multiport virtio-console devices.

https://cs.android.com/android/platform/superproject/main/+/main:device/google/cuttlefish/shared/config/ueventd.rc;l=18;drc=5204f119d859d3ae5f1a2ee1c6a05ee68d6a28ed

On Cuttlefish we're considering moving to multiport virtio-console
devices ( https://fedoraproject.org/wiki/Features/VirtioSerial ). It
would be possible to rely on device order here as well, but using names
to distinguish devices makes it possible to drop unused devices in the
future, rather than reserving indexes indefinitely.

Multiport virtio-console devices create uevents with DEVNAME=vport#p#
and DEVPATH=.../vport#p#, only exposing the name in a sysfs file.

Bug: 336663898
Test: Attach multiport console, run with `-DLOG_UEVENTS=1`
Test: Introduce ueventd policy using `devname sys_name`
Change-Id: I59632b556db4a47883eab97e90c0e6ca81a9c650
---
 init/README.ueventd.md  |  5 +++--
 init/devices.h          | 17 +++++++++++++----
 init/ueventd_parser.cpp |  4 ++++
 3 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/init/README.ueventd.md b/init/README.ueventd.md
index 3c7107a4d1b8..7d00195eb56a 100644
--- a/init/README.ueventd.md
+++ b/init/README.ueventd.md
@@ -59,9 +59,10 @@ device in. The section takes the below format of
 
 `subsystem_name` is used to match uevent `SUBSYSTEM` value
 
-`devname` takes one of two options
+`devname` takes one of three options
   1. `uevent_devname` specifies that the name of the node will be the uevent `DEVNAME`
-  2. `uevent_devpath` specified that the name of the node will be basename uevent `DEVPATH`
+  2. `uevent_devpath` specifies that the name of the node will be basename uevent `DEVPATH`
+  3. `sys_name` specifies that the name of the node will be the contents of `/sys/DEVPATH/name`
 
 `dirname` is an optional parameter that specifies a directory within `/dev` where the node will be
 created.
diff --git a/init/devices.h b/init/devices.h
index f9f4d7989a50..44ce2a920c0c 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -82,6 +82,7 @@ class Subsystem {
     enum DevnameSource {
         DEVNAME_UEVENT_DEVNAME,
         DEVNAME_UEVENT_DEVPATH,
+        DEVNAME_SYS_NAME,
     };
 
     Subsystem() {}
@@ -92,10 +93,18 @@ class Subsystem {
     // Returns the full path for a uevent of a device that is a member of this subsystem,
     // according to the rules parsed from ueventd.rc
     std::string ParseDevPath(const Uevent& uevent) const {
-        std::string devname = devname_source_ == DEVNAME_UEVENT_DEVNAME
-                                      ? uevent.device_name
-                                      : android::base::Basename(uevent.path);
-
+        std::string devname;
+        if (devname_source_ == DEVNAME_UEVENT_DEVNAME) {
+            devname = uevent.device_name;
+        } else if (devname_source_ == DEVNAME_UEVENT_DEVPATH) {
+            devname = android::base::Basename(uevent.path);
+        } else if (devname_source_ == DEVNAME_SYS_NAME) {
+            if (android::base::ReadFileToString("/sys/" + uevent.path + "/name", &devname)) {
+                devname.pop_back();  // Remove terminating newline
+            } else {
+                devname = uevent.device_name;
+            }
+        }
         return dir_name_ + "/" + devname;
     }
 
diff --git a/init/ueventd_parser.cpp b/init/ueventd_parser.cpp
index d34672e245c1..4395d8838386 100644
--- a/init/ueventd_parser.cpp
+++ b/init/ueventd_parser.cpp
@@ -218,6 +218,10 @@ Result<void> SubsystemParser::ParseDevName(std::vector<std::string>&& args) {
         subsystem_.devname_source_ = Subsystem::DEVNAME_UEVENT_DEVPATH;
         return {};
     }
+    if (args[1] == "sys_name") {
+        subsystem_.devname_source_ = Subsystem::DEVNAME_SYS_NAME;
+        return {};
+    }
 
     return Error() << "invalid devname '" << args[1] << "'";
 }

From 188b64778c6949bfd389ea3a2c90944bbcf106e2 Mon Sep 17 00:00:00 2001
From: William Loh <wloh@google.com>
Date: Wed, 24 Apr 2024 00:06:01 +0000
Subject: [PATCH 0870/1487] Create app-metadata directory

App metadata bundles, also known as Android Safety Labels (ASL),
contains information about the app's privacy and security practices.
This information is used to help users make more informed choices when,
for example, granting access to permissions.

ASL can currently only be preloaded on the system image or distributed
by the installer and written to a file in the app's codePath. To support
embedded ASL in APK we need to extract ASLs from APKs to a writeable
location. For non-preloaded apps we can write to the app's codePath like
the installer provided ASLs, however, we need to create a new writable
directory for preloaded apps located on read only partitions.

Bug: 336618214
Test: manual
Change-Id: I651b2dab45c3132d8467c507dc4ee304001f73f5
---
 rootdir/init.rc | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index e3896b1b27fd..2a3e22e6cae2 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -870,6 +870,9 @@ on post-fs-data
     mkdir /data/app-lib 0771 system system encryption=Require
     mkdir /data/app 0771 system system encryption=Require
 
+    # Create directory for app metadata files
+    mkdir /data/app-metadata 0700 system system encryption=Require
+
     # create directory for updated font files.
     mkdir /data/fonts/ 0771 root root encryption=Require
     mkdir /data/fonts/files 0771 system system

From c76a8937b02f72b4327b4a2bb316051af4418d49 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Wed, 10 Apr 2024 14:18:35 -0700
Subject: [PATCH 0871/1487] Make sure debuggerd_test is run on device.

Tests starting failing on aarch64, so force presubmit to run the
debuggerd tests on device to close this coverage hole.

Test: Treehugger and verify tests are run on device.
Change-Id: Ie40eab35e46cefd3cebc132d9c0a3d1ebdb0d766
---
 debuggerd/TEST_MAPPING | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/debuggerd/TEST_MAPPING b/debuggerd/TEST_MAPPING
index 61d71550ca2e..824d20a5a8b8 100644
--- a/debuggerd/TEST_MAPPING
+++ b/debuggerd/TEST_MAPPING
@@ -3,6 +3,10 @@
     {
       "name": "debuggerd_test"
     },
+    {
+      "name": "debuggerd_test",
+      "keywords": ["primary-device"]
+    },
     {
       "name": "libtombstoned_client_rust_test"
     },

From 6e774bae19bc8d92e1cb714237df43287eaba00d Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 26 Apr 2024 15:30:30 +0000
Subject: [PATCH 0872/1487] parse_line: allow -1 for apexes and sdk libraries.

Since we're in much worse trouble if `/data/system/packages.list` is
attacker-controlled, there doesn't seem like much benefit to having
the little bit of [incomplete] range checking we had on the uid
field (by using a wider type than `uid_t` actually is), and
apparently we're now abusing `-1` to mean "apex or sdk library",
despite `uid_t` being an unsigned type.

Bug: http://b/336659478
Change-Id: I7a270eea937d21fc1d7fcda8654054210cf631fe
---
 .../packagelistparser/packagelistparser.h        |  5 ++++-
 libpackagelistparser/packagelistparser.cpp       | 16 ++++------------
 2 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/libpackagelistparser/include/packagelistparser/packagelistparser.h b/libpackagelistparser/include/packagelistparser/packagelistparser.h
index e89cb5400db5..9bd212af3b08 100644
--- a/libpackagelistparser/include/packagelistparser/packagelistparser.h
+++ b/libpackagelistparser/include/packagelistparser/packagelistparser.h
@@ -33,7 +33,10 @@ typedef struct pkg_info {
   /** Package name like "com.android.blah". */
   char* name;
 
-  /** Package uid like 10014. */
+  /**
+   * Package uid like 10014.
+   * Note that apexes and SDK libraries may have a bogus 0xffffffff value.
+   */
   uid_t uid;
 
   /** Package's AndroidManifest.xml debuggable flag. */
diff --git a/libpackagelistparser/packagelistparser.cpp b/libpackagelistparser/packagelistparser.cpp
index 59c3a7491a45..638cc43fe9cb 100644
--- a/libpackagelistparser/packagelistparser.cpp
+++ b/libpackagelistparser/packagelistparser.cpp
@@ -63,14 +63,13 @@ static bool parse_gids(const char* path, size_t line_number, const char* gids, p
 }
 
 static bool parse_line(const char* path, size_t line_number, const char* line, pkg_info* info) {
-  unsigned long uid;
   int debuggable;
   char* gid_list;
   int profileable_from_shell = 0;
-
   int fields =
-      sscanf(line, "%ms %lu %d %ms %ms %ms %d %ld", &info->name, &uid, &debuggable, &info->data_dir,
-             &info->seinfo, &gid_list, &profileable_from_shell, &info->version_code);
+      sscanf(line, "%ms %u %d %ms %ms %ms %d %ld", &info->name, &info->uid,
+             &debuggable, &info->data_dir, &info->seinfo, &gid_list,
+             &profileable_from_shell, &info->version_code);
 
   // Handle the more complicated gids field and free the temporary string.
   bool gids_okay = parse_gids(path, line_number, gid_list, info);
@@ -84,14 +83,7 @@ static bool parse_line(const char* path, size_t line_number, const char* line, p
     return false;
   }
 
-  // Extra validation.
-  if (uid > UID_MAX) {
-    ALOGE("%s:%zu: uid %lu > UID_MAX", path, line_number, uid);
-    return false;
-  }
-  info->uid = uid;
-
-  // Integer to bool conversions.
+  // Convert integers to bools.
   info->debuggable = debuggable;
   info->profileable_from_shell = profileable_from_shell;
 

From 1c46a008651f39caf32a08e1a72f6f0c3968012d Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Tue, 23 Apr 2024 17:24:26 -0700
Subject: [PATCH 0873/1487] Replace malloc_not_svelte with malloc_low_memory.

The malloc_not_svelte variable name is confusing and makes the
low memory config the default. Change this so that the default is
the regular allocator, and that Malloc_low_memory is used to enable
the low memory allocator.

Update blueprint rules so that scudo is the default action.

Test: Verified scudo config is used by default.
Test: Verfified Android GO config uses the jemalloc low memory config.
Change-Id: Ie7b4b005a6377e2a031bbae979d66b50c8b3bcdb
---
 debuggerd/Android.bp                              | 15 ++++++++++-----
 .../libdebuggerd/include/libdebuggerd/scudo.h     |  4 ++++
 debuggerd/libdebuggerd/scudo.cpp                  |  4 ++++
 3 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 2529516da626..3a882ea8f41f 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -240,11 +240,16 @@ cc_library_static {
         "libdebuggerd/backtrace.cpp",
         "libdebuggerd/gwp_asan.cpp",
         "libdebuggerd/open_files_list.cpp",
+        "libdebuggerd/scudo.cpp",
         "libdebuggerd/tombstone.cpp",
         "libdebuggerd/tombstone_proto.cpp",
         "libdebuggerd/utility.cpp",
     ],
 
+    cflags: [
+        "-DUSE_SCUDO",
+    ],
+
     local_include_dirs: ["libdebuggerd/include"],
     export_include_dirs: ["libdebuggerd/include"],
 
@@ -256,6 +261,7 @@ cc_library_static {
         "bionic_libc_platform_headers",
         "gwp_asan_headers",
         "liblog_headers",
+        "scudo_headers",
     ],
 
     static_libs: [
@@ -273,6 +279,7 @@ cc_library_static {
         "libtombstone_proto",
         "libprocinfo",
         "libprotobuf-cpp-lite",
+        "libscudo",
     ],
 
     target: {
@@ -312,11 +319,9 @@ cc_library_static {
             cflags: ["-DROOT_POSSIBLE"],
         },
 
-        malloc_not_svelte: {
-            cflags: ["-DUSE_SCUDO"],
-            whole_static_libs: ["libscudo"],
-            srcs: ["libdebuggerd/scudo.cpp"],
-            header_libs: ["scudo_headers"],
+        malloc_low_memory: {
+            cflags: ["-UUSE_SCUDO"],
+            exclude_static_libs: ["libscudo"],
         },
     },
     apex_available: [
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/scudo.h b/debuggerd/libdebuggerd/include/libdebuggerd/scudo.h
index a506859a4211..89bf5a96da74 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/scudo.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/scudo.h
@@ -16,6 +16,8 @@
 
 #pragma once
 
+#if defined(USE_SCUDO)
+
 #include "types.h"
 #include "utility.h"
 
@@ -49,3 +51,5 @@ class ScudoCrashData {
   void FillInCause(Cause* cause, const scudo_error_report* report,
                    unwindstack::AndroidUnwinder* unwinder) const;
 };
+
+#endif  // USE_SCUDO
diff --git a/debuggerd/libdebuggerd/scudo.cpp b/debuggerd/libdebuggerd/scudo.cpp
index 3fa3bd032585..4ee87c841ccb 100644
--- a/debuggerd/libdebuggerd/scudo.cpp
+++ b/debuggerd/libdebuggerd/scudo.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#if defined(USE_SCUDO)
+
 #include "libdebuggerd/scudo.h"
 #include "libdebuggerd/tombstone.h"
 
@@ -141,3 +143,5 @@ void ScudoCrashData::AddCauseProtos(Tombstone* tombstone,
     FillInCause(tombstone->add_causes(), &error_info_.reports[report_num++], unwinder);
   }
 }
+
+#endif  // USE_SCUDO

From 38d36e44927d56f45042fb5e11a342a3a7dd5daa Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Fri, 26 Apr 2024 21:08:48 +0000
Subject: [PATCH 0874/1487] libutils: T* is a trivial type

Avoid calling constructors/destructors for
each element, when we have Vector<T*>. These
are used in libbinder and elsewhere.

std::vector is still faster but uses more mem.

Bugs: me
Test: boot && binderLibTest
Change-Id: Id1239daddd018f8eee5480d1cb6dd25d6f4df808
---
 libutils/binder/include/utils/TypeHelpers.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/libutils/binder/include/utils/TypeHelpers.h b/libutils/binder/include/utils/TypeHelpers.h
index 1554f52ee176..21d9b3db1090 100644
--- a/libutils/binder/include/utils/TypeHelpers.h
+++ b/libutils/binder/include/utils/TypeHelpers.h
@@ -109,6 +109,11 @@ ANDROID_BASIC_TYPES_TRAITS( unsigned long long )
 ANDROID_BASIC_TYPES_TRAITS( float )
 ANDROID_BASIC_TYPES_TRAITS( double )
 
+template<typename T> struct trait_trivial_ctor<T*>   { enum { value = true }; };
+template<typename T> struct trait_trivial_dtor<T*>   { enum { value = true }; };
+template<typename T> struct trait_trivial_copy<T*>   { enum { value = true }; };
+template<typename T> struct trait_trivial_move<T*>   { enum { value = true }; };
+
 // ---------------------------------------------------------------------------
 
 

From c2eaac5ed29aaeca42a7a6ab734c1dbd978dc9e7 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Wed, 27 Mar 2024 14:30:13 -0700
Subject: [PATCH 0875/1487] [MTE] disable memtag stack in early init

when introducing instrumentation for MTE stack history buffer, we cannot
use stack MTE in early init

Bug: 309446520
Change-Id: I0921ae4ffe03ed971697f8daff4215c9b3772e35
---
 init/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/init/Android.bp b/init/Android.bp
index 6d63e41e2164..4332e03bb6b6 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -452,6 +452,7 @@ init_first_stage_cc_defaults {
 
         // First stage init is weird: it may start without stdout/stderr, and no /proc.
         hwaddress: false,
+        memtag_stack: false,
     },
 
     // Install adb_debug.prop into debug ramdisk.

From fff3c9298589432de1215514836b974d7cd6f6df Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 29 Apr 2024 16:39:01 +0000
Subject: [PATCH 0876/1487] Update shell_and_utilities for V.

Change-Id: Ia617ba0e2b056b3b620400cb5e78445f810c388a
---
 shell_and_utilities/README.md | 67 +++++++++++++++++++++++++++--------
 1 file changed, 53 insertions(+), 14 deletions(-)

diff --git a/shell_and_utilities/README.md b/shell_and_utilities/README.md
index 9a733bb4b203..c7c622ec7da7 100644
--- a/shell_and_utilities/README.md
+++ b/shell_and_utilities/README.md
@@ -37,7 +37,46 @@ commands than there are symlinks for in `/system/bin`. You can get the
 full list for a release by running `toybox` directly.
 
 
-## Android 14 ("U")
+## Android 15 (API level 35, "Vanilla Ice Cream")
+
+BSD: fsck\_msdos newfs\_msdos
+
+bzip2: bzcat bzip2 bunzip2
+
+gavinhoward/bc: bc
+
+one-true-awk: awk
+
+toolbox: getevent getprop setprop start stop
+
+toybox ([0.8.11](https://landley.net/toybox/news.html#08-04-2024)-ish):
+[ acpi base64 basename blkdiscard blkid blockdev brctl cal cat chattr
+chcon chgrp chmod chown chroot chrt cksum clear cmp comm cp cpio cut
+date dd devmem df diff dirname dmesg dos2unix du echo egrep env expand
+expr fallocate false fgrep file find flock fmt free freeramdisk fsfreeze
+fsync getconf getenforce **getfattr** getopt **gpiodetect** **gpiofind**
+**gpioget** **gpioinfo** **gpioset** grep groups gunzip gzip head help hostname
+hwclock i2cdetect i2cdump i2cget i2cset **i2ctransfer** iconv id ifconfig
+inotifyd insmod install ionice iorenice iotop kill killall ln load\_policy
+log logger logname losetup ls lsattr lsmod lsof lspci lsusb makedevs
+md5sum **memeater** microcom mkdir mkfifo mknod mkswap mktemp modinfo modprobe
+more mount mountpoint mv nbd-client nc netcat netstat nice nl nohup
+nproc nsenter od partprobe paste patch pgrep pidof ping ping6 pivot\_root
+pkill pmap printenv printf prlimit ps pwd pwdx readelf readlink realpath
+renice restorecon rev rfkill rm rmdir rmmod rtcwake runcon sed sendevent
+seq setenforce **setfattr** setsid sha1sum sha224sum sha256sum sha384sum
+sha512sum sleep sort split stat strings stty swapoff swapon sync sysctl
+tac tail tar taskset tee test time timeout top touch tr traceroute
+traceroute6 true truncate tty tunctl uclampset ulimit umount uname
+uniq unix2dos unlink unshare uptime usleep uudecode uuencode uuidgen
+vconfig vi vmstat watch wc which whoami xargs xxd yes zcat
+
+Note: technically getfattr and setfattr were available in earlier versions,
+but the symlinks were missing until this release, so they were only available
+as `toybox getfattr` and `toybox setfattr` rather than directly.
+
+
+## Android 14 (API level 34, "Upside Down Cake")
 
 BSD: fsck\_msdos newfs\_msdos
 
@@ -71,7 +110,7 @@ uniq unix2dos unlink unshare uptime usleep uudecode uuencode uuidgen
 vconfig vi vmstat watch wc which whoami xargs xxd yes zcat
 
 
-## Android 13 ("T")
+## Android 13 (33, "Tiramisu")
 
 BSD: fsck\_msdos newfs\_msdos
 
@@ -105,7 +144,7 @@ uniq unix2dos unlink unshare uptime usleep uudecode uuencode uuidgen
 vconfig vi vmstat watch wc which whoami xargs xxd yes zcat
 
 
-## Android 12 ("S")
+## Android 12 (31, "Snow Cone")
 
 BSD: fsck\_msdos newfs\_msdos
 
@@ -139,7 +178,7 @@ unlink unshare uptime usleep uudecode uuencode uuidgen vconfig vi
 vmstat watch wc which whoami xargs xxd yes zcat
 
 
-## Android 11 ("R")
+## Android 11 (API level 30, "Red Velvet Cake")
 
 BSD: fsck\_msdos newfs\_msdos
 
@@ -173,7 +212,7 @@ usleep uudecode uuencode uuidgen vconfig **vi** vmstat watch wc which
 whoami xargs xxd yes zcat
 
 
-## Android 10 ("Q")
+## Android 10 (API level 29, "Quince Tart")
 
 BSD: grep fsck\_msdos newfs\_msdos
 
@@ -205,7 +244,7 @@ true truncate tty **tunctl** ulimit umount uname uniq unix2dos **unlink**
 wc which whoami xargs xxd yes zcat
 
 
-## Android 9.0 (Pie)
+## Android 9.0 (API level 28, "Pie")
 
 BSD: dd grep
 
@@ -232,7 +271,7 @@ umount uname uniq unix2dos uptime usleep uudecode uuencode vmstat wc
 which whoami xargs xxd yes zcat
 
 
-## Android 8.0 (Oreo)
+## Android 8.0 (API level 26, "Oreo")
 
 BSD: dd grep
 
@@ -257,7 +296,7 @@ tty ulimit umount uname uniq unix2dos uptime usleep **uudecode** **uuencode**
 vmstat wc which whoami xargs xxd yes **zcat**
 
 
-## Android 7.0 (Nougat)
+## Android 7.0 (API level 24, "Nougat")
 
 BSD: dd grep
 
@@ -279,7 +318,7 @@ time timeout touch tr true truncate **tty** **ulimit** umount uname uniq unix2do
 **uptime** usleep vmstat wc which whoami xargs **xxd** yes
 
 
-## Android 6.0 (Marshmallow)
+## Android 6.0 (API level 23, "Marshmallow")
 
 BSD: dd du grep
 
@@ -300,7 +339,7 @@ time timeout touch tr true truncate umount uname uniq unix2dos usleep
 vmstat wc which whoami xargs yes
 
 
-## Android 5.0 (Lollipop)
+## Android 5.0 (API level 21, "Lollipop")
 
 BSD: cat chown cp dd du grep kill ln mv printenv rm rmdir sleep sync
 
@@ -312,7 +351,7 @@ sendevent setenforce setprop setsebool smd start stop swapoff swapon
 top touch umount uptime vmstat watchprops wipe
 
 
-## Android 4.4 (KitKat)
+## Android 4.4 (API level 19, "KitKat")
 
 BSD: cat cp dd du grep newfs\_msdos
 
@@ -324,7 +363,7 @@ schedtop sendevent setconsole setenforce setprop setsebool sleep smd start
 stop swapoff swapon sync top touch umount uptime vmstat watchprops wipe
 
 
-## Android 4.1-4.3 (JellyBean)
+## Android 4.1-4.3 (API level 16, "Jelly Bean")
 
 BSD: cat cp dd du grep newfs\_msdos
 
@@ -336,7 +375,7 @@ sendevent setconsole setenforce setprop setsebool sleep smd start stop
 sync top touch umount uptime vmstat watchprops wipe
 
 
-## Android 4.0 (IceCreamSandwich)
+## Android 4.0 (API level 14, "Ice Cream Sandwich")
 
 BSD: cat dd newfs\_msdos
 
@@ -347,7 +386,7 @@ schedtop sendevent setconsole setprop sleep smd start stop sync top
 touch umount uptime vmstat watchprops wipe
 
 
-## Android 2.3 (Gingerbread)
+## Android 2.3 (API level 9, "Gingerbread")
 
 BSD: cat dd newfs\_msdos
 

From c0659f0107014651f24d7d14cc8ce301e6a0467d Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Tue, 30 Apr 2024 10:43:45 +0900
Subject: [PATCH 0877/1487] libvendorsupport provides an API to replace vndk
 version

ro.vndk.version cannot be simply replaced with ro.board.api_level with
the vndk deprecation. Even with the latest system updates, devices may
still run on old vendor images that do not define ro.board.api_level,
but define ro.vndk.version.
To provide the replacement of ro.vndk.version, provide a platform API
AVendorSupport_getVendorApiLevel() to return the expected vendor
version.

Bug: 312311458
Bug: 312315580
Test: manual test for AVendorSupport_getVendorApiLevel()
Change-Id: Id7c04483956d95fd49414cebde41d7cc4d2fb1d1
---
 libvendorsupport/Android.bp                    |  3 ++-
 .../include/vendorsupport/api_level.h          | 18 ++++++++++++++++++
 .../{version_props.c => version_props.cpp}     | 14 ++++++++++++++
 3 files changed, 34 insertions(+), 1 deletion(-)
 rename libvendorsupport/{version_props.c => version_props.cpp} (79%)

diff --git a/libvendorsupport/Android.bp b/libvendorsupport/Android.bp
index e87959ec4e57..a22737c06967 100644
--- a/libvendorsupport/Android.bp
+++ b/libvendorsupport/Android.bp
@@ -23,7 +23,7 @@ cc_library {
     llndk: {
         symbol_file: "libvendorsupport.map.txt",
     },
-    srcs: ["version_props.c"],
+    srcs: ["version_props.cpp"],
     cflags: [
         "-Wall",
         "-Werror",
@@ -32,6 +32,7 @@ cc_library {
     export_include_dirs: ["include"],
     shared_libs: [
         "liblog",
+        "libbase",
     ],
 }
 
diff --git a/libvendorsupport/include/vendorsupport/api_level.h b/libvendorsupport/include/vendorsupport/api_level.h
index d365075e0431..3427bc614626 100644
--- a/libvendorsupport/include/vendorsupport/api_level.h
+++ b/libvendorsupport/include/vendorsupport/api_level.h
@@ -44,4 +44,22 @@ int AVendorSupport_getVendorApiLevelOf(int sdkApiLevel);
  */
 int AVendorSupport_getSdkApiLevelOf(int vendorApiLevel);
 
+#if !defined(__ANDROID_VENDOR__)
+/**
+ * @brief Provide vendor API level to system modules.
+ *
+ * @details
+ * Before deprecating VNDK, system modules read ro.vndk.version to find the
+ * API level that vendor image had implemented. With the VNDK deprecation, this
+ * must be replaced with ro.board.api_level. However, there still are devices
+ * keeping old vendor partitions with the new system upgraded. In this case, the
+ * VNDK version can be used as before.
+ * This API is for platform only.
+ *
+ * @return ro.vndk.version if exist. Otherwise fallback to ro.board.api_level.
+ * 0 if none of these properties are found. This is unexpected, though.
+ */
+int AVendorSupport_getVendorApiLevel();
+#endif  // __ANDROID_VENDOR__
+
 __END_DECLS
diff --git a/libvendorsupport/version_props.c b/libvendorsupport/version_props.cpp
similarity index 79%
rename from libvendorsupport/version_props.c
rename to libvendorsupport/version_props.cpp
index 835828c0ac82..ecba8999101d 100644
--- a/libvendorsupport/version_props.c
+++ b/libvendorsupport/version_props.cpp
@@ -16,6 +16,10 @@
 
 #include <log/log.h>
 
+#if !defined(__ANDROID_VENDOR__)
+#include <android-base/properties.h>
+#endif
+
 int AVendorSupport_getVendorApiLevelOf(int sdkApiLevel) {
     if (sdkApiLevel < __ANDROID_API_V__) {
         return sdkApiLevel;
@@ -39,3 +43,13 @@ int AVendorSupport_getSdkApiLevelOf(int vendorApiLevel) {
     ALOGE("Unexpected vendor api level: %d", vendorApiLevel);
     return __INVALID_API_LEVEL;
 }
+
+#if !defined(__ANDROID_VENDOR__)
+int AVendorSupport_getVendorApiLevel() {
+    int vendorApiLevel = android::base::GetIntProperty("ro.vndk.version", 0);
+    if (vendorApiLevel) {
+        return vendorApiLevel;
+    }
+    return android::base::GetIntProperty("ro.board.api_level", 0);
+}
+#endif  // __ANDROID_VENDOR__

From 7bfbe4171491c24d3eac8ba55e2cfeba8310cb44 Mon Sep 17 00:00:00 2001
From: Xiaohui Niu <quic_xiaohuin@quicinc.com>
Date: Fri, 26 Apr 2024 11:08:15 +0800
Subject: [PATCH 0878/1487] Fix fallback signal issue.

Add signo for target thread in fallback path;
Update test for seccomp tombstone thread abort.

Bug: 336946834

Test: debuggerd_test
Test: Send fatal signal to process with NO_NEW_PRIVS
Change-Id: Ie9d77a93da9cd89ab7093b8949f311e03d96ec50
---
 debuggerd/debuggerd_test.cpp         | 3 +++
 debuggerd/libdebuggerd/tombstone.cpp | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 7c52e6e50de9..e4e2f99cc28c 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -1667,6 +1667,9 @@ TEST_F(CrasherTest, seccomp_tombstone_thread_abort) {
 
   std::string result;
   ConsumeFd(std::move(output_fd), &result);
+  ASSERT_MATCH(
+      result,
+      R"(signal 6 \(SIGABRT\))");
   ASSERT_BACKTRACE_FRAME(result, "abort");
 }
 
diff --git a/debuggerd/libdebuggerd/tombstone.cpp b/debuggerd/libdebuggerd/tombstone.cpp
index 375ed8a2cccc..5a416d64319a 100644
--- a/debuggerd/libdebuggerd/tombstone.cpp
+++ b/debuggerd/libdebuggerd/tombstone.cpp
@@ -76,7 +76,7 @@ void engrave_tombstone_ucontext(int tombstone_fd, int proto_fd, uint64_t abort_m
   threads[target_tid] = ThreadInfo {
     .registers = std::move(regs), .uid = uid, .tid = target_tid,
     .thread_name = std::move(thread_name), .pid = pid, .command_line = std::move(command_line),
-    .selinux_label = std::move(selinux_label), .siginfo = siginfo,
+    .selinux_label = std::move(selinux_label), .siginfo = siginfo, .signo = siginfo->si_signo,
     // Only supported on aarch64 for now.
 #if defined(__aarch64__)
     .tagged_addr_ctrl = prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0),

From 030dd05027f1f6cde06449e0aae25c1f3eb937f5 Mon Sep 17 00:00:00 2001
From: Snehal <snehalreddy@google.com>
Date: Tue, 30 Apr 2024 14:31:14 +0000
Subject: [PATCH 0879/1487] [Coverage] Fix coverage bug in which extra garbage
 is being written

Bug: 296356127

Change-Id: I2e4128af461b297bbe170c015dc52899089e9b8b
---
 trusty/line-coverage/coverage.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/line-coverage/coverage.cpp b/trusty/line-coverage/coverage.cpp
index 5f7b3a3f65bb..e4db59ca72c5 100644
--- a/trusty/line-coverage/coverage.cpp
+++ b/trusty/line-coverage/coverage.cpp
@@ -174,7 +174,7 @@ Result<void> CoverageRecord::SaveFile(const std::string& filename) {
     }
 
     uintptr_t* begin = (uintptr_t*)((char *)shm_ + sizeof(struct control));
-    bool ret = WriteFully(output_fd, begin, record_len_);
+    bool ret = WriteFully(output_fd, begin, record_len_ - sizeof(struct control));
     if(!ret) {
         fprintf(stderr, "Coverage write to file failed\n");
     }

From c9d44b84fef800f5edb6225b1dd20420b38d4037 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 30 Apr 2024 20:20:43 +0000
Subject: [PATCH 0880/1487] Don't reject "ctl.stop.*" during shutdown.

We're shutting down anyway, so the service is either dead already
or about to be killed, and callers get upset (and don't have a good
response themselves) if we reject the request.

This was seen by a partner where adbd was asked to stop during
shutdown.

Bug: https://issuetracker.google.com/336223505
Change-Id: If09feeef2e0f2d1be9ff84a88cca6ed593a35362
---
 init/property_service.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index 5a1b63b2e49a..d02ca1e497e6 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -453,6 +453,10 @@ static uint32_t SendControlMessage(const std::string& msg, const std::string& na
                                    SocketConnection* socket, std::string* error) {
     auto lock = std::lock_guard{accept_messages_lock};
     if (!accept_messages) {
+        // If we're already shutting down and you're asking us to stop something,
+        // just say we did (https://issuetracker.google.com/336223505).
+        if (msg == "stop") return PROP_SUCCESS;
+
         *error = "Received control message after shutdown, ignoring";
         return PROP_ERROR_HANDLE_CONTROL_MESSAGE;
     }

From b33025849de1766770636d799779d404b103a933 Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Wed, 1 May 2024 16:16:42 +0900
Subject: [PATCH 0881/1487] Use no_full_install: true instead of installable:
 false

So far, we have used `instalable: false` to avoid collision with the
other modules that are installed to the same path. A typical example was
<foo> and <foo>.microdroid. The latter is a modified version of the
former for the inclusion of the microdroid image. They however both have
the same instalation path (ex: system/bin) and stem (ex: foo) so that we
can reference them using the same path regardless of whether we are in
Android or microdroid.

However, the use of `installable: false` for the purpose is actually
incorrect, because `installable: false` also means, obviously, "this
module shouldn't be installed". The only reason this incorrect way has
worked is simply because packaging modules (ex: android_filesystem)
didn't respect the property when gathering the modules.

As packaging modules are now fixed to respect `installable: false`, we
need a correct way of avoiding the collision. `no_full_install: true` is
it.

If a module has this property set to true, it is never installed to the
full instal path like out/target/product/<partition>/... It can be
installed only via packaging modules.

Bug: 338160898
Test: m
Change-Id: I37380c19232f2c497bdf492a83cdc16616f0ae8d
---
 init/Android.bp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index 4322f627cd79..dd1f9aa3d0d2 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -330,7 +330,7 @@ cc_binary {
     recovery_available: false,
     static_libs: ["libinit.microdroid"],
     cflags: ["-DMICRODROID=1"],
-    installable: false,
+    no_full_install: true,
     visibility: ["//packages/modules/Virtualization/microdroid"],
 }
 
@@ -480,7 +480,7 @@ cc_binary {
         "init_first_stage_defaults",
     ],
     cflags: ["-DMICRODROID=1"],
-    installable: false,
+    no_full_install: true,
 }
 
 phony {

From 6d8304aa469b76d487e027cb1cf7ea1e18784dbc Mon Sep 17 00:00:00 2001
From: Nate Myren <ntmyren@google.com>
Date: Wed, 1 May 2024 19:19:53 +0000
Subject: [PATCH 0882/1487] Revert "Only write appcompat properties if flag is
 defined"

Revert submission 3049635-cherrypicker-L52500030003287943:N44300030053199935

Reason for revert: b/338244859
Bug: 338244859

Reverted changes: /q/submissionid:3049635-cherrypicker-L52500030003287943:N44300030053199935

Change-Id: I4b99429ce5df0af30e6ad99d3463d4dc2c96c012
---
 init/Android.bp           | 4 ----
 init/property_service.cpp | 2 --
 2 files changed, 6 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index c4e74d068b0d..6d63e41e2164 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -96,7 +96,6 @@ soong_config_module_type {
     config_namespace: "ANDROID",
     bool_variables: [
         "PRODUCT_INSTALL_DEBUG_POLICY_TO_SYSTEM_EXT",
-        "release_write_appcompat_override_system_properties",
     ],
     properties: [
         "cflags",
@@ -160,9 +159,6 @@ libinit_cc_defaults {
                 "-DINSTALL_DEBUG_POLICY_TO_SYSTEM_EXT=1",
             ],
         },
-        release_write_appcompat_override_system_properties: {
-            cflags: ["-DWRITE_APPCOMPAT_OVERRIDE_SYSTEM_PROPERTIES"],
-        }
     },
     static_libs: [
         "libavb",
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 5a1b63b2e49a..58a0a7faa05d 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1308,14 +1308,12 @@ void CreateSerializedPropertyInfo() {
     }
     selinux_android_restorecon(PROP_TREE_FILE, 0);
 
-#ifdef WRITE_APPCOMPAT_OVERRIDE_SYSTEM_PROPERTIES
     mkdir(APPCOMPAT_OVERRIDE_PROP_FOLDERNAME, S_IRWXU | S_IXGRP | S_IXOTH);
     if (!WriteStringToFile(serialized_contexts, APPCOMPAT_OVERRIDE_PROP_TREE_FILE, 0444, 0, 0,
                            false)) {
         PLOG(ERROR) << "Unable to write appcompat override property infos to file";
     }
     selinux_android_restorecon(APPCOMPAT_OVERRIDE_PROP_TREE_FILE, 0);
-#endif
 }
 
 static void ExportKernelBootProps() {

From d18649eab31dc8d2ffb6e6935c118319f90dc9f7 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <jaegeuk@google.com>
Date: Fri, 19 Apr 2024 17:10:04 -0700
Subject: [PATCH 0883/1487] Add device= in Fstab

This adds a raw partition to /data.

Bug: 336319772
Change-Id: Iaae51452be621a15ccd9c2530dae44f4c8714b2f
Signed-off-by: Jaegeuk Kim <jaegeuk@google.com>
---
 fs_mgr/fs_mgr.cpp                     | 13 +++++++---
 fs_mgr/fs_mgr_format.cpp              | 21 ++++++++++------
 fs_mgr/libfstab/fstab.cpp             | 36 +++++++++++++++++++--------
 fs_mgr/libfstab/include/fstab/fstab.h |  3 ++-
 4 files changed, 51 insertions(+), 22 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 8c0c1efe3ac8..835a3e7f6758 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -40,6 +40,7 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <numeric>
 #include <string>
 #include <string_view>
 #include <thread>
@@ -1553,7 +1554,9 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                     fs_mgr_set_blk_ro(attempted_entry.blk_device, false);
                     if (!call_vdc({"cryptfs", "encryptFstab", attempted_entry.blk_device,
                                    attempted_entry.mount_point, wiped ? "true" : "false",
-                                   attempted_entry.fs_type, attempted_entry.zoned_device},
+                                   attempted_entry.fs_type,
+                                   attempted_entry.fs_mgr_flags.is_zoned ? "true" : "false",
+                                   android::base::Join(attempted_entry.user_devices, ' ')},
                                   nullptr)) {
                         LERROR << "Encryption failed";
                         set_type_property(encryptable);
@@ -1596,7 +1599,9 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
 
                 if (!call_vdc({"cryptfs", "encryptFstab", current_entry.blk_device,
                                current_entry.mount_point, "true" /* shouldFormat */,
-                               current_entry.fs_type, current_entry.zoned_device},
+                               current_entry.fs_type,
+                               current_entry.fs_mgr_flags.is_zoned ? "true" : "false",
+                               android::base::Join(current_entry.user_devices, ' ')},
                               nullptr)) {
                     LERROR << "Encryption failed";
                 } else {
@@ -1621,7 +1626,9 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
         if (mount_errno != EBUSY && mount_errno != EACCES &&
             should_use_metadata_encryption(attempted_entry)) {
             if (!call_vdc({"cryptfs", "mountFstab", attempted_entry.blk_device,
-                           attempted_entry.mount_point, attempted_entry.zoned_device},
+                           attempted_entry.mount_point,
+                           current_entry.fs_mgr_flags.is_zoned ? "true" : "false",
+                           android::base::Join(current_entry.user_devices, ' ')},
                           nullptr)) {
                 ++error_count;
             } else if (current_entry.mount_point == "/data") {
diff --git a/fs_mgr/fs_mgr_format.cpp b/fs_mgr/fs_mgr_format.cpp
index 8e7615010605..0dde1d3748df 100644
--- a/fs_mgr/fs_mgr_format.cpp
+++ b/fs_mgr/fs_mgr_format.cpp
@@ -125,7 +125,8 @@ static int format_ext4(const std::string& fs_blkdev, const std::string& fs_mnt_p
 }
 
 static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool needs_projid,
-                       bool needs_casefold, bool fs_compress, const std::string& zoned_device) {
+                       bool needs_casefold, bool fs_compress, bool is_zoned,
+                       const std::vector<std::string>& user_devices) {
     if (!dev_sz) {
         int rc = get_dev_sz(fs_blkdev, &dev_sz);
         if (rc) {
@@ -159,16 +160,21 @@ static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool needs
     args.push_back(block_size.c_str());
     args.push_back("-b");
     args.push_back(block_size.c_str());
-    if (!zoned_device.empty()) {
-        args.push_back("-c");
-        args.push_back(zoned_device.c_str());
+
+    if (is_zoned) {
         args.push_back("-m");
+    }
+    for (auto& device : user_devices) {
+        args.push_back("-c");
+        args.push_back(device.c_str());
+    }
+
+    if (user_devices.empty()) {
         args.push_back(fs_blkdev.c_str());
+        args.push_back(size_str.c_str());
     } else {
         args.push_back(fs_blkdev.c_str());
-        args.push_back(size_str.c_str());
     }
-
     return logwrap_fork_execvp(args.size(), args.data(), nullptr, false, LOG_KLOG, false, nullptr);
 }
 
@@ -184,7 +190,8 @@ int fs_mgr_do_format(const FstabEntry& entry) {
 
     if (entry.fs_type == "f2fs") {
         return format_f2fs(entry.blk_device, entry.length, needs_projid, needs_casefold,
-                           entry.fs_mgr_flags.fs_compress, entry.zoned_device);
+                           entry.fs_mgr_flags.fs_compress, entry.fs_mgr_flags.is_zoned,
+                           entry.user_devices);
     } else if (entry.fs_type == "ext4") {
         return format_ext4(entry.blk_device, entry.mount_point, needs_projid,
                            entry.fs_mgr_flags.ext_meta_csum);
diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index 6fa22fee5336..57157effd1a8 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -147,6 +147,29 @@ void ParseMountFlags(const std::string& flags, FstabEntry* entry) {
     entry->fs_options = std::move(fs_options);
 }
 
+void ParseUserDevices(const std::string& arg, FstabEntry* entry) {
+    auto param = Split(arg, ":");
+    if (param.size() != 2) {
+        LWARNING << "Warning: device= malformed: " << arg;
+        return;
+    }
+
+    if (access(param[1].c_str(), F_OK) != 0) {
+        LWARNING << "Warning: device does not exist : " << param[1];
+        return;
+    }
+
+    if (param[0] == "zoned") {
+        // atgc in f2fs does not support a zoned device
+        auto options = Split(entry->fs_options, ",");
+        options.erase(std::remove(options.begin(), options.end(), "atgc"), options.end());
+        entry->fs_options = android::base::Join(options, ",");
+        LINFO << "Removed ATGC in fs_options as " << entry->fs_options << " for zoned device";
+        entry->fs_mgr_flags.is_zoned = true;
+    }
+    entry->user_devices.push_back(param[1]);
+}
+
 bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
     for (const auto& flag : Split(flags, ",")) {
         if (flag.empty() || flag == "defaults") continue;
@@ -311,17 +334,8 @@ bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
             if (!ParseByteCount(arg, &entry->zram_backingdev_size)) {
                 LWARNING << "Warning: zram_backingdev_size= flag malformed: " << arg;
             }
-        } else if (flag == "zoned_device") {
-            if (access("/dev/block/by-name/zoned_device", F_OK) == 0) {
-                entry->zoned_device = "/dev/block/by-name/zoned_device";
-
-                // atgc in f2fs does not support a zoned device
-                auto options = Split(entry->fs_options, ",");
-                options.erase(std::remove(options.begin(), options.end(), "atgc"), options.end());
-                entry->fs_options = android::base::Join(options, ",");
-                LINFO << "Removed ATGC in fs_options as " << entry->fs_options
-                      << " for zoned device=" << entry->zoned_device;
-            }
+        } else if (StartsWith(flag, "device=")) {
+            ParseUserDevices(arg, entry);
         } else {
             LWARNING << "Warning: unknown flag: " << flag;
         }
diff --git a/fs_mgr/libfstab/include/fstab/fstab.h b/fs_mgr/libfstab/include/fstab/fstab.h
index 5e4019ca17ff..29b74ed5c267 100644
--- a/fs_mgr/libfstab/include/fstab/fstab.h
+++ b/fs_mgr/libfstab/include/fstab/fstab.h
@@ -32,7 +32,7 @@ namespace fs_mgr {
 
 struct FstabEntry {
     std::string blk_device;
-    std::string zoned_device;
+    std::vector<std::string> user_devices;
     std::string logical_partition_name;
     std::string mount_point;
     std::string fs_type;
@@ -85,6 +85,7 @@ struct FstabEntry {
         bool ext_meta_csum : 1;
         bool fs_compress : 1;
         bool overlayfs_remove_missing_lowerdir : 1;
+        bool is_zoned : 1;
     } fs_mgr_flags = {};
 
     bool is_encryptable() const { return fs_mgr_flags.crypt; }

From ef637fd13c799387e9c775b07ef21ba1f5139e2e Mon Sep 17 00:00:00 2001
From: Kiyoung Kim <kiyoungkim@google.com>
Date: Fri, 3 May 2024 16:09:43 +0900
Subject: [PATCH 0884/1487] Move llndk.libraries.txt definition

Previously llndk.libraries.txt definition was located in VNDK along with
other vndk related libraries.txt files. As of VNDK deprecation, all
other VNDK libraries.txt files are being removed, and there is no need
to keep llndk.libraries.txt whtin the VNDK project, as LLNDK is not
VNDK. This change moves definition of llndk.libraries.txt into system
core project, to keep with other files installed in /system/etc.

Bug: 328994089
Test: AOSP CF build succeeded
Change-Id: I1535ebbab514ecf81a044c0e5ac4472f964f4312
---
 rootdir/Android.bp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 06227c31804b..108c7c2e7e15 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -113,3 +113,7 @@ prebuilt_etc {
     src: "init-debug.rc",
     sub_dir: "init",
 }
+
+llndk_libraries_txt {
+    name: "llndk.libraries.txt",
+}

From f9b4b0fe0b1e03dca120bd0be5e2be780ece522f Mon Sep 17 00:00:00 2001
From: Martijn Coenen <maco@google.com>
Date: Mon, 6 May 2024 13:22:28 +0000
Subject: [PATCH 0885/1487] Add maco to OWNERS.

Change-Id: I6e9d770a4a7c2a66774f9fe4fd342ceefade5e71
---
 janitors/OWNERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/janitors/OWNERS b/janitors/OWNERS
index a28737ebccc4..c25d9e465b0b 100644
--- a/janitors/OWNERS
+++ b/janitors/OWNERS
@@ -3,4 +3,5 @@ ccross@google.com
 cferris@google.com
 dwillemsen@google.com
 enh@google.com
+maco@google.com
 sadafebrahimi@google.com

From c542da26743a8fe42b7a91a19766e7f502388065 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 2 May 2024 11:36:22 -0700
Subject: [PATCH 0886/1487] libsnapshot: update write error logs

We want to print how much total data we are attempting to write if a
failure occurs

Bug: 336461151
Test: th
Change-Id: I269b7e280df34994c80fa8ef7d39163d053fa9ea
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
index 95398e4b9d46..1117ec9658f0 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.cpp
@@ -731,7 +731,8 @@ bool CowWriterV3::WriteOperation(std::span<const CowOperationV3> ops,
             i += chunk;
         }
         if (total_written != total_data_size) {
-            PLOG(ERROR) << "write failed for data of size: " << data.size()
+            PLOG(ERROR) << "write failed for data vector of size: " << data.size()
+                        << " and total data length: " << total_data_size
                         << " at offset: " << next_data_pos_ << " " << errno
                         << ", only wrote: " << total_written;
             return false;

From 4647b6b3058fd8d17622e72beaea54e64db7afe3 Mon Sep 17 00:00:00 2001
From: Devin Moore <devinmoore@google.com>
Date: Fri, 3 May 2024 00:02:24 +0000
Subject: [PATCH 0887/1487] Add page size info to tombstone

Now that Android devices can use 16k page size, it's important that we
know what configuration the device is in when see issues.

1) If the device is in 4k mode, we see nothing new.

2) If the device is in 16k mode, we see this line in the tombstones:

Page size: 16

3) If the device is in 4k mode, but was previous in 16k mode we see:

Has been in 16kb mode: yes

Test: atest debuggerd_test
Test: atest debuggerd_test with ro.misctrl.16kb_before="1"
Test: adb shell cat /data/tombstones/tombstone_00
Bug: 335247092
Change-Id: If7ca3b0954a01070ff413758296460ca1d023ca5
---
 debuggerd/libdebuggerd/tombstone_proto.cpp         | 3 +++
 debuggerd/libdebuggerd/tombstone_proto_to_text.cpp | 7 +++++++
 debuggerd/proto/tombstone.proto                    | 5 ++++-
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index 4cde986104c5..5546b7bcc21f 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -714,6 +714,9 @@ void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder*
                           error.c_str());
   }
 
+  result.set_page_size(getpagesize());
+  result.set_has_been_16kb_mode(android::base::GetBoolProperty("ro.misctrl.16kb_before", false));
+
   auto cmd_line = result.mutable_command_line();
   for (const auto& arg : target_thread.command_line) {
     *cmd_line->Add() = arg;
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index cefa2d62e64a..08c1cc0dae12 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -586,6 +586,13 @@ bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback)
   CBL("Timestamp: %s", tombstone.timestamp().c_str());
   CBL("Process uptime: %ds", tombstone.process_uptime());
 
+  // only print this info if the page size is not 4k or has been in 16k mode
+  if (tombstone.page_size() != 4096) {
+    CBL("Page size: %d bytes", tombstone.page_size());
+  } else if (tombstone.has_been_16kb_mode()) {
+    CBL("Has been in 16kb mode: yes");
+  }
+
   // Process header
   const auto& threads = tombstone.threads();
   auto main_thread_it = threads.find(tombstone.tid());
diff --git a/debuggerd/proto/tombstone.proto b/debuggerd/proto/tombstone.proto
index 214cbfb46bee..e70d525ee914 100644
--- a/debuggerd/proto/tombstone.proto
+++ b/debuggerd/proto/tombstone.proto
@@ -46,7 +46,10 @@ message Tombstone {
   repeated LogBuffer log_buffers = 18;
   repeated FD open_fds = 19;
 
-  reserved 22 to 999;
+  uint32 page_size = 22;
+  bool has_been_16kb_mode = 23;
+
+  reserved 24 to 999;
 }
 
 enum Architecture {

From 5bec4e0cddf2bd61cbf60d59628b77fdda9730ce Mon Sep 17 00:00:00 2001
From: Kiyoung Kim <kiyoungkim@google.com>
Date: Tue, 7 May 2024 14:54:20 +0900
Subject: [PATCH 0888/1487] Move sanitizer.libraries.txt definition into Soong

Currently sanitizer.libraries.txt module is defined from Makefile, while
all logics to create the list of modules is implmented within the Soong.
This change moves sanitizer.libraries.txt module definition into Soong,
so it can be generated without sharing list of modules over Make
variable.

Bug: 339131599
Test: AOSP CF build succeeded, with same list of modules in
/system/etc/sanitizer.libraries.txt
Change-Id: I25cd4cf55b0a0992d05990d1b67869435f37de93
---
 rootdir/Android.bp |  4 ++++
 rootdir/Android.mk | 20 --------------------
 2 files changed, 4 insertions(+), 20 deletions(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 108c7c2e7e15..bd24f22f3abc 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -117,3 +117,7 @@ prebuilt_etc {
 llndk_libraries_txt {
     name: "llndk.libraries.txt",
 }
+
+sanitizer_libraries_txt {
+    name: "sanitizer.libraries.txt",
+}
\ No newline at end of file
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 2394b14aa041..06e87301da17 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -210,26 +210,6 @@ $(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/init.environ.rc.in
 	$(hide) sed -i -e 's?%EXPORT_GLOBAL_HWASAN_OPTIONS%?$(EXPORT_GLOBAL_HWASAN_OPTIONS)?g' $@
 	$(hide) sed -i -e 's?%EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE%?$(EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE)?g' $@
 
-#######################################
-# sanitizer.libraries.txt
-include $(CLEAR_VARS)
-LOCAL_MODULE := sanitizer.libraries.txt
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_MODULE_CLASS := ETC
-LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)
-LOCAL_MODULE_STEM := $(LOCAL_MODULE)
-include $(BUILD_SYSTEM)/base_rules.mk
-$(LOCAL_BUILT_MODULE): PRIVATE_SANITIZER_RUNTIME_LIBRARIES := \
-    $(SANITIZER_STEMS) \
-    $(2ND_SANITIZER_STEMS)
-$(LOCAL_BUILT_MODULE):
-	@echo "Generate: $@"
-	@mkdir -p $(dir $@)
-	$(hide) echo -n > $@
-	$(hide) $(foreach lib,$(PRIVATE_SANITIZER_RUNTIME_LIBRARIES), \
-		echo $(lib) >> $@;)
-
 #######################################
 # ramdisk_node_list
 include $(CLEAR_VARS)

From 87b1dc23c23472633c144f90d1790f592b1c5119 Mon Sep 17 00:00:00 2001
From: Akshata Kadam <akshata.jadhav@ittiam.com>
Date: Mon, 29 Apr 2024 15:23:01 +0530
Subject: [PATCH 0889/1487] Updated 'cc' field of fuzz_config in Android.bp
 file

corrected cc field in fuzz_config

Bug: 306435930
Test: Build liblp_apis_fuzzer

Change-Id: Id74b2d0d6328ba84df1dcabd47ab1795206f8ca2
---
 fs_mgr/liblp/fuzzer/Android.bp | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/fs_mgr/liblp/fuzzer/Android.bp b/fs_mgr/liblp/fuzzer/Android.bp
index a9e3509af7fa..46bd03197dac 100644
--- a/fs_mgr/liblp/fuzzer/Android.bp
+++ b/fs_mgr/liblp/fuzzer/Android.bp
@@ -15,6 +15,10 @@
  *
  */
 
+package {
+    default_team: "trendy_team_android_kernel",
+}
+
 cc_defaults {
     name: "liblp_fuzz_defaults",
     header_libs: [
@@ -33,7 +37,7 @@ cc_defaults {
     ],
     fuzz_config: {
         cc: [
-            "android-media-fuzzing-reports@google.com",
+            "android-systems-storage@google.com",
         ],
         componentid: 59148,
         hotlists: ["4593311"],
@@ -41,8 +45,8 @@ cc_defaults {
         vector: "local_no_privileges_required",
         service_privilege: "privileged",
         users: "multi_user",
-        fuzzed_code_usage: "shipped"
-    }
+        fuzzed_code_usage: "shipped",
+    },
 }
 
 cc_fuzz {
@@ -196,6 +200,6 @@ cc_fuzz {
         ":test_vendor_boot_v4_with_frag",
     ],
     cflags: [
-      "-Wno-unused-parameter",
-   ],
+        "-Wno-unused-parameter",
+    ],
 }

From b47c9b065f9028b7c2f995add83b12d7e23210aa Mon Sep 17 00:00:00 2001
From: Snehal <snehalreddy@google.com>
Date: Tue, 7 May 2024 15:06:44 +0000
Subject: [PATCH 0890/1487] [Trusty][Coverage] Update counter to let Trusty
 know coverage dump has been read

Bug: 339194547

Change-Id: I075742200998e837e59ba9c24e4dca8b5d4d1199
---
 trusty/utils/coverage-controller/controller.cpp | 1 +
 trusty/utils/coverage-controller/controller.h   | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/trusty/utils/coverage-controller/controller.cpp b/trusty/utils/coverage-controller/controller.cpp
index 381a45285c2c..f5d70b16d4fa 100644
--- a/trusty/utils/coverage-controller/controller.cpp
+++ b/trusty/utils/coverage-controller/controller.cpp
@@ -60,6 +60,7 @@ void Controller::run(std::string output_dir) {
                 filename.insert(0, output_dir);
                 android::base::Result<void> res = record_list_[index]->SaveFile(filename);
                 counters[index]++;
+                WRITE_ONCE(control->read_buffer_cnt, counters[index]);
             }
             if(complete_cnt == counters[index] &&
                 !(flags & FLAG_RUN)) {
diff --git a/trusty/utils/coverage-controller/controller.h b/trusty/utils/coverage-controller/controller.h
index f7789bfed076..841a1aeb1165 100644
--- a/trusty/utils/coverage-controller/controller.h
+++ b/trusty/utils/coverage-controller/controller.h
@@ -35,9 +35,9 @@
 struct control {
     /* Written by controller, read by instrumented TA */
     uint64_t        cntrl_flags;
+    uint64_t        read_buffer_cnt;
 
     /* Written by instrumented TA, read by controller */
-    uint64_t        oper_flags;
     uint64_t        write_buffer_start_count;
     uint64_t        write_buffer_complete_count;
 };

From 2f77c2a5160493de5f9a24c0bfe0933cdc0a3f70 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Tue, 7 May 2024 12:25:31 -0700
Subject: [PATCH 0891/1487] Clean up usage of 32 bit/64 bit checks.

Rather than have to create a number of #if defines for the memory
dumping parts of the tombstone, create a single function to generate
these strings for the memory tests.

Make CrasherTest.smoke use a regex that passes on 32 bit and 64 bit.

Make the tests page size agnostic.

Bug: 339017792

Test: Treehugger.
Test: Ran 32 bit and 64 bit versions of tests on a real device.
Test: Ran on the aosp_cf_x86_64_phone_pgagnostic-trunk_staging-userdebug
Change-Id: If9365061b85de23b00a1bf947d85923cde06c068
---
 debuggerd/debuggerd_test.cpp                  |  39 +--
 .../libdebuggerd/test/dump_memory_test.cpp    | 266 ++++++------------
 2 files changed, 107 insertions(+), 198 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index e4e2f99cc28c..baddf65787c0 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -332,12 +332,7 @@ TEST_F(CrasherTest, smoke) {
 
   std::string result;
   ConsumeFd(std::move(output_fd), &result);
-#ifdef __LP64__
-  ASSERT_MATCH(result,
-               R"(signal 11 \(SIGSEGV\), code 1 \(SEGV_MAPERR\), fault addr 0x000000000000dead)");
-#else
-  ASSERT_MATCH(result, R"(signal 11 \(SIGSEGV\), code 1 \(SEGV_MAPERR\), fault addr 0x0000dead)");
-#endif
+  ASSERT_MATCH(result, R"(signal 11 \(SIGSEGV\), code 1 \(SEGV_MAPERR\), fault addr 0x0+dead)");
 
   if (mte_supported()) {
     // Test that the default TAGGED_ADDR_CTRL value is set.
@@ -1829,10 +1824,14 @@ GwpAsanTestParameters gwp_asan_tests[] = {
      "Use After Free, 0 bytes into a 7-byte allocation"},
     {/* alloc_size */ 15, /* free_before_access */ true, /* access_offset */ 1,
      "Use After Free, 1 byte into a 15-byte allocation"},
-    {/* alloc_size */ 4096, /* free_before_access */ false, /* access_offset */ 4098,
-     "Buffer Overflow, 2 bytes right of a 4096-byte allocation"},
-    {/* alloc_size */ 4096, /* free_before_access */ false, /* access_offset */ -1,
-     "Buffer Underflow, 1 byte left of a 4096-byte allocation"},
+    {/* alloc_size */ static_cast<size_t>(getpagesize()), /* free_before_access */ false,
+     /* access_offset */ getpagesize() + 2,
+     android::base::StringPrintf("Buffer Overflow, 2 bytes right of a %d-byte allocation",
+                                 getpagesize())},
+    {/* alloc_size */ static_cast<size_t>(getpagesize()), /* free_before_access */ false,
+     /* access_offset */ -1,
+     android::base::StringPrintf("Buffer Underflow, 1 byte left of a %d-byte allocation",
+                                 getpagesize())},
 };
 
 INSTANTIATE_TEST_SUITE_P(
@@ -2977,30 +2976,34 @@ TEST_F(CrasherTest, verify_map_format) {
   std::string match_str;
   // Verify none.
   match_str = android::base::StringPrintf(
-      "    %s-%s ---         0      1000\\n",
+      "    %s-%s ---         0      %x\\n",
       format_map_pointer(reinterpret_cast<uintptr_t>(none_map)).c_str(),
-      format_map_pointer(reinterpret_cast<uintptr_t>(none_map) + getpagesize() - 1).c_str());
+      format_map_pointer(reinterpret_cast<uintptr_t>(none_map) + getpagesize() - 1).c_str(),
+      getpagesize());
   ASSERT_MATCH(result, match_str);
 
   // Verify read-only.
   match_str = android::base::StringPrintf(
-      "    %s-%s r--         0      1000\\n",
+      "    %s-%s r--         0      %x\\n",
       format_map_pointer(reinterpret_cast<uintptr_t>(r_map)).c_str(),
-      format_map_pointer(reinterpret_cast<uintptr_t>(r_map) + getpagesize() - 1).c_str());
+      format_map_pointer(reinterpret_cast<uintptr_t>(r_map) + getpagesize() - 1).c_str(),
+      getpagesize());
   ASSERT_MATCH(result, match_str);
 
   // Verify write-only.
   match_str = android::base::StringPrintf(
-      "    %s-%s -w-         0      1000\\n",
+      "    %s-%s -w-         0      %x\\n",
       format_map_pointer(reinterpret_cast<uintptr_t>(w_map)).c_str(),
-      format_map_pointer(reinterpret_cast<uintptr_t>(w_map) + getpagesize() - 1).c_str());
+      format_map_pointer(reinterpret_cast<uintptr_t>(w_map) + getpagesize() - 1).c_str(),
+      getpagesize());
   ASSERT_MATCH(result, match_str);
 
   // Verify exec-only.
   match_str = android::base::StringPrintf(
-      "    %s-%s --x         0      1000\\n",
+      "    %s-%s --x         0      %x\\n",
       format_map_pointer(reinterpret_cast<uintptr_t>(x_map)).c_str(),
-      format_map_pointer(reinterpret_cast<uintptr_t>(x_map) + getpagesize() - 1).c_str());
+      format_map_pointer(reinterpret_cast<uintptr_t>(x_map) + getpagesize() - 1).c_str(),
+      getpagesize());
   ASSERT_MATCH(result, match_str);
 
   // Verify file map with non-zero offset and a name.
diff --git a/debuggerd/libdebuggerd/test/dump_memory_test.cpp b/debuggerd/libdebuggerd/test/dump_memory_test.cpp
index 5be145aad128..dee7b4827af7 100644
--- a/debuggerd/libdebuggerd/test/dump_memory_test.cpp
+++ b/debuggerd/libdebuggerd/test/dump_memory_test.cpp
@@ -20,6 +20,8 @@
 #include <string>
 
 #include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/stringprintf.h>
 #include <gtest/gtest.h>
 #include <unwindstack/Memory.h>
 
@@ -27,61 +29,64 @@
 
 #include "log_fake.h"
 
-const char g_expected_full_dump[] =
-"\nmemory near r1:\n"
+std::string GetMemoryString(uintptr_t addr, const std::vector<uint64_t>& data) {
+  // Must be even number of data values.
+  CHECK((data.size() & 1) == 0);
+
+  std::string str;
+  for (size_t i = 0; i < data.size(); i += 2) {
+    str += "    ";
+    std::string ascii_str = "";
+    for (size_t j = 0; j < 2; j++) {
+      for (size_t k = 0; k < 8; k++) {
+        uint8_t c = (data[i + j] >> (k * 8)) & 0xff;
+        if (c >= 0x20 && c < 0x7f) {
+          ascii_str += c;
+        } else {
+          ascii_str += '.';
+        }
+      }
+    }
 #if defined(__LP64__)
-"    0000000012345650 0706050403020100 0f0e0d0c0b0a0908  ................\n"
-"    0000000012345660 1716151413121110 1f1e1d1c1b1a1918  ................\n"
-"    0000000012345670 2726252423222120 2f2e2d2c2b2a2928   !\"#$%&'()*+,-./\n"
-"    0000000012345680 3736353433323130 3f3e3d3c3b3a3938  0123456789:;<=>?\n"
-"    0000000012345690 4746454443424140 4f4e4d4c4b4a4948  @ABCDEFGHIJKLMNO\n"
-"    00000000123456a0 5756555453525150 5f5e5d5c5b5a5958  PQRSTUVWXYZ[\\]^_\n"
-"    00000000123456b0 6766656463626160 6f6e6d6c6b6a6968  `abcdefghijklmno\n"
-"    00000000123456c0 7776757473727170 7f7e7d7c7b7a7978  pqrstuvwxyz{|}~.\n"
-"    00000000123456d0 8786858483828180 8f8e8d8c8b8a8988  ................\n"
-"    00000000123456e0 9796959493929190 9f9e9d9c9b9a9998  ................\n"
-"    00000000123456f0 a7a6a5a4a3a2a1a0 afaeadacabaaa9a8  ................\n"
-"    0000000012345700 b7b6b5b4b3b2b1b0 bfbebdbcbbbab9b8  ................\n"
-"    0000000012345710 c7c6c5c4c3c2c1c0 cfcecdcccbcac9c8  ................\n"
-"    0000000012345720 d7d6d5d4d3d2d1d0 dfdedddcdbdad9d8  ................\n"
-"    0000000012345730 e7e6e5e4e3e2e1e0 efeeedecebeae9e8  ................\n"
-"    0000000012345740 f7f6f5f4f3f2f1f0 fffefdfcfbfaf9f8  ................\n";
+    str += android::base::StringPrintf("%016zx %016zx %016zx  ", addr, data[i], data[i + 1]);
 #else
-"    12345650 03020100 07060504 0b0a0908 0f0e0d0c  ................\n"
-"    12345660 13121110 17161514 1b1a1918 1f1e1d1c  ................\n"
-"    12345670 23222120 27262524 2b2a2928 2f2e2d2c   !\"#$%&'()*+,-./\n"
-"    12345680 33323130 37363534 3b3a3938 3f3e3d3c  0123456789:;<=>?\n"
-"    12345690 43424140 47464544 4b4a4948 4f4e4d4c  @ABCDEFGHIJKLMNO\n"
-"    123456a0 53525150 57565554 5b5a5958 5f5e5d5c  PQRSTUVWXYZ[\\]^_\n"
-"    123456b0 63626160 67666564 6b6a6968 6f6e6d6c  `abcdefghijklmno\n"
-"    123456c0 73727170 77767574 7b7a7978 7f7e7d7c  pqrstuvwxyz{|}~.\n"
-"    123456d0 83828180 87868584 8b8a8988 8f8e8d8c  ................\n"
-"    123456e0 93929190 97969594 9b9a9998 9f9e9d9c  ................\n"
-"    123456f0 a3a2a1a0 a7a6a5a4 abaaa9a8 afaeadac  ................\n"
-"    12345700 b3b2b1b0 b7b6b5b4 bbbab9b8 bfbebdbc  ................\n"
-"    12345710 c3c2c1c0 c7c6c5c4 cbcac9c8 cfcecdcc  ................\n"
-"    12345720 d3d2d1d0 d7d6d5d4 dbdad9d8 dfdedddc  ................\n"
-"    12345730 e3e2e1e0 e7e6e5e4 ebeae9e8 efeeedec  ................\n"
-"    12345740 f3f2f1f0 f7f6f5f4 fbfaf9f8 fffefdfc  ................\n";
+    str += android::base::StringPrintf(
+        "%08zx %08zx %08zx %08zx %08zx  ", addr, static_cast<uintptr_t>(data[i] & 0xffffffff),
+        static_cast<uintptr_t>(data[i] >> 32), static_cast<uintptr_t>(data[i + 1] & 0xffffffff),
+        static_cast<uintptr_t>(data[i + 1] >> 32));
 #endif
+    str += ascii_str + "\n";
+    addr += 0x10;
+  }
+  return str;
+}
 
-const char g_expected_partial_dump[] = \
-"\nmemory near pc:\n"
-#if defined(__LP64__)
-"    00000000123455e0 0706050403020100 0f0e0d0c0b0a0908  ................\n"
-"    00000000123455f0 1716151413121110 1f1e1d1c1b1a1918  ................\n"
-"    0000000012345600 2726252423222120 2f2e2d2c2b2a2928   !\"#$%&'()*+,-./\n"
-"    0000000012345610 3736353433323130 3f3e3d3c3b3a3938  0123456789:;<=>?\n"
-"    0000000012345620 4746454443424140 4f4e4d4c4b4a4948  @ABCDEFGHIJKLMNO\n"
-"    0000000012345630 5756555453525150 5f5e5d5c5b5a5958  PQRSTUVWXYZ[\\]^_\n";
-#else
-"    123455e0 03020100 07060504 0b0a0908 0f0e0d0c  ................\n"
-"    123455f0 13121110 17161514 1b1a1918 1f1e1d1c  ................\n"
-"    12345600 23222120 27262524 2b2a2928 2f2e2d2c   !\"#$%&'()*+,-./\n"
-"    12345610 33323130 37363534 3b3a3938 3f3e3d3c  0123456789:;<=>?\n"
-"    12345620 43424140 47464544 4b4a4948 4f4e4d4c  @ABCDEFGHIJKLMNO\n"
-"    12345630 53525150 57565554 5b5a5958 5f5e5d5c  PQRSTUVWXYZ[\\]^_\n";
-#endif
+const std::vector<uint64_t>& GetDefaultData() {
+  static std::vector<uint64_t> data(
+      {0x0706050403020100UL, 0x0f0e0d0c0b0a0908UL, 0x1716151413121110UL, 0x1f1e1d1c1b1a1918UL,
+       0x2726252423222120UL, 0x2f2e2d2c2b2a2928UL, 0x3736353433323130UL, 0x3f3e3d3c3b3a3938UL,
+       0x4746454443424140UL, 0x4f4e4d4c4b4a4948UL, 0x5756555453525150UL, 0x5f5e5d5c5b5a5958UL,
+       0x6766656463626160UL, 0x6f6e6d6c6b6a6968UL, 0x7776757473727170UL, 0x7f7e7d7c7b7a7978UL,
+       0x8786858483828180UL, 0x8f8e8d8c8b8a8988UL, 0x9796959493929190UL, 0x9f9e9d9c9b9a9998UL,
+       0xa7a6a5a4a3a2a1a0UL, 0xafaeadacabaaa9a8UL, 0xb7b6b5b4b3b2b1b0UL, 0xbfbebdbcbbbab9b8UL,
+       0xc7c6c5c4c3c2c1c0UL, 0xcfcecdcccbcac9c8UL, 0xd7d6d5d4d3d2d1d0UL, 0xdfdedddcdbdad9d8UL,
+       0xe7e6e5e4e3e2e1e0UL, 0xefeeedecebeae9e8UL, 0xf7f6f5f4f3f2f1f0UL, 0xfffefdfcfbfaf9f8UL});
+  return data;
+}
+
+std::string GetFullDumpString() {
+  std::string str = "\nmemory near r1:\n";
+  str += GetMemoryString(0x12345650U, GetDefaultData());
+  return str;
+}
+
+std::string GetPartialDumpString() {
+  std::string str = "\nmemory near pc:\n";
+  std::vector<uint64_t> data = GetDefaultData();
+  data.resize(12);
+  str += GetMemoryString(0x123455e0U, data);
+  return str;
+}
 
 class MemoryMock : public unwindstack::Memory {
  public:
@@ -189,7 +194,7 @@ TEST_F(DumpMemoryTest, aligned_addr) {
   std::string tombstone_contents;
   ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
   ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
-  ASSERT_STREQ(g_expected_full_dump, tombstone_contents.c_str());
+  ASSERT_EQ(GetFullDumpString(), tombstone_contents);
 
   // Verify that the log buf is empty, and no error messages.
   ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -209,7 +214,7 @@ TEST_F(DumpMemoryTest, partial_read) {
   std::string tombstone_contents;
   ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
   ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
-  ASSERT_STREQ(g_expected_full_dump, tombstone_contents.c_str());
+  ASSERT_EQ(GetFullDumpString(), tombstone_contents);
 
   // Verify that the log buf is empty, and no error messages.
   ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -228,7 +233,7 @@ TEST_F(DumpMemoryTest, unaligned_addr) {
   std::string tombstone_contents;
   ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
   ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
-  ASSERT_STREQ(g_expected_full_dump, tombstone_contents.c_str());
+  ASSERT_EQ(GetFullDumpString(), tombstone_contents);
 
   // Verify that the log buf is empty, and no error messages.
   ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -260,7 +265,7 @@ TEST_F(DumpMemoryTest, memory_partially_unreadable) {
   std::string tombstone_contents;
   ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
   ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
-  ASSERT_STREQ(g_expected_partial_dump, tombstone_contents.c_str());
+  ASSERT_EQ(GetPartialDumpString(), tombstone_contents);
 
   // Verify that the log buf is empty, and no error messages.
   ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -280,7 +285,7 @@ TEST_F(DumpMemoryTest, memory_partially_unreadable_unaligned_return) {
   std::string tombstone_contents;
   ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
   ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
-  ASSERT_STREQ(g_expected_partial_dump, tombstone_contents.c_str());
+  ASSERT_EQ(GetPartialDumpString(), tombstone_contents);
 
 #if defined(__LP64__)
   ASSERT_STREQ("6 DEBUG Bytes read 102, is not a multiple of 8\n", getFakeLogPrint().c_str());
@@ -305,7 +310,7 @@ TEST_F(DumpMemoryTest, memory_partially_unreadable_two_unaligned_reads) {
   std::string tombstone_contents;
   ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
   ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
-  ASSERT_STREQ(g_expected_partial_dump, tombstone_contents.c_str());
+  ASSERT_EQ(GetPartialDumpString(), tombstone_contents);
 
 #if defined(__LP64__)
   ASSERT_STREQ("6 DEBUG Bytes read 45, is not a multiple of 8\n"
@@ -331,44 +336,9 @@ TEST_F(DumpMemoryTest, address_low_fence) {
   std::string tombstone_contents;
   ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
   ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
-  const char* expected_dump = \
-"\nmemory near r1:\n"
-#if defined(__LP64__)
-"    0000000000001000 0000000000000000 0000000000000000  ................\n"
-"    0000000000001010 0000000000000000 0000000000000000  ................\n"
-"    0000000000001020 0000000000000000 0000000000000000  ................\n"
-"    0000000000001030 0000000000000000 0000000000000000  ................\n"
-"    0000000000001040 0000000000000000 0000000000000000  ................\n"
-"    0000000000001050 0000000000000000 0000000000000000  ................\n"
-"    0000000000001060 0000000000000000 0000000000000000  ................\n"
-"    0000000000001070 0000000000000000 0000000000000000  ................\n"
-"    0000000000001080 0000000000000000 0000000000000000  ................\n"
-"    0000000000001090 0000000000000000 0000000000000000  ................\n"
-"    00000000000010a0 0000000000000000 0000000000000000  ................\n"
-"    00000000000010b0 0000000000000000 0000000000000000  ................\n"
-"    00000000000010c0 0000000000000000 0000000000000000  ................\n"
-"    00000000000010d0 0000000000000000 0000000000000000  ................\n"
-"    00000000000010e0 0000000000000000 0000000000000000  ................\n"
-"    00000000000010f0 0000000000000000 0000000000000000  ................\n";
-#else
-"    00001000 00000000 00000000 00000000 00000000  ................\n"
-"    00001010 00000000 00000000 00000000 00000000  ................\n"
-"    00001020 00000000 00000000 00000000 00000000  ................\n"
-"    00001030 00000000 00000000 00000000 00000000  ................\n"
-"    00001040 00000000 00000000 00000000 00000000  ................\n"
-"    00001050 00000000 00000000 00000000 00000000  ................\n"
-"    00001060 00000000 00000000 00000000 00000000  ................\n"
-"    00001070 00000000 00000000 00000000 00000000  ................\n"
-"    00001080 00000000 00000000 00000000 00000000  ................\n"
-"    00001090 00000000 00000000 00000000 00000000  ................\n"
-"    000010a0 00000000 00000000 00000000 00000000  ................\n"
-"    000010b0 00000000 00000000 00000000 00000000  ................\n"
-"    000010c0 00000000 00000000 00000000 00000000  ................\n"
-"    000010d0 00000000 00000000 00000000 00000000  ................\n"
-"    000010e0 00000000 00000000 00000000 00000000  ................\n"
-"    000010f0 00000000 00000000 00000000 00000000  ................\n";
-#endif
-  ASSERT_STREQ(expected_dump, tombstone_contents.c_str());
+  std::string expected_dump = "\nmemory near r1:\n";
+  expected_dump += GetMemoryString(0x1000, std::vector<uint64_t>(32, 0UL));
+  ASSERT_EQ(expected_dump, tombstone_contents);
 
   // Verify that the log buf is empty, and no error messages.
   ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -414,61 +384,17 @@ TEST_F(DumpMemoryTest, memory_address_nearly_too_high) {
   std::string tombstone_contents;
   ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
   ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
-  const char* expected_dump = \
-"\nmemory near r4:\n"
+  std::string expected_dump = "\nmemory near r4:\n";
+  uintptr_t addr;
 #if defined(__aarch64__)
-"    00ffffffffffff00 0706050403020100 0f0e0d0c0b0a0908  ................\n"
-"    00ffffffffffff10 1716151413121110 1f1e1d1c1b1a1918  ................\n"
-"    00ffffffffffff20 2726252423222120 2f2e2d2c2b2a2928   !\"#$%&'()*+,-./\n"
-"    00ffffffffffff30 3736353433323130 3f3e3d3c3b3a3938  0123456789:;<=>?\n"
-"    00ffffffffffff40 4746454443424140 4f4e4d4c4b4a4948  @ABCDEFGHIJKLMNO\n"
-"    00ffffffffffff50 5756555453525150 5f5e5d5c5b5a5958  PQRSTUVWXYZ[\\]^_\n"
-"    00ffffffffffff60 6766656463626160 6f6e6d6c6b6a6968  `abcdefghijklmno\n"
-"    00ffffffffffff70 7776757473727170 7f7e7d7c7b7a7978  pqrstuvwxyz{|}~.\n"
-"    00ffffffffffff80 8786858483828180 8f8e8d8c8b8a8988  ................\n"
-"    00ffffffffffff90 9796959493929190 9f9e9d9c9b9a9998  ................\n"
-"    00ffffffffffffa0 a7a6a5a4a3a2a1a0 afaeadacabaaa9a8  ................\n"
-"    00ffffffffffffb0 b7b6b5b4b3b2b1b0 bfbebdbcbbbab9b8  ................\n"
-"    00ffffffffffffc0 c7c6c5c4c3c2c1c0 cfcecdcccbcac9c8  ................\n"
-"    00ffffffffffffd0 d7d6d5d4d3d2d1d0 dfdedddcdbdad9d8  ................\n"
-"    00ffffffffffffe0 e7e6e5e4e3e2e1e0 efeeedecebeae9e8  ................\n"
-"    00fffffffffffff0 f7f6f5f4f3f2f1f0 fffefdfcfbfaf9f8  ................\n";
+  addr = 0x00ffffffffffff00UL;
 #elif defined(__LP64__)
-"    ffffffffffffff00 0706050403020100 0f0e0d0c0b0a0908  ................\n"
-"    ffffffffffffff10 1716151413121110 1f1e1d1c1b1a1918  ................\n"
-"    ffffffffffffff20 2726252423222120 2f2e2d2c2b2a2928   !\"#$%&'()*+,-./\n"
-"    ffffffffffffff30 3736353433323130 3f3e3d3c3b3a3938  0123456789:;<=>?\n"
-"    ffffffffffffff40 4746454443424140 4f4e4d4c4b4a4948  @ABCDEFGHIJKLMNO\n"
-"    ffffffffffffff50 5756555453525150 5f5e5d5c5b5a5958  PQRSTUVWXYZ[\\]^_\n"
-"    ffffffffffffff60 6766656463626160 6f6e6d6c6b6a6968  `abcdefghijklmno\n"
-"    ffffffffffffff70 7776757473727170 7f7e7d7c7b7a7978  pqrstuvwxyz{|}~.\n"
-"    ffffffffffffff80 8786858483828180 8f8e8d8c8b8a8988  ................\n"
-"    ffffffffffffff90 9796959493929190 9f9e9d9c9b9a9998  ................\n"
-"    ffffffffffffffa0 a7a6a5a4a3a2a1a0 afaeadacabaaa9a8  ................\n"
-"    ffffffffffffffb0 b7b6b5b4b3b2b1b0 bfbebdbcbbbab9b8  ................\n"
-"    ffffffffffffffc0 c7c6c5c4c3c2c1c0 cfcecdcccbcac9c8  ................\n"
-"    ffffffffffffffd0 d7d6d5d4d3d2d1d0 dfdedddcdbdad9d8  ................\n"
-"    ffffffffffffffe0 e7e6e5e4e3e2e1e0 efeeedecebeae9e8  ................\n"
-"    fffffffffffffff0 f7f6f5f4f3f2f1f0 fffefdfcfbfaf9f8  ................\n";
+  addr = 0xffffffffffffff00UL;
 #else
-"    ffffff00 03020100 07060504 0b0a0908 0f0e0d0c  ................\n"
-"    ffffff10 13121110 17161514 1b1a1918 1f1e1d1c  ................\n"
-"    ffffff20 23222120 27262524 2b2a2928 2f2e2d2c   !\"#$%&'()*+,-./\n"
-"    ffffff30 33323130 37363534 3b3a3938 3f3e3d3c  0123456789:;<=>?\n"
-"    ffffff40 43424140 47464544 4b4a4948 4f4e4d4c  @ABCDEFGHIJKLMNO\n"
-"    ffffff50 53525150 57565554 5b5a5958 5f5e5d5c  PQRSTUVWXYZ[\\]^_\n"
-"    ffffff60 63626160 67666564 6b6a6968 6f6e6d6c  `abcdefghijklmno\n"
-"    ffffff70 73727170 77767574 7b7a7978 7f7e7d7c  pqrstuvwxyz{|}~.\n"
-"    ffffff80 83828180 87868584 8b8a8988 8f8e8d8c  ................\n"
-"    ffffff90 93929190 97969594 9b9a9998 9f9e9d9c  ................\n"
-"    ffffffa0 a3a2a1a0 a7a6a5a4 abaaa9a8 afaeadac  ................\n"
-"    ffffffb0 b3b2b1b0 b7b6b5b4 bbbab9b8 bfbebdbc  ................\n"
-"    ffffffc0 c3c2c1c0 c7c6c5c4 cbcac9c8 cfcecdcc  ................\n"
-"    ffffffd0 d3d2d1d0 d7d6d5d4 dbdad9d8 dfdedddc  ................\n"
-"    ffffffe0 e3e2e1e0 e7e6e5e4 ebeae9e8 efeeedec  ................\n"
-"    fffffff0 f3f2f1f0 f7f6f5f4 fbfaf9f8 fffefdfc  ................\n";
+  addr = 0xffffff00UL;
 #endif
-  ASSERT_STREQ(expected_dump, tombstone_contents.c_str());
+  expected_dump += GetMemoryString(addr, GetDefaultData());
+  ASSERT_EQ(expected_dump, tombstone_contents);
 
   // Verify that the log buf is empty, and no error messages.
   ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -490,30 +416,15 @@ TEST_F(DumpMemoryTest, first_read_empty) {
   std::string tombstone_contents;
   ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
   ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
-  const char* expected_dump = \
-"\nmemory near r4:\n"
-#if defined(__LP64__)
-R"(    0000000010001000 8786858483828180 8f8e8d8c8b8a8988  ................
-    0000000010001010 9796959493929190 9f9e9d9c9b9a9998  ................
-    0000000010001020 a7a6a5a4a3a2a1a0 afaeadacabaaa9a8  ................
-    0000000010001030 b7b6b5b4b3b2b1b0 bfbebdbcbbbab9b8  ................
-    0000000010001040 c7c6c5c4c3c2c1c0 cfcecdcccbcac9c8  ................
-    0000000010001050 d7d6d5d4d3d2d1d0 dfdedddcdbdad9d8  ................
-    0000000010001060 e7e6e5e4e3e2e1e0 efeeedecebeae9e8  ................
-    0000000010001070 f7f6f5f4f3f2f1f0 fffefdfcfbfaf9f8  ................
-)";
-#else
-R"(    10001000 83828180 87868584 8b8a8988 8f8e8d8c  ................
-    10001010 93929190 97969594 9b9a9998 9f9e9d9c  ................
-    10001020 a3a2a1a0 a7a6a5a4 abaaa9a8 afaeadac  ................
-    10001030 b3b2b1b0 b7b6b5b4 bbbab9b8 bfbebdbc  ................
-    10001040 c3c2c1c0 c7c6c5c4 cbcac9c8 cfcecdcc  ................
-    10001050 d3d2d1d0 d7d6d5d4 dbdad9d8 dfdedddc  ................
-    10001060 e3e2e1e0 e7e6e5e4 ebeae9e8 efeeedec  ................
-    10001070 f3f2f1f0 f7f6f5f4 fbfaf9f8 fffefdfc  ................
-)";
-#endif
-  ASSERT_STREQ(expected_dump, tombstone_contents.c_str());
+  std::string expected_dump = "\nmemory near r4:\n";
+  expected_dump += GetMemoryString(
+      0x10000000 + page_size,
+      std::vector<uint64_t>{
+          0x8786858483828180UL, 0x8f8e8d8c8b8a8988UL, 0x9796959493929190UL, 0x9f9e9d9c9b9a9998UL,
+          0xa7a6a5a4a3a2a1a0UL, 0xafaeadacabaaa9a8UL, 0xb7b6b5b4b3b2b1b0UL, 0xbfbebdbcbbbab9b8UL,
+          0xc7c6c5c4c3c2c1c0UL, 0xcfcecdcccbcac9c8UL, 0xd7d6d5d4d3d2d1d0UL, 0xdfdedddcdbdad9d8UL,
+          0xe7e6e5e4e3e2e1e0UL, 0xefeeedecebeae9e8UL, 0xf7f6f5f4f3f2f1f0UL, 0xfffefdfcfbfaf9f8UL});
+  ASSERT_EQ(expected_dump, tombstone_contents);
 
   // Verify that the log buf is empty, and no error messages.
   ASSERT_STREQ("", getFakeLogBuf().c_str());
@@ -535,16 +446,11 @@ TEST_F(DumpMemoryTest, first_read_empty_second_read_stops) {
   std::string tombstone_contents;
   ASSERT_TRUE(lseek(log_.tfd, 0, SEEK_SET) == 0);
   ASSERT_TRUE(android::base::ReadFdToString(log_.tfd, &tombstone_contents));
-  const char* expected_dump = \
-"\nmemory near r4:\n"
-#if defined(__LP64__)
-"    0000000010001000 c7c6c5c4c3c2c1c0 cfcecdcccbcac9c8  ................\n"
-"    0000000010001010 d7d6d5d4d3d2d1d0 dfdedddcdbdad9d8  ................\n";
-#else
-"    10001000 c3c2c1c0 c7c6c5c4 cbcac9c8 cfcecdcc  ................\n"
-"    10001010 d3d2d1d0 d7d6d5d4 dbdad9d8 dfdedddc  ................\n";
-#endif
-  ASSERT_STREQ(expected_dump, tombstone_contents.c_str());
+  std::string expected_dump = "\nmemory near r4:\n";
+  expected_dump += GetMemoryString(
+      0x10000000 + page_size, std::vector<uint64_t>{0xc7c6c5c4c3c2c1c0UL, 0xcfcecdcccbcac9c8UL,
+                                                    0xd7d6d5d4d3d2d1d0UL, 0xdfdedddcdbdad9d8UL});
+  ASSERT_EQ(expected_dump, tombstone_contents);
 
   // Verify that the log buf is empty, and no error messages.
   ASSERT_STREQ("", getFakeLogBuf().c_str());

From 3ff250f6d7fe139f02b28fabe38c8a94f95205da Mon Sep 17 00:00:00 2001
From: Sijie Chen <sijiec@google.com>
Date: Mon, 25 Mar 2024 20:06:18 +0000
Subject: [PATCH 0892/1487] [Berberis][CrashReporting] Extend ThreadInfo to
 have guest registers

This CL is to get guest registers information.

Bug: b/321799516
Test: m
Testing for TLS Slot:
Manual testing by: 1. crash the jni tests to produce tombstones file 2.
get the signature field of guest state header 3. verified it is the same
value as NATIVE_BRIDGE_GUEST_STATE_SIGNATURE

Manual test the arm64 by: 1. flash build to pixel phone and verify
retrieving TLS_SLOT_THREAD_ID's tid field is the same as current thread
id.

Testing for register values:
Test and print out registers values for riscv64, looks make sense that
has null zero value slots.

Change-Id: Iff44ac5c2b202e44f3fb4e6909fbea141e54ae6b
---
 debuggerd/Android.bp                          |  12 ++
 debuggerd/crash_dump.cpp                      | 115 ++++++++++++++++++
 .../libdebuggerd/include/libdebuggerd/types.h |   2 +
 3 files changed, 129 insertions(+)

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 3a882ea8f41f..0c5543ed931d 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -452,6 +452,7 @@ cc_binary {
 
     header_libs: [
         "bionic_libc_platform_headers",
+        "libnative_bridge_support_accessor_headers",
     ],
 
     static_libs: [
@@ -461,6 +462,8 @@ cc_binary {
 
         "libtombstone_proto",
         "libprotobuf-cpp-lite",
+
+        "libnative_bridge_guest_state_accessor",
     ],
 
     shared_libs: [
@@ -476,6 +479,15 @@ cc_binary {
 
     // Required for tests.
     required: ["crash_dump.policy"],
+
+    target: {
+        android: {
+            header_libs: [
+                "libnative_bridge_support_accessor_headers", // For dlext_namespaces.h
+            ],
+            shared_libs: ["libdl_android"], // For android_get_exported_namespace implementation
+        },
+    },
 }
 
 cc_binary {
diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 203b4855b3b0..bc00c86a8ecd 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -25,6 +25,7 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
+#include <cstdint>
 #include <limits>
 #include <map>
 #include <memory>
@@ -42,6 +43,7 @@
 #include <android-base/unique_fd.h>
 #include <bionic/macros.h>
 #include <bionic/reserved_signals.h>
+#include <bionic/tls_defines.h>
 #include <cutils/sockets.h>
 #include <log/log.h>
 #include <private/android_filesystem_config.h>
@@ -52,7 +54,18 @@
 
 #include <unwindstack/AndroidUnwinder.h>
 #include <unwindstack/Error.h>
+#include <unwindstack/MachineArm.h>
+#include <unwindstack/MachineArm64.h>
+#include <unwindstack/MachineRiscv64.h>
 #include <unwindstack/Regs.h>
+#include <unwindstack/RegsArm.h>
+#include <unwindstack/RegsArm64.h>
+#include <unwindstack/RegsRiscv64.h>
+#include <unwindstack/UserArm.h>
+#include <unwindstack/UserArm64.h>
+#include <unwindstack/UserRiscv64.h>
+
+#include <native_bridge_support/guest_state_accessor/accessor.h>
 
 #include "libdebuggerd/backtrace.h"
 #include "libdebuggerd/tombstone.h"
@@ -403,6 +416,107 @@ static void InstallSigPipeHandler() {
   sigaction(SIGPIPE, &action, nullptr);
 }
 
+static bool PtracePeek(int request, pid_t tid, uintptr_t addr, void* data, std::string err_msg,
+                       uintptr_t* result) {
+  errno = 0;
+  *result = ptrace(request, tid, addr, data);
+  if (errno != 0) {
+    PLOG(ERROR) << err_msg;
+    return false;
+  }
+  return true;
+}
+
+static bool GetGuestRegistersFromCrashedProcess([[maybe_unused]] pid_t tid,
+                                                NativeBridgeGuestRegs* guest_regs) {
+  auto process_memory = unwindstack::Memory::CreateProcessMemoryCached(tid);
+
+  uintptr_t header_ptr = 0;
+  uintptr_t base = 0;
+#if defined(__x86_64__)
+  if (!PtracePeek(PTRACE_PEEKUSER, tid, offsetof(user_regs_struct, fs_base), nullptr,
+                  "failed to read thread register for thread " + std::to_string(tid), &base)) {
+    return false;
+  }
+#elif defined(__aarch64__)
+  // base is implicitly casted to uint64_t.
+  struct iovec pt_iov {
+    .iov_base = &base, .iov_len = sizeof(base),
+  };
+
+  if (ptrace(PTRACE_GETREGSET, tid, NT_ARM_TLS, &pt_iov) != 0) {
+    PLOG(ERROR) << "failed to read thread register for thread " << tid;
+  }
+#else
+  // TODO(b/339287219): Add case for Riscv host.
+  return false;
+#endif
+  auto ptr_to_guest_slot = base + TLS_SLOT_NATIVE_BRIDGE_GUEST_STATE * sizeof(uintptr_t);
+  if (!process_memory->ReadFully(ptr_to_guest_slot, &header_ptr, sizeof(uintptr_t))) {
+    PLOG(ERROR) << "failed to get guest state TLS slot content for thread " << tid;
+    return false;
+  }
+
+  NativeBridgeGuestStateHeader header;
+  if (!process_memory->ReadFully(header_ptr, &header, sizeof(NativeBridgeGuestStateHeader))) {
+    PLOG(ERROR) << "failed to get the guest state header for thread " << tid;
+    return false;
+  }
+  if (header.signature != NATIVE_BRIDGE_GUEST_STATE_SIGNATURE) {
+    // Return when ptr points to unmapped memory or no valid guest state.
+    return false;
+  }
+  auto guest_state_data_copy = std::make_unique<unsigned char[]>(header.guest_state_data_size);
+  if (!process_memory->ReadFully(reinterpret_cast<uintptr_t>(header.guest_state_data),
+                                 guest_state_data_copy.get(), header.guest_state_data_size)) {
+    PLOG(ERROR) << "failed to read the guest state data for thread " << tid;
+    return false;
+  }
+
+  LoadGuestStateRegisters(guest_state_data_copy.get(), header.guest_state_data_size, guest_regs);
+  return true;
+}
+
+static void ReadGuestRegisters(std::unique_ptr<unwindstack::Regs>* regs, pid_t tid) {
+  NativeBridgeGuestRegs guest_regs;
+  if (!GetGuestRegistersFromCrashedProcess(tid, &guest_regs)) {
+    return;
+  }
+
+  switch (guest_regs.guest_arch) {
+    case NATIVE_BRIDGE_ARCH_ARM: {
+      unwindstack::arm_user_regs arm_user_regs = {};
+      for (size_t i = 0; i < unwindstack::ARM_REG_LAST; i++) {
+        arm_user_regs.regs[i] = guest_regs.regs_arm.r[i];
+      }
+      regs->reset(unwindstack::RegsArm::Read(&arm_user_regs));
+      break;
+    }
+#if defined(__LP64__)
+    case NATIVE_BRIDGE_ARCH_ARM64: {
+      unwindstack::arm64_user_regs arm64_user_regs = {};
+      for (size_t i = 0; i < unwindstack::ARM64_REG_R31; i++) {
+        arm64_user_regs.regs[i] = guest_regs.regs_arm64.x[i];
+      }
+      arm64_user_regs.sp = guest_regs.regs_arm64.sp;
+      arm64_user_regs.pc = guest_regs.regs_arm64.ip;
+      regs->reset(unwindstack::RegsArm64::Read(&arm64_user_regs));
+      break;
+    }
+    case NATIVE_BRIDGE_ARCH_RISCV64: {
+      unwindstack::riscv64_user_regs riscv64_user_regs = {};
+      // RISCV64_REG_PC is at the first position.
+      riscv64_user_regs.regs[0] = guest_regs.regs_riscv64.ip;
+      for (size_t i = 1; i < unwindstack::RISCV64_REG_REAL_COUNT; i++) {
+        riscv64_user_regs.regs[i] = guest_regs.regs_riscv64.x[i];
+      }
+      regs->reset(unwindstack::RegsRiscv64::Read(&riscv64_user_regs, tid));
+      break;
+    }
+#endif
+  }
+}
+
 int main(int argc, char** argv) {
   DefuseSignalHandlers();
   InstallSigPipeHandler();
@@ -537,6 +651,7 @@ int main(int argc, char** argv) {
       }
 
       if (thread == g_target_thread) {
+        ReadGuestRegisters(&info.guest_registers, thread);
         // Read the thread's registers along with the rest of the crash info out of the pipe.
         ReadCrashInfo(input_pipe, &siginfo, &info.registers, &process_info, &recoverable_crash);
         info.siginfo = &siginfo;
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/types.h b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
index 4d69658e2cbd..c799f2448436 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/types.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
@@ -39,6 +39,8 @@ struct ThreadInfo {
 
   int signo = 0;
   siginfo_t* siginfo = nullptr;
+
+  std::unique_ptr<unwindstack::Regs> guest_registers;
 };
 
 // This struct is written into a pipe from inside the crashing process.

From 4c3a9dfd2fc8d120b1b1a8d689e3d0974861b3ea Mon Sep 17 00:00:00 2001
From: Sijie Chen <sijiec@google.com>
Date: Fri, 26 Apr 2024 00:40:22 +0000
Subject: [PATCH 0893/1487] [Berberis][CrashReporting] Dump guest thread info
 to tombstone file

As title.

Bug: b/321799516
Test: riscv64, checked tombstone file has wanted block.
https://paste.googleplex.com/5958508322750464
Added arm64 support and tested arm64 unwinding in internal repo.
https://paste.googleplex.com/6545612887818240

Change-Id: I4e8a3414d0198de88a577ef4d5672a9ad0286fc5
---
 debuggerd/crash_dump.cpp                      | 39 ++++++++++++++++++-
 .../include/libdebuggerd/tombstone.h          |  8 +++-
 debuggerd/libdebuggerd/tombstone.cpp          |  6 ++-
 debuggerd/libdebuggerd/tombstone_proto.cpp    | 34 ++++++++++++++--
 .../libdebuggerd/tombstone_proto_to_text.cpp  | 37 ++++++++++++++++--
 debuggerd/proto/tombstone.proto               |  7 +++-
 6 files changed, 117 insertions(+), 14 deletions(-)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index bc00c86a8ecd..4640aebd5e74 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -30,6 +30,7 @@
 #include <map>
 #include <memory>
 #include <set>
+#include <string>
 #include <vector>
 
 #include <android-base/errno_restorer.h>
@@ -81,6 +82,10 @@ using android::base::ErrnoRestorer;
 using android::base::StringPrintf;
 using android::base::unique_fd;
 
+// This stores guest architecture. When the architecture is supported, tombstone file will output
+// guest state information.
+static Architecture g_guest_arch;
+
 static bool pid_contains_tid(int pid_proc_fd, pid_t tid) {
   struct stat st;
   std::string task_path = StringPrintf("task/%d", tid);
@@ -490,6 +495,8 @@ static void ReadGuestRegisters(std::unique_ptr<unwindstack::Regs>* regs, pid_t t
         arm_user_regs.regs[i] = guest_regs.regs_arm.r[i];
       }
       regs->reset(unwindstack::RegsArm::Read(&arm_user_regs));
+
+      g_guest_arch = Architecture::ARM32;
       break;
     }
 #if defined(__LP64__)
@@ -501,6 +508,8 @@ static void ReadGuestRegisters(std::unique_ptr<unwindstack::Regs>* regs, pid_t t
       arm64_user_regs.sp = guest_regs.regs_arm64.sp;
       arm64_user_regs.pc = guest_regs.regs_arm64.ip;
       regs->reset(unwindstack::RegsArm64::Read(&arm64_user_regs));
+
+      g_guest_arch = Architecture::ARM64;
       break;
     }
     case NATIVE_BRIDGE_ARCH_RISCV64: {
@@ -511,6 +520,8 @@ static void ReadGuestRegisters(std::unique_ptr<unwindstack::Regs>* regs, pid_t t
         riscv64_user_regs.regs[i] = guest_regs.regs_riscv64.x[i];
       }
       regs->reset(unwindstack::RegsRiscv64::Read(&riscv64_user_regs, tid));
+
+      g_guest_arch = Architecture::RISCV64;
       break;
     }
 #endif
@@ -775,8 +786,32 @@ int main(int argc, char** argv) {
 
     {
       ATRACE_NAME("engrave_tombstone");
-      engrave_tombstone(std::move(g_output_fd), std::move(g_proto_fd), &unwinder, thread_info,
-                        g_target_thread, process_info, &open_files, &amfd_data);
+      unwindstack::ArchEnum regs_arch = unwindstack::ARCH_UNKNOWN;
+      switch (g_guest_arch) {
+        case Architecture::ARM32: {
+          regs_arch = unwindstack::ARCH_ARM;
+          break;
+        }
+        case Architecture::ARM64: {
+          regs_arch = unwindstack::ARCH_ARM64;
+          break;
+        }
+        case Architecture::RISCV64: {
+          regs_arch = unwindstack::ARCH_RISCV64;
+          break;
+        }
+        default: {
+        }
+      }
+      if (regs_arch == unwindstack::ARCH_UNKNOWN) {
+        engrave_tombstone(std::move(g_output_fd), std::move(g_proto_fd), &unwinder, thread_info,
+                          g_target_thread, process_info, &open_files, &amfd_data);
+      } else {
+        unwindstack::AndroidRemoteUnwinder guest_unwinder(vm_pid, regs_arch);
+        engrave_tombstone(std::move(g_output_fd), std::move(g_proto_fd), &unwinder, thread_info,
+                          g_target_thread, process_info, &open_files, &amfd_data, &g_guest_arch,
+                          &guest_unwinder);
+      }
     }
   }
 
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
index be999e04e6a0..6371dbe9c804 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
@@ -28,6 +28,7 @@
 #include <android-base/unique_fd.h>
 
 #include "open_files_list.h"
+#include "tombstone.pb.h"
 #include "types.h"
 
 // Forward declarations
@@ -54,14 +55,17 @@ void engrave_tombstone(android::base::unique_fd output_fd, android::base::unique
                        unwindstack::AndroidUnwinder* unwinder,
                        const std::map<pid_t, ThreadInfo>& thread_info, pid_t target_thread,
                        const ProcessInfo& process_info, OpenFilesList* open_files,
-                       std::string* amfd_data);
+                       std::string* amfd_data, Architecture* guest_arch = nullptr,
+                       unwindstack::AndroidUnwinder* guest_unwinder = nullptr);
 
 void engrave_tombstone_ucontext(int tombstone_fd, int proto_fd, uint64_t abort_msg_address,
                                 siginfo_t* siginfo, ucontext_t* ucontext);
 
 void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
                              const std::map<pid_t, ThreadInfo>& threads, pid_t target_thread,
-                             const ProcessInfo& process_info, const OpenFilesList* open_files);
+                             const ProcessInfo& process_info, const OpenFilesList* open_files,
+                             Architecture* guest_arch,
+                             unwindstack::AndroidUnwinder* guest_unwinder);
 
 bool tombstone_proto_to_text(
     const Tombstone& tombstone,
diff --git a/debuggerd/libdebuggerd/tombstone.cpp b/debuggerd/libdebuggerd/tombstone.cpp
index 5a416d64319a..0da2ca7b8712 100644
--- a/debuggerd/libdebuggerd/tombstone.cpp
+++ b/debuggerd/libdebuggerd/tombstone.cpp
@@ -125,10 +125,12 @@ void engrave_tombstone(unique_fd output_fd, unique_fd proto_fd,
                        unwindstack::AndroidUnwinder* unwinder,
                        const std::map<pid_t, ThreadInfo>& threads, pid_t target_thread,
                        const ProcessInfo& process_info, OpenFilesList* open_files,
-                       std::string* amfd_data) {
+                       std::string* amfd_data, Architecture* guest_arch,
+                       unwindstack::AndroidUnwinder* guest_unwinder) {
   // Don't copy log messages to tombstone unless this is a development device.
   Tombstone tombstone;
-  engrave_tombstone_proto(&tombstone, unwinder, threads, target_thread, process_info, open_files);
+  engrave_tombstone_proto(&tombstone, unwinder, threads, target_thread, process_info, open_files,
+                          guest_arch, guest_unwinder);
 
   if (proto_fd != -1) {
     if (!tombstone.SerializeToFileDescriptor(proto_fd.get())) {
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index 5546b7bcc21f..5e170df0ba09 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -482,7 +482,8 @@ static void dump_thread_backtrace(std::vector<unwindstack::FrameData>& frames, T
 }
 
 static void dump_thread(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
-                        const ThreadInfo& thread_info, bool memory_dump = false) {
+                        const ThreadInfo& thread_info, bool memory_dump = false,
+                        unwindstack::AndroidUnwinder* guest_unwinder = nullptr) {
   Thread thread;
 
   thread.set_id(thread_info.tid);
@@ -509,6 +510,26 @@ static void dump_thread(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwi
 
   auto& threads = *tombstone->mutable_threads();
   threads[thread_info.tid] = thread;
+
+  if (guest_unwinder) {
+    if (!thread_info.guest_registers) {
+      async_safe_format_log(ANDROID_LOG_INFO, LOG_TAG,
+                            "No guest state registers information for tid %d", thread_info.tid);
+      return;
+    }
+    Thread guest_thread;
+    unwindstack::AndroidUnwinderData guest_data;
+    guest_data.saved_initial_regs = std::make_optional<std::unique_ptr<unwindstack::Regs>>();
+    if (guest_unwinder->Unwind(thread_info.guest_registers.get(), guest_data)) {
+      dump_thread_backtrace(guest_data.frames, guest_thread);
+    } else {
+      async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG,
+                            "Unwind guest state registers failed for tid %d: Error %s",
+                            thread_info.tid, guest_data.GetErrorString().c_str());
+    }
+    dump_registers(guest_unwinder, *guest_data.saved_initial_regs, guest_thread, memory_dump);
+    *tombstone->mutable_guest_thread() = guest_thread;
+  }
 }
 
 static void dump_mappings(Tombstone* tombstone, unwindstack::Maps* maps,
@@ -686,10 +707,17 @@ static void dump_tags_around_fault_addr(Signal* signal, const Tombstone& tombsto
 
 void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
                              const std::map<pid_t, ThreadInfo>& threads, pid_t target_tid,
-                             const ProcessInfo& process_info, const OpenFilesList* open_files) {
+                             const ProcessInfo& process_info, const OpenFilesList* open_files,
+                             Architecture* guest_arch,
+                             unwindstack::AndroidUnwinder* guest_unwinder) {
   Tombstone result;
 
   result.set_arch(get_arch());
+  if (guest_arch != nullptr) {
+    result.set_guest_arch(*guest_arch);
+  } else {
+    result.set_guest_arch(Architecture::NONE);
+  }
   result.set_build_fingerprint(android::base::GetProperty("ro.build.fingerprint", "unknown"));
   result.set_revision(android::base::GetProperty("ro.revision", "unknown"));
   result.set_timestamp(get_timestamp());
@@ -750,7 +778,7 @@ void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder*
   dump_abort_message(&result, unwinder->GetProcessMemory(), process_info);
   dump_crash_details(&result, unwinder->GetProcessMemory(), process_info);
   // Dump the target thread, but save the memory around the registers.
-  dump_thread(&result, unwinder, target_thread, /* memory_dump */ true);
+  dump_thread(&result, unwinder, target_thread, /* memory_dump */ true, guest_unwinder);
 
   for (const auto& [tid, thread_info] : threads) {
     if (tid != target_tid) {
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index 08c1cc0dae12..7b296923b4b9 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -79,8 +79,8 @@ static std::string describe_pac_enabled_keys(long value) {
   return describe_end(value, desc);
 }
 
-static const char* abi_string(const Tombstone& tombstone) {
-  switch (tombstone.arch()) {
+static const char* abi_string(const Architecture& arch) {
+  switch (arch) {
     case Architecture::ARM32:
       return "arm";
     case Architecture::ARM64:
@@ -578,11 +578,37 @@ void print_logs(CallbackType callback, const Tombstone& tombstone, int tail) {
   }
 }
 
+static void print_guest_thread(CallbackType callback, const Tombstone& tombstone,
+                               const Thread& guest_thread) {
+  CBS("--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---");
+  CBS("Guest thread information");
+  print_thread_registers(callback, tombstone, guest_thread, true);
+
+  CBS("");
+  CB(true, "%d total frames", guest_thread.current_backtrace().size());
+  CB(true, "backtrace:");
+  print_backtrace(callback, tombstone, guest_thread.current_backtrace(), true);
+
+  print_thread_memory_dump(callback, tombstone, guest_thread);
+
+  CBS("");
+
+  // No memory maps to print.
+  if (!tombstone.memory_mappings().empty()) {
+    print_memory_maps(callback, tombstone);
+  } else {
+    CBS("No memory maps found");
+  }
+}
+
 bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback) {
   CBL("*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***");
   CBL("Build fingerprint: '%s'", tombstone.build_fingerprint().c_str());
   CBL("Revision: '%s'", tombstone.revision().c_str());
-  CBL("ABI: '%s'", abi_string(tombstone));
+  CBL("ABI: '%s'", abi_string(tombstone.arch()));
+  if (tombstone.guest_arch() != Architecture::NONE) {
+    CBL("Guest architecture: '%s'", abi_string(tombstone.guest_arch()));
+  }
   CBL("Timestamp: %s", tombstone.timestamp().c_str());
   CBL("Process uptime: %ds", tombstone.process_uptime());
 
@@ -635,5 +661,10 @@ bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback)
 
   print_logs(callback, tombstone, 0);
 
+  // Process guest thread
+  if (tombstone.has_guest_thread()) {
+    print_guest_thread(callback, tombstone, tombstone.guest_thread());
+  }
+
   return true;
 }
diff --git a/debuggerd/proto/tombstone.proto b/debuggerd/proto/tombstone.proto
index e70d525ee914..4ddc54ff3eed 100644
--- a/debuggerd/proto/tombstone.proto
+++ b/debuggerd/proto/tombstone.proto
@@ -22,6 +22,7 @@ message CrashDetail {
 
 message Tombstone {
   Architecture arch = 1;
+  Architecture guest_arch = 24;
   string build_fingerprint = 2;
   string revision = 3;
   string timestamp = 4;
@@ -42,6 +43,7 @@ message Tombstone {
   repeated Cause causes = 15;
 
   map<uint32, Thread> threads = 16;
+  Thread guest_thread = 25;
   repeated MemoryMapping memory_mappings = 17;
   repeated LogBuffer log_buffers = 18;
   repeated FD open_fds = 19;
@@ -49,7 +51,7 @@ message Tombstone {
   uint32 page_size = 22;
   bool has_been_16kb_mode = 23;
 
-  reserved 24 to 999;
+  reserved 26 to 999;
 }
 
 enum Architecture {
@@ -58,8 +60,9 @@ enum Architecture {
   X86 = 2;
   X86_64 = 3;
   RISCV64 = 4;
+  NONE = 5;
 
-  reserved 5 to 999;
+  reserved 6 to 999;
 }
 
 message Signal {

From 899c1bdfa185f1432e4b955a38478e4a984675fb Mon Sep 17 00:00:00 2001
From: Dimitry Ivanov <dimitry@google.com>
Date: Fri, 10 May 2024 10:02:07 +0000
Subject: [PATCH 0894/1487] Revert "[Berberis][CrashReporting] Dump guest
 thread info to tom..."

Revert submission 3062926

Reason for revert: We want guest state to be present in all threads - revert to be able to fix the proto field type.

Reverted changes: /q/submissionid:3062926

Change-Id: I87b282a0d9caebe4eae2e7d8eca8ec8ebaa3eca6
---
 debuggerd/crash_dump.cpp                      | 39 +------------------
 .../include/libdebuggerd/tombstone.h          |  8 +---
 debuggerd/libdebuggerd/tombstone.cpp          |  6 +--
 debuggerd/libdebuggerd/tombstone_proto.cpp    | 34 ++--------------
 .../libdebuggerd/tombstone_proto_to_text.cpp  | 37 ++----------------
 debuggerd/proto/tombstone.proto               |  7 +---
 6 files changed, 14 insertions(+), 117 deletions(-)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 4640aebd5e74..bc00c86a8ecd 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -30,7 +30,6 @@
 #include <map>
 #include <memory>
 #include <set>
-#include <string>
 #include <vector>
 
 #include <android-base/errno_restorer.h>
@@ -82,10 +81,6 @@ using android::base::ErrnoRestorer;
 using android::base::StringPrintf;
 using android::base::unique_fd;
 
-// This stores guest architecture. When the architecture is supported, tombstone file will output
-// guest state information.
-static Architecture g_guest_arch;
-
 static bool pid_contains_tid(int pid_proc_fd, pid_t tid) {
   struct stat st;
   std::string task_path = StringPrintf("task/%d", tid);
@@ -495,8 +490,6 @@ static void ReadGuestRegisters(std::unique_ptr<unwindstack::Regs>* regs, pid_t t
         arm_user_regs.regs[i] = guest_regs.regs_arm.r[i];
       }
       regs->reset(unwindstack::RegsArm::Read(&arm_user_regs));
-
-      g_guest_arch = Architecture::ARM32;
       break;
     }
 #if defined(__LP64__)
@@ -508,8 +501,6 @@ static void ReadGuestRegisters(std::unique_ptr<unwindstack::Regs>* regs, pid_t t
       arm64_user_regs.sp = guest_regs.regs_arm64.sp;
       arm64_user_regs.pc = guest_regs.regs_arm64.ip;
       regs->reset(unwindstack::RegsArm64::Read(&arm64_user_regs));
-
-      g_guest_arch = Architecture::ARM64;
       break;
     }
     case NATIVE_BRIDGE_ARCH_RISCV64: {
@@ -520,8 +511,6 @@ static void ReadGuestRegisters(std::unique_ptr<unwindstack::Regs>* regs, pid_t t
         riscv64_user_regs.regs[i] = guest_regs.regs_riscv64.x[i];
       }
       regs->reset(unwindstack::RegsRiscv64::Read(&riscv64_user_regs, tid));
-
-      g_guest_arch = Architecture::RISCV64;
       break;
     }
 #endif
@@ -786,32 +775,8 @@ int main(int argc, char** argv) {
 
     {
       ATRACE_NAME("engrave_tombstone");
-      unwindstack::ArchEnum regs_arch = unwindstack::ARCH_UNKNOWN;
-      switch (g_guest_arch) {
-        case Architecture::ARM32: {
-          regs_arch = unwindstack::ARCH_ARM;
-          break;
-        }
-        case Architecture::ARM64: {
-          regs_arch = unwindstack::ARCH_ARM64;
-          break;
-        }
-        case Architecture::RISCV64: {
-          regs_arch = unwindstack::ARCH_RISCV64;
-          break;
-        }
-        default: {
-        }
-      }
-      if (regs_arch == unwindstack::ARCH_UNKNOWN) {
-        engrave_tombstone(std::move(g_output_fd), std::move(g_proto_fd), &unwinder, thread_info,
-                          g_target_thread, process_info, &open_files, &amfd_data);
-      } else {
-        unwindstack::AndroidRemoteUnwinder guest_unwinder(vm_pid, regs_arch);
-        engrave_tombstone(std::move(g_output_fd), std::move(g_proto_fd), &unwinder, thread_info,
-                          g_target_thread, process_info, &open_files, &amfd_data, &g_guest_arch,
-                          &guest_unwinder);
-      }
+      engrave_tombstone(std::move(g_output_fd), std::move(g_proto_fd), &unwinder, thread_info,
+                        g_target_thread, process_info, &open_files, &amfd_data);
     }
   }
 
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
index 6371dbe9c804..be999e04e6a0 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
@@ -28,7 +28,6 @@
 #include <android-base/unique_fd.h>
 
 #include "open_files_list.h"
-#include "tombstone.pb.h"
 #include "types.h"
 
 // Forward declarations
@@ -55,17 +54,14 @@ void engrave_tombstone(android::base::unique_fd output_fd, android::base::unique
                        unwindstack::AndroidUnwinder* unwinder,
                        const std::map<pid_t, ThreadInfo>& thread_info, pid_t target_thread,
                        const ProcessInfo& process_info, OpenFilesList* open_files,
-                       std::string* amfd_data, Architecture* guest_arch = nullptr,
-                       unwindstack::AndroidUnwinder* guest_unwinder = nullptr);
+                       std::string* amfd_data);
 
 void engrave_tombstone_ucontext(int tombstone_fd, int proto_fd, uint64_t abort_msg_address,
                                 siginfo_t* siginfo, ucontext_t* ucontext);
 
 void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
                              const std::map<pid_t, ThreadInfo>& threads, pid_t target_thread,
-                             const ProcessInfo& process_info, const OpenFilesList* open_files,
-                             Architecture* guest_arch,
-                             unwindstack::AndroidUnwinder* guest_unwinder);
+                             const ProcessInfo& process_info, const OpenFilesList* open_files);
 
 bool tombstone_proto_to_text(
     const Tombstone& tombstone,
diff --git a/debuggerd/libdebuggerd/tombstone.cpp b/debuggerd/libdebuggerd/tombstone.cpp
index 0da2ca7b8712..5a416d64319a 100644
--- a/debuggerd/libdebuggerd/tombstone.cpp
+++ b/debuggerd/libdebuggerd/tombstone.cpp
@@ -125,12 +125,10 @@ void engrave_tombstone(unique_fd output_fd, unique_fd proto_fd,
                        unwindstack::AndroidUnwinder* unwinder,
                        const std::map<pid_t, ThreadInfo>& threads, pid_t target_thread,
                        const ProcessInfo& process_info, OpenFilesList* open_files,
-                       std::string* amfd_data, Architecture* guest_arch,
-                       unwindstack::AndroidUnwinder* guest_unwinder) {
+                       std::string* amfd_data) {
   // Don't copy log messages to tombstone unless this is a development device.
   Tombstone tombstone;
-  engrave_tombstone_proto(&tombstone, unwinder, threads, target_thread, process_info, open_files,
-                          guest_arch, guest_unwinder);
+  engrave_tombstone_proto(&tombstone, unwinder, threads, target_thread, process_info, open_files);
 
   if (proto_fd != -1) {
     if (!tombstone.SerializeToFileDescriptor(proto_fd.get())) {
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index 5e170df0ba09..5546b7bcc21f 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -482,8 +482,7 @@ static void dump_thread_backtrace(std::vector<unwindstack::FrameData>& frames, T
 }
 
 static void dump_thread(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
-                        const ThreadInfo& thread_info, bool memory_dump = false,
-                        unwindstack::AndroidUnwinder* guest_unwinder = nullptr) {
+                        const ThreadInfo& thread_info, bool memory_dump = false) {
   Thread thread;
 
   thread.set_id(thread_info.tid);
@@ -510,26 +509,6 @@ static void dump_thread(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwi
 
   auto& threads = *tombstone->mutable_threads();
   threads[thread_info.tid] = thread;
-
-  if (guest_unwinder) {
-    if (!thread_info.guest_registers) {
-      async_safe_format_log(ANDROID_LOG_INFO, LOG_TAG,
-                            "No guest state registers information for tid %d", thread_info.tid);
-      return;
-    }
-    Thread guest_thread;
-    unwindstack::AndroidUnwinderData guest_data;
-    guest_data.saved_initial_regs = std::make_optional<std::unique_ptr<unwindstack::Regs>>();
-    if (guest_unwinder->Unwind(thread_info.guest_registers.get(), guest_data)) {
-      dump_thread_backtrace(guest_data.frames, guest_thread);
-    } else {
-      async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG,
-                            "Unwind guest state registers failed for tid %d: Error %s",
-                            thread_info.tid, guest_data.GetErrorString().c_str());
-    }
-    dump_registers(guest_unwinder, *guest_data.saved_initial_regs, guest_thread, memory_dump);
-    *tombstone->mutable_guest_thread() = guest_thread;
-  }
 }
 
 static void dump_mappings(Tombstone* tombstone, unwindstack::Maps* maps,
@@ -707,17 +686,10 @@ static void dump_tags_around_fault_addr(Signal* signal, const Tombstone& tombsto
 
 void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
                              const std::map<pid_t, ThreadInfo>& threads, pid_t target_tid,
-                             const ProcessInfo& process_info, const OpenFilesList* open_files,
-                             Architecture* guest_arch,
-                             unwindstack::AndroidUnwinder* guest_unwinder) {
+                             const ProcessInfo& process_info, const OpenFilesList* open_files) {
   Tombstone result;
 
   result.set_arch(get_arch());
-  if (guest_arch != nullptr) {
-    result.set_guest_arch(*guest_arch);
-  } else {
-    result.set_guest_arch(Architecture::NONE);
-  }
   result.set_build_fingerprint(android::base::GetProperty("ro.build.fingerprint", "unknown"));
   result.set_revision(android::base::GetProperty("ro.revision", "unknown"));
   result.set_timestamp(get_timestamp());
@@ -778,7 +750,7 @@ void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder*
   dump_abort_message(&result, unwinder->GetProcessMemory(), process_info);
   dump_crash_details(&result, unwinder->GetProcessMemory(), process_info);
   // Dump the target thread, but save the memory around the registers.
-  dump_thread(&result, unwinder, target_thread, /* memory_dump */ true, guest_unwinder);
+  dump_thread(&result, unwinder, target_thread, /* memory_dump */ true);
 
   for (const auto& [tid, thread_info] : threads) {
     if (tid != target_tid) {
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index 7b296923b4b9..08c1cc0dae12 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -79,8 +79,8 @@ static std::string describe_pac_enabled_keys(long value) {
   return describe_end(value, desc);
 }
 
-static const char* abi_string(const Architecture& arch) {
-  switch (arch) {
+static const char* abi_string(const Tombstone& tombstone) {
+  switch (tombstone.arch()) {
     case Architecture::ARM32:
       return "arm";
     case Architecture::ARM64:
@@ -578,37 +578,11 @@ void print_logs(CallbackType callback, const Tombstone& tombstone, int tail) {
   }
 }
 
-static void print_guest_thread(CallbackType callback, const Tombstone& tombstone,
-                               const Thread& guest_thread) {
-  CBS("--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---");
-  CBS("Guest thread information");
-  print_thread_registers(callback, tombstone, guest_thread, true);
-
-  CBS("");
-  CB(true, "%d total frames", guest_thread.current_backtrace().size());
-  CB(true, "backtrace:");
-  print_backtrace(callback, tombstone, guest_thread.current_backtrace(), true);
-
-  print_thread_memory_dump(callback, tombstone, guest_thread);
-
-  CBS("");
-
-  // No memory maps to print.
-  if (!tombstone.memory_mappings().empty()) {
-    print_memory_maps(callback, tombstone);
-  } else {
-    CBS("No memory maps found");
-  }
-}
-
 bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback) {
   CBL("*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***");
   CBL("Build fingerprint: '%s'", tombstone.build_fingerprint().c_str());
   CBL("Revision: '%s'", tombstone.revision().c_str());
-  CBL("ABI: '%s'", abi_string(tombstone.arch()));
-  if (tombstone.guest_arch() != Architecture::NONE) {
-    CBL("Guest architecture: '%s'", abi_string(tombstone.guest_arch()));
-  }
+  CBL("ABI: '%s'", abi_string(tombstone));
   CBL("Timestamp: %s", tombstone.timestamp().c_str());
   CBL("Process uptime: %ds", tombstone.process_uptime());
 
@@ -661,10 +635,5 @@ bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback)
 
   print_logs(callback, tombstone, 0);
 
-  // Process guest thread
-  if (tombstone.has_guest_thread()) {
-    print_guest_thread(callback, tombstone, tombstone.guest_thread());
-  }
-
   return true;
 }
diff --git a/debuggerd/proto/tombstone.proto b/debuggerd/proto/tombstone.proto
index 4ddc54ff3eed..e70d525ee914 100644
--- a/debuggerd/proto/tombstone.proto
+++ b/debuggerd/proto/tombstone.proto
@@ -22,7 +22,6 @@ message CrashDetail {
 
 message Tombstone {
   Architecture arch = 1;
-  Architecture guest_arch = 24;
   string build_fingerprint = 2;
   string revision = 3;
   string timestamp = 4;
@@ -43,7 +42,6 @@ message Tombstone {
   repeated Cause causes = 15;
 
   map<uint32, Thread> threads = 16;
-  Thread guest_thread = 25;
   repeated MemoryMapping memory_mappings = 17;
   repeated LogBuffer log_buffers = 18;
   repeated FD open_fds = 19;
@@ -51,7 +49,7 @@ message Tombstone {
   uint32 page_size = 22;
   bool has_been_16kb_mode = 23;
 
-  reserved 26 to 999;
+  reserved 24 to 999;
 }
 
 enum Architecture {
@@ -60,9 +58,8 @@ enum Architecture {
   X86 = 2;
   X86_64 = 3;
   RISCV64 = 4;
-  NONE = 5;
 
-  reserved 6 to 999;
+  reserved 5 to 999;
 }
 
 message Signal {

From cdf499f9cdfe35711ad011d133ccbc6565960c37 Mon Sep 17 00:00:00 2001
From: Dimitry Ivanov <dimitry@google.com>
Date: Fri, 10 May 2024 10:02:07 +0000
Subject: [PATCH 0895/1487] Revert "[Berberis][CrashReporting] Extend
 ThreadInfo to have gue..."

Revert submission 3062926

Reason for revert: We want guest state to be present in all threads - revert to be able to fix the proto field type.

Reverted changes: /q/submissionid:3062926

Change-Id: I32b745cca95a619b78bdce0a7d948ac479d42f21
---
 debuggerd/Android.bp                          |  12 --
 debuggerd/crash_dump.cpp                      | 115 ------------------
 .../libdebuggerd/include/libdebuggerd/types.h |   2 -
 3 files changed, 129 deletions(-)

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 0c5543ed931d..3a882ea8f41f 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -452,7 +452,6 @@ cc_binary {
 
     header_libs: [
         "bionic_libc_platform_headers",
-        "libnative_bridge_support_accessor_headers",
     ],
 
     static_libs: [
@@ -462,8 +461,6 @@ cc_binary {
 
         "libtombstone_proto",
         "libprotobuf-cpp-lite",
-
-        "libnative_bridge_guest_state_accessor",
     ],
 
     shared_libs: [
@@ -479,15 +476,6 @@ cc_binary {
 
     // Required for tests.
     required: ["crash_dump.policy"],
-
-    target: {
-        android: {
-            header_libs: [
-                "libnative_bridge_support_accessor_headers", // For dlext_namespaces.h
-            ],
-            shared_libs: ["libdl_android"], // For android_get_exported_namespace implementation
-        },
-    },
 }
 
 cc_binary {
diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index bc00c86a8ecd..203b4855b3b0 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -25,7 +25,6 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
-#include <cstdint>
 #include <limits>
 #include <map>
 #include <memory>
@@ -43,7 +42,6 @@
 #include <android-base/unique_fd.h>
 #include <bionic/macros.h>
 #include <bionic/reserved_signals.h>
-#include <bionic/tls_defines.h>
 #include <cutils/sockets.h>
 #include <log/log.h>
 #include <private/android_filesystem_config.h>
@@ -54,18 +52,7 @@
 
 #include <unwindstack/AndroidUnwinder.h>
 #include <unwindstack/Error.h>
-#include <unwindstack/MachineArm.h>
-#include <unwindstack/MachineArm64.h>
-#include <unwindstack/MachineRiscv64.h>
 #include <unwindstack/Regs.h>
-#include <unwindstack/RegsArm.h>
-#include <unwindstack/RegsArm64.h>
-#include <unwindstack/RegsRiscv64.h>
-#include <unwindstack/UserArm.h>
-#include <unwindstack/UserArm64.h>
-#include <unwindstack/UserRiscv64.h>
-
-#include <native_bridge_support/guest_state_accessor/accessor.h>
 
 #include "libdebuggerd/backtrace.h"
 #include "libdebuggerd/tombstone.h"
@@ -416,107 +403,6 @@ static void InstallSigPipeHandler() {
   sigaction(SIGPIPE, &action, nullptr);
 }
 
-static bool PtracePeek(int request, pid_t tid, uintptr_t addr, void* data, std::string err_msg,
-                       uintptr_t* result) {
-  errno = 0;
-  *result = ptrace(request, tid, addr, data);
-  if (errno != 0) {
-    PLOG(ERROR) << err_msg;
-    return false;
-  }
-  return true;
-}
-
-static bool GetGuestRegistersFromCrashedProcess([[maybe_unused]] pid_t tid,
-                                                NativeBridgeGuestRegs* guest_regs) {
-  auto process_memory = unwindstack::Memory::CreateProcessMemoryCached(tid);
-
-  uintptr_t header_ptr = 0;
-  uintptr_t base = 0;
-#if defined(__x86_64__)
-  if (!PtracePeek(PTRACE_PEEKUSER, tid, offsetof(user_regs_struct, fs_base), nullptr,
-                  "failed to read thread register for thread " + std::to_string(tid), &base)) {
-    return false;
-  }
-#elif defined(__aarch64__)
-  // base is implicitly casted to uint64_t.
-  struct iovec pt_iov {
-    .iov_base = &base, .iov_len = sizeof(base),
-  };
-
-  if (ptrace(PTRACE_GETREGSET, tid, NT_ARM_TLS, &pt_iov) != 0) {
-    PLOG(ERROR) << "failed to read thread register for thread " << tid;
-  }
-#else
-  // TODO(b/339287219): Add case for Riscv host.
-  return false;
-#endif
-  auto ptr_to_guest_slot = base + TLS_SLOT_NATIVE_BRIDGE_GUEST_STATE * sizeof(uintptr_t);
-  if (!process_memory->ReadFully(ptr_to_guest_slot, &header_ptr, sizeof(uintptr_t))) {
-    PLOG(ERROR) << "failed to get guest state TLS slot content for thread " << tid;
-    return false;
-  }
-
-  NativeBridgeGuestStateHeader header;
-  if (!process_memory->ReadFully(header_ptr, &header, sizeof(NativeBridgeGuestStateHeader))) {
-    PLOG(ERROR) << "failed to get the guest state header for thread " << tid;
-    return false;
-  }
-  if (header.signature != NATIVE_BRIDGE_GUEST_STATE_SIGNATURE) {
-    // Return when ptr points to unmapped memory or no valid guest state.
-    return false;
-  }
-  auto guest_state_data_copy = std::make_unique<unsigned char[]>(header.guest_state_data_size);
-  if (!process_memory->ReadFully(reinterpret_cast<uintptr_t>(header.guest_state_data),
-                                 guest_state_data_copy.get(), header.guest_state_data_size)) {
-    PLOG(ERROR) << "failed to read the guest state data for thread " << tid;
-    return false;
-  }
-
-  LoadGuestStateRegisters(guest_state_data_copy.get(), header.guest_state_data_size, guest_regs);
-  return true;
-}
-
-static void ReadGuestRegisters(std::unique_ptr<unwindstack::Regs>* regs, pid_t tid) {
-  NativeBridgeGuestRegs guest_regs;
-  if (!GetGuestRegistersFromCrashedProcess(tid, &guest_regs)) {
-    return;
-  }
-
-  switch (guest_regs.guest_arch) {
-    case NATIVE_BRIDGE_ARCH_ARM: {
-      unwindstack::arm_user_regs arm_user_regs = {};
-      for (size_t i = 0; i < unwindstack::ARM_REG_LAST; i++) {
-        arm_user_regs.regs[i] = guest_regs.regs_arm.r[i];
-      }
-      regs->reset(unwindstack::RegsArm::Read(&arm_user_regs));
-      break;
-    }
-#if defined(__LP64__)
-    case NATIVE_BRIDGE_ARCH_ARM64: {
-      unwindstack::arm64_user_regs arm64_user_regs = {};
-      for (size_t i = 0; i < unwindstack::ARM64_REG_R31; i++) {
-        arm64_user_regs.regs[i] = guest_regs.regs_arm64.x[i];
-      }
-      arm64_user_regs.sp = guest_regs.regs_arm64.sp;
-      arm64_user_regs.pc = guest_regs.regs_arm64.ip;
-      regs->reset(unwindstack::RegsArm64::Read(&arm64_user_regs));
-      break;
-    }
-    case NATIVE_BRIDGE_ARCH_RISCV64: {
-      unwindstack::riscv64_user_regs riscv64_user_regs = {};
-      // RISCV64_REG_PC is at the first position.
-      riscv64_user_regs.regs[0] = guest_regs.regs_riscv64.ip;
-      for (size_t i = 1; i < unwindstack::RISCV64_REG_REAL_COUNT; i++) {
-        riscv64_user_regs.regs[i] = guest_regs.regs_riscv64.x[i];
-      }
-      regs->reset(unwindstack::RegsRiscv64::Read(&riscv64_user_regs, tid));
-      break;
-    }
-#endif
-  }
-}
-
 int main(int argc, char** argv) {
   DefuseSignalHandlers();
   InstallSigPipeHandler();
@@ -651,7 +537,6 @@ int main(int argc, char** argv) {
       }
 
       if (thread == g_target_thread) {
-        ReadGuestRegisters(&info.guest_registers, thread);
         // Read the thread's registers along with the rest of the crash info out of the pipe.
         ReadCrashInfo(input_pipe, &siginfo, &info.registers, &process_info, &recoverable_crash);
         info.siginfo = &siginfo;
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/types.h b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
index c799f2448436..4d69658e2cbd 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/types.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
@@ -39,8 +39,6 @@ struct ThreadInfo {
 
   int signo = 0;
   siginfo_t* siginfo = nullptr;
-
-  std::unique_ptr<unwindstack::Regs> guest_registers;
 };
 
 // This struct is written into a pipe from inside the crashing process.

From 7ae58649ae74fd40b89451f0669fa0756f3affd4 Mon Sep 17 00:00:00 2001
From: Keir Fraser <keirf@google.com>
Date: Mon, 13 May 2024 13:09:18 +0000
Subject: [PATCH 0896/1487] mkbootfs: Fix -f typo in usage message

Bug: 328362894
Change-Id: I559fb2640cb9fda7dbba172709ad1c3a7f3b6dd9
---
 mkbootfs/mkbootfs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mkbootfs/mkbootfs.c b/mkbootfs/mkbootfs.c
index d3922bf1a0f9..569a10cf9496 100644
--- a/mkbootfs/mkbootfs.c
+++ b/mkbootfs/mkbootfs.c
@@ -402,7 +402,7 @@ static const struct option long_options[] = {
 static void usage(void)
 {
     fprintf(stderr,
-            "Usage: mkbootfs [-n FILE] [-d DIR|-F FILE] DIR...\n"
+            "Usage: mkbootfs [-n FILE] [-d DIR|-f FILE] DIR...\n"
             "\n"
             "\t-d, --dirname=DIR: fs-config directory\n"
             "\t-f, --file=FILE: Canned configuration file\n"

From b2016ecadc9370df57abb447d7a1ef0aeae6823f Mon Sep 17 00:00:00 2001
From: Keir Fraser <keirf@google.com>
Date: Mon, 13 May 2024 10:07:26 +0000
Subject: [PATCH 0897/1487] mkbootfs: Fix usage message for dev node list files

Bug: 328362894
Change-Id: If44918c52ff5bb0ca207fa4817ac14ae5af8c55f
---
 mkbootfs/mkbootfs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/mkbootfs/mkbootfs.c b/mkbootfs/mkbootfs.c
index 569a10cf9496..eaa5d55b4070 100644
--- a/mkbootfs/mkbootfs.c
+++ b/mkbootfs/mkbootfs.c
@@ -410,11 +410,11 @@ static void usage(void)
             "\t-n, --nodes=FILE: Dev nodes description file\n"
             "\n"
             "Dev nodes description:\n"
-            "\t[dir|nod] [perms] [uid] [gid] [c|b] [minor] [major]\n"
+            "\t[dir|nod] [perms] [uid] [gid] [c|b] [major] [minor]\n"
             "\tExample:\n"
             "\t\t# My device nodes\n"
             "\t\tdir dev 0755 0 0\n"
-            "\t\tnod dev/null 0600 0 0 c 1 5\n"
+            "\t\tnod dev/null 0600 0 0 c 1 3\n"
     );
 }
 

From 3e0d4b9f77567ab02a7c7892bfedbed21937360a Mon Sep 17 00:00:00 2001
From: Donnie Pollitz <donpollitz@google.com>
Date: Mon, 22 Apr 2024 18:57:40 +0000
Subject: [PATCH 0898/1487] Merge "storageproxyd: Add arguments for storage
 mapping and max file" into main am: 63ef65c138 am: 0d49c512be

Original change: https://android-review.googlesource.com/c/platform/system/core/+/2994377

Bug: 324989972
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:b041bf19a182c311424f9647f7a06da25b0fe8b5)
Merged-In: I67261a520bef86d2cf8f13e1c0f9731c4ed0b6f6
Change-Id: I67261a520bef86d2cf8f13e1c0f9731c4ed0b6f6
---
 trusty/storage/proxy/proxy.c   |  73 ++++++++-
 trusty/storage/proxy/storage.c | 287 +++++++++++++++++++++++++++++----
 trusty/storage/proxy/storage.h |  11 +-
 3 files changed, 340 insertions(+), 31 deletions(-)

diff --git a/trusty/storage/proxy/proxy.c b/trusty/storage/proxy/proxy.c
index 67e935e39324..6cb72d59765f 100644
--- a/trusty/storage/proxy/proxy.c
+++ b/trusty/storage/proxy/proxy.c
@@ -41,9 +41,13 @@ static const char* ss_data_root;
 static const char* trusty_devname;
 static const char* rpmb_devname;
 static const char* ss_srv_name = STORAGE_DISK_PROXY_PORT;
+static const char* max_file_size_from;
 
 static enum dev_type dev_type = MMC_RPMB;
 
+/* List head for storage mapping, elements added at init, and never removed */
+static struct storage_mapping_node* storage_mapping_head;
+
 static enum dev_type parse_dev_type(const char* dev_type_name) {
     if (!strcmp(dev_type_name, "mmc")) {
         return MMC_RPMB;
@@ -58,17 +62,61 @@ static enum dev_type parse_dev_type(const char* dev_type_name) {
     }
 }
 
-static const char* _sopts = "hp:d:r:t:";
+static int parse_and_append_file_mapping(const char* file_mapping) {
+    if (file_mapping == NULL) {
+        ALOGE("Provided file mapping is null\n");
+        return -1;
+    }
+    char* file_mapping_dup = strdup(file_mapping);
+    if (file_mapping_dup == NULL) {
+        ALOGE("Couldn't duplicate string: %s\n", file_mapping);
+        return -1;
+    }
+    const char* file_name = strtok(file_mapping_dup, ":");
+    if (file_name == NULL) {
+        ALOGE("No file name found\n");
+        return -1;
+    }
+    const char* backing_storage = strtok(NULL, ":");
+    if (backing_storage == NULL) {
+        ALOGE("No backing storage found\n");
+        return -1;
+    }
+
+    struct storage_mapping_node* new_node = malloc(sizeof(struct storage_mapping_node));
+    if (new_node == NULL) {
+        ALOGE("Couldn't allocate additional storage_mapping_node\n");
+        return -1;
+    }
+    *new_node = (struct storage_mapping_node){.file_name = file_name,
+                                              .backing_storage = backing_storage,
+                                              .next = storage_mapping_head,
+                                              .fd = -1};
+    storage_mapping_head = new_node;
+    return 0;
+}
+
+static const char* _sopts = "hp:d:r:t:m:f:";
 static const struct option _lopts[] = {{"help", no_argument, NULL, 'h'},
                                        {"trusty_dev", required_argument, NULL, 'd'},
                                        {"data_path", required_argument, NULL, 'p'},
                                        {"rpmb_dev", required_argument, NULL, 'r'},
                                        {"dev_type", required_argument, NULL, 't'},
+                                       {"max_file_size_from", required_argument, NULL, 'm'},
+                                       {"file_storage_mapping", required_argument, NULL, 'f'},
                                        {0, 0, 0, 0}};
 
 static void show_usage_and_exit(int code) {
-    ALOGE("usage: storageproxyd -d <trusty_dev> -p <data_path> -r <rpmb_dev> -t <dev_type>\n");
+    ALOGE("usage: storageproxyd -d <trusty_dev> -p <data_path> -r <rpmb_dev> -t <dev_type>  [-m "
+          "<file>] [-f <file>:<mapping>]\n");
     ALOGE("Available dev types: mmc, virt\n");
+    ALOGE("-f = Maps secure storage files like `0` and `persist/0`\n"
+          "to block devices.  Storageproxyd will handle creating the\n"
+          "appropriate symlinks in the root datapath.\n");
+    ALOGE("-m = Specifies the max size constraint for file backed storages.\n"
+          "The constraint is chosen by giving a file, this allows for passing a\n"
+          "block device for which a max file size can be queried.  File based\n"
+          "storages will be constrained to that size as well.\n");
     exit(code);
 }
 
@@ -187,6 +235,7 @@ static int proxy_loop(void) {
 static void parse_args(int argc, char* argv[]) {
     int opt;
     int oidx = 0;
+    int rc = 0;
 
     while ((opt = getopt_long(argc, argv, _sopts, _lopts, &oidx)) != -1) {
         switch (opt) {
@@ -210,6 +259,18 @@ static void parse_args(int argc, char* argv[]) {
                 }
                 break;
 
+            case 'f':
+                rc = parse_and_append_file_mapping(optarg);
+                if (rc < 0) {
+                    ALOGE("Failed to parse file mapping: %s\n", optarg);
+                    show_usage_and_exit(EXIT_FAILURE);
+                }
+                break;
+
+            case 'm':
+                max_file_size_from = strdup(optarg);
+                break;
+
             default:
                 ALOGE("unrecognized option (%c):\n", opt);
                 show_usage_and_exit(EXIT_FAILURE);
@@ -225,6 +286,12 @@ static void parse_args(int argc, char* argv[]) {
     ALOGI("storage data root: %s\n", ss_data_root);
     ALOGI("trusty dev: %s\n", trusty_devname);
     ALOGI("rpmb dev: %s\n", rpmb_devname);
+    ALOGI("File Mappings: \n");
+    const struct storage_mapping_node* curr = storage_mapping_head;
+    for (; curr != NULL; curr = curr->next) {
+        ALOGI("\t%s -> %s\n", curr->file_name, curr->backing_storage);
+    }
+    ALOGI("max file size from: %s\n", max_file_size_from ? max_file_size_from : "(unset)");
 }
 
 int main(int argc, char* argv[]) {
@@ -252,7 +319,7 @@ int main(int argc, char* argv[]) {
     ABinderProcess_startThreadPool();
 
     /* initialize secure storage directory */
-    rc = storage_init(ss_data_root);
+    rc = storage_init(ss_data_root, storage_mapping_head, max_file_size_from);
     if (rc < 0) return EXIT_FAILURE;
 
     /* open rpmb device */
diff --git a/trusty/storage/proxy/storage.c b/trusty/storage/proxy/storage.c
index 8c8edb779e6a..1dab93d9c6a6 100644
--- a/trusty/storage/proxy/storage.c
+++ b/trusty/storage/proxy/storage.c
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <assert.h>
 #include <cutils/properties.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -39,16 +40,20 @@
 #define ALTERNATE_DATA_DIR "alternate/"
 
 /* Maximum file size for filesystem backed storage (i.e. not block dev backed storage) */
-#define MAX_FILE_SIZE (0x10000000000)
+static size_t max_file_size = 0x10000000000;
 
 enum sync_state {
     SS_UNUSED = -1,
-    SS_CLEAN =  0,
-    SS_DIRTY =  1,
+    SS_CLEAN = 0,
+    SS_DIRTY = 1,
+    SS_CLEAN_NEED_SYMLINK = 2,
 };
 
 static const char *ssdir_name;
 
+/* List head for storage mapping, elements added at init, and never removed */
+static struct storage_mapping_node* storage_mapping_head;
+
 /*
  * Property set to 1 after we have opened a file under ssdir_name. The backing
  * files for both TD and TDP are currently located under /data/vendor/ss and can
@@ -75,24 +80,103 @@ static struct {
    uint8_t data[MAX_READ_SIZE];
 }  read_rsp;
 
-static uint32_t insert_fd(int open_flags, int fd)
-{
+static uint32_t insert_fd(int open_flags, int fd, struct storage_mapping_node* node) {
     uint32_t handle = fd;
 
     if (handle < FD_TBL_SIZE) {
-            fd_state[fd] = SS_CLEAN; /* fd clean */
-            if (open_flags & O_TRUNC) {
-                fd_state[fd] = SS_DIRTY;  /* set fd dirty */
-            }
+        fd_state[fd] = SS_CLEAN; /* fd clean */
+        if (open_flags & O_TRUNC) {
+            assert(node == NULL);
+            fd_state[fd] = SS_DIRTY; /* set fd dirty */
+        }
+
+        if (node != NULL) {
+            fd_state[fd] = SS_CLEAN_NEED_SYMLINK;
+        }
     } else {
             ALOGW("%s: untracked fd %u\n", __func__, fd);
             if (open_flags & (O_TRUNC | O_CREAT)) {
                 fs_state = SS_DIRTY;
             }
     }
+
+    if (node != NULL) {
+        node->fd = fd;
+    }
+
     return handle;
 }
 
+static void clear_fd_symlink_status(uint32_t handle, struct storage_mapping_node* entry) {
+    /* Always clear FD, in case fd is not in FD_TBL */
+    entry->fd = -1;
+
+    if (handle >= FD_TBL_SIZE) {
+        ALOGE("%s: untracked fd=%u\n", __func__, handle);
+        return;
+    }
+
+    if (fd_state[handle] == SS_CLEAN_NEED_SYMLINK) {
+        fd_state[handle] = SS_CLEAN;
+    }
+}
+
+static struct storage_mapping_node* get_pending_symlink_mapping(uint32_t handle) {
+    /* Fast lookup failure, is it in FD TBL */
+    if (handle < FD_TBL_SIZE && fd_state[handle] != SS_CLEAN_NEED_SYMLINK) {
+        return NULL;
+    }
+
+    /* Go find our mapping */
+    struct storage_mapping_node* curr = storage_mapping_head;
+    for (; curr != NULL; curr = curr->next) {
+        if (curr->fd == handle) {
+            return curr;
+        }
+    }
+
+    /* Safety check: state inconsistent if we get here with handle inside table range */
+    assert(handle >= FD_TBL_SIZE);
+
+    return NULL;
+};
+
+static int possibly_symlink_and_clear_mapping(uint32_t handle) {
+    struct storage_mapping_node* entry = get_pending_symlink_mapping(handle);
+    if (entry == NULL) {
+        /* No mappings pending */
+        return 0;
+    }
+
+    /* Create full path */
+    char* path = NULL;
+    int rc = asprintf(&path, "%s/%s", ssdir_name, entry->file_name);
+    if (rc < 0) {
+        ALOGE("%s: asprintf failed\n", __func__);
+        return -1;
+    }
+
+    /* Try and setup the symlinking */
+    ALOGI("Creating symlink %s->%s\n", path, entry->backing_storage);
+    rc = symlink(entry->backing_storage, path);
+    if (rc < 0) {
+        ALOGE("%s: error symlinking %s->%s (%s)\n", __func__, path, entry->backing_storage,
+              strerror(errno));
+        free(path);
+        return rc;
+    }
+    free(path);
+
+    clear_fd_symlink_status(handle, entry);
+
+    return rc;
+}
+
+static bool is_pending_symlink(uint32_t handle) {
+    struct storage_mapping_node* entry = get_pending_symlink_mapping(handle);
+    return entry != NULL;
+}
+
 static int lookup_fd(uint32_t handle, bool dirty)
 {
     if (dirty) {
@@ -107,6 +191,12 @@ static int lookup_fd(uint32_t handle, bool dirty)
 
 static int remove_fd(uint32_t handle)
 {
+    /* Cleanup fd in symlink mapping if it exists */
+    struct storage_mapping_node* entry = get_pending_symlink_mapping(handle);
+    if (entry != NULL) {
+        entry->fd = -1;
+    }
+
     if (handle < FD_TBL_SIZE) {
         fd_state[handle] = SS_UNUSED; /* set to uninstalled */
     }
@@ -247,11 +337,73 @@ static void sync_parent(const char* path, struct watcher* watcher) {
     watch_progress(watcher, "done syncing parent");
 }
 
+static struct storage_mapping_node* get_storage_mapping_entry(const char* source) {
+    struct storage_mapping_node* curr = storage_mapping_head;
+    for (; curr != NULL; curr = curr->next) {
+        if (!strcmp(source, curr->file_name)) {
+            ALOGI("Found backing file %s for %s\n", curr->backing_storage, source);
+            return curr;
+        }
+    }
+    return NULL;
+}
+
+static bool is_backing_storage_mapped(const char* source) {
+    const struct storage_mapping_node* curr = storage_mapping_head;
+    for (; curr != NULL; curr = curr->next) {
+        if (!strcmp(source, curr->backing_storage)) {
+            ALOGI("Backed storage mapping exists for %s\n", curr->backing_storage);
+            return true;
+        }
+    }
+    return false;
+}
+
+/* Attempts to open a backed file, if mapped, without creating the symlink. Symlink will be created
+ * later on the first write.  This allows us to continue reporting zero read sizes until the first
+ * write. */
+static int open_possibly_mapped_file(const char* short_path, const char* full_path, int open_flags,
+                                     struct storage_mapping_node** entry) {
+    /* See if mapping exists, report upstream if there is no mapping. */
+    struct storage_mapping_node* mapping_entry = get_storage_mapping_entry(short_path);
+    if (mapping_entry == NULL) {
+        return TEMP_FAILURE_RETRY(open(full_path, open_flags, S_IRUSR | S_IWUSR));
+    }
+
+    /* Check for existence of root path, we don't allow mappings during early boot */
+    struct stat buf = {0};
+    if (stat(ssdir_name, &buf) != 0) {
+        ALOGW("Root path not accessible yet, refuse to open mappings for now.\n");
+        return -1;
+    }
+
+    /* We don't support exclusive opening of mapped files */
+    if (open_flags & O_EXCL) {
+        ALOGE("Requesting exclusive open on backed storage isn't supported: %s\n", full_path);
+        return -1;
+    }
+
+    /* Try and open mapping file */
+    open_flags &= ~(O_CREAT | O_EXCL);
+    ALOGI("%s Attempting to open mapped file: %s\n", __func__, mapping_entry->backing_storage);
+    int fd =
+            TEMP_FAILURE_RETRY(open(mapping_entry->backing_storage, open_flags, S_IRUSR | S_IWUSR));
+    if (fd < 0) {
+        ALOGE("%s Failed to open mapping file: %s\n", __func__, mapping_entry->backing_storage);
+        return -1;
+    }
+
+    /* Let caller know which entry we used for opening */
+    *entry = mapping_entry;
+    return fd;
+}
+
 int storage_file_open(struct storage_msg* msg, const void* r, size_t req_len,
                       struct watcher* watcher) {
     char* path = NULL;
     const struct storage_file_open_req *req = r;
     struct storage_file_open_resp resp = {0};
+    struct storage_mapping_node* mapping_entry = NULL;
 
     if (req_len < sizeof(*req)) {
         ALOGE("%s: invalid request length (%zd < %zd)\n",
@@ -321,14 +473,18 @@ int storage_file_open(struct storage_msg* msg, const void* r, size_t req_len,
         if (req->flags & STORAGE_FILE_OPEN_CREATE_EXCLUSIVE) {
             /* create exclusive */
             open_flags |= O_CREAT | O_EXCL;
-            rc = TEMP_FAILURE_RETRY(open(path, open_flags, S_IRUSR | S_IWUSR));
+
+            /* Look for and attempt opening a mapping, else just do normal open. */
+            rc = open_possibly_mapped_file(req->name, path, open_flags, &mapping_entry);
         } else {
             /* try open first */
             rc = TEMP_FAILURE_RETRY(open(path, open_flags, S_IRUSR | S_IWUSR));
             if (rc == -1 && errno == ENOENT) {
                 /* then try open with O_CREATE */
                 open_flags |= O_CREAT;
-                rc = TEMP_FAILURE_RETRY(open(path, open_flags, S_IRUSR | S_IWUSR));
+
+                /* Look for and attempt opening a mapping, else just do normal open. */
+                rc = open_possibly_mapped_file(req->name, path, open_flags, &mapping_entry);
             }
 
         }
@@ -356,7 +512,7 @@ int storage_file_open(struct storage_msg* msg, const void* r, size_t req_len,
 
     /* at this point rc contains storage file fd */
     msg->result = STORAGE_NO_ERROR;
-    resp.handle = insert_fd(open_flags, rc);
+    resp.handle = insert_fd(open_flags, rc, mapping_entry);
     ALOGV("%s: \"%s\": fd = %u: handle = %d\n",
           __func__, path, rc, resp.handle);
 
@@ -433,6 +589,14 @@ int storage_file_write(struct storage_msg* msg, const void* r, size_t req_len,
         goto err_response;
     }
 
+    /* Handle any delayed symlinking for this handle if any */
+    rc = possibly_symlink_and_clear_mapping(req->handle);
+    if (rc < 0) {
+        ALOGE("Failed to symlink storage\n");
+        msg->result = STORAGE_ERR_GENERIC;
+        goto err_response;
+    }
+
     int fd = lookup_fd(req->handle, true);
     watch_progress(watcher, "writing");
     if (write_with_retry(fd, &req->data[0], req_len - sizeof(*req),
@@ -479,6 +643,14 @@ int storage_file_read(struct storage_msg* msg, const void* r, size_t req_len,
         goto err_response;
     }
 
+    /* If this handle has a delayed symlink we should report 0 size reads until first write occurs
+     */
+    if (is_pending_symlink(req->handle)) {
+        ALOGI("Pending symlink: Forcing read result 0.\n");
+        msg->result = STORAGE_NO_ERROR;
+        return ipc_respond(msg, &read_rsp, sizeof(read_rsp.hdr));
+    }
+
     int fd = lookup_fd(req->handle, false);
     watch_progress(watcher, "reading");
     ssize_t read_res = read_with_retry(fd, read_rsp.hdr.data, req->size,
@@ -592,7 +764,7 @@ int storage_file_get_max_size(struct storage_msg* msg, const void* r, size_t req
             goto err_response;
         }
     } else {
-        max_size = MAX_FILE_SIZE;
+        max_size = max_file_size;
     }
 
     resp.max_size = max_size;
@@ -603,17 +775,78 @@ int storage_file_get_max_size(struct storage_msg* msg, const void* r, size_t req
     return ipc_respond(msg, NULL, 0);
 }
 
-int storage_init(const char *dirname)
-{
+int determine_max_file_size(const char* max_file_size_from) {
+    /* Use default if none passed in */
+    if (max_file_size_from == NULL) {
+        ALOGI("No max file source given, continuing to use default: 0x%lx\n", max_file_size);
+        return 0;
+    }
+
+    /* Check that max_file_size_from is part of our mapping list. */
+    if (!is_backing_storage_mapped(max_file_size_from)) {
+        ALOGE("%s: file doesn't match mapped storages (filename=%s)\n", __func__,
+              max_file_size_from);
+        return -1;
+    }
+
+    ALOGI("Using %s to determine max file size.\n", max_file_size_from);
+
+    /* Error if max file size source not found, possible misconfig. */
+    struct stat buf = {0};
+    int rc = stat(max_file_size_from, &buf);
+    if (rc < 0) {
+        ALOGE("%s: error stat'ing file (filename=%s): %s\n", __func__, max_file_size_from,
+              strerror(errno));
+        return -1;
+    }
+
+    /* Currently only support block device as max file size source */
+    if ((buf.st_mode & S_IFMT) != S_IFBLK) {
+        ALOGE("Unsupported max file size source type: %d\n", buf.st_mode);
+        return -1;
+    }
+
+    ALOGI("%s is a block device, determining block device size\n", max_file_size_from);
+    uint64_t max_size = 0;
+    int fd = TEMP_FAILURE_RETRY(open(max_file_size_from, O_RDONLY | O_NONBLOCK));
+    if (fd < 0) {
+        ALOGE("%s: failed to open backing file %s for ioctl: %s\n", __func__, max_file_size_from,
+              strerror(errno));
+        return -1;
+    }
+    rc = ioctl(fd, BLKGETSIZE64, &max_size);
+    if (rc < 0) {
+        ALOGE("%s: error calling ioctl on file (fd=%d): %s\n", __func__, fd, strerror(errno));
+        close(fd);
+        return -1;
+    }
+    close(fd);
+    max_file_size = max_size;
+
+    ALOGI("Using 0x%lx as max file size\n", max_file_size);
+    return 0;
+}
+
+int storage_init(const char* dirname, struct storage_mapping_node* mappings,
+                 const char* max_file_size_from) {
     /* If there is an active DSU image, use the alternate fs mode. */
     alternate_mode = is_gsi_running();
 
     fs_state = SS_CLEAN;
     for (uint i = 0; i < FD_TBL_SIZE; i++) {
-        fd_state[i] = SS_UNUSED;  /* uninstalled */
+        fd_state[i] = SS_UNUSED; /* uninstalled */
     }
 
     ssdir_name = dirname;
+
+    storage_mapping_head = mappings;
+
+    /* Set the max file size based on incoming configuration */
+    int rc = determine_max_file_size(max_file_size_from);
+    if (rc < 0) {
+        return rc;
+    }
+
     return 0;
 }
 
@@ -623,17 +856,17 @@ int storage_sync_checkpoint(struct watcher* watcher) {
     watch_progress(watcher, "sync fd table");
     /* sync fd table and reset it to clean state first */
     for (uint fd = 0; fd < FD_TBL_SIZE; fd++) {
-         if (fd_state[fd] == SS_DIRTY) {
-             if (fs_state == SS_CLEAN) {
-                 /* need to sync individual fd */
-                 rc = fsync(fd);
-                 if (rc < 0) {
-                     ALOGE("fsync for fd=%d failed: %s\n", fd, strerror(errno));
-                     return rc;
-                 }
-             }
-             fd_state[fd] = SS_CLEAN; /* set to clean */
-         }
+        if (fd_state[fd] == SS_DIRTY) {
+            if (fs_state == SS_CLEAN) {
+                /* need to sync individual fd */
+                rc = fsync(fd);
+                if (rc < 0) {
+                    ALOGE("fsync for fd=%d failed: %s\n", fd, strerror(errno));
+                    return rc;
+                }
+            }
+            fd_state[fd] = SS_CLEAN; /* set to clean */
+        }
     }
 
     /* check if we need to sync all filesystems */
diff --git a/trusty/storage/proxy/storage.h b/trusty/storage/proxy/storage.h
index f29fdf2e8047..6dbfe3706076 100644
--- a/trusty/storage/proxy/storage.h
+++ b/trusty/storage/proxy/storage.h
@@ -21,6 +21,14 @@
 /* Defined in watchdog.h */
 struct watcher;
 
+/* Is used for managing alternate backing storage, generally will be a block device. */
+struct storage_mapping_node {
+    struct storage_mapping_node* next;
+    const char* file_name;
+    const char* backing_storage;
+    int fd;
+};
+
 int storage_file_delete(struct storage_msg* msg, const void* req, size_t req_len,
                         struct watcher* watcher);
 
@@ -45,6 +53,7 @@ int storage_file_set_size(struct storage_msg* msg, const void* req, size_t req_l
 int storage_file_get_max_size(struct storage_msg* msg, const void* req, size_t req_len,
                               struct watcher* watcher);
 
-int storage_init(const char* dirname);
+int storage_init(const char* dirname, struct storage_mapping_node* head,
+                 const char* max_file_size_from);
 
 int storage_sync_checkpoint(struct watcher* watcher);

From 0b36b59e4565cdd735d029886a2b19a0570feef2 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Tue, 14 May 2024 19:43:07 +0000
Subject: [PATCH 0899/1487] Create OWNERS for test_upgrade_mte

Change-Id: I0dd6bccf9f6a1767f11fd3e687d819eceaab7b5e
---
 init/test_upgrade_mte/OWNERS | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 init/test_upgrade_mte/OWNERS

diff --git a/init/test_upgrade_mte/OWNERS b/init/test_upgrade_mte/OWNERS
new file mode 100644
index 000000000000..79625dfb160f
--- /dev/null
+++ b/init/test_upgrade_mte/OWNERS
@@ -0,0 +1,5 @@
+fmayer@google.com
+
+eugenis@google.com
+mitchp@google.com
+pcc@google.com

From a474b174ff98a31fb19bfb9b339c9732f2c5c822 Mon Sep 17 00:00:00 2001
From: Treehugger Robot
 <android-test-infra-autosubmit@system.gserviceaccount.com>
Date: Mon, 22 Apr 2024 22:48:49 +0000
Subject: [PATCH 0900/1487] Merge "storageproxyd: Fix x86 builds" into main am:
 bbdc19b7e1 am: 2b029e300b

Original change: https://android-review.googlesource.com/c/platform/system/core/+/3053402

Bug: 324989972
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:60f55841c5573a466fad716c283156aad1e369c2)
Merged-In: Ibf2e73ec1b08bfb44a6b92e11376b6b59555c8d6
Change-Id: Ibf2e73ec1b08bfb44a6b92e11376b6b59555c8d6
---
 trusty/storage/proxy/storage.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/trusty/storage/proxy/storage.c b/trusty/storage/proxy/storage.c
index 1dab93d9c6a6..6d0c616715c1 100644
--- a/trusty/storage/proxy/storage.c
+++ b/trusty/storage/proxy/storage.c
@@ -40,7 +40,7 @@
 #define ALTERNATE_DATA_DIR "alternate/"
 
 /* Maximum file size for filesystem backed storage (i.e. not block dev backed storage) */
-static size_t max_file_size = 0x10000000000;
+static uint64_t max_file_size = 0x10000000000;
 
 enum sync_state {
     SS_UNUSED = -1,
@@ -778,7 +778,8 @@ int storage_file_get_max_size(struct storage_msg* msg, const void* r, size_t req
 int determine_max_file_size(const char* max_file_size_from) {
     /* Use default if none passed in */
     if (max_file_size_from == NULL) {
-        ALOGI("No max file source given, continuing to use default: 0x%lx\n", max_file_size);
+        ALOGI("No max file source given, continuing to use default: 0x%" PRIx64 "\n",
+              max_file_size);
         return 0;
     }
 
@@ -823,7 +824,7 @@ int determine_max_file_size(const char* max_file_size_from) {
     close(fd);
     max_file_size = max_size;
 
-    ALOGI("Using 0x%lx as max file size\n", max_file_size);
+    ALOGI("Using 0x%" PRIx64 " as max file size\n", max_file_size);
     return 0;
 }
 

From cb53fe136b8302c3c49e9456fe25af2ed8c7fd95 Mon Sep 17 00:00:00 2001
From: Sijie Chen <sijiec@google.com>
Date: Fri, 10 May 2024 18:40:48 +0000
Subject: [PATCH 0901/1487] Reland "[Berberis][CrashReporting] Extend
 ThreadInfo to ..."

Revert submission 3081452-revert-3062926-CJGHTRPCBP

Reason for revert: Will make the change base on the original CLs for a reland.

(Original CL commit message)
This CL is to get guest registers information.

Bug: b/321799516
Test: m
Testing for TLS Slot:
Manual testing by: 1. crash the jni tests to produce tombstones file 2.
get the signature field of guest state header 3. verified it is the same
value as NATIVE_BRIDGE_GUEST_STATE_SIGNATURE

Manual test the arm64 by: 1. flash build to pixel phone and verify
retrieving TLS_SLOT_THREAD_ID's tid field is the same as current thread
id.

Testing for register values:
Test and print out registers values for riscv64, looks make sense that
has null zero value slots.

Change-Id: Ieebf845bff517380ee07fac77f24b48efeb53521
---
 debuggerd/Android.bp                          |  12 ++
 debuggerd/crash_dump.cpp                      | 111 ++++++++++++++++++
 .../libdebuggerd/include/libdebuggerd/types.h |   2 +
 3 files changed, 125 insertions(+)

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 3a882ea8f41f..0c5543ed931d 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -452,6 +452,7 @@ cc_binary {
 
     header_libs: [
         "bionic_libc_platform_headers",
+        "libnative_bridge_support_accessor_headers",
     ],
 
     static_libs: [
@@ -461,6 +462,8 @@ cc_binary {
 
         "libtombstone_proto",
         "libprotobuf-cpp-lite",
+
+        "libnative_bridge_guest_state_accessor",
     ],
 
     shared_libs: [
@@ -476,6 +479,15 @@ cc_binary {
 
     // Required for tests.
     required: ["crash_dump.policy"],
+
+    target: {
+        android: {
+            header_libs: [
+                "libnative_bridge_support_accessor_headers", // For dlext_namespaces.h
+            ],
+            shared_libs: ["libdl_android"], // For android_get_exported_namespace implementation
+        },
+    },
 }
 
 cc_binary {
diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 203b4855b3b0..6706650b90d3 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -25,6 +25,7 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
+#include <cstdint>
 #include <limits>
 #include <map>
 #include <memory>
@@ -42,6 +43,7 @@
 #include <android-base/unique_fd.h>
 #include <bionic/macros.h>
 #include <bionic/reserved_signals.h>
+#include <bionic/tls_defines.h>
 #include <cutils/sockets.h>
 #include <log/log.h>
 #include <private/android_filesystem_config.h>
@@ -52,7 +54,18 @@
 
 #include <unwindstack/AndroidUnwinder.h>
 #include <unwindstack/Error.h>
+#include <unwindstack/MachineArm.h>
+#include <unwindstack/MachineArm64.h>
+#include <unwindstack/MachineRiscv64.h>
 #include <unwindstack/Regs.h>
+#include <unwindstack/RegsArm.h>
+#include <unwindstack/RegsArm64.h>
+#include <unwindstack/RegsRiscv64.h>
+#include <unwindstack/UserArm.h>
+#include <unwindstack/UserArm64.h>
+#include <unwindstack/UserRiscv64.h>
+
+#include <native_bridge_support/guest_state_accessor/accessor.h>
 
 #include "libdebuggerd/backtrace.h"
 #include "libdebuggerd/tombstone.h"
@@ -403,6 +416,103 @@ static void InstallSigPipeHandler() {
   sigaction(SIGPIPE, &action, nullptr);
 }
 
+static bool PtracePeek(int request, pid_t tid, uintptr_t addr, void* data, std::string_view err_msg,
+                       uintptr_t* result) {
+  errno = 0;
+  *result = ptrace(request, tid, addr, data);
+  if (errno != 0) {
+    PLOG(ERROR) << err_msg;
+    return false;
+  }
+  return true;
+}
+
+static bool GetGuestRegistersFromCrashedProcess([[maybe_unused]] pid_t tid,
+                                                NativeBridgeGuestRegs* guest_regs) {
+  auto process_memory = unwindstack::Memory::CreateProcessMemoryCached(tid);
+
+  uintptr_t header_ptr = 0;
+  uintptr_t base = 0;
+#if defined(__x86_64__)
+  if (!PtracePeek(PTRACE_PEEKUSER, tid, offsetof(user_regs_struct, fs_base), nullptr,
+                  "failed to read thread register for thread " + std::to_string(tid), &base)) {
+    return false;
+  }
+#elif defined(__aarch64__)
+  // base is implicitly casted to uint64_t.
+  struct iovec pt_iov {
+    .iov_base = &base, .iov_len = sizeof(base),
+  };
+
+  if (ptrace(PTRACE_GETREGSET, tid, NT_ARM_TLS, &pt_iov) != 0) {
+    PLOG(ERROR) << "failed to read thread register for thread " << tid;
+  }
+#else
+  // TODO(b/339287219): Add case for Riscv host.
+  return false;
+#endif
+  auto ptr_to_guest_slot = base + TLS_SLOT_NATIVE_BRIDGE_GUEST_STATE * sizeof(uintptr_t);
+  if (!process_memory->ReadFully(ptr_to_guest_slot, &header_ptr, sizeof(uintptr_t))) {
+    PLOG(ERROR) << "failed to get guest state TLS slot content for thread " << tid;
+    return false;
+  }
+
+  NativeBridgeGuestStateHeader header;
+  if (!process_memory->ReadFully(header_ptr, &header, sizeof(NativeBridgeGuestStateHeader))) {
+    PLOG(ERROR) << "failed to get the guest state header for thread " << tid;
+    return false;
+  }
+  if (header.signature != NATIVE_BRIDGE_GUEST_STATE_SIGNATURE) {
+    // Return when ptr points to unmapped memory or no valid guest state.
+    return false;
+  }
+  auto guest_state_data_copy = std::make_unique<unsigned char[]>(header.guest_state_data_size);
+  if (!process_memory->ReadFully(reinterpret_cast<uintptr_t>(header.guest_state_data),
+                                 guest_state_data_copy.get(), header.guest_state_data_size)) {
+    PLOG(ERROR) << "failed to read the guest state data for thread " << tid;
+    return false;
+  }
+
+  LoadGuestStateRegisters(guest_state_data_copy.get(), header.guest_state_data_size, guest_regs);
+  return true;
+}
+
+static void ReadGuestRegisters([[maybe_unused]] std::unique_ptr<unwindstack::Regs>* regs,
+                               pid_t tid) {
+  // TODO: remove [[maybe_unused]], when the ARM32 case is removed from the native bridge support.
+  NativeBridgeGuestRegs guest_regs;
+  if (!GetGuestRegistersFromCrashedProcess(tid, &guest_regs)) {
+    return;
+  }
+
+  switch (guest_regs.guest_arch) {
+#if defined(__LP64__)
+    case NATIVE_BRIDGE_ARCH_ARM64: {
+      unwindstack::arm64_user_regs arm64_user_regs = {};
+      for (size_t i = 0; i < unwindstack::ARM64_REG_R31; i++) {
+        arm64_user_regs.regs[i] = guest_regs.regs_arm64.x[i];
+      }
+      arm64_user_regs.sp = guest_regs.regs_arm64.sp;
+      arm64_user_regs.pc = guest_regs.regs_arm64.ip;
+      regs->reset(unwindstack::RegsArm64::Read(&arm64_user_regs));
+      break;
+    }
+    case NATIVE_BRIDGE_ARCH_RISCV64: {
+      unwindstack::riscv64_user_regs riscv64_user_regs = {};
+      // RISCV64_REG_PC is at the first position.
+      riscv64_user_regs.regs[0] = guest_regs.regs_riscv64.ip;
+      for (size_t i = 1; i < unwindstack::RISCV64_REG_REAL_COUNT; i++) {
+        riscv64_user_regs.regs[i] = guest_regs.regs_riscv64.x[i];
+      }
+      regs->reset(unwindstack::RegsRiscv64::Read(&riscv64_user_regs, tid));
+      break;
+    }
+#endif
+    default:
+      break;
+  }
+}
+
 int main(int argc, char** argv) {
   DefuseSignalHandlers();
   InstallSigPipeHandler();
@@ -551,6 +661,7 @@ int main(int argc, char** argv) {
           continue;
         }
       }
+      ReadGuestRegisters(&info.guest_registers, thread);
 
       thread_info[thread] = std::move(info);
     }
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/types.h b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
index 4d69658e2cbd..c799f2448436 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/types.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
@@ -39,6 +39,8 @@ struct ThreadInfo {
 
   int signo = 0;
   siginfo_t* siginfo = nullptr;
+
+  std::unique_ptr<unwindstack::Regs> guest_registers;
 };
 
 // This struct is written into a pipe from inside the crashing process.

From c8027933b339ab3221a606590a7e6dccb840723b Mon Sep 17 00:00:00 2001
From: Sijie Chen <sijiec@google.com>
Date: Fri, 10 May 2024 18:40:48 +0000
Subject: [PATCH 0902/1487] Reland "[Berberis][CrashReporting] Dump guest
 thread inf..."

Guest thread information will print out follow host thread.

Revert submission 3081452-revert-3062926-CJGHTRPCBP

Reason for revert: Will make the change base on the original CLs for a reland.

Bug: b/321799516
Test: riscv64, checked tombstone file has wanted block.
https://paste.googleplex.com/6282302317658112
Added arm64 support and tested arm64 unwinding in internal repo.
https://paste.googleplex.com/6545612887818240

Change-Id: Ie54ad6f359d60283442adfcd9ee95f5a116e4b72
---
 debuggerd/crash_dump.cpp                      | 36 +++++++++++++++++-
 .../include/libdebuggerd/tombstone.h          |  8 +++-
 debuggerd/libdebuggerd/tombstone.cpp          |  6 ++-
 debuggerd/libdebuggerd/tombstone_proto.cpp    | 37 +++++++++++++++++--
 .../libdebuggerd/tombstone_proto_to_text.cpp  | 33 +++++++++++++++--
 debuggerd/proto/tombstone.proto               |  7 +++-
 6 files changed, 112 insertions(+), 15 deletions(-)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 6706650b90d3..852c159a5b29 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -81,6 +81,10 @@ using android::base::ErrnoRestorer;
 using android::base::StringPrintf;
 using android::base::unique_fd;
 
+// This stores guest architecture. When the architecture is supported, tombstone file will output
+// guest state information.
+static Architecture g_guest_arch;
+
 static bool pid_contains_tid(int pid_proc_fd, pid_t tid) {
   struct stat st;
   std::string task_path = StringPrintf("task/%d", tid);
@@ -495,6 +499,8 @@ static void ReadGuestRegisters([[maybe_unused]] std::unique_ptr<unwindstack::Reg
       arm64_user_regs.sp = guest_regs.regs_arm64.sp;
       arm64_user_regs.pc = guest_regs.regs_arm64.ip;
       regs->reset(unwindstack::RegsArm64::Read(&arm64_user_regs));
+
+      g_guest_arch = Architecture::ARM64;
       break;
     }
     case NATIVE_BRIDGE_ARCH_RISCV64: {
@@ -505,6 +511,8 @@ static void ReadGuestRegisters([[maybe_unused]] std::unique_ptr<unwindstack::Reg
         riscv64_user_regs.regs[i] = guest_regs.regs_riscv64.x[i];
       }
       regs->reset(unwindstack::RegsRiscv64::Read(&riscv64_user_regs, tid));
+
+      g_guest_arch = Architecture::RISCV64;
       break;
     }
 #endif
@@ -771,8 +779,32 @@ int main(int argc, char** argv) {
 
     {
       ATRACE_NAME("engrave_tombstone");
-      engrave_tombstone(std::move(g_output_fd), std::move(g_proto_fd), &unwinder, thread_info,
-                        g_target_thread, process_info, &open_files, &amfd_data);
+      unwindstack::ArchEnum regs_arch = unwindstack::ARCH_UNKNOWN;
+      switch (g_guest_arch) {
+        case Architecture::ARM32: {
+          regs_arch = unwindstack::ARCH_ARM;
+          break;
+        }
+        case Architecture::ARM64: {
+          regs_arch = unwindstack::ARCH_ARM64;
+          break;
+        }
+        case Architecture::RISCV64: {
+          regs_arch = unwindstack::ARCH_RISCV64;
+          break;
+        }
+        default: {
+        }
+      }
+      if (regs_arch == unwindstack::ARCH_UNKNOWN) {
+        engrave_tombstone(std::move(g_output_fd), std::move(g_proto_fd), &unwinder, thread_info,
+                          g_target_thread, process_info, &open_files, &amfd_data);
+      } else {
+        unwindstack::AndroidRemoteUnwinder guest_unwinder(vm_pid, regs_arch);
+        engrave_tombstone(std::move(g_output_fd), std::move(g_proto_fd), &unwinder, thread_info,
+                          g_target_thread, process_info, &open_files, &amfd_data, &g_guest_arch,
+                          &guest_unwinder);
+      }
     }
   }
 
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
index be999e04e6a0..dfdfabdff19f 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
@@ -28,6 +28,7 @@
 #include <android-base/unique_fd.h>
 
 #include "open_files_list.h"
+#include "tombstone.pb.h"
 #include "types.h"
 
 // Forward declarations
@@ -54,14 +55,17 @@ void engrave_tombstone(android::base::unique_fd output_fd, android::base::unique
                        unwindstack::AndroidUnwinder* unwinder,
                        const std::map<pid_t, ThreadInfo>& thread_info, pid_t target_thread,
                        const ProcessInfo& process_info, OpenFilesList* open_files,
-                       std::string* amfd_data);
+                       std::string* amfd_data, const Architecture* guest_arch = nullptr,
+                       unwindstack::AndroidUnwinder* guest_unwinder = nullptr);
 
 void engrave_tombstone_ucontext(int tombstone_fd, int proto_fd, uint64_t abort_msg_address,
                                 siginfo_t* siginfo, ucontext_t* ucontext);
 
 void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
                              const std::map<pid_t, ThreadInfo>& threads, pid_t target_thread,
-                             const ProcessInfo& process_info, const OpenFilesList* open_files);
+                             const ProcessInfo& process_info, const OpenFilesList* open_files,
+                             const Architecture* guest_arch,
+                             unwindstack::AndroidUnwinder* guest_unwinder);
 
 bool tombstone_proto_to_text(
     const Tombstone& tombstone,
diff --git a/debuggerd/libdebuggerd/tombstone.cpp b/debuggerd/libdebuggerd/tombstone.cpp
index 5a416d64319a..0ce55738a2a4 100644
--- a/debuggerd/libdebuggerd/tombstone.cpp
+++ b/debuggerd/libdebuggerd/tombstone.cpp
@@ -125,10 +125,12 @@ void engrave_tombstone(unique_fd output_fd, unique_fd proto_fd,
                        unwindstack::AndroidUnwinder* unwinder,
                        const std::map<pid_t, ThreadInfo>& threads, pid_t target_thread,
                        const ProcessInfo& process_info, OpenFilesList* open_files,
-                       std::string* amfd_data) {
+                       std::string* amfd_data, const Architecture* guest_arch,
+                       unwindstack::AndroidUnwinder* guest_unwinder) {
   // Don't copy log messages to tombstone unless this is a development device.
   Tombstone tombstone;
-  engrave_tombstone_proto(&tombstone, unwinder, threads, target_thread, process_info, open_files);
+  engrave_tombstone_proto(&tombstone, unwinder, threads, target_thread, process_info, open_files,
+                          guest_arch, guest_unwinder);
 
   if (proto_fd != -1) {
     if (!tombstone.SerializeToFileDescriptor(proto_fd.get())) {
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index 5546b7bcc21f..3e8ab6ea5c81 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -482,7 +482,8 @@ static void dump_thread_backtrace(std::vector<unwindstack::FrameData>& frames, T
 }
 
 static void dump_thread(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
-                        const ThreadInfo& thread_info, bool memory_dump = false) {
+                        const ThreadInfo& thread_info, bool memory_dump = false,
+                        unwindstack::AndroidUnwinder* guest_unwinder = nullptr) {
   Thread thread;
 
   thread.set_id(thread_info.tid);
@@ -509,6 +510,27 @@ static void dump_thread(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwi
 
   auto& threads = *tombstone->mutable_threads();
   threads[thread_info.tid] = thread;
+
+  if (guest_unwinder) {
+    if (!thread_info.guest_registers) {
+      async_safe_format_log(ANDROID_LOG_INFO, LOG_TAG,
+                            "No guest state registers information for tid %d", thread_info.tid);
+      return;
+    }
+    Thread guest_thread;
+    unwindstack::AndroidUnwinderData guest_data;
+    guest_data.saved_initial_regs = std::make_optional<std::unique_ptr<unwindstack::Regs>>();
+    if (guest_unwinder->Unwind(thread_info.guest_registers.get(), guest_data)) {
+      dump_thread_backtrace(guest_data.frames, guest_thread);
+    } else {
+      async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG,
+                            "Unwind guest state registers failed for tid %d: Error %s",
+                            thread_info.tid, guest_data.GetErrorString().c_str());
+    }
+    dump_registers(guest_unwinder, *guest_data.saved_initial_regs, guest_thread, memory_dump);
+    auto& guest_threads = *tombstone->mutable_guest_threads();
+    guest_threads[thread_info.tid] = guest_thread;
+  }
 }
 
 static void dump_mappings(Tombstone* tombstone, unwindstack::Maps* maps,
@@ -686,10 +708,17 @@ static void dump_tags_around_fault_addr(Signal* signal, const Tombstone& tombsto
 
 void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
                              const std::map<pid_t, ThreadInfo>& threads, pid_t target_tid,
-                             const ProcessInfo& process_info, const OpenFilesList* open_files) {
+                             const ProcessInfo& process_info, const OpenFilesList* open_files,
+                             const Architecture* guest_arch,
+                             unwindstack::AndroidUnwinder* guest_unwinder) {
   Tombstone result;
 
   result.set_arch(get_arch());
+  if (guest_arch != nullptr) {
+    result.set_guest_arch(*guest_arch);
+  } else {
+    result.set_guest_arch(Architecture::NONE);
+  }
   result.set_build_fingerprint(android::base::GetProperty("ro.build.fingerprint", "unknown"));
   result.set_revision(android::base::GetProperty("ro.revision", "unknown"));
   result.set_timestamp(get_timestamp());
@@ -750,11 +779,11 @@ void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder*
   dump_abort_message(&result, unwinder->GetProcessMemory(), process_info);
   dump_crash_details(&result, unwinder->GetProcessMemory(), process_info);
   // Dump the target thread, but save the memory around the registers.
-  dump_thread(&result, unwinder, target_thread, /* memory_dump */ true);
+  dump_thread(&result, unwinder, target_thread, /* memory_dump */ true, guest_unwinder);
 
   for (const auto& [tid, thread_info] : threads) {
     if (tid != target_tid) {
-      dump_thread(&result, unwinder, thread_info);
+      dump_thread(&result, unwinder, thread_info, /* memory_dump */ false, guest_unwinder);
     }
   }
 
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index 08c1cc0dae12..19007194e79e 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -79,8 +79,8 @@ static std::string describe_pac_enabled_keys(long value) {
   return describe_end(value, desc);
 }
 
-static const char* abi_string(const Tombstone& tombstone) {
-  switch (tombstone.arch()) {
+static const char* abi_string(const Architecture& arch) {
+  switch (arch) {
     case Architecture::ARM32:
       return "arm";
     case Architecture::ARM64:
@@ -578,11 +578,28 @@ void print_logs(CallbackType callback, const Tombstone& tombstone, int tail) {
   }
 }
 
+static void print_guest_thread(CallbackType callback, const Tombstone& tombstone,
+                               const Thread& guest_thread, pid_t tid, bool should_log) {
+  CBS("--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---");
+  CBS("Guest thread information for tid: %d", tid);
+  print_thread_registers(callback, tombstone, guest_thread, should_log);
+
+  CBS("");
+  CB(true, "%d total frames", guest_thread.current_backtrace().size());
+  CB(true, "backtrace:");
+  print_backtrace(callback, tombstone, guest_thread.current_backtrace(), should_log);
+
+  print_thread_memory_dump(callback, tombstone, guest_thread);
+}
+
 bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback) {
   CBL("*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***");
   CBL("Build fingerprint: '%s'", tombstone.build_fingerprint().c_str());
   CBL("Revision: '%s'", tombstone.revision().c_str());
-  CBL("ABI: '%s'", abi_string(tombstone));
+  CBL("ABI: '%s'", abi_string(tombstone.arch()));
+  if (tombstone.guest_arch() != Architecture::NONE) {
+    CBL("Guest architecture: '%s'", abi_string(tombstone.guest_arch()));
+  }
   CBL("Timestamp: %s", tombstone.timestamp().c_str());
   CBL("Process uptime: %ds", tombstone.process_uptime());
 
@@ -607,6 +624,12 @@ bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback)
 
   print_logs(callback, tombstone, 50);
 
+  const auto& guest_threads = tombstone.guest_threads();
+  auto main_guest_thread_it = guest_threads.find(tombstone.tid());
+  if (main_guest_thread_it != threads.end()) {
+    print_guest_thread(callback, tombstone, main_guest_thread_it->second, tombstone.tid(), true);
+  }
+
   // protobuf's map is unordered, so sort the keys first.
   std::set<int> thread_ids;
   for (const auto& [tid, _] : threads) {
@@ -618,6 +641,10 @@ bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback)
   for (const auto& tid : thread_ids) {
     CBS("--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---");
     print_thread(callback, tombstone, threads.find(tid)->second);
+    auto guest_thread_it = guest_threads.find(tid);
+    if (guest_thread_it != guest_threads.end()) {
+      print_guest_thread(callback, tombstone, guest_thread_it->second, tid, false);
+    }
   }
 
   if (tombstone.open_fds().size() > 0) {
diff --git a/debuggerd/proto/tombstone.proto b/debuggerd/proto/tombstone.proto
index e70d525ee914..6f9cd9612507 100644
--- a/debuggerd/proto/tombstone.proto
+++ b/debuggerd/proto/tombstone.proto
@@ -22,6 +22,7 @@ message CrashDetail {
 
 message Tombstone {
   Architecture arch = 1;
+  Architecture guest_arch = 24;
   string build_fingerprint = 2;
   string revision = 3;
   string timestamp = 4;
@@ -42,6 +43,7 @@ message Tombstone {
   repeated Cause causes = 15;
 
   map<uint32, Thread> threads = 16;
+  map<uint32, Thread> guest_threads = 25;
   repeated MemoryMapping memory_mappings = 17;
   repeated LogBuffer log_buffers = 18;
   repeated FD open_fds = 19;
@@ -49,7 +51,7 @@ message Tombstone {
   uint32 page_size = 22;
   bool has_been_16kb_mode = 23;
 
-  reserved 24 to 999;
+  reserved 26 to 999;
 }
 
 enum Architecture {
@@ -58,8 +60,9 @@ enum Architecture {
   X86 = 2;
   X86_64 = 3;
   RISCV64 = 4;
+  NONE = 5;
 
-  reserved 5 to 999;
+  reserved 6 to 999;
 }
 
 message Signal {

From b3c145e0f755236b2c9b6fcd838c2641cd505d60 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Mon, 13 May 2024 17:44:57 -0700
Subject: [PATCH 0903/1487] Fix mte_upgrade_test

init ignored the rc file because of incorrect permissions
also replace deprecated "push" with "push-file"

Test: atest mte_upgrade_test
Bug: 335232356
Change-Id: I4c17311dbb1d001567f4cdda65036f16aec2b5c1
---
 init/test_upgrade_mte/AndroidTest.xml | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/init/test_upgrade_mte/AndroidTest.xml b/init/test_upgrade_mte/AndroidTest.xml
index b89cde8dfa99..e08afc0879b8 100644
--- a/init/test_upgrade_mte/AndroidTest.xml
+++ b/init/test_upgrade_mte/AndroidTest.xml
@@ -20,11 +20,13 @@
     <target_preparer class="com.android.tradefed.targetprep.PushFilePreparer">
       <option name="cleanup" value="true" />
       <option name="remount-system" value="true" />
-      <option name="push" value="mte_upgrade_test.rc->/system/etc/init/mte_upgrade_test.rc" />
-      <option name="push" value="mte_upgrade_test_helper->/system/bin/mte_upgrade_test_helper" />
-      <option name="push" value="mte_upgrade_test_helper->/data/local/tmp/app_process64" />
+
+      <option name="push-file" key="mte_upgrade_test.rc" value="/system/etc/init/mte_upgrade_test.rc" />
+      <option name="push-file" key="mte_upgrade_test_helper" value="/system/bin/mte_upgrade_test_helper" />
+      <option name="push-file" key="mte_upgrade_test_helper" value="/data/local/tmp/app_process64" />
+      <option name="post-push" value="chmod 644 /system/etc/init/mte_upgrade_test.rc" />
     </target_preparer>
     <test class="com.android.tradefed.testtype.HostTest" >
         <option name="jar" value="mte_upgrade_test.jar" />
     </test>
-</configuration>
\ No newline at end of file
+</configuration>

From 1277bd4dfdd85b05fb864ce0c9fdd0d0085d3610 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Tue, 14 May 2024 17:35:15 -0700
Subject: [PATCH 0904/1487] Prevent mte_upgrade_test from hanging if MTE is
 disabled

Turns out we didn't need the syscall because the kernel checks
for async MTE fault on exit.

Test: atest mte_upgrade_test with and without MTE
Change-Id: Iebdf181d67b4586926499c7549c72e73efc13c56
---
 init/test_upgrade_mte/mte_upgrade_test_helper.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/init/test_upgrade_mte/mte_upgrade_test_helper.cpp b/init/test_upgrade_mte/mte_upgrade_test_helper.cpp
index 6728cc6d099c..c4b175adc4c2 100644
--- a/init/test_upgrade_mte/mte_upgrade_test_helper.cpp
+++ b/init/test_upgrade_mte/mte_upgrade_test_helper.cpp
@@ -22,6 +22,7 @@
 #include <sys/prctl.h>
 #include <time.h>
 #include <unistd.h>
+
 #include <memory>
 
 int MaybeDowngrade() {
@@ -65,7 +66,5 @@ int main(int argc, char** argv) {
     // This binary gets run by src/com/android/tests/init/MteUpgradeTest.java, which
     // asserts that it crashes as expected.
     f[17] = 'x';
-    char buf[1];
-    read(1, buf, 1);
     return 0;
 }

From c5cec3c71c1c9d4a406f91e7ea77b1943f86ebc3 Mon Sep 17 00:00:00 2001
From: Keir Fraser <keirf@google.com>
Date: Mon, 13 May 2024 10:11:34 +0000
Subject: [PATCH 0905/1487] mkbootfs: Allow invocation with no directories
 specified

1. A non-empty archive can still be generated, if a dev nodes
file is specified; and
2. cpio itself handles the case of an empty archive
(containing only the trailer entry), for example:
  echo -n | cpio -oc | cpio -it

Bug: 328362894
Change-Id: If17796f445e50842249554a1e82478bc375cf5eb
---
 mkbootfs/mkbootfs.c | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/mkbootfs/mkbootfs.c b/mkbootfs/mkbootfs.c
index eaa5d55b4070..84a0a4eeeb2b 100644
--- a/mkbootfs/mkbootfs.c
+++ b/mkbootfs/mkbootfs.c
@@ -445,11 +445,6 @@ int main(int argc, char *argv[])
     int num_dirs = argc - optind;
     argv += optind;
 
-    if (num_dirs <= 0) {
-        usage();
-        errx(1, "no directories to process?!");
-    }
-
     while(num_dirs-- > 0){
         char *x = strchr(*argv, '=');
         if(x != 0) {

From 188d59a9191edd182e3430b4bceb757738a1786b Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Wed, 15 May 2024 20:03:53 +0000
Subject: [PATCH 0906/1487] 16k kernel dev option changes ro.build.fingerprint

When someone uses the 16kb dev option, they switch
out the kernel, but the same build is used. Make
sure this is visible in the fingerprint to help
split up any analytics or reports.

Bug: 332406754
Test: no change on normal device, on 16k dev option device:

:) adb shell getprop ro.product.build.16k_page.enabled
true
:) adb shell getconf PAGE_SIZE
16384
:) adb shell getprop ro.build.fingerprint
generic/aosp_cf_x86_64_phone_pgagnostic_16kb/vsoc_x86_64_pgagnostic:VanillaIceCream/MAIN.b7aab5e4/eng.smorel.20240514.203625:userdebug/test-keys
                                       ^^^^^^
             ----------------------------/

cheers

Change-Id: I9632237cef4a3b077761022eda8cf42784a41753
---
 init/property_service.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index d3cdd437f8ef..cd5933d23045 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -974,6 +974,17 @@ static std::string ConstructBuildFingerprint(bool legacy) {
     std::string build_fingerprint = GetProperty("ro.product.brand", UNKNOWN);
     build_fingerprint += '/';
     build_fingerprint += GetProperty("ro.product.name", UNKNOWN);
+
+    // should be set in /product/etc/build.prop
+    // when we have a dev option device, and we've switched the kernel to 16kb mode
+    // we use the same system image, but we've switched out the kernel, so make it
+    // visible at a high level
+    bool has16KbDevOption =
+            android::base::GetBoolProperty("ro.product.build.16k_page.enabled", false);
+    if (has16KbDevOption && getpagesize() == 16384) {
+        build_fingerprint += "_16kb";
+    }
+
     build_fingerprint += '/';
     build_fingerprint += GetProperty("ro.product.device", UNKNOWN);
     build_fingerprint += ':';

From f01048743ab300595c265a74ec31858f0cc59267 Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Fri, 10 May 2024 01:37:09 -0700
Subject: [PATCH 0907/1487] Define String8 and String16 operator<=>

Previously, in C++20 mode, using <=> on String8 or String16 would
compare the pointer values from the implicit conversion operators
returning const char* and const char16_t*. Instead, compare the string
content. This is especially a problem with STL containers that prefer
<=> when it is available.

See https://godbolt.org/z/cc1hW17h3 for a demo of the problem.

Bug: 339775405
Test: treehugger
Change-Id: I5ee6af96dee0c9968a1bab1ad96729e45bb1ac50
---
 libutils/binder/String16_test.cpp        | 44 +++++++++++++++++++++++
 libutils/binder/String8_test.cpp         | 46 +++++++++++++++++++++++-
 libutils/binder/include/utils/String16.h | 36 +++++++++++++++++++
 libutils/binder/include/utils/String8.h  | 36 +++++++++++++++++++
 4 files changed, 161 insertions(+), 1 deletion(-)

diff --git a/libutils/binder/String16_test.cpp b/libutils/binder/String16_test.cpp
index 6f4642e8fb6d..83cc5990ba43 100644
--- a/libutils/binder/String16_test.cpp
+++ b/libutils/binder/String16_test.cpp
@@ -16,6 +16,8 @@
 
 #include <utils/String16.h>
 #include <utils/String8.h>
+#include <compare>
+#include <utility>
 
 #include <gtest/gtest.h>
 
@@ -257,3 +259,45 @@ TEST(String16Test, insert) {
     EXPECT_EQ(NO_MEMORY, s.insert(3, u"", SIZE_MAX));
     EXPECT_STR16EQ(u"foo!bar", s.c_str());
 }
+
+TEST(String16Test, comparisons) {
+    const char16_t* cstr1 = u"abc";
+    const char16_t* cstr2 = u"def";
+
+    // str1 and str1b will point to different blocks of memory but with equal contents.
+    String16 str1(cstr1);
+    String16 str1b(cstr1);
+    String16 str2(cstr2);
+
+    EXPECT_TRUE((str1 <=> str1b) == 0);
+    EXPECT_FALSE(str1 != str1b);
+    EXPECT_FALSE(str1 < str1b);
+    EXPECT_TRUE(str1 <= str1b);
+    EXPECT_TRUE(str1 == str1b);
+    EXPECT_TRUE(str1 >= str1b);
+    EXPECT_FALSE(str1 > str1b);
+
+    EXPECT_TRUE((str1 <=> str2) < 0);
+    EXPECT_TRUE((str2 <=> str1) > 0);
+    EXPECT_TRUE(str1 != str2);
+    EXPECT_TRUE(str1 < str2);
+    EXPECT_TRUE(str1 <= str2);
+    EXPECT_FALSE(str1 == str2);
+    EXPECT_FALSE(str1 >= str2);
+    EXPECT_FALSE(str1 > str2);
+
+    // Verify that pre-C++20 comparison operators work with a std::pair of a String8, which only
+    // provides <=> in C++20 and up. See b/339775405.
+
+    std::pair<String16, int> pair1(str1, 13);
+    std::pair<String16, int> pair1b(str1b, 13);
+    std::pair<String16, int> pair2(str2, 13);
+
+    EXPECT_TRUE(pair1 == pair1b);
+    EXPECT_FALSE(pair1 < pair1b);
+    EXPECT_FALSE(pair1 > pair1b);
+
+    EXPECT_TRUE(pair1 != pair2);
+    EXPECT_TRUE(pair1 < pair2);
+    EXPECT_FALSE(pair1 > pair2);
+}
diff --git a/libutils/binder/String8_test.cpp b/libutils/binder/String8_test.cpp
index 6f7882a3892b..fc3c329412d4 100644
--- a/libutils/binder/String8_test.cpp
+++ b/libutils/binder/String8_test.cpp
@@ -17,8 +17,10 @@
 #define LOG_TAG "String8_test"
 
 #include <log/log.h>
-#include <utils/String8.h>
 #include <utils/String16.h>
+#include <utils/String8.h>
+#include <compare>
+#include <utility>
 
 #include <gtest/gtest.h>
 
@@ -132,3 +134,45 @@ TEST_F(String8Test, removeAll) {
     EXPECT_TRUE(s.removeAll("o"));
     EXPECT_STREQ("Hell, wrld!", s.c_str());
 }
+
+TEST_F(String8Test, comparisons) {
+    const char* cstr1 = "abc";
+    const char* cstr2 = "def";
+
+    // str1 and str1b will point to different blocks of memory but with equal contents.
+    String8 str1(cstr1);
+    String8 str1b(cstr1);
+    String8 str2(cstr2);
+
+    EXPECT_TRUE((str1 <=> str1b) == 0);
+    EXPECT_FALSE(str1 != str1b);
+    EXPECT_FALSE(str1 < str1b);
+    EXPECT_TRUE(str1 <= str1b);
+    EXPECT_TRUE(str1 == str1b);
+    EXPECT_TRUE(str1 >= str1b);
+    EXPECT_FALSE(str1 > str1b);
+
+    EXPECT_TRUE((str1 <=> str2) < 0);
+    EXPECT_TRUE((str2 <=> str1) > 0);
+    EXPECT_TRUE(str1 != str2);
+    EXPECT_TRUE(str1 < str2);
+    EXPECT_TRUE(str1 <= str2);
+    EXPECT_FALSE(str1 == str2);
+    EXPECT_FALSE(str1 >= str2);
+    EXPECT_FALSE(str1 > str2);
+
+    // Verify that pre-C++20 comparison operators work with a std::pair of a String8, which only
+    // provides <=> in C++20 and up. See b/339775405.
+
+    std::pair<String8, int> pair1(str1, 13);
+    std::pair<String8, int> pair1b(str1b, 13);
+    std::pair<String8, int> pair2(str2, 13);
+
+    EXPECT_TRUE(pair1 == pair1b);
+    EXPECT_FALSE(pair1 < pair1b);
+    EXPECT_FALSE(pair1 > pair1b);
+
+    EXPECT_TRUE(pair1 != pair2);
+    EXPECT_TRUE(pair1 < pair2);
+    EXPECT_FALSE(pair1 > pair2);
+}
diff --git a/libutils/binder/include/utils/String16.h b/libutils/binder/include/utils/String16.h
index c7135766b097..867dbac34a0d 100644
--- a/libutils/binder/include/utils/String16.h
+++ b/libutils/binder/include/utils/String16.h
@@ -29,6 +29,10 @@
 #define HAS_STRING_VIEW
 #endif
 
+#if __cplusplus >= 202002L
+#include <compare>
+#endif
+
 // ---------------------------------------------------------------------------
 
 namespace android {
@@ -105,6 +109,9 @@ class String16
     inline  bool                operator!=(const String16& other) const;
     inline  bool                operator>=(const String16& other) const;
     inline  bool                operator>(const String16& other) const;
+#if __cplusplus >= 202002L
+    inline std::strong_ordering operator<=>(const String16& other) const;
+#endif
 
     inline  bool                operator<(const char16_t* other) const;
     inline  bool                operator<=(const char16_t* other) const;
@@ -112,6 +119,9 @@ class String16
     inline  bool                operator!=(const char16_t* other) const;
     inline  bool                operator>=(const char16_t* other) const;
     inline  bool                operator>(const char16_t* other) const;
+#if __cplusplus >= 202002L
+    inline std::strong_ordering operator<=>(const char16_t* other) const;
+#endif
 
     inline                      operator const char16_t*() const;
 
@@ -334,6 +344,19 @@ inline bool String16::operator>(const String16& other) const
     return strzcmp16(mString, size(), other.mString, other.size()) > 0;
 }
 
+#if __cplusplus >= 202002L
+inline std::strong_ordering String16::operator<=>(const String16& other) const {
+    int result = strzcmp16(mString, size(), other.mString, other.size());
+    if (result == 0) {
+        return std::strong_ordering::equal;
+    } else if (result < 0) {
+        return std::strong_ordering::less;
+    } else {
+        return std::strong_ordering::greater;
+    }
+}
+#endif
+
 inline bool String16::operator<(const char16_t* other) const
 {
     return strcmp16(mString, other) < 0;
@@ -364,6 +387,19 @@ inline bool String16::operator>(const char16_t* other) const
     return strcmp16(mString, other) > 0;
 }
 
+#if __cplusplus >= 202002L
+inline std::strong_ordering String16::operator<=>(const char16_t* other) const {
+    int result = strcmp16(mString, other);
+    if (result == 0) {
+        return std::strong_ordering::equal;
+    } else if (result < 0) {
+        return std::strong_ordering::less;
+    } else {
+        return std::strong_ordering::greater;
+    }
+}
+#endif
+
 inline String16::operator const char16_t*() const
 {
     return mString;
diff --git a/libutils/binder/include/utils/String8.h b/libutils/binder/include/utils/String8.h
index 6d250723b628..e0d7588f6a19 100644
--- a/libutils/binder/include/utils/String8.h
+++ b/libutils/binder/include/utils/String8.h
@@ -36,6 +36,10 @@
 #define HAS_STRING_VIEW
 #endif
 
+#if __cplusplus >= 202002L
+#include <compare>
+#endif
+
 // ---------------------------------------------------------------------------
 
 namespace android {
@@ -106,6 +110,9 @@ class String8
     inline  bool                operator!=(const String8& other) const;
     inline  bool                operator>=(const String8& other) const;
     inline  bool                operator>(const String8& other) const;
+#if __cplusplus >= 202002L
+    inline std::strong_ordering operator<=>(const String8& other) const;
+#endif
 
     inline  bool                operator<(const char* other) const;
     inline  bool                operator<=(const char* other) const;
@@ -113,6 +120,9 @@ class String8
     inline  bool                operator!=(const char* other) const;
     inline  bool                operator>=(const char* other) const;
     inline  bool                operator>(const char* other) const;
+#if __cplusplus >= 202002L
+    inline std::strong_ordering operator<=>(const char* other) const;
+#endif
 
     inline                      operator const char*() const;
 
@@ -302,6 +312,19 @@ inline bool String8::operator>(const String8& other) const
     return strcmp(mString, other.mString) > 0;
 }
 
+#if __cplusplus >= 202002L
+inline std::strong_ordering String8::operator<=>(const String8& other) const {
+    int result = strcmp(mString, other.mString);
+    if (result == 0) {
+        return std::strong_ordering::equal;
+    } else if (result < 0) {
+        return std::strong_ordering::less;
+    } else {
+        return std::strong_ordering::greater;
+    }
+}
+#endif
+
 inline bool String8::operator<(const char* other) const
 {
     return strcmp(mString, other) < 0;
@@ -332,6 +355,19 @@ inline bool String8::operator>(const char* other) const
     return strcmp(mString, other) > 0;
 }
 
+#if __cplusplus >= 202002L
+inline std::strong_ordering String8::operator<=>(const char* other) const {
+    int result = strcmp(mString, other);
+    if (result == 0) {
+        return std::strong_ordering::equal;
+    } else if (result < 0) {
+        return std::strong_ordering::less;
+    } else {
+        return std::strong_ordering::greater;
+    }
+}
+#endif
+
 inline String8::operator const char*() const
 {
     return mString;

From ec54595aff70654988a84e2e4b6f9fc2385c0a3d Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Tue, 14 May 2024 14:02:44 +0900
Subject: [PATCH 0908/1487] libstatssocket_lazy: add isAvailable()

Early processes might not have access to libstatssocket. They should be
able to check before using libstatssocket APIs. Adding isAvailable().

Bug: 281162849
Test: atest libstatssocket_lazy_test
Test: atest StagedRollbackTest
Change-Id: Ie2a851ef5bcf4fe081898153d688a843d8886788
---
 libstats/socket_lazy/Android.bp               | 11 +++++++-
 .../socket_lazy/include/statssocket_lazy.h    | 25 +++++++++++++++++++
 libstats/socket_lazy/libstatssocket_lazy.cpp  | 13 ++++++++--
 .../tests/libstatssocket_lazy_test.cpp        |  6 +++++
 4 files changed, 52 insertions(+), 3 deletions(-)
 create mode 100644 libstats/socket_lazy/include/statssocket_lazy.h

diff --git a/libstats/socket_lazy/Android.bp b/libstats/socket_lazy/Android.bp
index b2cd7b26bbe4..241e87af3743 100644
--- a/libstats/socket_lazy/Android.bp
+++ b/libstats/socket_lazy/Android.bp
@@ -7,6 +7,12 @@ package {
 
 cc_library_static {
     name: "libstatssocket_lazy",
+    local_include_dirs: [
+        "include",
+    ],
+    export_include_dirs: [
+        "include",
+    ],
     header_libs: [
         "libstatssocket_headers",
     ],
@@ -28,7 +34,10 @@ cc_test {
         "-Wall",
         "-Werror",
     ],
-    test_suites: ["device-tests", "mts-statsd"],
+    test_suites: [
+        "device-tests",
+        "mts-statsd",
+    ],
     test_config: "libstatssocket_lazy_test.xml",
     // TODO(b/153588990): Remove when the build system properly separates.
     // 32bit and 64bit architectures.
diff --git a/libstats/socket_lazy/include/statssocket_lazy.h b/libstats/socket_lazy/include/statssocket_lazy.h
new file mode 100644
index 000000000000..7dda0bac49c1
--- /dev/null
+++ b/libstats/socket_lazy/include/statssocket_lazy.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace android::statssocket::lazy {
+
+// See if libstatssocket.so is available. Early processes relying on _lazy might not have access
+// to libstatssocket.so when they start before the StatsD APEX is available.
+bool IsAvailable();
+
+}  // namespace android::statssocket::lazy
diff --git a/libstats/socket_lazy/libstatssocket_lazy.cpp b/libstats/socket_lazy/libstatssocket_lazy.cpp
index fe94ef2d86f2..d907c7e27926 100644
--- a/libstats/socket_lazy/libstatssocket_lazy.cpp
+++ b/libstats/socket_lazy/libstatssocket_lazy.cpp
@@ -23,8 +23,10 @@
 
 #include "log/log.h"
 
-#include "stats_event.h"
-#include "stats_socket.h"
+#include <stats_event.h>
+#include <stats_socket.h>
+
+#include "statssocket_lazy.h"
 
 // This file provides a lazy interface to libstatssocket.so to address early boot dependencies.
 // Specifically bootanimation, surfaceflinger, and lmkd run before the statsd APEX is loaded and
@@ -77,6 +79,13 @@ static void* LoadLibstatssocket(int dlopen_flags) {
     return dlopen("libstatssocket.so", dlopen_flags);
 }
 
+namespace android::statssocket::lazy {
+bool IsAvailable() {
+    static const void* handle = LoadLibstatssocket(RTLD_NOW);
+    return handle != nullptr;
+}
+}  // namespace android::statssocket::lazy
+
 //
 // Initialization and symbol binding.
 
diff --git a/libstats/socket_lazy/tests/libstatssocket_lazy_test.cpp b/libstats/socket_lazy/tests/libstatssocket_lazy_test.cpp
index 3de6cd76253c..733f1e41cdf4 100644
--- a/libstats/socket_lazy/tests/libstatssocket_lazy_test.cpp
+++ b/libstats/socket_lazy/tests/libstatssocket_lazy_test.cpp
@@ -21,6 +21,8 @@
 #include "stats_event.h"
 #include "stats_socket.h"
 
+#include "statssocket_lazy.h"
+
 // The tests here are just for the case when libstatssocket.so cannot be loaded by
 // libstatssocket_lazy.
 class LibstatssocketLazyTest : public ::testing::Test {
@@ -57,3 +59,7 @@ TEST_F(LibstatssocketLazyTest, NoLibstatssocketForStatsEvent) {
 TEST_F(LibstatssocketLazyTest, NoLibstatssocketForStatsSocket) {
     EXPECT_DEATH(AStatsSocket_close(), kLoadFailed);
 }
+
+TEST_F(LibstatssocketLazyTest, IsAvailableFalse) {
+    EXPECT_FALSE(android::statssocket::lazy::IsAvailable());
+}

From 3a9a989484451f2345d87901056df63dcf9796b5 Mon Sep 17 00:00:00 2001
From: Josh Gao <jmgao@fb.com>
Date: Thu, 16 May 2024 13:52:17 -0700
Subject: [PATCH 0909/1487] crasher: hide xom from help when unavailable

Test: m crasher
Change-Id: Iaf25dd650eb5cf6e8b0933f574b3d4a208b74da9
---
 debuggerd/crasher/crasher.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/debuggerd/crasher/crasher.cpp b/debuggerd/crasher/crasher.cpp
index 3b52776d7b32..05143ed05530 100644
--- a/debuggerd/crasher/crasher.cpp
+++ b/debuggerd/crasher/crasher.cpp
@@ -202,7 +202,9 @@ static int usage() {
     fprintf(stderr, "  fdsan_file            close a file descriptor that's owned by a FILE*\n");
     fprintf(stderr, "  fdsan_dir             close a file descriptor that's owned by a DIR*\n");
     fprintf(stderr, "  seccomp               fail a seccomp check\n");
+#if defined(__LP64__)
     fprintf(stderr, "  xom                   read execute-only memory\n");
+#endif
     fprintf(stderr, "\n");
     fprintf(stderr, "  LOG_ALWAYS_FATAL      call liblog LOG_ALWAYS_FATAL\n");
     fprintf(stderr, "  LOG_ALWAYS_FATAL_IF   call liblog LOG_ALWAYS_FATAL_IF\n");

From 2df897c1fcb1d833efedf58d9eb91e4ea1b2f5c3 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Thu, 16 May 2024 21:33:51 +0000
Subject: [PATCH 0910/1487] No longer require root for PermissiveMteTest

We can now read tombstones as shell user

Change-Id: I2371360e87dc186f37c2d13ebae28b57abe76845
---
 debuggerd/test_permissive_mte/AndroidTest.xml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/debuggerd/test_permissive_mte/AndroidTest.xml b/debuggerd/test_permissive_mte/AndroidTest.xml
index bd3d0182c67a..db5f5b81296c 100644
--- a/debuggerd/test_permissive_mte/AndroidTest.xml
+++ b/debuggerd/test_permissive_mte/AndroidTest.xml
@@ -17,8 +17,6 @@
     <option name="test-suite-tag" value="init_test_upgrade_mte" />
     <option name="test-suite-tag" value="apct" />
 
-    <!-- For tombstone inspection. -->
-    <target_preparer class="com.android.tradefed.targetprep.RootTargetPreparer"/>
     <target_preparer class="com.android.tradefed.targetprep.PushFilePreparer">
       <option name="cleanup" value="true" />
       <option name="push" value="mte_crash->/data/local/tmp/mte_crash" />

From 1ebf9cb66322f83c65003a62e866b0fe2d974f9b Mon Sep 17 00:00:00 2001
From: Luzanne Batoon <batoon@google.com>
Date: Thu, 9 May 2024 18:26:58 +0000
Subject: [PATCH 0911/1487] Add restorecon flags for force and data data

Test: m
Bug: 210155681

Change-Id: I9d5b64c48d21e83fb8f03dac261efc530c5f8aa6
---
 init/util.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/init/util.cpp b/init/util.cpp
index e5efc7da61bc..375e905d50ed 100644
--- a/init/util.cpp
+++ b/init/util.cpp
@@ -570,6 +570,8 @@ Result<std::pair<int, std::vector<std::string>>> ParseRestorecon(
             {"--recursive", SELINUX_ANDROID_RESTORECON_RECURSE},
             {"--skip-ce", SELINUX_ANDROID_RESTORECON_SKIPCE},
             {"--cross-filesystems", SELINUX_ANDROID_RESTORECON_CROSS_FILESYSTEMS},
+            {"--force", SELINUX_ANDROID_RESTORECON_FORCE},
+            {"--data-data", SELINUX_ANDROID_RESTORECON_DATADATA},
             {0, 0}};
 
     int flag = 0;

From c4b24f70e6405669d02881b0d06b70a6c5b300f8 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Thu, 16 May 2024 22:59:16 +0000
Subject: [PATCH 0912/1487] cleanup: PLOG(FATAL) crashes, does not need else
 branch

Change-Id: I49a439d444dc9f566a05bab23d8cfd06ce56d4a6
---
 debuggerd/crash_dump.cpp | 43 ++++++++++++++++++++--------------------
 1 file changed, 21 insertions(+), 22 deletions(-)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 852c159a5b29..bebd4b628717 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -303,28 +303,27 @@ static void ReadCrashInfo(unique_fd& fd, siginfo_t* siginfo,
   *recoverable_crash = false;
   if (rc == -1) {
     PLOG(FATAL) << "failed to read target ucontext";
-  } else {
-    ssize_t expected_size = 0;
-    switch (crash_info->header.version) {
-      case 1:
-      case 2:
-      case 3:
-        expected_size = sizeof(CrashInfoHeader) + sizeof(CrashInfoDataStatic);
-        break;
-
-      case 4:
-        expected_size = sizeof(CrashInfoHeader) + sizeof(CrashInfoDataDynamic);
-        break;
-
-      default:
-        LOG(FATAL) << "unexpected CrashInfo version: " << crash_info->header.version;
-        break;
-    };
-
-    if (rc < expected_size) {
-      LOG(FATAL) << "read " << rc << " bytes when reading target crash information, expected "
-                 << expected_size;
-    }
+  }
+  ssize_t expected_size = 0;
+  switch (crash_info->header.version) {
+    case 1:
+    case 2:
+    case 3:
+      expected_size = sizeof(CrashInfoHeader) + sizeof(CrashInfoDataStatic);
+      break;
+
+    case 4:
+      expected_size = sizeof(CrashInfoHeader) + sizeof(CrashInfoDataDynamic);
+      break;
+
+    default:
+      LOG(FATAL) << "unexpected CrashInfo version: " << crash_info->header.version;
+      break;
+  };
+
+  if (rc < expected_size) {
+    LOG(FATAL) << "read " << rc << " bytes when reading target crash information, expected "
+                << expected_size;
   }
 
   switch (crash_info->header.version) {

From 208fccdae8c520d49355dd51b9808f2bfd088881 Mon Sep 17 00:00:00 2001
From: Dennis Shen <dzshen@google.com>
Date: Fri, 17 May 2024 00:46:28 +0000
Subject: [PATCH 0913/1487] init.rc: set up init.rc for aconfigd to initialize
 mainline storage

aconfigd-mainline-init is the service target to initialize mainline
storage files. aconfigd is the service target to start aconfigd socket
for incoming messages.

Bug: b/312444587
Test: m and avd
Change-Id: Ic8052eaf933501da3371812c482ad816ec353b27
---
 rootdir/init.rc | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index f7f0cc385e85..e8b737d0770d 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -640,8 +640,7 @@ on post-fs
     mkdir /metadata/aconfig/boot 0775 root system
 
     mkdir /metadata/aconfig_test_missions 0775 root system
-    exec_start aconfigd-init
-    start aconfigd
+    exec_start aconfigd-platform-init
 
 on late-fs
     # Ensure that tracefs has the correct permissions.
@@ -1031,6 +1030,8 @@ on post-fs-data
     # Wait for apexd to finish activating APEXes before starting more processes.
     wait_for_prop apexd.status activated
     perform_apex_config
+    exec_start aconfigd-mainline-init
+    start aconfigd
 
     # Create directories for boot animation.
     mkdir /data/misc/bootanim 0755 system system

From aed74bad41a6c2ae44f65bf9f3b0593ca86613e2 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 17 May 2024 11:31:36 +0000
Subject: [PATCH 0914/1487] Remove stray semicolon.

Change-Id: Ic50a84888a7e0c059b4c06716e20e5f120b9b343
---
 debuggerd/crash_dump.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index bebd4b628717..77d4a07af619 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -319,7 +319,7 @@ static void ReadCrashInfo(unique_fd& fd, siginfo_t* siginfo,
     default:
       LOG(FATAL) << "unexpected CrashInfo version: " << crash_info->header.version;
       break;
-  };
+  }
 
   if (rc < expected_size) {
     LOG(FATAL) << "read " << rc << " bytes when reading target crash information, expected "

From 4334a6320c9b4a83dc41e2d1f7f13a41193b6c1f Mon Sep 17 00:00:00 2001
From: Snehal <snehalreddy@google.com>
Date: Tue, 14 May 2024 15:43:21 +0000
Subject: [PATCH 0915/1487] [Trusty][Metrics] Update struct to add is_crash on
 the NS side

Bug: 340509044

Change-Id: I4547286c5cefa3caaf1bf1c30f205145fb5e689c
---
 trusty/metrics/include/trusty/metrics/tipc.h | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/trusty/metrics/include/trusty/metrics/tipc.h b/trusty/metrics/include/trusty/metrics/tipc.h
index e2cf57b8f8d6..b4428d576def 100644
--- a/trusty/metrics/include/trusty/metrics/tipc.h
+++ b/trusty/metrics/include/trusty/metrics/tipc.h
@@ -49,6 +49,7 @@
  * @METRICS_CMD_REQ_SHIFT:            number of bits used by @METRICS_CMD_RESP_BIT
  * @METRICS_CMD_REPORT_EVENT_DROP:    report gaps in the event stream
  * @METRICS_CMD_REPORT_CRASH:         report an app crash event
+ * @METRICS_CMD_REPORT_EXIT:          report an app exit
  * @METRICS_CMD_REPORT_STORAGE_ERROR: report trusty storage error
  */
 enum metrics_cmd {
@@ -57,7 +58,8 @@ enum metrics_cmd {
 
     METRICS_CMD_REPORT_EVENT_DROP = (1 << METRICS_CMD_REQ_SHIFT),
     METRICS_CMD_REPORT_CRASH = (2 << METRICS_CMD_REQ_SHIFT),
-    METRICS_CMD_REPORT_STORAGE_ERROR = (3 << METRICS_CMD_REQ_SHIFT),
+    METRICS_CMD_REPORT_EXIT = (3 << METRICS_CMD_REQ_SHIFT),
+    METRICS_CMD_REPORT_STORAGE_ERROR = (4 << METRICS_CMD_REQ_SHIFT),
 };
 
 /**
@@ -91,10 +93,23 @@ struct metrics_resp {
     uint32_t status;
 } __attribute__((__packed__));
 
+/**
+ * struct metrics_report_exit_req - arguments of %METRICS_CMD_REPORT_EXIT
+ *                                   requests
+ * @app_id: app_id in the form UUID in ascii format
+ *          "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+ * @exit_code: architecture-specific exit code
+ */
+struct metrics_report_exit_req {
+    char app_id[UUID_STR_SIZE];
+    uint32_t exit_code;
+} __attribute__((__packed__));
+
 /**
  * struct metrics_report_crash_req - arguments of %METRICS_CMD_REPORT_CRASH
  *                                   requests
- * @app_id: uuid of the app that crashed
+ * @app_id: app_id in the form UUID in ascii format
+ *          "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
  * @crash_reason: architecture-specific code representing the reason for the
  *                crash
  */
@@ -158,6 +173,7 @@ struct metrics_msg {
     struct metrics_req req;
     union {
         struct metrics_report_crash_req crash_args;
+        struct metrics_report_exit_req exit_args;
         struct metrics_report_storage_error_req storage_args;
     };
 } __attribute__((__packed__));
\ No newline at end of file

From 5e88a32def8c1ba2f4661fa0ee1fff47495c0506 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= <maze@google.com>
Date: Tue, 19 Mar 2024 16:45:28 -0700
Subject: [PATCH 0916/1487] make apex init .XXrc parsing honour .35rc even
 though we're not yet sdk=35
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Test: TreeHugger
Signed-off-by: Maciej Żenczykowski <maze@google.com>
Change-Id: I315cfe77c60988d8cdc8ef64bf8cb2f5c37c93db
---
 init/apex_init_util.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/init/apex_init_util.cpp b/init/apex_init_util.cpp
index 6d17f36e2201..e5a7fbcc0b8c 100644
--- a/init/apex_init_util.cpp
+++ b/init/apex_init_util.cpp
@@ -107,8 +107,9 @@ static Result<void> ParseRcScripts(const std::vector<std::string>& files) {
     }
     // APEXes can have versioned RC files. These should be filtered based on
     // SDK version.
-    auto filtered = FilterVersionedConfigs(
-            files, android::base::GetIntProperty("ro.build.version.sdk", INT_MAX));
+    int sdk = android::base::GetIntProperty("ro.build.version.sdk", INT_MAX);
+    if (sdk < 35) sdk = 35;  // aosp/main merges only into sdk=35+ (ie. __ANDROID_API_V__+)
+    auto filtered = FilterVersionedConfigs(files, sdk);
     if (filtered.empty()) {
         return {};
     }

From a8a2c5a7e19dad4ba79ae0281b8d36a9042877ce Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Mon, 20 May 2024 21:56:19 +0000
Subject: [PATCH 0917/1487] init: delay 'user root' test to W+

We'll make it a build time check in V after this.

Due to being a runtime flog, it was hard to spot and
debug, so delaying.

Bug: 340953047
Test: boot, CtsInitTestCases
Change-Id: Ica1a1c780e230c88615dad7937404d2b0fe9c68f
---
 init/host_init_stubs.h  | 1 +
 init/init_test.cpp      | 2 +-
 init/service_parser.cpp | 6 +++---
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/init/host_init_stubs.h b/init/host_init_stubs.h
index 753ed6bb294d..2fef9d3498c9 100644
--- a/init/host_init_stubs.h
+++ b/init/host_init_stubs.h
@@ -32,6 +32,7 @@
 #define __ANDROID_API_S__ 31
 #define __ANDROID_API_T__ 33
 #define __ANDROID_API_U__ 34
+#define __ANDROID_API_V__ 35
 
 // sys/system_properties.h
 #define PROP_VALUE_MAX 92
diff --git a/init/init_test.cpp b/init/init_test.cpp
index 7e8513bfc921..b2f586b78e77 100644
--- a/init/init_test.cpp
+++ b/init/init_test.cpp
@@ -630,7 +630,7 @@ service A something
 
     ASSERT_TRUE(parser.ParseConfig(tf.path));
 
-    if (GetIntProperty("ro.vendor.api_level", 0) > __ANDROID_API_U__) {
+    if (GetIntProperty("ro.vendor.api_level", 0) > __ANDROID_API_V__) {
         ASSERT_EQ(1u, parser.parse_error_count());
     } else {
         ASSERT_EQ(0u, parser.parse_error_count());
diff --git a/init/service_parser.cpp b/init/service_parser.cpp
index 92e350be607c..6f3e3682ed5d 100644
--- a/init/service_parser.cpp
+++ b/init/service_parser.cpp
@@ -680,12 +680,12 @@ Result<void> ServiceParser::EndSection() {
     }
 
     if (service_->proc_attr_.parsed_uid == std::nullopt) {
-        if (android::base::GetIntProperty("ro.vendor.api_level", 0) > __ANDROID_API_U__) {
+        if (android::base::GetIntProperty("ro.vendor.api_level", 0) > __ANDROID_API_V__) {
             return Error() << "No user specified for service '" << service_->name()
-                           << "'. Defaults to root.";
+                           << "', so it would have been root.";
         } else {
             LOG(WARNING) << "No user specified for service '" << service_->name()
-                         << "'. Defaults to root.";
+                         << "', so it is root.";
         }
     }
 

From b87b2555406fd9541389a1bc4671816e7153e75c Mon Sep 17 00:00:00 2001
From: Sami Tolvanen <samitolvanen@google.com>
Date: Tue, 21 May 2024 17:27:39 +0000
Subject: [PATCH 0918/1487] riscv64: increase ASLR randomness for Sv48/57

Linux 6.9+ supports 33 bits with Sv48 and Sv57. Increase the
maximum and update the comment.

Bug: https://github.com/google/android-riscv64/issues/1
Test: Treehugger
Change-Id: Ia2731143ad30c5febe2058d35a381c01b14d8c3c
---
 init/security.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/init/security.cpp b/init/security.cpp
index 3e15447506c7..a0d63bca83ff 100644
--- a/init/security.cpp
+++ b/init/security.cpp
@@ -114,10 +114,9 @@ Result<void> SetMmapRndBitsAction(const BuiltinArguments&) {
         return {};
     }
 #elif defined(__riscv)
-    // TODO: sv48 and sv57 have both been added to the kernel, but the kernel
-    // still doesn't support more than 24 bits.
-    // https://github.com/google/android-riscv64/issues/1
-    if (SetMmapRndBitsMin(24, 24, false)) {
+    // riscv64 supports 24 rnd bits with Sv39, and starting with the 6.9 kernel,
+    // 33 bits with Sv48 and Sv57.
+    if (SetMmapRndBitsMin(33, 24, false)) {
         return {};
     }
 #elif defined(__x86_64__)

From 230f639275bc7241a9fa46384d4a9ef8c722fa74 Mon Sep 17 00:00:00 2001
From: Dennis Shen <dzshen@google.com>
Date: Tue, 21 May 2024 15:30:59 +0000
Subject: [PATCH 0919/1487] init.rc: add a new maps dir under /metadata/aconfig
 dir

Bug: b/312444587
Test: m and avd
Change-Id: Idf19d314b51cc409e58d6a2f2ae1831bfc3d717d
---
 rootdir/init.rc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index e8b737d0770d..59537697332d 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -637,6 +637,7 @@ on post-fs
 
     mkdir /metadata/aconfig 0775 root system
     mkdir /metadata/aconfig/flags 0770 root system
+    mkdir /metadata/aconfig/maps 0775 root system
     mkdir /metadata/aconfig/boot 0775 root system
 
     mkdir /metadata/aconfig_test_missions 0775 root system

From 78c65e52a8409ddb7774fc4ad814d6f68ac83f7f Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Mon, 20 May 2024 18:05:40 -0700
Subject: [PATCH 0920/1487] Set ro.fstype.data when /data is mounted

Test: th
Bug: 341216848
Change-Id: I8adf12661eeb790bf0beb80409a678d53c2baea5
---
 fs_mgr/fs_mgr.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 835a3e7f6758..7f41cea83673 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -1656,6 +1656,19 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
             continue;
         }
     }
+    if (userdata_mounted) {
+        Fstab mounted_fstab;
+        if (!ReadFstabFromFile("/proc/mounts", &mounted_fstab)) {
+            LOG(ERROR) << "Could't load fstab from /proc/mounts , unable to set ro.fstype.data . "
+                          "init.rc actions depending on this prop would not run, boot might fail.";
+        } else {
+            for (const auto& entry : mounted_fstab) {
+                if (entry.mount_point == "/data") {
+                    android::base::SetProperty("ro.fstype.data", entry.fs_type);
+                }
+            }
+        }
+    }
 
     set_type_property(encryptable);
 

From 564d970bd081571bb648077a32d2a6daa982673c Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Wed, 22 May 2024 13:07:13 -0700
Subject: [PATCH 0921/1487] init: Use std::string_view instead of std::string
 where appropriate

Slightly reduce the time that is required to start the init process by
changing two static std::string variables into std::string_view variables.

Change-Id: Ib683a603da5f3d8968b26453b12544fed8a6397f
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 init/devices.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/init/devices.cpp b/init/devices.cpp
index e76786a6d495..792d8c843ea5 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -25,6 +25,7 @@
 #include <filesystem>
 #include <memory>
 #include <string>
+#include <string_view>
 #include <thread>
 
 #include <android-base/chrono_utils.h>
@@ -377,8 +378,8 @@ std::vector<std::string> DeviceHandler::GetBlockDeviceSymlinks(const Uevent& uev
 
     if (FindPlatformDevice(uevent.path, &device)) {
         // Skip /devices/platform or /devices/ if present
-        static const std::string devices_platform_prefix = "/devices/platform/";
-        static const std::string devices_prefix = "/devices/";
+        static constexpr std::string_view devices_platform_prefix = "/devices/platform/";
+        static constexpr std::string_view devices_prefix = "/devices/";
 
         if (StartsWith(device, devices_platform_prefix)) {
             device = device.substr(devices_platform_prefix.length());

From 0e8f64bb507376ea98024f634377125657289af5 Mon Sep 17 00:00:00 2001
From: Yi Kong <yikong@google.com>
Date: Fri, 24 May 2024 00:45:33 +0900
Subject: [PATCH 0922/1487] Fix build with ToT libc++

system/core/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h:174:33: error: no template named 'vector' in namespace 'std'
  174 |     bool GetSequenceDataV2(std::vector<uint32_t>* merge_op_blocks, std::vector<int>* other_ops,
      |                            ~~~~~^

Test: Build with ToT libc++
Change-Id: I1858b30bd4eb6df39411a60a64d6bf16d2a7bfa6
---
 fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h | 4 +++-
 fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h   | 1 +
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
index 21dc6667a5df..635a38c5235a 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
@@ -17,6 +17,8 @@
 #pragma once
 
 #include <memory>
+#include <vector>
+
 #include "libsnapshot/cow_format.h"
 
 namespace android {
@@ -50,4 +52,4 @@ class ICompressor {
     const uint32_t block_size_;
 };
 }  // namespace snapshot
-}  // namespace android
\ No newline at end of file
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
index 3f49c69a8a0e..3389f5863ee1 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h
@@ -19,6 +19,7 @@
 #include <memory>
 #include <optional>
 #include <unordered_map>
+#include <vector>
 
 #include <android-base/unique_fd.h>
 #include <libsnapshot/cow_format.h>

From 75ed08fb0bcd3306897d7dfbad189ea4d2fb8919 Mon Sep 17 00:00:00 2001
From: Sijie Chen <sijiec@google.com>
Date: Thu, 23 May 2024 00:10:07 +0000
Subject: [PATCH 0923/1487] [Berberis][CrashReporting] Add riscv case for
 thread local retrieve

As title.

Bug: 339287219
Test: NA
Change-Id: Ia75659330d1203f4f1fbaf019d41cb72c3986cd4
---
 debuggerd/crash_dump.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 77d4a07af619..1c1fb8a598e2 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -449,7 +449,16 @@ static bool GetGuestRegistersFromCrashedProcess([[maybe_unused]] pid_t tid,
 
   if (ptrace(PTRACE_GETREGSET, tid, NT_ARM_TLS, &pt_iov) != 0) {
     PLOG(ERROR) << "failed to read thread register for thread " << tid;
+    return false;
+  }
+#elif defined(__riscv)
+  struct user_regs_struct regs;
+  struct iovec pt_iov = {.iov_base = &regs, .iov_len = sizeof(regs)};
+  if (ptrace(PTRACE_GETREGSET, tid, NT_PRSTATUS, &pt_iov) != 0) {
+    PLOG(ERROR) << "failed to read thread register for thread " << tid;
+    return false;
   }
+  base = reinterpret_cast<uintptr_t>(regs.tp);
 #else
   // TODO(b/339287219): Add case for Riscv host.
   return false;

From 254436b3ae008853837e2a2a1232c12b92f67a72 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@acm.org>
Date: Thu, 23 May 2024 11:14:50 -0700
Subject: [PATCH 0924/1487] Make more DeviceHandler member functions private

Make all member functions private that are not called from outside
DeviceHandlermember functions.

Bug: 335708738
Change-Id: Ibe2e5f6b8b45a79b5be59665627e0a46de4e439a
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 init/devices.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/init/devices.h b/init/devices.h
index 44ce2a920c0c..6da1232595b4 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -127,9 +127,6 @@ class DeviceHandler : public UeventHandler {
     virtual ~DeviceHandler() = default;
 
     void HandleUevent(const Uevent& uevent) override;
-    void ColdbootDone() override;
-
-    std::vector<std::string> GetBlockDeviceSymlinks(const Uevent& uevent) const;
 
     // `androidboot.partition_map` allows associating a partition name for a raw block device
     // through a comma separated and semicolon deliminated list. For example,
@@ -138,11 +135,13 @@ class DeviceHandler : public UeventHandler {
     static std::string GetPartitionNameForDevice(const std::string& device);
 
   private:
+    void ColdbootDone() override;
     bool FindPlatformDevice(std::string path, std::string* platform_device_path) const;
     std::tuple<mode_t, uid_t, gid_t> GetDevicePermissions(
         const std::string& path, const std::vector<std::string>& links) const;
     void MakeDevice(const std::string& path, bool block, int major, int minor,
                     const std::vector<std::string>& links) const;
+    std::vector<std::string> GetBlockDeviceSymlinks(const Uevent& uevent) const;
     void HandleDevice(const std::string& action, const std::string& devpath, bool block, int major,
                       int minor, const std::vector<std::string>& links) const;
     void FixupSysPermissions(const std::string& upath, const std::string& subsystem) const;

From 01edc0939fc1fa8f079dedd3385a8bcf144e5f8a Mon Sep 17 00:00:00 2001
From: Peter Collingbourne <pcc@google.com>
Date: Thu, 23 May 2024 14:26:14 -0700
Subject: [PATCH 0925/1487] Remove fs_config lines for /data/*test*.

These lines were originally added to avoid needing to manually chmod
+x files pushed to these directories on the device, but adb push now
automatically copies the x bit from the host for paths without an
fs_config, so they should no longer be necessary.

Bug: 341415989
Change-Id: I83007dfe05de7b86c26373460af1f199a6d21147
---
 libcutils/fs_config.cpp | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/libcutils/fs_config.cpp b/libcutils/fs_config.cpp
index 5efe2098bac8..c34cd711e691 100644
--- a/libcutils/fs_config.cpp
+++ b/libcutils/fs_config.cpp
@@ -68,10 +68,6 @@ static const struct fs_path_config android_dirs[] = {
     { 01771, AID_SYSTEM,       AID_MISC,         0, "data/misc" },
     { 00775, AID_MEDIA_RW,     AID_MEDIA_RW,     0, "data/media/Music" },
     { 00775, AID_MEDIA_RW,     AID_MEDIA_RW,     0, "data/media" },
-    { 00750, AID_ROOT,         AID_SHELL,        0, "data/nativetest" },
-    { 00750, AID_ROOT,         AID_SHELL,        0, "data/nativetest64" },
-    { 00750, AID_ROOT,         AID_SHELL,        0, "data/benchmarktest" },
-    { 00750, AID_ROOT,         AID_SHELL,        0, "data/benchmarktest64" },
     { 00775, AID_ROOT,         AID_ROOT,         0, "data/preloads" },
     { 00771, AID_SYSTEM,       AID_SYSTEM,       0, "data" },
     { 00755, AID_ROOT,         AID_SYSTEM,       0, "mnt" },
@@ -143,12 +139,6 @@ static const struct fs_path_config android_files[] = {
     { 00644, AID_SYSTEM,    AID_SYSTEM,    0, "data/app-private/*" },
     { 00644, AID_APP,       AID_APP,       0, "data/data/*" },
     { 00644, AID_MEDIA_RW,  AID_MEDIA_RW,  0, "data/media/*" },
-    { 00640, AID_ROOT,      AID_SHELL,     0, "data/nativetest/tests.txt" },
-    { 00640, AID_ROOT,      AID_SHELL,     0, "data/nativetest64/tests.txt" },
-    { 00750, AID_ROOT,      AID_SHELL,     0, "data/nativetest/*" },
-    { 00750, AID_ROOT,      AID_SHELL,     0, "data/nativetest64/*" },
-    { 00750, AID_ROOT,      AID_SHELL,     0, "data/benchmarktest/*" },
-    { 00750, AID_ROOT,      AID_SHELL,     0, "data/benchmarktest64/*" },
     { 00600, AID_ROOT,      AID_ROOT,      0, "default.prop" }, // legacy
     { 00600, AID_ROOT,      AID_ROOT,      0, "system/etc/prop.default" },
     { 00600, AID_ROOT,      AID_ROOT,      0, "odm/build.prop" }, // legacy; only for P release

From 67ea4959a2391717f7149b6902e39631606a21c2 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 22 May 2024 12:18:45 -0700
Subject: [PATCH 0926/1487] libsnapshot: get read_ahead_size from build

In the case that read ahead size is set by the build, we want to read
that property rather than use our default.

Bug: 332255580
Test: th
Change-Id: I5302a9a275d284be6c68edab9e13aae1128eb699
---
 .../android/snapshot/snapshot.proto           |  3 ++
 fs_mgr/libsnapshot/partition_cow_creator.h    |  1 +
 fs_mgr/libsnapshot/snapshot.cpp               | 43 +++++++++----------
 3 files changed, 25 insertions(+), 22 deletions(-)

diff --git a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
index 076a918fe421..25f1d8847c59 100644
--- a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
+++ b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
@@ -120,6 +120,9 @@ message SnapshotStatus {
 
     // Max bytes to be compressed at once (4k, 8k, 16k, 32k, 64k, 128k)
     uint64 compression_factor = 16;
+
+    // Default value is 32, can be set lower for low mem devices
+    uint32 read_ahead_size = 17;
 }
 
 // Next: 8
diff --git a/fs_mgr/libsnapshot/partition_cow_creator.h b/fs_mgr/libsnapshot/partition_cow_creator.h
index cbd664fef062..a75d993c7b7c 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator.h
+++ b/fs_mgr/libsnapshot/partition_cow_creator.h
@@ -60,6 +60,7 @@ struct PartitionCowCreator {
     bool using_snapuserd = false;
     std::string compression_algorithm;
     uint64_t compression_factor;
+    uint32_t read_ahead_size;
 
     // True if multi-threaded compression should be enabled
     bool enable_threading;
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 7ca53ad42dfe..8620620e4714 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -101,8 +101,7 @@ static constexpr auto kUpdateStateCheckInterval = 2s;
  * time, they could use O_DIRECT functionality wherein the I/O to the source
  * block device will be O_DIRECT.
  */
-static constexpr auto kCowReadAheadSizeKb = 32;
-static constexpr auto kSourceReadAheadSizeKb = 32;
+static constexpr auto kReadAheadSizeKb = 32;
 
 // Note: IImageManager is an incomplete type in the header, so the default
 // destructor doesn't work.
@@ -418,6 +417,7 @@ bool SnapshotManager::CreateSnapshot(LockedFile* lock, PartitionCowCreator* cow_
     status->set_using_snapuserd(cow_creator->using_snapuserd);
     status->set_compression_algorithm(cow_creator->compression_algorithm);
     status->set_compression_factor(cow_creator->compression_factor);
+    status->set_read_ahead_size(cow_creator->read_ahead_size);
     if (cow_creator->enable_threading) {
         status->set_enable_threading(cow_creator->enable_threading);
     }
@@ -1142,8 +1142,8 @@ auto SnapshotManager::CheckMergeState(const std::function<bool()>& before_cancel
     return result;
 }
 
-auto SnapshotManager::CheckMergeState(LockedFile* lock, const std::function<bool()>& before_cancel)
-        -> MergeResult {
+auto SnapshotManager::CheckMergeState(LockedFile* lock,
+                                      const std::function<bool()>& before_cancel) -> MergeResult {
     SnapshotUpdateStatus update_status = ReadSnapshotUpdateStatus(lock);
     switch (update_status.state()) {
         case UpdateState::None:
@@ -1765,9 +1765,8 @@ bool SnapshotManager::PerformInitTransition(InitTransition transition,
                                base_path_merge;
                 snapuserd_argv->emplace_back(std::move(message));
             }
-
-            SetReadAheadSize(cow_image_device, kCowReadAheadSizeKb);
-            SetReadAheadSize(source_device, kSourceReadAheadSizeKb);
+            SetReadAheadSize(cow_image_device, snapshot_status.read_ahead_size());
+            SetReadAheadSize(source_device, snapshot_status.read_ahead_size());
 
             // Do not attempt to connect to the new snapuserd yet, it hasn't
             // been started. We do however want to wait for the misc device
@@ -2852,8 +2851,8 @@ bool SnapshotManager::UnmapAllSnapshots(LockedFile* lock) {
     return true;
 }
 
-auto SnapshotManager::OpenFile(const std::string& file, int lock_flags)
-        -> std::unique_ptr<LockedFile> {
+auto SnapshotManager::OpenFile(const std::string& file,
+                               int lock_flags) -> std::unique_ptr<LockedFile> {
     unique_fd fd(open(file.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
     if (fd < 0) {
         PLOG(ERROR) << "Open failed: " << file;
@@ -3309,19 +3308,19 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
         LOG(INFO) << "using compression algorithm: " << compression_algorithm
                   << ", max compressible block size: " << compression_factor;
     }
-
-    PartitionCowCreator cow_creator{
-            .target_metadata = target_metadata.get(),
-            .target_suffix = target_suffix,
-            .target_partition = nullptr,
-            .current_metadata = current_metadata.get(),
-            .current_suffix = current_suffix,
-            .update = nullptr,
-            .extra_extents = {},
-            .using_snapuserd = using_snapuserd,
-            .compression_algorithm = compression_algorithm,
-            .compression_factor = compression_factor,
-    };
+    auto read_ahead_size =
+            android::base::GetUintProperty<uint>("ro.virtual_ab.read_ahead_size", kReadAheadSizeKb);
+    PartitionCowCreator cow_creator{.target_metadata = target_metadata.get(),
+                                    .target_suffix = target_suffix,
+                                    .target_partition = nullptr,
+                                    .current_metadata = current_metadata.get(),
+                                    .current_suffix = current_suffix,
+                                    .update = nullptr,
+                                    .extra_extents = {},
+                                    .using_snapuserd = using_snapuserd,
+                                    .compression_algorithm = compression_algorithm,
+                                    .compression_factor = compression_factor,
+                                    .read_ahead_size = read_ahead_size};
 
     if (dap_metadata.vabc_feature_set().has_threaded()) {
         cow_creator.enable_threading = dap_metadata.vabc_feature_set().threaded();

From 6c0800fbbdaa56c4d38cb24bcd0289cb0bf88e74 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 22 May 2024 12:36:36 -0700
Subject: [PATCH 0927/1487] update supported compression methods

Test: th
Change-Id: Ice13f58e6d29b8f28a4d43a86fb59e91ae9e9dde
---
 fs_mgr/libsnapshot/android/snapshot/snapshot.proto | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
index 25f1d8847c59..c6c3aecb82c3 100644
--- a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
+++ b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
@@ -103,7 +103,7 @@ message SnapshotStatus {
     // The old partition size (if none existed, this will be zero).
     uint64 old_partition_size = 10;
 
-    // Compression algorithm (none, gz, lz4, zstd, or brotli).
+    // Compression algorithm (none, lz4, zstd).
     string compression_algorithm = 11;
 
     // Estimated COW size from OTA manifest.

From 09e081f98eaa8da729ec7637afce0d0ecc9d84e1 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 23 May 2024 10:56:30 -0700
Subject: [PATCH 0928/1487] snapshot_proto add build configuration variables

We are adding low memory device configurables. Post OTA reboot, these
values need to be read during 1st stage init and set. Since .ro props
aren't available at this stage, we need to flush these configurables to
snapshot_protos that lives under /Metadata

Bug: 332255580
Test: th
Change-Id: Iff84c0dfe9c6931ea13165b380e11cee6343ce91
---
 fs_mgr/libsnapshot/android/snapshot/snapshot.proto | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
index c6c3aecb82c3..d04c9c19d05c 100644
--- a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
+++ b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
@@ -123,6 +123,15 @@ message SnapshotStatus {
 
     // Default value is 32, can be set lower for low mem devices
     uint32 read_ahead_size = 17;
+
+    // Enable direct reads on source device
+    bool o_direct = 18;
+
+    // Blocks size to be verified at once
+    uint64 verify_block_size = 19;
+
+    // Default value is 2, configures threads to do verification phase
+    uint32 num_verify_threads = 20;
 }
 
 // Next: 8

From 43b2abf797b0ce62e02717118facad559b49e00b Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 23 May 2024 14:13:27 -0700
Subject: [PATCH 0929/1487] libsnapshot: set num merge threads

Read number of merge threads from build. In the case that this isn't
specified, fallback to our default.

**THIS doesn't seem to be currently working. It looks like we can't
directly read the property here?

Test: th
Change-Id: I115b6b987699759168d34239d030cfcd0238b1b4
---
 .../snapuserd/user-space-merge/handler_manager.cpp           | 5 ++++-
 .../snapuserd/user-space-merge/snapuserd_server.h            | 2 +-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index 711e70473ac3..ea11f0e6e480 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -19,6 +19,7 @@
 
 #include <android-base/logging.h>
 
+#include "android-base/properties.h"
 #include "merge_worker.h"
 #include "read_worker.h"
 #include "snapuserd_core.h"
@@ -235,8 +236,10 @@ void SnapshotHandlerManager::MonitorMerge() {
 
         LOG(INFO) << "MonitorMerge: active-merge-threads: " << active_merge_threads_;
         {
+            auto num_merge_threads = android::base::GetUintProperty<uint>(
+                    "ro.virtual_ab.num_merge_threads", kMaxMergeThreads);
             std::lock_guard<std::mutex> lock(lock_);
-            while (active_merge_threads_ < kMaxMergeThreads && merge_handlers_.size() > 0) {
+            while (active_merge_threads_ < num_merge_threads && merge_handlers_.size() > 0) {
                 auto handler = merge_handlers_.front();
                 merge_handlers_.pop();
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index 3013c47fcced..d9cf97f9d396 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -39,7 +39,7 @@ namespace android {
 namespace snapshot {
 
 static constexpr uint32_t kMaxPacketSize = 512;
-static constexpr uint8_t kMaxMergeThreads = 2;
+
 static constexpr char kBootSnapshotsWithoutSlotSwitch[] =
         "/metadata/ota/snapshot-boot-without-slot-switch";
 

From 262f1e8096a0a93de4a7a6dba1ae38b88da2e82b Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@acm.org>
Date: Thu, 23 May 2024 11:20:07 -0700
Subject: [PATCH 0930/1487] Create the /dev/sys/block/by-name/zoned_device
 symbolic link

This link will be used to change the sysfs attributes of the zoned block
device from an .rc file.

Bug: 335708738
Change-Id: I99f74c121e7d9da404c0564860c03ac1efe6c6d8
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 init/devices.cpp | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/init/devices.cpp b/init/devices.cpp
index 792d8c843ea5..5560c20bcb69 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -435,6 +435,7 @@ std::vector<std::string> DeviceHandler::GetBlockDeviceSymlinks(const Uevent& uev
     if (ReadFileToString("/sys/class/block/" + uevent.device_name + "/queue/zoned", &model) &&
         !StartsWith(model, "none")) {
         links.emplace_back("/dev/block/by-name/zoned_device");
+        links.emplace_back("/dev/sys/block/by-name/zoned_device");
     }
 
     auto last_slash = uevent.path.rfind('/');
@@ -483,11 +484,21 @@ void DeviceHandler::HandleDevice(const std::string& action, const std::string& d
     // event.
     if (action == "add" || (action == "change" && StartsWith(devpath, "/dev/block/dm-"))) {
         for (const auto& link : links) {
+            std::string target;
+            if (StartsWith(link, "/dev/block/")) {
+                target = devpath;
+            } else if (StartsWith(link, "/dev/sys/block/")) {
+                target = "/sys/class/block/" + Basename(devpath);
+            } else {
+                LOG(ERROR) << "Unrecognized link type: " << link;
+                continue;
+            }
+
             if (!mkdir_recursive(Dirname(link), 0755)) {
                 PLOG(ERROR) << "Failed to create directory " << Dirname(link);
             }
 
-            if (symlink(devpath.c_str(), link.c_str())) {
+            if (symlink(target.c_str(), link.c_str())) {
                 if (errno != EEXIST) {
                     PLOG(ERROR) << "Failed to symlink " << devpath << " to " << link;
                 } else if (std::string link_path;

From 81f1da48bcc692127fbce589344ac4cfe34d6776 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 23 May 2024 10:23:32 -0700
Subject: [PATCH 0931/1487] create_snapshot: Build the binary as static

Build it statically so that it gets easy to be deployed
in lab host without additional shared dependency.

Bug: 342328623
Test: Build create_snapshot; ldd create_snapshot
Change-Id: Ie788ba34bfff38cf78f29ad41d912dcad3bf77de
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/Android.bp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 914b4a63f115..402eb82164f0 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -503,6 +503,8 @@ cc_binary {
             enabled: false,
         },
     },
+    stl: "libc++_static",
+    static_executable: true,
 }
 
 python_library_host {

From 7badb51d228c760bb9203f34f2e577c93e9078d2 Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Wed, 8 May 2024 16:21:18 -0700
Subject: [PATCH 0932/1487] Mark libutils_binder_sdk as snapshot supported

Bug: 302718225
Test: https://r.android.com/2803466
Change-Id: I3a26e1c4c63e0ed6de896ef31eb56f3a3a6bba01
---
 libutils/binder/Android.bp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libutils/binder/Android.bp b/libutils/binder/Android.bp
index 60b0cb62c2bb..54b98aff0629 100644
--- a/libutils/binder/Android.bp
+++ b/libutils/binder/Android.bp
@@ -41,11 +41,13 @@ cc_defaults {
 cc_library {
     name: "libutils_binder",
     defaults: ["libutils_binder_impl_defaults"],
+    cmake_snapshot_supported: false,
 }
 
 cc_library_shared {
     name: "libutils_binder_sdk",
     defaults: ["libutils_binder_impl_defaults_nodeps"],
+    cmake_snapshot_supported: true,
 
     header_libs: [
         "liblog_stub",

From 0a2a015e39db778eca620e970472728b4897d41b Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Tue, 30 Apr 2024 10:47:35 -0700
Subject: [PATCH 0933/1487] Fix libutils_binder_sdk build warnings

-Wclass-memaccess
-Winvalid-offsetof
-Wsequence-point
-Wzero-as-null-pointer-constant (turned on in ag/4503295)

Bug: 285204695
Test: m libutils_binder_sdk
Change-Id: I5b988f498cb8e0cf04617a4f7fd41ba9970d321d
---
 libutils/binder/Android.bp                  |  6 ++++++
 libutils/binder/SharedBuffer.cpp            |  2 +-
 libutils/binder/String16.cpp                | 17 +++++++++++++++++
 libutils/binder/include/utils/RefBase.h     |  9 ++++-----
 libutils/binder/include/utils/TypeHelpers.h |  4 ++--
 5 files changed, 30 insertions(+), 8 deletions(-)

diff --git a/libutils/binder/Android.bp b/libutils/binder/Android.bp
index 54b98aff0629..e3583912d8d4 100644
--- a/libutils/binder/Android.bp
+++ b/libutils/binder/Android.bp
@@ -22,6 +22,12 @@ cc_defaults {
         "VectorImpl.cpp",
     ],
 
+    cflags: [
+        "-Winvalid-offsetof",
+        "-Wsequence-point",
+        "-Wzero-as-null-pointer-constant",
+    ],
+
     apex_available: [
         "//apex_available:anyapex",
         "//apex_available:platform",
diff --git a/libutils/binder/SharedBuffer.cpp b/libutils/binder/SharedBuffer.cpp
index 3e703dbc85f6..d16bdb08670c 100644
--- a/libutils/binder/SharedBuffer.cpp
+++ b/libutils/binder/SharedBuffer.cpp
@@ -75,7 +75,7 @@ SharedBuffer* SharedBuffer::editResize(size_t newSize) const
         LOG_ALWAYS_FATAL_IF((newSize >= (SIZE_MAX - sizeof(SharedBuffer))),
                             "Invalid buffer size %zu", newSize);
 
-        buf = (SharedBuffer*)realloc(buf, sizeof(SharedBuffer) + newSize);
+        buf = (SharedBuffer*)realloc(reinterpret_cast<void*>(buf), sizeof(SharedBuffer) + newSize);
         if (buf != nullptr) {
             buf->mSize = newSize;
             return buf;
diff --git a/libutils/binder/String16.cpp b/libutils/binder/String16.cpp
index 07a3d23f694c..96e147721533 100644
--- a/libutils/binder/String16.cpp
+++ b/libutils/binder/String16.cpp
@@ -22,6 +22,19 @@
 
 #include "SharedBuffer.h"
 
+#define LIBUTILS_PRAGMA(arg) _Pragma(#arg)
+#if defined(__clang__)
+#define LIBUTILS_PRAGMA_FOR_COMPILER(arg) LIBUTILS_PRAGMA(clang arg)
+#elif defined(__GNUC__)
+#define LIBUTILS_PRAGMA_FOR_COMPILER(arg) LIBUTILS_PRAGMA(GCC arg)
+#else
+#define LIBUTILS_PRAGMA_FOR_COMPILER(arg)
+#endif
+#define LIBUTILS_IGNORE(warning_flag)             \
+    LIBUTILS_PRAGMA_FOR_COMPILER(diagnostic push) \
+    LIBUTILS_PRAGMA_FOR_COMPILER(diagnostic ignored warning_flag)
+#define LIBUTILS_IGNORE_END() LIBUTILS_PRAGMA_FOR_COMPILER(diagnostic pop)
+
 namespace android {
 
 static const StaticString16 emptyString(u"");
@@ -347,7 +360,9 @@ void String16::release()
 bool String16::isStaticString() const {
     // See String16.h for notes on the memory layout of String16::StaticData and
     // SharedBuffer.
+    LIBUTILS_IGNORE("-Winvalid-offsetof")
     static_assert(sizeof(SharedBuffer) - offsetof(SharedBuffer, mClientMetadata) == 4);
+    LIBUTILS_IGNORE_END()
     const uint32_t* p = reinterpret_cast<const uint32_t*>(mString);
     return (*(p - 1) & kIsSharedBufferAllocated) == 0;
 }
@@ -355,7 +370,9 @@ bool String16::isStaticString() const {
 size_t String16::staticStringSize() const {
     // See String16.h for notes on the memory layout of String16::StaticData and
     // SharedBuffer.
+    LIBUTILS_IGNORE("-Winvalid-offsetof")
     static_assert(sizeof(SharedBuffer) - offsetof(SharedBuffer, mClientMetadata) == 4);
+    LIBUTILS_IGNORE_END()
     const uint32_t* p = reinterpret_cast<const uint32_t*>(mString);
     return static_cast<size_t>(*(p - 1));
 }
diff --git a/libutils/binder/include/utils/RefBase.h b/libutils/binder/include/utils/RefBase.h
index f03e1be0a7da..b6a8707a830f 100644
--- a/libutils/binder/include/utils/RefBase.h
+++ b/libutils/binder/include/utils/RefBase.h
@@ -555,7 +555,7 @@ template<typename T>
 wp<T>::wp(T* other)
     : m_ptr(other)
 {
-    m_refs = other ? m_refs = other->createWeak(this) : nullptr;
+    m_refs = other ? other->createWeak(this) : nullptr;
 }
 
 template <typename T>
@@ -662,8 +662,7 @@ wp<T>& wp<T>::operator = (const wp<U>& other)
 template<typename T> template<typename U>
 wp<T>& wp<T>::operator = (const sp<U>& other)
 {
-    weakref_type* newRefs =
-        other != nullptr ? other->createWeak(this) : 0;
+    weakref_type* newRefs = other != nullptr ? other->createWeak(this) : nullptr;
     U* otherPtr(other.m_ptr);
     if (m_ptr) m_refs->decWeak(this);
     m_ptr = otherPtr;
@@ -695,8 +694,8 @@ void wp<T>::clear()
 {
     if (m_ptr) {
         m_refs->decWeak(this);
-        m_refs = 0;
-        m_ptr = 0;
+        m_refs = nullptr;
+        m_ptr = nullptr;
     }
 }
 
diff --git a/libutils/binder/include/utils/TypeHelpers.h b/libutils/binder/include/utils/TypeHelpers.h
index 21d9b3db1090..007036bbdb9c 100644
--- a/libutils/binder/include/utils/TypeHelpers.h
+++ b/libutils/binder/include/utils/TypeHelpers.h
@@ -200,7 +200,7 @@ template<typename TYPE>
 typename std::enable_if<use_trivial_move<TYPE>::value>::type
 inline
 move_forward_type(TYPE* d, const TYPE* s, size_t n = 1) {
-    memmove(d, s, n*sizeof(TYPE));
+    memmove(reinterpret_cast<void*>(d), s, n * sizeof(TYPE));
 }
 
 template<typename TYPE>
@@ -227,7 +227,7 @@ template<typename TYPE>
 typename std::enable_if<use_trivial_move<TYPE>::value>::type
 inline
 move_backward_type(TYPE* d, const TYPE* s, size_t n = 1) {
-    memmove(d, s, n*sizeof(TYPE));
+    memmove(reinterpret_cast<void*>(d), s, n * sizeof(TYPE));
 }
 
 template<typename TYPE>

From b1a58e12dd834cddf5f77c0f7bbd0e357f06d4b5 Mon Sep 17 00:00:00 2001
From: Seth Moore <sethmo@google.com>
Date: Tue, 28 May 2024 19:09:40 +0000
Subject: [PATCH 0934/1487] Use shared trusty OWNERs file

Change-Id: I20f118c39927f56890a37eaa059249db5285e59b
---
 trusty/OWNERS | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/trusty/OWNERS b/trusty/OWNERS
index 40167925c0d6..46f1410a9536 100644
--- a/trusty/OWNERS
+++ b/trusty/OWNERS
@@ -1,11 +1,5 @@
-armellel@google.com
-arve@android.com
-danielangell@google.com
-gmar@google.com
+# include OWNERS from the top level trusty repo
+include trusty:main:/OWNERS
+
 mikemcternan@google.com
-mmaurer@google.com
-ncbray@google.com
-swillden@google.com
-thurston@google.com
-trong@google.com
-wenhaowang@google.com
+swillden@google.com
\ No newline at end of file

From b9e0545c855634897be33e71f6ecaa3794890c6c Mon Sep 17 00:00:00 2001
From: Nate Myren <ntmyren@google.com>
Date: Tue, 28 May 2024 23:40:59 +0000
Subject: [PATCH 0935/1487] Revert^2 "Only write appcompat properties if flag
 is defined"

This reverts commit 6d8304aa469b76d487e027cb1cf7ea1e18784dbc.

Reason for revert: resubmission

Change-Id: Ifb66efa2b1b7a734302316259690950306af99ec
---
 init/Android.bp           | 4 ++++
 init/property_service.cpp | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/init/Android.bp b/init/Android.bp
index 6d63e41e2164..c4e74d068b0d 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -96,6 +96,7 @@ soong_config_module_type {
     config_namespace: "ANDROID",
     bool_variables: [
         "PRODUCT_INSTALL_DEBUG_POLICY_TO_SYSTEM_EXT",
+        "release_write_appcompat_override_system_properties",
     ],
     properties: [
         "cflags",
@@ -159,6 +160,9 @@ libinit_cc_defaults {
                 "-DINSTALL_DEBUG_POLICY_TO_SYSTEM_EXT=1",
             ],
         },
+        release_write_appcompat_override_system_properties: {
+            cflags: ["-DWRITE_APPCOMPAT_OVERRIDE_SYSTEM_PROPERTIES"],
+        }
     },
     static_libs: [
         "libavb",
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 58a0a7faa05d..5a1b63b2e49a 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1308,12 +1308,14 @@ void CreateSerializedPropertyInfo() {
     }
     selinux_android_restorecon(PROP_TREE_FILE, 0);
 
+#ifdef WRITE_APPCOMPAT_OVERRIDE_SYSTEM_PROPERTIES
     mkdir(APPCOMPAT_OVERRIDE_PROP_FOLDERNAME, S_IRWXU | S_IXGRP | S_IXOTH);
     if (!WriteStringToFile(serialized_contexts, APPCOMPAT_OVERRIDE_PROP_TREE_FILE, 0444, 0, 0,
                            false)) {
         PLOG(ERROR) << "Unable to write appcompat override property infos to file";
     }
     selinux_android_restorecon(APPCOMPAT_OVERRIDE_PROP_TREE_FILE, 0);
+#endif
 }
 
 static void ExportKernelBootProps() {

From 5088e588f7d68716e7641f520b961f28e06f676b Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Wed, 29 May 2024 00:03:19 +0000
Subject: [PATCH 0936/1487] init: 'user root' check use vendor API

This changes user root to use the year date format
that vendor API uses.

Previously this still applied to V devices, which switched
to using API level 202404 after 35.

They recommend the year/date form, and there is no
constant for this.

Bug: 340953047
Test: service_test
Change-Id: I5ba8d1251c877a785e41f0cfcc35d7cb0776f8c7
---
 init/host_init_stubs.h  | 1 -
 init/init_test.cpp      | 2 +-
 init/service_parser.cpp | 2 +-
 3 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/init/host_init_stubs.h b/init/host_init_stubs.h
index 2fef9d3498c9..753ed6bb294d 100644
--- a/init/host_init_stubs.h
+++ b/init/host_init_stubs.h
@@ -32,7 +32,6 @@
 #define __ANDROID_API_S__ 31
 #define __ANDROID_API_T__ 33
 #define __ANDROID_API_U__ 34
-#define __ANDROID_API_V__ 35
 
 // sys/system_properties.h
 #define PROP_VALUE_MAX 92
diff --git a/init/init_test.cpp b/init/init_test.cpp
index b2f586b78e77..50882737c304 100644
--- a/init/init_test.cpp
+++ b/init/init_test.cpp
@@ -630,7 +630,7 @@ service A something
 
     ASSERT_TRUE(parser.ParseConfig(tf.path));
 
-    if (GetIntProperty("ro.vendor.api_level", 0) > __ANDROID_API_V__) {
+    if (GetIntProperty("ro.vendor.api_level", 0) > 202404) {
         ASSERT_EQ(1u, parser.parse_error_count());
     } else {
         ASSERT_EQ(0u, parser.parse_error_count());
diff --git a/init/service_parser.cpp b/init/service_parser.cpp
index 6f3e3682ed5d..de902e6a8568 100644
--- a/init/service_parser.cpp
+++ b/init/service_parser.cpp
@@ -680,7 +680,7 @@ Result<void> ServiceParser::EndSection() {
     }
 
     if (service_->proc_attr_.parsed_uid == std::nullopt) {
-        if (android::base::GetIntProperty("ro.vendor.api_level", 0) > __ANDROID_API_V__) {
+        if (android::base::GetIntProperty("ro.vendor.api_level", 0) > 202404) {
             return Error() << "No user specified for service '" << service_->name()
                            << "', so it would have been root.";
         } else {

From 49ecca71b56be77a2b4380d16564013c0f70c94c Mon Sep 17 00:00:00 2001
From: Peter Collingbourne <pcc@google.com>
Date: Wed, 29 May 2024 14:22:40 -0700
Subject: [PATCH 0937/1487] Add fs_config entry for *.rc files.

Android init will refuse to read files that are world writable. Since
adb push makes files world writable by default, this means that adb
pushed rc files cannot be read by init. Fix it by adding an fs_config
entry for *.rc that sets their permissions to 644 root:root.

Bug: 343370899
Change-Id: If9c4dd4796caae6d177d9fdeef880949e5639648
---
 libcutils/fs_config.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libcutils/fs_config.cpp b/libcutils/fs_config.cpp
index 5efe2098bac8..b9d83f272c08 100644
--- a/libcutils/fs_config.cpp
+++ b/libcutils/fs_config.cpp
@@ -217,6 +217,7 @@ static const struct fs_path_config android_files[] = {
     { 00755, AID_ROOT,      AID_ROOT,      0, "bin/*" },
     { 00640, AID_ROOT,      AID_SHELL,     0, "fstab.*" },
     { 00750, AID_ROOT,      AID_SHELL,     0, "init*" },
+    { 00644, AID_ROOT,      AID_ROOT,      0, "*.rc" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "odm/bin/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "odm/framework/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "odm/app/*" },

From 062eb59a83fe62fd5701958e7fe433b8768d66d6 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Wed, 29 May 2024 23:26:16 +0000
Subject: [PATCH 0938/1487] Revert "Set ro.fstype.data when /data is mounted"

Revert submission 3095293-fstype

Reason for revert: breaks build cf_x86_64_only_phone-next-userdebug

Reverted changes: /q/submissionid:3095293-fstype

Change-Id: I2d1b2561ec7a3d8ea954b375153dce1a936d0294
---
 fs_mgr/fs_mgr.cpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 7f41cea83673..835a3e7f6758 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -1656,19 +1656,6 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
             continue;
         }
     }
-    if (userdata_mounted) {
-        Fstab mounted_fstab;
-        if (!ReadFstabFromFile("/proc/mounts", &mounted_fstab)) {
-            LOG(ERROR) << "Could't load fstab from /proc/mounts , unable to set ro.fstype.data . "
-                          "init.rc actions depending on this prop would not run, boot might fail.";
-        } else {
-            for (const auto& entry : mounted_fstab) {
-                if (entry.mount_point == "/data") {
-                    android::base::SetProperty("ro.fstype.data", entry.fs_type);
-                }
-            }
-        }
-    }
 
     set_type_property(encryptable);
 

From ed92eabfbb15bbe6d9e6efe55edc57ef7eb5f6f1 Mon Sep 17 00:00:00 2001
From: Kiyoung Kim <kiyoungkim@google.com>
Date: Wed, 29 May 2024 17:19:04 +0900
Subject: [PATCH 0939/1487] Make public.libraries.android.txt available to
 filesystem

public.libraries.android.txt was not installable as it was used only
from microdroid. However, this module can also be used from system
image, as there is no difference from the content. This change marks the
module as no_full_install, so it can be installed in the system image
defined in Android.bp

Bug: 343357947
Test: AOSP CF build succeeded
Change-Id: I15fd47b173b5b718972a6ee18b3aecb58826909c
---
 rootdir/Android.bp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index bd24f22f3abc..e8f7627f9162 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -62,7 +62,7 @@ prebuilt_etc {
     name: "public.libraries.android.txt",
     src: "etc/public.libraries.android.txt",
     filename: "public.libraries.txt",
-    installable: false,
+    no_full_install: true,
 }
 
 // adb_debug.prop in debug ramdisk

From 915f32d892be387e1419883b7ea080340b83595a Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 30 May 2024 19:11:07 +0000
Subject: [PATCH 0940/1487] Revert^2 "Set ro.fstype.data when /data is mounted"

062eb59a83fe62fd5701958e7fe433b8768d66d6

Change-Id: I20c4d4c17e4a314eb8754ed9c03db3dd8e3a5d0f
---
 fs_mgr/fs_mgr.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 835a3e7f6758..7f41cea83673 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -1656,6 +1656,19 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
             continue;
         }
     }
+    if (userdata_mounted) {
+        Fstab mounted_fstab;
+        if (!ReadFstabFromFile("/proc/mounts", &mounted_fstab)) {
+            LOG(ERROR) << "Could't load fstab from /proc/mounts , unable to set ro.fstype.data . "
+                          "init.rc actions depending on this prop would not run, boot might fail.";
+        } else {
+            for (const auto& entry : mounted_fstab) {
+                if (entry.mount_point == "/data") {
+                    android::base::SetProperty("ro.fstype.data", entry.fs_type);
+                }
+            }
+        }
+    }
 
     set_type_property(encryptable);
 

From 4e1776cedfaa68fab341e657e025ae31eb95f194 Mon Sep 17 00:00:00 2001
From: Will Deacon <willdeacon@google.com>
Date: Fri, 31 May 2024 15:34:18 +0000
Subject: [PATCH 0941/1487] Revert "Load modules from _16K dir when running on
 16K kernel"

This reverts commit ffdb017e7d0141d09d67c735913196a8dc166671.

Overriding an explicitly-specified module path (e.g. passed via the
'-d <path>' argument) because the kernel is using 16KiB pages is
inconsistent and unexpected. Revert this change in anticipation of
filtering incompatible modules instead.

Bug: 343971855
Test: Verified that _16k module directory is excluded by modprobe when running in userspace fastboot with 4k pages.
Change-Id: If9c6e2d26fc53b12f543d531d64ef3d288ddc179
---
 toolbox/modprobe.cpp | 20 --------------------
 1 file changed, 20 deletions(-)

diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index b0e76ea81bdc..45dd9b8c18d9 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -15,7 +15,6 @@
  */
 
 #include <ctype.h>
-#include <fcntl.h>
 #include <getopt.h>
 #include <stdlib.h>
 
@@ -28,7 +27,6 @@
 #include <modprobe/modprobe.h>
 
 #include <sys/utsname.h>
-#include <unistd.h>
 
 namespace {
 
@@ -107,11 +105,6 @@ static int KernelVersionNameFilter(const dirent* de) {
     return 0;
 }
 
-std::string GetPageSizeSuffix() {
-    static const size_t page_size = sysconf(_SC_PAGE_SIZE);
-    return android::base::StringPrintf("_%zuk", page_size / 1024);
-}
-
 }  // anonymous namespace
 
 extern "C" int modprobe_main(int argc, char** argv) {
@@ -240,19 +233,6 @@ extern "C" int modprobe_main(int argc, char** argv) {
         // Allow modules to be directly inside /lib/modules
         mod_dirs.emplace_back(LIB_MODULES_PREFIX);
     }
-    if (getpagesize() != 4096) {
-        struct utsname uts {};
-        if (uname(&uts)) {
-            PLOG(FATAL) << "Failed to get kernel version";
-        }
-        const auto module_dir = android::base::StringPrintf("/lib/modules/%s%s", uts.release,
-                                                            GetPageSizeSuffix().c_str());
-        struct stat st {};
-        if (stat(module_dir.c_str(), &st) == 0 && S_ISDIR(st.st_mode)) {
-            mod_dirs.clear();
-            mod_dirs.emplace_back(module_dir);
-        }
-    }
 
     LOG(DEBUG) << "mode is " << mode;
     LOG(DEBUG) << "mod_dirs is: " << android::base::Join(mod_dirs, " ");

From f2474379e76acefc4c918e292486b23b9a72e99e Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Fri, 31 May 2024 22:35:25 +0000
Subject: [PATCH 0942/1487] Add reserved to CrashDetail proto

Change-Id: I176abc740744907d8559b94b9d1361b44dcbcb14
---
 debuggerd/proto/tombstone.proto | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/debuggerd/proto/tombstone.proto b/debuggerd/proto/tombstone.proto
index 6f9cd9612507..b662d36805aa 100644
--- a/debuggerd/proto/tombstone.proto
+++ b/debuggerd/proto/tombstone.proto
@@ -18,6 +18,8 @@ option java_outer_classname = "TombstoneProtos";
 message CrashDetail {
   bytes name = 1;
   bytes data = 2;
+
+  reserved 3 to 999;
 }
 
 message Tombstone {

From f28b9a8b882d7a3ef5efdce1d7428e6b5e654116 Mon Sep 17 00:00:00 2001
From: Allen Hair <allenhair@google.com>
Date: Mon, 3 Jun 2024 19:14:52 +0000
Subject: [PATCH 0943/1487] Revert "Move native coverage output directory."

This reverts commit 65430f8de60c8b9f90a2e5e30da6d36f03e5860c.

Reason for revert: Checking to see if this is the root cause for b/342673274.

Change-Id: I9bb319e73443e57b4ac0b61f5209048d5eb7e6c0
---
 rootdir/Android.mk | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 0d5abbff4d62..593bb1e349e8 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -85,9 +85,9 @@ endif
 EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS :=
 ifeq ($(CLANG_COVERAGE),true)
   ifeq ($(CLANG_COVERAGE_CONTINUOUS_MODE),true)
-    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/local/tmp/clang%c-%20m.profraw
+    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang%c-%20m.profraw
   else
-    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/local/tmp/clang-%20m.profraw
+    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang-%20m.profraw
   endif
 endif
 

From c088de18793802e635c9771ccefd3c7d1083bf11 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 4 Jun 2024 16:47:32 +0000
Subject: [PATCH 0944/1487] libc++fs is part of libc++ now.

Change-Id: I2be806de736377e77bb49e4b3b9f72e25f7d717a
---
 fastboot/Android.bp           | 2 --
 fs_mgr/libsnapshot/Android.bp | 3 ---
 init/Android.bp               | 2 --
 init/fuzzer/Android.bp        | 1 -
 4 files changed, 8 deletions(-)

diff --git a/fastboot/Android.bp b/fastboot/Android.bp
index c0445f359f08..774af284cdac 100644
--- a/fastboot/Android.bp
+++ b/fastboot/Android.bp
@@ -190,7 +190,6 @@ cc_binary {
 
     static_libs: [
         "android.hardware.health-translate-ndk",
-        "libc++fs",
         "libhealthhalutils",
         "libhealthshim",
         "libfastbootshim",
@@ -416,7 +415,6 @@ cc_test_host {
     srcs: ["vendor_boot_img_utils_test.cpp"],
     static_libs: [
         "libbase",
-        "libc++fs",
         "libfastboot",
         "libgmock",
         "liblog",
diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 402eb82164f0..39b5b76531a4 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -126,7 +126,6 @@ cc_library {
         "libprotobuf-cpp-lite",
     ],
     static_libs: [
-        "libc++fs",
         "libsnapshot_cow",
     ],
 }
@@ -269,7 +268,6 @@ cc_defaults {
         "android.hardware.boot@1.1",
         "android.hardware.boot-V1-ndk",
         "libbrotli",
-        "libc++fs",
         "libfs_mgr_binder",
         "libgflags",
         "libgsi",
@@ -350,7 +348,6 @@ cc_binary {
     ],
     static_libs: [
         "libbrotli",
-        "libc++fs",
         "libfstab",
         "libz",
         "update_metadata-protos",
diff --git a/init/Android.bp b/init/Android.bp
index dd1f9aa3d0d2..cd5f38702f84 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -168,7 +168,6 @@ libinit_cc_defaults {
         "libavb",
         "libavf_cc_flags",
         "libbootloader_message",
-        "libc++fs",
         "libcgrouprc_format",
         "liblmkd_utils",
         "liblz4",
@@ -371,7 +370,6 @@ init_first_stage_cc_defaults {
     ],
 
     static_libs: [
-        "libc++fs",
         "libfs_avb",
         "libavf_cc_flags",
         "libfs_mgr",
diff --git a/init/fuzzer/Android.bp b/init/fuzzer/Android.bp
index 9916246d4fc6..5823932d2442 100644
--- a/init/fuzzer/Android.bp
+++ b/init/fuzzer/Android.bp
@@ -20,7 +20,6 @@ package {
 cc_defaults {
     name: "libinit_fuzzer_defaults",
     static_libs: [
-        "libc++fs",
         "liblmkd_utils",
         "libmodprobe",
         "libprotobuf-cpp-lite",

From 571d4faecb7d1e8f6551236a4f6c026b22715aff Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Tue, 4 Jun 2024 23:10:06 +0000
Subject: [PATCH 0945/1487] PREUPLOAD += bpfmt

Bugs: me
Test: upload with bp file
Change-Id: Ie8da54e7f4ceda4c50d9537bf9e8a232653d920d
---
 PREUPLOAD.cfg | 1 +
 1 file changed, 1 insertion(+)

diff --git a/PREUPLOAD.cfg b/PREUPLOAD.cfg
index 9b96f3691b55..f47c3171c9a2 100644
--- a/PREUPLOAD.cfg
+++ b/PREUPLOAD.cfg
@@ -1,6 +1,7 @@
 [Builtin Hooks]
 clang_format = true
 rustfmt = true
+bpfmt = true
 
 [Builtin Hooks Options]
 clang_format = --commit ${PREUPLOAD_COMMIT} --style file --extensions c,h,cc,cpp

From 81a1b3ec235fa0a9d09c6b2156b623523a12678f Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Mon, 20 May 2024 22:31:11 +0000
Subject: [PATCH 0946/1487] init: enable 'user root' check at build time

For visibility.

We could make this only for new API levels, but it isn't
currently exposed at build time, and visibility is good
on upgrades.

Bug: 340953047
Test: build, on device passing and failing requirements
Change-Id: I3a0ea47560c65114bc1b8685954d1fb7687cb8df
---
 init/Android.bp         | 10 ++++++++++
 init/host_init_stubs.h  |  1 +
 init/service_parser.cpp | 15 ++++++++++++++-
 3 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/init/Android.bp b/init/Android.bp
index dd1f9aa3d0d2..6992da4b0ab2 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -571,6 +571,11 @@ cc_library_static {
     ],
     export_include_dirs: ["test_utils/include"], // for tests
     header_libs: ["bionic_libc_platform_headers"],
+    product_variables: {
+        shipping_api_level: {
+            cflags: ["-DBUILD_SHIPPING_API_LEVEL=%s"],
+        },
+    },
 }
 
 // Host Verifier
@@ -625,6 +630,11 @@ cc_defaults {
             enabled: false,
         },
     },
+    product_variables: {
+        shipping_api_level: {
+            cflags: ["-DBUILD_SHIPPING_API_LEVEL=%s"],
+        },
+    },
 }
 
 cc_binary {
diff --git a/init/host_init_stubs.h b/init/host_init_stubs.h
index 753ed6bb294d..2fef9d3498c9 100644
--- a/init/host_init_stubs.h
+++ b/init/host_init_stubs.h
@@ -32,6 +32,7 @@
 #define __ANDROID_API_S__ 31
 #define __ANDROID_API_T__ 33
 #define __ANDROID_API_U__ 34
+#define __ANDROID_API_V__ 35
 
 // sys/system_properties.h
 #define PROP_VALUE_MAX 92
diff --git a/init/service_parser.cpp b/init/service_parser.cpp
index de902e6a8568..6781c7083c1d 100644
--- a/init/service_parser.cpp
+++ b/init/service_parser.cpp
@@ -52,6 +52,18 @@ using android::base::StartsWith;
 namespace android {
 namespace init {
 
+#ifdef INIT_FULL_SOURCES
+// on full sources, we have better information on device to
+// make this decision
+constexpr bool kAlwaysErrorUserRoot = false;
+#else
+constexpr uint64_t kBuildShippingApiLevel = BUILD_SHIPPING_API_LEVEL + 0 /* +0 if empty */;
+// on partial sources, the host build, we don't have the specific
+// vendor API level, but we can enforce things based on the
+// shipping API level.
+constexpr bool kAlwaysErrorUserRoot = kBuildShippingApiLevel > __ANDROID_API_V__;
+#endif
+
 Result<void> ServiceParser::ParseCapabilities(std::vector<std::string>&& args) {
     service_->capabilities_ = 0;
 
@@ -680,7 +692,8 @@ Result<void> ServiceParser::EndSection() {
     }
 
     if (service_->proc_attr_.parsed_uid == std::nullopt) {
-        if (android::base::GetIntProperty("ro.vendor.api_level", 0) > 202404) {
+        if (kAlwaysErrorUserRoot ||
+            android::base::GetIntProperty("ro.vendor.api_level", 0) > 202404) {
             return Error() << "No user specified for service '" << service_->name()
                            << "', so it would have been root.";
         } else {

From f0d3447af550b3e1c9e6045a2e8d3aa246a0de0d Mon Sep 17 00:00:00 2001
From: Yihan Dong <slotus@google.com>
Date: Wed, 5 Jun 2024 01:09:02 +0000
Subject: [PATCH 0947/1487] Add proposed trendy teams for CTS modules

Change-Id: I6f4dbaa75c219dd75fec84ab8c9590c4c81ec737
Test: build locally
Bug: 341598672
---
 fs_mgr/tests/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs_mgr/tests/Android.bp b/fs_mgr/tests/Android.bp
index 2aeba0acd6a1..041762fa1dfe 100644
--- a/fs_mgr/tests/Android.bp
+++ b/fs_mgr/tests/Android.bp
@@ -14,6 +14,7 @@
 
 package {
     default_applicable_licenses: ["Android-Apache-2.0"],
+    default_team: "trendy_team_android_kernel",
 }
 
 cc_test {

From c991c3dbedd35d5291c68da15681b8b1efd02f9c Mon Sep 17 00:00:00 2001
From: Will Deacon <willdeacon@google.com>
Date: Fri, 31 May 2024 17:25:49 +0000
Subject: [PATCH 0948/1487] toolbox/modprobe: Filter module directories based
 on kernel page size

When modules for multiple kernels with the same major/minor versions
are installed on a device, modprobe will search the module directories
based on whatever order scandir() returned them. In this case, it is
possible that we will try to load modules with the wrong page size for
the running kernel, which can lead to obscure symbol CRC mismatches and
ultimately a system crash.

Adjust the scandir() filtering function so that the kernel page size is
taken into account in addition to the major/minor versions returned by
utsname(). The general rule is that module directories ending in "_Nk"
contain modules for a page-size of N KiB, whilst the absence of such
a suffix implies the default of 4 KiB.

Bug: 343971855
Test: Verified that _16k module directory is excluded by modprobe when running in userspace fastboot with 4k pages.
Change-Id: I78a0a249028bbb0bcdd78eb14de36e631e233be0
---
 toolbox/modprobe.cpp | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index 45dd9b8c18d9..7fde4915eb1a 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -17,6 +17,7 @@
 #include <ctype.h>
 #include <getopt.h>
 #include <stdlib.h>
+#include <unistd.h>
 
 #include <string>
 
@@ -85,6 +86,20 @@ void MyLogger(android::base::LogId id, android::base::LogSeverity severity, cons
     }
 }
 
+static bool ModDirMatchesKernelPageSize(const char* mod_dir) {
+    static const unsigned int kernel_pgsize_kb = getpagesize() / 1024;
+    const char* mod_sfx = strrchr(mod_dir, '_');
+    unsigned int mod_pgsize_kb;
+    int mod_sfx_len;
+
+    if (mod_sfx == NULL || sscanf(mod_sfx, "_%uk%n", &mod_pgsize_kb, &mod_sfx_len) != 1 ||
+        strlen(mod_sfx) != mod_sfx_len) {
+        mod_pgsize_kb = 4;
+    }
+
+    return kernel_pgsize_kb == mod_pgsize_kb;
+}
+
 // Find directories in format of "/lib/modules/x.y.z-*".
 static int KernelVersionNameFilter(const dirent* de) {
     unsigned int major, minor;
@@ -100,7 +115,7 @@ static int KernelVersionNameFilter(const dirent* de) {
     }
 
     if (android::base::StartsWith(de->d_name, kernel_version)) {
-        return 1;
+        return ModDirMatchesKernelPageSize(de->d_name);
     }
     return 0;
 }

From f2064c3a0df1a29d2097b52e32420116663470f2 Mon Sep 17 00:00:00 2001
From: Greg Kaiser <gkaiser@google.com>
Date: Thu, 6 Jun 2024 19:09:41 +0000
Subject: [PATCH 0949/1487] Update zygote32 rc file to match others

In I3aad4b4b1d2f54db9e7ba86db8a655d8552bad0a we set MaxPerformance
for zygote64_32, and in I7fcceeb22b722c2164b9acf0b517a32ce34731fd
we synced up zygote64 to match this.

However, this change never made it into the zygote32 rc file,
which we fix here.

Bug: 324014808
Test: Basic testing on 32-bit device
Change-Id: I6f0c4490330d05551952fd5d844e02a6b638ca68
---
 rootdir/init.zygote32.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rootdir/init.zygote32.rc b/rootdir/init.zygote32.rc
index 442bd153f5db..862afb6848c4 100644
--- a/rootdir/init.zygote32.rc
+++ b/rootdir/init.zygote32.rc
@@ -16,5 +16,5 @@ service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-sys
     onrestart restart --only-if-running media.tuner
     onrestart restart netd
     onrestart restart wificond
-    task_profiles ProcessCapacityHigh
+    task_profiles ProcessCapacityHigh MaxPerformance
     critical window=${zygote.critical_window.minute:-off} target=zygote-fatal

From 06603fe14399f09f2d7f6717cd469bf10a283091 Mon Sep 17 00:00:00 2001
From: Sijie Chen <sijiec@google.com>
Date: Tue, 11 Jun 2024 17:51:48 +0000
Subject: [PATCH 0950/1487] [CrashReporting] Correct guest arch init

Init guest arch to NONE, otherwise Arm32 will be used.

Bug: 288392666
Test: NA
Change-Id: Ib92b0351401b700a18d03e21a68569c2811d163c
---
 debuggerd/crash_dump.cpp | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 1c1fb8a598e2..8dd2b0d7385c 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -83,7 +83,7 @@ using android::base::unique_fd;
 
 // This stores guest architecture. When the architecture is supported, tombstone file will output
 // guest state information.
-static Architecture g_guest_arch;
+static Architecture g_guest_arch = Architecture::NONE;
 
 static bool pid_contains_tid(int pid_proc_fd, pid_t tid) {
   struct stat st;
@@ -789,10 +789,6 @@ int main(int argc, char** argv) {
       ATRACE_NAME("engrave_tombstone");
       unwindstack::ArchEnum regs_arch = unwindstack::ARCH_UNKNOWN;
       switch (g_guest_arch) {
-        case Architecture::ARM32: {
-          regs_arch = unwindstack::ARCH_ARM;
-          break;
-        }
         case Architecture::ARM64: {
           regs_arch = unwindstack::ARCH_ARM64;
           break;

From df67107ac4c2a73307597cb763d6c060e8844051 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 30 May 2024 00:18:30 +0000
Subject: [PATCH 0951/1487] libprocessgroup: Use default member initializers

... instead of direct initialization in the default constructor
implementation. This allows us to just explicitly default the
constructor and provide no implementation.

Initialize class variables in the header and remove no-op constructor
to simplify code.

Bug: 346584259
Test: m
Change-Id: Iba57f5cfbf8e4d5d18ce178d39f8bcd2d76c8aaa
---
 libprocessgroup/cgroup_map.h                         |  4 ++--
 .../cgrouprc_format/cgroup_controller.cpp            |  5 -----
 .../include/processgroup/format/cgroup_controller.h  | 12 ++++++------
 3 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/libprocessgroup/cgroup_map.h b/libprocessgroup/cgroup_map.h
index 5c6d3e21c468..9dd5bf5b1c7f 100644
--- a/libprocessgroup/cgroup_map.h
+++ b/libprocessgroup/cgroup_map.h
@@ -32,7 +32,7 @@ class CgroupController {
   public:
     // Does not own controller
     explicit CgroupController(const ACgroupController* controller)
-        : controller_(controller), state_(UNKNOWN) {}
+        : controller_(controller) {}
 
     uint32_t version() const;
     const char* name() const;
@@ -53,7 +53,7 @@ class CgroupController {
     };
 
     const ACgroupController* controller_ = nullptr;
-    ControllerState state_;
+    ControllerState state_ = ControllerState::UNKNOWN;
 };
 
 class CgroupMap {
diff --git a/libprocessgroup/cgrouprc_format/cgroup_controller.cpp b/libprocessgroup/cgrouprc_format/cgroup_controller.cpp
index 202b23eed30a..baf8f9da38a7 100644
--- a/libprocessgroup/cgrouprc_format/cgroup_controller.cpp
+++ b/libprocessgroup/cgrouprc_format/cgroup_controller.cpp
@@ -20,11 +20,6 @@ namespace android {
 namespace cgrouprc {
 namespace format {
 
-CgroupController::CgroupController() : version_(0), flags_(0) {
-    memset(name_, 0, sizeof(name_));
-    memset(path_, 0, sizeof(path_));
-}
-
 CgroupController::CgroupController(uint32_t version, uint32_t flags, const std::string& name,
                                    const std::string& path)
     : CgroupController() {
diff --git a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h b/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
index 40d85480b204..8d3aa56972d1 100644
--- a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
+++ b/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <stdint.h>
+#include <cstdint>
 #include <string>
 
 namespace android {
@@ -26,7 +26,7 @@ namespace format {
 // Minimal controller description to be mmapped into process address space
 struct CgroupController {
   public:
-    CgroupController();
+    CgroupController() = default;
     CgroupController(uint32_t version, uint32_t flags, const std::string& name,
                      const std::string& path);
 
@@ -41,10 +41,10 @@ struct CgroupController {
     static constexpr size_t CGROUP_NAME_BUF_SZ = 16;
     static constexpr size_t CGROUP_PATH_BUF_SZ = 32;
 
-    uint32_t version_;
-    uint32_t flags_;
-    char name_[CGROUP_NAME_BUF_SZ];
-    char path_[CGROUP_PATH_BUF_SZ];
+    uint32_t version_ = 0;
+    uint32_t flags_ = 0;
+    char name_[CGROUP_NAME_BUF_SZ] = {};
+    char path_[CGROUP_PATH_BUF_SZ] = {};
 };
 
 }  // namespace format

From 10826481bae21a4c5ddf7ee30f0719a72994ae6b Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 30 May 2024 15:13:11 +0000
Subject: [PATCH 0952/1487] libprocessgroup: Don't delegate to default
 constructor

Manually calling a defaulted default constructor from a another
constructor is superfluous, and can increase code size if the default
constructor is not otherwise used. There's nothing to delegate, so
remove the call.

Bug: 346584259
Test: m
Change-Id: Ia16aa041fdee7434587cf90645d7f95cba4e0d10
---
 libprocessgroup/cgrouprc_format/cgroup_controller.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libprocessgroup/cgrouprc_format/cgroup_controller.cpp b/libprocessgroup/cgrouprc_format/cgroup_controller.cpp
index baf8f9da38a7..56e67df59628 100644
--- a/libprocessgroup/cgrouprc_format/cgroup_controller.cpp
+++ b/libprocessgroup/cgrouprc_format/cgroup_controller.cpp
@@ -22,7 +22,7 @@ namespace format {
 
 CgroupController::CgroupController(uint32_t version, uint32_t flags, const std::string& name,
                                    const std::string& path)
-    : CgroupController() {
+{
     // strlcpy isn't available on host. Although there is an implementation
     // in licutils, libcutils itself depends on libcgrouprc_format, causing
     // a circular dependency.

From 54bfde03e1e0284fe01ceb143f9fe482be7db3cd Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 4 Jun 2024 23:25:29 +0000
Subject: [PATCH 0953/1487] libprocessgroup: Remove unused includes; add
 missing ones

No functional changes.

Bug: 346584259
Test: m
Change-Id: I68fa51f86b6baaa34fb2cdfdc16a4d1ff61e1e5f
---
 libprocessgroup/cgroup_map.cpp                     | 14 --------------
 libprocessgroup/cgroup_map.h                       |  5 -----
 .../processgroup/format/cgroup_controller.h        |  1 +
 .../include/processgroup/format/cgroup_file.h      |  2 ++
 libprocessgroup/sched_policy.cpp                   |  1 +
 libprocessgroup/setup/cgroup_descriptor.h          |  5 +++++
 libprocessgroup/task_profiles.cpp                  |  2 ++
 libprocessgroup/task_profiles.h                    |  4 ++--
 8 files changed, 13 insertions(+), 21 deletions(-)

diff --git a/libprocessgroup/cgroup_map.cpp b/libprocessgroup/cgroup_map.cpp
index c8ae2161ad3e..ebc059944335 100644
--- a/libprocessgroup/cgroup_map.cpp
+++ b/libprocessgroup/cgroup_map.cpp
@@ -18,33 +18,19 @@
 #define LOG_TAG "libprocessgroup"
 
 #include <errno.h>
-#include <fcntl.h>
-#include <grp.h>
-#include <pwd.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <time.h>
 #include <unistd.h>
 
 #include <regex>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
-#include <android-base/properties.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
-#include <android-base/unique_fd.h>
 #include <cgroup_map.h>
-#include <json/reader.h>
-#include <json/value.h>
 #include <processgroup/processgroup.h>
 
-using android::base::GetBoolProperty;
 using android::base::StartsWith;
 using android::base::StringPrintf;
-using android::base::unique_fd;
 using android::base::WriteStringToFile;
 
 static constexpr const char* CGROUP_PROCS_FILE = "/cgroup.procs";
diff --git a/libprocessgroup/cgroup_map.h b/libprocessgroup/cgroup_map.h
index 9dd5bf5b1c7f..31925d5d7816 100644
--- a/libprocessgroup/cgroup_map.h
+++ b/libprocessgroup/cgroup_map.h
@@ -16,14 +16,9 @@
 
 #pragma once
 
-#include <sys/cdefs.h>
 #include <sys/types.h>
 
-#include <map>
-#include <memory>
-#include <mutex>
 #include <string>
-#include <vector>
 
 #include <android/cgrouprc.h>
 
diff --git a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h b/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
index 8d3aa56972d1..9427a1cf9208 100644
--- a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
+++ b/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <cstddef>
 #include <cstdint>
 #include <string>
 
diff --git a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_file.h b/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_file.h
index f1678a114e7f..2d9786fe6794 100644
--- a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_file.h
+++ b/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_file.h
@@ -16,6 +16,8 @@
 
 #pragma once
 
+#include <cstdint>
+
 #include <processgroup/format/cgroup_controller.h>
 
 namespace android {
diff --git a/libprocessgroup/sched_policy.cpp b/libprocessgroup/sched_policy.cpp
index 1005b1e3e6d3..0f2640a0abcd 100644
--- a/libprocessgroup/sched_policy.cpp
+++ b/libprocessgroup/sched_policy.cpp
@@ -19,6 +19,7 @@
 #define LOG_TAG "SchedPolicy"
 
 #include <errno.h>
+#include <fcntl.h>
 #include <unistd.h>
 
 #include <android-base/logging.h>
diff --git a/libprocessgroup/setup/cgroup_descriptor.h b/libprocessgroup/setup/cgroup_descriptor.h
index 699c03cecf83..9982bfc73638 100644
--- a/libprocessgroup/setup/cgroup_descriptor.h
+++ b/libprocessgroup/setup/cgroup_descriptor.h
@@ -16,6 +16,11 @@
 
 #pragma once
 
+#include <cstdint>
+#include <string>
+
+#include <sys/stat.h>
+
 #include <processgroup/format/cgroup_controller.h>
 
 namespace android {
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 0c2252b17df4..48705481c47d 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -17,7 +17,9 @@
 //#define LOG_NDEBUG 0
 #define LOG_TAG "libprocessgroup"
 
+#include <dirent.h>
 #include <fcntl.h>
+#include <unistd.h>
 #include <task_profiles.h>
 #include <string>
 
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index 7e3c50d9fe35..184e9e35f0e6 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -16,10 +16,10 @@
 
 #pragma once
 
-#include <sys/cdefs.h>
 #include <sys/types.h>
-#include <functional>
+
 #include <map>
+#include <memory>
 #include <mutex>
 #include <span>
 #include <string>

From 4cb11951e2c7b071d4a7bee24858eb7d3f9ec247 Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Tue, 11 Jun 2024 20:17:44 +0000
Subject: [PATCH 0954/1487] Revert "Make foreground and background I/O priority
 different"

It has been reported that CL "Make foreground and background I/O
priority different" causes Android devices equipped with eMMC storage
to reboot if there is sufficient I/O activity. Hence revert commit
7f3fe0aaf286.

Bug: 186902601
Bug: 342034992
Change-Id: I4fa9c782eb0e801b410cb358e20fe41acebe1094
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 rootdir/init.rc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index ec203f91bfea..bf34a9e66a89 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -247,7 +247,6 @@ on init
     write /dev/blkio/background/blkio.bfq.weight 10
     write /dev/blkio/blkio.group_idle 0
     write /dev/blkio/background/blkio.group_idle 0
-    write /dev/blkio/blkio.prio.class promote-to-rt
     write /dev/blkio/background/blkio.prio.class restrict-to-be
 
     restorecon_recursive /mnt

From 9a3a1a14b4c39133db54e3bec712ce729052e54d Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 23 May 2024 14:37:00 -0700
Subject: [PATCH 0955/1487] libsnapshot: pass build config o_direct

If o_direct is enabled in build configuration, forward this argument to
snapuserd when the daemon is started.

Bug: 332255580
Test: th
Change-Id: I8e4be5503665031735dba2ebc748e209c45df942
---
 .../android/snapshot/snapshot.proto           |  6 ++-
 .../include/libsnapshot/snapshot.h            |  5 +++
 fs_mgr/libsnapshot/partition_cow_creator.h    |  3 ++
 fs_mgr/libsnapshot/snapshot.cpp               | 41 +++++++++++++------
 fs_mgr/libsnapshot/snapshot_test.cpp          | 35 ++++++++++++++++
 .../snapuserd/snapuserd_daemon.cpp            |  8 ++--
 fs_mgr/libsnapshot/utility.cpp                |  7 +++-
 fs_mgr/libsnapshot/utility.h                  |  1 +
 8 files changed, 87 insertions(+), 19 deletions(-)

diff --git a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
index d04c9c19d05c..2e948dda7429 100644
--- a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
+++ b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
@@ -124,8 +124,7 @@ message SnapshotStatus {
     // Default value is 32, can be set lower for low mem devices
     uint32 read_ahead_size = 17;
 
-    // Enable direct reads on source device
-    bool o_direct = 18;
+    reserved 18;
 
     // Blocks size to be verified at once
     uint64 verify_block_size = 19;
@@ -227,6 +226,9 @@ message SnapshotUpdateStatus {
 
     // legacy dm-snapshot based snapuserd
     bool legacy_snapuserd = 11;
+
+    // Enable direct reads from source device
+    bool o_direct = 12;
 }
 
 // Next: 10
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index 3ccc3dbf4fbd..6d422c6141b9 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -410,6 +410,7 @@ class SnapshotManager final : public ISnapshotManager {
     FRIEND_TEST(SnapshotTest, CreateSnapshot);
     FRIEND_TEST(SnapshotTest, FirstStageMountAfterRollback);
     FRIEND_TEST(SnapshotTest, FirstStageMountAndMerge);
+    FRIEND_TEST(SnapshotTest, FlagCheck);
     FRIEND_TEST(SnapshotTest, FlashSuperDuringMerge);
     FRIEND_TEST(SnapshotTest, FlashSuperDuringUpdate);
     FRIEND_TEST(SnapshotTest, MapPartialSnapshot);
@@ -425,6 +426,7 @@ class SnapshotManager final : public ISnapshotManager {
     FRIEND_TEST(SnapshotUpdateTest, DataWipeAfterRollback);
     FRIEND_TEST(SnapshotUpdateTest, DataWipeRollbackInRecovery);
     FRIEND_TEST(SnapshotUpdateTest, DataWipeWithStaleSnapshots);
+    FRIEND_TEST(SnapshotUpdateTest, FlagCheck);
     FRIEND_TEST(SnapshotUpdateTest, FullUpdateFlow);
     FRIEND_TEST(SnapshotUpdateTest, MergeCannotRemoveCow);
     FRIEND_TEST(SnapshotUpdateTest, MergeInRecovery);
@@ -822,6 +824,9 @@ class SnapshotManager final : public ISnapshotManager {
     // Check if io_uring API's need to be used
     bool UpdateUsesIouring(LockedFile* lock);
 
+    // Check if direct reads are enabled for the source image
+    bool UpdateUsesODirect(LockedFile* lock);
+
     // Wrapper around libdm, with diagnostics.
     bool DeleteDeviceIfExists(const std::string& name,
                               const std::chrono::milliseconds& timeout_ms = {});
diff --git a/fs_mgr/libsnapshot/partition_cow_creator.h b/fs_mgr/libsnapshot/partition_cow_creator.h
index a75d993c7b7c..1adbba2c8132 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator.h
+++ b/fs_mgr/libsnapshot/partition_cow_creator.h
@@ -62,6 +62,9 @@ struct PartitionCowCreator {
     uint64_t compression_factor;
     uint32_t read_ahead_size;
 
+    // Enable direct reads on source device
+    bool o_direct;
+
     // True if multi-threaded compression should be enabled
     bool enable_threading;
 
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 8620620e4714..c01360e0ba2c 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -1697,6 +1697,9 @@ bool SnapshotManager::PerformInitTransition(InitTransition transition,
         if (UpdateUsesIouring(lock.get())) {
             snapuserd_argv->emplace_back("-io_uring");
         }
+        if (UpdateUsesODirect(lock.get())) {
+            snapuserd_argv->emplace_back("-o_direct");
+        }
     }
 
     size_t num_cows = 0;
@@ -2114,6 +2117,11 @@ bool SnapshotManager::UpdateUsesIouring(LockedFile* lock) {
     return update_status.io_uring_enabled();
 }
 
+bool SnapshotManager::UpdateUsesODirect(LockedFile* lock) {
+    SnapshotUpdateStatus update_status = ReadSnapshotUpdateStatus(lock);
+    return update_status.o_direct();
+}
+
 /*
  * Please see b/304829384 for more details.
  *
@@ -3016,6 +3024,7 @@ bool SnapshotManager::WriteUpdateState(LockedFile* lock, UpdateState state,
         status.set_userspace_snapshots(old_status.userspace_snapshots());
         status.set_io_uring_enabled(old_status.io_uring_enabled());
         status.set_legacy_snapuserd(old_status.legacy_snapuserd());
+        status.set_o_direct(old_status.o_direct());
     }
     return WriteSnapshotUpdateStatus(lock, status);
 }
@@ -3310,17 +3319,19 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
     }
     auto read_ahead_size =
             android::base::GetUintProperty<uint>("ro.virtual_ab.read_ahead_size", kReadAheadSizeKb);
-    PartitionCowCreator cow_creator{.target_metadata = target_metadata.get(),
-                                    .target_suffix = target_suffix,
-                                    .target_partition = nullptr,
-                                    .current_metadata = current_metadata.get(),
-                                    .current_suffix = current_suffix,
-                                    .update = nullptr,
-                                    .extra_extents = {},
-                                    .using_snapuserd = using_snapuserd,
-                                    .compression_algorithm = compression_algorithm,
-                                    .compression_factor = compression_factor,
-                                    .read_ahead_size = read_ahead_size};
+    PartitionCowCreator cow_creator{
+            .target_metadata = target_metadata.get(),
+            .target_suffix = target_suffix,
+            .target_partition = nullptr,
+            .current_metadata = current_metadata.get(),
+            .current_suffix = current_suffix,
+            .update = nullptr,
+            .extra_extents = {},
+            .using_snapuserd = using_snapuserd,
+            .compression_algorithm = compression_algorithm,
+            .compression_factor = compression_factor,
+            .read_ahead_size = read_ahead_size,
+    };
 
     if (dap_metadata.vabc_feature_set().has_threaded()) {
         cow_creator.enable_threading = dap_metadata.vabc_feature_set().threaded();
@@ -3388,10 +3399,13 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
             status.set_io_uring_enabled(true);
             LOG(INFO) << "io_uring for snapshots enabled";
         }
-
+        if (GetODirectEnabledProperty()) {
+            status.set_o_direct(true);
+            LOG(INFO) << "o_direct for source image enabled";
+        }
         if (is_legacy_snapuserd) {
-            LOG(INFO) << "Setting legacy_snapuserd to true";
             status.set_legacy_snapuserd(true);
+            LOG(INFO) << "Setting legacy_snapuserd to true";
         }
     } else if (legacy_compression) {
         LOG(INFO) << "Virtual A/B using legacy snapuserd";
@@ -3827,6 +3841,7 @@ bool SnapshotManager::Dump(std::ostream& os) {
     ss << "Using snapuserd: " << update_status.using_snapuserd() << std::endl;
     ss << "Using userspace snapshots: " << update_status.userspace_snapshots() << std::endl;
     ss << "Using io_uring: " << update_status.io_uring_enabled() << std::endl;
+    ss << "Using o_direct: " << update_status.o_direct() << std::endl;
     ss << "Using XOR compression: " << GetXorCompressionEnabledProperty() << std::endl;
     ss << "Current slot: " << device_->GetSlotSuffix() << std::endl;
     ss << "Boot indicator: booting from " << GetCurrentSlot() << " slot" << std::endl;
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 80dad17cc274..3299ec5c9e12 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2647,6 +2647,41 @@ TEST_F(SnapshotUpdateTest, BadCowVersion) {
     ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
 }
 
+TEST_F(SnapshotTest, FlagCheck) {
+    if (!snapuserd_required_) {
+        GTEST_SKIP() << "Skipping snapuserd test";
+    }
+    ASSERT_TRUE(AcquireLock());
+
+    SnapshotUpdateStatus status = sm->ReadSnapshotUpdateStatus(lock_.get());
+
+    // Set flags in proto
+    status.set_o_direct(true);
+    status.set_io_uring_enabled(true);
+    status.set_userspace_snapshots(true);
+
+    sm->WriteSnapshotUpdateStatus(lock_.get(), status);
+    // Ensure a connection to the second-stage daemon, but use the first-stage
+    // code paths thereafter.
+    ASSERT_TRUE(sm->EnsureSnapuserdConnected());
+    sm->set_use_first_stage_snapuserd(true);
+
+    auto init = NewManagerForFirstStageMount("_b");
+    ASSERT_NE(init, nullptr);
+
+    lock_ = nullptr;
+
+    std::vector<std::string> snapuserd_argv;
+    ASSERT_TRUE(init->PerformInitTransition(SnapshotManager::InitTransition::SELINUX_DETACH,
+                                            &snapuserd_argv));
+    ASSERT_TRUE(std::find(snapuserd_argv.begin(), snapuserd_argv.end(), "-o_direct") !=
+                snapuserd_argv.end());
+    ASSERT_TRUE(std::find(snapuserd_argv.begin(), snapuserd_argv.end(), "-io_uring") !=
+                snapuserd_argv.end());
+    ASSERT_TRUE(std::find(snapuserd_argv.begin(), snapuserd_argv.end(), "-user_snapshot") !=
+                snapuserd_argv.end());
+}
+
 class FlashAfterUpdateTest : public SnapshotUpdateTest,
                              public WithParamInterface<std::tuple<uint32_t, bool>> {
   public:
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
index 0ebe543df3bf..67e9e52eafae 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
@@ -29,6 +29,7 @@ DEFINE_bool(socket_handoff, false,
             "If true, perform a socket hand-off with an existing snapuserd instance, then exit.");
 DEFINE_bool(user_snapshot, false, "If true, user-space snapshots are used");
 DEFINE_bool(io_uring, false, "If true, io_uring feature is enabled");
+DEFINE_bool(o_direct, false, "If true, enable direct reads on source device");
 
 namespace android {
 namespace snapshot {
@@ -67,7 +68,6 @@ bool Daemon::StartDaemon(int argc, char** argv) {
     if (!user_snapshots) {
         user_snapshots = IsUserspaceSnapshotsEnabled();
     }
-
     if (user_snapshots) {
         LOG(INFO) << "Starting daemon for user-space snapshots.....";
         return StartServerForUserspaceSnapshots(arg_start, argc, argv);
@@ -109,11 +109,13 @@ bool Daemon::StartServerForUserspaceSnapshots(int arg_start, int argc, char** ar
 
     for (int i = arg_start; i < argc; i++) {
         auto parts = android::base::Split(argv[i], ",");
+
         if (parts.size() != 4) {
-            LOG(ERROR) << "Malformed message, expected four sub-arguments.";
+            LOG(ERROR) << "Malformed message, expected at least four sub-arguments.";
             return false;
         }
-        auto handler = user_server_.AddHandler(parts[0], parts[1], parts[2], parts[3]);
+        auto handler =
+                user_server_.AddHandler(parts[0], parts[1], parts[2], parts[3], FLAGS_o_direct);
         if (!handler || !user_server_.StartHandler(parts[0])) {
             return false;
         }
diff --git a/fs_mgr/libsnapshot/utility.cpp b/fs_mgr/libsnapshot/utility.cpp
index fe2d95c644cd..7eaaca95bccf 100644
--- a/fs_mgr/libsnapshot/utility.cpp
+++ b/fs_mgr/libsnapshot/utility.cpp
@@ -199,7 +199,7 @@ bool WriteStringToFileAtomic(const std::string& content, const std::string& path
 }
 
 std::ostream& operator<<(std::ostream& os, const Now&) {
-    struct tm now {};
+    struct tm now{};
     time_t t = time(nullptr);
     localtime_r(&t, &now);
     return os << std::put_time(&now, "%Y%m%d-%H%M%S");
@@ -272,6 +272,11 @@ bool GetXorCompressionEnabledProperty() {
     return fetcher->GetBoolProperty("ro.virtual_ab.compression.xor.enabled", false);
 }
 
+bool GetODirectEnabledProperty() {
+    auto fetcher = IPropertyFetcher::GetInstance();
+    return fetcher->GetBoolProperty("ro.virtual_ab.o_direct.enabled", false);
+}
+
 std::string GetOtherPartitionName(const std::string& name) {
     auto suffix = android::fs_mgr::GetPartitionSlotSuffix(name);
     CHECK(suffix == "_a" || suffix == "_b");
diff --git a/fs_mgr/libsnapshot/utility.h b/fs_mgr/libsnapshot/utility.h
index f956a05449ac..7dae942b354d 100644
--- a/fs_mgr/libsnapshot/utility.h
+++ b/fs_mgr/libsnapshot/utility.h
@@ -133,6 +133,7 @@ bool GetLegacyCompressionEnabledProperty();
 bool GetUserspaceSnapshotsEnabledProperty();
 bool GetIouringEnabledProperty();
 bool GetXorCompressionEnabledProperty();
+bool GetODirectEnabledProperty();
 
 bool CanUseUserspaceSnapshots();
 bool IsDmSnapshotTestingEnabled();

From 64776335c06af73b03c750c11fb486e182f45ef6 Mon Sep 17 00:00:00 2001
From: Juan Yescas <jyescas@google.com>
Date: Mon, 10 Jun 2024 20:50:31 -0700
Subject: [PATCH 0956/1487] toolbox/modprobe: Load modules from /lib/modules
 based on page size

Load modules from /lib/modules for 4kb page size kernels when
the -d option is not present. Do not do this for 16kb page size kernels
due it will load the 4kb modules when PRODUCT_16K_DEVELOPER_OPTION
is true.

Depending on the value of PRODUCT_16K_DEVELOPER_OPTION, the
kernel modules can be located in several directories:

- true: There are 2 directories that contain the 4kb and 16kb
        modules.
        - 4kb modules are in /lib/modules
        - 16kb modules are in /lib/modules/<uname -r>_16k
- false: There is only one directory that contains only one type
        of the kernel modules, either 4kb or 16kb.
        - /lib/modules

This is a temporary fix for the 16kb developer option. This
b/346659501 will track the proper fix.

Test: Boot target husky-trunk_staging-userdebug with developer
      option.
Test: Boot target husky_pgagnostic-next-userdebug without developer
      option.
Bug: 345609905
Bug: 343971855
Change-Id: I9bab33d9f06743bd10ee804b20db8f39467fcc52
---
 toolbox/modprobe.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index 7fde4915eb1a..13026ac30aa8 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -245,8 +245,10 @@ extern "C" int modprobe_main(int argc, char** argv) {
         }
         free(kernel_dirs);
 
-        // Allow modules to be directly inside /lib/modules
-        mod_dirs.emplace_back(LIB_MODULES_PREFIX);
+        if (mod_dirs.empty() || getpagesize() == 4096) {
+            // Allow modules to be directly inside /lib/modules
+            mod_dirs.emplace_back(LIB_MODULES_PREFIX);
+        }
     }
 
     LOG(DEBUG) << "mode is " << mode;

From 28801377a5d09fce686edbd81c1d5e4d9f698e5e Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 29 May 2024 10:44:09 -0700
Subject: [PATCH 0957/1487] libsnapshot: configure threshold size

Test: th
Change-Id: Iba59fdc3e1188dd343314d129806d2c4c94aa8c5
---
 .../user-space-merge/snapuserd_verify.cpp         | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp
index 68173408045b..957c6a8a783a 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp
@@ -20,6 +20,7 @@
 #include <android-base/scopeguard.h>
 #include <android-base/strings.h>
 
+#include "android-base/properties.h"
 #include "snapuserd_core.h"
 
 namespace android {
@@ -104,7 +105,9 @@ bool UpdateVerify::VerifyBlocks(const std::string& partition_name,
     }
 
     loff_t file_offset = offset;
-    const uint64_t read_sz = kBlockSizeVerify;
+    auto verify_block_size = android::base::GetUintProperty<uint>("ro.virtual_ab.verify_block_size",
+                                                                  kBlockSizeVerify);
+    const uint64_t read_sz = verify_block_size;
 
     void* addr;
     ssize_t page_size = getpagesize();
@@ -130,7 +133,7 @@ bool UpdateVerify::VerifyBlocks(const std::string& partition_name,
         }
 
         bytes_read += to_read;
-        file_offset += (skip_blocks * kBlockSizeVerify);
+        file_offset += (skip_blocks * verify_block_size);
         if (file_offset >= dev_sz) {
             break;
         }
@@ -184,7 +187,9 @@ bool UpdateVerify::VerifyPartition(const std::string& partition_name,
      * latency.
      */
     int num_threads = kMinThreadsToVerify;
-    if (dev_sz > kThresholdSize) {
+    auto verify_threshold_size = android::base::GetUintProperty<uint>(
+            "ro.virtual_ab.verify_threshold_size", kThresholdSize);
+    if (dev_sz > verify_threshold_size) {
         num_threads = kMaxThreadsToVerify;
     }
 
@@ -192,11 +197,13 @@ bool UpdateVerify::VerifyPartition(const std::string& partition_name,
     off_t start_offset = 0;
     const int skip_blocks = num_threads;
 
+    auto verify_block_size =
+            android::base::GetUintProperty("ro.virtual_ab.verify_block_size", kBlockSizeVerify);
     while (num_threads) {
         threads.emplace_back(std::async(std::launch::async, &UpdateVerify::VerifyBlocks, this,
                                         partition_name, dm_block_device, start_offset, skip_blocks,
                                         dev_sz));
-        start_offset += kBlockSizeVerify;
+        start_offset += verify_block_size;
         num_threads -= 1;
         if (start_offset >= dev_sz) {
             break;

From db560090e4dcf19aa0909a27da473c4ac704af88 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 28 May 2024 18:25:12 -0700
Subject: [PATCH 0958/1487] libsnapshot: set thread priority

Read merge thread + worker thread priority from build configurations. In
the case of low memory devices, a lower priority will reduce CPU
utilization post OTA reboot.

Test: th
Change-Id: I812fccf2ca805d9686a837774e1770a2eebf979a
---
 .../libsnapshot/snapuserd/user-space-merge/merge_worker.cpp | 4 +++-
 .../libsnapshot/snapuserd/user-space-merge/read_worker.cpp  | 6 +++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index bd7eaca747d6..0f4674ced9e8 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -577,8 +577,10 @@ bool MergeWorker::Run() {
         SNAP_LOG(ERROR) << "Merge terminated early...";
         return true;
     }
+    auto merge_thread_priority = android::base::GetUintProperty<uint>(
+            "ro.virtual_ab.merge_thread_priority", ANDROID_PRIORITY_BACKGROUND);
 
-    if (!SetThreadPriority(ANDROID_PRIORITY_BACKGROUND)) {
+    if (!SetThreadPriority(merge_thread_priority)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index d40b6d11d92d..35a16219916c 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -17,8 +17,10 @@
 #include <libsnapshot/cow_format.h>
 #include <pthread.h>
 
+#include "android-base/properties.h"
 #include "read_worker.h"
 #include "snapuserd_core.h"
+#include "user-space-merge/worker.h"
 #include "utility.h"
 
 namespace android {
@@ -259,8 +261,10 @@ bool ReadWorker::Run() {
     SNAP_LOG(INFO) << "Processing snapshot I/O requests....";
 
     pthread_setname_np(pthread_self(), "ReadWorker");
+    auto worker_thread_priority = android::base::GetUintProperty<uint>(
+            "ro.virtual_ab.worker_thread_priority", ANDROID_PRIORITY_NORMAL);
 
-    if (!SetThreadPriority(ANDROID_PRIORITY_NORMAL)) {
+    if (!SetThreadPriority(worker_thread_priority)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 

From 0168ec74d02ee602b0406d8a407af25389a8577a Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 12 Jun 2024 18:32:57 +0000
Subject: [PATCH 0959/1487] Revert "libsnapshot: set thread priority"

This reverts commit db560090e4dcf19aa0909a27da473c4ac704af88.

Reason for revert: breakage on aosp-main

Change-Id: Ib3384dce1e08dd19bce305eee4249d7167d74e10
---
 .../libsnapshot/snapuserd/user-space-merge/merge_worker.cpp | 4 +---
 .../libsnapshot/snapuserd/user-space-merge/read_worker.cpp  | 6 +-----
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index 0f4674ced9e8..bd7eaca747d6 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -577,10 +577,8 @@ bool MergeWorker::Run() {
         SNAP_LOG(ERROR) << "Merge terminated early...";
         return true;
     }
-    auto merge_thread_priority = android::base::GetUintProperty<uint>(
-            "ro.virtual_ab.merge_thread_priority", ANDROID_PRIORITY_BACKGROUND);
 
-    if (!SetThreadPriority(merge_thread_priority)) {
+    if (!SetThreadPriority(ANDROID_PRIORITY_BACKGROUND)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index 35a16219916c..d40b6d11d92d 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -17,10 +17,8 @@
 #include <libsnapshot/cow_format.h>
 #include <pthread.h>
 
-#include "android-base/properties.h"
 #include "read_worker.h"
 #include "snapuserd_core.h"
-#include "user-space-merge/worker.h"
 #include "utility.h"
 
 namespace android {
@@ -261,10 +259,8 @@ bool ReadWorker::Run() {
     SNAP_LOG(INFO) << "Processing snapshot I/O requests....";
 
     pthread_setname_np(pthread_self(), "ReadWorker");
-    auto worker_thread_priority = android::base::GetUintProperty<uint>(
-            "ro.virtual_ab.worker_thread_priority", ANDROID_PRIORITY_NORMAL);
 
-    if (!SetThreadPriority(worker_thread_priority)) {
+    if (!SetThreadPriority(ANDROID_PRIORITY_NORMAL)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 

From c9fa93f4e892ea06c0c4f8a5270a90161ae4516d Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 13 Jun 2024 01:28:35 +0000
Subject: [PATCH 0960/1487] snapuserd: Don't statically link outside of
 ramdisk.

Also, remove snapuserd from the vendor ramdisk since this isn't used
anymore.

Bug: 345158294
Test: ldd snapuserd_ramdisk and system/bin/snapuserd
      apply full OTA on aosp_cf
Change-Id: I2c2ad1458d67a8449c548e22660f523ba9c86849
---
 fs_mgr/libsnapshot/snapuserd/Android.bp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 649309de1d67..f04020549d09 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -145,14 +145,6 @@ cc_defaults {
     ],
 
     include_dirs: ["bionic/libc/kernel"],
-    system_shared_libs: [],
-
-    // snapuserd is started during early boot by first-stage init. At that
-    // point, /system is mounted using the "dm-user" device-mapper kernel
-    // module. dm-user routes all I/O to userspace to be handled by
-    // snapuserd, which would lead to deadlock if we had to handle page
-    // faults for its code pages.
-    static_executable: true,
 }
 
 cc_binary {
@@ -165,10 +157,10 @@ cc_binary {
         "libsnapuserd_client",
     ],
     ramdisk_available: false,
-    vendor_ramdisk_available: true,
+    vendor_ramdisk_available: false,
 }
 
-// This target will install to /system/bin/snapuserd_ramdisk 
+// This target will install to /system/bin/snapuserd_ramdisk
 // It will also create a symblink on /system/bin/snapuserd that point to
 // /system/bin/snapuserd_ramdisk .
 // This way, init can check if generic ramdisk copy exists.
@@ -184,6 +176,15 @@ cc_binary {
     vendor_ramdisk_available: false,
     ramdisk: true,
     symlinks: ["snapuserd"],
+
+    system_shared_libs: [],
+
+    // snapuserd is started during early boot by first-stage init. At that
+    // point, /system is mounted using the "dm-user" device-mapper kernel
+    // module. dm-user routes all I/O to userspace to be handled by
+    // snapuserd, which would lead to deadlock if we had to handle page
+    // faults for its code pages.
+    static_executable: true,
 }
 
 cc_defaults {

From 3b795a1a7b6b17a3c593ff01bab2ad209552faf1 Mon Sep 17 00:00:00 2001
From: Henri Chataing <henrichataing@google.com>
Date: Thu, 13 Jun 2024 22:47:03 +0000
Subject: [PATCH 0961/1487] Make libexpresslog apex available

Test: TreeHugger
Change-Id: I10267c3a57d8a6553f9ef74d09b1cd81c6947a46
---
 libstats/expresslog/Android.bp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/libstats/expresslog/Android.bp b/libstats/expresslog/Android.bp
index 004f8b9bfb54..96ab59b10fdf 100644
--- a/libstats/expresslog/Android.bp
+++ b/libstats/expresslog/Android.bp
@@ -47,6 +47,11 @@ cc_library {
         "libstatssocket",
     ],
     export_include_dirs: ["include"],
+    min_sdk_version: "33",
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.btservices",
+    ],
 }
 
 genrule {
@@ -75,6 +80,11 @@ cc_library_static {
     shared_libs: [
         "libstatssocket",
     ],
+    min_sdk_version: "33",
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.btservices",
+    ],
 }
 
 cc_test {

From 064ac0bf15e5b8f29481c0b4a795759aefb08d03 Mon Sep 17 00:00:00 2001
From: Nelson Li <nelsonli@google.com>
Date: Mon, 17 Jun 2024 05:02:56 +0000
Subject: [PATCH 0962/1487] Convert `init_vendor` to Android.bp

`init_first_stage` is a dependency of `init_vendor` only when
`BOARD_USES_RECOVERY_AS_BOOT` is false.
Since `BOARD_USES_RECOVERY_AS_BOOT` is already defined in
`build/make/core/android_soong_config_vars.mk` within a
soong_namespace, we can use the `soong_config_module_type` to easily
convert this to Android.bp.

Bug: 347600829
Test: m init_vendor
Change-Id: I1ddcd5fb62983b01e51452c9b7367750e03e7f48
---
 init/Android.bp | 22 +++++++++++++++++++++-
 init/Android.mk | 16 ----------------
 2 files changed, 21 insertions(+), 17 deletions(-)
 delete mode 100644 init/Android.mk

diff --git a/init/Android.bp b/init/Android.bp
index 57e5a681a93a..6526a934e3fb 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -162,7 +162,7 @@ libinit_cc_defaults {
         },
         release_write_appcompat_override_system_properties: {
             cflags: ["-DWRITE_APPCOMPAT_OVERRIDE_SYSTEM_PROPERTIES"],
-        }
+        },
     },
     static_libs: [
         "libavb",
@@ -663,3 +663,23 @@ sh_binary {
     src: "extra_free_kbytes.sh",
     filename_from_src: true,
 }
+
+soong_config_module_type {
+    name: "board_use_recovery_as_boot_phony",
+    module_type: "phony",
+    config_namespace: "ANDROID",
+    bool_variables: ["BOARD_USES_RECOVERY_AS_BOOT"],
+    properties: ["required"],
+}
+
+board_use_recovery_as_boot_phony {
+    name: "init_vendor",
+    soong_config_variables: {
+        BOARD_USES_RECOVERY_AS_BOOT: {
+            required: [],
+            conditions_default: {
+                required: ["init_first_stage"],
+            },
+        },
+    },
+}
diff --git a/init/Android.mk b/init/Android.mk
deleted file mode 100644
index 4b85c15ea825..000000000000
--- a/init/Android.mk
+++ /dev/null
@@ -1,16 +0,0 @@
-# Copyright 2005 The Android Open Source Project
-
-LOCAL_PATH:= $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := init_vendor
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/NOTICE
-ifneq ($(BOARD_USES_RECOVERY_AS_BOOT),true)
-LOCAL_REQUIRED_MODULES := \
-   init_first_stage \
-
-endif  # BOARD_USES_RECOVERY_AS_BOOT
-include $(BUILD_PHONY_PACKAGE)

From 14fbf6d3909dab706568d1c409a941d5fd2a7428 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 17 Jun 2024 19:05:13 +0000
Subject: [PATCH 0963/1487] Revert "snapuserd: Don't statically link outside of
 ramdisk."

This reverts commit c9fa93f4e892ea06c0c4f8a5270a90161ae4516d.

Reason for revert: b/347670914
Bug: 347670914

Change-Id: I9d63a69ccf1f8de98ab7cc23b9fbf400863cddfb
---
 fs_mgr/libsnapshot/snapuserd/Android.bp | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index f04020549d09..649309de1d67 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -145,6 +145,14 @@ cc_defaults {
     ],
 
     include_dirs: ["bionic/libc/kernel"],
+    system_shared_libs: [],
+
+    // snapuserd is started during early boot by first-stage init. At that
+    // point, /system is mounted using the "dm-user" device-mapper kernel
+    // module. dm-user routes all I/O to userspace to be handled by
+    // snapuserd, which would lead to deadlock if we had to handle page
+    // faults for its code pages.
+    static_executable: true,
 }
 
 cc_binary {
@@ -157,10 +165,10 @@ cc_binary {
         "libsnapuserd_client",
     ],
     ramdisk_available: false,
-    vendor_ramdisk_available: false,
+    vendor_ramdisk_available: true,
 }
 
-// This target will install to /system/bin/snapuserd_ramdisk
+// This target will install to /system/bin/snapuserd_ramdisk 
 // It will also create a symblink on /system/bin/snapuserd that point to
 // /system/bin/snapuserd_ramdisk .
 // This way, init can check if generic ramdisk copy exists.
@@ -176,15 +184,6 @@ cc_binary {
     vendor_ramdisk_available: false,
     ramdisk: true,
     symlinks: ["snapuserd"],
-
-    system_shared_libs: [],
-
-    // snapuserd is started during early boot by first-stage init. At that
-    // point, /system is mounted using the "dm-user" device-mapper kernel
-    // module. dm-user routes all I/O to userspace to be handled by
-    // snapuserd, which would lead to deadlock if we had to handle page
-    // faults for its code pages.
-    static_executable: true,
 }
 
 cc_defaults {

From aaf11ec896d7458ddbadbd4c33888d9703cd650c Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 17 Jun 2024 19:05:13 +0000
Subject: [PATCH 0964/1487] Revert "snapuserd: Don't statically link outside of
 ramdisk."

This reverts commit c9fa93f4e892ea06c0c4f8a5270a90161ae4516d.

Reason for revert: b/347670914
Bug: 347670914
(cherry picked from https://android-review.googlesource.com/q/commit:14fbf6d3909dab706568d1c409a941d5fd2a7428)
Merged-In: I9d63a69ccf1f8de98ab7cc23b9fbf400863cddfb
Change-Id: I9d63a69ccf1f8de98ab7cc23b9fbf400863cddfb
---
 fs_mgr/libsnapshot/snapuserd/Android.bp | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index f04020549d09..649309de1d67 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -145,6 +145,14 @@ cc_defaults {
     ],
 
     include_dirs: ["bionic/libc/kernel"],
+    system_shared_libs: [],
+
+    // snapuserd is started during early boot by first-stage init. At that
+    // point, /system is mounted using the "dm-user" device-mapper kernel
+    // module. dm-user routes all I/O to userspace to be handled by
+    // snapuserd, which would lead to deadlock if we had to handle page
+    // faults for its code pages.
+    static_executable: true,
 }
 
 cc_binary {
@@ -157,10 +165,10 @@ cc_binary {
         "libsnapuserd_client",
     ],
     ramdisk_available: false,
-    vendor_ramdisk_available: false,
+    vendor_ramdisk_available: true,
 }
 
-// This target will install to /system/bin/snapuserd_ramdisk
+// This target will install to /system/bin/snapuserd_ramdisk 
 // It will also create a symblink on /system/bin/snapuserd that point to
 // /system/bin/snapuserd_ramdisk .
 // This way, init can check if generic ramdisk copy exists.
@@ -176,15 +184,6 @@ cc_binary {
     vendor_ramdisk_available: false,
     ramdisk: true,
     symlinks: ["snapuserd"],
-
-    system_shared_libs: [],
-
-    // snapuserd is started during early boot by first-stage init. At that
-    // point, /system is mounted using the "dm-user" device-mapper kernel
-    // module. dm-user routes all I/O to userspace to be handled by
-    // snapuserd, which would lead to deadlock if we had to handle page
-    // faults for its code pages.
-    static_executable: true,
 }
 
 cc_defaults {

From 00e1b61bb92b7a9905fdb5c00aba9ffd47a36dbf Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 28 May 2024 18:25:12 -0700
Subject: [PATCH 0965/1487] reupload: libsnapshot: set thread priority

It looks like we can't use <uint> as type with specifying size

Read merge thread + worker thread priority from build configurations. In
the case of low memory devices, a lower priority will reduce CPU
utilization post OTA reboot.

Test: th
Change-Id: Ie895be32e3aea66b46503c5270939bb42f58494a
---
 .../libsnapshot/snapuserd/user-space-merge/merge_worker.cpp | 4 +++-
 .../libsnapshot/snapuserd/user-space-merge/read_worker.cpp  | 6 +++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index bd7eaca747d6..4afc312e3da8 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -577,8 +577,10 @@ bool MergeWorker::Run() {
         SNAP_LOG(ERROR) << "Merge terminated early...";
         return true;
     }
+    auto merge_thread_priority = android::base::GetUintProperty<uint32_t>(
+            "ro.virtual_ab.merge_thread_priority", ANDROID_PRIORITY_BACKGROUND);
 
-    if (!SetThreadPriority(ANDROID_PRIORITY_BACKGROUND)) {
+    if (!SetThreadPriority(merge_thread_priority)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index d40b6d11d92d..7191f1f74a1f 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -17,8 +17,10 @@
 #include <libsnapshot/cow_format.h>
 #include <pthread.h>
 
+#include "android-base/properties.h"
 #include "read_worker.h"
 #include "snapuserd_core.h"
+#include "user-space-merge/worker.h"
 #include "utility.h"
 
 namespace android {
@@ -259,8 +261,10 @@ bool ReadWorker::Run() {
     SNAP_LOG(INFO) << "Processing snapshot I/O requests....";
 
     pthread_setname_np(pthread_self(), "ReadWorker");
+    auto worker_thread_priority = android::base::GetUintProperty<uint32_t>(
+            "ro.virtual_ab.worker_thread_priority", ANDROID_PRIORITY_NORMAL);
 
-    if (!SetThreadPriority(ANDROID_PRIORITY_NORMAL)) {
+    if (!SetThreadPriority(worker_thread_priority)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 

From c2ae951c7d6e51a8fc6db3c3f7be34064e94bd6e Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Mon, 3 Jun 2024 21:49:24 +0800
Subject: [PATCH 0966/1487] fs_mgr_overlayfs: Don't preemptively change mount
 propagation type

If the overlaid mount have no submount and is not submount of other
mount, then we don't need to change its propagation type.
This makes the remount process less disruptive as we create less
fragmented mount namespaces.
The general rule is still to always reboot after initial remount setup
to get the most predictable result.

Bug: 342967841
Test: adb_remount test
Change-Id: I19ca62018149f1fa81186824a9d7f1c32d9d6008
---
 fs_mgr/fs_mgr_overlayfs_mount.cpp | 29 +++++++++++++++++++++++------
 1 file changed, 23 insertions(+), 6 deletions(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index a1ec63b69bcb..bd0fcfd98274 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -412,6 +412,8 @@ static bool fs_mgr_overlayfs_mount_one(const FstabEntry& fstab_entry) {
     bool retval = true;
     bool move_dir_shared = true;
     bool parent_shared = true;
+    bool parent_have_parent = false;
+    bool parent_made_private = false;
     bool root_shared = true;
     bool root_made_private = false;
 
@@ -443,6 +445,10 @@ static bool fs_mgr_overlayfs_mount_one(const FstabEntry& fstab_entry) {
         if (entry.mount_point == "/") {
             root_shared = entry.shared_flag;
         }
+        // Ignore "/" as we don't overlay "/" directly.
+        if (entry.mount_point != "/") {
+            parent_have_parent |= android::base::StartsWith(mount_point, entry.mount_point + "/");
+        }
     }
 
     // Precondition is that kMoveMountTempDir is MS_PRIVATE, otherwise don't try to move any
@@ -453,11 +459,13 @@ static bool fs_mgr_overlayfs_mount_one(const FstabEntry& fstab_entry) {
 
     // Need to make the original mountpoint MS_PRIVATE, so that the overlayfs can be MS_MOVE.
     // This could happen if its parent mount is remounted later.
-    if (!fs_mgr_overlayfs_set_shared_mount(mount_point, false)) {
-        // If failed to set "/system" mount type, it might be due to "/system" not being a valid
-        // mountpoint after switch root. Retry with "/" in this case.
-        if (errno == EINVAL && mount_point == "/system") {
-            root_made_private = fs_mgr_overlayfs_set_shared_mount("/", false);
+    if (parent_have_parent) {
+        parent_made_private |= fs_mgr_overlayfs_set_shared_mount(mount_point, false);
+        if (!parent_made_private && errno == EINVAL && mount_point == "/system") {
+            // If failed to set "/system" mount type, it might be due to "/system" not being a valid
+            // mountpoint after switch root. Retry with "/" in this case.
+            parent_made_private |= fs_mgr_overlayfs_set_shared_mount("/", false);
+            root_made_private |= parent_made_private;
         }
     }
 
@@ -496,6 +504,15 @@ static bool fs_mgr_overlayfs_mount_one(const FstabEntry& fstab_entry) {
                 continue;
             }
         }
+        if (!parent_made_private) {
+            parent_made_private |= fs_mgr_overlayfs_set_shared_mount(mount_point, false);
+            if (!parent_made_private && errno == EINVAL && mount_point == "/system") {
+                // If failed to set "/system" mount type, it might be due to "/system" not being a
+                // valid mountpoint after switch root. Retry with "/" in this case.
+                parent_made_private |= fs_mgr_overlayfs_set_shared_mount("/", false);
+                root_made_private |= parent_made_private;
+            }
+        }
 
         if (new_entry.shared_flag) {
             new_entry.shared_flag = fs_mgr_overlayfs_set_shared_mount(new_entry.mount_point, false);
@@ -524,7 +541,7 @@ static bool fs_mgr_overlayfs_mount_one(const FstabEntry& fstab_entry) {
         rmdir(entry.dir.c_str());
     }
     // If the original (overridden) mount was MS_SHARED, then set the overlayfs mount to MS_SHARED.
-    if (parent_shared) {
+    if (parent_shared && parent_made_private) {
         fs_mgr_overlayfs_set_shared_mount(mount_point, true);
     }
     if (root_shared && root_made_private) {

From 28b37f27048679874f1e1185fe9f852d36872e73 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 7 Jun 2024 18:34:19 +0000
Subject: [PATCH 0967/1487] libprocessgroup: Add MaxActivationDepth

Cgroup v2 controllers can be enabled in a subtree of the shared
hierarchy. That allows users to limit the number of cgroups with a
controller enabled to less than the total number of cgroups. [1]

There are costs for each cgroup. Kernel memory is used for each cgroup,
plus additional memory for each active controller in each cgroup. Some
kernel operations scale with the number of cgroups (with a given
controller enabled), so it can be desirable to minimize the number of
cgroups with that controller enabled.

This change allows each v2 controller configuration to specify a maximum
activation depth, past which the controller will not be activated deeper
in the Android cgroup v2 hierarchy. The hierarchy root is defined as
depth 0. MaxActivationDepth is the field name for this purpose for
controllers in the Controllers array under Cgroups2 in cgroups.json.

Here are two examples:

"MaxActivationDepth": 1
This will activate the controller in every per-application cgroup, but
not in the per-process cgroups below.

/sys/fs/cgroup                depth=0  active=true  (controller listed in cgroup.subtree_control)
/sys/fs/cgroup/uid_0          depth=1  active=true  (controller NOT listed in cgroup.subtree_control)
/sys/fs/cgroup/uid_0/pid_100  depth=2  active=false (controller NOT listed in cgroup.subtree_control)

This can also be used with
PRODUCT_CGROUP_V2_SYS_APP_ISOLATION_ENABLED := true.

"MaxActivationDepth": 1
This will activate the controller only at the app / system level, but
not in per-application cgroups below. This results in a total of only
3 cgroups with the controller enabled (root, apps, system).

/sys/fs/cgroup                         depth=0  active=true  (controller listed in cgroup.subtree_control)
/sys/fs/cgroup/apps                    depth=1  active=true  (controller NOT listed in cgroup.subtree_control)
/sys/fs/cgroup/apps/uid_10000          depth=2  active=false (controller NOT listed in cgroup.subtree_control)
/sys/fs/cgroup/apps/uid_10000/pid_100  depth=3  active=false (controller NOT listed in cgroup.subtree_control)

[1] https://www.kernel.org/doc/html/latest/admin-guide/cgroup-v2.html#enabling-and-disabling

Bug: 346584259
Test: Cuttlefish with memcg v2
Change-Id: I62109ea935261c51fc30b2054c4d28d0360f7985
---
 libprocessgroup/Android.bp                    |   1 +
 libprocessgroup/cgroup_map.cpp                |   9 +-
 .../cgrouprc/cgroup_controller.cpp            |   5 +
 .../cgrouprc/include/android/cgrouprc.h       |   8 ++
 libprocessgroup/cgrouprc/libcgrouprc.map.txt  |   7 ++
 .../cgrouprc_format/cgroup_controller.cpp     |  10 +-
 .../processgroup/format/cgroup_controller.h   |   4 +-
 libprocessgroup/profiles/cgroups.proto        |   3 +-
 libprocessgroup/setup/Android.bp              |   1 +
 libprocessgroup/setup/cgroup_descriptor.h     |   3 +-
 libprocessgroup/setup/cgroup_map_write.cpp    |  25 +++-
 libprocessgroup/util/Android.bp               |  47 ++++++++
 libprocessgroup/util/OWNERS                   |   3 +
 libprocessgroup/util/TEST_MAPPING             |   7 ++
 .../util/include/processgroup/util.h          |  61 ++++++++++
 libprocessgroup/util/tests/util.cpp           | 109 ++++++++++++++++++
 16 files changed, 290 insertions(+), 13 deletions(-)
 create mode 100644 libprocessgroup/util/Android.bp
 create mode 100644 libprocessgroup/util/OWNERS
 create mode 100644 libprocessgroup/util/TEST_MAPPING
 create mode 100644 libprocessgroup/util/include/processgroup/util.h
 create mode 100644 libprocessgroup/util/tests/util.cpp

diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index d40be9f9ed6d..33e00bc5dc1e 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -84,6 +84,7 @@ cc_library {
     header_libs: [
         "libcutils_headers",
         "libprocessgroup_headers",
+        "libprocessgroup_util",
     ],
     export_include_dirs: ["include"],
     export_header_lib_headers: [
diff --git a/libprocessgroup/cgroup_map.cpp b/libprocessgroup/cgroup_map.cpp
index ebc059944335..52b5afe5ee6f 100644
--- a/libprocessgroup/cgroup_map.cpp
+++ b/libprocessgroup/cgroup_map.cpp
@@ -28,6 +28,7 @@
 #include <android-base/strings.h>
 #include <cgroup_map.h>
 #include <processgroup/processgroup.h>
+#include <processgroup/util.h>
 
 using android::base::StartsWith;
 using android::base::StringPrintf;
@@ -216,7 +217,13 @@ int CgroupMap::ActivateControllers(const std::string& path) const {
         for (uint32_t i = 0; i < controller_count; ++i) {
             const ACgroupController* controller = ACgroupFile_getController(i);
             const uint32_t flags = ACgroupController_getFlags(controller);
-            if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION) {
+            uint32_t max_activation_depth = UINT32_MAX;
+            if (__builtin_available(android 36, *)) {
+                max_activation_depth = ACgroupController_getMaxActivationDepth(controller);
+            }
+            const int depth = util::GetCgroupDepth(ACgroupController_getPath(controller), path);
+
+            if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
                 std::string str("+");
                 str.append(ACgroupController_getName(controller));
                 if (!WriteStringToFile(str, path + "/cgroup.subtree_control")) {
diff --git a/libprocessgroup/cgrouprc/cgroup_controller.cpp b/libprocessgroup/cgrouprc/cgroup_controller.cpp
index 5a326e55d4de..889b3becf1a2 100644
--- a/libprocessgroup/cgrouprc/cgroup_controller.cpp
+++ b/libprocessgroup/cgrouprc/cgroup_controller.cpp
@@ -32,6 +32,11 @@ uint32_t ACgroupController_getFlags(const ACgroupController* controller) {
     return controller->flags();
 }
 
+uint32_t ACgroupController_getMaxActivationDepth(const ACgroupController* controller) {
+    CHECK(controller != nullptr);
+    return controller->max_activation_depth();
+}
+
 const char* ACgroupController_getName(const ACgroupController* controller) {
     CHECK(controller != nullptr);
     return controller->name();
diff --git a/libprocessgroup/cgrouprc/include/android/cgrouprc.h b/libprocessgroup/cgrouprc/include/android/cgrouprc.h
index e704a36aac9d..3a57df547d60 100644
--- a/libprocessgroup/cgrouprc/include/android/cgrouprc.h
+++ b/libprocessgroup/cgrouprc/include/android/cgrouprc.h
@@ -78,6 +78,14 @@ __attribute__((warn_unused_result)) uint32_t ACgroupController_getVersion(const
 __attribute__((warn_unused_result, weak)) uint32_t ACgroupController_getFlags(
         const ACgroupController*) __INTRODUCED_IN(30);
 
+/**
+ * Returns the maximum activation depth of the given controller.
+ * Only applicable to cgroup v2 controllers.
+ * Returns UINT32_MAX if no maximum activation depth is set.
+ */
+__attribute__((warn_unused_result, weak)) uint32_t ACgroupController_getMaxActivationDepth(
+        const ACgroupController* controller) __INTRODUCED_IN(36);
+
 /**
  * Returns the name of the given controller.
  * If the given controller is null, return nullptr.
diff --git a/libprocessgroup/cgrouprc/libcgrouprc.map.txt b/libprocessgroup/cgrouprc/libcgrouprc.map.txt
index b62b10f3b457..30bd25f18dbd 100644
--- a/libprocessgroup/cgrouprc/libcgrouprc.map.txt
+++ b/libprocessgroup/cgrouprc/libcgrouprc.map.txt
@@ -16,3 +16,10 @@ LIBCGROUPRC_30 { # introduced=30
   local:
     *;
 };
+
+LIBCGROUPRC_36 { # introduced=36
+  global:
+    ACgroupController_getMaxActivationDepth; # llndk=202504 systemapi
+  local:
+    *;
+};
diff --git a/libprocessgroup/cgrouprc_format/cgroup_controller.cpp b/libprocessgroup/cgrouprc_format/cgroup_controller.cpp
index 56e67df59628..0dd909a29150 100644
--- a/libprocessgroup/cgrouprc_format/cgroup_controller.cpp
+++ b/libprocessgroup/cgrouprc_format/cgroup_controller.cpp
@@ -21,13 +21,11 @@ namespace cgrouprc {
 namespace format {
 
 CgroupController::CgroupController(uint32_t version, uint32_t flags, const std::string& name,
-                                   const std::string& path)
-{
+                                   const std::string& path, uint32_t max_activation_depth)
+    : version_(version), flags_(flags), max_activation_depth_(max_activation_depth) {
     // strlcpy isn't available on host. Although there is an implementation
     // in licutils, libcutils itself depends on libcgrouprc_format, causing
     // a circular dependency.
-    version_ = version;
-    flags_ = flags;
     strncpy(name_, name.c_str(), sizeof(name_) - 1);
     name_[sizeof(name_) - 1] = '\0';
     strncpy(path_, path.c_str(), sizeof(path_) - 1);
@@ -42,6 +40,10 @@ uint32_t CgroupController::flags() const {
     return flags_;
 }
 
+uint32_t CgroupController::max_activation_depth() const {
+    return max_activation_depth_;
+}
+
 const char* CgroupController::name() const {
     return name_;
 }
diff --git a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h b/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
index 9427a1cf9208..c0c1f6034fe4 100644
--- a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
+++ b/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
@@ -29,10 +29,11 @@ struct CgroupController {
   public:
     CgroupController() = default;
     CgroupController(uint32_t version, uint32_t flags, const std::string& name,
-                     const std::string& path);
+                     const std::string& path, uint32_t max_activation_depth);
 
     uint32_t version() const;
     uint32_t flags() const;
+    uint32_t max_activation_depth() const;
     const char* name() const;
     const char* path() const;
 
@@ -44,6 +45,7 @@ struct CgroupController {
 
     uint32_t version_ = 0;
     uint32_t flags_ = 0;
+    uint32_t max_activation_depth_ = UINT32_MAX;
     char name_[CGROUP_NAME_BUF_SZ] = {};
     char path_[CGROUP_PATH_BUF_SZ] = {};
 };
diff --git a/libprocessgroup/profiles/cgroups.proto b/libprocessgroup/profiles/cgroups.proto
index f2de3452a2d9..d2fd472d15a7 100644
--- a/libprocessgroup/profiles/cgroups.proto
+++ b/libprocessgroup/profiles/cgroups.proto
@@ -24,7 +24,7 @@ message Cgroups {
     Cgroups2 cgroups2 = 2 [json_name = "Cgroups2"];
 }
 
-// Next: 8
+// Next: 9
 message Cgroup {
     string controller = 1 [json_name = "Controller"];
     string path = 2 [json_name = "Path"];
@@ -36,6 +36,7 @@ message Cgroup {
 // https://developers.google.com/protocol-buffers/docs/proto3#default
     bool needs_activation = 6 [json_name = "NeedsActivation"];
     bool is_optional = 7 [json_name = "Optional"];
+    uint32 max_activation_depth = 8 [json_name = "MaxActivationDepth"];
 }
 
 // Next: 6
diff --git a/libprocessgroup/setup/Android.bp b/libprocessgroup/setup/Android.bp
index 1e0783ab03f3..76f0a11f1fa0 100644
--- a/libprocessgroup/setup/Android.bp
+++ b/libprocessgroup/setup/Android.bp
@@ -37,6 +37,7 @@ cc_library_shared {
     ],
     header_libs: [
         "libprocessgroup_headers",
+        "libprocessgroup_util",
     ],
     export_header_lib_headers: [
         "libprocessgroup_headers",
diff --git a/libprocessgroup/setup/cgroup_descriptor.h b/libprocessgroup/setup/cgroup_descriptor.h
index 9982bfc73638..06ce186fde7a 100644
--- a/libprocessgroup/setup/cgroup_descriptor.h
+++ b/libprocessgroup/setup/cgroup_descriptor.h
@@ -30,7 +30,8 @@ namespace cgrouprc {
 class CgroupDescriptor {
   public:
     CgroupDescriptor(uint32_t version, const std::string& name, const std::string& path,
-                     mode_t mode, const std::string& uid, const std::string& gid, uint32_t flags);
+                     mode_t mode, const std::string& uid, const std::string& gid, uint32_t flags,
+                     uint32_t max_activation_depth);
 
     const format::CgroupController* controller() const { return &controller_; }
     mode_t mode() const { return mode_; }
diff --git a/libprocessgroup/setup/cgroup_map_write.cpp b/libprocessgroup/setup/cgroup_map_write.cpp
index 1b26fbcc67a1..bd418747555f 100644
--- a/libprocessgroup/setup/cgroup_map_write.cpp
+++ b/libprocessgroup/setup/cgroup_map_write.cpp
@@ -42,6 +42,7 @@
 #include <processgroup/format/cgroup_file.h>
 #include <processgroup/processgroup.h>
 #include <processgroup/setup.h>
+#include <processgroup/util.h>
 
 #include "../build_flags.h"
 #include "cgroup_descriptor.h"
@@ -173,9 +174,15 @@ static void MergeCgroupToDescriptors(std::map<std::string, CgroupDescriptor>* de
         controller_flags |= CGROUPRC_CONTROLLER_FLAG_OPTIONAL;
     }
 
+    uint32_t max_activation_depth = UINT32_MAX;
+    if (cgroup.isMember("MaxActivationDepth")) {
+        max_activation_depth = cgroup["MaxActivationDepth"].asUInt();
+    }
+
     CgroupDescriptor descriptor(
             cgroups_version, name, path, std::strtoul(cgroup["Mode"].asString().c_str(), 0, 8),
-            cgroup["UID"].asString(), cgroup["GID"].asString(), controller_flags);
+            cgroup["UID"].asString(), cgroup["GID"].asString(), controller_flags,
+            max_activation_depth);
 
     auto iter = descriptors->find(name);
     if (iter == descriptors->end()) {
@@ -324,7 +331,8 @@ static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
         return false;
     }
 
-    if (controller->flags() & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION) {
+    if (controller->flags() & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION &&
+        controller->max_activation_depth() > 0) {
         std::string str = "+";
         str += controller->name();
         std::string path = controller->path();
@@ -433,8 +441,12 @@ static bool WriteRcFile(const std::map<std::string, CgroupDescriptor>& descripto
 
 CgroupDescriptor::CgroupDescriptor(uint32_t version, const std::string& name,
                                    const std::string& path, mode_t mode, const std::string& uid,
-                                   const std::string& gid, uint32_t flags = 0)
-    : controller_(version, flags, name, path), mode_(mode), uid_(uid), gid_(gid) {}
+                                   const std::string& gid, uint32_t flags,
+                                   uint32_t max_activation_depth)
+    : controller_(version, flags, name, path, max_activation_depth),
+      mode_(mode),
+      uid_(uid),
+      gid_(gid) {}
 
 void CgroupDescriptor::set_mounted(bool mounted) {
     uint32_t flags = controller_.flags();
@@ -502,8 +514,11 @@ static bool CreateV2SubHierarchy(
     for (const auto& [name, descriptor] : descriptors) {
         const format::CgroupController* controller = descriptor.controller();
         std::uint32_t flags = controller->flags();
+        std::uint32_t max_activation_depth = controller->max_activation_depth();
+        const int depth = util::GetCgroupDepth(controller->path(), path);
+
         if (controller->version() == 2 && name != CGROUPV2_HIERARCHY_NAME &&
-            flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION) {
+            flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
             std::string str("+");
             str += controller->name();
             if (!android::base::WriteStringToFile(str, path + "/cgroup.subtree_control")) {
diff --git a/libprocessgroup/util/Android.bp b/libprocessgroup/util/Android.bp
new file mode 100644
index 000000000000..4a940b774b14
--- /dev/null
+++ b/libprocessgroup/util/Android.bp
@@ -0,0 +1,47 @@
+//
+// 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.
+//
+
+package {
+    default_team: "trendy_team_android_kernel",
+    default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+cc_library_headers {
+    name: "libprocessgroup_util",
+    vendor_available: true,
+    product_available: true,
+    ramdisk_available: true,
+    vendor_ramdisk_available: true,
+    recovery_available: true,
+    host_supported: true,
+    native_bridge_supported: true,
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    min_sdk_version: "30",
+    export_include_dirs: [
+        "include",
+    ],
+    defaults: ["libprocessgroup_build_flags_cc"],
+}
+
+cc_test {
+    name: "libprocessgroup_util_test",
+    header_libs: ["libprocessgroup_util"],
+    srcs: ["tests/util.cpp"],
+    test_suites: ["general-tests"],
+}
diff --git a/libprocessgroup/util/OWNERS b/libprocessgroup/util/OWNERS
new file mode 100644
index 000000000000..54ea4001e769
--- /dev/null
+++ b/libprocessgroup/util/OWNERS
@@ -0,0 +1,3 @@
+# Bug component: 1293033
+surenb@google.com
+tjmercier@google.com
diff --git a/libprocessgroup/util/TEST_MAPPING b/libprocessgroup/util/TEST_MAPPING
new file mode 100644
index 000000000000..6ae2658ce9f4
--- /dev/null
+++ b/libprocessgroup/util/TEST_MAPPING
@@ -0,0 +1,7 @@
+{
+  "postsubmit": [
+    {
+      "name": "libprocessgroup_util_test"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/libprocessgroup/util/include/processgroup/util.h b/libprocessgroup/util/include/processgroup/util.h
new file mode 100644
index 000000000000..5240744c62ef
--- /dev/null
+++ b/libprocessgroup/util/include/processgroup/util.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <iterator>
+#include <string>
+
+namespace util {
+
+namespace internal {
+
+const char SEP = '/';
+
+std::string DeduplicateAndTrimSeparators(const std::string& path) {
+    bool lastWasSep = false;
+    std::string ret;
+
+    std::copy_if(path.begin(), path.end(), std::back_inserter(ret), [&lastWasSep](char c) {
+        if (lastWasSep) {
+            if (c == SEP) return false;
+            lastWasSep = false;
+        } else if (c == SEP) {
+            lastWasSep = true;
+        }
+        return true;
+    });
+
+    if (ret.length() > 1 && ret.back() == SEP) ret.pop_back();
+
+    return ret;
+}
+
+}  // namespace internal
+
+unsigned int GetCgroupDepth(const std::string& controller_root, const std::string& cgroup_path) {
+    const std::string deduped_root = internal::DeduplicateAndTrimSeparators(controller_root);
+    const std::string deduped_path = internal::DeduplicateAndTrimSeparators(cgroup_path);
+
+    if (deduped_root.empty() || deduped_path.empty() || !deduped_path.starts_with(deduped_root))
+        return 0;
+
+    return std::count(deduped_path.begin() + deduped_root.size(), deduped_path.end(),
+                      internal::SEP);
+}
+
+}  // namespace util
diff --git a/libprocessgroup/util/tests/util.cpp b/libprocessgroup/util/tests/util.cpp
new file mode 100644
index 000000000000..1de7d6f3fb36
--- /dev/null
+++ b/libprocessgroup/util/tests/util.cpp
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <processgroup/util.h>
+
+#include "gtest/gtest.h"
+
+using util::GetCgroupDepth;
+
+TEST(EmptyInputs, bothEmpty) {
+    EXPECT_EQ(GetCgroupDepth({}, {}), 0);
+}
+
+TEST(EmptyInputs, rootEmpty) {
+    EXPECT_EQ(GetCgroupDepth({}, "foo"), 0);
+}
+
+TEST(EmptyInputs, pathEmpty) {
+    EXPECT_EQ(GetCgroupDepth("foo", {}), 0);
+}
+
+TEST(InvalidInputs, pathNotInRoot) {
+    EXPECT_EQ(GetCgroupDepth("foo", "bar"), 0);
+}
+
+TEST(InvalidInputs, rootLargerThanPath) {
+    EXPECT_EQ(GetCgroupDepth("/a/long/path", "/short"), 0);
+}
+
+TEST(InvalidInputs, pathLargerThanRoot) {
+    EXPECT_EQ(GetCgroupDepth("/short", "/a/long/path"), 0);
+}
+
+TEST(InvalidInputs, missingSeparator) {
+    EXPECT_EQ(GetCgroupDepth("/controller/root", "/controller/rootcgroup"), 0);
+}
+
+TEST(ExtraSeparators, root) {
+    EXPECT_EQ(GetCgroupDepth("///sys/fs/cgroup", "/sys/fs/cgroup/a/b/c"), 3);
+    EXPECT_EQ(GetCgroupDepth("/sys///fs/cgroup", "/sys/fs/cgroup/a/b/c"), 3);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs///cgroup", "/sys/fs/cgroup/a/b/c"), 3);
+
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "///sys/fs/cgroup/a/b/c"), 3);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys///fs/cgroup/a/b/c"), 3);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs///cgroup/a/b/c"), 3);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup///a/b/c"), 3);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup/a///b/c"), 3);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup/a/b///c"), 3);
+}
+
+TEST(SeparatorEndings, rootEndsInSeparator) {
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup/", "/sys/fs/cgroup/a/b"), 2);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup///", "/sys/fs/cgroup/a/b"), 2);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup/", "/sys/fs/cgroup/a/b/"), 2);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup///", "/sys/fs/cgroup/a/b/"), 2);
+}
+
+TEST(SeparatorEndings, pathEndsInSeparator) {
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup/a/b/"), 2);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup/a/b///"), 2);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup/", "/sys/fs/cgroup/a/b/"), 2);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup/", "/sys/fs/cgroup/a/b///"), 2);
+}
+
+TEST(ValidInputs, rootHasZeroDepth) {
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup"), 0);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup/", "/sys/fs/cgroup"), 0);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup/"), 0);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup/", "/sys/fs/cgroup/"), 0);
+}
+
+TEST(ValidInputs, atLeastDepth10) {
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup/a/b/c/d/e/f/g/h/i/j"), 10);
+}
+
+TEST(ValidInputs, androidCgroupNames) {
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup/system/uid_0/pid_1000"), 3);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup/uid_0/pid_1000"), 2);
+
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup/apps/uid_100000/pid_1000"), 3);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup/uid_100000/pid_1000"), 2);
+
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup/apps"), 1);
+    EXPECT_EQ(GetCgroupDepth("/sys/fs/cgroup", "/sys/fs/cgroup/system"), 1);
+}
+
+TEST(ValidInputs, androidCgroupNames_nonDefaultRoot) {
+    EXPECT_EQ(GetCgroupDepth("/custom/root", "/custom/root/system/uid_0/pid_1000"), 3);
+    EXPECT_EQ(GetCgroupDepth("/custom/root", "/custom/root/uid_0/pid_1000"), 2);
+
+    EXPECT_EQ(GetCgroupDepth("/custom/root", "/custom/root/apps/uid_100000/pid_1000"), 3);
+    EXPECT_EQ(GetCgroupDepth("/custom/root", "/custom/root/uid_100000/pid_1000"), 2);
+
+    EXPECT_EQ(GetCgroupDepth("/custom/root", "/custom/root/apps"), 1);
+    EXPECT_EQ(GetCgroupDepth("/custom/root", "/custom/root/system"), 1);
+}

From a8f130693dff20e18c74467f68b7c6bcf93340d7 Mon Sep 17 00:00:00 2001
From: Liana Kazanova <lkazanova@google.com>
Date: Tue, 18 Jun 2024 22:20:43 +0000
Subject: [PATCH 0968/1487] Revert "reupload: libsnapshot: set thread priority"

This reverts commit 00e1b61bb92b7a9905fdb5c00aba9ffd47a36dbf.

Reason for revert: DroidMonitor: Potential culprit for b/348041418 - verifying through ABTD before revert submission. This is part of the standard investigation process, and does not mean your CL will be reverted.

Change-Id: Ib7422cc7bfb7815ede814fb5f0ee1d4537fe52d2
---
 .../libsnapshot/snapuserd/user-space-merge/merge_worker.cpp | 4 +---
 .../libsnapshot/snapuserd/user-space-merge/read_worker.cpp  | 6 +-----
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index 4afc312e3da8..bd7eaca747d6 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -577,10 +577,8 @@ bool MergeWorker::Run() {
         SNAP_LOG(ERROR) << "Merge terminated early...";
         return true;
     }
-    auto merge_thread_priority = android::base::GetUintProperty<uint32_t>(
-            "ro.virtual_ab.merge_thread_priority", ANDROID_PRIORITY_BACKGROUND);
 
-    if (!SetThreadPriority(merge_thread_priority)) {
+    if (!SetThreadPriority(ANDROID_PRIORITY_BACKGROUND)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index 7191f1f74a1f..d40b6d11d92d 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -17,10 +17,8 @@
 #include <libsnapshot/cow_format.h>
 #include <pthread.h>
 
-#include "android-base/properties.h"
 #include "read_worker.h"
 #include "snapuserd_core.h"
-#include "user-space-merge/worker.h"
 #include "utility.h"
 
 namespace android {
@@ -261,10 +259,8 @@ bool ReadWorker::Run() {
     SNAP_LOG(INFO) << "Processing snapshot I/O requests....";
 
     pthread_setname_np(pthread_self(), "ReadWorker");
-    auto worker_thread_priority = android::base::GetUintProperty<uint32_t>(
-            "ro.virtual_ab.worker_thread_priority", ANDROID_PRIORITY_NORMAL);
 
-    if (!SetThreadPriority(worker_thread_priority)) {
+    if (!SetThreadPriority(ANDROID_PRIORITY_NORMAL)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 

From c2970dd06f7b23179dddf71dd9041024cf743b26 Mon Sep 17 00:00:00 2001
From: Nelson Li <nelsonli@google.com>
Date: Wed, 19 Jun 2024 02:14:23 +0000
Subject: [PATCH 0969/1487] Rewrite `init_vendor` using select syntax

The `select` syntax rewrite makes it more concise and easier to
understand.

Bug: 347605145
Test: m init_vendor
Change-Id: I866bbe9360fdbdf69cac3c6a24bbe37306227755
---
 init/Android.bp | 22 +++++-----------------
 1 file changed, 5 insertions(+), 17 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index 6526a934e3fb..7b7a856e91ee 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -664,22 +664,10 @@ sh_binary {
     filename_from_src: true,
 }
 
-soong_config_module_type {
-    name: "board_use_recovery_as_boot_phony",
-    module_type: "phony",
-    config_namespace: "ANDROID",
-    bool_variables: ["BOARD_USES_RECOVERY_AS_BOOT"],
-    properties: ["required"],
-}
-
-board_use_recovery_as_boot_phony {
+phony {
     name: "init_vendor",
-    soong_config_variables: {
-        BOARD_USES_RECOVERY_AS_BOOT: {
-            required: [],
-            conditions_default: {
-                required: ["init_first_stage"],
-            },
-        },
-    },
+    required: select(soong_config_variable("ANDROID", "BOARD_USES_RECOVERY_AS_BOOT"), {
+        true: [],
+        default: ["init_first_stage"],
+    }),
 }

From 1fd7993f85bdf304bc53ca562b8c79a2142daa08 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 21 Jun 2024 22:17:12 +0000
Subject: [PATCH 0970/1487] libcutils: Add missing dependency on
 libprocessgroup_headers

cutils/sched_policy.h redirects to processgroup/sched_policy.h, but
libcutils does not export the libprocessgroup headers. So users have to
know about the hidden redirect to libprocessgroup and include a
libprocessgroup dependency in their Android.bp files in addition to
libcutils. Fix that.

Bug: 349105928
Test: m
Change-Id: I516bdf2cdeff980c1fcd18883ef8a2f0a9beb629
---
 libcutils/Android.bp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index e2975813ced1..39cae1b4b749 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -47,6 +47,8 @@ cc_library_headers {
     defaults: ["libcutils_defaults"],
 
     export_include_dirs: ["include"],
+    header_libs: ["libprocessgroup_headers"],
+    export_header_lib_headers: ["libprocessgroup_headers"],
     target: {
         vendor: {
             override_export_include_dirs: ["include_outside_system"],

From 6f13d115eb0191e240364b70e59186777c8683fd Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 21 Jun 2024 21:27:32 +0000
Subject: [PATCH 0971/1487] libutils: Remove unused dependency on
 libprocessgroup_headers

Bug: 349105928
Test: m
Change-Id: Ic3e64b073c0ba087c3db19fb428c8c9132c8211f
---
 libutils/Android.bp  | 2 --
 libutils/Threads.cpp | 5 -----
 2 files changed, 7 deletions(-)

diff --git a/libutils/Android.bp b/libutils/Android.bp
index 4877caeeebf6..305cbf0a8834 100644
--- a/libutils/Android.bp
+++ b/libutils/Android.bp
@@ -33,14 +33,12 @@ cc_library_headers {
         "libbase_headers",
         "libcutils_headers",
         "liblog_headers",
-        "libprocessgroup_headers",
         "libsystem_headers",
     ],
     export_header_lib_headers: [
         "libbase_headers",
         "libcutils_headers",
         "liblog_headers",
-        "libprocessgroup_headers",
         "libsystem_headers",
     ],
     export_include_dirs: ["include"],
diff --git a/libutils/Threads.cpp b/libutils/Threads.cpp
index 90ea29b22887..0b96ab0bbcb8 100644
--- a/libutils/Threads.cpp
+++ b/libutils/Threads.cpp
@@ -36,11 +36,6 @@
 
 #include <log/log.h>
 
-#if defined(__ANDROID__)
-#include <processgroup/processgroup.h>
-#include <processgroup/sched_policy.h>
-#endif
-
 #if defined(__ANDROID__)
 # define __android_unused
 #else

From 9fbe52662210c56041052f4a13bcc70f789ac26e Mon Sep 17 00:00:00 2001
From: Julien Desprez <jdesprez@google.com>
Date: Mon, 24 Jun 2024 20:37:20 +0000
Subject: [PATCH 0972/1487] Migrate vts_libsnapshot_test and friends to
 general-tests zip

for things that works in VTS, they should be buildable in general-tests
zip rather than device-tests. Which is cheaper in term of build resources.

Change-Id: If12442bf88cb5dd2b503e8023f925015890a39e2
Test: presubmit
Bug: None
---
 fs_mgr/libsnapshot/Android.bp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 39b5b76531a4..f0983186f22c 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -294,7 +294,7 @@ cc_test {
     ],
     test_suites: [
         "vts",
-        "device-tests",
+        "general-tests",
     ],
     test_options: {
         min_shipping_api_level: 30,
@@ -311,7 +311,7 @@ cc_test {
         "-DLIBSNAPSHOT_TEST_VAB_LEGACY",
     ],
     test_suites: [
-        "device-tests",
+        "general-tests",
     ],
     test_options: {
         // Legacy VAB launched in Android R.
@@ -414,7 +414,7 @@ cc_test {
         "libstorage_literals_headers",
     ],
     test_suites: [
-        "device-tests",
+        "general-tests",
     ],
     test_options: {
         min_shipping_api_level: 30,

From 7b55fbc6d4044a5059c63dea4678adb248e59f39 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 28 May 2024 18:25:12 -0700
Subject: [PATCH 0973/1487] reupload^2: libsnapshot: set thread priority

It looks like the previous error was due to a missing include that
somehow my LSP didn't catch. The build failure isn't reproducible on
aosp-main but is on git_main. Confirmed this new patch with the #include
builds correctly on git_main.

Read merge thread + worker thread priority from build configurations. In
the case of low memory devices, a lower priority will reduce CPU
utilization post OTA reboot.

Test: th
Change-Id: I7fd398c4688cf78abe738e7320b9f27f5f7d1e13
---
 .../snapuserd/user-space-merge/merge_worker.cpp        | 10 +++++++---
 .../snapuserd/user-space-merge/read_worker.cpp         |  7 ++++++-
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index bd7eaca747d6..e6a9a298968d 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -17,6 +17,8 @@
 #include <libsnapshot/cow_format.h>
 #include <pthread.h>
 
+#include <android-base/properties.h>
+
 #include "merge_worker.h"
 #include "snapuserd_core.h"
 #include "utility.h"
@@ -179,8 +181,8 @@ bool MergeWorker::MergeReplaceZeroOps() {
         bufsink_.ResetBufferOffset();
 
         if (snapuserd_->IsIOTerminated()) {
-            SNAP_LOG(ERROR)
-                    << "MergeReplaceZeroOps: MergeWorker threads terminated - shutting down merge";
+            SNAP_LOG(ERROR) << "MergeReplaceZeroOps: MergeWorker threads terminated - shutting "
+                               "down merge";
             return false;
         }
     }
@@ -577,8 +579,10 @@ bool MergeWorker::Run() {
         SNAP_LOG(ERROR) << "Merge terminated early...";
         return true;
     }
+    auto merge_thread_priority = android::base::GetUintProperty<uint32_t>(
+            "ro.virtual_ab.merge_thread_priority", ANDROID_PRIORITY_BACKGROUND);
 
-    if (!SetThreadPriority(ANDROID_PRIORITY_BACKGROUND)) {
+    if (!SetThreadPriority(merge_thread_priority)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index d40b6d11d92d..ef311d4757f0 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -14,11 +14,14 @@
  * limitations under the License.
  */
 
+#include <android-base/properties.h>
+
 #include <libsnapshot/cow_format.h>
 #include <pthread.h>
 
 #include "read_worker.h"
 #include "snapuserd_core.h"
+#include "user-space-merge/worker.h"
 #include "utility.h"
 
 namespace android {
@@ -259,8 +262,10 @@ bool ReadWorker::Run() {
     SNAP_LOG(INFO) << "Processing snapshot I/O requests....";
 
     pthread_setname_np(pthread_self(), "ReadWorker");
+    auto worker_thread_priority = android::base::GetUintProperty<uint32_t>(
+            "ro.virtual_ab.worker_thread_priority", ANDROID_PRIORITY_NORMAL);
 
-    if (!SetThreadPriority(ANDROID_PRIORITY_NORMAL)) {
+    if (!SetThreadPriority(worker_thread_priority)) {
         SNAP_PLOG(ERROR) << "Failed to set thread priority";
     }
 

From 8abaa8442f88800e8b653916828dd89f14aaa155 Mon Sep 17 00:00:00 2001
From: Priyanka Advani <padvani@google.com>
Date: Tue, 25 Jun 2024 18:11:53 +0000
Subject: [PATCH 0974/1487] Revert "Migrate vts_libsnapshot_test and friends to
 general-tests zip"

This reverts commit 9fbe52662210c56041052f4a13bcc70f789ac26e.

Reason for revert: Droidmonitor created revert due to b/349278999. Will be verifying through ABTD before submission.

Change-Id: I9eae3b5ce729e0efdc092c814cbe225bcd43d32f
---
 fs_mgr/libsnapshot/Android.bp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index f0983186f22c..39b5b76531a4 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -294,7 +294,7 @@ cc_test {
     ],
     test_suites: [
         "vts",
-        "general-tests",
+        "device-tests",
     ],
     test_options: {
         min_shipping_api_level: 30,
@@ -311,7 +311,7 @@ cc_test {
         "-DLIBSNAPSHOT_TEST_VAB_LEGACY",
     ],
     test_suites: [
-        "general-tests",
+        "device-tests",
     ],
     test_options: {
         // Legacy VAB launched in Android R.
@@ -414,7 +414,7 @@ cc_test {
         "libstorage_literals_headers",
     ],
     test_suites: [
-        "general-tests",
+        "device-tests",
     ],
     test_options: {
         min_shipping_api_level: 30,

From 47fde793b111aecdb34edba598b5697ba9c4701c Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Wed, 26 Jun 2024 17:50:14 +0000
Subject: [PATCH 0975/1487] libutils: CallStackTest log_stack check more log

Check last 10,000 instead of last 1,000 log entries.

Fixes: 348793356
Test: presubmit

Change-Id: I08c660ddd7e49466a4b55d96e46a402ee8912a24
---
 libutils/CallStack_test.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/libutils/CallStack_test.cpp b/libutils/CallStack_test.cpp
index 7afc2c33390f..bfe6b8798019 100644
--- a/libutils/CallStack_test.cpp
+++ b/libutils/CallStack_test.cpp
@@ -72,7 +72,8 @@ TEST(CallStackTest, thread_backtrace) {
 TEST(CallStackTest, log_stack) {
     android::CallStack::logStack("callstack_test");
     auto logger_list = android_logger_list_open(android_name_to_log_id("main"),
-                                                ANDROID_LOG_NONBLOCK, 1000, getpid());
+                                                ANDROID_LOG_NONBLOCK,
+                                                10000 /* tail */, getpid());
     ASSERT_NE(nullptr, logger_list);
     std::string log;
     while (true) {

From 791663022e9b8aac8d6576d658f5bad802eda41c Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 26 Jun 2024 20:22:37 +0000
Subject: [PATCH 0976/1487] fs_mgr_remount.cpp: pedantic grammar fixes.

In my defense, I genuinely thought it was telling me to try again.

Change-Id: I613cd076a13de440bc98a8385022dd9f4b74311c
---
 fs_mgr/fs_mgr_remount.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/fs_mgr_remount.cpp b/fs_mgr/fs_mgr_remount.cpp
index 79c0b6df03ae..f91d2327c857 100644
--- a/fs_mgr/fs_mgr_remount.cpp
+++ b/fs_mgr/fs_mgr_remount.cpp
@@ -171,11 +171,12 @@ bool VerifyCheckpointing() {
         }
         if (show_help) {
             show_help = false;
-            std::cerr << "WARNING: Userdata checkpoint is in progress. To force end checkpointing, "
-                         "call 'vdc checkpoint commitChanges'. This can lead to data corruption if "
-                         "rolled back."
+            std::cerr << "WARNING: Userdata checkpoint is in progress. "
+                         "To forcibly end checkpointing, "
+                         "call 'vdc checkpoint commitChanges'. "
+                         "This can lead to data corruption if rolled back."
                       << std::endl;
-            LOG(INFO) << "Waiting for checkpoint to complete and then continue remount.";
+            LOG(INFO) << "Waiting for checkpoint to complete before remounting...";
         }
         std::this_thread::sleep_for(4s);
     }

From 5c8a0f6752ad56234182fde9627620afa28c5211 Mon Sep 17 00:00:00 2001
From: jahinimtiaz <jahinimtiaz@google.com>
Date: Wed, 26 Jun 2024 21:00:25 +0000
Subject: [PATCH 0977/1487] Opt out of gtest error if no binary found

Bug: 348446766
Test: Presubmit
Change-Id: If1aaa9726529453fc612fe4dec31f334460436d4
---
 fs_mgr/libsnapshot/Android.bp           |  6 ++++++
 fs_mgr/libsnapshot/snapuserd/Android.bp | 10 +++++++++-
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 39b5b76531a4..cc6db358b098 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -316,6 +316,12 @@ cc_test {
     test_options: {
         // Legacy VAB launched in Android R.
         min_shipping_api_level: 30,
+        test_runner_options: [
+            {
+                name: "force-no-test-error",
+                value: "false",
+            },
+        ],
     },
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 649309de1d67..d83524a18ac0 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -168,7 +168,7 @@ cc_binary {
     vendor_ramdisk_available: true,
 }
 
-// This target will install to /system/bin/snapuserd_ramdisk 
+// This target will install to /system/bin/snapuserd_ramdisk
 // It will also create a symblink on /system/bin/snapuserd that point to
 // /system/bin/snapuserd_ramdisk .
 // This way, init can check if generic ramdisk copy exists.
@@ -249,6 +249,14 @@ cc_test {
     test_suites: [
         "device-tests",
     ],
+    test_options: {
+        test_runner_options: [
+            {
+                name: "force-no-test-error",
+                value: "false",
+            },
+        ],
+    },
 }
 
 // vts tests cannot be host_supported.

From 0509c71cc44523af4c44b20316be96f781d52e02 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 9 Feb 2024 19:18:32 +0000
Subject: [PATCH 0978/1487] Move StagedRollbackTest from postsubmit to
 presubmit

Bug: 324596460
Change-Id: Iad7bfd7cb56f0c16366a9aa61b9466545ee4c661
---
 libprocessgroup/TEST_MAPPING | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libprocessgroup/TEST_MAPPING b/libprocessgroup/TEST_MAPPING
index 29a9ff05094a..b713f6b5eafa 100644
--- a/libprocessgroup/TEST_MAPPING
+++ b/libprocessgroup/TEST_MAPPING
@@ -1,5 +1,5 @@
 {
-  "postsubmit": [
+  "presubmit": [
     {
       "name": "StagedRollbackTest"
     }

From 104d3cc4b9e8f8b8ce3d94ba607c6074c1ec81ff Mon Sep 17 00:00:00 2001
From: Pechetty Sravani <pechetty@google.com>
Date: Thu, 27 Jun 2024 01:49:59 +0000
Subject: [PATCH 0979/1487] Revert "Move StagedRollbackTest from postsubmit to
 presubmit"

This reverts commit 0509c71cc44523af4c44b20316be96f781d52e02.

Reason for revert: Droidmonitor triggered revert due to Test breakage in b/349693967. Will be verifying through ABTD before submission.

Change-Id: I66a706b8b4f9bf802f7ea1a6b50bb4847b915c92
---
 libprocessgroup/TEST_MAPPING | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libprocessgroup/TEST_MAPPING b/libprocessgroup/TEST_MAPPING
index b713f6b5eafa..29a9ff05094a 100644
--- a/libprocessgroup/TEST_MAPPING
+++ b/libprocessgroup/TEST_MAPPING
@@ -1,5 +1,5 @@
 {
-  "presubmit": [
+  "postsubmit": [
     {
       "name": "StagedRollbackTest"
     }

From 36e2a44710f1eab8d2f125106f400fc5b5cb194a Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 27 Jun 2024 01:58:24 +0000
Subject: [PATCH 0980/1487] Revert^2 "Move StagedRollbackTest from postsubmit
 to presubmit"

This reverts commit 104d3cc4b9e8f8b8ce3d94ba607c6074c1ec81ff.

Reason for revert: change from presubmit to presubmit-large
Bug: 349693967

Change-Id: I47ea41162aea0140bc460521d0638ce9ca8a96a3
---
 libprocessgroup/TEST_MAPPING | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libprocessgroup/TEST_MAPPING b/libprocessgroup/TEST_MAPPING
index 29a9ff05094a..0f670ef413d4 100644
--- a/libprocessgroup/TEST_MAPPING
+++ b/libprocessgroup/TEST_MAPPING
@@ -1,5 +1,5 @@
 {
-  "postsubmit": [
+  "presubmit-large": [
     {
       "name": "StagedRollbackTest"
     }

From a7b4a9d4f94113f9bde6f287ed6de1c38b2c2986 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <jaegeuk@google.com>
Date: Thu, 27 Jun 2024 10:27:21 -0700
Subject: [PATCH 0981/1487] Call sync() to guarantee blocks were released by
 unlink

Otherwise, the cached inode does not release the blocks which causes next
allocation for pinning fails.

Bug: 349270107
Change-Id: I4c2886683ea1949c1999e551a80b56dc37459dba
Signed-off-by: Jaegeuk Kim <jaegeuk@google.com>
---
 fs_mgr/libfiemap/fiemap_writer.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs_mgr/libfiemap/fiemap_writer.cpp b/fs_mgr/libfiemap/fiemap_writer.cpp
index 06e210eca836..d61e0071b54f 100644
--- a/fs_mgr/libfiemap/fiemap_writer.cpp
+++ b/fs_mgr/libfiemap/fiemap_writer.cpp
@@ -60,6 +60,7 @@ static_assert(sizeof(off_t) == sizeof(uint64_t));
 static inline void cleanup(const std::string& file_path, bool created) {
     if (created) {
         unlink(file_path.c_str());
+        sync();
     }
 }
 

From 8d9b33d64917a05e3342a9b7faef2156afdf8604 Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Thu, 27 Jun 2024 21:51:49 -0700
Subject: [PATCH 0982/1487] fs_mgr: avoid vector<const T>

A container of const T uses std::allocator<const T>, which was an
undocumented libc++ extension that has been removed.

See https://github.com/llvm/llvm-project/pull/96319.

Bug: 349681543
Test: m libfs_mgr
Change-Id: Ic7f50453f05293b7684be22393d6e5871e493983
---
 fs_mgr/fs_mgr_overlayfs_mount.cpp | 2 +-
 fs_mgr/fs_mgr_overlayfs_mount.h   | 2 +-
 fs_mgr/fs_mgr_vendor_overlay.cpp  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index bd0fcfd98274..b63b9e7aa0fb 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -74,7 +74,7 @@ bool fs_mgr_is_dsu_running() {
     return android::gsi::IsGsiRunning();
 }
 
-std::vector<const std::string> OverlayMountPoints() {
+std::vector<std::string> OverlayMountPoints() {
     // Never fallback to legacy cache mount point if within a DSU system,
     // because running a DSU system implies the device supports dynamic
     // partitions, which means legacy cache mustn't be used.
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.h b/fs_mgr/fs_mgr_overlayfs_mount.h
index 98b9007b505f..f941ab1d63f6 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.h
+++ b/fs_mgr/fs_mgr_overlayfs_mount.h
@@ -54,7 +54,7 @@ const std::string fs_mgr_mount_point(const std::string& mount_point);
 bool OverlayfsSetupAllowed(bool verbose = false);
 bool MountScratch(const std::string& device_path, bool readonly = false);
 bool fs_mgr_overlayfs_umount_scratch();
-std::vector<const std::string> OverlayMountPoints();
+std::vector<std::string> OverlayMountPoints();
 bool fs_mgr_overlayfs_already_mounted(const std::string& mount_point, bool overlay_only = true);
 bool fs_mgr_wants_overlayfs(android::fs_mgr::FstabEntry* entry);
 android::fs_mgr::Fstab fs_mgr_overlayfs_candidate_list(const android::fs_mgr::Fstab& fstab);
diff --git a/fs_mgr/fs_mgr_vendor_overlay.cpp b/fs_mgr/fs_mgr_vendor_overlay.cpp
index 6b742e55e1b0..6687283842b4 100644
--- a/fs_mgr/fs_mgr_vendor_overlay.cpp
+++ b/fs_mgr/fs_mgr_vendor_overlay.cpp
@@ -36,7 +36,7 @@ namespace {
 
 // The order of the list means the priority to show the files in the directory.
 // The last one has the highest priority.
-const std::vector<const std::string> kVendorOverlaySourceDirs = {
+const std::vector<std::string> kVendorOverlaySourceDirs = {
         "/system/vendor_overlay/",
         "/product/vendor_overlay/",
 };

From d8f5fd4edb0efe61c1b23e451564d2563aa9ec69 Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Thu, 27 Jun 2024 23:08:13 -0700
Subject: [PATCH 0983/1487] bootstat: avoid vector<const T>

A container of const T uses std::allocator<const T>, which was an
undocumented libc++ extension that has been removed.

See https://github.com/llvm/llvm-project/pull/96319.

Bug: 349681543
Test: m bootstat
Change-Id: Id338f439aa4caf8c9f3c6fc15faef19b1edc4368
---
 bootstat/bootstat.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bootstat/bootstat.cpp b/bootstat/bootstat.cpp
index d402bf17bdf2..d476d36a936f 100644
--- a/bootstat/bootstat.cpp
+++ b/bootstat/bootstat.cpp
@@ -499,7 +499,7 @@ int32_t BootReasonStrToEnum(const std::string& boot_reason) {
 }
 
 // Canonical list of supported primary reboot reasons.
-const std::vector<const std::string> knownReasons = {
+const std::vector<std::string> knownReasons = {
     // clang-format off
     // kernel
     "watchdog",

From dfd7b88fb47e92b611a6b654dafad44b8f065c34 Mon Sep 17 00:00:00 2001
From: Ashok Mutyala <quic_amutyala@quicinc.com>
Date: Tue, 28 May 2024 09:19:59 +0000
Subject: [PATCH 0984/1487] Add length parameter to format /data

With metadata encryption, if partition is wiped (or) cryptfs failed , it will do format without length which make partition size is grown large to occupy remaining space instead of restricting the Android defined partition size

Bug: 343159184
Test: Add length flag in fstab && fastboot erase userdata && fastboot reboot && df -h /data

Signed-off-by: Ashok Mutyala <quic_amutyala@quicinc.com>
Change-Id: Ifce4b78df5edb899c84a032004895802766cd5cf
---
 fs_mgr/fs_mgr.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 7f41cea83673..5156754a8538 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -1556,6 +1556,7 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                                    attempted_entry.mount_point, wiped ? "true" : "false",
                                    attempted_entry.fs_type,
                                    attempted_entry.fs_mgr_flags.is_zoned ? "true" : "false",
+                                   std::to_string(attempted_entry.length),
                                    android::base::Join(attempted_entry.user_devices, ' ')},
                                   nullptr)) {
                         LERROR << "Encryption failed";
@@ -1601,6 +1602,7 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                                current_entry.mount_point, "true" /* shouldFormat */,
                                current_entry.fs_type,
                                current_entry.fs_mgr_flags.is_zoned ? "true" : "false",
+                               std::to_string(current_entry.length),
                                android::base::Join(current_entry.user_devices, ' ')},
                               nullptr)) {
                     LERROR << "Encryption failed";

From d41c0f4a9e6e8178f5b8f46fe3b9a4530efc113a Mon Sep 17 00:00:00 2001
From: Tomasz Wasilczyk <twasilczyk@google.com>
Date: Tue, 25 Jun 2024 10:34:23 -0700
Subject: [PATCH 0985/1487] Migrate pthread to std::thread

Bug: 341997808
Test: atest --host libutils_test
Change-Id: I4f435d5d85efcbcc351b7620811c172badc2276d
---
 libutils/Looper.cpp                           | 33 ++-----------------
 .../arm64/source-based/libutils.so.lsdump     | 26 ---------------
 .../arm_arm64/source-based/libutils.so.lsdump | 26 ---------------
 libutils/include/utils/Looper.h               |  2 --
 4 files changed, 3 insertions(+), 84 deletions(-)

diff --git a/libutils/Looper.cpp b/libutils/Looper.cpp
index 7700c9030b91..e11d1973156a 100644
--- a/libutils/Looper.cpp
+++ b/libutils/Looper.cpp
@@ -70,8 +70,7 @@ int SimpleLooperCallback::handleEvent(int fd, int events, void* data) {
 // Maximum number of file descriptors for which to retrieve poll events each iteration.
 static const int EPOLL_MAX_EVENTS = 16;
 
-static pthread_once_t gTLSOnce = PTHREAD_ONCE_INIT;
-static pthread_key_t gTLSKey = 0;
+thread_local static sp<Looper> gThreadLocalLooper;
 
 Looper::Looper(bool allowNonCallbacks)
     : mAllowNonCallbacks(allowNonCallbacks),
@@ -91,38 +90,12 @@ Looper::Looper(bool allowNonCallbacks)
 Looper::~Looper() {
 }
 
-void Looper::initTLSKey() {
-    int error = pthread_key_create(&gTLSKey, threadDestructor);
-    LOG_ALWAYS_FATAL_IF(error != 0, "Could not allocate TLS key: %s", strerror(error));
-}
-
-void Looper::threadDestructor(void *st) {
-    Looper* const self = static_cast<Looper*>(st);
-    if (self != nullptr) {
-        self->decStrong((void*)threadDestructor);
-    }
-}
-
 void Looper::setForThread(const sp<Looper>& looper) {
-    sp<Looper> old = getForThread(); // also has side-effect of initializing TLS
-
-    if (looper != nullptr) {
-        looper->incStrong((void*)threadDestructor);
-    }
-
-    pthread_setspecific(gTLSKey, looper.get());
-
-    if (old != nullptr) {
-        old->decStrong((void*)threadDestructor);
-    }
+    gThreadLocalLooper = looper;
 }
 
 sp<Looper> Looper::getForThread() {
-    int result = pthread_once(& gTLSOnce, initTLSKey);
-    LOG_ALWAYS_FATAL_IF(result != 0, "pthread_once failed");
-
-    Looper* looper = (Looper*)pthread_getspecific(gTLSKey);
-    return sp<Looper>::fromExisting(looper);
+    return gThreadLocalLooper;
 }
 
 sp<Looper> Looper::prepare(int opts) {
diff --git a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
index 82ddca8f5d87..caea1a96c998 100644
--- a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
@@ -509,9 +509,6 @@
   {
    "name" : "_ZN7android47LightRefBase_reportIncStrongRequireStrongFailedEPKv"
   },
-  {
-   "name" : "_ZN7android6Looper10initTLSKeyEv"
-  },
   {
    "name" : "_ZN7android6Looper11sendMessageERKNS_2spINS_14MessageHandlerEEERKNS_7MessageE"
   },
@@ -527,9 +524,6 @@
   {
    "name" : "_ZN7android6Looper14removeMessagesERKNS_2spINS_14MessageHandlerEEEi"
   },
-  {
-   "name" : "_ZN7android6Looper16threadDestructorEPv"
-  },
   {
    "name" : "_ZN7android6Looper17sendMessageAtTimeElRKNS_2spINS_14MessageHandlerEEERKNS_7MessageE"
   },
@@ -6909,13 +6903,6 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
-  {
-   "access" : "private",
-   "function_name" : "android::Looper::initTLSKey",
-   "linker_set_key" : "_ZN7android6Looper10initTLSKeyEv",
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Looper.h"
-  },
   {
    "function_name" : "android::Looper::sendMessage",
    "linker_set_key" : "_ZN7android6Looper11sendMessageERKNS_2spINS_14MessageHandlerEEERKNS_7MessageE",
@@ -6988,19 +6975,6 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
-  {
-   "access" : "private",
-   "function_name" : "android::Looper::threadDestructor",
-   "linker_set_key" : "_ZN7android6Looper16threadDestructorEPv",
-   "parameters" :
-   [
-    {
-     "referenced_type" : "_ZTIPv"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Looper.h"
-  },
   {
    "function_name" : "android::Looper::sendMessageAtTime",
    "linker_set_key" : "_ZN7android6Looper17sendMessageAtTimeElRKNS_2spINS_14MessageHandlerEEERKNS_7MessageE",
diff --git a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
index dfc1ab581af6..b9c4c521f496 100644
--- a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
@@ -513,9 +513,6 @@
   {
    "name" : "_ZN7android47LightRefBase_reportIncStrongRequireStrongFailedEPKv"
   },
-  {
-   "name" : "_ZN7android6Looper10initTLSKeyEv"
-  },
   {
    "name" : "_ZN7android6Looper11sendMessageERKNS_2spINS_14MessageHandlerEEERKNS_7MessageE"
   },
@@ -531,9 +528,6 @@
   {
    "name" : "_ZN7android6Looper14removeMessagesERKNS_2spINS_14MessageHandlerEEEi"
   },
-  {
-   "name" : "_ZN7android6Looper16threadDestructorEPv"
-  },
   {
    "name" : "_ZN7android6Looper17sendMessageAtTimeExRKNS_2spINS_14MessageHandlerEEERKNS_7MessageE"
   },
@@ -6949,13 +6943,6 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
-  {
-   "access" : "private",
-   "function_name" : "android::Looper::initTLSKey",
-   "linker_set_key" : "_ZN7android6Looper10initTLSKeyEv",
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Looper.h"
-  },
   {
    "function_name" : "android::Looper::sendMessage",
    "linker_set_key" : "_ZN7android6Looper11sendMessageERKNS_2spINS_14MessageHandlerEEERKNS_7MessageE",
@@ -7028,19 +7015,6 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
-  {
-   "access" : "private",
-   "function_name" : "android::Looper::threadDestructor",
-   "linker_set_key" : "_ZN7android6Looper16threadDestructorEPv",
-   "parameters" :
-   [
-    {
-     "referenced_type" : "_ZTIPv"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Looper.h"
-  },
   {
    "function_name" : "android::Looper::sendMessageAtTime",
    "linker_set_key" : "_ZN7android6Looper17sendMessageAtTimeExRKNS_2spINS_14MessageHandlerEEERKNS_7MessageE",
diff --git a/libutils/include/utils/Looper.h b/libutils/include/utils/Looper.h
index 41c5536f4d33..a02280b13b4b 100644
--- a/libutils/include/utils/Looper.h
+++ b/libutils/include/utils/Looper.h
@@ -499,8 +499,6 @@ class Looper : public RefBase {
     void rebuildEpollLocked();
     void scheduleEpollRebuildLocked();
 
-    static void initTLSKey();
-    static void threadDestructor(void *st);
     static void initEpollEvent(struct epoll_event* eventItem);
 };
 

From 1bbf8f042f7ffb4a38657ccf6dca0798931fecd5 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Fri, 21 Jun 2024 10:53:53 -0700
Subject: [PATCH 0986/1487] libsnapshot: Check if the vendor is updated from
 Android S for GRF

In a GRF config, if Vendor partition is updated from Android 12; post
OTA reboot, first stage init will communicate to daemon to check if the
daemon can support socket handoff. If that succeeds, then it is a signal
that the vendor has been updated from Android 12. Use a marker in
/metadata to signal that the vendor was updated. If the marker is present,
then post OTA reboot, userspace snapshot will be used.

Bug: 333854394
Test: OTA
Android U (system) + S (vendor) -> Android V (system) + V (Vendor)

Change-Id: Ie38c4379010789a84e5b44529b407f9f82135271
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../include/libsnapshot/snapshot.h            |  4 +++
 fs_mgr/libsnapshot/snapshot.cpp               | 32 ++++++++++++++++++-
 init/first_stage_mount.cpp                    |  7 +---
 init/snapuserd_transition.cpp                 |  4 +++
 4 files changed, 40 insertions(+), 7 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index 6d422c6141b9..1ec863444480 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -335,6 +335,9 @@ class SnapshotManager final : public ISnapshotManager {
     // after loading selinux policy.
     bool PrepareSnapuserdArgsForSelinux(std::vector<std::string>* snapuserd_argv);
 
+    // If snapuserd from first stage init was started from system partition.
+    bool MarkSnapuserdFromSystem();
+
     // Detach dm-user devices from the first stage snapuserd. Load
     // new dm-user tables after loading selinux policy.
     bool DetachFirstStageSnapuserdForSelinux();
@@ -670,6 +673,7 @@ class SnapshotManager final : public ISnapshotManager {
     std::string GetForwardMergeIndicatorPath();
     std::string GetOldPartitionMetadataPath();
     std::string GetBootSnapshotsWithoutSlotSwitchPath();
+    std::string GetSnapuserdFromSystemPath();
 
     const LpMetadata* ReadOldPartitionMetadata(LockedFile* lock);
 
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index c01360e0ba2c..3a474d710c12 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -88,6 +88,7 @@ static constexpr char kBootSnapshotsWithoutSlotSwitch[] =
         "/metadata/ota/snapshot-boot-without-slot-switch";
 static constexpr char kBootIndicatorPath[] = "/metadata/ota/snapshot-boot";
 static constexpr char kRollbackIndicatorPath[] = "/metadata/ota/rollback-indicator";
+static constexpr char kSnapuserdFromSystem[] = "/metadata/ota/snapuserd-from-system";
 static constexpr auto kUpdateStateCheckInterval = 2s;
 /*
  * The readahead size is set to 32kb so that
@@ -318,7 +319,7 @@ bool SnapshotManager::RemoveAllUpdateState(LockedFile* lock, const std::function
     std::vector<std::string> files = {
             GetSnapshotBootIndicatorPath(),          GetRollbackIndicatorPath(),
             GetForwardMergeIndicatorPath(),          GetOldPartitionMetadataPath(),
-            GetBootSnapshotsWithoutSlotSwitchPath(),
+            GetBootSnapshotsWithoutSlotSwitchPath(), GetSnapuserdFromSystemPath(),
     };
     for (const auto& file : files) {
         RemoveFileIfExists(file);
@@ -1457,6 +1458,10 @@ std::string SnapshotManager::GetRollbackIndicatorPath() {
     return metadata_dir_ + "/" + android::base::Basename(kRollbackIndicatorPath);
 }
 
+std::string SnapshotManager::GetSnapuserdFromSystemPath() {
+    return metadata_dir_ + "/" + android::base::Basename(kSnapuserdFromSystem);
+}
+
 std::string SnapshotManager::GetForwardMergeIndicatorPath() {
     return metadata_dir_ + "/allow-forward-merge";
 }
@@ -2122,6 +2127,16 @@ bool SnapshotManager::UpdateUsesODirect(LockedFile* lock) {
     return update_status.o_direct();
 }
 
+bool SnapshotManager::MarkSnapuserdFromSystem() {
+    auto path = GetSnapuserdFromSystemPath();
+
+    if (!android::base::WriteStringToFile("1", path)) {
+        PLOG(ERROR) << "Unable to write to vendor update path: " << path;
+        return false;
+    }
+    return true;
+}
+
 /*
  * Please see b/304829384 for more details.
  *
@@ -2158,11 +2173,26 @@ bool SnapshotManager::UpdateUsesODirect(LockedFile* lock) {
  *         iii: If both (i) and (ii) are true, then use the dm-snapshot based
  *         approach.
  *
+ * 3: Post OTA reboot, if the vendor partition was updated from Android 12 to
+ * any other release post Android 12, then snapuserd binary will be "system"
+ * partition as post Android 12, init_boot will contain a copy of snapuserd
+ * binary. Thus, during first stage init, if init is able to communicate to
+ * daemon, that gives us a signal that the binary is from "system" copy. Hence,
+ * there is no need to fallback to legacy dm-snapshot. Thus, init will use a
+ * marker in /metadata to signal that the snapuserd binary from first stage init
+ * can handle userspace snapshots.
+ *
  */
 bool SnapshotManager::IsLegacySnapuserdPostReboot() {
     if (is_legacy_snapuserd_.has_value() && is_legacy_snapuserd_.value() == true) {
         auto slot = GetCurrentSlot();
         if (slot == Slot::Target) {
+            // If this marker is present, then daemon can handle userspace
+            // snapshots; also, it indicates that the vendor partition was
+            // updated from Android 12.
+            if (access(GetSnapuserdFromSystemPath().c_str(), F_OK) == 0) {
+                return false;
+            }
             return true;
         }
     }
diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index 5d3a2735489f..55cce6eaabbe 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -395,12 +395,7 @@ bool FirstStageMountVBootV2::CreateSnapshotPartitions(SnapshotManager* sm) {
 
     use_snapuserd_ = sm->IsSnapuserdRequired();
     if (use_snapuserd_) {
-        if (sm->UpdateUsesUserSnapshots()) {
-            LaunchFirstStageSnapuserd();
-        } else {
-            LOG(FATAL) << "legacy virtual-ab is no longer supported";
-            return false;
-        }
+        LaunchFirstStageSnapuserd();
     }
 
     sm->SetUeventRegenCallback([this](const std::string& device) -> bool {
diff --git a/init/snapuserd_transition.cpp b/init/snapuserd_transition.cpp
index 9e3ff4175e08..2370bc2050ef 100644
--- a/init/snapuserd_transition.cpp
+++ b/init/snapuserd_transition.cpp
@@ -100,6 +100,10 @@ void LaunchFirstStageSnapuserd() {
     }
     if (client->SupportsSecondStageSocketHandoff()) {
         setenv(kSnapuserdFirstStageInfoVar, "socket", 1);
+        auto sm = SnapshotManager::NewForFirstStageMount();
+        if (!sm->MarkSnapuserdFromSystem()) {
+            LOG(ERROR) << "Failed to update MarkSnapuserdFromSystem";
+        }
     }
 
     setenv(kSnapuserdFirstStagePidVar, std::to_string(pid).c_str(), 1);

From ab772110c74ec77e59c593fe7e3b3836fbdd164d Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 1 Jul 2024 13:21:36 +0000
Subject: [PATCH 0987/1487] Insulate against log spam.

We may as well check the entire log. The previous bump seems to have made this test less flaky, so why not go all the way?

Change-Id: I26b7524731ec755b724b9363fc9151f6a6d9116d
---
 libutils/CallStack_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libutils/CallStack_test.cpp b/libutils/CallStack_test.cpp
index bfe6b8798019..5ed3c27e8ef2 100644
--- a/libutils/CallStack_test.cpp
+++ b/libutils/CallStack_test.cpp
@@ -73,7 +73,7 @@ TEST(CallStackTest, log_stack) {
     android::CallStack::logStack("callstack_test");
     auto logger_list = android_logger_list_open(android_name_to_log_id("main"),
                                                 ANDROID_LOG_NONBLOCK,
-                                                10000 /* tail */, getpid());
+                                                INT_MAX /* tail */, getpid());
     ASSERT_NE(nullptr, logger_list);
     std::string log;
     while (true) {

From ef0f5bbcf117f7abf5b2c671568fb23b7200f41f Mon Sep 17 00:00:00 2001
From: Ted Bauer <tedbauer@google.com>
Date: Tue, 2 Jul 2024 14:42:44 +0000
Subject: [PATCH 0988/1487] Skip test that unmounts/remounts metadata partition

Aconfig flagging is migrating to a new storage backend that makes heavy
use of the /metadata partition. It is causing failures in tests like
vts_libsnapshot_test, which unmount and remount this partition. The
failed unmounts are due to the partition being busy.

The test should be reworked to not unmount and remount the partition;
linked bug in GSKIP_TEST for followup.

Bug: 349807180
Bug: 350715463
Test: m vts_libsnapshot_test
Change-Id: Ie4f8cadcad189b13b9eba1eb15c5251002e8138a
---
 fs_mgr/libsnapshot/snapshot_test.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 3299ec5c9e12..1435b12bf545 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -1978,6 +1978,8 @@ TEST_F(MetadataMountedTest, Android) {
 }
 
 TEST_F(MetadataMountedTest, Recovery) {
+    GTEST_SKIP() << "b/350715463";
+
     test_device->set_recovery(true);
     metadata_dir_ = test_device->GetMetadataDir();
 

From dcc81d427a9cfcb7560b4ba590ace3348b314860 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 2 Jul 2024 10:57:23 -0700
Subject: [PATCH 0989/1487] Make snapuserd recovery_available.

Bug: 349287459
Test: adb reboot recovery
      adb root
      adb shell ls -l /system/bin/snapuserd
Change-Id: I69a3f8d2fd2d7dc157d14a0f743650881eec473d
---
 fs_mgr/libsnapshot/snapuserd/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index d83524a18ac0..b3a7e8cf1eb4 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -166,6 +166,7 @@ cc_binary {
     ],
     ramdisk_available: false,
     vendor_ramdisk_available: true,
+    recovery_available: true,
 }
 
 // This target will install to /system/bin/snapuserd_ramdisk

From 0bdd68bb065cc168a262aae3b701ecb7335c6c52 Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Wed, 3 Jul 2024 18:41:05 +0900
Subject: [PATCH 0990/1487] Use no_full_install: true instead of installable:
 false

This is a follow-up on I37380c19232f2c497bdf492a83cdc16616f0ae8d.

Bug: 338160898
Bug: 345110999
Test: Microdroid boots even with BOARD_USES_RECOVERY_AS_BOOT
Change-Id: I41c1e40aeaffd5499fb6bd25e80b5be83470bc6b
---
 init/Android.bp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index 7b7a856e91ee..c70a5deaa678 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -338,7 +338,7 @@ soong_config_module_type {
     module_type: "cc_defaults",
     config_namespace: "ANDROID",
     bool_variables: ["BOARD_USES_RECOVERY_AS_BOOT"],
-    properties: ["installable"],
+    properties: ["no_full_install"],
 }
 
 // Do not install init_first_stage even with mma if we're system-as-root.
@@ -347,7 +347,7 @@ init_first_stage_cc_defaults {
     name: "init_first_stage_defaults",
     soong_config_variables: {
         BOARD_USES_RECOVERY_AS_BOOT: {
-            installable: false,
+            no_full_install: true,
         },
     },
 

From d9d7f7a8c3fe8e20bf32419fa3939c0cbfce283b Mon Sep 17 00:00:00 2001
From: Hans Boehm <hboehm@google.com>
Date: Wed, 3 Jul 2024 17:33:08 -0700
Subject: [PATCH 0991/1487] Make timeout messages distinct

... so that we can confirm that it's actually the poll() call that's
timing out.

Bug: 332593241
Test: Treehugger
Change-Id: I529be76a268d7ba1f7f26a953eb84945f3ac4924
---
 debuggerd/client/debuggerd_client.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/debuggerd/client/debuggerd_client.cpp b/debuggerd/client/debuggerd_client.cpp
index af1bb8181f4b..632f6f1c9024 100644
--- a/debuggerd/client/debuggerd_client.cpp
+++ b/debuggerd/client/debuggerd_client.cpp
@@ -138,7 +138,7 @@ bool debuggerd_trigger_dump(pid_t tid, DebuggerdDumpType dump_type, unsigned int
 
     auto remaining = end - std::chrono::steady_clock::now();
     if (remaining < decltype(remaining)::zero()) {
-      log_error(output_fd, 0, "timeout expired");
+      log_error(output_fd, 0, "timeout expired (update_timeout)");
       return false;
     }
 
@@ -254,7 +254,7 @@ bool debuggerd_trigger_dump(pid_t tid, DebuggerdDumpType dump_type, unsigned int
     if (timeout_ms <= 0) {
       remaining_ms = -1;
     } else if (remaining_ms < 0) {
-      log_error(output_fd, 0, "timeout expired");
+      log_error(output_fd, 0, "timeout expired before poll");
       return false;
     }
 
@@ -271,7 +271,7 @@ bool debuggerd_trigger_dump(pid_t tid, DebuggerdDumpType dump_type, unsigned int
         return false;
       }
     } else if (rc == 0) {
-      log_error(output_fd, 0, "timeout expired");
+      log_error(output_fd, 0, "poll timeout expired");
       return false;
     }
 

From e3a3d903aa0d724de5bce81d84d876798f801a0b Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 2 Jul 2024 10:57:23 -0700
Subject: [PATCH 0992/1487] Make snapuserd recovery_available.

Bug: 349287459
Test: adb reboot recovery
      adb root
      adb shell ls -l /system/bin/snapuserd
(cherry picked from https://android-review.googlesource.com/q/commit:dcc81d427a9cfcb7560b4ba590ace3348b314860)
Merged-In: I69a3f8d2fd2d7dc157d14a0f743650881eec473d
Change-Id: I69a3f8d2fd2d7dc157d14a0f743650881eec473d
---
 fs_mgr/libsnapshot/snapuserd/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 649309de1d67..eb5443c1c601 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -166,6 +166,7 @@ cc_binary {
     ],
     ramdisk_available: false,
     vendor_ramdisk_available: true,
+    recovery_available: true,
 }
 
 // This target will install to /system/bin/snapuserd_ramdisk 

From 8896d29c5f9292681fd9f068ccfe3df76ae99c0e Mon Sep 17 00:00:00 2001
From: Owner Cleanup Bot
 <swarming-tasks@owners-cleanup-prod.google.com.iam.gserviceaccount.com>
Date: Tue, 9 Jul 2024 21:12:29 +0000
Subject: [PATCH 0993/1487] Remove alanstokes@google.com from
 mini_keyctl/OWNERS

This suggested change is automatically generated based on group
memberships and affiliations.
If this change is unnecessary or in error, vote the lowest CR value
(i.e. reject the CL) and the bot will abandon it. Vote the highest CR to
approve this change. You may also abandon this change.

See the owner's recent activity for context:
https://android-review.googlesource.com/q/alanstokes@google.com

To report an issue, file a bug in the Infra>Codereview component.

Change-Id: I1b8637979a8206e6f8d1e56a7a9a4c84b7896739
---
 mini_keyctl/OWNERS | 1 -
 1 file changed, 1 deletion(-)

diff --git a/mini_keyctl/OWNERS b/mini_keyctl/OWNERS
index f9e7b25eaed9..1f2485a0c40c 100644
--- a/mini_keyctl/OWNERS
+++ b/mini_keyctl/OWNERS
@@ -1,4 +1,3 @@
-alanstokes@google.com
 ebiggers@google.com
 jeffv@google.com
 jiyong@google.com

From 453665b5f567b0042aa47fb658142693a26130c6 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 10 Jul 2024 00:28:03 -0700
Subject: [PATCH 0994/1487] snapuserd_test: Create dup of fd before passing it
 to cow writer

Bug: 352085551
Test: snapuserd_test - atest 10 iterations passed
Change-Id: I25549e546cb3ce234fcf92533effb124793f1953
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../user-space-merge/snapuserd_test.cpp          | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 56f7b5911012..6d0ae3d0988f 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -79,6 +79,8 @@ class SnapuserdTestBase : public ::testing::TestWithParam<TestParam> {
     std::unique_ptr<ICowWriter> CreateCowDeviceInternal();
     std::unique_ptr<ICowWriter> CreateV3Cow();
 
+    unique_fd GetCowFd() { return unique_fd{dup(cow_system_->fd)}; }
+
     std::unique_ptr<ITestHarness> harness_;
     size_t size_ = 10_MiB;
     int total_base_size_ = 0;
@@ -101,7 +103,9 @@ void SnapuserdTestBase::SetUp() {
 #endif
 }
 
-void SnapuserdTestBase::TearDown() {}
+void SnapuserdTestBase::TearDown() {
+    cow_system_ = nullptr;
+}
 
 void SnapuserdTestBase::CreateBaseDevice() {
     total_base_size_ = (size_ * 5);
@@ -132,10 +136,7 @@ std::unique_ptr<ICowWriter> SnapuserdTestBase::CreateCowDeviceInternal() {
     CowOptions options;
     options.compression = "gz";
 
-    unique_fd fd(cow_system_->fd);
-    cow_system_->fd = -1;
-
-    return CreateCowWriter(2, options, std::move(fd));
+    return CreateCowWriter(2, options, GetCowFd());
 }
 
 std::unique_ptr<ICowWriter> SnapuserdTestBase::CreateV3Cow() {
@@ -151,10 +152,7 @@ std::unique_ptr<ICowWriter> SnapuserdTestBase::CreateV3Cow() {
     std::string path = android::base::GetExecutableDirectory();
     cow_system_ = std::make_unique<TemporaryFile>(path);
 
-    unique_fd fd(cow_system_->fd);
-    cow_system_->fd = -1;
-
-    return CreateCowWriter(3, options, std::move(fd));
+    return CreateCowWriter(3, options, GetCowFd());
 }
 
 void SnapuserdTestBase::CreateCowDevice() {

From 0fb39f6e698d99157b2ce640a4bacd4479c0cf11 Mon Sep 17 00:00:00 2001
From: Tiffany Yang <ynaffit@google.com>
Date: Tue, 21 May 2024 16:43:35 -0700
Subject: [PATCH 0995/1487] init: Support for initializing virtio-console
 devices

This change allows init to ensure that a specified virtio-console
device file (`/dev/hvc*`) is available before `ueventd` coldboot.
Times out if device path is not encountered within 10 seconds.

Bug: 325538592
Test: build bertha_x86_64 and bertha_arm64
Change-Id: Ia1512e69ea607bf4d235595caa53668e2dac500c
---
 init/block_dev_initializer.cpp | 4 ++++
 init/block_dev_initializer.h   | 1 +
 2 files changed, 5 insertions(+)

diff --git a/init/block_dev_initializer.cpp b/init/block_dev_initializer.cpp
index a686d05131c7..8f5215856544 100644
--- a/init/block_dev_initializer.cpp
+++ b/init/block_dev_initializer.cpp
@@ -139,6 +139,10 @@ bool BlockDevInitializer::InitPlatformDevice(const std::string& dev_name) {
     return InitDevice("/sys/devices/platform", dev_name);
 }
 
+bool BlockDevInitializer::InitHvcDevice(const std::string& dev_name) {
+    return InitDevice("/sys/devices/virtual/tty", dev_name);
+}
+
 bool BlockDevInitializer::InitDevice(const std::string& syspath, const std::string& device_name) {
     bool found = false;
 
diff --git a/init/block_dev_initializer.h b/init/block_dev_initializer.h
index d5b1f6006449..cb1d365559a4 100644
--- a/init/block_dev_initializer.h
+++ b/init/block_dev_initializer.h
@@ -34,6 +34,7 @@ class BlockDevInitializer final {
     bool InitDevices(std::set<std::string> devices);
     bool InitDmDevice(const std::string& device);
     bool InitPlatformDevice(const std::string& device);
+    bool InitHvcDevice(const std::string& device);
 
   private:
     ListenerAction HandleUevent(const Uevent& uevent, std::set<std::string>* devices);

From 4d1894abc4e2b33032b0a74c5946f9db6393c24d Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 11 Jul 2024 09:53:23 -0700
Subject: [PATCH 0996/1487] Add debug logs to understand update start delay

Test: th
Bug: 352332753
Change-Id: I7c8f11409dc2a1312813b29a4c523b3fe17833c4
---
 fs_mgr/libsnapshot/snapshot.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 3a474d710c12..4d5531535632 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -2876,6 +2876,7 @@ bool SnapshotManager::UnmapAllSnapshots(LockedFile* lock) {
             return false;
         }
     }
+    LOG(INFO) << "Unmapped " << snapshots.size() << " partitions with snapshots";
 
     // Terminate the daemon and release the snapuserd_client_ object.
     // If we need to re-connect with the daemon, EnsureSnapuserdConnected()

From a3a6c8e0525ffdeeb1b773f0d388bbb84eb2f0a2 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Thu, 11 Jul 2024 23:54:48 +0000
Subject: [PATCH 0997/1487] Remove usage of ATOMIC_VAR_INIT.

The use of the macro ATOMIC_VAR_INIT is not necessary and is causing
warnings about it being deprecated. So remove it.

Test: Compiles without any warnings.
Change-Id: I137ffd0a7cf9a24c2c7ddea5c30f310722f57b98
---
 libcutils/trace-dev.inc  | 6 +++---
 libcutils/trace-host.cpp | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/libcutils/trace-dev.inc b/libcutils/trace-dev.inc
index 94945ec7d4f3..3bc6dc343ce4 100644
--- a/libcutils/trace-dev.inc
+++ b/libcutils/trace-dev.inc
@@ -49,17 +49,17 @@
 
 constexpr uint32_t kSeqNoNotInit = static_cast<uint32_t>(-1);
 
-atomic_bool              atrace_is_ready      = ATOMIC_VAR_INIT(false);
+atomic_bool              atrace_is_ready      = false;
 int                      atrace_marker_fd     = -1;
 uint64_t                 atrace_enabled_tags  = ATRACE_TAG_NOT_READY;
-static atomic_bool       atrace_is_enabled    = ATOMIC_VAR_INIT(true);
+static atomic_bool       atrace_is_enabled    = true;
 static pthread_mutex_t   atrace_tags_mutex    = PTHREAD_MUTEX_INITIALIZER;
 
 /**
  * Sequence number of debug.atrace.tags.enableflags the last time the enabled
  * tags were reloaded.
  **/
-static _Atomic(uint32_t) last_sequence_number = ATOMIC_VAR_INIT(kSeqNoNotInit);
+static _Atomic(uint32_t) last_sequence_number = kSeqNoNotInit;
 
 #if defined(__BIONIC__)
 // All zero prop_info that has a sequence number of 0. This is easier than
diff --git a/libcutils/trace-host.cpp b/libcutils/trace-host.cpp
index 2bf57ebbefb2..c45d0675c292 100644
--- a/libcutils/trace-host.cpp
+++ b/libcutils/trace-host.cpp
@@ -16,7 +16,7 @@
 
 #include <cutils/trace.h>
 
-atomic_bool             atrace_is_ready      = ATOMIC_VAR_INIT(true);
+atomic_bool             atrace_is_ready      = true;
 int                     atrace_marker_fd     = -1;
 uint64_t                atrace_enabled_tags  = 0;
 

From 22a683c7aa8648fdc66503ae68c8e3e22d7d26aa Mon Sep 17 00:00:00 2001
From: Ahmad Chaudhry <ahmadc@nvidia.com>
Date: Fri, 5 Jul 2024 05:12:21 +0000
Subject: [PATCH 0998/1487] fs_mgr: libfstab: allow recovery.fstab with suffix

Some platforms may need different fstab configs.
Accordingly, allow recovery init to select
a recovery.fstab with a suffix provided through
bootconfigs or cmdline during runtime,
to make a single recovery.img work on different
environments.

Change-Id: I0c2f61ffe9ddeb03afc54d8acc43b4917d65b846
---
 fs_mgr/libfstab/fstab.cpp | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index f00e0dc2616e..21d2e2ef37f0 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -520,6 +520,24 @@ std::vector<FstabPtrEntryType*> GetEntriesByPred(FstabPtr fstab, const Pred& pre
 
 }  // namespace
 
+// Return the path to the recovery fstab file.  There may be multiple fstab files;
+// the one that is returned will be the first that exists of recovery.fstab.<fstab_suffix>,
+// recovery.fstab.<hardware>, and recovery.fstab.<hardware.platform>.
+std::string GetRecoveryFstabPath() {
+    for (const char* prop : {"fstab_suffix", "hardware", "hardware.platform"}) {
+        std::string suffix;
+
+        if (!fs_mgr_get_boot_config(prop, &suffix)) continue;
+
+        std::string fstab_path = "/etc/recovery.fstab." + suffix;
+        if (access(fstab_path.c_str(), F_OK) == 0) {
+            return fstab_path;
+        }
+    }
+
+    return "/etc/recovery.fstab";
+}
+
 // Return the path to the fstab file.  There may be multiple fstab files; the
 // one that is returned will be the first that exists of fstab.<fstab_suffix>,
 // fstab.<hardware>, and fstab.<hardware.platform>.  The fstab is searched for
@@ -529,7 +547,7 @@ std::vector<FstabPtrEntryType*> GetEntriesByPred(FstabPtr fstab, const Pred& pre
 // the system/etc directory is supported too and is the preferred location.
 std::string GetFstabPath() {
     if (InRecovery()) {
-        return "/etc/recovery.fstab";
+        return GetRecoveryFstabPath();
     }
     for (const char* prop : {"fstab_suffix", "hardware", "hardware.platform"}) {
         std::string suffix;

From 2c2f3294b7f98c2715c56eb8c21c6b586bddbb09 Mon Sep 17 00:00:00 2001
From: Nelson Li <nelsonli@google.com>
Date: Thu, 11 Jul 2024 14:13:02 +0800
Subject: [PATCH 0999/1487] Convert *-developer-gsi.avbpubkey to Android.bp

Use `soong_config_module_type` to install `*-developer-gsi.avbpubkey`
to either `ramdisk` or `vendor_ramdisk` based on the value of
`BOARD_MOVE_GSI_AVB_KEYS_TO_VENDOR_BOOT` in each device.

In build/soong/android/paths.go's modulePartition() function, there is
already logic to construct `vendor_ramdisk` and `ramdisk` partitions
based on the different values of
`BOARD_MOVE_RECOVERY_RESOURCES_TO_VENDOR_BOOT` and
`BOARD_USES_RECOVERY_AS_BOOT`. And the logic is identical to the
original Android.mk.

Therefore, this change only needs to determine whether the avb public
keys should be placed in `vendor_ramdisk` or `ramdisk` based on the
value of `BOARD_MOVE_GSI_AVB_KEYS_TO_VENDOR_BOOT`. The rest of the
judgment logic can be ignored.

Bug: 347636127
Test: 1) lunch aosp_cf_x86_64_phone && m q-developer-gsi.avbpubkey
      2) check it installed to vendor_ramdisk/first_stage_ramdisk/avb/
      3) lunch yukawa && m q-developer-gsi.avbpubkey
      4) check it installed to ramdisk/avb/q-developer-gsi.avbpubkey
Change-Id: I6de1a038261f2feeae4504d8097c7392b166848d
---
 rootdir/avb/Android.bp | 71 ++++++++++++++++++++++++++++++++++++++++++
 rootdir/avb/Android.mk | 56 ---------------------------------
 2 files changed, 71 insertions(+), 56 deletions(-)
 create mode 100644 rootdir/avb/Android.bp
 delete mode 100644 rootdir/avb/Android.mk

diff --git a/rootdir/avb/Android.bp b/rootdir/avb/Android.bp
new file mode 100644
index 000000000000..a584e3e590f5
--- /dev/null
+++ b/rootdir/avb/Android.bp
@@ -0,0 +1,71 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+soong_config_module_type {
+    name: "avb_keys_prebuilt_avb",
+    module_type: "prebuilt_avb",
+    config_namespace: "ANDROID",
+    bool_variables: [
+        "BOARD_MOVE_GSI_AVB_KEYS_TO_VENDOR_BOOT",
+    ],
+    properties: [
+        "ramdisk",
+        "vendor_ramdisk",
+    ],
+}
+
+avb_keys_prebuilt_avb {
+    name: "q-developer-gsi.avbpubkey",
+    src: "q-developer-gsi.avbpubkey",
+    soong_config_variables: {
+        BOARD_MOVE_GSI_AVB_KEYS_TO_VENDOR_BOOT: {
+            ramdisk: false,
+            vendor_ramdisk: true,
+            conditions_default: {
+                ramdisk: true,
+                vendor_ramdisk: false,
+            },
+        },
+    },
+}
+
+avb_keys_prebuilt_avb {
+    name: "r-developer-gsi.avbpubkey",
+    src: "r-developer-gsi.avbpubkey",
+    soong_config_variables: {
+        BOARD_MOVE_GSI_AVB_KEYS_TO_VENDOR_BOOT: {
+            ramdisk: false,
+            vendor_ramdisk: true,
+            conditions_default: {
+                ramdisk: true,
+                vendor_ramdisk: false,
+            },
+        },
+    },
+}
+
+avb_keys_prebuilt_avb {
+    name: "s-developer-gsi.avbpubkey",
+    src: "s-developer-gsi.avbpubkey",
+    soong_config_variables: {
+        BOARD_MOVE_GSI_AVB_KEYS_TO_VENDOR_BOOT: {
+            ramdisk: false,
+            vendor_ramdisk: true,
+            conditions_default: {
+                ramdisk: true,
+                vendor_ramdisk: false,
+            },
+        },
+    },
+}
diff --git a/rootdir/avb/Android.mk b/rootdir/avb/Android.mk
deleted file mode 100644
index 8cf317231d41..000000000000
--- a/rootdir/avb/Android.mk
+++ /dev/null
@@ -1,56 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-
-ifeq ($(BOARD_MOVE_GSI_AVB_KEYS_TO_VENDOR_BOOT),true) # AVB keys are installed to vendor ramdisk
-  ifeq ($(BOARD_MOVE_RECOVERY_RESOURCES_TO_VENDOR_BOOT),true) # no dedicated recovery partition
-    my_gsi_avb_keys_path := $(TARGET_VENDOR_RAMDISK_OUT)/first_stage_ramdisk/avb
-  else # device has a dedicated recovery partition
-    my_gsi_avb_keys_path := $(TARGET_VENDOR_RAMDISK_OUT)/avb
-  endif
-else
-  ifeq ($(BOARD_USES_RECOVERY_AS_BOOT),true) # no dedicated recovery partition
-    my_gsi_avb_keys_path := $(TARGET_RECOVERY_ROOT_OUT)/first_stage_ramdisk/avb
-  else # device has a dedicated recovery partition
-    my_gsi_avb_keys_path := $(TARGET_RAMDISK_OUT)/avb
-  endif
-endif
-
-#######################################
-# q-developer-gsi.avbpubkey
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := q-developer-gsi.avbpubkey
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_MODULE_CLASS := ETC
-LOCAL_SRC_FILES := $(LOCAL_MODULE)
-LOCAL_MODULE_PATH := $(my_gsi_avb_keys_path)
-
-include $(BUILD_PREBUILT)
-
-#######################################
-# r-developer-gsi.avbpubkey
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := r-developer-gsi.avbpubkey
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_MODULE_CLASS := ETC
-LOCAL_SRC_FILES := $(LOCAL_MODULE)
-LOCAL_MODULE_PATH := $(my_gsi_avb_keys_path)
-
-include $(BUILD_PREBUILT)
-
-#######################################
-# s-developer-gsi.avbpubkey
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := s-developer-gsi.avbpubkey
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_MODULE_CLASS := ETC
-LOCAL_SRC_FILES := $(LOCAL_MODULE)
-LOCAL_MODULE_PATH := $(my_gsi_avb_keys_path)
-
-include $(BUILD_PREBUILT)
-
-my_gsi_avb_keys_path :=

From b335f4d4bee8607e177dd664af5835e837b0ea53 Mon Sep 17 00:00:00 2001
From: Nelson Li <nelsonli@google.com>
Date: Wed, 17 Jul 2024 10:16:39 +0800
Subject: [PATCH 1000/1487] Convert `asan.options` and `asan_extract` to
 Android.bp

In the original Android.mk, `asan.option` is only enabled when
"address" is present in SANITIZE_TARGET.
`asan_extract` is only enabled when `SANITIZE_TARGET_SYSTEM` is `true`
and `address` is present in SANITIZE_TARGET.

However, in the normal build system design, a module should `not`
decide when it should be enabled.
Therefore, the `ifeq` condition should be directly removed during
conversion.

The correct approach is:
Wait until converting `init.environ.rc`, then use `select` or similar
methods to determine whether it should use `asan.option` or
`asan_extract`.

Bug: 353164536
Test: SANITIZE_TARGET=address m init.environ.rc
      SANITIZE_TARGET_SYSTEM=true SANITIZE_TARGET=address m init.environ.rc
Change-Id: I69af3199536a3ba9f54dcfa198295826303e2d22
---
 rootdir/Android.bp | 15 ++++++++++++++-
 rootdir/Android.mk | 27 ---------------------------
 2 files changed, 14 insertions(+), 28 deletions(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index e8f7627f9162..7105ed52a8ba 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -114,10 +114,23 @@ prebuilt_etc {
     sub_dir: "init",
 }
 
+prebuilt_etc {
+    name: "asan.options",
+    src: "asan.options",
+}
+
+sh_binary {
+    name: "asan_extract",
+    src: "asan_extract.sh",
+    init_rc: ["asan_extract.rc"],
+    // We need bzip2 on device for extraction.
+    required: ["bzip2"],
+}
+
 llndk_libraries_txt {
     name: "llndk.libraries.txt",
 }
 
 sanitizer_libraries_txt {
     name: "sanitizer.libraries.txt",
-}
\ No newline at end of file
+}
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index 4c1f2e4f89b2..e6ccda788a1c 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -3,39 +3,12 @@ LOCAL_PATH:= $(call my-dir)
 $(eval $(call declare-1p-copy-files,system/core/rootdir,))
 
 #######################################
-# asan.options
 ifneq ($(filter address,$(SANITIZE_TARGET)),)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := asan.options
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_MODULE_CLASS := ETC
-LOCAL_SRC_FILES := $(LOCAL_MODULE)
-LOCAL_MODULE_PATH := $(TARGET_OUT)
-
-include $(BUILD_PREBUILT)
-
-# ASAN extration.
 ASAN_EXTRACT_FILES :=
 ifeq ($(SANITIZE_TARGET_SYSTEM),true)
-include $(CLEAR_VARS)
-LOCAL_MODULE:= asan_extract
-LOCAL_LICENSE_KINDS:= SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS:= notice
-LOCAL_MODULE_TAGS := optional
-LOCAL_MODULE_CLASS := EXECUTABLES
-LOCAL_SRC_FILES := asan_extract.sh
-LOCAL_INIT_RC := asan_extract.rc
-# We need bzip2 on device for extraction.
-LOCAL_REQUIRED_MODULES := bzip2
-include $(BUILD_PREBUILT)
 ASAN_EXTRACT_FILES := asan_extract
 endif
-
 endif
-
 #######################################
 # init.environ.rc
 

From 1315ca7b06b76ac50538c7444e7b2acb0b02f807 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Wed, 17 Jul 2024 14:48:57 -0700
Subject: [PATCH 1001/1487] Log lock time if it takes too long

Test: th
Bug: 352332753
Change-Id: Ie7397f7027a597cebb33206a6df845918bc3dab5
---
 fs_mgr/libsnapshot/snapshot.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 4d5531535632..32f6d8913375 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -21,6 +21,7 @@
 #include <sys/types.h>
 #include <sys/unistd.h>
 
+#include <chrono>
 #include <filesystem>
 #include <optional>
 #include <thread>
@@ -2892,6 +2893,7 @@ bool SnapshotManager::UnmapAllSnapshots(LockedFile* lock) {
 
 auto SnapshotManager::OpenFile(const std::string& file,
                                int lock_flags) -> std::unique_ptr<LockedFile> {
+    const auto start = std::chrono::system_clock::now();
     unique_fd fd(open(file.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW));
     if (fd < 0) {
         PLOG(ERROR) << "Open failed: " << file;
@@ -2904,6 +2906,11 @@ auto SnapshotManager::OpenFile(const std::string& file,
     // For simplicity, we want to CHECK that lock_mode == LOCK_EX, in some
     // calls, so strip extra flags.
     int lock_mode = lock_flags & (LOCK_EX | LOCK_SH);
+    const auto end = std::chrono::system_clock::now();
+    const auto duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+    if (duration_ms >= 1000ms) {
+        LOG(INFO) << "Taking lock on " << file << " took " << duration_ms.count() << "ms";
+    }
     return std::make_unique<LockedFile>(file, std::move(fd), lock_mode);
 }
 

From 9c77e66d56fe20c8763d007bd0722147816636b6 Mon Sep 17 00:00:00 2001
From: Mike McTernan <mikemcternan@google.com>
Date: Fri, 12 Jul 2024 20:40:53 +0100
Subject: [PATCH 1002/1487] storageproxy: set a property when secure storage
 becomes rw

Bug: 350362101
Test: ABTD
Change-Id: I877a62e5c6337f31ffe63a4fd3cdeb54b69a8ae6
---
 trusty/storage/proxy/storage.c | 38 +++++++++++++++++++++++++++-------
 1 file changed, 31 insertions(+), 7 deletions(-)

diff --git a/trusty/storage/proxy/storage.c b/trusty/storage/proxy/storage.c
index 6d0c616715c1..ca39f6aabc0e 100644
--- a/trusty/storage/proxy/storage.c
+++ b/trusty/storage/proxy/storage.c
@@ -55,7 +55,7 @@ static const char *ssdir_name;
 static struct storage_mapping_node* storage_mapping_head;
 
 /*
- * Property set to 1 after we have opened a file under ssdir_name. The backing
+ * Properties set to 1 after we have opened a file under ssdir_name. The backing
  * files for both TD and TDP are currently located under /data/vendor/ss and can
  * only be opened once userdata is mounted. This storageproxyd service is
  * restarted when userdata is available, which causes the Trusty storage service
@@ -64,11 +64,16 @@ static struct storage_mapping_node* storage_mapping_head;
  * ports will be available (although they may block if still being initialized),
  * and connections will not be reset after this point (assuming the
  * storageproxyd service stays running).
+ *
+ * fs_ready - secure storage is read-only (due to checkpointing after upgrade)
+ * fs_ready_rw - secure storage is readable and writable
  */
 #define FS_READY_PROPERTY "ro.vendor.trusty.storage.fs_ready"
+#define FS_READY_RW_PROPERTY "ro.vendor.trusty.storage.fs_ready_rw"
 
 /* has FS_READY_PROPERTY been set? */
-static bool fs_ready_initialized = false;
+static bool fs_ready_set = false;
+static bool fs_ready_rw_set = false;
 
 static enum sync_state fs_state;
 static enum sync_state fd_state[FD_TBL_SIZE];
@@ -80,6 +85,17 @@ static struct {
    uint8_t data[MAX_READ_SIZE];
 }  read_rsp;
 
+static bool property_set_helper(const char* prop) {
+    int rc = property_set(prop, "1");
+    if (rc == 0) {
+        ALOGI("Set property %s\n", prop);
+    } else {
+        ALOGE("Could not set property %s, rc: %d\n", prop, rc);
+    }
+
+    return rc == 0;
+}
+
 static uint32_t insert_fd(int open_flags, int fd, struct storage_mapping_node* node) {
     uint32_t handle = fd;
 
@@ -520,12 +536,20 @@ int storage_file_open(struct storage_msg* msg, const void* r, size_t req_len,
     path = NULL;
 
     /* a backing file has been opened, notify any waiting init steps */
-    if (!fs_ready_initialized) {
-        rc = property_set(FS_READY_PROPERTY, "1");
-        if (rc == 0) {
-            fs_ready_initialized = true;
+    if (!fs_ready_set || !fs_ready_rw_set) {
+        bool is_checkpoint_active = false;
+
+        rc = is_data_checkpoint_active(&is_checkpoint_active);
+        if (rc != 0) {
+            ALOGE("is_data_checkpoint_active() failed (%d)\n", rc);
         } else {
-            ALOGE("Could not set property %s, rc: %d\n", FS_READY_PROPERTY, rc);
+            if (!fs_ready_rw_set && !is_checkpoint_active) {
+                fs_ready_rw_set = property_set_helper(FS_READY_RW_PROPERTY);
+            }
+
+            if (!fs_ready_set) {
+                fs_ready_set = property_set_helper(FS_READY_PROPERTY);
+            }
         }
     }
 

From 47a95af84f59acf66d27fbe61341d32f4c324bc5 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 18 Jul 2024 09:10:56 -0700
Subject: [PATCH 1003/1487] Add debug logs to understand slow update start
 issue

Test: th
Bug: 352332753
Change-Id: I2d8f99217722479dcae2e2ea0f74bbf112725ce2
---
 fs_mgr/libsnapshot/snapshot.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 32f6d8913375..66743789af81 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -2866,10 +2866,12 @@ bool SnapshotManager::UnmapAllSnapshots() {
 }
 
 bool SnapshotManager::UnmapAllSnapshots(LockedFile* lock) {
+    LOG(INFO) << "Lock acquired for " << __FUNCTION__;
     std::vector<std::string> snapshots;
     if (!ListSnapshots(lock, &snapshots)) {
         return false;
     }
+    LOG(INFO) << "Found " << snapshots.size() << " partitions with snapshots";
 
     for (const auto& snapshot : snapshots) {
         if (!UnmapPartitionWithSnapshot(lock, snapshot)) {

From c6dfdbb761da5709b0cb9379ea2a9908775dd2fd Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 11 Jul 2024 10:56:44 -0700
Subject: [PATCH 1004/1487] Set block device as RO/RW before mount

umount is faster if an RO mount is on top of an RO block device.

Test: th
Bug: 349507086
Change-Id: I621cafd5b15c2c4e104ae7678a1bcf2588fe29b6
---
 fs_mgr/fs_mgr.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 5156754a8538..ea2e3a8c754b 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -826,6 +826,9 @@ static int __mount(const std::string& source, const std::string& target, const F
     if (read_only) {
         mountflags |= MS_RDONLY;
     }
+    if (!fs_mgr_set_blk_ro(source, read_only)) {
+        PLOG(ERROR) << "Failed to set " << source << " as " << (read_only ? "RO" : "RW");
+    }
     int ret = 0;
     int save_errno = 0;
     int gc_allowance = 0;
@@ -880,9 +883,6 @@ static int __mount(const std::string& source, const std::string& target, const F
     }
     PINFO << __FUNCTION__ << "(source=" << source << source_missing << ",target=" << target
           << target_missing << ",type=" << entry.fs_type << ")=" << ret;
-    if ((ret == 0) && (mountflags & MS_RDONLY) != 0) {
-        fs_mgr_set_blk_ro(source);
-    }
     if (ret == 0) {
         android::base::SetProperty("ro.boottime.init.mount." + Basename(target),
                                    std::to_string(t.duration().count()));

From b885e4ad533ea4d12e18a0147d298be0cd8cec72 Mon Sep 17 00:00:00 2001
From: Tiffany Yang <ynaffit@google.com>
Date: Wed, 22 May 2024 21:04:38 -0700
Subject: [PATCH 1005/1487] init: Wait for /dev/hvc1 during ARCVM first-stage
 mount

This commit introduces a function to allow ARC-specific logic during
first-stage mount by checking for the existence of an indicator file
at the path "/is_arcvm".

ARC uses the virtio-console device `hvc1` to pass byte data to Android
before second-stage init. Ensure that /dev/hvc1 is initialized before
ARCVM continues booting, but allow other devices to bypass this device
initialization.

Bug: 325538592
Test: boot ARC, ensure /dev/hvc1 can be read during PropertyInit
Change-Id: Ic258b7b004b59da462f4990131a5c11fc94eca62
---
 init/first_stage_mount.cpp | 5 +++++
 init/selinux.cpp           | 2 ++
 init/util.h                | 5 +++++
 3 files changed, 12 insertions(+)

diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index 55cce6eaabbe..927b45f22e4c 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -305,6 +305,11 @@ bool FirstStageMountVBootV2::InitDevices() {
             return false;
         }
     }
+
+    if (IsArcvm() && !block_dev_init_.InitHvcDevice("hvc1")) {
+        return false;
+    }
+
     return true;
 }
 
diff --git a/init/selinux.cpp b/init/selinux.cpp
index c2d9b8d286f6..01af2b64d2dd 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -474,6 +474,8 @@ void SelinuxRestoreContext() {
     RestoreconIfExists(SnapshotManager::GetGlobalRollbackIndicatorPath().c_str(), 0);
     RestoreconIfExists("/metadata/gsi",
                        SELINUX_ANDROID_RESTORECON_RECURSE | SELINUX_ANDROID_RESTORECON_SKIP_SEHASH);
+
+    RestoreconIfExists("/dev/hvc1", 0);
 }
 
 int SelinuxKlogCallback(int type, const char* fmt, ...) {
diff --git a/init/util.h b/init/util.h
index aa24123dfc9f..056539181d99 100644
--- a/init/util.h
+++ b/init/util.h
@@ -18,6 +18,7 @@
 
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <sys/unistd.h>
 
 #include <chrono>
 #include <functional>
@@ -108,6 +109,10 @@ inline constexpr bool IsMicrodroid() {
 #endif
 }
 
+inline bool IsArcvm() {
+    return !access("/is_arcvm", F_OK);
+}
+
 bool Has32BitAbi();
 
 std::string GetApexNameFromFileName(const std::string& path);

From b525463558d4776c12f2e5328987f0131ad1b737 Mon Sep 17 00:00:00 2001
From: Mike McTernan <mikemcternan@google.com>
Date: Thu, 18 Jul 2024 14:42:28 +0100
Subject: [PATCH 1006/1487] init: set a new trigger when a vold checkpoint is
 committed

Add post-fs-data-checkpointed trigger when vold completes checkpointing
after an OTA update.

Bug: 350362101
Test: ABTD
Change-Id: I647a73a942174015b46c5f40bd8f8d3347977ecd
---
 init/README.md  | 8 +++++---
 rootdir/init.rc | 3 +++
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/init/README.md b/init/README.md
index 11c4e1cf3770..0bb26e891d69 100644
--- a/init/README.md
+++ b/init/README.md
@@ -499,9 +499,11 @@ have been omitted.
    4. `late-fs` - Mount partitions marked as latemounted.
    5. `post-fs-data` - Mount and configure `/data`; set up encryption. `/metadata` is
       reformatted here if it couldn't mount in first-stage init.
-   6. `zygote-start` - Start the zygote.
-   7. `early-boot` - After zygote has started.
-   8. `boot` - After `early-boot` actions have completed.
+   6. `post-fs-data-checkpointed` - Triggered when vold has completed committing a checkpoint
+      after an OTA update. Not triggered if checkpointing is not needed or supported.
+   7. `zygote-start` - Start the zygote.
+   8. `early-boot` - After zygote has started.
+   9. `boot` - After `early-boot` actions have completed.
 
 Commands
 --------
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 2443b7cf6dcb..b804c1bde0cf 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1087,6 +1087,9 @@ on post-fs-data
     # Update dm-verity state and set partition.*.verified properties.
     verity_update_state
 
+on property:vold.checkpoint_committed=1
+    trigger post-fs-data-checkpointed
+
 # It is recommended to put unnecessary data/ initialization from post-fs-data
 # to start-zygote in device's init.rc to unblock zygote start.
 on zygote-start

From d959fc72c13bb0154bfcaf52cbd33aefeba61a34 Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Mon, 22 Jul 2024 11:24:03 +0900
Subject: [PATCH 1007/1487] Update visibility according to the change AVF
 directories layout

Bug: 352458998
Test: m nothing
Change-Id: Ibdae7e76a66104cc644b7f82059a2dc5f08659d0
---
 init/Android.bp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/Android.bp b/init/Android.bp
index c70a5deaa678..ffb63806361f 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -330,7 +330,7 @@ cc_binary {
     static_libs: ["libinit.microdroid"],
     cflags: ["-DMICRODROID=1"],
     no_full_install: true,
-    visibility: ["//packages/modules/Virtualization/microdroid"],
+    visibility: ["//packages/modules/Virtualization/build/microdroid"],
 }
 
 soong_config_module_type {

From 4363e8c3a781df3569ed02983e74257cfd3b910b Mon Sep 17 00:00:00 2001
From: Jack Wu <wjack@google.com>
Date: Wed, 10 Jul 2024 14:47:14 +0800
Subject: [PATCH 1008/1487] charger: fix show qustion mark when start to draw
 UI

skip drawing UI if battery status is not ready.

Bug: 343093322
Test: confirm offmode charge UI behavior
Change-Id: Ic5ed4577502bea22f693b7ec0b577dc25ba24712
Signed-off-by: Jack Wu <wjack@google.com>
---
 healthd/healthd_mode_charger.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/healthd/healthd_mode_charger.cpp b/healthd/healthd_mode_charger.cpp
index 26af13b31436..54b469be397f 100644
--- a/healthd/healthd_mode_charger.cpp
+++ b/healthd/healthd_mode_charger.cpp
@@ -306,8 +306,8 @@ void Charger::UpdateScreenState(int64_t now) {
 
     if (!batt_anim_.run || now < next_screen_transition_) return;
 
-    // If battery level is not ready, keep checking in the defined time
-    if (health_info_.battery_level == 0 && health_info_.battery_status == BatteryStatus::UNKNOWN) {
+    // If battery status is not ready, keep checking in the defined time
+    if (health_info_.battery_status == BatteryStatus::UNKNOWN) {
         if (wait_batt_level_timestamp_ == 0) {
             // Set max delay time and skip drawing screen
             wait_batt_level_timestamp_ = now + MAX_BATT_LEVEL_WAIT_TIME;
@@ -317,7 +317,7 @@ void Charger::UpdateScreenState(int64_t now) {
             // Do nothing, keep waiting
             return;
         }
-        // If timeout and battery level is still not ready, draw unknown battery
+        // If timeout and battery status is still not ready, draw unknown battery
     }
 
     if (healthd_draw_ == nullptr) return;

From 1b76cb48ef83bceb2a5f85ec0e18f69dde9ba0ae Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 1 Jul 2024 10:07:43 -0700
Subject: [PATCH 1009/1487] libsnapshot: Address GRF config when updating from
 Android S config

Bug: 333854394
Test: 1)S+U > V+V , FULL OTA pass
2)S+U > S+V, FULL OTA pass
Change-Id: Ia8e6db89c3395930856ace8940424e60cae92375
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshot.cpp | 45 ++++++++++++++++++++++++++-------
 1 file changed, 36 insertions(+), 9 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 66743789af81..11aa3f934778 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -20,6 +20,7 @@
 #include <sys/file.h>
 #include <sys/types.h>
 #include <sys/unistd.h>
+#include <sys/xattr.h>
 
 #include <chrono>
 #include <filesystem>
@@ -91,6 +92,8 @@ static constexpr char kBootIndicatorPath[] = "/metadata/ota/snapshot-boot";
 static constexpr char kRollbackIndicatorPath[] = "/metadata/ota/rollback-indicator";
 static constexpr char kSnapuserdFromSystem[] = "/metadata/ota/snapuserd-from-system";
 static constexpr auto kUpdateStateCheckInterval = 2s;
+static constexpr char kOtaFileContext[] = "u:object_r:ota_metadata_file:s0";
+
 /*
  * The readahead size is set to 32kb so that
  * there is no significant memory pressure (/proc/pressure/memory) during boot.
@@ -2135,6 +2138,24 @@ bool SnapshotManager::MarkSnapuserdFromSystem() {
         PLOG(ERROR) << "Unable to write to vendor update path: " << path;
         return false;
     }
+
+    unique_fd fd(open(path.c_str(), O_PATH));
+    if (fd < 0) {
+        PLOG(ERROR) << "Failed to open file: " << path;
+        return false;
+    }
+
+    /*
+     * This function is invoked by first stage init and hence we need to
+     * explicitly set the correct selinux label for this file as update_engine
+     * will try to remove this file later on once the snapshot merge is
+     * complete.
+     */
+    if (fsetxattr(fd.get(), XATTR_NAME_SELINUX, kOtaFileContext, strlen(kOtaFileContext) + 1, 0) <
+        0) {
+        PLOG(ERROR) << "fsetxattr for the path: " << path << " failed";
+    }
+
     return true;
 }
 
@@ -2185,18 +2206,24 @@ bool SnapshotManager::MarkSnapuserdFromSystem() {
  *
  */
 bool SnapshotManager::IsLegacySnapuserdPostReboot() {
-    if (is_legacy_snapuserd_.has_value() && is_legacy_snapuserd_.value() == true) {
-        auto slot = GetCurrentSlot();
-        if (slot == Slot::Target) {
-            // If this marker is present, then daemon can handle userspace
-            // snapshots; also, it indicates that the vendor partition was
-            // updated from Android 12.
-            if (access(GetSnapuserdFromSystemPath().c_str(), F_OK) == 0) {
-                return false;
-            }
+    auto slot = GetCurrentSlot();
+    if (slot == Slot::Target) {
+        /*
+            If this marker is present, the daemon can handle userspace snapshots.
+            During post-OTA reboot, this implies that the vendor partition is
+            Android 13 or higher. If the snapshots were created on an
+            Android 12 vendor, this means the vendor partition has been updated.
+        */
+        if (access(GetSnapuserdFromSystemPath().c_str(), F_OK) == 0) {
+            is_snapshot_userspace_ = true;
+            return false;
+        }
+        // If the marker isn't present and if the vendor is still in Android 12
+        if (is_legacy_snapuserd_.has_value() && is_legacy_snapuserd_.value() == true) {
             return true;
         }
     }
+
     return false;
 }
 

From 3360d387d205ce3f89b311c20f25adbcec1bebbc Mon Sep 17 00:00:00 2001
From: Betty Zhou <bettyzhou@google.com>
Date: Fri, 19 Jul 2024 13:40:53 -0700
Subject: [PATCH 1010/1487] Add adb-remount-sh to presubmit & kernel-presubmit
 group.

Test: test-mapping test
Bug: 231996550
Change-Id: Ic03dcf8c316e64bc5d6b106b598c0af590d24802
---
 fs_mgr/TEST_MAPPING | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index 32e8b88e1833..192232d6c4b0 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -33,6 +33,9 @@
     }
   ],
   "kernel-presubmit": [
+    {
+      "name": "adb-remount-sh"
+    },
     {
       "name": "libdm_test"
     },

From 6906249312be46b64b6b6221ba33bad196bf6cd6 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 11 Jul 2024 10:06:47 -0700
Subject: [PATCH 1011/1487] Skip tests if vendor partition is on Android S

Bug: 349278999
Test: vts_libsnapshot_test on GSI config
Change-Id: I6826b287565e8a78bea21b4830ad30f1c30a01bf
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../include_test/libsnapshot/test_helpers.h    | 18 ++++++++++++++++++
 fs_mgr/libsnapshot/snapshot_test.cpp           |  7 +++++++
 2 files changed, 25 insertions(+)

diff --git a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
index 90813fe79e69..0afd8bd22ae5 100644
--- a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
+++ b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
@@ -30,6 +30,8 @@
 #include <storage_literals/storage_literals.h>
 #include <update_engine/update_metadata.pb.h>
 
+#include "utility.h"
+
 namespace android {
 namespace snapshot {
 
@@ -234,5 +236,21 @@ bool IsVirtualAbEnabled();
 
 #define RETURN_IF_NON_VIRTUAL_AB() RETURN_IF_NON_VIRTUAL_AB_MSG("")
 
+#define SKIP_IF_VENDOR_ON_ANDROID_S()                                        \
+    do {                                                                     \
+        if (IsVendorFromAndroid12())                                         \
+            GTEST_SKIP() << "Skip test as Vendor partition is on Android S"; \
+    } while (0)
+
+#define RETURN_IF_VENDOR_ON_ANDROID_S_MSG(msg) \
+    do {                                       \
+        if (IsVendorFromAndroid12()) {         \
+            std::cerr << (msg);                \
+            return;                            \
+        }                                      \
+    } while (0)
+
+#define RETURN_IF_VENDOR_ON_ANDROID_S() RETURN_IF_VENDOR_ON_ANDROID_S_MSG("")
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 1435b12bf545..07f13014dd4d 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -122,6 +122,7 @@ class SnapshotTest : public ::testing::Test {
         LOG(INFO) << "Starting test: " << test_name_;
 
         SKIP_IF_NON_VIRTUAL_AB();
+        SKIP_IF_VENDOR_ON_ANDROID_S();
 
         SetupProperties();
         if (!DeviceSupportsMode()) {
@@ -168,6 +169,7 @@ class SnapshotTest : public ::testing::Test {
 
     void TearDown() override {
         RETURN_IF_NON_VIRTUAL_AB();
+        RETURN_IF_VENDOR_ON_ANDROID_S();
 
         LOG(INFO) << "Tearing down SnapshotTest test: " << test_name_;
 
@@ -1015,6 +1017,7 @@ class SnapshotUpdateTest : public SnapshotTest {
   public:
     void SetUp() override {
         SKIP_IF_NON_VIRTUAL_AB();
+        SKIP_IF_VENDOR_ON_ANDROID_S();
 
         SnapshotTest::SetUp();
         if (!image_manager_) {
@@ -1097,6 +1100,7 @@ class SnapshotUpdateTest : public SnapshotTest {
     }
     void TearDown() override {
         RETURN_IF_NON_VIRTUAL_AB();
+        RETURN_IF_VENDOR_ON_ANDROID_S();
 
         LOG(INFO) << "Tearing down SnapshotUpdateTest test: " << test_name_;
 
@@ -2833,6 +2837,7 @@ void SnapshotTestEnvironment::SetUp() {
     // that is fixed, don't call GTEST_SKIP here, but instead call GTEST_SKIP in individual test
     // suites.
     RETURN_IF_NON_VIRTUAL_AB_MSG("Virtual A/B is not enabled, skipping global setup.\n");
+    RETURN_IF_VENDOR_ON_ANDROID_S_MSG("Test not enabled for Vendor on Android S.\n");
 
     std::vector<std::string> paths = {
             // clang-format off
@@ -2887,6 +2892,8 @@ void SnapshotTestEnvironment::SetUp() {
 
 void SnapshotTestEnvironment::TearDown() {
     RETURN_IF_NON_VIRTUAL_AB();
+    RETURN_IF_VENDOR_ON_ANDROID_S();
+
     if (super_images_ != nullptr) {
         DeleteBackingImage(super_images_.get(), "fake-super");
     }

From 5c1378a5ffaebee585cce4894e62993e5c407eeb Mon Sep 17 00:00:00 2001
From: Tommy Chiu <tommychiu@google.com>
Date: Wed, 15 May 2024 09:50:31 +0000
Subject: [PATCH 1012/1487] Add trusty_rkp_set_uds_cert for UdsCert
 provisioning

Bug: 330791928
Test: trusty_rkp_set_uds_cert /data/rkp_uds_cert_test.xml
Change-Id: I368be346197099ff6d3fe7a09d666791faada040
---
 trusty/keymaster/Android.bp                   |  37 ++-
 .../trusty_keymaster/ipc/keymaster_ipc.h      |   2 +
 .../set_uds_certs/rkp_uds_cert_test.xml       |  42 +++
 .../set_uds_certs/set_uds_certificates.cpp    | 279 ++++++++++++++++++
 4 files changed, 358 insertions(+), 2 deletions(-)
 create mode 100644 trusty/keymaster/set_uds_certs/rkp_uds_cert_test.xml
 create mode 100644 trusty/keymaster/set_uds_certs/set_uds_certificates.cpp

diff --git a/trusty/keymaster/Android.bp b/trusty/keymaster/Android.bp
index b249013ba217..aca59b6c6290 100644
--- a/trusty/keymaster/Android.bp
+++ b/trusty/keymaster/Android.bp
@@ -44,7 +44,7 @@ cc_binary {
         "libtrusty",
         "libkeymaster_messages",
         "libkeymaster3device",
-        "android.hardware.keymaster@3.0"
+        "android.hardware.keymaster@3.0",
     ],
 }
 
@@ -74,7 +74,7 @@ cc_binary {
         "libtrusty",
         "libkeymaster_messages",
         "libkeymaster4",
-        "android.hardware.keymaster@4.0"
+        "android.hardware.keymaster@4.0",
     ],
 
     vintf_fragments: ["4.0/android.hardware.keymaster@4.0-service.trusty.xml"],
@@ -208,3 +208,36 @@ cc_binary {
         "-Werror",
     ],
 }
+
+prebuilt_etc {
+    name: "rkp_uds_cert_test.xml",
+    vendor: true,
+    src: "set_uds_certs/rkp_uds_cert_test.xml",
+}
+
+cc_binary {
+    name: "trusty_rkp_set_uds_cert",
+    vendor: true,
+
+    srcs: [
+        "set_uds_certs/set_uds_certificates.cpp",
+        "ipc/trusty_keymaster_ipc.cpp",
+    ],
+
+    local_include_dirs: ["include"],
+
+    shared_libs: [
+        "libc",
+        "libcrypto",
+        "liblog",
+        "libtrusty",
+        "libhardware",
+        "libkeymaster_messages",
+        "libutils",
+        "libxml2",
+    ],
+    cflags: [
+        "-Wall",
+        "-Werror",
+    ],
+}
diff --git a/trusty/keymaster/include/trusty_keymaster/ipc/keymaster_ipc.h b/trusty/keymaster/include/trusty_keymaster/ipc/keymaster_ipc.h
index 09f696bb50da..822e93334fb2 100644
--- a/trusty/keymaster/include/trusty_keymaster/ipc/keymaster_ipc.h
+++ b/trusty/keymaster/include/trusty_keymaster/ipc/keymaster_ipc.h
@@ -78,6 +78,8 @@ enum keymaster_command : uint32_t {
     KM_SET_ATTESTATION_IDS = (0xc000 << KEYMASTER_REQ_SHIFT),
     KM_SET_ATTESTATION_IDS_KM3 = (0xc001 << KEYMASTER_REQ_SHIFT),
     KM_CONFIGURE_BOOT_PATCHLEVEL = (0xd000 << KEYMASTER_REQ_SHIFT),
+    KM_APPEND_UDS_CERT_CHAIN = (0xe0000 << KEYMASTER_REQ_SHIFT),
+    KM_CLEAR_UDS_CERT_CHAIN = (0xe0001 << KEYMASTER_REQ_SHIFT),
 };
 
 #ifdef __ANDROID__
diff --git a/trusty/keymaster/set_uds_certs/rkp_uds_cert_test.xml b/trusty/keymaster/set_uds_certs/rkp_uds_cert_test.xml
new file mode 100644
index 000000000000..73b7b4c30d1a
--- /dev/null
+++ b/trusty/keymaster/set_uds_certs/rkp_uds_cert_test.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0"?>
+<PixelUdsCertificates>
+  <CertificateChain>
+    <NumberOfCertificates>3</NumberOfCertificates>
+    <Certificate format="pem">
+-----BEGIN CERTIFICATE-----
+MIIBWTCB3qADAgECAgUA3q2+7zAMBggqhkjOPQQDAwUAMBIxEDAOBgNVBAMMB0dT
+TUkxLjAwIhgPMjAyNDAxMDEwMDAwMDBaGA85OTk5MTIzMTIzNTk1OVowEjEQMA4G
+A1UEAwwHR1NNSTEuMDB2MBAGByqGSM49AgEGBSuBBAAiA2IABFsNPdsPmx2NKNiT
+7oReF36HTXjftRfGffYgPf/vEhrT7XLJ7dThkcb+OFYWYlOckdk3DRgqTNWQXsot
+UsZhwRveU8huEjOBO5+dwDiWPs+s9jSRAn5inlTqJ0YGAmdHRzAMBggqhkjOPQQD
+AwUAA2gAMGUCMQCuiJwmRWOgfWbqdSlnXfhCbphjdWc6sHelLkkM21vxQ3RZkhC2
+ERh90RA1rxB+XTgCMHZrYG3leS0PEoz5hUviv27LbBHBU6GeOzrS2e0VH0BMSNXN
+iP9Wnit+mJw58niEGw==
+-----END CERTIFICATE-----
+    </Certificate>
+    <Certificate format="pem">
+-----BEGIN CERTIFICATE-----
+MIIBWTCB3qADAgECAgUA3q2+7zAMBggqhkjOPQQDAwUAMBIxEDAOBgNVBAMMB0dT
+TUkxLjAwIhgPMjAyNDAxMDEwMDAwMDBaGA85OTk5MTIzMTIzNTk1OVowEjEQMA4G
+A1UEAwwHR1NNSTEuMDB2MBAGByqGSM49AgEGBSuBBAAiA2IABFsNPdsPmx2NKNiT
+7oReF36HTXjftRfGffYgPf/vEhrT7XLJ7dThkcb+OFYWYlOckdk3DRgqTNWQXsot
+UsZhwRveU8huEjOBO5+dwDiWPs+s9jSRAn5inlTqJ0YGAmdHRzAMBggqhkjOPQQD
+AwUAA2gAMGUCMQCuiJwmRWOgfWbqdSlnXfhCbphjdWc6sHelLkkM21vxQ3RZkhC2
+ERh90RA1rxB+XTgCMHZrYG3leS0PEoz5hUviv27LbBHBU6GeOzrS2e0VH0BMSNXN
+iP9Wnit+mJw58niEGw==
+-----END CERTIFICATE-----
+    </Certificate>
+    <Certificate format="pem">
+-----BEGIN CERTIFICATE-----
+MIIBWTCB3qADAgECAgUA3q2+7zAMBggqhkjOPQQDAwUAMBIxEDAOBgNVBAMMB0dT
+TUkxLjAwIhgPMjAyNDAxMDEwMDAwMDBaGA85OTk5MTIzMTIzNTk1OVowEjEQMA4G
+A1UEAwwHR1NNSTEuMDB2MBAGByqGSM49AgEGBSuBBAAiA2IABFsNPdsPmx2NKNiT
+7oReF36HTXjftRfGffYgPf/vEhrT7XLJ7dThkcb+OFYWYlOckdk3DRgqTNWQXsot
+UsZhwRveU8huEjOBO5+dwDiWPs+s9jSRAn5inlTqJ0YGAmdHRzAMBggqhkjOPQQD
+AwUAA2gAMGUCMQCuiJwmRWOgfWbqdSlnXfhCbphjdWc6sHelLkkM21vxQ3RZkhC2
+ERh90RA1rxB+XTgCMHZrYG3leS0PEoz5hUviv27LbBHBU6GeOzrS2e0VH0BMSNXN
+iP9Wnit+mJw58niEGw==
+-----END CERTIFICATE-----
+    </Certificate>
+  </CertificateChain>
+</PixelUdsCertificates>
diff --git a/trusty/keymaster/set_uds_certs/set_uds_certificates.cpp b/trusty/keymaster/set_uds_certs/set_uds_certificates.cpp
new file mode 100644
index 000000000000..13356a911d9d
--- /dev/null
+++ b/trusty/keymaster/set_uds_certs/set_uds_certificates.cpp
@@ -0,0 +1,279 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <errno.h>
+#include <getopt.h>
+#include <libxml/xmlreader.h>
+#include <openssl/pem.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <string>
+
+#include <trusty_keymaster/ipc/trusty_keymaster_ipc.h>
+
+static const char* _sopts = "h";
+static const struct option _lopts[] = {
+        {"help", no_argument, 0, 'h'},
+        {0, 0, 0, 0},
+};
+
+static const char* usage =
+        "Usage: %s [options] xml-file\n"
+        "\n"
+        "options:\n"
+        "  -h, --help            prints this message and exit\n"
+        "\n";
+
+static void print_usage_and_exit(const char* prog, int code) {
+    fprintf(stderr, usage, prog);
+    exit(code);
+}
+
+static void parse_options(int argc, char** argv) {
+    int c;
+    int oidx = 0;
+
+    while (1) {
+        c = getopt_long(argc, argv, _sopts, _lopts, &oidx);
+        if (c == -1) {
+            break; /* done */
+        }
+
+        switch (c) {
+            case 'h':
+                print_usage_and_exit(argv[0], EXIT_SUCCESS);
+                break;
+
+            default:
+                print_usage_and_exit(argv[0], EXIT_FAILURE);
+        }
+    }
+}
+
+struct AppendUdsCertificateRequest : public keymaster::KeymasterMessage {
+    explicit AppendUdsCertificateRequest(int32_t ver = keymaster::kDefaultMessageVersion)
+        : KeymasterMessage(ver) {}
+
+    size_t SerializedSize() const override { return cert_data.SerializedSize(); }
+    uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override {
+        return cert_data.Serialize(buf, end);
+    }
+    bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override {
+        return cert_data.Deserialize(buf_ptr, end);
+    }
+
+    keymaster::Buffer cert_data;
+};
+
+struct ClearUdsCertificateRequest : public keymaster::KeymasterMessage {
+    explicit ClearUdsCertificateRequest(int32_t ver = keymaster::kDefaultMessageVersion)
+        : KeymasterMessage(ver) {}
+
+    size_t SerializedSize() const override { return 0; }
+    uint8_t* Serialize(uint8_t* buf, const uint8_t*) const override { return buf; }
+    bool Deserialize(const uint8_t**, const uint8_t*) override { return true; };
+};
+
+struct KeymasterNoResponse : public keymaster::KeymasterResponse{
+    explicit KeymasterNoResponse(int32_t ver = keymaster::kDefaultMessageVersion)
+        : keymaster::KeymasterResponse(ver) {}
+
+    size_t NonErrorSerializedSize() const override { return 0; }
+    uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t*) const override { return buf; }
+    bool NonErrorDeserialize(const uint8_t**, const uint8_t*) override { return true; }
+};
+
+struct AppendUdsCertificateResponse : public KeymasterNoResponse {};
+struct ClearUdsCertificateResponse : public KeymasterNoResponse {};
+
+static int set_uds_cert_bin(uint32_t cmd, const void* cert_data, size_t cert_data_size) {
+    int ret;
+
+    AppendUdsCertificateRequest req;
+    req.cert_data.Reinitialize(cert_data, cert_data_size);
+    AppendUdsCertificateResponse rsp;
+
+    ret = trusty_keymaster_send(cmd, req, &rsp);
+    if (ret) {
+        fprintf(stderr, "trusty_keymaster_send cmd 0x%x failed %d\n", cmd, ret);
+        return ret;
+    }
+
+    return 0;
+}
+
+static int set_uds_cert_pem(uint32_t cmd, const xmlChar* pemkey) {
+    int ret;
+    int sslret;
+
+    /* Convert from pem to binary */
+    BIO* bio = BIO_new_mem_buf(pemkey, xmlStrlen(pemkey));
+    if (!bio) {
+        fprintf(stderr, "BIO_new_mem_buf failed\n");
+        ERR_print_errors_fp(stderr);
+        return -1;
+    }
+
+    char* key_name;
+    char* key_header;
+    uint8_t* key;
+    long keylen;
+    sslret = PEM_read_bio(bio, &key_name, &key_header, &key, &keylen);
+    BIO_free(bio);
+
+    if (!sslret) {
+        fprintf(stderr, "PEM_read_bio failed\n");
+        ERR_print_errors_fp(stderr);
+        return -1;
+    }
+
+    /* Send key in binary format to trusty */
+    ret = set_uds_cert_bin(cmd, key, keylen);
+
+    OPENSSL_free(key_name);
+    OPENSSL_free(key_header);
+    OPENSSL_free(key);
+
+    return ret;
+}
+
+static int set_uds_cert(uint32_t cmd, const xmlChar* format, const xmlChar* str) {
+    int ret;
+
+    if (xmlStrEqual(format, BAD_CAST "pem")) {
+        ret = set_uds_cert_pem(cmd, str);
+    } else {
+        printf("unsupported key/cert format: %s\n", format);
+        return -1;
+    }
+    return ret;
+}
+
+// TODO: Guard by Production Mode
+static int clear_cert_chain() {
+    int ret;
+    ClearUdsCertificateRequest req;
+    ClearUdsCertificateResponse rsp;
+
+    ret = trusty_keymaster_send(KM_CLEAR_UDS_CERT_CHAIN, req, &rsp);
+    if (ret) {
+        fprintf(stderr, "%s: trusty_keymaster_send failed %d\n", __func__, ret);
+        return ret;
+    }
+    return 0;
+}
+
+static int process_xml(xmlTextReaderPtr xml) {
+    int ret;
+    const xmlChar* element = NULL;
+    const xmlChar* element_format = NULL;
+    bool isPixelUdsCert = false;
+
+    while ((ret = xmlTextReaderRead(xml)) == 1) {
+        int nodetype = xmlTextReaderNodeType(xml);
+        const xmlChar *name, *value;
+        name = xmlTextReaderConstName(xml);
+        switch (nodetype) {
+            case XML_READER_TYPE_ELEMENT:
+                element = name;
+                element_format = xmlTextReaderGetAttribute(xml, BAD_CAST "format");
+                if (isPixelUdsCert || xmlStrEqual(name, BAD_CAST "PixelUdsCertificates")) {
+                    // The first element name must be "PixelUdsCertificates"
+                    isPixelUdsCert = true;
+                } else {
+                    fprintf(stderr, "Not a PixelUdsCertificates: \"%s\"\n", name);
+                    return -1;
+                }
+                if (xmlStrEqual(name, BAD_CAST "CertificateChain")) {
+                    ret = clear_cert_chain();
+                    if (ret) {
+                        fprintf(stderr, "%s: Clear cert chain cmd failed, %d\n", element, ret);
+                        return ret;
+                    }
+                    printf("%s: Clear cert chain cmd done\n", element);
+                }
+                break;
+            case XML_READER_TYPE_TEXT:
+                value = xmlTextReaderConstValue(xml);
+                uint32_t cmd;
+                if (xmlStrEqual(element, BAD_CAST "Certificate")) {
+                    cmd = KM_APPEND_UDS_CERT_CHAIN;
+                } else {
+                    break;
+                }
+
+                ret = set_uds_cert(cmd, element_format, value);
+                if (ret) {
+                    fprintf(stderr, "%s, format %s: Cmd 0x%x failed, %d\n", element, element_format,
+                            cmd, ret);
+                    return ret;
+                }
+                printf("%s, format %s: Cmd 0x%x done\n", element, element_format, cmd);
+                break;
+            case XML_READER_TYPE_END_ELEMENT:
+                element = NULL;
+                break;
+        }
+    }
+    return ret;
+}
+
+static int parse_and_provision_xml_file(const char* filename) {
+    int ret;
+    xmlTextReaderPtr xml = xmlReaderForFile(filename, NULL, 0);
+    if (!xml) {
+        fprintf(stderr, "failed to open %s\n", filename);
+        return -1;
+    }
+
+    ret = process_xml(xml);
+
+    xmlFreeTextReader(xml);
+    if (ret != 0) {
+        fprintf(stderr, "Failed to parse or process %s\n", filename);
+        return -1;
+    }
+
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    int ret = 0;
+
+    parse_options(argc, argv);
+    if (optind + 1 != argc) {
+        print_usage_and_exit(argv[0], EXIT_FAILURE);
+    }
+
+    ret = trusty_keymaster_connect();
+    if (ret) {
+        fprintf(stderr, "trusty_keymaster_connect failed %d\n", ret);
+        return EXIT_FAILURE;
+    }
+
+    ret = parse_and_provision_xml_file(argv[optind]);
+    if (ret) {
+        fprintf(stderr, "parse_and_provision_xml_file failed %d\n", ret);
+        trusty_keymaster_disconnect();
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_SUCCESS;
+}

From 9088d1bb12b1a97f49055abef609e0fc48a10234 Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Fri, 9 Jun 2023 09:52:49 +0900
Subject: [PATCH 1013/1487] init: non-crashing service can restart immediately

This CL allows restart_period to be set to a value shorter than 5s.
Previously this was prohibited to rate limit crashing services. That
behavior is considered to be a bit too conservative because some
services don't crash, but exit deliverately.

adbd is the motivating example. When adb root or adb unroot is
requested, it changes its mode of operation (via sysprop), exits itself,
and restarts (by init) to enter into the mode. However, due to the 5s
delay, the mode change can complete no earlier than 5 seconds after adbd
was started last time. This can slow the mode change when it is
requested right after the boot.

With this CL, restart_period can be set to a value smaller than 5. And
services like adbd can make use of it. However, in ordef to rate limit
crashing service, the default is enforced if the service was crashed
last time. In addition, such intended restart is not counted as crashes
when monitoring successive crashes during booting.

Bug: 286061817
Bug: 339844204
Test: /packages/modules/Virtualization/vm/vm_shell.sh start-microdroid \
 --auto-connect -- --protected
* with this change: within 2s
* without this change: over 6s
(cherry picked from https://android-review.googlesource.com/q/commit:0d277d777f290729fd9708b88f7ed57f0e0e49eb)
Merged-In: I1b3f0c92d349e8c8760821cf50fb69997b67b242
Change-Id: I1b3f0c92d349e8c8760821cf50fb69997b67b242
---
 init/README.md          | 13 ++++++++-----
 init/service.cpp        |  4 +++-
 init/service.h          | 17 +++++++++++++++--
 init/service_parser.cpp |  4 ++--
 4 files changed, 28 insertions(+), 10 deletions(-)

diff --git a/init/README.md b/init/README.md
index aaafe788779f..734e14eee3de 100644
--- a/init/README.md
+++ b/init/README.md
@@ -316,11 +316,14 @@ runs the service.
   intended to be used with the `exec_start` builtin for any must-have checks during boot.
 
 `restart_period <seconds>`
-> If a non-oneshot service exits, it will be restarted at its start time plus
-  this period. It defaults to 5s to rate limit crashing services.
-  This can be increased for services that are meant to run periodically. For
-  example, it may be set to 3600 to indicate that the service should run every hour
-  or 86400 to indicate that the service should run every day.
+> If a non-oneshot service exits, it will be restarted at its previous start time plus this period.
+  The default value is 5s. This can be used to implement periodic services together with the
+  `timeout_period` command below. For example, it may be set to 3600 to indicate that the service
+  should run every hour or 86400 to indicate that the service should run every day. This can be set
+  to a value shorter than 5s for example 0, but the minimum 5s delay is enforced if the restart was
+  due to a crash. This is to rate limit persistentally crashing services. In other words,
+  `<seconds>` smaller than 5 is respected only when the service exits deliverately and successfully
+  (i.e. by calling exit(0)).
 
 `rlimit <resource> <cur> <max>`
 > This applies the given rlimit to the service. rlimits are inherited by child
diff --git a/init/service.cpp b/init/service.cpp
index bd704cf8e79e..7d83d60e4c83 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -298,6 +298,7 @@ void Service::Reap(const siginfo_t& siginfo) {
     pid_ = 0;
     flags_ &= (~SVC_RUNNING);
     start_order_ = 0;
+    was_last_exit_ok_ = siginfo.si_code == CLD_EXITED && siginfo.si_status == 0;
 
     // Oneshot processes go into the disabled state on exit,
     // except when manually restarted.
@@ -321,7 +322,8 @@ void Service::Reap(const siginfo_t& siginfo) {
     // If we crash > 4 times in 'fatal_crash_window_' minutes or before boot_completed,
     // reboot into bootloader or set crashing property
     boot_clock::time_point now = boot_clock::now();
-    if (((flags_ & SVC_CRITICAL) || is_process_updatable) && !(flags_ & SVC_RESTART)) {
+    if (((flags_ & SVC_CRITICAL) || is_process_updatable) && !(flags_ & SVC_RESTART) &&
+        !was_last_exit_ok_) {
         bool boot_completed = GetBoolProperty("sys.boot_completed", false);
         if (now < time_crashed_ + fatal_crash_window_ || !boot_completed) {
             if (++crash_count_ > 4) {
diff --git a/init/service.h b/init/service.h
index c314aa1c6cb8..f5f361901c27 100644
--- a/init/service.h
+++ b/init/service.h
@@ -19,6 +19,7 @@
 #include <signal.h>
 #include <sys/types.h>
 
+#include <algorithm>
 #include <chrono>
 #include <memory>
 #include <optional>
@@ -113,6 +114,7 @@ class Service {
     pid_t pid() const { return pid_; }
     android::base::boot_clock::time_point time_started() const { return time_started_; }
     int crash_count() const { return crash_count_; }
+    int was_last_exit_ok() const { return was_last_exit_ok_; }
     uid_t uid() const { return proc_attr_.uid; }
     gid_t gid() const { return proc_attr_.gid; }
     int namespace_flags() const { return namespaces_.flags; }
@@ -128,7 +130,15 @@ class Service {
     bool process_cgroup_empty() const { return process_cgroup_empty_; }
     unsigned long start_order() const { return start_order_; }
     void set_sigstop(bool value) { sigstop_ = value; }
-    std::chrono::seconds restart_period() const { return restart_period_; }
+    std::chrono::seconds restart_period() const {
+        // If the service exited abnormally or due to timeout, late limit the restart even if
+        // restart_period is set to a very short value.
+        // If not, i.e. restart after a deliberate and successful exit, respect the period.
+        if (!was_last_exit_ok_) {
+            return std::max(restart_period_, default_restart_period_);
+        }
+        return restart_period_;
+    }
     std::optional<std::chrono::seconds> timeout_period() const { return timeout_period_; }
     const std::vector<std::string>& args() const { return args_; }
     bool is_updatable() const { return updatable_; }
@@ -171,6 +181,8 @@ class Service {
     int crash_count_;                     // number of times crashed within window
     std::chrono::minutes fatal_crash_window_ = 4min;  // fatal() when more than 4 crashes in it
     std::optional<std::string> fatal_reboot_target_;  // reboot target of fatal handler
+    bool was_last_exit_ok_ =
+            true;  // true if the service never exited, or exited with status code 0
 
     std::optional<CapSet> capabilities_;
     ProcessAttributes proc_attr_;
@@ -211,7 +223,8 @@ class Service {
 
     bool sigstop_ = false;
 
-    std::chrono::seconds restart_period_ = 5s;
+    const std::chrono::seconds default_restart_period_ = 5s;
+    std::chrono::seconds restart_period_ = default_restart_period_;
     std::optional<std::chrono::seconds> timeout_period_;
 
     bool updatable_ = false;
diff --git a/init/service_parser.cpp b/init/service_parser.cpp
index 1ee309d98b75..cc39565deac5 100644
--- a/init/service_parser.cpp
+++ b/init/service_parser.cpp
@@ -364,8 +364,8 @@ Result<void> ServiceParser::ParseRebootOnFailure(std::vector<std::string>&& args
 
 Result<void> ServiceParser::ParseRestartPeriod(std::vector<std::string>&& args) {
     int period;
-    if (!ParseInt(args[1], &period, 5)) {
-        return Error() << "restart_period value must be an integer >= 5";
+    if (!ParseInt(args[1], &period, 0)) {
+        return Error() << "restart_period value must be an integer >= 0";
     }
     service_->restart_period_ = std::chrono::seconds(period);
     return {};

From 555d2393b6ba28de4cc84bc23e0e87957e086756 Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Fri, 9 Jun 2023 09:52:49 +0900
Subject: [PATCH 1014/1487] init: non-crashing service can restart immediately

This CL allows restart_period to be set to a value shorter than 5s.
Previously this was prohibited to rate limit crashing services. That
behavior is considered to be a bit too conservative because some
services don't crash, but exit deliverately.

adbd is the motivating example. When adb root or adb unroot is
requested, it changes its mode of operation (via sysprop), exits itself,
and restarts (by init) to enter into the mode. However, due to the 5s
delay, the mode change can complete no earlier than 5 seconds after adbd
was started last time. This can slow the mode change when it is
requested right after the boot.

With this CL, restart_period can be set to a value smaller than 5. And
services like adbd can make use of it. However, in ordef to rate limit
crashing service, the default is enforced if the service was crashed
last time. In addition, such intended restart is not counted as crashes
when monitoring successive crashes during booting.

Bug: 286061817
Bug: 339844204
Test: /packages/modules/Virtualization/vm/vm_shell.sh start-microdroid \
 --auto-connect -- --protected
* with this change: within 2s
* without this change: over 6s
(cherry picked from https://android-review.googlesource.com/q/commit:0d277d777f290729fd9708b88f7ed57f0e0e49eb)
Merged-In: I1b3f0c92d349e8c8760821cf50fb69997b67b242
Change-Id: I1b3f0c92d349e8c8760821cf50fb69997b67b242
---
 init/README.md          | 13 ++++++++-----
 init/service.cpp        |  4 +++-
 init/service.h          | 17 +++++++++++++++--
 init/service_parser.cpp |  4 ++--
 4 files changed, 28 insertions(+), 10 deletions(-)

diff --git a/init/README.md b/init/README.md
index 4a262c920e2a..e1f506ce6aa9 100644
--- a/init/README.md
+++ b/init/README.md
@@ -279,11 +279,14 @@ runs the service.
   intended to be used with the `exec_start` builtin for any must-have checks during boot.
 
 `restart_period <seconds>`
-> If a non-oneshot service exits, it will be restarted at its start time plus
-  this period. It defaults to 5s to rate limit crashing services.
-  This can be increased for services that are meant to run periodically. For
-  example, it may be set to 3600 to indicate that the service should run every hour
-  or 86400 to indicate that the service should run every day.
+> If a non-oneshot service exits, it will be restarted at its previous start time plus this period.
+  The default value is 5s. This can be used to implement periodic services together with the
+  `timeout_period` command below. For example, it may be set to 3600 to indicate that the service
+  should run every hour or 86400 to indicate that the service should run every day. This can be set
+  to a value shorter than 5s for example 0, but the minimum 5s delay is enforced if the restart was
+  due to a crash. This is to rate limit persistentally crashing services. In other words,
+  `<seconds>` smaller than 5 is respected only when the service exits deliverately and successfully
+  (i.e. by calling exit(0)).
 
 `rlimit <resource> <cur> <max>`
 > This applies the given rlimit to the service. rlimits are inherited by child
diff --git a/init/service.cpp b/init/service.cpp
index c3069f5b2b59..a423656ec5de 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -289,6 +289,7 @@ void Service::Reap(const siginfo_t& siginfo) {
     pid_ = 0;
     flags_ &= (~SVC_RUNNING);
     start_order_ = 0;
+    was_last_exit_ok_ = siginfo.si_code == CLD_EXITED && siginfo.si_status == 0;
 
     // Oneshot processes go into the disabled state on exit,
     // except when manually restarted.
@@ -312,7 +313,8 @@ void Service::Reap(const siginfo_t& siginfo) {
     // If we crash > 4 times in 'fatal_crash_window_' minutes or before boot_completed,
     // reboot into bootloader or set crashing property
     boot_clock::time_point now = boot_clock::now();
-    if (((flags_ & SVC_CRITICAL) || is_process_updatable) && !(flags_ & SVC_RESTART)) {
+    if (((flags_ & SVC_CRITICAL) || is_process_updatable) && !(flags_ & SVC_RESTART) &&
+        !was_last_exit_ok_) {
         bool boot_completed = GetBoolProperty("sys.boot_completed", false);
         if (now < time_crashed_ + fatal_crash_window_ || !boot_completed) {
             if (++crash_count_ > 4) {
diff --git a/init/service.h b/init/service.h
index 043555fa47d7..41d929956bfb 100644
--- a/init/service.h
+++ b/init/service.h
@@ -19,6 +19,7 @@
 #include <signal.h>
 #include <sys/types.h>
 
+#include <algorithm>
 #include <chrono>
 #include <memory>
 #include <optional>
@@ -109,6 +110,7 @@ class Service {
     pid_t pid() const { return pid_; }
     android::base::boot_clock::time_point time_started() const { return time_started_; }
     int crash_count() const { return crash_count_; }
+    int was_last_exit_ok() const { return was_last_exit_ok_; }
     uid_t uid() const { return proc_attr_.uid; }
     gid_t gid() const { return proc_attr_.gid; }
     int namespace_flags() const { return namespaces_.flags; }
@@ -124,7 +126,15 @@ class Service {
     bool process_cgroup_empty() const { return process_cgroup_empty_; }
     unsigned long start_order() const { return start_order_; }
     void set_sigstop(bool value) { sigstop_ = value; }
-    std::chrono::seconds restart_period() const { return restart_period_; }
+    std::chrono::seconds restart_period() const {
+        // If the service exited abnormally or due to timeout, late limit the restart even if
+        // restart_period is set to a very short value.
+        // If not, i.e. restart after a deliberate and successful exit, respect the period.
+        if (!was_last_exit_ok_) {
+            return std::max(restart_period_, default_restart_period_);
+        }
+        return restart_period_;
+    }
     std::optional<std::chrono::seconds> timeout_period() const { return timeout_period_; }
     const std::vector<std::string>& args() const { return args_; }
     bool is_updatable() const { return updatable_; }
@@ -158,6 +168,8 @@ class Service {
     int crash_count_;                     // number of times crashed within window
     std::chrono::minutes fatal_crash_window_ = 4min;  // fatal() when more than 4 crashes in it
     std::optional<std::string> fatal_reboot_target_;  // reboot target of fatal handler
+    bool was_last_exit_ok_ =
+            true;  // true if the service never exited, or exited with status code 0
 
     std::optional<CapSet> capabilities_;
     ProcessAttributes proc_attr_;
@@ -198,7 +210,8 @@ class Service {
 
     bool sigstop_ = false;
 
-    std::chrono::seconds restart_period_ = 5s;
+    const std::chrono::seconds default_restart_period_ = 5s;
+    std::chrono::seconds restart_period_ = default_restart_period_;
     std::optional<std::chrono::seconds> timeout_period_;
 
     bool updatable_ = false;
diff --git a/init/service_parser.cpp b/init/service_parser.cpp
index 57c311a5223a..75e93e5ff4cd 100644
--- a/init/service_parser.cpp
+++ b/init/service_parser.cpp
@@ -363,8 +363,8 @@ Result<void> ServiceParser::ParseRebootOnFailure(std::vector<std::string>&& args
 
 Result<void> ServiceParser::ParseRestartPeriod(std::vector<std::string>&& args) {
     int period;
-    if (!ParseInt(args[1], &period, 5)) {
-        return Error() << "restart_period value must be an integer >= 5";
+    if (!ParseInt(args[1], &period, 0)) {
+        return Error() << "restart_period value must be an integer >= 0";
     }
     service_->restart_period_ = std::chrono::seconds(period);
     return {};

From 1fbba3ed0d8e9566d28733907bfa0285bbbf3a11 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 28 May 2024 16:36:52 -0700
Subject: [PATCH 1015/1487] libsnapshot: cap merge op count

Set op processing window during snapshot merge from the build. The lower
the merge count, the lower the memory strain during the merge process

Bug: 332255580
Test: verify merge_size propogates to snapuserd daemon
Change-Id: Ic7770115bca963d923a7a276897c5deac30f9faf
---
 fs_mgr/libsnapshot/android/snapshot/snapshot.proto |  4 ++++
 fs_mgr/libsnapshot/include/libsnapshot/snapshot.h  |  2 ++
 fs_mgr/libsnapshot/snapshot.cpp                    | 13 +++++++++++++
 fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp  |  6 +++---
 .../snapuserd/user-space-merge/extractor.cpp       |  2 +-
 .../snapuserd/user-space-merge/handler_manager.cpp |  4 ++--
 .../snapuserd/user-space-merge/handler_manager.h   | 14 ++++++--------
 .../snapuserd/user-space-merge/merge_worker.cpp    | 10 ++++++++--
 .../snapuserd/user-space-merge/merge_worker.h      |  4 +++-
 .../snapuserd/user-space-merge/snapuserd_core.cpp  |  9 +++++----
 .../snapuserd/user-space-merge/snapuserd_core.h    |  5 +++--
 .../user-space-merge/snapuserd_readahead.cpp       | 10 ++++++++--
 .../user-space-merge/snapuserd_readahead.h         |  4 +++-
 .../user-space-merge/snapuserd_server.cpp          |  6 ++++--
 .../snapuserd/user-space-merge/snapuserd_server.h  |  3 ++-
 .../snapuserd/user-space-merge/snapuserd_test.cpp  | 14 ++++++++------
 16 files changed, 75 insertions(+), 35 deletions(-)

diff --git a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
index 2e948dda7429..62f99013e97f 100644
--- a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
+++ b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
@@ -229,6 +229,10 @@ message SnapshotUpdateStatus {
 
     // Enable direct reads from source device
     bool o_direct = 12;
+
+    // Number of cow operations to be merged at once
+    uint32 cow_op_merge_size = 13;
+
 }
 
 // Next: 10
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index 1ec863444480..4a3ec1d3a7c4 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -831,6 +831,8 @@ class SnapshotManager final : public ISnapshotManager {
     // Check if direct reads are enabled for the source image
     bool UpdateUsesODirect(LockedFile* lock);
 
+    // Get value of maximum cow op merge size
+    uint32_t GetUpdateCowOpMergeSize(LockedFile* lock);
     // Wrapper around libdm, with diagnostics.
     bool DeleteDeviceIfExists(const std::string& name,
                               const std::chrono::milliseconds& timeout_ms = {});
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 11aa3f934778..265445b6066d 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -1709,6 +1709,10 @@ bool SnapshotManager::PerformInitTransition(InitTransition transition,
         if (UpdateUsesODirect(lock.get())) {
             snapuserd_argv->emplace_back("-o_direct");
         }
+        uint cow_op_merge_size = GetUpdateCowOpMergeSize(lock.get());
+        if (cow_op_merge_size != 0) {
+            snapuserd_argv->emplace_back("-cow_op_merge_size=" + std::to_string(cow_op_merge_size));
+        }
     }
 
     size_t num_cows = 0;
@@ -2131,6 +2135,11 @@ bool SnapshotManager::UpdateUsesODirect(LockedFile* lock) {
     return update_status.o_direct();
 }
 
+uint32_t SnapshotManager::GetUpdateCowOpMergeSize(LockedFile* lock) {
+    SnapshotUpdateStatus update_status = ReadSnapshotUpdateStatus(lock);
+    return update_status.cow_op_merge_size();
+}
+
 bool SnapshotManager::MarkSnapuserdFromSystem() {
     auto path = GetSnapuserdFromSystemPath();
 
@@ -3092,6 +3101,7 @@ bool SnapshotManager::WriteUpdateState(LockedFile* lock, UpdateState state,
         status.set_io_uring_enabled(old_status.io_uring_enabled());
         status.set_legacy_snapuserd(old_status.legacy_snapuserd());
         status.set_o_direct(old_status.o_direct());
+        status.set_cow_op_merge_size(old_status.cow_op_merge_size());
     }
     return WriteSnapshotUpdateStatus(lock, status);
 }
@@ -3474,6 +3484,8 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
             status.set_legacy_snapuserd(true);
             LOG(INFO) << "Setting legacy_snapuserd to true";
         }
+        status.set_cow_op_merge_size(
+                android::base::GetUintProperty<uint32_t>("ro.virtual_ab.cow_op_merge_size", 0));
     } else if (legacy_compression) {
         LOG(INFO) << "Virtual A/B using legacy snapuserd";
     } else {
@@ -3909,6 +3921,7 @@ bool SnapshotManager::Dump(std::ostream& os) {
     ss << "Using userspace snapshots: " << update_status.userspace_snapshots() << std::endl;
     ss << "Using io_uring: " << update_status.io_uring_enabled() << std::endl;
     ss << "Using o_direct: " << update_status.o_direct() << std::endl;
+    ss << "Cow op merge size (0 for uncapped): " << update_status.cow_op_merge_size() << std::endl;
     ss << "Using XOR compression: " << GetXorCompressionEnabledProperty() << std::endl;
     ss << "Current slot: " << device_->GetSlotSuffix() << std::endl;
     ss << "Boot indicator: booting from " << GetCurrentSlot() << " slot" << std::endl;
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
index 67e9e52eafae..dd2dd565907b 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
@@ -30,6 +30,7 @@ DEFINE_bool(socket_handoff, false,
 DEFINE_bool(user_snapshot, false, "If true, user-space snapshots are used");
 DEFINE_bool(io_uring, false, "If true, io_uring feature is enabled");
 DEFINE_bool(o_direct, false, "If true, enable direct reads on source device");
+DEFINE_int32(cow_op_merge_size, 0, "number of operations to be processed at once");
 
 namespace android {
 namespace snapshot {
@@ -106,7 +107,6 @@ bool Daemon::StartServerForUserspaceSnapshots(int arg_start, int argc, char** ar
         }
         return user_server_.Run();
     }
-
     for (int i = arg_start; i < argc; i++) {
         auto parts = android::base::Split(argv[i], ",");
 
@@ -114,8 +114,8 @@ bool Daemon::StartServerForUserspaceSnapshots(int arg_start, int argc, char** ar
             LOG(ERROR) << "Malformed message, expected at least four sub-arguments.";
             return false;
         }
-        auto handler =
-                user_server_.AddHandler(parts[0], parts[1], parts[2], parts[3], FLAGS_o_direct);
+        auto handler = user_server_.AddHandler(parts[0], parts[1], parts[2], parts[3],
+                                               FLAGS_o_direct, FLAGS_cow_op_merge_size);
         if (!handler || !user_server_.StartHandler(parts[0])) {
             return false;
         }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.cpp
index c85331b348c7..ef4ba93fed55 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/extractor.cpp
@@ -41,7 +41,7 @@ Extractor::Extractor(const std::string& base_path, const std::string& cow_path)
 bool Extractor::Init() {
     auto opener = factory_.CreateTestOpener(control_name_);
     handler_ = std::make_shared<SnapshotHandler>(control_name_, cow_path_, base_path_, base_path_,
-                                                 opener, 1, false, false, false);
+                                                 opener, 1, false, false, false, 0);
     if (!handler_->InitCowDevice()) {
         return false;
     }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index ea11f0e6e480..fdd9cce0cbc3 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -53,10 +53,10 @@ std::shared_ptr<HandlerThread> SnapshotHandlerManager::AddHandler(
         const std::string& misc_name, const std::string& cow_device_path,
         const std::string& backing_device, const std::string& base_path_merge,
         std::shared_ptr<IBlockServerOpener> opener, int num_worker_threads, bool use_iouring,
-        bool o_direct) {
+        bool o_direct, uint32_t cow_op_merge_size) {
     auto snapuserd = std::make_shared<SnapshotHandler>(
             misc_name, cow_device_path, backing_device, base_path_merge, opener, num_worker_threads,
-            use_iouring, perform_verification_, o_direct);
+            use_iouring, perform_verification_, o_direct, cow_op_merge_size);
     if (!snapuserd->InitCowDevice()) {
         LOG(ERROR) << "Failed to initialize Snapuserd";
         return nullptr;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
index f23f07eb5e4a..ecf5d5c38bda 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
@@ -52,13 +52,11 @@ class ISnapshotHandlerManager {
     virtual ~ISnapshotHandlerManager() {}
 
     // Add a new snapshot handler but do not start serving requests yet.
-    virtual std::shared_ptr<HandlerThread> AddHandler(const std::string& misc_name,
-                                                      const std::string& cow_device_path,
-                                                      const std::string& backing_device,
-                                                      const std::string& base_path_merge,
-                                                      std::shared_ptr<IBlockServerOpener> opener,
-                                                      int num_worker_threads, bool use_iouring,
-                                                      bool o_direct) = 0;
+    virtual std::shared_ptr<HandlerThread> AddHandler(
+            const std::string& misc_name, const std::string& cow_device_path,
+            const std::string& backing_device, const std::string& base_path_merge,
+            std::shared_ptr<IBlockServerOpener> opener, int num_worker_threads, bool use_iouring,
+            bool o_direct, uint32_t cow_op_merge_size) = 0;
 
     // Start serving requests on a snapshot handler.
     virtual bool StartHandler(const std::string& misc_name) = 0;
@@ -98,7 +96,7 @@ class SnapshotHandlerManager final : public ISnapshotHandlerManager {
                                               const std::string& base_path_merge,
                                               std::shared_ptr<IBlockServerOpener> opener,
                                               int num_worker_threads, bool use_iouring,
-                                              bool o_direct) override;
+                                              bool o_direct, uint32_t cow_op_merge_size) override;
     bool StartHandler(const std::string& misc_name) override;
     bool DeleteHandler(const std::string& misc_name) override;
     bool InitiateMerge(const std::string& misc_name) override;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index e6a9a298968d..e2c58741a885 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -32,12 +32,18 @@ using android::base::unique_fd;
 
 MergeWorker::MergeWorker(const std::string& cow_device, const std::string& misc_name,
                          const std::string& base_path_merge,
-                         std::shared_ptr<SnapshotHandler> snapuserd)
-    : Worker(cow_device, misc_name, base_path_merge, snapuserd) {}
+                         std::shared_ptr<SnapshotHandler> snapuserd, uint32_t cow_op_merge_size)
+    : Worker(cow_device, misc_name, base_path_merge, snapuserd),
+      cow_op_merge_size_(cow_op_merge_size) {}
 
 int MergeWorker::PrepareMerge(uint64_t* source_offset, int* pending_ops,
                               std::vector<const CowOperation*>* replace_zero_vec) {
     int num_ops = *pending_ops;
+    // 0 indicates ro.virtual_ab.cow_op_merge_size was not set in the build
+    if (cow_op_merge_size_ != 0) {
+        num_ops = std::min(cow_op_merge_size_, static_cast<uint32_t>(*pending_ops));
+    }
+
     int nr_consecutive = 0;
     bool checkOrderedOp = (replace_zero_vec == nullptr);
     size_t num_blocks = 1;
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.h
index 478d4c8a270c..a19352dad47a 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.h
@@ -23,7 +23,8 @@ namespace snapshot {
 class MergeWorker : public Worker {
   public:
     MergeWorker(const std::string& cow_device, const std::string& misc_name,
-                const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd);
+                const std::string& base_path_merge, std::shared_ptr<SnapshotHandler> snapuserd,
+                uint32_t cow_op_merge_size);
     bool Run();
 
   private:
@@ -53,6 +54,7 @@ class MergeWorker : public Worker {
     // syscalls and fallback to synchronous I/O, we
     // don't want huge queue depth
     int queue_depth_ = 8;
+    uint32_t cow_op_merge_size_ = 0;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
index 05ba047b5463..7c9a64ee4b8f 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp
@@ -36,7 +36,8 @@ using android::base::unique_fd;
 SnapshotHandler::SnapshotHandler(std::string misc_name, std::string cow_device,
                                  std::string backing_device, std::string base_path_merge,
                                  std::shared_ptr<IBlockServerOpener> opener, int num_worker_threads,
-                                 bool use_iouring, bool perform_verification, bool o_direct) {
+                                 bool use_iouring, bool perform_verification, bool o_direct,
+                                 uint32_t cow_op_merge_size) {
     misc_name_ = std::move(misc_name);
     cow_device_ = std::move(cow_device);
     backing_store_device_ = std::move(backing_device);
@@ -46,6 +47,7 @@ SnapshotHandler::SnapshotHandler(std::string misc_name, std::string cow_device,
     is_io_uring_enabled_ = use_iouring;
     perform_verification_ = perform_verification;
     o_direct_ = o_direct;
+    cow_op_merge_size_ = cow_op_merge_size;
 }
 
 bool SnapshotHandler::InitializeWorkers() {
@@ -60,12 +62,11 @@ bool SnapshotHandler::InitializeWorkers() {
 
         worker_threads_.push_back(std::move(wt));
     }
-
     merge_thread_ = std::make_unique<MergeWorker>(cow_device_, misc_name_, base_path_merge_,
-                                                  GetSharedPtr());
+                                                  GetSharedPtr(), cow_op_merge_size_);
 
     read_ahead_thread_ = std::make_unique<ReadAhead>(cow_device_, backing_store_device_, misc_name_,
-                                                     GetSharedPtr());
+                                                     GetSharedPtr(), cow_op_merge_size_);
 
     update_verify_ = std::make_unique<UpdateVerify>(misc_name_);
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index 9b7238a5d15c..c7de9951f34b 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -104,7 +104,8 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
   public:
     SnapshotHandler(std::string misc_name, std::string cow_device, std::string backing_device,
                     std::string base_path_merge, std::shared_ptr<IBlockServerOpener> opener,
-                    int num_workers, bool use_iouring, bool perform_verification, bool o_direct);
+                    int num_workers, bool use_iouring, bool perform_verification, bool o_direct,
+                    uint32_t cow_op_merge_size);
     bool InitCowDevice();
     bool Start();
 
@@ -247,7 +248,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     bool resume_merge_ = false;
     bool merge_complete_ = false;
     bool o_direct_ = false;
-
+    uint32_t cow_op_merge_size_ = 0;
     std::unique_ptr<UpdateVerify> update_verify_;
     std::shared_ptr<IBlockServerOpener> block_server_opener_;
 };
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index 2baf20ddde83..6b1ed0cd7d98 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -18,6 +18,7 @@
 
 #include <pthread.h>
 
+#include "android-base/properties.h"
 #include "snapuserd_core.h"
 #include "utility.h"
 
@@ -29,11 +30,13 @@ using namespace android::dm;
 using android::base::unique_fd;
 
 ReadAhead::ReadAhead(const std::string& cow_device, const std::string& backing_device,
-                     const std::string& misc_name, std::shared_ptr<SnapshotHandler> snapuserd) {
+                     const std::string& misc_name, std::shared_ptr<SnapshotHandler> snapuserd,
+                     uint32_t cow_op_merge_size) {
     cow_device_ = cow_device;
     backing_store_device_ = backing_device;
     misc_name_ = misc_name;
     snapuserd_ = snapuserd;
+    cow_op_merge_size_ = cow_op_merge_size;
 }
 
 void ReadAhead::CheckOverlap(const CowOperation* cow_op) {
@@ -62,8 +65,11 @@ int ReadAhead::PrepareNextReadAhead(uint64_t* source_offset, int* pending_ops,
                                     std::vector<uint64_t>& blocks,
                                     std::vector<const CowOperation*>& xor_op_vec) {
     int num_ops = *pending_ops;
-    int nr_consecutive = 0;
+    if (cow_op_merge_size_ != 0) {
+        num_ops = std::min(static_cast<int>(cow_op_merge_size_), *pending_ops);
+    }
 
+    int nr_consecutive = 0;
     bool is_ops_present = (!RAIterDone() && num_ops);
 
     if (!is_ops_present) {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.h
index d3ba1265bb83..4885c9608716 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.h
@@ -35,7 +35,8 @@ class SnapshotHandler;
 class ReadAhead {
   public:
     ReadAhead(const std::string& cow_device, const std::string& backing_device,
-              const std::string& misc_name, std::shared_ptr<SnapshotHandler> snapuserd);
+              const std::string& misc_name, std::shared_ptr<SnapshotHandler> snapuserd,
+              uint32_t cow_op_merge_size);
     bool RunThread();
 
   private:
@@ -106,6 +107,7 @@ class ReadAhead {
     // syscalls and fallback to synchronous I/O, we
     // don't want huge queue depth
     int queue_depth_ = 8;
+    uint32_t cow_op_merge_size_;
     std::unique_ptr<struct io_uring> ring_;
 };
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index 0b881b683e65..c0af5c5b7cc7 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -347,7 +347,8 @@ std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string&
                                                               const std::string& cow_device_path,
                                                               const std::string& backing_device,
                                                               const std::string& base_path_merge,
-                                                              const bool o_direct) {
+                                                              const bool o_direct,
+                                                              uint32_t cow_op_merge_size) {
     // We will need multiple worker threads only during
     // device boot after OTA. For all other purposes,
     // one thread is sufficient. We don't want to consume
@@ -369,7 +370,8 @@ std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string&
     auto opener = block_server_factory_->CreateOpener(misc_name);
 
     return handlers_->AddHandler(misc_name, cow_device_path, backing_device, base_path_merge,
-                                 opener, num_worker_threads, io_uring_enabled_, o_direct);
+                                 opener, num_worker_threads, io_uring_enabled_, o_direct,
+                                 cow_op_merge_size);
 }
 
 bool UserSnapshotServer::WaitForSocket() {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index d9cf97f9d396..ceea36ae4638 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -87,7 +87,8 @@ class UserSnapshotServer {
                                               const std::string& cow_device_path,
                                               const std::string& backing_device,
                                               const std::string& base_path_merge,
-                                              bool o_direct = false);
+                                              bool o_direct = false,
+                                              uint32_t cow_op_merge_size = 0);
     bool StartHandler(const std::string& misc_name);
 
     void SetTerminating() { terminating_ = true; }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 6d0ae3d0988f..9042f2bb8655 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -67,6 +67,7 @@ struct TestParam {
     std::string compression;
     int block_size;
     int num_threads;
+    uint32_t cow_op_merge_size;
 };
 
 class SnapuserdTestBase : public ::testing::TestWithParam<TestParam> {
@@ -708,9 +709,9 @@ void SnapuserdTest::InitCowDevice() {
     auto opener = factory->CreateOpener(system_device_ctrl_name_);
     handlers_->DisableVerification();
     const TestParam params = GetParam();
-    auto handler = handlers_->AddHandler(system_device_ctrl_name_, cow_system_->path,
-                                         base_dev_->GetPath(), base_dev_->GetPath(), opener, 1,
-                                         params.io_uring, params.o_direct);
+    auto handler = handlers_->AddHandler(
+            system_device_ctrl_name_, cow_system_->path, base_dev_->GetPath(), base_dev_->GetPath(),
+            opener, 1, params.io_uring, params.o_direct, params.cow_op_merge_size);
     ASSERT_NE(handler, nullptr);
     ASSERT_NE(handler->snapuserd(), nullptr);
 #ifdef __ANDROID__
@@ -1227,9 +1228,9 @@ void HandlerTest::InitializeDevice() {
     ASSERT_NE(opener_, nullptr);
 
     const TestParam params = GetParam();
-    handler_ = std::make_shared<SnapshotHandler>(system_device_ctrl_name_, cow_system_->path,
-                                                 base_dev_->GetPath(), base_dev_->GetPath(),
-                                                 opener_, 1, false, false, params.o_direct);
+    handler_ = std::make_shared<SnapshotHandler>(
+            system_device_ctrl_name_, cow_system_->path, base_dev_->GetPath(), base_dev_->GetPath(),
+            opener_, 1, false, false, params.o_direct, params.cow_op_merge_size);
     ASSERT_TRUE(handler_->InitCowDevice());
     ASSERT_TRUE(handler_->InitializeWorkers());
 
@@ -1507,6 +1508,7 @@ std::vector<TestParam> GetVariableBlockTestConfigs() {
                     param.num_threads = thread;
                     param.io_uring = io_uring;
                     param.o_direct = false;
+                    param.cow_op_merge_size = 0;
                     testParams.push_back(std::move(param));
                 }
             }

From 39fe6e1d384b0730161d6b545199dfb10110de58 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 24 Jul 2024 14:50:01 -0700
Subject: [PATCH 1016/1487] libsnapshot: add test for merge_size param

Add test to make sure that setting the protobuf successfully propogates
the gflag argument to snapuserd_handler.

Bug: 332255580
Test: th
Change-Id: Ic7a008bee7dd3ca29faa0a5409f0513f1551bf37
---
 fs_mgr/libsnapshot/snapshot_test.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 07f13014dd4d..b2e36d426072 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2665,6 +2665,7 @@ TEST_F(SnapshotTest, FlagCheck) {
     status.set_o_direct(true);
     status.set_io_uring_enabled(true);
     status.set_userspace_snapshots(true);
+    status.set_cow_op_merge_size(16);
 
     sm->WriteSnapshotUpdateStatus(lock_.get(), status);
     // Ensure a connection to the second-stage daemon, but use the first-stage
@@ -2686,6 +2687,8 @@ TEST_F(SnapshotTest, FlagCheck) {
                 snapuserd_argv.end());
     ASSERT_TRUE(std::find(snapuserd_argv.begin(), snapuserd_argv.end(), "-user_snapshot") !=
                 snapuserd_argv.end());
+    ASSERT_TRUE(std::find(snapuserd_argv.begin(), snapuserd_argv.end(), "-cow_op_merge_size=16") !=
+                snapuserd_argv.end());
 }
 
 class FlashAfterUpdateTest : public SnapshotUpdateTest,

From 77d388f2858357f4d5229878c3e8f9ce0a359984 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 11 Jul 2024 10:06:47 -0700
Subject: [PATCH 1017/1487] Skip tests if vendor partition is on Android S

Bug: 349278999
Test: vts_libsnapshot_test on GSI config
Signed-off-by: Akilesh Kailash <akailash@google.com>
(cherry picked from https://android-review.googlesource.com/q/commit:6906249312be46b64b6b6221ba33bad196bf6cd6)
Merged-In: I6826b287565e8a78bea21b4830ad30f1c30a01bf
Change-Id: I6826b287565e8a78bea21b4830ad30f1c30a01bf
---
 .../include_test/libsnapshot/test_helpers.h    | 18 ++++++++++++++++++
 fs_mgr/libsnapshot/snapshot_test.cpp           |  7 +++++++
 2 files changed, 25 insertions(+)

diff --git a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
index 90813fe79e69..0afd8bd22ae5 100644
--- a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
+++ b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
@@ -30,6 +30,8 @@
 #include <storage_literals/storage_literals.h>
 #include <update_engine/update_metadata.pb.h>
 
+#include "utility.h"
+
 namespace android {
 namespace snapshot {
 
@@ -234,5 +236,21 @@ bool IsVirtualAbEnabled();
 
 #define RETURN_IF_NON_VIRTUAL_AB() RETURN_IF_NON_VIRTUAL_AB_MSG("")
 
+#define SKIP_IF_VENDOR_ON_ANDROID_S()                                        \
+    do {                                                                     \
+        if (IsVendorFromAndroid12())                                         \
+            GTEST_SKIP() << "Skip test as Vendor partition is on Android S"; \
+    } while (0)
+
+#define RETURN_IF_VENDOR_ON_ANDROID_S_MSG(msg) \
+    do {                                       \
+        if (IsVendorFromAndroid12()) {         \
+            std::cerr << (msg);                \
+            return;                            \
+        }                                      \
+    } while (0)
+
+#define RETURN_IF_VENDOR_ON_ANDROID_S() RETURN_IF_VENDOR_ON_ANDROID_S_MSG("")
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 1435b12bf545..07f13014dd4d 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -122,6 +122,7 @@ class SnapshotTest : public ::testing::Test {
         LOG(INFO) << "Starting test: " << test_name_;
 
         SKIP_IF_NON_VIRTUAL_AB();
+        SKIP_IF_VENDOR_ON_ANDROID_S();
 
         SetupProperties();
         if (!DeviceSupportsMode()) {
@@ -168,6 +169,7 @@ class SnapshotTest : public ::testing::Test {
 
     void TearDown() override {
         RETURN_IF_NON_VIRTUAL_AB();
+        RETURN_IF_VENDOR_ON_ANDROID_S();
 
         LOG(INFO) << "Tearing down SnapshotTest test: " << test_name_;
 
@@ -1015,6 +1017,7 @@ class SnapshotUpdateTest : public SnapshotTest {
   public:
     void SetUp() override {
         SKIP_IF_NON_VIRTUAL_AB();
+        SKIP_IF_VENDOR_ON_ANDROID_S();
 
         SnapshotTest::SetUp();
         if (!image_manager_) {
@@ -1097,6 +1100,7 @@ class SnapshotUpdateTest : public SnapshotTest {
     }
     void TearDown() override {
         RETURN_IF_NON_VIRTUAL_AB();
+        RETURN_IF_VENDOR_ON_ANDROID_S();
 
         LOG(INFO) << "Tearing down SnapshotUpdateTest test: " << test_name_;
 
@@ -2833,6 +2837,7 @@ void SnapshotTestEnvironment::SetUp() {
     // that is fixed, don't call GTEST_SKIP here, but instead call GTEST_SKIP in individual test
     // suites.
     RETURN_IF_NON_VIRTUAL_AB_MSG("Virtual A/B is not enabled, skipping global setup.\n");
+    RETURN_IF_VENDOR_ON_ANDROID_S_MSG("Test not enabled for Vendor on Android S.\n");
 
     std::vector<std::string> paths = {
             // clang-format off
@@ -2887,6 +2892,8 @@ void SnapshotTestEnvironment::SetUp() {
 
 void SnapshotTestEnvironment::TearDown() {
     RETURN_IF_NON_VIRTUAL_AB();
+    RETURN_IF_VENDOR_ON_ANDROID_S();
+
     if (super_images_ != nullptr) {
         DeleteBackingImage(super_images_.get(), "fake-super");
     }

From adaf620dde1cffba59bacf8cb475cabdfcb1eff6 Mon Sep 17 00:00:00 2001
From: Antonio Kantek <kanant@google.com>
Date: Thu, 25 Jul 2024 16:07:41 -0700
Subject: [PATCH 1018/1487] Enable secondary_user_on_secondary_display for
 CtsFsMgrTestCases

secondary_user_on_secondary_display is for background users that have
access to UI on assigned displays (a.k.a. visible background users) on devices
that have config_multiuserVisibleBackgroundUsers enabled. The main use
case is Automotive's multi-display Whole Cabin experience where
passengers (modeled as visible background users) can interact with the display
in front of them concurrently with the driver (modeled as the the
current user) interacting with driver's display.

Bug: 349714805
Flag: EXEMPT test fix
Test: atest CtsFsMgrTestCases
Test: atest --user-type secondary_user_on_secondary_display CtsFsMgrTestCases
Change-Id: I0e4498fd431f5c70135d8704f1d2fa5476620ef1
---
 fs_mgr/tests/AndroidTest.xml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs_mgr/tests/AndroidTest.xml b/fs_mgr/tests/AndroidTest.xml
index de835b3adfba..1c06ebd337be 100644
--- a/fs_mgr/tests/AndroidTest.xml
+++ b/fs_mgr/tests/AndroidTest.xml
@@ -16,6 +16,7 @@
     <option name="config-descriptor:metadata" key="parameter" value="not_instant_app" />
     <option name="config-descriptor:metadata" key="parameter" value="multi_abi" />
     <option name="config-descriptor:metadata" key="parameter" value="secondary_user" />
+    <option name="config-descriptor:metadata" key="parameter" value="secondary_user_on_secondary_display" />
     <target_preparer class="com.android.compatibility.common.tradefed.targetprep.FilePusher">
         <option name="cleanup" value="true" />
         <option name="push" value="CtsFsMgrTestCases->/data/local/tmp/CtsFsMgrTestCases" />

From 1f00f794e6585b73881ac2f11f1fdede1278e54e Mon Sep 17 00:00:00 2001
From: "Chaitanya Cheemala (xWF)" <ccheemala@google.com>
Date: Tue, 30 Jul 2024 09:05:17 +0000
Subject: [PATCH 1019/1487] Revert "Set block device as RO/RW before mount"

This reverts commit c6dfdbb761da5709b0cb9379ea2a9908775dd2fd.

Reason for revert: Likely culprit for b/356319388  - verifying through ABTD before revert submission. This is part of the standard investigation process, and does not mean your CL will be reverted.

Change-Id: Ibd85b26a02f0278676f330c6825d3cb15eefe3fc
---
 fs_mgr/fs_mgr.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index ea2e3a8c754b..5156754a8538 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -826,9 +826,6 @@ static int __mount(const std::string& source, const std::string& target, const F
     if (read_only) {
         mountflags |= MS_RDONLY;
     }
-    if (!fs_mgr_set_blk_ro(source, read_only)) {
-        PLOG(ERROR) << "Failed to set " << source << " as " << (read_only ? "RO" : "RW");
-    }
     int ret = 0;
     int save_errno = 0;
     int gc_allowance = 0;
@@ -883,6 +880,9 @@ static int __mount(const std::string& source, const std::string& target, const F
     }
     PINFO << __FUNCTION__ << "(source=" << source << source_missing << ",target=" << target
           << target_missing << ",type=" << entry.fs_type << ")=" << ret;
+    if ((ret == 0) && (mountflags & MS_RDONLY) != 0) {
+        fs_mgr_set_blk_ro(source);
+    }
     if (ret == 0) {
         android::base::SetProperty("ro.boottime.init.mount." + Basename(target),
                                    std::to_string(t.duration().count()));

From 9ca9303b051d71fa9b7d96b570187ef396538879 Mon Sep 17 00:00:00 2001
From: Daniel Rosenberg <drosen@google.com>
Date: Mon, 29 Jul 2024 14:23:28 -0700
Subject: [PATCH 1020/1487] Format if Encryption was Interrupted

If we're partially through setting up metadata encryption, failures
leave the partition in a known bad state, and we can avoid an eventual
boot into recovery by taking the format path.

Bug: 351704691
Test: Inserted debug code to reboot during initial encryption setup
      Verified device boots successfully on second attempt
Change-Id: I2d8591fa68ab0656e42b7b12f69001a5897e1a61
---
 fs_mgr/fs_mgr.cpp       | 42 ++++++++++++++++++++++++++++++++---------
 fs_mgr/include/fs_mgr.h |  4 ++++
 2 files changed, 37 insertions(+), 9 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 5156754a8538..003c6fbb4303 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -930,7 +930,8 @@ static bool should_use_metadata_encryption(const FstabEntry& entry) {
 // attempted_idx: On return, will indicate which fstab entry
 //     succeeded. In case of failure, it will be the start_idx.
 // Sets errno to match the 1st mount failure on failure.
-static bool mount_with_alternatives(Fstab& fstab, int start_idx, int* end_idx, int* attempted_idx) {
+static bool mount_with_alternatives(Fstab& fstab, int start_idx, bool interrupted, int* end_idx,
+                                    int* attempted_idx) {
     unsigned long i;
     int mount_errno = 0;
     bool mounted = false;
@@ -949,6 +950,13 @@ static bool mount_with_alternatives(Fstab& fstab, int start_idx, int* end_idx, i
             continue;
         }
 
+        if (interrupted) {
+            LINFO << __FUNCTION__ << "(): skipping fstab mountpoint=" << fstab[i].mount_point
+                  << " rec[" << i << "].fs_type=" << fstab[i].fs_type
+                  << " (previously interrupted during encryption step)";
+            continue;
+        }
+
         // fstab[start_idx].blk_device is already updated to /dev/dm-<N> by
         // AVB related functions. Copy it from start_idx to the current index i.
         if ((i != start_idx) && fstab[i].fs_mgr_flags.logical &&
@@ -1416,6 +1424,15 @@ static bool IsMountPointMounted(const std::string& mount_point) {
     return GetEntryForMountPoint(&fstab, mount_point) != nullptr;
 }
 
+std::string fs_mgr_metadata_encryption_in_progress_file_name(const FstabEntry& entry) {
+    return entry.metadata_key_dir + "/in_progress";
+}
+
+bool WasMetadataEncryptionInterrupted(const FstabEntry& entry) {
+    if (!should_use_metadata_encryption(entry)) return false;
+    return access(fs_mgr_metadata_encryption_in_progress_file_name(entry).c_str(), R_OK) == 0;
+}
+
 // When multiple fstab records share the same mount_point, it will try to mount each
 // one in turn, and ignore any duplicates after a first successful mount.
 // Returns -1 on error, and  FS_MGR_MNTALL_* otherwise.
@@ -1530,7 +1547,9 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
         int top_idx = i;
         int attempted_idx = -1;
 
-        bool mret = mount_with_alternatives(*fstab, i, &last_idx_inspected, &attempted_idx);
+        bool encryption_interrupted = WasMetadataEncryptionInterrupted(current_entry);
+        bool mret = mount_with_alternatives(*fstab, i, encryption_interrupted, &last_idx_inspected,
+                                            &attempted_idx);
         auto& attempted_entry = (*fstab)[attempted_idx];
         i = last_idx_inspected;
         int mount_errno = errno;
@@ -1579,13 +1598,18 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
         // Mounting failed, understand why and retry.
         wiped = partition_wiped(current_entry.blk_device.c_str());
         if (mount_errno != EBUSY && mount_errno != EACCES &&
-            current_entry.fs_mgr_flags.formattable && wiped) {
+            current_entry.fs_mgr_flags.formattable && (wiped || encryption_interrupted)) {
             // current_entry and attempted_entry point at the same partition, but sometimes
             // at two different lines in the fstab.  Use current_entry for formatting
             // as that is the preferred one.
-            LERROR << __FUNCTION__ << "(): " << realpath(current_entry.blk_device)
-                   << " is wiped and " << current_entry.mount_point << " " << current_entry.fs_type
-                   << " is formattable. Format it.";
+            if (wiped)
+                LERROR << __FUNCTION__ << "(): " << realpath(current_entry.blk_device)
+                       << " is wiped and " << current_entry.mount_point << " "
+                       << current_entry.fs_type << " is formattable. Format it.";
+            if (encryption_interrupted)
+                LERROR << __FUNCTION__ << "(): " << realpath(current_entry.blk_device)
+                       << " was interrupted during encryption and " << current_entry.mount_point
+                       << " " << current_entry.fs_type << " is formattable. Format it.";
 
             checkpoint_manager.Revert(&current_entry);
 
@@ -1625,7 +1649,7 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
         }
 
         // mount(2) returned an error, handle the encryptable/formattable case.
-        if (mount_errno != EBUSY && mount_errno != EACCES &&
+        if (mount_errno != EBUSY && mount_errno != EACCES && !encryption_interrupted &&
             should_use_metadata_encryption(attempted_entry)) {
             if (!call_vdc({"cryptfs", "mountFstab", attempted_entry.blk_device,
                            attempted_entry.mount_point,
@@ -1643,13 +1667,13 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
             // Use StringPrintf to output "(null)" instead.
             if (attempted_entry.fs_mgr_flags.no_fail) {
                 PERROR << android::base::StringPrintf(
-                        "Ignoring failure to mount an un-encryptable or wiped "
+                        "Ignoring failure to mount an un-encryptable, interrupted, or wiped "
                         "partition on %s at %s options: %s",
                         attempted_entry.blk_device.c_str(), attempted_entry.mount_point.c_str(),
                         attempted_entry.fs_options.c_str());
             } else {
                 PERROR << android::base::StringPrintf(
-                        "Failed to mount an un-encryptable or wiped partition "
+                        "Failed to mount an un-encryptable, interrupted, or wiped partition "
                         "on %s at %s options: %s",
                         attempted_entry.blk_device.c_str(), attempted_entry.mount_point.c_str(),
                         attempted_entry.fs_options.c_str());
diff --git a/fs_mgr/include/fs_mgr.h b/fs_mgr/include/fs_mgr.h
index bc4a7a6c2cf5..2e1cf76ea46f 100644
--- a/fs_mgr/include/fs_mgr.h
+++ b/fs_mgr/include/fs_mgr.h
@@ -144,3 +144,7 @@ bool fs_mgr_create_canonical_mount_point(const std::string& mount_point);
 // Unlike fs_mgr_overlayfs, mount overlayfs without upperdir and workdir, so the
 // filesystem cannot be remount read-write.
 bool fs_mgr_mount_overlayfs_fstab_entry(const android::fs_mgr::FstabEntry& entry);
+
+// File name used to track if encryption was interrupted, leading to a known bad fs state
+std::string fs_mgr_metadata_encryption_in_progress_file_name(
+        const android::fs_mgr::FstabEntry& entry);

From fcbb743d86f2842e33189d360d0202027dd28e64 Mon Sep 17 00:00:00 2001
From: Inseob Kim <inseob@google.com>
Date: Tue, 30 Jul 2024 16:32:20 +0900
Subject: [PATCH 1021/1487] Migrate init.environ.rc module to Soong

Makefile module still remains to handle post install commands. We're
going to move that to somewhere else as a followup.

Bug: 353429422
Test: boot with and without USE_SOONG_DEFINED_SYSTEM_IMAGE
Change-Id: I85ec048e6e57981ad4496ea90762aa34bd9a5ca1
---
 rootdir/Android.bp | 53 ++++++++++++++++++++++++++++++++++++++++++++++
 rootdir/Android.mk | 44 ++++++--------------------------------
 2 files changed, 59 insertions(+), 38 deletions(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 7105ed52a8ba..3b79cd5e6dc5 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -134,3 +134,56 @@ llndk_libraries_txt {
 sanitizer_libraries_txt {
     name: "sanitizer.libraries.txt",
 }
+
+EXPORT_GLOBAL_ASAN_OPTIONS = select(soong_config_variable("ANDROID", "ASAN_ENABLED"), {
+    true: "export ASAN_OPTIONS include=/system/asan.options",
+    default: "",
+})
+
+EXPORT_GLOBAL_HWASAN_OPTIONS = select((soong_config_variable("ANDROID", "HWASAN_ENABLED"), soong_config_variable("ANDROID", "HWADDRESS_SANITIZER_GLOBAL_OPTIONS")), {
+    (true, ""): "",
+    (true, any @ options): "export HWASAN_OPTIONS " + options,
+    (default, default): "",
+})
+
+EXPORT_GLOBAL_GCOV_OPTIONS = select(soong_config_variable("ANDROID", "GCOV_COVERAGE"), {
+    true: "export GCOV_PREFIX /data/misc/trace",
+    default: "",
+})
+
+EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS = select((soong_config_variable("ANDROID", "CLANG_COVERAGE"), soong_config_variable("ANDROID", "CLANG_COVERAGE_CONTINUOUS_MODE")), {
+    (true, true): "export LLVM_PROFILE_FILE /data/misc/trace/clang%c-%20m.profraw",
+    (true, default): "export LLVM_PROFILE_FILE /data/misc/trace/clang-%20m.profraw",
+    (default, default): "",
+})
+
+EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE = select(soong_config_variable("ANDROID", "SCUDO_ALLOCATION_RING_BUFFER_SIZE"), {
+    "": "",
+    any @ size: "export SCUDO_ALLOCATION_RING_BUFFER_SIZE " + size,
+    default: "",
+})
+
+genrule {
+    name: "init.environ.rc.gen",
+    srcs: ["init.environ.rc.in"],
+    out: ["init.environ.rc"],
+    cmd: "cp -f $(in) $(out) && " +
+        "sed -i -e 's?%EXPORT_GLOBAL_ASAN_OPTIONS%?" + EXPORT_GLOBAL_ASAN_OPTIONS + "?g' $(out) && " +
+        "sed -i -e 's?%EXPORT_GLOBAL_GCOV_OPTIONS%?" + EXPORT_GLOBAL_GCOV_OPTIONS + "?g' $(out) && " +
+        "sed -i -e 's?%EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS%?" + EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS + "?g' $(out) && " +
+        "sed -i -e 's?%EXPORT_GLOBAL_HWASAN_OPTIONS%?" + EXPORT_GLOBAL_HWASAN_OPTIONS + "?g' $(out) && " +
+        "sed -i -e 's?%EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE%?" + EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE + "?g' $(out)",
+}
+
+prebuilt_root {
+    name: "init.environ.rc-soong",
+    src: ":init.environ.rc.gen",
+    filename: "init.environ.rc",
+    install_in_root: true,
+    no_full_install: true,
+    required: select((soong_config_variable("ANDROID", "ASAN_ENABLED"), soong_config_variable("ANDROID", "SANITIZE_TARGET_SYSTEM_ENABLED")), {
+        (true, true): ["asan.options", "asan_extract"],
+        (true, default): ["asan.options"],
+        (default, default): [],
+    }),
+}
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index e6ccda788a1c..e743743bd832 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -11,6 +11,7 @@ endif
 endif
 #######################################
 # init.environ.rc
+# TODO(b/353429422): move LOCAL_POST_INSTALL_CMD to other rules and remove Android.mk module.
 
 include $(CLEAR_VARS)
 LOCAL_MODULE_CLASS := ETC
@@ -19,36 +20,8 @@ LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
 LOCAL_LICENSE_CONDITIONS := notice
 LOCAL_MODULE_PATH := $(TARGET_ROOT_OUT)
 
-EXPORT_GLOBAL_ASAN_OPTIONS :=
 ifneq ($(filter address,$(SANITIZE_TARGET)),)
-  EXPORT_GLOBAL_ASAN_OPTIONS := export ASAN_OPTIONS include=/system/asan.options
-  LOCAL_REQUIRED_MODULES := asan.options $(ASAN_OPTIONS_FILES) $(ASAN_EXTRACT_FILES)
-endif
-
-EXPORT_GLOBAL_HWASAN_OPTIONS :=
-ifneq ($(filter hwaddress,$(SANITIZE_TARGET)),)
-  ifneq ($(HWADDRESS_SANITIZER_GLOBAL_OPTIONS),)
-    EXPORT_GLOBAL_HWASAN_OPTIONS := export HWASAN_OPTIONS $(HWADDRESS_SANITIZER_GLOBAL_OPTIONS)
-  endif
-endif
-
-EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE :=
-ifneq ($(PRODUCT_SCUDO_ALLOCATION_RING_BUFFER_SIZE),)
-  EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE := export SCUDO_ALLOCATION_RING_BUFFER_SIZE $(PRODUCT_SCUDO_ALLOCATION_RING_BUFFER_SIZE)
-endif
-
-EXPORT_GLOBAL_GCOV_OPTIONS :=
-ifeq ($(NATIVE_COVERAGE),true)
-  EXPORT_GLOBAL_GCOV_OPTIONS := export GCOV_PREFIX /data/misc/trace
-endif
-
-EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS :=
-ifeq ($(CLANG_COVERAGE),true)
-  ifeq ($(CLANG_COVERAGE_CONTINUOUS_MODE),true)
-    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang%c-%20m.profraw
-  else
-    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang-%20m.profraw
-  endif
+  LOCAL_REQUIRED_MODULES := asan.options $(ASAN_EXTRACT_FILES)
 endif
 
 # Put it here instead of in init.rc module definition,
@@ -173,15 +146,10 @@ ALL_DEFAULT_INSTALLED_MODULES += $(ALL_ROOTDIR_SYMLINKS)
 include $(BUILD_SYSTEM)/base_rules.mk
 
 $(ALL_ROOTDIR_SYMLINKS): $(LOCAL_BUILT_MODULE)
-$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/init.environ.rc.in
-	@echo "Generate: $< -> $@"
-	@mkdir -p $(dir $@)
-	$(hide) cp $< $@
-	$(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' $@
-	$(hide) sed -i -e 's?%EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE%?$(EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE)?g' $@
+
+init.environ.rc-soong := $(call intermediates-dir-for,ETC,init.environ.rc-soong)/init.environ.rc-soong
+$(eval $(call copy-one-file,$(init.environ.rc-soong),$(LOCAL_BUILT_MODULE)))
+init.environ.rc-soong :=
 
 #######################################
 # ramdisk_node_list

From 2fea1dd4abdb2250a94fe4a048b8d09a08a82f35 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= <arve@android.com>
Date: Wed, 13 Sep 2023 17:51:20 -0700
Subject: [PATCH 1022/1487] trusty: gatekeeper: Add device option

Add commandline option to specify the trusty device to use.

Bug: 300338484
Test: VtsHalGatekeeperTargetTest
Change-Id: Ib2ef34dfc104c65119a98937280ae9db74417766
---
 trusty/gatekeeper/service.cpp             | 56 ++++++++++++++++++++++-
 trusty/gatekeeper/trusty_gatekeeper_ipc.c |  9 ++--
 trusty/gatekeeper/trusty_gatekeeper_ipc.h |  1 +
 3 files changed, 62 insertions(+), 4 deletions(-)

diff --git a/trusty/gatekeeper/service.cpp b/trusty/gatekeeper/service.cpp
index d09804f9a6e6..59366b84d112 100644
--- a/trusty/gatekeeper/service.cpp
+++ b/trusty/gatekeeper/service.cpp
@@ -18,12 +18,66 @@
 #include <android-base/logging.h>
 #include <android/binder_manager.h>
 #include <android/binder_process.h>
+#include <getopt.h>
 
 #include "trusty_gatekeeper.h"
+#include "trusty_gatekeeper_ipc.h"
 
 using aidl::android::hardware::gatekeeper::TrustyGateKeeperDevice;
 
-int main() {
+static const char* _sopts = "hD:";
+static const struct option _lopts[] = {
+        {"help", no_argument, 0, 'h'},
+        {"dev", required_argument, 0, 'D'},
+        {0, 0, 0, 0},
+};
+
+static const char* usage =
+        "Usage: %s [options]\n"
+        "\n"
+        "options:\n"
+        "  -h, --help            prints this message and exit\n"
+        "  -D, --dev name        Trusty device name\n"
+        "\n";
+
+static const char* usage_long = "\n";
+
+static void print_usage_and_exit(const char* prog, int code, bool verbose) {
+    fprintf(stderr, usage, prog);
+    if (verbose) {
+        fprintf(stderr, "%s", usage_long);
+    }
+    exit(code);
+}
+
+static void parse_options(int argc, char** argv) {
+    int c;
+    int oidx = 0;
+
+    while (1) {
+        c = getopt_long(argc, argv, _sopts, _lopts, &oidx);
+        if (c == -1) {
+            break; /* done */
+        }
+
+        switch (c) {
+            case 'D':
+                trusty_gatekeeper_set_dev_name(optarg);
+                break;
+
+            case 'h':
+                print_usage_and_exit(argv[0], EXIT_SUCCESS, true);
+                break;
+
+            default:
+                print_usage_and_exit(argv[0], EXIT_FAILURE, false);
+        }
+    }
+}
+
+int main(int argc, char** argv) {
+    parse_options(argc, argv);
+
     ABinderProcess_setThreadPoolMaxThreadCount(0);
 
     std::shared_ptr<TrustyGateKeeperDevice> gatekeeper =
diff --git a/trusty/gatekeeper/trusty_gatekeeper_ipc.c b/trusty/gatekeeper/trusty_gatekeeper_ipc.c
index f67944b35de6..5ca951cd5c47 100644
--- a/trusty/gatekeeper/trusty_gatekeeper_ipc.c
+++ b/trusty/gatekeeper/trusty_gatekeeper_ipc.c
@@ -28,12 +28,15 @@
 #include "trusty_gatekeeper_ipc.h"
 #include "gatekeeper_ipc.h"
 
-#define TRUSTY_DEVICE_NAME "/dev/trusty-ipc-dev0"
-
+static const char* trusty_device_name = "/dev/trusty-ipc-dev0";
 static int handle_ = 0;
 
+void trusty_gatekeeper_set_dev_name(const char* device_name) {
+    trusty_device_name = device_name;
+}
+
 int trusty_gatekeeper_connect() {
-    int rc = tipc_connect(TRUSTY_DEVICE_NAME, GATEKEEPER_PORT);
+    int rc = tipc_connect(trusty_device_name, GATEKEEPER_PORT);
     if (rc < 0) {
         return rc;
     }
diff --git a/trusty/gatekeeper/trusty_gatekeeper_ipc.h b/trusty/gatekeeper/trusty_gatekeeper_ipc.h
index f8de7f87389c..47ba33b38a7f 100644
--- a/trusty/gatekeeper/trusty_gatekeeper_ipc.h
+++ b/trusty/gatekeeper/trusty_gatekeeper_ipc.h
@@ -16,6 +16,7 @@
 
 __BEGIN_DECLS
 
+void trusty_gatekeeper_set_dev_name(const char* device_name);
 int trusty_gatekeeper_connect();
 int trusty_gatekeeper_call(uint32_t cmd, void *in, uint32_t in_size, uint8_t *out,
                            uint32_t *out_size);

From 31154a9e609382048c9533b2a73a945fa6ddbbca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= <arve@android.com>
Date: Wed, 13 Sep 2023 18:08:41 -0700
Subject: [PATCH 1023/1487] trusty: keymaster: Add commandline option to
 specify device name

Bug: 300338484
Test: VtsAidlKeyMintTargetTest (emulator subset)
Change-Id: I7ca0a7e72b55fcf9e9b015f68425b67c778aca9e
---
 .../ipc/trusty_keymaster_ipc.h                |  1 +
 trusty/keymaster/ipc/trusty_keymaster_ipc.cpp |  7 ++-
 trusty/keymaster/keymint/service.cpp          | 55 ++++++++++++++++++-
 3 files changed, 60 insertions(+), 3 deletions(-)

diff --git a/trusty/keymaster/include/trusty_keymaster/ipc/trusty_keymaster_ipc.h b/trusty/keymaster/include/trusty_keymaster/ipc/trusty_keymaster_ipc.h
index efad254c8b9b..15241f4ab355 100644
--- a/trusty/keymaster/include/trusty_keymaster/ipc/trusty_keymaster_ipc.h
+++ b/trusty/keymaster/include/trusty_keymaster/ipc/trusty_keymaster_ipc.h
@@ -26,6 +26,7 @@ const uint32_t TRUSTY_KEYMASTER_RECV_BUF_SIZE = 2 * 4096;
 const uint32_t TRUSTY_KEYMASTER_SEND_BUF_SIZE =
         (4096 - sizeof(struct keymaster_message) - 16 /* tipc header */);
 
+void trusty_keymaster_set_dev_name(const char* device_name);
 int trusty_keymaster_connect(void);
 int trusty_keymaster_call(uint32_t cmd, void* in, uint32_t in_size, uint8_t* out,
                           uint32_t* out_size);
diff --git a/trusty/keymaster/ipc/trusty_keymaster_ipc.cpp b/trusty/keymaster/ipc/trusty_keymaster_ipc.cpp
index db1a9f40782e..c01877fe8961 100644
--- a/trusty/keymaster/ipc/trusty_keymaster_ipc.cpp
+++ b/trusty/keymaster/ipc/trusty_keymaster_ipc.cpp
@@ -36,15 +36,18 @@
 #include <trusty_keymaster/ipc/trusty_keymaster_ipc.h>
 #include <utils/Timers.h>
 
-#define TRUSTY_DEVICE_NAME "/dev/trusty-ipc-dev0"
+static const char* trusty_device_name = "/dev/trusty-ipc-dev0";
 
 static int handle_ = -1;
 
 static const int timeout_ms = 10 * 1000;
 static const int max_timeout_ms = 60 * 1000;
 
+void trusty_keymaster_set_dev_name(const char* device_name) {
+    trusty_device_name = device_name;
+}
 int trusty_keymaster_connect() {
-    int rc = tipc_connect(TRUSTY_DEVICE_NAME, KEYMASTER_PORT);
+    int rc = tipc_connect(trusty_device_name, KEYMASTER_PORT);
     if (rc < 0) {
         return rc;
     }
diff --git a/trusty/keymaster/keymint/service.cpp b/trusty/keymaster/keymint/service.cpp
index 14549d2b7160..583d8402416d 100644
--- a/trusty/keymaster/keymint/service.cpp
+++ b/trusty/keymaster/keymint/service.cpp
@@ -18,11 +18,13 @@
 #include <android-base/logging.h>
 #include <android/binder_manager.h>
 #include <android/binder_process.h>
+#include <getopt.h>
 
 #include <trusty_keymaster/TrustyKeyMintDevice.h>
 #include <trusty_keymaster/TrustyRemotelyProvisionedComponentDevice.h>
 #include <trusty_keymaster/TrustySecureClock.h>
 #include <trusty_keymaster/TrustySharedSecret.h>
+#include <trusty_keymaster/ipc/trusty_keymaster_ipc.h>
 
 using aidl::android::hardware::security::keymint::trusty::TrustyKeyMintDevice;
 using aidl::android::hardware::security::keymint::trusty::TrustyRemotelyProvisionedComponentDevice;
@@ -39,7 +41,58 @@ std::shared_ptr<T> addService(Args&&... args) {
     return service;
 }
 
-int main() {
+static const char* _sopts = "hD:";
+static const struct option _lopts[] = {
+        {"help", no_argument, 0, 'h'},
+        {"dev", required_argument, 0, 'D'},
+        {0, 0, 0, 0},
+};
+
+static const char* usage =
+        "Usage: %s [options]\n"
+        "\n"
+        "options:\n"
+        "  -h, --help            prints this message and exit\n"
+        "  -D, --dev name        Trusty device name\n"
+        "\n";
+
+static const char* usage_long = "\n";
+
+static void print_usage_and_exit(const char* prog, int code, bool verbose) {
+    fprintf(stderr, usage, prog);
+    if (verbose) {
+        fprintf(stderr, "%s", usage_long);
+    }
+    exit(code);
+}
+
+static void parse_options(int argc, char** argv) {
+    int c;
+    int oidx = 0;
+
+    while (1) {
+        c = getopt_long(argc, argv, _sopts, _lopts, &oidx);
+        if (c == -1) {
+            break; /* done */
+        }
+
+        switch (c) {
+            case 'D':
+                trusty_keymaster_set_dev_name(optarg);
+                break;
+
+            case 'h':
+                print_usage_and_exit(argv[0], EXIT_SUCCESS, true);
+                break;
+
+            default:
+                print_usage_and_exit(argv[0], EXIT_FAILURE, false);
+        }
+    }
+}
+
+int main(int argc, char** argv) {
+    parse_options(argc, argv);
     auto trustyKeymaster = std::make_shared<keymaster::TrustyKeymaster>();
     int err = trustyKeymaster->Initialize(keymaster::KmVersion::KEYMINT_3);
     if (err != 0) {

From b4158e2599e5413d26123266317b639a0c3c4a23 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= <arve@android.com>
Date: Wed, 13 Sep 2023 18:20:38 -0700
Subject: [PATCH 1024/1487] trusty: keymint: Add commandline option to specify
 device name

Bug: 300338484
Test: VtsAidlKeyMintTargetTest (emulator subset)
Change-Id: Ibaa89dd0a3db65565101c0a37303c7155f999fb7
---
 trusty/keymint/Android.bp              |  3 ++-
 trusty/keymint/src/keymint_hal_main.rs | 22 ++++++++++++++++++----
 2 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/trusty/keymint/Android.bp b/trusty/keymint/Android.bp
index 19dcc98753f4..92d9c6fbb01d 100644
--- a/trusty/keymint/Android.bp
+++ b/trusty/keymint/Android.bp
@@ -24,11 +24,12 @@ rust_binary {
     init_rc: ["android.hardware.security.keymint-service.rust.trusty.rc"],
     vintf_fragments: ["android.hardware.security.keymint-service.rust.trusty.xml"],
     srcs: [
-        "src/keymint_hal_main.rs"
+        "src/keymint_hal_main.rs",
     ],
     rustlibs: [
         "libandroid_logger",
         "libbinder_rs",
+        "libclap",
         "libkmr_wire",
         "libkmr_hal",
         "libtrusty-rs",
diff --git a/trusty/keymint/src/keymint_hal_main.rs b/trusty/keymint/src/keymint_hal_main.rs
index ef0c598fe4d1..3c5627bd18e4 100644
--- a/trusty/keymint/src/keymint_hal_main.rs
+++ b/trusty/keymint/src/keymint_hal_main.rs
@@ -14,6 +14,7 @@
 // limitations under the License.
 
 //! This module implements the HAL service for Keymint (Rust) in Trusty.
+use clap::Parser;
 use kmr_hal::{
     extract_rsp, keymint, rpc, secureclock, send_hal_info, sharedsecret, SerializedChannel,
 };
@@ -81,6 +82,13 @@ impl SerializedChannel for TipcChannel {
     }
 }
 
+#[derive(Parser, Debug)]
+struct Args {
+    /// Tipc device path
+    #[arg(short, long, default_value_t = DEFAULT_DEVICE.to_string())]
+    dev: String,
+}
+
 fn main() {
     if let Err(HalServiceError(e)) = inner_main() {
         panic!("HAL service failed: {:?}", e);
@@ -88,6 +96,7 @@ fn main() {
 }
 
 fn inner_main() -> Result<(), HalServiceError> {
+    let args = Args::parse();
     // Initialize Android logging.
     android_logger::init_once(
         android_logger::Config::default()
@@ -106,10 +115,15 @@ fn inner_main() -> Result<(), HalServiceError> {
     binder::ProcessState::start_thread_pool();
 
     // Create connection to the TA
-    let connection = trusty::TipcChannel::connect(DEFAULT_DEVICE, TRUSTY_KEYMINT_RUST_SERVICE_NAME)
-        .map_err(|e| {
-            HalServiceError(format!("Failed to connect to Trusty Keymint TA because of {:?}.", e))
-        })?;
+    let connection =
+        trusty::TipcChannel::connect(args.dev.as_str(), TRUSTY_KEYMINT_RUST_SERVICE_NAME).map_err(
+            |e| {
+                HalServiceError(format!(
+                    "Failed to connect to Trusty Keymint TA at {} because of {:?}.",
+                    args.dev, e
+                ))
+            },
+        )?;
     let tipc_channel = Arc::new(Mutex::new(TipcChannel(connection)));
 
     // Register the Keymint service

From b654f2c287fd6504da2b46317c919b100842a96c Mon Sep 17 00:00:00 2001
From: Jerome Gaillard <jgaillard@google.com>
Date: Wed, 31 Jul 2024 15:52:09 +0000
Subject: [PATCH 1025/1487] Remove Windows-specific code from Trace.h

libcutils builds for Windows, so there is no need to handle Windows
differently in Trace.h.

Bug: 322360037
Test: build libutils for Windows

Change-Id: If17de95a2222c7d17c74988695d68754f06957ea
---
 libutils/include/utils/Trace.h | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/libutils/include/utils/Trace.h b/libutils/include/utils/Trace.h
index 9986bf5f9004..180910003991 100644
--- a/libutils/include/utils/Trace.h
+++ b/libutils/include/utils/Trace.h
@@ -17,13 +17,6 @@
 #ifndef ANDROID_TRACE_H
 #define ANDROID_TRACE_H
 
-#if defined(_WIN32)
-
-#define ATRACE_NAME(...)
-#define ATRACE_CALL()
-
-#else  // !_WIN32
-
 #include <stdint.h>
 
 #include <cutils/trace.h>
@@ -56,6 +49,4 @@ class ScopedTrace {
 
 }  // namespace android
 
-#endif  // _WIN32
-
 #endif // ANDROID_TRACE_H

From bd153e76db333d5f980603b8db2204608ff421f5 Mon Sep 17 00:00:00 2001
From: Liana Kazanova <lkazanova@google.com>
Date: Wed, 31 Jul 2024 17:56:36 +0000
Subject: [PATCH 1026/1487] Revert "Migrate init.environ.rc module to Soong"

Revert submission 3197177-init_environ_rc_soong

Reason for revert: DroidMonitor: Potential culprit for b/356587212 - verifying through ABTD before revert submission. This is part of the standard investigation process, and does not mean your CL will be reverted.

Reverted changes: /q/submissionid:3197177-init_environ_rc_soong

Change-Id: I3834d7f76f4baef747f3536167ad9bd2d2a474b4
---
 rootdir/Android.bp | 53 ----------------------------------------------
 rootdir/Android.mk | 44 ++++++++++++++++++++++++++++++++------
 2 files changed, 38 insertions(+), 59 deletions(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 3b79cd5e6dc5..7105ed52a8ba 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -134,56 +134,3 @@ llndk_libraries_txt {
 sanitizer_libraries_txt {
     name: "sanitizer.libraries.txt",
 }
-
-EXPORT_GLOBAL_ASAN_OPTIONS = select(soong_config_variable("ANDROID", "ASAN_ENABLED"), {
-    true: "export ASAN_OPTIONS include=/system/asan.options",
-    default: "",
-})
-
-EXPORT_GLOBAL_HWASAN_OPTIONS = select((soong_config_variable("ANDROID", "HWASAN_ENABLED"), soong_config_variable("ANDROID", "HWADDRESS_SANITIZER_GLOBAL_OPTIONS")), {
-    (true, ""): "",
-    (true, any @ options): "export HWASAN_OPTIONS " + options,
-    (default, default): "",
-})
-
-EXPORT_GLOBAL_GCOV_OPTIONS = select(soong_config_variable("ANDROID", "GCOV_COVERAGE"), {
-    true: "export GCOV_PREFIX /data/misc/trace",
-    default: "",
-})
-
-EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS = select((soong_config_variable("ANDROID", "CLANG_COVERAGE"), soong_config_variable("ANDROID", "CLANG_COVERAGE_CONTINUOUS_MODE")), {
-    (true, true): "export LLVM_PROFILE_FILE /data/misc/trace/clang%c-%20m.profraw",
-    (true, default): "export LLVM_PROFILE_FILE /data/misc/trace/clang-%20m.profraw",
-    (default, default): "",
-})
-
-EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE = select(soong_config_variable("ANDROID", "SCUDO_ALLOCATION_RING_BUFFER_SIZE"), {
-    "": "",
-    any @ size: "export SCUDO_ALLOCATION_RING_BUFFER_SIZE " + size,
-    default: "",
-})
-
-genrule {
-    name: "init.environ.rc.gen",
-    srcs: ["init.environ.rc.in"],
-    out: ["init.environ.rc"],
-    cmd: "cp -f $(in) $(out) && " +
-        "sed -i -e 's?%EXPORT_GLOBAL_ASAN_OPTIONS%?" + EXPORT_GLOBAL_ASAN_OPTIONS + "?g' $(out) && " +
-        "sed -i -e 's?%EXPORT_GLOBAL_GCOV_OPTIONS%?" + EXPORT_GLOBAL_GCOV_OPTIONS + "?g' $(out) && " +
-        "sed -i -e 's?%EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS%?" + EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS + "?g' $(out) && " +
-        "sed -i -e 's?%EXPORT_GLOBAL_HWASAN_OPTIONS%?" + EXPORT_GLOBAL_HWASAN_OPTIONS + "?g' $(out) && " +
-        "sed -i -e 's?%EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE%?" + EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE + "?g' $(out)",
-}
-
-prebuilt_root {
-    name: "init.environ.rc-soong",
-    src: ":init.environ.rc.gen",
-    filename: "init.environ.rc",
-    install_in_root: true,
-    no_full_install: true,
-    required: select((soong_config_variable("ANDROID", "ASAN_ENABLED"), soong_config_variable("ANDROID", "SANITIZE_TARGET_SYSTEM_ENABLED")), {
-        (true, true): ["asan.options", "asan_extract"],
-        (true, default): ["asan.options"],
-        (default, default): [],
-    }),
-}
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index e743743bd832..e6ccda788a1c 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -11,7 +11,6 @@ endif
 endif
 #######################################
 # init.environ.rc
-# TODO(b/353429422): move LOCAL_POST_INSTALL_CMD to other rules and remove Android.mk module.
 
 include $(CLEAR_VARS)
 LOCAL_MODULE_CLASS := ETC
@@ -20,8 +19,36 @@ LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
 LOCAL_LICENSE_CONDITIONS := notice
 LOCAL_MODULE_PATH := $(TARGET_ROOT_OUT)
 
+EXPORT_GLOBAL_ASAN_OPTIONS :=
 ifneq ($(filter address,$(SANITIZE_TARGET)),)
-  LOCAL_REQUIRED_MODULES := asan.options $(ASAN_EXTRACT_FILES)
+  EXPORT_GLOBAL_ASAN_OPTIONS := export ASAN_OPTIONS include=/system/asan.options
+  LOCAL_REQUIRED_MODULES := asan.options $(ASAN_OPTIONS_FILES) $(ASAN_EXTRACT_FILES)
+endif
+
+EXPORT_GLOBAL_HWASAN_OPTIONS :=
+ifneq ($(filter hwaddress,$(SANITIZE_TARGET)),)
+  ifneq ($(HWADDRESS_SANITIZER_GLOBAL_OPTIONS),)
+    EXPORT_GLOBAL_HWASAN_OPTIONS := export HWASAN_OPTIONS $(HWADDRESS_SANITIZER_GLOBAL_OPTIONS)
+  endif
+endif
+
+EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE :=
+ifneq ($(PRODUCT_SCUDO_ALLOCATION_RING_BUFFER_SIZE),)
+  EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE := export SCUDO_ALLOCATION_RING_BUFFER_SIZE $(PRODUCT_SCUDO_ALLOCATION_RING_BUFFER_SIZE)
+endif
+
+EXPORT_GLOBAL_GCOV_OPTIONS :=
+ifeq ($(NATIVE_COVERAGE),true)
+  EXPORT_GLOBAL_GCOV_OPTIONS := export GCOV_PREFIX /data/misc/trace
+endif
+
+EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS :=
+ifeq ($(CLANG_COVERAGE),true)
+  ifeq ($(CLANG_COVERAGE_CONTINUOUS_MODE),true)
+    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang%c-%20m.profraw
+  else
+    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang-%20m.profraw
+  endif
 endif
 
 # Put it here instead of in init.rc module definition,
@@ -146,10 +173,15 @@ ALL_DEFAULT_INSTALLED_MODULES += $(ALL_ROOTDIR_SYMLINKS)
 include $(BUILD_SYSTEM)/base_rules.mk
 
 $(ALL_ROOTDIR_SYMLINKS): $(LOCAL_BUILT_MODULE)
-
-init.environ.rc-soong := $(call intermediates-dir-for,ETC,init.environ.rc-soong)/init.environ.rc-soong
-$(eval $(call copy-one-file,$(init.environ.rc-soong),$(LOCAL_BUILT_MODULE)))
-init.environ.rc-soong :=
+$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/init.environ.rc.in
+	@echo "Generate: $< -> $@"
+	@mkdir -p $(dir $@)
+	$(hide) cp $< $@
+	$(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' $@
+	$(hide) sed -i -e 's?%EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE%?$(EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE)?g' $@
 
 #######################################
 # ramdisk_node_list

From b7fa335ed80ab016ee8325a2ec561699c812241f Mon Sep 17 00:00:00 2001
From: Inseob Kim <inseob@google.com>
Date: Tue, 30 Jul 2024 16:32:20 +0900
Subject: [PATCH 1027/1487] Reland "Migrate init.environ.rc module to Soong"

Makefile module still remains to handle post install commands. We're
going to move that to somewhere else as a followup.

Relanding with a fix for hwasan build.
HWADDRESS_SANITIZER_GLOBAL_OPTIONS is set by Soong's MakeVars, so we
can't refer the variable on soong config modules. Instead, as the
variable is hard-coded, this change hard-codes options in Android.bp.

Bug: 353429422
Test: boot cuttlefish w/ and w/o USE_SOONG_DEFINED_SYSTEM_IMAGE
Test: boot shiba with SANITIZE_TARGET=hwaddress
Change-Id: I4f61d7f800e0563c49dec0151d4a648ce9814bc9
---
 rootdir/Android.bp | 55 ++++++++++++++++++++++++++++++++++++++++++++++
 rootdir/Android.mk | 44 +++++--------------------------------
 2 files changed, 61 insertions(+), 38 deletions(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 7105ed52a8ba..bbc50534c3ba 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -134,3 +134,58 @@ llndk_libraries_txt {
 sanitizer_libraries_txt {
     name: "sanitizer.libraries.txt",
 }
+
+EXPORT_GLOBAL_ASAN_OPTIONS = select(soong_config_variable("ANDROID", "ASAN_ENABLED"), {
+    true: "export ASAN_OPTIONS include=/system/asan.options",
+    default: "",
+})
+
+EXPORT_GLOBAL_HWASAN_OPTIONS = select(soong_config_variable("ANDROID", "HWASAN_ENABLED"), {
+    true: "export HWASAN_OPTIONS heap_history_size=1023,stack_history_size=512,export_memory_stats=0,max_malloc_fill_size=131072,malloc_fill_byte=0",
+    default: "",
+})
+
+EXPORT_GLOBAL_GCOV_OPTIONS = select(soong_config_variable("ANDROID", "GCOV_COVERAGE"), {
+    true: "export GCOV_PREFIX /data/misc/trace",
+    default: "",
+})
+
+EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS = select((soong_config_variable("ANDROID", "CLANG_COVERAGE"), soong_config_variable("ANDROID", "CLANG_COVERAGE_CONTINUOUS_MODE")), {
+    (true, true): "export LLVM_PROFILE_FILE /data/misc/trace/clang%c-%20m.profraw",
+    (true, default): "export LLVM_PROFILE_FILE /data/misc/trace/clang-%20m.profraw",
+    (default, default): "",
+})
+
+EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE = select(soong_config_variable("ANDROID", "SCUDO_ALLOCATION_RING_BUFFER_SIZE"), {
+    "": "",
+    any @ size: "export SCUDO_ALLOCATION_RING_BUFFER_SIZE " + size,
+    default: "",
+})
+
+genrule {
+    name: "init.environ.rc.gen",
+    srcs: ["init.environ.rc.in"],
+    out: ["init.environ.rc"],
+    cmd: "cp -f $(in) $(out) && " +
+        "sed -i -e 's?%EXPORT_GLOBAL_ASAN_OPTIONS%?" + EXPORT_GLOBAL_ASAN_OPTIONS + "?g' $(out) && " +
+        "sed -i -e 's?%EXPORT_GLOBAL_GCOV_OPTIONS%?" + EXPORT_GLOBAL_GCOV_OPTIONS + "?g' $(out) && " +
+        "sed -i -e 's?%EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS%?" + EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS + "?g' $(out) && " +
+        "sed -i -e 's?%EXPORT_GLOBAL_HWASAN_OPTIONS%?" + EXPORT_GLOBAL_HWASAN_OPTIONS + "?g' $(out) && " +
+        "sed -i -e 's?%EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE%?" + EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE + "?g' $(out)",
+}
+
+prebuilt_root {
+    name: "init.environ.rc-soong",
+    src: ":init.environ.rc.gen",
+    filename: "init.environ.rc",
+    install_in_root: true,
+    no_full_install: true,
+    required: select((soong_config_variable("ANDROID", "ASAN_ENABLED"), soong_config_variable("ANDROID", "SANITIZE_TARGET_SYSTEM_ENABLED")), {
+        (true, true): [
+            "asan.options",
+            "asan_extract",
+        ],
+        (true, default): ["asan.options"],
+        (default, default): [],
+    }),
+}
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index e6ccda788a1c..e743743bd832 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -11,6 +11,7 @@ endif
 endif
 #######################################
 # init.environ.rc
+# TODO(b/353429422): move LOCAL_POST_INSTALL_CMD to other rules and remove Android.mk module.
 
 include $(CLEAR_VARS)
 LOCAL_MODULE_CLASS := ETC
@@ -19,36 +20,8 @@ LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
 LOCAL_LICENSE_CONDITIONS := notice
 LOCAL_MODULE_PATH := $(TARGET_ROOT_OUT)
 
-EXPORT_GLOBAL_ASAN_OPTIONS :=
 ifneq ($(filter address,$(SANITIZE_TARGET)),)
-  EXPORT_GLOBAL_ASAN_OPTIONS := export ASAN_OPTIONS include=/system/asan.options
-  LOCAL_REQUIRED_MODULES := asan.options $(ASAN_OPTIONS_FILES) $(ASAN_EXTRACT_FILES)
-endif
-
-EXPORT_GLOBAL_HWASAN_OPTIONS :=
-ifneq ($(filter hwaddress,$(SANITIZE_TARGET)),)
-  ifneq ($(HWADDRESS_SANITIZER_GLOBAL_OPTIONS),)
-    EXPORT_GLOBAL_HWASAN_OPTIONS := export HWASAN_OPTIONS $(HWADDRESS_SANITIZER_GLOBAL_OPTIONS)
-  endif
-endif
-
-EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE :=
-ifneq ($(PRODUCT_SCUDO_ALLOCATION_RING_BUFFER_SIZE),)
-  EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE := export SCUDO_ALLOCATION_RING_BUFFER_SIZE $(PRODUCT_SCUDO_ALLOCATION_RING_BUFFER_SIZE)
-endif
-
-EXPORT_GLOBAL_GCOV_OPTIONS :=
-ifeq ($(NATIVE_COVERAGE),true)
-  EXPORT_GLOBAL_GCOV_OPTIONS := export GCOV_PREFIX /data/misc/trace
-endif
-
-EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS :=
-ifeq ($(CLANG_COVERAGE),true)
-  ifeq ($(CLANG_COVERAGE_CONTINUOUS_MODE),true)
-    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang%c-%20m.profraw
-  else
-    EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS := export LLVM_PROFILE_FILE /data/misc/trace/clang-%20m.profraw
-  endif
+  LOCAL_REQUIRED_MODULES := asan.options $(ASAN_EXTRACT_FILES)
 endif
 
 # Put it here instead of in init.rc module definition,
@@ -173,15 +146,10 @@ ALL_DEFAULT_INSTALLED_MODULES += $(ALL_ROOTDIR_SYMLINKS)
 include $(BUILD_SYSTEM)/base_rules.mk
 
 $(ALL_ROOTDIR_SYMLINKS): $(LOCAL_BUILT_MODULE)
-$(LOCAL_BUILT_MODULE): $(LOCAL_PATH)/init.environ.rc.in
-	@echo "Generate: $< -> $@"
-	@mkdir -p $(dir $@)
-	$(hide) cp $< $@
-	$(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' $@
-	$(hide) sed -i -e 's?%EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE%?$(EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE)?g' $@
+
+init.environ.rc-soong := $(call intermediates-dir-for,ETC,init.environ.rc-soong)/init.environ.rc-soong
+$(eval $(call copy-one-file,$(init.environ.rc-soong),$(LOCAL_BUILT_MODULE)))
+init.environ.rc-soong :=
 
 #######################################
 # ramdisk_node_list

From 6c277195abb1118a135eed284dff83f4ba3b70a6 Mon Sep 17 00:00:00 2001
From: Richard Chang <richardycc@google.com>
Date: Thu, 18 Jul 2024 08:03:59 +0000
Subject: [PATCH 1028/1487] fs_mgr: check available space before creating zram
 backing device

This CL adds a check to ensure that there is enough free space on
the device before creating the zram backing device.
If there is not enough space, the zram backing device will not be
created.

Adding a system property 'ro.zram_backing_device_min_free_mb' to
define the minimum free space reserved for booting.
If the property is not set, skip the available space check.

Bug: 322821637
Bug: 326877642
Test: Fill up userdata, enlarge zram backing device size on next
boot.

Change-Id: I135b4beee2a8a21f8214f6579368a8d0d8792255
---
 fs_mgr/fs_mgr.cpp | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 5156754a8538..90fbd5092539 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -28,6 +28,7 @@
 #include <sys/ioctl.h>
 #include <sys/mount.h>
 #include <sys/stat.h>
+#include <sys/statvfs.h>
 #include <sys/swap.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
@@ -2069,11 +2070,45 @@ static bool InstallZramDevice(const std::string& device) {
     return true;
 }
 
+/*
+ * Zram backing device can be created as long as /data has at least `size`
+ * free space, though we may want to leave some extra space for the remaining
+ * boot process and other system activities.
+ */
+static bool ZramBackingDeviceSizeAvailable(off64_t size) {
+    constexpr const char* data_path = "/data";
+    uint64_t min_free_mb =
+            android::base::GetUintProperty<uint64_t>("ro.zram_backing_device_min_free_mb", 0);
+
+    // No min_free property. Skip the available size check.
+    if (min_free_mb == 0) return true;
+
+    struct statvfs vst;
+    if (statvfs(data_path, &vst) < 0) {
+        PERROR << "Cannot check available space: " << data_path;
+        return false;
+    }
+
+    uint64_t size_free = static_cast<uint64_t>(vst.f_bfree) * vst.f_frsize;
+    uint64_t size_required = size + (min_free_mb * 1024 * 1024);
+    if (size_required > size_free) {
+        PERROR << "Free space is not enough for zram backing device: " << size_required << " > "
+               << size_free;
+        return false;
+    }
+    return true;
+}
+
 static bool PrepareZramBackingDevice(off64_t size) {
 
     constexpr const char* file_path = "/data/per_boot/zram_swap";
     if (size == 0) return true;
 
+    // Check available space
+    if (!ZramBackingDeviceSizeAvailable(size)) {
+        PERROR << "No space for target path: " << file_path;
+        return false;
+    }
     // Prepare target path
     unique_fd target_fd(TEMP_FAILURE_RETRY(open(file_path, O_RDWR | O_CREAT | O_CLOEXEC, 0600)));
     if (target_fd.get() == -1) {
@@ -2082,6 +2117,7 @@ static bool PrepareZramBackingDevice(off64_t size) {
     }
     if (fallocate(target_fd.get(), 0, 0, size) < 0) {
         PERROR << "Cannot truncate target path: " << file_path;
+        unlink(file_path);
         return false;
     }
 

From d60a2aa19937bacd1a1374d7b26b52078293a334 Mon Sep 17 00:00:00 2001
From: Ilya Byckevich <byckevich.ilja@gmail.com>
Date: Fri, 26 Jul 2024 21:06:18 +0200
Subject: [PATCH 1029/1487] fs_mgr: Remove deprecated mount option

Mount option "nomblk_io_submit" was deleted from
upstream kernel v3.9 in 36ade451a5d736e61ac8302b64aacc5acb5e440f
and has not reappeared since then.
Now it only generates 'Ignoring removed nomblk_io_submit option'
in the logs

Test: manual
Change-Id: Ie609e7d3d38e808eeede1f1c55435ed027726025
---
 fs_mgr/fs_mgr.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 5156754a8538..711d7c144565 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -215,10 +215,6 @@ static void check_fs(const std::string& blk_device, const std::string& fs_type,
          */
         if (!(*fs_stat & FS_STAT_FULL_MOUNT_FAILED)) {  // already tried if full mount failed
             errno = 0;
-            if (fs_type == "ext4") {
-                // This option is only valid with ext4
-                tmpmnt_opts += ",nomblk_io_submit";
-            }
             ret = mount(blk_device.c_str(), target.c_str(), fs_type.c_str(), tmpmnt_flags,
                         tmpmnt_opts.c_str());
             PINFO << __FUNCTION__ << "(): mount(" << blk_device << "," << target << "," << fs_type

From 3ce6cb9b6ee16c94b0cec3b2b331517ec36e641d Mon Sep 17 00:00:00 2001
From: Inseob Kim <inseob@google.com>
Date: Wed, 31 Jul 2024 13:10:48 +0900
Subject: [PATCH 1030/1487] Refactor init.environ.rc to append than replace

Bug: 353429422
Test: boot
Change-Id: Ibd432fa39fc75f8b49ae26fbc6b74f11fb3f771d
---
 rootdir/Android.bp         | 10 +++++-----
 rootdir/init.environ.rc.in |  7 ++-----
 2 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index bbc50534c3ba..1e7b48b3112d 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -167,11 +167,11 @@ genrule {
     srcs: ["init.environ.rc.in"],
     out: ["init.environ.rc"],
     cmd: "cp -f $(in) $(out) && " +
-        "sed -i -e 's?%EXPORT_GLOBAL_ASAN_OPTIONS%?" + EXPORT_GLOBAL_ASAN_OPTIONS + "?g' $(out) && " +
-        "sed -i -e 's?%EXPORT_GLOBAL_GCOV_OPTIONS%?" + EXPORT_GLOBAL_GCOV_OPTIONS + "?g' $(out) && " +
-        "sed -i -e 's?%EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS%?" + EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS + "?g' $(out) && " +
-        "sed -i -e 's?%EXPORT_GLOBAL_HWASAN_OPTIONS%?" + EXPORT_GLOBAL_HWASAN_OPTIONS + "?g' $(out) && " +
-        "sed -i -e 's?%EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE%?" + EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE + "?g' $(out)",
+        "echo '    " + EXPORT_GLOBAL_ASAN_OPTIONS + "' >> $(out) && " +
+        "echo '    " + EXPORT_GLOBAL_GCOV_OPTIONS + "' >> $(out) && " +
+        "echo '    " + EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS + "' >> $(out) && " +
+        "echo '    " + EXPORT_GLOBAL_HWASAN_OPTIONS + "' >> $(out) && " +
+        "echo '    " + EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE + "' >> $(out)",
 }
 
 prebuilt_root {
diff --git a/rootdir/init.environ.rc.in b/rootdir/init.environ.rc.in
index 7ba1f46e7a7f..9249270b39fc 100644
--- a/rootdir/init.environ.rc.in
+++ b/rootdir/init.environ.rc.in
@@ -10,8 +10,5 @@ on early-init
     export ANDROID_TZDATA_ROOT /apex/com.android.tzdata
     export EXTERNAL_STORAGE /sdcard
     export ASEC_MOUNTPOINT /mnt/asec
-    %EXPORT_GLOBAL_ASAN_OPTIONS%
-    %EXPORT_GLOBAL_GCOV_OPTIONS%
-    %EXPORT_GLOBAL_CLANG_COVERAGE_OPTIONS%
-    %EXPORT_GLOBAL_HWASAN_OPTIONS%
-    %EXPORT_GLOBAL_SCUDO_ALLOCATION_RING_BUFFER_SIZE%
+    # Additional environment variables will be appended here during build (see Android.bp).
+    # DO NOT ADD additional sections like 'on <event>' here.

From 5fbb9ca987bbac7c32caa97d0c8ec8556659f46f Mon Sep 17 00:00:00 2001
From: Owner Cleanup Bot
 <swarming-tasks@owners-cleanup-prod.google.com.iam.gserviceaccount.com>
Date: Sun, 4 Aug 2024 17:36:43 +0000
Subject: [PATCH 1031/1487] Remove lpy@google.com from libgrallocusage/OWNERS

This suggested change is automatically generated based on group
memberships and affiliations.
If this change is unnecessary or in error, vote the lowest CR value
(i.e. reject the CL) and the bot will abandon it. Vote the highest CR to
approve this change. You may also abandon this change.

See the owner's recent activity for context:
https://android-review.googlesource.com/q/lpy@google.com

To report an issue, file a bug in the Infra>Codereview component.

Change-Id: I89123426e2cf94e879c94044ce08f56962a101ec
---
 libgrallocusage/OWNERS | 1 -
 1 file changed, 1 deletion(-)

diff --git a/libgrallocusage/OWNERS b/libgrallocusage/OWNERS
index de2bf16f4c73..249dcb000864 100644
--- a/libgrallocusage/OWNERS
+++ b/libgrallocusage/OWNERS
@@ -1,2 +1 @@
 jreck@google.com
-lpy@google.com

From c474dfa204d17978156947fb5b2952313f47a9c4 Mon Sep 17 00:00:00 2001
From: Owner Cleanup Bot
 <swarming-tasks@owners-cleanup-prod.google.com.iam.gserviceaccount.com>
Date: Sun, 4 Aug 2024 17:36:57 +0000
Subject: [PATCH 1032/1487] Remove lpy@google.com from libsystem/OWNERS

This suggested change is automatically generated based on group
memberships and affiliations.
If this change is unnecessary or in error, vote the lowest CR value
(i.e. reject the CL) and the bot will abandon it. Vote the highest CR to
approve this change. You may also abandon this change.

See the owner's recent activity for context:
https://android-review.googlesource.com/q/lpy@google.com

To report an issue, file a bug in the Infra>Codereview component.

Change-Id: I60ce6f3e4c89202460427607887a0144409d0b03
---
 libsystem/OWNERS | 1 -
 1 file changed, 1 deletion(-)

diff --git a/libsystem/OWNERS b/libsystem/OWNERS
index 9bda04c4dc22..6c6fe1f70da8 100644
--- a/libsystem/OWNERS
+++ b/libsystem/OWNERS
@@ -1,6 +1,5 @@
 # graphics/composer
 adyabr@google.com
-lpy@google.com
 
 # camera
 etalvala@google.com

From 8e62c8a9b44302108ddcb10f7c3efb410c4b0f1e Mon Sep 17 00:00:00 2001
From: Bart Van Assche <bvanassche@google.com>
Date: Sun, 4 Aug 2024 16:10:57 -0700
Subject: [PATCH 1033/1487] libcutils: Split uevent_open_socket()

The best time to attach a BPF filter to a socket is before a socket
starts receiving data. Netlink sockets start receiving data after bind()
has been called. uevent_open_socket() calls socket() and bind(). Hence
split uevent_open_socket() into two functions: one function that calls
socket() and another function that calls bind().

Bug: 203462310
Change-Id: Ia41dee4683358cf9fbb6288fad863cd4f4ac9924
Signed-off-by: Bart Van Assche <bvanassche@google.com>
---
 .../arm64/source-based/libcutils.so.lsdump    | 218 ++++++------------
 .../source-based/libcutils.so.lsdump          | 208 +++++------------
 libcutils/include/cutils/uevent.h             |   2 +
 libcutils/uevent.cpp                          |  62 +++--
 4 files changed, 191 insertions(+), 299 deletions(-)

diff --git a/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump b/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
index 67c7514a6547..7ed131cf48f8 100644
--- a/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
+++ b/libcutils/abi-dumps/arm64/source-based/libcutils.so.lsdump
@@ -6,7 +6,6 @@
    "linker_set_key" : "_ZTIA0_i",
    "name" : "int[0]",
    "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIA0_i",
    "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
   }
  ],
@@ -17,8 +16,6 @@
    "is_integral" : true,
    "linker_set_key" : "_ZTIa",
    "name" : "signed char",
-   "referenced_type" : "_ZTIa",
-   "self_type" : "_ZTIa",
    "size" : 1
   },
   {
@@ -27,8 +24,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIb",
    "name" : "bool",
-   "referenced_type" : "_ZTIb",
-   "self_type" : "_ZTIb",
    "size" : 1
   },
   {
@@ -37,25 +32,27 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIc",
    "name" : "char",
-   "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIc",
    "size" : 1
   },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIf",
    "name" : "float",
-   "referenced_type" : "_ZTIf",
-   "self_type" : "_ZTIf",
    "size" : 4
   },
+  {
+   "alignment" : 1,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIh",
+   "name" : "unsigned char",
+   "size" : 1
+  },
   {
    "alignment" : 4,
    "is_integral" : true,
    "linker_set_key" : "_ZTIi",
    "name" : "int",
-   "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIi",
    "size" : 4
   },
   {
@@ -64,8 +61,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIj",
    "name" : "unsigned int",
-   "referenced_type" : "_ZTIj",
-   "self_type" : "_ZTIj",
    "size" : 4
   },
   {
@@ -73,8 +68,6 @@
    "is_integral" : true,
    "linker_set_key" : "_ZTIl",
    "name" : "long",
-   "referenced_type" : "_ZTIl",
-   "self_type" : "_ZTIl",
    "size" : 8
   },
   {
@@ -83,85 +76,55 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIm",
    "name" : "unsigned long",
-   "referenced_type" : "_ZTIm",
-   "self_type" : "_ZTIm",
    "size" : 8
   },
   {
-   "linker_set_key" : "_ZTIv",
-   "name" : "void",
-   "referenced_type" : "_ZTIv",
-   "self_type" : "_ZTIv"
-  }
- ],
- "elf_functions" :
- [
-  {
-   "name" : "_Z23socket_make_sockaddr_unPKciP11sockaddr_unPj"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZN7android4base4TrimIRNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES8_OT_"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE4syncEv"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE6setbufEPcl"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE7seekposENS_4fposI9mbstate_tEEj"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE8overflowEi"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE9pbackfailEi"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE9underflowEv"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEEC2Ev"
+   "alignment" : 16,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIo",
+   "name" : "unsigned __int128",
+   "size" : 16
   },
   {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEED0Ev"
+   "alignment" : 2,
+   "is_integral" : true,
+   "linker_set_key" : "_ZTIs",
+   "name" : "short",
+   "size" : 2
   },
   {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEED2Ev"
+   "alignment" : 2,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIt",
+   "name" : "unsigned short",
+   "size" : 2
   },
   {
-   "binding" : "weak",
-   "name" : "_ZNSt3__124__put_character_sequenceIcNS_11char_traitsIcEEEERNS_13basic_ostreamIT_T0_EES7_PKS4_m"
+   "linker_set_key" : "_ZTIv",
+   "name" : "void"
   },
   {
-   "binding" : "weak",
-   "name" : "_ZNSt3__16vectorI5EntryNS_9allocatorIS1_EEE24__emplace_back_slow_pathIJS1_EEEvDpOT_"
+   "alignment" : 8,
+   "is_integral" : true,
+   "linker_set_key" : "_ZTIx",
+   "name" : "long long",
+   "size" : 8
   },
   {
-   "binding" : "weak",
-   "name" : "_ZNSt3__17getlineIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS_13basic_istreamIT_T0_EES9_RNS_12basic_stringIS6_S7_T1_EES6_"
-  },
+   "alignment" : 8,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIy",
+   "name" : "unsigned long long",
+   "size" : 8
+  }
+ ],
+ "elf_functions" :
+ [
   {
-   "binding" : "weak",
-   "name" : "_ZNSt3__1lsINS_11char_traitsIcEEEERNS_13basic_ostreamIcT_EES6_PKc"
+   "name" : "_Z23socket_make_sockaddr_unPKciP11sockaddr_unPj"
   },
   {
    "name" : "android_get_control_file"
@@ -487,6 +450,12 @@
   {
    "name" : "str_parms_to_str"
   },
+  {
+   "name" : "uevent_bind"
+  },
+  {
+   "name" : "uevent_create_socket"
+  },
   {
    "name" : "uevent_kernel_multicast_recv"
   },
@@ -502,22 +471,6 @@
  ],
  "elf_objects" :
  [
-  {
-   "binding" : "weak",
-   "name" : "_ZTCNSt3__114basic_ifstreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZTTNSt3__114basic_ifstreamIcNS_11char_traitsIcEEEE"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZTVNSt3__113basic_filebufIcNS_11char_traitsIcEEEE"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZTVNSt3__114basic_ifstreamIcNS_11char_traitsIcEEEE"
-  },
   {
    "name" : "atrace_enabled_tags"
   },
@@ -553,8 +506,6 @@
    ],
    "linker_set_key" : "_ZTI12IoSchedClass",
    "name" : "IoSchedClass",
-   "referenced_type" : "_ZTI12IoSchedClass",
-   "self_type" : "_ZTI12IoSchedClass",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h",
    "underlying_type" : "_ZTIj"
@@ -575,9 +526,7 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFbPvS_E",
    "return_type" : "_ZTIb",
-   "self_type" : "_ZTIFbPvS_E",
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
   {
@@ -596,9 +545,7 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFbPvS_S_E",
    "return_type" : "_ZTIb",
-   "self_type" : "_ZTIFbPvS_S_E",
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
   {
@@ -611,9 +558,7 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFiPvE",
    "return_type" : "_ZTIi",
-   "self_type" : "_ZTIFiPvE",
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
   {
@@ -632,9 +577,7 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFvPKcS0_PvE",
    "return_type" : "_ZTIv",
-   "self_type" : "_ZTIFvPKcS0_PvE",
    "source_file" : "system/core/libcutils/include/cutils/properties.h"
   }
  ],
@@ -2266,6 +2209,33 @@
    "return_type" : "_ZTIPc",
    "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
   },
+  {
+   "function_name" : "uevent_bind",
+   "linker_set_key" : "uevent_bind",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/uevent.h"
+  },
+  {
+   "function_name" : "uevent_create_socket",
+   "linker_set_key" : "uevent_create_socket",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIb"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/uevent.h"
+  },
   {
    "function_name" : "uevent_kernel_multicast_recv",
    "linker_set_key" : "uevent_kernel_multicast_recv",
@@ -2374,7 +2344,6 @@
    "linker_set_key" : "_ZTIP12IoSchedClass",
    "name" : "IoSchedClass *",
    "referenced_type" : "_ZTI12IoSchedClass",
-   "self_type" : "_ZTIP12IoSchedClass",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h"
   },
@@ -2383,7 +2352,6 @@
    "linker_set_key" : "_ZTIP12RecordStream",
    "name" : "RecordStream *",
    "referenced_type" : "_ZTI12RecordStream",
-   "self_type" : "_ZTIP12RecordStream",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
   },
@@ -2392,7 +2360,6 @@
    "linker_set_key" : "_ZTIP13native_handle",
    "name" : "native_handle *",
    "referenced_type" : "_ZTI13native_handle",
-   "self_type" : "_ZTIP13native_handle",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
   },
@@ -2401,7 +2368,6 @@
    "linker_set_key" : "_ZTIP5cnode",
    "name" : "cnode *",
    "referenced_type" : "_ZTI5cnode",
-   "self_type" : "_ZTIP5cnode",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
   },
@@ -2410,7 +2376,6 @@
    "linker_set_key" : "_ZTIP7Hashmap",
    "name" : "Hashmap *",
    "referenced_type" : "_ZTI7Hashmap",
-   "self_type" : "_ZTIP7Hashmap",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
@@ -2419,7 +2384,6 @@
    "linker_set_key" : "_ZTIP9fs_config",
    "name" : "fs_config *",
    "referenced_type" : "_ZTI9fs_config",
-   "self_type" : "_ZTIP9fs_config",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/private/fs_config.h"
   },
@@ -2428,7 +2392,6 @@
    "linker_set_key" : "_ZTIP9str_parms",
    "name" : "str_parms *",
    "referenced_type" : "_ZTI9str_parms",
-   "self_type" : "_ZTIP9str_parms",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
   },
@@ -2437,7 +2400,6 @@
    "linker_set_key" : "_ZTIPFbPvS_E",
    "name" : "bool (*)(void *, void *)",
    "referenced_type" : "_ZTIFbPvS_E",
-   "self_type" : "_ZTIPFbPvS_E",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
@@ -2446,7 +2408,6 @@
    "linker_set_key" : "_ZTIPFbPvS_S_E",
    "name" : "bool (*)(void *, void *, void *)",
    "referenced_type" : "_ZTIFbPvS_S_E",
-   "self_type" : "_ZTIPFbPvS_S_E",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
@@ -2455,7 +2416,6 @@
    "linker_set_key" : "_ZTIPFiPvE",
    "name" : "int (*)(void *)",
    "referenced_type" : "_ZTIFiPvE",
-   "self_type" : "_ZTIPFiPvE",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
@@ -2464,7 +2424,6 @@
    "linker_set_key" : "_ZTIPFvPKcS0_PvE",
    "name" : "void (*)(const char *, const char *, void *)",
    "referenced_type" : "_ZTIFvPKcS0_PvE",
-   "self_type" : "_ZTIPFvPKcS0_PvE",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/properties.h"
   },
@@ -2473,7 +2432,6 @@
    "linker_set_key" : "_ZTIPK13native_handle",
    "name" : "const native_handle *",
    "referenced_type" : "_ZTIK13native_handle",
-   "self_type" : "_ZTIPK13native_handle",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
   },
@@ -2482,7 +2440,6 @@
    "linker_set_key" : "_ZTIPK22cutils_socket_buffer_t",
    "name" : "const cutils_socket_buffer_t *",
    "referenced_type" : "_ZTIK22cutils_socket_buffer_t",
-   "self_type" : "_ZTIPK22cutils_socket_buffer_t",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/sockets.h"
   },
@@ -2491,7 +2448,6 @@
    "linker_set_key" : "_ZTIPK5iovec",
    "name" : "const iovec *",
    "referenced_type" : "_ZTIK5iovec",
-   "self_type" : "_ZTIPK5iovec",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/klog.h"
   },
@@ -2500,7 +2456,6 @@
    "linker_set_key" : "_ZTIPKc",
    "name" : "const char *",
    "referenced_type" : "_ZTIKc",
-   "self_type" : "_ZTIPKc",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
   },
@@ -2509,7 +2464,6 @@
    "linker_set_key" : "_ZTIPKv",
    "name" : "const void *",
    "referenced_type" : "_ZTIKv",
-   "self_type" : "_ZTIPKv",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/sockets.h"
   },
@@ -2518,7 +2472,6 @@
    "linker_set_key" : "_ZTIPPv",
    "name" : "void **",
    "referenced_type" : "_ZTIPv",
-   "self_type" : "_ZTIPPv",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
   },
@@ -2527,7 +2480,6 @@
    "linker_set_key" : "_ZTIPc",
    "name" : "char *",
    "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIPc",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
   },
@@ -2536,7 +2488,6 @@
    "linker_set_key" : "_ZTIPf",
    "name" : "float *",
    "referenced_type" : "_ZTIf",
-   "self_type" : "_ZTIPf",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
   },
@@ -2545,7 +2496,6 @@
    "linker_set_key" : "_ZTIPi",
    "name" : "int *",
    "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIPi",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h"
   },
@@ -2554,7 +2504,6 @@
    "linker_set_key" : "_ZTIPj",
    "name" : "unsigned int *",
    "referenced_type" : "_ZTIj",
-   "self_type" : "_ZTIPj",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/misc.h"
   },
@@ -2563,7 +2512,6 @@
    "linker_set_key" : "_ZTIPm",
    "name" : "unsigned long *",
    "referenced_type" : "_ZTIm",
-   "self_type" : "_ZTIPm",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
   },
@@ -2572,7 +2520,6 @@
    "linker_set_key" : "_ZTIPv",
    "name" : "void *",
    "referenced_type" : "_ZTIv",
-   "self_type" : "_ZTIPv",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/misc.h"
   }
@@ -2585,7 +2532,6 @@
    "linker_set_key" : "_ZTIK13native_handle",
    "name" : "const native_handle",
    "referenced_type" : "_ZTI13native_handle",
-   "self_type" : "_ZTIK13native_handle",
    "size" : 12,
    "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
   },
@@ -2595,7 +2541,6 @@
    "linker_set_key" : "_ZTIK22cutils_socket_buffer_t",
    "name" : "const cutils_socket_buffer_t",
    "referenced_type" : "_ZTI22cutils_socket_buffer_t",
-   "self_type" : "_ZTIK22cutils_socket_buffer_t",
    "size" : 16,
    "source_file" : "system/core/libcutils/include/cutils/sockets.h"
   },
@@ -2605,7 +2550,6 @@
    "linker_set_key" : "_ZTIK5iovec",
    "name" : "const iovec",
    "referenced_type" : "_ZTI5iovec",
-   "self_type" : "_ZTIK5iovec",
    "size" : 16,
    "source_file" : "system/core/libcutils/include/cutils/klog.h"
   },
@@ -2615,7 +2559,6 @@
    "linker_set_key" : "_ZTIKc",
    "name" : "const char",
    "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIKc",
    "size" : 1,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
   },
@@ -2624,7 +2567,6 @@
    "linker_set_key" : "_ZTIKv",
    "name" : "const void",
    "referenced_type" : "_ZTIv",
-   "self_type" : "_ZTIKv",
    "source_file" : "system/core/libcutils/include/cutils/sockets.h"
   }
  ],
@@ -2656,8 +2598,6 @@
    ],
    "linker_set_key" : "_ZTI13native_handle",
    "name" : "native_handle",
-   "referenced_type" : "_ZTI13native_handle",
-   "self_type" : "_ZTI13native_handle",
    "size" : 12,
    "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
   },
@@ -2677,8 +2617,6 @@
    ],
    "linker_set_key" : "_ZTI22cutils_socket_buffer_t",
    "name" : "cutils_socket_buffer_t",
-   "referenced_type" : "_ZTI22cutils_socket_buffer_t",
-   "self_type" : "_ZTI22cutils_socket_buffer_t",
    "size" : 16,
    "source_file" : "system/core/libcutils/include/cutils/sockets.h"
   },
@@ -2713,8 +2651,6 @@
    ],
    "linker_set_key" : "_ZTI5cnode",
    "name" : "cnode",
-   "referenced_type" : "_ZTI5cnode",
-   "self_type" : "_ZTI5cnode",
    "size" : 40,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
   },
@@ -2744,8 +2680,6 @@
    ],
    "linker_set_key" : "_ZTI9fs_config",
    "name" : "fs_config",
-   "referenced_type" : "_ZTI9fs_config",
-   "self_type" : "_ZTI9fs_config",
    "size" : 24,
    "source_file" : "system/core/libcutils/include/private/fs_config.h"
   }
diff --git a/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump b/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
index f75240c04074..fe4361a39e2a 100644
--- a/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
+++ b/libcutils/abi-dumps/arm_arm64/source-based/libcutils.so.lsdump
@@ -6,7 +6,6 @@
    "linker_set_key" : "_ZTIA0_i",
    "name" : "int[0]",
    "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIA0_i",
    "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
   }
  ],
@@ -17,8 +16,6 @@
    "is_integral" : true,
    "linker_set_key" : "_ZTIa",
    "name" : "signed char",
-   "referenced_type" : "_ZTIa",
-   "self_type" : "_ZTIa",
    "size" : 1
   },
   {
@@ -27,8 +24,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIb",
    "name" : "bool",
-   "referenced_type" : "_ZTIb",
-   "self_type" : "_ZTIb",
    "size" : 1
   },
   {
@@ -37,25 +32,27 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIc",
    "name" : "char",
-   "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIc",
    "size" : 1
   },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIf",
    "name" : "float",
-   "referenced_type" : "_ZTIf",
-   "self_type" : "_ZTIf",
    "size" : 4
   },
+  {
+   "alignment" : 1,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIh",
+   "name" : "unsigned char",
+   "size" : 1
+  },
   {
    "alignment" : 4,
    "is_integral" : true,
    "linker_set_key" : "_ZTIi",
    "name" : "int",
-   "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIi",
    "size" : 4
   },
   {
@@ -64,33 +61,47 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIj",
    "name" : "unsigned int",
-   "referenced_type" : "_ZTIj",
-   "self_type" : "_ZTIj",
+   "size" : 4
+  },
+  {
+   "alignment" : 4,
+   "is_integral" : true,
+   "linker_set_key" : "_ZTIl",
+   "name" : "long",
+   "size" : 4
+  },
+  {
+   "alignment" : 4,
+   "is_integral" : true,
+   "is_unsigned" : true,
+   "linker_set_key" : "_ZTIm",
+   "name" : "unsigned long",
    "size" : 4
   },
+  {
+   "alignment" : 2,
+   "is_integral" : true,
+   "linker_set_key" : "_ZTIs",
+   "name" : "short",
+   "size" : 2
+  },
   {
    "alignment" : 2,
    "is_integral" : true,
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIt",
    "name" : "unsigned short",
-   "referenced_type" : "_ZTIt",
-   "self_type" : "_ZTIt",
    "size" : 2
   },
   {
    "linker_set_key" : "_ZTIv",
-   "name" : "void",
-   "referenced_type" : "_ZTIv",
-   "self_type" : "_ZTIv"
+   "name" : "void"
   },
   {
    "alignment" : 8,
    "is_integral" : true,
    "linker_set_key" : "_ZTIx",
    "name" : "long long",
-   "referenced_type" : "_ZTIx",
-   "self_type" : "_ZTIx",
    "size" : 8
   },
   {
@@ -99,8 +110,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIy",
    "name" : "unsigned long long",
-   "referenced_type" : "_ZTIy",
-   "self_type" : "_ZTIy",
    "size" : 8
   }
  ],
@@ -113,66 +122,6 @@
    "binding" : "weak",
    "name" : "_ZN7android4base4TrimIRNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES8_OT_"
   },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE4syncEv"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE6setbufEPci"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE7seekposENS_4fposI9mbstate_tEEj"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE8overflowEi"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE9pbackfailEi"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE9underflowEv"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEEC2Ev"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEED0Ev"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEED2Ev"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__124__put_character_sequenceIcNS_11char_traitsIcEEEERNS_13basic_ostreamIT_T0_EES7_PKS4_j"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__16vectorI5EntryNS_9allocatorIS1_EEE24__emplace_back_slow_pathIJS1_EEEvDpOT_"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__17getlineIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS_13basic_istreamIT_T0_EES9_RNS_12basic_stringIS6_S7_T1_EES6_"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__1lsINS_11char_traitsIcEEEERNS_13basic_ostreamIcT_EES6_PKc"
-  },
   {
    "name" : "android_get_control_file"
   },
@@ -497,6 +446,12 @@
   {
    "name" : "str_parms_to_str"
   },
+  {
+   "name" : "uevent_bind"
+  },
+  {
+   "name" : "uevent_create_socket"
+  },
   {
    "name" : "uevent_kernel_multicast_recv"
   },
@@ -512,22 +467,6 @@
  ],
  "elf_objects" :
  [
-  {
-   "binding" : "weak",
-   "name" : "_ZTCNSt3__114basic_ifstreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZTTNSt3__114basic_ifstreamIcNS_11char_traitsIcEEEE"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZTVNSt3__113basic_filebufIcNS_11char_traitsIcEEEE"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZTVNSt3__114basic_ifstreamIcNS_11char_traitsIcEEEE"
-  },
   {
    "name" : "atrace_enabled_tags"
   },
@@ -563,8 +502,6 @@
    ],
    "linker_set_key" : "_ZTI12IoSchedClass",
    "name" : "IoSchedClass",
-   "referenced_type" : "_ZTI12IoSchedClass",
-   "self_type" : "_ZTI12IoSchedClass",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h",
    "underlying_type" : "_ZTIj"
@@ -585,9 +522,7 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFbPvS_E",
    "return_type" : "_ZTIb",
-   "self_type" : "_ZTIFbPvS_E",
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
   {
@@ -606,9 +541,7 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFbPvS_S_E",
    "return_type" : "_ZTIb",
-   "self_type" : "_ZTIFbPvS_S_E",
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
   {
@@ -621,9 +554,7 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFiPvE",
    "return_type" : "_ZTIi",
-   "self_type" : "_ZTIFiPvE",
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
   {
@@ -642,9 +573,7 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFvPKcS0_PvE",
    "return_type" : "_ZTIv",
-   "self_type" : "_ZTIFvPKcS0_PvE",
    "source_file" : "system/core/libcutils/include/cutils/properties.h"
   }
  ],
@@ -2276,6 +2205,33 @@
    "return_type" : "_ZTIPc",
    "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
   },
+  {
+   "function_name" : "uevent_bind",
+   "linker_set_key" : "uevent_bind",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/uevent.h"
+  },
+  {
+   "function_name" : "uevent_create_socket",
+   "linker_set_key" : "uevent_create_socket",
+   "parameters" :
+   [
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIb"
+    }
+   ],
+   "return_type" : "_ZTIi",
+   "source_file" : "system/core/libcutils/include/cutils/uevent.h"
+  },
   {
    "function_name" : "uevent_kernel_multicast_recv",
    "linker_set_key" : "uevent_kernel_multicast_recv",
@@ -2384,7 +2340,6 @@
    "linker_set_key" : "_ZTIP12IoSchedClass",
    "name" : "IoSchedClass *",
    "referenced_type" : "_ZTI12IoSchedClass",
-   "self_type" : "_ZTIP12IoSchedClass",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h"
   },
@@ -2393,7 +2348,6 @@
    "linker_set_key" : "_ZTIP12RecordStream",
    "name" : "RecordStream *",
    "referenced_type" : "_ZTI12RecordStream",
-   "self_type" : "_ZTIP12RecordStream",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
   },
@@ -2402,7 +2356,6 @@
    "linker_set_key" : "_ZTIP13native_handle",
    "name" : "native_handle *",
    "referenced_type" : "_ZTI13native_handle",
-   "self_type" : "_ZTIP13native_handle",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
   },
@@ -2411,7 +2364,6 @@
    "linker_set_key" : "_ZTIP5cnode",
    "name" : "cnode *",
    "referenced_type" : "_ZTI5cnode",
-   "self_type" : "_ZTIP5cnode",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
   },
@@ -2420,7 +2372,6 @@
    "linker_set_key" : "_ZTIP7Hashmap",
    "name" : "Hashmap *",
    "referenced_type" : "_ZTI7Hashmap",
-   "self_type" : "_ZTIP7Hashmap",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
@@ -2429,7 +2380,6 @@
    "linker_set_key" : "_ZTIP9fs_config",
    "name" : "fs_config *",
    "referenced_type" : "_ZTI9fs_config",
-   "self_type" : "_ZTIP9fs_config",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/private/fs_config.h"
   },
@@ -2438,7 +2388,6 @@
    "linker_set_key" : "_ZTIP9str_parms",
    "name" : "str_parms *",
    "referenced_type" : "_ZTI9str_parms",
-   "self_type" : "_ZTIP9str_parms",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
   },
@@ -2447,7 +2396,6 @@
    "linker_set_key" : "_ZTIPFbPvS_E",
    "name" : "bool (*)(void *, void *)",
    "referenced_type" : "_ZTIFbPvS_E",
-   "self_type" : "_ZTIPFbPvS_E",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
@@ -2456,7 +2404,6 @@
    "linker_set_key" : "_ZTIPFbPvS_S_E",
    "name" : "bool (*)(void *, void *, void *)",
    "referenced_type" : "_ZTIFbPvS_S_E",
-   "self_type" : "_ZTIPFbPvS_S_E",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
@@ -2465,7 +2412,6 @@
    "linker_set_key" : "_ZTIPFiPvE",
    "name" : "int (*)(void *)",
    "referenced_type" : "_ZTIFiPvE",
-   "self_type" : "_ZTIPFiPvE",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/hashmap.h"
   },
@@ -2474,7 +2420,6 @@
    "linker_set_key" : "_ZTIPFvPKcS0_PvE",
    "name" : "void (*)(const char *, const char *, void *)",
    "referenced_type" : "_ZTIFvPKcS0_PvE",
-   "self_type" : "_ZTIPFvPKcS0_PvE",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/properties.h"
   },
@@ -2483,7 +2428,6 @@
    "linker_set_key" : "_ZTIPK13native_handle",
    "name" : "const native_handle *",
    "referenced_type" : "_ZTIK13native_handle",
-   "self_type" : "_ZTIPK13native_handle",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
   },
@@ -2492,7 +2436,6 @@
    "linker_set_key" : "_ZTIPK22cutils_socket_buffer_t",
    "name" : "const cutils_socket_buffer_t *",
    "referenced_type" : "_ZTIK22cutils_socket_buffer_t",
-   "self_type" : "_ZTIPK22cutils_socket_buffer_t",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/sockets.h"
   },
@@ -2501,7 +2444,6 @@
    "linker_set_key" : "_ZTIPK5iovec",
    "name" : "const iovec *",
    "referenced_type" : "_ZTIK5iovec",
-   "self_type" : "_ZTIPK5iovec",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/klog.h"
   },
@@ -2510,7 +2452,6 @@
    "linker_set_key" : "_ZTIPKc",
    "name" : "const char *",
    "referenced_type" : "_ZTIKc",
-   "self_type" : "_ZTIPKc",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
   },
@@ -2519,7 +2460,6 @@
    "linker_set_key" : "_ZTIPKv",
    "name" : "const void *",
    "referenced_type" : "_ZTIKv",
-   "self_type" : "_ZTIPKv",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/sockets.h"
   },
@@ -2528,7 +2468,6 @@
    "linker_set_key" : "_ZTIPPv",
    "name" : "void **",
    "referenced_type" : "_ZTIPv",
-   "self_type" : "_ZTIPPv",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/record_stream.h"
   },
@@ -2537,7 +2476,6 @@
    "linker_set_key" : "_ZTIPc",
    "name" : "char *",
    "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIPc",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
   },
@@ -2546,7 +2484,6 @@
    "linker_set_key" : "_ZTIPf",
    "name" : "float *",
    "referenced_type" : "_ZTIf",
-   "self_type" : "_ZTIPf",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/str_parms.h"
   },
@@ -2555,7 +2492,6 @@
    "linker_set_key" : "_ZTIPi",
    "name" : "int *",
    "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIPi",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/iosched_policy.h"
   },
@@ -2564,7 +2500,6 @@
    "linker_set_key" : "_ZTIPj",
    "name" : "unsigned int *",
    "referenced_type" : "_ZTIj",
-   "self_type" : "_ZTIPj",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/misc.h"
   },
@@ -2573,7 +2508,6 @@
    "linker_set_key" : "_ZTIPv",
    "name" : "void *",
    "referenced_type" : "_ZTIv",
-   "self_type" : "_ZTIPv",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/cutils/misc.h"
   },
@@ -2582,7 +2516,6 @@
    "linker_set_key" : "_ZTIPy",
    "name" : "unsigned long long *",
    "referenced_type" : "_ZTIy",
-   "self_type" : "_ZTIPy",
    "size" : 4,
    "source_file" : "system/core/libcutils/include/private/canned_fs_config.h"
   }
@@ -2595,7 +2528,6 @@
    "linker_set_key" : "_ZTIK13native_handle",
    "name" : "const native_handle",
    "referenced_type" : "_ZTI13native_handle",
-   "self_type" : "_ZTIK13native_handle",
    "size" : 12,
    "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
   },
@@ -2605,7 +2537,6 @@
    "linker_set_key" : "_ZTIK22cutils_socket_buffer_t",
    "name" : "const cutils_socket_buffer_t",
    "referenced_type" : "_ZTI22cutils_socket_buffer_t",
-   "self_type" : "_ZTIK22cutils_socket_buffer_t",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/sockets.h"
   },
@@ -2615,7 +2546,6 @@
    "linker_set_key" : "_ZTIK5iovec",
    "name" : "const iovec",
    "referenced_type" : "_ZTI5iovec",
-   "self_type" : "_ZTIK5iovec",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/klog.h"
   },
@@ -2625,7 +2555,6 @@
    "linker_set_key" : "_ZTIKc",
    "name" : "const char",
    "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIKc",
    "size" : 1,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
   },
@@ -2634,7 +2563,6 @@
    "linker_set_key" : "_ZTIKv",
    "name" : "const void",
    "referenced_type" : "_ZTIv",
-   "self_type" : "_ZTIKv",
    "source_file" : "system/core/libcutils/include/cutils/sockets.h"
   }
  ],
@@ -2666,8 +2594,6 @@
    ],
    "linker_set_key" : "_ZTI13native_handle",
    "name" : "native_handle",
-   "referenced_type" : "_ZTI13native_handle",
-   "self_type" : "_ZTI13native_handle",
    "size" : 12,
    "source_file" : "system/core/libcutils/include/cutils/native_handle.h"
   },
@@ -2687,8 +2613,6 @@
    ],
    "linker_set_key" : "_ZTI22cutils_socket_buffer_t",
    "name" : "cutils_socket_buffer_t",
-   "referenced_type" : "_ZTI22cutils_socket_buffer_t",
-   "self_type" : "_ZTI22cutils_socket_buffer_t",
    "size" : 8,
    "source_file" : "system/core/libcutils/include/cutils/sockets.h"
   },
@@ -2723,8 +2647,6 @@
    ],
    "linker_set_key" : "_ZTI5cnode",
    "name" : "cnode",
-   "referenced_type" : "_ZTI5cnode",
-   "self_type" : "_ZTI5cnode",
    "size" : 20,
    "source_file" : "system/core/libcutils/include/cutils/config_utils.h"
   },
@@ -2754,8 +2676,6 @@
    ],
    "linker_set_key" : "_ZTI9fs_config",
    "name" : "fs_config",
-   "referenced_type" : "_ZTI9fs_config",
-   "self_type" : "_ZTI9fs_config",
    "size" : 24,
    "source_file" : "system/core/libcutils/include/private/fs_config.h"
   }
diff --git a/libcutils/include/cutils/uevent.h b/libcutils/include/cutils/uevent.h
index da1c2aae6b37..1be981bf0dfa 100644
--- a/libcutils/include/cutils/uevent.h
+++ b/libcutils/include/cutils/uevent.h
@@ -24,6 +24,8 @@
 extern "C" {
 #endif
 
+int uevent_create_socket(int buf_sz, bool passcred);
+int uevent_bind(int socket);
 int uevent_open_socket(int buf_sz, bool passcred);
 ssize_t uevent_kernel_multicast_recv(int socket, void *buffer, size_t length);
 ssize_t uevent_kernel_multicast_uid_recv(int socket, void *buffer, size_t length, uid_t *uid);
diff --git a/libcutils/uevent.cpp b/libcutils/uevent.cpp
index 40bbd5c8fdbc..f01a479cd8f5 100644
--- a/libcutils/uevent.cpp
+++ b/libcutils/uevent.cpp
@@ -92,20 +92,22 @@ ssize_t uevent_kernel_recv(int socket, void* buffer, size_t length, bool require
     return -1;
 }
 
-int uevent_open_socket(int buf_sz, bool passcred) {
-    struct sockaddr_nl addr;
-    int on = passcred;
+/*
+ * Creates an unbound netlink socket for receiving uevent messages.
+ * @buf_sz: socket receive buffer size.
+ * @passcred: whether or not to enable receiving the SCM_CREDENTIALS control
+ *	message.
+ *
+ * Returns: a socket descriptor upon success or -1 upon failure.
+ */
+int uevent_create_socket(int buf_sz, bool passcred) {
+    int s = socket(PF_NETLINK, SOCK_DGRAM | SOCK_CLOEXEC, NETLINK_KOBJECT_UEVENT);
+    if (s < 0) {
+        return -1;
+    }
+
     int buf_sz_readback = 0;
     socklen_t optlen = sizeof(buf_sz_readback);
-    int s;
-
-    memset(&addr, 0, sizeof(addr));
-    addr.nl_family = AF_NETLINK;
-    addr.nl_pid = 0;
-    addr.nl_groups = 0xffffffff;
-
-    s = socket(PF_NETLINK, SOCK_DGRAM | SOCK_CLOEXEC, NETLINK_KOBJECT_UEVENT);
-    if (s < 0) return -1;
 
     if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &buf_sz, sizeof(buf_sz)) < 0 ||
           getsockopt(s, SOL_SOCKET, SO_RCVBUF, &buf_sz_readback, &optlen) < 0) {
@@ -123,9 +125,43 @@ int uevent_open_socket(int buf_sz, bool passcred) {
         }
     }
 
+    int on = passcred;
+
     setsockopt(s, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on));
 
-    if (bind(s, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+    return s;
+}
+
+/*
+ * Binds a netlink socket. Binding a netlink socket makes the kernel start
+ * sending netlink messages to that netlink socket.
+ *
+ * Returns: 0 upon success; -1 upon error.
+ */
+int uevent_bind(int socket) {
+    struct sockaddr_nl addr = {
+            .nl_family = AF_NETLINK,
+            .nl_pid = 0,
+            .nl_groups = 0xffffffff,
+    };
+    return bind(socket, (struct sockaddr*)&addr, sizeof(addr));
+}
+
+/*
+ * Creates a bound netlink socket for receiving uevent messages.
+ * @buf_sz: socket receive buffer size.
+ * @passcred: whether or not to enable receiving the SCM_CREDENTIALS control
+ *	message.
+ *
+ * Returns: a socket descriptor upon success or -1 upon failure.
+ */
+int uevent_open_socket(int buf_sz, bool passcred) {
+    int s = uevent_create_socket(buf_sz, passcred);
+    if (s < 0) {
+        return -1;
+    }
+
+    if (uevent_bind(s) < 0) {
         close(s);
         return -1;
     }

From 55c047fd4407b2707eee48c3cdb56f63b3229a9b Mon Sep 17 00:00:00 2001
From: Chungkai Mei <chungkai@google.com>
Date: Mon, 5 Aug 2024 05:16:20 +0000
Subject: [PATCH 1034/1487] libmodprobe: use ordered map for deterministic
 module loading

To ensure stable loading of parallel modules, switch to an ordered map structure. This will prevent potential dependency issues and conflicts.

Bug: 314213605
Change-Id: I8e00678e18417550b3be0c4228e4908a830e648c
Signed-off-by: Chungkai Mei <chungkai@google.com>
---
 libmodprobe/libmodprobe.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index 1a40da1226ef..8cc0b9b2e07b 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -447,7 +447,7 @@ bool Modprobe::IsBlocklisted(const std::string& module_name) {
 // Softdeps are taken care in InsmodWithDeps().
 bool Modprobe::LoadModulesParallel(int num_threads) {
     bool ret = true;
-    std::unordered_map<std::string, std::vector<std::string>> mod_with_deps;
+    std::map<std::string, std::vector<std::string>> mod_with_deps;
 
     // Get dependencies
     for (const auto& module : module_load_) {

From d5359abe11d6d76a958c3a63ac2665136d631406 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= <arve@android.com>
Date: Fri, 8 Sep 2023 14:32:12 -0700
Subject: [PATCH 1035/1487] trusty: libtrusty: Add vsock support

Add support for connecting to a vsock port that multiplexes trusty
services. The first vsock packet contains the tipc port name. To enable
this mode, pass "VSOCK:<cid>:<port>" as the device name string (where
<cid> and <port> is replaced with the cid and port numbers you want to
connect to).

Test: manual - ran storageproxyd and storage test with new option
Bug: 298705967
Change-Id: I9b75244ca38b7eb69ed7fc19b27aa309d0f7ed13
---
 trusty/libtrusty/trusty.c | 148 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 148 insertions(+)

diff --git a/trusty/libtrusty/trusty.c b/trusty/libtrusty/trusty.c
index f44f8b444f06..63262a0d0102 100644
--- a/trusty/libtrusty/trusty.c
+++ b/trusty/libtrusty/trusty.c
@@ -23,16 +23,161 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/uio.h>
 #include <unistd.h>
 
+#include <linux/vm_sockets.h> /* must be after sys/socket.h */
 #include <log/log.h>
 
 #include <trusty/ipc.h>
 
+static const char* strip_prefix(const char* str, const char* prefix) {
+    size_t prefix_len = strlen(prefix);
+    if (strncmp(str, prefix, prefix_len) == 0) {
+        return str + prefix_len;
+    } else {
+        return NULL;
+    }
+}
+
+static bool use_vsock_connection = false;
+static int tipc_vsock_connect(const char* type_cid_port_str, const char* srv_name) {
+    int ret;
+    const char* cid_port_str;
+    char* port_str;
+    char* end_str;
+    int socket_type;
+    if ((cid_port_str = strip_prefix(type_cid_port_str, "STREAM:"))) {
+        socket_type = SOCK_STREAM;
+    } else if ((cid_port_str = strip_prefix(type_cid_port_str, "SEQPACKET:"))) {
+        socket_type = SOCK_SEQPACKET;
+    } else {
+        /*
+         * Default to SOCK_STREAM if neither type is specified.
+         *
+         * TODO: use SOCK_SEQPACKET by default instead of SOCK_STREAM when SOCK_SEQPACKET is fully
+         * supported since it matches tipc better. At the moment SOCK_SEQPACKET is not supported by
+         * crosvm. It is also significantly slower since the Linux kernel implementation (as of
+         * v6.7-rc1) sends credit update packets every time it receives a data packet while the
+         * SOCK_STREAM version skips these unless the remaining buffer space is "low".
+         */
+        socket_type = SOCK_STREAM;
+        cid_port_str = type_cid_port_str;
+    }
+    long cid = strtol(cid_port_str, &port_str, 0);
+    if (port_str[0] != ':') {
+        ALOGE("%s: invalid VSOCK str, \"%s\", need cid:port missing : after cid\n", __func__,
+              cid_port_str);
+        return -EINVAL;
+    }
+    long port = strtol(port_str + 1, &end_str, 0);
+    if (end_str[0] != '\0') {
+        ALOGE("%s: invalid VSOCK str, \"%s\", need cid:port got %ld:%ld\n", __func__, cid_port_str,
+              cid, port);
+        return -EINVAL;
+    }
+    int fd = socket(AF_VSOCK, socket_type, 0);
+    if (fd < 0) {
+        ret = -errno;
+        ALOGE("%s: can't get vsock %ld:%ld socket for tipc service \"%s\" (err=%d)\n", __func__,
+              cid, port, srv_name, errno);
+        return ret < 0 ? ret : -1;
+    }
+    struct timeval connect_timeout = {.tv_sec = 60, .tv_usec = 0};
+    ret = setsockopt(fd, AF_VSOCK, SO_VM_SOCKETS_CONNECT_TIMEOUT, &connect_timeout,
+                     sizeof(connect_timeout));
+    if (ret) {
+        ALOGE("%s: vsock %ld:%ld: Failed to set connect timeout (err=%d)\n", __func__, cid, port,
+              errno);
+        /* failed to set longer timeout, but try to connect anyway */
+    }
+    struct sockaddr_vm sa = {
+            .svm_family = AF_VSOCK,
+            .svm_port = port,
+            .svm_cid = cid,
+    };
+    int retry = 10;
+    do {
+        ret = TEMP_FAILURE_RETRY(connect(fd, (struct sockaddr*)&sa, sizeof(sa)));
+        if (ret && (errno == ENODEV || errno == ESOCKTNOSUPPORT) && --retry) {
+            /*
+             * The kernel returns ESOCKTNOSUPPORT instead of ENODEV if the socket type is
+             * SOCK_SEQPACKET and the guest CID we are trying to connect to is not ready yet.
+             */
+            ALOGE("%s: Can't connect to vsock %ld:%ld for tipc service \"%s\" (err=%d) %d retries "
+                  "remaining\n",
+                  __func__, cid, port, srv_name, errno, retry);
+            sleep(1);
+        } else {
+            retry = 0;
+        }
+    } while (retry);
+    if (ret) {
+        ret = -errno;
+        ALOGE("%s: Can't connect to vsock %ld:%ld for tipc service \"%s\" (err=%d)\n", __func__,
+              cid, port, srv_name, errno);
+        close(fd);
+        return ret < 0 ? ret : -1;
+    }
+    /*
+     * TODO: Current vsock tipc bridge in trusty expects a port name in the
+     * first packet. We need to replace this with a protocol that also does DICE
+     * based authentication.
+     */
+    ret = TEMP_FAILURE_RETRY(write(fd, srv_name, strlen(srv_name)));
+    if (ret != strlen(srv_name)) {
+        ret = -errno;
+        ALOGE("%s: vsock %ld:%ld: failed to send tipc service name \"%s\" (err=%d)\n", __func__,
+              cid, port, srv_name, errno);
+        close(fd);
+        return ret < 0 ? ret : -1;
+    }
+    /*
+     * Work around lack of seq packet support. Read a status byte to prevent
+     * the caller from sending more data until srv_name has been read.
+     */
+    int8_t status;
+    ret = TEMP_FAILURE_RETRY(read(fd, &status, sizeof(status)));
+    if (ret != sizeof(status)) {
+        ALOGE("%s: vsock %ld:%ld: failed to read status byte for connect to tipc service name "
+              "\"%s\" (err=%d)\n",
+              __func__, cid, port, srv_name, errno);
+        close(fd);
+        return ret < 0 ? ret : -1;
+    }
+    use_vsock_connection = true;
+    return fd;
+}
+
+static size_t tipc_vsock_send(int fd, const struct iovec* iov, int iovcnt, struct trusty_shm* shms,
+                              int shmcnt) {
+    int ret;
+
+    (void)shms;
+    if (shmcnt != 0) {
+        ALOGE("%s: vsock does not yet support passing fds\n", __func__);
+        return -ENOTSUP;
+    }
+    ret = TEMP_FAILURE_RETRY(writev(fd, iov, iovcnt));
+    if (ret < 0) {
+        ret = -errno;
+        ALOGE("%s: failed to send message (err=%d)\n", __func__, errno);
+        return ret < 0 ? ret : -1;
+    }
+
+    return ret;
+}
+
 int tipc_connect(const char* dev_name, const char* srv_name) {
     int fd;
     int rc;
 
+    const char* type_cid_port_str = strip_prefix(dev_name, "VSOCK:");
+    if (type_cid_port_str) {
+        return tipc_vsock_connect(type_cid_port_str, srv_name);
+    }
+
     fd = TEMP_FAILURE_RETRY(open(dev_name, O_RDWR));
     if (fd < 0) {
         rc = -errno;
@@ -54,6 +199,9 @@ int tipc_connect(const char* dev_name, const char* srv_name) {
 
 ssize_t tipc_send(int fd, const struct iovec* iov, int iovcnt, struct trusty_shm* shms,
                   int shmcnt) {
+    if (use_vsock_connection) {
+        return tipc_vsock_send(fd, iov, iovcnt, shms, shmcnt);
+    }
     struct tipc_send_msg_req req;
     req.iov = (__u64)iov;
     req.iov_cnt = (__u64)iovcnt;

From dfeaa4e32b3a60d04de35a4235822845755fb06a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= <arve@android.com>
Date: Wed, 13 Sep 2023 18:17:18 -0700
Subject: [PATCH 1036/1487] trusty: libtrusty-rs: Add vsock support

Bug: 298705967
Test: Manual run android.hardware.security.keymint-service.rust.trusty -d VSOCK:2048:1

Change-Id: I2aa5660c3c86fed53420b874de3ef6db9dc22f96
---
 trusty/libtrusty-rs/Android.bp |  5 +-
 trusty/libtrusty-rs/src/lib.rs | 92 +++++++++++++++++++++++++++++++++-
 2 files changed, 93 insertions(+), 4 deletions(-)

diff --git a/trusty/libtrusty-rs/Android.bp b/trusty/libtrusty-rs/Android.bp
index 4fc162b89034..e2890054c476 100644
--- a/trusty/libtrusty-rs/Android.bp
+++ b/trusty/libtrusty-rs/Android.bp
@@ -21,9 +21,10 @@ rust_library {
     crate_name: "trusty",
     vendor_available: true,
     srcs: [
-        "src/lib.rs"
+        "src/lib.rs",
     ],
     rustlibs: [
+        "liblog_rust",
         "libnix",
         "liblibc",
     ],
@@ -36,5 +37,5 @@ rust_test {
     rustlibs: [
         "libtrusty-rs",
         "liblibc",
-    ]
+    ],
 }
diff --git a/trusty/libtrusty-rs/src/lib.rs b/trusty/libtrusty-rs/src/lib.rs
index 22b894a47afb..9237c8b050d1 100644
--- a/trusty/libtrusty-rs/src/lib.rs
+++ b/trusty/libtrusty-rs/src/lib.rs
@@ -61,12 +61,18 @@
 //! ```
 
 use crate::sys::tipc_connect;
+use log::{trace, warn};
+use nix::sys::socket;
+use std::convert::From;
 use std::ffi::CString;
 use std::fs::File;
+use std::io;
 use std::io::prelude::*;
 use std::io::{ErrorKind, Result};
 use std::os::unix::prelude::AsRawFd;
 use std::path::Path;
+use std::thread;
+use std::time;
 
 mod sys;
 
@@ -98,7 +104,89 @@ impl TipcChannel {
     /// bytes. This is handled with a panic because the service names are all
     /// hard-coded constants, and so such an error should always be indicative of a
     /// bug in the calling code.
-    pub fn connect(device: impl AsRef<Path>, service: &str) -> Result<Self> {
+    pub fn connect(device: &str, service: &str) -> Result<Self> {
+        if let Some(cid_port_str) = device.strip_prefix("VSOCK:") {
+            Self::connect_vsock(cid_port_str, service)
+        } else {
+            Self::connect_tipc(device, service)
+        }
+    }
+
+    fn connect_vsock(type_cid_port_str: &str, service: &str) -> Result<Self> {
+        let cid_port_str;
+        let socket_type;
+        if let Some(stream_cid_port_str) = type_cid_port_str.strip_prefix("STREAM:") {
+            socket_type = socket::SockType::Stream;
+            cid_port_str = stream_cid_port_str;
+        } else if let Some(seqpacket_cid_port_str) = type_cid_port_str.strip_prefix("SEQPACKET:") {
+            socket_type = socket::SockType::SeqPacket;
+            cid_port_str = seqpacket_cid_port_str;
+        } else {
+            /*
+             * Default to SOCK_STREAM if neither type is specified.
+             *
+             * TODO: use SOCK_SEQPACKET by default instead of SOCK_STREAM when SOCK_SEQPACKET is fully
+             * supported since it matches tipc better. At the moment SOCK_SEQPACKET is not supported by
+             * crosvm. It is also significantly slower since the Linux kernel implementation (as of
+             * v6.7-rc1) sends credit update packets every time it receives a data packet while the
+             * SOCK_STREAM version skips these unless the remaining buffer space is "low".
+             */
+            socket_type = socket::SockType::Stream;
+            cid_port_str = type_cid_port_str;
+        }
+
+        let [cid, port]: [u32; 2] = cid_port_str
+            .split(':')
+            .map(|v| v.parse::<u32>().map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e)))
+            .collect::<Result<Vec<u32>>>()?
+            .try_into()
+            .map_err(|e| {
+                io::Error::new(io::ErrorKind::InvalidInput, format!("Wrong number of args: {e:?}"))
+            })?;
+
+        trace!("got cid, port: {cid}, {port}");
+        let s = socket::socket(
+            socket::AddressFamily::Vsock,
+            socket_type,
+            socket::SockFlag::SOCK_CLOEXEC,
+            None,
+        )?;
+        trace!("got socket");
+        let sa = socket::VsockAddr::new(cid, port);
+        trace!("got sa");
+
+        //let connect_timeout = libc::timeval {tv_sec: 60, tv_usec: 0};
+        // TODO: Set AF_VSOCK/SO_VM_SOCKETS_CONNECT_TIMEOUT sockopt.
+
+        let mut retry = 10;
+        loop {
+            let res = socket::connect(s.as_raw_fd(), &sa);
+            if res.is_ok() || retry <= 0 {
+                res?;
+                break;
+            }
+            warn!("vsock:{cid}:{port} connect failed {res:?}, {retry} retries remaining");
+            retry -= 1;
+            thread::sleep(time::Duration::from_secs(5));
+        }
+        trace!("connected");
+        // TODO: Current vsock tipc bridge in trusty expects a port name in the
+        // first packet. We need to replace this with a protocol that also does DICE
+        // based authentication.
+        // `s` is a valid file descriptor because it came from socket::socket.
+        let mut channel = Self(File::from(s));
+        channel.send(service.as_bytes())?;
+        trace!("sent tipc port name");
+
+        // Work around lack of seq packet support. Read a status byte to prevent
+        // the caller from sending more data until srv_name has been read.
+        let mut status = [0; 1];
+        channel.recv_no_alloc(&mut status)?;
+        trace!("got status byte: {status:?}");
+        Ok(channel)
+    }
+
+    fn connect_tipc(device: impl AsRef<Path>, service: &str) -> Result<Self> {
         let file = File::options().read(true).write(true).open(device)?;
 
         let srv_name = CString::new(service).expect("Service name contained null bytes");
@@ -108,7 +196,7 @@ impl TipcChannel {
             tipc_connect(file.as_raw_fd(), srv_name.as_ptr())?;
         }
 
-        Ok(TipcChannel(file))
+        Ok(Self(file))
     }
 
     /// Sends a message to the connected service.

From 3df2dc1aaed17ed9bc682cab1058fa8f29fbd39d Mon Sep 17 00:00:00 2001
From: Sandeep Dhavale <dhavale@google.com>
Date: Mon, 5 Aug 2024 17:03:38 -0700
Subject: [PATCH 1037/1487] snapuserd: remove implicit assumption about dm-user
 in BufferSink

This removes implicit assumption that BufferSink can only be used with
dm-user. User of BufferSink can specify size of header during
BufferSink::Initialize to reserve the space for the header.

Also get rid of now unused structure dm_user_payload and
dm_user_message.

Test: TH
Test: ota
Test: vts_snapused_test
Bug: 357711761
Change-Id: I1e550393ce1f0277fe215015fa6948ad3c3b68ba
Signed-off-by: Sandeep Dhavale <dhavale@google.com>
---
 .../snapuserd/dm_user_block_server.cpp        |  8 ++++---
 .../include/snapuserd/dm_user_block_server.h  |  1 +
 .../include/snapuserd/snapuserd_buffer.h      |  9 ++++++--
 .../include/snapuserd/snapuserd_kernel.h      | 10 ---------
 .../snapuserd/snapuserd_buffer.cpp            | 22 +++++++++----------
 5 files changed, 24 insertions(+), 26 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp b/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp
index e98833502554..4599ad3b31d8 100644
--- a/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/dm_user_block_server.cpp
@@ -27,11 +27,12 @@ using android::base::unique_fd;
 DmUserBlockServer::DmUserBlockServer(const std::string& misc_name, unique_fd&& ctrl_fd,
                                      Delegate* delegate, size_t buffer_size)
     : misc_name_(misc_name), ctrl_fd_(std::move(ctrl_fd)), delegate_(delegate) {
-    buffer_.Initialize(buffer_size);
+    buffer_.Initialize(sizeof(struct dm_user_header), buffer_size);
 }
 
 bool DmUserBlockServer::ProcessRequests() {
-    struct dm_user_header* header = buffer_.GetHeaderPtr();
+    struct dm_user_header* header =
+            reinterpret_cast<struct dm_user_header*>(buffer_.GetHeaderPtr());
     if (!android::base::ReadFully(ctrl_fd_, header, sizeof(*header))) {
         if (errno != ENOTBLK) {
             SNAP_PLOG(ERROR) << "Control-read failed";
@@ -90,7 +91,8 @@ bool DmUserBlockServer::SendBufferedIo() {
 }
 
 void DmUserBlockServer::SendError() {
-    struct dm_user_header* header = buffer_.GetHeaderPtr();
+    struct dm_user_header* header =
+            reinterpret_cast<struct dm_user_header*>(buffer_.GetHeaderPtr());
     header->type = DM_USER_RESP_ERROR;
     // This is an issue with the dm-user interface. There
     // is no way to propagate the I/O error back to dm-user
diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/dm_user_block_server.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/dm_user_block_server.h
index f1f8da1430e2..35c6bfbb21e7 100644
--- a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/dm_user_block_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/dm_user_block_server.h
@@ -20,6 +20,7 @@
 
 #include <snapuserd/block_server.h>
 #include <snapuserd/snapuserd_buffer.h>
+#include <snapuserd/snapuserd_kernel.h>
 
 namespace android {
 namespace snapshot {
diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_buffer.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_buffer.h
index c5ca2b120184..cc7c48c96ab7 100644
--- a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_buffer.h
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_buffer.h
@@ -27,13 +27,17 @@ namespace snapshot {
 
 class BufferSink final {
   public:
-    void Initialize(size_t size);
+    // Do not reserve any space of header by default
+    void Initialize(size_t size) { return Initialize(0, size); };
+    // This allows to set const header_size_ to be used if caller needs it
+    // for example, while working with dm_user
+    void Initialize(size_t header_size, size_t size);
     void* GetBufPtr() { return buffer_.get(); }
     void Clear() { memset(GetBufPtr(), 0, buffer_size_); }
     void* GetPayloadBuffer(size_t size);
     void* GetBuffer(size_t requested, size_t* actual);
     void UpdateBufferOffset(size_t size) { buffer_offset_ += size; }
-    struct dm_user_header* GetHeaderPtr();
+    void* GetHeaderPtr();
     void ResetBufferOffset() { buffer_offset_ = 0; }
     void* GetPayloadBufPtr();
     loff_t GetPayloadBytesWritten() { return buffer_offset_; }
@@ -56,6 +60,7 @@ class BufferSink final {
     std::unique_ptr<uint8_t[]> buffer_;
     loff_t buffer_offset_;
     size_t buffer_size_;
+    size_t header_size_;
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_kernel.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_kernel.h
index 7ab75dc7966c..14291b214f22 100644
--- a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_kernel.h
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_kernel.h
@@ -92,15 +92,5 @@ struct dm_user_header {
     __u64 len;
 } __attribute__((packed));
 
-struct dm_user_payload {
-    __u8 buf[];
-};
-
-// Message comprising both header and payload
-struct dm_user_message {
-    struct dm_user_header header;
-    struct dm_user_payload payload;
-};
-
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_buffer.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_buffer.cpp
index 490c0e63a1bc..51b2490342ac 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_buffer.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_buffer.cpp
@@ -22,8 +22,9 @@
 namespace android {
 namespace snapshot {
 
-void BufferSink::Initialize(size_t size) {
-    buffer_size_ = size + sizeof(struct dm_user_header);
+void BufferSink::Initialize(size_t header_size, size_t size) {
+    header_size_ = header_size;
+    buffer_size_ = size + header_size;
     buffer_offset_ = 0;
     buffer_ = std::make_unique<uint8_t[]>(buffer_size_);
 }
@@ -41,11 +42,11 @@ void* BufferSink::AcquireBuffer(size_t size, size_t to_write) {
 
 void* BufferSink::GetPayloadBuffer(size_t size) {
     char* buffer = reinterpret_cast<char*>(GetBufPtr());
-    struct dm_user_message* msg = (struct dm_user_message*)(&(buffer[0]));
-    if ((buffer_size_ - buffer_offset_ - sizeof(msg->header)) < size) {
+
+    if ((buffer_size_ - buffer_offset_ - header_size_) < size) {
         return nullptr;
     }
-    return (char*)msg->payload.buf + buffer_offset_;
+    return (char*)(&buffer[0] + header_size_ + buffer_offset_);
 }
 
 void* BufferSink::GetBuffer(size_t requested, size_t* actual) {
@@ -58,19 +59,18 @@ void* BufferSink::GetBuffer(size_t requested, size_t* actual) {
     return buf;
 }
 
-struct dm_user_header* BufferSink::GetHeaderPtr() {
-    if (!(sizeof(struct dm_user_header) <= buffer_size_)) {
+void* BufferSink::GetHeaderPtr() {
+    // If no sufficient space or header not reserved
+    if (!(header_size_ <= buffer_size_) || !header_size_) {
         return nullptr;
     }
     char* buf = reinterpret_cast<char*>(GetBufPtr());
-    struct dm_user_header* header = (struct dm_user_header*)(&(buf[0]));
-    return header;
+    return (void*)(&(buf[0]));
 }
 
 void* BufferSink::GetPayloadBufPtr() {
     char* buffer = reinterpret_cast<char*>(GetBufPtr());
-    struct dm_user_message* msg = reinterpret_cast<struct dm_user_message*>(&(buffer[0]));
-    return msg->payload.buf;
+    return &buffer[header_size_];
 }
 
 }  // namespace snapshot

From 61c07a09e8e234ede8f60f4d8898415a03da16ff Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Wed, 7 Aug 2024 17:19:24 +0000
Subject: [PATCH 1038/1487] Revert^2 "Set block device as RO/RW before mount"

Original CL reverted due to missing permission on vold.
The missing permission is added in aosp/3202313 , hence re-submit.

This reverts commit 1f00f794e6585b73881ac2f11f1fdede1278e54e.


Reason for revert: b/349507086

Change-Id: Ia1086f3c8c65c476bdc119fe59ed4fd3a21f8591
---
 fs_mgr/fs_mgr.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 5156754a8538..ea2e3a8c754b 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -826,6 +826,9 @@ static int __mount(const std::string& source, const std::string& target, const F
     if (read_only) {
         mountflags |= MS_RDONLY;
     }
+    if (!fs_mgr_set_blk_ro(source, read_only)) {
+        PLOG(ERROR) << "Failed to set " << source << " as " << (read_only ? "RO" : "RW");
+    }
     int ret = 0;
     int save_errno = 0;
     int gc_allowance = 0;
@@ -880,9 +883,6 @@ static int __mount(const std::string& source, const std::string& target, const F
     }
     PINFO << __FUNCTION__ << "(source=" << source << source_missing << ",target=" << target
           << target_missing << ",type=" << entry.fs_type << ")=" << ret;
-    if ((ret == 0) && (mountflags & MS_RDONLY) != 0) {
-        fs_mgr_set_blk_ro(source);
-    }
     if (ret == 0) {
         android::base::SetProperty("ro.boottime.init.mount." + Basename(target),
                                    std::to_string(t.duration().count()));

From a880e5675b747b9f3d5631b656e0a7408edc6ad7 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 7 Aug 2024 10:35:50 -0700
Subject: [PATCH 1039/1487] snapuserd_test: skip test if dm-user kernel driver
 is absent

Bug: 357487459
Test: snapuserd_test
Change-Id: I8458f223fc35fcfa042588e67a30c5bb273b0277
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |  4 ++
 .../user-space-merge/snapuserd_test.cpp       |  8 ++++
 fs_mgr/libsnapshot/snapuserd/utility.cpp      | 37 +++++++++++++++++++
 fs_mgr/libsnapshot/snapuserd/utility.h        |  5 +++
 4 files changed, 54 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index b3a7e8cf1eb4..efbcb5a4e174 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -267,6 +267,10 @@ cc_test {
     test_suites: [
         "vts",
     ],
+    test_options: {
+        // VABC mandatory in Android T per VSR.
+        min_shipping_api_level: 32,
+    },
 }
 
 cc_binary_host {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 9042f2bb8655..4dfb9bf4ef17 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -1530,6 +1530,14 @@ INSTANTIATE_TEST_SUITE_P(Io, HandlerTest, ::testing::ValuesIn(GetTestConfigs()))
 int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
+#ifdef __ANDROID__
+    if (!android::snapshot::CanUseUserspaceSnapshots() ||
+        android::snapshot::IsVendorFromAndroid12()) {
+        std::cerr << "snapuserd_test not supported on this device\n";
+        return 0;
+    }
+#endif
+
     gflags::ParseCommandLineFlags(&argc, &argv, false);
 
     return RUN_ALL_TESTS();
diff --git a/fs_mgr/libsnapshot/snapuserd/utility.cpp b/fs_mgr/libsnapshot/snapuserd/utility.cpp
index 684ca3d7ba9b..b44f5abd2355 100644
--- a/fs_mgr/libsnapshot/snapuserd/utility.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/utility.cpp
@@ -14,11 +14,14 @@
 
 #include "utility.h"
 
+#include <android-base/properties.h>
 #include <sys/resource.h>
 #include <sys/utsname.h>
 #include <unistd.h>
 
 #include <android-base/file.h>
+#include <android-base/logging.h>
+#include <libdm/dm.h>
 #include <processgroup/processgroup.h>
 
 #include <private/android_filesystem_config.h>
@@ -27,6 +30,7 @@ namespace android {
 namespace snapshot {
 
 using android::base::unique_fd;
+using android::dm::DeviceMapper;
 
 bool SetThreadPriority([[maybe_unused]] int priority) {
 #ifdef __ANDROID__
@@ -61,5 +65,38 @@ bool KernelSupportsIoUring() {
     return major > 5 || (major == 5 && minor >= 6);
 }
 
+bool GetUserspaceSnapshotsEnabledProperty() {
+    return android::base::GetBoolProperty("ro.virtual_ab.userspace.snapshots.enabled", false);
+}
+
+bool KernelSupportsCompressedSnapshots() {
+    auto& dm = DeviceMapper::Instance();
+    return dm.GetTargetByName("user", nullptr);
+}
+
+bool IsVendorFromAndroid12() {
+    const std::string UNKNOWN = "unknown";
+    const std::string vendor_release =
+            android::base::GetProperty("ro.vendor.build.version.release_or_codename", UNKNOWN);
+
+    if (vendor_release.find("12") != std::string::npos) {
+        return true;
+    }
+    return false;
+}
+
+bool CanUseUserspaceSnapshots() {
+    if (!GetUserspaceSnapshotsEnabledProperty()) {
+        LOG(INFO) << "Virtual A/B - Userspace snapshots disabled";
+        return false;
+    }
+
+    if (!KernelSupportsCompressedSnapshots()) {
+        LOG(ERROR) << "Userspace snapshots requested, but no kernel support is available.";
+        return false;
+    }
+    return true;
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/utility.h b/fs_mgr/libsnapshot/snapuserd/utility.h
index c3c3cbae913d..50be4183708c 100644
--- a/fs_mgr/libsnapshot/snapuserd/utility.h
+++ b/fs_mgr/libsnapshot/snapuserd/utility.h
@@ -24,5 +24,10 @@ bool SetThreadPriority(int priority);
 bool SetProfiles(std::initializer_list<std::string_view> profiles);
 bool KernelSupportsIoUring();
 
+bool GetUserspaceSnapshotsEnabledProperty();
+bool KernelSupportsCompressedSnapshots();
+bool CanUseUserspaceSnapshots();
+bool IsVendorFromAndroid12();
+
 }  // namespace snapshot
 }  // namespace android

From 2317bbad07a5dddac480fba6db2b9d0210d566cd Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 24 Jul 2024 11:27:11 -0700
Subject: [PATCH 1040/1487] libsnapshot: compile tests for both 32 and 64 bit

Bug: 352605053
Test: th
Change-Id: I0566e237d1151c705d61623be4b496d73b9ec3ea
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/Android.bp           | 16 +++++++++-------
 fs_mgr/libsnapshot/snapuserd/Android.bp | 12 +++++++++++-
 2 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index cc6db358b098..0a9a95c57bed 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -281,9 +281,17 @@ cc_defaults {
     header_libs: [
         "libstorage_literals_headers",
     ],
+    compile_multilib: "both",
+    multilib: {
+        lib32: {
+            suffix: "32",
+        },
+        lib64: {
+            suffix: "64",
+        },
+    },
     auto_gen_config: true,
     require_root: true,
-    compile_multilib: "first",
 }
 
 cc_test {
@@ -316,12 +324,6 @@ cc_test {
     test_options: {
         // Legacy VAB launched in Android R.
         min_shipping_api_level: 30,
-        test_runner_options: [
-            {
-                name: "force-no-test-error",
-                value: "false",
-            },
-        ],
     },
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index b3a7e8cf1eb4..43be0987b431 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -238,9 +238,19 @@ cc_defaults {
     test_options: {
         min_shipping_api_level: 30,
     },
+
+    compile_multilib: "both",
+    multilib: {
+        lib32: {
+            suffix: "32",
+        },
+        lib64: {
+            suffix: "64",
+        },
+    },
+
     auto_gen_config: true,
     require_root: true,
-    compile_multilib: "first",
 }
 
 cc_test {

From df5ae06d4ce417a8ba9b2d2210943fc31e0381ae Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Wed, 7 Aug 2024 20:31:50 +0000
Subject: [PATCH 1041/1487] Small clean-up of debuggerd test.

For the debuggerd_test.cpp tests, don't include any libdebuggerd
internal headers.

Test: Compiles and unit tests pass.
Change-Id: I6335dc9e09992f5725a24fc45a8356efab7158e6
---
 debuggerd/debuggerd_test.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index baddf65787c0..08619b980c33 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -18,6 +18,7 @@
 #include <dlfcn.h>
 #include <err.h>
 #include <fcntl.h>
+#include <inttypes.h>
 #include <linux/prctl.h>
 #include <malloc.h>
 #include <pthread.h>
@@ -69,7 +70,6 @@
 #include "crash_test.h"
 #include "debuggerd/handler.h"
 #include "gtest/gtest.h"
-#include "libdebuggerd/utility.h"
 #include "protocol.h"
 #include "tombstoned/tombstoned.h"
 #include "util.h"
@@ -86,6 +86,7 @@ using ::testing::HasSubstr;
 #define ARCH_SUFFIX ""
 #endif
 
+constexpr size_t kTagGranuleSize = 16;
 constexpr char kWaitForDebuggerKey[] = "debug.debuggerd.wait_for_debugger";
 
 #define TIMEOUT(seconds, expr)                                     \

From 873ae91b9558cb935c9d816899588fbfd6d775a8 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 8 Aug 2024 05:29:52 +0000
Subject: [PATCH 1042/1487] Revert "libsnapshot: compile tests for both 32 and
 64 bit"

This reverts commit 2317bbad07a5dddac480fba6db2b9d0210d566cd.

Reason for revert: b/358254699

Change-Id: Icb9dc0d48f3e39a45a69f9aa36f9bfe46d27e37a
---
 fs_mgr/libsnapshot/Android.bp           | 16 +++++++---------
 fs_mgr/libsnapshot/snapuserd/Android.bp | 12 +-----------
 2 files changed, 8 insertions(+), 20 deletions(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 0a9a95c57bed..cc6db358b098 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -281,17 +281,9 @@ cc_defaults {
     header_libs: [
         "libstorage_literals_headers",
     ],
-    compile_multilib: "both",
-    multilib: {
-        lib32: {
-            suffix: "32",
-        },
-        lib64: {
-            suffix: "64",
-        },
-    },
     auto_gen_config: true,
     require_root: true,
+    compile_multilib: "first",
 }
 
 cc_test {
@@ -324,6 +316,12 @@ cc_test {
     test_options: {
         // Legacy VAB launched in Android R.
         min_shipping_api_level: 30,
+        test_runner_options: [
+            {
+                name: "force-no-test-error",
+                value: "false",
+            },
+        ],
     },
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 43be0987b431..b3a7e8cf1eb4 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -238,19 +238,9 @@ cc_defaults {
     test_options: {
         min_shipping_api_level: 30,
     },
-
-    compile_multilib: "both",
-    multilib: {
-        lib32: {
-            suffix: "32",
-        },
-        lib64: {
-            suffix: "64",
-        },
-    },
-
     auto_gen_config: true,
     require_root: true,
+    compile_multilib: "first",
 }
 
 cc_test {

From a791e913048801a2a74beaea42b992c380eb8c2c Mon Sep 17 00:00:00 2001
From: mingwei xue <mingwei.xue@transsion.corp-partner.google.com>
Date: Thu, 8 Aug 2024 03:38:57 +0000
Subject: [PATCH 1043/1487] Fix SnapshotTest crash

For Android 12 vendor project, SnapshotTestEnvironment setup is skipped. So, test_device is not initialized, which will cause other tests to fail.

Change-Id: I6ce6a9e7ea2c210e25c2a5ffadaaa6348086ea7f
BUG:350678717
Test:run vts -m vts_libsnapshot_test
---
 fs_mgr/libsnapshot/snapshot_test.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index b2e36d426072..d66490c5e327 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2840,7 +2840,6 @@ void SnapshotTestEnvironment::SetUp() {
     // that is fixed, don't call GTEST_SKIP here, but instead call GTEST_SKIP in individual test
     // suites.
     RETURN_IF_NON_VIRTUAL_AB_MSG("Virtual A/B is not enabled, skipping global setup.\n");
-    RETURN_IF_VENDOR_ON_ANDROID_S_MSG("Test not enabled for Vendor on Android S.\n");
 
     std::vector<std::string> paths = {
             // clang-format off

From b6e4179dab36223516d53c63ae0b00940106642e Mon Sep 17 00:00:00 2001
From: Inseob Kim <inseob@google.com>
Date: Mon, 5 Aug 2024 16:33:25 +0900
Subject: [PATCH 1044/1487] Add /mnt/vm and mount tmpfs onto it for early VM

It will be used as a storage for early boot virtmgr.

Bug: 354059281
Test: boot and check /mnt/vm
Change-Id: I4a0c604161356b631c21913a0f8c3f2d796a3c65
---
 rootdir/init.rc | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index b804c1bde0cf..7c089c245d56 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -648,6 +648,14 @@ on late-fs
     chmod 0755 /sys/kernel/tracing
     chmod 0755 /sys/kernel/debug/tracing
 
+    # Early HALs may use early VM. Mount /mnt/vm before starting such HALs.
+    mkdir /mnt/vm 0755 root root
+    mount tmpfs tmpfs /mnt/vm nosuid nodev noexec rw
+    restorecon /mnt/vm
+    chown system system /mnt/vm
+    chmod 0770 /mnt/vm
+    mkdir /mnt/vm/early 0770 system system
+
     # HALs required before storage encryption can get unlocked (FBE)
     class_start early_hal
 

From e34549af332e4be13a2ffb385455280d4736c1a9 Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Fri, 9 Aug 2024 15:58:53 +0900
Subject: [PATCH 1045/1487] Clean up userspace-reboot

The feature was deprecated last year.

Bug: 292469129
Test: atest CtsInitTestCases
Change-Id: I826502770ab3fa566be57a33829f1103efa893fb
---
 fs_mgr/fs_mgr.cpp              | 200 ++-----------------------------
 fs_mgr/include/fs_mgr.h        |  21 +---
 fs_mgr/tests/fs_mgr_test.cpp   |  17 ---
 init/builtins.cpp              |  37 +-----
 init/property_service.cpp      |   5 +-
 init/property_service_test.cpp |   6 -
 init/reboot.cpp                | 210 +--------------------------------
 rootdir/init.rc                |  41 -------
 rootdir/init.usb.rc            |   4 -
 9 files changed, 15 insertions(+), 526 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 3e70f79370fd..76578dd2ccf7 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -1433,16 +1433,16 @@ bool WasMetadataEncryptionInterrupted(const FstabEntry& entry) {
 // When multiple fstab records share the same mount_point, it will try to mount each
 // one in turn, and ignore any duplicates after a first successful mount.
 // Returns -1 on error, and  FS_MGR_MNTALL_* otherwise.
-MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
+int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
     int encryptable = FS_MGR_MNTALL_DEV_NOT_ENCRYPTABLE;
     int error_count = 0;
     CheckpointManager checkpoint_manager;
     AvbUniquePtr avb_handle(nullptr);
     bool wiped = false;
-
     bool userdata_mounted = false;
+
     if (fstab->empty()) {
-        return {FS_MGR_MNTALL_FAIL, userdata_mounted};
+        return FS_MGR_MNTALL_FAIL;
     }
 
     bool scratch_can_be_mounted = true;
@@ -1521,7 +1521,7 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                 if (!avb_handle) {
                     LERROR << "Failed to open AvbHandle";
                     set_type_property(encryptable);
-                    return {FS_MGR_MNTALL_FAIL, userdata_mounted};
+                    return FS_MGR_MNTALL_FAIL;
                 }
             }
             if (avb_handle->SetUpAvbHashtree(&current_entry, true /* wait_for_verity_dev */) ==
@@ -1557,7 +1557,7 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
 
             if (status == FS_MGR_MNTALL_FAIL) {
                 // Fatal error - no point continuing.
-                return {status, userdata_mounted};
+                return status;
             }
 
             if (status != FS_MGR_MNTALL_DEV_NOT_ENCRYPTABLE) {
@@ -1577,7 +1577,7 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                                   nullptr)) {
                         LERROR << "Encryption failed";
                         set_type_property(encryptable);
-                        return {FS_MGR_MNTALL_FAIL, userdata_mounted};
+                        return FS_MGR_MNTALL_FAIL;
                     }
                 }
             }
@@ -1696,9 +1696,9 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
     set_type_property(encryptable);
 
     if (error_count) {
-        return {FS_MGR_MNTALL_FAIL, userdata_mounted};
+        return FS_MGR_MNTALL_FAIL;
     } else {
-        return {encryptable, userdata_mounted};
+        return encryptable;
     }
 }
 
@@ -1735,190 +1735,6 @@ int fs_mgr_umount_all(android::fs_mgr::Fstab* fstab) {
     return ret;
 }
 
-static std::chrono::milliseconds GetMillisProperty(const std::string& name,
-                                                   std::chrono::milliseconds default_value) {
-    auto value = GetUintProperty(name, static_cast<uint64_t>(default_value.count()));
-    return std::chrono::milliseconds(std::move(value));
-}
-
-static bool fs_mgr_unmount_all_data_mounts(const std::string& data_block_device) {
-    LINFO << __FUNCTION__ << "(): about to umount everything on top of " << data_block_device;
-    Timer t;
-    auto timeout = GetMillisProperty("init.userspace_reboot.userdata_remount.timeoutmillis", 5s);
-    while (true) {
-        bool umount_done = true;
-        Fstab proc_mounts;
-        if (!ReadFstabFromFile("/proc/mounts", &proc_mounts)) {
-            LERROR << __FUNCTION__ << "(): Can't read /proc/mounts";
-            return false;
-        }
-        // Now proceed with other bind mounts on top of /data.
-        for (const auto& entry : proc_mounts) {
-            std::string block_device;
-            if (StartsWith(entry.blk_device, "/dev/block") &&
-                !Realpath(entry.blk_device, &block_device)) {
-                PWARNING << __FUNCTION__ << "(): failed to realpath " << entry.blk_device;
-                block_device = entry.blk_device;
-            }
-            if (data_block_device == block_device) {
-                if (umount2(entry.mount_point.c_str(), 0) != 0) {
-                    PERROR << __FUNCTION__ << "(): Failed to umount " << entry.mount_point;
-                    umount_done = false;
-                }
-            }
-        }
-        if (umount_done) {
-            LINFO << __FUNCTION__ << "(): Unmounting /data took " << t;
-            return true;
-        }
-        if (t.duration() > timeout) {
-            LERROR << __FUNCTION__ << "(): Timed out unmounting all mounts on "
-                   << data_block_device;
-            Fstab remaining_mounts;
-            if (!ReadFstabFromFile("/proc/mounts", &remaining_mounts)) {
-                LERROR << __FUNCTION__ << "(): Can't read /proc/mounts";
-            } else {
-                LERROR << __FUNCTION__ << "(): Following mounts remaining";
-                for (const auto& e : remaining_mounts) {
-                    LERROR << __FUNCTION__ << "(): mount point: " << e.mount_point
-                           << " block device: " << e.blk_device;
-                }
-            }
-            return false;
-        }
-        std::this_thread::sleep_for(50ms);
-    }
-}
-
-static bool UnwindDmDeviceStack(const std::string& block_device,
-                                std::vector<std::string>* dm_stack) {
-    if (!StartsWith(block_device, "/dev/block/")) {
-        LWARNING << block_device << " is not a block device";
-        return false;
-    }
-    std::string current = block_device;
-    DeviceMapper& dm = DeviceMapper::Instance();
-    while (true) {
-        dm_stack->push_back(current);
-        if (!dm.IsDmBlockDevice(current)) {
-            break;
-        }
-        auto parent = dm.GetParentBlockDeviceByPath(current);
-        if (!parent) {
-            return false;
-        }
-        current = *parent;
-    }
-    return true;
-}
-
-FstabEntry* fs_mgr_get_mounted_entry_for_userdata(Fstab* fstab,
-                                                  const std::string& data_block_device) {
-    std::vector<std::string> dm_stack;
-    if (!UnwindDmDeviceStack(data_block_device, &dm_stack)) {
-        LERROR << "Failed to unwind dm-device stack for " << data_block_device;
-        return nullptr;
-    }
-    for (auto& entry : *fstab) {
-        if (entry.mount_point != "/data") {
-            continue;
-        }
-        std::string block_device;
-        if (entry.fs_mgr_flags.logical) {
-            if (!fs_mgr_update_logical_partition(&entry)) {
-                LERROR << "Failed to update logic partition " << entry.blk_device;
-                continue;
-            }
-            block_device = entry.blk_device;
-        } else if (!Realpath(entry.blk_device, &block_device)) {
-            PWARNING << "Failed to realpath " << entry.blk_device;
-            block_device = entry.blk_device;
-        }
-        if (std::find(dm_stack.begin(), dm_stack.end(), block_device) != dm_stack.end()) {
-            return &entry;
-        }
-    }
-    LERROR << "Didn't find entry that was used to mount /data onto " << data_block_device;
-    return nullptr;
-}
-
-// TODO(b/143970043): return different error codes based on which step failed.
-int fs_mgr_remount_userdata_into_checkpointing(Fstab* fstab) {
-    Fstab proc_mounts;
-    if (!ReadFstabFromFile("/proc/mounts", &proc_mounts)) {
-        LERROR << "Can't read /proc/mounts";
-        return -1;
-    }
-    auto mounted_entry = GetEntryForMountPoint(&proc_mounts, "/data");
-    if (mounted_entry == nullptr) {
-        LERROR << "/data is not mounted";
-        return -1;
-    }
-    std::string block_device;
-    if (!Realpath(mounted_entry->blk_device, &block_device)) {
-        PERROR << "Failed to realpath " << mounted_entry->blk_device;
-        return -1;
-    }
-    auto fstab_entry = fs_mgr_get_mounted_entry_for_userdata(fstab, block_device);
-    if (fstab_entry == nullptr) {
-        LERROR << "Can't find /data in fstab";
-        return -1;
-    }
-    bool force_umount = GetBoolProperty("sys.init.userdata_remount.force_umount", false);
-    if (force_umount) {
-        LINFO << "Will force an umount of userdata even if it's not required";
-    }
-    if (!force_umount && !SupportsCheckpoint(fstab_entry)) {
-        LINFO << "Userdata doesn't support checkpointing. Nothing to do";
-        return 0;
-    }
-    CheckpointManager checkpoint_manager;
-    if (!force_umount && !checkpoint_manager.NeedsCheckpoint()) {
-        LINFO << "Checkpointing not needed. Don't remount";
-        return 0;
-    }
-    if (!force_umount && fstab_entry->fs_mgr_flags.checkpoint_fs) {
-        // Userdata is f2fs, simply remount it.
-        if (!checkpoint_manager.Update(fstab_entry)) {
-            LERROR << "Failed to remount userdata in checkpointing mode";
-            return -1;
-        }
-        if (mount(block_device.c_str(), fstab_entry->mount_point.c_str(), "none",
-                  MS_REMOUNT | fstab_entry->flags, fstab_entry->fs_options.c_str()) != 0) {
-            PERROR << "Failed to remount userdata in checkpointing mode";
-            return -1;
-        }
-    } else {
-        LINFO << "Unmounting /data before remounting into checkpointing mode";
-        if (!fs_mgr_unmount_all_data_mounts(block_device)) {
-            LERROR << "Failed to umount /data";
-            return -1;
-        }
-        DeviceMapper& dm = DeviceMapper::Instance();
-        while (dm.IsDmBlockDevice(block_device)) {
-            auto next_device = dm.GetParentBlockDeviceByPath(block_device);
-            auto name = dm.GetDmDeviceNameByPath(block_device);
-            if (!name) {
-                LERROR << "Failed to get dm-name for " << block_device;
-                return -1;
-            }
-            LINFO << "Deleting " << block_device << " named " << *name;
-            if (!dm.DeleteDevice(*name, 3s)) {
-                return -1;
-            }
-            if (!next_device) {
-                LERROR << "Failed to find parent device for " << block_device;
-            }
-            block_device = *next_device;
-        }
-        LINFO << "Remounting /data";
-        // TODO(b/143970043): remove this hack after fs_mgr_mount_all is refactored.
-        auto result = fs_mgr_mount_all(fstab, MOUNT_MODE_ONLY_USERDATA);
-        return result.code == FS_MGR_MNTALL_FAIL ? -1 : 0;
-    }
-    return 0;
-}
-
 // wrapper to __mount() and expects a fully prepared fstab_rec,
 // unlike fs_mgr_do_mount which does more things with avb / verity etc.
 int fs_mgr_do_mount_one(const FstabEntry& entry, const std::string& alt_mount_point) {
diff --git a/fs_mgr/include/fs_mgr.h b/fs_mgr/include/fs_mgr.h
index 2e1cf76ea46f..af5ae2d168e5 100644
--- a/fs_mgr/include/fs_mgr.h
+++ b/fs_mgr/include/fs_mgr.h
@@ -58,13 +58,8 @@ enum mount_mode {
 #define FS_MGR_MNTALL_DEV_NEEDS_RECOVERY 4
 #define FS_MGR_MNTALL_DEV_NOT_ENCRYPTABLE 0
 #define FS_MGR_MNTALL_FAIL (-1)
-
-struct MountAllResult {
-    // One of the FS_MGR_MNTALL_* returned code defined above.
-    int code;
-    // Whether userdata was mounted as a result of |fs_mgr_mount_all| call.
-    bool userdata_mounted;
-};
+// fs_mgr_mount_all() updates fstab entries that reference device-mapper.
+int fs_mgr_mount_all(android::fs_mgr::Fstab* fstab, int mount_mode);
 
 struct HashtreeInfo {
     // The hash algorithm used to build the merkle tree.
@@ -75,13 +70,6 @@ struct HashtreeInfo {
     bool check_at_most_once;
 };
 
-// fs_mgr_mount_all() updates fstab entries that reference device-mapper.
-// Returns a |MountAllResult|. The first element is one of the FS_MNG_MNTALL_* return codes
-// defined above, and the second element tells whether this call to fs_mgr_mount_all was responsible
-// for mounting userdata. Later is required for init to correctly enqueue fs-related events as part
-// of userdata remount during userspace reboot.
-MountAllResult fs_mgr_mount_all(android::fs_mgr::Fstab* fstab, int mount_mode);
-
 #define FS_MGR_DOMNT_FAILED (-1)
 #define FS_MGR_DOMNT_BUSY (-2)
 #define FS_MGR_DOMNT_SUCCESS 0
@@ -127,11 +115,6 @@ enum FsMgrUmountStatus : int {
 // it destroys verity devices from device mapper after the device is unmounted.
 int fs_mgr_umount_all(android::fs_mgr::Fstab* fstab);
 
-// Finds a entry in |fstab| that was used to mount a /data on |data_block_device|.
-android::fs_mgr::FstabEntry* fs_mgr_get_mounted_entry_for_userdata(
-        android::fs_mgr::Fstab* fstab, const std::string& data_block_device);
-int fs_mgr_remount_userdata_into_checkpointing(android::fs_mgr::Fstab* fstab);
-
 // Finds the dm_bow device on which this block device is stacked, or returns
 // empty string
 std::string fs_mgr_find_bow_device(const std::string& block_device);
diff --git a/fs_mgr/tests/fs_mgr_test.cpp b/fs_mgr/tests/fs_mgr_test.cpp
index 322bf1b08930..bd3d6b532929 100644
--- a/fs_mgr/tests/fs_mgr_test.cpp
+++ b/fs_mgr/tests/fs_mgr_test.cpp
@@ -1062,23 +1062,6 @@ TEST(fs_mgr, DefaultFstabContainsUserdata) {
             << "Default fstab doesn't contain /data entry";
 }
 
-TEST(fs_mgr, UserdataMountedFromDefaultFstab) {
-    if (getuid() != 0) {
-        GTEST_SKIP() << "Must be run as root.";
-        return;
-    }
-    Fstab fstab;
-    ASSERT_TRUE(ReadDefaultFstab(&fstab)) << "Failed to read default fstab";
-    Fstab proc_mounts;
-    ASSERT_TRUE(ReadFstabFromFile("/proc/mounts", &proc_mounts)) << "Failed to read /proc/mounts";
-    auto mounted_entry = GetEntryForMountPoint(&proc_mounts, "/data");
-    ASSERT_NE(mounted_entry, nullptr) << "/data is not mounted";
-    std::string block_device;
-    ASSERT_TRUE(android::base::Realpath(mounted_entry->blk_device, &block_device));
-    ASSERT_NE(nullptr, fs_mgr_get_mounted_entry_for_userdata(&fstab, block_device))
-            << "/data wasn't mounted from default fstab";
-}
-
 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Readahead_Size_KB) {
     TemporaryFile tf;
     ASSERT_TRUE(tf.fd != -1);
diff --git a/init/builtins.cpp b/init/builtins.cpp
index 606ea8c0aacf..2b965b66c238 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -606,8 +606,6 @@ static Result<void> queue_fs_event(int code) {
     return Error() << "Invalid code: " << code;
 }
 
-static int initial_mount_fstab_return_code = -1;
-
 /* <= Q: mount_all <fstab> [ <path> ]* [--<options>]*
  * >= R: mount_all [ <fstab> ] [--<options>]*
  *
@@ -648,19 +646,10 @@ static Result<void> do_mount_all(const BuiltinArguments& args) {
         import_late(mount_all->rc_paths);
     }
 
-    if (mount_fstab_result.userdata_mounted) {
-        // This call to fs_mgr_mount_all mounted userdata. Keep the result in
-        // order for userspace reboot to correctly remount userdata.
-        LOG(INFO) << "Userdata mounted using "
-                  << (mount_all->fstab_path.empty() ? "(default fstab)" : mount_all->fstab_path)
-                  << " result : " << mount_fstab_result.code;
-        initial_mount_fstab_return_code = mount_fstab_result.code;
-    }
-
     if (queue_event) {
         /* queue_fs_event will queue event based on mount_fstab return code
          * and return processed return code*/
-        auto queue_fs_result = queue_fs_event(mount_fstab_result.code);
+        auto queue_fs_result = queue_fs_event(mount_fstab_result);
         if (!queue_fs_result.ok()) {
             return Error() << "queue_fs_event() failed: " << queue_fs_result.error();
         }
@@ -1178,29 +1167,6 @@ static Result<void> ExecVdcRebootOnFailure(const std::string& vdc_arg) {
     return ExecWithFunctionOnFailure(args, reboot);
 }
 
-static Result<void> do_remount_userdata(const BuiltinArguments& args) {
-    if (initial_mount_fstab_return_code == -1) {
-        return Error() << "Calling remount_userdata too early";
-    }
-    Fstab fstab;
-    if (!ReadDefaultFstab(&fstab)) {
-        // TODO(b/135984674): should we reboot here?
-        return Error() << "Failed to read fstab";
-    }
-    // TODO(b/135984674): check that fstab contains /data.
-    if (auto rc = fs_mgr_remount_userdata_into_checkpointing(&fstab); rc < 0) {
-        std::string proc_mounts_output;
-        android::base::ReadFileToString("/proc/mounts", &proc_mounts_output, true);
-        android::base::WriteStringToFile(proc_mounts_output,
-                                         "/metadata/userspacereboot/mount_info.txt");
-        trigger_shutdown("reboot,mount_userdata_failed");
-    }
-    if (auto result = queue_fs_event(initial_mount_fstab_return_code); !result.ok()) {
-        return Error() << "queue_fs_event() failed: " << result.error();
-    }
-    return {};
-}
-
 static Result<void> do_installkey(const BuiltinArguments& args) {
     if (!is_file_crypto()) return {};
 
@@ -1361,7 +1327,6 @@ const BuiltinFunctionMap& GetBuiltinFunctionMap() {
         {"umount_all",              {0,     1,    {false,  do_umount_all}}},
         {"update_linker_config",    {0,     0,    {false,  do_update_linker_config}}},
         {"readahead",               {1,     2,    {true,   do_readahead}}},
-        {"remount_userdata",        {0,     0,    {false,  do_remount_userdata}}},
         {"restart",                 {1,     2,    {false,  do_restart}}},
         {"restorecon",              {1,     kMax, {true,   do_restorecon}}},
         {"restorecon_recursive",    {1,     kMax, {true,   do_restorecon_recursive}}},
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 0d6eb153300e..053239f02535 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -102,7 +102,6 @@ using android::properties::BuildTrie;
 using android::properties::ParsePropertyInfoFile;
 using android::properties::PropertyInfoAreaFile;
 using android::properties::PropertyInfoEntry;
-using android::sysprop::InitProperties::is_userspace_reboot_supported;
 
 namespace android {
 namespace init {
@@ -569,8 +568,8 @@ std::optional<uint32_t> HandlePropertySet(const std::string& name, const std::st
         }
         LOG(INFO) << "Received sys.powerctl='" << value << "' from pid: " << cr.pid
                   << process_log_string;
-        if (value == "reboot,userspace" && !is_userspace_reboot_supported().value_or(false)) {
-            *error = "Userspace reboot is not supported by this device";
+        if (value == "reboot,userspace") {
+            *error = "Userspace reboot is deprecated.";
             return {PROP_ERROR_INVALID_VALUE};
         }
     }
diff --git a/init/property_service_test.cpp b/init/property_service_test.cpp
index 5f34cc4da308..eed8312cfd80 100644
--- a/init/property_service_test.cpp
+++ b/init/property_service_test.cpp
@@ -82,12 +82,6 @@ TEST(property_service, userspace_reboot_not_supported) {
         GTEST_SKIP() << "Skipping test, must be run as root.";
         return;
     }
-    const std::string original_value = GetProperty("init.userspace_reboot.is_supported", "");
-    auto guard = android::base::make_scope_guard([&original_value]() {
-        SetProperty("init.userspace_reboot.is_supported", original_value);
-    });
-
-    ASSERT_TRUE(SetProperty("init.userspace_reboot.is_supported", "false"));
     EXPECT_FALSE(SetProperty("sys.powerctl", "reboot,userspace"));
 }
 
diff --git a/init/reboot.cpp b/init/reboot.cpp
index 150f8f40e23c..66ee9772af36 100644
--- a/init/reboot.cpp
+++ b/init/reboot.cpp
@@ -87,16 +87,6 @@ static bool shutting_down = false;
 
 static const std::set<std::string> kDebuggingServices{"tombstoned", "logd", "adbd", "console"};
 
-static std::set<std::string> GetPostDataDebuggingServices() {
-    std::set<std::string> ret;
-    for (const auto& s : ServiceList::GetInstance()) {
-        if (kDebuggingServices.count(s->name()) && s->is_post_data()) {
-            ret.insert(s->name());
-        }
-    }
-    return ret;
-}
-
 static void PersistRebootReason(const char* reason, bool write_to_property) {
     if (write_to_property) {
         SetProperty(LAST_REBOOT_REASON_PROPERTY, reason);
@@ -810,196 +800,6 @@ static void EnterShutdown() {
     }
 }
 
-static void LeaveShutdown() {
-    LOG(INFO) << "Leaving shutdown mode";
-    shutting_down = false;
-    StartSendingMessages();
-}
-
-static std::chrono::milliseconds GetMillisProperty(const std::string& name,
-                                                   std::chrono::milliseconds default_value) {
-    auto value = GetUintProperty(name, static_cast<uint64_t>(default_value.count()));
-    return std::chrono::milliseconds(std::move(value));
-}
-
-static Result<void> DoUserspaceReboot() {
-    LOG(INFO) << "Userspace reboot initiated";
-    // An ugly way to pass a more precise reason on why fallback to hard reboot was triggered.
-    std::string sub_reason = "";
-    auto guard = android::base::make_scope_guard([&sub_reason] {
-        // Leave shutdown so that we can handle a full reboot.
-        LeaveShutdown();
-        trigger_shutdown("reboot,userspace_failed,shutdown_aborted," + sub_reason);
-    });
-    // Triggering userspace-reboot-requested will result in a bunch of setprop
-    // actions. We should make sure, that all of them are propagated before
-    // proceeding with userspace reboot. Synchronously setting sys.init.userspace_reboot.in_progress
-    // property is not perfect, but it should do the trick.
-    if (!android::sysprop::InitProperties::userspace_reboot_in_progress(true)) {
-        sub_reason = "setprop";
-        return Error() << "Failed to set sys.init.userspace_reboot.in_progress property";
-    }
-    EnterShutdown();
-    if (!SetProperty("sys.powerctl", "")) {
-        sub_reason = "resetprop";
-        return Error() << "Failed to reset sys.powerctl property";
-    }
-    std::set<std::string> stop_first;
-    // Remember the services that were enabled. We will need to manually enable them again otherwise
-    // triggers like class_start won't restart them.
-    std::set<std::string> were_enabled;
-    for (const auto& s : ServiceList::GetInstance().services_in_shutdown_order()) {
-        if (s->is_post_data() && !kDebuggingServices.count(s->name())) {
-            stop_first.insert(s->name());
-        }
-        // TODO(ioffe): we should also filter out temporary services here.
-        if (s->is_post_data() && s->IsEnabled()) {
-            were_enabled.insert(s->name());
-        }
-    }
-    {
-        Timer sync_timer;
-        LOG(INFO) << "sync() before terminating services...";
-        sync();
-        LOG(INFO) << "sync() took " << sync_timer;
-    }
-    auto sigterm_timeout = GetMillisProperty("init.userspace_reboot.sigterm.timeoutmillis", 5s);
-    auto sigkill_timeout = GetMillisProperty("init.userspace_reboot.sigkill.timeoutmillis", 10s);
-    LOG(INFO) << "Timeout to terminate services: " << sigterm_timeout.count() << "ms "
-              << "Timeout to kill services: " << sigkill_timeout.count() << "ms";
-    std::string services_file_name = "/metadata/userspacereboot/services.txt";
-    const int flags = O_RDWR | O_CREAT | O_SYNC | O_APPEND | O_CLOEXEC;
-    StopServicesAndLogViolations(stop_first, sigterm_timeout, true /* SIGTERM */);
-    if (int r = StopServicesAndLogViolations(stop_first, sigkill_timeout, false /* SIGKILL */);
-        r > 0) {
-        auto fd = unique_fd(TEMP_FAILURE_RETRY(open(services_file_name.c_str(), flags, 0666)));
-        android::base::WriteStringToFd("Post-data services still running: \n", fd);
-        for (const auto& s : ServiceList::GetInstance()) {
-            if (s->IsRunning() && stop_first.count(s->name())) {
-                android::base::WriteStringToFd(s->name() + "\n", fd);
-            }
-        }
-        sub_reason = "sigkill";
-        return Error() << r << " post-data services are still running";
-    }
-    if (auto result = KillZramBackingDevice(); !result.ok()) {
-        sub_reason = "zram";
-        return result;
-    }
-    if (auto result = CallVdc("volume", "reset"); !result.ok()) {
-        sub_reason = "vold_reset";
-        return result;
-    }
-    const auto& debugging_services = GetPostDataDebuggingServices();
-    if (int r = StopServicesAndLogViolations(debugging_services, sigkill_timeout,
-                                             false /* SIGKILL */);
-        r > 0) {
-        auto fd = unique_fd(TEMP_FAILURE_RETRY(open(services_file_name.c_str(), flags, 0666)));
-        android::base::WriteStringToFd("Debugging services still running: \n", fd);
-        for (const auto& s : ServiceList::GetInstance()) {
-            if (s->IsRunning() && debugging_services.count(s->name())) {
-                android::base::WriteStringToFd(s->name() + "\n", fd);
-            }
-        }
-        sub_reason = "sigkill_debug";
-        return Error() << r << " debugging services are still running";
-    }
-    {
-        Timer sync_timer;
-        LOG(INFO) << "sync() after stopping services...";
-        sync();
-        LOG(INFO) << "sync() took " << sync_timer;
-    }
-    if (auto result = UnmountAllApexes(); !result.ok()) {
-        sub_reason = "apex";
-        return result;
-    }
-    if (!SwitchToMountNamespaceIfNeeded(NS_BOOTSTRAP).ok()) {
-        sub_reason = "ns_switch";
-        return Error() << "Failed to switch to bootstrap namespace";
-    }
-    ActionManager::GetInstance().RemoveActionIf([](const auto& action) -> bool {
-        if (action->IsFromApex()) {
-            std::string trigger_name = action->BuildTriggersString();
-            LOG(INFO) << "Removing action (" << trigger_name << ") from (" << action->filename()
-                      << ":" << action->line() << ")";
-            return true;
-        }
-        return false;
-    });
-    // Remove services that were defined in an APEX
-    ServiceList::GetInstance().RemoveServiceIf([](const std::unique_ptr<Service>& s) -> bool {
-        if (s->is_from_apex()) {
-            LOG(INFO) << "Removing service '" << s->name() << "' because it's defined in an APEX";
-            return true;
-        }
-        return false;
-    });
-    // Re-enable services
-    for (const auto& s : ServiceList::GetInstance()) {
-        if (were_enabled.count(s->name())) {
-            LOG(INFO) << "Re-enabling service '" << s->name() << "'";
-            s->Enable();
-        }
-    }
-    ServiceList::GetInstance().ResetState();
-    LeaveShutdown();
-    ActionManager::GetInstance().QueueEventTrigger("userspace-reboot-resume");
-    guard.Disable();  // Go on with userspace reboot.
-    return {};
-}
-
-static void UserspaceRebootWatchdogThread() {
-    auto started_timeout = GetMillisProperty("init.userspace_reboot.started.timeoutmillis", 10s);
-    if (!WaitForProperty("sys.init.userspace_reboot.in_progress", "1", started_timeout)) {
-        LOG(ERROR) << "Userspace reboot didn't start in " << started_timeout.count()
-                   << "ms. Switching to full reboot";
-        // Init might be wedged, don't try to write reboot reason into a persistent property and do
-        // a dirty reboot.
-        PersistRebootReason("userspace_failed,watchdog_triggered,failed_to_start", false);
-        RebootSystem(ANDROID_RB_RESTART2, "userspace_failed,watchdog_triggered,failed_to_start");
-    }
-    LOG(INFO) << "Starting userspace reboot watchdog";
-    auto watchdog_timeout = GetMillisProperty("init.userspace_reboot.watchdog.timeoutmillis", 5min);
-    LOG(INFO) << "UserspaceRebootWatchdog timeout: " << watchdog_timeout.count() << "ms";
-    if (!WaitForProperty("sys.boot_completed", "1", watchdog_timeout)) {
-        LOG(ERROR) << "Failed to boot in " << watchdog_timeout.count()
-                   << "ms. Switching to full reboot";
-        // In this case device is in a boot loop. Only way to recover is to do dirty reboot.
-        // Since init might be wedged, don't try to write reboot reason into a persistent property.
-        PersistRebootReason("userspace_failed,watchdog_triggered,failed_to_boot", false);
-        RebootSystem(ANDROID_RB_RESTART2, "userspace_failed,watchdog_triggered,failed_to_boot");
-    }
-    LOG(INFO) << "Device booted, stopping userspace reboot watchdog";
-}
-
-static void HandleUserspaceReboot() {
-    if (!android::sysprop::InitProperties::is_userspace_reboot_supported().value_or(false)) {
-        LOG(ERROR) << "Attempted a userspace reboot on a device that doesn't support it";
-        return;
-    }
-    // Spinnig up a separate thread will fail the setns call later in the boot sequence.
-    // Fork a new process to monitor userspace reboot while we are investigating a better solution.
-    pid_t pid = fork();
-    if (pid < 0) {
-        PLOG(ERROR) << "Failed to fork process for userspace reboot watchdog. Switching to full "
-                    << "reboot";
-        trigger_shutdown("reboot,userspace_failed,watchdog_fork");
-        return;
-    }
-    if (pid == 0) {
-        // Child
-        UserspaceRebootWatchdogThread();
-        _exit(EXIT_SUCCESS);
-    }
-    LOG(INFO) << "Clearing queue and starting userspace-reboot-requested trigger";
-    auto& am = ActionManager::GetInstance();
-    am.ClearQueue();
-    am.QueueEventTrigger("userspace-reboot-requested");
-    auto handler = [](const BuiltinArguments&) { return DoUserspaceReboot(); };
-    am.QueueBuiltinAction(handler, "userspace-reboot");
-}
-
 /**
  * Check if "command" field is set in bootloader message.
  *
@@ -1030,7 +830,6 @@ void HandlePowerctlMessage(const std::string& command) {
     std::string reboot_target = "";
     bool run_fsck = false;
     bool command_invalid = false;
-    bool userspace_reboot = false;
 
     if (cmd_params[0] == "shutdown") {
         cmd = ANDROID_RB_POWEROFF;
@@ -1051,8 +850,8 @@ void HandlePowerctlMessage(const std::string& command) {
         if (cmd_params.size() >= 2) {
             reboot_target = cmd_params[1];
             if (reboot_target == "userspace") {
-                LOG(INFO) << "Userspace reboot requested";
-                userspace_reboot = true;
+                LOG(ERROR) << "Userspace reboot is deprecated.";
+                return;
             }
             // adb reboot fastboot should boot into bootloader for devices not
             // supporting logical partitions.
@@ -1130,11 +929,6 @@ void HandlePowerctlMessage(const std::string& command) {
     // messages, etc) from properties during reboot.
     StopSendingMessages();
 
-    if (userspace_reboot) {
-        HandleUserspaceReboot();
-        return;
-    }
-
     LOG(INFO) << "Clear action queue and start shutdown trigger";
     ActionManager::GetInstance().ClearQueue();
     // Queue shutdown trigger first
diff --git a/rootdir/init.rc b/rootdir/init.rc
index b804c1bde0cf..a9178aabb1a0 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -620,7 +620,6 @@ on post-fs
     mkdir /metadata/bootstat 0750 system log
     mkdir /metadata/ota 0750 root system
     mkdir /metadata/ota/snapshots 0750 root system
-    mkdir /metadata/userspacereboot 0770 root system
     mkdir /metadata/watchdog 0770 root system
 
     mkdir /metadata/apex 0700 root system
@@ -1323,46 +1322,6 @@ on property:ro.debuggable=1
 on init && property:ro.debuggable=1
     start console
 
-on userspace-reboot-requested
-  # TODO(b/135984674): reset all necessary properties here.
-  setprop sys.boot_completed ""
-  setprop dev.bootcomplete ""
-  setprop sys.init.updatable_crashing ""
-  setprop sys.init.updatable_crashing_process_name ""
-  setprop sys.user.0.ce_available ""
-  setprop sys.shutdown.requested ""
-  setprop service.bootanim.exit ""
-  setprop service.bootanim.progress ""
-
-on userspace-reboot-fs-remount
-  # Make sure that vold is running.
-  # This is mostly a precaution measure in case vold for some reason wasn't running when
-  # userspace reboot was initiated.
-  start vold
-  exec - system system -- /system/bin/vdc checkpoint resetCheckpoint
-  exec - system system -- /system/bin/vdc checkpoint markBootAttempt
-  # Unmount /data_mirror mounts in the reverse order of corresponding mounts.
-  umount /data_mirror/data_ce/null/0
-  umount /data_mirror/data_ce/null
-  umount /data_mirror/data_de/null
-  umount /data_mirror/storage_area/0
-  umount /data_mirror/storage_area
-  umount /data_mirror/cur_profiles
-  umount /data_mirror/ref_profiles
-  umount /data_mirror
-  remount_userdata
-  start bootanim
-
-on userspace-reboot-resume
-  trigger userspace-reboot-fs-remount
-  trigger post-fs-data
-  trigger zygote-start
-  trigger early-boot
-  trigger boot
-
-on property:sys.boot_completed=1 && property:sys.init.userspace_reboot.in_progress=1
-  setprop sys.init.userspace_reboot.in_progress ""
-
 # Multi-Gen LRU Experiment
 on property:persist.device_config.mglru_native.lru_gen_config=none
   write /sys/kernel/mm/lru_gen/enabled 0
diff --git a/rootdir/init.usb.rc b/rootdir/init.usb.rc
index dde784e2594d..b30d6d02c58e 100644
--- a/rootdir/init.usb.rc
+++ b/rootdir/init.usb.rc
@@ -139,7 +139,3 @@ on property:sys.usb.typec.power_role=source
 on property:sys.usb.typec.power_role=sink
     write /sys/class/dual_role_usb/otg_default/power_role ${sys.usb.typec.power_role}
     setprop sys.usb.typec.state ${sys.usb.typec.power_role}
-
-on userspace-reboot-requested
-  setprop sys.usb.config ""
-  setprop sys.usb.state ""

From f91503bd18de89c38be495b14ca045be31fd54d7 Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Fri, 9 Aug 2024 16:17:20 +0900
Subject: [PATCH 1046/1487] Clean up userspace-reboot (#2)

Bug: 292469129
Test: CtsInitTestCases
Test: system/core/bootstat/boot_reason_test.sh
Change-Id: I00deb50c5634ade6b69d5b6bf4d08c5101e0beb8
---
 init/builtins.cpp | 26 ++++++++------------------
 1 file changed, 8 insertions(+), 18 deletions(-)

diff --git a/init/builtins.cpp b/init/builtins.cpp
index 2b965b66c238..122adb7f6ce5 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -1137,29 +1137,19 @@ static Result<void> ExecWithFunctionOnFailure(const std::vector<std::string>& ar
 }
 
 static Result<void> ExecVdcRebootOnFailure(const std::string& vdc_arg) {
-    bool should_reboot_into_recovery = true;
     auto reboot_reason = vdc_arg + "_failed";
-    if (android::sysprop::InitProperties::userspace_reboot_in_progress().value_or(false)) {
-        should_reboot_into_recovery = false;
-        reboot_reason = "userspace_failed," + vdc_arg;
-    }
 
-    auto reboot = [reboot_reason, should_reboot_into_recovery](const std::string& message) {
+    auto reboot = [reboot_reason](const std::string& message) {
         // TODO (b/122850122): support this in gsi
-        if (should_reboot_into_recovery) {
-            if (IsFbeEnabled() && !android::gsi::IsGsiRunning()) {
-                LOG(ERROR) << message << ": Rebooting into recovery, reason: " << reboot_reason;
-                if (auto result = reboot_into_recovery(
-                            {"--prompt_and_wipe_data", "--reason="s + reboot_reason});
-                    !result.ok()) {
-                    LOG(FATAL) << "Could not reboot into recovery: " << result.error();
-                }
-            } else {
-                LOG(ERROR) << "Failure (reboot suppressed): " << reboot_reason;
+        if (IsFbeEnabled() && !android::gsi::IsGsiRunning()) {
+            LOG(ERROR) << message << ": Rebooting into recovery, reason: " << reboot_reason;
+            if (auto result = reboot_into_recovery(
+                        {"--prompt_and_wipe_data", "--reason="s + reboot_reason});
+                !result.ok()) {
+                LOG(FATAL) << "Could not reboot into recovery: " << result.error();
             }
         } else {
-            LOG(ERROR) << message << ": rebooting, reason: " << reboot_reason;
-            trigger_shutdown("reboot," + reboot_reason);
+            LOG(ERROR) << "Failure (reboot suppressed): " << reboot_reason;
         }
     };
 

From 30203af8fdfaa01b2b6aa7fafaffc908b9b74034 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 9 Aug 2024 15:55:38 +0000
Subject: [PATCH 1047/1487] There's only one <sys/system_properties.h> now.

Change-Id: I4d535484b9e25fda304fb748b7796e513c832265
---
 .../snapuserd/user-space-merge/snapuserd_server.cpp           | 4 +---
 init/init.cpp                                                 | 4 +---
 init/property_service.cpp                                     | 4 +---
 init/property_service_test.cpp                                | 4 +---
 libcutils/properties.cpp                                      | 3 +--
 libcutils/trace-dev.inc                                       | 3 +--
 6 files changed, 6 insertions(+), 16 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index c0af5c5b7cc7..013df350bbad 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -22,6 +22,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/socket.h>
+#include <sys/system_properties.h>
 #include <sys/types.h>
 #include <unistd.h>
 
@@ -35,9 +36,6 @@
 #include <snapuserd/snapuserd_client.h>
 #include "snapuserd_server.h"
 
-#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
-#include <sys/_system_properties.h>
-
 namespace android {
 namespace snapshot {
 
diff --git a/init/init.cpp b/init/init.cpp
index 19e909fcb5aa..4878660e191c 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -26,13 +26,11 @@
 #include <sys/eventfd.h>
 #include <sys/mount.h>
 #include <sys/signalfd.h>
+#include <sys/system_properties.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
 #include <unistd.h>
 
-#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
-#include <sys/_system_properties.h>
-
 #include <filesystem>
 #include <fstream>
 #include <functional>
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 0d6eb153300e..2f3ff5c626d7 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -31,14 +31,12 @@
 #include <sys/mman.h>
 #include <sys/poll.h>
 #include <sys/select.h>
+#include <sys/system_properties.h>
 #include <sys/types.h>
 #include <sys/un.h>
 #include <unistd.h>
 #include <wchar.h>
 
-#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
-#include <sys/_system_properties.h>
-
 #include <map>
 #include <memory>
 #include <mutex>
diff --git a/init/property_service_test.cpp b/init/property_service_test.cpp
index 5f34cc4da308..386c36867af4 100644
--- a/init/property_service_test.cpp
+++ b/init/property_service_test.cpp
@@ -16,11 +16,9 @@
 
 #include <errno.h>
 #include <sys/socket.h>
+#include <sys/system_properties.h>
 #include <sys/un.h>
 
-#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
-#include <sys/_system_properties.h>
-
 #include <android-base/properties.h>
 #include <android-base/scopeguard.h>
 #include <android-base/strings.h>
diff --git a/libcutils/properties.cpp b/libcutils/properties.cpp
index 03f04961cd1c..d3a2b50abfb2 100644
--- a/libcutils/properties.cpp
+++ b/libcutils/properties.cpp
@@ -93,8 +93,7 @@ int property_get(const char* key, char* value, const char* default_value) {
 
 #if __has_include(<sys/system_properties.h>)
 
-#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
-#include <sys/_system_properties.h>
+#include <sys/system_properties.h>
 
 struct callback_data {
     void (*callback)(const char* name, const char* value, void* cookie);
diff --git a/libcutils/trace-dev.inc b/libcutils/trace-dev.inc
index 3bc6dc343ce4..c911b4f82062 100644
--- a/libcutils/trace-dev.inc
+++ b/libcutils/trace-dev.inc
@@ -36,8 +36,7 @@
 #include <log/log_properties.h>
 
 #if defined(__BIONIC__)
-#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
-#include <sys/_system_properties.h>
+#include <sys/system_properties.h>
 #endif
 
 /**

From fcb8666eed813bc3ddfd080f0dfb7ffdb1011787 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 1 Aug 2024 20:52:30 +0000
Subject: [PATCH 1048/1487] libprocessgroup: Rename CgroupController ->
 CgroupControllerWrapper

So that the name is not overloaded with libcgrouprc_format's
CgroupController, which can be confusing.

Bug: 349105928
Test: m
Change-Id: I39df9814c500de68fd20139e661363ba51ea3543
---
 libprocessgroup/cgroup_map.cpp         | 34 +++++++++++++-------------
 libprocessgroup/cgroup_map.h           |  8 +++---
 libprocessgroup/processgroup.cpp       |  2 +-
 libprocessgroup/task_profiles.cpp      |  6 ++---
 libprocessgroup/task_profiles.h        | 18 +++++++-------
 libprocessgroup/task_profiles_test.cpp |  4 +--
 6 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/libprocessgroup/cgroup_map.cpp b/libprocessgroup/cgroup_map.cpp
index 52b5afe5ee6f..fb01cfda9ff3 100644
--- a/libprocessgroup/cgroup_map.cpp
+++ b/libprocessgroup/cgroup_map.cpp
@@ -38,26 +38,26 @@ static constexpr const char* CGROUP_PROCS_FILE = "/cgroup.procs";
 static constexpr const char* CGROUP_TASKS_FILE = "/tasks";
 static constexpr const char* CGROUP_TASKS_FILE_V2 = "/cgroup.threads";
 
-uint32_t CgroupController::version() const {
+uint32_t CgroupControllerWrapper::version() const {
     CHECK(HasValue());
     return ACgroupController_getVersion(controller_);
 }
 
-const char* CgroupController::name() const {
+const char* CgroupControllerWrapper::name() const {
     CHECK(HasValue());
     return ACgroupController_getName(controller_);
 }
 
-const char* CgroupController::path() const {
+const char* CgroupControllerWrapper::path() const {
     CHECK(HasValue());
     return ACgroupController_getPath(controller_);
 }
 
-bool CgroupController::HasValue() const {
+bool CgroupControllerWrapper::HasValue() const {
     return controller_ != nullptr;
 }
 
-bool CgroupController::IsUsable() {
+bool CgroupControllerWrapper::IsUsable() {
     if (!HasValue()) return false;
 
     if (state_ == UNKNOWN) {
@@ -72,7 +72,7 @@ bool CgroupController::IsUsable() {
     return state_ == USABLE;
 }
 
-std::string CgroupController::GetTasksFilePath(const std::string& rel_path) const {
+std::string CgroupControllerWrapper::GetTasksFilePath(const std::string& rel_path) const {
     std::string tasks_path = path();
 
     if (!rel_path.empty()) {
@@ -81,8 +81,8 @@ std::string CgroupController::GetTasksFilePath(const std::string& rel_path) cons
     return (version() == 1) ? tasks_path + CGROUP_TASKS_FILE : tasks_path + CGROUP_TASKS_FILE_V2;
 }
 
-std::string CgroupController::GetProcsFilePath(const std::string& rel_path, uid_t uid,
-                                               pid_t pid) const {
+std::string CgroupControllerWrapper::GetProcsFilePath(const std::string& rel_path, uid_t uid,
+                                                      pid_t pid) const {
     std::string proc_path(path());
     proc_path.append("/").append(rel_path);
     proc_path = regex_replace(proc_path, std::regex("<uid>"), std::to_string(uid));
@@ -91,7 +91,7 @@ std::string CgroupController::GetProcsFilePath(const std::string& rel_path, uid_
     return proc_path.append(CGROUP_PROCS_FILE);
 }
 
-bool CgroupController::GetTaskGroup(pid_t tid, std::string* group) const {
+bool CgroupControllerWrapper::GetTaskGroup(pid_t tid, std::string* group) const {
     std::string file_name = StringPrintf("/proc/%d/cgroup", tid);
     std::string content;
     if (!android::base::ReadFileToString(file_name, &content)) {
@@ -175,40 +175,40 @@ void CgroupMap::Print() const {
     }
 }
 
-CgroupController CgroupMap::FindController(const std::string& name) const {
+CgroupControllerWrapper CgroupMap::FindController(const std::string& name) const {
     if (!loaded_) {
         LOG(ERROR) << "CgroupMap::FindController called for [" << getpid()
                    << "] failed, RC file was not initialized properly";
-        return CgroupController(nullptr);
+        return CgroupControllerWrapper(nullptr);
     }
 
     auto controller_count = ACgroupFile_getControllerCount();
     for (uint32_t i = 0; i < controller_count; ++i) {
         const ACgroupController* controller = ACgroupFile_getController(i);
         if (name == ACgroupController_getName(controller)) {
-            return CgroupController(controller);
+            return CgroupControllerWrapper(controller);
         }
     }
 
-    return CgroupController(nullptr);
+    return CgroupControllerWrapper(nullptr);
 }
 
-CgroupController CgroupMap::FindControllerByPath(const std::string& path) const {
+CgroupControllerWrapper CgroupMap::FindControllerByPath(const std::string& path) const {
     if (!loaded_) {
         LOG(ERROR) << "CgroupMap::FindControllerByPath called for [" << getpid()
                    << "] failed, RC file was not initialized properly";
-        return CgroupController(nullptr);
+        return CgroupControllerWrapper(nullptr);
     }
 
     auto controller_count = ACgroupFile_getControllerCount();
     for (uint32_t i = 0; i < controller_count; ++i) {
         const ACgroupController* controller = ACgroupFile_getController(i);
         if (StartsWith(path, ACgroupController_getPath(controller))) {
-            return CgroupController(controller);
+            return CgroupControllerWrapper(controller);
         }
     }
 
-    return CgroupController(nullptr);
+    return CgroupControllerWrapper(nullptr);
 }
 
 int CgroupMap::ActivateControllers(const std::string& path) const {
diff --git a/libprocessgroup/cgroup_map.h b/libprocessgroup/cgroup_map.h
index 31925d5d7816..ec3bd7870df0 100644
--- a/libprocessgroup/cgroup_map.h
+++ b/libprocessgroup/cgroup_map.h
@@ -23,10 +23,10 @@
 #include <android/cgrouprc.h>
 
 // Convenient wrapper of an ACgroupController pointer.
-class CgroupController {
+class CgroupControllerWrapper {
   public:
     // Does not own controller
-    explicit CgroupController(const ACgroupController* controller)
+    explicit CgroupControllerWrapper(const ACgroupController* controller)
         : controller_(controller) {}
 
     uint32_t version() const;
@@ -57,8 +57,8 @@ class CgroupMap {
     static bool SetupCgroups();
 
     static CgroupMap& GetInstance();
-    CgroupController FindController(const std::string& name) const;
-    CgroupController FindControllerByPath(const std::string& path) const;
+    CgroupControllerWrapper FindController(const std::string& name) const;
+    CgroupControllerWrapper FindControllerByPath(const std::string& path) const;
     int ActivateControllers(const std::string& path) const;
 
   private:
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 387c104ff4c5..83a2258bf2fb 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -94,7 +94,7 @@ static bool CgroupKillAvailable() {
 }
 
 static bool CgroupGetMemcgAppsPath(std::string* path) {
-    CgroupController controller = CgroupMap::GetInstance().FindController("memory");
+    CgroupControllerWrapper controller = CgroupMap::GetInstance().FindController("memory");
 
     if (!controller.HasValue()) {
         return false;
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 48705481c47d..67ecc1d500a5 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -123,8 +123,8 @@ const std::string& ProfileAttribute::file_name() const {
     return file_name_;
 }
 
-void ProfileAttribute::Reset(const CgroupController& controller, const std::string& file_name,
-                             const std::string& file_v2_name) {
+void ProfileAttribute::Reset(const CgroupControllerWrapper& controller,
+                             const std::string& file_name, const std::string& file_v2_name) {
     controller_ = controller;
     file_name_ = file_name;
     file_v2_name_ = file_v2_name;
@@ -333,7 +333,7 @@ bool SetAttributeAction::IsValidForTask(pid_t tid) const {
     return optional_;
 }
 
-SetCgroupAction::SetCgroupAction(const CgroupController& c, const std::string& p)
+SetCgroupAction::SetCgroupAction(const CgroupControllerWrapper& c, const std::string& p)
     : controller_(c), path_(p) {
     FdCacheHelper::Init(controller_.GetTasksFilePath(path_), fd_[ProfileAction::RCT_TASK]);
     // uid and pid don't matter because IsAppDependentPath ensures the path doesn't use them
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index 184e9e35f0e6..abb3ca5c37d6 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -32,9 +32,9 @@
 class IProfileAttribute {
   public:
     virtual ~IProfileAttribute() = 0;
-    virtual void Reset(const CgroupController& controller, const std::string& file_name,
+    virtual void Reset(const CgroupControllerWrapper& controller, const std::string& file_name,
                        const std::string& file_v2_name) = 0;
-    virtual const CgroupController* controller() const = 0;
+    virtual const CgroupControllerWrapper* controller() const = 0;
     virtual const std::string& file_name() const = 0;
     virtual bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const = 0;
     virtual bool GetPathForTask(pid_t tid, std::string* path) const = 0;
@@ -46,14 +46,14 @@ class ProfileAttribute : public IProfileAttribute {
     // Cgroup attributes may have different names in the v1 and v2 hierarchies. If `file_v2_name` is
     // not empty, `file_name` is the name for the v1 hierarchy and `file_v2_name` is the name for
     // the v2 hierarchy. If `file_v2_name` is empty, `file_name` is used for both hierarchies.
-    ProfileAttribute(const CgroupController& controller, const std::string& file_name,
+    ProfileAttribute(const CgroupControllerWrapper& controller, const std::string& file_name,
                      const std::string& file_v2_name)
         : controller_(controller), file_name_(file_name), file_v2_name_(file_v2_name) {}
     ~ProfileAttribute() = default;
 
-    const CgroupController* controller() const override { return &controller_; }
+    const CgroupControllerWrapper* controller() const override { return &controller_; }
     const std::string& file_name() const override;
-    void Reset(const CgroupController& controller, const std::string& file_name,
+    void Reset(const CgroupControllerWrapper& controller, const std::string& file_name,
                const std::string& file_v2_name) override;
 
     bool GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const override;
@@ -61,7 +61,7 @@ class ProfileAttribute : public IProfileAttribute {
     bool GetPathForUID(uid_t uid, std::string* path) const override;
 
   private:
-    CgroupController controller_;
+    CgroupControllerWrapper controller_;
     std::string file_name_;
     std::string file_v2_name_;
 };
@@ -142,7 +142,7 @@ class SetAttributeAction : public ProfileAction {
 // Set cgroup profile element
 class SetCgroupAction : public ProfileAction {
   public:
-    SetCgroupAction(const CgroupController& c, const std::string& p);
+    SetCgroupAction(const CgroupControllerWrapper& c, const std::string& p);
 
     const char* Name() const override { return "SetCgroup"; }
     bool ExecuteForProcess(uid_t uid, pid_t pid) const override;
@@ -152,10 +152,10 @@ class SetCgroupAction : public ProfileAction {
     bool IsValidForProcess(uid_t uid, pid_t pid) const override;
     bool IsValidForTask(pid_t tid) const override;
 
-    const CgroupController* controller() const { return &controller_; }
+    const CgroupControllerWrapper* controller() const { return &controller_; }
 
   private:
-    CgroupController controller_;
+    CgroupControllerWrapper controller_;
     std::string path_;
     android::base::unique_fd fd_[ProfileAction::RCT_COUNT];
     mutable std::mutex fd_mutex_;
diff --git a/libprocessgroup/task_profiles_test.cpp b/libprocessgroup/task_profiles_test.cpp
index d19da2b548bc..dff6d677e16a 100644
--- a/libprocessgroup/task_profiles_test.cpp
+++ b/libprocessgroup/task_profiles_test.cpp
@@ -102,10 +102,10 @@ class ProfileAttributeMock : public IProfileAttribute {
   public:
     ProfileAttributeMock(const std::string& file_name) : file_name_(file_name) {}
     ~ProfileAttributeMock() override = default;
-    void Reset(const CgroupController&, const std::string&, const std::string&) override {
+    void Reset(const CgroupControllerWrapper&, const std::string&, const std::string&) override {
         CHECK(false);
     }
-    const CgroupController* controller() const override {
+    const CgroupControllerWrapper* controller() const override {
         CHECK(false);
         return {};
     }

From 9c53c803e1b3fcfc0426baa0ee7fc0fcf8fb6c7b Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 1 Aug 2024 21:47:29 +0000
Subject: [PATCH 1049/1487] libprocessgroup: Rename files
 a_cgroup_controller.cpp, a_cgroup_file.cpp

These are for ACgroupController and ACgroupFile, but share a filename
with libcgrouprc_format's CgroupController which can be confusing.

Bug: 349105928
Test: m
Change-Id: Idb270068169b71b0a33101407ddbb5a38cc8d469
---
 libprocessgroup/cgrouprc/Android.bp                           | 4 ++--
 .../{cgroup_controller.cpp => a_cgroup_controller.cpp}        | 0
 .../cgrouprc/{cgroup_file.cpp => a_cgroup_file.cpp}           | 0
 3 files changed, 2 insertions(+), 2 deletions(-)
 rename libprocessgroup/cgrouprc/{cgroup_controller.cpp => a_cgroup_controller.cpp} (100%)
 rename libprocessgroup/cgrouprc/{cgroup_file.cpp => a_cgroup_file.cpp} (100%)

diff --git a/libprocessgroup/cgrouprc/Android.bp b/libprocessgroup/cgrouprc/Android.bp
index 7522cfe3900c..cb912476e26a 100644
--- a/libprocessgroup/cgrouprc/Android.bp
+++ b/libprocessgroup/cgrouprc/Android.bp
@@ -32,8 +32,8 @@ cc_library {
         symbol_file: "libcgrouprc.map.txt",
     },
     srcs: [
-        "cgroup_controller.cpp",
-        "cgroup_file.cpp",
+        "a_cgroup_controller.cpp",
+        "a_cgroup_file.cpp",
     ],
     cflags: [
         "-Wall",
diff --git a/libprocessgroup/cgrouprc/cgroup_controller.cpp b/libprocessgroup/cgrouprc/a_cgroup_controller.cpp
similarity index 100%
rename from libprocessgroup/cgrouprc/cgroup_controller.cpp
rename to libprocessgroup/cgrouprc/a_cgroup_controller.cpp
diff --git a/libprocessgroup/cgrouprc/cgroup_file.cpp b/libprocessgroup/cgrouprc/a_cgroup_file.cpp
similarity index 100%
rename from libprocessgroup/cgrouprc/cgroup_file.cpp
rename to libprocessgroup/cgrouprc/a_cgroup_file.cpp

From 7c94e5b25ce283bbdd3304afcc70d76ccbe8edb6 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 6 Aug 2024 18:21:07 +0000
Subject: [PATCH 1050/1487] libprocessgroup: Remove unused
 CgroupMap::SetupCgroups declaration

SetupCgroups was moved from CgroupMap in libprocessgroup to SetupCgroup
in libprocessgroup_setup, but the old declaration was not removed.

Fixes: 6f9ce2e548e4 ("libprocessgroup: Move CgroupSetupCgroups() to libprocessgroup_setup")
Test: m
Change-Id: I9f85000392b59a105bb202fae277a5582449822a
---
 libprocessgroup/cgroup_map.h | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/libprocessgroup/cgroup_map.h b/libprocessgroup/cgroup_map.h
index ec3bd7870df0..364279414336 100644
--- a/libprocessgroup/cgroup_map.h
+++ b/libprocessgroup/cgroup_map.h
@@ -53,9 +53,6 @@ class CgroupControllerWrapper {
 
 class CgroupMap {
   public:
-    // Selinux policy ensures only init process can successfully use this function
-    static bool SetupCgroups();
-
     static CgroupMap& GetInstance();
     CgroupControllerWrapper FindController(const std::string& name) const;
     CgroupControllerWrapper FindControllerByPath(const std::string& path) const;

From 227254f61602eab532727d3d968dabba9653b0dc Mon Sep 17 00:00:00 2001
From: mingwei xue <mingwei.xue@transsion.corp-partner.google.com>
Date: Thu, 8 Aug 2024 03:38:57 +0000
Subject: [PATCH 1051/1487] Fix SnapshotTest crash

For Android 12 vendor project, SnapshotTestEnvironment setup is skipped. So, test_device is not initialized, which will cause other tests to fail.

BUG:350678717
Test:run vts -m vts_libsnapshot_test
(cherry picked from https://android-review.googlesource.com/q/commit:a791e913048801a2a74beaea42b992c380eb8c2c)
Merged-In: I6ce6a9e7ea2c210e25c2a5ffadaaa6348086ea7f
Change-Id: I6ce6a9e7ea2c210e25c2a5ffadaaa6348086ea7f
---
 fs_mgr/libsnapshot/snapshot_test.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 07f13014dd4d..bf16b0fb3db5 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2837,7 +2837,6 @@ void SnapshotTestEnvironment::SetUp() {
     // that is fixed, don't call GTEST_SKIP here, but instead call GTEST_SKIP in individual test
     // suites.
     RETURN_IF_NON_VIRTUAL_AB_MSG("Virtual A/B is not enabled, skipping global setup.\n");
-    RETURN_IF_VENDOR_ON_ANDROID_S_MSG("Test not enabled for Vendor on Android S.\n");
 
     std::vector<std::string> paths = {
             // clang-format off

From d945d204082ce1d27c1ecdc31019835375b48347 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Fri, 9 Aug 2024 20:49:09 +0000
Subject: [PATCH 1052/1487] init_kill_services_test: formatting for merges

Adding formatting here, as we will start a push for people
using this, if they run into any linkToDeath issue, or if
they want to test this.

Bugs: me
Test: N/A
Change-Id: I72510d61926ce694671d897519463f37892a8d12
---
 .../init_kill_services_test.cpp               | 24 ++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/init/test_kill_services/init_kill_services_test.cpp b/init/test_kill_services/init_kill_services_test.cpp
index 3af92bb55ff6..96f0faf39a66 100644
--- a/init/test_kill_services/init_kill_services_test.cpp
+++ b/init/test_kill_services/init_kill_services_test.cpp
@@ -87,6 +87,24 @@ static inline std::string PrintName(const testing::TestParamInfo<std::string>& i
     return info.param;
 }
 
-INSTANTIATE_TEST_CASE_P(DeathTest, InitKillServicesTest,
-                        ::testing::Values("lmkd", "ueventd", "hwservicemanager", "servicemanager"),
-                        PrintName);
+INSTANTIATE_TEST_CASE_P(
+        DeathTest, InitKillServicesTest,
+        ::testing::Values(
+                // clang-format off
+
+// TODO: we may want a more automatic way of testing this for services based on some
+// criteria (e.g. not disabled), but for now adding core services one at a time
+
+// BEGIN INTERNAL ONLY MERGE GUARD (add things here if internal only, move down later)
+// END INTERNAL ONLY MERGE GUARD
+
+// BEGIN AOSP ONLY (add things here if adding to AOSP)
+    "lmkd",
+    "ueventd",
+    "hwservicemanager",
+    "servicemanager"
+// END AOSP ONLY
+
+                // clang-format on
+                ),
+        PrintName);

From 164f29700744963b4e7906b165da375dfbb67a59 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Fri, 9 Aug 2024 20:50:51 +0000
Subject: [PATCH 1053/1487] init_kill_services_test: += system_suspend

Get coverage for this.

Bugs: me
Test: atest init_kill_services_test
Change-Id: I2b0fcb8d273f89de6d0ad115a8de0c0314dbfc3f
---
 init/test_kill_services/init_kill_services_test.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/init/test_kill_services/init_kill_services_test.cpp b/init/test_kill_services/init_kill_services_test.cpp
index 96f0faf39a66..efba9f677700 100644
--- a/init/test_kill_services/init_kill_services_test.cpp
+++ b/init/test_kill_services/init_kill_services_test.cpp
@@ -102,7 +102,8 @@ INSTANTIATE_TEST_CASE_P(
     "lmkd",
     "ueventd",
     "hwservicemanager",
-    "servicemanager"
+    "servicemanager",
+    "system_suspend"
 // END AOSP ONLY
 
                 // clang-format on

From aed90550d060d4ca51d8048ab9dbd7e8d0937b65 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Fri, 9 Aug 2024 20:52:43 +0000
Subject: [PATCH 1054/1487] init_kill_services_test: smoreland@ owners

I've always maintained this test, would also take
overall init ownership, ;p

Bugs: me
Test: N/A
Change-Id: Id0ea93226b9afd22f8bc192a5a1b61e15d01f3e2
---
 init/test_kill_services/OWNERS | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 init/test_kill_services/OWNERS

diff --git a/init/test_kill_services/OWNERS b/init/test_kill_services/OWNERS
new file mode 100644
index 000000000000..40164aae0c50
--- /dev/null
+++ b/init/test_kill_services/OWNERS
@@ -0,0 +1 @@
+smoreland@google.com

From c85af5595254fae175cea517fe33ddaf5ba1183f Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 3 Jul 2024 17:00:31 -0700
Subject: [PATCH 1055/1487] libsnapshot: Simplify wipe handling in recovery.

This refactors HandleImminentDataWipe to address some shortcomings
discovered through testing. Previously, it always called
CreateSnapshotsAndLogicalPartitions, which meant trying to use snapuserd
even if completely unnecessary.

Instead we now peek at the update state and eliminate the "easy" cases
ahead of time. These are "none", "initiated", and "unverified" when
either a rollback happens or there is no forward merge indicator. In
this case we simply return early and allow the wipe to continue
(disabling the current slot if necessary).

The hard case, when a merge is needed, is still handled within
ProcessUpdateStateOnDataWipe. However it's no longer recursive, and it
can assume a merge is about to initiated or already in progress.

In all cases except a merge failure, we change the update state to None
to clear any roadblocks update_engine or the bootloader might encounter.
A merge failure, however, still blocks a data wipe. The way to recover
from this is adb sideload.

Bug: 350613336
Test: vts_libsnapshot_test
      wipe in INITIATED state, no merge
      wipe in UNVERIFIED state, no merge
      wipe in UNVERIFIED + rollback state, no merge
      wipe in MERGING state, merge
Change-Id: I387aabcfa6304118be88ddbb85842111d5c2ef6a
---
 fs_mgr/libsnapshot/device_info.cpp            |  18 ++
 fs_mgr/libsnapshot/device_info.h              |   1 +
 .../include/libsnapshot/mock_device_info.h    |   1 +
 .../include/libsnapshot/snapshot.h            |  11 +-
 .../include_test/libsnapshot/test_helpers.h   |   1 +
 .../partition_cow_creator_test.cpp            |   8 +-
 fs_mgr/libsnapshot/snapshot.cpp               | 178 ++++++++++--------
 fs_mgr/libsnapshot/snapshot_test.cpp          |  13 +-
 8 files changed, 137 insertions(+), 94 deletions(-)

diff --git a/fs_mgr/libsnapshot/device_info.cpp b/fs_mgr/libsnapshot/device_info.cpp
index 0ab61033f915..e0969f4c7101 100644
--- a/fs_mgr/libsnapshot/device_info.cpp
+++ b/fs_mgr/libsnapshot/device_info.cpp
@@ -104,6 +104,24 @@ bool DeviceInfo::IsFirstStageInit() const {
     return first_stage_init_;
 }
 
+bool DeviceInfo::SetActiveBootSlot([[maybe_unused]] unsigned int slot) {
+#ifdef LIBSNAPSHOT_USE_HAL
+    if (!EnsureBootHal()) {
+        return false;
+    }
+
+    CommandResult result = boot_control_->SetActiveBootSlot(slot);
+    if (!result.success) {
+        LOG(ERROR) << "Error setting slot " << slot << " active: " << result.errMsg;
+        return false;
+    }
+    return true;
+#else
+    LOG(ERROR) << "HAL support not enabled.";
+    return false;
+#endif
+}
+
 bool DeviceInfo::SetSlotAsUnbootable([[maybe_unused]] unsigned int slot) {
 #ifdef LIBSNAPSHOT_USE_HAL
     if (!EnsureBootHal()) {
diff --git a/fs_mgr/libsnapshot/device_info.h b/fs_mgr/libsnapshot/device_info.h
index d06f1be7cb89..9153abb018be 100644
--- a/fs_mgr/libsnapshot/device_info.h
+++ b/fs_mgr/libsnapshot/device_info.h
@@ -36,6 +36,7 @@ class DeviceInfo final : public SnapshotManager::IDeviceInfo {
     std::string GetSuperDevice(uint32_t slot) const override;
     bool IsOverlayfsSetup() const override;
     bool SetBootControlMergeStatus(MergeStatus status) override;
+    bool SetActiveBootSlot(unsigned int slot) override;
     bool SetSlotAsUnbootable(unsigned int slot) override;
     bool IsRecovery() const override;
     std::unique_ptr<IImageManager> OpenImageManager() const override;
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/mock_device_info.h b/fs_mgr/libsnapshot/include/libsnapshot/mock_device_info.h
index 573a85b24072..ca1ac1e6b225 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/mock_device_info.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/mock_device_info.h
@@ -29,6 +29,7 @@ class MockDeviceInfo : public SnapshotManager::IDeviceInfo {
     MOCK_METHOD(const android::fs_mgr::IPartitionOpener&, GetPartitionOpener, (), (const));
     MOCK_METHOD(bool, IsOverlayfsSetup, (), (const, override));
     MOCK_METHOD(bool, SetBootControlMergeStatus, (MergeStatus status), (override));
+    MOCK_METHOD(bool, SetActiveBootSlot, (unsigned int slot), (override));
     MOCK_METHOD(bool, SetSlotAsUnbootable, (unsigned int slot), (override));
     MOCK_METHOD(bool, IsRecovery, (), (const, override));
     MOCK_METHOD(bool, IsFirstStageInit, (), (const, override));
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index 4a3ec1d3a7c4..deb2d6e92bc6 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -104,6 +104,7 @@ class ISnapshotManager {
         virtual const android::fs_mgr::IPartitionOpener& GetPartitionOpener() const = 0;
         virtual bool IsOverlayfsSetup() const = 0;
         virtual bool SetBootControlMergeStatus(MergeStatus status) = 0;
+        virtual bool SetActiveBootSlot(unsigned int slot) = 0;
         virtual bool SetSlotAsUnbootable(unsigned int slot) = 0;
         virtual bool IsRecovery() const = 0;
         virtual bool IsTestDevice() const { return false; }
@@ -675,6 +676,8 @@ class SnapshotManager final : public ISnapshotManager {
     std::string GetBootSnapshotsWithoutSlotSwitchPath();
     std::string GetSnapuserdFromSystemPath();
 
+    bool HasForwardMergeIndicator();
+
     const LpMetadata* ReadOldPartitionMetadata(LockedFile* lock);
 
     bool MapAllPartitions(LockedFile* lock, const std::string& super_device, uint32_t slot,
@@ -785,11 +788,8 @@ class SnapshotManager final : public ISnapshotManager {
     bool UpdateForwardMergeIndicator(bool wipe);
 
     // Helper for HandleImminentDataWipe.
-    // Call ProcessUpdateState and handle states with special rules before data wipe. Specifically,
-    // if |allow_forward_merge| and allow-forward-merge indicator exists, initiate merge if
-    // necessary.
-    UpdateState ProcessUpdateStateOnDataWipe(bool allow_forward_merge,
-                                             const std::function<bool()>& callback);
+    // Call ProcessUpdateState and handle states with special rules before data wipe.
+    UpdateState ProcessUpdateStateOnDataWipe(const std::function<bool()>& callback);
 
     // Return device string of a mapped image, or if it is not available, the mapped image path.
     bool GetMappedImageDeviceStringOrPath(const std::string& device_name,
@@ -848,7 +848,6 @@ class SnapshotManager final : public ISnapshotManager {
     std::string metadata_dir_;
     std::unique_ptr<IImageManager> images_;
     bool use_first_stage_snapuserd_ = false;
-    bool in_factory_data_reset_ = false;
     std::function<bool(const std::string&)> uevent_regen_callback_;
     std::unique_ptr<SnapuserdClient> snapuserd_client_;
     std::unique_ptr<LpMetadata> old_partition_metadata_;
diff --git a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
index 0afd8bd22ae5..620b03c14e36 100644
--- a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
+++ b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
@@ -92,6 +92,7 @@ class TestDeviceInfo : public SnapshotManager::IDeviceInfo {
     }
     bool IsOverlayfsSetup() const override { return false; }
     bool IsRecovery() const override { return recovery_; }
+    bool SetActiveBootSlot([[maybe_unused]] unsigned int slot) override { return true; }
     bool SetSlotAsUnbootable(unsigned int slot) override {
         unbootable_slots_.insert(slot);
         return true;
diff --git a/fs_mgr/libsnapshot/partition_cow_creator_test.cpp b/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
index a4a2c1a681fc..8356c0c24b18 100644
--- a/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
+++ b/fs_mgr/libsnapshot/partition_cow_creator_test.cpp
@@ -250,8 +250,8 @@ TEST_F(PartitionCowCreatorTest, CompressionEnabled) {
                                 .target_partition = system_b,
                                 .current_metadata = builder_a.get(),
                                 .current_suffix = "_a",
-                                .using_snapuserd = true,
-                                .update = &update};
+                                .update = &update,
+                                .using_snapuserd = true};
 
     auto ret = creator.Run();
     ASSERT_TRUE(ret.has_value());
@@ -276,8 +276,8 @@ TEST_F(PartitionCowCreatorTest, CompressionWithNoManifest) {
                                 .target_partition = system_b,
                                 .current_metadata = builder_a.get(),
                                 .current_suffix = "_a",
-                                .using_snapuserd = true,
-                                .update = nullptr};
+                                .update = nullptr,
+                                .using_snapuserd = true};
 
     auto ret = creator.Run();
     ASSERT_FALSE(ret.has_value());
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 265445b6066d..108fd903b431 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -4005,44 +4005,90 @@ bool SnapshotManager::HandleImminentDataWipe(const std::function<void()>& callba
         // We allow the wipe to continue, because if we can't mount /metadata,
         // it is unlikely the device would have booted anyway. If there is no
         // metadata partition, then the device predates Virtual A/B.
+        LOG(INFO) << "/metadata not found; allowing wipe.";
         return true;
     }
 
-    // Check this early, so we don't accidentally start trying to populate
-    // the state file in recovery. Note we don't call GetUpdateState since
-    // we want errors in acquiring the lock to be propagated, instead of
-    // returning UpdateState::None.
-    auto state_file = GetStateFilePath();
-    if (access(state_file.c_str(), F_OK) != 0 && errno == ENOENT) {
-        return true;
+    // This could happen if /metadata mounted but there is no filesystem
+    // structure. Weird, but we have to assume there's no OTA pending, and
+    // thus we let the wipe proceed.
+    UpdateState state;
+    {
+        auto lock = LockExclusive();
+        if (!lock) {
+            LOG(ERROR) << "Unable to determine update state; allowing wipe.";
+            return true;
+        }
+
+        state = ReadUpdateState(lock.get());
+        LOG(INFO) << "Update state before wipe: " << state << "; slot: " << GetCurrentSlot()
+                  << "; suffix: " << device_->GetSlotSuffix();
     }
 
-    auto slot_number = SlotNumberForSlotSuffix(device_->GetSlotSuffix());
-    auto super_path = device_->GetSuperDevice(slot_number);
-    if (!CreateLogicalAndSnapshotPartitions(super_path, 20s)) {
-        LOG(ERROR) << "Unable to map partitions to complete merge.";
-        return false;
+    bool try_merge = false;
+    switch (state) {
+        case UpdateState::None:
+        case UpdateState::Initiated:
+            LOG(INFO) << "Wipe is not impacted by update state; allowing wipe.";
+            break;
+        case UpdateState::Unverified:
+            if (GetCurrentSlot() != Slot::Target) {
+                LOG(INFO) << "Wipe is not impacted by rolled back update; allowing wipe";
+                break;
+            }
+            if (!HasForwardMergeIndicator()) {
+                auto slot_number = SlotNumberForSlotSuffix(device_->GetSlotSuffix());
+                auto other_slot_number = SlotNumberForSlotSuffix(device_->GetOtherSlotSuffix());
+
+                // We're not allowed to forward merge, so forcefully rollback the
+                // slot switch.
+                LOG(INFO) << "Allowing wipe due to lack of forward merge indicator; reverting to "
+                             "old slot since update will be deleted.";
+                device_->SetSlotAsUnbootable(slot_number);
+                device_->SetActiveBootSlot(other_slot_number);
+                break;
+            }
+
+            // Forward merge indicator means we have to mount snapshots and try to merge.
+            LOG(INFO) << "Forward merge indicator is present.";
+            try_merge = true;
+            break;
+        case UpdateState::Merging:
+        case UpdateState::MergeFailed:
+            try_merge = true;
+            break;
+        case UpdateState::MergeNeedsReboot:
+        case UpdateState::Cancelled:
+            LOG(INFO) << "Unexpected update state in recovery; allowing wipe.";
+            break;
+        default:
+            break;
     }
 
-    auto process_callback = [&]() -> bool {
-        if (callback) {
-            callback();
+    if (try_merge) {
+        auto slot_number = SlotNumberForSlotSuffix(device_->GetSlotSuffix());
+        auto super_path = device_->GetSuperDevice(slot_number);
+        if (!CreateLogicalAndSnapshotPartitions(super_path, 20s)) {
+            LOG(ERROR) << "Unable to map partitions to complete merge.";
+            return false;
         }
-        return true;
-    };
 
-    in_factory_data_reset_ = true;
-    UpdateState state =
-            ProcessUpdateStateOnDataWipe(true /* allow_forward_merge */, process_callback);
-    in_factory_data_reset_ = false;
+        auto process_callback = [&]() -> bool {
+            if (callback) {
+                callback();
+            }
+            return true;
+        };
 
-    if (state == UpdateState::MergeFailed) {
-        return false;
-    }
+        state = ProcessUpdateStateOnDataWipe(process_callback);
+        if (state == UpdateState::MergeFailed) {
+            return false;
+        }
 
-    // Nothing should be depending on partitions now, so unmap them all.
-    if (!UnmapAllPartitionsInRecovery()) {
-        LOG(ERROR) << "Unable to unmap all partitions; fastboot may fail to flash.";
+        // Nothing should be depending on partitions now, so unmap them all.
+        if (!UnmapAllPartitionsInRecovery()) {
+            LOG(ERROR) << "Unable to unmap all partitions; fastboot may fail to flash.";
+        }
     }
 
     if (state != UpdateState::None) {
@@ -4088,58 +4134,40 @@ bool SnapshotManager::FinishMergeInRecovery() {
     return true;
 }
 
-UpdateState SnapshotManager::ProcessUpdateStateOnDataWipe(bool allow_forward_merge,
-                                                          const std::function<bool()>& callback) {
-    auto slot_number = SlotNumberForSlotSuffix(device_->GetSlotSuffix());
-    UpdateState state = ProcessUpdateState(callback);
-    LOG(INFO) << "Update state in recovery: " << state;
-    switch (state) {
-        case UpdateState::MergeFailed:
-            LOG(ERROR) << "Unrecoverable merge failure detected.";
-            return state;
-        case UpdateState::Unverified: {
-            // If an OTA was just applied but has not yet started merging:
-            //
-            // - if forward merge is allowed, initiate merge and call
-            // ProcessUpdateState again.
-            //
-            // - if forward merge is not allowed, we
-            // have no choice but to revert slots, because the current slot will
-            // immediately become unbootable. Rather than wait for the device
-            // to reboot N times until a rollback, we proactively disable the
-            // new slot instead.
-            //
-            // Since the rollback is inevitable, we don't treat a HAL failure
-            // as an error here.
-            auto slot = GetCurrentSlot();
-            if (slot == Slot::Target) {
-                if (allow_forward_merge &&
-                    access(GetForwardMergeIndicatorPath().c_str(), F_OK) == 0) {
-                    LOG(INFO) << "Forward merge allowed, initiating merge now.";
-
-                    if (!InitiateMerge()) {
-                        LOG(ERROR) << "Failed to initiate merge on data wipe.";
-                        return UpdateState::MergeFailed;
-                    }
-                    return ProcessUpdateStateOnDataWipe(false /* allow_forward_merge */, callback);
+UpdateState SnapshotManager::ProcessUpdateStateOnDataWipe(const std::function<bool()>& callback) {
+    while (true) {
+        UpdateState state = ProcessUpdateState(callback);
+        LOG(INFO) << "Processed updated state in recovery: " << state;
+        switch (state) {
+            case UpdateState::MergeFailed:
+                LOG(ERROR) << "Unrecoverable merge failure detected.";
+                return state;
+            case UpdateState::Unverified: {
+                // Unverified was already handled earlier, in HandleImminentDataWipe,
+                // but it will fall through here if a forward merge is required.
+                //
+                // If InitiateMerge fails, we early return. If it succeeds, then we
+                // are guaranteed that the next call to ProcessUpdateState will not
+                // return Unverified.
+                if (!InitiateMerge()) {
+                    LOG(ERROR) << "Failed to initiate merge on data wipe.";
+                    return UpdateState::MergeFailed;
                 }
-
-                LOG(ERROR) << "Reverting to old slot since update will be deleted.";
-                device_->SetSlotAsUnbootable(slot_number);
-            } else {
-                LOG(INFO) << "Booting from " << slot << " slot, no action is taken.";
+                continue;
             }
-            break;
+            case UpdateState::MergeNeedsReboot:
+                // We shouldn't get here, because nothing is depending on
+                // logical partitions.
+                LOG(ERROR) << "Unexpected merge-needs-reboot state in recovery.";
+                return state;
+            default:
+                return state;
         }
-        case UpdateState::MergeNeedsReboot:
-            // We shouldn't get here, because nothing is depending on
-            // logical partitions.
-            LOG(ERROR) << "Unexpected merge-needs-reboot state in recovery.";
-            break;
-        default:
-            break;
     }
-    return state;
+}
+
+bool SnapshotManager::HasForwardMergeIndicator() {
+    return access(GetForwardMergeIndicatorPath().c_str(), F_OK) == 0;
 }
 
 bool SnapshotManager::EnsureNoOverflowSnapshot(LockedFile* lock) {
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index b2e36d426072..c29da175a788 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2102,10 +2102,10 @@ TEST_F(SnapshotUpdateTest, DataWipeRollbackInRecovery) {
     test_device->set_recovery(true);
     auto new_sm = NewManagerForFirstStageMount(test_device);
 
+    EXPECT_EQ(new_sm->GetUpdateState(), UpdateState::Unverified);
     ASSERT_TRUE(new_sm->HandleImminentDataWipe());
     // Manually mount metadata so that we can call GetUpdateState() below.
     MountMetadata();
-    EXPECT_EQ(new_sm->GetUpdateState(), UpdateState::None);
     EXPECT_TRUE(test_device->IsSlotUnbootable(1));
     EXPECT_FALSE(test_device->IsSlotUnbootable(0));
 }
@@ -2127,6 +2127,7 @@ TEST_F(SnapshotUpdateTest, DataWipeAfterRollback) {
     test_device->set_recovery(true);
     auto new_sm = NewManagerForFirstStageMount(test_device);
 
+    EXPECT_EQ(new_sm->GetUpdateState(), UpdateState::Unverified);
     ASSERT_TRUE(new_sm->HandleImminentDataWipe());
     EXPECT_EQ(new_sm->GetUpdateState(), UpdateState::None);
     EXPECT_FALSE(test_device->IsSlotUnbootable(0));
@@ -2135,10 +2136,6 @@ TEST_F(SnapshotUpdateTest, DataWipeAfterRollback) {
 
 // Test update package that requests data wipe.
 TEST_F(SnapshotUpdateTest, DataWipeRequiredInPackage) {
-    if (ShouldSkipLegacyMerging()) {
-        GTEST_SKIP() << "Skipping legacy merge in test";
-    }
-
     AddOperationForPartitions();
     // Execute the update.
     ASSERT_TRUE(sm->BeginUpdate());
@@ -2157,6 +2154,7 @@ TEST_F(SnapshotUpdateTest, DataWipeRequiredInPackage) {
     test_device->set_recovery(true);
     auto new_sm = NewManagerForFirstStageMount(test_device);
 
+    EXPECT_EQ(new_sm->GetUpdateState(), UpdateState::Unverified);
     ASSERT_TRUE(new_sm->HandleImminentDataWipe());
     // Manually mount metadata so that we can call GetUpdateState() below.
     MountMetadata();
@@ -2178,10 +2176,6 @@ TEST_F(SnapshotUpdateTest, DataWipeRequiredInPackage) {
 
 // Test update package that requests data wipe.
 TEST_F(SnapshotUpdateTest, DataWipeWithStaleSnapshots) {
-    if (ShouldSkipLegacyMerging()) {
-        GTEST_SKIP() << "Skipping legacy merge in test";
-    }
-
     AddOperationForPartitions();
 
     // Execute the update.
@@ -2222,6 +2216,7 @@ TEST_F(SnapshotUpdateTest, DataWipeWithStaleSnapshots) {
     test_device->set_recovery(true);
     auto new_sm = NewManagerForFirstStageMount(test_device);
 
+    EXPECT_EQ(new_sm->GetUpdateState(), UpdateState::Unverified);
     ASSERT_TRUE(new_sm->HandleImminentDataWipe());
     // Manually mount metadata so that we can call GetUpdateState() below.
     MountMetadata();

From 412d097d4af58179387ecf8046e0397e4bbfb1fc Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Mon, 12 Aug 2024 10:11:52 +0900
Subject: [PATCH 1056/1487] Remove InitProperties

As userspace reboot is deprecated, there's no clients.

Bug: 292469129
Test: m
Change-Id: Iafdd719b67fe74dc42498f7ecde2aa5b677ecd0c
---
 init/Android.bp                               |  1 -
 init/builtins.cpp                             |  1 -
 init/property_service.cpp                     |  1 -
 init/reboot.cpp                               |  1 -
 init/sysprop/Android.bp                       | 16 ---------
 init/sysprop/InitProperties.sysprop           | 36 -------------------
 .../api/com.android.sysprop.init-current.txt  | 14 --------
 .../api/com.android.sysprop.init-latest.txt   | 14 --------
 8 files changed, 84 deletions(-)
 delete mode 100644 init/sysprop/Android.bp
 delete mode 100644 init/sysprop/InitProperties.sysprop
 delete mode 100644 init/sysprop/api/com.android.sysprop.init-current.txt
 delete mode 100644 init/sysprop/api/com.android.sysprop.init-latest.txt

diff --git a/init/Android.bp b/init/Android.bp
index ffb63806361f..ed1f14820ea6 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -226,7 +226,6 @@ cc_defaults {
     ],
     whole_static_libs: [
         "libcap",
-        "libcom.android.sysprop.init",
     ],
     header_libs: ["bootimg_headers"],
     proto: {
diff --git a/init/builtins.cpp b/init/builtins.cpp
index 122adb7f6ce5..1e81692e7a45 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -46,7 +46,6 @@
 #include <map>
 #include <memory>
 
-#include <InitProperties.sysprop.h>
 #include <android-base/chrono_utils.h>
 #include <android-base/file.h>
 #include <android-base/logging.h>
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 96a9cd4e47dc..4d3742a32280 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -46,7 +46,6 @@
 #include <thread>
 #include <vector>
 
-#include <InitProperties.sysprop.h>
 #include <android-base/chrono_utils.h>
 #include <android-base/file.h>
 #include <android-base/logging.h>
diff --git a/init/reboot.cpp b/init/reboot.cpp
index 66ee9772af36..ef9db9fdae30 100644
--- a/init/reboot.cpp
+++ b/init/reboot.cpp
@@ -39,7 +39,6 @@
 #include <thread>
 #include <vector>
 
-#include <InitProperties.sysprop.h>
 #include <android-base/chrono_utils.h>
 #include <android-base/file.h>
 #include <android-base/logging.h>
diff --git a/init/sysprop/Android.bp b/init/sysprop/Android.bp
deleted file mode 100644
index 296cdc16dbf1..000000000000
--- a/init/sysprop/Android.bp
+++ /dev/null
@@ -1,16 +0,0 @@
-package {
-    // See: http://go/android-license-faq
-    // A large-scale-change added 'default_applicable_licenses' to import
-    // all of the 'license_kinds' from "system_core_init_license"
-    // to get the below license kinds:
-    //   SPDX-license-identifier-Apache-2.0
-    default_applicable_licenses: ["system_core_init_license"],
-}
-
-sysprop_library {
-  name: "com.android.sysprop.init",
-  srcs: ["InitProperties.sysprop"],
-  property_owner: "Platform",
-  api_packages: ["android.sysprop"],
-  recovery_available: true,
-}
diff --git a/init/sysprop/InitProperties.sysprop b/init/sysprop/InitProperties.sysprop
deleted file mode 100644
index 24c2434d0d33..000000000000
--- a/init/sysprop/InitProperties.sysprop
+++ /dev/null
@@ -1,36 +0,0 @@
-# Copyright (C) 2019 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-owner: Platform
-module: "android.sysprop.InitProperties"
-
-# Serves as a signal to all processes that userspace reboot is happening.
-prop {
-    api_name: "userspace_reboot_in_progress"
-    type: Boolean
-    scope: Public
-    access: ReadWrite
-    prop_name: "sys.init.userspace_reboot.in_progress"
-    integer_as_bool: true
-}
-
-# Shows whenever the device supports userspace reboot or not.
-prop {
-    api_name: "is_userspace_reboot_supported"
-    type: Boolean
-    scope: Public
-    access: Readonly
-    prop_name: "init.userspace_reboot.is_supported"
-    integer_as_bool: true
-}
diff --git a/init/sysprop/api/com.android.sysprop.init-current.txt b/init/sysprop/api/com.android.sysprop.init-current.txt
deleted file mode 100644
index 01f4e9a91367..000000000000
--- a/init/sysprop/api/com.android.sysprop.init-current.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-props {
-  module: "android.sysprop.InitProperties"
-  prop {
-    api_name: "is_userspace_reboot_supported"
-    prop_name: "init.userspace_reboot.is_supported"
-    integer_as_bool: true
-  }
-  prop {
-    api_name: "userspace_reboot_in_progress"
-    access: ReadWrite
-    prop_name: "sys.init.userspace_reboot.in_progress"
-    integer_as_bool: true
-  }
-}
diff --git a/init/sysprop/api/com.android.sysprop.init-latest.txt b/init/sysprop/api/com.android.sysprop.init-latest.txt
deleted file mode 100644
index 01f4e9a91367..000000000000
--- a/init/sysprop/api/com.android.sysprop.init-latest.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-props {
-  module: "android.sysprop.InitProperties"
-  prop {
-    api_name: "is_userspace_reboot_supported"
-    prop_name: "init.userspace_reboot.is_supported"
-    integer_as_bool: true
-  }
-  prop {
-    api_name: "userspace_reboot_in_progress"
-    access: ReadWrite
-    prop_name: "sys.init.userspace_reboot.in_progress"
-    integer_as_bool: true
-  }
-}

From eecb1078280bfddc456af51882afc335e5ba1f35 Mon Sep 17 00:00:00 2001
From: Yi Kong <yikong@google.com>
Date: Mon, 12 Aug 2024 18:14:57 +0800
Subject: [PATCH 1057/1487] Remove unnecessary std::move

Moving a temporary object prevents copy elision, and could reduce
performance.

This fixes -Wpessimizing-move compiler warning.

Test: presubmit
Bug: 154270751
Change-Id: I4900bcfd14d461f7ded0500eca0a6b386ed59c8f
---
 debuggerd/tombstoned/tombstoned.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/debuggerd/tombstoned/tombstoned.cpp b/debuggerd/tombstoned/tombstoned.cpp
index fa67d46e61b1..2c7237934ec6 100644
--- a/debuggerd/tombstoned/tombstoned.cpp
+++ b/debuggerd/tombstoned/tombstoned.cpp
@@ -158,7 +158,7 @@ class CrashQueue {
       }
     }
 
-    return std::move(result);
+    return result;
   }
 
   std::optional<CrashOutput> get_output(DebuggerdDumpType dump_type) {

From ae0b2903872e1b8e8865230f332bf69690270104 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Mon, 5 Aug 2024 18:18:35 +0000
Subject: [PATCH 1058/1487] libprocessgroup: Convert libprocessgroup_util to
 static library

To avoid duplicate symbol linker error and prep for addition of json
descriptor reading and activation functions in upcoming changes.

Bug: 349105928
Test: m
Change-Id: I5cd663d6007ef330b872b8cf8ed046ee68b6d736
---
 libprocessgroup/Android.bp                    |  2 +-
 libprocessgroup/setup/Android.bp              |  2 +-
 libprocessgroup/util/Android.bp               |  7 ++-
 .../util/include/processgroup/util.h          | 38 +-----------
 libprocessgroup/util/util.cpp                 | 59 +++++++++++++++++++
 5 files changed, 67 insertions(+), 41 deletions(-)
 create mode 100644 libprocessgroup/util/util.cpp

diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index 33e00bc5dc1e..a60bfe97344a 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -79,12 +79,12 @@ cc_library {
     ],
     static_libs: [
         "libjsoncpp",
+        "libprocessgroup_util",
     ],
     // for cutils/android_filesystem_config.h
     header_libs: [
         "libcutils_headers",
         "libprocessgroup_headers",
-        "libprocessgroup_util",
     ],
     export_include_dirs: ["include"],
     export_header_lib_headers: [
diff --git a/libprocessgroup/setup/Android.bp b/libprocessgroup/setup/Android.bp
index 76f0a11f1fa0..1a4ad0118ac4 100644
--- a/libprocessgroup/setup/Android.bp
+++ b/libprocessgroup/setup/Android.bp
@@ -34,10 +34,10 @@ cc_library_shared {
     ],
     static_libs: [
         "libcgrouprc_format",
+        "libprocessgroup_util",
     ],
     header_libs: [
         "libprocessgroup_headers",
-        "libprocessgroup_util",
     ],
     export_header_lib_headers: [
         "libprocessgroup_headers",
diff --git a/libprocessgroup/util/Android.bp b/libprocessgroup/util/Android.bp
index 4a940b774b14..54ba69b4eb70 100644
--- a/libprocessgroup/util/Android.bp
+++ b/libprocessgroup/util/Android.bp
@@ -19,7 +19,7 @@ package {
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
-cc_library_headers {
+cc_library_static {
     name: "libprocessgroup_util",
     vendor_available: true,
     product_available: true,
@@ -36,12 +36,15 @@ cc_library_headers {
     export_include_dirs: [
         "include",
     ],
+    srcs: [
+        "util.cpp",
+    ],
     defaults: ["libprocessgroup_build_flags_cc"],
 }
 
 cc_test {
     name: "libprocessgroup_util_test",
-    header_libs: ["libprocessgroup_util"],
+    static_libs: ["libprocessgroup_util"],
     srcs: ["tests/util.cpp"],
     test_suites: ["general-tests"],
 }
diff --git a/libprocessgroup/util/include/processgroup/util.h b/libprocessgroup/util/include/processgroup/util.h
index 5240744c62ef..8d013af55164 100644
--- a/libprocessgroup/util/include/processgroup/util.h
+++ b/libprocessgroup/util/include/processgroup/util.h
@@ -16,46 +16,10 @@
 
 #pragma once
 
-#include <algorithm>
-#include <iterator>
 #include <string>
 
 namespace util {
 
-namespace internal {
-
-const char SEP = '/';
-
-std::string DeduplicateAndTrimSeparators(const std::string& path) {
-    bool lastWasSep = false;
-    std::string ret;
-
-    std::copy_if(path.begin(), path.end(), std::back_inserter(ret), [&lastWasSep](char c) {
-        if (lastWasSep) {
-            if (c == SEP) return false;
-            lastWasSep = false;
-        } else if (c == SEP) {
-            lastWasSep = true;
-        }
-        return true;
-    });
-
-    if (ret.length() > 1 && ret.back() == SEP) ret.pop_back();
-
-    return ret;
-}
-
-}  // namespace internal
-
-unsigned int GetCgroupDepth(const std::string& controller_root, const std::string& cgroup_path) {
-    const std::string deduped_root = internal::DeduplicateAndTrimSeparators(controller_root);
-    const std::string deduped_path = internal::DeduplicateAndTrimSeparators(cgroup_path);
-
-    if (deduped_root.empty() || deduped_path.empty() || !deduped_path.starts_with(deduped_root))
-        return 0;
-
-    return std::count(deduped_path.begin() + deduped_root.size(), deduped_path.end(),
-                      internal::SEP);
-}
+unsigned int GetCgroupDepth(const std::string& controller_root, const std::string& cgroup_path);
 
 }  // namespace util
diff --git a/libprocessgroup/util/util.cpp b/libprocessgroup/util/util.cpp
new file mode 100644
index 000000000000..9b88a223a617
--- /dev/null
+++ b/libprocessgroup/util/util.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <processgroup/util.h>
+
+#include <algorithm>
+#include <iterator>
+
+namespace {
+
+const char SEP = '/';
+
+std::string DeduplicateAndTrimSeparators(const std::string& path) {
+    bool lastWasSep = false;
+    std::string ret;
+
+    std::copy_if(path.begin(), path.end(), std::back_inserter(ret), [&lastWasSep](char c) {
+        if (lastWasSep) {
+            if (c == SEP) return false;
+            lastWasSep = false;
+        } else if (c == SEP) {
+            lastWasSep = true;
+        }
+        return true;
+    });
+
+    if (ret.length() > 1 && ret.back() == SEP) ret.pop_back();
+
+    return ret;
+}
+
+}  // anonymous namespace
+
+namespace util {
+
+unsigned int GetCgroupDepth(const std::string& controller_root, const std::string& cgroup_path) {
+    const std::string deduped_root = DeduplicateAndTrimSeparators(controller_root);
+    const std::string deduped_path = DeduplicateAndTrimSeparators(cgroup_path);
+
+    if (deduped_root.empty() || deduped_path.empty() || !deduped_path.starts_with(deduped_root))
+        return 0;
+
+    return std::count(deduped_path.begin() + deduped_root.size(), deduped_path.end(), SEP);
+}
+
+}  // namespace util

From 1df3536b955fd4c0ee4c7b760beea29c1a1bdec5 Mon Sep 17 00:00:00 2001
From: "Chaitanya Cheemala (xWF)" <ccheemala@google.com>
Date: Tue, 13 Aug 2024 08:28:03 +0000
Subject: [PATCH 1059/1487] Revert^3 "Set block device as RO/RW before mount"

This reverts commit 61c07a09e8e234ede8f60f4d8898415a03da16ff.

Reason for revert: Likely culprit for b/359414718  - verifying through ABTD before revert submission. This is part of the standard investigation process, and does not mean your CL will be reverted.

Change-Id: Ie40dcc6d3549183ba146c4ff37edc0d1e57d0cca
---
 fs_mgr/fs_mgr.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index ea2e3a8c754b..5156754a8538 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -826,9 +826,6 @@ static int __mount(const std::string& source, const std::string& target, const F
     if (read_only) {
         mountflags |= MS_RDONLY;
     }
-    if (!fs_mgr_set_blk_ro(source, read_only)) {
-        PLOG(ERROR) << "Failed to set " << source << " as " << (read_only ? "RO" : "RW");
-    }
     int ret = 0;
     int save_errno = 0;
     int gc_allowance = 0;
@@ -883,6 +880,9 @@ static int __mount(const std::string& source, const std::string& target, const F
     }
     PINFO << __FUNCTION__ << "(source=" << source << source_missing << ",target=" << target
           << target_missing << ",type=" << entry.fs_type << ")=" << ret;
+    if ((ret == 0) && (mountflags & MS_RDONLY) != 0) {
+        fs_mgr_set_blk_ro(source);
+    }
     if (ret == 0) {
         android::base::SetProperty("ro.boottime.init.mount." + Basename(target),
                                    std::to_string(t.duration().count()));

From 095f29209508520b5958b037cb016d26820666d9 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Wed, 15 May 2024 18:34:29 -0700
Subject: [PATCH 1060/1487] Allow to re-enable MTE a specified time after a
 permissive fault

The timeout has to be determined experimentally. Generally, it must be
high enough to at least be the next instruction, and can be otherwise as
low as performance reasons allow.

This feature is for debugging only.

Test: atest PermissiveMteTest
Bug: 309604766
Change-Id: I54eff23374ebb239fd75b3b59ae72a7c33654454
---
 debuggerd/handler/debuggerd_handler.cpp       | 87 ++++++++++++++++++-
 debuggerd/test_permissive_mte/mte_crash.cpp   |  9 ++
 .../tests/debuggerd/PermissiveMteTest.java    | 28 ++++++
 3 files changed, 122 insertions(+), 2 deletions(-)

diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index e26746b607f5..42f0aa0d96da 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -36,10 +36,12 @@
 #include <sys/uio.h>
 #include <sys/un.h>
 #include <sys/wait.h>
+#include <time.h>
 #include <unistd.h>
 
 #include <android-base/macros.h>
 #include <android-base/parsebool.h>
+#include <android-base/parseint.h>
 #include <android-base/properties.h>
 #include <android-base/unique_fd.h>
 #include <async_safe/log.h>
@@ -115,6 +117,59 @@ static bool is_permissive_mte() {
          (permissive_env && ParseBool(permissive_env) == ParseBoolResult::kTrue);
 }
 
+static bool parse_uint_with_error_reporting(const char* s, const char* name, int* v) {
+  if (android::base::ParseInt(s, v) && *v >= 0) {
+    return true;
+  }
+  async_safe_format_log(ANDROID_LOG_ERROR, "libc", "invalid %s: %s", name, s);
+  return false;
+}
+
+// We cannot use base::GetIntProperty, because that internally uses
+// std::string, which allocates.
+static bool property_parse_int(const char* name, int* out) {
+  const prop_info* pi = __system_property_find(name);
+  if (!pi) return false;
+  struct cookie_t {
+    int* out;
+    bool empty;
+  } cookie{out, true};
+  __system_property_read_callback(
+      pi,
+      [](void* raw_cookie, const char* name, const char* value, uint32_t) {
+        // Property is set to empty value, ignoring.
+        if (!*value) return;
+        cookie_t* cookie = reinterpret_cast<cookie_t*>(raw_cookie);
+        if (parse_uint_with_error_reporting(value, name, cookie->out)) cookie->empty = false;
+      },
+      &cookie);
+  return !cookie.empty;
+}
+
+static int permissive_mte_renable_timer() {
+  if (char* env = getenv("MTE_PERMISSIVE_REENABLE_TIME_CPUMS")) {
+    int v;
+    if (parse_uint_with_error_reporting(env, "MTE_PERMISSIVE_REENABLE_TIME_CPUMS", &v)) return v;
+  }
+
+  char process_sysprop_name[512];
+  async_safe_format_buffer(process_sysprop_name, sizeof(process_sysprop_name),
+                           "persist.sys.mte.permissive_reenable_timer.process.%s", getprogname());
+  int v;
+  if (property_parse_int(process_sysprop_name, &v)) return v;
+  if (property_parse_int("persist.sys.mte.permissive_reenable_timer.default", &v)) return v;
+  char process_deviceconf_sysprop_name[512];
+  async_safe_format_buffer(
+      process_deviceconf_sysprop_name, sizeof(process_deviceconf_sysprop_name),
+      "persist.device_config.memory_safety_native.permissive_reenable_timer.process.%s",
+      getprogname());
+  if (property_parse_int(process_deviceconf_sysprop_name, &v)) return v;
+  if (property_parse_int(
+          "persist.device_config.memory_safety_native.permissive_reenable_timer.default", &v))
+    return v;
+  return 0;
+}
+
 static inline void futex_wait(volatile void* ftx, int value) {
   syscall(__NR_futex, ftx, FUTEX_WAIT, value, nullptr, nullptr, 0);
 }
@@ -599,12 +654,40 @@ static void debuggerd_signal_handler(int signal_number, siginfo_t* info, void* c
     if (tagged_addr_ctrl < 0) {
       fatal_errno("failed to PR_GET_TAGGED_ADDR_CTRL");
     }
+    int previous = tagged_addr_ctrl & PR_MTE_TCF_MASK;
     tagged_addr_ctrl = (tagged_addr_ctrl & ~PR_MTE_TCF_MASK) | PR_MTE_TCF_NONE;
     if (prctl(PR_SET_TAGGED_ADDR_CTRL, tagged_addr_ctrl, 0, 0, 0) < 0) {
       fatal_errno("failed to PR_SET_TAGGED_ADDR_CTRL");
     }
-    async_safe_format_log(ANDROID_LOG_ERROR, "libc",
-                          "MTE ERROR DETECTED BUT RUNNING IN PERMISSIVE MODE. CONTINUING.");
+    if (int reenable_timer = permissive_mte_renable_timer()) {
+      async_safe_format_log(ANDROID_LOG_ERROR, "libc",
+                            "MTE ERROR DETECTED BUT RUNNING IN PERMISSIVE MODE. CONTINUING WITH "
+                            "MTE DISABLED FOR %d MS OF CPU TIME.",
+                            reenable_timer);
+      timer_t timerid{};
+      struct sigevent sev {};
+      sev.sigev_signo = BIONIC_ENABLE_MTE;
+      sev.sigev_notify = SIGEV_THREAD_ID;
+      sev.sigev_value.sival_int = previous;
+      sev.sigev_notify_thread_id = __gettid();
+      // This MUST be CLOCK_THREAD_CPUTIME_ID. If we used CLOCK_MONOTONIC we could get stuck
+      // in an endless loop of re-running the same instruction, calling this signal handler,
+      // and re-enabling MTE before we had a chance to re-run the instruction.
+      if (timer_create(CLOCK_THREAD_CPUTIME_ID, &sev, &timerid) == -1) {
+        fatal_errno("timer_create() failed");
+      }
+      struct itimerspec its {};
+      its.it_value.tv_sec = reenable_timer / 1000;
+      its.it_value.tv_nsec = (reenable_timer % 1000) * 1000000;
+
+      if (timer_settime(timerid, 0, &its, nullptr) == -1) {
+        fatal_errno("timer_settime() failed");
+      }
+    } else {
+      async_safe_format_log(
+          ANDROID_LOG_ERROR, "libc",
+          "MTE ERROR DETECTED BUT RUNNING IN PERMISSIVE MODE. CONTINUING WITH MTE DISABLED.");
+    }
     pthread_mutex_unlock(&crash_mutex);
   }
 
diff --git a/debuggerd/test_permissive_mte/mte_crash.cpp b/debuggerd/test_permissive_mte/mte_crash.cpp
index 97ad73fbc381..75b70edb8fbb 100644
--- a/debuggerd/test_permissive_mte/mte_crash.cpp
+++ b/debuggerd/test_permissive_mte/mte_crash.cpp
@@ -20,5 +20,14 @@
 int main(int, char**) {
   volatile char* f = (char*)malloc(1);
   printf("%c\n", f[17]);
+#ifdef __aarch64__
+  if (getenv("MTE_PERMISSIVE_REENABLE_TIME_CPUMS")) {
+    // Burn some cycles because the MTE_PERMISSIVE_REENABLE_TIME_CPUMS is based on CPU clock.
+    for (int i = 0; i < 1000000000; ++i) {
+      asm("isb");
+    }
+    printf("%c\n", f[17]);
+  }
+#endif
   return 0;
 }
diff --git a/debuggerd/test_permissive_mte/src/com/android/tests/debuggerd/PermissiveMteTest.java b/debuggerd/test_permissive_mte/src/com/android/tests/debuggerd/PermissiveMteTest.java
index 0203adcd4ac7..544299dd1a31 100644
--- a/debuggerd/test_permissive_mte/src/com/android/tests/debuggerd/PermissiveMteTest.java
+++ b/debuggerd/test_permissive_mte/src/com/android/tests/debuggerd/PermissiveMteTest.java
@@ -97,6 +97,34 @@ public void testCrash() throws Exception {
     }
     assertThat(numberTombstones).isEqualTo(1);
   }
+
+  @Test
+  public void testReenableCrash() throws Exception {
+    CommandResult result =
+        getDevice().executeShellV2Command("MTE_PERMISSIVE=1 MTE_PERMISSIVE_REENABLE_TIME_CPUMS=1 "
+                                          + "/data/local/tmp/mte_crash testReenableCrash "
+                                          + mUUID);
+    assertThat(result.getExitCode()).isEqualTo(0);
+    int numberTombstones = 0;
+    String[] tombstones = getDevice().getChildren("/data/tombstones");
+    for (String tombstone : tombstones) {
+      if (!tombstone.endsWith(".pb")) {
+        continue;
+      }
+      String tombstonePath = "/data/tombstones/" + tombstone;
+      Tombstone tombstoneProto = parseTombstone(tombstonePath);
+      if (!tombstoneProto.getCommandLineList().stream().anyMatch(x -> x.contains(mUUID))) {
+        continue;
+      }
+      if (!tombstoneProto.getCommandLineList().stream().anyMatch(
+              x -> x.contains("testReenableCrash"))) {
+        continue;
+      }
+      numberTombstones++;
+    }
+    assertThat(numberTombstones).isEqualTo(2);
+  }
+
   @Test
   public void testCrashProperty() throws Exception {
     String prevValue = getDevice().getProperty("persist.sys.mte.permissive");

From 673e6bb0899c51e29400ed0098a30005e6a4d506 Mon Sep 17 00:00:00 2001
From: Rick Yiu <rickyiu@google.com>
Date: Mon, 1 Jul 2024 08:23:09 +0000
Subject: [PATCH 1061/1487] Create a new group for foreground of multi-window

In multi-window mode, currently the focused window will be top-app,
and others will be foreground. However, the cpu resource we assign to
typical foreground group may not meet the performance need of those
windows. Therefore, create a new group for them so that we could
distinguish their performance need.

Bug: 200769420
Test: group created
Change-Id: I84c61f9ed4d167e156dafb7a816b6482e80a8523
---
 libprocessgroup/profiles/task_profiles.json | 39 +++++++++++++++++++++
 rootdir/init.rc                             | 14 ++++++++
 2 files changed, 53 insertions(+)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 1fc66ba10a64..ec125aaf21c9 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -10,6 +10,11 @@
       "Controller": "cpuset",
       "File": "foreground/cpus"
     },
+    {
+      "Name": "HighCapacityWICPUs",
+      "Controller": "cpuset",
+      "File": "foreground_window/cpus"
+    },
     {
       "Name": "MaxCapacityCPUs",
       "Controller": "cpuset",
@@ -158,6 +163,19 @@
         }
       ]
     },
+    {
+      "Name": "HighPerformanceWI",
+      "Actions": [
+        {
+          "Name": "JoinCgroup",
+          "Params":
+          {
+            "Controller": "cpu",
+            "Path": "foreground_window"
+          }
+        }
+      ]
+    },
     {
       "Name": "MaxPerformance",
       "Actions": [
@@ -381,6 +399,19 @@
         }
       ]
     },
+    {
+      "Name": "ProcessCapacityHighWI",
+      "Actions": [
+        {
+          "Name": "JoinCgroup",
+          "Params":
+          {
+            "Controller": "cpuset",
+            "Path": "foreground_window"
+          }
+        }
+      ]
+    },
     {
       "Name": "ProcessCapacityMax",
       "Actions": [
@@ -638,6 +669,10 @@
       "Name": "SCHED_SP_FOREGROUND",
       "Profiles": [ "HighPerformance", "HighIoPriority", "TimerSlackNormal" ]
     },
+    {
+      "Name": "SCHED_SP_FOREGROUND_WINDOW",
+      "Profiles": [ "HighPerformanceWI", "HighIoPriority", "TimerSlackNormal" ]
+    },
     {
       "Name": "SCHED_SP_TOP_APP",
       "Profiles": [ "MaxPerformance", "MaxIoPriority", "TimerSlackNormal" ]
@@ -666,6 +701,10 @@
       "Name": "CPUSET_SP_FOREGROUND",
       "Profiles": [ "HighPerformance", "ProcessCapacityHigh", "HighIoPriority", "TimerSlackNormal" ]
     },
+    {
+      "Name": "CPUSET_SP_FOREGROUND_WINDOW",
+      "Profiles": [ "HighPerformanceWI", "ProcessCapacityHighWI", "HighIoPriority", "TimerSlackNormal" ]
+    },
     {
       "Name": "CPUSET_SP_TOP_APP",
       "Profiles": [ "MaxPerformance", "ProcessCapacityMax", "MaxIoPriority", "TimerSlackNormal" ]
diff --git a/rootdir/init.rc b/rootdir/init.rc
index e867998d6882..b967831585a2 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -145,6 +145,7 @@ on init
 
     # cpuctl hierarchy for devices using utilclamp
     mkdir /dev/cpuctl/foreground
+    mkdir /dev/cpuctl/foreground_window
     mkdir /dev/cpuctl/background
     mkdir /dev/cpuctl/top-app
     mkdir /dev/cpuctl/rt
@@ -153,6 +154,7 @@ on init
     mkdir /dev/cpuctl/dex2oat
     chown system system /dev/cpuctl
     chown system system /dev/cpuctl/foreground
+    chown system system /dev/cpuctl/foreground_window
     chown system system /dev/cpuctl/background
     chown system system /dev/cpuctl/top-app
     chown system system /dev/cpuctl/rt
@@ -161,6 +163,7 @@ on init
     chown system system /dev/cpuctl/dex2oat
     chown system system /dev/cpuctl/tasks
     chown system system /dev/cpuctl/foreground/tasks
+    chown system system /dev/cpuctl/foreground_window/tasks
     chown system system /dev/cpuctl/background/tasks
     chown system system /dev/cpuctl/top-app/tasks
     chown system system /dev/cpuctl/rt/tasks
@@ -169,6 +172,7 @@ on init
     chown system system /dev/cpuctl/dex2oat/tasks
     chown system system /dev/cpuctl/cgroup.procs
     chown system system /dev/cpuctl/foreground/cgroup.procs
+    chown system system /dev/cpuctl/foreground_window/cgroup.procs
     chown system system /dev/cpuctl/background/cgroup.procs
     chown system system /dev/cpuctl/top-app/cgroup.procs
     chown system system /dev/cpuctl/rt/cgroup.procs
@@ -177,6 +181,7 @@ on init
     chown system system /dev/cpuctl/dex2oat/cgroup.procs
     chmod 0664 /dev/cpuctl/tasks
     chmod 0664 /dev/cpuctl/foreground/tasks
+    chmod 0664 /dev/cpuctl/foreground_window/tasks
     chmod 0664 /dev/cpuctl/background/tasks
     chmod 0664 /dev/cpuctl/top-app/tasks
     chmod 0664 /dev/cpuctl/rt/tasks
@@ -185,6 +190,7 @@ on init
     chmod 0664 /dev/cpuctl/dex2oat/tasks
     chmod 0664 /dev/cpuctl/cgroup.procs
     chmod 0664 /dev/cpuctl/foreground/cgroup.procs
+    chmod 0664 /dev/cpuctl/foreground_window/cgroup.procs
     chmod 0664 /dev/cpuctl/background/cgroup.procs
     chmod 0664 /dev/cpuctl/top-app/cgroup.procs
     chmod 0664 /dev/cpuctl/rt/cgroup.procs
@@ -354,6 +360,9 @@ on init
     mkdir /dev/cpuset/foreground
     copy /dev/cpuset/cpus /dev/cpuset/foreground/cpus
     copy /dev/cpuset/mems /dev/cpuset/foreground/mems
+    mkdir /dev/cpuset/foreground_window
+    copy /dev/cpuset/cpus /dev/cpuset/foreground_window/cpus
+    copy /dev/cpuset/mems /dev/cpuset/foreground_window/mems
     mkdir /dev/cpuset/background
     copy /dev/cpuset/cpus /dev/cpuset/background/cpus
     copy /dev/cpuset/mems /dev/cpuset/background/mems
@@ -382,6 +391,7 @@ on init
     # change permissions for all cpusets we'll touch at runtime
     chown system system /dev/cpuset
     chown system system /dev/cpuset/foreground
+    chown system system /dev/cpuset/foreground_window
     chown system system /dev/cpuset/background
     chown system system /dev/cpuset/system-background
     chown system system /dev/cpuset/top-app
@@ -389,6 +399,7 @@ on init
     chown system system /dev/cpuset/camera-daemon
     chown system system /dev/cpuset/tasks
     chown system system /dev/cpuset/foreground/tasks
+    chown system system /dev/cpuset/foreground_window/tasks
     chown system system /dev/cpuset/background/tasks
     chown system system /dev/cpuset/system-background/tasks
     chown system system /dev/cpuset/top-app/tasks
@@ -396,6 +407,7 @@ on init
     chown system system /dev/cpuset/camera-daemon/tasks
     chown system system /dev/cpuset/cgroup.procs
     chown system system /dev/cpuset/foreground/cgroup.procs
+    chown system system /dev/cpuset/foreground_window/cgroup.procs
     chown system system /dev/cpuset/background/cgroup.procs
     chown system system /dev/cpuset/system-background/cgroup.procs
     chown system system /dev/cpuset/top-app/cgroup.procs
@@ -406,6 +418,7 @@ on init
     chmod 0775 /dev/cpuset/system-background
 
     chmod 0664 /dev/cpuset/foreground/tasks
+    chmod 0664 /dev/cpuset/foreground_window/tasks
     chmod 0664 /dev/cpuset/background/tasks
     chmod 0664 /dev/cpuset/system-background/tasks
     chmod 0664 /dev/cpuset/top-app/tasks
@@ -413,6 +426,7 @@ on init
     chmod 0664 /dev/cpuset/tasks
     chmod 0664 /dev/cpuset/camera-daemon/tasks
     chmod 0664 /dev/cpuset/foreground/cgroup.procs
+    chmod 0664 /dev/cpuset/foreground_window/cgroup.procs
     chmod 0664 /dev/cpuset/background/cgroup.procs
     chmod 0664 /dev/cpuset/system-background/cgroup.procs
     chmod 0664 /dev/cpuset/top-app/cgroup.procs

From a726c8c28c1cf40e5095fded49357cf962c250cb Mon Sep 17 00:00:00 2001
From: Rick Yiu <rickyiu@google.com>
Date: Wed, 7 Aug 2024 09:06:19 +0000
Subject: [PATCH 1062/1487] Add a new policy for for foreground of multi-window

Add SP_FOREGROUND_MW.

Bug: 200769420
Test: build pass
Change-Id: I203ebb2cbe0409b7bee8542ad276cd4e96c8eacb
---
 .../include/processgroup/sched_policy.h       |  1 +
 libprocessgroup/sched_policy.cpp              | 31 +++++++++++++------
 2 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/libprocessgroup/include/processgroup/sched_policy.h b/libprocessgroup/include/processgroup/sched_policy.h
index a18847ee7ddd..1b6ea669d71a 100644
--- a/libprocessgroup/include/processgroup/sched_policy.h
+++ b/libprocessgroup/include/processgroup/sched_policy.h
@@ -48,6 +48,7 @@ typedef enum {
     SP_TOP_APP = 5,
     SP_RT_APP = 6,
     SP_RESTRICTED = 7,
+    SP_FOREGROUND_WINDOW = 8,
     SP_CNT,
     SP_MAX = SP_CNT - 1,
     SP_SYSTEM_DEFAULT = SP_FOREGROUND,
diff --git a/libprocessgroup/sched_policy.cpp b/libprocessgroup/sched_policy.cpp
index 0f2640a0abcd..042bcd24c471 100644
--- a/libprocessgroup/sched_policy.cpp
+++ b/libprocessgroup/sched_policy.cpp
@@ -58,6 +58,8 @@ int set_cpuset_policy(pid_t tid, SchedPolicy policy) {
             return SetTaskProfiles(tid, {"CPUSET_SP_SYSTEM"}, true) ? 0 : -1;
         case SP_RESTRICTED:
             return SetTaskProfiles(tid, {"CPUSET_SP_RESTRICTED"}, true) ? 0 : -1;
+        case SP_FOREGROUND_WINDOW:
+            return SetTaskProfiles(tid, {"CPUSET_SP_FOREGROUND_WINDOW"}, true) ? 0 : -1;
         default:
             break;
     }
@@ -110,6 +112,9 @@ int set_sched_policy(pid_t tid, SchedPolicy policy) {
         case SP_RT_APP:
             SLOGD("RT  tid %d (%s)", tid, thread_name);
             break;
+        case SP_FOREGROUND_WINDOW:
+            SLOGD("WI  tid %d (%s)", tid, thread_name);
+            break;
         default:
             SLOGD("??? tid %d (%s)", tid, thread_name);
             break;
@@ -129,6 +134,8 @@ int set_sched_policy(pid_t tid, SchedPolicy policy) {
             return SetTaskProfiles(tid, {"SCHED_SP_SYSTEM"}, true) ? 0 : -1;
         case SP_RT_APP:
             return SetTaskProfiles(tid, {"SCHED_SP_RT_APP"}, true) ? 0 : -1;
+        case SP_FOREGROUND_WINDOW:
+            return SetTaskProfiles(tid, {"SCHED_SP_FOREGROUND_WINDOW"}, true) ? 0 : -1;
         default:
             return SetTaskProfiles(tid, {"SCHED_SP_DEFAULT"}, true) ? 0 : -1;
     }
@@ -179,6 +186,8 @@ static int get_sched_policy_from_group(const std::string& group, SchedPolicy* po
         *policy = SP_TOP_APP;
     } else if (group == "restricted") {
         *policy = SP_RESTRICTED;
+    } else if (group == "foreground_window") {
+        *policy = SP_FOREGROUND_WINDOW;
     } else {
         errno = ERANGE;
         return -1;
@@ -235,7 +244,7 @@ const char* get_sched_policy_name(SchedPolicy policy) {
     static const char* const kSchedPolicyNames[] = {
             [SP_BACKGROUND] = "bg", [SP_FOREGROUND] = "fg", [SP_SYSTEM] = "  ",
             [SP_AUDIO_APP] = "aa",  [SP_AUDIO_SYS] = "as",  [SP_TOP_APP] = "ta",
-            [SP_RT_APP] = "rt",     [SP_RESTRICTED] = "rs",
+            [SP_RT_APP] = "rt",     [SP_RESTRICTED] = "rs", [SP_FOREGROUND_WINDOW] = "wi",
     };
     static_assert(arraysize(kSchedPolicyNames) == SP_CNT, "missing name");
     if (policy < SP_BACKGROUND || policy >= SP_CNT) {
@@ -249,14 +258,16 @@ const char* get_cpuset_policy_profile_name(SchedPolicy policy) {
      *  cpuset profile array for:
      *  SP_DEFAULT(-1), SP_BACKGROUND(0), SP_FOREGROUND(1),
      *  SP_SYSTEM(2), SP_AUDIO_APP(3), SP_AUDIO_SYS(4),
-     *  SP_TOP_APP(5), SP_RT_APP(6), SP_RESTRICTED(7)
+     *  SP_TOP_APP(5), SP_RT_APP(6), SP_RESTRICTED(7),
+     *  SP_FOREGROUND_WINDOW(8)
      *  index is policy + 1
      *  this need keep in sync with SchedPolicy enum
      */
     static constexpr const char* kCpusetProfiles[SP_CNT + 1] = {
-            "CPUSET_SP_DEFAULT", "CPUSET_SP_BACKGROUND", "CPUSET_SP_FOREGROUND",
-            "CPUSET_SP_SYSTEM",  "CPUSET_SP_FOREGROUND", "CPUSET_SP_FOREGROUND",
-            "CPUSET_SP_TOP_APP", "CPUSET_SP_DEFAULT",    "CPUSET_SP_RESTRICTED"};
+            "CPUSET_SP_DEFAULT",      "CPUSET_SP_BACKGROUND", "CPUSET_SP_FOREGROUND",
+            "CPUSET_SP_SYSTEM",       "CPUSET_SP_FOREGROUND", "CPUSET_SP_FOREGROUND",
+            "CPUSET_SP_TOP_APP",      "CPUSET_SP_DEFAULT",    "CPUSET_SP_RESTRICTED",
+            "CPUSET_SP_FOREGROUND_WINDOW"};
     if (policy < SP_DEFAULT || policy >= SP_CNT) {
         return nullptr;
     }
@@ -268,14 +279,16 @@ const char* get_sched_policy_profile_name(SchedPolicy policy) {
      *  sched profile array for:
      *  SP_DEFAULT(-1), SP_BACKGROUND(0), SP_FOREGROUND(1),
      *  SP_SYSTEM(2), SP_AUDIO_APP(3), SP_AUDIO_SYS(4),
-     *  SP_TOP_APP(5), SP_RT_APP(6), SP_RESTRICTED(7)
+     *  SP_TOP_APP(5), SP_RT_APP(6), SP_RESTRICTED(7),
+     *  SP_FOREGROUND_WINDOW(8)
      *  index is policy + 1
      *  this need keep in sync with SchedPolicy enum
      */
     static constexpr const char* kSchedProfiles[SP_CNT + 1] = {
-            "SCHED_SP_DEFAULT", "SCHED_SP_BACKGROUND", "SCHED_SP_FOREGROUND",
-            "SCHED_SP_SYSTEM",  "SCHED_SP_FOREGROUND", "SCHED_SP_FOREGROUND",
-            "SCHED_SP_TOP_APP", "SCHED_SP_RT_APP",     "SCHED_SP_DEFAULT"};
+            "SCHED_SP_DEFAULT",      "SCHED_SP_BACKGROUND", "SCHED_SP_FOREGROUND",
+            "SCHED_SP_SYSTEM",       "SCHED_SP_FOREGROUND", "SCHED_SP_FOREGROUND",
+            "SCHED_SP_TOP_APP",      "SCHED_SP_RT_APP",     "SCHED_SP_DEFAULT",
+            "SCHED_SP_FOREGROUND_WINDOW"};
     if (policy < SP_DEFAULT || policy >= SP_CNT) {
         return nullptr;
     }

From 560cb93d9ea6b720c615f33d09d2171ff71f6266 Mon Sep 17 00:00:00 2001
From: Nelson Li <nelsonli@google.com>
Date: Wed, 14 Aug 2024 15:29:36 +0800
Subject: [PATCH 1063/1487] Convert ramdisk_node_list to Android.bp
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`ramdisk_node_list` is a hardcoded dependency in
`build/make/core/Makefile`, but it only serves as an input for
generating `ramdisk.img` and isn't installed on the device.

Therefore, we can directly use a `filegroup` and set
`export_to_make_var` for use in build/make/core/Makefile.

In addition, since there are no `Android.mk` files in the
subdirectories of `system/core/rootdir/`,
`include (callall−makefiles−under,(LOCAL_PATH))` can also be
deleted.

Bug: 359423289
Test: m -j $(PRODUCT_OUT)/ramdisk.img
Change-Id: Ia2bf636bfd7917bf7044d9726b4b52932bb161c8
---
 rootdir/Android.bp |  6 ++++++
 rootdir/Android.mk | 14 --------------
 2 files changed, 6 insertions(+), 14 deletions(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 1e7b48b3112d..5f0a2c327a14 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -189,3 +189,9 @@ prebuilt_root {
         (default, default): [],
     }),
 }
+
+filegroup {
+    name: "ramdisk_node_list",
+    srcs: ["ramdisk_node_list"],
+    export_to_make_var: "RAMDISK_NODE_LIST",
+}
diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index e743743bd832..f866e9bd4cce 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -151,17 +151,3 @@ init.environ.rc-soong := $(call intermediates-dir-for,ETC,init.environ.rc-soong)
 $(eval $(call copy-one-file,$(init.environ.rc-soong),$(LOCAL_BUILT_MODULE)))
 init.environ.rc-soong :=
 
-#######################################
-# ramdisk_node_list
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := ramdisk_node_list
-LOCAL_MODULE_CLASS := ETC
-LOCAL_SRC_FILES := $(LOCAL_MODULE)
-LOCAL_MODULE_PATH := $(PRODUCT_OUT)
-
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-include $(BUILD_PREBUILT)
-
-include $(call all-makefiles-under,$(LOCAL_PATH))

From 344c4c071ca3e8faef7ecd5b057fe89fcfec3e23 Mon Sep 17 00:00:00 2001
From: Tim Van Patten <timvp@google.com>
Date: Thu, 15 Aug 2024 16:19:05 -0600
Subject: [PATCH 1064/1487] Add AID for CrOS EC

Add AID for CrOS EC. The AID will be used to update the file access
permissions for /dev/cros_ec. This file is accessed by various
tools/daemons/services that interact with the Embedded Controller via
the linux kernel ChromeOS Embedded Controller (cros_ec) driver.

Bug: 349695348
Test: $ adb shell id -u cros_ec
Test: $ adb shell id -g cros_ec
Change-Id: I6baca9d2b63c45823ed5529bf27b904bf67edf8b
---
 libcutils/include/private/android_filesystem_config.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libcutils/include/private/android_filesystem_config.h b/libcutils/include/private/android_filesystem_config.h
index ea61cc2a7407..eeb0394172b2 100644
--- a/libcutils/include/private/android_filesystem_config.h
+++ b/libcutils/include/private/android_filesystem_config.h
@@ -142,6 +142,7 @@
 #define AID_SECURITY_LOG_WRITER 1091 /* write to security log */
 #define AID_PRNG_SEEDER 1092         /* PRNG seeder daemon */
 #define AID_UPROBESTATS 1093         /* uid for uprobestats */
+#define AID_CROS_EC 1094             /* uid for accessing ChromeOS EC (cros_ec) */
 /* Changes to this file must be made in AOSP, *not* in internal branches. */
 
 #define AID_SHELL 2000 /* adb and debug shell user */

From 148f602f2388dde03b06c59a491c527ba7e46017 Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Mon, 19 Aug 2024 14:29:04 +0900
Subject: [PATCH 1065/1487] init: clean up unused Service[List]::post_data

post_data was used by Userspace Reboot, which was removed.

Bug: 293377020
Test: atest CtsInitTestCases
Change-Id: I1a5bf328f62b8afbe58eef62c64689471e6b018c
---
 init/README.md        | 2 +-
 init/builtins.cpp     | 3 +--
 init/service.cpp      | 2 --
 init/service.h        | 4 ----
 init/service_list.cpp | 8 --------
 init/service_list.h   | 5 -----
 rootdir/init.rc       | 2 --
 7 files changed, 2 insertions(+), 24 deletions(-)

diff --git a/init/README.md b/init/README.md
index 0bb26e891d69..1e1576514a2f 100644
--- a/init/README.md
+++ b/init/README.md
@@ -636,7 +636,7 @@ provides the `aidl_lazy_test_1` interface.
   Properties are expanded within _level_.
 
 `mark_post_data`
-> Used to mark the point right after /data is mounted.
+> (This action is deprecated and no-op.)
 
 `mkdir <path> [<mode>] [<owner>] [<group>] [encryption=<action>] [key=<key>]`
 > Create a directory at _path_, optionally with the given mode, owner, and
diff --git a/init/builtins.cpp b/init/builtins.cpp
index 1e81692e7a45..3f3bec6df904 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -1171,8 +1171,7 @@ static Result<void> do_init_user0(const BuiltinArguments& args) {
 }
 
 static Result<void> do_mark_post_data(const BuiltinArguments& args) {
-    ServiceList::GetInstance().MarkPostData();
-
+    LOG(INFO) << "deprecated action `mark_post_data` called.";
     return {};
 }
 
diff --git a/init/service.cpp b/init/service.cpp
index 31308a0363a0..d76a5d5e0d3c 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -653,8 +653,6 @@ Result<void> Service::Start() {
         SetMountNamespace();
     }
 
-    post_data_ = ServiceList::GetInstance().IsPostData();
-
     LOG(INFO) << "starting service '" << name_ << "'...";
 
     std::vector<Descriptor> descriptors;
diff --git a/init/service.h b/init/service.h
index 5e9af25db64c..ae75553d3213 100644
--- a/init/service.h
+++ b/init/service.h
@@ -144,8 +144,6 @@ class Service {
     std::optional<std::chrono::seconds> timeout_period() const { return timeout_period_; }
     const std::vector<std::string>& args() const { return args_; }
     bool is_updatable() const { return updatable_; }
-    bool is_post_data() const { return post_data_; }
-    bool is_from_apex() const { return base::StartsWith(filename_, "/apex/"); }
     void set_oneshot(bool value) {
         if (value) {
             flags_ |= SVC_ONESHOT;
@@ -244,8 +242,6 @@ class Service {
 
     std::optional<MountNamespace> mount_namespace_;
 
-    bool post_data_ = false;
-
     std::optional<std::string> on_failure_reboot_target_;
 
     std::string filename_;
diff --git a/init/service_list.cpp b/init/service_list.cpp
index 1c56e8a596c7..e6cc2c98f546 100644
--- a/init/service_list.cpp
+++ b/init/service_list.cpp
@@ -68,14 +68,6 @@ void ServiceList::DumpState() const {
     }
 }
 
-void ServiceList::MarkPostData() {
-    post_data_ = true;
-}
-
-bool ServiceList::IsPostData() {
-    return post_data_;
-}
-
 void ServiceList::StartDelayedServices() {
     for (const auto& name : delayed_service_names_) {
         Service* service = FindService(name);
diff --git a/init/service_list.h b/init/service_list.h
index 44e84535cdab..fd7fc05cdeba 100644
--- a/init/service_list.h
+++ b/init/service_list.h
@@ -83,19 +83,14 @@ class ServiceList {
     auto end() const { return services_.end(); }
     const std::vector<Service*> services_in_shutdown_order() const;
 
-    void MarkPostData();
-    bool IsPostData();
     void DelayService(const Service& service);
     void StartDelayedServices();
 
-    void ResetState() { post_data_ = false; }
-
     auto size() const { return services_.size(); }
 
   private:
     std::vector<std::unique_ptr<Service>> services_;
 
-    bool post_data_ = false;
     std::vector<std::string> delayed_service_names_;
 };
 
diff --git a/rootdir/init.rc b/rootdir/init.rc
index b967831585a2..7b2b96a7d4c2 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -696,8 +696,6 @@ on property:ro.product.cpu.abilist64=* && property:bootreceiver.enable=1
 
 on post-fs-data
 
-    mark_post_data
-
     # Start checkpoint before we touch data
     exec - system system -- /system/bin/vdc checkpoint prepareCheckpoint
 

From 4c6edd3c8f027d45441cd135e3f1129e8b3b12b1 Mon Sep 17 00:00:00 2001
From: Julien Desprez <jdesprez@google.com>
Date: Mon, 19 Aug 2024 16:12:44 +0000
Subject: [PATCH 1066/1487] Reland aosp/3144167: Migrate vts_libsnapshot_test
 and friends to general-tests zip

for things that works in VTS, they should be buildable in general-tests
zip rather than device-tests. Which is cheaper in term of build resources.

The underlying issue should have been fixed in b/349278999

Change-Id: I611db1d60bd5b29f42f3404ed8b313024aca39ce
Test: presubmit
Bug: 358400696
---
 fs_mgr/libsnapshot/Android.bp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index cc6db358b098..f297125c60be 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -294,7 +294,7 @@ cc_test {
     ],
     test_suites: [
         "vts",
-        "device-tests",
+        "general-tests",
     ],
     test_options: {
         min_shipping_api_level: 30,
@@ -311,7 +311,7 @@ cc_test {
         "-DLIBSNAPSHOT_TEST_VAB_LEGACY",
     ],
     test_suites: [
-        "device-tests",
+        "general-tests",
     ],
     test_options: {
         // Legacy VAB launched in Android R.
@@ -420,7 +420,7 @@ cc_test {
         "libstorage_literals_headers",
     ],
     test_suites: [
-        "device-tests",
+        "general-tests",
     ],
     test_options: {
         min_shipping_api_level: 30,

From deb1de9dc60d84341484deb2f2cc982accd9dbea Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 7 Aug 2024 10:35:50 -0700
Subject: [PATCH 1067/1487] snapuserd_test: skip test if dm-user kernel driver
 is absent

Bug: 357487459
Test: snapuserd_test
Signed-off-by: Akilesh Kailash <akailash@google.com>
(cherry picked from https://android-review.googlesource.com/q/commit:a880e5675b747b9f3d5631b656e0a7408edc6ad7)
Merged-In: I8458f223fc35fcfa042588e67a30c5bb273b0277
Change-Id: I8458f223fc35fcfa042588e67a30c5bb273b0277
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |  4 ++
 .../user-space-merge/snapuserd_test.cpp       |  8 ++++
 fs_mgr/libsnapshot/snapuserd/utility.cpp      | 37 +++++++++++++++++++
 fs_mgr/libsnapshot/snapuserd/utility.h        |  5 +++
 4 files changed, 54 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index b3a7e8cf1eb4..efbcb5a4e174 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -267,6 +267,10 @@ cc_test {
     test_suites: [
         "vts",
     ],
+    test_options: {
+        // VABC mandatory in Android T per VSR.
+        min_shipping_api_level: 32,
+    },
 }
 
 cc_binary_host {
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 6d0ae3d0988f..271090fa581a 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -1528,6 +1528,14 @@ INSTANTIATE_TEST_SUITE_P(Io, HandlerTest, ::testing::ValuesIn(GetTestConfigs()))
 int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
+#ifdef __ANDROID__
+    if (!android::snapshot::CanUseUserspaceSnapshots() ||
+        android::snapshot::IsVendorFromAndroid12()) {
+        std::cerr << "snapuserd_test not supported on this device\n";
+        return 0;
+    }
+#endif
+
     gflags::ParseCommandLineFlags(&argc, &argv, false);
 
     return RUN_ALL_TESTS();
diff --git a/fs_mgr/libsnapshot/snapuserd/utility.cpp b/fs_mgr/libsnapshot/snapuserd/utility.cpp
index 684ca3d7ba9b..b44f5abd2355 100644
--- a/fs_mgr/libsnapshot/snapuserd/utility.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/utility.cpp
@@ -14,11 +14,14 @@
 
 #include "utility.h"
 
+#include <android-base/properties.h>
 #include <sys/resource.h>
 #include <sys/utsname.h>
 #include <unistd.h>
 
 #include <android-base/file.h>
+#include <android-base/logging.h>
+#include <libdm/dm.h>
 #include <processgroup/processgroup.h>
 
 #include <private/android_filesystem_config.h>
@@ -27,6 +30,7 @@ namespace android {
 namespace snapshot {
 
 using android::base::unique_fd;
+using android::dm::DeviceMapper;
 
 bool SetThreadPriority([[maybe_unused]] int priority) {
 #ifdef __ANDROID__
@@ -61,5 +65,38 @@ bool KernelSupportsIoUring() {
     return major > 5 || (major == 5 && minor >= 6);
 }
 
+bool GetUserspaceSnapshotsEnabledProperty() {
+    return android::base::GetBoolProperty("ro.virtual_ab.userspace.snapshots.enabled", false);
+}
+
+bool KernelSupportsCompressedSnapshots() {
+    auto& dm = DeviceMapper::Instance();
+    return dm.GetTargetByName("user", nullptr);
+}
+
+bool IsVendorFromAndroid12() {
+    const std::string UNKNOWN = "unknown";
+    const std::string vendor_release =
+            android::base::GetProperty("ro.vendor.build.version.release_or_codename", UNKNOWN);
+
+    if (vendor_release.find("12") != std::string::npos) {
+        return true;
+    }
+    return false;
+}
+
+bool CanUseUserspaceSnapshots() {
+    if (!GetUserspaceSnapshotsEnabledProperty()) {
+        LOG(INFO) << "Virtual A/B - Userspace snapshots disabled";
+        return false;
+    }
+
+    if (!KernelSupportsCompressedSnapshots()) {
+        LOG(ERROR) << "Userspace snapshots requested, but no kernel support is available.";
+        return false;
+    }
+    return true;
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/utility.h b/fs_mgr/libsnapshot/snapuserd/utility.h
index c3c3cbae913d..50be4183708c 100644
--- a/fs_mgr/libsnapshot/snapuserd/utility.h
+++ b/fs_mgr/libsnapshot/snapuserd/utility.h
@@ -24,5 +24,10 @@ bool SetThreadPriority(int priority);
 bool SetProfiles(std::initializer_list<std::string_view> profiles);
 bool KernelSupportsIoUring();
 
+bool GetUserspaceSnapshotsEnabledProperty();
+bool KernelSupportsCompressedSnapshots();
+bool CanUseUserspaceSnapshots();
+bool IsVendorFromAndroid12();
+
 }  // namespace snapshot
 }  // namespace android

From 205bb15e866a12d823b80c364bbf7c101701e64f Mon Sep 17 00:00:00 2001
From: Jordan R Abrahams-Whitehead <ajordanr@google.com>
Date: Fri, 9 Aug 2024 20:12:24 +0000
Subject: [PATCH 1068/1487] Add cpu-target-features binary

This is a very small executable which is used to determine what CPU
target features are enabled for a given compiler toolchain. The actual
source code is in bionic.

Bug: 354747380
Test: Installed on to cuttlefish and ran for x86_64

Change-Id: I348060054ae4427d1ae903a384340413fe714c4c
---
 shell_and_utilities/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/shell_and_utilities/Android.bp b/shell_and_utilities/Android.bp
index d85f6edb34a2..d5893de63d37 100644
--- a/shell_and_utilities/Android.bp
+++ b/shell_and_utilities/Android.bp
@@ -18,6 +18,7 @@ phony {
         "awk",
         "bc",
         "bzip2",
+        "cpu-target-features",
         "fsck.exfat",
         "ldd",
         "logwrapper",

From e3e7bc7d90eae872ba5f91579f76a3794a5055e2 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Fri, 26 Apr 2024 09:38:50 -0700
Subject: [PATCH 1069/1487] [MTE] write stack history into tombstone

We will change the symbolizer to use this information to output
something like:

Potentially referenced stack object:
  0 bytes inside a stack variable "variableName" in stack frame of function functionName
  at source.cc:1234

Bug: 309446520
Change-Id: I1163ac81ac6b5e184387eb9e058d97a7227e3671
---
 debuggerd/Android.bp                          |   1 +
 debuggerd/crash_dump.cpp                      |   9 +
 .../include/libdebuggerd/tombstone.h          |   5 +-
 .../libdebuggerd/include/libdebuggerd/types.h |   3 +
 .../test/mte_stack_record_test.cpp            | 157 ++++++++++++++++++
 .../test/tombstone_proto_to_text_test.cpp     |  28 ++++
 debuggerd/libdebuggerd/tombstone_proto.cpp    | 128 +++++++++++++-
 .../libdebuggerd/tombstone_proto_to_text.cpp  |  13 ++
 debuggerd/proto/tombstone.proto               |  19 ++-
 9 files changed, 357 insertions(+), 6 deletions(-)
 create mode 100644 debuggerd/libdebuggerd/test/mte_stack_record_test.cpp

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 0c5543ed931d..c365cac523cc 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -359,6 +359,7 @@ cc_test {
         "libdebuggerd/test/dump_memory_test.cpp",
         "libdebuggerd/test/elf_fake.cpp",
         "libdebuggerd/test/log_fake.cpp",
+        "libdebuggerd/test/mte_stack_record_test.cpp",
         "libdebuggerd/test/open_files_list_test.cpp",
         "libdebuggerd/test/tombstone_proto_to_text_test.cpp",
     ],
diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 8dd2b0d7385c..c9235eeff524 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -662,6 +662,15 @@ int main(int argc, char** argv) {
         info.pac_enabled_keys = -1;
       }
 
+#if defined(__aarch64__)
+      struct iovec tls_iov = {
+          &info.tls,
+          sizeof(info.tls),
+      };
+      if (ptrace(PTRACE_GETREGSET, thread, NT_ARM_TLS, reinterpret_cast<void*>(&tls_iov)) == -1) {
+        info.tls = 0;
+      }
+#endif
       if (thread == g_target_thread) {
         // Read the thread's registers along with the rest of the crash info out of the pipe.
         ReadCrashInfo(input_pipe, &siginfo, &info.registers, &process_info, &recoverable_crash);
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
index dfdfabdff19f..074b0957a91c 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
@@ -73,5 +73,8 @@ bool tombstone_proto_to_text(
 
 void fill_in_backtrace_frame(BacktraceFrame* f, const unwindstack::FrameData& frame);
 void set_human_readable_cause(Cause* cause, uint64_t fault_addr);
-
+#if defined(__aarch64__)
+void dump_stack_history(unwindstack::AndroidUnwinder* unwinder, uintptr_t target_tls,
+                        StackHistoryBuffer& shb_ob, bool nounwind = false);
+#endif
 #endif  // _DEBUGGERD_TOMBSTONE_H
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/types.h b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
index c799f2448436..f7fc2a3b7df3 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/types.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/types.h
@@ -41,6 +41,9 @@ struct ThreadInfo {
   siginfo_t* siginfo = nullptr;
 
   std::unique_ptr<unwindstack::Regs> guest_registers;
+#if defined(__aarch64__)
+  uintptr_t tls;  // This is currently used for MTE stack history buffer.
+#endif
 };
 
 // This struct is written into a pipe from inside the crashing process.
diff --git a/debuggerd/libdebuggerd/test/mte_stack_record_test.cpp b/debuggerd/libdebuggerd/test/mte_stack_record_test.cpp
new file mode 100644
index 000000000000..4b788f3b7aed
--- /dev/null
+++ b/debuggerd/libdebuggerd/test/mte_stack_record_test.cpp
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#if defined(__aarch64__)
+
+#include <stdint.h>
+#include <sys/mman.h>
+
+#include <optional>
+
+#include "bionic/mte.h"
+#include "bionic/page.h"
+#include "unwindstack/AndroidUnwinder.h"
+#include "unwindstack/Memory.h"
+
+#include <android-base/test_utils.h>
+#include "gtest/gtest.h"
+
+#include "libdebuggerd/tombstone.h"
+
+struct ScopedUnmap {
+  void* ptr;
+  size_t size;
+  ~ScopedUnmap() { munmap(ptr, size); }
+};
+
+class MteStackHistoryTest : public ::testing::TestWithParam<int> {
+  void SetUp() override {
+#if !defined(__aarch64__)
+    GTEST_SKIP();
+#endif
+    SKIP_WITH_HWASAN;
+    unwinder.emplace();
+    unwindstack::ErrorData E;
+    ASSERT_TRUE(unwinder->Initialize(E));
+  }
+
+ protected:
+  // std::optional so we don't construct it for the SKIP cases.
+  std::optional<unwindstack::AndroidLocalUnwinder> unwinder;
+};
+
+TEST(MteStackHistoryUnwindTest, TestOne) {
+#if !defined(__aarch64__)
+  GTEST_SKIP();
+#endif
+  SKIP_WITH_HWASAN;
+  size_t size = stack_mte_ringbuffer_size(0);
+  char* data = static_cast<char*>(stack_mte_ringbuffer_allocate(0, nullptr));
+  ScopedUnmap s{data, size};
+
+  uintptr_t taggedfp = (1ULL << 56) | 1;
+  uintptr_t pc = reinterpret_cast<uintptr_t>(&memcpy);
+  memcpy(data, &pc, sizeof(pc));
+  memcpy(data + 8, &taggedfp, sizeof(taggedfp));
+
+  // The MTE TLS is at TLS - 3, so we allocate 3 placeholders.
+  void* tls[4] = {data + 16};
+
+  unwindstack::AndroidLocalUnwinder unwinder;
+  unwindstack::ErrorData E;
+  unwinder.Initialize(E);
+  StackHistoryBuffer shb;
+  dump_stack_history(&unwinder, reinterpret_cast<uintptr_t>(&tls[3]), shb, /* nounwind= */ false);
+  ASSERT_EQ(shb.entries_size(), 1);
+  const StackHistoryBufferEntry& e = shb.entries(0);
+  EXPECT_EQ(e.addr().pc(), pc);
+  EXPECT_EQ(e.addr().file_name(), "/apex/com.android.runtime/lib64/bionic/libc.so");
+  EXPECT_EQ(e.fp(), 1ULL);
+  EXPECT_EQ(e.tag(), 1ULL);
+}
+
+TEST_P(MteStackHistoryTest, TestEmpty) {
+  int size_cls = GetParam();
+  size_t size = stack_mte_ringbuffer_size(size_cls);
+  void* data = stack_mte_ringbuffer_allocate(size_cls, nullptr);
+  ScopedUnmap s{data, size};
+  // The MTE TLS is at TLS - 3, so we allocate 3 placeholders.
+  void* tls[4] = {data};
+
+  StackHistoryBuffer shb;
+  dump_stack_history(&*unwinder, reinterpret_cast<uintptr_t>(&tls[3]), shb, /* nounwind= */ true);
+  EXPECT_EQ(shb.entries_size(), 0);
+}
+
+TEST_P(MteStackHistoryTest, TestFull) {
+  int size_cls = GetParam();
+  size_t size = stack_mte_ringbuffer_size(size_cls);
+  char* data = static_cast<char*>(stack_mte_ringbuffer_allocate(size_cls, nullptr));
+  ScopedUnmap s{data, size};
+  uintptr_t itr = 1;
+  for (char* d = data; d < &data[size]; d += 16) {
+    uintptr_t taggedfp = ((itr & 15) << 56) | itr;
+    uintptr_t pc = itr;
+    memcpy(d, &pc, sizeof(pc));
+    memcpy(d + 8, &taggedfp, sizeof(taggedfp));
+    ++itr;
+  }
+  // The MTE TLS is at TLS - 3, so we allocate 3 placeholders.
+  // Because the buffer is full, and we point at one past the last inserted element,
+  // due to wrap-around we point at the beginning of the buffer.
+  void* tls[4] = {data};
+
+  StackHistoryBuffer shb;
+  dump_stack_history(&*unwinder, reinterpret_cast<uintptr_t>(&tls[3]), shb, /* nounwind= */ true);
+  EXPECT_EQ(static_cast<size_t>(shb.entries_size()), size / 16);
+  for (const auto& entry : shb.entries()) {
+    EXPECT_EQ(entry.addr().pc(), --itr);
+    EXPECT_EQ(entry.addr().pc(), entry.fp());
+    EXPECT_EQ(entry.addr().pc() & 15, entry.tag());
+  }
+}
+
+TEST_P(MteStackHistoryTest, TestHalfFull) {
+  int size_cls = GetParam();
+  size_t size = stack_mte_ringbuffer_size(size_cls);
+  size_t half_size = size / 2;
+
+  char* data = static_cast<char*>(stack_mte_ringbuffer_allocate(size_cls, nullptr));
+  ScopedUnmap s{data, size};
+
+  uintptr_t itr = 1;
+  for (char* d = data; d < &data[half_size]; d += 16) {
+    uintptr_t taggedfp = ((itr & 15) << 56) | itr;
+    uintptr_t pc = itr;
+    memcpy(d, &pc, sizeof(pc));
+    memcpy(d + 8, &taggedfp, sizeof(taggedfp));
+    ++itr;
+  }
+  // The MTE TLS is at TLS - 3, so we allocate 3 placeholders.
+  void* tls[4] = {&data[half_size]};
+
+  StackHistoryBuffer shb;
+  dump_stack_history(&*unwinder, reinterpret_cast<uintptr_t>(&tls[3]), shb, /* nounwind= */ true);
+  EXPECT_EQ(static_cast<size_t>(shb.entries_size()), half_size / 16);
+  for (const auto& entry : shb.entries()) {
+    EXPECT_EQ(entry.addr().pc(), --itr);
+    EXPECT_EQ(entry.addr().pc(), entry.fp());
+    EXPECT_EQ(entry.addr().pc() & 15, entry.tag());
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P(MteStackHistoryTestInstance, MteStackHistoryTest, testing::Range(0, 8));
+
+#endif
diff --git a/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
index a4c08a4503bb..4fd26430187e 100644
--- a/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
+++ b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
@@ -134,3 +134,31 @@ TEST_F(TombstoneProtoToTextTest, crash_detail_bytes) {
   ProtoToString();
   EXPECT_MATCH(text_, R"(CRASH_DETAIL_NAME: 'helloworld\\1\\255\\3')");
 }
+
+TEST_F(TombstoneProtoToTextTest, stack_record) {
+  auto* cause = tombstone_->add_causes();
+  cause->set_human_readable("stack tag-mismatch on thread 123");
+  auto* stack = tombstone_->mutable_stack_history_buffer();
+  stack->set_tid(123);
+  {
+    auto* shb_entry = stack->add_entries();
+    shb_entry->set_fp(0x1);
+    shb_entry->set_tag(0xb);
+    auto* addr = shb_entry->mutable_addr();
+    addr->set_rel_pc(0x567);
+    addr->set_file_name("foo.so");
+    addr->set_build_id("ABC123");
+  }
+  {
+    auto* shb_entry = stack->add_entries();
+    shb_entry->set_fp(0x2);
+    shb_entry->set_tag(0xc);
+    auto* addr = shb_entry->mutable_addr();
+    addr->set_rel_pc(0x678);
+    addr->set_file_name("bar.so");
+  }
+  ProtoToString();
+  EXPECT_MATCH(text_, "stack tag-mismatch on thread 123");
+  EXPECT_MATCH(text_, "stack_record fp:0x1 tag:0xb pc:foo\\.so\\+0x567 \\(BuildId: ABC123\\)");
+  EXPECT_MATCH(text_, "stack_record fp:0x2 tag:0xc pc:bar\\.so\\+0x678");
+}
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index 3e8ab6ea5c81..b6fc4e2dc679 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -27,6 +27,7 @@
 #include <inttypes.h>
 #include <signal.h>
 #include <stddef.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
@@ -49,9 +50,11 @@
 
 #include <android/log.h>
 #include <android/set_abort_message.h>
+#include <bionic/crash_detail_internal.h>
 #include <bionic/macros.h>
+#include <bionic/mte.h>
 #include <bionic/reserved_signals.h>
-#include <bionic/crash_detail_internal.h>
+#include <bionic/tls_defines.h>
 #include <log/log.h>
 #include <log/log_read.h>
 #include <log/logprint.h>
@@ -202,8 +205,117 @@ void set_human_readable_cause(Cause* cause, uint64_t fault_addr) {
       error_type_str, diff, byte_suffix, location_str, heap_object.size(), heap_object.address()));
 }
 
+#if defined(__aarch64__)
+void dump_stack_history(unwindstack::AndroidUnwinder* unwinder, uintptr_t target_tls,
+                        StackHistoryBuffer& shb_obj, bool nounwind) {
+  auto process_memory = unwinder->GetProcessMemory();
+  target_tls += sizeof(void*) * TLS_SLOT_STACK_MTE;
+  uintptr_t stack_mte;
+  if (!process_memory->ReadFully(target_tls, &stack_mte, sizeof(stack_mte))) {
+    async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG,
+                          "dump_stack_history: failed to read TLS_SLOT_STACK_MTE: %m");
+    return;
+  }
+  if (stack_mte == 0) {
+    async_safe_format_log(ANDROID_LOG_DEBUG, LOG_TAG,
+                          "dump_stack_history: stack history buffer is null");
+    return;
+  }
+  uintptr_t untagged_stack_mte = untag_address(stack_mte);
+  uintptr_t buf_size = stack_mte_ringbuffer_size_from_pointer(stack_mte);
+  if (buf_size == 0) {
+    async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG, "dump_stack_history: empty size");
+    return;
+  }
+  uintptr_t buf_start = untagged_stack_mte & ~(buf_size - 1ULL);
+  std::vector<char> buf(buf_size);
+  if (!process_memory->ReadFully(buf_start, buf.data(), buf.size())) {
+    async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG,
+                          "dump_stack_history: failed to read stack history: %m");
+    return;
+  }
+  uintptr_t original_off = untagged_stack_mte - buf_start;
+  if (original_off % 16 || original_off > buf_size) {
+    async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG,
+                          "dump_stack_history: invalid offset: %" PRIuPTR, original_off);
+    return;
+  }
+
+  // The original_off is the next slot that would have been written, so the last
+  // slot that was written is the previous one.
+  for (uintptr_t idx = 16; idx <= buf_size; idx += 16) {
+    int64_t off = original_off - idx;
+    if (off < 0) off += buf_size;
+    uintptr_t pc, taggedfp;
+    memcpy(&pc, &(buf[off]), sizeof(pc));
+    memcpy(&taggedfp, &(buf[off + sizeof(pc)]), sizeof(taggedfp));
+
+    if (pc == 0) break;
+    uintptr_t fp = untag_address(taggedfp);
+    uintptr_t tag = taggedfp >> 56;
+
+    unwindstack::FrameData frame_data;
+
+    if (nounwind) {
+      frame_data.pc = pc;
+    } else {
+      // +4 is to counteract the "pc adjustment" in BuildFrameFromPcOnly.
+      // BuildFrameFromPcOnly assumes we are unwinding, so it needs to correct for that
+      // the PC is the return address. That is not the case here.
+      // It doesn't really matter, because either should be in the correct function, but
+      // this is more correct (and consistent with the nounwind case).
+      frame_data = unwinder->BuildFrameFromPcOnly(pc);
+      frame_data.pc += 4;
+      frame_data.rel_pc += 4;
+    }
+
+    StackHistoryBufferEntry* entry = shb_obj.add_entries();
+    fill_in_backtrace_frame(entry->mutable_addr(), frame_data);
+    entry->set_fp(fp);
+    entry->set_tag(tag);
+  }
+}
+
+static pid_t get_containing_thread(unwindstack::MapInfo* map_info, pid_t main_tid) {
+  if (map_info == nullptr) return 0;
+
+  std::string name = map_info->name();
+  if (name == "[stack]") {
+    return main_tid;
+  }
+  int tid;
+  if (sscanf(name.c_str(), "[anon:stack_and_tls:%d", &tid) != 1) {
+    return 0;
+  }
+  return tid;
+}
+
+static std::optional<std::string> maybe_stack_mte_cause(
+    Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder, const ThreadInfo& target_thread,
+    [[maybe_unused]] const std::map<pid_t, ThreadInfo>& threads, uint64_t fault_addr) {
+  unwindstack::Maps* maps = unwinder->GetMaps();
+  auto map_info = maps->Find(untag_address(fault_addr));
+  pid_t tid = get_containing_thread(map_info.get(), target_thread.tid);
+  if (!tid) {
+    return std::nullopt;
+  }
+  auto it = threads.find(tid);
+  if (it != threads.end()) {
+    StackHistoryBuffer* shb = tombstone->mutable_stack_history_buffer();
+    shb->set_tid(tid);
+    dump_stack_history(unwinder, it->second.tls, *shb);
+  } else {
+    async_safe_format_log(ANDROID_LOG_ERROR, LOG_TAG,
+                          "dump_probable_cause: unknown target thread %d", tid);
+  }
+  return StringPrintf("stack tag-mismatch on thread %u", tid);
+}
+
+#endif
+
 static void dump_probable_cause(Tombstone* tombstone, unwindstack::AndroidUnwinder* unwinder,
-                                const ProcessInfo& process_info, const ThreadInfo& target_thread) {
+                                const ProcessInfo& process_info, const ThreadInfo& target_thread,
+                                [[maybe_unused]] const std::map<pid_t, ThreadInfo>& threads) {
 #if defined(USE_SCUDO)
   ScudoCrashData scudo_crash_data(unwinder->GetProcessMemory().get(), process_info);
   if (scudo_crash_data.CrashIsMine()) {
@@ -247,7 +359,15 @@ static void dump_probable_cause(Tombstone* tombstone, unwindstack::AndroidUnwind
     } else {
       cause = get_stack_overflow_cause(fault_addr, target_thread.registers->sp(), maps);
     }
-  } else if (si->si_signo == SIGSYS && si->si_code == SYS_SECCOMP) {
+  }
+#if defined(__aarch64__) && defined(SEGV_MTESERR)
+  else if (si->si_signo == SIGSEGV && si->si_code == SEGV_MTESERR) {
+    // If this was a heap MTE crash, it would have been handled by scudo. Checking whether it
+    // is a stack one.
+    cause = maybe_stack_mte_cause(tombstone, unwinder, target_thread, threads, fault_addr);
+  }
+#endif
+  else if (si->si_signo == SIGSYS && si->si_code == SYS_SECCOMP) {
     cause = StringPrintf("seccomp prevented call to disallowed %s system call %d", ABI_STRING,
                          si->si_syscall);
   }
@@ -787,7 +907,7 @@ void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder*
     }
   }
 
-  dump_probable_cause(&result, unwinder, process_info, target_thread);
+  dump_probable_cause(&result, unwinder, process_info, target_thread, threads);
 
   dump_mappings(&result, unwinder->GetMaps(), unwinder->GetProcessMemory());
 
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index 19007194e79e..c3f94700f43b 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -511,6 +511,19 @@ static void print_main_thread(CallbackType callback, const Tombstone& tombstone,
         "order of likelihood.");
   }
 
+  if (tombstone.has_stack_history_buffer()) {
+    for (const StackHistoryBufferEntry& shbe : tombstone.stack_history_buffer().entries()) {
+      std::string stack_record_str = StringPrintf(
+          "stack_record fp:0x%" PRIx64 " tag:0x%" PRIx64 " pc:%s+0x%" PRIx64, shbe.fp(), shbe.tag(),
+          shbe.addr().file_name().c_str(), shbe.addr().rel_pc());
+      if (!shbe.addr().build_id().empty()) {
+        StringAppendF(&stack_record_str, " (BuildId: %s)", shbe.addr().build_id().c_str());
+      }
+
+      CBL("%s", stack_record_str.c_str());
+    }
+  }
+
   for (const Cause& cause : tombstone.causes()) {
     if (tombstone.causes_size() > 1) {
       CBS("");
diff --git a/debuggerd/proto/tombstone.proto b/debuggerd/proto/tombstone.proto
index b662d36805aa..444c9732f084 100644
--- a/debuggerd/proto/tombstone.proto
+++ b/debuggerd/proto/tombstone.proto
@@ -22,6 +22,21 @@ message CrashDetail {
   reserved 3 to 999;
 }
 
+message StackHistoryBufferEntry {
+  BacktraceFrame addr = 1;
+  uint64 fp = 2;
+  uint64 tag = 3;
+
+  reserved 4 to 999;
+}
+
+message StackHistoryBuffer {
+  uint64 tid = 1;
+  repeated StackHistoryBufferEntry entries = 2;
+
+  reserved 3 to 999;
+}
+
 message Tombstone {
   Architecture arch = 1;
   Architecture guest_arch = 24;
@@ -53,7 +68,9 @@ message Tombstone {
   uint32 page_size = 22;
   bool has_been_16kb_mode = 23;
 
-  reserved 26 to 999;
+  StackHistoryBuffer stack_history_buffer = 26;
+
+  reserved 27 to 999;
 }
 
 enum Architecture {

From d6790c4bc64bfd7145b8a14b45e9e3f1a3db6c62 Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Wed, 21 Aug 2024 14:15:52 +0900
Subject: [PATCH 1070/1487] init_parser_fuzzer: remove interface checks

CheckInterfaceInheritanceHierarchy() is for host_init_verifier to check
the interface names at buildtime. We don't need to fuzz the host-side
verification code.

Bug: 326827772
Test: run init_parser_fuzzer
Change-Id: Ie01dc2953fd6e69ef3c2cb9caadf7b9964a3d244
---
 init/fuzzer/Android.bp             |  2 -
 init/fuzzer/init_parser_fuzzer.cpp | 61 ------------------------------
 2 files changed, 63 deletions(-)

diff --git a/init/fuzzer/Android.bp b/init/fuzzer/Android.bp
index 5823932d2442..8cfd597d9738 100644
--- a/init/fuzzer/Android.bp
+++ b/init/fuzzer/Android.bp
@@ -30,7 +30,6 @@ cc_defaults {
     shared_libs: [
         "libbase",
         "libfs_mgr",
-        "libhidl-gen-utils",
         "liblog",
         "libprocessgroup",
         "libselinux",
@@ -49,7 +48,6 @@ cc_fuzz {
     srcs: [
         "init_parser_fuzzer.cpp",
     ],
-    shared_libs: ["libhidlmetadata",],
     defaults: [
         "libinit_fuzzer_defaults",
     ],
diff --git a/init/fuzzer/init_parser_fuzzer.cpp b/init/fuzzer/init_parser_fuzzer.cpp
index dc764650a752..21b04f4b391c 100644
--- a/init/fuzzer/init_parser_fuzzer.cpp
+++ b/init/fuzzer/init_parser_fuzzer.cpp
@@ -15,9 +15,7 @@
  */
 
 #include <fuzzer/FuzzedDataProvider.h>
-#include <hidl/metadata.h>
 #include <import_parser.h>
-#include <interface_utils.h>
 #include <rlimit_parser.h>
 
 using namespace android;
@@ -34,7 +32,6 @@ const std::string kValidPaths[] = {
 };
 
 const int32_t kMaxBytes = 256;
-const std::string kValidInterfaces = "android.frameworks.vr.composer@2.0::IVrComposerClient";
 
 class InitParserFuzzer {
   public:
@@ -44,9 +41,6 @@ class InitParserFuzzer {
   private:
     void InvokeParser();
     void InvokeLimitParser();
-    void InvokeInterfaceUtils();
-    InterfaceInheritanceHierarchyMap GenerateHierarchyMap();
-    std::vector<HidlInterfaceMetadata> GenerateInterfaceMetadata();
 
     FuzzedDataProvider fdp_;
 };
@@ -64,60 +58,6 @@ void InitParserFuzzer::InvokeLimitParser() {
     }
 }
 
-std::vector<HidlInterfaceMetadata> InitParserFuzzer::GenerateInterfaceMetadata() {
-    std::vector<HidlInterfaceMetadata> random_interface;
-    for (size_t idx = 0; idx < fdp_.ConsumeIntegral<size_t>(); ++idx) {
-        HidlInterfaceMetadata metadata;
-        metadata.name = fdp_.ConsumeRandomLengthString(kMaxBytes);
-        for (size_t idx1 = 0; idx1 < fdp_.ConsumeIntegral<size_t>(); ++idx1) {
-            metadata.inherited.push_back(fdp_.ConsumeRandomLengthString(kMaxBytes));
-        }
-        random_interface.push_back(metadata);
-    }
-    return random_interface;
-}
-
-InterfaceInheritanceHierarchyMap InitParserFuzzer::GenerateHierarchyMap() {
-    InterfaceInheritanceHierarchyMap result;
-    std::vector<HidlInterfaceMetadata> random_interface;
-    if (fdp_.ConsumeBool()) {
-        random_interface = GenerateInterfaceMetadata();
-    } else {
-        random_interface = HidlInterfaceMetadata::all();
-    }
-
-    for (const HidlInterfaceMetadata& iface : random_interface) {
-        std::set<FQName> inherited_interfaces;
-        for (const std::string& intf : iface.inherited) {
-            FQName fqname;
-            (void)fqname.setTo(intf);
-            inherited_interfaces.insert(fqname);
-        }
-        FQName fqname;
-        (void)fqname.setTo(iface.name);
-        result[fqname] = inherited_interfaces;
-    }
-    return result;
-}
-
-void InitParserFuzzer::InvokeInterfaceUtils() {
-    InterfaceInheritanceHierarchyMap hierarchy_map = GenerateHierarchyMap();
-    SetKnownInterfaces(hierarchy_map);
-    IsKnownInterface(fdp_.ConsumeRandomLengthString(kMaxBytes));
-    std::set<std::string> interface_set;
-    for (size_t idx = 0; idx < fdp_.ConsumeIntegral<size_t>(); ++idx) {
-        auto set_interface_values = fdp_.PickValueInArray<const std::function<void()>>({
-                [&]() {
-                    interface_set.insert(("aidl/" + fdp_.ConsumeRandomLengthString(kMaxBytes)));
-                },
-                [&]() { interface_set.insert(fdp_.ConsumeRandomLengthString(kMaxBytes)); },
-                [&]() { interface_set.insert(kValidInterfaces); },
-        });
-        set_interface_values();
-    }
-    CheckInterfaceInheritanceHierarchy(interface_set, hierarchy_map);
-}
-
 void InitParserFuzzer::InvokeParser() {
     Parser parser;
     std::string name = fdp_.ConsumeBool() ? fdp_.ConsumeRandomLengthString(kMaxBytes) : "import";
@@ -132,7 +72,6 @@ void InitParserFuzzer::Process() {
     while (fdp_.remaining_bytes()) {
         auto invoke_parser_fuzzer = fdp_.PickValueInArray<const std::function<void()>>({
                 [&]() { InvokeParser(); },
-                [&]() { InvokeInterfaceUtils(); },
                 [&]() { InvokeLimitParser(); },
         });
         invoke_parser_fuzzer();

From 95c4242cf6eb67b0ae36aeb3e15325919765e3df Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Wed, 21 Aug 2024 13:57:44 +0900
Subject: [PATCH 1071/1487] host_init_verifier: check interface names directly

Previously, ServiceParser did the check, but only when it's invoked by
host_init_verifier. Host_init_verifier can do it directly, which removes
unnecessary runtime dependencies from init.

Bug: 326827772
Test: host_init_verifier detects wrong HIDL interface names.
Change-Id: I4c8bb0e89a5def7341c48c52af730795a6ee13c0
---
 init/host_init_verifier.cpp | 15 +++++++++++--
 init/interface_utils.cpp    | 42 ++++++++++++++++++-------------------
 init/interface_utils.h      |  2 --
 3 files changed, 34 insertions(+), 25 deletions(-)

diff --git a/init/host_init_verifier.cpp b/init/host_init_verifier.cpp
index f746ab954e3a..52be0a16786b 100644
--- a/init/host_init_verifier.cpp
+++ b/init/host_init_verifier.cpp
@@ -298,8 +298,7 @@ int main(int argc, char** argv) {
     ServiceList& sl = ServiceList::GetInstance();
     Parser parser;
     parser.AddSectionParser("service",
-                            std::make_unique<ServiceParser>(&sl, GetSubcontext(),
-                                                            *interface_inheritance_hierarchy_map));
+                            std::make_unique<ServiceParser>(&sl, GetSubcontext(), std::nullopt));
     parser.AddSectionParser("on", std::make_unique<ActionParser>(&am, GetSubcontext()));
     parser.AddSectionParser("import", std::make_unique<HostImportParser>());
 
@@ -317,11 +316,23 @@ int main(int argc, char** argv) {
             return EXIT_FAILURE;
         }
     }
+
     size_t failures = parser.parse_error_count() + am.CheckAllCommands() + sl.CheckAllCommands();
     if (failures > 0) {
         LOG(ERROR) << "Failed to parse init scripts with " << failures << " error(s).";
         return EXIT_FAILURE;
     }
+
+    for (const auto& service : sl) {
+        if (const auto& result = CheckInterfaceInheritanceHierarchy(
+                    service->interfaces(), *interface_inheritance_hierarchy_map);
+            !result.ok()) {
+            LOG(ERROR) << service->filename() << ": invalid interface in service '"
+                       << service->name() << "': " << result.error();
+            return EXIT_FAILURE;
+        }
+    }
+
     return EXIT_SUCCESS;
 }
 
diff --git a/init/interface_utils.cpp b/init/interface_utils.cpp
index 1b76bba5f80f..84407aa7030f 100644
--- a/init/interface_utils.cpp
+++ b/init/interface_utils.cpp
@@ -39,27 +39,6 @@ std::string FQNamesToString(const std::set<FQName>& fqnames) {
     return android::base::Join(fqname_strings, " ");
 }
 
-}  // namespace
-
-Result<void> CheckInterfaceInheritanceHierarchy(const std::set<std::string>& instances,
-                                                const InterfaceInheritanceHierarchyMap& hierarchy) {
-    std::set<FQName> interface_fqnames;
-    for (const std::string& instance : instances) {
-        // There is insufficient build-time information on AIDL interfaces to check them here
-        // TODO(b/139307527): Rework how services store interfaces to avoid excess string parsing
-        if (base::Split(instance, "/")[0] == "aidl") {
-            continue;
-        }
-
-        FqInstance fqinstance;
-        if (!fqinstance.setTo(instance)) {
-            return Error() << "Unable to parse interface instance '" << instance << "'";
-        }
-        interface_fqnames.insert(fqinstance.getFqName());
-    }
-    return CheckInterfaceInheritanceHierarchy(interface_fqnames, hierarchy);
-}
-
 Result<void> CheckInterfaceInheritanceHierarchy(const std::set<FQName>& interfaces,
                                                 const InterfaceInheritanceHierarchyMap& hierarchy) {
     std::ostringstream error_stream;
@@ -90,6 +69,27 @@ Result<void> CheckInterfaceInheritanceHierarchy(const std::set<FQName>& interfac
     return {};
 }
 
+}  // namespace
+
+Result<void> CheckInterfaceInheritanceHierarchy(const std::set<std::string>& instances,
+                                                const InterfaceInheritanceHierarchyMap& hierarchy) {
+    std::set<FQName> interface_fqnames;
+    for (const std::string& instance : instances) {
+        // There is insufficient build-time information on AIDL interfaces to check them here
+        // TODO(b/139307527): Rework how services store interfaces to avoid excess string parsing
+        if (base::Split(instance, "/")[0] == "aidl") {
+            continue;
+        }
+
+        FqInstance fqinstance;
+        if (!fqinstance.setTo(instance)) {
+            return Error() << "Unable to parse interface instance '" << instance << "'";
+        }
+        interface_fqnames.insert(fqinstance.getFqName());
+    }
+    return CheckInterfaceInheritanceHierarchy(interface_fqnames, hierarchy);
+}
+
 std::optional<std::set<FQName>> known_interfaces;
 
 void SetKnownInterfaces(const InterfaceInheritanceHierarchyMap& hierarchy) {
diff --git a/init/interface_utils.h b/init/interface_utils.h
index 4ca377f64468..214fedae184f 100644
--- a/init/interface_utils.h
+++ b/init/interface_utils.h
@@ -34,8 +34,6 @@ using InterfaceInheritanceHierarchyMap = std::map<android::FQName, std::set<andr
 // interface set. Uses the provided hierarchy data.
 Result<void> CheckInterfaceInheritanceHierarchy(const std::set<std::string>& instances,
                                                 const InterfaceInheritanceHierarchyMap& hierarchy);
-Result<void> CheckInterfaceInheritanceHierarchy(const std::set<android::FQName>& interfaces,
-                                                const InterfaceInheritanceHierarchyMap& hierarchy);
 
 // Saves the set of known interfaces using the provided HIDL interface
 // inheritance hierarchy.

From d51fb54d56ae7628bc29cb0a894ff300cb7230fa Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Wed, 21 Aug 2024 16:25:10 +0900
Subject: [PATCH 1072/1487] init: remove interface checks from init

HIDL interface checks are done by host_init_verifier at build-time.

Bug: 326827772
Test: mmma system/core/init
Change-Id: I18e9590aba614bebfdbc6aa8bca7036821a6c4f3
---
 init/Android.bp                   |  3 +--
 init/host_init_verifier.cpp       |  3 +--
 init/init.cpp                     |  8 +++-----
 init/init_test.cpp                |  9 +++------
 init/reboot_test.cpp              |  3 +--
 init/service_parser.cpp           | 27 ---------------------------
 init/service_parser.h             | 11 ++---------
 init/service_test.cpp             |  3 +--
 init/test_utils/service_utils.cpp |  3 +--
 9 files changed, 13 insertions(+), 57 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index ed1f14820ea6..8f1ca3de1c7a 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -38,7 +38,6 @@ init_common_sources = [
     "capabilities.cpp",
     "epoll.cpp",
     "import_parser.cpp",
-    "interface_utils.cpp",
     "interprocess_fifo.cpp",
     "keychords.cpp",
     "parser.cpp",
@@ -88,6 +87,7 @@ init_device_sources = [
 init_host_sources = [
     "check_builtins.cpp",
     "host_import_parser.cpp",
+    "interface_utils.cpp",
 ]
 
 soong_config_module_type {
@@ -190,7 +190,6 @@ libinit_cc_defaults {
         "libext4_utils",
         "libfs_mgr",
         "libgsi",
-        "libhidl-gen-utils",
         "liblog",
         "liblogwrap",
         "liblp",
diff --git a/init/host_init_verifier.cpp b/init/host_init_verifier.cpp
index 52be0a16786b..287857a5cd5a 100644
--- a/init/host_init_verifier.cpp
+++ b/init/host_init_verifier.cpp
@@ -297,8 +297,7 @@ int main(int argc, char** argv) {
     ActionManager& am = ActionManager::GetInstance();
     ServiceList& sl = ServiceList::GetInstance();
     Parser parser;
-    parser.AddSectionParser("service",
-                            std::make_unique<ServiceParser>(&sl, GetSubcontext(), std::nullopt));
+    parser.AddSectionParser("service", std::make_unique<ServiceParser>(&sl, GetSubcontext()));
     parser.AddSectionParser("on", std::make_unique<ActionParser>(&am, GetSubcontext()));
     parser.AddSectionParser("import", std::make_unique<HostImportParser>());
 
diff --git a/init/init.cpp b/init/init.cpp
index 4878660e191c..6c8089926ae8 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -268,8 +268,8 @@ void DumpState() {
 Parser CreateParser(ActionManager& action_manager, ServiceList& service_list) {
     Parser parser;
 
-    parser.AddSectionParser("service", std::make_unique<ServiceParser>(
-                                               &service_list, GetSubcontext(), std::nullopt));
+    parser.AddSectionParser("service",
+                            std::make_unique<ServiceParser>(&service_list, GetSubcontext()));
     parser.AddSectionParser("on", std::make_unique<ActionParser>(&action_manager, GetSubcontext()));
     parser.AddSectionParser("import", std::make_unique<ImportParser>(&parser));
 
@@ -324,9 +324,7 @@ Parser CreateApexConfigParser(ActionManager& action_manager, ServiceList& servic
         }
     }
 #endif  // RECOVERY
-    parser.AddSectionParser("service",
-                            std::make_unique<ServiceParser>(&service_list, subcontext,
-                            std::nullopt));
+    parser.AddSectionParser("service", std::make_unique<ServiceParser>(&service_list, subcontext));
     parser.AddSectionParser("on", std::make_unique<ActionParser>(&action_manager, subcontext));
 
     return parser;
diff --git a/init/init_test.cpp b/init/init_test.cpp
index 50882737c304..f280de96d1f6 100644
--- a/init/init_test.cpp
+++ b/init/init_test.cpp
@@ -62,8 +62,7 @@ void TestInit(const std::string& init_script_file, const BuiltinFunctionMap& tes
     Action::set_function_map(&test_function_map);
 
     Parser parser;
-    parser.AddSectionParser("service",
-                            std::make_unique<ServiceParser>(service_list, nullptr, std::nullopt));
+    parser.AddSectionParser("service", std::make_unique<ServiceParser>(service_list, nullptr));
     parser.AddSectionParser("on", std::make_unique<ActionParser>(action_manager, nullptr));
     parser.AddSectionParser("import", std::make_unique<ImportParser>(&parser));
 
@@ -625,8 +624,7 @@ service A something
 
     ServiceList service_list;
     Parser parser;
-    parser.AddSectionParser("service",
-                            std::make_unique<ServiceParser>(&service_list, nullptr, std::nullopt));
+    parser.AddSectionParser("service", std::make_unique<ServiceParser>(&service_list, nullptr));
 
     ASSERT_TRUE(parser.ParseConfig(tf.path));
 
@@ -657,8 +655,7 @@ service A something
 
     ServiceList service_list;
     Parser parser;
-    parser.AddSectionParser("service",
-                            std::make_unique<ServiceParser>(&service_list, nullptr, std::nullopt));
+    parser.AddSectionParser("service", std::make_unique<ServiceParser>(&service_list, nullptr));
 
     ASSERT_TRUE(parser.ParseConfig(tf.path));
     ASSERT_EQ(1u, parser.parse_error_count());
diff --git a/init/reboot_test.cpp b/init/reboot_test.cpp
index b3d038d14f74..b7a1cfdb591e 100644
--- a/init/reboot_test.cpp
+++ b/init/reboot_test.cpp
@@ -103,8 +103,7 @@ service $name /system/bin/yes
                                        "$selabel", GetSecurityContext(), false);
     ServiceList& service_list = ServiceList::GetInstance();
     Parser parser;
-    parser.AddSectionParser("service",
-                            std::make_unique<ServiceParser>(&service_list, nullptr, std::nullopt));
+    parser.AddSectionParser("service", std::make_unique<ServiceParser>(&service_list, nullptr));
 
     TemporaryFile tf;
     ASSERT_TRUE(tf.fd != -1);
diff --git a/init/service_parser.cpp b/init/service_parser.cpp
index 6781c7083c1d..e6f3af6177f5 100644
--- a/init/service_parser.cpp
+++ b/init/service_parser.cpp
@@ -27,7 +27,6 @@
 #include <android-base/parseint.h>
 #include <android-base/properties.h>
 #include <android-base/strings.h>
-#include <hidl-util/FQName.h>
 #include <processgroup/processgroup.h>
 #include <system/thread_defs.h>
 
@@ -201,24 +200,6 @@ Result<void> ServiceParser::ParsePriority(std::vector<std::string>&& args) {
 Result<void> ServiceParser::ParseInterface(std::vector<std::string>&& args) {
     const std::string& interface_name = args[1];
     const std::string& instance_name = args[2];
-
-    // AIDL services don't use fully qualified names and instead just use "interface aidl <name>"
-    if (interface_name != "aidl") {
-        FQName fq_name;
-        if (!FQName::parse(interface_name, &fq_name)) {
-            return Error() << "Invalid fully-qualified name for interface '" << interface_name
-                           << "'";
-        }
-
-        if (!fq_name.isFullyQualified()) {
-            return Error() << "Interface name not fully-qualified '" << interface_name << "'";
-        }
-
-        if (fq_name.isValidValueName()) {
-            return Error() << "Interface name must not be a value name '" << interface_name << "'";
-        }
-    }
-
     const std::string fullname = interface_name + "/" + instance_name;
 
     for (const auto& svc : *service_list_) {
@@ -702,14 +683,6 @@ Result<void> ServiceParser::EndSection() {
         }
     }
 
-    if (interface_inheritance_hierarchy_) {
-        if (const auto& check_hierarchy_result = CheckInterfaceInheritanceHierarchy(
-                    service_->interfaces(), *interface_inheritance_hierarchy_);
-            !check_hierarchy_result.ok()) {
-            return Error() << check_hierarchy_result.error();
-        }
-    }
-
     if (SelinuxGetVendorAndroidVersion() >= __ANDROID_API_R__) {
         if ((service_->flags() & SVC_CRITICAL) != 0 && (service_->flags() & SVC_ONESHOT) != 0) {
             return Error() << "service '" << service_->name()
diff --git a/init/service_parser.h b/init/service_parser.h
index 670a5c6cd494..f06cfc47d9f5 100644
--- a/init/service_parser.h
+++ b/init/service_parser.h
@@ -18,7 +18,6 @@
 
 #include <vector>
 
-#include "interface_utils.h"
 #include "parser.h"
 #include "service.h"
 #include "service_list.h"
@@ -29,13 +28,8 @@ namespace init {
 
 class ServiceParser : public SectionParser {
   public:
-    ServiceParser(
-            ServiceList* service_list, Subcontext* subcontext,
-            const std::optional<InterfaceInheritanceHierarchyMap>& interface_inheritance_hierarchy)
-        : service_list_(service_list),
-          subcontext_(subcontext),
-          interface_inheritance_hierarchy_(interface_inheritance_hierarchy),
-          service_(nullptr) {}
+    ServiceParser(ServiceList* service_list, Subcontext* subcontext)
+        : service_list_(service_list), subcontext_(subcontext), service_(nullptr) {}
     Result<void> ParseSection(std::vector<std::string>&& args, const std::string& filename,
                               int line) override;
     Result<void> ParseLineSection(std::vector<std::string>&& args, int line) override;
@@ -88,7 +82,6 @@ class ServiceParser : public SectionParser {
 
     ServiceList* service_list_;
     Subcontext* subcontext_;
-    std::optional<InterfaceInheritanceHierarchyMap> interface_inheritance_hierarchy_;
     std::unique_ptr<Service> service_;
     std::string filename_;
 };
diff --git a/init/service_test.cpp b/init/service_test.cpp
index a3590b5367b9..53b53ed5a332 100644
--- a/init/service_test.cpp
+++ b/init/service_test.cpp
@@ -253,8 +253,7 @@ service $name /system/bin/yes
                                        "$selabel", GetSecurityContext(), false);
     ServiceList& service_list = ServiceList::GetInstance();
     Parser parser;
-    parser.AddSectionParser("service",
-                            std::make_unique<ServiceParser>(&service_list, nullptr, std::nullopt));
+    parser.AddSectionParser("service", std::make_unique<ServiceParser>(&service_list, nullptr));
 
     TemporaryFile tf;
     ASSERT_GE(tf.fd, 0);
diff --git a/init/test_utils/service_utils.cpp b/init/test_utils/service_utils.cpp
index 6426ed9fd800..7002a67d5276 100644
--- a/init/test_utils/service_utils.cpp
+++ b/init/test_utils/service_utils.cpp
@@ -30,8 +30,7 @@ namespace init {
 android::base::Result<ServiceInterfacesMap> GetOnDeviceServiceInterfacesMap() {
     ServiceList& service_list = ServiceList::GetInstance();
     Parser parser;
-    parser.AddSectionParser("service",
-                            std::make_unique<ServiceParser>(&service_list, nullptr, std::nullopt));
+    parser.AddSectionParser("service", std::make_unique<ServiceParser>(&service_list, nullptr));
     for (const auto& location : {
                  "/init.rc",
                  "/system/etc/init",

From 3fa77a15c5149d4e760d79999a9d1c54c1f4eaa5 Mon Sep 17 00:00:00 2001
From: Stephen Crane <cranes@google.com>
Date: Thu, 22 Aug 2024 20:57:56 +0000
Subject: [PATCH 1073/1487] trusty: Add host build for rpmb_dev

Building rpmb_dev as a host tool in soong makes it easy to package for
acloud, rather than building it in the Trusty build system and uploading
that to the remote instance.

Test: m
Bug: 354771029
Change-Id: I3b7f623238957ae3b25524d424025fd08f805657
---
 trusty/utils/rpmb_dev/Android.bp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/utils/rpmb_dev/Android.bp b/trusty/utils/rpmb_dev/Android.bp
index 5e9caafeef11..603a1a80ad4a 100644
--- a/trusty/utils/rpmb_dev/Android.bp
+++ b/trusty/utils/rpmb_dev/Android.bp
@@ -18,12 +18,12 @@ package {
 cc_binary {
     name: "rpmb_dev",
     vendor: true,
+    host_supported: true,
 
     srcs: [
         "rpmb_dev.c",
     ],
     shared_libs: [
-        "libc",
         "libcutils",
         "liblog",
         "libcrypto",

From b47e18a6599a08619455e8b602af492589a6fb5b Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Fri, 23 Aug 2024 00:10:58 +0000
Subject: [PATCH 1074/1487] Standardize page property.

ro.boot.hardware.cpu.pagesize is used on some devices to
report the page size. However, we also know what value this
should be from the CPU. Rather than create a separate property
for this, standardize around this property.

This also allows us to test the value of this property on all
devices.

Bug: 358696947
Test: Vts16KPageSizeTest
Change-Id: I7f6260c68e17e7df8a789e9066a7171f3a56f4b0
---
 init/property_service.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index 0d6eb153300e..208d76f9498c 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -1255,6 +1255,16 @@ void PropertyLoadBootDefaults() {
     update_sys_usb_config();
 }
 
+void PropertyLoadDerivedDefaults() {
+    const char* PAGE_PROP = "ro.boot.hardware.cpu.pagesize";
+    if (GetProperty(PAGE_PROP, "").empty()) {
+        std::string error;
+        if (PropertySetNoSocket(PAGE_PROP, std::to_string(getpagesize()), &error) != PROP_SUCCESS) {
+            LOG(ERROR) << "Could not set '" << PAGE_PROP << "' because: " << error;
+        }
+    }
+}
+
 bool LoadPropertyInfoFromFile(const std::string& filename,
                               std::vector<PropertyInfoEntry>* property_infos) {
     auto file_contents = std::string();
@@ -1425,6 +1435,7 @@ void PropertyInit() {
     ExportKernelBootProps();
 
     PropertyLoadBootDefaults();
+    PropertyLoadDerivedDefaults();
 }
 
 static void HandleInitSocket() {

From 3f11b6ac64d87a9cfe137629912adad0b35754bc Mon Sep 17 00:00:00 2001
From: Julien Desprez <jdesprez@google.com>
Date: Fri, 23 Aug 2024 04:02:09 +0000
Subject: [PATCH 1075/1487] Move snapuserd_test to general-tests

The test should be able to build and run from generic-build.

Change-Id: I380565bbcae53c454fa1cbff655c8c6fe1000097
Test: presubmit
Bug: 358400696
---
 fs_mgr/libsnapshot/snapuserd/Android.bp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index efbcb5a4e174..9e1415612999 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -248,7 +248,7 @@ cc_test {
     defaults: ["snapuserd_test_defaults"],
     host_supported: true,
     test_suites: [
-        "device-tests",
+        "general-tests",
     ],
     test_options: {
         test_runner_options: [

From 1220d17108cb3b4af9c0fb440a9f9e8f5a9fe2a9 Mon Sep 17 00:00:00 2001
From: Nick Kralevich <nnk@google.com>
Date: Thu, 22 Aug 2024 13:56:36 -0700
Subject: [PATCH 1076/1487] init.rc: Fix entropy pool initialization

Init is responsible for initializing the /dev/[u]random entropy
pool, to ensure that high quality random numbers are available
to all Android processes. Previously Android mixed in data
from /system/etc/prop.default, which included properties which
differed on a device-by-device basis. That file no longer exists,
and init generates the following error at boot:

  init: Command 'copy /system/etc/prop.default /dev/urandom'
  action=init (/system/etc/init/hw/init.rc:106) took 0ms and
  failed: Could not read input file '/system/etc/prop.default':
  open() failed: No such file or directory

Instead of reading a property file, this change modifies init.rc
to read from /proc/bootconfig. The bootconfig file contains
per-device data which was previously on the command line, such
as androidboot.serialno. Additionally, it contains device-class
information such as androidboot.hardware,
androidboot.hardware.platform, and data which frequently churns
such as androidboot.vbmeta.digest. These help ensure that the
random number initialization is at least unique on a per
device-class basis.

Relying on /proc/bootconfig accomplishes the same goal that
relying on /system/etc/prop.default was intended to accomplish.
And /proc/bootconfig is in a more stable location than
/system/etc/prop.default, hopefully preventing future regressions.

Bug: 361624398
Test: Device boots and error above goes away
Change-Id: Id5c891e871217d62ff6517c5804b4acc2d723622
---
 rootdir/init.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 7b2b96a7d4c2..63e3d0646586 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -103,7 +103,7 @@ on init
 
     # Mix device-specific information into the entropy pool
     copy /proc/cmdline /dev/urandom
-    copy /system/etc/prop.default /dev/urandom
+    copy /proc/bootconfig /dev/urandom
 
     symlink /proc/self/fd/0 /dev/stdin
     symlink /proc/self/fd/1 /dev/stdout

From 4e96338890663cc6aa3a306f3932b78f5d562b3b Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 26 Aug 2024 12:43:04 +0000
Subject: [PATCH 1077/1487] host_signal_fixup.h: remove unused file.

We don't need this any more because the glibc headers have been updated, but it looks like it wasn't being used anyway.

Change-Id: Ie98ae473af504c49a8cae07fa06ec7f1568f662d
---
 .../libdebuggerd/test/host_signal_fixup.h     | 65 -------------------
 1 file changed, 65 deletions(-)
 delete mode 100644 debuggerd/libdebuggerd/test/host_signal_fixup.h

diff --git a/debuggerd/libdebuggerd/test/host_signal_fixup.h b/debuggerd/libdebuggerd/test/host_signal_fixup.h
deleted file mode 100644
index 762bae5fb504..000000000000
--- a/debuggerd/libdebuggerd/test/host_signal_fixup.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (C) 2015 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.
- */
-
-#ifndef _DEBUGGERD_TEST_HOST_SIGNAL_FIXUP_H
-#define _DEBUGGERD_TEST_HOST_SIGNAL_FIXUP_H
-
-#include <signal.h>
-
-#if !defined(__BIONIC__)
-
-// In order to compile parts of debuggerd for the host, we need to
-// define these values.
-
-#if !defined(NSIGILL)
-#define NSIGILL ILL_BADSTK
-#endif
-
-#if !defined(BUS_MCEERR_AR)
-#define BUS_MCEERR_AR 4
-#endif
-#if !defined(BUS_MCEERR_AO)
-#define BUS_MCEERR_AO 5
-#endif
-#if !defined(NSIGBUS)
-#define NSIGBUS BUS_MCEERR_AO
-#endif
-
-#if !defined(NSIGFPE)
-#define NSIGFPE FPE_FLTSUB
-#endif
-
-#if !defined(NSIGSEGV)
-#define NSIGSEGV SEGV_ACCERR
-#endif
-
-#if !defined(TRAP_BRANCH)
-#define TRAP_BRANCH 3
-#endif
-#if !defined(TRAP_HWBKPT)
-#define TRAP_HWBKPT 4
-#endif
-#if !defined(NSIGTRAP)
-#define NSIGTRAP TRAP_HWBKPT
-#endif
-
-#if !defined(SI_DETHREAD)
-#define SI_DETHREAD (-7)
-#endif
-
-#endif
-
-#endif // _DEBUGGERD_TEST_HOST_SIGNAL_FIXUP_H

From 1e7b7cbc58a2d22fe1e788067cd0a15c93e7b2af Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Mon, 26 Aug 2024 15:30:32 -0700
Subject: [PATCH 1078/1487] Move variable only used on aarch64.

The kTagGranuleSize is only used in aarch64, so you can get
unused variable warnings for other targets. Move this definition
closer to where it's used and in aarch64 code.

Test: Build with unused checking on.
Change-Id: I9baf660430508ee3ca1efb62585ee1b038c6b0f3
---
 debuggerd/debuggerd_test.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 08619b980c33..962097e65d16 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -86,7 +86,6 @@ using ::testing::HasSubstr;
 #define ARCH_SUFFIX ""
 #endif
 
-constexpr size_t kTagGranuleSize = 16;
 constexpr char kWaitForDebuggerKey[] = "debug.debuggerd.wait_for_debugger";
 
 #define TIMEOUT(seconds, expr)                                     \
@@ -742,6 +741,8 @@ TEST_F(CrasherTest, mte_multiple_causes) {
 }
 
 #if defined(__aarch64__)
+constexpr size_t kTagGranuleSize = 16;
+
 static uintptr_t CreateTagMapping() {
   // Some of the MTE tag dump tests assert that there is an inaccessible page to the left and right
   // of the PROT_MTE page, so map three pages and set the two guard pages to PROT_NONE.

From 9b4ad17bfbdf3d0791f58ed6e480e20cf371990a Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Tue, 27 Aug 2024 13:07:58 +0900
Subject: [PATCH 1079/1487] libinit_host: clean up dependencies

libinit_host doesn't need HIDL stuff. host_init_verifier does HIDL
interface checks.

Bug: 326827772
Test: mmma system/core
Change-Id: I59c1444649a62202abb54a2e0cceee38522c1259
---
 init/Android.bp        | 40 ++++++++++++++++++++++++++++------------
 init/noop_builtins.cpp | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 60 insertions(+), 12 deletions(-)
 create mode 100644 init/noop_builtins.cpp

diff --git a/init/Android.bp b/init/Android.bp
index 8f1ca3de1c7a..18a79d6c4285 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -84,11 +84,6 @@ init_device_sources = [
     "ueventd.cpp",
     "ueventd_parser.cpp",
 ]
-init_host_sources = [
-    "check_builtins.cpp",
-    "host_import_parser.cpp",
-    "interface_utils.cpp",
-]
 
 soong_config_module_type {
     name: "libinit_cc_defaults",
@@ -606,8 +601,6 @@ cc_defaults {
     whole_static_libs: ["libcap"],
     shared_libs: [
         "libcutils",
-        "libhidl-gen-utils",
-        "libhidlmetadata",
         "liblog",
         "libprocessgroup",
         "libprotobuf-cpp-lite",
@@ -615,9 +608,6 @@ cc_defaults {
     proto: {
         type: "lite",
     },
-    generated_headers: [
-        "generated_stub_builtin_function_map",
-    ],
     target: {
         android: {
             enabled: false,
@@ -636,17 +626,43 @@ cc_defaults {
 cc_binary {
     name: "host_init_verifier",
     defaults: ["init_host_defaults"],
-    srcs: ["host_init_verifier.cpp"] + init_common_sources + init_host_sources,
+    srcs: [
+        "check_builtins.cpp",
+        "host_import_parser.cpp",
+        "host_init_verifier.cpp",
+        "interface_utils.cpp",
+    ] + init_common_sources,
     generated_headers: [
         "generated_android_ids",
+        "generated_stub_builtin_function_map",
+    ],
+    shared_libs: [
+        "libhidl-gen-utils",
+        "libhidlmetadata",
     ],
 }
 
+genrule {
+    name: "noop_builtin_function_map",
+    tool_files: ["host_builtin_map.py"],
+    out: ["noop_builtin_function_map.h"],
+    srcs: [
+        "builtins.cpp",
+        "noop_builtins.cpp",
+    ],
+    cmd: "$(location host_builtin_map.py) --builtins $(location builtins.cpp) --check_builtins $(location noop_builtins.cpp) > $(out)",
+}
+
 cc_library_host_static {
     name: "libinit_host",
     defaults: ["init_host_defaults"],
-    srcs: init_common_sources + init_host_sources,
+    srcs: [
+        "noop_builtins.cpp",
+    ] + init_common_sources,
     export_include_dirs: ["."],
+    generated_headers: [
+        "noop_builtin_function_map",
+    ],
     proto: {
         export_proto_headers: true,
     },
diff --git a/init/noop_builtins.cpp b/init/noop_builtins.cpp
new file mode 100644
index 000000000000..c4e140be3aa3
--- /dev/null
+++ b/init/noop_builtins.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Note that parser will perform arity checks only.
+
+#include <android-base/result.h>
+
+#include "builtin_arguments.h"
+#include "builtins.h"
+
+namespace android::init {
+
+static base::Result<void> check_stub(const BuiltinArguments&) {
+    return {};
+}
+
+#include "noop_builtin_function_map.h"
+
+}  // namespace android::init

From d96c6b8e881054de1eb38ac87612b975ec4aaf27 Mon Sep 17 00:00:00 2001
From: terryguan <terryguan@google.com>
Date: Fri, 16 Aug 2024 14:27:23 -0700
Subject: [PATCH 1080/1487] Add resume from hibernation in first stage init

If bootconfig hibernation_resume_device is present in boot config, then
we write that value to /sys/power/resume

Bug: 339688542
Test: Check resume from hibernation/boots with/without config present
Change-Id: I1a9bf63af4dab07e494740722898c1aba33c00b5
---
 fs_mgr/libfstab/fstab_priv.h          |  3 ---
 fs_mgr/libfstab/include/fstab/fstab.h |  3 +++
 init/first_stage_init.cpp             | 19 +++++++++++++++++++
 3 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libfstab/fstab_priv.h b/fs_mgr/libfstab/fstab_priv.h
index 5105da001031..73cb1751863f 100644
--- a/fs_mgr/libfstab/fstab_priv.h
+++ b/fs_mgr/libfstab/fstab_priv.h
@@ -39,9 +39,6 @@ std::string GetFstabPath();
 void ImportBootconfigFromString(const std::string& bootconfig,
                                 const std::function<void(std::string, std::string)>& fn);
 
-bool GetBootconfigFromString(const std::string& bootconfig, const std::string& key,
-                             std::string* out);
-
 void ImportKernelCmdlineFromString(const std::string& cmdline,
                                    const std::function<void(std::string, std::string)>& fn);
 
diff --git a/fs_mgr/libfstab/include/fstab/fstab.h b/fs_mgr/libfstab/include/fstab/fstab.h
index 1696daff0f77..21fe01726a9f 100644
--- a/fs_mgr/libfstab/include/fstab/fstab.h
+++ b/fs_mgr/libfstab/include/fstab/fstab.h
@@ -153,5 +153,8 @@ bool GetKernelCmdline(const std::string& key, std::string* out);
 // Return the "other" slot for the given slot suffix.
 std::string OtherSlotSuffix(const std::string& suffix);
 
+bool GetBootconfigFromString(const std::string& bootconfig, const std::string& key,
+                             std::string* out);
+
 }  // namespace fs_mgr
 }  // namespace android
diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index bfe636bbfb37..e06a6459314f 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -38,6 +38,7 @@
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
 #include <android/avf_cc_flags.h>
+#include <fs_mgr.h>
 #include <modprobe/modprobe.h>
 #include <private/android_filesystem_config.h>
 
@@ -303,6 +304,22 @@ static BootMode GetBootMode(const std::string& cmdline, const std::string& bootc
     return BootMode::NORMAL_MODE;
 }
 
+static void MaybeResumeFromHibernation(const std::string& bootconfig) {
+    std::string hibernationResumeDevice;
+    android::fs_mgr::GetBootconfigFromString(bootconfig, "androidboot.hibernation_resume_device",
+                                             &hibernationResumeDevice);
+    if (!hibernationResumeDevice.empty()) {
+        android::base::unique_fd fd(open("/sys/power/resume", O_RDWR | O_CLOEXEC));
+        if (fd >= 0) {
+            if (!android::base::WriteStringToFd(hibernationResumeDevice, fd)) {
+                PLOG(ERROR) << "Failed to write to /sys/power/resume";
+            }
+        } else {
+            PLOG(ERROR) << "Failed to open /sys/power/resume";
+        }
+    }
+}
+
 static std::unique_ptr<FirstStageMount> CreateFirstStageMount(const std::string& cmdline) {
     auto ret = FirstStageMount::Create(cmdline);
     if (ret.ok()) {
@@ -442,6 +459,8 @@ int FirstStageMain(int argc, char** argv) {
                   << module_elapse_time.count() << " ms";
     }
 
+    MaybeResumeFromHibernation(bootconfig);
+
     std::unique_ptr<FirstStageMount> fsm;
 
     bool created_devices = false;

From 715dd707c4c085a6eb79c29e52f32cfb8ce51aeb Mon Sep 17 00:00:00 2001
From: Inseob Kim <inseob@google.com>
Date: Wed, 28 Aug 2024 15:47:33 +0900
Subject: [PATCH 1081/1487] Move adb_keys to product partition

/adb_keys will be moved to /product/etc/security as it's a
product-specific file. To prevent regression, /adb_keys will be a
symlink to the new location.

Bug: 353430323
Test: boot and connect adb with ADB_VENDOR_KEYS
Change-Id: I3dd200a1583be8f99bd5c30ecfed1bdc544ca783
---
 rootdir/Android.mk | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rootdir/Android.mk b/rootdir/Android.mk
index f866e9bd4cce..ac9ca857fc6f 100644
--- a/rootdir/Android.mk
+++ b/rootdir/Android.mk
@@ -35,7 +35,8 @@ LOCAL_POST_INSTALL_CMD := mkdir -p $(addprefix $(TARGET_ROOT_OUT)/, \
     ln -sf /system/etc $(TARGET_ROOT_OUT)/etc; \
     ln -sf /data/user_de/0/com.android.shell/files/bugreports $(TARGET_ROOT_OUT)/bugreports; \
     ln -sfn /sys/kernel/debug $(TARGET_ROOT_OUT)/d; \
-    ln -sf /storage/self/primary $(TARGET_ROOT_OUT)/sdcard
+    ln -sf /storage/self/primary $(TARGET_ROOT_OUT)/sdcard; \
+    ln -sf /product/etc/security/adb_keys $(TARGET_ROOT_OUT)/adb_keys
 
 ALL_ROOTDIR_SYMLINKS := \
   $(TARGET_ROOT_OUT)/bin \
@@ -150,4 +151,3 @@ $(ALL_ROOTDIR_SYMLINKS): $(LOCAL_BUILT_MODULE)
 init.environ.rc-soong := $(call intermediates-dir-for,ETC,init.environ.rc-soong)/init.environ.rc-soong
 $(eval $(call copy-one-file,$(init.environ.rc-soong),$(LOCAL_BUILT_MODULE)))
 init.environ.rc-soong :=
-

From 398203d1da98a2afac10827cc4140f60e525e480 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 13 Mar 2024 14:17:25 -0700
Subject: [PATCH 1082/1487] libsnapshot: Move snapshot metadata to super
 partition.

snapshot metadata files are stored in /metadata. This means, we cannot
wipe after installing any update.

This patch does the following:

1: Create a scratch space in super partition. The scratch space for ota
   metadata is just about 1MB.

2: Create ext4 filesystem on top of scratch block device.

3: Mount the scratch on /mnt/scratch_super

4: When snapshot-manager instance is created, point the /mnt/scratch/ota
to metadata_dir_ so that all the snapshot files are stored in the new
path.

All the logic of OTA remains the same. This flow is enabled only on userdebug builds for now and the only consumer would be snapshotctl

$snapshotctl apply-update /data/nbd/ -w

During init, we would have to mount the scratch partition to detect
if there is any pending updates.

With this, we would now be able to wipe the device along with the update flow. This will help incremental flashing wherein we would end up saving ~35-40 seconds on Pixel devices.

With this flow, the end-to-end update for incremental builds takes
~20-30 seconds.

Bug: 330744468
Test: Pixel 6 incremental flashing with wipe, Full OTA, vts_libsnapshot
Change-Id: Iac6ce2cf37b70ea221cd18175c8962988d03d95b
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fastboot/Android.bp                           |   1 +
 fs_mgr/fs_mgr_priv.h                          |   2 -
 fs_mgr/include/fs_mgr.h                       |   6 +
 fs_mgr/libsnapshot/Android.bp                 |   3 +
 fs_mgr/libsnapshot/device_info.cpp            |  19 +-
 fs_mgr/libsnapshot/device_info.h              |   8 +-
 .../include/libsnapshot/snapshot.h            |   5 +
 .../include_test/libsnapshot/test_helpers.h   |   5 +-
 fs_mgr/libsnapshot/scratch_super.cpp          | 417 ++++++++++++++++++
 fs_mgr/libsnapshot/scratch_super.h            |  33 ++
 fs_mgr/libsnapshot/snapshot.cpp               |  42 +-
 fs_mgr/libsnapshot/snapshot_test.cpp          |  10 +
 fs_mgr/libsnapshot/snapshotctl.cpp            |  64 ++-
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   1 +
 .../snapuserd/snapuserd_client.cpp            |  17 +-
 init/first_stage_mount.cpp                    |   8 +
 16 files changed, 618 insertions(+), 23 deletions(-)
 create mode 100644 fs_mgr/libsnapshot/scratch_super.cpp
 create mode 100644 fs_mgr/libsnapshot/scratch_super.h

diff --git a/fastboot/Android.bp b/fastboot/Android.bp
index 774af284cdac..bfe0768f884e 100644
--- a/fastboot/Android.bp
+++ b/fastboot/Android.bp
@@ -186,6 +186,7 @@ cc_binary {
         "libprotobuf-cpp-lite",
         "libsparse",
         "libutils",
+        "libselinux",
     ],
 
     static_libs: [
diff --git a/fs_mgr/fs_mgr_priv.h b/fs_mgr/fs_mgr_priv.h
index 7e4d5e54db4c..84e4924fba19 100644
--- a/fs_mgr/fs_mgr_priv.h
+++ b/fs_mgr/fs_mgr_priv.h
@@ -80,10 +80,8 @@
 
 using namespace std::chrono_literals;
 
-bool fs_mgr_set_blk_ro(const std::string& blockdev, bool readonly = true);
 bool fs_mgr_is_device_unlocked();
 
-bool fs_mgr_is_ext4(const std::string& blk_device);
 bool fs_mgr_is_f2fs(const std::string& blk_device);
 
 bool fs_mgr_filesystem_available(const std::string& filesystem);
diff --git a/fs_mgr/include/fs_mgr.h b/fs_mgr/include/fs_mgr.h
index af5ae2d168e5..9cfa93f7877b 100644
--- a/fs_mgr/include/fs_mgr.h
+++ b/fs_mgr/include/fs_mgr.h
@@ -104,6 +104,12 @@ int fs_mgr_setup_verity(android::fs_mgr::FstabEntry* fstab, bool wait_for_verity
 // returned. Otherwise, it will use the current slot.
 std::string fs_mgr_get_super_partition_name(int slot = -1);
 
+// Set readonly for the block device
+bool fs_mgr_set_blk_ro(const std::string& blockdev, bool readonly = true);
+
+// Check if the block device has ext4 filesystem
+bool fs_mgr_is_ext4(const std::string& blk_device);
+
 enum FsMgrUmountStatus : int {
     SUCCESS = 0,
     ERROR_UNKNOWN = 1 << 0,
diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index f297125c60be..4828c4c15b5d 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -46,6 +46,7 @@ cc_defaults {
         "libfstab",
         "libsnapuserd_client",
         "libz",
+        "libselinux",
     ],
     header_libs: [
         "libfiemap_headers",
@@ -91,6 +92,7 @@ filegroup {
         "partition_cow_creator.cpp",
         "return.cpp",
         "utility.cpp",
+        "scratch_super.cpp",
     ],
 }
 
@@ -351,6 +353,7 @@ cc_binary {
     ],
     srcs: [
         "snapshotctl.cpp",
+        "scratch_super.cpp",
     ],
     static_libs: [
         "libbrotli",
diff --git a/fs_mgr/libsnapshot/device_info.cpp b/fs_mgr/libsnapshot/device_info.cpp
index e0969f4c7101..19f3e0293a18 100644
--- a/fs_mgr/libsnapshot/device_info.cpp
+++ b/fs_mgr/libsnapshot/device_info.cpp
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "device_info.h"
+#include "scratch_super.h"
 
 #include <android-base/logging.h>
 #include <fs_mgr.h>
@@ -37,8 +38,24 @@ constexpr bool kIsRecovery = true;
 constexpr bool kIsRecovery = false;
 #endif
 
+DeviceInfo::DeviceInfo() {
+    std::string scratch_device = android::snapshot::GetScratchOtaMetadataPartition();
+    if (!scratch_device.empty()) {
+        std::string scratch_metadata =
+                android::snapshot::MapScratchOtaMetadataPartition(scratch_device);
+        if (!scratch_metadata.empty()) {
+            SetMetadataDir(scratch_metadata);
+            SetTempMetadata();
+        }
+    }
+}
+
 std::string DeviceInfo::GetMetadataDir() const {
-    return "/metadata/ota"s;
+    return metadata_dir_;
+}
+
+void DeviceInfo::SetMetadataDir(const std::string& value) {
+    metadata_dir_ = value;
 }
 
 std::string DeviceInfo::GetSlotSuffix() const {
diff --git a/fs_mgr/libsnapshot/device_info.h b/fs_mgr/libsnapshot/device_info.h
index 9153abb018be..e93ec4960d55 100644
--- a/fs_mgr/libsnapshot/device_info.h
+++ b/fs_mgr/libsnapshot/device_info.h
@@ -29,6 +29,7 @@ class DeviceInfo final : public SnapshotManager::IDeviceInfo {
     using MergeStatus = ::aidl::android::hardware::boot::MergeStatus;
 
   public:
+    DeviceInfo();
     std::string GetMetadataDir() const override;
     std::string GetSlotSuffix() const override;
     std::string GetOtherSlotSuffix() const override;
@@ -42,14 +43,19 @@ class DeviceInfo final : public SnapshotManager::IDeviceInfo {
     std::unique_ptr<IImageManager> OpenImageManager() const override;
     bool IsFirstStageInit() const override;
     android::dm::IDeviceMapper& GetDeviceMapper() override;
-
+    void SetMetadataDir(const std::string& value);
     void set_first_stage_init(bool value) { first_stage_init_ = value; }
+    bool IsTempMetadata() const override { return temp_metadata_; }
+    void SetTempMetadata() { temp_metadata_ = true; }
 
   private:
     bool EnsureBootHal();
 
     android::fs_mgr::PartitionOpener opener_;
     bool first_stage_init_ = false;
+    // Default value
+    std::string metadata_dir_ = "/metadata/ota";
+    bool temp_metadata_ = false;
 #ifdef LIBSNAPSHOT_USE_HAL
     std::unique_ptr<::android::hal::BootControlClient> boot_control_;
 #endif
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index deb2d6e92bc6..7ae55db316b5 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -111,6 +111,7 @@ class ISnapshotManager {
         virtual bool IsFirstStageInit() const = 0;
         virtual std::unique_ptr<IImageManager> OpenImageManager() const = 0;
         virtual android::dm::IDeviceMapper& GetDeviceMapper() = 0;
+        virtual bool IsTempMetadata() const = 0;
 
         // Helper method for implementing OpenImageManager.
         std::unique_ptr<IImageManager> OpenImageManager(const std::string& gsid_dir) const;
@@ -329,6 +330,10 @@ class SnapshotManager final : public ISnapshotManager {
     // might be needed to perform first-stage mounts.
     static bool IsSnapshotManagerNeeded();
 
+    // Map the temp OTA metadata partition from super
+    static bool MapTempOtaMetadataPartitionIfNeeded(
+            const std::function<bool(const std::string&)>& init);
+
     // Helper function for second stage init to restorecon on the rollback indicator.
     static std::string GetGlobalRollbackIndicatorPath();
 
diff --git a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
index 620b03c14e36..1cd66515ed3e 100644
--- a/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
+++ b/fs_mgr/libsnapshot/include_test/libsnapshot/test_helpers.h
@@ -79,7 +79,7 @@ class TestDeviceInfo : public SnapshotManager::IDeviceInfo {
         : TestDeviceInfo(fake_super) {
         set_slot_suffix(slot_suffix);
     }
-    std::string GetMetadataDir() const override { return "/metadata/ota/test"s; }
+    std::string GetMetadataDir() const override { return metadata_dir_; }
     std::string GetSlotSuffix() const override { return slot_suffix_; }
     std::string GetOtherSlotSuffix() const override { return slot_suffix_ == "_a" ? "_b" : "_a"; }
     std::string GetSuperDevice([[maybe_unused]] uint32_t slot) const override { return "super"; }
@@ -120,6 +120,7 @@ class TestDeviceInfo : public SnapshotManager::IDeviceInfo {
     void set_dm(android::dm::IDeviceMapper* dm) { dm_ = dm; }
 
     MergeStatus merge_status() const { return merge_status_; }
+    bool IsTempMetadata() const override { return temp_metadata_; }
 
   private:
     std::string slot_suffix_ = "_a";
@@ -129,6 +130,8 @@ class TestDeviceInfo : public SnapshotManager::IDeviceInfo {
     bool first_stage_init_ = false;
     std::unordered_set<uint32_t> unbootable_slots_;
     android::dm::IDeviceMapper* dm_ = nullptr;
+    std::string metadata_dir_ = "/metadata/ota/test";
+    bool temp_metadata_ = false;
 };
 
 class DeviceMapperWrapper : public android::dm::IDeviceMapper {
diff --git a/fs_mgr/libsnapshot/scratch_super.cpp b/fs_mgr/libsnapshot/scratch_super.cpp
new file mode 100644
index 000000000000..805abf3f9b04
--- /dev/null
+++ b/fs_mgr/libsnapshot/scratch_super.cpp
@@ -0,0 +1,417 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/fs.h>
+#include <selinux/selinux.h>
+#include <stdlib.h>
+#include <sys/mount.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <sys/types.h>
+#include <sys/vfs.h>
+#include <unistd.h>
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/macros.h>
+#include <android-base/properties.h>
+#include <android-base/scopeguard.h>
+#include <android-base/strings.h>
+#include <android-base/unique_fd.h>
+#include <ext4_utils/ext4_utils.h>
+
+#include <libsnapshot/snapshot.h>
+
+#include <fs_mgr.h>
+#include <fs_mgr_dm_linear.h>
+#include <fstab/fstab.h>
+#include <liblp/builder.h>
+#include <storage_literals/storage_literals.h>
+#include <algorithm>
+#include <filesystem>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "device_info.h"
+#include "scratch_super.h"
+
+using namespace std::literals;
+using namespace android::dm;
+using namespace android::fs_mgr;
+using namespace android::storage_literals;
+
+namespace android {
+namespace snapshot {
+
+static bool UmountScratch() {
+    auto ota_dir = std::string(kOtaMetadataMount) + "/" + "ota";
+    std::error_code ec;
+
+    if (std::filesystem::remove_all(ota_dir, ec) == static_cast<std::uintmax_t>(-1)) {
+        LOG(ERROR) << "Failed to remove OTA directory: " << ec.message();
+        return false;
+    }
+
+    if (umount(kOtaMetadataMount) != 0) {
+        PLOG(ERROR) << "UmountScratch failed";
+        return false;
+    }
+
+    LOG(INFO) << "umount scratch_super success";
+    return true;
+}
+
+bool CleanupScratchOtaMetadataIfPresent(const ISnapshotManager::IDeviceInfo* info) {
+    if (!UmountScratch()) {
+        return false;
+    }
+
+    std::unique_ptr<MetadataBuilder> builder;
+    const auto partition_name = android::base::Basename(kOtaMetadataMount);
+    const std::vector<int> slots = {0, 1};
+
+    if (info == nullptr) {
+        info = new android::snapshot::DeviceInfo();
+    }
+
+    std::string super_device;
+    if (info->IsTestDevice()) {
+        super_device = "super";
+    } else {
+        super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();
+    }
+    const auto& opener = info->GetPartitionOpener();
+    std::string slot_suffix = info->GetSlotSuffix();
+    int slot = SlotNumberForSlotSuffix(slot_suffix);
+    // Walk both the slots and clean up metadata related to scratch space from
+    // both the slots.
+    for (auto slot : slots) {
+        std::unique_ptr<MetadataBuilder> builder = MetadataBuilder::New(opener, super_device, slot);
+        if (!builder) {
+            return false;
+        }
+
+        if (builder->FindPartition(partition_name) != nullptr) {
+            builder->RemovePartition(partition_name);
+            auto metadata = builder->Export();
+            if (!metadata) {
+                return false;
+            }
+            if (!UpdatePartitionTable(info->GetPartitionOpener(), super_device, *metadata.get(),
+                                      slot)) {
+                LOG(ERROR) << "UpdatePartitionTable failed for slot: " << slot;
+                return false;
+            }
+            if (DestroyLogicalPartition(partition_name)) {
+                LOG(INFO) << "CleanupScratchOtaMetadata success for slot: " << slot;
+            }
+        }
+    }
+
+    return true;
+}
+
+static bool SetupOTADirs() {
+    if (setfscreatecon(android::snapshot::kOtaMetadataFileContext)) {
+        PLOG(ERROR) << "setfscreatecon failed: " << android::snapshot::kOtaMetadataFileContext;
+        return false;
+    }
+    const auto ota_dir = std::string(kOtaMetadataMount) + "/" + "ota";
+    if (mkdir(ota_dir.c_str(), 0755) != 0 && errno != EEXIST) {
+        PLOG(ERROR) << "mkdir " << ota_dir;
+        return false;
+    }
+
+    const auto snapshot_dir = ota_dir + "/" + "snapshots";
+    if (mkdir(snapshot_dir.c_str(), 0755) != 0 && errno != EEXIST) {
+        PLOG(ERROR) << "mkdir " << snapshot_dir;
+        return false;
+    }
+    if (setfscreatecon(nullptr)) {
+        PLOG(ERROR) << "setfscreatecon null";
+        return false;
+    }
+    return true;
+}
+
+static bool MountScratch(const std::string& device_path) {
+    if (access(device_path.c_str(), R_OK | W_OK)) {
+        LOG(ERROR) << "Path does not exist or is not readwrite: " << device_path;
+        return false;
+    }
+
+    std::string filesystem_candidate;
+    if (fs_mgr_is_ext4(device_path)) {
+        filesystem_candidate = "ext4";
+    } else {
+        LOG(ERROR) << "Scratch partition is not ext4";
+        return false;
+    }
+    if (setfscreatecon(android::snapshot::kOtaMetadataFileContext)) {
+        PLOG(ERROR) << "setfscreatecon failed: " << android::snapshot::kOtaMetadataFileContext;
+        return false;
+    }
+    if (mkdir(kOtaMetadataMount, 0755) && (errno != EEXIST)) {
+        PLOG(ERROR) << "create " << kOtaMetadataMount;
+        return false;
+    }
+
+    android::fs_mgr::FstabEntry entry;
+    entry.blk_device = device_path;
+    entry.mount_point = kOtaMetadataMount;
+    entry.flags = MS_NOATIME;
+    entry.flags |= MS_SYNCHRONOUS;
+    entry.fs_options = "nodiscard";
+    fs_mgr_set_blk_ro(device_path, false);
+    entry.fs_mgr_flags.check = true;
+
+    bool mounted = false;
+    entry.fs_type = filesystem_candidate.c_str();
+    if (fs_mgr_do_mount_one(entry) == 0) {
+        mounted = true;
+    }
+
+    if (setfscreatecon(nullptr)) {
+        PLOG(ERROR) << "setfscreatecon null";
+        return false;
+    }
+    if (!mounted) {
+        rmdir(kOtaMetadataMount);
+        return false;
+    }
+
+    return true;
+}
+
+static bool MakeScratchFilesystem(const std::string& scratch_device) {
+    std::string fs_type;
+    std::string command;
+    if (!access(kMkExt4, X_OK)) {
+        fs_type = "ext4";
+        command = kMkExt4 + " -F -b 4096 -t ext4 -m 0 -O has_journal -M "s + kOtaMetadataMount;
+    } else {
+        LOG(ERROR) << "No supported mkfs command or filesystem driver available, supported "
+                      "filesystems "
+                      "are: f2fs, ext4";
+        return false;
+    }
+    command += " " + scratch_device + " >/dev/null 2>/dev/null </dev/null";
+    fs_mgr_set_blk_ro(scratch_device, false);
+    auto ret = system(command.c_str());
+    if (ret) {
+        LOG(ERROR) << "make " << fs_type << " filesystem on " << scratch_device
+                   << " return=" << ret;
+        return false;
+    }
+    return true;
+}
+
+static bool CreateDynamicScratch(const ISnapshotManager::IDeviceInfo* info,
+                                 std::string* scratch_device) {
+    const auto partition_name = android::base::Basename(kOtaMetadataMount);
+    auto& dm = DeviceMapper::Instance();
+    if (info == nullptr) {
+        info = new android::snapshot::DeviceInfo();
+    }
+
+    std::string super_device;
+    if (info->IsTestDevice()) {
+        super_device = "super";
+    } else {
+        super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();
+    }
+
+    bool partition_exists = dm.GetState(partition_name) != DmDeviceState::INVALID;
+    if (partition_exists) {
+        LOG(ERROR) << "Partition already exists: " << partition_name;
+        return false;
+    }
+
+    const auto& opener = info->GetPartitionOpener();
+    std::string slot_suffix = info->GetSlotSuffix();
+    int slot = SlotNumberForSlotSuffix(slot_suffix);
+    std::unique_ptr<MetadataBuilder> builder = MetadataBuilder::New(opener, super_device, slot);
+
+    if (!builder) {
+        LOG(ERROR) << "open " << super_device << " failed";
+        return false;
+    }
+
+    auto partition = builder->FindPartition(partition_name);
+    partition_exists = partition != nullptr;
+    if (partition_exists) {
+        LOG(ERROR) << "Partition exists in super metadata";
+        return false;
+    }
+
+    partition = builder->AddPartition(partition_name, LP_PARTITION_ATTR_NONE);
+    if (!partition) {
+        LOG(ERROR) << "AddPartition failed " << partition_name;
+        return false;
+    }
+
+    auto free_space = builder->AllocatableSpace() - builder->UsedSpace();
+    if (free_space < kOtaMetadataPartitionSize) {
+        LOG(ERROR) << "No space in super partition. Free space: " << free_space
+                   << " Requested space: " << kOtaMetadataPartitionSize;
+        return false;
+    }
+
+    LOG(INFO) << "CreateDynamicScratch: free_space: " << free_space
+              << " scratch_size: " << kOtaMetadataPartitionSize << " slot_number: " << slot;
+
+    if (!builder->ResizePartition(partition, kOtaMetadataPartitionSize)) {
+        LOG(ERROR) << "ResizePartition failed: " << partition_name << " free_space: " << free_space
+                   << " scratch_size: " << kOtaMetadataPartitionSize;
+        return false;
+    }
+
+    auto metadata = builder->Export();
+    CreateLogicalPartitionParams params;
+
+    if (!metadata ||
+        !UpdatePartitionTable(info->GetPartitionOpener(), super_device, *metadata.get(), slot)) {
+        LOG(ERROR) << "UpdatePartitionTable failed: " << partition_name;
+        return false;
+    }
+    params = {
+            .block_device = super_device,
+            .metadata_slot = slot,
+            .partition_name = partition_name,
+            .force_writable = true,
+            .timeout_ms = 10s,
+            .partition_opener = &info->GetPartitionOpener(),
+    };
+
+    if (!CreateLogicalPartition(params, scratch_device)) {
+        LOG(ERROR) << "CreateLogicalPartition failed";
+        return false;
+    }
+
+    LOG(INFO) << "Scratch device created successfully: " << *scratch_device << " slot: " << slot;
+    return true;
+}
+
+bool IsScratchOtaMetadataOnSuper() {
+    auto partition_name = android::base::Basename(kOtaMetadataMount);
+    auto source_slot = fs_mgr_get_slot_suffix();
+    auto source_slot_number = SlotNumberForSlotSuffix(source_slot);
+
+    const auto super_device =
+            kPhysicalDevice + fs_mgr_get_super_partition_name(!source_slot_number);
+
+    auto metadata = android::fs_mgr::ReadMetadata(super_device, !source_slot_number);
+    if (!metadata) {
+        return false;
+    }
+    auto partition = android::fs_mgr::FindPartition(*metadata.get(), partition_name);
+    if (!partition) {
+        return false;
+    }
+
+    auto& dm = DeviceMapper::Instance();
+    if (dm.GetState(partition_name) == DmDeviceState::ACTIVE) {
+        LOG(INFO) << "Partition: " << partition_name << " is active";
+        return true;
+    }
+
+    CreateLogicalPartitionParams params = {
+            .block_device = super_device,
+            .metadata = metadata.get(),
+            .partition = partition,
+    };
+
+    std::string scratch_path;
+    if (!CreateLogicalPartition(params, &scratch_path)) {
+        LOG(ERROR) << "Could not create logical partition: " << partition_name;
+        return false;
+    }
+    LOG(INFO) << "Scratch device: " << scratch_path << " created successfully";
+
+    return true;
+}
+
+std::string GetScratchOtaMetadataPartition() {
+    std::string device;
+    auto& dm = DeviceMapper::Instance();
+    auto partition_name = android::base::Basename(kOtaMetadataMount);
+
+    bool invalid_partition = (dm.GetState(partition_name) == DmDeviceState::INVALID);
+    if (!invalid_partition && dm.GetDmDevicePathByName(partition_name, &device)) {
+        return device;
+    }
+    return "";
+}
+
+static bool ScratchAlreadyMounted(const std::string& mount_point) {
+    android::fs_mgr::Fstab fstab;
+    if (!ReadFstabFromProcMounts(&fstab)) {
+        return false;
+    }
+    for (const auto& entry : GetEntriesForMountPoint(&fstab, mount_point)) {
+        if (entry->fs_type == "ext4") {
+            return true;
+        }
+    }
+    return false;
+}
+
+std::string MapScratchOtaMetadataPartition(const std::string& scratch_device) {
+    if (!ScratchAlreadyMounted(kOtaMetadataMount)) {
+        if (!MountScratch(scratch_device)) {
+            return "";
+        }
+    }
+
+    auto ota_dir = std::string(kOtaMetadataMount) + "/" + "ota";
+    if (access(ota_dir.c_str(), F_OK) != 0) {
+        return "";
+    }
+    return ota_dir;
+}
+
+// Entry point to create a scratch device on super partition
+// This will create a 1MB space in super. The space will be
+// from the current active slot. Ext4 filesystem will be created
+// on this scratch device and all the OTA related directories
+// will be created.
+bool CreateScratchOtaMetadataOnSuper(const ISnapshotManager::IDeviceInfo* info) {
+    std::string scratch_device;
+
+    if (!CreateDynamicScratch(info, &scratch_device)) {
+        LOG(ERROR) << "CreateDynamicScratch failed";
+        return false;
+    }
+    if (!MakeScratchFilesystem(scratch_device)) {
+        LOG(ERROR) << "MakeScratchFilesystem failed";
+        return false;
+    }
+    if (!MountScratch(scratch_device)) {
+        LOG(ERROR) << "MountScratch failed";
+        return false;
+    }
+    if (!SetupOTADirs()) {
+        LOG(ERROR) << "SetupOTADirs failed";
+        return false;
+    }
+    return true;
+}
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/scratch_super.h b/fs_mgr/libsnapshot/scratch_super.h
new file mode 100644
index 000000000000..3e6fe702fd76
--- /dev/null
+++ b/fs_mgr/libsnapshot/scratch_super.h
@@ -0,0 +1,33 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+namespace android {
+namespace snapshot {
+
+constexpr char kMkExt4[] = "/system/bin/mke2fs";
+constexpr char kOtaMetadataFileContext[] = "u:object_r:ota_metadata_file:s0";
+constexpr char kOtaMetadataMount[] = "/mnt/scratch_ota_metadata_super";
+const size_t kOtaMetadataPartitionSize = uint64_t(1 * 1024 * 1024);
+constexpr char kPhysicalDevice[] = "/dev/block/by-name/";
+
+bool IsScratchOtaMetadataOnSuper();
+std::string GetScratchOtaMetadataPartition();
+std::string MapScratchOtaMetadataPartition(const std::string& device);
+bool CreateScratchOtaMetadataOnSuper(const ISnapshotManager::IDeviceInfo* info = nullptr);
+bool CleanupScratchOtaMetadataIfPresent(const ISnapshotManager::IDeviceInfo* info = nullptr);
+
+}  // namespace snapshot
+}  // namespace android
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 108fd903b431..6c3bedd865b5 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -48,6 +48,7 @@
 #include <libsnapshot/snapshot_stats.h>
 #include "device_info.h"
 #include "partition_cow_creator.h"
+#include "scratch_super.h"
 #include "snapshot_metadata_updater.h"
 #include "utility.h"
 
@@ -117,7 +118,11 @@ std::unique_ptr<SnapshotManager> SnapshotManager::New(IDeviceInfo* info) {
         info = new DeviceInfo();
     }
 
-    return std::unique_ptr<SnapshotManager>(new SnapshotManager(info));
+    auto sm = std::unique_ptr<SnapshotManager>(new SnapshotManager(info));
+    if (info->IsTempMetadata()) {
+        LOG(INFO) << "Using temp metadata from super";
+    }
+    return sm;
 }
 
 std::unique_ptr<SnapshotManager> SnapshotManager::NewForFirstStageMount(IDeviceInfo* info) {
@@ -1110,6 +1115,13 @@ UpdateState SnapshotManager::ProcessUpdateState(const std::function<bool()>& cal
         if (result.state == UpdateState::MergeFailed) {
             AcknowledgeMergeFailure(result.failure_code);
         }
+
+        if (result.state == UpdateState::MergeCompleted) {
+            if (device_->IsTempMetadata()) {
+                CleanupScratchOtaMetadataIfPresent();
+            }
+        }
+
         if (result.state != UpdateState::Merging) {
             // Either there is no merge, or the merge was finished, so no need
             // to keep waiting.
@@ -2310,7 +2322,27 @@ bool SnapshotManager::ListSnapshots(LockedFile* lock, std::vector<std::string>*
 }
 
 bool SnapshotManager::IsSnapshotManagerNeeded() {
-    return access(kBootIndicatorPath, F_OK) == 0;
+    if (access(kBootIndicatorPath, F_OK) == 0) {
+        return true;
+    }
+
+    if (IsScratchOtaMetadataOnSuper()) {
+        return true;
+    }
+
+    return false;
+}
+
+bool SnapshotManager::MapTempOtaMetadataPartitionIfNeeded(
+        const std::function<bool(const std::string&)>& init) {
+    auto device = android::snapshot::GetScratchOtaMetadataPartition();
+    if (!device.empty()) {
+        init(device);
+        if (android::snapshot::MapScratchOtaMetadataPartition(device).empty()) {
+            return false;
+        }
+    }
+    return true;
 }
 
 std::string SnapshotManager::GetGlobalRollbackIndicatorPath() {
@@ -2397,6 +2429,12 @@ bool SnapshotManager::MapAllPartitions(LockedFile* lock, const std::string& supe
             continue;
         }
 
+        if (GetPartitionName(partition) ==
+            android::base::Basename(android::snapshot::kOtaMetadataMount)) {
+            LOG(INFO) << "Partition: " << GetPartitionName(partition) << " skipping";
+            continue;
+        }
+
         CreateLogicalPartitionParams params = {
                 .block_device = super_device,
                 .metadata = metadata.get(),
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 16c247fdcf92..46c3a35e9d8f 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -47,6 +47,7 @@
 #include <android/snapshot/snapshot.pb.h>
 #include <libsnapshot/test_helpers.h>
 #include "partition_cow_creator.h"
+#include "scratch_super.h"
 #include "utility.h"
 
 // Mock classes are not used. Header included to ensure mocked class definition aligns with the
@@ -1342,6 +1343,15 @@ class SnapshotUpdateTest : public SnapshotTest {
     DynamicPartitionGroup* group_ = nullptr;
 };
 
+TEST_F(SnapshotUpdateTest, SuperOtaMetadataTest) {
+    auto info = new TestDeviceInfo(fake_super);
+    ASSERT_TRUE(CreateScratchOtaMetadataOnSuper(info));
+    std::string scratch_device = GetScratchOtaMetadataPartition();
+    ASSERT_NE(scratch_device, "");
+    ASSERT_NE(MapScratchOtaMetadataPartition(scratch_device), "");
+    ASSERT_TRUE(CleanupScratchOtaMetadataIfPresent(info));
+}
+
 // Test full update flow executed by update_engine. Some partitions uses super empty space,
 // some uses images, and some uses both.
 // Also test UnmapUpdateSnapshot unmaps everything.
diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 0158d4d9cea1..23c3ccf58126 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -16,7 +16,6 @@
 
 #include <sysexits.h>
 #include <unistd.h>
-
 #include <chrono>
 #include <filesystem>
 #include <fstream>
@@ -46,6 +45,7 @@
 #include <storage_literals/storage_literals.h>
 
 #include "partition_cow_creator.h"
+#include "scratch_super.h"
 
 #ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
 #include <BootControlClient.h>
@@ -57,6 +57,8 @@ using namespace android::storage_literals;
 using android::base::LogdLogger;
 using android::base::StderrLogger;
 using android::base::TeeLogger;
+using namespace android::dm;
+using namespace android::fs_mgr;
 using android::fs_mgr::CreateLogicalPartitionParams;
 using android::fs_mgr::FindPartition;
 using android::fs_mgr::GetPartitionSize;
@@ -97,7 +99,7 @@ namespace snapshot {
 #ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
 class MapSnapshots {
   public:
-    MapSnapshots(std::string path = "");
+    MapSnapshots(std::string path = "", bool metadata_super = false);
     bool CreateSnapshotDevice(std::string& partition_name, std::string& patch);
     bool InitiateThreadedSnapshotWrite(std::string& pname, std::string& snapshot_patch);
     bool FinishSnapshotWrites();
@@ -122,15 +124,12 @@ class MapSnapshots {
 
     std::vector<std::string> patchfiles_;
     chromeos_update_engine::DeltaArchiveManifest manifest_;
+    bool metadata_super_ = false;
 };
 
-MapSnapshots::MapSnapshots(std::string path) {
-    sm_ = SnapshotManager::New();
-    if (!sm_) {
-        std::cout << "Failed to create snapshotmanager";
-        exit(1);
-    }
+MapSnapshots::MapSnapshots(std::string path, bool metadata_super) {
     snapshot_dir_path_ = path + "/";
+    metadata_super_ = metadata_super;
 }
 
 std::string MapSnapshots::GetGroupName(const android::fs_mgr::LpMetadata& pt,
@@ -150,6 +149,12 @@ std::string MapSnapshots::GetGroupName(const android::fs_mgr::LpMetadata& pt,
 }
 
 bool MapSnapshots::PrepareUpdate() {
+    if (metadata_super_ && !CreateScratchOtaMetadataOnSuper()) {
+        LOG(ERROR) << "Failed to create OTA metadata on super";
+        return false;
+    }
+    sm_ = SnapshotManager::New();
+
     auto source_slot = fs_mgr_get_slot_suffix();
     auto source_slot_number = SlotNumberForSlotSuffix(source_slot);
     auto super_source = fs_mgr_get_super_partition_name(source_slot_number);
@@ -234,14 +239,22 @@ bool MapSnapshots::PrepareUpdate() {
 
 bool MapSnapshots::GetCowDevicePath(std::string partition_name, std::string* cow_path) {
     auto& dm = android::dm::DeviceMapper::Instance();
-    std::string cow_device = partition_name + "-cow";
+
+    std::string cow_device = partition_name + "-cow-img";
+    if (metadata_super_) {
+        // If COW device exists on /data, then data wipe cannot be done.
+        if (dm.GetDmDevicePathByName(cow_device, cow_path)) {
+            LOG(ERROR) << "COW device exists on /data: " << *cow_path;
+            return false;
+        }
+    }
+
+    cow_device = partition_name + "-cow";
     if (dm.GetDmDevicePathByName(cow_device, cow_path)) {
         return true;
     }
 
     LOG(INFO) << "Failed to find cow path: " << cow_device << " Checking the device for -img path";
-    // If the COW device exists only on /data
-    cow_device = partition_name + "-cow-img";
     if (!dm.GetDmDevicePathByName(cow_device, cow_path)) {
         LOG(ERROR) << "Failed to cow path: " << cow_device;
         return false;
@@ -321,6 +334,12 @@ bool MapSnapshots::ApplyUpdate() {
 }
 
 bool MapSnapshots::BeginUpdate() {
+    if (metadata_super_ && !CreateScratchOtaMetadataOnSuper()) {
+        LOG(ERROR) << "Failed to create OTA metadata on super";
+        return false;
+    }
+    sm_ = SnapshotManager::New();
+
     lock_ = sm_->LockExclusive();
     std::vector<std::string> snapshots;
     sm_->ListSnapshots(lock_.get(), &snapshots);
@@ -470,10 +489,12 @@ bool MapSnapshots::FinishSnapshotWrites() {
 }
 
 bool MapSnapshots::UnmapCowImagePath(std::string& name) {
+    sm_ = SnapshotManager::New();
     return sm_->UnmapCowImage(name);
 }
 
 bool MapSnapshots::DeleteSnapshots() {
+    sm_ = SnapshotManager::New();
     lock_ = sm_->LockExclusive();
     if (!sm_->RemoveAllUpdateState(lock_.get())) {
         LOG(ERROR) << "Remove All Update State failed";
@@ -583,13 +604,19 @@ bool ApplyUpdate(int argc, char** argv) {
     }
 
     if (argc < 3) {
-        std::cerr << " apply-update <directory location where snapshot patches are present>"
+        std::cerr << " apply-update <directory location where snapshot patches are present> {-w}"
                      "    Apply the snapshots to the COW block device\n";
         return false;
     }
 
     std::string path = std::string(argv[2]);
-    MapSnapshots cow(path);
+    bool metadata_on_super = false;
+    if (argc == 4) {
+        if (std::string(argv[3]) == "-w") {
+            metadata_on_super = true;
+        }
+    }
+    MapSnapshots cow(path, metadata_on_super);
     if (!cow.ApplyUpdate()) {
         return false;
     }
@@ -607,7 +634,7 @@ bool MapPrecreatedSnapshots(int argc, char** argv) {
     }
 
     if (argc < 3) {
-        std::cerr << " map-snapshots <directory location where snapshot patches are present>"
+        std::cerr << " map-snapshots <directory location where snapshot patches are present> {-w}"
                      "    Map all snapshots based on patches present in the directory\n";
         return false;
     }
@@ -638,7 +665,14 @@ bool MapPrecreatedSnapshots(int argc, char** argv) {
         }
     }
 
-    MapSnapshots cow(path);
+    bool metadata_on_super = false;
+    if (argc == 4) {
+        if (std::string(argv[3]) == "-w") {
+            metadata_on_super = true;
+        }
+    }
+
+    MapSnapshots cow(path, metadata_on_super);
     if (!cow.BeginUpdate()) {
         LOG(ERROR) << "BeginUpdate failed";
         return false;
diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 9e1415612999..734066baa821 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -42,6 +42,7 @@ cc_library_static {
     static_libs: [
         "libcutils_sockets",
         "libfs_mgr_file_wait",
+        "libdm",
     ],
     shared_libs: [
         "libbase",
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
index 789c98071737..ddefb9f91f19 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
@@ -35,6 +35,7 @@
 #include <android-base/properties.h>
 #include <android-base/strings.h>
 #include <fs_mgr/file_wait.h>
+#include <libdm/dm.h>
 #include <snapuserd/snapuserd_client.h>
 
 namespace android {
@@ -333,7 +334,21 @@ bool SnapuserdClient::QueryUpdateVerification() {
 }
 
 std::string SnapuserdClient::GetDaemonAliveIndicatorPath() {
-    return "/metadata/ota/" + std::string(kDaemonAliveIndicator);
+    std::string metadata_dir;
+    std::string temp_metadata_mnt = "/mnt/scratch_ota_metadata_super";
+
+    auto& dm = ::android::dm::DeviceMapper::Instance();
+    auto partition_name = android::base::Basename(temp_metadata_mnt);
+
+    bool invalid_partition = (dm.GetState(partition_name) == dm::DmDeviceState::INVALID);
+    std::string temp_device;
+    if (!invalid_partition && dm.GetDmDevicePathByName(partition_name, &temp_device)) {
+        metadata_dir = temp_metadata_mnt + "/" + "ota/";
+    } else {
+        metadata_dir = "/metadata/ota/";
+    }
+
+    return metadata_dir + std::string(kDaemonAliveIndicator);
 }
 
 bool SnapuserdClient::IsTransitionedDaemonReady() {
diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index 927b45f22e4c..ece430b70e21 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -371,6 +371,14 @@ bool FirstStageMountVBootV2::CreateLogicalPartitions() {
     }
 
     if (SnapshotManager::IsSnapshotManagerNeeded()) {
+        auto init_devices = [this](const std::string& device) -> bool {
+            if (android::base::StartsWith(device, "/dev/block/dm-")) {
+                return block_dev_init_.InitDmDevice(device);
+            }
+            return block_dev_init_.InitDevices({device});
+        };
+
+        SnapshotManager::MapTempOtaMetadataPartitionIfNeeded(init_devices);
         auto sm = SnapshotManager::NewForFirstStageMount();
         if (!sm) {
             return false;

From f61be9ea3965d0e59e47b47013712fe00f59c01f Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Tue, 30 Jul 2024 15:31:33 -0700
Subject: [PATCH 1083/1487] Make some fstab functions available outside of
 fs_mgr

Test: th
Bug: 353436188
Change-Id: I5d1d80935d345245dece579ea2d2cbdb61ebaf11
---
 fs_mgr/include/fs_mgr/roots.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/fs_mgr/include/fs_mgr/roots.h b/fs_mgr/include/fs_mgr/roots.h
index 65c59cfe6c7d..e19f9ad5346a 100644
--- a/fs_mgr/include/fs_mgr/roots.h
+++ b/fs_mgr/include/fs_mgr/roots.h
@@ -29,6 +29,8 @@ namespace fs_mgr {
 // first match or nullptr.
 FstabEntry* GetEntryForPath(Fstab* fstab, const std::string& path);
 
+std::vector<FstabEntry*> GetEntriesForPath(Fstab* fstab, const std::string& path);
+
 // Make sure that the volume 'path' is on is mounted.
 // * If 'mount_point' is nullptr, use mount point in fstab. Caller can call
 //   fs_mgr_ensure_path_unmounted() with the same 'path' argument to unmount.

From c2f2263bbffaff863942231552e10aaa79db9603 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Wed, 24 Jul 2024 10:29:23 -0700
Subject: [PATCH 1084/1487] Skip F2FS formatting for dev option enabled devices

F2FS does not support page_size!=block_size configuration, and
dev option devices need to toggle between 4K/16K mode, hence F2FS
requires a data wipe every time page size changes. This is inconveinent,
skip F2FS formatting instead.

Test: th
Bug: 353436188
Change-Id: Ic33dbc39c16db3aee4c47349a9693aacec240de8
---
 fs_mgr/fs_mgr.cpp | 64 ++++++++++++++++++++++++++++++++++-------------
 1 file changed, 46 insertions(+), 18 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 76578dd2ccf7..6052699dc6a8 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -38,10 +38,8 @@
 
 #include <array>
 #include <chrono>
-#include <functional>
 #include <map>
 #include <memory>
-#include <numeric>
 #include <string>
 #include <string_view>
 #include <thread>
@@ -66,6 +64,7 @@
 #include <fs_mgr/file_wait.h>
 #include <fs_mgr_overlayfs.h>
 #include <fscrypt/fscrypt.h>
+#include <fstab/fstab.h>
 #include <libdm/dm.h>
 #include <libdm/loop_control.h>
 #include <liblp/metadata_format.h>
@@ -82,7 +81,7 @@
 #define F2FS_FSCK_BIN   "/system/bin/fsck.f2fs"
 #define MKSWAP_BIN      "/system/bin/mkswap"
 #define TUNE2FS_BIN     "/system/bin/tune2fs"
-#define RESIZE2FS_BIN "/system/bin/resize2fs"
+#define RESIZE2FS_BIN   "/system/bin/resize2fs"
 
 #define FSCK_LOG_FILE   "/dev/fscklogs/log"
 
@@ -138,8 +137,8 @@ enum FsStatFlags {
 static void log_fs_stat(const std::string& blk_device, int fs_stat) {
     std::string msg =
             android::base::StringPrintf("\nfs_stat,%s,0x%x\n", blk_device.c_str(), fs_stat);
-    android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(FSCK_LOG_FILE, O_WRONLY | O_CLOEXEC |
-                                                        O_APPEND | O_CREAT, 0664)));
+    android::base::unique_fd fd(TEMP_FAILURE_RETRY(
+            open(FSCK_LOG_FILE, O_WRONLY | O_CLOEXEC | O_APPEND | O_CREAT, 0664)));
     if (fd == -1 || !android::base::WriteStringToFd(msg, fd)) {
         LWARNING << __FUNCTION__ << "() cannot log " << msg;
     }
@@ -593,7 +592,7 @@ static void tune_metadata_csum(const std::string& blk_device, const FstabEntry&
 
     // Must give `-T now` to prevent last_fsck_time from growing too large,
     // otherwise, tune2fs won't enable metadata_csum.
-    const char* tune2fs_args[] = {TUNE2FS_BIN, "-O",        "metadata_csum,64bit,extent",
+    const char* tune2fs_args[] = {TUNE2FS_BIN, "-O",  "metadata_csum,64bit,extent",
                                   "-T",        "now", blk_device.c_str()};
     const char* resize2fs_args[] = {RESIZE2FS_BIN, "-b", blk_device.c_str()};
 
@@ -1430,6 +1429,34 @@ bool WasMetadataEncryptionInterrupted(const FstabEntry& entry) {
     return access(fs_mgr_metadata_encryption_in_progress_file_name(entry).c_str(), R_OK) == 0;
 }
 
+FstabEntry* LocateFormattableEntry(FstabEntry* const begin, FstabEntry* const end) {
+    const bool dev_option_enabled =
+            android::base::GetBoolProperty("ro.product.build.16k_page.enabled", false);
+    FstabEntry* f2fs_entry = nullptr;
+    for (auto iter = begin; iter->blk_device == begin->blk_device && iter < end; iter++) {
+        if (iter->fs_mgr_flags.formattable) {
+            if (getpagesize() != 4096 && is_f2fs(iter->fs_type) && dev_option_enabled) {
+                f2fs_entry = iter;
+                continue;
+            }
+            if (f2fs_entry) {
+                LOG(INFO) << "Skipping F2FS format for block device " << iter->blk_device << " @ "
+                          << iter->mount_point
+                          << " in non-4K mode for dev option enabled devices, "
+                             "as these devices need to toggle between 4K/16K mode, and F2FS does "
+                             "not support page_size != block_size configuration.";
+            }
+            return iter;
+        }
+    }
+    if (f2fs_entry) {
+        LOG(INFO) << "Using F2FS for " << f2fs_entry->blk_device << " @ " << f2fs_entry->mount_point
+                  << " even though we are in non-4K mode. Device might require a data wipe after "
+                     "going back to 4K mode, as F2FS does not support page_size != block_size";
+    }
+    return f2fs_entry;
+}
+
 // When multiple fstab records share the same mount_point, it will try to mount each
 // one in turn, and ignore any duplicates after a first successful mount.
 // Returns -1 on error, and  FS_MGR_MNTALL_* otherwise.
@@ -1540,8 +1567,8 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
             }
         }
 
-        int last_idx_inspected;
-        int top_idx = i;
+        int last_idx_inspected = -1;
+        const int top_idx = i;
         int attempted_idx = -1;
 
         bool encryption_interrupted = WasMetadataEncryptionInterrupted(current_entry);
@@ -1591,7 +1618,8 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
             // Success!  Go get the next one.
             continue;
         }
-
+        auto formattable_entry =
+                LocateFormattableEntry(fstab->data() + top_idx, fstab->data() + fstab->size());
         // Mounting failed, understand why and retry.
         wiped = partition_wiped(current_entry.blk_device.c_str());
         if (mount_errno != EBUSY && mount_errno != EACCES &&
@@ -1619,12 +1647,12 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                 encryptable = FS_MGR_MNTALL_DEV_IS_METADATA_ENCRYPTED;
                 set_type_property(encryptable);
 
-                if (!call_vdc({"cryptfs", "encryptFstab", current_entry.blk_device,
-                               current_entry.mount_point, "true" /* shouldFormat */,
-                               current_entry.fs_type,
-                               current_entry.fs_mgr_flags.is_zoned ? "true" : "false",
-                               std::to_string(current_entry.length),
-                               android::base::Join(current_entry.user_devices, ' ')},
+                if (!call_vdc({"cryptfs", "encryptFstab", formattable_entry->blk_device,
+                               formattable_entry->mount_point, "true" /* shouldFormat */,
+                               formattable_entry->fs_type,
+                               formattable_entry->fs_mgr_flags.is_zoned ? "true" : "false",
+                               std::to_string(formattable_entry->length),
+                               android::base::Join(formattable_entry->user_devices, ' ')},
                               nullptr)) {
                     LERROR << "Encryption failed";
                 } else {
@@ -1633,7 +1661,7 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                 }
             }
 
-            if (fs_mgr_do_format(current_entry) == 0) {
+            if (fs_mgr_do_format(*formattable_entry) == 0) {
                 // Let's replay the mount actions.
                 i = top_idx - 1;
                 continue;
@@ -1749,12 +1777,12 @@ int fs_mgr_do_mount_one(const FstabEntry& entry, const std::string& alt_mount_po
     int ret = prepare_fs_for_mount(entry.blk_device, entry, mount_point);
     // Wiped case doesn't require to try __mount below.
     if (ret & FS_STAT_INVALID_MAGIC) {
-      return FS_MGR_DOMNT_FAILED;
+        return FS_MGR_DOMNT_FAILED;
     }
 
     ret = __mount(entry.blk_device, mount_point, entry);
     if (ret) {
-      ret = (errno == EBUSY) ? FS_MGR_DOMNT_BUSY : FS_MGR_DOMNT_FAILED;
+        ret = (errno == EBUSY) ? FS_MGR_DOMNT_BUSY : FS_MGR_DOMNT_FAILED;
     }
 
     return ret;

From 15e98464736c331509733edc07a1ce01602d8a54 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Wed, 28 Aug 2024 19:27:09 +0000
Subject: [PATCH 1085/1487] isBlockAligned to use uint64_t

We want to avoid the usage of size_t for any integer value that could
exceed 2^32 (for 32 bit platforms). Let's update the usage here for
future compatibilty and avoid silent truncation failures.

Bug: 361048795
Test: th
Change-Id: I9ce2ca21706270a218f06f7d2b7dc9fade185a68
---
 fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h              | 2 +-
 fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
index 871ed273fc89..9e7cf7a2cd08 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/writer_v3.h
@@ -82,7 +82,7 @@ class CowWriterV3 : public CowWriterBase {
                                                  CowOperationType type);
     size_t GetCompressionFactor(const size_t blocks_to_compress, CowOperationType type) const;
 
-    constexpr bool IsBlockAligned(const size_t size) {
+    constexpr bool IsBlockAligned(const uint64_t size) {
         // These are the only block size supported. Block size beyond 256k
         // may impact random read performance post OTA boot.
         const size_t values[] = {4_KiB, 8_KiB, 16_KiB, 32_KiB, 64_KiB, 128_KiB, 256_KiB};
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
index 04b2736e9843..378d809792f4 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h
@@ -57,7 +57,7 @@ class ReadWorker : public Worker, public IBlockServer::Delegate {
     bool ReadFromSourceDevice(const CowOperation* cow_op, void* buffer);
     bool ReadDataFromBaseDevice(sector_t sector, void* buffer, size_t read_size);
 
-    constexpr bool IsBlockAligned(size_t size) { return ((size & (BLOCK_SZ - 1)) == 0); }
+    constexpr bool IsBlockAligned(uint64_t size) { return ((size & (BLOCK_SZ - 1)) == 0); }
     constexpr sector_t ChunkToSector(chunk_t chunk) { return chunk << CHUNK_SHIFT; }
     constexpr chunk_t SectorToChunk(sector_t sector) { return sector >> CHUNK_SHIFT; }
 

From b9b2830c8127008a742ba9529a6a64d8d87deb18 Mon Sep 17 00:00:00 2001
From: Alice Wang <aliceywang@google.com>
Date: Wed, 31 Jul 2024 18:41:00 +0000
Subject: [PATCH 1086/1487] [km] Add a new rust binary for non-secure KeyMint
 host

The new binary sets non-secure RoT for keymint. The non-secure
version will be used on cuttlefish.

Bug: 355194622
Test: CF is gets booted with KeyMint TA in VM
Change-Id: Iff202c6d4bb70dabeb866b4f3fbc18c006bb219e
---
 trusty/keymint/Android.bp              | 22 ++++++++++++++----
 trusty/keymint/src/keymint_hal_main.rs | 31 ++++++++++++++++++++++++--
 2 files changed, 47 insertions(+), 6 deletions(-)

diff --git a/trusty/keymint/Android.bp b/trusty/keymint/Android.bp
index 92d9c6fbb01d..1b87d806f277 100644
--- a/trusty/keymint/Android.bp
+++ b/trusty/keymint/Android.bp
@@ -17,12 +17,10 @@ package {
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
-rust_binary {
-    name: "android.hardware.security.keymint-service.rust.trusty",
+rust_defaults {
+    name: "android.hardware.security.keymint-service.rust.trusty.default",
     relative_install_path: "hw",
     vendor: true,
-    init_rc: ["android.hardware.security.keymint-service.rust.trusty.rc"],
-    vintf_fragments: ["android.hardware.security.keymint-service.rust.trusty.xml"],
     srcs: [
         "src/keymint_hal_main.rs",
     ],
@@ -37,7 +35,23 @@ rust_binary {
         "liblog_rust",
     ],
     prefer_rlib: true,
+}
+
+rust_binary {
+    name: "android.hardware.security.keymint-service.rust.trusty",
+    defaults: ["android.hardware.security.keymint-service.rust.trusty.default"],
+    init_rc: ["android.hardware.security.keymint-service.rust.trusty.rc"],
+    vintf_fragments: ["android.hardware.security.keymint-service.rust.trusty.xml"],
     required: [
         "android.hardware.hardware_keystore.xml",
     ],
 }
+
+rust_binary {
+    name: "android.hardware.security.keymint-service.rust.trusty.nonsecure",
+    defaults: ["android.hardware.security.keymint-service.rust.trusty.default"],
+    features: ["nonsecure"],
+    rustlibs: [
+        "libkmr_hal_nonsecure",
+    ],
+}
diff --git a/trusty/keymint/src/keymint_hal_main.rs b/trusty/keymint/src/keymint_hal_main.rs
index 3c5627bd18e4..a0b1d792c2b1 100644
--- a/trusty/keymint/src/keymint_hal_main.rs
+++ b/trusty/keymint/src/keymint_hal_main.rs
@@ -18,7 +18,7 @@ use clap::Parser;
 use kmr_hal::{
     extract_rsp, keymint, rpc, secureclock, send_hal_info, sharedsecret, SerializedChannel,
 };
-use log::{error, info};
+use log::{error, info, warn};
 use std::{
     ffi::CString,
     ops::DerefMut,
@@ -109,7 +109,11 @@ fn inner_main() -> Result<(), HalServiceError> {
         error!("{}", panic_info);
     }));
 
-    info!("Trusty KM HAL service is starting.");
+    if cfg!(feature = "nonsecure") {
+        warn!("Non-secure Trusty KM HAL service is starting.");
+    } else {
+        info!("Trusty KM HAL service is starting.");
+    }
 
     info!("Starting thread pool now.");
     binder::ProcessState::start_thread_pool();
@@ -126,6 +130,29 @@ fn inner_main() -> Result<(), HalServiceError> {
         )?;
     let tipc_channel = Arc::new(Mutex::new(TipcChannel(connection)));
 
+    #[cfg(feature = "nonsecure")]
+    {
+        // When the non-secure feature is enabled, retrieve root-of-trust information
+        // (with the exception of the verified boot key hash) from Android properties, and
+        // populate the TA with this information. On a real device, the bootloader should
+        // provide this data to the TA directly.
+        let boot_req = kmr_hal_nonsecure::get_boot_info();
+        info!("boot/HAL->TA: boot info is {:?}", boot_req);
+        kmr_hal::send_boot_info(tipc_channel.lock().unwrap().deref_mut(), boot_req)
+            .map_err(|e| HalServiceError(format!("Failed to send boot info: {:?}", e)))?;
+        // When the non-secure feature is enabled, also retrieve device ID information
+        // (except for IMEI/MEID values) from Android properties and populate the TA with
+        // this information. On a real device, a factory provisioning process would populate
+        // this information.
+        let attest_ids = kmr_hal_nonsecure::attestation_id_info();
+        if let Err(e) =
+            kmr_hal::send_attest_ids(tipc_channel.lock().unwrap().deref_mut(), attest_ids)
+        {
+            error!("Failed to send attestation ID info: {:?}", e);
+        }
+        info!("Successfully sent non-secure boot info and attestation IDs to the TA.");
+    }
+
     // Register the Keymint service
     let km_service = keymint::Device::new_as_binder(tipc_channel.clone());
     let km_service_name = format!("{}/{}", KM_SERVICE_NAME, SERVICE_INSTANCE);

From 093fd351fa21cc7bce7911dc6d6e4642fbdd3c76 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 29 Aug 2024 20:55:07 -0700
Subject: [PATCH 1087/1487] libsnapshot: static link libselinux

libsnapshot_init is linked by microdroid. Adding libselinux as whole_static_libs in `libsnapshot_defaults` will bloat the super image of microdroid.

Instead, statically link libselinux for libsnapshot_init.

On Pixel 7 Pro:

Microdroid super image: 47173836
Baseline (Without this change): 47161548

Bug: 362839899
Test: Build, verify microdroid super image size.
Change-Id: I3c589097173b305c1d39af9edbfb8c5e29f21410
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/Android.bp | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 4828c4c15b5d..fabb72ddbb96 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -46,7 +46,6 @@ cc_defaults {
         "libfstab",
         "libsnapuserd_client",
         "libz",
-        "libselinux",
     ],
     header_libs: [
         "libfiemap_headers",
@@ -112,6 +111,9 @@ cc_library_static {
     static_libs: [
         "libfs_mgr_binder",
     ],
+    whole_static_libs: [
+        "libselinux",
+    ],
 }
 
 cc_library {
@@ -130,6 +132,9 @@ cc_library {
     static_libs: [
         "libsnapshot_cow",
     ],
+    whole_static_libs: [
+        "libselinux",
+    ],
 }
 
 cc_library_static {
@@ -144,6 +149,7 @@ cc_library_static {
     ],
     static_libs: [
         "libfs_mgr",
+        "libselinux",
     ],
 }
 
@@ -161,6 +167,9 @@ cc_library_static {
     static_libs: [
         "libfs_mgr",
     ],
+    whole_static_libs: [
+        "libselinux",
+    ],
 }
 
 cc_defaults {
@@ -243,6 +252,7 @@ cc_library_static {
         "libfs_mgr",
         "libgmock",
         "libgtest",
+        "libselinux",
     ],
 }
 

From 23276f63af8010a69fef28b6694f1383985eeb02 Mon Sep 17 00:00:00 2001
From: Eric Caruso <ejcaruso@google.com>
Date: Fri, 30 Aug 2024 10:51:38 -0400
Subject: [PATCH 1088/1487] ueventd: fix confusing indentation

Bug: None
Test: compile
Change-Id: I8eb39792ed13ba61dd6a61e9771935ece33ae915
---
 init/devices.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/init/devices.cpp b/init/devices.cpp
index 5560c20bcb69..a4785878176e 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -330,11 +330,11 @@ void DeviceHandler::MakeDevice(const std::string& path, bool block, int major, i
             if (gid != s.st_gid) {
                 new_group = gid;
             }
-        if (mode != s.st_mode) {
-            if (chmod(path.c_str(), mode) != 0) {
-                PLOG(ERROR) << "Cannot chmod " << path << " to " << mode;
+            if (mode != s.st_mode) {
+                if (chmod(path.c_str(), mode) != 0) {
+                    PLOG(ERROR) << "Cannot chmod " << path << " to " << mode;
+                }
             }
-        }
         } else {
             PLOG(ERROR) << "Cannot stat " << path;
         }

From 109eae5cd76d06c4ef35c9b5c14e94c9cc311eb0 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 22 Aug 2024 17:31:07 +0000
Subject: [PATCH 1089/1487] libsnapshot: compile tests for both 32 and 64 bit

Bug: 360254891
Test: vts_libsnapshot_test
Change-Id: I7c49bf5e40c58022e1930e054ebc0bd9319b4da2
---
 fs_mgr/libsnapshot/Android.bp           | 11 ++++++++++-
 fs_mgr/libsnapshot/snapuserd/Android.bp | 12 +++++++++++-
 2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 4828c4c15b5d..f98b2b59b66f 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -285,7 +285,6 @@ cc_defaults {
     ],
     auto_gen_config: true,
     require_root: true,
-    compile_multilib: "first",
 }
 
 cc_test {
@@ -298,6 +297,15 @@ cc_test {
         "vts",
         "general-tests",
     ],
+    compile_multilib: "both",
+    multilib: {
+        lib32: {
+            suffix: "32",
+        },
+        lib64: {
+            suffix: "64",
+        },
+    },
     test_options: {
         min_shipping_api_level: 30,
     },
@@ -315,6 +323,7 @@ cc_test {
     test_suites: [
         "general-tests",
     ],
+    compile_multilib: "64",
     test_options: {
         // Legacy VAB launched in Android R.
         min_shipping_api_level: 30,
diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 734066baa821..8d0bf7d6b8d4 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -239,9 +239,19 @@ cc_defaults {
     test_options: {
         min_shipping_api_level: 30,
     },
+
+    compile_multilib: "both",
+    multilib: {
+        lib32: {
+            suffix: "32",
+        },
+        lib64: {
+            suffix: "64",
+        },
+    },
+
     auto_gen_config: true,
     require_root: true,
-    compile_multilib: "first",
 }
 
 cc_test {

From bb4a40955aa8c1350c6f2dc1ac5a0ade7bcab724 Mon Sep 17 00:00:00 2001
From: Eric Caruso <ejcaruso@google.com>
Date: Fri, 30 Aug 2024 13:34:24 -0400
Subject: [PATCH 1090/1487] ueventd: fix other assorted style nits

Indentation in this file is four spaces, remove an
unnecessary trailing semicolon, put a space between
a type declaration and its structured binding.

clang-format shuffled a line around as well.

Bug: None
Test: compile
Change-Id: Ib4cf17fecb1e54971020dc77b7903d2aac5dd9c1
---
 init/devices.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/init/devices.cpp b/init/devices.cpp
index 5560c20bcb69..4035e11f8f6a 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -283,7 +283,7 @@ std::tuple<mode_t, uid_t, gid_t> DeviceHandler::GetDevicePermissions(
 
 void DeviceHandler::MakeDevice(const std::string& path, bool block, int major, int minor,
                                const std::vector<std::string>& links) const {
-    auto[mode, uid, gid] = GetDevicePermissions(path, links);
+    auto [mode, uid, gid] = GetDevicePermissions(path, links);
     mode |= (block ? S_IFBLK : S_IFCHR);
 
     std::string secontext;
@@ -531,7 +531,7 @@ void DeviceHandler::HandleAshmemUevent(const Uevent& uevent) {
         if (!ReadFileToString(boot_id_path, &boot_id)) {
             PLOG(ERROR) << "Cannot duplicate ashmem device node. Failed to read " << boot_id_path;
             return;
-        };
+        }
         boot_id = Trim(boot_id);
 
         Uevent dup_ashmem_uevent = uevent;
@@ -542,10 +542,10 @@ void DeviceHandler::HandleAshmemUevent(const Uevent& uevent) {
 }
 
 void DeviceHandler::HandleUevent(const Uevent& uevent) {
-  if (uevent.action == "add" || uevent.action == "change" ||
-      uevent.action == "bind" || uevent.action == "online") {
-    FixupSysPermissions(uevent.path, uevent.subsystem);
-  }
+    if (uevent.action == "add" || uevent.action == "change" || uevent.action == "bind" ||
+        uevent.action == "online") {
+        FixupSysPermissions(uevent.path, uevent.subsystem);
+    }
 
     // if it's not a /dev device, nothing to do
     if (uevent.major < 0 || uevent.minor < 0) return;

From 642a98e2a77d3398269d588ca16e99dcdaeb68d5 Mon Sep 17 00:00:00 2001
From: Dan Shi <dshi@google.com>
Date: Fri, 30 Aug 2024 23:14:15 +0000
Subject: [PATCH 1091/1487] Revert "Skip F2FS formatting for dev option enabled
 devices"

This reverts commit c2f2263bbffaff863942231552e10aaa79db9603.

Reason for revert: possble cause of b/363089777

Change-Id: Ie7979e49bcbab6c99c0c7cba71e0b3858bfe0fbf
---
 fs_mgr/fs_mgr.cpp | 64 +++++++++++++----------------------------------
 1 file changed, 18 insertions(+), 46 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 6052699dc6a8..76578dd2ccf7 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -38,8 +38,10 @@
 
 #include <array>
 #include <chrono>
+#include <functional>
 #include <map>
 #include <memory>
+#include <numeric>
 #include <string>
 #include <string_view>
 #include <thread>
@@ -64,7 +66,6 @@
 #include <fs_mgr/file_wait.h>
 #include <fs_mgr_overlayfs.h>
 #include <fscrypt/fscrypt.h>
-#include <fstab/fstab.h>
 #include <libdm/dm.h>
 #include <libdm/loop_control.h>
 #include <liblp/metadata_format.h>
@@ -81,7 +82,7 @@
 #define F2FS_FSCK_BIN   "/system/bin/fsck.f2fs"
 #define MKSWAP_BIN      "/system/bin/mkswap"
 #define TUNE2FS_BIN     "/system/bin/tune2fs"
-#define RESIZE2FS_BIN   "/system/bin/resize2fs"
+#define RESIZE2FS_BIN "/system/bin/resize2fs"
 
 #define FSCK_LOG_FILE   "/dev/fscklogs/log"
 
@@ -137,8 +138,8 @@ enum FsStatFlags {
 static void log_fs_stat(const std::string& blk_device, int fs_stat) {
     std::string msg =
             android::base::StringPrintf("\nfs_stat,%s,0x%x\n", blk_device.c_str(), fs_stat);
-    android::base::unique_fd fd(TEMP_FAILURE_RETRY(
-            open(FSCK_LOG_FILE, O_WRONLY | O_CLOEXEC | O_APPEND | O_CREAT, 0664)));
+    android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(FSCK_LOG_FILE, O_WRONLY | O_CLOEXEC |
+                                                        O_APPEND | O_CREAT, 0664)));
     if (fd == -1 || !android::base::WriteStringToFd(msg, fd)) {
         LWARNING << __FUNCTION__ << "() cannot log " << msg;
     }
@@ -592,7 +593,7 @@ static void tune_metadata_csum(const std::string& blk_device, const FstabEntry&
 
     // Must give `-T now` to prevent last_fsck_time from growing too large,
     // otherwise, tune2fs won't enable metadata_csum.
-    const char* tune2fs_args[] = {TUNE2FS_BIN, "-O",  "metadata_csum,64bit,extent",
+    const char* tune2fs_args[] = {TUNE2FS_BIN, "-O",        "metadata_csum,64bit,extent",
                                   "-T",        "now", blk_device.c_str()};
     const char* resize2fs_args[] = {RESIZE2FS_BIN, "-b", blk_device.c_str()};
 
@@ -1429,34 +1430,6 @@ bool WasMetadataEncryptionInterrupted(const FstabEntry& entry) {
     return access(fs_mgr_metadata_encryption_in_progress_file_name(entry).c_str(), R_OK) == 0;
 }
 
-FstabEntry* LocateFormattableEntry(FstabEntry* const begin, FstabEntry* const end) {
-    const bool dev_option_enabled =
-            android::base::GetBoolProperty("ro.product.build.16k_page.enabled", false);
-    FstabEntry* f2fs_entry = nullptr;
-    for (auto iter = begin; iter->blk_device == begin->blk_device && iter < end; iter++) {
-        if (iter->fs_mgr_flags.formattable) {
-            if (getpagesize() != 4096 && is_f2fs(iter->fs_type) && dev_option_enabled) {
-                f2fs_entry = iter;
-                continue;
-            }
-            if (f2fs_entry) {
-                LOG(INFO) << "Skipping F2FS format for block device " << iter->blk_device << " @ "
-                          << iter->mount_point
-                          << " in non-4K mode for dev option enabled devices, "
-                             "as these devices need to toggle between 4K/16K mode, and F2FS does "
-                             "not support page_size != block_size configuration.";
-            }
-            return iter;
-        }
-    }
-    if (f2fs_entry) {
-        LOG(INFO) << "Using F2FS for " << f2fs_entry->blk_device << " @ " << f2fs_entry->mount_point
-                  << " even though we are in non-4K mode. Device might require a data wipe after "
-                     "going back to 4K mode, as F2FS does not support page_size != block_size";
-    }
-    return f2fs_entry;
-}
-
 // When multiple fstab records share the same mount_point, it will try to mount each
 // one in turn, and ignore any duplicates after a first successful mount.
 // Returns -1 on error, and  FS_MGR_MNTALL_* otherwise.
@@ -1567,8 +1540,8 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
             }
         }
 
-        int last_idx_inspected = -1;
-        const int top_idx = i;
+        int last_idx_inspected;
+        int top_idx = i;
         int attempted_idx = -1;
 
         bool encryption_interrupted = WasMetadataEncryptionInterrupted(current_entry);
@@ -1618,8 +1591,7 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
             // Success!  Go get the next one.
             continue;
         }
-        auto formattable_entry =
-                LocateFormattableEntry(fstab->data() + top_idx, fstab->data() + fstab->size());
+
         // Mounting failed, understand why and retry.
         wiped = partition_wiped(current_entry.blk_device.c_str());
         if (mount_errno != EBUSY && mount_errno != EACCES &&
@@ -1647,12 +1619,12 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                 encryptable = FS_MGR_MNTALL_DEV_IS_METADATA_ENCRYPTED;
                 set_type_property(encryptable);
 
-                if (!call_vdc({"cryptfs", "encryptFstab", formattable_entry->blk_device,
-                               formattable_entry->mount_point, "true" /* shouldFormat */,
-                               formattable_entry->fs_type,
-                               formattable_entry->fs_mgr_flags.is_zoned ? "true" : "false",
-                               std::to_string(formattable_entry->length),
-                               android::base::Join(formattable_entry->user_devices, ' ')},
+                if (!call_vdc({"cryptfs", "encryptFstab", current_entry.blk_device,
+                               current_entry.mount_point, "true" /* shouldFormat */,
+                               current_entry.fs_type,
+                               current_entry.fs_mgr_flags.is_zoned ? "true" : "false",
+                               std::to_string(current_entry.length),
+                               android::base::Join(current_entry.user_devices, ' ')},
                               nullptr)) {
                     LERROR << "Encryption failed";
                 } else {
@@ -1661,7 +1633,7 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                 }
             }
 
-            if (fs_mgr_do_format(*formattable_entry) == 0) {
+            if (fs_mgr_do_format(current_entry) == 0) {
                 // Let's replay the mount actions.
                 i = top_idx - 1;
                 continue;
@@ -1777,12 +1749,12 @@ int fs_mgr_do_mount_one(const FstabEntry& entry, const std::string& alt_mount_po
     int ret = prepare_fs_for_mount(entry.blk_device, entry, mount_point);
     // Wiped case doesn't require to try __mount below.
     if (ret & FS_STAT_INVALID_MAGIC) {
-        return FS_MGR_DOMNT_FAILED;
+      return FS_MGR_DOMNT_FAILED;
     }
 
     ret = __mount(entry.blk_device, mount_point, entry);
     if (ret) {
-        ret = (errno == EBUSY) ? FS_MGR_DOMNT_BUSY : FS_MGR_DOMNT_FAILED;
+      ret = (errno == EBUSY) ? FS_MGR_DOMNT_BUSY : FS_MGR_DOMNT_FAILED;
     }
 
     return ret;

From a287592b9c1128727228391cb3615f72df4eb442 Mon Sep 17 00:00:00 2001
From: Yi Kong <yikong@google.com>
Date: Tue, 3 Sep 2024 16:44:54 +0900
Subject: [PATCH 1092/1487] Remove unnecessary std::move

Moving a temporary object prevents copy elision, and could reduce
performance.

This fixes -Wpessimizing-move compiler warning.

Test: presubmit
Bug: 154270751
Change-Id: I6d967966f75fb15e9b5c5e4661bd5ca3af37e8e0
---
 fastboot/vendor_boot_img_utils_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fastboot/vendor_boot_img_utils_test.cpp b/fastboot/vendor_boot_img_utils_test.cpp
index 467c6e9d9b7d..81072705d6dc 100644
--- a/fastboot/vendor_boot_img_utils_test.cpp
+++ b/fastboot/vendor_boot_img_utils_test.cpp
@@ -163,7 +163,7 @@ struct TestFileHandle {
   protected:
     // |rel_path| is the relative path under test data directory.
     TestFileHandle(const std::filesystem::path& rel_path)
-        : abs_path_(std::move(std::filesystem::path(GetExecutableDirectory()) / rel_path)) {}
+        : abs_path_(std::filesystem::path(GetExecutableDirectory()) / rel_path) {}
     // Given |read_fd|, the readonly fd on the test file, return an fd that's suitable for client
     // to use. Implementation is responsible for managing the lifetime of the returned fd.
     virtual android::base::Result<borrowed_fd> Transform(const std::filesystem::path& abs_path,

From 698f913f643f2a6fc6e2703611cd1cd5831b21bf Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Tue, 3 Sep 2024 20:40:28 +0000
Subject: [PATCH 1093/1487] Remove NDK exports

Base headers should come from sysroot.

Bug: N/A
Test: build
Change-Id: Ifd6d6353851a16c2744af241c6092657c595223c
---
 libsync/Android.bp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/libsync/Android.bp b/libsync/Android.bp
index b6b4a6e49271..99c88cf21113 100644
--- a/libsync/Android.bp
+++ b/libsync/Android.bp
@@ -27,9 +27,6 @@ ndk_library {
     name: "libsync",
     symbol_file: "libsync.map.txt",
     first_version: "26",
-    export_header_libs: [
-        "libsync_headers",
-    ],
 }
 
 cc_defaults {

From 469b62a334ff0ad8fe176404e4cb03a12596a092 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Mon, 26 Aug 2024 20:33:15 +0000
Subject: [PATCH 1094/1487] Use fallback linker allocator in trace_handler.

There is more than one function that can allocate in the fallback
path. Therefore, make sure that all functions that can allocate have
switched to the fallback linker allocator before allocating. This
is mostly a problem for the trace_handler function call, which iterates
over all known threads and gets backtraces for them.

Add a ScopedUseFallbackAllocator class to do the switching to make it
easier to have the same code everywhere.

Add two tests to verify that no allocations are occuring during
a tombstone or backtrace on the fallback path. These tests are not
comprehensive since they can't verify that the linker allocator is
using the fallback allocator, but they are better than nothing.

Remove the debuggerd_fallback_tombstone() function since it only
enables the linker callback and then calls engrave_tombstone_ucontext().
The enabling is now done with the ScopedUseLinkerAllocator.

Restructure the case where sending the signal to a thread fails so
that the fallback allocator can be enabled properly.

Bug: 359692763

Test: Ran debuggerd -b <PID> and debuggerd <PID> on a process that
Test: goes throught the fallback path.
Test: Unit tests pass along with two new tests.
Test: Forced a fallback process to crash and verified tombstone generated.
Test: Instrumented the linker allocator and verified that the trace_handler
Test: function never calls the normal linker allocator as it runs.
Change-Id: I2710921076634eac97f41bec8c3a29c1d75ae5ec
---
 debuggerd/debuggerd_test.cpp             |  69 +++++++++++
 debuggerd/handler/debuggerd_fallback.cpp | 148 +++++++++++++++--------
 2 files changed, 167 insertions(+), 50 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 962097e65d16..e33cea5c868b 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -1773,6 +1773,75 @@ TEST_F(CrasherTest, seccomp_crash_logcat) {
   AssertDeath(SIGABRT);
 }
 
+extern "C" void malloc_enable();
+extern "C" void malloc_disable();
+
+TEST_F(CrasherTest, seccomp_tombstone_no_allocation) {
+  int intercept_result;
+  unique_fd output_fd;
+
+  static const auto dump_type = kDebuggerdTombstone;
+  StartProcess(
+      []() {
+        std::thread a(foo);
+        std::thread b(bar);
+
+        std::this_thread::sleep_for(100ms);
+
+        // Disable allocations to verify that nothing in the fallback
+        // signal handler does an allocation.
+        malloc_disable();
+        raise_debugger_signal(dump_type);
+        _exit(0);
+      },
+      &seccomp_fork);
+
+  StartIntercept(&output_fd, dump_type);
+  FinishCrasher();
+  AssertDeath(0);
+  FinishIntercept(&intercept_result);
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_BACKTRACE_FRAME(result, "raise_debugger_signal");
+  ASSERT_BACKTRACE_FRAME(result, "foo");
+  ASSERT_BACKTRACE_FRAME(result, "bar");
+}
+
+TEST_F(CrasherTest, seccomp_backtrace_no_allocation) {
+  int intercept_result;
+  unique_fd output_fd;
+
+  static const auto dump_type = kDebuggerdNativeBacktrace;
+  StartProcess(
+      []() {
+        std::thread a(foo);
+        std::thread b(bar);
+
+        std::this_thread::sleep_for(100ms);
+
+        // Disable allocations to verify that nothing in the fallback
+        // signal handler does an allocation.
+        malloc_disable();
+        raise_debugger_signal(dump_type);
+        _exit(0);
+      },
+      &seccomp_fork);
+
+  StartIntercept(&output_fd, dump_type);
+  FinishCrasher();
+  AssertDeath(0);
+  FinishIntercept(&intercept_result);
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  ASSERT_BACKTRACE_FRAME(result, "raise_debugger_signal");
+  ASSERT_BACKTRACE_FRAME(result, "foo");
+  ASSERT_BACKTRACE_FRAME(result, "bar");
+}
+
 TEST_F(CrasherTest, competing_tracer) {
   int intercept_result;
   unique_fd output_fd;
diff --git a/debuggerd/handler/debuggerd_fallback.cpp b/debuggerd/handler/debuggerd_fallback.cpp
index 4721391ef58b..8ab5f253fcc7 100644
--- a/debuggerd/handler/debuggerd_fallback.cpp
+++ b/debuggerd/handler/debuggerd_fallback.cpp
@@ -48,50 +48,69 @@ using android::base::unique_fd;
 extern "C" bool __linker_enable_fallback_allocator();
 extern "C" void __linker_disable_fallback_allocator();
 
-// This is incredibly sketchy to do inside of a signal handler, especially when libbacktrace
-// uses the C++ standard library throughout, but this code runs in the linker, so we'll be using
-// the linker's malloc instead of the libc one. Switch it out for a replacement, just in case.
-//
-// This isn't the default method of dumping because it can fail in cases such as address space
-// exhaustion.
-static void debuggerd_fallback_trace(int output_fd, ucontext_t* ucontext) {
-  if (!__linker_enable_fallback_allocator()) {
-    async_safe_format_log(ANDROID_LOG_ERROR, "libc", "fallback allocator already in use");
-    return;
+// This file implements a fallback path for processes that do not allow the
+// normal fork and exec of crash_dump to handle crashes/unwinds.
+// The issue is that all of this happens from within a signal handler, which
+// can cause problems since this code uses the linker allocator which is not
+// thread safe. In order to avoid any problems allocating, the code calls
+// a function to switch to use a fallback allocator in the linker that will
+// only be used for the current thread. All of the libunwindstack code does
+// allocations using C++ stl, but should be fine since the code runs in the
+// linker and should use the fallback handler.
+
+// This method can still fail if the virtual space is exhausted on a 32 bit
+// process or mmap failing due to hitting the maximum number of maps (65535
+// total maps) on a 64 bit process.
+
+// Class to handle automatically turning on and off the fallback allocator.
+class ScopedUseFallbackAllocator {
+ public:
+  ScopedUseFallbackAllocator() { Enable(); }
+
+  ~ScopedUseFallbackAllocator() { Disable(); }
+
+  bool Enable() {
+    if (!enabled_) {
+      enabled_ = __linker_enable_fallback_allocator();
+      if (!enabled_) {
+        async_safe_format_log(ANDROID_LOG_ERROR, "libc",
+                              "Unable to enable fallback allocator, already in use.");
+      }
+    }
+    return enabled_;
   }
 
-  {
-    std::unique_ptr<unwindstack::Regs> regs;
-
-    ThreadInfo thread;
-    thread.pid = getpid();
-    thread.tid = gettid();
-    thread.thread_name = get_thread_name(gettid());
-    thread.registers.reset(
-        unwindstack::Regs::CreateFromUcontext(unwindstack::Regs::CurrentArch(), ucontext));
-
-    // Do not use the thread cache here because it will call pthread_key_create
-    // which doesn't work in linker code. See b/189803009.
-    // Use a normal cached object because the thread is stopped, and there
-    // is no chance of data changing between reads.
-    auto process_memory = unwindstack::Memory::CreateProcessMemoryCached(getpid());
-    // TODO: Create this once and store it in a global?
-    unwindstack::AndroidLocalUnwinder unwinder(process_memory);
-    dump_backtrace_thread(output_fd, &unwinder, thread);
+  void Disable() {
+    if (enabled_) {
+      __linker_disable_fallback_allocator();
+      enabled_ = false;
+    }
   }
-  __linker_disable_fallback_allocator();
-}
 
-static void debuggerd_fallback_tombstone(int output_fd, int proto_fd, ucontext_t* ucontext,
-                                         siginfo_t* siginfo, void* abort_message) {
-  if (!__linker_enable_fallback_allocator()) {
-    async_safe_format_log(ANDROID_LOG_ERROR, "libc", "fallback allocator already in use");
-    return;
-  }
+  bool enabled() { return enabled_; }
 
-  engrave_tombstone_ucontext(output_fd, proto_fd, reinterpret_cast<uintptr_t>(abort_message),
-                             siginfo, ucontext);
-  __linker_disable_fallback_allocator();
+ private:
+  bool enabled_ = false;
+};
+
+static void debuggerd_fallback_trace(int output_fd, ucontext_t* ucontext) {
+  std::unique_ptr<unwindstack::Regs> regs;
+
+  ThreadInfo thread;
+  thread.pid = getpid();
+  thread.tid = gettid();
+  thread.thread_name = get_thread_name(gettid());
+  thread.registers.reset(
+      unwindstack::Regs::CreateFromUcontext(unwindstack::Regs::CurrentArch(), ucontext));
+
+  // Do not use the thread cache here because it will call pthread_key_create
+  // which doesn't work in linker code. See b/189803009.
+  // Use a normal cached object because the thread is stopped, and there
+  // is no chance of data changing between reads.
+  auto process_memory = unwindstack::Memory::CreateProcessMemoryCached(getpid());
+  // TODO: Create this once and store it in a global?
+  unwindstack::AndroidLocalUnwinder unwinder(process_memory);
+  dump_backtrace_thread(output_fd, &unwinder, thread);
 }
 
 static bool forward_output(int src_fd, int dst_fd, pid_t expected_tid) {
@@ -154,6 +173,11 @@ static std::pair<pid_t, int> unpack_thread_fd(uint64_t value) {
 }
 
 static void trace_handler(siginfo_t* info, ucontext_t* ucontext) {
+  ScopedUseFallbackAllocator allocator;
+  if (!allocator.enabled()) {
+    return;
+  }
+
   static std::atomic<uint64_t> trace_output(pack_thread_fd(-1, -1));
 
   if (info->si_value.sival_ptr == kDebuggerdFallbackSivalPtrRequestDump) {
@@ -181,6 +205,11 @@ static void trace_handler(siginfo_t* info, ucontext_t* ucontext) {
       async_safe_format_log(ANDROID_LOG_ERROR, "libc", "failed to write to output fd");
     }
 
+    // Stop using the fallback allocator before the close. This will prevent
+    // a race condition where the thread backtracing all of the threads tries
+    // to re-acquire the fallback allocator.
+    allocator.Disable();
+
     close(fd);
     return;
   }
@@ -210,10 +239,15 @@ static void trace_handler(siginfo_t* info, ucontext_t* ucontext) {
 
   // Send a signal to all of our siblings, asking them to dump their stack.
   pid_t current_tid = gettid();
-  if (!iterate_tids(current_tid, [&output_fd, &current_tid](pid_t tid) {
+  if (!iterate_tids(current_tid, [&allocator, &output_fd, &current_tid](pid_t tid) {
         if (current_tid == tid) {
           return;
         }
+
+        if (!allocator.enabled()) {
+          return;
+        }
+
         // Use a pipe, to be able to detect situations where the thread gracefully exits before
         // receiving our signal.
         unique_fd pipe_read, pipe_write;
@@ -233,22 +267,29 @@ static void trace_handler(siginfo_t* info, ucontext_t* ucontext) {
           return;
         }
 
+        // Disable our use of the fallback allocator while the target thread
+        // is getting the backtrace.
+        allocator.Disable();
+
         siginfo_t siginfo = {};
         siginfo.si_code = SI_QUEUE;
         siginfo.si_value.sival_ptr = kDebuggerdFallbackSivalPtrRequestDump;
         siginfo.si_pid = getpid();
         siginfo.si_uid = getuid();
 
-        if (syscall(__NR_rt_tgsigqueueinfo, getpid(), tid, BIONIC_SIGNAL_DEBUGGER, &siginfo) != 0) {
+        if (syscall(__NR_rt_tgsigqueueinfo, getpid(), tid, BIONIC_SIGNAL_DEBUGGER, &siginfo) == 0) {
+          if (!forward_output(pipe_read.get(), output_fd.get(), tid)) {
+            async_safe_format_log(ANDROID_LOG_ERROR, "libc",
+                                  "timeout expired while waiting for thread %d to dump", tid);
+          }
+        } else {
           async_safe_format_log(ANDROID_LOG_ERROR, "libc", "failed to send trace signal to %d: %s",
                                 tid, strerror(errno));
-          return;
         }
 
-        bool success = forward_output(pipe_read.get(), output_fd.get(), tid);
-        if (!success) {
-          async_safe_format_log(ANDROID_LOG_ERROR, "libc",
-                                "timeout expired while waiting for thread %d to dump", tid);
+        // The thread should be finished now, so try and re-enable the fallback allocator.
+        if (!allocator.Enable()) {
+          return;
         }
 
         // Regardless of whether the poll succeeds, check to see if the thread took fd ownership.
@@ -260,14 +301,15 @@ static void trace_handler(siginfo_t* info, ucontext_t* ucontext) {
             close(fd);
           }
         }
-
-        return;
       })) {
     async_safe_format_log(ANDROID_LOG_ERROR, "libc", "failed to open /proc/%d/task: %s",
                           current_tid, strerror(errno));
   }
 
-  dump_backtrace_footer(output_fd.get());
+  if (allocator.enabled()) {
+    dump_backtrace_footer(output_fd.get());
+  }
+
   tombstoned_notify_completion(tombstone_socket.get());
 }
 
@@ -295,7 +337,13 @@ static void crash_handler(siginfo_t* info, ucontext_t* ucontext, void* abort_mes
   unique_fd tombstone_socket, output_fd, proto_fd;
   bool tombstoned_connected = tombstoned_connect(getpid(), &tombstone_socket, &output_fd, &proto_fd,
                                                  kDebuggerdTombstoneProto);
-  debuggerd_fallback_tombstone(output_fd.get(), proto_fd.get(), ucontext, info, abort_message);
+  {
+    ScopedUseFallbackAllocator allocator;
+    if (allocator.enabled()) {
+      engrave_tombstone_ucontext(output_fd.get(), proto_fd.get(),
+                                 reinterpret_cast<uintptr_t>(abort_message), info, ucontext);
+    }
+  }
   if (tombstoned_connected) {
     tombstoned_notify_completion(tombstone_socket.get());
   }

From d694b615916468b3a519eba381a3c1e49fd82b8f Mon Sep 17 00:00:00 2001
From: Alice Wang <aliceywang@google.com>
Date: Mon, 2 Sep 2024 13:03:48 +0000
Subject: [PATCH 1095/1487] [km] Include non-secure KM HAL with Trusty VM in
 /system_ext

Bug: 355194622
Test: launch_cvd --noresume --console=true \
     --extra_kernel_cmdline='androidboot.selinux=permissive' \
     --secure_hals=guest_keymint_trusty_insecure
Change-Id: I1ecdca049cfd6d33caf98f95d1260083bed2c155
---
 trusty/keymint/Android.bp                     |  6 ++-
 ...nt-service.rust.trusty.system.nonsecure.rc | 17 ++++++++
 trusty/keymint/trusty-keymint.mk              | 43 +++++++++++++++++++
 trusty/trusty-base.mk                         | 14 +-----
 4 files changed, 65 insertions(+), 15 deletions(-)
 create mode 100644 trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
 create mode 100644 trusty/keymint/trusty-keymint.mk

diff --git a/trusty/keymint/Android.bp b/trusty/keymint/Android.bp
index 1b87d806f277..5cdd381e1a2e 100644
--- a/trusty/keymint/Android.bp
+++ b/trusty/keymint/Android.bp
@@ -20,7 +20,6 @@ package {
 rust_defaults {
     name: "android.hardware.security.keymint-service.rust.trusty.default",
     relative_install_path: "hw",
-    vendor: true,
     srcs: [
         "src/keymint_hal_main.rs",
     ],
@@ -39,6 +38,7 @@ rust_defaults {
 
 rust_binary {
     name: "android.hardware.security.keymint-service.rust.trusty",
+    vendor: true,
     defaults: ["android.hardware.security.keymint-service.rust.trusty.default"],
     init_rc: ["android.hardware.security.keymint-service.rust.trusty.rc"],
     vintf_fragments: ["android.hardware.security.keymint-service.rust.trusty.xml"],
@@ -48,8 +48,10 @@ rust_binary {
 }
 
 rust_binary {
-    name: "android.hardware.security.keymint-service.rust.trusty.nonsecure",
+    name: "android.hardware.security.keymint-service.rust.trusty.system.nonsecure",
+    system_ext_specific: true,
     defaults: ["android.hardware.security.keymint-service.rust.trusty.default"],
+    init_rc: ["android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc"],
     features: ["nonsecure"],
     rustlibs: [
         "libkmr_hal_nonsecure",
diff --git a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
new file mode 100644
index 000000000000..318c13b45b18
--- /dev/null
+++ b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
@@ -0,0 +1,17 @@
+service system.keymint.rust-trusty.nonsecure \
+  /system_ext/bin/hw/android.hardware.security.keymint-service.rust.trusty.system.nonsecure \
+  --dev ${ro.hardware.trusty_ipc_dev.keymint:-/dev/trusty-ipc-dev0}
+    disabled
+    user nobody
+    group drmrpc
+    # The keymint service is not allowed to restart.
+    # If it crashes, a device restart is required.
+    oneshot
+
+# Only starts the non-secure KeyMint HALs when the KeyMint VM feature is enabled
+# TODO(b/357821690): Start the KeyMint HALs when the KeyMint VM is ready once the Trusty VM
+# has a mechanism to notify the host.
+on late-fs && property:ro.hardware.security.keymint.trusty.system=1 && \
+   property:ro.hardware.trusty_vm_cid=*
+    setprop ro.hardware.trusty_ipc_dev.keymint VSOCK:${ro.hardware.trusty_vm_cid}:1
+    start system.keymint.rust-trusty.nonsecure
diff --git a/trusty/keymint/trusty-keymint.mk b/trusty/keymint/trusty-keymint.mk
new file mode 100644
index 000000000000..d5791eab2011
--- /dev/null
+++ b/trusty/keymint/trusty-keymint.mk
@@ -0,0 +1,43 @@
+#
+# Copyright (C) 2024 The Android Open-Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+#
+# This makefile should be included by devices that use Trusty TEE
+# to pull in a set of Trusty KeyMint specific modules.
+#
+# Allow KeyMint HAL service implementation selection at build time. This must be
+# synchronized with the TA implementation included in Trusty. Possible values:
+#
+# - Rust implementation for Trusty VM (requires Trusty VM support):
+#   export TRUSTY_KEYMINT_IMPL=rust
+#   export TRUSTY_SYSTEM_VM=nonsecure
+# - Rust implementation for Trusty TEE (no Trusty VM support):
+#   export TRUSTY_KEYMINT_IMPL=rust
+# - C++ implementation (default): (any other value or unset TRUSTY_KEYMINT_IMPL)
+
+ifeq ($(TRUSTY_KEYMINT_IMPL),rust)
+    ifeq ($(TRUSTY_SYSTEM_VM),nonsecure)
+        LOCAL_KEYMINT_PRODUCT_PACKAGE := android.hardware.security.keymint-service.rust.trusty.system.nonsecure
+    else
+        LOCAL_KEYMINT_PRODUCT_PACKAGE := android.hardware.security.keymint-service.rust.trusty
+    endif
+else
+    # Default to the C++ implementation
+    LOCAL_KEYMINT_PRODUCT_PACKAGE := android.hardware.security.keymint-service.trusty
+endif
+
+PRODUCT_PACKAGES += \
+    $(LOCAL_KEYMINT_PRODUCT_PACKAGE) \
diff --git a/trusty/trusty-base.mk b/trusty/trusty-base.mk
index b21eca6df824..9d810dcb7fc6 100644
--- a/trusty/trusty-base.mk
+++ b/trusty/trusty-base.mk
@@ -22,18 +22,7 @@
 # For gatekeeper, we include the generic -service and -impl to use legacy
 # HAL loading of gatekeeper.trusty.
 
-# Allow the KeyMint HAL service implementation to be selected at build time.  This needs to be
-# done in sync with the TA implementation included in Trusty.  Possible values are:
-#
-# - Rust implementation:   export TRUSTY_KEYMINT_IMPL=rust
-# - C++ implementation:    (any other value of TRUSTY_KEYMINT_IMPL)
-
-ifeq ($(TRUSTY_KEYMINT_IMPL),rust)
-    LOCAL_KEYMINT_PRODUCT_PACKAGE := android.hardware.security.keymint-service.rust.trusty
-else
-    # Default to the C++ implementation
-    LOCAL_KEYMINT_PRODUCT_PACKAGE := android.hardware.security.keymint-service.trusty
-endif
+$(call inherit-product, system/core/trusty/keymint/trusty-keymint.mk)
 
 ifeq ($(SECRETKEEPER_ENABLED),true)
     LOCAL_SECRETKEEPER_PRODUCT_PACKAGE := android.hardware.security.secretkeeper.trusty
@@ -42,7 +31,6 @@ else
 endif
 
 PRODUCT_PACKAGES += \
-	$(LOCAL_KEYMINT_PRODUCT_PACKAGE) \
 	$(LOCAL_SECRETKEEPER_PRODUCT_PACKAGE) \
 	android.hardware.gatekeeper-service.trusty \
 	trusty_apploader \

From 3217fa2158b6f4d277d274026724d45780c7046d Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 3 Sep 2024 19:17:52 -0700
Subject: [PATCH 1096/1487] fs_mgr: Add support for MS_LAZYTIME.

"lazytime" as a mount option was removed recently in favor of
MS_LAZYTIME.  This is causing mount failures when calling
IVold::commitChanges.

Bug: 329657783
Test: cuttlefish on android-mainline
Change-Id: Id01c1e5bbd0c82e07126be65f638e16600c058e3
---
 fs_mgr/libfstab/fstab.cpp    | 5 +++++
 fs_mgr/tests/fs_mgr_test.cpp | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index 21d2e2ef37f0..d344b2d198fc 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -39,6 +39,10 @@
 #include "fstab_priv.h"
 #include "logging_macros.h"
 
+#if !defined(MS_LAZYTIME)
+#define MS_LAZYTIME (1 << 25)
+#endif
+
 using android::base::EndsWith;
 using android::base::ParseByteCount;
 using android::base::ParseInt;
@@ -74,6 +78,7 @@ FlagList kMountFlagsList[] = {
         {"private", MS_PRIVATE},
         {"slave", MS_SLAVE},
         {"shared", MS_SHARED},
+        {"lazytime", MS_LAZYTIME},
         {"defaults", 0},
 };
 
diff --git a/fs_mgr/tests/fs_mgr_test.cpp b/fs_mgr/tests/fs_mgr_test.cpp
index 322bf1b08930..0aa3a1afdcfb 100644
--- a/fs_mgr/tests/fs_mgr_test.cpp
+++ b/fs_mgr/tests/fs_mgr_test.cpp
@@ -37,6 +37,10 @@
 using namespace android::fs_mgr;
 using namespace testing;
 
+#if !defined(MS_LAZYTIME)
+#define MS_LAZYTIME (1 << 25)
+#endif
+
 namespace {
 
 const std::string cmdline =
@@ -329,6 +333,7 @@ TEST(fs_mgr, fs_mgr_read_fstab_file_proc_mounts) {
                 {"private", MS_PRIVATE},
                 {"slave", MS_SLAVE},
                 {"shared", MS_SHARED},
+                {"lazytime", MS_LAZYTIME},
                 {"defaults", 0},
                 {0, 0},
         };

From 4f13b13aac146c87f1dbba3bbd877eaa4129b26f Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Wed, 4 Sep 2024 17:34:25 -0700
Subject: [PATCH 1097/1487] [fastboot+init] avoid std::allocator<const T>

std::vector<const T> uses std::allocator<const T>, which is an
undocumented libc++ extension to the C++ standard library. The extension
was removed in llvm.org/PR96319. Use an ordinary non-const T instead.

Bug: http://b/349681543
Test: m fuzzy_fastboot CtsInitTestCases
Test: m MODULES-IN-system-core
Flag: EXEMPT, refactor to fix build failure
Change-Id: Ia98a2f090e87541fd35a89bd75bf9638bc7dc711
---
 fastboot/fuzzy_fastboot/transport_sniffer.cpp |  2 +-
 init/keychords_test.cpp                       | 21 +++++++++----------
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/fastboot/fuzzy_fastboot/transport_sniffer.cpp b/fastboot/fuzzy_fastboot/transport_sniffer.cpp
index b55ffd31a888..0aef350052e1 100644
--- a/fastboot/fuzzy_fastboot/transport_sniffer.cpp
+++ b/fastboot/fuzzy_fastboot/transport_sniffer.cpp
@@ -90,7 +90,7 @@ std::string TransportSniffer::CreateTrace() {
     // and be printed as a string, or just a raw byte-buffer
     const auto msg = [&ret, no_print](const std::vector<char>& buf) {
         ret += android::base::StringPrintf("(%lu bytes): ", buf.size());
-        std::vector<const char>::iterator iter = buf.end();
+        std::vector<char>::const_iterator iter = buf.end();
         const unsigned max_chars = 50;
         if (buf.size() > max_chars) {
             iter = buf.begin() + max_chars;
diff --git a/init/keychords_test.cpp b/init/keychords_test.cpp
index 5789bf58b924..2b1d42831a7f 100644
--- a/init/keychords_test.cpp
+++ b/init/keychords_test.cpp
@@ -168,16 +168,16 @@ const std::vector<int> escape_chord = {KEY_ESC};
 const std::vector<int> triple1_chord = {KEY_BACKSPACE, KEY_VOLUMEDOWN, KEY_VOLUMEUP};
 const std::vector<int> triple2_chord = {KEY_VOLUMEDOWN, KEY_VOLUMEUP, KEY_BACK};
 
-const std::vector<const std::vector<int>> empty_chords;
-const std::vector<const std::vector<int>> chords = {
-    escape_chord,
-    triple1_chord,
-    triple2_chord,
+const std::vector<std::vector<int>> empty_chords;
+const std::vector<std::vector<int>> chords = {
+        escape_chord,
+        triple1_chord,
+        triple2_chord,
 };
 
 class TestFrame {
   public:
-    TestFrame(const std::vector<const std::vector<int>>& chords, EventHandler* ev = nullptr);
+    TestFrame(const std::vector<std::vector<int>>& chords, EventHandler* ev = nullptr);
 
     void RelaxForMs(std::chrono::milliseconds wait = 1ms);
 
@@ -194,16 +194,15 @@ class TestFrame {
     std::string Format() const;
 
   private:
-    static std::string Format(const std::vector<const std::vector<int>>& chords);
+    static std::string Format(const std::vector<std::vector<int>>& chords);
 
     Epoll epoll_;
     Keychords keychords_;
-    std::vector<const std::vector<int>> keycodes_;
+    std::vector<std::vector<int>> keycodes_;
     EventHandler* ev_;
 };
 
-TestFrame::TestFrame(const std::vector<const std::vector<int>>& chords, EventHandler* ev)
-    : ev_(ev) {
+TestFrame::TestFrame(const std::vector<std::vector<int>>& chords, EventHandler* ev) : ev_(ev) {
     if (!epoll_.Open().ok()) return;
     for (const auto& keycodes : chords) keychords_.Register(keycodes);
     keychords_.Start(&epoll_, [this](const std::vector<int>& keycodes) {
@@ -262,7 +261,7 @@ void TestFrame::WaitForChord(const std::vector<int>& chord) {
     for (int retry = 1000; retry && !IsChord(chord); --retry) RelaxForMs();
 }
 
-std::string TestFrame::Format(const std::vector<const std::vector<int>>& chords) {
+std::string TestFrame::Format(const std::vector<std::vector<int>>& chords) {
     std::string ret("{");
     if (!chords.empty()) {
         ret += android::base::Join(chords.front(), ' ');

From 81c5e02b50ca8e3c2e3fbf83c196f3ca4b791b6c Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 5 Sep 2024 13:54:12 -0700
Subject: [PATCH 1098/1487] snapshotctl: Check device for -img path

If the device exists only on /data, then the image path should
be checked with -img.

Bug: 330744468
Test: snapshotctl apply-update
Change-Id: I64ff7d803fdaaa02d2d6929994ad1124bfffab8b
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshotctl.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 23c3ccf58126..97a8cb21054a 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -255,6 +255,8 @@ bool MapSnapshots::GetCowDevicePath(std::string partition_name, std::string* cow
     }
 
     LOG(INFO) << "Failed to find cow path: " << cow_device << " Checking the device for -img path";
+    // If the COW device exists only on /data
+    cow_device = partition_name + "-cow-img";
     if (!dm.GetDmDevicePathByName(cow_device, cow_path)) {
         LOG(ERROR) << "Failed to cow path: " << cow_device;
         return false;

From dfca1f129eee397bd5641f35559337d4afbe5680 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 5 Sep 2024 22:56:36 +0000
Subject: [PATCH 1099/1487] Reland Skip F2FS formatting for dev option enabled
 devices

F2FS does not support page_size!=block_size configuration, and
dev option devices need to toggle between 4K/16K mode, hence F2FS
requires a data wipe every time page size changes. This is inconveinent,
skip F2FS formatting instead.

The original CL had a bug where `iter->blk_device` is accessed before
checking if `iter` is out of bounds. Fixed by flipping order of two
conditions in an && operator.

Test: th
Bug: 353436188

This reverts commit 642a98e2a77d3398269d588ca16e99dcdaeb68d5.

Change-Id: I89551f219efc44bad29a190edff5412a5cc67840
---
 fs_mgr/fs_mgr.cpp | 67 ++++++++++++++++++++++++++++++++++-------------
 1 file changed, 49 insertions(+), 18 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 76578dd2ccf7..fbd990b96fbd 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -38,10 +38,8 @@
 
 #include <array>
 #include <chrono>
-#include <functional>
 #include <map>
 #include <memory>
-#include <numeric>
 #include <string>
 #include <string_view>
 #include <thread>
@@ -66,6 +64,7 @@
 #include <fs_mgr/file_wait.h>
 #include <fs_mgr_overlayfs.h>
 #include <fscrypt/fscrypt.h>
+#include <fstab/fstab.h>
 #include <libdm/dm.h>
 #include <libdm/loop_control.h>
 #include <liblp/metadata_format.h>
@@ -82,7 +81,7 @@
 #define F2FS_FSCK_BIN   "/system/bin/fsck.f2fs"
 #define MKSWAP_BIN      "/system/bin/mkswap"
 #define TUNE2FS_BIN     "/system/bin/tune2fs"
-#define RESIZE2FS_BIN "/system/bin/resize2fs"
+#define RESIZE2FS_BIN   "/system/bin/resize2fs"
 
 #define FSCK_LOG_FILE   "/dev/fscklogs/log"
 
@@ -138,8 +137,8 @@ enum FsStatFlags {
 static void log_fs_stat(const std::string& blk_device, int fs_stat) {
     std::string msg =
             android::base::StringPrintf("\nfs_stat,%s,0x%x\n", blk_device.c_str(), fs_stat);
-    android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(FSCK_LOG_FILE, O_WRONLY | O_CLOEXEC |
-                                                        O_APPEND | O_CREAT, 0664)));
+    android::base::unique_fd fd(TEMP_FAILURE_RETRY(
+            open(FSCK_LOG_FILE, O_WRONLY | O_CLOEXEC | O_APPEND | O_CREAT, 0664)));
     if (fd == -1 || !android::base::WriteStringToFd(msg, fd)) {
         LWARNING << __FUNCTION__ << "() cannot log " << msg;
     }
@@ -593,7 +592,7 @@ static void tune_metadata_csum(const std::string& blk_device, const FstabEntry&
 
     // Must give `-T now` to prevent last_fsck_time from growing too large,
     // otherwise, tune2fs won't enable metadata_csum.
-    const char* tune2fs_args[] = {TUNE2FS_BIN, "-O",        "metadata_csum,64bit,extent",
+    const char* tune2fs_args[] = {TUNE2FS_BIN, "-O",  "metadata_csum,64bit,extent",
                                   "-T",        "now", blk_device.c_str()};
     const char* resize2fs_args[] = {RESIZE2FS_BIN, "-b", blk_device.c_str()};
 
@@ -1430,6 +1429,37 @@ bool WasMetadataEncryptionInterrupted(const FstabEntry& entry) {
     return access(fs_mgr_metadata_encryption_in_progress_file_name(entry).c_str(), R_OK) == 0;
 }
 
+static FstabEntry* LocateFormattableEntry(FstabEntry* const begin, FstabEntry* const end) {
+    if (begin == end) {
+        return nullptr;
+    }
+    const bool dev_option_enabled =
+            android::base::GetBoolProperty("ro.product.build.16k_page.enabled", false);
+    FstabEntry* f2fs_entry = nullptr;
+    for (auto iter = begin; iter != end && iter->blk_device == begin->blk_device; iter++) {
+        if (iter->fs_mgr_flags.formattable) {
+            if (getpagesize() != 4096 && is_f2fs(iter->fs_type) && dev_option_enabled) {
+                f2fs_entry = iter;
+                continue;
+            }
+            if (f2fs_entry) {
+                LOG(INFO) << "Skipping F2FS format for block device " << iter->blk_device << " @ "
+                          << iter->mount_point
+                          << " in non-4K mode for dev option enabled devices, "
+                             "as these devices need to toggle between 4K/16K mode, and F2FS does "
+                             "not support page_size != block_size configuration.";
+            }
+            return iter;
+        }
+    }
+    if (f2fs_entry) {
+        LOG(INFO) << "Using F2FS for " << f2fs_entry->blk_device << " @ " << f2fs_entry->mount_point
+                  << " even though we are in non-4K mode. Device might require a data wipe after "
+                     "going back to 4K mode, as F2FS does not support page_size != block_size";
+    }
+    return f2fs_entry;
+}
+
 // When multiple fstab records share the same mount_point, it will try to mount each
 // one in turn, and ignore any duplicates after a first successful mount.
 // Returns -1 on error, and  FS_MGR_MNTALL_* otherwise.
@@ -1540,8 +1570,8 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
             }
         }
 
-        int last_idx_inspected;
-        int top_idx = i;
+        int last_idx_inspected = -1;
+        const int top_idx = i;
         int attempted_idx = -1;
 
         bool encryption_interrupted = WasMetadataEncryptionInterrupted(current_entry);
@@ -1591,7 +1621,8 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
             // Success!  Go get the next one.
             continue;
         }
-
+        auto formattable_entry =
+                LocateFormattableEntry(fstab->data() + top_idx, fstab->data() + fstab->size());
         // Mounting failed, understand why and retry.
         wiped = partition_wiped(current_entry.blk_device.c_str());
         if (mount_errno != EBUSY && mount_errno != EACCES &&
@@ -1619,12 +1650,12 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                 encryptable = FS_MGR_MNTALL_DEV_IS_METADATA_ENCRYPTED;
                 set_type_property(encryptable);
 
-                if (!call_vdc({"cryptfs", "encryptFstab", current_entry.blk_device,
-                               current_entry.mount_point, "true" /* shouldFormat */,
-                               current_entry.fs_type,
-                               current_entry.fs_mgr_flags.is_zoned ? "true" : "false",
-                               std::to_string(current_entry.length),
-                               android::base::Join(current_entry.user_devices, ' ')},
+                if (!call_vdc({"cryptfs", "encryptFstab", formattable_entry->blk_device,
+                               formattable_entry->mount_point, "true" /* shouldFormat */,
+                               formattable_entry->fs_type,
+                               formattable_entry->fs_mgr_flags.is_zoned ? "true" : "false",
+                               std::to_string(formattable_entry->length),
+                               android::base::Join(formattable_entry->user_devices, ' ')},
                               nullptr)) {
                     LERROR << "Encryption failed";
                 } else {
@@ -1633,7 +1664,7 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                 }
             }
 
-            if (fs_mgr_do_format(current_entry) == 0) {
+            if (fs_mgr_do_format(*formattable_entry) == 0) {
                 // Let's replay the mount actions.
                 i = top_idx - 1;
                 continue;
@@ -1749,12 +1780,12 @@ int fs_mgr_do_mount_one(const FstabEntry& entry, const std::string& alt_mount_po
     int ret = prepare_fs_for_mount(entry.blk_device, entry, mount_point);
     // Wiped case doesn't require to try __mount below.
     if (ret & FS_STAT_INVALID_MAGIC) {
-      return FS_MGR_DOMNT_FAILED;
+        return FS_MGR_DOMNT_FAILED;
     }
 
     ret = __mount(entry.blk_device, mount_point, entry);
     if (ret) {
-      ret = (errno == EBUSY) ? FS_MGR_DOMNT_BUSY : FS_MGR_DOMNT_FAILED;
+        ret = (errno == EBUSY) ? FS_MGR_DOMNT_BUSY : FS_MGR_DOMNT_FAILED;
     }
 
     return ret;

From 43997540358e3cf522aa0ee96b0ab09406fb692b Mon Sep 17 00:00:00 2001
From: terryguan <terryguan@google.com>
Date: Thu, 5 Sep 2024 17:35:41 -0700
Subject: [PATCH 1100/1487] init: add a swapoff built-in command

Enables a method for swapping off certain block devices or files. This
will be used before hibernation occurs.

Bug: 339688542
Test: Manual, verified that calling swapoff from a init file swapsoff
location that is specified

Change-Id: I212a6f303a023c3e440b557caae82ad3904ac9c9
---
 init/README.md    | 4 +++-
 init/builtins.cpp | 9 +++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/init/README.md b/init/README.md
index 0bb26e891d69..3a2da90d488c 100644
--- a/init/README.md
+++ b/init/README.md
@@ -745,6 +745,9 @@ provides the `aidl_lazy_test_1` interface.
   fstab.${ro.hardware} or fstab.${ro.hardware.platform} will be scanned for
   under /odm/etc, /vendor/etc, or / at runtime, in that order.
 
+`swapoff <path>`
+> Stops swapping to the file or block device specified by path.
+
 `symlink <target> <path>`
 > Create a symbolic link at _path_ with the value _target_
 
@@ -788,7 +791,6 @@ provides the `aidl_lazy_test_1` interface.
   If the file does not exist, it will be created. If it does exist,
   it will be truncated. Properties are expanded within _content_.
 
-
 Imports
 -------
 `import <path>`
diff --git a/init/builtins.cpp b/init/builtins.cpp
index 606ea8c0aacf..f743a30e0291 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -36,6 +36,7 @@
 #include <sys/resource.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
+#include <sys/swap.h>
 #include <sys/syscall.h>
 #include <sys/system_properties.h>
 #include <sys/time.h>
@@ -1316,6 +1317,13 @@ static Result<void> do_enter_default_mount_ns(const BuiltinArguments& args) {
     return {};
 }
 
+static Result<void> do_swapoff(const BuiltinArguments& args) {
+    if (!swapoff(args[1].c_str())) {
+        return ErrnoError() << "swapoff() failed";
+    }
+    return {};
+}
+
 // Builtin-function-map start
 const BuiltinFunctionMap& GetBuiltinFunctionMap() {
     constexpr std::size_t kMax = std::numeric_limits<std::size_t>::max();
@@ -1372,6 +1380,7 @@ const BuiltinFunctionMap& GetBuiltinFunctionMap() {
         {"start",                   {1,     1,    {false,  do_start}}},
         {"stop",                    {1,     1,    {false,  do_stop}}},
         {"swapon_all",              {0,     1,    {false,  do_swapon_all}}},
+        {"swapoff",                 {1,     1,    {false,  do_swapoff}}},
         {"enter_default_mount_ns",  {0,     0,    {false,  do_enter_default_mount_ns}}},
         {"symlink",                 {2,     2,    {true,   do_symlink}}},
         {"sysclktz",                {1,     1,    {false,  do_sysclktz}}},

From be2cc9f93077ad024aa2aee31dd9ad5fa5873ecc Mon Sep 17 00:00:00 2001
From: Aditya Kumar <appujee@google.com>
Date: Thu, 5 Sep 2024 14:03:59 -0700
Subject: [PATCH 1101/1487] Fix type of android_thread_func typedef

Found the error with latest clang: https://android-build.corp.google.com/artifact/pending/P80448506/art-host-x86_64/latest/view/logs%2Fbuild_error.log

```
out/soong/.intermediates/system/core/libutils/libutils/linux_glibc_x86_64_static/obj/system/core/libutils/Threads.o system/core/libutils/Threads.cpp
system/core/libutils/Threads.cpp:149:21: error: cast from 'android_thread_func_t' (aka 'int (*)(void *)') to 'android_pthread_entry' (aka 'void *(*)(void *)') converts to incompatible function type [-Werror,-Wcast-function-type-mismatch]
  149 |                     (android_pthread_entry)entryFunction, userData);
      |                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 error generated.
```

Change-Id: Ie2423a568483c975a36a1fa0b06a3f93a27be5aa
---
 libutils/Threads.cpp | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/libutils/Threads.cpp b/libutils/Threads.cpp
index 0b96ab0bbcb8..d8d75acf4716 100644
--- a/libutils/Threads.cpp
+++ b/libutils/Threads.cpp
@@ -60,7 +60,7 @@ using namespace android;
  * We create it "detached", so it cleans up after itself.
  */
 
-typedef void* (*android_pthread_entry)(void*);
+typedef int (*android_pthread_entry)(void*);
 
 #if defined(__ANDROID__)
 struct thread_data_t {
@@ -88,6 +88,20 @@ struct thread_data_t {
 };
 #endif
 
+// Adapted from bionic's implmenetation of trampoline to make C11 thrd_create
+// work with pthread_create.
+struct libutil_thread_data {
+  android_pthread_entry _Nonnull entry_func;
+  void* _Nullable entry_func_arg;
+};
+
+static void* _Nonnull libutil_thread_trampoline(void* _Nonnull arg) {
+  libutil_thread_data *data_ptr = static_cast<libutil_thread_data*>(arg);
+  int result = data_ptr->entry_func(data_ptr->entry_func_arg);
+  delete data_ptr;
+  return reinterpret_cast<void*>(static_cast<uintptr_t>(result));
+}
+
 void androidSetThreadName(const char* name) {
 #if defined(__linux__)
     // Mac OS doesn't have this, and we build libutil for the host too
@@ -145,8 +159,13 @@ int androidCreateRawThreadEtc(android_thread_func_t entryFunction,
 
     errno = 0;
     pthread_t thread;
+
+    libutil_thread_data* pthread_arg = new libutil_thread_data;
+    pthread_arg->entry_func = entryFunction;
+    pthread_arg->entry_func_arg = userData;
+
     int result = pthread_create(&thread, &attr,
-                    (android_pthread_entry)entryFunction, userData);
+                    libutil_thread_trampoline, pthread_arg);
     pthread_attr_destroy(&attr);
     if (result != 0) {
         ALOGE("androidCreateRawThreadEtc failed (entry=%p, res=%d, %s)\n"

From 133fc74fa4870fddf34552e86d141ef52c981eee Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Fri, 6 Sep 2024 21:37:24 +0000
Subject: [PATCH 1102/1487] Remove unused variable.

Test: Builds with -Wunused-variable
Change-Id: Ibe6c28c8dd510303450f8400ba7d721fd5c44fc3
---
 fs_mgr/libsnapshot/scratch_super.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/scratch_super.cpp b/fs_mgr/libsnapshot/scratch_super.cpp
index 805abf3f9b04..93c4bbd994d0 100644
--- a/fs_mgr/libsnapshot/scratch_super.cpp
+++ b/fs_mgr/libsnapshot/scratch_super.cpp
@@ -98,7 +98,6 @@ bool CleanupScratchOtaMetadataIfPresent(const ISnapshotManager::IDeviceInfo* inf
     }
     const auto& opener = info->GetPartitionOpener();
     std::string slot_suffix = info->GetSlotSuffix();
-    int slot = SlotNumberForSlotSuffix(slot_suffix);
     // Walk both the slots and clean up metadata related to scratch space from
     // both the slots.
     for (auto slot : slots) {

From ced57af116652f4050a8cc3c75948f02d5334fff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= <arve@android.com>
Date: Mon, 9 Oct 2023 15:57:26 -0700
Subject: [PATCH 1103/1487] trusty: keymint/gatekeeper: Pass device name from
 init scripts

If the ro.hardware.trusty_ipc_dev.gatekeeper (respectively .keymint) property is set, pass it as the device name to the gatekeeper (respectively keymint) HALs.

Test: "setprop ro.hardware.trusty_ipc_dev VSOCK:2048:1" and restart HALs
Change-Id: I0947e532ac70ce1821cec49897f21ca10e1af03e
---
 .../gatekeeper/android.hardware.gatekeeper-service.trusty.rc | 3 ++-
 .../android.hardware.security.keymint-service.trusty.rc      | 3 ++-
 .../android.hardware.security.keymint-service.rust.trusty.rc | 5 +++--
 3 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/trusty/gatekeeper/android.hardware.gatekeeper-service.trusty.rc b/trusty/gatekeeper/android.hardware.gatekeeper-service.trusty.rc
index 66ecbd1f0a68..2c9bd8305594 100644
--- a/trusty/gatekeeper/android.hardware.gatekeeper-service.trusty.rc
+++ b/trusty/gatekeeper/android.hardware.gatekeeper-service.trusty.rc
@@ -1,4 +1,5 @@
-service vendor.gatekeeper_default /vendor/bin/hw/android.hardware.gatekeeper-service.trusty
+service vendor.gatekeeper_default /vendor/bin/hw/android.hardware.gatekeeper-service.trusty \
+                                          --dev ${ro.hardware.trusty_ipc_dev.gatekeeper:-/dev/trusty-ipc-dev0}
     class hal
     user system
     group system
diff --git a/trusty/keymaster/keymint/android.hardware.security.keymint-service.trusty.rc b/trusty/keymaster/keymint/android.hardware.security.keymint-service.trusty.rc
index 389af412f4f7..0ceb58416124 100644
--- a/trusty/keymaster/keymint/android.hardware.security.keymint-service.trusty.rc
+++ b/trusty/keymaster/keymint/android.hardware.security.keymint-service.trusty.rc
@@ -1,4 +1,5 @@
-service vendor.keymint-trusty /vendor/bin/hw/android.hardware.security.keymint-service.trusty
+service vendor.keymint-trusty /vendor/bin/hw/android.hardware.security.keymint-service.trusty \
+                                          --dev ${ro.hardware.trusty_ipc_dev.keymint:-/dev/trusty-ipc-dev0}
     class early_hal
     user nobody
     group drmrpc
diff --git a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.rc b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.rc
index e3d94c659328..3e3f2a5c3035 100644
--- a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.rc
+++ b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.rc
@@ -1,7 +1,8 @@
-service vendor.keymint.rust-trusty /vendor/bin/hw/android.hardware.security.keymint-service.rust.trusty
+service vendor.keymint.rust-trusty /vendor/bin/hw/android.hardware.security.keymint-service.rust.trusty \
+                                          --dev ${ro.hardware.trusty_ipc_dev.keymint:-/dev/trusty-ipc-dev0}
     class early_hal
     user nobody
     group drmrpc
     # The keymint service is not allowed to restart.
     # If it crashes, a device restart is required.
-    oneshot
\ No newline at end of file
+    oneshot

From c1ad204f85439063a6e058c285cb0bd4c519c890 Mon Sep 17 00:00:00 2001
From: Nelson Li <nelsonli@google.com>
Date: Tue, 10 Sep 2024 06:31:13 +0000
Subject: [PATCH 1104/1487] Rename system/core/rootdir/Android.mk to
 create_root_structure.mk

Since Soong currently doesn't support the `install_directory`
functionality, this file cannot be directly converted to Android.bp.
Moreover, the main content of `system/core/rootdir/Android.mk` is to
create directories and symlinks for the root file system. Therefore,
we'll first rename it and move it to build/core/main.mk for handling.

In addition, consolidate the handling of `meta-lic` related parts into
build/core/tasks/meta-lic.mk.

Bug: 353642907
Test: m -j init.environ.rc
Change-Id: I356c4b05c56b02b0243c12dbeddd4653ba4e137c
---
 rootdir/{Android.mk => create_root_structure.mk} | 2 --
 1 file changed, 2 deletions(-)
 rename rootdir/{Android.mk => create_root_structure.mk} (99%)

diff --git a/rootdir/Android.mk b/rootdir/create_root_structure.mk
similarity index 99%
rename from rootdir/Android.mk
rename to rootdir/create_root_structure.mk
index ac9ca857fc6f..1daf239b4d70 100644
--- a/rootdir/Android.mk
+++ b/rootdir/create_root_structure.mk
@@ -1,7 +1,5 @@
 LOCAL_PATH:= $(call my-dir)
 
-$(eval $(call declare-1p-copy-files,system/core/rootdir,))
-
 #######################################
 ifneq ($(filter address,$(SANITIZE_TARGET)),)
 ASAN_EXTRACT_FILES :=

From 0bec59c496ca3dcdd26f8d453fcd750bdc932b93 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 10 Sep 2024 15:47:17 +0000
Subject: [PATCH 1105/1487] Remind the reader that they'll need to modify CTS
 too.

Also duplicate the warning to the other set of updatable ids.

Bug: http://b/364993041
Change-Id: I128ddeb468c1f2f872772c9f2505a29f7537eb8a
---
 libcutils/include/private/android_filesystem_config.h | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/libcutils/include/private/android_filesystem_config.h b/libcutils/include/private/android_filesystem_config.h
index eeb0394172b2..b0bddf501674 100644
--- a/libcutils/include/private/android_filesystem_config.h
+++ b/libcutils/include/private/android_filesystem_config.h
@@ -143,7 +143,8 @@
 #define AID_PRNG_SEEDER 1092         /* PRNG seeder daemon */
 #define AID_UPROBESTATS 1093         /* uid for uprobestats */
 #define AID_CROS_EC 1094             /* uid for accessing ChromeOS EC (cros_ec) */
-/* Changes to this file must be made in AOSP, *not* in internal branches. */
+// Additions to this file must be made in AOSP, *not* in internal branches.
+// You will also need to update expect_ids() in bionic/tests/grp_pwd_test.cpp.
 
 #define AID_SHELL 2000 /* adb and debug shell user */
 #define AID_CACHE 2001 /* cache access */
@@ -158,7 +159,7 @@
 #define AID_OEM_RESERVED_START 2900
 #define AID_OEM_RESERVED_END 2999
 
-/* The 3000 series are intended for use as supplemental group id's only.
+/* The 3000 series are intended for use as supplemental group ids only.
  * They indicate special Android capabilities that the kernel is aware of. */
 #define AID_NET_BT_ADMIN 3001 /* bluetooth: create any socket */
 #define AID_NET_BT 3002       /* bluetooth: create sco, rfcomm or l2cap sockets */
@@ -172,6 +173,8 @@
 #define AID_UHID 3011         /* Allow read/write to /dev/uhid node */
 #define AID_READTRACEFS 3012  /* Allow tracefs read */
 #define AID_VIRTUALMACHINE 3013 /* Allows VMs to tune for performance*/
+// Additions to this file must be made in AOSP, *not* in internal branches.
+// You will also need to update expect_ids() in bionic/tests/grp_pwd_test.cpp.
 
 /* The range 5000-5999 is also reserved for vendor partition. */
 #define AID_OEM_RESERVED_2_START 5000

From 9ac82420cb501cc16e4431f3fc767877a9964bd0 Mon Sep 17 00:00:00 2001
From: Matt Gilbride <mattgilbride@google.com>
Date: Tue, 20 Aug 2024 21:23:22 +0000
Subject: [PATCH 1106/1487] Support vendor partition in non-debuggable pVMs

Use the existence of
/proc/device-tree/avf/vendor_hashtree_descriptor_root_digest (rather
than kernel param androidboot.microdroid.mount_vendor=1) to know if the
vendor partition is requested.

Bug: 340506965
Test: TH
Change-Id: I0ac1c773e44454fd9c52559d833dc8eca211889c
---
 init/first_stage_mount.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index ece430b70e21..c26b31e93441 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -156,6 +156,13 @@ static Result<Fstab> ReadFirstStageFstabAndroid() {
     return fstab;
 }
 
+static bool IsRequestingMicrodroidVendorPartition(const std::string& cmdline) {
+    if (virtualization::IsEnableTpuAssignableDeviceFlagEnabled()) {
+        return access("/proc/device-tree/avf/vendor_hashtree_descriptor_root_digest", F_OK) == 0;
+    }
+    return cmdline.find("androidboot.microdroid.mount_vendor=1") != std::string::npos;
+}
+
 // Note: this is a temporary solution to avoid blocking devs that depend on /vendor partition in
 // Microdroid. For the proper solution the /vendor fstab should probably be defined in the DT.
 // TODO(b/285855430): refactor this
@@ -166,7 +173,7 @@ static Result<Fstab> ReadFirstStageFstabMicrodroid(const std::string& cmdline) {
     if (!ReadDefaultFstab(&fstab)) {
         return Error() << "failed to read fstab";
     }
-    if (cmdline.find("androidboot.microdroid.mount_vendor=1") == std::string::npos) {
+    if (!IsRequestingMicrodroidVendorPartition(cmdline)) {
         // We weren't asked to mount /vendor partition, filter it out from the fstab.
         auto predicate = [](const auto& entry) { return entry.mount_point == "/vendor"; };
         fstab.erase(std::remove_if(fstab.begin(), fstab.end(), predicate), fstab.end());

From b17d7be2e55fc8b866bacbc88d8059b7088dc14c Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 11 Sep 2024 16:23:18 +0000
Subject: [PATCH 1107/1487] debuggerd: recognize jumps to non-executable
 memory.

We have fairly fancy detection of stack pointer issues, but nothing for the program counter...

Bug: https://issuetracker.google.com/365602121
Change-Id: I7e7061a1b473089a0f31438df5ebc65b283475bc
---
 debuggerd/libdebuggerd/tombstone_proto.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index b6fc4e2dc679..ed4fd5369899 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -356,6 +356,9 @@ static void dump_probable_cause(Tombstone* tombstone, unwindstack::AndroidUnwind
     auto map_info = maps->Find(fault_addr);
     if (map_info != nullptr && map_info->flags() == PROT_EXEC) {
       cause = "execute-only (no-read) memory access error; likely due to data in .text.";
+    } else if (fault_addr == target_thread.registers->pc() &&
+               map_info != nullptr && (map_info->flags() & PROT_EXEC) == 0) {
+      cause = "trying to execute non-executable memory.";
     } else {
       cause = get_stack_overflow_cause(fault_addr, target_thread.registers->sp(), maps);
     }

From 26d10f158446b898c22e3fdef1e730255e48fab0 Mon Sep 17 00:00:00 2001
From: Shengsong Tan <sstan@google.com>
Date: Thu, 12 Sep 2024 06:44:20 +0000
Subject: [PATCH 1108/1487] Remove usage of base/logging.h in libfs_avb

As part of the effort to uprev libchrome in Android, we are
removing Android dependencies to libchrome utility functions
that are not strictly required.

This CL remove the usage of base/logging.h and replace by
android-base/logging.h

Bug: 360917504
Test: atest libfs_avb_internal_test

Change-Id: Ibcc476aebcff2fe5cfc2e3a3cd04168c02bc05f5
---
 fs_mgr/libfs_avb/avb_ops.cpp     | 1 +
 fs_mgr/libfs_avb/avb_util.cpp    | 1 +
 fs_mgr/libfs_avb/fs_avb.cpp      | 1 +
 fs_mgr/libfs_avb/fs_avb_util.cpp | 1 +
 fs_mgr/libfs_avb/util.cpp        | 1 +
 fs_mgr/libfs_avb/util.h          | 6 ------
 6 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/fs_mgr/libfs_avb/avb_ops.cpp b/fs_mgr/libfs_avb/avb_ops.cpp
index cc197761984d..7f0083997cd8 100644
--- a/fs_mgr/libfs_avb/avb_ops.cpp
+++ b/fs_mgr/libfs_avb/avb_ops.cpp
@@ -34,6 +34,7 @@
 
 #include <string>
 
+#include <android-base/logging.h>
 #include <android-base/macros.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
diff --git a/fs_mgr/libfs_avb/avb_util.cpp b/fs_mgr/libfs_avb/avb_util.cpp
index 90b65ce4c5b0..37c9eabb8f70 100644
--- a/fs_mgr/libfs_avb/avb_util.cpp
+++ b/fs_mgr/libfs_avb/avb_util.cpp
@@ -21,6 +21,7 @@
 #include <array>
 #include <sstream>
 
+#include <android-base/logging.h>
 #include <android-base/file.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
diff --git a/fs_mgr/libfs_avb/fs_avb.cpp b/fs_mgr/libfs_avb/fs_avb.cpp
index be48de6cc835..4e6aaf500a87 100644
--- a/fs_mgr/libfs_avb/fs_avb.cpp
+++ b/fs_mgr/libfs_avb/fs_avb.cpp
@@ -28,6 +28,7 @@
 #include <vector>
 
 #include <android-base/file.h>
+#include <android-base/logging.h>
 #include <android-base/parseint.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
diff --git a/fs_mgr/libfs_avb/fs_avb_util.cpp b/fs_mgr/libfs_avb/fs_avb_util.cpp
index 532622694bf0..a74aa2587d09 100644
--- a/fs_mgr/libfs_avb/fs_avb_util.cpp
+++ b/fs_mgr/libfs_avb/fs_avb_util.cpp
@@ -20,6 +20,7 @@
 #include <string>
 #include <vector>
 
+#include <android-base/logging.h>
 #include <android-base/strings.h>
 #include <fstab/fstab.h>
 #include <libavb/libavb.h>
diff --git a/fs_mgr/libfs_avb/util.cpp b/fs_mgr/libfs_avb/util.cpp
index 7783d04e68e9..79c7b9494c0c 100644
--- a/fs_mgr/libfs_avb/util.cpp
+++ b/fs_mgr/libfs_avb/util.cpp
@@ -22,6 +22,7 @@
 
 #include <thread>
 
+#include <android-base/logging.h>
 #include <android-base/stringprintf.h>
 #include <android-base/unique_fd.h>
 #include <linux/fs.h>
diff --git a/fs_mgr/libfs_avb/util.h b/fs_mgr/libfs_avb/util.h
index 29d1e9c548f2..570456046f72 100644
--- a/fs_mgr/libfs_avb/util.h
+++ b/fs_mgr/libfs_avb/util.h
@@ -20,12 +20,6 @@
 #include <string>
 #include <vector>
 
-#ifdef HOST_TEST
-#include <base/logging.h>
-#else
-#include <android-base/logging.h>
-#endif
-
 #include <android-base/result.h>
 
 using android::base::ErrnoError;

From 807ab25891ac365dcae7a9f701f80fb7852f735f Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Thu, 12 Sep 2024 18:28:50 +0900
Subject: [PATCH 1109/1487] Define linker.config.json as a filegroup

The linker.config.json file is required for soong to generate a
system image.

Bug: 365670526
Test: lunch aosp_cf_x86_64_phone_soong_system-trunk_staging-userdebug
      && m
Change-Id: I86389e4143cd2fc08b812d50962bf7ec007894ab
---
 rootdir/Android.bp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 5f0a2c327a14..44acbbae4b4d 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -50,10 +50,15 @@ prebuilt_etc {
     recovery_available: true,
 }
 
+filegroup {
+    name: "system_linker_config_json_file",
+    srcs: ["etc/linker.config.json"],
+}
+
 // TODO(b/147210213) Generate list of libraries during build and fill in at build time
 linker_config {
     name: "system_linker_config",
-    src: "etc/linker.config.json",
+    src: ":system_linker_config_json_file",
     installable: false,
 }
 

From f5af00e79fe45bbd9f897cac444afa6f3d318e8b Mon Sep 17 00:00:00 2001
From: Inseob Kim <inseob@google.com>
Date: Fri, 13 Sep 2024 14:02:10 +0900
Subject: [PATCH 1110/1487] Mount /mnt/vm earlier

To support early VM in the init stage.

Bug: 331320802
Test: boot and check /mnt/vm
Change-Id: If6f20a616ad24ae194e6fae292c9be200b63185b
---
 rootdir/init.rc | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 63e3d0646586..4b3ad822fd9b 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -495,6 +495,14 @@ on init
     start hwservicemanager
     start vndservicemanager
 
+    # Mount /mnt/vm ASAP to allow early VMs to run.
+    mkdir /mnt/vm 0755 root root
+    mount tmpfs tmpfs /mnt/vm nosuid nodev noexec rw
+    restorecon /mnt/vm
+    chown system system /mnt/vm
+    chmod 0770 /mnt/vm
+    mkdir /mnt/vm/early 0770 system system
+
 # Run boringssl self test for each ABI.  Any failures trigger reboot to firmware.
 import /system/etc/init/hw/init.boringssl.${ro.zygote}.rc
 
@@ -661,14 +669,6 @@ on late-fs
     chmod 0755 /sys/kernel/tracing
     chmod 0755 /sys/kernel/debug/tracing
 
-    # Early HALs may use early VM. Mount /mnt/vm before starting such HALs.
-    mkdir /mnt/vm 0755 root root
-    mount tmpfs tmpfs /mnt/vm nosuid nodev noexec rw
-    restorecon /mnt/vm
-    chown system system /mnt/vm
-    chmod 0770 /mnt/vm
-    mkdir /mnt/vm/early 0770 system system
-
     # HALs required before storage encryption can get unlocked (FBE)
     class_start early_hal
 

From 7b577cf43c115179e9234ed35a895987bfb57469 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Mon, 16 Sep 2024 17:24:25 +0000
Subject: [PATCH 1111/1487] libsnapshot: CHECK -> CHECK_EQ

This will print the values of the strings which are not equal
so that we can debug.

Bug: 366531882
Test: build, TH
Change-Id: I36a2b8d3fbda145e07cd8ccb01152a3a3adf21b0
---
 fs_mgr/libsnapshot/snapshot_stats.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/snapshot_stats.cpp b/fs_mgr/libsnapshot/snapshot_stats.cpp
index 9b6eb2c62aa3..8e9d9c5f3bc4 100644
--- a/fs_mgr/libsnapshot/snapshot_stats.cpp
+++ b/fs_mgr/libsnapshot/snapshot_stats.cpp
@@ -25,7 +25,7 @@ namespace snapshot {
 
 SnapshotMergeStats* SnapshotMergeStats::GetInstance(SnapshotManager& parent) {
     static SnapshotMergeStats g_instance(parent.GetMergeStateFilePath());
-    CHECK(g_instance.path_ == parent.GetMergeStateFilePath());
+    CHECK_EQ(g_instance.path_, parent.GetMergeStateFilePath());
     return &g_instance;
 }
 

From 7d9c9af9467da2848923a8e45a84b00ca4625a25 Mon Sep 17 00:00:00 2001
From: Paul Ramirez <peramirez@google.com>
Date: Mon, 16 Sep 2024 20:44:57 +0000
Subject: [PATCH 1112/1487] Add getFdStateDebug to access Looper's callbacks

Added getFdStateDebug to access Looper's internal state.

Flag: EXEMPT testing
Test: TEST=libutils_test; m $TEST && $ANDROID_HOST_OUT/nativetest64/$TEST/$TEST --gtest_filter="LooperTest.getFdStateDebug*"
Change-Id: I253ed4a6fa1040053117dcea3be80e55eef9a9b0
---
 libutils/Looper.cpp                           |   15 +
 libutils/Looper_test.cpp                      |   46 +
 .../arm64/source-based/libutils.so.lsdump     | 2103 +++--------------
 .../arm_arm64/source-based/libutils.so.lsdump | 1620 +++----------
 libutils/include/utils/Looper.h               |    6 +
 5 files changed, 707 insertions(+), 3083 deletions(-)

diff --git a/libutils/Looper.cpp b/libutils/Looper.cpp
index e11d1973156a..2541aa807a1e 100644
--- a/libutils/Looper.cpp
+++ b/libutils/Looper.cpp
@@ -496,6 +496,21 @@ int Looper::addFd(int fd, int ident, int events, const sp<LooperCallback>& callb
     return 1;
 }
 
+bool Looper::getFdStateDebug(int fd, int* ident, int* events, sp<LooperCallback>* cb, void** data) {
+    AutoMutex _l(mLock);
+    if (auto seqNumIt = mSequenceNumberByFd.find(fd); seqNumIt != mSequenceNumberByFd.cend()) {
+        if (auto reqIt = mRequests.find(seqNumIt->second); reqIt != mRequests.cend()) {
+            const Request& request = reqIt->second;
+            if (ident) *ident = request.ident;
+            if (events) *events = request.events;
+            if (cb) *cb = request.callback;
+            if (data) *data = request.data;
+            return true;
+        }
+    }
+    return false;
+}
+
 int Looper::removeFd(int fd) {
     AutoMutex _l(mLock);
     const auto& it = mSequenceNumberByFd.find(fd);
diff --git a/libutils/Looper_test.cpp b/libutils/Looper_test.cpp
index c859f9c61802..a7a9987a7745 100644
--- a/libutils/Looper_test.cpp
+++ b/libutils/Looper_test.cpp
@@ -410,6 +410,52 @@ TEST_F(LooperTest, AddFd_WhenNoCallbackAndAllowNonCallbacksIsFalse_ReturnsError)
             << "addFd should return -1 because arguments were invalid";
 }
 
+class LooperCallbackStub final : public LooperCallback {
+  public:
+    LooperCallbackStub(std::function<int()> callback) : mCallback{callback} {}
+
+    int handleEvent(int /*fd*/, int /*events*/, void* /*data*/) override { return mCallback(); }
+
+  private:
+    std::function<int()> mCallback;
+};
+
+TEST_F(LooperTest, getFdStateDebug_WhenFdIsInRequests_ReturnsTrue) {
+    Pipe pipe;
+    const int fd = pipe.receiveFd;
+    constexpr int expectedIdent{Looper::POLL_CALLBACK};
+    sp<LooperCallback> expectedCallback =
+            sp<LooperCallbackStub>::make([]() constexpr -> int { return 0; });
+    void* expectedData = this;
+
+    EXPECT_EQ(1, mLooper->addFd(fd, expectedIdent, Looper::EVENT_INPUT, expectedCallback,
+                                expectedData));
+
+    int ident;
+    int events;
+    sp<LooperCallback> callback;
+    void* data;
+
+    EXPECT_TRUE(mLooper->getFdStateDebug(fd, &ident, &events, &callback, &data));
+
+    EXPECT_EQ(ident, expectedIdent);
+    EXPECT_EQ(events, Looper::EVENT_INPUT);
+    EXPECT_EQ(callback, expectedCallback);
+    EXPECT_EQ(data, expectedData);
+}
+
+TEST_F(LooperTest, getFdStateDebug_WhenFdIsNotInRequests_ReturnsFalse) {
+    Pipe pipe;
+    const int notAddedFd = pipe.receiveFd;
+
+    int ident;
+    int events;
+    sp<LooperCallback> callback;
+    void* data;
+
+    EXPECT_FALSE(mLooper->getFdStateDebug(notAddedFd, &ident, &events, &callback, &data));
+}
+
 TEST_F(LooperTest, RemoveFd_WhenCallbackNotAdded_ReturnsZero) {
     int result = mLooper->removeFd(1);
 
diff --git a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
index caea1a96c998..00609a9c2653 100644
--- a/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm64/source-based/libutils.so.lsdump
@@ -6,7 +6,6 @@
    "linker_set_key" : "_ZTIA0_i",
    "name" : "int[0]",
    "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIA0_i",
    "source_file" : "system/core/libcutils/include_outside_system/cutils/native_handle.h"
   },
   {
@@ -14,7 +13,6 @@
    "linker_set_key" : "_ZTIA1_Ds",
    "name" : "char16_t[1]",
    "referenced_type" : "_ZTIDs",
-   "self_type" : "_ZTIA1_Ds",
    "size" : 2,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -23,7 +21,6 @@
    "linker_set_key" : "_ZTIA20_c",
    "name" : "char[20]",
    "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIA20_c",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -32,7 +29,6 @@
    "linker_set_key" : "_ZTIA5121_h",
    "name" : "unsigned char[5121]",
    "referenced_type" : "_ZTIh",
-   "self_type" : "_ZTIA5121_h",
    "size" : 5121,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   },
@@ -41,7 +37,6 @@
    "linker_set_key" : "_ZTIA8_j",
    "name" : "unsigned int[8]",
    "referenced_type" : "_ZTIj",
-   "self_type" : "_ZTIA8_j",
    "size" : 32,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -50,7 +45,6 @@
    "linker_set_key" : "_ZTIA_f",
    "name" : "float[]",
    "referenced_type" : "_ZTIf",
-   "self_type" : "_ZTIA_f",
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   }
  ],
@@ -62,16 +56,12 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIDi",
    "name" : "char32_t",
-   "referenced_type" : "_ZTIDi",
-   "self_type" : "_ZTIDi",
    "size" : 4
   },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIDn",
    "name" : "std::nullptr_t",
-   "referenced_type" : "_ZTIDn",
-   "self_type" : "_ZTIDn",
    "size" : 8
   },
   {
@@ -80,8 +70,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIDs",
    "name" : "char16_t",
-   "referenced_type" : "_ZTIDs",
-   "self_type" : "_ZTIDs",
    "size" : 2
   },
   {
@@ -89,8 +77,6 @@
    "is_integral" : true,
    "linker_set_key" : "_ZTIa",
    "name" : "signed char",
-   "referenced_type" : "_ZTIa",
-   "self_type" : "_ZTIa",
    "size" : 1
   },
   {
@@ -99,8 +85,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIb",
    "name" : "bool",
-   "referenced_type" : "_ZTIb",
-   "self_type" : "_ZTIb",
    "size" : 1
   },
   {
@@ -109,24 +93,18 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIc",
    "name" : "char",
-   "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIc",
    "size" : 1
   },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTId",
    "name" : "double",
-   "referenced_type" : "_ZTId",
-   "self_type" : "_ZTId",
    "size" : 8
   },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIf",
    "name" : "float",
-   "referenced_type" : "_ZTIf",
-   "self_type" : "_ZTIf",
    "size" : 4
   },
   {
@@ -135,8 +113,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIh",
    "name" : "unsigned char",
-   "referenced_type" : "_ZTIh",
-   "self_type" : "_ZTIh",
    "size" : 1
   },
   {
@@ -144,8 +120,6 @@
    "is_integral" : true,
    "linker_set_key" : "_ZTIi",
    "name" : "int",
-   "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIi",
    "size" : 4
   },
   {
@@ -154,8 +128,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIj",
    "name" : "unsigned int",
-   "referenced_type" : "_ZTIj",
-   "self_type" : "_ZTIj",
    "size" : 4
   },
   {
@@ -163,8 +135,6 @@
    "is_integral" : true,
    "linker_set_key" : "_ZTIl",
    "name" : "long",
-   "referenced_type" : "_ZTIl",
-   "self_type" : "_ZTIl",
    "size" : 8
   },
   {
@@ -173,8 +143,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIm",
    "name" : "unsigned long",
-   "referenced_type" : "_ZTIm",
-   "self_type" : "_ZTIm",
    "size" : 8
   },
   {
@@ -182,8 +150,6 @@
    "is_integral" : true,
    "linker_set_key" : "_ZTIs",
    "name" : "short",
-   "referenced_type" : "_ZTIs",
-   "self_type" : "_ZTIs",
    "size" : 2
   },
   {
@@ -192,23 +158,17 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIt",
    "name" : "unsigned short",
-   "referenced_type" : "_ZTIt",
-   "self_type" : "_ZTIt",
    "size" : 2
   },
   {
    "linker_set_key" : "_ZTIv",
-   "name" : "void",
-   "referenced_type" : "_ZTIv",
-   "self_type" : "_ZTIv"
+   "name" : "void"
   },
   {
    "alignment" : 8,
    "is_integral" : true,
    "linker_set_key" : "_ZTIx",
    "name" : "long long",
-   "referenced_type" : "_ZTIx",
-   "self_type" : "_ZTIx",
    "size" : 8
   },
   {
@@ -217,8 +177,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIy",
    "name" : "unsigned long long",
-   "referenced_type" : "_ZTIy",
-   "self_type" : "_ZTIy",
    "size" : 8
   }
  ],
@@ -491,18 +449,6 @@
   {
    "name" : "_ZN7android27add_sysprop_change_callbackEPFvvEi"
   },
-  {
-   "binding" : "weak",
-   "name" : "_ZN7android2spINS_14LooperCallbackEE5clearEv"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZN7android2spINS_6LooperEEaSEOS2_"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZN7android2spINS_6ThreadEE5clearEv"
-  },
   {
    "name" : "_ZN7android30get_report_sysprop_change_funcEv"
   },
@@ -524,6 +470,9 @@
   {
    "name" : "_ZN7android6Looper14removeMessagesERKNS_2spINS_14MessageHandlerEEEi"
   },
+  {
+   "name" : "_ZN7android6Looper15getFdStateDebugEiPiS1_PNS_2spINS_14LooperCallbackEEEPPv"
+  },
   {
    "name" : "_ZN7android6Looper17sendMessageAtTimeElRKNS_2spINS_14MessageHandlerEEERKNS_7MessageE"
   },
@@ -1046,78 +995,6 @@
   {
    "name" : "_ZNK7android6Thread9isRunningEv"
   },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_28sysprop_change_callback_infoEE10do_destroyEPvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_28sysprop_change_callback_infoEE12do_constructEPvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_28sysprop_change_callback_infoEE15do_move_forwardEPvPKvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_28sysprop_change_callback_infoEE16do_move_backwardEPvPKvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_28sysprop_change_callback_infoEE7do_copyEPvPKvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_28sysprop_change_callback_infoEE8do_splatEPvPKvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_6Looper15MessageEnvelopeEE10do_destroyEPvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_6Looper15MessageEnvelopeEE12do_constructEPvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_6Looper15MessageEnvelopeEE15do_move_forwardEPvPKvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_6Looper15MessageEnvelopeEE16do_move_backwardEPvPKvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_6Looper15MessageEnvelopeEE7do_copyEPvPKvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_6Looper15MessageEnvelopeEE8do_splatEPvPKvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_6Looper8ResponseEE10do_destroyEPvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_6Looper8ResponseEE12do_constructEPvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_6Looper8ResponseEE15do_move_forwardEPvPKvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_6Looper8ResponseEE16do_move_backwardEPvPKvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_6Looper8ResponseEE7do_copyEPvPKvm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNK7android6VectorINS_6Looper8ResponseEE8do_splatEPvPKvm"
-  },
   {
    "name" : "_ZNK7android7RefBase10createWeakEPKv"
   },
@@ -1196,54 +1073,6 @@
   {
    "name" : "_ZNK7android9Tokenizer19peekRemainderOfLineEv"
   },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIimEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE14__erase_uniqueIiEEmRKT_"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIimEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE25__emplace_unique_key_argsIiJRiRKmEEENS_4pairINS_15__hash_iteratorIPNS_11__hash_nodeIS2_PvEEEEbEERKT_DpOT0_"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIimEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE6rehashEm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIimEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE6removeENS_21__hash_const_iteratorIPNS_11__hash_nodeIS2_PvEEEE"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIimEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE8__rehashEm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeImN7android6Looper7RequestEEENS_22__unordered_map_hasherImS5_NS_4hashImEELb1EEENS_21__unordered_map_equalImS5_NS_8equal_toImEELb1EEENS_9allocatorIS5_EEE14__erase_uniqueImEEmRKT_"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeImN7android6Looper7RequestEEENS_22__unordered_map_hasherImS5_NS_4hashImEELb1EEENS_21__unordered_map_equalImS5_NS_8equal_toImEELb1EEENS_9allocatorIS5_EEE25__emplace_unique_key_argsImJRKmRS4_EEENS_4pairINS_15__hash_iteratorIPNS_11__hash_nodeIS5_PvEEEEbEERKT_DpOT0_"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeImN7android6Looper7RequestEEENS_22__unordered_map_hasherImS5_NS_4hashImEELb1EEENS_21__unordered_map_equalImS5_NS_8equal_toImEELb1EEENS_9allocatorIS5_EEE4findImEENS_15__hash_iteratorIPNS_11__hash_nodeIS5_PvEEEERKT_"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeImN7android6Looper7RequestEEENS_22__unordered_map_hasherImS5_NS_4hashImEELb1EEENS_21__unordered_map_equalImS5_NS_8equal_toImEELb1EEENS_9allocatorIS5_EEE5eraseENS_21__hash_const_iteratorIPNS_11__hash_nodeIS5_PvEEEE"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeImN7android6Looper7RequestEEENS_22__unordered_map_hasherImS5_NS_4hashImEELb1EEENS_21__unordered_map_equalImS5_NS_8equal_toImEELb1EEENS_9allocatorIS5_EEE6rehashEm"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeImN7android6Looper7RequestEEENS_22__unordered_map_hasherImS5_NS_4hashImEELb1EEENS_21__unordered_map_equalImS5_NS_8equal_toImEELb1EEENS_9allocatorIS5_EEE6removeENS_21__hash_const_iteratorIPNS_11__hash_nodeIS5_PvEEEE"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeImN7android6Looper7RequestEEENS_22__unordered_map_hasherImS5_NS_4hashImEELb1EEENS_21__unordered_map_equalImS5_NS_8equal_toImEELb1EEENS_9allocatorIS5_EEE8__rehashEm"
-  },
   {
    "name" : "_ZTv0_n24_N7android14LooperCallbackD0Ev"
   },
@@ -1437,67 +1266,6 @@
  ],
  "enum_types" :
  [
-  {
-   "alignment" : 4,
-   "enum_fields" :
-   [
-    {
-     "enum_field_value" : -1,
-     "name" : "SP_DEFAULT"
-    },
-    {
-     "enum_field_value" : 0,
-     "name" : "SP_BACKGROUND"
-    },
-    {
-     "enum_field_value" : 1,
-     "name" : "SP_FOREGROUND"
-    },
-    {
-     "enum_field_value" : 2,
-     "name" : "SP_SYSTEM"
-    },
-    {
-     "enum_field_value" : 3,
-     "name" : "SP_AUDIO_APP"
-    },
-    {
-     "enum_field_value" : 4,
-     "name" : "SP_AUDIO_SYS"
-    },
-    {
-     "enum_field_value" : 5,
-     "name" : "SP_TOP_APP"
-    },
-    {
-     "enum_field_value" : 6,
-     "name" : "SP_RT_APP"
-    },
-    {
-     "enum_field_value" : 7,
-     "name" : "SP_RESTRICTED"
-    },
-    {
-     "enum_field_value" : 8,
-     "name" : "SP_CNT"
-    },
-    {
-     "enum_field_value" : 7,
-     "name" : "SP_MAX"
-    },
-    {
-     "enum_field_value" : 1,
-     "name" : "SP_SYSTEM_DEFAULT"
-    }
-   ],
-   "linker_set_key" : "_ZTI11SchedPolicy",
-   "name" : "SchedPolicy",
-   "referenced_type" : "_ZTI11SchedPolicy",
-   "self_type" : "_ZTI11SchedPolicy",
-   "size" : 4,
-   "source_file" : "system/core/libprocessgroup/include/processgroup/sched_policy.h",
-   "underlying_type" : "_ZTIi"
-  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -1517,8 +1285,6 @@
    ],
    "linker_set_key" : "_ZTI13android_hdr_t",
    "name" : "android_hdr_t",
-   "referenced_type" : "_ZTI13android_hdr_t",
-   "self_type" : "_ZTI13android_hdr_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.0.h",
    "underlying_type" : "_ZTIj"
@@ -1534,8 +1300,6 @@
    ],
    "linker_set_key" : "_ZTI18android_hdr_v1_2_t",
    "name" : "android_hdr_v1_2_t",
-   "referenced_type" : "_ZTI18android_hdr_v1_2_t",
-   "self_type" : "_ZTI18android_hdr_v1_2_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.2.h",
    "underlying_type" : "_ZTIj"
@@ -1583,8 +1347,6 @@
    ],
    "linker_set_key" : "_ZTI19android_LogPriority",
    "name" : "android_LogPriority",
-   "referenced_type" : "_ZTI19android_LogPriority",
-   "self_type" : "_ZTI19android_LogPriority",
    "size" : 4,
    "source_file" : "system/logging/liblog/include_vndk/android/log.h",
    "underlying_type" : "_ZTIj"
@@ -1824,8 +1586,6 @@
    ],
    "linker_set_key" : "_ZTI19android_dataspace_t",
    "name" : "android_dataspace_t",
-   "referenced_type" : "_ZTI19android_dataspace_t",
-   "self_type" : "_ZTI19android_dataspace_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.0.h",
    "underlying_type" : "_ZTIj"
@@ -1861,8 +1621,6 @@
    ],
    "linker_set_key" : "_ZTI19android_flex_format",
    "name" : "android_flex_format",
-   "referenced_type" : "_ZTI19android_flex_format",
-   "self_type" : "_ZTI19android_flex_format",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics.h",
    "underlying_type" : "_ZTIj"
@@ -1894,8 +1652,6 @@
    ],
    "linker_set_key" : "_ZTI19android_transform_t",
    "name" : "android_transform_t",
-   "referenced_type" : "_ZTI19android_transform_t",
-   "self_type" : "_ZTI19android_transform_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.0.h",
    "underlying_type" : "_ZTIj"
@@ -1947,8 +1703,6 @@
    ],
    "linker_set_key" : "_ZTI20android_color_mode_t",
    "name" : "android_color_mode_t",
-   "referenced_type" : "_ZTI20android_color_mode_t",
-   "self_type" : "_ZTI20android_color_mode_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.0.h",
    "underlying_type" : "_ZTIj"
@@ -1980,8 +1734,6 @@
    ],
    "linker_set_key" : "_ZTI21$SYSTEM_TIME_BOOTTIME",
    "name" : "(unnamed)",
-   "referenced_type" : "_ZTI21$SYSTEM_TIME_BOOTTIME",
-   "self_type" : "_ZTI21$SYSTEM_TIME_BOOTTIME",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Timers.h",
    "underlying_type" : "_ZTIj"
@@ -2021,8 +1773,6 @@
    ],
    "linker_set_key" : "_ZTI22android_flex_component",
    "name" : "android_flex_component",
-   "referenced_type" : "_ZTI22android_flex_component",
-   "self_type" : "_ZTI22android_flex_component",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics.h",
    "underlying_type" : "_ZTIj"
@@ -2114,8 +1864,6 @@
    ],
    "linker_set_key" : "_ZTI22android_pixel_format_t",
    "name" : "android_pixel_format_t",
-   "referenced_type" : "_ZTI22android_pixel_format_t",
-   "self_type" : "_ZTI22android_pixel_format_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.0.h",
    "underlying_type" : "_ZTIj"
@@ -2179,8 +1927,6 @@
    ],
    "linker_set_key" : "_ZTI23$ANDROID_PRIORITY_AUDIO",
    "name" : "(unnamed)",
-   "referenced_type" : "_ZTI23$ANDROID_PRIORITY_AUDIO",
-   "self_type" : "_ZTI23$ANDROID_PRIORITY_AUDIO",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/thread_defs.h",
    "underlying_type" : "_ZTIi"
@@ -2208,8 +1954,6 @@
    ],
    "linker_set_key" : "_ZTI24android_dataspace_v1_1_t",
    "name" : "android_dataspace_v1_1_t",
-   "referenced_type" : "_ZTI24android_dataspace_v1_1_t",
-   "self_type" : "_ZTI24android_dataspace_v1_1_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.1.h",
    "underlying_type" : "_ZTIj"
@@ -2237,8 +1981,6 @@
    ],
    "linker_set_key" : "_ZTI24android_dataspace_v1_2_t",
    "name" : "android_dataspace_v1_2_t",
-   "referenced_type" : "_ZTI24android_dataspace_v1_2_t",
-   "self_type" : "_ZTI24android_dataspace_v1_2_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.2.h",
    "underlying_type" : "_ZTIj"
@@ -2262,8 +2004,6 @@
    ],
    "linker_set_key" : "_ZTI25android_color_mode_v1_1_t",
    "name" : "android_color_mode_v1_1_t",
-   "referenced_type" : "_ZTI25android_color_mode_v1_1_t",
-   "self_type" : "_ZTI25android_color_mode_v1_1_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.1.h",
    "underlying_type" : "_ZTIj"
@@ -2279,8 +2019,6 @@
    ],
    "linker_set_key" : "_ZTI25android_color_mode_v1_2_t",
    "name" : "android_color_mode_v1_2_t",
-   "referenced_type" : "_ZTI25android_color_mode_v1_2_t",
-   "self_type" : "_ZTI25android_color_mode_v1_2_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.2.h",
    "underlying_type" : "_ZTIj"
@@ -2320,8 +2058,6 @@
    ],
    "linker_set_key" : "_ZTI25android_color_transform_t",
    "name" : "android_color_transform_t",
-   "referenced_type" : "_ZTI25android_color_transform_t",
-   "self_type" : "_ZTI25android_color_transform_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.0.h",
    "underlying_type" : "_ZTIj"
@@ -2349,8 +2085,6 @@
    ],
    "linker_set_key" : "_ZTI25android_pixel_format_sw_t",
    "name" : "android_pixel_format_sw_t",
-   "referenced_type" : "_ZTI25android_pixel_format_sw_t",
-   "self_type" : "_ZTI25android_pixel_format_sw_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-sw.h",
    "underlying_type" : "_ZTIj"
@@ -2390,8 +2124,6 @@
    ],
    "linker_set_key" : "_ZTI27android_pixel_format_v1_1_t",
    "name" : "android_pixel_format_v1_1_t",
-   "referenced_type" : "_ZTI27android_pixel_format_v1_1_t",
-   "self_type" : "_ZTI27android_pixel_format_v1_1_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.1.h",
    "underlying_type" : "_ZTIj"
@@ -2407,8 +2139,6 @@
    ],
    "linker_set_key" : "_ZTI27android_pixel_format_v1_2_t",
    "name" : "android_pixel_format_v1_2_t",
-   "referenced_type" : "_ZTI27android_pixel_format_v1_2_t",
-   "self_type" : "_ZTI27android_pixel_format_v1_2_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.2.h",
    "underlying_type" : "_ZTIj"
@@ -2436,8 +2166,6 @@
    ],
    "linker_set_key" : "_ZTI28android_render_intent_v1_1_t",
    "name" : "android_render_intent_v1_1_t",
-   "referenced_type" : "_ZTI28android_render_intent_v1_1_t",
-   "self_type" : "_ZTI28android_render_intent_v1_1_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.1.h",
    "underlying_type" : "_ZTIj"
@@ -2493,8 +2221,6 @@
    ],
    "linker_set_key" : "_ZTI6log_id",
    "name" : "log_id",
-   "referenced_type" : "_ZTI6log_id",
-   "self_type" : "_ZTI6log_id",
    "size" : 4,
    "source_file" : "system/logging/liblog/include_vndk/android/log.h",
    "underlying_type" : "_ZTIj"
@@ -2518,8 +2244,6 @@
    ],
    "linker_set_key" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE",
    "name" : "android::VectorImpl::(unnamed)",
-   "referenced_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE",
-   "self_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h",
    "underlying_type" : "_ZTIj"
@@ -2543,8 +2267,7 @@
    ],
    "linker_set_key" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE",
    "name" : "android::VectorImpl::(unnamed)",
-   "referenced_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h",
    "underlying_type" : "_ZTIj"
@@ -2560,8 +2283,6 @@
    ],
    "linker_set_key" : "_ZTIN7android13trait_pointerINS_28sysprop_change_callback_infoEE6$valueE",
    "name" : "android::trait_pointer<android::sysprop_change_callback_info>::(unnamed)",
-   "referenced_type" : "_ZTIN7android13trait_pointerINS_28sysprop_change_callback_infoEE6$valueE",
-   "self_type" : "_ZTIN7android13trait_pointerINS_28sysprop_change_callback_infoEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2577,8 +2298,6 @@
    ],
    "linker_set_key" : "_ZTIN7android13trait_pointerINS_6Looper15MessageEnvelopeEE6$valueE",
    "name" : "android::trait_pointer<android::Looper::MessageEnvelope>::(unnamed)",
-   "referenced_type" : "_ZTIN7android13trait_pointerINS_6Looper15MessageEnvelopeEE6$valueE",
-   "self_type" : "_ZTIN7android13trait_pointerINS_6Looper15MessageEnvelopeEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2594,8 +2313,6 @@
    ],
    "linker_set_key" : "_ZTIN7android13trait_pointerINS_6Looper8ResponseEE6$valueE",
    "name" : "android::trait_pointer<android::Looper::Response>::(unnamed)",
-   "referenced_type" : "_ZTIN7android13trait_pointerINS_6Looper8ResponseEE6$valueE",
-   "self_type" : "_ZTIN7android13trait_pointerINS_6Looper8ResponseEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2687,8 +2404,6 @@
    ],
    "linker_set_key" : "_ZTIN7android15$ALREADY_EXISTSE",
    "name" : "android::(unnamed)",
-   "referenced_type" : "_ZTIN7android15$ALREADY_EXISTSE",
-   "self_type" : "_ZTIN7android15$ALREADY_EXISTSE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Errors.h",
    "underlying_type" : "_ZTIi"
@@ -2780,8 +2495,7 @@
    ],
    "linker_set_key" : "_ZTIN7android15$ALREADY_EXISTSE",
    "name" : "android::(unnamed)",
-   "referenced_type" : "_ZTIN7android15$ALREADY_EXISTSE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/Errors.sdump",
-   "self_type" : "_ZTIN7android15$ALREADY_EXISTSE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/Errors.sdump",
+   "self_type" : "_ZTIN7android15$ALREADY_EXISTSE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/Errors.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/Errors.h",
    "underlying_type" : "_ZTIi"
@@ -2841,8 +2555,6 @@
    ],
    "linker_set_key" : "_ZTIN7android15$PRIORITY_AUDIOE",
    "name" : "android::(unnamed)",
-   "referenced_type" : "_ZTIN7android15$PRIORITY_AUDIOE",
-   "self_type" : "_ZTIN7android15$PRIORITY_AUDIOE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/ThreadDefs.h",
    "underlying_type" : "_ZTIi"
@@ -2858,8 +2570,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyINS_28sysprop_change_callback_infoEE6$valueE",
    "name" : "android::trait_trivial_copy<android::sysprop_change_callback_info>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyINS_28sysprop_change_callback_infoEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyINS_28sysprop_change_callback_infoEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2875,8 +2585,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyINS_6Looper15MessageEnvelopeEE6$valueE",
    "name" : "android::trait_trivial_copy<android::Looper::MessageEnvelope>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper15MessageEnvelopeEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper15MessageEnvelopeEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2892,8 +2600,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyINS_6Looper8ResponseEE6$valueE",
    "name" : "android::trait_trivial_copy<android::Looper::Response>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper8ResponseEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper8ResponseEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2909,8 +2615,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIbE6$valueE",
    "name" : "android::trait_trivial_copy<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2926,8 +2630,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIbE6$valueE",
    "name" : "android::trait_trivial_copy<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2943,8 +2646,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcE6$valueE",
    "name" : "android::trait_trivial_copy<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2960,8 +2661,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcE6$valueE",
    "name" : "android::trait_trivial_copy<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2977,8 +2677,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
    "name" : "android::trait_trivial_copy<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2994,8 +2692,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
    "name" : "android::trait_trivial_copy<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3011,8 +2708,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
    "name" : "android::trait_trivial_copy<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3028,8 +2723,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
    "name" : "android::trait_trivial_copy<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3045,8 +2739,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3062,8 +2754,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3079,8 +2770,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
    "name" : "android::trait_trivial_copy<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3096,8 +2785,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
    "name" : "android::trait_trivial_copy<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3113,8 +2801,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3130,8 +2816,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3147,8 +2832,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
    "name" : "android::trait_trivial_copy<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3164,8 +2847,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
    "name" : "android::trait_trivial_copy<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3181,8 +2863,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3198,8 +2878,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3215,8 +2894,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
    "name" : "android::trait_trivial_copy<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3232,8 +2909,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
    "name" : "android::trait_trivial_copy<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3249,8 +2925,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3266,8 +2940,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3283,8 +2956,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
    "name" : "android::trait_trivial_copy<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3300,8 +2971,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
    "name" : "android::trait_trivial_copy<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3317,8 +2987,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxE6$valueE",
    "name" : "android::trait_trivial_copy<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3334,8 +3002,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxE6$valueE",
    "name" : "android::trait_trivial_copy<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3351,8 +3018,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3368,8 +3033,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3385,8 +3049,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEE6$valueE",
    "name" : "android::trait_trivial_ctor<android::sysprop_change_callback_info>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3402,8 +3064,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_6Looper15MessageEnvelopeEE6$valueE",
    "name" : "android::trait_trivial_ctor<android::Looper::MessageEnvelope>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper15MessageEnvelopeEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper15MessageEnvelopeEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3419,8 +3079,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_6Looper8ResponseEE6$valueE",
    "name" : "android::trait_trivial_ctor<android::Looper::Response>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper8ResponseEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper8ResponseEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3436,8 +3094,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
    "name" : "android::trait_trivial_ctor<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3453,8 +3109,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
    "name" : "android::trait_trivial_ctor<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3470,8 +3125,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
    "name" : "android::trait_trivial_ctor<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3487,8 +3140,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
    "name" : "android::trait_trivial_ctor<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3504,8 +3156,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
    "name" : "android::trait_trivial_ctor<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3521,8 +3171,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
    "name" : "android::trait_trivial_ctor<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3538,8 +3187,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
    "name" : "android::trait_trivial_ctor<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3555,8 +3202,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
    "name" : "android::trait_trivial_ctor<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3572,8 +3218,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3589,8 +3233,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3606,8 +3249,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
    "name" : "android::trait_trivial_ctor<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3623,8 +3264,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
    "name" : "android::trait_trivial_ctor<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3640,8 +3280,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3657,8 +3295,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3674,8 +3311,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
    "name" : "android::trait_trivial_ctor<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3691,8 +3326,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
    "name" : "android::trait_trivial_ctor<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3708,8 +3342,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3725,8 +3357,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3742,8 +3373,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
    "name" : "android::trait_trivial_ctor<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3759,8 +3388,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
    "name" : "android::trait_trivial_ctor<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3776,8 +3404,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3793,8 +3419,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3810,8 +3435,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
    "name" : "android::trait_trivial_ctor<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3827,8 +3450,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
    "name" : "android::trait_trivial_ctor<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3844,8 +3466,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
    "name" : "android::trait_trivial_ctor<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3861,8 +3481,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
    "name" : "android::trait_trivial_ctor<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3878,8 +3497,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3895,8 +3512,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3912,8 +3528,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEE6$valueE",
    "name" : "android::trait_trivial_dtor<android::sysprop_change_callback_info>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3929,8 +3543,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEE6$valueE",
    "name" : "android::trait_trivial_dtor<android::Looper::MessageEnvelope>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3946,8 +3558,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEE6$valueE",
    "name" : "android::trait_trivial_dtor<android::Looper::Response>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3963,8 +3573,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
    "name" : "android::trait_trivial_dtor<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3980,8 +3588,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
    "name" : "android::trait_trivial_dtor<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3997,8 +3604,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
    "name" : "android::trait_trivial_dtor<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4014,8 +3619,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
    "name" : "android::trait_trivial_dtor<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4031,8 +3635,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
    "name" : "android::trait_trivial_dtor<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4048,8 +3650,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
    "name" : "android::trait_trivial_dtor<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4065,8 +3666,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
    "name" : "android::trait_trivial_dtor<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4082,8 +3681,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
    "name" : "android::trait_trivial_dtor<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4099,8 +3697,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4116,8 +3712,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4133,8 +3728,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
    "name" : "android::trait_trivial_dtor<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4150,8 +3743,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
    "name" : "android::trait_trivial_dtor<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4167,8 +3759,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4184,8 +3774,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4201,8 +3790,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
    "name" : "android::trait_trivial_dtor<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4218,8 +3805,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
    "name" : "android::trait_trivial_dtor<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4235,8 +3821,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4252,8 +3836,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4269,8 +3852,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
    "name" : "android::trait_trivial_dtor<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4286,8 +3867,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
    "name" : "android::trait_trivial_dtor<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4303,8 +3883,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4320,8 +3898,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4337,8 +3914,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
    "name" : "android::trait_trivial_dtor<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4354,8 +3929,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
    "name" : "android::trait_trivial_dtor<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4371,8 +3945,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
    "name" : "android::trait_trivial_dtor<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4388,8 +3960,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
    "name" : "android::trait_trivial_dtor<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4405,8 +3976,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4422,8 +3991,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4439,8 +4007,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEE6$valueE",
    "name" : "android::trait_trivial_move<android::sysprop_change_callback_info>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4456,8 +4022,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_6Looper15MessageEnvelopeEE6$valueE",
    "name" : "android::trait_trivial_move<android::Looper::MessageEnvelope>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper15MessageEnvelopeEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper15MessageEnvelopeEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4473,8 +4037,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_6Looper8ResponseEE6$valueE",
    "name" : "android::trait_trivial_move<android::Looper::Response>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper8ResponseEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper8ResponseEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4490,8 +4052,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE",
    "name" : "android::trait_trivial_move<android::String8>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/String8.h",
    "underlying_type" : "_ZTIj"
@@ -4507,8 +4067,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE",
    "name" : "android::trait_trivial_move<android::String8>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h",
    "underlying_type" : "_ZTIj"
@@ -4524,8 +4083,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_8String16EE6$valueE",
    "name" : "android::trait_trivial_move<android::String16>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h",
    "underlying_type" : "_ZTIj"
@@ -4541,8 +4098,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIbE6$valueE",
    "name" : "android::trait_trivial_move<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4558,8 +4113,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIbE6$valueE",
    "name" : "android::trait_trivial_move<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4575,8 +4129,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcE6$valueE",
    "name" : "android::trait_trivial_move<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4592,8 +4144,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcE6$valueE",
    "name" : "android::trait_trivial_move<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4609,8 +4160,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdE6$valueE",
    "name" : "android::trait_trivial_move<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4626,8 +4175,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdE6$valueE",
    "name" : "android::trait_trivial_move<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4643,8 +4191,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfE6$valueE",
    "name" : "android::trait_trivial_move<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4660,8 +4206,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfE6$valueE",
    "name" : "android::trait_trivial_move<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4677,8 +4222,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhE6$valueE",
    "name" : "android::trait_trivial_move<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4694,8 +4237,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhE6$valueE",
    "name" : "android::trait_trivial_move<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4711,8 +4253,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiE6$valueE",
    "name" : "android::trait_trivial_move<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4728,8 +4268,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiE6$valueE",
    "name" : "android::trait_trivial_move<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4745,8 +4284,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjE6$valueE",
    "name" : "android::trait_trivial_move<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4762,8 +4299,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjE6$valueE",
    "name" : "android::trait_trivial_move<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4779,8 +4315,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlE6$valueE",
    "name" : "android::trait_trivial_move<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4796,8 +4330,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlE6$valueE",
    "name" : "android::trait_trivial_move<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4813,8 +4346,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveImE6$valueE",
    "name" : "android::trait_trivial_move<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4830,8 +4361,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveImE6$valueE",
    "name" : "android::trait_trivial_move<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4847,8 +4377,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsE6$valueE",
    "name" : "android::trait_trivial_move<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4864,8 +4392,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsE6$valueE",
    "name" : "android::trait_trivial_move<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4881,8 +4408,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveItE6$valueE",
    "name" : "android::trait_trivial_move<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4898,8 +4423,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveItE6$valueE",
    "name" : "android::trait_trivial_move<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4915,8 +4439,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvE6$valueE",
    "name" : "android::trait_trivial_move<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4932,8 +4454,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvE6$valueE",
    "name" : "android::trait_trivial_move<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4949,8 +4470,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxE6$valueE",
    "name" : "android::trait_trivial_move<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4966,8 +4485,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxE6$valueE",
    "name" : "android::trait_trivial_move<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4983,8 +4501,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
    "name" : "android::trait_trivial_move<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -5000,8 +4516,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
    "name" : "android::trait_trivial_move<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -5021,8 +4536,6 @@
    ],
    "linker_set_key" : "_ZTIN7android5Mutex8$PRIVATEE",
    "name" : "android::Mutex::(unnamed)",
-   "referenced_type" : "_ZTIN7android5Mutex8$PRIVATEE",
-   "self_type" : "_ZTIN7android5Mutex8$PRIVATEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Mutex.h",
    "underlying_type" : "_ZTIj"
@@ -5054,8 +4567,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6Looper12$EVENT_ERRORE",
    "name" : "android::Looper::(unnamed)",
-   "referenced_type" : "_ZTIN7android6Looper12$EVENT_ERRORE",
-   "self_type" : "_ZTIN7android6Looper12$EVENT_ERRORE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "underlying_type" : "_ZTIj"
@@ -5083,8 +4594,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6Looper14$POLL_CALLBACKE",
    "name" : "android::Looper::(unnamed)",
-   "referenced_type" : "_ZTIN7android6Looper14$POLL_CALLBACKE",
-   "self_type" : "_ZTIN7android6Looper14$POLL_CALLBACKE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "underlying_type" : "_ZTIi"
@@ -5100,8 +4609,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6Looper28$PREPARE_ALLOW_NON_CALLBACKSE",
    "name" : "android::Looper::(unnamed)",
-   "referenced_type" : "_ZTIN7android6Looper28$PREPARE_ALLOW_NON_CALLBACKSE",
-   "self_type" : "_ZTIN7android6Looper28$PREPARE_ALLOW_NON_CALLBACKSE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "underlying_type" : "_ZTIj"
@@ -5121,8 +4628,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6RWLock8$PRIVATEE",
    "name" : "android::RWLock::(unnamed)",
-   "referenced_type" : "_ZTIN7android6RWLock8$PRIVATEE",
-   "self_type" : "_ZTIN7android6RWLock8$PRIVATEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RWLock.h",
    "underlying_type" : "_ZTIj"
@@ -5154,8 +4659,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6traitsINS_28sysprop_change_callback_infoEE17$has_trivial_copyE",
    "name" : "android::traits<android::sysprop_change_callback_info>::(unnamed)",
-   "referenced_type" : "_ZTIN7android6traitsINS_28sysprop_change_callback_infoEE17$has_trivial_copyE",
-   "self_type" : "_ZTIN7android6traitsINS_28sysprop_change_callback_infoEE17$has_trivial_copyE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -5187,8 +4690,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6traitsINS_6Looper15MessageEnvelopeEE17$has_trivial_copyE",
    "name" : "android::traits<android::Looper::MessageEnvelope>::(unnamed)",
-   "referenced_type" : "_ZTIN7android6traitsINS_6Looper15MessageEnvelopeEE17$has_trivial_copyE",
-   "self_type" : "_ZTIN7android6traitsINS_6Looper15MessageEnvelopeEE17$has_trivial_copyE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -5220,8 +4721,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6traitsINS_6Looper8ResponseEE17$has_trivial_copyE",
    "name" : "android::traits<android::Looper::Response>::(unnamed)",
-   "referenced_type" : "_ZTIN7android6traitsINS_6Looper8ResponseEE17$has_trivial_copyE",
-   "self_type" : "_ZTIN7android6traitsINS_6Looper8ResponseEE17$has_trivial_copyE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -5253,8 +4752,6 @@
    ],
    "linker_set_key" : "_ZTIN7android7FileMap9MapAdviceE",
    "name" : "android::FileMap::MapAdvice",
-   "referenced_type" : "_ZTIN7android7FileMap9MapAdviceE",
-   "self_type" : "_ZTIN7android7FileMap9MapAdviceE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/FileMap.h",
    "underlying_type" : "_ZTIj"
@@ -5271,8 +4768,6 @@
    ],
    "linker_set_key" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
    "name" : "android::RefBase::(unnamed)",
-   "referenced_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
-   "self_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "underlying_type" : "_ZTIj"
@@ -5289,8 +4784,7 @@
    ],
    "linker_set_key" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
    "name" : "android::RefBase::(unnamed)",
-   "referenced_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
    "underlying_type" : "_ZTIj"
@@ -5315,8 +4809,6 @@
    ],
    "linker_set_key" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE",
    "name" : "android::RefBase::(unnamed)",
-   "referenced_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE",
-   "self_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "underlying_type" : "_ZTIj"
@@ -5341,8 +4833,7 @@
    ],
    "linker_set_key" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE",
    "name" : "android::RefBase::(unnamed)",
-   "referenced_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
    "underlying_type" : "_ZTIj"
@@ -5362,8 +4853,6 @@
    ],
    "linker_set_key" : "_ZTIN7android9Condition10WakeUpTypeE",
    "name" : "android::Condition::WakeUpType",
-   "referenced_type" : "_ZTIN7android9Condition10WakeUpTypeE",
-   "self_type" : "_ZTIN7android9Condition10WakeUpTypeE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Condition.h",
    "underlying_type" : "_ZTIj"
@@ -5383,8 +4872,6 @@
    ],
    "linker_set_key" : "_ZTIN7android9Condition8$PRIVATEE",
    "name" : "android::Condition::(unnamed)",
-   "referenced_type" : "_ZTIN7android9Condition8$PRIVATEE",
-   "self_type" : "_ZTIN7android9Condition8$PRIVATEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Condition.h",
    "underlying_type" : "_ZTIj"
@@ -5401,8 +4888,6 @@
    ],
    "linker_set_key" : "_ZTIN7android9FdPrinter18$MAX_FORMAT_STRINGE",
    "name" : "android::FdPrinter::(unnamed)",
-   "referenced_type" : "_ZTIN7android9FdPrinter18$MAX_FORMAT_STRINGE",
-   "self_type" : "_ZTIN7android9FdPrinter18$MAX_FORMAT_STRINGE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Printer.h",
    "underlying_type" : "_ZTIj"
@@ -5435,9 +4920,7 @@
      "referenced_type" : "_ZTIPPv"
     }
    ],
-   "referenced_type" : "_ZTIFiPFiPvES_PKcimPS_E",
    "return_type" : "_ZTIi",
-   "self_type" : "_ZTIFiPFiPvES_PKcimPS_E",
    "source_file" : "system/core/libutils/include/utils/AndroidThreads.h"
   },
   {
@@ -5453,9 +4936,7 @@
      "referenced_type" : "_ZTIPKv"
     }
    ],
-   "referenced_type" : "_ZTIFiPKvS0_E",
    "return_type" : "_ZTIi",
-   "self_type" : "_ZTIFiPKvS0_E",
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
@@ -5474,9 +4955,7 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFiPKvS0_PvE",
    "return_type" : "_ZTIi",
-   "self_type" : "_ZTIFiPKvS0_PvE",
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
@@ -5489,9 +4968,7 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFiPvE",
    "return_type" : "_ZTIi",
-   "self_type" : "_ZTIFiPvE",
    "source_file" : "system/core/libutils/include/utils/AndroidThreads.h"
   },
   {
@@ -5510,18 +4987,14 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFiiiPvE",
    "return_type" : "_ZTIi",
-   "self_type" : "_ZTIFiiiPvE",
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIFvvE",
    "name" : "void ()",
-   "referenced_type" : "_ZTIFvvE",
    "return_type" : "_ZTIv",
-   "self_type" : "_ZTIFvvE",
    "source_file" : "system/core/libutils/include/utils/misc.h"
   }
  ],
@@ -6849,48 +6322,6 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/misc.h"
   },
-  {
-   "function_name" : "android::sp<android::LooperCallback>::clear",
-   "linker_set_key" : "_ZN7android2spINS_14LooperCallbackEE5clearEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android2spINS_14LooperCallbackEEE"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
-  },
-  {
-   "function_name" : "android::sp<android::Looper>::operator=",
-   "linker_set_key" : "_ZN7android2spINS_6LooperEEaSEOS2_",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android2spINS_6LooperEEE"
-    },
-    {
-     "referenced_type" : "_ZTION7android2spINS_6LooperEEE"
-    }
-   ],
-   "return_type" : "_ZTIRN7android2spINS_6LooperEEE",
-   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
-  },
-  {
-   "function_name" : "android::sp<android::Thread>::clear",
-   "linker_set_key" : "_ZN7android2spINS_6ThreadEE5clearEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android2spINS_6ThreadEEE"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
-  },
   {
    "function_name" : "android::LightRefBase_reportIncStrongRequireStrongFailed",
    "linker_set_key" : "_ZN7android47LightRefBase_reportIncStrongRequireStrongFailedEPKv",
@@ -6975,6 +6406,34 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
+  {
+   "function_name" : "android::Looper::getFdStateDebug",
+   "linker_set_key" : "_ZN7android6Looper15getFdStateDebugEiPiS1_PNS_2spINS_14LooperCallbackEEEPPv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android6LooperE"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPi"
+    },
+    {
+     "referenced_type" : "_ZTIPi"
+    },
+    {
+     "referenced_type" : "_ZTIPN7android2spINS_14LooperCallbackEEE"
+    },
+    {
+     "referenced_type" : "_ZTIPPv"
+    }
+   ],
+   "return_type" : "_ZTIb",
+   "source_file" : "system/core/libutils/include/utils/Looper.h"
+  },
   {
    "function_name" : "android::Looper::sendMessageAtTime",
    "linker_set_key" : "_ZN7android6Looper17sendMessageAtTimeElRKNS_2spINS_14MessageHandlerEEERKNS_7MessageE",
@@ -7701,7 +7160,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -7730,7 +7189,7 @@
    "parameters" :
    [
     {
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7749,7 +7208,7 @@
    "parameters" :
    [
     {
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7768,7 +7227,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7784,7 +7243,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7800,7 +7259,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7816,7 +7275,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7832,7 +7291,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7848,7 +7307,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIb"
@@ -7868,7 +7327,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7885,7 +7344,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7902,7 +7361,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIi"
@@ -7919,7 +7378,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIj"
@@ -7939,7 +7398,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -7953,7 +7412,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -7967,7 +7426,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -7981,7 +7440,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -7995,7 +7454,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8008,7 +7467,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIm"
@@ -8025,7 +7484,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8044,7 +7503,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8060,7 +7519,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIm"
@@ -8076,7 +7535,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8089,7 +7548,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8108,7 +7567,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8121,7 +7580,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -8140,7 +7599,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -8159,7 +7618,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8175,7 +7634,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8194,10 +7653,10 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8210,7 +7669,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8226,7 +7685,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8245,10 +7704,10 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIi",
@@ -8263,7 +7722,7 @@
      "referenced_type" : "_ZTIPKc"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
@@ -8278,7 +7737,7 @@
      "referenced_type" : "_ZTISt9__va_list"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
@@ -8288,7 +7747,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8301,7 +7760,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8317,7 +7776,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -8333,7 +7792,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -8352,7 +7811,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -8368,7 +7827,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -8387,7 +7846,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8403,7 +7862,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8422,7 +7881,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIRKN7android8String16E"
@@ -8438,10 +7897,10 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8454,7 +7913,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8467,7 +7926,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -8483,7 +7942,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -8502,7 +7961,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -8518,7 +7977,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -8537,7 +7996,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8553,7 +8012,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8572,7 +8031,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIRKN7android8String16E"
@@ -8588,10 +8047,10 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8604,7 +8063,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8617,7 +8076,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8630,7 +8089,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -9005,7 +8464,7 @@
      "referenced_type" : "_ZTIPN7android8String16E"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -9159,7 +8618,7 @@
      "referenced_type" : "_ZTIPN7android8String16E"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -9571,7 +9030,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIm"
@@ -9587,7 +9046,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIm",
@@ -9601,7 +9060,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIm",
@@ -9740,433 +9199,37 @@
    "source_file" : "system/core/libutils/include/utils/Thread.h"
   },
   {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::sysprop_change_callback_info>::do_destroy",
-   "linker_set_key" : "_ZNK7android6VectorINS_28sysprop_change_callback_infoEE10do_destroyEPvm",
+   "function_name" : "android::RefBase::createWeak",
+   "linker_set_key" : "_ZNK7android7RefBase10createWeakEPKv",
    "parameters" :
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_28sysprop_change_callback_infoEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIm"
+     "referenced_type" : "_ZTIPKv"
     }
    ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
+   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::sysprop_change_callback_info>::do_construct",
-   "linker_set_key" : "_ZNK7android6VectorINS_28sysprop_change_callback_infoEE12do_constructEPvm",
+   "function_name" : "android::RefBase::getWeakRefs",
+   "linker_set_key" : "_ZNK7android7RefBase11getWeakRefsEv",
    "parameters" :
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_28sysprop_change_callback_infoEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
+   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::sysprop_change_callback_info>::do_move_forward",
-   "linker_set_key" : "_ZNK7android6VectorINS_28sysprop_change_callback_infoEE15do_move_forwardEPvPKvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_28sysprop_change_callback_infoEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIPKv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::sysprop_change_callback_info>::do_move_backward",
-   "linker_set_key" : "_ZNK7android6VectorINS_28sysprop_change_callback_infoEE16do_move_backwardEPvPKvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_28sysprop_change_callback_infoEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIPKv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::sysprop_change_callback_info>::do_copy",
-   "linker_set_key" : "_ZNK7android6VectorINS_28sysprop_change_callback_infoEE7do_copyEPvPKvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_28sysprop_change_callback_infoEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIPKv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::sysprop_change_callback_info>::do_splat",
-   "linker_set_key" : "_ZNK7android6VectorINS_28sysprop_change_callback_infoEE8do_splatEPvPKvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_28sysprop_change_callback_infoEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIPKv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::Looper::MessageEnvelope>::do_destroy",
-   "linker_set_key" : "_ZNK7android6VectorINS_6Looper15MessageEnvelopeEE10do_destroyEPvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_6Looper15MessageEnvelopeEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::Looper::MessageEnvelope>::do_construct",
-   "linker_set_key" : "_ZNK7android6VectorINS_6Looper15MessageEnvelopeEE12do_constructEPvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_6Looper15MessageEnvelopeEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::Looper::MessageEnvelope>::do_move_forward",
-   "linker_set_key" : "_ZNK7android6VectorINS_6Looper15MessageEnvelopeEE15do_move_forwardEPvPKvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_6Looper15MessageEnvelopeEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIPKv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::Looper::MessageEnvelope>::do_move_backward",
-   "linker_set_key" : "_ZNK7android6VectorINS_6Looper15MessageEnvelopeEE16do_move_backwardEPvPKvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_6Looper15MessageEnvelopeEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIPKv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::Looper::MessageEnvelope>::do_copy",
-   "linker_set_key" : "_ZNK7android6VectorINS_6Looper15MessageEnvelopeEE7do_copyEPvPKvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_6Looper15MessageEnvelopeEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIPKv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::Looper::MessageEnvelope>::do_splat",
-   "linker_set_key" : "_ZNK7android6VectorINS_6Looper15MessageEnvelopeEE8do_splatEPvPKvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_6Looper15MessageEnvelopeEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIPKv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::Looper::Response>::do_destroy",
-   "linker_set_key" : "_ZNK7android6VectorINS_6Looper8ResponseEE10do_destroyEPvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_6Looper8ResponseEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::Looper::Response>::do_construct",
-   "linker_set_key" : "_ZNK7android6VectorINS_6Looper8ResponseEE12do_constructEPvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_6Looper8ResponseEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::Looper::Response>::do_move_forward",
-   "linker_set_key" : "_ZNK7android6VectorINS_6Looper8ResponseEE15do_move_forwardEPvPKvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_6Looper8ResponseEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIPKv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::Looper::Response>::do_move_backward",
-   "linker_set_key" : "_ZNK7android6VectorINS_6Looper8ResponseEE16do_move_backwardEPvPKvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_6Looper8ResponseEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIPKv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::Looper::Response>::do_copy",
-   "linker_set_key" : "_ZNK7android6VectorINS_6Looper8ResponseEE7do_copyEPvPKvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_6Looper8ResponseEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIPKv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "access" : "protected",
-   "function_name" : "android::Vector<android::Looper::Response>::do_splat",
-   "linker_set_key" : "_ZNK7android6VectorINS_6Looper8ResponseEE8do_splatEPvPKvm",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android6VectorINS_6Looper8ResponseEEE"
-    },
-    {
-     "referenced_type" : "_ZTIPv"
-    },
-    {
-     "referenced_type" : "_ZTIPKv"
-    },
-    {
-     "referenced_type" : "_ZTIm"
-    }
-   ],
-   "return_type" : "_ZTIv",
-   "source_file" : "system/core/libutils/include/utils/Vector.h"
-  },
-  {
-   "function_name" : "android::RefBase::createWeak",
-   "linker_set_key" : "_ZNK7android7RefBase10createWeakEPKv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
-    },
-    {
-     "referenced_type" : "_ZTIPKv"
-    }
-   ],
-   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
-  },
-  {
-   "function_name" : "android::RefBase::getWeakRefs",
-   "linker_set_key" : "_ZNK7android7RefBase11getWeakRefsEv",
-   "parameters" :
-   [
-    {
-     "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
-    }
-   ],
-   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
-  },
-  {
-   "function_name" : "android::RefBase::weakref_type::getWeakCount",
-   "linker_set_key" : "_ZNK7android7RefBase12weakref_type12getWeakCountEv",
+   "function_name" : "android::RefBase::weakref_type::getWeakCount",
+   "linker_set_key" : "_ZNK7android7RefBase12weakref_type12getWeakCountEv",
    "parameters" :
    [
     {
@@ -10187,7 +9250,7 @@
      "referenced_type" : "_ZTIPKN7android7RefBase12weakref_typeE"
     }
    ],
-   "return_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "return_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
@@ -10210,7 +9273,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -10226,7 +9289,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIi",
@@ -10239,7 +9302,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -10255,7 +9318,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -10271,7 +9334,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -10288,10 +9351,10 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
@@ -10302,10 +9365,10 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
@@ -10315,7 +9378,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -10335,7 +9398,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIm",
@@ -10935,7 +9998,6 @@
    "linker_set_key" : "_ZTIRA1_KDs",
    "name" : "const char16_t (&)[1]",
    "referenced_type" : "_ZTIA1_KDs",
-   "self_type" : "_ZTIRA1_KDs",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -10943,8 +10005,7 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIRKN7android10VectorImplE",
    "name" : "const android::VectorImpl &",
-   "referenced_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIRKN7android10VectorImplE",
+   "referenced_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -10953,7 +10014,6 @@
    "linker_set_key" : "_ZTIRKN7android16ReferenceRenamerE",
    "name" : "const android::ReferenceRenamer &",
    "referenced_type" : "_ZTIKN7android16ReferenceRenamerE",
-   "self_type" : "_ZTIRKN7android16ReferenceRenamerE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -10962,7 +10022,6 @@
    "linker_set_key" : "_ZTIRKN7android16SortedVectorImplE",
    "name" : "const android::SortedVectorImpl &",
    "referenced_type" : "_ZTIKN7android16SortedVectorImplE",
-   "self_type" : "_ZTIRKN7android16SortedVectorImplE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -10971,7 +10030,6 @@
    "linker_set_key" : "_ZTIRKN7android28sysprop_change_callback_infoE",
    "name" : "const android::sysprop_change_callback_info &",
    "referenced_type" : "_ZTIKN7android28sysprop_change_callback_infoE",
-   "self_type" : "_ZTIRKN7android28sysprop_change_callback_infoE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -10980,7 +10038,6 @@
    "linker_set_key" : "_ZTIRKN7android2spINS_14LooperCallbackEEE",
    "name" : "const android::sp<android::LooperCallback> &",
    "referenced_type" : "_ZTIKN7android2spINS_14LooperCallbackEEE",
-   "self_type" : "_ZTIRKN7android2spINS_14LooperCallbackEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -10989,7 +10046,6 @@
    "linker_set_key" : "_ZTIRKN7android2spINS_14MessageHandlerEEE",
    "name" : "const android::sp<android::MessageHandler> &",
    "referenced_type" : "_ZTIKN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIRKN7android2spINS_14MessageHandlerEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -10998,7 +10054,6 @@
    "linker_set_key" : "_ZTIRKN7android2spINS_20SimpleLooperCallbackEEE",
    "name" : "const android::sp<android::SimpleLooperCallback> &",
    "referenced_type" : "_ZTIKN7android2spINS_20SimpleLooperCallbackEEE",
-   "self_type" : "_ZTIRKN7android2spINS_20SimpleLooperCallbackEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11007,16 +10062,14 @@
    "linker_set_key" : "_ZTIRKN7android2spINS_6LooperEEE",
    "name" : "const android::sp<android::Looper> &",
    "referenced_type" : "_ZTIKN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTIRKN7android2spINS_6LooperEEE",
    "size" : 8,
-   "source_file" : "system/core/libutils/include/utils/Looper.h"
+   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTIRKN7android2spINS_6ThreadEEE",
    "name" : "const android::sp<android::Thread> &",
    "referenced_type" : "_ZTIKN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTIRKN7android2spINS_6ThreadEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11025,7 +10078,6 @@
    "linker_set_key" : "_ZTIRKN7android2wpINS_14MessageHandlerEEE",
    "name" : "const android::wp<android::MessageHandler> &",
    "referenced_type" : "_ZTIKN7android2wpINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIRKN7android2wpINS_14MessageHandlerEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11034,7 +10086,6 @@
    "linker_set_key" : "_ZTIRKN7android6Looper15MessageEnvelopeE",
    "name" : "const android::Looper::MessageEnvelope &",
    "referenced_type" : "_ZTIKN7android6Looper15MessageEnvelopeE",
-   "self_type" : "_ZTIRKN7android6Looper15MessageEnvelopeE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11043,7 +10094,6 @@
    "linker_set_key" : "_ZTIRKN7android6Looper8ResponseE",
    "name" : "const android::Looper::Response &",
    "referenced_type" : "_ZTIKN7android6Looper8ResponseE",
-   "self_type" : "_ZTIRKN7android6Looper8ResponseE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11052,7 +10102,6 @@
    "linker_set_key" : "_ZTIRKN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "name" : "const android::Vector<android::sysprop_change_callback_info> &",
    "referenced_type" : "_ZTIKN7android6VectorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIRKN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11061,7 +10110,6 @@
    "linker_set_key" : "_ZTIRKN7android7MessageE",
    "name" : "const android::Message &",
    "referenced_type" : "_ZTIKN7android7MessageE",
-   "self_type" : "_ZTIRKN7android7MessageE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -11070,7 +10118,6 @@
    "linker_set_key" : "_ZTIRKN7android7String8E",
    "name" : "const android::String8 &",
    "referenced_type" : "_ZTIKN7android7String8E",
-   "self_type" : "_ZTIRKN7android7String8E",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
@@ -11078,8 +10125,8 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIRKN7android7String8E",
    "name" : "const android::String8 &",
-   "referenced_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -11088,7 +10135,6 @@
    "linker_set_key" : "_ZTIRKN7android8String1610StaticDataILm1EEE",
    "name" : "const android::String16::StaticData<1> &",
    "referenced_type" : "_ZTIKN7android8String1610StaticDataILm1EEE",
-   "self_type" : "_ZTIRKN7android8String1610StaticDataILm1EEE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11097,7 +10143,6 @@
    "linker_set_key" : "_ZTIRKN7android8String16E",
    "name" : "const android::String16 &",
    "referenced_type" : "_ZTIKN7android8String16E",
-   "self_type" : "_ZTIRKN7android8String16E",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11106,7 +10151,6 @@
    "linker_set_key" : "_ZTIRKa",
    "name" : "const signed char &",
    "referenced_type" : "_ZTIKa",
-   "self_type" : "_ZTIRKa",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11115,7 +10159,6 @@
    "linker_set_key" : "_ZTIRKb",
    "name" : "const bool &",
    "referenced_type" : "_ZTIKb",
-   "self_type" : "_ZTIRKb",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11124,7 +10167,6 @@
    "linker_set_key" : "_ZTIRKd",
    "name" : "const double &",
    "referenced_type" : "_ZTIKd",
-   "self_type" : "_ZTIRKd",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11133,7 +10175,6 @@
    "linker_set_key" : "_ZTIRKf",
    "name" : "const float &",
    "referenced_type" : "_ZTIKf",
-   "self_type" : "_ZTIRKf",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11142,7 +10183,6 @@
    "linker_set_key" : "_ZTIRKh",
    "name" : "const unsigned char &",
    "referenced_type" : "_ZTIKh",
-   "self_type" : "_ZTIRKh",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11151,7 +10191,6 @@
    "linker_set_key" : "_ZTIRKi",
    "name" : "const int &",
    "referenced_type" : "_ZTIKi",
-   "self_type" : "_ZTIRKi",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11160,7 +10199,6 @@
    "linker_set_key" : "_ZTIRKj",
    "name" : "const unsigned int &",
    "referenced_type" : "_ZTIKj",
-   "self_type" : "_ZTIRKj",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11169,7 +10207,6 @@
    "linker_set_key" : "_ZTIRKl",
    "name" : "const long &",
    "referenced_type" : "_ZTIKl",
-   "self_type" : "_ZTIRKl",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11178,7 +10215,6 @@
    "linker_set_key" : "_ZTIRKm",
    "name" : "const unsigned long &",
    "referenced_type" : "_ZTIKm",
-   "self_type" : "_ZTIRKm",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11187,7 +10223,6 @@
    "linker_set_key" : "_ZTIRKs",
    "name" : "const short &",
    "referenced_type" : "_ZTIKs",
-   "self_type" : "_ZTIRKs",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11196,7 +10231,6 @@
    "linker_set_key" : "_ZTIRKt",
    "name" : "const unsigned short &",
    "referenced_type" : "_ZTIKt",
-   "self_type" : "_ZTIRKt",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11204,8 +10238,7 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIRN7android10VectorImplE",
    "name" : "android::VectorImpl &",
-   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIRN7android10VectorImplE",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11213,8 +10246,7 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIRN7android16SortedVectorImplE",
    "name" : "android::SortedVectorImpl &",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIRN7android16SortedVectorImplE",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11223,7 +10255,6 @@
    "linker_set_key" : "_ZTIRN7android2spINS_14LooperCallbackEEE",
    "name" : "android::sp<android::LooperCallback> &",
    "referenced_type" : "_ZTIN7android2spINS_14LooperCallbackEEE",
-   "self_type" : "_ZTIRN7android2spINS_14LooperCallbackEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11232,7 +10263,6 @@
    "linker_set_key" : "_ZTIRN7android2spINS_14MessageHandlerEEE",
    "name" : "android::sp<android::MessageHandler> &",
    "referenced_type" : "_ZTIN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIRN7android2spINS_14MessageHandlerEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11241,7 +10271,6 @@
    "linker_set_key" : "_ZTIRN7android2spINS_20SimpleLooperCallbackEEE",
    "name" : "android::sp<android::SimpleLooperCallback> &",
    "referenced_type" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
-   "self_type" : "_ZTIRN7android2spINS_20SimpleLooperCallbackEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11250,7 +10279,6 @@
    "linker_set_key" : "_ZTIRN7android2spINS_6LooperEEE",
    "name" : "android::sp<android::Looper> &",
    "referenced_type" : "_ZTIN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTIRN7android2spINS_6LooperEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11259,7 +10287,6 @@
    "linker_set_key" : "_ZTIRN7android2spINS_6ThreadEEE",
    "name" : "android::sp<android::Thread> &",
    "referenced_type" : "_ZTIN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTIRN7android2spINS_6ThreadEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11268,7 +10295,6 @@
    "linker_set_key" : "_ZTIRN7android5MutexE",
    "name" : "android::Mutex &",
    "referenced_type" : "_ZTIN7android5MutexE",
-   "self_type" : "_ZTIRN7android5MutexE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Mutex.h"
   },
@@ -11277,7 +10303,6 @@
    "linker_set_key" : "_ZTIRN7android6Looper8ResponseE",
    "name" : "android::Looper::Response &",
    "referenced_type" : "_ZTIN7android6Looper8ResponseE",
-   "self_type" : "_ZTIRN7android6Looper8ResponseE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11286,7 +10311,6 @@
    "linker_set_key" : "_ZTIRN7android6RWLockE",
    "name" : "android::RWLock &",
    "referenced_type" : "_ZTIN7android6RWLockE",
-   "self_type" : "_ZTIRN7android6RWLockE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -11295,7 +10319,6 @@
    "linker_set_key" : "_ZTIRN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "name" : "android::Vector<android::sysprop_change_callback_info> &",
    "referenced_type" : "_ZTIN7android6VectorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIRN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11304,7 +10327,6 @@
    "linker_set_key" : "_ZTIRN7android7FileMapE",
    "name" : "android::FileMap &",
    "referenced_type" : "_ZTIN7android7FileMapE",
-   "self_type" : "_ZTIRN7android7FileMapE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -11313,7 +10335,6 @@
    "linker_set_key" : "_ZTIRN7android7PrinterE",
    "name" : "android::Printer &",
    "referenced_type" : "_ZTIN7android7PrinterE",
-   "self_type" : "_ZTIRN7android7PrinterE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -11322,7 +10343,6 @@
    "linker_set_key" : "_ZTIRN7android7String8E",
    "name" : "android::String8 &",
    "referenced_type" : "_ZTIN7android7String8E",
-   "self_type" : "_ZTIRN7android7String8E",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
@@ -11330,8 +10350,8 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIRN7android7String8E",
    "name" : "android::String8 &",
-   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIRN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIRN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -11340,7 +10360,6 @@
    "linker_set_key" : "_ZTIRN7android8String16E",
    "name" : "android::String16 &",
    "referenced_type" : "_ZTIN7android8String16E",
-   "self_type" : "_ZTIRN7android8String16E",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11349,7 +10368,6 @@
    "linker_set_key" : "_ZTIRP13native_handle",
    "name" : "native_handle *&",
    "referenced_type" : "_ZTIP13native_handle",
-   "self_type" : "_ZTIRP13native_handle",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11358,7 +10376,6 @@
    "linker_set_key" : "_ZTIRPFiiiPvE",
    "name" : "int (*&)(int, int, void *)",
    "referenced_type" : "_ZTIPFiiiPvE",
-   "self_type" : "_ZTIRPFiiiPvE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11367,7 +10384,6 @@
    "linker_set_key" : "_ZTIRb",
    "name" : "bool &",
    "referenced_type" : "_ZTIb",
-   "self_type" : "_ZTIRb",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   }
@@ -11379,7 +10395,6 @@
    "linker_set_key" : "_ZTIP13native_handle",
    "name" : "native_handle *",
    "referenced_type" : "_ZTI13native_handle",
-   "self_type" : "_ZTIP13native_handle",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11388,7 +10403,6 @@
    "linker_set_key" : "_ZTIP18android_flex_plane",
    "name" : "android_flex_plane *",
    "referenced_type" : "_ZTI18android_flex_plane",
-   "self_type" : "_ZTIP18android_flex_plane",
    "size" : 8,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -11397,7 +10411,6 @@
    "linker_set_key" : "_ZTIP3DIR",
    "name" : "DIR *",
    "referenced_type" : "_ZTI3DIR",
-   "self_type" : "_ZTIP3DIR",
    "size" : 8,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -11406,7 +10419,6 @@
    "linker_set_key" : "_ZTIP7__sFILE",
    "name" : "__sFILE *",
    "referenced_type" : "_ZTI7__sFILE",
-   "self_type" : "_ZTIP7__sFILE",
    "size" : 8,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -11415,7 +10427,6 @@
    "linker_set_key" : "_ZTIP7log_msg",
    "name" : "log_msg *",
    "referenced_type" : "_ZTI7log_msg",
-   "self_type" : "_ZTIP7log_msg",
    "size" : 8,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   },
@@ -11424,7 +10435,6 @@
    "linker_set_key" : "_ZTIPDs",
    "name" : "char16_t *",
    "referenced_type" : "_ZTIDs",
-   "self_type" : "_ZTIPDs",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11433,7 +10443,6 @@
    "linker_set_key" : "_ZTIPFiPFiPvES_PKcimPS_E",
    "name" : "int (*)(int (*)(void *), void *, const char *, int, unsigned long, void **)",
    "referenced_type" : "_ZTIFiPFiPvES_PKcimPS_E",
-   "self_type" : "_ZTIPFiPFiPvES_PKcimPS_E",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/AndroidThreads.h"
   },
@@ -11442,7 +10451,6 @@
    "linker_set_key" : "_ZTIPFiPKvS0_E",
    "name" : "int (*)(const void *, const void *)",
    "referenced_type" : "_ZTIFiPKvS0_E",
-   "self_type" : "_ZTIPFiPKvS0_E",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11451,7 +10459,6 @@
    "linker_set_key" : "_ZTIPFiPKvS0_PvE",
    "name" : "int (*)(const void *, const void *, void *)",
    "referenced_type" : "_ZTIFiPKvS0_PvE",
-   "self_type" : "_ZTIPFiPKvS0_PvE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11460,7 +10467,6 @@
    "linker_set_key" : "_ZTIPFiPvE",
    "name" : "int (*)(void *)",
    "referenced_type" : "_ZTIFiPvE",
-   "self_type" : "_ZTIPFiPvE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/AndroidThreads.h"
   },
@@ -11469,7 +10475,6 @@
    "linker_set_key" : "_ZTIPFiiiPvE",
    "name" : "int (*)(int, int, void *)",
    "referenced_type" : "_ZTIFiiiPvE",
-   "self_type" : "_ZTIPFiiiPvE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11478,7 +10483,6 @@
    "linker_set_key" : "_ZTIPFvvE",
    "name" : "void (*)()",
    "referenced_type" : "_ZTIFvvE",
-   "self_type" : "_ZTIPFvvE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/misc.h"
   },
@@ -11487,7 +10491,6 @@
    "linker_set_key" : "_ZTIPK13native_handle",
    "name" : "const native_handle *",
    "referenced_type" : "_ZTIK13native_handle",
-   "self_type" : "_ZTIPK13native_handle",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/NativeHandle.h"
   },
@@ -11496,7 +10499,6 @@
    "linker_set_key" : "_ZTIPK7log_msg",
    "name" : "const log_msg *",
    "referenced_type" : "_ZTIK7log_msg",
-   "self_type" : "_ZTIPK7log_msg",
    "size" : 8,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   },
@@ -11505,7 +10507,6 @@
    "linker_set_key" : "_ZTIPKDi",
    "name" : "const char32_t *",
    "referenced_type" : "_ZTIKDi",
-   "self_type" : "_ZTIPKDi",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -11514,7 +10515,6 @@
    "linker_set_key" : "_ZTIPKDs",
    "name" : "const char16_t *",
    "referenced_type" : "_ZTIKDs",
-   "self_type" : "_ZTIPKDs",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11523,7 +10523,6 @@
    "linker_set_key" : "_ZTIPKN7android10VectorImplE",
    "name" : "const android::VectorImpl *",
    "referenced_type" : "_ZTIKN7android10VectorImplE",
-   "self_type" : "_ZTIPKN7android10VectorImplE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
   },
@@ -11531,8 +10530,8 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIPKN7android10VectorImplE",
    "name" : "const android::VectorImpl *",
-   "referenced_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11541,7 +10540,6 @@
    "linker_set_key" : "_ZTIPKN7android12LightRefBaseINS_12NativeHandleEEE",
    "name" : "const android::LightRefBase<android::NativeHandle> *",
    "referenced_type" : "_ZTIKN7android12LightRefBaseINS_12NativeHandleEEE",
-   "self_type" : "_ZTIPKN7android12LightRefBaseINS_12NativeHandleEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
@@ -11550,7 +10548,6 @@
    "linker_set_key" : "_ZTIPKN7android12NativeHandleE",
    "name" : "const android::NativeHandle *",
    "referenced_type" : "_ZTIKN7android12NativeHandleE",
-   "self_type" : "_ZTIPKN7android12NativeHandleE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/NativeHandle.h"
   },
@@ -11559,7 +10556,6 @@
    "linker_set_key" : "_ZTIPKN7android16SortedVectorImplE",
    "name" : "const android::SortedVectorImpl *",
    "referenced_type" : "_ZTIKN7android16SortedVectorImplE",
-   "self_type" : "_ZTIPKN7android16SortedVectorImplE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11568,7 +10564,6 @@
    "linker_set_key" : "_ZTIPKN7android28sysprop_change_callback_infoE",
    "name" : "const android::sysprop_change_callback_info *",
    "referenced_type" : "_ZTIKN7android28sysprop_change_callback_infoE",
-   "self_type" : "_ZTIPKN7android28sysprop_change_callback_infoE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11577,7 +10572,6 @@
    "linker_set_key" : "_ZTIPKN7android2spINS_14LooperCallbackEEE",
    "name" : "const android::sp<android::LooperCallback> *",
    "referenced_type" : "_ZTIKN7android2spINS_14LooperCallbackEEE",
-   "self_type" : "_ZTIPKN7android2spINS_14LooperCallbackEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11586,7 +10580,6 @@
    "linker_set_key" : "_ZTIPKN7android2spINS_14MessageHandlerEEE",
    "name" : "const android::sp<android::MessageHandler> *",
    "referenced_type" : "_ZTIKN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIPKN7android2spINS_14MessageHandlerEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11595,7 +10588,6 @@
    "linker_set_key" : "_ZTIPKN7android2spINS_6LooperEEE",
    "name" : "const android::sp<android::Looper> *",
    "referenced_type" : "_ZTIKN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTIPKN7android2spINS_6LooperEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11604,7 +10596,6 @@
    "linker_set_key" : "_ZTIPKN7android2spINS_6ThreadEEE",
    "name" : "const android::sp<android::Thread> *",
    "referenced_type" : "_ZTIKN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTIPKN7android2spINS_6ThreadEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11613,7 +10604,6 @@
    "linker_set_key" : "_ZTIPKN7android2wpINS_14MessageHandlerEEE",
    "name" : "const android::wp<android::MessageHandler> *",
    "referenced_type" : "_ZTIKN7android2wpINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIPKN7android2wpINS_14MessageHandlerEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11622,7 +10612,6 @@
    "linker_set_key" : "_ZTIPKN7android2wpINS_6ThreadEEE",
    "name" : "const android::wp<android::Thread> *",
    "referenced_type" : "_ZTIKN7android2wpINS_6ThreadEEE",
-   "self_type" : "_ZTIPKN7android2wpINS_6ThreadEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11631,7 +10620,6 @@
    "linker_set_key" : "_ZTIPKN7android4base11borrowed_fdE",
    "name" : "const android::base::borrowed_fd *",
    "referenced_type" : "_ZTIKN7android4base11borrowed_fdE",
-   "self_type" : "_ZTIPKN7android4base11borrowed_fdE",
    "size" : 8,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -11640,7 +10628,6 @@
    "linker_set_key" : "_ZTIPKN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "name" : "const android::base::unique_fd_impl<android::base::DefaultCloser> *",
    "referenced_type" : "_ZTIKN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
-   "self_type" : "_ZTIPKN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "size" : 8,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -11649,7 +10636,6 @@
    "linker_set_key" : "_ZTIPKN7android6Looper15MessageEnvelopeE",
    "name" : "const android::Looper::MessageEnvelope *",
    "referenced_type" : "_ZTIKN7android6Looper15MessageEnvelopeE",
-   "self_type" : "_ZTIPKN7android6Looper15MessageEnvelopeE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11658,7 +10644,6 @@
    "linker_set_key" : "_ZTIPKN7android6Looper7RequestE",
    "name" : "const android::Looper::Request *",
    "referenced_type" : "_ZTIKN7android6Looper7RequestE",
-   "self_type" : "_ZTIPKN7android6Looper7RequestE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -11667,7 +10652,6 @@
    "linker_set_key" : "_ZTIPKN7android6Looper8ResponseE",
    "name" : "const android::Looper::Response *",
    "referenced_type" : "_ZTIKN7android6Looper8ResponseE",
-   "self_type" : "_ZTIPKN7android6Looper8ResponseE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11676,7 +10660,6 @@
    "linker_set_key" : "_ZTIPKN7android6LooperE",
    "name" : "const android::Looper *",
    "referenced_type" : "_ZTIKN7android6LooperE",
-   "self_type" : "_ZTIPKN7android6LooperE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -11685,7 +10668,6 @@
    "linker_set_key" : "_ZTIPKN7android6ThreadE",
    "name" : "const android::Thread *",
    "referenced_type" : "_ZTIKN7android6ThreadE",
-   "self_type" : "_ZTIPKN7android6ThreadE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Thread.h"
   },
@@ -11694,7 +10676,6 @@
    "linker_set_key" : "_ZTIPKN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "name" : "const android::Vector<android::sysprop_change_callback_info> *",
    "referenced_type" : "_ZTIKN7android6VectorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIPKN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11703,7 +10684,6 @@
    "linker_set_key" : "_ZTIPKN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "name" : "const android::Vector<android::Looper::MessageEnvelope> *",
    "referenced_type" : "_ZTIKN7android6VectorINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIPKN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11712,7 +10692,6 @@
    "linker_set_key" : "_ZTIPKN7android6VectorINS_6Looper8ResponseEEE",
    "name" : "const android::Vector<android::Looper::Response> *",
    "referenced_type" : "_ZTIKN7android6VectorINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIPKN7android6VectorINS_6Looper8ResponseEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11721,7 +10700,6 @@
    "linker_set_key" : "_ZTIPKN7android6VectorINS_7String8EEE",
    "name" : "const android::Vector<android::String8> *",
    "referenced_type" : "_ZTIKN7android6VectorINS_7String8EEE",
-   "self_type" : "_ZTIPKN7android6VectorINS_7String8EEE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/Vector.h"
   },
@@ -11730,7 +10708,6 @@
    "linker_set_key" : "_ZTIPKN7android7FileMapE",
    "name" : "const android::FileMap *",
    "referenced_type" : "_ZTIKN7android7FileMapE",
-   "self_type" : "_ZTIPKN7android7FileMapE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -11739,7 +10716,6 @@
    "linker_set_key" : "_ZTIPKN7android7RefBase12weakref_typeE",
    "name" : "const android::RefBase::weakref_type *",
    "referenced_type" : "_ZTIKN7android7RefBase12weakref_typeE",
-   "self_type" : "_ZTIPKN7android7RefBase12weakref_typeE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -11748,7 +10724,6 @@
    "linker_set_key" : "_ZTIPKN7android7RefBaseE",
    "name" : "const android::RefBase *",
    "referenced_type" : "_ZTIKN7android7RefBaseE",
-   "self_type" : "_ZTIPKN7android7RefBaseE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11756,8 +10731,8 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIPKN7android7RefBaseE",
    "name" : "const android::RefBase *",
-   "referenced_type" : "_ZTIKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -11766,7 +10741,6 @@
    "linker_set_key" : "_ZTIPKN7android7String8E",
    "name" : "const android::String8 *",
    "referenced_type" : "_ZTIKN7android7String8E",
-   "self_type" : "_ZTIPKN7android7String8E",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
@@ -11774,8 +10748,8 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIPKN7android7String8E",
    "name" : "const android::String8 *",
-   "referenced_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -11784,7 +10758,6 @@
    "linker_set_key" : "_ZTIPKN7android8String16E",
    "name" : "const android::String16 *",
    "referenced_type" : "_ZTIKN7android8String16E",
-   "self_type" : "_ZTIPKN7android8String16E",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11793,7 +10766,6 @@
    "linker_set_key" : "_ZTIPKN7android9StopWatchE",
    "name" : "const android::StopWatch *",
    "referenced_type" : "_ZTIKN7android9StopWatchE",
-   "self_type" : "_ZTIPKN7android9StopWatchE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StopWatch.h"
   },
@@ -11802,7 +10774,6 @@
    "linker_set_key" : "_ZTIPKN7android9TokenizerE",
    "name" : "const android::Tokenizer *",
    "referenced_type" : "_ZTIKN7android9TokenizerE",
-   "self_type" : "_ZTIPKN7android9TokenizerE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Tokenizer.h"
   },
@@ -11811,7 +10782,6 @@
    "linker_set_key" : "_ZTIPKc",
    "name" : "const char *",
    "referenced_type" : "_ZTIKc",
-   "self_type" : "_ZTIPKc",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -11820,7 +10790,6 @@
    "linker_set_key" : "_ZTIPKh",
    "name" : "const unsigned char *",
    "referenced_type" : "_ZTIKh",
-   "self_type" : "_ZTIPKh",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/JenkinsHash.h"
   },
@@ -11829,7 +10798,6 @@
    "linker_set_key" : "_ZTIPKt",
    "name" : "const unsigned short *",
    "referenced_type" : "_ZTIKt",
-   "self_type" : "_ZTIPKt",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/JenkinsHash.h"
   },
@@ -11838,7 +10806,6 @@
    "linker_set_key" : "_ZTIPKv",
    "name" : "const void *",
    "referenced_type" : "_ZTIKv",
-   "self_type" : "_ZTIPKv",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
@@ -11847,7 +10814,6 @@
    "linker_set_key" : "_ZTIPN7android10LogPrinterE",
    "name" : "android::LogPrinter *",
    "referenced_type" : "_ZTIN7android10LogPrinterE",
-   "self_type" : "_ZTIPN7android10LogPrinterE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -11855,8 +10821,7 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIPN7android10VectorImplE",
    "name" : "android::VectorImpl *",
-   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android10VectorImplE",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11865,7 +10830,6 @@
    "linker_set_key" : "_ZTIPN7android11ScopedTraceE",
    "name" : "android::ScopedTrace *",
    "referenced_type" : "_ZTIN7android11ScopedTraceE",
-   "self_type" : "_ZTIPN7android11ScopedTraceE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Trace.h"
   },
@@ -11874,7 +10838,6 @@
    "linker_set_key" : "_ZTIPN7android12LightRefBaseINS_12NativeHandleEEE",
    "name" : "android::LightRefBase<android::NativeHandle> *",
    "referenced_type" : "_ZTIN7android12LightRefBaseINS_12NativeHandleEEE",
-   "self_type" : "_ZTIPN7android12LightRefBaseINS_12NativeHandleEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
@@ -11883,7 +10846,6 @@
    "linker_set_key" : "_ZTIPN7android12NativeHandleE",
    "name" : "android::NativeHandle *",
    "referenced_type" : "_ZTIN7android12NativeHandleE",
-   "self_type" : "_ZTIPN7android12NativeHandleE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11892,7 +10854,6 @@
    "linker_set_key" : "_ZTIPN7android13PrefixPrinterE",
    "name" : "android::PrefixPrinter *",
    "referenced_type" : "_ZTIN7android13PrefixPrinterE",
-   "self_type" : "_ZTIPN7android13PrefixPrinterE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -11901,7 +10862,6 @@
    "linker_set_key" : "_ZTIPN7android14LooperCallbackE",
    "name" : "android::LooperCallback *",
    "referenced_type" : "_ZTIN7android14LooperCallbackE",
-   "self_type" : "_ZTIPN7android14LooperCallbackE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11910,7 +10870,6 @@
    "linker_set_key" : "_ZTIPN7android14MessageHandlerE",
    "name" : "android::MessageHandler *",
    "referenced_type" : "_ZTIN7android14MessageHandlerE",
-   "self_type" : "_ZTIPN7android14MessageHandlerE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11919,7 +10878,6 @@
    "linker_set_key" : "_ZTIPN7android14StaticString16ILm1EEE",
    "name" : "android::StaticString16<1> *",
    "referenced_type" : "_ZTIN7android14StaticString16ILm1EEE",
-   "self_type" : "_ZTIPN7android14StaticString16ILm1EEE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11928,7 +10886,6 @@
    "linker_set_key" : "_ZTIPN7android14String8PrinterE",
    "name" : "android::String8Printer *",
    "referenced_type" : "_ZTIN7android14String8PrinterE",
-   "self_type" : "_ZTIPN7android14String8PrinterE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -11937,7 +10894,6 @@
    "linker_set_key" : "_ZTIPN7android16ReferenceRenamerE",
    "name" : "android::ReferenceRenamer *",
    "referenced_type" : "_ZTIN7android16ReferenceRenamerE",
-   "self_type" : "_ZTIPN7android16ReferenceRenamerE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11945,8 +10901,8 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIPN7android16ReferenceRenamerE",
    "name" : "android::ReferenceRenamer *",
-   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -11954,8 +10910,7 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIPN7android16SortedVectorImplE",
    "name" : "android::SortedVectorImpl *",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android16SortedVectorImplE",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11964,7 +10919,6 @@
    "linker_set_key" : "_ZTIPN7android18WeakMessageHandlerE",
    "name" : "android::WeakMessageHandler *",
    "referenced_type" : "_ZTIN7android18WeakMessageHandlerE",
-   "self_type" : "_ZTIPN7android18WeakMessageHandlerE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -11973,7 +10927,6 @@
    "linker_set_key" : "_ZTIPN7android19VirtualLightRefBaseE",
    "name" : "android::VirtualLightRefBase *",
    "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE",
-   "self_type" : "_ZTIPN7android19VirtualLightRefBaseE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
@@ -11981,8 +10934,8 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIPN7android19VirtualLightRefBaseE",
    "name" : "android::VirtualLightRefBase *",
-   "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/LightRefBase.h"
   },
@@ -11991,7 +10944,6 @@
    "linker_set_key" : "_ZTIPN7android20SimpleLooperCallbackE",
    "name" : "android::SimpleLooperCallback *",
    "referenced_type" : "_ZTIN7android20SimpleLooperCallbackE",
-   "self_type" : "_ZTIPN7android20SimpleLooperCallbackE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12000,7 +10952,6 @@
    "linker_set_key" : "_ZTIPN7android28sysprop_change_callback_infoE",
    "name" : "android::sysprop_change_callback_info *",
    "referenced_type" : "_ZTIN7android28sysprop_change_callback_infoE",
-   "self_type" : "_ZTIPN7android28sysprop_change_callback_infoE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12009,7 +10960,6 @@
    "linker_set_key" : "_ZTIPN7android2spINS_12NativeHandleEEE",
    "name" : "android::sp<android::NativeHandle> *",
    "referenced_type" : "_ZTIN7android2spINS_12NativeHandleEEE",
-   "self_type" : "_ZTIPN7android2spINS_12NativeHandleEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12018,7 +10968,6 @@
    "linker_set_key" : "_ZTIPN7android2spINS_14LooperCallbackEEE",
    "name" : "android::sp<android::LooperCallback> *",
    "referenced_type" : "_ZTIN7android2spINS_14LooperCallbackEEE",
-   "self_type" : "_ZTIPN7android2spINS_14LooperCallbackEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12027,7 +10976,6 @@
    "linker_set_key" : "_ZTIPN7android2spINS_14MessageHandlerEEE",
    "name" : "android::sp<android::MessageHandler> *",
    "referenced_type" : "_ZTIN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIPN7android2spINS_14MessageHandlerEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12036,7 +10984,6 @@
    "linker_set_key" : "_ZTIPN7android2spINS_20SimpleLooperCallbackEEE",
    "name" : "android::sp<android::SimpleLooperCallback> *",
    "referenced_type" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
-   "self_type" : "_ZTIPN7android2spINS_20SimpleLooperCallbackEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12045,7 +10992,6 @@
    "linker_set_key" : "_ZTIPN7android2spINS_6LooperEEE",
    "name" : "android::sp<android::Looper> *",
    "referenced_type" : "_ZTIN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTIPN7android2spINS_6LooperEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12054,7 +11000,6 @@
    "linker_set_key" : "_ZTIPN7android2spINS_6ThreadEEE",
    "name" : "android::sp<android::Thread> *",
    "referenced_type" : "_ZTIN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTIPN7android2spINS_6ThreadEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12063,7 +11008,6 @@
    "linker_set_key" : "_ZTIPN7android2wpINS_14MessageHandlerEEE",
    "name" : "android::wp<android::MessageHandler> *",
    "referenced_type" : "_ZTIN7android2wpINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIPN7android2wpINS_14MessageHandlerEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12072,7 +11016,6 @@
    "linker_set_key" : "_ZTIPN7android2wpINS_6ThreadEEE",
    "name" : "android::wp<android::Thread> *",
    "referenced_type" : "_ZTIN7android2wpINS_6ThreadEEE",
-   "self_type" : "_ZTIPN7android2wpINS_6ThreadEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12081,7 +11024,6 @@
    "linker_set_key" : "_ZTIPN7android4base11borrowed_fdE",
    "name" : "android::base::borrowed_fd *",
    "referenced_type" : "_ZTIN7android4base11borrowed_fdE",
-   "self_type" : "_ZTIPN7android4base11borrowed_fdE",
    "size" : 8,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -12090,7 +11032,6 @@
    "linker_set_key" : "_ZTIPN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "name" : "android::base::unique_fd_impl<android::base::DefaultCloser> *",
    "referenced_type" : "_ZTIN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
-   "self_type" : "_ZTIPN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "size" : 8,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -12099,7 +11040,6 @@
    "linker_set_key" : "_ZTIPN7android5Mutex8AutolockE",
    "name" : "android::Mutex::Autolock *",
    "referenced_type" : "_ZTIN7android5Mutex8AutolockE",
-   "self_type" : "_ZTIPN7android5Mutex8AutolockE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Mutex.h"
   },
@@ -12108,7 +11048,6 @@
    "linker_set_key" : "_ZTIPN7android5MutexE",
    "name" : "android::Mutex *",
    "referenced_type" : "_ZTIN7android5MutexE",
-   "self_type" : "_ZTIPN7android5MutexE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Mutex.h"
   },
@@ -12117,7 +11056,6 @@
    "linker_set_key" : "_ZTIPN7android6Looper15MessageEnvelopeE",
    "name" : "android::Looper::MessageEnvelope *",
    "referenced_type" : "_ZTIN7android6Looper15MessageEnvelopeE",
-   "self_type" : "_ZTIPN7android6Looper15MessageEnvelopeE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12126,7 +11064,6 @@
    "linker_set_key" : "_ZTIPN7android6Looper8ResponseE",
    "name" : "android::Looper::Response *",
    "referenced_type" : "_ZTIN7android6Looper8ResponseE",
-   "self_type" : "_ZTIPN7android6Looper8ResponseE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12135,7 +11072,6 @@
    "linker_set_key" : "_ZTIPN7android6LooperE",
    "name" : "android::Looper *",
    "referenced_type" : "_ZTIN7android6LooperE",
-   "self_type" : "_ZTIPN7android6LooperE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12144,7 +11080,6 @@
    "linker_set_key" : "_ZTIPN7android6RWLock9AutoRLockE",
    "name" : "android::RWLock::AutoRLock *",
    "referenced_type" : "_ZTIN7android6RWLock9AutoRLockE",
-   "self_type" : "_ZTIPN7android6RWLock9AutoRLockE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -12153,7 +11088,6 @@
    "linker_set_key" : "_ZTIPN7android6RWLock9AutoWLockE",
    "name" : "android::RWLock::AutoWLock *",
    "referenced_type" : "_ZTIN7android6RWLock9AutoWLockE",
-   "self_type" : "_ZTIPN7android6RWLock9AutoWLockE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -12162,7 +11096,6 @@
    "linker_set_key" : "_ZTIPN7android6RWLockE",
    "name" : "android::RWLock *",
    "referenced_type" : "_ZTIN7android6RWLockE",
-   "self_type" : "_ZTIPN7android6RWLockE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -12171,7 +11104,6 @@
    "linker_set_key" : "_ZTIPN7android6ThreadE",
    "name" : "android::Thread *",
    "referenced_type" : "_ZTIN7android6ThreadE",
-   "self_type" : "_ZTIPN7android6ThreadE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12180,7 +11112,6 @@
    "linker_set_key" : "_ZTIPN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "name" : "android::Vector<android::sysprop_change_callback_info> *",
    "referenced_type" : "_ZTIN7android6VectorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIPN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -12189,7 +11120,6 @@
    "linker_set_key" : "_ZTIPN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::Vector<android::Looper::MessageEnvelope> *",
    "referenced_type" : "_ZTIN7android6VectorINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIPN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -12198,7 +11128,6 @@
    "linker_set_key" : "_ZTIPN7android6VectorINS_6Looper8ResponseEEE",
    "name" : "android::Vector<android::Looper::Response> *",
    "referenced_type" : "_ZTIN7android6VectorINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIPN7android6VectorINS_6Looper8ResponseEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -12207,7 +11136,6 @@
    "linker_set_key" : "_ZTIPN7android6VectorINS_7String8EEE",
    "name" : "android::Vector<android::String8> *",
    "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE",
-   "self_type" : "_ZTIPN7android6VectorINS_7String8EEE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/Vector.h"
   },
@@ -12216,7 +11144,6 @@
    "linker_set_key" : "_ZTIPN7android7FileMapE",
    "name" : "android::FileMap *",
    "referenced_type" : "_ZTIN7android7FileMapE",
-   "self_type" : "_ZTIPN7android7FileMapE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -12225,7 +11152,6 @@
    "linker_set_key" : "_ZTIPN7android7MessageE",
    "name" : "android::Message *",
    "referenced_type" : "_ZTIN7android7MessageE",
-   "self_type" : "_ZTIPN7android7MessageE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -12234,7 +11160,6 @@
    "linker_set_key" : "_ZTIPN7android7PrinterE",
    "name" : "android::Printer *",
    "referenced_type" : "_ZTIN7android7PrinterE",
-   "self_type" : "_ZTIPN7android7PrinterE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -12243,7 +11168,6 @@
    "linker_set_key" : "_ZTIPN7android7RefBase12weakref_implE",
    "name" : "android::RefBase::weakref_impl *",
    "referenced_type" : "_ZTIN7android7RefBase12weakref_implE",
-   "self_type" : "_ZTIPN7android7RefBase12weakref_implE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12252,7 +11176,6 @@
    "linker_set_key" : "_ZTIPN7android7RefBase12weakref_typeE",
    "name" : "android::RefBase::weakref_type *",
    "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE",
-   "self_type" : "_ZTIPN7android7RefBase12weakref_typeE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12260,8 +11183,8 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIPN7android7RefBase12weakref_typeE",
    "name" : "android::RefBase::weakref_type *",
-   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -12270,7 +11193,6 @@
    "linker_set_key" : "_ZTIPN7android7RefBaseE",
    "name" : "android::RefBase *",
    "referenced_type" : "_ZTIN7android7RefBaseE",
-   "self_type" : "_ZTIPN7android7RefBaseE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12278,8 +11200,8 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIPN7android7RefBaseE",
    "name" : "android::RefBase *",
-   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -12288,7 +11210,6 @@
    "linker_set_key" : "_ZTIPN7android7String8E",
    "name" : "android::String8 *",
    "referenced_type" : "_ZTIN7android7String8E",
-   "self_type" : "_ZTIPN7android7String8E",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -12296,8 +11217,8 @@
    "alignment" : 8,
    "linker_set_key" : "_ZTIPN7android7String8E",
    "name" : "android::String8 *",
-   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -12306,7 +11227,6 @@
    "linker_set_key" : "_ZTIPN7android8String1610StaticDataILm1EEE",
    "name" : "android::String16::StaticData<1> *",
    "referenced_type" : "_ZTIN7android8String1610StaticDataILm1EEE",
-   "self_type" : "_ZTIPN7android8String1610StaticDataILm1EEE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -12315,7 +11235,6 @@
    "linker_set_key" : "_ZTIPN7android8String16E",
    "name" : "android::String16 *",
    "referenced_type" : "_ZTIN7android8String16E",
-   "self_type" : "_ZTIPN7android8String16E",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -12324,7 +11243,6 @@
    "linker_set_key" : "_ZTIPN7android9ConditionE",
    "name" : "android::Condition *",
    "referenced_type" : "_ZTIN7android9ConditionE",
-   "self_type" : "_ZTIPN7android9ConditionE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Condition.h"
   },
@@ -12333,7 +11251,6 @@
    "linker_set_key" : "_ZTIPN7android9FdPrinterE",
    "name" : "android::FdPrinter *",
    "referenced_type" : "_ZTIN7android9FdPrinterE",
-   "self_type" : "_ZTIPN7android9FdPrinterE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -12342,7 +11259,6 @@
    "linker_set_key" : "_ZTIPN7android9StopWatchE",
    "name" : "android::StopWatch *",
    "referenced_type" : "_ZTIN7android9StopWatchE",
-   "self_type" : "_ZTIPN7android9StopWatchE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StopWatch.h"
   },
@@ -12351,7 +11267,6 @@
    "linker_set_key" : "_ZTIPN7android9TokenizerE",
    "name" : "android::Tokenizer *",
    "referenced_type" : "_ZTIN7android9TokenizerE",
-   "self_type" : "_ZTIPN7android9TokenizerE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Tokenizer.h"
   },
@@ -12360,7 +11275,6 @@
    "linker_set_key" : "_ZTIPPN7android9TokenizerE",
    "name" : "android::Tokenizer **",
    "referenced_type" : "_ZTIPN7android9TokenizerE",
-   "self_type" : "_ZTIPPN7android9TokenizerE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Tokenizer.h"
   },
@@ -12369,7 +11283,6 @@
    "linker_set_key" : "_ZTIPPv",
    "name" : "void **",
    "referenced_type" : "_ZTIPv",
-   "self_type" : "_ZTIPPv",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/AndroidThreads.h"
   },
@@ -12378,7 +11291,6 @@
    "linker_set_key" : "_ZTIPc",
    "name" : "char *",
    "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIPc",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -12387,7 +11299,6 @@
    "linker_set_key" : "_ZTIPh",
    "name" : "unsigned char *",
    "referenced_type" : "_ZTIh",
-   "self_type" : "_ZTIPh",
    "size" : 8,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -12396,7 +11307,6 @@
    "linker_set_key" : "_ZTIPi",
    "name" : "int *",
    "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIPi",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -12405,7 +11315,6 @@
    "linker_set_key" : "_ZTIPm",
    "name" : "unsigned long *",
    "referenced_type" : "_ZTIm",
-   "self_type" : "_ZTIPm",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
@@ -12414,7 +11323,6 @@
    "linker_set_key" : "_ZTIPv",
    "name" : "void *",
    "referenced_type" : "_ZTIv",
-   "self_type" : "_ZTIPv",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   }
@@ -12427,7 +11335,6 @@
    "linker_set_key" : "_ZTIA1_KDs",
    "name" : "const char16_t[1]",
    "referenced_type" : "_ZTIA1_Ds",
-   "self_type" : "_ZTIA1_KDs",
    "size" : 2,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -12437,7 +11344,6 @@
    "linker_set_key" : "_ZTIK13native_handle",
    "name" : "const native_handle",
    "referenced_type" : "_ZTI13native_handle",
-   "self_type" : "_ZTIK13native_handle",
    "size" : 12,
    "source_file" : "system/core/libutils/include/utils/NativeHandle.h"
   },
@@ -12447,7 +11353,6 @@
    "linker_set_key" : "_ZTIK7log_msg",
    "name" : "const log_msg",
    "referenced_type" : "_ZTI7log_msg",
-   "self_type" : "_ZTIK7log_msg",
    "size" : 5124,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   },
@@ -12457,7 +11362,6 @@
    "linker_set_key" : "_ZTIKDi",
    "name" : "const char32_t",
    "referenced_type" : "_ZTIDi",
-   "self_type" : "_ZTIKDi",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -12467,7 +11371,6 @@
    "linker_set_key" : "_ZTIKDs",
    "name" : "const char16_t",
    "referenced_type" : "_ZTIDs",
-   "self_type" : "_ZTIKDs",
    "size" : 2,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -12476,8 +11379,8 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android10VectorImplE",
    "name" : "const android::VectorImpl",
-   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 40,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -12487,7 +11390,6 @@
    "linker_set_key" : "_ZTIKN7android10VectorImplE",
    "name" : "const android::VectorImpl",
    "referenced_type" : "_ZTIN7android10VectorImplE",
-   "self_type" : "_ZTIKN7android10VectorImplE",
    "size" : 40,
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
   },
@@ -12497,7 +11399,6 @@
    "linker_set_key" : "_ZTIKN7android12LightRefBaseINS_12NativeHandleEEE",
    "name" : "const android::LightRefBase<android::NativeHandle>",
    "referenced_type" : "_ZTIN7android12LightRefBaseINS_12NativeHandleEEE",
-   "self_type" : "_ZTIKN7android12LightRefBaseINS_12NativeHandleEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
@@ -12507,7 +11408,6 @@
    "linker_set_key" : "_ZTIKN7android12NativeHandleE",
    "name" : "const android::NativeHandle",
    "referenced_type" : "_ZTIN7android12NativeHandleE",
-   "self_type" : "_ZTIKN7android12NativeHandleE",
    "size" : 24,
    "source_file" : "system/core/libutils/include/utils/NativeHandle.h"
   },
@@ -12516,8 +11416,7 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android16ReferenceRenamerE",
    "name" : "const android::ReferenceRenamer",
-   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIKN7android16ReferenceRenamerE",
+   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -12526,8 +11425,7 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android16SortedVectorImplE",
    "name" : "const android::SortedVectorImpl",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIKN7android16SortedVectorImplE",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 40,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -12537,7 +11435,6 @@
    "linker_set_key" : "_ZTIKN7android28sysprop_change_callback_infoE",
    "name" : "const android::sysprop_change_callback_info",
    "referenced_type" : "_ZTIN7android28sysprop_change_callback_infoE",
-   "self_type" : "_ZTIKN7android28sysprop_change_callback_infoE",
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12547,7 +11444,6 @@
    "linker_set_key" : "_ZTIKN7android2spINS_14LooperCallbackEEE",
    "name" : "const android::sp<android::LooperCallback>",
    "referenced_type" : "_ZTIN7android2spINS_14LooperCallbackEEE",
-   "self_type" : "_ZTIKN7android2spINS_14LooperCallbackEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12557,7 +11453,6 @@
    "linker_set_key" : "_ZTIKN7android2spINS_14MessageHandlerEEE",
    "name" : "const android::sp<android::MessageHandler>",
    "referenced_type" : "_ZTIN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIKN7android2spINS_14MessageHandlerEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12567,7 +11462,6 @@
    "linker_set_key" : "_ZTIKN7android2spINS_20SimpleLooperCallbackEEE",
    "name" : "const android::sp<android::SimpleLooperCallback>",
    "referenced_type" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
-   "self_type" : "_ZTIKN7android2spINS_20SimpleLooperCallbackEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12577,7 +11471,6 @@
    "linker_set_key" : "_ZTIKN7android2spINS_6LooperEEE",
    "name" : "const android::sp<android::Looper>",
    "referenced_type" : "_ZTIN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTIKN7android2spINS_6LooperEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12587,7 +11480,6 @@
    "linker_set_key" : "_ZTIKN7android2spINS_6ThreadEEE",
    "name" : "const android::sp<android::Thread>",
    "referenced_type" : "_ZTIN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTIKN7android2spINS_6ThreadEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12597,7 +11489,6 @@
    "linker_set_key" : "_ZTIKN7android2wpINS_14MessageHandlerEEE",
    "name" : "const android::wp<android::MessageHandler>",
    "referenced_type" : "_ZTIN7android2wpINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIKN7android2wpINS_14MessageHandlerEEE",
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12607,7 +11498,6 @@
    "linker_set_key" : "_ZTIKN7android2wpINS_6ThreadEEE",
    "name" : "const android::wp<android::Thread>",
    "referenced_type" : "_ZTIN7android2wpINS_6ThreadEEE",
-   "self_type" : "_ZTIKN7android2wpINS_6ThreadEEE",
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12617,7 +11507,6 @@
    "linker_set_key" : "_ZTIKN7android4base11borrowed_fdE",
    "name" : "const android::base::borrowed_fd",
    "referenced_type" : "_ZTIN7android4base11borrowed_fdE",
-   "self_type" : "_ZTIKN7android4base11borrowed_fdE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -12627,7 +11516,6 @@
    "linker_set_key" : "_ZTIKN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "name" : "const android::base::unique_fd_impl<android::base::DefaultCloser>",
    "referenced_type" : "_ZTIN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
-   "self_type" : "_ZTIKN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -12637,7 +11525,6 @@
    "linker_set_key" : "_ZTIKN7android6Looper15MessageEnvelopeE",
    "name" : "const android::Looper::MessageEnvelope",
    "referenced_type" : "_ZTIN7android6Looper15MessageEnvelopeE",
-   "self_type" : "_ZTIKN7android6Looper15MessageEnvelopeE",
    "size" : 24,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12647,7 +11534,6 @@
    "linker_set_key" : "_ZTIKN7android6Looper7RequestE",
    "name" : "const android::Looper::Request",
    "referenced_type" : "_ZTIN7android6Looper7RequestE",
-   "self_type" : "_ZTIKN7android6Looper7RequestE",
    "size" : 32,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -12657,7 +11543,6 @@
    "linker_set_key" : "_ZTIKN7android6Looper8ResponseE",
    "name" : "const android::Looper::Response",
    "referenced_type" : "_ZTIN7android6Looper8ResponseE",
-   "self_type" : "_ZTIKN7android6Looper8ResponseE",
    "size" : 48,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12667,7 +11552,6 @@
    "linker_set_key" : "_ZTIKN7android6LooperE",
    "name" : "const android::Looper",
    "referenced_type" : "_ZTIN7android6LooperE",
-   "self_type" : "_ZTIKN7android6LooperE",
    "size" : 264,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -12677,7 +11561,6 @@
    "linker_set_key" : "_ZTIKN7android6ThreadE",
    "name" : "const android::Thread",
    "referenced_type" : "_ZTIN7android6ThreadE",
-   "self_type" : "_ZTIKN7android6ThreadE",
    "size" : 152,
    "source_file" : "system/core/libutils/include/utils/Thread.h"
   },
@@ -12687,7 +11570,6 @@
    "linker_set_key" : "_ZTIKN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "name" : "const android::Vector<android::sysprop_change_callback_info>",
    "referenced_type" : "_ZTIN7android6VectorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIKN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "size" : 40,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -12697,7 +11579,6 @@
    "linker_set_key" : "_ZTIKN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "name" : "const android::Vector<android::Looper::MessageEnvelope>",
    "referenced_type" : "_ZTIN7android6VectorINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIKN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "size" : 40,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -12707,7 +11588,6 @@
    "linker_set_key" : "_ZTIKN7android6VectorINS_6Looper8ResponseEEE",
    "name" : "const android::Vector<android::Looper::Response>",
    "referenced_type" : "_ZTIN7android6VectorINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIKN7android6VectorINS_6Looper8ResponseEEE",
    "size" : 40,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -12717,7 +11597,6 @@
    "linker_set_key" : "_ZTIKN7android6VectorINS_7String8EEE",
    "name" : "const android::Vector<android::String8>",
    "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE",
-   "self_type" : "_ZTIKN7android6VectorINS_7String8EEE",
    "size" : 40,
    "source_file" : "system/core/libutils/binder/include/utils/Vector.h"
   },
@@ -12727,7 +11606,6 @@
    "linker_set_key" : "_ZTIKN7android7FileMapE",
    "name" : "const android::FileMap",
    "referenced_type" : "_ZTIN7android7FileMapE",
-   "self_type" : "_ZTIKN7android7FileMapE",
    "size" : 48,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -12737,7 +11615,6 @@
    "linker_set_key" : "_ZTIKN7android7MessageE",
    "name" : "const android::Message",
    "referenced_type" : "_ZTIN7android7MessageE",
-   "self_type" : "_ZTIKN7android7MessageE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -12746,8 +11623,7 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android7RefBase12weakref_typeE",
    "name" : "const android::RefBase::weakref_type",
-   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIKN7android7RefBase12weakref_typeE",
+   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -12756,8 +11632,8 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android7RefBaseE",
    "name" : "const android::RefBase",
-   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 16,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -12767,7 +11643,6 @@
    "linker_set_key" : "_ZTIKN7android7RefBaseE",
    "name" : "const android::RefBase",
    "referenced_type" : "_ZTIN7android7RefBaseE",
-   "self_type" : "_ZTIKN7android7RefBaseE",
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12776,8 +11651,8 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android7String8E",
    "name" : "const android::String8",
-   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -12787,7 +11662,6 @@
    "linker_set_key" : "_ZTIKN7android7String8E",
    "name" : "const android::String8",
    "referenced_type" : "_ZTIN7android7String8E",
-   "self_type" : "_ZTIKN7android7String8E",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
@@ -12797,7 +11671,6 @@
    "linker_set_key" : "_ZTIKN7android8String1610StaticDataILm1EEE",
    "name" : "const android::String16::StaticData<1>",
    "referenced_type" : "_ZTIN7android8String1610StaticDataILm1EEE",
-   "self_type" : "_ZTIKN7android8String1610StaticDataILm1EEE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -12807,7 +11680,6 @@
    "linker_set_key" : "_ZTIKN7android8String16E",
    "name" : "const android::String16",
    "referenced_type" : "_ZTIN7android8String16E",
-   "self_type" : "_ZTIKN7android8String16E",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -12817,7 +11689,6 @@
    "linker_set_key" : "_ZTIKN7android9StopWatchE",
    "name" : "const android::StopWatch",
    "referenced_type" : "_ZTIN7android9StopWatchE",
-   "self_type" : "_ZTIKN7android9StopWatchE",
    "size" : 24,
    "source_file" : "system/core/libutils/include/utils/StopWatch.h"
   },
@@ -12827,27 +11698,15 @@
    "linker_set_key" : "_ZTIKN7android9TokenizerE",
    "name" : "const android::Tokenizer",
    "referenced_type" : "_ZTIN7android9TokenizerE",
-   "self_type" : "_ZTIKN7android9TokenizerE",
    "size" : 56,
    "source_file" : "system/core/libutils/include/utils/Tokenizer.h"
   },
-  {
-   "alignment" : 8,
-   "is_const" : true,
-   "linker_set_key" : "_ZTIKPKc",
-   "name" : "const char *const",
-   "referenced_type" : "_ZTIPKc",
-   "self_type" : "_ZTIKPKc",
-   "size" : 8,
-   "source_file" : "system/core/libprocessgroup/include/processgroup/processgroup.h"
-  },
   {
    "alignment" : 8,
    "is_const" : true,
    "linker_set_key" : "_ZTIKPN7android7RefBase12weakref_implE",
    "name" : "android::RefBase::weakref_impl *const",
    "referenced_type" : "_ZTIPN7android7RefBase12weakref_implE",
-   "self_type" : "_ZTIKPN7android7RefBase12weakref_implE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12857,7 +11716,6 @@
    "linker_set_key" : "_ZTIKa",
    "name" : "const signed char",
    "referenced_type" : "_ZTIa",
-   "self_type" : "_ZTIKa",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12867,7 +11725,6 @@
    "linker_set_key" : "_ZTIKb",
    "name" : "const bool",
    "referenced_type" : "_ZTIb",
-   "self_type" : "_ZTIKb",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12877,7 +11734,6 @@
    "linker_set_key" : "_ZTIKc",
    "name" : "const char",
    "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIKc",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -12887,7 +11743,6 @@
    "linker_set_key" : "_ZTIKd",
    "name" : "const double",
    "referenced_type" : "_ZTId",
-   "self_type" : "_ZTIKd",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12897,7 +11752,6 @@
    "linker_set_key" : "_ZTIKf",
    "name" : "const float",
    "referenced_type" : "_ZTIf",
-   "self_type" : "_ZTIKf",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12907,7 +11761,6 @@
    "linker_set_key" : "_ZTIKh",
    "name" : "const unsigned char",
    "referenced_type" : "_ZTIh",
-   "self_type" : "_ZTIKh",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12917,7 +11770,6 @@
    "linker_set_key" : "_ZTIKi",
    "name" : "const int",
    "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIKi",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12927,7 +11779,6 @@
    "linker_set_key" : "_ZTIKj",
    "name" : "const unsigned int",
    "referenced_type" : "_ZTIj",
-   "self_type" : "_ZTIKj",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12937,7 +11788,6 @@
    "linker_set_key" : "_ZTIKl",
    "name" : "const long",
    "referenced_type" : "_ZTIl",
-   "self_type" : "_ZTIKl",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12947,7 +11797,6 @@
    "linker_set_key" : "_ZTIKm",
    "name" : "const unsigned long",
    "referenced_type" : "_ZTIm",
-   "self_type" : "_ZTIKm",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12957,7 +11806,6 @@
    "linker_set_key" : "_ZTIKs",
    "name" : "const short",
    "referenced_type" : "_ZTIs",
-   "self_type" : "_ZTIKs",
    "size" : 2,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12967,7 +11815,6 @@
    "linker_set_key" : "_ZTIKt",
    "name" : "const unsigned short",
    "referenced_type" : "_ZTIt",
-   "self_type" : "_ZTIKt",
    "size" : 2,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12976,7 +11823,6 @@
    "linker_set_key" : "_ZTIKv",
    "name" : "const void",
    "referenced_type" : "_ZTIv",
-   "self_type" : "_ZTIKv",
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
   {
@@ -12985,7 +11831,6 @@
    "linker_set_key" : "_ZTIVb",
    "name" : "volatile bool",
    "referenced_type" : "_ZTIb",
-   "self_type" : "_ZTIVb",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/Thread.h"
   }
@@ -13038,8 +11883,6 @@
    ],
    "linker_set_key" : "_ZTI12logger_entry",
    "name" : "logger_entry",
-   "referenced_type" : "_ZTI12logger_entry",
-   "self_type" : "_ZTI12logger_entry",
    "size" : 28,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   },
@@ -13084,8 +11927,6 @@
    ],
    "linker_set_key" : "_ZTI13android_ycbcr",
    "name" : "android_ycbcr",
-   "referenced_type" : "_ZTI13android_ycbcr",
-   "self_type" : "_ZTI13android_ycbcr",
    "size" : 80,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13115,8 +11956,6 @@
    ],
    "linker_set_key" : "_ZTI13native_handle",
    "name" : "native_handle",
-   "referenced_type" : "_ZTI13native_handle",
-   "self_type" : "_ZTI13native_handle",
    "size" : 12,
    "source_file" : "system/core/libcutils/include_outside_system/cutils/native_handle.h"
   },
@@ -13136,8 +11975,6 @@
    ],
    "linker_set_key" : "_ZTI16android_xy_color",
    "name" : "android_xy_color",
-   "referenced_type" : "_ZTI16android_xy_color",
-   "self_type" : "_ZTI16android_xy_color",
    "size" : 8,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13187,8 +12024,6 @@
    ],
    "linker_set_key" : "_ZTI18android_flex_plane",
    "name" : "android_flex_plane",
-   "referenced_type" : "_ZTI18android_flex_plane",
-   "self_type" : "_ZTI18android_flex_plane",
    "size" : 40,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13213,8 +12048,6 @@
    ],
    "linker_set_key" : "_ZTI19android_flex_layout",
    "name" : "android_flex_layout",
-   "referenced_type" : "_ZTI19android_flex_layout",
-   "self_type" : "_ZTI19android_flex_layout",
    "size" : 16,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13239,8 +12072,6 @@
    ],
    "linker_set_key" : "_ZTI20android_depth_points",
    "name" : "android_depth_points",
-   "referenced_type" : "_ZTI20android_depth_points",
-   "self_type" : "_ZTI20android_depth_points",
    "size" : 36,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13285,8 +12116,6 @@
    ],
    "linker_set_key" : "_ZTI21__android_log_message",
    "name" : "__android_log_message",
-   "referenced_type" : "_ZTI21__android_log_message",
-   "self_type" : "_ZTI21__android_log_message",
    "size" : 48,
    "source_file" : "system/logging/liblog/include_vndk/android/log.h"
   },
@@ -13306,8 +12135,6 @@
    ],
    "linker_set_key" : "_ZTI25android_cta861_3_metadata",
    "name" : "android_cta861_3_metadata",
-   "referenced_type" : "_ZTI25android_cta861_3_metadata",
-   "self_type" : "_ZTI25android_cta861_3_metadata",
    "size" : 8,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13347,8 +12174,6 @@
    ],
    "linker_set_key" : "_ZTI26android_smpte2086_metadata",
    "name" : "android_smpte2086_metadata",
-   "referenced_type" : "_ZTI26android_smpte2086_metadata",
-   "self_type" : "_ZTI26android_smpte2086_metadata",
    "size" : 40,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13362,8 +12187,6 @@
    ],
    "linker_set_key" : "_ZTI7log_msg",
    "name" : "log_msg",
-   "referenced_type" : "_ZTI7log_msg",
-   "self_type" : "_ZTI7log_msg",
    "size" : 5124,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   },
@@ -13383,8 +12206,6 @@
    ],
    "linker_set_key" : "_ZTI8log_time",
    "name" : "log_time",
-   "referenced_type" : "_ZTI8log_time",
-   "self_type" : "_ZTI8log_time",
    "size" : 8,
    "source_file" : "system/logging/liblog/include_vndk/log/log_time.h"
   },
@@ -13426,8 +12247,6 @@
    "linker_set_key" : "_ZTIN7android10LogPrinterE",
    "name" : "android::LogPrinter",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android10LogPrinterE",
-   "self_type" : "_ZTIN7android10LogPrinterE",
    "size" : 40,
    "source_file" : "system/core/libutils/include/utils/Printer.h",
    "vtable_components" :
@@ -13487,8 +12306,6 @@
    "linker_set_key" : "_ZTIN7android10VectorImplE",
    "name" : "android::VectorImpl",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android10VectorImplE",
-   "self_type" : "_ZTIN7android10VectorImplE",
    "size" : 40,
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h",
    "vtable_components" :
@@ -13566,8 +12383,7 @@
    "linker_set_key" : "_ZTIN7android10VectorImplE",
    "name" : "android::VectorImpl",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 40,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h",
    "vtable_components" :
@@ -13626,8 +12442,6 @@
    "linker_set_key" : "_ZTIN7android11ScopedTraceE",
    "name" : "android::ScopedTrace",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android11ScopedTraceE",
-   "self_type" : "_ZTIN7android11ScopedTraceE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Trace.h"
   },
@@ -13644,8 +12458,6 @@
    "linker_set_key" : "_ZTIN7android12LightRefBaseINS_12NativeHandleEEE",
    "name" : "android::LightRefBase<android::NativeHandle>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android12LightRefBaseINS_12NativeHandleEEE",
-   "self_type" : "_ZTIN7android12LightRefBaseINS_12NativeHandleEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h",
    "template_args" :
@@ -13666,8 +12478,6 @@
    "linker_set_key" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE",
    "name" : "android::LightRefBase<android::VirtualLightRefBase>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE",
-   "self_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h",
    "template_args" :
@@ -13688,13 +12498,12 @@
    "linker_set_key" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE",
    "name" : "android::LightRefBase<android::VirtualLightRefBase>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/LightRefBase.h",
    "template_args" :
    [
-    "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+    "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
    ]
   },
   {
@@ -13723,8 +12532,6 @@
    "linker_set_key" : "_ZTIN7android12NativeHandleE",
    "name" : "android::NativeHandle",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android12NativeHandleE",
-   "self_type" : "_ZTIN7android12NativeHandleE",
    "size" : 24,
    "source_file" : "system/core/libutils/include/utils/NativeHandle.h"
   },
@@ -13754,8 +12561,6 @@
    "linker_set_key" : "_ZTIN7android13PrefixPrinterE",
    "name" : "android::PrefixPrinter",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android13PrefixPrinterE",
-   "self_type" : "_ZTIN7android13PrefixPrinterE",
    "size" : 24,
    "source_file" : "system/core/libutils/include/utils/Printer.h",
    "vtable_components" :
@@ -13787,8 +12592,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android13trait_pointerINS_28sysprop_change_callback_infoEEE",
    "name" : "android::trait_pointer<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android13trait_pointerINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android13trait_pointerINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -13800,8 +12603,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android13trait_pointerINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::trait_pointer<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android13trait_pointerINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android13trait_pointerINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -13813,8 +12614,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android13trait_pointerINS_6Looper8ResponseEEE",
    "name" : "android::trait_pointer<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android13trait_pointerINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android13trait_pointerINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -13834,8 +12633,6 @@
    "linker_set_key" : "_ZTIN7android14LooperCallbackE",
    "name" : "android::LooperCallback",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android14LooperCallbackE",
-   "self_type" : "_ZTIN7android14LooperCallbackE",
    "size" : 24,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "vtable_components" :
@@ -13921,8 +12718,6 @@
    "linker_set_key" : "_ZTIN7android14MessageHandlerE",
    "name" : "android::MessageHandler",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android14MessageHandlerE",
-   "self_type" : "_ZTIN7android14MessageHandlerE",
    "size" : 24,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "vtable_components" :
@@ -14001,8 +12796,6 @@
    "linker_set_key" : "_ZTIN7android14ReferenceMoverE",
    "name" : "android::ReferenceMover",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android14ReferenceMoverE",
-   "self_type" : "_ZTIN7android14ReferenceMoverE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -14011,8 +12804,7 @@
    "linker_set_key" : "_ZTIN7android14ReferenceMoverE",
    "name" : "android::ReferenceMover",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android14ReferenceMoverE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android14ReferenceMoverE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android14ReferenceMoverE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -14036,8 +12828,6 @@
    "linker_set_key" : "_ZTIN7android14StaticString16ILm1EEE",
    "name" : "android::StaticString16<1>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android14StaticString16ILm1EEE",
-   "self_type" : "_ZTIN7android14StaticString16ILm1EEE",
    "size" : 16,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -14067,8 +12857,6 @@
    "linker_set_key" : "_ZTIN7android14String8PrinterE",
    "name" : "android::String8Printer",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android14String8PrinterE",
-   "self_type" : "_ZTIN7android14String8PrinterE",
    "size" : 24,
    "source_file" : "system/core/libutils/include/utils/Printer.h",
    "vtable_components" :
@@ -14101,8 +12889,6 @@
    "linker_set_key" : "_ZTIN7android16ReferenceRenamerE",
    "name" : "android::ReferenceRenamer",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android16ReferenceRenamerE",
-   "self_type" : "_ZTIN7android16ReferenceRenamerE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "vtable_components" :
@@ -14125,8 +12911,7 @@
    "linker_set_key" : "_ZTIN7android16ReferenceRenamerE",
    "name" : "android::ReferenceRenamer",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
    "vtable_components" :
@@ -14155,8 +12940,6 @@
    "linker_set_key" : "_ZTIN7android16SortedVectorImplE",
    "name" : "android::SortedVectorImpl",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE",
-   "self_type" : "_ZTIN7android16SortedVectorImplE",
    "size" : 40,
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h",
    "vtable_components" :
@@ -14211,14 +12994,13 @@
    "base_specifiers" :
    [
     {
-     "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "linker_set_key" : "_ZTIN7android16SortedVectorImplE",
    "name" : "android::SortedVectorImpl",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 40,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h",
    "vtable_components" :
@@ -14278,8 +13060,6 @@
    ],
    "linker_set_key" : "_ZTIN7android16use_trivial_moveINS_28sysprop_change_callback_infoEEE",
    "name" : "android::use_trivial_move<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android16use_trivial_moveINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android16use_trivial_moveINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14297,8 +13077,6 @@
    ],
    "linker_set_key" : "_ZTIN7android16use_trivial_moveINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::use_trivial_move<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android16use_trivial_moveINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android16use_trivial_moveINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14316,8 +13094,6 @@
    ],
    "linker_set_key" : "_ZTIN7android16use_trivial_moveINS_6Looper8ResponseEEE",
    "name" : "android::use_trivial_move<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android16use_trivial_moveINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android16use_trivial_moveINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14345,8 +13121,6 @@
    "linker_set_key" : "_ZTIN7android18WeakMessageHandlerE",
    "name" : "android::WeakMessageHandler",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android18WeakMessageHandlerE",
-   "self_type" : "_ZTIN7android18WeakMessageHandlerE",
    "size" : 40,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "vtable_components" :
@@ -14423,8 +13197,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyINS_28sysprop_change_callback_infoEEE",
    "name" : "android::trait_trivial_copy<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14436,8 +13208,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::trait_trivial_copy<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14449,8 +13219,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyINS_6Looper8ResponseEEE",
    "name" : "android::trait_trivial_copy<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14462,8 +13230,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIbEE",
    "name" : "android::trait_trivial_copy<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIbEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIbEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14475,8 +13241,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIbEE",
    "name" : "android::trait_trivial_copy<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14488,8 +13253,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcEE",
    "name" : "android::trait_trivial_copy<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIcEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIcEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14501,8 +13264,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcEE",
    "name" : "android::trait_trivial_copy<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14514,8 +13276,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdEE",
    "name" : "android::trait_trivial_copy<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIdEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14527,8 +13287,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdEE",
    "name" : "android::trait_trivial_copy<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14540,8 +13299,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfEE",
    "name" : "android::trait_trivial_copy<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIfEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14553,8 +13310,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfEE",
    "name" : "android::trait_trivial_copy<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14566,8 +13322,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhEE",
    "name" : "android::trait_trivial_copy<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIhEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14579,8 +13333,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhEE",
    "name" : "android::trait_trivial_copy<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14592,8 +13345,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiEE",
    "name" : "android::trait_trivial_copy<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIiEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14605,8 +13356,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiEE",
    "name" : "android::trait_trivial_copy<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14618,8 +13368,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjEE",
    "name" : "android::trait_trivial_copy<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIjEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14631,8 +13379,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjEE",
    "name" : "android::trait_trivial_copy<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14644,8 +13391,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlEE",
    "name" : "android::trait_trivial_copy<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIlEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14657,8 +13402,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlEE",
    "name" : "android::trait_trivial_copy<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14670,8 +13414,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyImEE",
    "name" : "android::trait_trivial_copy<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyImEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyImEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14683,8 +13425,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyImEE",
    "name" : "android::trait_trivial_copy<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14696,8 +13437,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsEE",
    "name" : "android::trait_trivial_copy<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIsEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14709,8 +13448,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsEE",
    "name" : "android::trait_trivial_copy<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14722,8 +13460,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyItEE",
    "name" : "android::trait_trivial_copy<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyItEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyItEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14735,8 +13471,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyItEE",
    "name" : "android::trait_trivial_copy<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14748,8 +13483,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvEE",
    "name" : "android::trait_trivial_copy<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIvEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14761,8 +13494,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvEE",
    "name" : "android::trait_trivial_copy<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14774,8 +13506,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxEE",
    "name" : "android::trait_trivial_copy<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIxEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIxEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14787,8 +13517,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxEE",
    "name" : "android::trait_trivial_copy<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14800,8 +13529,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyEE",
    "name" : "android::trait_trivial_copy<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIyEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIyEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14813,8 +13540,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyEE",
    "name" : "android::trait_trivial_copy<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14826,8 +13552,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEEE",
    "name" : "android::trait_trivial_ctor<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14839,8 +13563,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::trait_trivial_ctor<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14852,8 +13574,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_6Looper8ResponseEEE",
    "name" : "android::trait_trivial_ctor<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14865,8 +13585,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbEE",
    "name" : "android::trait_trivial_ctor<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIbEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14878,8 +13596,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbEE",
    "name" : "android::trait_trivial_ctor<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14891,8 +13608,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcEE",
    "name" : "android::trait_trivial_ctor<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIcEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14904,8 +13619,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcEE",
    "name" : "android::trait_trivial_ctor<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14917,8 +13631,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdEE",
    "name" : "android::trait_trivial_ctor<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIdEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14930,8 +13642,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdEE",
    "name" : "android::trait_trivial_ctor<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14943,8 +13654,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfEE",
    "name" : "android::trait_trivial_ctor<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIfEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14956,8 +13665,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfEE",
    "name" : "android::trait_trivial_ctor<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14969,8 +13677,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhEE",
    "name" : "android::trait_trivial_ctor<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIhEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14982,8 +13688,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhEE",
    "name" : "android::trait_trivial_ctor<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14995,8 +13700,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiEE",
    "name" : "android::trait_trivial_ctor<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIiEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15008,8 +13711,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiEE",
    "name" : "android::trait_trivial_ctor<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15021,8 +13723,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjEE",
    "name" : "android::trait_trivial_ctor<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIjEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15034,8 +13734,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjEE",
    "name" : "android::trait_trivial_ctor<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15047,8 +13746,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlEE",
    "name" : "android::trait_trivial_ctor<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIlEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15060,8 +13757,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlEE",
    "name" : "android::trait_trivial_ctor<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15073,8 +13769,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImEE",
    "name" : "android::trait_trivial_ctor<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorImEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15086,8 +13780,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImEE",
    "name" : "android::trait_trivial_ctor<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15099,8 +13792,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsEE",
    "name" : "android::trait_trivial_ctor<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIsEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15112,8 +13803,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsEE",
    "name" : "android::trait_trivial_ctor<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15125,8 +13815,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItEE",
    "name" : "android::trait_trivial_ctor<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorItEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15138,8 +13826,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItEE",
    "name" : "android::trait_trivial_ctor<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15151,8 +13838,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvEE",
    "name" : "android::trait_trivial_ctor<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIvEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15164,8 +13849,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvEE",
    "name" : "android::trait_trivial_ctor<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15177,8 +13861,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxEE",
    "name" : "android::trait_trivial_ctor<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIxEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15190,8 +13872,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxEE",
    "name" : "android::trait_trivial_ctor<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15203,8 +13884,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyEE",
    "name" : "android::trait_trivial_ctor<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIyEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15216,8 +13895,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyEE",
    "name" : "android::trait_trivial_ctor<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15229,8 +13907,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEEE",
    "name" : "android::trait_trivial_dtor<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15242,8 +13918,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::trait_trivial_dtor<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15255,8 +13929,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEEE",
    "name" : "android::trait_trivial_dtor<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15268,8 +13940,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbEE",
    "name" : "android::trait_trivial_dtor<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIbEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15281,8 +13951,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbEE",
    "name" : "android::trait_trivial_dtor<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15294,8 +13963,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcEE",
    "name" : "android::trait_trivial_dtor<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIcEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15307,8 +13974,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcEE",
    "name" : "android::trait_trivial_dtor<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15320,8 +13986,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdEE",
    "name" : "android::trait_trivial_dtor<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIdEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15333,8 +13997,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdEE",
    "name" : "android::trait_trivial_dtor<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15346,8 +14009,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfEE",
    "name" : "android::trait_trivial_dtor<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIfEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15359,8 +14020,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfEE",
    "name" : "android::trait_trivial_dtor<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15372,8 +14032,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhEE",
    "name" : "android::trait_trivial_dtor<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIhEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15385,8 +14043,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhEE",
    "name" : "android::trait_trivial_dtor<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15398,8 +14055,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiEE",
    "name" : "android::trait_trivial_dtor<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIiEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15411,8 +14066,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiEE",
    "name" : "android::trait_trivial_dtor<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15424,8 +14078,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjEE",
    "name" : "android::trait_trivial_dtor<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIjEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15437,8 +14089,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjEE",
    "name" : "android::trait_trivial_dtor<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15450,8 +14101,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlEE",
    "name" : "android::trait_trivial_dtor<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIlEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15463,8 +14112,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlEE",
    "name" : "android::trait_trivial_dtor<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15476,8 +14124,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImEE",
    "name" : "android::trait_trivial_dtor<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorImEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15489,8 +14135,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImEE",
    "name" : "android::trait_trivial_dtor<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15502,8 +14147,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsEE",
    "name" : "android::trait_trivial_dtor<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIsEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15515,8 +14158,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsEE",
    "name" : "android::trait_trivial_dtor<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15528,8 +14170,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItEE",
    "name" : "android::trait_trivial_dtor<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorItEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15541,8 +14181,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItEE",
    "name" : "android::trait_trivial_dtor<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15554,8 +14193,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvEE",
    "name" : "android::trait_trivial_dtor<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIvEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15567,8 +14204,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvEE",
    "name" : "android::trait_trivial_dtor<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15580,8 +14216,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxEE",
    "name" : "android::trait_trivial_dtor<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIxEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15593,8 +14227,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxEE",
    "name" : "android::trait_trivial_dtor<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15606,8 +14239,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyEE",
    "name" : "android::trait_trivial_dtor<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIyEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15619,8 +14250,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyEE",
    "name" : "android::trait_trivial_dtor<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15632,8 +14262,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEEE",
    "name" : "android::trait_trivial_move<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15645,8 +14273,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::trait_trivial_move<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15658,8 +14284,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_6Looper8ResponseEEE",
    "name" : "android::trait_trivial_move<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15671,8 +14295,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE",
    "name" : "android::trait_trivial_move<android::String8>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/String8.h",
    "template_args" :
@@ -15684,21 +14306,18 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE",
    "name" : "android::trait_trivial_move<android::String8>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h",
    "template_args" :
    [
-    "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+    "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
    ]
   },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_8String16EEE",
    "name" : "android::trait_trivial_move<android::String16>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EEE",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h",
    "template_args" :
@@ -15710,8 +14329,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIbEE",
    "name" : "android::trait_trivial_move<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIbEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIbEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15723,8 +14340,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIbEE",
    "name" : "android::trait_trivial_move<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15736,8 +14352,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcEE",
    "name" : "android::trait_trivial_move<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIcEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIcEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15749,8 +14363,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcEE",
    "name" : "android::trait_trivial_move<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15762,8 +14375,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdEE",
    "name" : "android::trait_trivial_move<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIdEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIdEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15775,8 +14386,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdEE",
    "name" : "android::trait_trivial_move<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15788,8 +14398,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfEE",
    "name" : "android::trait_trivial_move<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIfEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIfEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15801,8 +14409,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfEE",
    "name" : "android::trait_trivial_move<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15814,8 +14421,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhEE",
    "name" : "android::trait_trivial_move<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIhEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIhEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15827,8 +14432,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhEE",
    "name" : "android::trait_trivial_move<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15840,8 +14444,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiEE",
    "name" : "android::trait_trivial_move<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIiEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIiEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15853,8 +14455,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiEE",
    "name" : "android::trait_trivial_move<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15866,8 +14467,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjEE",
    "name" : "android::trait_trivial_move<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIjEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIjEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15879,8 +14478,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjEE",
    "name" : "android::trait_trivial_move<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15892,8 +14490,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlEE",
    "name" : "android::trait_trivial_move<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIlEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIlEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15905,8 +14501,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlEE",
    "name" : "android::trait_trivial_move<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15918,8 +14513,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveImEE",
    "name" : "android::trait_trivial_move<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveImEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveImEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15931,8 +14524,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveImEE",
    "name" : "android::trait_trivial_move<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15944,8 +14536,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsEE",
    "name" : "android::trait_trivial_move<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIsEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIsEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15957,8 +14547,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsEE",
    "name" : "android::trait_trivial_move<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15970,8 +14559,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveItEE",
    "name" : "android::trait_trivial_move<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveItEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveItEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15983,8 +14570,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveItEE",
    "name" : "android::trait_trivial_move<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15996,8 +14582,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvEE",
    "name" : "android::trait_trivial_move<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIvEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIvEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16009,8 +14593,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvEE",
    "name" : "android::trait_trivial_move<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16022,8 +14605,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxEE",
    "name" : "android::trait_trivial_move<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIxEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIxEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16035,8 +14616,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxEE",
    "name" : "android::trait_trivial_move<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16048,8 +14628,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyEE",
    "name" : "android::trait_trivial_move<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIyEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16061,8 +14639,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyEE",
    "name" : "android::trait_trivial_move<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16081,8 +14658,6 @@
    "linker_set_key" : "_ZTIN7android19VirtualLightRefBaseE",
    "name" : "android::VirtualLightRefBase",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE",
-   "self_type" : "_ZTIN7android19VirtualLightRefBaseE",
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h",
    "vtable_components" :
@@ -16109,14 +14684,13 @@
    "base_specifiers" :
    [
     {
-     "referenced_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "linker_set_key" : "_ZTIN7android19VirtualLightRefBaseE",
    "name" : "android::VirtualLightRefBase",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 16,
    "source_file" : "system/core/libutils/binder/include/utils/LightRefBase.h",
    "vtable_components" :
@@ -16158,8 +14732,6 @@
    "linker_set_key" : "_ZTIN7android20SimpleLooperCallbackE",
    "name" : "android::SimpleLooperCallback",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android20SimpleLooperCallbackE",
-   "self_type" : "_ZTIN7android20SimpleLooperCallbackE",
    "size" : 32,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "vtable_components" :
@@ -16245,8 +14817,6 @@
    "linker_set_key" : "_ZTIN7android2spINS_12NativeHandleEEE",
    "name" : "android::sp<android::NativeHandle>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2spINS_12NativeHandleEEE",
-   "self_type" : "_ZTIN7android2spINS_12NativeHandleEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h",
    "template_args" :
@@ -16267,8 +14837,6 @@
    "linker_set_key" : "_ZTIN7android2spINS_14LooperCallbackEEE",
    "name" : "android::sp<android::LooperCallback>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2spINS_14LooperCallbackEEE",
-   "self_type" : "_ZTIN7android2spINS_14LooperCallbackEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h",
    "template_args" :
@@ -16289,8 +14857,6 @@
    "linker_set_key" : "_ZTIN7android2spINS_14MessageHandlerEEE",
    "name" : "android::sp<android::MessageHandler>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIN7android2spINS_14MessageHandlerEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h",
    "template_args" :
@@ -16311,8 +14877,6 @@
    "linker_set_key" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
    "name" : "android::sp<android::SimpleLooperCallback>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
-   "self_type" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h",
    "template_args" :
@@ -16333,8 +14897,6 @@
    "linker_set_key" : "_ZTIN7android2spINS_6LooperEEE",
    "name" : "android::sp<android::Looper>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTIN7android2spINS_6LooperEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h",
    "template_args" :
@@ -16355,8 +14917,6 @@
    "linker_set_key" : "_ZTIN7android2spINS_6ThreadEEE",
    "name" : "android::sp<android::Thread>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTIN7android2spINS_6ThreadEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h",
    "template_args" :
@@ -16383,8 +14943,6 @@
    "linker_set_key" : "_ZTIN7android2wpINS_14MessageHandlerEEE",
    "name" : "android::wp<android::MessageHandler>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2wpINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIN7android2wpINS_14MessageHandlerEEE",
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "template_args" :
@@ -16411,8 +14969,6 @@
    "linker_set_key" : "_ZTIN7android2wpINS_6ThreadEEE",
    "name" : "android::wp<android::Thread>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2wpINS_6ThreadEEE",
-   "self_type" : "_ZTIN7android2wpINS_6ThreadEEE",
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "template_args" :
@@ -16432,8 +14988,6 @@
    ],
    "linker_set_key" : "_ZTIN7android4base11borrowed_fdE",
    "name" : "android::base::borrowed_fd",
-   "referenced_type" : "_ZTIN7android4base11borrowed_fdE",
-   "self_type" : "_ZTIN7android4base11borrowed_fdE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -16441,8 +14995,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android4base13DefaultCloserE",
    "name" : "android::base::DefaultCloser",
-   "referenced_type" : "_ZTIN7android4base13DefaultCloserE",
-   "self_type" : "_ZTIN7android4base13DefaultCloserE",
    "size" : 1,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -16459,8 +15011,6 @@
    "linker_set_key" : "_ZTIN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "name" : "android::base::unique_fd_impl<android::base::DefaultCloser>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
-   "self_type" : "_ZTIN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h",
    "template_args" :
@@ -16481,8 +15031,6 @@
    "linker_set_key" : "_ZTIN7android5Mutex8AutolockE",
    "name" : "android::Mutex::Autolock",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android5Mutex8AutolockE",
-   "self_type" : "_ZTIN7android5Mutex8AutolockE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Mutex.h"
   },
@@ -16499,8 +15047,6 @@
    "linker_set_key" : "_ZTIN7android5MutexE",
    "name" : "android::Mutex",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android5MutexE",
-   "self_type" : "_ZTIN7android5MutexE",
    "size" : 40,
    "source_file" : "system/core/libutils/include/utils/Mutex.h"
   },
@@ -16526,8 +15072,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6Looper15MessageEnvelopeE",
    "name" : "android::Looper::MessageEnvelope",
-   "referenced_type" : "_ZTIN7android6Looper15MessageEnvelopeE",
-   "self_type" : "_ZTIN7android6Looper15MessageEnvelopeE",
    "size" : 24,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -16563,8 +15107,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6Looper7RequestE",
    "name" : "android::Looper::Request",
-   "referenced_type" : "_ZTIN7android6Looper7RequestE",
-   "self_type" : "_ZTIN7android6Looper7RequestE",
    "size" : 32,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -16590,8 +15132,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6Looper8ResponseE",
    "name" : "android::Looper::Response",
-   "referenced_type" : "_ZTIN7android6Looper8ResponseE",
-   "self_type" : "_ZTIN7android6Looper8ResponseE",
    "size" : 48,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -16693,8 +15233,6 @@
    "linker_set_key" : "_ZTIN7android6LooperE",
    "name" : "android::Looper",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6LooperE",
-   "self_type" : "_ZTIN7android6LooperE",
    "size" : 264,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "vtable_components" :
@@ -16741,8 +15279,6 @@
    "linker_set_key" : "_ZTIN7android6RWLock9AutoRLockE",
    "name" : "android::RWLock::AutoRLock",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6RWLock9AutoRLockE",
-   "self_type" : "_ZTIN7android6RWLock9AutoRLockE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -16759,8 +15295,6 @@
    "linker_set_key" : "_ZTIN7android6RWLock9AutoWLockE",
    "name" : "android::RWLock::AutoWLock",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6RWLock9AutoWLockE",
-   "self_type" : "_ZTIN7android6RWLock9AutoWLockE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -16777,8 +15311,6 @@
    "linker_set_key" : "_ZTIN7android6RWLockE",
    "name" : "android::RWLock",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6RWLockE",
-   "self_type" : "_ZTIN7android6RWLockE",
    "size" : 56,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -16851,8 +15383,6 @@
    "linker_set_key" : "_ZTIN7android6ThreadE",
    "name" : "android::Thread",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6ThreadE",
-   "self_type" : "_ZTIN7android6ThreadE",
    "size" : 152,
    "source_file" : "system/core/libutils/include/utils/Thread.h",
    "vtable_components" :
@@ -16947,8 +15477,6 @@
    "linker_set_key" : "_ZTIN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "name" : "android::Vector<android::sysprop_change_callback_info>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6VectorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "size" : 40,
    "source_file" : "system/core/libutils/include/utils/Vector.h",
    "template_args" :
@@ -17004,8 +15532,6 @@
    "linker_set_key" : "_ZTIN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::Vector<android::Looper::MessageEnvelope>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6VectorINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "size" : 40,
    "source_file" : "system/core/libutils/include/utils/Vector.h",
    "template_args" :
@@ -17061,8 +15587,6 @@
    "linker_set_key" : "_ZTIN7android6VectorINS_6Looper8ResponseEEE",
    "name" : "android::Vector<android::Looper::Response>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6VectorINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android6VectorINS_6Looper8ResponseEEE",
    "size" : 40,
    "source_file" : "system/core/libutils/include/utils/Vector.h",
    "template_args" :
@@ -17112,19 +15636,17 @@
    [
     {
      "access" : "private",
-     "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "linker_set_key" : "_ZTIN7android6VectorINS_7String8EEE",
    "name" : "android::Vector<android::String8>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE",
-   "self_type" : "_ZTIN7android6VectorINS_7String8EEE",
    "size" : 40,
    "source_file" : "system/core/libutils/binder/include/utils/Vector.h",
    "template_args" :
    [
-    "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+    "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
    ],
    "vtable_components" :
    [
@@ -17167,8 +15689,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android6traitsINS_28sysprop_change_callback_infoEEE",
    "name" : "android::traits<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android6traitsINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android6traitsINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -17180,8 +15700,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android6traitsINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::traits<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android6traitsINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android6traitsINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -17193,8 +15711,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android6traitsINS_6Looper8ResponseEEE",
    "name" : "android::traits<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android6traitsINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android6traitsINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -17245,8 +15761,6 @@
    "linker_set_key" : "_ZTIN7android7FileMapE",
    "name" : "android::FileMap",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7FileMapE",
-   "self_type" : "_ZTIN7android7FileMapE",
    "size" : 48,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -17261,8 +15775,6 @@
    ],
    "linker_set_key" : "_ZTIN7android7MessageE",
    "name" : "android::Message",
-   "referenced_type" : "_ZTIN7android7MessageE",
-   "self_type" : "_ZTIN7android7MessageE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -17271,8 +15783,6 @@
    "linker_set_key" : "_ZTIN7android7PrinterE",
    "name" : "android::Printer",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7PrinterE",
-   "self_type" : "_ZTIN7android7PrinterE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Printer.h",
    "vtable_components" :
@@ -17306,8 +15816,6 @@
    "linker_set_key" : "_ZTIN7android7RefBase12weakref_typeE",
    "name" : "android::RefBase::weakref_type",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE",
-   "self_type" : "_ZTIN7android7RefBase12weakref_typeE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -17316,8 +15824,7 @@
    "linker_set_key" : "_ZTIN7android7RefBase12weakref_typeE",
    "name" : "android::RefBase::weakref_type",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -17335,8 +15842,6 @@
    "linker_set_key" : "_ZTIN7android7RefBaseE",
    "name" : "android::RefBase",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7RefBaseE",
-   "self_type" : "_ZTIN7android7RefBaseE",
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "vtable_components" :
@@ -17384,8 +15889,7 @@
    "linker_set_key" : "_ZTIN7android7RefBaseE",
    "name" : "android::RefBase",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 16,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
    "vtable_components" :
@@ -17432,8 +15936,6 @@
    "linker_set_key" : "_ZTIN7android7String8E",
    "name" : "android::String8",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7String8E",
-   "self_type" : "_ZTIN7android7String8E",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
@@ -17450,8 +15952,7 @@
    "linker_set_key" : "_ZTIN7android7String8E",
    "name" : "android::String8",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm64_armv8-a_static_afdo-libutils_lto-none/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm64_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -17471,8 +15972,6 @@
    ],
    "linker_set_key" : "_ZTIN7android8String1610StaticDataILm1EEE",
    "name" : "android::String16::StaticData<1>",
-   "referenced_type" : "_ZTIN7android8String1610StaticDataILm1EEE",
-   "self_type" : "_ZTIN7android8String1610StaticDataILm1EEE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -17489,8 +15988,6 @@
    "linker_set_key" : "_ZTIN7android8String16E",
    "name" : "android::String16",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android8String16E",
-   "self_type" : "_ZTIN7android8String16E",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -17507,8 +16004,6 @@
    "linker_set_key" : "_ZTIN7android9ConditionE",
    "name" : "android::Condition",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android9ConditionE",
-   "self_type" : "_ZTIN7android9ConditionE",
    "size" : 48,
    "source_file" : "system/core/libutils/include/utils/Condition.h"
   },
@@ -17550,8 +16045,6 @@
    "linker_set_key" : "_ZTIN7android9FdPrinterE",
    "name" : "android::FdPrinter",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android9FdPrinterE",
-   "self_type" : "_ZTIN7android9FdPrinterE",
    "size" : 48,
    "source_file" : "system/core/libutils/include/utils/Printer.h",
    "vtable_components" :
@@ -17604,8 +16097,6 @@
    "linker_set_key" : "_ZTIN7android9StopWatchE",
    "name" : "android::StopWatch",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android9StopWatchE",
-   "self_type" : "_ZTIN7android9StopWatchE",
    "size" : 24,
    "source_file" : "system/core/libutils/include/utils/StopWatch.h"
   },
@@ -17658,8 +16149,6 @@
    "linker_set_key" : "_ZTIN7android9TokenizerE",
    "name" : "android::Tokenizer",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android9TokenizerE",
-   "self_type" : "_ZTIN7android9TokenizerE",
    "size" : 56,
    "source_file" : "system/core/libutils/include/utils/Tokenizer.h"
   },
@@ -17680,8 +16169,6 @@
    "linker_set_key" : "_ZTIN7log_msgUt_E",
    "name" : "log_msg::(anonymous)",
    "record_kind" : "union",
-   "referenced_type" : "_ZTIN7log_msgUt_E",
-   "self_type" : "_ZTIN7log_msgUt_E",
    "size" : 5124,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   }
@@ -17693,7 +16180,6 @@
    "linker_set_key" : "_ZTION7android2spINS_12NativeHandleEEE",
    "name" : "android::sp<android::NativeHandle> &&",
    "referenced_type" : "_ZTIN7android2spINS_12NativeHandleEEE",
-   "self_type" : "_ZTION7android2spINS_12NativeHandleEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -17702,7 +16188,6 @@
    "linker_set_key" : "_ZTION7android2spINS_14MessageHandlerEEE",
    "name" : "android::sp<android::MessageHandler> &&",
    "referenced_type" : "_ZTIN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTION7android2spINS_14MessageHandlerEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -17711,7 +16196,6 @@
    "linker_set_key" : "_ZTION7android2spINS_20SimpleLooperCallbackEEE",
    "name" : "android::sp<android::SimpleLooperCallback> &&",
    "referenced_type" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
-   "self_type" : "_ZTION7android2spINS_20SimpleLooperCallbackEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -17720,7 +16204,6 @@
    "linker_set_key" : "_ZTION7android2spINS_6LooperEEE",
    "name" : "android::sp<android::Looper> &&",
    "referenced_type" : "_ZTIN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTION7android2spINS_6LooperEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -17729,7 +16212,6 @@
    "linker_set_key" : "_ZTION7android2spINS_6ThreadEEE",
    "name" : "android::sp<android::Thread> &&",
    "referenced_type" : "_ZTIN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTION7android2spINS_6ThreadEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -17738,7 +16220,6 @@
    "linker_set_key" : "_ZTION7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "name" : "android::base::unique_fd_impl<android::base::DefaultCloser> &&",
    "referenced_type" : "_ZTIN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
-   "self_type" : "_ZTION7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "size" : 8,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -17747,7 +16228,6 @@
    "linker_set_key" : "_ZTION7android7FileMapE",
    "name" : "android::FileMap &&",
    "referenced_type" : "_ZTIN7android7FileMapE",
-   "self_type" : "_ZTION7android7FileMapE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -17756,7 +16236,6 @@
    "linker_set_key" : "_ZTION7android8String16E",
    "name" : "android::String16 &&",
    "referenced_type" : "_ZTIN7android8String16E",
-   "self_type" : "_ZTION7android8String16E",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   }
diff --git a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
index b9c4c521f496..5e4985651b31 100644
--- a/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
+++ b/libutils/abi-dumps/arm_arm64/source-based/libutils.so.lsdump
@@ -6,7 +6,6 @@
    "linker_set_key" : "_ZTIA0_i",
    "name" : "int[0]",
    "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIA0_i",
    "source_file" : "system/core/libcutils/include_outside_system/cutils/native_handle.h"
   },
   {
@@ -14,7 +13,6 @@
    "linker_set_key" : "_ZTIA1_Ds",
    "name" : "char16_t[1]",
    "referenced_type" : "_ZTIDs",
-   "self_type" : "_ZTIA1_Ds",
    "size" : 2,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -23,7 +21,6 @@
    "linker_set_key" : "_ZTIA20_c",
    "name" : "char[20]",
    "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIA20_c",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -32,7 +29,6 @@
    "linker_set_key" : "_ZTIA5121_h",
    "name" : "unsigned char[5121]",
    "referenced_type" : "_ZTIh",
-   "self_type" : "_ZTIA5121_h",
    "size" : 5121,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   },
@@ -41,7 +37,6 @@
    "linker_set_key" : "_ZTIA8_j",
    "name" : "unsigned int[8]",
    "referenced_type" : "_ZTIj",
-   "self_type" : "_ZTIA8_j",
    "size" : 32,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -50,7 +45,6 @@
    "linker_set_key" : "_ZTIA_f",
    "name" : "float[]",
    "referenced_type" : "_ZTIf",
-   "self_type" : "_ZTIA_f",
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   }
  ],
@@ -62,16 +56,12 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIDi",
    "name" : "char32_t",
-   "referenced_type" : "_ZTIDi",
-   "self_type" : "_ZTIDi",
    "size" : 4
   },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIDn",
    "name" : "std::nullptr_t",
-   "referenced_type" : "_ZTIDn",
-   "self_type" : "_ZTIDn",
    "size" : 4
   },
   {
@@ -80,8 +70,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIDs",
    "name" : "char16_t",
-   "referenced_type" : "_ZTIDs",
-   "self_type" : "_ZTIDs",
    "size" : 2
   },
   {
@@ -89,8 +77,6 @@
    "is_integral" : true,
    "linker_set_key" : "_ZTIa",
    "name" : "signed char",
-   "referenced_type" : "_ZTIa",
-   "self_type" : "_ZTIa",
    "size" : 1
   },
   {
@@ -99,8 +85,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIb",
    "name" : "bool",
-   "referenced_type" : "_ZTIb",
-   "self_type" : "_ZTIb",
    "size" : 1
   },
   {
@@ -109,24 +93,18 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIc",
    "name" : "char",
-   "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIc",
    "size" : 1
   },
   {
    "alignment" : 8,
    "linker_set_key" : "_ZTId",
    "name" : "double",
-   "referenced_type" : "_ZTId",
-   "self_type" : "_ZTId",
    "size" : 8
   },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIf",
    "name" : "float",
-   "referenced_type" : "_ZTIf",
-   "self_type" : "_ZTIf",
    "size" : 4
   },
   {
@@ -135,8 +113,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIh",
    "name" : "unsigned char",
-   "referenced_type" : "_ZTIh",
-   "self_type" : "_ZTIh",
    "size" : 1
   },
   {
@@ -144,8 +120,6 @@
    "is_integral" : true,
    "linker_set_key" : "_ZTIi",
    "name" : "int",
-   "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIi",
    "size" : 4
   },
   {
@@ -154,8 +128,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIj",
    "name" : "unsigned int",
-   "referenced_type" : "_ZTIj",
-   "self_type" : "_ZTIj",
    "size" : 4
   },
   {
@@ -163,8 +135,6 @@
    "is_integral" : true,
    "linker_set_key" : "_ZTIl",
    "name" : "long",
-   "referenced_type" : "_ZTIl",
-   "self_type" : "_ZTIl",
    "size" : 4
   },
   {
@@ -173,8 +143,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIm",
    "name" : "unsigned long",
-   "referenced_type" : "_ZTIm",
-   "self_type" : "_ZTIm",
    "size" : 4
   },
   {
@@ -182,8 +150,6 @@
    "is_integral" : true,
    "linker_set_key" : "_ZTIs",
    "name" : "short",
-   "referenced_type" : "_ZTIs",
-   "self_type" : "_ZTIs",
    "size" : 2
   },
   {
@@ -192,23 +158,17 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIt",
    "name" : "unsigned short",
-   "referenced_type" : "_ZTIt",
-   "self_type" : "_ZTIt",
    "size" : 2
   },
   {
    "linker_set_key" : "_ZTIv",
-   "name" : "void",
-   "referenced_type" : "_ZTIv",
-   "self_type" : "_ZTIv"
+   "name" : "void"
   },
   {
    "alignment" : 8,
    "is_integral" : true,
    "linker_set_key" : "_ZTIx",
    "name" : "long long",
-   "referenced_type" : "_ZTIx",
-   "self_type" : "_ZTIx",
    "size" : 8
   },
   {
@@ -217,8 +177,6 @@
    "is_unsigned" : true,
    "linker_set_key" : "_ZTIy",
    "name" : "unsigned long long",
-   "referenced_type" : "_ZTIy",
-   "self_type" : "_ZTIy",
    "size" : 8
   }
  ],
@@ -495,10 +453,22 @@
    "binding" : "weak",
    "name" : "_ZN7android2spINS_14LooperCallbackEE5clearEv"
   },
+  {
+   "binding" : "weak",
+   "name" : "_ZN7android2spINS_14LooperCallbackEEaSERKS2_"
+  },
+  {
+   "binding" : "weak",
+   "name" : "_ZN7android2spINS_6LooperEED2Ev"
+  },
   {
    "binding" : "weak",
    "name" : "_ZN7android2spINS_6LooperEEaSEOS2_"
   },
+  {
+   "binding" : "weak",
+   "name" : "_ZN7android2spINS_6LooperEEaSERKS2_"
+  },
   {
    "binding" : "weak",
    "name" : "_ZN7android2spINS_6ThreadEE5clearEv"
@@ -528,6 +498,9 @@
   {
    "name" : "_ZN7android6Looper14removeMessagesERKNS_2spINS_14MessageHandlerEEEi"
   },
+  {
+   "name" : "_ZN7android6Looper15getFdStateDebugEiPiS1_PNS_2spINS_14LooperCallbackEEEPPv"
+  },
   {
    "name" : "_ZN7android6Looper17sendMessageAtTimeExRKNS_2spINS_14MessageHandlerEEERKNS_7MessageE"
   },
@@ -1202,71 +1175,43 @@
   },
   {
    "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE14__erase_uniqueIiEEjRKT_"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE25__emplace_unique_key_argsIiJRiRKyEEENS_4pairINS_15__hash_iteratorIPNS_11__hash_nodeIS2_PvEEEEbEERKT_DpOT0_"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE4findIiEENS_15__hash_iteratorIPNS_11__hash_nodeIS2_PvEEEERKT_"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE5eraseENS_21__hash_const_iteratorIPNS_11__hash_nodeIS2_PvEEEE"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE6rehashEj"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE6removeENS_21__hash_const_iteratorIPNS_11__hash_nodeIS2_PvEEEE"
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEENS_8equal_toIiEELb1EEENS_21__unordered_map_equalIiS2_S7_S5_Lb1EEENS_9allocatorIS2_EEE11__do_rehashILb1EEEvj"
   },
   {
    "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE8__rehashEj"
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEENS_8equal_toIiEELb1EEENS_21__unordered_map_equalIiS2_S7_S5_Lb1EEENS_9allocatorIS2_EEE14__erase_uniqueIiEEjRKT_"
   },
   {
    "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEED2Ev"
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEENS_8equal_toIiEELb1EEENS_21__unordered_map_equalIiS2_S7_S5_Lb1EEENS_9allocatorIS2_EEE25__emplace_unique_key_argsIiJRiRKyEEENS_4pairINS_15__hash_iteratorIPNS_11__hash_nodeIS2_PvEEEEbEERKT_DpOT0_"
   },
   {
    "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE14__erase_uniqueIyEEjRKT_"
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEENS_8equal_toIiEELb1EEENS_21__unordered_map_equalIiS2_S7_S5_Lb1EEENS_9allocatorIS2_EEE4findIiEENS_15__hash_iteratorIPNS_11__hash_nodeIS2_PvEEEERKT_"
   },
   {
    "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE17__deallocate_nodeEPNS_16__hash_node_baseIPNS_11__hash_nodeIS5_PvEEEE"
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIiyEENS_22__unordered_map_hasherIiS2_NS_4hashIiEENS_8equal_toIiEELb1EEENS_21__unordered_map_equalIiS2_S7_S5_Lb1EEENS_9allocatorIS2_EEE8__rehashILb1EEEvj"
   },
   {
    "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE25__emplace_unique_key_argsIyJRKyRS4_EEENS_4pairINS_15__hash_iteratorIPNS_11__hash_nodeIS5_PvEEEEbEERKT_DpOT0_"
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEENS_8equal_toIyEELb1EEENS_21__unordered_map_equalIyS5_SA_S8_Lb1EEENS_9allocatorIS5_EEE11__do_rehashILb1EEEvj"
   },
   {
    "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE4findIyEENS_15__hash_iteratorIPNS_11__hash_nodeIS5_PvEEEERKT_"
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEENS_8equal_toIyEELb1EEENS_21__unordered_map_equalIyS5_SA_S8_Lb1EEENS_9allocatorIS5_EEE14__erase_uniqueIyEEjRKT_"
   },
   {
    "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE5eraseENS_21__hash_const_iteratorIPNS_11__hash_nodeIS5_PvEEEE"
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEENS_8equal_toIyEELb1EEENS_21__unordered_map_equalIyS5_SA_S8_Lb1EEENS_9allocatorIS5_EEE25__emplace_unique_key_argsIyJRKyRS4_EEENS_4pairINS_15__hash_iteratorIPNS_11__hash_nodeIS5_PvEEEEbEERKT_DpOT0_"
   },
   {
    "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE6rehashEj"
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEENS_8equal_toIyEELb1EEENS_21__unordered_map_equalIyS5_SA_S8_Lb1EEENS_9allocatorIS5_EEE4findIyEENS_15__hash_iteratorIPNS_11__hash_nodeIS5_PvEEEERKT_"
   },
   {
    "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE6removeENS_21__hash_const_iteratorIPNS_11__hash_nodeIS5_PvEEEE"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEE8__rehashEj"
-  },
-  {
-   "binding" : "weak",
-   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEELb1EEENS_21__unordered_map_equalIyS5_NS_8equal_toIyEELb1EEENS_9allocatorIS5_EEED2Ev"
+   "name" : "_ZNSt3__112__hash_tableINS_17__hash_value_typeIyN7android6Looper7RequestEEENS_22__unordered_map_hasherIyS5_NS_4hashIyEENS_8equal_toIyEELb1EEENS_21__unordered_map_equalIyS5_SA_S8_Lb1EEENS_9allocatorIS5_EEE8__rehashILb1EEEvj"
   },
   {
    "name" : "_ZTv0_n12_N7android14LooperCallbackD0Ev"
@@ -1461,67 +1406,6 @@
  ],
  "enum_types" :
  [
-  {
-   "alignment" : 4,
-   "enum_fields" :
-   [
-    {
-     "enum_field_value" : -1,
-     "name" : "SP_DEFAULT"
-    },
-    {
-     "enum_field_value" : 0,
-     "name" : "SP_BACKGROUND"
-    },
-    {
-     "enum_field_value" : 1,
-     "name" : "SP_FOREGROUND"
-    },
-    {
-     "enum_field_value" : 2,
-     "name" : "SP_SYSTEM"
-    },
-    {
-     "enum_field_value" : 3,
-     "name" : "SP_AUDIO_APP"
-    },
-    {
-     "enum_field_value" : 4,
-     "name" : "SP_AUDIO_SYS"
-    },
-    {
-     "enum_field_value" : 5,
-     "name" : "SP_TOP_APP"
-    },
-    {
-     "enum_field_value" : 6,
-     "name" : "SP_RT_APP"
-    },
-    {
-     "enum_field_value" : 7,
-     "name" : "SP_RESTRICTED"
-    },
-    {
-     "enum_field_value" : 8,
-     "name" : "SP_CNT"
-    },
-    {
-     "enum_field_value" : 7,
-     "name" : "SP_MAX"
-    },
-    {
-     "enum_field_value" : 1,
-     "name" : "SP_SYSTEM_DEFAULT"
-    }
-   ],
-   "linker_set_key" : "_ZTI11SchedPolicy",
-   "name" : "SchedPolicy",
-   "referenced_type" : "_ZTI11SchedPolicy",
-   "self_type" : "_ZTI11SchedPolicy",
-   "size" : 4,
-   "source_file" : "system/core/libprocessgroup/include/processgroup/sched_policy.h",
-   "underlying_type" : "_ZTIi"
-  },
   {
    "alignment" : 4,
    "enum_fields" :
@@ -1541,8 +1425,6 @@
    ],
    "linker_set_key" : "_ZTI13android_hdr_t",
    "name" : "android_hdr_t",
-   "referenced_type" : "_ZTI13android_hdr_t",
-   "self_type" : "_ZTI13android_hdr_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.0.h",
    "underlying_type" : "_ZTIj"
@@ -1558,8 +1440,6 @@
    ],
    "linker_set_key" : "_ZTI18android_hdr_v1_2_t",
    "name" : "android_hdr_v1_2_t",
-   "referenced_type" : "_ZTI18android_hdr_v1_2_t",
-   "self_type" : "_ZTI18android_hdr_v1_2_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.2.h",
    "underlying_type" : "_ZTIj"
@@ -1607,8 +1487,6 @@
    ],
    "linker_set_key" : "_ZTI19android_LogPriority",
    "name" : "android_LogPriority",
-   "referenced_type" : "_ZTI19android_LogPriority",
-   "self_type" : "_ZTI19android_LogPriority",
    "size" : 4,
    "source_file" : "system/logging/liblog/include_vndk/android/log.h",
    "underlying_type" : "_ZTIj"
@@ -1848,8 +1726,6 @@
    ],
    "linker_set_key" : "_ZTI19android_dataspace_t",
    "name" : "android_dataspace_t",
-   "referenced_type" : "_ZTI19android_dataspace_t",
-   "self_type" : "_ZTI19android_dataspace_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.0.h",
    "underlying_type" : "_ZTIj"
@@ -1885,8 +1761,6 @@
    ],
    "linker_set_key" : "_ZTI19android_flex_format",
    "name" : "android_flex_format",
-   "referenced_type" : "_ZTI19android_flex_format",
-   "self_type" : "_ZTI19android_flex_format",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics.h",
    "underlying_type" : "_ZTIj"
@@ -1918,8 +1792,6 @@
    ],
    "linker_set_key" : "_ZTI19android_transform_t",
    "name" : "android_transform_t",
-   "referenced_type" : "_ZTI19android_transform_t",
-   "self_type" : "_ZTI19android_transform_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.0.h",
    "underlying_type" : "_ZTIj"
@@ -1971,8 +1843,6 @@
    ],
    "linker_set_key" : "_ZTI20android_color_mode_t",
    "name" : "android_color_mode_t",
-   "referenced_type" : "_ZTI20android_color_mode_t",
-   "self_type" : "_ZTI20android_color_mode_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.0.h",
    "underlying_type" : "_ZTIj"
@@ -2004,8 +1874,6 @@
    ],
    "linker_set_key" : "_ZTI21$SYSTEM_TIME_BOOTTIME",
    "name" : "(unnamed)",
-   "referenced_type" : "_ZTI21$SYSTEM_TIME_BOOTTIME",
-   "self_type" : "_ZTI21$SYSTEM_TIME_BOOTTIME",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Timers.h",
    "underlying_type" : "_ZTIj"
@@ -2045,8 +1913,6 @@
    ],
    "linker_set_key" : "_ZTI22android_flex_component",
    "name" : "android_flex_component",
-   "referenced_type" : "_ZTI22android_flex_component",
-   "self_type" : "_ZTI22android_flex_component",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics.h",
    "underlying_type" : "_ZTIj"
@@ -2138,8 +2004,6 @@
    ],
    "linker_set_key" : "_ZTI22android_pixel_format_t",
    "name" : "android_pixel_format_t",
-   "referenced_type" : "_ZTI22android_pixel_format_t",
-   "self_type" : "_ZTI22android_pixel_format_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.0.h",
    "underlying_type" : "_ZTIj"
@@ -2203,8 +2067,6 @@
    ],
    "linker_set_key" : "_ZTI23$ANDROID_PRIORITY_AUDIO",
    "name" : "(unnamed)",
-   "referenced_type" : "_ZTI23$ANDROID_PRIORITY_AUDIO",
-   "self_type" : "_ZTI23$ANDROID_PRIORITY_AUDIO",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/thread_defs.h",
    "underlying_type" : "_ZTIi"
@@ -2232,8 +2094,6 @@
    ],
    "linker_set_key" : "_ZTI24android_dataspace_v1_1_t",
    "name" : "android_dataspace_v1_1_t",
-   "referenced_type" : "_ZTI24android_dataspace_v1_1_t",
-   "self_type" : "_ZTI24android_dataspace_v1_1_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.1.h",
    "underlying_type" : "_ZTIj"
@@ -2261,8 +2121,6 @@
    ],
    "linker_set_key" : "_ZTI24android_dataspace_v1_2_t",
    "name" : "android_dataspace_v1_2_t",
-   "referenced_type" : "_ZTI24android_dataspace_v1_2_t",
-   "self_type" : "_ZTI24android_dataspace_v1_2_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.2.h",
    "underlying_type" : "_ZTIj"
@@ -2286,8 +2144,6 @@
    ],
    "linker_set_key" : "_ZTI25android_color_mode_v1_1_t",
    "name" : "android_color_mode_v1_1_t",
-   "referenced_type" : "_ZTI25android_color_mode_v1_1_t",
-   "self_type" : "_ZTI25android_color_mode_v1_1_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.1.h",
    "underlying_type" : "_ZTIj"
@@ -2303,8 +2159,6 @@
    ],
    "linker_set_key" : "_ZTI25android_color_mode_v1_2_t",
    "name" : "android_color_mode_v1_2_t",
-   "referenced_type" : "_ZTI25android_color_mode_v1_2_t",
-   "self_type" : "_ZTI25android_color_mode_v1_2_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.2.h",
    "underlying_type" : "_ZTIj"
@@ -2344,8 +2198,6 @@
    ],
    "linker_set_key" : "_ZTI25android_color_transform_t",
    "name" : "android_color_transform_t",
-   "referenced_type" : "_ZTI25android_color_transform_t",
-   "self_type" : "_ZTI25android_color_transform_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.0.h",
    "underlying_type" : "_ZTIj"
@@ -2373,8 +2225,6 @@
    ],
    "linker_set_key" : "_ZTI25android_pixel_format_sw_t",
    "name" : "android_pixel_format_sw_t",
-   "referenced_type" : "_ZTI25android_pixel_format_sw_t",
-   "self_type" : "_ZTI25android_pixel_format_sw_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-sw.h",
    "underlying_type" : "_ZTIj"
@@ -2414,8 +2264,6 @@
    ],
    "linker_set_key" : "_ZTI27android_pixel_format_v1_1_t",
    "name" : "android_pixel_format_v1_1_t",
-   "referenced_type" : "_ZTI27android_pixel_format_v1_1_t",
-   "self_type" : "_ZTI27android_pixel_format_v1_1_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.1.h",
    "underlying_type" : "_ZTIj"
@@ -2431,8 +2279,6 @@
    ],
    "linker_set_key" : "_ZTI27android_pixel_format_v1_2_t",
    "name" : "android_pixel_format_v1_2_t",
-   "referenced_type" : "_ZTI27android_pixel_format_v1_2_t",
-   "self_type" : "_ZTI27android_pixel_format_v1_2_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.2.h",
    "underlying_type" : "_ZTIj"
@@ -2460,8 +2306,6 @@
    ],
    "linker_set_key" : "_ZTI28android_render_intent_v1_1_t",
    "name" : "android_render_intent_v1_1_t",
-   "referenced_type" : "_ZTI28android_render_intent_v1_1_t",
-   "self_type" : "_ZTI28android_render_intent_v1_1_t",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics-base-v1.1.h",
    "underlying_type" : "_ZTIj"
@@ -2517,8 +2361,6 @@
    ],
    "linker_set_key" : "_ZTI6log_id",
    "name" : "log_id",
-   "referenced_type" : "_ZTI6log_id",
-   "self_type" : "_ZTI6log_id",
    "size" : 4,
    "source_file" : "system/logging/liblog/include_vndk/android/log.h",
    "underlying_type" : "_ZTIj"
@@ -2542,8 +2384,6 @@
    ],
    "linker_set_key" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE",
    "name" : "android::VectorImpl::(unnamed)",
-   "referenced_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE",
-   "self_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h",
    "underlying_type" : "_ZTIj"
@@ -2567,8 +2407,7 @@
    ],
    "linker_set_key" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE",
    "name" : "android::VectorImpl::(unnamed)",
-   "referenced_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android10VectorImpl17$HAS_TRIVIAL_COPYE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h",
    "underlying_type" : "_ZTIj"
@@ -2584,8 +2423,6 @@
    ],
    "linker_set_key" : "_ZTIN7android13trait_pointerINS_28sysprop_change_callback_infoEE6$valueE",
    "name" : "android::trait_pointer<android::sysprop_change_callback_info>::(unnamed)",
-   "referenced_type" : "_ZTIN7android13trait_pointerINS_28sysprop_change_callback_infoEE6$valueE",
-   "self_type" : "_ZTIN7android13trait_pointerINS_28sysprop_change_callback_infoEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2601,8 +2438,6 @@
    ],
    "linker_set_key" : "_ZTIN7android13trait_pointerINS_6Looper15MessageEnvelopeEE6$valueE",
    "name" : "android::trait_pointer<android::Looper::MessageEnvelope>::(unnamed)",
-   "referenced_type" : "_ZTIN7android13trait_pointerINS_6Looper15MessageEnvelopeEE6$valueE",
-   "self_type" : "_ZTIN7android13trait_pointerINS_6Looper15MessageEnvelopeEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2618,8 +2453,6 @@
    ],
    "linker_set_key" : "_ZTIN7android13trait_pointerINS_6Looper8ResponseEE6$valueE",
    "name" : "android::trait_pointer<android::Looper::Response>::(unnamed)",
-   "referenced_type" : "_ZTIN7android13trait_pointerINS_6Looper8ResponseEE6$valueE",
-   "self_type" : "_ZTIN7android13trait_pointerINS_6Looper8ResponseEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2711,8 +2544,6 @@
    ],
    "linker_set_key" : "_ZTIN7android15$ALREADY_EXISTSE",
    "name" : "android::(unnamed)",
-   "referenced_type" : "_ZTIN7android15$ALREADY_EXISTSE",
-   "self_type" : "_ZTIN7android15$ALREADY_EXISTSE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Errors.h",
    "underlying_type" : "_ZTIi"
@@ -2804,8 +2635,7 @@
    ],
    "linker_set_key" : "_ZTIN7android15$ALREADY_EXISTSE",
    "name" : "android::(unnamed)",
-   "referenced_type" : "_ZTIN7android15$ALREADY_EXISTSE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/Errors.sdump",
-   "self_type" : "_ZTIN7android15$ALREADY_EXISTSE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/Errors.sdump",
+   "self_type" : "_ZTIN7android15$ALREADY_EXISTSE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/Errors.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/Errors.h",
    "underlying_type" : "_ZTIi"
@@ -2865,8 +2695,6 @@
    ],
    "linker_set_key" : "_ZTIN7android15$PRIORITY_AUDIOE",
    "name" : "android::(unnamed)",
-   "referenced_type" : "_ZTIN7android15$PRIORITY_AUDIOE",
-   "self_type" : "_ZTIN7android15$PRIORITY_AUDIOE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/ThreadDefs.h",
    "underlying_type" : "_ZTIi"
@@ -2882,8 +2710,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyINS_28sysprop_change_callback_infoEE6$valueE",
    "name" : "android::trait_trivial_copy<android::sysprop_change_callback_info>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyINS_28sysprop_change_callback_infoEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyINS_28sysprop_change_callback_infoEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2899,8 +2725,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyINS_6Looper15MessageEnvelopeEE6$valueE",
    "name" : "android::trait_trivial_copy<android::Looper::MessageEnvelope>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper15MessageEnvelopeEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper15MessageEnvelopeEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2916,8 +2740,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyINS_6Looper8ResponseEE6$valueE",
    "name" : "android::trait_trivial_copy<android::Looper::Response>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper8ResponseEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper8ResponseEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2933,8 +2755,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIbE6$valueE",
    "name" : "android::trait_trivial_copy<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2950,8 +2770,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIbE6$valueE",
    "name" : "android::trait_trivial_copy<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2967,8 +2786,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcE6$valueE",
    "name" : "android::trait_trivial_copy<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -2984,8 +2801,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcE6$valueE",
    "name" : "android::trait_trivial_copy<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3001,8 +2817,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
    "name" : "android::trait_trivial_copy<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3018,8 +2832,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdE6$valueE",
    "name" : "android::trait_trivial_copy<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3035,8 +2848,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
    "name" : "android::trait_trivial_copy<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3052,8 +2863,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfE6$valueE",
    "name" : "android::trait_trivial_copy<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3069,8 +2879,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3086,8 +2894,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3103,8 +2910,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
    "name" : "android::trait_trivial_copy<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3120,8 +2925,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiE6$valueE",
    "name" : "android::trait_trivial_copy<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3137,8 +2941,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3154,8 +2956,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3171,8 +2972,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
    "name" : "android::trait_trivial_copy<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3188,8 +2987,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlE6$valueE",
    "name" : "android::trait_trivial_copy<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3205,8 +3003,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3222,8 +3018,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyImE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3239,8 +3034,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
    "name" : "android::trait_trivial_copy<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3256,8 +3049,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsE6$valueE",
    "name" : "android::trait_trivial_copy<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3273,8 +3065,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3290,8 +3080,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyItE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3307,8 +3096,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
    "name" : "android::trait_trivial_copy<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3324,8 +3111,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvE6$valueE",
    "name" : "android::trait_trivial_copy<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3341,8 +3127,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxE6$valueE",
    "name" : "android::trait_trivial_copy<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3358,8 +3142,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxE6$valueE",
    "name" : "android::trait_trivial_copy<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3375,8 +3158,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3392,8 +3173,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyE6$valueE",
    "name" : "android::trait_trivial_copy<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3409,8 +3189,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEE6$valueE",
    "name" : "android::trait_trivial_ctor<android::sysprop_change_callback_info>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3426,8 +3204,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_6Looper15MessageEnvelopeEE6$valueE",
    "name" : "android::trait_trivial_ctor<android::Looper::MessageEnvelope>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper15MessageEnvelopeEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper15MessageEnvelopeEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3443,8 +3219,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_6Looper8ResponseEE6$valueE",
    "name" : "android::trait_trivial_ctor<android::Looper::Response>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper8ResponseEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper8ResponseEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3460,8 +3234,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
    "name" : "android::trait_trivial_ctor<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3477,8 +3249,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE",
    "name" : "android::trait_trivial_ctor<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3494,8 +3265,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
    "name" : "android::trait_trivial_ctor<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3511,8 +3280,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE",
    "name" : "android::trait_trivial_ctor<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3528,8 +3296,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
    "name" : "android::trait_trivial_ctor<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3545,8 +3311,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE",
    "name" : "android::trait_trivial_ctor<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3562,8 +3327,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
    "name" : "android::trait_trivial_ctor<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3579,8 +3342,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE",
    "name" : "android::trait_trivial_ctor<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3596,8 +3358,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3613,8 +3373,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3630,8 +3389,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
    "name" : "android::trait_trivial_ctor<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3647,8 +3404,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE",
    "name" : "android::trait_trivial_ctor<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3664,8 +3420,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3681,8 +3435,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3698,8 +3451,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
    "name" : "android::trait_trivial_ctor<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3715,8 +3466,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE",
    "name" : "android::trait_trivial_ctor<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3732,8 +3482,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3749,8 +3497,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3766,8 +3513,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
    "name" : "android::trait_trivial_ctor<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3783,8 +3528,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE",
    "name" : "android::trait_trivial_ctor<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3800,8 +3544,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3817,8 +3559,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3834,8 +3575,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
    "name" : "android::trait_trivial_ctor<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3851,8 +3590,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE",
    "name" : "android::trait_trivial_ctor<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3868,8 +3606,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
    "name" : "android::trait_trivial_ctor<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3885,8 +3621,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE",
    "name" : "android::trait_trivial_ctor<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3902,8 +3637,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3919,8 +3652,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE",
    "name" : "android::trait_trivial_ctor<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3936,8 +3668,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEE6$valueE",
    "name" : "android::trait_trivial_dtor<android::sysprop_change_callback_info>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3953,8 +3683,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEE6$valueE",
    "name" : "android::trait_trivial_dtor<android::Looper::MessageEnvelope>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3970,8 +3698,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEE6$valueE",
    "name" : "android::trait_trivial_dtor<android::Looper::Response>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -3987,8 +3713,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
    "name" : "android::trait_trivial_dtor<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4004,8 +3728,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE",
    "name" : "android::trait_trivial_dtor<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4021,8 +3744,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
    "name" : "android::trait_trivial_dtor<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4038,8 +3759,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE",
    "name" : "android::trait_trivial_dtor<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4055,8 +3775,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
    "name" : "android::trait_trivial_dtor<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4072,8 +3790,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE",
    "name" : "android::trait_trivial_dtor<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4089,8 +3806,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
    "name" : "android::trait_trivial_dtor<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4106,8 +3821,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE",
    "name" : "android::trait_trivial_dtor<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4123,8 +3837,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4140,8 +3852,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4157,8 +3868,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
    "name" : "android::trait_trivial_dtor<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4174,8 +3883,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE",
    "name" : "android::trait_trivial_dtor<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4191,8 +3899,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4208,8 +3914,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4225,8 +3930,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
    "name" : "android::trait_trivial_dtor<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4242,8 +3945,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE",
    "name" : "android::trait_trivial_dtor<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4259,8 +3961,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4276,8 +3976,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4293,8 +3992,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
    "name" : "android::trait_trivial_dtor<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4310,8 +4007,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE",
    "name" : "android::trait_trivial_dtor<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4327,8 +4023,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4344,8 +4038,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4361,8 +4054,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
    "name" : "android::trait_trivial_dtor<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4378,8 +4069,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE",
    "name" : "android::trait_trivial_dtor<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4395,8 +4085,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
    "name" : "android::trait_trivial_dtor<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4412,8 +4100,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE",
    "name" : "android::trait_trivial_dtor<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4429,8 +4116,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4446,8 +4131,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE",
    "name" : "android::trait_trivial_dtor<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4463,8 +4147,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEE6$valueE",
    "name" : "android::trait_trivial_move<android::sysprop_change_callback_info>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4480,8 +4162,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_6Looper15MessageEnvelopeEE6$valueE",
    "name" : "android::trait_trivial_move<android::Looper::MessageEnvelope>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper15MessageEnvelopeEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper15MessageEnvelopeEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4497,8 +4177,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_6Looper8ResponseEE6$valueE",
    "name" : "android::trait_trivial_move<android::Looper::Response>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper8ResponseEE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper8ResponseEE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4514,8 +4192,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE",
    "name" : "android::trait_trivial_move<android::String8>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/String8.h",
    "underlying_type" : "_ZTIj"
@@ -4531,8 +4207,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE",
    "name" : "android::trait_trivial_move<android::String8>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h",
    "underlying_type" : "_ZTIj"
@@ -4548,8 +4223,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_8String16EE6$valueE",
    "name" : "android::trait_trivial_move<android::String16>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h",
    "underlying_type" : "_ZTIj"
@@ -4565,8 +4238,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIbE6$valueE",
    "name" : "android::trait_trivial_move<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4582,8 +4253,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIbE6$valueE",
    "name" : "android::trait_trivial_move<bool>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIbE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4599,8 +4269,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcE6$valueE",
    "name" : "android::trait_trivial_move<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4616,8 +4284,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcE6$valueE",
    "name" : "android::trait_trivial_move<char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIcE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4633,8 +4300,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdE6$valueE",
    "name" : "android::trait_trivial_move<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4650,8 +4315,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdE6$valueE",
    "name" : "android::trait_trivial_move<double>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIdE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4667,8 +4331,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfE6$valueE",
    "name" : "android::trait_trivial_move<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4684,8 +4346,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfE6$valueE",
    "name" : "android::trait_trivial_move<float>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIfE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4701,8 +4362,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhE6$valueE",
    "name" : "android::trait_trivial_move<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4718,8 +4377,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhE6$valueE",
    "name" : "android::trait_trivial_move<unsigned char>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIhE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4735,8 +4393,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiE6$valueE",
    "name" : "android::trait_trivial_move<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4752,8 +4408,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiE6$valueE",
    "name" : "android::trait_trivial_move<int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIiE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4769,8 +4424,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjE6$valueE",
    "name" : "android::trait_trivial_move<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4786,8 +4439,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjE6$valueE",
    "name" : "android::trait_trivial_move<unsigned int>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIjE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4803,8 +4455,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlE6$valueE",
    "name" : "android::trait_trivial_move<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4820,8 +4470,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlE6$valueE",
    "name" : "android::trait_trivial_move<long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIlE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4837,8 +4486,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveImE6$valueE",
    "name" : "android::trait_trivial_move<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4854,8 +4501,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveImE6$valueE",
    "name" : "android::trait_trivial_move<unsigned long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveImE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4871,8 +4517,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsE6$valueE",
    "name" : "android::trait_trivial_move<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4888,8 +4532,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsE6$valueE",
    "name" : "android::trait_trivial_move<short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIsE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4905,8 +4548,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveItE6$valueE",
    "name" : "android::trait_trivial_move<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4922,8 +4563,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveItE6$valueE",
    "name" : "android::trait_trivial_move<unsigned short>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveItE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4939,8 +4579,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvE6$valueE",
    "name" : "android::trait_trivial_move<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4956,8 +4594,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvE6$valueE",
    "name" : "android::trait_trivial_move<void>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIvE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4973,8 +4610,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxE6$valueE",
    "name" : "android::trait_trivial_move<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -4990,8 +4625,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxE6$valueE",
    "name" : "android::trait_trivial_move<long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIxE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -5007,8 +4641,6 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
    "name" : "android::trait_trivial_move<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -5024,8 +4656,7 @@
    ],
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyE6$valueE",
    "name" : "android::trait_trivial_move<unsigned long long>::(unnamed)",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIyE6$valueE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -5045,8 +4676,6 @@
    ],
    "linker_set_key" : "_ZTIN7android5Mutex8$PRIVATEE",
    "name" : "android::Mutex::(unnamed)",
-   "referenced_type" : "_ZTIN7android5Mutex8$PRIVATEE",
-   "self_type" : "_ZTIN7android5Mutex8$PRIVATEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Mutex.h",
    "underlying_type" : "_ZTIj"
@@ -5078,8 +4707,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6Looper12$EVENT_ERRORE",
    "name" : "android::Looper::(unnamed)",
-   "referenced_type" : "_ZTIN7android6Looper12$EVENT_ERRORE",
-   "self_type" : "_ZTIN7android6Looper12$EVENT_ERRORE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "underlying_type" : "_ZTIj"
@@ -5107,8 +4734,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6Looper14$POLL_CALLBACKE",
    "name" : "android::Looper::(unnamed)",
-   "referenced_type" : "_ZTIN7android6Looper14$POLL_CALLBACKE",
-   "self_type" : "_ZTIN7android6Looper14$POLL_CALLBACKE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "underlying_type" : "_ZTIi"
@@ -5124,8 +4749,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6Looper28$PREPARE_ALLOW_NON_CALLBACKSE",
    "name" : "android::Looper::(unnamed)",
-   "referenced_type" : "_ZTIN7android6Looper28$PREPARE_ALLOW_NON_CALLBACKSE",
-   "self_type" : "_ZTIN7android6Looper28$PREPARE_ALLOW_NON_CALLBACKSE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "underlying_type" : "_ZTIj"
@@ -5145,8 +4768,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6RWLock8$PRIVATEE",
    "name" : "android::RWLock::(unnamed)",
-   "referenced_type" : "_ZTIN7android6RWLock8$PRIVATEE",
-   "self_type" : "_ZTIN7android6RWLock8$PRIVATEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RWLock.h",
    "underlying_type" : "_ZTIj"
@@ -5178,8 +4799,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6traitsINS_28sysprop_change_callback_infoEE17$has_trivial_copyE",
    "name" : "android::traits<android::sysprop_change_callback_info>::(unnamed)",
-   "referenced_type" : "_ZTIN7android6traitsINS_28sysprop_change_callback_infoEE17$has_trivial_copyE",
-   "self_type" : "_ZTIN7android6traitsINS_28sysprop_change_callback_infoEE17$has_trivial_copyE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -5211,8 +4830,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6traitsINS_6Looper15MessageEnvelopeEE17$has_trivial_copyE",
    "name" : "android::traits<android::Looper::MessageEnvelope>::(unnamed)",
-   "referenced_type" : "_ZTIN7android6traitsINS_6Looper15MessageEnvelopeEE17$has_trivial_copyE",
-   "self_type" : "_ZTIN7android6traitsINS_6Looper15MessageEnvelopeEE17$has_trivial_copyE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -5244,8 +4861,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6traitsINS_6Looper8ResponseEE17$has_trivial_copyE",
    "name" : "android::traits<android::Looper::Response>::(unnamed)",
-   "referenced_type" : "_ZTIN7android6traitsINS_6Looper8ResponseEE17$has_trivial_copyE",
-   "self_type" : "_ZTIN7android6traitsINS_6Looper8ResponseEE17$has_trivial_copyE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "underlying_type" : "_ZTIj"
@@ -5277,8 +4892,6 @@
    ],
    "linker_set_key" : "_ZTIN7android7FileMap9MapAdviceE",
    "name" : "android::FileMap::MapAdvice",
-   "referenced_type" : "_ZTIN7android7FileMap9MapAdviceE",
-   "self_type" : "_ZTIN7android7FileMap9MapAdviceE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/FileMap.h",
    "underlying_type" : "_ZTIj"
@@ -5295,8 +4908,6 @@
    ],
    "linker_set_key" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
    "name" : "android::RefBase::(unnamed)",
-   "referenced_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
-   "self_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "underlying_type" : "_ZTIj"
@@ -5313,8 +4924,7 @@
    ],
    "linker_set_key" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE",
    "name" : "android::RefBase::(unnamed)",
-   "referenced_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBase17$FIRST_INC_STRONGE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
    "underlying_type" : "_ZTIj"
@@ -5339,8 +4949,6 @@
    ],
    "linker_set_key" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE",
    "name" : "android::RefBase::(unnamed)",
-   "referenced_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE",
-   "self_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "underlying_type" : "_ZTIj"
@@ -5365,8 +4973,7 @@
    ],
    "linker_set_key" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE",
    "name" : "android::RefBase::(unnamed)",
-   "referenced_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBase21$OBJECT_LIFETIME_MASKE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
    "underlying_type" : "_ZTIj"
@@ -5386,8 +4993,6 @@
    ],
    "linker_set_key" : "_ZTIN7android9Condition10WakeUpTypeE",
    "name" : "android::Condition::WakeUpType",
-   "referenced_type" : "_ZTIN7android9Condition10WakeUpTypeE",
-   "self_type" : "_ZTIN7android9Condition10WakeUpTypeE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Condition.h",
    "underlying_type" : "_ZTIj"
@@ -5407,8 +5012,6 @@
    ],
    "linker_set_key" : "_ZTIN7android9Condition8$PRIVATEE",
    "name" : "android::Condition::(unnamed)",
-   "referenced_type" : "_ZTIN7android9Condition8$PRIVATEE",
-   "self_type" : "_ZTIN7android9Condition8$PRIVATEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Condition.h",
    "underlying_type" : "_ZTIj"
@@ -5425,8 +5028,6 @@
    ],
    "linker_set_key" : "_ZTIN7android9FdPrinter18$MAX_FORMAT_STRINGE",
    "name" : "android::FdPrinter::(unnamed)",
-   "referenced_type" : "_ZTIN7android9FdPrinter18$MAX_FORMAT_STRINGE",
-   "self_type" : "_ZTIN7android9FdPrinter18$MAX_FORMAT_STRINGE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Printer.h",
    "underlying_type" : "_ZTIj"
@@ -5459,9 +5060,7 @@
      "referenced_type" : "_ZTIPPv"
     }
    ],
-   "referenced_type" : "_ZTIFiPFiPvES_PKcijPS_E",
    "return_type" : "_ZTIi",
-   "self_type" : "_ZTIFiPFiPvES_PKcijPS_E",
    "source_file" : "system/core/libutils/include/utils/AndroidThreads.h"
   },
   {
@@ -5477,9 +5076,7 @@
      "referenced_type" : "_ZTIPKv"
     }
    ],
-   "referenced_type" : "_ZTIFiPKvS0_E",
    "return_type" : "_ZTIi",
-   "self_type" : "_ZTIFiPKvS0_E",
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
@@ -5498,9 +5095,7 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFiPKvS0_PvE",
    "return_type" : "_ZTIi",
-   "self_type" : "_ZTIFiPKvS0_PvE",
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
   {
@@ -5513,9 +5108,7 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFiPvE",
    "return_type" : "_ZTIi",
-   "self_type" : "_ZTIFiPvE",
    "source_file" : "system/core/libutils/include/utils/AndroidThreads.h"
   },
   {
@@ -5534,18 +5127,14 @@
      "referenced_type" : "_ZTIPv"
     }
    ],
-   "referenced_type" : "_ZTIFiiiPvE",
    "return_type" : "_ZTIi",
-   "self_type" : "_ZTIFiiiPvE",
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIFvvE",
    "name" : "void ()",
-   "referenced_type" : "_ZTIFvvE",
    "return_type" : "_ZTIv",
-   "self_type" : "_ZTIFvvE",
    "source_file" : "system/core/libutils/include/utils/misc.h"
   }
  ],
@@ -6886,6 +6475,35 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
+  {
+   "function_name" : "android::sp<android::LooperCallback>::operator=",
+   "linker_set_key" : "_ZN7android2spINS_14LooperCallbackEEaSERKS2_",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android2spINS_14LooperCallbackEEE"
+    },
+    {
+     "referenced_type" : "_ZTIRKN7android2spINS_14LooperCallbackEEE"
+    }
+   ],
+   "return_type" : "_ZTIRN7android2spINS_14LooperCallbackEEE",
+   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
+  },
+  {
+   "function_name" : "android::sp<android::Looper>::~sp",
+   "linker_set_key" : "_ZN7android2spINS_6LooperEED2Ev",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android2spINS_6LooperEEE"
+    }
+   ],
+   "return_type" : "_ZTIv",
+   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
+  },
   {
    "function_name" : "android::sp<android::Looper>::operator=",
    "linker_set_key" : "_ZN7android2spINS_6LooperEEaSEOS2_",
@@ -6902,6 +6520,22 @@
    "return_type" : "_ZTIRN7android2spINS_6LooperEEE",
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
+  {
+   "function_name" : "android::sp<android::Looper>::operator=",
+   "linker_set_key" : "_ZN7android2spINS_6LooperEEaSERKS2_",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android2spINS_6LooperEEE"
+    },
+    {
+     "referenced_type" : "_ZTIRKN7android2spINS_6LooperEEE"
+    }
+   ],
+   "return_type" : "_ZTIRN7android2spINS_6LooperEEE",
+   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
+  },
   {
    "function_name" : "android::sp<android::Thread>::clear",
    "linker_set_key" : "_ZN7android2spINS_6ThreadEE5clearEv",
@@ -7015,6 +6649,34 @@
    "return_type" : "_ZTIv",
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
+  {
+   "function_name" : "android::Looper::getFdStateDebug",
+   "linker_set_key" : "_ZN7android6Looper15getFdStateDebugEiPiS1_PNS_2spINS_14LooperCallbackEEEPPv",
+   "parameters" :
+   [
+    {
+     "is_this_ptr" : true,
+     "referenced_type" : "_ZTIPN7android6LooperE"
+    },
+    {
+     "referenced_type" : "_ZTIi"
+    },
+    {
+     "referenced_type" : "_ZTIPi"
+    },
+    {
+     "referenced_type" : "_ZTIPi"
+    },
+    {
+     "referenced_type" : "_ZTIPN7android2spINS_14LooperCallbackEEE"
+    },
+    {
+     "referenced_type" : "_ZTIPPv"
+    }
+   ],
+   "return_type" : "_ZTIb",
+   "source_file" : "system/core/libutils/include/utils/Looper.h"
+  },
   {
    "function_name" : "android::Looper::sendMessageAtTime",
    "linker_set_key" : "_ZN7android6Looper17sendMessageAtTimeExRKNS_2spINS_14MessageHandlerEEERKNS_7MessageE",
@@ -7741,7 +7403,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -7770,7 +7432,7 @@
    "parameters" :
    [
     {
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7789,7 +7451,7 @@
    "parameters" :
    [
     {
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7808,7 +7470,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7824,7 +7486,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7840,7 +7502,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7856,7 +7518,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7872,7 +7534,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7888,7 +7550,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIb"
@@ -7908,7 +7570,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7925,7 +7587,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -7942,7 +7604,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIi"
@@ -7959,7 +7621,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIj"
@@ -7979,7 +7641,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -7993,7 +7655,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8007,7 +7669,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8021,7 +7683,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8035,7 +7697,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8048,7 +7710,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIj"
@@ -8065,7 +7727,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8084,7 +7746,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8100,7 +7762,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIj"
@@ -8116,7 +7778,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8129,7 +7791,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8148,7 +7810,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8161,7 +7823,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -8180,7 +7842,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -8199,7 +7861,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8215,7 +7877,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8234,10 +7896,10 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8250,7 +7912,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8266,7 +7928,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8285,10 +7947,10 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIi",
@@ -8303,7 +7965,7 @@
      "referenced_type" : "_ZTIPKc"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
@@ -8318,7 +7980,7 @@
      "referenced_type" : "_ZTISt9__va_list"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
@@ -8328,7 +7990,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8341,7 +8003,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8357,7 +8019,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -8373,7 +8035,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -8392,7 +8054,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -8408,7 +8070,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -8427,7 +8089,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8443,7 +8105,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8462,7 +8124,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIRKN7android8String16E"
@@ -8478,10 +8140,10 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8494,7 +8156,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8507,7 +8169,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -8523,7 +8185,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDi"
@@ -8542,7 +8204,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -8558,7 +8220,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKDs"
@@ -8577,7 +8239,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8593,7 +8255,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -8612,7 +8274,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIRKN7android8String16E"
@@ -8628,10 +8290,10 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8644,7 +8306,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8657,7 +8319,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -8670,7 +8332,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -9045,7 +8707,7 @@
      "referenced_type" : "_ZTIPN7android8String16E"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -9199,7 +8861,7 @@
      "referenced_type" : "_ZTIPN7android8String16E"
     },
     {
-     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIv",
@@ -9611,7 +9273,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIj"
@@ -9627,7 +9289,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIj",
@@ -9641,7 +9303,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIj",
@@ -10182,13 +9844,13 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
     }
    ],
-   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
@@ -10198,10 +9860,10 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
-   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "return_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
@@ -10227,7 +9889,7 @@
      "referenced_type" : "_ZTIPKN7android7RefBase12weakref_typeE"
     }
    ],
-   "return_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "return_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
   {
@@ -10250,7 +9912,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -10266,7 +9928,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIi",
@@ -10279,7 +9941,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -10295,7 +9957,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -10311,7 +9973,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKv"
@@ -10328,10 +9990,10 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
@@ -10342,10 +10004,10 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
-   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "return_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
   {
@@ -10355,7 +10017,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     },
     {
      "referenced_type" : "_ZTIPKc"
@@ -10375,7 +10037,7 @@
    [
     {
      "is_this_ptr" : true,
-     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "return_type" : "_ZTIj",
@@ -10975,7 +10637,6 @@
    "linker_set_key" : "_ZTIRA1_KDs",
    "name" : "const char16_t (&)[1]",
    "referenced_type" : "_ZTIA1_KDs",
-   "self_type" : "_ZTIRA1_KDs",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -10983,8 +10644,7 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIRKN7android10VectorImplE",
    "name" : "const android::VectorImpl &",
-   "referenced_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIRKN7android10VectorImplE",
+   "referenced_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -10993,7 +10653,6 @@
    "linker_set_key" : "_ZTIRKN7android16ReferenceRenamerE",
    "name" : "const android::ReferenceRenamer &",
    "referenced_type" : "_ZTIKN7android16ReferenceRenamerE",
-   "self_type" : "_ZTIRKN7android16ReferenceRenamerE",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -11002,7 +10661,6 @@
    "linker_set_key" : "_ZTIRKN7android16SortedVectorImplE",
    "name" : "const android::SortedVectorImpl &",
    "referenced_type" : "_ZTIKN7android16SortedVectorImplE",
-   "self_type" : "_ZTIRKN7android16SortedVectorImplE",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11011,7 +10669,6 @@
    "linker_set_key" : "_ZTIRKN7android28sysprop_change_callback_infoE",
    "name" : "const android::sysprop_change_callback_info &",
    "referenced_type" : "_ZTIKN7android28sysprop_change_callback_infoE",
-   "self_type" : "_ZTIRKN7android28sysprop_change_callback_infoE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11020,7 +10677,6 @@
    "linker_set_key" : "_ZTIRKN7android2spINS_14LooperCallbackEEE",
    "name" : "const android::sp<android::LooperCallback> &",
    "referenced_type" : "_ZTIKN7android2spINS_14LooperCallbackEEE",
-   "self_type" : "_ZTIRKN7android2spINS_14LooperCallbackEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11029,7 +10685,6 @@
    "linker_set_key" : "_ZTIRKN7android2spINS_14MessageHandlerEEE",
    "name" : "const android::sp<android::MessageHandler> &",
    "referenced_type" : "_ZTIKN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIRKN7android2spINS_14MessageHandlerEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11038,7 +10693,6 @@
    "linker_set_key" : "_ZTIRKN7android2spINS_20SimpleLooperCallbackEEE",
    "name" : "const android::sp<android::SimpleLooperCallback> &",
    "referenced_type" : "_ZTIKN7android2spINS_20SimpleLooperCallbackEEE",
-   "self_type" : "_ZTIRKN7android2spINS_20SimpleLooperCallbackEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11047,16 +10701,14 @@
    "linker_set_key" : "_ZTIRKN7android2spINS_6LooperEEE",
    "name" : "const android::sp<android::Looper> &",
    "referenced_type" : "_ZTIKN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTIRKN7android2spINS_6LooperEEE",
    "size" : 4,
-   "source_file" : "system/core/libutils/include/utils/Looper.h"
+   "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
   {
    "alignment" : 4,
    "linker_set_key" : "_ZTIRKN7android2spINS_6ThreadEEE",
    "name" : "const android::sp<android::Thread> &",
    "referenced_type" : "_ZTIKN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTIRKN7android2spINS_6ThreadEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11065,7 +10717,6 @@
    "linker_set_key" : "_ZTIRKN7android2wpINS_14MessageHandlerEEE",
    "name" : "const android::wp<android::MessageHandler> &",
    "referenced_type" : "_ZTIKN7android2wpINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIRKN7android2wpINS_14MessageHandlerEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11074,7 +10725,6 @@
    "linker_set_key" : "_ZTIRKN7android6Looper15MessageEnvelopeE",
    "name" : "const android::Looper::MessageEnvelope &",
    "referenced_type" : "_ZTIKN7android6Looper15MessageEnvelopeE",
-   "self_type" : "_ZTIRKN7android6Looper15MessageEnvelopeE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11083,7 +10733,6 @@
    "linker_set_key" : "_ZTIRKN7android6Looper8ResponseE",
    "name" : "const android::Looper::Response &",
    "referenced_type" : "_ZTIKN7android6Looper8ResponseE",
-   "self_type" : "_ZTIRKN7android6Looper8ResponseE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11092,7 +10741,6 @@
    "linker_set_key" : "_ZTIRKN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "name" : "const android::Vector<android::sysprop_change_callback_info> &",
    "referenced_type" : "_ZTIKN7android6VectorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIRKN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11101,7 +10749,6 @@
    "linker_set_key" : "_ZTIRKN7android7MessageE",
    "name" : "const android::Message &",
    "referenced_type" : "_ZTIKN7android7MessageE",
-   "self_type" : "_ZTIRKN7android7MessageE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -11110,7 +10757,6 @@
    "linker_set_key" : "_ZTIRKN7android7String8E",
    "name" : "const android::String8 &",
    "referenced_type" : "_ZTIKN7android7String8E",
-   "self_type" : "_ZTIRKN7android7String8E",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
@@ -11118,8 +10764,8 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIRKN7android7String8E",
    "name" : "const android::String8 &",
-   "referenced_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIRKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -11128,7 +10774,6 @@
    "linker_set_key" : "_ZTIRKN7android8String1610StaticDataILj1EEE",
    "name" : "const android::String16::StaticData<1> &",
    "referenced_type" : "_ZTIKN7android8String1610StaticDataILj1EEE",
-   "self_type" : "_ZTIRKN7android8String1610StaticDataILj1EEE",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11137,7 +10782,6 @@
    "linker_set_key" : "_ZTIRKN7android8String16E",
    "name" : "const android::String16 &",
    "referenced_type" : "_ZTIKN7android8String16E",
-   "self_type" : "_ZTIRKN7android8String16E",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11146,7 +10790,6 @@
    "linker_set_key" : "_ZTIRKa",
    "name" : "const signed char &",
    "referenced_type" : "_ZTIKa",
-   "self_type" : "_ZTIRKa",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11155,7 +10798,6 @@
    "linker_set_key" : "_ZTIRKb",
    "name" : "const bool &",
    "referenced_type" : "_ZTIKb",
-   "self_type" : "_ZTIRKb",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11164,7 +10806,6 @@
    "linker_set_key" : "_ZTIRKd",
    "name" : "const double &",
    "referenced_type" : "_ZTIKd",
-   "self_type" : "_ZTIRKd",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11173,7 +10814,6 @@
    "linker_set_key" : "_ZTIRKf",
    "name" : "const float &",
    "referenced_type" : "_ZTIKf",
-   "self_type" : "_ZTIRKf",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11182,7 +10822,6 @@
    "linker_set_key" : "_ZTIRKh",
    "name" : "const unsigned char &",
    "referenced_type" : "_ZTIKh",
-   "self_type" : "_ZTIRKh",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11191,7 +10830,6 @@
    "linker_set_key" : "_ZTIRKi",
    "name" : "const int &",
    "referenced_type" : "_ZTIKi",
-   "self_type" : "_ZTIRKi",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11200,7 +10838,6 @@
    "linker_set_key" : "_ZTIRKj",
    "name" : "const unsigned int &",
    "referenced_type" : "_ZTIKj",
-   "self_type" : "_ZTIRKj",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11209,7 +10846,6 @@
    "linker_set_key" : "_ZTIRKs",
    "name" : "const short &",
    "referenced_type" : "_ZTIKs",
-   "self_type" : "_ZTIRKs",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11218,7 +10854,6 @@
    "linker_set_key" : "_ZTIRKt",
    "name" : "const unsigned short &",
    "referenced_type" : "_ZTIKt",
-   "self_type" : "_ZTIRKt",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11227,7 +10862,6 @@
    "linker_set_key" : "_ZTIRKx",
    "name" : "const long long &",
    "referenced_type" : "_ZTIKx",
-   "self_type" : "_ZTIRKx",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11236,7 +10870,6 @@
    "linker_set_key" : "_ZTIRKy",
    "name" : "const unsigned long long &",
    "referenced_type" : "_ZTIKy",
-   "self_type" : "_ZTIRKy",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11244,8 +10877,7 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIRN7android10VectorImplE",
    "name" : "android::VectorImpl &",
-   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIRN7android10VectorImplE",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11253,8 +10885,7 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIRN7android16SortedVectorImplE",
    "name" : "android::SortedVectorImpl &",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIRN7android16SortedVectorImplE",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11263,7 +10894,6 @@
    "linker_set_key" : "_ZTIRN7android2spINS_14LooperCallbackEEE",
    "name" : "android::sp<android::LooperCallback> &",
    "referenced_type" : "_ZTIN7android2spINS_14LooperCallbackEEE",
-   "self_type" : "_ZTIRN7android2spINS_14LooperCallbackEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11272,7 +10902,6 @@
    "linker_set_key" : "_ZTIRN7android2spINS_14MessageHandlerEEE",
    "name" : "android::sp<android::MessageHandler> &",
    "referenced_type" : "_ZTIN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIRN7android2spINS_14MessageHandlerEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11281,7 +10910,6 @@
    "linker_set_key" : "_ZTIRN7android2spINS_20SimpleLooperCallbackEEE",
    "name" : "android::sp<android::SimpleLooperCallback> &",
    "referenced_type" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
-   "self_type" : "_ZTIRN7android2spINS_20SimpleLooperCallbackEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11290,7 +10918,6 @@
    "linker_set_key" : "_ZTIRN7android2spINS_6LooperEEE",
    "name" : "android::sp<android::Looper> &",
    "referenced_type" : "_ZTIN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTIRN7android2spINS_6LooperEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11299,7 +10926,6 @@
    "linker_set_key" : "_ZTIRN7android2spINS_6ThreadEEE",
    "name" : "android::sp<android::Thread> &",
    "referenced_type" : "_ZTIN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTIRN7android2spINS_6ThreadEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11308,7 +10934,6 @@
    "linker_set_key" : "_ZTIRN7android5MutexE",
    "name" : "android::Mutex &",
    "referenced_type" : "_ZTIN7android5MutexE",
-   "self_type" : "_ZTIRN7android5MutexE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Mutex.h"
   },
@@ -11317,7 +10942,6 @@
    "linker_set_key" : "_ZTIRN7android6Looper8ResponseE",
    "name" : "android::Looper::Response &",
    "referenced_type" : "_ZTIN7android6Looper8ResponseE",
-   "self_type" : "_ZTIRN7android6Looper8ResponseE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11326,7 +10950,6 @@
    "linker_set_key" : "_ZTIRN7android6RWLockE",
    "name" : "android::RWLock &",
    "referenced_type" : "_ZTIN7android6RWLockE",
-   "self_type" : "_ZTIRN7android6RWLockE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -11335,7 +10958,6 @@
    "linker_set_key" : "_ZTIRN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "name" : "android::Vector<android::sysprop_change_callback_info> &",
    "referenced_type" : "_ZTIN7android6VectorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIRN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11344,7 +10966,6 @@
    "linker_set_key" : "_ZTIRN7android7FileMapE",
    "name" : "android::FileMap &",
    "referenced_type" : "_ZTIN7android7FileMapE",
-   "self_type" : "_ZTIRN7android7FileMapE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -11353,7 +10974,6 @@
    "linker_set_key" : "_ZTIRN7android7PrinterE",
    "name" : "android::Printer &",
    "referenced_type" : "_ZTIN7android7PrinterE",
-   "self_type" : "_ZTIRN7android7PrinterE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -11362,7 +10982,6 @@
    "linker_set_key" : "_ZTIRN7android7String8E",
    "name" : "android::String8 &",
    "referenced_type" : "_ZTIN7android7String8E",
-   "self_type" : "_ZTIRN7android7String8E",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
@@ -11370,8 +10989,8 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIRN7android7String8E",
    "name" : "android::String8 &",
-   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIRN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIRN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -11380,7 +10999,6 @@
    "linker_set_key" : "_ZTIRN7android8String16E",
    "name" : "android::String16 &",
    "referenced_type" : "_ZTIN7android8String16E",
-   "self_type" : "_ZTIRN7android8String16E",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11389,7 +11007,6 @@
    "linker_set_key" : "_ZTIRP13native_handle",
    "name" : "native_handle *&",
    "referenced_type" : "_ZTIP13native_handle",
-   "self_type" : "_ZTIRP13native_handle",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11398,7 +11015,6 @@
    "linker_set_key" : "_ZTIRPFiiiPvE",
    "name" : "int (*&)(int, int, void *)",
    "referenced_type" : "_ZTIPFiiiPvE",
-   "self_type" : "_ZTIRPFiiiPvE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11407,7 +11023,6 @@
    "linker_set_key" : "_ZTIRb",
    "name" : "bool &",
    "referenced_type" : "_ZTIb",
-   "self_type" : "_ZTIRb",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   }
@@ -11419,7 +11034,6 @@
    "linker_set_key" : "_ZTIP13native_handle",
    "name" : "native_handle *",
    "referenced_type" : "_ZTI13native_handle",
-   "self_type" : "_ZTIP13native_handle",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11428,7 +11042,6 @@
    "linker_set_key" : "_ZTIP18android_flex_plane",
    "name" : "android_flex_plane *",
    "referenced_type" : "_ZTI18android_flex_plane",
-   "self_type" : "_ZTIP18android_flex_plane",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -11437,7 +11050,6 @@
    "linker_set_key" : "_ZTIP3DIR",
    "name" : "DIR *",
    "referenced_type" : "_ZTI3DIR",
-   "self_type" : "_ZTIP3DIR",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -11446,7 +11058,6 @@
    "linker_set_key" : "_ZTIP7__sFILE",
    "name" : "__sFILE *",
    "referenced_type" : "_ZTI7__sFILE",
-   "self_type" : "_ZTIP7__sFILE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -11455,7 +11066,6 @@
    "linker_set_key" : "_ZTIP7log_msg",
    "name" : "log_msg *",
    "referenced_type" : "_ZTI7log_msg",
-   "self_type" : "_ZTIP7log_msg",
    "size" : 4,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   },
@@ -11464,7 +11074,6 @@
    "linker_set_key" : "_ZTIPDs",
    "name" : "char16_t *",
    "referenced_type" : "_ZTIDs",
-   "self_type" : "_ZTIPDs",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11473,7 +11082,6 @@
    "linker_set_key" : "_ZTIPFiPFiPvES_PKcijPS_E",
    "name" : "int (*)(int (*)(void *), void *, const char *, int, unsigned int, void **)",
    "referenced_type" : "_ZTIFiPFiPvES_PKcijPS_E",
-   "self_type" : "_ZTIPFiPFiPvES_PKcijPS_E",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/AndroidThreads.h"
   },
@@ -11482,7 +11090,6 @@
    "linker_set_key" : "_ZTIPFiPKvS0_E",
    "name" : "int (*)(const void *, const void *)",
    "referenced_type" : "_ZTIFiPKvS0_E",
-   "self_type" : "_ZTIPFiPKvS0_E",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11491,7 +11098,6 @@
    "linker_set_key" : "_ZTIPFiPKvS0_PvE",
    "name" : "int (*)(const void *, const void *, void *)",
    "referenced_type" : "_ZTIFiPKvS0_PvE",
-   "self_type" : "_ZTIPFiPKvS0_PvE",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11500,7 +11106,6 @@
    "linker_set_key" : "_ZTIPFiPvE",
    "name" : "int (*)(void *)",
    "referenced_type" : "_ZTIFiPvE",
-   "self_type" : "_ZTIPFiPvE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/AndroidThreads.h"
   },
@@ -11509,7 +11114,6 @@
    "linker_set_key" : "_ZTIPFiiiPvE",
    "name" : "int (*)(int, int, void *)",
    "referenced_type" : "_ZTIFiiiPvE",
-   "self_type" : "_ZTIPFiiiPvE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11518,7 +11122,6 @@
    "linker_set_key" : "_ZTIPFvvE",
    "name" : "void (*)()",
    "referenced_type" : "_ZTIFvvE",
-   "self_type" : "_ZTIPFvvE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/misc.h"
   },
@@ -11527,7 +11130,6 @@
    "linker_set_key" : "_ZTIPK13native_handle",
    "name" : "const native_handle *",
    "referenced_type" : "_ZTIK13native_handle",
-   "self_type" : "_ZTIPK13native_handle",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/NativeHandle.h"
   },
@@ -11536,7 +11138,6 @@
    "linker_set_key" : "_ZTIPK7log_msg",
    "name" : "const log_msg *",
    "referenced_type" : "_ZTIK7log_msg",
-   "self_type" : "_ZTIPK7log_msg",
    "size" : 4,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   },
@@ -11545,7 +11146,6 @@
    "linker_set_key" : "_ZTIPKDi",
    "name" : "const char32_t *",
    "referenced_type" : "_ZTIKDi",
-   "self_type" : "_ZTIPKDi",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -11554,7 +11154,6 @@
    "linker_set_key" : "_ZTIPKDs",
    "name" : "const char16_t *",
    "referenced_type" : "_ZTIKDs",
-   "self_type" : "_ZTIPKDs",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11563,7 +11162,6 @@
    "linker_set_key" : "_ZTIPKN7android10VectorImplE",
    "name" : "const android::VectorImpl *",
    "referenced_type" : "_ZTIKN7android10VectorImplE",
-   "self_type" : "_ZTIPKN7android10VectorImplE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
   },
@@ -11571,8 +11169,8 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIPKN7android10VectorImplE",
    "name" : "const android::VectorImpl *",
-   "referenced_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11581,7 +11179,6 @@
    "linker_set_key" : "_ZTIPKN7android12LightRefBaseINS_12NativeHandleEEE",
    "name" : "const android::LightRefBase<android::NativeHandle> *",
    "referenced_type" : "_ZTIKN7android12LightRefBaseINS_12NativeHandleEEE",
-   "self_type" : "_ZTIPKN7android12LightRefBaseINS_12NativeHandleEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
@@ -11590,7 +11187,6 @@
    "linker_set_key" : "_ZTIPKN7android12NativeHandleE",
    "name" : "const android::NativeHandle *",
    "referenced_type" : "_ZTIKN7android12NativeHandleE",
-   "self_type" : "_ZTIPKN7android12NativeHandleE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/NativeHandle.h"
   },
@@ -11599,7 +11195,6 @@
    "linker_set_key" : "_ZTIPKN7android16SortedVectorImplE",
    "name" : "const android::SortedVectorImpl *",
    "referenced_type" : "_ZTIKN7android16SortedVectorImplE",
-   "self_type" : "_ZTIPKN7android16SortedVectorImplE",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11608,7 +11203,6 @@
    "linker_set_key" : "_ZTIPKN7android28sysprop_change_callback_infoE",
    "name" : "const android::sysprop_change_callback_info *",
    "referenced_type" : "_ZTIKN7android28sysprop_change_callback_infoE",
-   "self_type" : "_ZTIPKN7android28sysprop_change_callback_infoE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11617,7 +11211,6 @@
    "linker_set_key" : "_ZTIPKN7android2spINS_14LooperCallbackEEE",
    "name" : "const android::sp<android::LooperCallback> *",
    "referenced_type" : "_ZTIKN7android2spINS_14LooperCallbackEEE",
-   "self_type" : "_ZTIPKN7android2spINS_14LooperCallbackEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11626,7 +11219,6 @@
    "linker_set_key" : "_ZTIPKN7android2spINS_14MessageHandlerEEE",
    "name" : "const android::sp<android::MessageHandler> *",
    "referenced_type" : "_ZTIKN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIPKN7android2spINS_14MessageHandlerEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11635,7 +11227,6 @@
    "linker_set_key" : "_ZTIPKN7android2spINS_6LooperEEE",
    "name" : "const android::sp<android::Looper> *",
    "referenced_type" : "_ZTIKN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTIPKN7android2spINS_6LooperEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11644,7 +11235,6 @@
    "linker_set_key" : "_ZTIPKN7android2spINS_6ThreadEEE",
    "name" : "const android::sp<android::Thread> *",
    "referenced_type" : "_ZTIKN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTIPKN7android2spINS_6ThreadEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11653,7 +11243,6 @@
    "linker_set_key" : "_ZTIPKN7android2wpINS_14MessageHandlerEEE",
    "name" : "const android::wp<android::MessageHandler> *",
    "referenced_type" : "_ZTIKN7android2wpINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIPKN7android2wpINS_14MessageHandlerEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11662,7 +11251,6 @@
    "linker_set_key" : "_ZTIPKN7android2wpINS_6ThreadEEE",
    "name" : "const android::wp<android::Thread> *",
    "referenced_type" : "_ZTIKN7android2wpINS_6ThreadEEE",
-   "self_type" : "_ZTIPKN7android2wpINS_6ThreadEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11671,7 +11259,6 @@
    "linker_set_key" : "_ZTIPKN7android4base11borrowed_fdE",
    "name" : "const android::base::borrowed_fd *",
    "referenced_type" : "_ZTIKN7android4base11borrowed_fdE",
-   "self_type" : "_ZTIPKN7android4base11borrowed_fdE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -11680,7 +11267,6 @@
    "linker_set_key" : "_ZTIPKN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "name" : "const android::base::unique_fd_impl<android::base::DefaultCloser> *",
    "referenced_type" : "_ZTIKN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
-   "self_type" : "_ZTIPKN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -11689,7 +11275,6 @@
    "linker_set_key" : "_ZTIPKN7android6Looper15MessageEnvelopeE",
    "name" : "const android::Looper::MessageEnvelope *",
    "referenced_type" : "_ZTIKN7android6Looper15MessageEnvelopeE",
-   "self_type" : "_ZTIPKN7android6Looper15MessageEnvelopeE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11698,7 +11283,6 @@
    "linker_set_key" : "_ZTIPKN7android6Looper7RequestE",
    "name" : "const android::Looper::Request *",
    "referenced_type" : "_ZTIKN7android6Looper7RequestE",
-   "self_type" : "_ZTIPKN7android6Looper7RequestE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -11707,7 +11291,6 @@
    "linker_set_key" : "_ZTIPKN7android6Looper8ResponseE",
    "name" : "const android::Looper::Response *",
    "referenced_type" : "_ZTIKN7android6Looper8ResponseE",
-   "self_type" : "_ZTIPKN7android6Looper8ResponseE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -11716,7 +11299,6 @@
    "linker_set_key" : "_ZTIPKN7android6LooperE",
    "name" : "const android::Looper *",
    "referenced_type" : "_ZTIKN7android6LooperE",
-   "self_type" : "_ZTIPKN7android6LooperE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -11725,7 +11307,6 @@
    "linker_set_key" : "_ZTIPKN7android6ThreadE",
    "name" : "const android::Thread *",
    "referenced_type" : "_ZTIKN7android6ThreadE",
-   "self_type" : "_ZTIPKN7android6ThreadE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Thread.h"
   },
@@ -11734,7 +11315,6 @@
    "linker_set_key" : "_ZTIPKN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "name" : "const android::Vector<android::sysprop_change_callback_info> *",
    "referenced_type" : "_ZTIKN7android6VectorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIPKN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11743,7 +11323,6 @@
    "linker_set_key" : "_ZTIPKN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "name" : "const android::Vector<android::Looper::MessageEnvelope> *",
    "referenced_type" : "_ZTIKN7android6VectorINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIPKN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11752,7 +11331,6 @@
    "linker_set_key" : "_ZTIPKN7android6VectorINS_6Looper8ResponseEEE",
    "name" : "const android::Vector<android::Looper::Response> *",
    "referenced_type" : "_ZTIKN7android6VectorINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIPKN7android6VectorINS_6Looper8ResponseEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -11761,7 +11339,6 @@
    "linker_set_key" : "_ZTIPKN7android6VectorINS_7String8EEE",
    "name" : "const android::Vector<android::String8> *",
    "referenced_type" : "_ZTIKN7android6VectorINS_7String8EEE",
-   "self_type" : "_ZTIPKN7android6VectorINS_7String8EEE",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/Vector.h"
   },
@@ -11770,7 +11347,6 @@
    "linker_set_key" : "_ZTIPKN7android7FileMapE",
    "name" : "const android::FileMap *",
    "referenced_type" : "_ZTIKN7android7FileMapE",
-   "self_type" : "_ZTIPKN7android7FileMapE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -11779,7 +11355,6 @@
    "linker_set_key" : "_ZTIPKN7android7RefBase12weakref_typeE",
    "name" : "const android::RefBase::weakref_type *",
    "referenced_type" : "_ZTIKN7android7RefBase12weakref_typeE",
-   "self_type" : "_ZTIPKN7android7RefBase12weakref_typeE",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -11788,7 +11363,6 @@
    "linker_set_key" : "_ZTIPKN7android7RefBaseE",
    "name" : "const android::RefBase *",
    "referenced_type" : "_ZTIKN7android7RefBaseE",
-   "self_type" : "_ZTIPKN7android7RefBaseE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11796,8 +11370,8 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIPKN7android7RefBaseE",
    "name" : "const android::RefBase *",
-   "referenced_type" : "_ZTIKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -11806,7 +11380,6 @@
    "linker_set_key" : "_ZTIPKN7android7String8E",
    "name" : "const android::String8 *",
    "referenced_type" : "_ZTIKN7android7String8E",
-   "self_type" : "_ZTIPKN7android7String8E",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
@@ -11814,8 +11387,8 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIPKN7android7String8E",
    "name" : "const android::String8 *",
-   "referenced_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -11824,7 +11397,6 @@
    "linker_set_key" : "_ZTIPKN7android8String16E",
    "name" : "const android::String16 *",
    "referenced_type" : "_ZTIKN7android8String16E",
-   "self_type" : "_ZTIPKN7android8String16E",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11833,7 +11405,6 @@
    "linker_set_key" : "_ZTIPKN7android9StopWatchE",
    "name" : "const android::StopWatch *",
    "referenced_type" : "_ZTIKN7android9StopWatchE",
-   "self_type" : "_ZTIPKN7android9StopWatchE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StopWatch.h"
   },
@@ -11842,7 +11413,6 @@
    "linker_set_key" : "_ZTIPKN7android9TokenizerE",
    "name" : "const android::Tokenizer *",
    "referenced_type" : "_ZTIKN7android9TokenizerE",
-   "self_type" : "_ZTIPKN7android9TokenizerE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Tokenizer.h"
   },
@@ -11851,7 +11421,6 @@
    "linker_set_key" : "_ZTIPKc",
    "name" : "const char *",
    "referenced_type" : "_ZTIKc",
-   "self_type" : "_ZTIPKc",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -11860,7 +11429,6 @@
    "linker_set_key" : "_ZTIPKh",
    "name" : "const unsigned char *",
    "referenced_type" : "_ZTIKh",
-   "self_type" : "_ZTIPKh",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/JenkinsHash.h"
   },
@@ -11869,7 +11437,6 @@
    "linker_set_key" : "_ZTIPKt",
    "name" : "const unsigned short *",
    "referenced_type" : "_ZTIKt",
-   "self_type" : "_ZTIPKt",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/JenkinsHash.h"
   },
@@ -11878,7 +11445,6 @@
    "linker_set_key" : "_ZTIPKv",
    "name" : "const void *",
    "referenced_type" : "_ZTIKv",
-   "self_type" : "_ZTIPKv",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
@@ -11887,7 +11453,6 @@
    "linker_set_key" : "_ZTIPN7android10LogPrinterE",
    "name" : "android::LogPrinter *",
    "referenced_type" : "_ZTIN7android10LogPrinterE",
-   "self_type" : "_ZTIPN7android10LogPrinterE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -11895,8 +11460,7 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIPN7android10VectorImplE",
    "name" : "android::VectorImpl *",
-   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android10VectorImplE",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -11905,7 +11469,6 @@
    "linker_set_key" : "_ZTIPN7android11ScopedTraceE",
    "name" : "android::ScopedTrace *",
    "referenced_type" : "_ZTIN7android11ScopedTraceE",
-   "self_type" : "_ZTIPN7android11ScopedTraceE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Trace.h"
   },
@@ -11914,7 +11477,6 @@
    "linker_set_key" : "_ZTIPN7android12LightRefBaseINS_12NativeHandleEEE",
    "name" : "android::LightRefBase<android::NativeHandle> *",
    "referenced_type" : "_ZTIN7android12LightRefBaseINS_12NativeHandleEEE",
-   "self_type" : "_ZTIPN7android12LightRefBaseINS_12NativeHandleEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
@@ -11923,7 +11485,6 @@
    "linker_set_key" : "_ZTIPN7android12NativeHandleE",
    "name" : "android::NativeHandle *",
    "referenced_type" : "_ZTIN7android12NativeHandleE",
-   "self_type" : "_ZTIPN7android12NativeHandleE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11932,7 +11493,6 @@
    "linker_set_key" : "_ZTIPN7android13PrefixPrinterE",
    "name" : "android::PrefixPrinter *",
    "referenced_type" : "_ZTIN7android13PrefixPrinterE",
-   "self_type" : "_ZTIPN7android13PrefixPrinterE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -11941,7 +11501,6 @@
    "linker_set_key" : "_ZTIPN7android14LooperCallbackE",
    "name" : "android::LooperCallback *",
    "referenced_type" : "_ZTIN7android14LooperCallbackE",
-   "self_type" : "_ZTIPN7android14LooperCallbackE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -11950,7 +11509,6 @@
    "linker_set_key" : "_ZTIPN7android14MessageHandlerE",
    "name" : "android::MessageHandler *",
    "referenced_type" : "_ZTIN7android14MessageHandlerE",
-   "self_type" : "_ZTIPN7android14MessageHandlerE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11959,7 +11517,6 @@
    "linker_set_key" : "_ZTIPN7android14StaticString16ILj1EEE",
    "name" : "android::StaticString16<1> *",
    "referenced_type" : "_ZTIN7android14StaticString16ILj1EEE",
-   "self_type" : "_ZTIPN7android14StaticString16ILj1EEE",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -11968,7 +11525,6 @@
    "linker_set_key" : "_ZTIPN7android14String8PrinterE",
    "name" : "android::String8Printer *",
    "referenced_type" : "_ZTIN7android14String8PrinterE",
-   "self_type" : "_ZTIPN7android14String8PrinterE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -11977,7 +11533,6 @@
    "linker_set_key" : "_ZTIPN7android16ReferenceRenamerE",
    "name" : "android::ReferenceRenamer *",
    "referenced_type" : "_ZTIN7android16ReferenceRenamerE",
-   "self_type" : "_ZTIPN7android16ReferenceRenamerE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -11985,8 +11540,8 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIPN7android16ReferenceRenamerE",
    "name" : "android::ReferenceRenamer *",
-   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -11994,8 +11549,7 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIPN7android16SortedVectorImplE",
    "name" : "android::SortedVectorImpl *",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android16SortedVectorImplE",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -12004,7 +11558,6 @@
    "linker_set_key" : "_ZTIPN7android18WeakMessageHandlerE",
    "name" : "android::WeakMessageHandler *",
    "referenced_type" : "_ZTIN7android18WeakMessageHandlerE",
-   "self_type" : "_ZTIPN7android18WeakMessageHandlerE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -12013,7 +11566,6 @@
    "linker_set_key" : "_ZTIPN7android19VirtualLightRefBaseE",
    "name" : "android::VirtualLightRefBase *",
    "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE",
-   "self_type" : "_ZTIPN7android19VirtualLightRefBaseE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
@@ -12021,8 +11573,8 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIPN7android19VirtualLightRefBaseE",
    "name" : "android::VirtualLightRefBase *",
-   "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/LightRefBase.h"
   },
@@ -12031,7 +11583,6 @@
    "linker_set_key" : "_ZTIPN7android20SimpleLooperCallbackE",
    "name" : "android::SimpleLooperCallback *",
    "referenced_type" : "_ZTIN7android20SimpleLooperCallbackE",
-   "self_type" : "_ZTIPN7android20SimpleLooperCallbackE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12040,7 +11591,6 @@
    "linker_set_key" : "_ZTIPN7android28sysprop_change_callback_infoE",
    "name" : "android::sysprop_change_callback_info *",
    "referenced_type" : "_ZTIN7android28sysprop_change_callback_infoE",
-   "self_type" : "_ZTIPN7android28sysprop_change_callback_infoE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12049,7 +11599,6 @@
    "linker_set_key" : "_ZTIPN7android2spINS_12NativeHandleEEE",
    "name" : "android::sp<android::NativeHandle> *",
    "referenced_type" : "_ZTIN7android2spINS_12NativeHandleEEE",
-   "self_type" : "_ZTIPN7android2spINS_12NativeHandleEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12058,7 +11607,6 @@
    "linker_set_key" : "_ZTIPN7android2spINS_14LooperCallbackEEE",
    "name" : "android::sp<android::LooperCallback> *",
    "referenced_type" : "_ZTIN7android2spINS_14LooperCallbackEEE",
-   "self_type" : "_ZTIPN7android2spINS_14LooperCallbackEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12067,7 +11615,6 @@
    "linker_set_key" : "_ZTIPN7android2spINS_14MessageHandlerEEE",
    "name" : "android::sp<android::MessageHandler> *",
    "referenced_type" : "_ZTIN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIPN7android2spINS_14MessageHandlerEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12076,7 +11623,6 @@
    "linker_set_key" : "_ZTIPN7android2spINS_20SimpleLooperCallbackEEE",
    "name" : "android::sp<android::SimpleLooperCallback> *",
    "referenced_type" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
-   "self_type" : "_ZTIPN7android2spINS_20SimpleLooperCallbackEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12085,7 +11631,6 @@
    "linker_set_key" : "_ZTIPN7android2spINS_6LooperEEE",
    "name" : "android::sp<android::Looper> *",
    "referenced_type" : "_ZTIN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTIPN7android2spINS_6LooperEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12094,7 +11639,6 @@
    "linker_set_key" : "_ZTIPN7android2spINS_6ThreadEEE",
    "name" : "android::sp<android::Thread> *",
    "referenced_type" : "_ZTIN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTIPN7android2spINS_6ThreadEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12103,7 +11647,6 @@
    "linker_set_key" : "_ZTIPN7android2wpINS_14MessageHandlerEEE",
    "name" : "android::wp<android::MessageHandler> *",
    "referenced_type" : "_ZTIN7android2wpINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIPN7android2wpINS_14MessageHandlerEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12112,7 +11655,6 @@
    "linker_set_key" : "_ZTIPN7android2wpINS_6ThreadEEE",
    "name" : "android::wp<android::Thread> *",
    "referenced_type" : "_ZTIN7android2wpINS_6ThreadEEE",
-   "self_type" : "_ZTIPN7android2wpINS_6ThreadEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12121,7 +11663,6 @@
    "linker_set_key" : "_ZTIPN7android4base11borrowed_fdE",
    "name" : "android::base::borrowed_fd *",
    "referenced_type" : "_ZTIN7android4base11borrowed_fdE",
-   "self_type" : "_ZTIPN7android4base11borrowed_fdE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -12130,7 +11671,6 @@
    "linker_set_key" : "_ZTIPN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "name" : "android::base::unique_fd_impl<android::base::DefaultCloser> *",
    "referenced_type" : "_ZTIN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
-   "self_type" : "_ZTIPN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -12139,7 +11679,6 @@
    "linker_set_key" : "_ZTIPN7android5Mutex8AutolockE",
    "name" : "android::Mutex::Autolock *",
    "referenced_type" : "_ZTIN7android5Mutex8AutolockE",
-   "self_type" : "_ZTIPN7android5Mutex8AutolockE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Mutex.h"
   },
@@ -12148,7 +11687,6 @@
    "linker_set_key" : "_ZTIPN7android5MutexE",
    "name" : "android::Mutex *",
    "referenced_type" : "_ZTIN7android5MutexE",
-   "self_type" : "_ZTIPN7android5MutexE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Mutex.h"
   },
@@ -12157,7 +11695,6 @@
    "linker_set_key" : "_ZTIPN7android6Looper15MessageEnvelopeE",
    "name" : "android::Looper::MessageEnvelope *",
    "referenced_type" : "_ZTIN7android6Looper15MessageEnvelopeE",
-   "self_type" : "_ZTIPN7android6Looper15MessageEnvelopeE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12166,7 +11703,6 @@
    "linker_set_key" : "_ZTIPN7android6Looper8ResponseE",
    "name" : "android::Looper::Response *",
    "referenced_type" : "_ZTIN7android6Looper8ResponseE",
-   "self_type" : "_ZTIPN7android6Looper8ResponseE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12175,7 +11711,6 @@
    "linker_set_key" : "_ZTIPN7android6LooperE",
    "name" : "android::Looper *",
    "referenced_type" : "_ZTIN7android6LooperE",
-   "self_type" : "_ZTIPN7android6LooperE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12184,7 +11719,6 @@
    "linker_set_key" : "_ZTIPN7android6RWLock9AutoRLockE",
    "name" : "android::RWLock::AutoRLock *",
    "referenced_type" : "_ZTIN7android6RWLock9AutoRLockE",
-   "self_type" : "_ZTIPN7android6RWLock9AutoRLockE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -12193,7 +11727,6 @@
    "linker_set_key" : "_ZTIPN7android6RWLock9AutoWLockE",
    "name" : "android::RWLock::AutoWLock *",
    "referenced_type" : "_ZTIN7android6RWLock9AutoWLockE",
-   "self_type" : "_ZTIPN7android6RWLock9AutoWLockE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -12202,7 +11735,6 @@
    "linker_set_key" : "_ZTIPN7android6RWLockE",
    "name" : "android::RWLock *",
    "referenced_type" : "_ZTIN7android6RWLockE",
-   "self_type" : "_ZTIPN7android6RWLockE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -12211,7 +11743,6 @@
    "linker_set_key" : "_ZTIPN7android6ThreadE",
    "name" : "android::Thread *",
    "referenced_type" : "_ZTIN7android6ThreadE",
-   "self_type" : "_ZTIPN7android6ThreadE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12220,7 +11751,6 @@
    "linker_set_key" : "_ZTIPN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "name" : "android::Vector<android::sysprop_change_callback_info> *",
    "referenced_type" : "_ZTIN7android6VectorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIPN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -12229,7 +11759,6 @@
    "linker_set_key" : "_ZTIPN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::Vector<android::Looper::MessageEnvelope> *",
    "referenced_type" : "_ZTIN7android6VectorINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIPN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -12238,7 +11767,6 @@
    "linker_set_key" : "_ZTIPN7android6VectorINS_6Looper8ResponseEEE",
    "name" : "android::Vector<android::Looper::Response> *",
    "referenced_type" : "_ZTIN7android6VectorINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIPN7android6VectorINS_6Looper8ResponseEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -12247,7 +11775,6 @@
    "linker_set_key" : "_ZTIPN7android6VectorINS_7String8EEE",
    "name" : "android::Vector<android::String8> *",
    "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE",
-   "self_type" : "_ZTIPN7android6VectorINS_7String8EEE",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/Vector.h"
   },
@@ -12256,7 +11783,6 @@
    "linker_set_key" : "_ZTIPN7android7FileMapE",
    "name" : "android::FileMap *",
    "referenced_type" : "_ZTIN7android7FileMapE",
-   "self_type" : "_ZTIPN7android7FileMapE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -12265,7 +11791,6 @@
    "linker_set_key" : "_ZTIPN7android7MessageE",
    "name" : "android::Message *",
    "referenced_type" : "_ZTIN7android7MessageE",
-   "self_type" : "_ZTIPN7android7MessageE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -12274,7 +11799,6 @@
    "linker_set_key" : "_ZTIPN7android7PrinterE",
    "name" : "android::Printer *",
    "referenced_type" : "_ZTIN7android7PrinterE",
-   "self_type" : "_ZTIPN7android7PrinterE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -12283,7 +11807,6 @@
    "linker_set_key" : "_ZTIPN7android7RefBase12weakref_implE",
    "name" : "android::RefBase::weakref_impl *",
    "referenced_type" : "_ZTIN7android7RefBase12weakref_implE",
-   "self_type" : "_ZTIPN7android7RefBase12weakref_implE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12292,7 +11815,6 @@
    "linker_set_key" : "_ZTIPN7android7RefBase12weakref_typeE",
    "name" : "android::RefBase::weakref_type *",
    "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE",
-   "self_type" : "_ZTIPN7android7RefBase12weakref_typeE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12300,8 +11822,8 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIPN7android7RefBase12weakref_typeE",
    "name" : "android::RefBase::weakref_type *",
-   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -12310,7 +11832,6 @@
    "linker_set_key" : "_ZTIPN7android7RefBaseE",
    "name" : "android::RefBase *",
    "referenced_type" : "_ZTIN7android7RefBaseE",
-   "self_type" : "_ZTIPN7android7RefBaseE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12318,8 +11839,8 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIPN7android7RefBaseE",
    "name" : "android::RefBase *",
-   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -12328,7 +11849,6 @@
    "linker_set_key" : "_ZTIPN7android7String8E",
    "name" : "android::String8 *",
    "referenced_type" : "_ZTIN7android7String8E",
-   "self_type" : "_ZTIPN7android7String8E",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -12336,8 +11856,8 @@
    "alignment" : 4,
    "linker_set_key" : "_ZTIPN7android7String8E",
    "name" : "android::String8 *",
-   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIPN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -12346,7 +11866,6 @@
    "linker_set_key" : "_ZTIPN7android8String1610StaticDataILj1EEE",
    "name" : "android::String16::StaticData<1> *",
    "referenced_type" : "_ZTIN7android8String1610StaticDataILj1EEE",
-   "self_type" : "_ZTIPN7android8String1610StaticDataILj1EEE",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -12355,7 +11874,6 @@
    "linker_set_key" : "_ZTIPN7android8String16E",
    "name" : "android::String16 *",
    "referenced_type" : "_ZTIN7android8String16E",
-   "self_type" : "_ZTIPN7android8String16E",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -12364,7 +11882,6 @@
    "linker_set_key" : "_ZTIPN7android9ConditionE",
    "name" : "android::Condition *",
    "referenced_type" : "_ZTIN7android9ConditionE",
-   "self_type" : "_ZTIPN7android9ConditionE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Condition.h"
   },
@@ -12373,7 +11890,6 @@
    "linker_set_key" : "_ZTIPN7android9FdPrinterE",
    "name" : "android::FdPrinter *",
    "referenced_type" : "_ZTIN7android9FdPrinterE",
-   "self_type" : "_ZTIPN7android9FdPrinterE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Printer.h"
   },
@@ -12382,7 +11898,6 @@
    "linker_set_key" : "_ZTIPN7android9StopWatchE",
    "name" : "android::StopWatch *",
    "referenced_type" : "_ZTIN7android9StopWatchE",
-   "self_type" : "_ZTIPN7android9StopWatchE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StopWatch.h"
   },
@@ -12391,7 +11906,6 @@
    "linker_set_key" : "_ZTIPN7android9TokenizerE",
    "name" : "android::Tokenizer *",
    "referenced_type" : "_ZTIN7android9TokenizerE",
-   "self_type" : "_ZTIPN7android9TokenizerE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Tokenizer.h"
   },
@@ -12400,7 +11914,6 @@
    "linker_set_key" : "_ZTIPPN7android9TokenizerE",
    "name" : "android::Tokenizer **",
    "referenced_type" : "_ZTIPN7android9TokenizerE",
-   "self_type" : "_ZTIPPN7android9TokenizerE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Tokenizer.h"
   },
@@ -12409,7 +11922,6 @@
    "linker_set_key" : "_ZTIPPv",
    "name" : "void **",
    "referenced_type" : "_ZTIPv",
-   "self_type" : "_ZTIPPv",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/AndroidThreads.h"
   },
@@ -12418,7 +11930,6 @@
    "linker_set_key" : "_ZTIPc",
    "name" : "char *",
    "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIPc",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -12427,7 +11938,6 @@
    "linker_set_key" : "_ZTIPh",
    "name" : "unsigned char *",
    "referenced_type" : "_ZTIh",
-   "self_type" : "_ZTIPh",
    "size" : 4,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -12436,7 +11946,6 @@
    "linker_set_key" : "_ZTIPi",
    "name" : "int *",
    "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIPi",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -12445,7 +11954,6 @@
    "linker_set_key" : "_ZTIPj",
    "name" : "unsigned int *",
    "referenced_type" : "_ZTIj",
-   "self_type" : "_ZTIPj",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/Unicode.h"
   },
@@ -12454,7 +11962,6 @@
    "linker_set_key" : "_ZTIPv",
    "name" : "void *",
    "referenced_type" : "_ZTIv",
-   "self_type" : "_ZTIPv",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   }
@@ -12467,7 +11974,6 @@
    "linker_set_key" : "_ZTIA1_KDs",
    "name" : "const char16_t[1]",
    "referenced_type" : "_ZTIA1_Ds",
-   "self_type" : "_ZTIA1_KDs",
    "size" : 2,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -12477,7 +11983,6 @@
    "linker_set_key" : "_ZTIK13native_handle",
    "name" : "const native_handle",
    "referenced_type" : "_ZTI13native_handle",
-   "self_type" : "_ZTIK13native_handle",
    "size" : 12,
    "source_file" : "system/core/libutils/include/utils/NativeHandle.h"
   },
@@ -12487,7 +11992,6 @@
    "linker_set_key" : "_ZTIK7log_msg",
    "name" : "const log_msg",
    "referenced_type" : "_ZTI7log_msg",
-   "self_type" : "_ZTIK7log_msg",
    "size" : 5124,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   },
@@ -12497,7 +12001,6 @@
    "linker_set_key" : "_ZTIKDi",
    "name" : "const char32_t",
    "referenced_type" : "_ZTIDi",
-   "self_type" : "_ZTIKDi",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -12507,7 +12010,6 @@
    "linker_set_key" : "_ZTIKDs",
    "name" : "const char16_t",
    "referenced_type" : "_ZTIDs",
-   "self_type" : "_ZTIKDs",
    "size" : 2,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -12516,8 +12018,8 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android10VectorImplE",
    "name" : "const android::VectorImpl",
-   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIKN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 20,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -12527,7 +12029,6 @@
    "linker_set_key" : "_ZTIKN7android10VectorImplE",
    "name" : "const android::VectorImpl",
    "referenced_type" : "_ZTIN7android10VectorImplE",
-   "self_type" : "_ZTIKN7android10VectorImplE",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h"
   },
@@ -12537,7 +12038,6 @@
    "linker_set_key" : "_ZTIKN7android12LightRefBaseINS_12NativeHandleEEE",
    "name" : "const android::LightRefBase<android::NativeHandle>",
    "referenced_type" : "_ZTIN7android12LightRefBaseINS_12NativeHandleEEE",
-   "self_type" : "_ZTIKN7android12LightRefBaseINS_12NativeHandleEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
@@ -12547,7 +12047,6 @@
    "linker_set_key" : "_ZTIKN7android12NativeHandleE",
    "name" : "const android::NativeHandle",
    "referenced_type" : "_ZTIN7android12NativeHandleE",
-   "self_type" : "_ZTIKN7android12NativeHandleE",
    "size" : 12,
    "source_file" : "system/core/libutils/include/utils/NativeHandle.h"
   },
@@ -12556,8 +12055,7 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android16ReferenceRenamerE",
    "name" : "const android::ReferenceRenamer",
-   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIKN7android16ReferenceRenamerE",
+   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -12566,8 +12064,7 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android16SortedVectorImplE",
    "name" : "const android::SortedVectorImpl",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIKN7android16SortedVectorImplE",
+   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 20,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h"
   },
@@ -12577,7 +12074,6 @@
    "linker_set_key" : "_ZTIKN7android28sysprop_change_callback_infoE",
    "name" : "const android::sysprop_change_callback_info",
    "referenced_type" : "_ZTIN7android28sysprop_change_callback_infoE",
-   "self_type" : "_ZTIKN7android28sysprop_change_callback_infoE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12587,7 +12083,6 @@
    "linker_set_key" : "_ZTIKN7android2spINS_14LooperCallbackEEE",
    "name" : "const android::sp<android::LooperCallback>",
    "referenced_type" : "_ZTIN7android2spINS_14LooperCallbackEEE",
-   "self_type" : "_ZTIKN7android2spINS_14LooperCallbackEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12597,7 +12092,6 @@
    "linker_set_key" : "_ZTIKN7android2spINS_14MessageHandlerEEE",
    "name" : "const android::sp<android::MessageHandler>",
    "referenced_type" : "_ZTIN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIKN7android2spINS_14MessageHandlerEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12607,7 +12101,6 @@
    "linker_set_key" : "_ZTIKN7android2spINS_20SimpleLooperCallbackEEE",
    "name" : "const android::sp<android::SimpleLooperCallback>",
    "referenced_type" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
-   "self_type" : "_ZTIKN7android2spINS_20SimpleLooperCallbackEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12617,7 +12110,6 @@
    "linker_set_key" : "_ZTIKN7android2spINS_6LooperEEE",
    "name" : "const android::sp<android::Looper>",
    "referenced_type" : "_ZTIN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTIKN7android2spINS_6LooperEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -12627,7 +12119,6 @@
    "linker_set_key" : "_ZTIKN7android2spINS_6ThreadEEE",
    "name" : "const android::sp<android::Thread>",
    "referenced_type" : "_ZTIN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTIKN7android2spINS_6ThreadEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12637,7 +12128,6 @@
    "linker_set_key" : "_ZTIKN7android2wpINS_14MessageHandlerEEE",
    "name" : "const android::wp<android::MessageHandler>",
    "referenced_type" : "_ZTIN7android2wpINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIKN7android2wpINS_14MessageHandlerEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12647,7 +12137,6 @@
    "linker_set_key" : "_ZTIKN7android2wpINS_6ThreadEEE",
    "name" : "const android::wp<android::Thread>",
    "referenced_type" : "_ZTIN7android2wpINS_6ThreadEEE",
-   "self_type" : "_ZTIKN7android2wpINS_6ThreadEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12657,7 +12146,6 @@
    "linker_set_key" : "_ZTIKN7android4base11borrowed_fdE",
    "name" : "const android::base::borrowed_fd",
    "referenced_type" : "_ZTIN7android4base11borrowed_fdE",
-   "self_type" : "_ZTIKN7android4base11borrowed_fdE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -12667,7 +12155,6 @@
    "linker_set_key" : "_ZTIKN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "name" : "const android::base::unique_fd_impl<android::base::DefaultCloser>",
    "referenced_type" : "_ZTIN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
-   "self_type" : "_ZTIKN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -12677,7 +12164,6 @@
    "linker_set_key" : "_ZTIKN7android6Looper15MessageEnvelopeE",
    "name" : "const android::Looper::MessageEnvelope",
    "referenced_type" : "_ZTIN7android6Looper15MessageEnvelopeE",
-   "self_type" : "_ZTIKN7android6Looper15MessageEnvelopeE",
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12687,7 +12173,6 @@
    "linker_set_key" : "_ZTIKN7android6Looper7RequestE",
    "name" : "const android::Looper::Request",
    "referenced_type" : "_ZTIN7android6Looper7RequestE",
-   "self_type" : "_ZTIKN7android6Looper7RequestE",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -12697,7 +12182,6 @@
    "linker_set_key" : "_ZTIKN7android6Looper8ResponseE",
    "name" : "const android::Looper::Response",
    "referenced_type" : "_ZTIN7android6Looper8ResponseE",
-   "self_type" : "_ZTIKN7android6Looper8ResponseE",
    "size" : 32,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12707,7 +12191,6 @@
    "linker_set_key" : "_ZTIKN7android6LooperE",
    "name" : "const android::Looper",
    "referenced_type" : "_ZTIN7android6LooperE",
-   "self_type" : "_ZTIKN7android6LooperE",
    "size" : 136,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -12717,7 +12200,6 @@
    "linker_set_key" : "_ZTIKN7android6ThreadE",
    "name" : "const android::Thread",
    "referenced_type" : "_ZTIN7android6ThreadE",
-   "self_type" : "_ZTIKN7android6ThreadE",
    "size" : 44,
    "source_file" : "system/core/libutils/include/utils/Thread.h"
   },
@@ -12727,7 +12209,6 @@
    "linker_set_key" : "_ZTIKN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "name" : "const android::Vector<android::sysprop_change_callback_info>",
    "referenced_type" : "_ZTIN7android6VectorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIKN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -12737,7 +12218,6 @@
    "linker_set_key" : "_ZTIKN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "name" : "const android::Vector<android::Looper::MessageEnvelope>",
    "referenced_type" : "_ZTIN7android6VectorINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIKN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -12747,7 +12227,6 @@
    "linker_set_key" : "_ZTIKN7android6VectorINS_6Looper8ResponseEEE",
    "name" : "const android::Vector<android::Looper::Response>",
    "referenced_type" : "_ZTIN7android6VectorINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIKN7android6VectorINS_6Looper8ResponseEEE",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/Vector.h"
   },
@@ -12757,7 +12236,6 @@
    "linker_set_key" : "_ZTIKN7android6VectorINS_7String8EEE",
    "name" : "const android::Vector<android::String8>",
    "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE",
-   "self_type" : "_ZTIKN7android6VectorINS_7String8EEE",
    "size" : 20,
    "source_file" : "system/core/libutils/binder/include/utils/Vector.h"
   },
@@ -12767,7 +12245,6 @@
    "linker_set_key" : "_ZTIKN7android7FileMapE",
    "name" : "const android::FileMap",
    "referenced_type" : "_ZTIN7android7FileMapE",
-   "self_type" : "_ZTIKN7android7FileMapE",
    "size" : 32,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -12777,7 +12254,6 @@
    "linker_set_key" : "_ZTIKN7android7MessageE",
    "name" : "const android::Message",
    "referenced_type" : "_ZTIN7android7MessageE",
-   "self_type" : "_ZTIKN7android7MessageE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -12786,8 +12262,7 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android7RefBase12weakref_typeE",
    "name" : "const android::RefBase::weakref_type",
-   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIKN7android7RefBase12weakref_typeE",
+   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -12796,8 +12271,8 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android7RefBaseE",
    "name" : "const android::RefBase",
-   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIKN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -12807,7 +12282,6 @@
    "linker_set_key" : "_ZTIKN7android7RefBaseE",
    "name" : "const android::RefBase",
    "referenced_type" : "_ZTIN7android7RefBaseE",
-   "self_type" : "_ZTIKN7android7RefBaseE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12816,8 +12290,8 @@
    "is_const" : true,
    "linker_set_key" : "_ZTIKN7android7String8E",
    "name" : "const android::String8",
-   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIKN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -12827,7 +12301,6 @@
    "linker_set_key" : "_ZTIKN7android7String8E",
    "name" : "const android::String8",
    "referenced_type" : "_ZTIN7android7String8E",
-   "self_type" : "_ZTIKN7android7String8E",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
@@ -12837,7 +12310,6 @@
    "linker_set_key" : "_ZTIKN7android8String1610StaticDataILj1EEE",
    "name" : "const android::String16::StaticData<1>",
    "referenced_type" : "_ZTIN7android8String1610StaticDataILj1EEE",
-   "self_type" : "_ZTIKN7android8String1610StaticDataILj1EEE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -12847,7 +12319,6 @@
    "linker_set_key" : "_ZTIKN7android8String16E",
    "name" : "const android::String16",
    "referenced_type" : "_ZTIN7android8String16E",
-   "self_type" : "_ZTIKN7android8String16E",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -12857,7 +12328,6 @@
    "linker_set_key" : "_ZTIKN7android9StopWatchE",
    "name" : "const android::StopWatch",
    "referenced_type" : "_ZTIN7android9StopWatchE",
-   "self_type" : "_ZTIKN7android9StopWatchE",
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/StopWatch.h"
   },
@@ -12867,27 +12337,15 @@
    "linker_set_key" : "_ZTIKN7android9TokenizerE",
    "name" : "const android::Tokenizer",
    "referenced_type" : "_ZTIN7android9TokenizerE",
-   "self_type" : "_ZTIKN7android9TokenizerE",
    "size" : 28,
    "source_file" : "system/core/libutils/include/utils/Tokenizer.h"
   },
-  {
-   "alignment" : 4,
-   "is_const" : true,
-   "linker_set_key" : "_ZTIKPKc",
-   "name" : "const char *const",
-   "referenced_type" : "_ZTIPKc",
-   "self_type" : "_ZTIKPKc",
-   "size" : 4,
-   "source_file" : "system/core/libprocessgroup/include/processgroup/processgroup.h"
-  },
   {
    "alignment" : 4,
    "is_const" : true,
    "linker_set_key" : "_ZTIKPN7android7RefBase12weakref_implE",
    "name" : "android::RefBase::weakref_impl *const",
    "referenced_type" : "_ZTIPN7android7RefBase12weakref_implE",
-   "self_type" : "_ZTIKPN7android7RefBase12weakref_implE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -12897,7 +12355,6 @@
    "linker_set_key" : "_ZTIKa",
    "name" : "const signed char",
    "referenced_type" : "_ZTIa",
-   "self_type" : "_ZTIKa",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12907,7 +12364,6 @@
    "linker_set_key" : "_ZTIKb",
    "name" : "const bool",
    "referenced_type" : "_ZTIb",
-   "self_type" : "_ZTIKb",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12917,7 +12373,6 @@
    "linker_set_key" : "_ZTIKc",
    "name" : "const char",
    "referenced_type" : "_ZTIc",
-   "self_type" : "_ZTIKc",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -12927,7 +12382,6 @@
    "linker_set_key" : "_ZTIKd",
    "name" : "const double",
    "referenced_type" : "_ZTId",
-   "self_type" : "_ZTIKd",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12937,7 +12391,6 @@
    "linker_set_key" : "_ZTIKf",
    "name" : "const float",
    "referenced_type" : "_ZTIf",
-   "self_type" : "_ZTIKf",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12947,7 +12400,6 @@
    "linker_set_key" : "_ZTIKh",
    "name" : "const unsigned char",
    "referenced_type" : "_ZTIh",
-   "self_type" : "_ZTIKh",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12957,7 +12409,6 @@
    "linker_set_key" : "_ZTIKi",
    "name" : "const int",
    "referenced_type" : "_ZTIi",
-   "self_type" : "_ZTIKi",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12967,7 +12418,6 @@
    "linker_set_key" : "_ZTIKj",
    "name" : "const unsigned int",
    "referenced_type" : "_ZTIj",
-   "self_type" : "_ZTIKj",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12977,7 +12427,6 @@
    "linker_set_key" : "_ZTIKs",
    "name" : "const short",
    "referenced_type" : "_ZTIs",
-   "self_type" : "_ZTIKs",
    "size" : 2,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12987,7 +12436,6 @@
    "linker_set_key" : "_ZTIKt",
    "name" : "const unsigned short",
    "referenced_type" : "_ZTIt",
-   "self_type" : "_ZTIKt",
    "size" : 2,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -12996,7 +12444,6 @@
    "linker_set_key" : "_ZTIKv",
    "name" : "const void",
    "referenced_type" : "_ZTIv",
-   "self_type" : "_ZTIKv",
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h"
   },
   {
@@ -13005,7 +12452,6 @@
    "linker_set_key" : "_ZTIKx",
    "name" : "const long long",
    "referenced_type" : "_ZTIx",
-   "self_type" : "_ZTIKx",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -13015,7 +12461,6 @@
    "linker_set_key" : "_ZTIKy",
    "name" : "const unsigned long long",
    "referenced_type" : "_ZTIy",
-   "self_type" : "_ZTIKy",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h"
   },
@@ -13025,7 +12470,6 @@
    "linker_set_key" : "_ZTIVb",
    "name" : "volatile bool",
    "referenced_type" : "_ZTIb",
-   "self_type" : "_ZTIVb",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/Thread.h"
   }
@@ -13078,8 +12522,6 @@
    ],
    "linker_set_key" : "_ZTI12logger_entry",
    "name" : "logger_entry",
-   "referenced_type" : "_ZTI12logger_entry",
-   "self_type" : "_ZTI12logger_entry",
    "size" : 28,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   },
@@ -13124,8 +12566,6 @@
    ],
    "linker_set_key" : "_ZTI13android_ycbcr",
    "name" : "android_ycbcr",
-   "referenced_type" : "_ZTI13android_ycbcr",
-   "self_type" : "_ZTI13android_ycbcr",
    "size" : 56,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13155,8 +12595,6 @@
    ],
    "linker_set_key" : "_ZTI13native_handle",
    "name" : "native_handle",
-   "referenced_type" : "_ZTI13native_handle",
-   "self_type" : "_ZTI13native_handle",
    "size" : 12,
    "source_file" : "system/core/libcutils/include_outside_system/cutils/native_handle.h"
   },
@@ -13176,8 +12614,6 @@
    ],
    "linker_set_key" : "_ZTI16android_xy_color",
    "name" : "android_xy_color",
-   "referenced_type" : "_ZTI16android_xy_color",
-   "self_type" : "_ZTI16android_xy_color",
    "size" : 8,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13227,8 +12663,6 @@
    ],
    "linker_set_key" : "_ZTI18android_flex_plane",
    "name" : "android_flex_plane",
-   "referenced_type" : "_ZTI18android_flex_plane",
-   "self_type" : "_ZTI18android_flex_plane",
    "size" : 32,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13253,8 +12687,6 @@
    ],
    "linker_set_key" : "_ZTI19android_flex_layout",
    "name" : "android_flex_layout",
-   "referenced_type" : "_ZTI19android_flex_layout",
-   "self_type" : "_ZTI19android_flex_layout",
    "size" : 12,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13279,8 +12711,6 @@
    ],
    "linker_set_key" : "_ZTI20android_depth_points",
    "name" : "android_depth_points",
-   "referenced_type" : "_ZTI20android_depth_points",
-   "self_type" : "_ZTI20android_depth_points",
    "size" : 36,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13325,8 +12755,6 @@
    ],
    "linker_set_key" : "_ZTI21__android_log_message",
    "name" : "__android_log_message",
-   "referenced_type" : "_ZTI21__android_log_message",
-   "self_type" : "_ZTI21__android_log_message",
    "size" : 28,
    "source_file" : "system/logging/liblog/include_vndk/android/log.h"
   },
@@ -13346,8 +12774,6 @@
    ],
    "linker_set_key" : "_ZTI25android_cta861_3_metadata",
    "name" : "android_cta861_3_metadata",
-   "referenced_type" : "_ZTI25android_cta861_3_metadata",
-   "self_type" : "_ZTI25android_cta861_3_metadata",
    "size" : 8,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13387,8 +12813,6 @@
    ],
    "linker_set_key" : "_ZTI26android_smpte2086_metadata",
    "name" : "android_smpte2086_metadata",
-   "referenced_type" : "_ZTI26android_smpte2086_metadata",
-   "self_type" : "_ZTI26android_smpte2086_metadata",
    "size" : 40,
    "source_file" : "system/core/libsystem/include/system/graphics.h"
   },
@@ -13402,8 +12826,6 @@
    ],
    "linker_set_key" : "_ZTI7log_msg",
    "name" : "log_msg",
-   "referenced_type" : "_ZTI7log_msg",
-   "self_type" : "_ZTI7log_msg",
    "size" : 5124,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   },
@@ -13423,8 +12845,6 @@
    ],
    "linker_set_key" : "_ZTI8log_time",
    "name" : "log_time",
-   "referenced_type" : "_ZTI8log_time",
-   "self_type" : "_ZTI8log_time",
    "size" : 8,
    "source_file" : "system/logging/liblog/include_vndk/log/log_time.h"
   },
@@ -13466,8 +12886,6 @@
    "linker_set_key" : "_ZTIN7android10LogPrinterE",
    "name" : "android::LogPrinter",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android10LogPrinterE",
-   "self_type" : "_ZTIN7android10LogPrinterE",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/Printer.h",
    "vtable_components" :
@@ -13527,8 +12945,6 @@
    "linker_set_key" : "_ZTIN7android10VectorImplE",
    "name" : "android::VectorImpl",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android10VectorImplE",
-   "self_type" : "_ZTIN7android10VectorImplE",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h",
    "vtable_components" :
@@ -13606,8 +13022,7 @@
    "linker_set_key" : "_ZTIN7android10VectorImplE",
    "name" : "android::VectorImpl",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 20,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h",
    "vtable_components" :
@@ -13666,8 +13081,6 @@
    "linker_set_key" : "_ZTIN7android11ScopedTraceE",
    "name" : "android::ScopedTrace",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android11ScopedTraceE",
-   "self_type" : "_ZTIN7android11ScopedTraceE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/Trace.h"
   },
@@ -13684,8 +13097,6 @@
    "linker_set_key" : "_ZTIN7android12LightRefBaseINS_12NativeHandleEEE",
    "name" : "android::LightRefBase<android::NativeHandle>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android12LightRefBaseINS_12NativeHandleEEE",
-   "self_type" : "_ZTIN7android12LightRefBaseINS_12NativeHandleEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h",
    "template_args" :
@@ -13706,8 +13117,6 @@
    "linker_set_key" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE",
    "name" : "android::LightRefBase<android::VirtualLightRefBase>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE",
-   "self_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h",
    "template_args" :
@@ -13728,13 +13137,12 @@
    "linker_set_key" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE",
    "name" : "android::LightRefBase<android::VirtualLightRefBase>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/LightRefBase.h",
    "template_args" :
    [
-    "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+    "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
    ]
   },
   {
@@ -13763,8 +13171,6 @@
    "linker_set_key" : "_ZTIN7android12NativeHandleE",
    "name" : "android::NativeHandle",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android12NativeHandleE",
-   "self_type" : "_ZTIN7android12NativeHandleE",
    "size" : 12,
    "source_file" : "system/core/libutils/include/utils/NativeHandle.h"
   },
@@ -13794,8 +13200,6 @@
    "linker_set_key" : "_ZTIN7android13PrefixPrinterE",
    "name" : "android::PrefixPrinter",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android13PrefixPrinterE",
-   "self_type" : "_ZTIN7android13PrefixPrinterE",
    "size" : 12,
    "source_file" : "system/core/libutils/include/utils/Printer.h",
    "vtable_components" :
@@ -13827,8 +13231,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android13trait_pointerINS_28sysprop_change_callback_infoEEE",
    "name" : "android::trait_pointer<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android13trait_pointerINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android13trait_pointerINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -13840,8 +13242,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android13trait_pointerINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::trait_pointer<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android13trait_pointerINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android13trait_pointerINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -13853,8 +13253,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android13trait_pointerINS_6Looper8ResponseEEE",
    "name" : "android::trait_pointer<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android13trait_pointerINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android13trait_pointerINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -13874,8 +13272,6 @@
    "linker_set_key" : "_ZTIN7android14LooperCallbackE",
    "name" : "android::LooperCallback",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android14LooperCallbackE",
-   "self_type" : "_ZTIN7android14LooperCallbackE",
    "size" : 12,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "vtable_components" :
@@ -13961,8 +13357,6 @@
    "linker_set_key" : "_ZTIN7android14MessageHandlerE",
    "name" : "android::MessageHandler",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android14MessageHandlerE",
-   "self_type" : "_ZTIN7android14MessageHandlerE",
    "size" : 12,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "vtable_components" :
@@ -14041,8 +13435,6 @@
    "linker_set_key" : "_ZTIN7android14ReferenceMoverE",
    "name" : "android::ReferenceMover",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android14ReferenceMoverE",
-   "self_type" : "_ZTIN7android14ReferenceMoverE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -14051,8 +13443,7 @@
    "linker_set_key" : "_ZTIN7android14ReferenceMoverE",
    "name" : "android::ReferenceMover",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android14ReferenceMoverE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android14ReferenceMoverE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android14ReferenceMoverE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -14076,8 +13467,6 @@
    "linker_set_key" : "_ZTIN7android14StaticString16ILj1EEE",
    "name" : "android::StaticString16<1>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android14StaticString16ILj1EEE",
-   "self_type" : "_ZTIN7android14StaticString16ILj1EEE",
    "size" : 12,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -14107,8 +13496,6 @@
    "linker_set_key" : "_ZTIN7android14String8PrinterE",
    "name" : "android::String8Printer",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android14String8PrinterE",
-   "self_type" : "_ZTIN7android14String8PrinterE",
    "size" : 12,
    "source_file" : "system/core/libutils/include/utils/Printer.h",
    "vtable_components" :
@@ -14141,8 +13528,6 @@
    "linker_set_key" : "_ZTIN7android16ReferenceRenamerE",
    "name" : "android::ReferenceRenamer",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android16ReferenceRenamerE",
-   "self_type" : "_ZTIN7android16ReferenceRenamerE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "vtable_components" :
@@ -14165,8 +13550,7 @@
    "linker_set_key" : "_ZTIN7android16ReferenceRenamerE",
    "name" : "android::ReferenceRenamer",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android16ReferenceRenamerE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
    "vtable_components" :
@@ -14195,8 +13579,6 @@
    "linker_set_key" : "_ZTIN7android16SortedVectorImplE",
    "name" : "android::SortedVectorImpl",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE",
-   "self_type" : "_ZTIN7android16SortedVectorImplE",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/VectorImpl.h",
    "vtable_components" :
@@ -14251,14 +13633,13 @@
    "base_specifiers" :
    [
     {
-     "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "linker_set_key" : "_ZTIN7android16SortedVectorImplE",
    "name" : "android::SortedVectorImpl",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android16SortedVectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 20,
    "source_file" : "system/core/libutils/binder/include/utils/VectorImpl.h",
    "vtable_components" :
@@ -14318,8 +13699,6 @@
    ],
    "linker_set_key" : "_ZTIN7android16use_trivial_moveINS_28sysprop_change_callback_infoEEE",
    "name" : "android::use_trivial_move<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android16use_trivial_moveINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android16use_trivial_moveINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14337,8 +13716,6 @@
    ],
    "linker_set_key" : "_ZTIN7android16use_trivial_moveINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::use_trivial_move<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android16use_trivial_moveINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android16use_trivial_moveINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14356,8 +13733,6 @@
    ],
    "linker_set_key" : "_ZTIN7android16use_trivial_moveINS_6Looper8ResponseEEE",
    "name" : "android::use_trivial_move<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android16use_trivial_moveINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android16use_trivial_moveINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14385,8 +13760,6 @@
    "linker_set_key" : "_ZTIN7android18WeakMessageHandlerE",
    "name" : "android::WeakMessageHandler",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android18WeakMessageHandlerE",
-   "self_type" : "_ZTIN7android18WeakMessageHandlerE",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "vtable_components" :
@@ -14463,8 +13836,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyINS_28sysprop_change_callback_infoEEE",
    "name" : "android::trait_trivial_copy<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14476,8 +13847,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::trait_trivial_copy<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14489,8 +13858,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyINS_6Looper8ResponseEEE",
    "name" : "android::trait_trivial_copy<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14502,8 +13869,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIbEE",
    "name" : "android::trait_trivial_copy<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIbEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIbEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14515,8 +13880,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIbEE",
    "name" : "android::trait_trivial_copy<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14528,8 +13892,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcEE",
    "name" : "android::trait_trivial_copy<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIcEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIcEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14541,8 +13903,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIcEE",
    "name" : "android::trait_trivial_copy<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14554,8 +13915,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdEE",
    "name" : "android::trait_trivial_copy<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIdEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14567,8 +13926,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIdEE",
    "name" : "android::trait_trivial_copy<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14580,8 +13938,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfEE",
    "name" : "android::trait_trivial_copy<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIfEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14593,8 +13949,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIfEE",
    "name" : "android::trait_trivial_copy<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14606,8 +13961,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhEE",
    "name" : "android::trait_trivial_copy<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIhEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14619,8 +13972,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIhEE",
    "name" : "android::trait_trivial_copy<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14632,8 +13984,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiEE",
    "name" : "android::trait_trivial_copy<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIiEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14645,8 +13995,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIiEE",
    "name" : "android::trait_trivial_copy<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14658,8 +14007,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjEE",
    "name" : "android::trait_trivial_copy<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIjEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14671,8 +14018,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIjEE",
    "name" : "android::trait_trivial_copy<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14684,8 +14030,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlEE",
    "name" : "android::trait_trivial_copy<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIlEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14697,8 +14041,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIlEE",
    "name" : "android::trait_trivial_copy<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14710,8 +14053,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyImEE",
    "name" : "android::trait_trivial_copy<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyImEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyImEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14723,8 +14064,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyImEE",
    "name" : "android::trait_trivial_copy<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14736,8 +14076,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsEE",
    "name" : "android::trait_trivial_copy<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIsEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14749,8 +14087,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIsEE",
    "name" : "android::trait_trivial_copy<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14762,8 +14099,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyItEE",
    "name" : "android::trait_trivial_copy<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyItEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyItEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14775,8 +14110,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyItEE",
    "name" : "android::trait_trivial_copy<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14788,8 +14122,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvEE",
    "name" : "android::trait_trivial_copy<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIvEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14801,8 +14133,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIvEE",
    "name" : "android::trait_trivial_copy<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14814,8 +14145,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxEE",
    "name" : "android::trait_trivial_copy<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIxEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIxEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14827,8 +14156,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIxEE",
    "name" : "android::trait_trivial_copy<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14840,8 +14168,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyEE",
    "name" : "android::trait_trivial_copy<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIyEE",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIyEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14853,8 +14179,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_copyIyEE",
    "name" : "android::trait_trivial_copy<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_copyIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_copyIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_copyIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14866,8 +14191,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEEE",
    "name" : "android::trait_trivial_ctor<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14879,8 +14202,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::trait_trivial_ctor<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14892,8 +14213,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorINS_6Looper8ResponseEEE",
    "name" : "android::trait_trivial_ctor<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14905,8 +14224,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbEE",
    "name" : "android::trait_trivial_ctor<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIbEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14918,8 +14235,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIbEE",
    "name" : "android::trait_trivial_ctor<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14931,8 +14247,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcEE",
    "name" : "android::trait_trivial_ctor<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIcEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14944,8 +14258,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIcEE",
    "name" : "android::trait_trivial_ctor<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14957,8 +14270,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdEE",
    "name" : "android::trait_trivial_ctor<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIdEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14970,8 +14281,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIdEE",
    "name" : "android::trait_trivial_ctor<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14983,8 +14293,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfEE",
    "name" : "android::trait_trivial_ctor<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIfEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -14996,8 +14304,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIfEE",
    "name" : "android::trait_trivial_ctor<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15009,8 +14316,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhEE",
    "name" : "android::trait_trivial_ctor<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIhEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15022,8 +14327,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIhEE",
    "name" : "android::trait_trivial_ctor<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15035,8 +14339,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiEE",
    "name" : "android::trait_trivial_ctor<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIiEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15048,8 +14350,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIiEE",
    "name" : "android::trait_trivial_ctor<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15061,8 +14362,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjEE",
    "name" : "android::trait_trivial_ctor<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIjEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15074,8 +14373,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIjEE",
    "name" : "android::trait_trivial_ctor<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15087,8 +14385,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlEE",
    "name" : "android::trait_trivial_ctor<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIlEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15100,8 +14396,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIlEE",
    "name" : "android::trait_trivial_ctor<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15113,8 +14408,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImEE",
    "name" : "android::trait_trivial_ctor<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorImEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15126,8 +14419,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorImEE",
    "name" : "android::trait_trivial_ctor<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15139,8 +14431,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsEE",
    "name" : "android::trait_trivial_ctor<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIsEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15152,8 +14442,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIsEE",
    "name" : "android::trait_trivial_ctor<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15165,8 +14454,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItEE",
    "name" : "android::trait_trivial_ctor<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorItEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15178,8 +14465,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorItEE",
    "name" : "android::trait_trivial_ctor<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15191,8 +14477,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvEE",
    "name" : "android::trait_trivial_ctor<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIvEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15204,8 +14488,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIvEE",
    "name" : "android::trait_trivial_ctor<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15217,8 +14500,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxEE",
    "name" : "android::trait_trivial_ctor<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIxEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15230,8 +14511,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIxEE",
    "name" : "android::trait_trivial_ctor<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15243,8 +14523,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyEE",
    "name" : "android::trait_trivial_ctor<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyEE",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIyEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15256,8 +14534,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_ctorIyEE",
    "name" : "android::trait_trivial_ctor<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_ctorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_ctorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_ctorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15269,8 +14546,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEEE",
    "name" : "android::trait_trivial_dtor<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15282,8 +14557,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::trait_trivial_dtor<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15295,8 +14568,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEEE",
    "name" : "android::trait_trivial_dtor<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15308,8 +14579,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbEE",
    "name" : "android::trait_trivial_dtor<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIbEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15321,8 +14590,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIbEE",
    "name" : "android::trait_trivial_dtor<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15334,8 +14602,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcEE",
    "name" : "android::trait_trivial_dtor<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIcEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15347,8 +14613,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIcEE",
    "name" : "android::trait_trivial_dtor<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15360,8 +14625,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdEE",
    "name" : "android::trait_trivial_dtor<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIdEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15373,8 +14636,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIdEE",
    "name" : "android::trait_trivial_dtor<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15386,8 +14648,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfEE",
    "name" : "android::trait_trivial_dtor<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIfEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15399,8 +14659,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIfEE",
    "name" : "android::trait_trivial_dtor<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15412,8 +14671,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhEE",
    "name" : "android::trait_trivial_dtor<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIhEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15425,8 +14682,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIhEE",
    "name" : "android::trait_trivial_dtor<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15438,8 +14694,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiEE",
    "name" : "android::trait_trivial_dtor<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIiEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15451,8 +14705,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIiEE",
    "name" : "android::trait_trivial_dtor<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15464,8 +14717,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjEE",
    "name" : "android::trait_trivial_dtor<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIjEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15477,8 +14728,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIjEE",
    "name" : "android::trait_trivial_dtor<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15490,8 +14740,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlEE",
    "name" : "android::trait_trivial_dtor<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIlEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15503,8 +14751,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIlEE",
    "name" : "android::trait_trivial_dtor<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15516,8 +14763,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImEE",
    "name" : "android::trait_trivial_dtor<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorImEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15529,8 +14774,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorImEE",
    "name" : "android::trait_trivial_dtor<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15542,8 +14786,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsEE",
    "name" : "android::trait_trivial_dtor<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIsEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15555,8 +14797,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIsEE",
    "name" : "android::trait_trivial_dtor<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15568,8 +14809,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItEE",
    "name" : "android::trait_trivial_dtor<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorItEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15581,8 +14820,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorItEE",
    "name" : "android::trait_trivial_dtor<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15594,8 +14832,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvEE",
    "name" : "android::trait_trivial_dtor<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIvEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15607,8 +14843,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIvEE",
    "name" : "android::trait_trivial_dtor<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15620,8 +14855,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxEE",
    "name" : "android::trait_trivial_dtor<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIxEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15633,8 +14866,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIxEE",
    "name" : "android::trait_trivial_dtor<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15646,8 +14878,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyEE",
    "name" : "android::trait_trivial_dtor<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyEE",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIyEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15659,8 +14889,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_dtorIyEE",
    "name" : "android::trait_trivial_dtor<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_dtorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_dtorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_dtorIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15672,8 +14901,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEEE",
    "name" : "android::trait_trivial_move<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15685,8 +14912,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::trait_trivial_move<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15698,8 +14923,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_6Looper8ResponseEEE",
    "name" : "android::trait_trivial_move<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15711,8 +14934,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE",
    "name" : "android::trait_trivial_move<android::String8>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/String8.h",
    "template_args" :
@@ -15724,21 +14945,18 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE",
    "name" : "android::trait_trivial_move<android::String8>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveINS_7String8EEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h",
    "template_args" :
    [
-    "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+    "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
    ]
   },
   {
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveINS_8String16EEE",
    "name" : "android::trait_trivial_move<android::String16>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveINS_8String16EEE",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h",
    "template_args" :
@@ -15750,8 +14968,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIbEE",
    "name" : "android::trait_trivial_move<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIbEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIbEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15763,8 +14979,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIbEE",
    "name" : "android::trait_trivial_move<bool>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIbEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15776,8 +14991,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcEE",
    "name" : "android::trait_trivial_move<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIcEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIcEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15789,8 +15002,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIcEE",
    "name" : "android::trait_trivial_move<char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIcEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15802,8 +15014,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdEE",
    "name" : "android::trait_trivial_move<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIdEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIdEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15815,8 +15025,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIdEE",
    "name" : "android::trait_trivial_move<double>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIdEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15828,8 +15037,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfEE",
    "name" : "android::trait_trivial_move<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIfEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIfEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15841,8 +15048,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIfEE",
    "name" : "android::trait_trivial_move<float>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIfEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15854,8 +15060,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhEE",
    "name" : "android::trait_trivial_move<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIhEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIhEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15867,8 +15071,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIhEE",
    "name" : "android::trait_trivial_move<unsigned char>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIhEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15880,8 +15083,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiEE",
    "name" : "android::trait_trivial_move<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIiEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIiEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15893,8 +15094,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIiEE",
    "name" : "android::trait_trivial_move<int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIiEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15906,8 +15106,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjEE",
    "name" : "android::trait_trivial_move<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIjEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIjEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15919,8 +15117,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIjEE",
    "name" : "android::trait_trivial_move<unsigned int>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIjEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15932,8 +15129,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlEE",
    "name" : "android::trait_trivial_move<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIlEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIlEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15945,8 +15140,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIlEE",
    "name" : "android::trait_trivial_move<long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIlEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15958,8 +15152,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveImEE",
    "name" : "android::trait_trivial_move<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveImEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveImEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15971,8 +15163,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveImEE",
    "name" : "android::trait_trivial_move<unsigned long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveImEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15984,8 +15175,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsEE",
    "name" : "android::trait_trivial_move<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIsEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIsEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -15997,8 +15186,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIsEE",
    "name" : "android::trait_trivial_move<short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIsEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16010,8 +15198,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveItEE",
    "name" : "android::trait_trivial_move<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveItEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveItEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16023,8 +15209,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveItEE",
    "name" : "android::trait_trivial_move<unsigned short>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveItEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16036,8 +15221,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvEE",
    "name" : "android::trait_trivial_move<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIvEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIvEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16049,8 +15232,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIvEE",
    "name" : "android::trait_trivial_move<void>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIvEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16062,8 +15244,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxEE",
    "name" : "android::trait_trivial_move<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIxEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIxEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16075,8 +15255,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIxEE",
    "name" : "android::trait_trivial_move<long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIxEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16088,8 +15267,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyEE",
    "name" : "android::trait_trivial_move<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyEE",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIyEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16101,8 +15278,7 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android18trait_trivial_moveIyEE",
    "name" : "android::trait_trivial_move<unsigned long long>",
-   "referenced_type" : "_ZTIN7android18trait_trivial_moveIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android18trait_trivial_moveIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android18trait_trivial_moveIyEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/TypeHelpers.h",
    "template_args" :
@@ -16121,8 +15297,6 @@
    "linker_set_key" : "_ZTIN7android19VirtualLightRefBaseE",
    "name" : "android::VirtualLightRefBase",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE",
-   "self_type" : "_ZTIN7android19VirtualLightRefBaseE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/LightRefBase.h",
    "vtable_components" :
@@ -16149,14 +15323,13 @@
    "base_specifiers" :
    [
     {
-     "referenced_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIN7android12LightRefBaseINS_19VirtualLightRefBaseEEE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "linker_set_key" : "_ZTIN7android19VirtualLightRefBaseE",
    "name" : "android::VirtualLightRefBase",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android19VirtualLightRefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/LightRefBase.h",
    "vtable_components" :
@@ -16198,8 +15371,6 @@
    "linker_set_key" : "_ZTIN7android20SimpleLooperCallbackE",
    "name" : "android::SimpleLooperCallback",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android20SimpleLooperCallbackE",
-   "self_type" : "_ZTIN7android20SimpleLooperCallbackE",
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "vtable_components" :
@@ -16285,8 +15456,6 @@
    "linker_set_key" : "_ZTIN7android2spINS_12NativeHandleEEE",
    "name" : "android::sp<android::NativeHandle>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2spINS_12NativeHandleEEE",
-   "self_type" : "_ZTIN7android2spINS_12NativeHandleEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h",
    "template_args" :
@@ -16307,8 +15476,6 @@
    "linker_set_key" : "_ZTIN7android2spINS_14LooperCallbackEEE",
    "name" : "android::sp<android::LooperCallback>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2spINS_14LooperCallbackEEE",
-   "self_type" : "_ZTIN7android2spINS_14LooperCallbackEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h",
    "template_args" :
@@ -16329,8 +15496,6 @@
    "linker_set_key" : "_ZTIN7android2spINS_14MessageHandlerEEE",
    "name" : "android::sp<android::MessageHandler>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIN7android2spINS_14MessageHandlerEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h",
    "template_args" :
@@ -16351,8 +15516,6 @@
    "linker_set_key" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
    "name" : "android::sp<android::SimpleLooperCallback>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
-   "self_type" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h",
    "template_args" :
@@ -16373,8 +15536,6 @@
    "linker_set_key" : "_ZTIN7android2spINS_6LooperEEE",
    "name" : "android::sp<android::Looper>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTIN7android2spINS_6LooperEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h",
    "template_args" :
@@ -16395,8 +15556,6 @@
    "linker_set_key" : "_ZTIN7android2spINS_6ThreadEEE",
    "name" : "android::sp<android::Thread>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTIN7android2spINS_6ThreadEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h",
    "template_args" :
@@ -16423,8 +15582,6 @@
    "linker_set_key" : "_ZTIN7android2wpINS_14MessageHandlerEEE",
    "name" : "android::wp<android::MessageHandler>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2wpINS_14MessageHandlerEEE",
-   "self_type" : "_ZTIN7android2wpINS_14MessageHandlerEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "template_args" :
@@ -16451,8 +15608,6 @@
    "linker_set_key" : "_ZTIN7android2wpINS_6ThreadEEE",
    "name" : "android::wp<android::Thread>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android2wpINS_6ThreadEEE",
-   "self_type" : "_ZTIN7android2wpINS_6ThreadEEE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "template_args" :
@@ -16472,8 +15627,6 @@
    ],
    "linker_set_key" : "_ZTIN7android4base11borrowed_fdE",
    "name" : "android::base::borrowed_fd",
-   "referenced_type" : "_ZTIN7android4base11borrowed_fdE",
-   "self_type" : "_ZTIN7android4base11borrowed_fdE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -16481,8 +15634,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android4base13DefaultCloserE",
    "name" : "android::base::DefaultCloser",
-   "referenced_type" : "_ZTIN7android4base13DefaultCloserE",
-   "self_type" : "_ZTIN7android4base13DefaultCloserE",
    "size" : 1,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -16499,8 +15650,6 @@
    "linker_set_key" : "_ZTIN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "name" : "android::base::unique_fd_impl<android::base::DefaultCloser>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
-   "self_type" : "_ZTIN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h",
    "template_args" :
@@ -16521,8 +15670,6 @@
    "linker_set_key" : "_ZTIN7android5Mutex8AutolockE",
    "name" : "android::Mutex::Autolock",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android5Mutex8AutolockE",
-   "self_type" : "_ZTIN7android5Mutex8AutolockE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Mutex.h"
   },
@@ -16539,8 +15686,6 @@
    "linker_set_key" : "_ZTIN7android5MutexE",
    "name" : "android::Mutex",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android5MutexE",
-   "self_type" : "_ZTIN7android5MutexE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Mutex.h"
   },
@@ -16566,8 +15711,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6Looper15MessageEnvelopeE",
    "name" : "android::Looper::MessageEnvelope",
-   "referenced_type" : "_ZTIN7android6Looper15MessageEnvelopeE",
-   "self_type" : "_ZTIN7android6Looper15MessageEnvelopeE",
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -16603,8 +15746,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6Looper7RequestE",
    "name" : "android::Looper::Request",
-   "referenced_type" : "_ZTIN7android6Looper7RequestE",
-   "self_type" : "_ZTIN7android6Looper7RequestE",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -16630,8 +15771,6 @@
    ],
    "linker_set_key" : "_ZTIN7android6Looper8ResponseE",
    "name" : "android::Looper::Response",
-   "referenced_type" : "_ZTIN7android6Looper8ResponseE",
-   "self_type" : "_ZTIN7android6Looper8ResponseE",
    "size" : 32,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -16733,8 +15872,6 @@
    "linker_set_key" : "_ZTIN7android6LooperE",
    "name" : "android::Looper",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6LooperE",
-   "self_type" : "_ZTIN7android6LooperE",
    "size" : 136,
    "source_file" : "system/core/libutils/include/utils/Looper.h",
    "vtable_components" :
@@ -16781,8 +15918,6 @@
    "linker_set_key" : "_ZTIN7android6RWLock9AutoRLockE",
    "name" : "android::RWLock::AutoRLock",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6RWLock9AutoRLockE",
-   "self_type" : "_ZTIN7android6RWLock9AutoRLockE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -16799,8 +15934,6 @@
    "linker_set_key" : "_ZTIN7android6RWLock9AutoWLockE",
    "name" : "android::RWLock::AutoWLock",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6RWLock9AutoWLockE",
-   "self_type" : "_ZTIN7android6RWLock9AutoWLockE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -16817,8 +15950,6 @@
    "linker_set_key" : "_ZTIN7android6RWLockE",
    "name" : "android::RWLock",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6RWLockE",
-   "self_type" : "_ZTIN7android6RWLockE",
    "size" : 40,
    "source_file" : "system/core/libutils/include/utils/RWLock.h"
   },
@@ -16891,8 +16022,6 @@
    "linker_set_key" : "_ZTIN7android6ThreadE",
    "name" : "android::Thread",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6ThreadE",
-   "self_type" : "_ZTIN7android6ThreadE",
    "size" : 44,
    "source_file" : "system/core/libutils/include/utils/Thread.h",
    "vtable_components" :
@@ -16987,8 +16116,6 @@
    "linker_set_key" : "_ZTIN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "name" : "android::Vector<android::sysprop_change_callback_info>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6VectorINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android6VectorINS_28sysprop_change_callback_infoEEE",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/Vector.h",
    "template_args" :
@@ -17044,8 +16171,6 @@
    "linker_set_key" : "_ZTIN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::Vector<android::Looper::MessageEnvelope>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6VectorINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android6VectorINS_6Looper15MessageEnvelopeEEE",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/Vector.h",
    "template_args" :
@@ -17101,8 +16226,6 @@
    "linker_set_key" : "_ZTIN7android6VectorINS_6Looper8ResponseEEE",
    "name" : "android::Vector<android::Looper::Response>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6VectorINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android6VectorINS_6Looper8ResponseEEE",
    "size" : 20,
    "source_file" : "system/core/libutils/include/utils/Vector.h",
    "template_args" :
@@ -17152,19 +16275,17 @@
    [
     {
      "access" : "private",
-     "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+     "referenced_type" : "_ZTIN7android10VectorImplE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
     }
    ],
    "linker_set_key" : "_ZTIN7android6VectorINS_7String8EEE",
    "name" : "android::Vector<android::String8>",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android6VectorINS_7String8EEE",
-   "self_type" : "_ZTIN7android6VectorINS_7String8EEE",
    "size" : 20,
    "source_file" : "system/core/libutils/binder/include/utils/Vector.h",
    "template_args" :
    [
-    "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump"
+    "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump"
    ],
    "vtable_components" :
    [
@@ -17207,8 +16328,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android6traitsINS_28sysprop_change_callback_infoEEE",
    "name" : "android::traits<android::sysprop_change_callback_info>",
-   "referenced_type" : "_ZTIN7android6traitsINS_28sysprop_change_callback_infoEEE",
-   "self_type" : "_ZTIN7android6traitsINS_28sysprop_change_callback_infoEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -17220,8 +16339,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android6traitsINS_6Looper15MessageEnvelopeEEE",
    "name" : "android::traits<android::Looper::MessageEnvelope>",
-   "referenced_type" : "_ZTIN7android6traitsINS_6Looper15MessageEnvelopeEEE",
-   "self_type" : "_ZTIN7android6traitsINS_6Looper15MessageEnvelopeEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -17233,8 +16350,6 @@
    "alignment" : 1,
    "linker_set_key" : "_ZTIN7android6traitsINS_6Looper8ResponseEEE",
    "name" : "android::traits<android::Looper::Response>",
-   "referenced_type" : "_ZTIN7android6traitsINS_6Looper8ResponseEEE",
-   "self_type" : "_ZTIN7android6traitsINS_6Looper8ResponseEEE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/TypeHelpers.h",
    "template_args" :
@@ -17285,8 +16400,6 @@
    "linker_set_key" : "_ZTIN7android7FileMapE",
    "name" : "android::FileMap",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7FileMapE",
-   "self_type" : "_ZTIN7android7FileMapE",
    "size" : 32,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -17301,8 +16414,6 @@
    ],
    "linker_set_key" : "_ZTIN7android7MessageE",
    "name" : "android::Message",
-   "referenced_type" : "_ZTIN7android7MessageE",
-   "self_type" : "_ZTIN7android7MessageE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Looper.h"
   },
@@ -17311,8 +16422,6 @@
    "linker_set_key" : "_ZTIN7android7PrinterE",
    "name" : "android::Printer",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7PrinterE",
-   "self_type" : "_ZTIN7android7PrinterE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Printer.h",
    "vtable_components" :
@@ -17346,8 +16455,6 @@
    "linker_set_key" : "_ZTIN7android7RefBase12weakref_typeE",
    "name" : "android::RefBase::weakref_type",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE",
-   "self_type" : "_ZTIN7android7RefBase12weakref_typeE",
    "size" : 1,
    "source_file" : "system/core/libutils/include/utils/RefBase.h"
   },
@@ -17356,8 +16463,7 @@
    "linker_set_key" : "_ZTIN7android7RefBase12weakref_typeE",
    "name" : "android::RefBase::weakref_type",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBase12weakref_typeE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 1,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h"
   },
@@ -17375,8 +16481,6 @@
    "linker_set_key" : "_ZTIN7android7RefBaseE",
    "name" : "android::RefBase",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7RefBaseE",
-   "self_type" : "_ZTIN7android7RefBaseE",
    "size" : 8,
    "source_file" : "system/core/libutils/include/utils/RefBase.h",
    "vtable_components" :
@@ -17424,8 +16528,7 @@
    "linker_set_key" : "_ZTIN7android7RefBaseE",
    "name" : "android::RefBase",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7RefBaseE#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/RefBase.h",
    "vtable_components" :
@@ -17472,8 +16575,6 @@
    "linker_set_key" : "_ZTIN7android7String8E",
    "name" : "android::String8",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7String8E",
-   "self_type" : "_ZTIN7android7String8E",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/String8.h"
   },
@@ -17490,8 +16591,7 @@
    "linker_set_key" : "_ZTIN7android7String8E",
    "name" : "android::String8",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
-   "self_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor.VanillaIceCream_arm_armv8-a_static_afdo-libutils/e560d7b19ebf7276b3e850d3d346dec8/obj/system/core/libutils/binder/RefBase.sdump",
+   "self_type" : "_ZTIN7android7String8E#ODR:out/soong/.intermediates/system/core/libutils/binder/libutils_binder/android_vendor_arm_armv8-a_cortex-a53_static_afdo-libutils/obj/system/core/libutils/binder/RefBase.sdump",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String8.h"
   },
@@ -17511,8 +16611,6 @@
    ],
    "linker_set_key" : "_ZTIN7android8String1610StaticDataILj1EEE",
    "name" : "android::String16::StaticData<1>",
-   "referenced_type" : "_ZTIN7android8String1610StaticDataILj1EEE",
-   "self_type" : "_ZTIN7android8String1610StaticDataILj1EEE",
    "size" : 8,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -17529,8 +16627,6 @@
    "linker_set_key" : "_ZTIN7android8String16E",
    "name" : "android::String16",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android8String16E",
-   "self_type" : "_ZTIN7android8String16E",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   },
@@ -17547,8 +16643,6 @@
    "linker_set_key" : "_ZTIN7android9ConditionE",
    "name" : "android::Condition",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android9ConditionE",
-   "self_type" : "_ZTIN7android9ConditionE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/Condition.h"
   },
@@ -17590,8 +16684,6 @@
    "linker_set_key" : "_ZTIN7android9FdPrinterE",
    "name" : "android::FdPrinter",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android9FdPrinterE",
-   "self_type" : "_ZTIN7android9FdPrinterE",
    "size" : 36,
    "source_file" : "system/core/libutils/include/utils/Printer.h",
    "vtable_components" :
@@ -17644,8 +16736,6 @@
    "linker_set_key" : "_ZTIN7android9StopWatchE",
    "name" : "android::StopWatch",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android9StopWatchE",
-   "self_type" : "_ZTIN7android9StopWatchE",
    "size" : 16,
    "source_file" : "system/core/libutils/include/utils/StopWatch.h"
   },
@@ -17698,8 +16788,6 @@
    "linker_set_key" : "_ZTIN7android9TokenizerE",
    "name" : "android::Tokenizer",
    "record_kind" : "class",
-   "referenced_type" : "_ZTIN7android9TokenizerE",
-   "self_type" : "_ZTIN7android9TokenizerE",
    "size" : 28,
    "source_file" : "system/core/libutils/include/utils/Tokenizer.h"
   },
@@ -17720,8 +16808,6 @@
    "linker_set_key" : "_ZTIN7log_msgUt_E",
    "name" : "log_msg::(anonymous)",
    "record_kind" : "union",
-   "referenced_type" : "_ZTIN7log_msgUt_E",
-   "self_type" : "_ZTIN7log_msgUt_E",
    "size" : 5124,
    "source_file" : "system/logging/liblog/include_vndk/log/log_read.h"
   }
@@ -17733,7 +16819,6 @@
    "linker_set_key" : "_ZTION7android2spINS_12NativeHandleEEE",
    "name" : "android::sp<android::NativeHandle> &&",
    "referenced_type" : "_ZTIN7android2spINS_12NativeHandleEEE",
-   "self_type" : "_ZTION7android2spINS_12NativeHandleEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -17742,7 +16827,6 @@
    "linker_set_key" : "_ZTION7android2spINS_14MessageHandlerEEE",
    "name" : "android::sp<android::MessageHandler> &&",
    "referenced_type" : "_ZTIN7android2spINS_14MessageHandlerEEE",
-   "self_type" : "_ZTION7android2spINS_14MessageHandlerEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -17751,7 +16835,6 @@
    "linker_set_key" : "_ZTION7android2spINS_20SimpleLooperCallbackEEE",
    "name" : "android::sp<android::SimpleLooperCallback> &&",
    "referenced_type" : "_ZTIN7android2spINS_20SimpleLooperCallbackEEE",
-   "self_type" : "_ZTION7android2spINS_20SimpleLooperCallbackEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -17760,7 +16843,6 @@
    "linker_set_key" : "_ZTION7android2spINS_6LooperEEE",
    "name" : "android::sp<android::Looper> &&",
    "referenced_type" : "_ZTIN7android2spINS_6LooperEEE",
-   "self_type" : "_ZTION7android2spINS_6LooperEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -17769,7 +16851,6 @@
    "linker_set_key" : "_ZTION7android2spINS_6ThreadEEE",
    "name" : "android::sp<android::Thread> &&",
    "referenced_type" : "_ZTIN7android2spINS_6ThreadEEE",
-   "self_type" : "_ZTION7android2spINS_6ThreadEEE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/StrongPointer.h"
   },
@@ -17778,7 +16859,6 @@
    "linker_set_key" : "_ZTION7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "name" : "android::base::unique_fd_impl<android::base::DefaultCloser> &&",
    "referenced_type" : "_ZTIN7android4base14unique_fd_implINS0_13DefaultCloserEEE",
-   "self_type" : "_ZTION7android4base14unique_fd_implINS0_13DefaultCloserEEE",
    "size" : 4,
    "source_file" : "system/libbase/include/android-base/unique_fd.h"
   },
@@ -17787,7 +16867,6 @@
    "linker_set_key" : "_ZTION7android7FileMapE",
    "name" : "android::FileMap &&",
    "referenced_type" : "_ZTIN7android7FileMapE",
-   "self_type" : "_ZTION7android7FileMapE",
    "size" : 4,
    "source_file" : "system/core/libutils/include/utils/FileMap.h"
   },
@@ -17796,7 +16875,6 @@
    "linker_set_key" : "_ZTION7android8String16E",
    "name" : "android::String16 &&",
    "referenced_type" : "_ZTIN7android8String16E",
-   "self_type" : "_ZTION7android8String16E",
    "size" : 4,
    "source_file" : "system/core/libutils/binder/include/utils/String16.h"
   }
diff --git a/libutils/include/utils/Looper.h b/libutils/include/utils/Looper.h
index a02280b13b4b..eea348e3798f 100644
--- a/libutils/include/utils/Looper.h
+++ b/libutils/include/utils/Looper.h
@@ -322,6 +322,12 @@ class Looper : public RefBase {
     int addFd(int fd, int ident, int events, Looper_callbackFunc callback, void* data);
     int addFd(int fd, int ident, int events, const sp<LooperCallback>& callback, void* data);
 
+    /**
+     * May be useful for testing, instead of executing a looper on another thread for code expecting
+     * a looper, you can call callbacks directly.
+     */
+    bool getFdStateDebug(int fd, int* ident, int* events, sp<LooperCallback>* cb, void** data);
+
     /**
      * Removes a previously added file descriptor from the looper.
      *

From b5d9d909c57528b903effca220e0ad80cff69a9d Mon Sep 17 00:00:00 2001
From: Shengsong Tan <sstan@google.com>
Date: Wed, 18 Sep 2024 02:11:43 +0000
Subject: [PATCH 1113/1487] Remove usage of base/string/* in libfs_avb

As part of the effort to uprev libchrome in Android, we are
removing Android dependencies to libchrome utility functions
that are not strictly required.

This CL remove the usage of base/string/* and replace by
android-base/string*

Bug: 360917504
Change-Id: I89e7bdd66bdf8f565f6b2084a70335616a644069
Test: atest libfs_avb_internal_test
---
 fs_mgr/libfs_avb/tests/avb_util_test.cpp    | 6 +++---
 fs_mgr/libfs_avb/tests/basic_test.cpp       | 1 -
 fs_mgr/libfs_avb/tests/fs_avb_test.cpp      | 4 ++--
 fs_mgr/libfs_avb/tests/fs_avb_test_util.cpp | 9 ++++-----
 fs_mgr/libfs_avb/tests/fs_avb_test_util.h   | 4 ++--
 5 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/fs_mgr/libfs_avb/tests/avb_util_test.cpp b/fs_mgr/libfs_avb/tests/avb_util_test.cpp
index ee83cda38d79..5dc26ac25dd1 100644
--- a/fs_mgr/libfs_avb/tests/avb_util_test.cpp
+++ b/fs_mgr/libfs_avb/tests/avb_util_test.cpp
@@ -16,10 +16,10 @@
 
 #include <endian.h>
 
+#include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 #include <base/files/file_util.h>
 #include <base/rand_util.h>
-#include <base/strings/string_util.h>
 #include <libavb/libavb.h>
 
 #include "avb_util.h"
@@ -70,7 +70,7 @@ void AvbUtilTest::SetVBMetaFlags(const base::FilePath& image_path, uint32_t flag
 
     std::string image_file_name = image_path.RemoveExtension().BaseName().value();
     bool is_vbmeta_partition =
-        base::StartsWith(image_file_name, "vbmeta", base::CompareCase::INSENSITIVE_ASCII);
+        android::base::StartsWithIgnoreCase(image_file_name, "vbmeta");
 
     android::base::unique_fd fd(open(image_path.value().c_str(), O_RDWR | O_CLOEXEC));
     EXPECT_TRUE(fd > 0);
@@ -603,7 +603,7 @@ bool AvbUtilTest::CompareVBMeta(const base::FilePath& avb_image_path,
     std::string image_file_name = avb_image_path.RemoveExtension().BaseName().value();
 
     base::FilePath extracted_vbmeta_path;
-    if (base::StartsWith(image_file_name, "vbmeta", base::CompareCase::INSENSITIVE_ASCII)) {
+    if (android::base::StartsWithIgnoreCase(image_file_name, "vbmeta")) {
         extracted_vbmeta_path = avb_image_path;  // no need to extract if it's a vbmeta image.
     } else {
         extracted_vbmeta_path = ExtractVBMetaImage(avb_image_path, image_file_name + "-vbmeta.img");
diff --git a/fs_mgr/libfs_avb/tests/basic_test.cpp b/fs_mgr/libfs_avb/tests/basic_test.cpp
index d49affb424d7..e0d465e17213 100644
--- a/fs_mgr/libfs_avb/tests/basic_test.cpp
+++ b/fs_mgr/libfs_avb/tests/basic_test.cpp
@@ -20,7 +20,6 @@
 
 #include <android-base/file.h>
 #include <base/files/file_util.h>
-#include <base/strings/string_util.h>
 
 namespace fs_avb_host_test {
 
diff --git a/fs_mgr/libfs_avb/tests/fs_avb_test.cpp b/fs_mgr/libfs_avb/tests/fs_avb_test.cpp
index 2c819a929468..5f153f507226 100644
--- a/fs_mgr/libfs_avb/tests/fs_avb_test.cpp
+++ b/fs_mgr/libfs_avb/tests/fs_avb_test.cpp
@@ -18,8 +18,8 @@
 #include <stdlib.h>
 
 #include <android-base/file.h>
+#include <android-base/strings.h>
 #include <base/files/file_util.h>
-#include <base/strings/string_util.h>
 #include <fs_avb/fs_avb.h>
 #include <libavb/libavb.h>
 
@@ -49,7 +49,7 @@ void PublicFsAvbTest::ModifyVBMetaHeaderFlags(const base::FilePath& vbmeta_image
 
     // Only support modifying the flags in vbmeta*.img.
     std::string image_file_name = vbmeta_image_path.RemoveExtension().BaseName().value();
-    ASSERT_TRUE(base::StartsWith(image_file_name, "vbmeta", base::CompareCase::INSENSITIVE_ASCII));
+    ASSERT_TRUE(android::base::StartsWithIgnoreCase(image_file_name, "vbmeta"));
 
     android::base::unique_fd fd(open(vbmeta_image_path.value().c_str(), O_RDWR | O_CLOEXEC));
     EXPECT_TRUE(fd > 0);
diff --git a/fs_mgr/libfs_avb/tests/fs_avb_test_util.cpp b/fs_mgr/libfs_avb/tests/fs_avb_test_util.cpp
index 1c95cf0fe56d..28fdbc2860fa 100644
--- a/fs_mgr/libfs_avb/tests/fs_avb_test_util.cpp
+++ b/fs_mgr/libfs_avb/tests/fs_avb_test_util.cpp
@@ -19,8 +19,9 @@
 #include <stdlib.h>
 
 #include <android-base/file.h>
+#include <android-base/strings.h>
+#include <android-base/stringprintf.h>
 #include <base/files/file_util.h>
-#include <base/strings/string_util.h>
 
 namespace fs_avb_host_test {
 
@@ -64,9 +65,7 @@ std::string BaseFsAvbTest::CalcVBMetaDigest(const std::string& file_name,
     std::string vbmeta_digest_data;
     EXPECT_TRUE(base::ReadFileToString(vbmeta_digest_path, &vbmeta_digest_data));
     // Returns the trimmed digest.
-    std::string trimmed_digest_data;
-    base::TrimString(vbmeta_digest_data, " \t\n", &trimmed_digest_data);
-    return trimmed_digest_data;
+    return android::base::Trim(vbmeta_digest_data);
 }
 
 base::FilePath BaseFsAvbTest::GenerateVBMetaImage(
@@ -91,7 +90,7 @@ base::FilePath BaseFsAvbTest::GenerateVBMetaImage(
     // --chain_partitions
     std::string chain_partition_options;
     for (const auto& partition : chain_partitions) {
-        chain_partition_options += base::StringPrintf(
+        chain_partition_options += android::base::StringPrintf(
                 " --chain_partition %s:%u:%s", partition.partition_name.c_str(),
                 partition.rollback_index_location, partition.key_blob_path.value().c_str());
     }
diff --git a/fs_mgr/libfs_avb/tests/fs_avb_test_util.h b/fs_mgr/libfs_avb/tests/fs_avb_test_util.h
index ab1980bb92ef..fbda0e16bd7e 100644
--- a/fs_mgr/libfs_avb/tests/fs_avb_test_util.h
+++ b/fs_mgr/libfs_avb/tests/fs_avb_test_util.h
@@ -26,9 +26,9 @@
 #include <string>
 #include <vector>
 
+#include <android-base/stringprintf.h>
 #include <android-base/unique_fd.h>
 #include <base/files/file_path.h>
-#include <base/strings/stringprintf.h>
 #include <fs_avb/types.h>
 #include <gtest/gtest.h>
 
@@ -37,7 +37,7 @@
 // the command exits normally with exit status |expected_exit_status|.
 #define EXPECT_COMMAND(expected_exit_status, command_format, ...)                   \
     do {                                                                            \
-        int rc = system(base::StringPrintf(command_format, ##__VA_ARGS__).c_str()); \
+        int rc = system(android::base::StringPrintf(command_format, ##__VA_ARGS__).c_str()); \
         EXPECT_TRUE(WIFEXITED(rc));                                                 \
         EXPECT_EQ(WEXITSTATUS(rc), expected_exit_status);                           \
     } while (0);

From 72b0186a38816b66d8a9a450a8c12d71d38a7870 Mon Sep 17 00:00:00 2001
From: Jerry Chang <chenghsiuchang@google.com>
Date: Thu, 11 Jul 2024 02:05:43 +0000
Subject: [PATCH 1114/1487] Add input event profile to mitigate input latency
 of input threads

Bug: 347122505
Test: manual dump Perfetto

Change-Id: I224fa31a7358fcd32dfb1c3fa9dec35101e97163
---
 libprocessgroup/profiles/task_profiles.json | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 1fc66ba10a64..f45391173382 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -689,6 +689,10 @@
     {
       "Name": "OtaProfiles",
       "Profiles": [ "ServiceCapacityLow", "LowIoPriority", "HighEnergySaving" ]
+    },
+    {
+      "Name": "InputPolicy",
+      "Profiles": [ "MaxPerformance", "ProcessCapacityMax", "TimerSlackNormal" ]
     }
   ]
 }

From f3f3845b444608e982015c95ae50c8de3aad3820 Mon Sep 17 00:00:00 2001
From: Snehal <snehalreddy@google.com>
Date: Fri, 19 Jul 2024 13:13:19 +0000
Subject: [PATCH 1115/1487] Update struct to include far and elr on the NS side

Bug: 354119614

Change-Id: I88a5f08ead9a536e12bc4a3e8d701e01aa8b8f29
---
 trusty/metrics/include/trusty/metrics/tipc.h | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/trusty/metrics/include/trusty/metrics/tipc.h b/trusty/metrics/include/trusty/metrics/tipc.h
index b4428d576def..4c4d37df1680 100644
--- a/trusty/metrics/include/trusty/metrics/tipc.h
+++ b/trusty/metrics/include/trusty/metrics/tipc.h
@@ -43,6 +43,8 @@
 
 #define UUID_STR_SIZE (37)
 
+#define HASH_SIZE_BYTES 64
+
 /**
  * enum metrics_cmd - command identifiers for metrics interface
  * @METRICS_CMD_RESP_BIT:             message is a response
@@ -112,10 +114,22 @@ struct metrics_report_exit_req {
  *          "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
  * @crash_reason: architecture-specific code representing the reason for the
  *                crash
+ * @far: Fault Address Register corresponding to the crash. It is set to 0 and
+ *       not always revealed
+ * @far_hash: Fault Address Register obfuscated, always revealed
+ * @elr: Exception Link Register corresponding to the crash. It is set to 0 and
+ *       not always revealed
+ * @elr_hash: Exception Link Register obfuscated, always revealed
+ * @is_hash: Boolean value indicating whether far and elr have been ob
  */
 struct metrics_report_crash_req {
     char app_id[UUID_STR_SIZE];
     uint32_t crash_reason;
+    uint64_t far;
+    uint8_t far_hash[HASH_SIZE_BYTES];
+    uint64_t elr;
+    uint8_t elr_hash[HASH_SIZE_BYTES];
+    bool is_hash;
 } __attribute__((__packed__));
 
 enum TrustyStorageErrorType {

From cfdfb32d13d7ab3d9793bddf2e055f538dd92ee7 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Thu, 19 Sep 2024 02:02:45 +0000
Subject: [PATCH 1116/1487] Remove define of SA_EXPOSE_TAGBITS.

This is in the uapi headers now.

Test: Builds and treehugger.
Change-Id: I0dcebeec722ae2835a1054ee8b39329cd06799d4
---
 debuggerd/handler/debuggerd_handler.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index 42f0aa0d96da..ddc3244f19f8 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -838,7 +838,6 @@ void debuggerd_init(debuggerd_callbacks_t* callbacks) {
   // Use the alternate signal stack if available so we can catch stack overflows.
   action.sa_flags |= SA_ONSTACK;
 
-#define SA_EXPOSE_TAGBITS 0x00000800
   // Request that the kernel set tag bits in the fault address. This is necessary for diagnosing MTE
   // faults.
   action.sa_flags |= SA_EXPOSE_TAGBITS;

From 10120f1db2f127f756777f85cb107085da7118e8 Mon Sep 17 00:00:00 2001
From: Nelson Li <nelsonli@google.com>
Date: Thu, 19 Sep 2024 07:19:25 +0000
Subject: [PATCH 1117/1487] Move the `dist` target of `mke2fs` to
 `build/core/tasks`

Because `mke2fs`, `make_f2fs`, and `make_f2fs_casefold` have
`recovery_available` set to true, Soong forcibly adds a new variation
with a `_recovery` suffix to the existing variations. If this is
directly added to the `dist` of the corresponding module, it will cause
duplication of the `android_recovery_<arch>/meta_lic` and
`android_<arch>/meta_lic` files.

Therefore, it is temporarily moved to `build/core/tasks`. Once the
issues are resolved, they will be moved to the corresponding modules.

Bug: 349741178
Test: m sdk dist
Change-Id: Id003f6aed85c909aeb36606691cc4daf10c9c1d4
---
 fastboot/Android.mk | 25 -------------------------
 1 file changed, 25 deletions(-)
 delete mode 100644 fastboot/Android.mk

diff --git a/fastboot/Android.mk b/fastboot/Android.mk
deleted file mode 100644
index cde0cb28e24f..000000000000
--- a/fastboot/Android.mk
+++ /dev/null
@@ -1,25 +0,0 @@
-# Copyright (C) 2007 Google Inc.
-#
-# 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.
-
-LOCAL_PATH:= $(call my-dir)
-
-#
-# Package fastboot-related executables.
-#
-
-my_dist_files := $(HOST_OUT_EXECUTABLES)/mke2fs
-my_dist_files += $(HOST_OUT_EXECUTABLES)/make_f2fs
-my_dist_files += $(HOST_OUT_EXECUTABLES)/make_f2fs_casefold
-$(call dist-for-goals,dist_files sdk,$(my_dist_files))
-my_dist_files :=

From 2ea6ecf71d74ea1c7acf4e24f349113ec6cdba68 Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Thu, 19 Sep 2024 07:48:33 +0000
Subject: [PATCH 1118/1487] trusty: keymint: rename trusty_ipc_dev property

matching the naming convention for a system service property

Bug: 309007107
Test: launch_cvd --noresume --console=true \
      --extra_kernel_cmdline='androidboot.selinux=permissive' \
      --secure_hals=guest_keymint_trusty_insecure
Change-Id: I7c31f36dcac49d60469de44ce75c9b46a333786e
---
 ...security.keymint-service.rust.trusty.system.nonsecure.rc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
index 318c13b45b18..2799188c4408 100644
--- a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
+++ b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
@@ -1,6 +1,6 @@
 service system.keymint.rust-trusty.nonsecure \
   /system_ext/bin/hw/android.hardware.security.keymint-service.rust.trusty.system.nonsecure \
-  --dev ${ro.hardware.trusty_ipc_dev.keymint:-/dev/trusty-ipc-dev0}
+  --dev ${system.keymint.trusty_ipc_dev:-/dev/trusty-ipc-dev0}
     disabled
     user nobody
     group drmrpc
@@ -12,6 +12,6 @@ service system.keymint.rust-trusty.nonsecure \
 # TODO(b/357821690): Start the KeyMint HALs when the KeyMint VM is ready once the Trusty VM
 # has a mechanism to notify the host.
 on late-fs && property:ro.hardware.security.keymint.trusty.system=1 && \
-   property:ro.hardware.trusty_vm_cid=*
-    setprop ro.hardware.trusty_ipc_dev.keymint VSOCK:${ro.hardware.trusty_vm_cid}:1
+   property:trusty_vm_system.vm_cid=*
+    setprop system.keymint.trusty_ipc_dev VSOCK:${trusty_vm_system.vm_cid}:1
     start system.keymint.rust-trusty.nonsecure

From ad5948a81070df52aad6e90abc4aafa527e71a31 Mon Sep 17 00:00:00 2001
From: Shengsong Tan <sstan@google.com>
Date: Fri, 20 Sep 2024 04:49:35 +0000
Subject: [PATCH 1119/1487] Replace base::RandInt with
 std::uniform_int_distribution

As part of the effort to uprev libchrome in Android, we are
removing Android dependencies to libchrome utility functions
that are not strictly required.
This CL remove the usage of base::RandInt and replace by std cpp

Bug: 360917504
Change-Id: I83ea0f00ca07074f8c6c9a69db343a65cc8deb27
Test: atest libfs_avb_internal_test
---
 fs_mgr/libfs_avb/tests/avb_util_test.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libfs_avb/tests/avb_util_test.cpp b/fs_mgr/libfs_avb/tests/avb_util_test.cpp
index 5dc26ac25dd1..85eeeb075fc0 100644
--- a/fs_mgr/libfs_avb/tests/avb_util_test.cpp
+++ b/fs_mgr/libfs_avb/tests/avb_util_test.cpp
@@ -16,10 +16,11 @@
 
 #include <endian.h>
 
+#include <random>
+
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 #include <base/files/file_util.h>
-#include <base/rand_util.h>
 #include <libavb/libavb.h>
 
 #include "avb_util.h"
@@ -727,7 +728,10 @@ void AvbUtilTest::ModifyFile(const base::FilePath& file_path, size_t offset, ssi
 
     // Introduces a new modification.
     if (length > 0) {
-        int modify_location = base::RandInt(offset, offset + length - 1);
+        // mersenne_twister_engine seeded with the default seed source.
+        static std::mt19937 gen(std::random_device{}());
+        std::uniform_int_distribution<> rand_distribution(offset, offset + length - 1);
+        int modify_location = rand_distribution(gen);
         file_content[modify_location] ^= 0x80;
         last_file_path = file_path.value();
         last_modified_location = modify_location;

From 34083b7151101cd2ed0e865eb4e40a54fd2f1131 Mon Sep 17 00:00:00 2001
From: Andrew Walbran <qwandor@google.com>
Date: Fri, 20 Sep 2024 15:20:41 +0100
Subject: [PATCH 1120/1487] Use std::sync::LazyLock rather than once_cell.

This was recently stabilised in Rust 1.80.

Test: Treehugger
Change-Id: I33a16bb1ad6c868c5d32ab72d08ce4e7f910300f
---
 libstats/pull_rust/Android.bp    | 1 -
 libstats/pull_rust/stats_pull.rs | 7 +++----
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/libstats/pull_rust/Android.bp b/libstats/pull_rust/Android.bp
index 69020267dffe..2a8939edbc60 100644
--- a/libstats/pull_rust/Android.bp
+++ b/libstats/pull_rust/Android.bp
@@ -61,7 +61,6 @@ rust_library {
     srcs: ["stats_pull.rs"],
     rustlibs: [
         "liblog_rust",
-        "libonce_cell",
         "libstatslog_rust_header",
         "libstatspull_bindgen",
     ],
diff --git a/libstats/pull_rust/stats_pull.rs b/libstats/pull_rust/stats_pull.rs
index b2bebcc4edaa..03929e3b2e83 100644
--- a/libstats/pull_rust/stats_pull.rs
+++ b/libstats/pull_rust/stats_pull.rs
@@ -14,13 +14,12 @@
 
 //! A Rust interface for the StatsD pull API.
 
-use once_cell::sync::Lazy;
 use statslog_rust_header::{Atoms, Stat, StatsError};
 use statspull_bindgen::*;
 use std::collections::HashMap;
 use std::convert::TryInto;
 use std::os::raw::c_void;
-use std::sync::Mutex;
+use std::sync::{LazyLock, Mutex};
 
 /// The return value of callbacks.
 pub type StatsPullResult = Vec<Box<dyn Stat>>;
@@ -107,8 +106,8 @@ impl Default for Metadata {
     }
 }
 
-static COOKIES: Lazy<Mutex<HashMap<i32, fn() -> StatsPullResult>>> =
-    Lazy::new(|| Mutex::new(HashMap::new()));
+static COOKIES: LazyLock<Mutex<HashMap<i32, fn() -> StatsPullResult>>> =
+    LazyLock::new(|| Mutex::new(HashMap::new()));
 
 /// # Safety
 ///

From 47718268d4537ea5db1228ab9aa18a176f0c7b92 Mon Sep 17 00:00:00 2001
From: Han Wang <wanghan1995315@gmail.com>
Date: Sun, 31 Dec 2023 02:46:38 +0000
Subject: [PATCH 1121/1487] Remove OEM_UNLOCK_PROP usage

 * It was only used for adb host scripts, but after commit
   "Remove sys.oem_unlock_allowed check for Android device"
   in 2016, there is no usage for it. Remove it because this prop
   is now exposed to untrusted apps, which is not desirable.

Change-Id: Ic1c2f4e06b3a07ecf3f724fe5085974c626cb3fc
---
 .../libpropertyinfoserializer/property_info_serializer_test.cpp  | 1 -
 1 file changed, 1 deletion(-)

diff --git a/property_service/libpropertyinfoserializer/property_info_serializer_test.cpp b/property_service/libpropertyinfoserializer/property_info_serializer_test.cpp
index a484441c9e16..bed4a73bddaa 100644
--- a/property_service/libpropertyinfoserializer/property_info_serializer_test.cpp
+++ b/property_service/libpropertyinfoserializer/property_info_serializer_test.cpp
@@ -729,7 +729,6 @@ TEST(propertyinfoserializer, RealProperties) {
       {"sys.ims.QMI_DAEMON_STATUS", "u:object_r:qcom_ims_prop:s0"},
       {"sys.listeners.registered", "u:object_r:qseecomtee_prop:s0"},
       {"sys.logbootcomplete", "u:object_r:system_prop:s0"},
-      {"sys.oem_unlock_allowed", "u:object_r:system_prop:s0"},
       {"sys.qcom.devup", "u:object_r:system_prop:s0"},
       {"sys.sysctl.extra_free_kbytes", "u:object_r:system_prop:s0"},
       {"sys.usb.config", "u:object_r:system_radio_prop:s0"},

From a3b9e560bdd6b7676cb41ab0293a777b65754063 Mon Sep 17 00:00:00 2001
From: Pawan Wagh <waghpawan@google.com>
Date: Mon, 23 Sep 2024 20:32:48 +0000
Subject: [PATCH 1122/1487] Replace ANDROID_VENDOR with ANDROID_VNDK in
 versioning

API_LEVEL_AT_LEAST Check doesn't work on product modules

Bug: 368559337
Test: Boot device
Change-Id: I8b37b39caa642afc4d8c2b7adf6eed0b08efb40c
---
 libvendorsupport/include_llndk/android/llndk-versioning.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/libvendorsupport/include_llndk/android/llndk-versioning.h b/libvendorsupport/include_llndk/android/llndk-versioning.h
index cf82fb71259a..0402c28805c1 100644
--- a/libvendorsupport/include_llndk/android/llndk-versioning.h
+++ b/libvendorsupport/include_llndk/android/llndk-versioning.h
@@ -25,7 +25,7 @@
     __attribute__((annotate("introduced_in_llndk=" #vendor_api_level)))
 #endif
 
-#if defined(__ANDROID_VENDOR__)
+#if defined(__ANDROID_VNDK__)
 
 // Use this macro as an `if` statement to call an API that are available to both NDK and LLNDK.
 // This returns true for the vendor modules if the vendor_api_level is less than or equal to the
@@ -33,7 +33,7 @@
 #define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
     constexpr(__ANDROID_VENDOR_API__ >= vendor_api_level)
 
-#else  // __ANDROID_VENDOR__
+#else  // __ANDROID_VNDK__
 
 // For non-vendor modules, API_LEVEL_AT_LEAST is replaced with __builtin_available(sdk_api_level) to
 // guard the API for __INTRODUCED_IN.
@@ -42,4 +42,4 @@
     (__builtin_available(android sdk_api_level, *))
 #endif
 
-#endif  // __ANDROID_VENDOR__
+#endif  // __ANDROID_VNDK__

From e60b760e7463bcf66b7c1da3dd6d70e2f19f30db Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= <maze@google.com>
Date: Wed, 18 Sep 2024 18:11:14 +0000
Subject: [PATCH 1123/1487] start netd earlier
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In this change we're moving the asynchronous netd startup ahead of
the async statd and *synchronous* update_verifier.

This is desirable as we want a netd failure (which could
happen due to some mainline incompatibility wrt. bpf
or mainline shipped shared libs: resolver or netd updatable)
to be considered a signal for a bad boot.

It's still asynchronous though, so it's not ideal.

Test: TreeHugger
Signed-off-by: Maciej Żenczykowski <maze@google.com>
Change-Id: Ib3e252f085f569864feddaf20ac80858a3bb969d
---
 init/README.md  | 7 ++++---
 rootdir/init.rc | 5 ++++-
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/init/README.md b/init/README.md
index de57208e87a2..560c5280fe6c 100644
--- a/init/README.md
+++ b/init/README.md
@@ -501,9 +501,10 @@ have been omitted.
       reformatted here if it couldn't mount in first-stage init.
    6. `post-fs-data-checkpointed` - Triggered when vold has completed committing a checkpoint
       after an OTA update. Not triggered if checkpointing is not needed or supported.
-   7. `zygote-start` - Start the zygote.
-   8. `early-boot` - After zygote has started.
-   9. `boot` - After `early-boot` actions have completed.
+   7. `bpf-progs-loaded` - Starts things that want to start ASAP but need eBPF (incl. netd)
+   8. `zygote-start` - Start the zygote.
+   9. `early-boot` - After zygote has started.
+  10. `boot` - After `early-boot` actions have completed.
 
 Commands
 --------
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 63e3d0646586..41b94515b639 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -560,6 +560,7 @@ on late-init
 
     # Should be before netd, but after apex, properties and logging is available.
     trigger load_bpf_programs
+    trigger bpf-progs-loaded
 
     # Now we can start zygote.
     trigger zygote-start
@@ -1109,6 +1110,9 @@ on post-fs-data
 on property:vold.checkpoint_committed=1
     trigger post-fs-data-checkpointed
 
+on bpf-progs-loaded
+    start netd
+
 # It is recommended to put unnecessary data/ initialization from post-fs-data
 # to start-zygote in device's init.rc to unblock zygote start.
 on zygote-start
@@ -1116,7 +1120,6 @@ on zygote-start
     # A/B update verifier that marks a successful boot.
     exec_start update_verifier
     start statsd
-    start netd
     start zygote
     start zygote_secondary
 

From b4b3950e528cc62e874e59d052b2e9a600de708a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= <maze@google.com>
Date: Mon, 23 Sep 2024 21:24:00 +0000
Subject: [PATCH 1124/1487] Fix the trigger name for loading bpf programs.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The trigger name should be load-bpf-programs, not load_bpf_programs.

Test: TreeHugger
Signed-off-by: Maciej Żenczykowski <maze@google.com>
Change-Id: I00cff0a3dd971de39dfc3226b140be972854ea28
---
 rootdir/init.rc | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index d80416db8ffe..1acd637749f8 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -567,7 +567,7 @@ on late-init
     trigger post-fs-data
 
     # Should be before netd, but after apex, properties and logging is available.
-    trigger load_bpf_programs
+    trigger load-bpf-programs
     trigger bpf-progs-loaded
 
     # Now we can start zygote.
@@ -1110,6 +1110,19 @@ on post-fs-data
 on property:vold.checkpoint_committed=1
     trigger post-fs-data-checkpointed
 
+# It is important that we start bpfloader after:
+#   - /sys/fs/bpf is already mounted,
+#   - apex (incl. rollback) is initialized (so that we can load bpf
+#     programs shipped as part of apex mainline modules)
+#   - logd is ready for us to log stuff
+#
+# At the same time we want to be as early as possible to reduce races and thus
+# failures (before memory is fragmented, and cpu is busy running tons of other
+# stuff) and we absolutely want to be before netd and the system boot slot is
+# considered to have booted successfully.
+on load-bpf-programs
+    exec_start bpfloader
+
 on bpf-progs-loaded
     start netd
 
@@ -1280,7 +1293,7 @@ on property:net.tcp_def_init_rwnd=*
 # controlling access. On older kernels, the paranoid value is the only means of
 # controlling access. It is normally 3 (allow only root), but the shell user
 # can lower it to 1 (allowing thread-scoped pofiling) via security.perf_harden.
-on load_bpf_programs && property:sys.init.perf_lsm_hooks=1
+on load-bpf-programs && property:sys.init.perf_lsm_hooks=1
     write /proc/sys/kernel/perf_event_paranoid -1
 on property:security.perf_harden=0 && property:sys.init.perf_lsm_hooks=""
     write /proc/sys/kernel/perf_event_paranoid 1

From 4f0e3eb6f2eec51f688001e13da673106eec8dd1 Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Wed, 18 Sep 2024 05:55:47 +0000
Subject: [PATCH 1125/1487] trusty: utils: trusty-ut-ctrl: add to system_ext

Bug: 367423387
Test: atest VtsHalSecureStorageTargetTest

Change-Id: I70a8a9108c7399f99bfdf26b00c5fbd1fcb039c6
---
 trusty/utils/trusty-ut-ctrl/Android.bp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/trusty/utils/trusty-ut-ctrl/Android.bp b/trusty/utils/trusty-ut-ctrl/Android.bp
index 6fc2a48d7213..b76e55fb8b1e 100644
--- a/trusty/utils/trusty-ut-ctrl/Android.bp
+++ b/trusty/utils/trusty-ut-ctrl/Android.bp
@@ -18,7 +18,8 @@ package {
 
 cc_binary {
     name: "trusty-ut-ctrl",
-    vendor: true,
+    vendor_available: true,
+    system_ext_specific: true,
 
     srcs: ["ut-ctrl.c"],
     shared_libs: [

From d26f39ab0eacaf5318b814a1e4aa859660d52287 Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Thu, 19 Sep 2024 07:46:55 +0000
Subject: [PATCH 1126/1487] trusty: storage: proxy: FS_READY property setting
 on vendor only

Bug: 367965796
Test: launch_cvd --noresume --console=true \
      --extra_kernel_cmdline='androidboot.selinux=permissive' \
      --secure_hals=guest_keymint_trusty_insecure
Change-Id: I4d5ea1762f7cf9edfd8cbc00e2aec13caae965f4
---
 trusty/storage/proxy/Android.bp |  7 ++++++-
 trusty/storage/proxy/storage.c  | 26 ++++++++++++++++----------
 2 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/trusty/storage/proxy/Android.bp b/trusty/storage/proxy/Android.bp
index e362b8b97e21..7ef0e6f83be6 100644
--- a/trusty/storage/proxy/Android.bp
+++ b/trusty/storage/proxy/Android.bp
@@ -47,7 +47,12 @@ cc_binary {
         "libtrustystorageinterface",
         "libtrusty",
     ],
-
+    target: {
+        vendor: {
+            // vendor variant requires this flag
+            cflags: ["-DVENDOR_FS_READY_PROPERTY"],
+        },
+    },
     cflags: [
         "-Wall",
         "-Werror",
diff --git a/trusty/storage/proxy/storage.c b/trusty/storage/proxy/storage.c
index ca39f6aabc0e..72c4e93fef16 100644
--- a/trusty/storage/proxy/storage.c
+++ b/trusty/storage/proxy/storage.c
@@ -54,6 +54,8 @@ static const char *ssdir_name;
 /* List head for storage mapping, elements added at init, and never removed */
 static struct storage_mapping_node* storage_mapping_head;
 
+#ifdef VENDOR_FS_READY_PROPERTY
+
 /*
  * Properties set to 1 after we have opened a file under ssdir_name. The backing
  * files for both TD and TDP are currently located under /data/vendor/ss and can
@@ -75,16 +77,6 @@ static struct storage_mapping_node* storage_mapping_head;
 static bool fs_ready_set = false;
 static bool fs_ready_rw_set = false;
 
-static enum sync_state fs_state;
-static enum sync_state fd_state[FD_TBL_SIZE];
-
-static bool alternate_mode;
-
-static struct {
-   struct storage_file_read_resp hdr;
-   uint8_t data[MAX_READ_SIZE];
-}  read_rsp;
-
 static bool property_set_helper(const char* prop) {
     int rc = property_set(prop, "1");
     if (rc == 0) {
@@ -96,6 +88,18 @@ static bool property_set_helper(const char* prop) {
     return rc == 0;
 }
 
+#endif  // #ifdef VENDOR_FS_READY_PROPERTY
+
+static enum sync_state fs_state;
+static enum sync_state fd_state[FD_TBL_SIZE];
+
+static bool alternate_mode;
+
+static struct {
+    struct storage_file_read_resp hdr;
+    uint8_t data[MAX_READ_SIZE];
+} read_rsp;
+
 static uint32_t insert_fd(int open_flags, int fd, struct storage_mapping_node* node) {
     uint32_t handle = fd;
 
@@ -535,6 +539,7 @@ int storage_file_open(struct storage_msg* msg, const void* r, size_t req_len,
     free(path);
     path = NULL;
 
+#ifdef VENDOR_FS_READY_PROPERTY
     /* a backing file has been opened, notify any waiting init steps */
     if (!fs_ready_set || !fs_ready_rw_set) {
         bool is_checkpoint_active = false;
@@ -552,6 +557,7 @@ int storage_file_open(struct storage_msg* msg, const void* r, size_t req_len,
             }
         }
     }
+#endif  // #ifdef VENDOR_FS_READY_PROPERTY
 
     return ipc_respond(msg, &resp, sizeof(resp));
 

From 16f94816dbdc4747036eb1933ee39c5602253571 Mon Sep 17 00:00:00 2001
From: "Pechetty Sravani (xWF)" <pechetty@google.com>
Date: Tue, 24 Sep 2024 15:27:48 +0000
Subject: [PATCH 1127/1487] Revert "Support vendor partition in non-debuggable
 pVMs"

Revert submission 3236797-b/340506965

Reason for revert: DroidMonitor created revert due to b/366178299.

Reverted changes: /q/submissionid:3236797-b/340506965

Tracking bug: b/369390218

Change-Id: I0ec7fe89a7a0ca3a9981cd80222d03a785e9b28f
---
 init/first_stage_mount.cpp | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index c26b31e93441..ece430b70e21 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -156,13 +156,6 @@ static Result<Fstab> ReadFirstStageFstabAndroid() {
     return fstab;
 }
 
-static bool IsRequestingMicrodroidVendorPartition(const std::string& cmdline) {
-    if (virtualization::IsEnableTpuAssignableDeviceFlagEnabled()) {
-        return access("/proc/device-tree/avf/vendor_hashtree_descriptor_root_digest", F_OK) == 0;
-    }
-    return cmdline.find("androidboot.microdroid.mount_vendor=1") != std::string::npos;
-}
-
 // Note: this is a temporary solution to avoid blocking devs that depend on /vendor partition in
 // Microdroid. For the proper solution the /vendor fstab should probably be defined in the DT.
 // TODO(b/285855430): refactor this
@@ -173,7 +166,7 @@ static Result<Fstab> ReadFirstStageFstabMicrodroid(const std::string& cmdline) {
     if (!ReadDefaultFstab(&fstab)) {
         return Error() << "failed to read fstab";
     }
-    if (!IsRequestingMicrodroidVendorPartition(cmdline)) {
+    if (cmdline.find("androidboot.microdroid.mount_vendor=1") == std::string::npos) {
         // We weren't asked to mount /vendor partition, filter it out from the fstab.
         auto predicate = [](const auto& entry) { return entry.mount_point == "/vendor"; };
         fstab.erase(std::remove_if(fstab.begin(), fstab.end(), predicate), fstab.end());

From 69f3da832fb080b1e2db2270e26b16c84d7b194e Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Wed, 28 Aug 2024 06:51:35 +0000
Subject: [PATCH 1128/1487] trusty: support secure storage in system-ext

Bug: 355194622
Test: CF gets booted with KeyMint TA in VM
Change-Id: I3708ac572068162ca57c0e9b287296cea73215a7
---
 trusty/storage/interface/Android.bp      |  3 +-
 trusty/storage/proxy/Android.bp          | 26 ++++++----
 trusty/trusty-storage-cf.mk              | 25 +++++++++
 trusty/utils/rpmb_dev/Android.bp         | 23 +++++++--
 trusty/utils/rpmb_dev/rpmb_dev.system.rc | 64 ++++++++++++++++++++++++
 5 files changed, 125 insertions(+), 16 deletions(-)
 create mode 100644 trusty/trusty-storage-cf.mk
 create mode 100644 trusty/utils/rpmb_dev/rpmb_dev.system.rc

diff --git a/trusty/storage/interface/Android.bp b/trusty/storage/interface/Android.bp
index d031b0c1e938..769f53d8eb7d 100644
--- a/trusty/storage/interface/Android.bp
+++ b/trusty/storage/interface/Android.bp
@@ -20,6 +20,7 @@ package {
 
 cc_library_static {
     name: "libtrustystorageinterface",
-    vendor: true,
+    vendor_available: true,
+    system_ext_specific: true,
     export_include_dirs: ["include"],
 }
diff --git a/trusty/storage/proxy/Android.bp b/trusty/storage/proxy/Android.bp
index 7ef0e6f83be6..f32188a22dca 100644
--- a/trusty/storage/proxy/Android.bp
+++ b/trusty/storage/proxy/Android.bp
@@ -18,10 +18,8 @@ package {
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
-cc_binary {
-    name: "storageproxyd",
-    vendor: true,
-
+cc_defaults {
+    name: "storageproxyd.defaults",
     srcs: [
         "checkpoint_handling.cpp",
         "ipc.c",
@@ -47,14 +45,22 @@ cc_binary {
         "libtrustystorageinterface",
         "libtrusty",
     ],
-    target: {
-        vendor: {
-            // vendor variant requires this flag
-            cflags: ["-DVENDOR_FS_READY_PROPERTY"],
-        },
-    },
     cflags: [
         "-Wall",
         "-Werror",
     ],
 }
+
+cc_binary {
+    name: "storageproxyd",
+    defaults: ["storageproxyd.defaults"],
+    vendor: true,
+    // vendor variant requires this flag
+    cflags: ["-DVENDOR_FS_READY_PROPERTY"],
+}
+
+cc_binary {
+    name: "storageproxyd.system",
+    defaults: ["storageproxyd.defaults"],
+    system_ext_specific: true,
+}
diff --git a/trusty/trusty-storage-cf.mk b/trusty/trusty-storage-cf.mk
new file mode 100644
index 000000000000..3b46445da4f1
--- /dev/null
+++ b/trusty/trusty-storage-cf.mk
@@ -0,0 +1,25 @@
+#
+# Copyright (C) 2024 The Android Open-Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+#
+# This makefile should be included by the cuttlefish device
+# when enabling the Trusty VM to pull in the baseline set
+# of storage specific modules
+
+PRODUCT_PACKAGES += \
+	storageproxyd.system \
+	rpmb_dev.system \
+
diff --git a/trusty/utils/rpmb_dev/Android.bp b/trusty/utils/rpmb_dev/Android.bp
index 603a1a80ad4a..13f151d2e84e 100644
--- a/trusty/utils/rpmb_dev/Android.bp
+++ b/trusty/utils/rpmb_dev/Android.bp
@@ -15,11 +15,8 @@ package {
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
-cc_binary {
-    name: "rpmb_dev",
-    vendor: true,
-    host_supported: true,
-
+cc_defaults {
+    name: "rpmb_dev.cc_defaults",
     srcs: [
         "rpmb_dev.c",
     ],
@@ -32,7 +29,23 @@ cc_binary {
         "-Wall",
         "-Werror",
     ],
+}
+
+cc_binary {
+    name: "rpmb_dev",
+    defaults: ["rpmb_dev.cc_defaults"],
+    vendor: true,
+    host_supported: true,
     init_rc: [
         "rpmb_dev.rc",
     ],
 }
+
+cc_binary {
+    name: "rpmb_dev.system",
+    defaults: ["rpmb_dev.cc_defaults"],
+    system_ext_specific: true,
+    init_rc: [
+        "rpmb_dev.system.rc",
+    ],
+}
diff --git a/trusty/utils/rpmb_dev/rpmb_dev.system.rc b/trusty/utils/rpmb_dev/rpmb_dev.system.rc
new file mode 100644
index 000000000000..b78c4e2a10da
--- /dev/null
+++ b/trusty/utils/rpmb_dev/rpmb_dev.system.rc
@@ -0,0 +1,64 @@
+service storageproxyd_system /system_ext/bin/storageproxyd.system \
+        -d ${storageproxyd_system.trusty_ipc_dev:-/dev/trusty-ipc-dev0} \
+        -r /dev/socket/rpmb_mock_system \
+        -p /data/secure_storage_system \
+        -t sock
+    disabled
+    user system
+    group system
+
+service rpmb_mock_init_system /system_ext/bin/rpmb_dev.system \
+        --dev /mnt/secure_storage_rpmb_system/persist/RPMB_DATA --init --size 2048
+    disabled
+    user system
+    group system
+    oneshot
+
+service rpmb_mock_system /system_ext/bin/rpmb_dev.system \
+        --dev /mnt/secure_storage_rpmb_system/persist/RPMB_DATA \
+        --sock rpmb_mock_system
+    disabled
+    user system
+    group system
+    socket rpmb_mock_system stream 660 system system
+
+# storageproxyd
+on late-fs && \
+    property:trusty_vm_system_nonsecure.ready=1 && \
+    property:storageproxyd_system.trusty_ipc_dev=*
+    wait /dev/socket/rpmb_mock_system
+    start storageproxyd_system
+
+
+# RPMB Mock
+on post-fs && \
+    property:trusty_vm_system_nonsecure.ready=1 && \
+    property:trusty_vm_system.vm_cid=*
+    # Create a persistent location for the RPMB data
+    # (work around lack of RPMb block device on CF).
+    # file contexts secure_storage_rpmb_system_file
+    # (only used on Cuttlefish as this is non secure)
+    mkdir /metadata/secure_storage_rpmb_system 0770 system system
+    mkdir /mnt/secure_storage_rpmb_system 0770 system system
+    symlink /metadata/secure_storage_rpmb_system \
+            /mnt/secure_storage_rpmb_system/persist
+    # Create a system persist directory in /metadata
+    # (work around lack of dedicated system persist partition).
+    # file contexts secure_storage_persist_system_file
+    mkdir /metadata/secure_storage_persist_system 0770 system system
+    mkdir /mnt/secure_storage_persist_system 0770 system system
+    symlink /metadata/secure_storage_persist_system \
+            /mnt/secure_storage_persist_system/persist
+    setprop storageproxyd_system.trusty_ipc_dev VSOCK:${trusty_vm_system.vm_cid}:1
+    exec_start rpmb_mock_init_system
+    start rpmb_mock_system
+
+on post-fs-data && \
+    property:trusty_vm_system_nonsecure.ready=1 && \
+    property:storageproxyd_system.trusty_ipc_dev=*
+    # file contexts secure_storage_system_file
+    mkdir /data/secure_storage_system 0770 root system
+    symlink /mnt/secure_storage_persist_system/persist \
+            /data/secure_storage_system/persist
+    chown root system /data/secure_storage_system/persist
+    restart storageproxyd_system

From 3d90ed0ceab2937f72183281aca1120619cadf1b Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Wed, 25 Sep 2024 06:32:25 +0000
Subject: [PATCH 1129/1487] trusty: utils: trusty-ut-ctrl: fix the vendor
 target

Bug: 369492636
Test: trusty-ut-ctl -D <trusty device> <port-name>

Change-Id: I9d8a298941caa4e3c5a424269577580be0ba79c8
---
 trusty/utils/trusty-ut-ctrl/Android.bp | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/trusty/utils/trusty-ut-ctrl/Android.bp b/trusty/utils/trusty-ut-ctrl/Android.bp
index b76e55fb8b1e..c255614b0c75 100644
--- a/trusty/utils/trusty-ut-ctrl/Android.bp
+++ b/trusty/utils/trusty-ut-ctrl/Android.bp
@@ -16,10 +16,8 @@ package {
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
-cc_binary {
-    name: "trusty-ut-ctrl",
-    vendor_available: true,
-    system_ext_specific: true,
+cc_defaults {
+    name: "trusty-ut-ctrl.defaults",
 
     srcs: ["ut-ctrl.c"],
     shared_libs: [
@@ -34,3 +32,15 @@ cc_binary {
         "-Werror",
     ],
 }
+
+cc_binary {
+    name: "trusty-ut-ctrl",
+    defaults: ["trusty-ut-ctrl.defaults"],
+    vendor: true,
+}
+
+cc_binary {
+    name: "trusty-ut-ctrl.system",
+    defaults: ["trusty-ut-ctrl.defaults"],
+    system_ext_specific: true,
+}

From 1396f9d3bb43ea44aa6b0a67fe44570828f9f668 Mon Sep 17 00:00:00 2001
From: Vova Sharaienko <sharaienko@google.com>
Date: Thu, 26 Sep 2024 00:10:31 +0000
Subject: [PATCH 1130/1487] Add host support to libexpresslog

- change to a set of build artifacts

Flag: EXEMPT Refactor

Ignore-AOSP-First: will cp to aosp after
Bug: n/a
Test: build
Change-Id: I8b565a9237319da0b24fed2c802f0e03a15bcd57
---
 libstats/expresslog/Android.bp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/libstats/expresslog/Android.bp b/libstats/expresslog/Android.bp
index 96ab59b10fdf..b4413e12ddd6 100644
--- a/libstats/expresslog/Android.bp
+++ b/libstats/expresslog/Android.bp
@@ -1,4 +1,3 @@
-
 //
 // Copyright (C) 2023 The Android Open Source Project
 //
@@ -28,6 +27,7 @@ cc_defaults {
 
 cc_library {
     name: "libexpresslog",
+    host_supported: true,
     defaults: ["expresslog_defaults"],
     cflags: [
         "-DNAMESPACE_FOR_HASH_FUNCTIONS=farmhash",
@@ -74,6 +74,7 @@ genrule {
 
 cc_library_static {
     name: "libstatslog_express",
+    host_supported: true,
     generated_sources: ["statslog_express.cpp"],
     generated_headers: ["statslog_express.h"],
     export_generated_headers: ["statslog_express.h"],
@@ -119,5 +120,5 @@ cc_test {
     ],
     shared_libs: [
         "libstatssocket",
-    ]
+    ],
 }

From 8a32d828847a989523ebee8d21d084cf1d55a605 Mon Sep 17 00:00:00 2001
From: Vova Sharaienko <sharaienko@google.com>
Date: Thu, 26 Sep 2024 17:59:38 +0000
Subject: [PATCH 1131/1487] Added ownership attribution for test targets

Flag: NONE Docs
Bug: n/a
Test: build
Ignore-AOSP-First: will cp to aosp after
Change-Id: I6ca6e48ea1ec704216833c2c04177b0022e7b659
---
 libstats/expresslog/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libstats/expresslog/Android.bp b/libstats/expresslog/Android.bp
index b4413e12ddd6..f70252afc777 100644
--- a/libstats/expresslog/Android.bp
+++ b/libstats/expresslog/Android.bp
@@ -15,6 +15,7 @@
 //
 package {
     default_applicable_licenses: ["Android-Apache-2.0"],
+    default_team: "trendy_team_android_telemetry_client_infra",
 }
 
 cc_defaults {

From 1ec5290872b1bd120e44ebffddd47b2a62bc90d1 Mon Sep 17 00:00:00 2001
From: Hans Boehm <hboehm@google.com>
Date: Thu, 26 Sep 2024 12:59:37 -0700
Subject: [PATCH 1132/1487] Remove unnecessary getpriority() system call

This was introduced for a valid reason in aosp/1224543, but that reason
was later removed. This code wasn't.

It is not worth making a system call in order to possibly avoid a second
one, which I expect is no more expensive in that, particularly easy,
case.

Test: Treehugger
Change-Id: I346f9b641c6feb791247b16fb900a4ad97e646d2
---
 libutils/Threads.cpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/libutils/Threads.cpp b/libutils/Threads.cpp
index d8d75acf4716..111d46af9e2d 100644
--- a/libutils/Threads.cpp
+++ b/libutils/Threads.cpp
@@ -313,11 +313,6 @@ void androidSetCreateThreadFunc(android_create_thread_fn func)
 int androidSetThreadPriority(pid_t tid, int pri)
 {
     int rc = 0;
-    int curr_pri = getpriority(PRIO_PROCESS, tid);
-
-    if (curr_pri == pri) {
-        return rc;
-    }
 
     if (setpriority(PRIO_PROCESS, tid, pri) < 0) {
         rc = INVALID_OPERATION;

From 717b4a7187c5ff89d293432b0f5f22a34b1b4710 Mon Sep 17 00:00:00 2001
From: Vova Sharaienko <sharaienko@google.com>
Date: Thu, 26 Sep 2024 21:11:51 +0000
Subject: [PATCH 1133/1487] Add host support to libexpresslog

- change to a set of build artifacts

Flag: EXEMPT Refactor

Ignore-AOSP-First: will cp to aosp after
Bug: n/a
Test: build
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:1396f9d3bb43ea44aa6b0a67fe44570828f9f668)
Merged-In: I8b565a9237319da0b24fed2c802f0e03a15bcd57
Change-Id: I8b565a9237319da0b24fed2c802f0e03a15bcd57
---
 libstats/expresslog/Android.bp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/libstats/expresslog/Android.bp b/libstats/expresslog/Android.bp
index 96ab59b10fdf..b4413e12ddd6 100644
--- a/libstats/expresslog/Android.bp
+++ b/libstats/expresslog/Android.bp
@@ -1,4 +1,3 @@
-
 //
 // Copyright (C) 2023 The Android Open Source Project
 //
@@ -28,6 +27,7 @@ cc_defaults {
 
 cc_library {
     name: "libexpresslog",
+    host_supported: true,
     defaults: ["expresslog_defaults"],
     cflags: [
         "-DNAMESPACE_FOR_HASH_FUNCTIONS=farmhash",
@@ -74,6 +74,7 @@ genrule {
 
 cc_library_static {
     name: "libstatslog_express",
+    host_supported: true,
     generated_sources: ["statslog_express.cpp"],
     generated_headers: ["statslog_express.h"],
     export_generated_headers: ["statslog_express.h"],
@@ -119,5 +120,5 @@ cc_test {
     ],
     shared_libs: [
         "libstatssocket",
-    ]
+    ],
 }

From 78d5f7c6f5712560c83dd64ab69addbb16bec4aa Mon Sep 17 00:00:00 2001
From: Vova Sharaienko <sharaienko@google.com>
Date: Thu, 26 Sep 2024 21:12:01 +0000
Subject: [PATCH 1134/1487] Added ownership attribution for test targets

Flag: NONE Docs
Bug: n/a
Test: build
Ignore-AOSP-First: will cp to aosp after
(cherry picked from https://googleplex-android-review.googlesource.com/q/commit:8a32d828847a989523ebee8d21d084cf1d55a605)
Merged-In: I6ca6e48ea1ec704216833c2c04177b0022e7b659
Change-Id: I6ca6e48ea1ec704216833c2c04177b0022e7b659
---
 libstats/expresslog/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libstats/expresslog/Android.bp b/libstats/expresslog/Android.bp
index 96ab59b10fdf..f8fc88f7e320 100644
--- a/libstats/expresslog/Android.bp
+++ b/libstats/expresslog/Android.bp
@@ -16,6 +16,7 @@
 //
 package {
     default_applicable_licenses: ["Android-Apache-2.0"],
+    default_team: "trendy_team_android_telemetry_client_infra",
 }
 
 cc_defaults {

From 6f0ebcb5260a8e769e0e029596d21c0efabe361b Mon Sep 17 00:00:00 2001
From: Jan Dabros <dabros@google.com>
Date: Thu, 19 Oct 2023 11:36:37 +0000
Subject: [PATCH 1135/1487] init: Look for super partition only on a boot
 device

Init code is bailing out as soon as `super` partition was
found in the system, ignoring rest of uevents.

In case given device contains multiple boot sources, `super`
partition as well as all other partitions shall be taken
from the same boot source, instead of relying on
`which uevent came first`.

Bug: 309244873, 349144493
Test: Plug secondary USB boot device to device that supports multiple
      boot sources. Select boot from USB. Device boots properly.

Signed-off-by: Jan Dabros <dabros@google.com>
Signed-off-by: Konrad Adamczyk <konrada@google.com>

Change-Id: I70eb7d4223258ec273faa523cb67ddab0b7c32a0
---
 init/block_dev_initializer.cpp |  6 +++++-
 init/devices.cpp               | 22 ++++++++++++++++++++++
 init/devices.h                 |  1 +
 3 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/init/block_dev_initializer.cpp b/init/block_dev_initializer.cpp
index 8f5215856544..cabeb01090b0 100644
--- a/init/block_dev_initializer.cpp
+++ b/init/block_dev_initializer.cpp
@@ -98,7 +98,11 @@ ListenerAction BlockDevInitializer::HandleUevent(const Uevent& uevent,
 
     LOG(VERBOSE) << __PRETTY_FUNCTION__ << ": found partition: " << name;
 
-    devices->erase(iter);
+    // Remove partition from the list only if it was found on boot device
+    if (device_handler_->IsBootDevice(uevent)) {
+        devices->erase(iter);
+    }
+
     device_handler_->HandleUevent(uevent);
     return devices->empty() ? ListenerAction::kStop : ListenerAction::kContinue;
 }
diff --git a/init/devices.cpp b/init/devices.cpp
index f2bb9d27607d..6a3a64dd81f3 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -188,6 +188,28 @@ void SysfsPermissions::SetPermissions(const std::string& path) const {
     }
 }
 
+bool DeviceHandler::IsBootDevice(const Uevent& uevent) const {
+    std::string device;
+
+    if (FindPlatformDevice(uevent.path, &device)) {
+        // Skip /devices/platform or /devices/ if present
+        static constexpr std::string_view devices_platform_prefix = "/devices/platform/";
+        static constexpr std::string_view devices_prefix = "/devices/";
+
+        if (StartsWith(device, devices_platform_prefix)) {
+            device = device.substr(devices_platform_prefix.length());
+        } else if (StartsWith(device, devices_prefix)) {
+            device = device.substr(devices_prefix.length());
+        }
+    } else if (FindPciDevicePrefix(uevent.path, &device)) {
+    } else if (FindVbdDevicePrefix(uevent.path, &device)) {
+    } else {
+        return false;
+    }
+
+    return boot_devices_.find(device) != boot_devices_.end();
+}
+
 std::string DeviceHandler::GetPartitionNameForDevice(const std::string& query_device) {
     static const auto partition_map = [] {
         std::vector<std::pair<std::string, std::string>> partition_map;
diff --git a/init/devices.h b/init/devices.h
index 6da1232595b4..4df604d00cef 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -133,6 +133,7 @@ class DeviceHandler : public UeventHandler {
     // `androidboot.partition_map=vdb,metadata;vdc,userdata` maps `vdb` to `metadata` and `vdc` to
     // `userdata`.
     static std::string GetPartitionNameForDevice(const std::string& device);
+    bool IsBootDevice(const Uevent& uevent) const;
 
   private:
     void ColdbootDone() override;

From 0d84909d667bf3ebd49db2ba87af759d1f326aba Mon Sep 17 00:00:00 2001
From: Sandeep Dhavale <dhavale@google.com>
Date: Fri, 27 Sep 2024 13:37:18 -0700
Subject: [PATCH 1136/1487] libsnapshot: Use words for xor ops

Use words instead of doing xor byte-by-byte for the entire buffer.
Profiling this with unittest, I can see the xor ops is much faster.

Also handle the word size appropriately for 32bit and 64bit platforms.

simpleperf shows that ProcessXorOp() is atleast 30% faster.
Similar improvement is seen for ProcessXorData().

Test: snapuserd_test
Bug: 369905394
Change-Id: I0bd8586f7fc1bf184f19320667b8195b07f9cdf2
Signed-off-by: Sandeep Dhavale <dhavale@google.com>
---
 .../snapuserd/user-space-merge/read_worker.cpp       | 11 ++++++++---
 .../user-space-merge/snapuserd_readahead.cpp         | 12 +++++++-----
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
index ef311d4757f0..33767d6547e8 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.cpp
@@ -104,6 +104,8 @@ bool ReadWorker::ProcessCopyOp(const CowOperation* cow_op, void* buffer) {
 }
 
 bool ReadWorker::ProcessXorOp(const CowOperation* cow_op, void* buffer) {
+    using WordType = std::conditional_t<sizeof(void*) == sizeof(uint64_t), uint64_t, uint32_t>;
+
     if (!ReadFromSourceDevice(cow_op, buffer)) {
         return false;
     }
@@ -120,9 +122,12 @@ bool ReadWorker::ProcessXorOp(const CowOperation* cow_op, void* buffer) {
         return false;
     }
 
-    auto xor_out = reinterpret_cast<uint8_t*>(buffer);
-    for (size_t i = 0; i < BLOCK_SZ; i++) {
-        xor_out[i] ^= xor_buffer_[i];
+    auto xor_in = reinterpret_cast<const WordType*>(xor_buffer_.data());
+    auto xor_out = reinterpret_cast<WordType*>(buffer);
+    auto num_words = BLOCK_SZ / sizeof(WordType);
+
+    for (auto i = 0; i < num_words; i++) {
+        xor_out[i] ^= xor_in[i];
     }
     return true;
 }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index 6b1ed0cd7d98..9a1d441c46a1 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -458,6 +458,7 @@ bool ReadAhead::ReapIoCompletions(int pending_ios_to_complete) {
 void ReadAhead::ProcessXorData(size_t& block_xor_index, size_t& xor_index,
                                std::vector<const CowOperation*>& xor_op_vec, void* buffer,
                                loff_t& buffer_offset) {
+    using WordType = std::conditional_t<sizeof(void*) == sizeof(uint64_t), uint64_t, uint32_t>;
     loff_t xor_buf_offset = 0;
 
     while (block_xor_index < blocks_.size()) {
@@ -470,13 +471,14 @@ void ReadAhead::ProcessXorData(size_t& block_xor_index, size_t& xor_index,
             // Check if this block is an XOR op
             if (xor_op->new_block == new_block) {
                 // Pointer to the data read from base device
-                uint8_t* buffer = reinterpret_cast<uint8_t*>(bufptr);
+                auto buffer_words = reinterpret_cast<WordType*>(bufptr);
                 // Get the xor'ed data read from COW device
-                uint8_t* xor_data = reinterpret_cast<uint8_t*>((char*)bufsink_.GetPayloadBufPtr() +
-                                                               xor_buf_offset);
+                auto xor_data_words = reinterpret_cast<WordType*>(
+                        (char*)bufsink_.GetPayloadBufPtr() + xor_buf_offset);
+                auto num_words = BLOCK_SZ / sizeof(WordType);
 
-                for (size_t byte_offset = 0; byte_offset < BLOCK_SZ; byte_offset++) {
-                    buffer[byte_offset] ^= xor_data[byte_offset];
+                for (auto i = 0; i < num_words; i++) {
+                    buffer_words[i] ^= xor_data_words[i];
                 }
 
                 // Move to next XOR op

From bc067ef9f0408f3b7c4f5dcae3b6aec51f386e4d Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 1 Oct 2024 11:01:08 -0700
Subject: [PATCH 1137/1487] libdm: Redact keys from dm-crypt targets when
 calling GetTable.

Ignore-AOSP-First: security fix
Bug: 368069390
Test: libdm_test
Change-Id: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
---
 fs_mgr/libdm/dm.cpp      | 14 ++++++++++++++
 fs_mgr/libdm/dm_test.cpp | 28 ++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+)

diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index a9633226f3dd..94c320ac4dce 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -551,6 +551,17 @@ bool DeviceMapper::GetTableInfo(const std::string& name, std::vector<TargetInfo>
     return GetTable(name, DM_STATUS_TABLE_FLAG, table);
 }
 
+void RedactTableInfo(const struct dm_target_spec& spec, std::string* data) {
+    if (DeviceMapper::GetTargetType(spec) == "crypt") {
+        auto parts = android::base::Split(*data, " ");
+        if (parts.size() < 2) {
+            return;
+        }
+        parts[1] = "redacted";
+        *data = android::base::Join(parts, " ");
+    }
+}
+
 // private methods of DeviceMapper
 bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
                             std::vector<TargetInfo>* table) {
@@ -589,6 +600,9 @@ bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
             // Note: we use c_str() to eliminate any extra trailing 0s.
             data = std::string(&buffer[data_offset], next_cursor - data_offset).c_str();
         }
+        if (flags & DM_STATUS_TABLE_FLAG) {
+            RedactTableInfo(*spec, &data);
+        }
         table->emplace_back(*spec, data);
         cursor = next_cursor;
     }
diff --git a/fs_mgr/libdm/dm_test.cpp b/fs_mgr/libdm/dm_test.cpp
index b890f471503b..5eddb513c1f1 100644
--- a/fs_mgr/libdm/dm_test.cpp
+++ b/fs_mgr/libdm/dm_test.cpp
@@ -814,3 +814,31 @@ TEST_F(DmTest, ThinProvisioning) {
     TempDevice thin("thin", thinTable);
     ASSERT_TRUE(thin.valid());
 }
+
+TEST_F(DmTest, RedactDmCrypt) {
+    static constexpr uint64_t kImageSize = 65536;
+    unique_fd temp_file(CreateTempFile("file_1", kImageSize));
+    ASSERT_GE(temp_file, 0);
+
+    LoopDevice loop(temp_file, 10s);
+    ASSERT_TRUE(loop.valid());
+
+    static constexpr const char* kAlgorithm = "aes-cbc-essiv:sha256";
+    static constexpr const char* kKey = "0e64ef514e6a1315b1f6390cb57c9e6a";
+
+    auto target = std::make_unique<DmTargetCrypt>(0, kImageSize / 512, kAlgorithm, kKey, 0,
+                                                  loop.device(), 0);
+    target->AllowDiscards();
+
+    DmTable table;
+    table.AddTarget(std::move(target));
+
+    auto& dm = DeviceMapper::Instance();
+    std::string crypt_path;
+    ASSERT_TRUE(dm.CreateDevice(test_name_, table, &crypt_path, 10s));
+
+    std::vector<DeviceMapper::TargetInfo> targets;
+    ASSERT_TRUE(dm.GetTableInfo(test_name_, &targets));
+    ASSERT_EQ(targets.size(), 1);
+    EXPECT_EQ(targets[0].data.find(kKey), std::string::npos);
+}

From 981664df08619b66ad51daf52356ff02f98a2b77 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 27 Aug 2024 16:50:10 +0000
Subject: [PATCH 1138/1487] libprocessgroup: Remove schedtune support

Schedtune was an out of tree cgroup controller present in Android
kernels up to 4.19. It was replaced with uclamp and the cpu controller.
Now that 4.19 is EOL and unsupported, and schedtune is not present in
any supported Android kernels, remove the userspace support for
schedtune.

Bug: 362504801
Change-Id: If8baaf1a616984c5dbaac1bbd03e23ad001bc29c
---
 libcutils/sched_policy_test.cpp               |   7 -
 .../include/processgroup/sched_policy.h       |   8 -
 libprocessgroup/profiles/Android.bp           |  46 -----
 libprocessgroup/profiles/cgroups_28.json      |  11 --
 libprocessgroup/profiles/cgroups_29.json      |  11 --
 libprocessgroup/profiles/cgroups_30.json      |  12 --
 .../profiles/task_profiles_28.json            | 160 ------------------
 .../profiles/task_profiles_29.json            | 160 ------------------
 .../profiles/task_profiles_30.json            | 160 ------------------
 libprocessgroup/sched_policy.cpp              |  15 +-
 10 files changed, 2 insertions(+), 588 deletions(-)
 delete mode 100644 libprocessgroup/profiles/cgroups_28.json
 delete mode 100644 libprocessgroup/profiles/cgroups_29.json
 delete mode 100644 libprocessgroup/profiles/cgroups_30.json
 delete mode 100644 libprocessgroup/profiles/task_profiles_28.json
 delete mode 100644 libprocessgroup/profiles/task_profiles_29.json
 delete mode 100644 libprocessgroup/profiles/task_profiles_30.json

diff --git a/libcutils/sched_policy_test.cpp b/libcutils/sched_policy_test.cpp
index 50bd6d0b8794..264174309781 100644
--- a/libcutils/sched_policy_test.cpp
+++ b/libcutils/sched_policy_test.cpp
@@ -67,13 +67,6 @@ static void AssertPolicy(SchedPolicy expected_policy) {
 }
 
 TEST(SchedPolicy, set_sched_policy) {
-    if (!schedboost_enabled()) {
-        // schedboost_enabled() (i.e. CONFIG_CGROUP_SCHEDTUNE) is optional;
-        // it's only needed on devices using energy-aware scheduler.
-        GTEST_LOG_(INFO) << "skipping test that requires CONFIG_CGROUP_SCHEDTUNE";
-        return;
-    }
-
     ASSERT_EQ(0, set_sched_policy(0, SP_BACKGROUND));
     ASSERT_EQ(0, set_cpuset_policy(0, SP_BACKGROUND));
     AssertPolicy(SP_BACKGROUND);
diff --git a/libprocessgroup/include/processgroup/sched_policy.h b/libprocessgroup/include/processgroup/sched_policy.h
index 1b6ea669d71a..92cd367bfbe3 100644
--- a/libprocessgroup/include/processgroup/sched_policy.h
+++ b/libprocessgroup/include/processgroup/sched_policy.h
@@ -29,14 +29,6 @@ extern "C" {
  */
 extern bool cpusets_enabled();
 
-/*
- * Check if Linux kernel enables SCHEDTUNE feature (only available in Android
- * common kernel or Linaro LSK, not in mainline Linux as of v4.9)
- *
- * Return value: 1 if Linux kernel CONFIG_CGROUP_SCHEDTUNE=y; 0 otherwise.
- */
-extern bool schedboost_enabled();
-
 /* Keep in sync with THREAD_GROUP_* in frameworks/base/core/java/android/os/Process.java */
 typedef enum {
     SP_DEFAULT = -1,
diff --git a/libprocessgroup/profiles/Android.bp b/libprocessgroup/profiles/Android.bp
index 885971a7a34f..1ec9f7f3b3c0 100644
--- a/libprocessgroup/profiles/Android.bp
+++ b/libprocessgroup/profiles/Android.bp
@@ -19,11 +19,6 @@ package {
 prebuilt_etc {
     name: "cgroups.json",
     src: "cgroups.json",
-    required: [
-        "cgroups_28.json",
-        "cgroups_29.json",
-        "cgroups_30.json",
-    ],
 }
 
 prebuilt_etc {
@@ -33,50 +28,9 @@ prebuilt_etc {
     src: "cgroups.recovery.json",
 }
 
-prebuilt_etc {
-    name: "cgroups_28.json",
-    src: "cgroups_28.json",
-    sub_dir: "task_profiles",
-}
-
-prebuilt_etc {
-    name: "cgroups_29.json",
-    src: "cgroups_29.json",
-    sub_dir: "task_profiles",
-}
-
-prebuilt_etc {
-    name: "cgroups_30.json",
-    src: "cgroups_30.json",
-    sub_dir: "task_profiles",
-}
-
 prebuilt_etc {
     name: "task_profiles.json",
     src: "task_profiles.json",
-    required: [
-        "task_profiles_28.json",
-        "task_profiles_29.json",
-        "task_profiles_30.json",
-    ],
-}
-
-prebuilt_etc {
-    name: "task_profiles_28.json",
-    src: "task_profiles_28.json",
-    sub_dir: "task_profiles",
-}
-
-prebuilt_etc {
-    name: "task_profiles_29.json",
-    src: "task_profiles_29.json",
-    sub_dir: "task_profiles",
-}
-
-prebuilt_etc {
-    name: "task_profiles_30.json",
-    src: "task_profiles_30.json",
-    sub_dir: "task_profiles",
 }
 
 cc_defaults {
diff --git a/libprocessgroup/profiles/cgroups_28.json b/libprocessgroup/profiles/cgroups_28.json
deleted file mode 100644
index 17d4929497d5..000000000000
--- a/libprocessgroup/profiles/cgroups_28.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "Cgroups": [
-    {
-      "Controller": "schedtune",
-      "Path": "/dev/stune",
-      "Mode": "0755",
-      "UID": "system",
-      "GID": "system"
-    }
-  ]
-}
diff --git a/libprocessgroup/profiles/cgroups_29.json b/libprocessgroup/profiles/cgroups_29.json
deleted file mode 100644
index 17d4929497d5..000000000000
--- a/libprocessgroup/profiles/cgroups_29.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "Cgroups": [
-    {
-      "Controller": "schedtune",
-      "Path": "/dev/stune",
-      "Mode": "0755",
-      "UID": "system",
-      "GID": "system"
-    }
-  ]
-}
diff --git a/libprocessgroup/profiles/cgroups_30.json b/libprocessgroup/profiles/cgroups_30.json
deleted file mode 100644
index 80a074bf1c84..000000000000
--- a/libprocessgroup/profiles/cgroups_30.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  "Cgroups": [
-    {
-      "Controller": "schedtune",
-      "Path": "/dev/stune",
-      "Mode": "0755",
-      "UID": "system",
-      "GID": "system",
-      "Optional": true
-    }
-  ]
-}
diff --git a/libprocessgroup/profiles/task_profiles_28.json b/libprocessgroup/profiles/task_profiles_28.json
deleted file mode 100644
index e7be5487d148..000000000000
--- a/libprocessgroup/profiles/task_profiles_28.json
+++ /dev/null
@@ -1,160 +0,0 @@
-{
-  "Attributes": [
-    {
-      "Name": "STuneBoost",
-      "Controller": "schedtune",
-      "File": "schedtune.boost"
-    },
-    {
-      "Name": "STunePreferIdle",
-      "Controller": "schedtune",
-      "File": "schedtune.prefer_idle"
-    }
-  ],
-
-  "Profiles": [
-    {
-      "Name": "HighEnergySaving",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "background"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "NormalPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": ""
-          }
-        }
-      ]
-    },
-    {
-      "Name": "ServicePerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "background"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "HighPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "foreground"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "MaxPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "top-app"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "RealtimePerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "rt"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "CameraServicePerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "camera-daemon"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "NNApiHALPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "nnapi-hal"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "Dex2oatPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "background"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "CpuPolicySpread",
-      "Actions": [
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "STunePreferIdle",
-            "Value": "1"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "CpuPolicyPack",
-      "Actions": [
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "STunePreferIdle",
-            "Value": "0"
-          }
-        }
-      ]
-    }
-  ]
-}
diff --git a/libprocessgroup/profiles/task_profiles_29.json b/libprocessgroup/profiles/task_profiles_29.json
deleted file mode 100644
index 6174c8d0fa94..000000000000
--- a/libprocessgroup/profiles/task_profiles_29.json
+++ /dev/null
@@ -1,160 +0,0 @@
-{
-  "Attributes": [
-    {
-      "Name": "STuneBoost",
-      "Controller": "schedtune",
-      "File": "schedtune.boost"
-    },
-    {
-      "Name": "STunePreferIdle",
-      "Controller": "schedtune",
-      "File": "schedtune.prefer_idle"
-    }
-  ],
-
-  "Profiles": [
-    {
-      "Name": "HighEnergySaving",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "background"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "NormalPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": ""
-          }
-        }
-      ]
-    },
-    {
-      "Name": "HighPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "foreground"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "ServicePerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "background"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "MaxPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "top-app"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "RealtimePerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "rt"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "CameraServicePerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "camera-daemon"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "NNApiHALPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "nnapi-hal"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "Dex2oatPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "background"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "CpuPolicySpread",
-      "Actions": [
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "STunePreferIdle",
-            "Value": "1"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "CpuPolicyPack",
-      "Actions": [
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "STunePreferIdle",
-            "Value": "0"
-          }
-        }
-      ]
-    }
-  ]
-}
diff --git a/libprocessgroup/profiles/task_profiles_30.json b/libprocessgroup/profiles/task_profiles_30.json
deleted file mode 100644
index e7be5487d148..000000000000
--- a/libprocessgroup/profiles/task_profiles_30.json
+++ /dev/null
@@ -1,160 +0,0 @@
-{
-  "Attributes": [
-    {
-      "Name": "STuneBoost",
-      "Controller": "schedtune",
-      "File": "schedtune.boost"
-    },
-    {
-      "Name": "STunePreferIdle",
-      "Controller": "schedtune",
-      "File": "schedtune.prefer_idle"
-    }
-  ],
-
-  "Profiles": [
-    {
-      "Name": "HighEnergySaving",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "background"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "NormalPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": ""
-          }
-        }
-      ]
-    },
-    {
-      "Name": "ServicePerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "background"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "HighPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "foreground"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "MaxPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "top-app"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "RealtimePerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "rt"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "CameraServicePerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "camera-daemon"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "NNApiHALPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "nnapi-hal"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "Dex2oatPerformance",
-      "Actions": [
-        {
-          "Name": "JoinCgroup",
-          "Params":
-          {
-            "Controller": "schedtune",
-            "Path": "background"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "CpuPolicySpread",
-      "Actions": [
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "STunePreferIdle",
-            "Value": "1"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "CpuPolicyPack",
-      "Actions": [
-        {
-          "Name": "SetAttribute",
-          "Params":
-          {
-            "Name": "STunePreferIdle",
-            "Value": "0"
-          }
-        }
-      ]
-    }
-  ]
-}
diff --git a/libprocessgroup/sched_policy.cpp b/libprocessgroup/sched_policy.cpp
index 042bcd24c471..5a53c35de7f1 100644
--- a/libprocessgroup/sched_policy.cpp
+++ b/libprocessgroup/sched_policy.cpp
@@ -148,20 +148,10 @@ bool cpusets_enabled() {
     return enabled;
 }
 
-static bool schedtune_enabled() {
-    return (CgroupMap::GetInstance().FindController("schedtune").IsUsable());
-}
-
 static bool cpuctl_enabled() {
     return (CgroupMap::GetInstance().FindController("cpu").IsUsable());
 }
 
-bool schedboost_enabled() {
-    static bool enabled = schedtune_enabled() || cpuctl_enabled();
-
-    return enabled;
-}
-
 static int getCGroupSubsys(pid_t tid, const char* subsys, std::string& subgroup) {
     auto controller = CgroupMap::GetInstance().FindController(subsys);
 
@@ -201,9 +191,8 @@ int get_sched_policy(pid_t tid, SchedPolicy* policy) {
     }
 
     std::string group;
-    if (schedboost_enabled()) {
-        if ((getCGroupSubsys(tid, "schedtune", group) < 0) &&
-            (getCGroupSubsys(tid, "cpu", group) < 0)) {
+    if (cpuctl_enabled()) {
+        if (getCGroupSubsys(tid, "cpu", group) < 0) {
             LOG(ERROR) << "Failed to find cpu cgroup for tid " << tid;
             return -1;
         }

From a23013dd4ba9d9de8a2eec75c5e0d4f406cf8a58 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Mon, 23 Sep 2024 14:46:11 -0700
Subject: [PATCH 1139/1487] libsnapshot: configure num worker threads

Forward number of worker threads build configuration to snapuserd. these
are the threads that will be used to serve i/o requests to dm-user.

Bug: 361438985
Test: OTA with print logs post OTA reboot
Change-Id: Ib70a3cb8766b96232ea6f97effece041534dc922
---
 .../android/snapshot/snapshot.proto           |  2 ++
 .../include/libsnapshot/snapshot.h            |  4 ++++
 fs_mgr/libsnapshot/snapshot.cpp               | 21 +++++++++++++++----
 .../snapuserd/snapuserd_daemon.cpp            |  6 ++++--
 .../user-space-merge/snapuserd_server.cpp     | 20 ++++++++++--------
 .../user-space-merge/snapuserd_server.h       |  1 +
 6 files changed, 39 insertions(+), 15 deletions(-)

diff --git a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
index 62f99013e97f..5fb71a37b71a 100644
--- a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
+++ b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
@@ -233,6 +233,8 @@ message SnapshotUpdateStatus {
     // Number of cow operations to be merged at once
     uint32 cow_op_merge_size = 13;
 
+    // Number of worker threads to serve I/O from dm-user
+    uint32 num_worker_threads = 14;
 }
 
 // Next: 10
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index 7ae55db316b5..8ff41dbcba9f 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -838,6 +838,10 @@ class SnapshotManager final : public ISnapshotManager {
 
     // Get value of maximum cow op merge size
     uint32_t GetUpdateCowOpMergeSize(LockedFile* lock);
+
+    // Get number of threads to perform post OTA boot verification
+    uint32_t GetUpdateWorkerCount(LockedFile* lock);
+
     // Wrapper around libdm, with diagnostics.
     bool DeleteDeviceIfExists(const std::string& name,
                               const std::chrono::milliseconds& timeout_ms = {});
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 6c3bedd865b5..05dec68d5766 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -1235,8 +1235,8 @@ auto SnapshotManager::CheckMergeState(LockedFile* lock,
                 wrong_phase = true;
                 break;
             default:
-                LOG(ERROR) << "Unknown merge status for \"" << snapshot << "\": "
-                           << "\"" << result.state << "\"";
+                LOG(ERROR) << "Unknown merge status for \"" << snapshot << "\": " << "\""
+                           << result.state << "\"";
                 if (failure_code == MergeFailureCode::Ok) {
                     failure_code = MergeFailureCode::UnexpectedMergeState;
                 }
@@ -1725,6 +1725,10 @@ bool SnapshotManager::PerformInitTransition(InitTransition transition,
         if (cow_op_merge_size != 0) {
             snapuserd_argv->emplace_back("-cow_op_merge_size=" + std::to_string(cow_op_merge_size));
         }
+        uint32_t worker_count = GetUpdateWorkerCount(lock.get());
+        if (worker_count != 0) {
+            snapuserd_argv->emplace_back("-worker_count=" + std::to_string(worker_count));
+        }
     }
 
     size_t num_cows = 0;
@@ -2152,6 +2156,11 @@ uint32_t SnapshotManager::GetUpdateCowOpMergeSize(LockedFile* lock) {
     return update_status.cow_op_merge_size();
 }
 
+uint32_t SnapshotManager::GetUpdateWorkerCount(LockedFile* lock) {
+    SnapshotUpdateStatus update_status = ReadSnapshotUpdateStatus(lock);
+    return update_status.num_worker_threads();
+}
+
 bool SnapshotManager::MarkSnapuserdFromSystem() {
     auto path = GetSnapuserdFromSystemPath();
 
@@ -3140,6 +3149,7 @@ bool SnapshotManager::WriteUpdateState(LockedFile* lock, UpdateState state,
         status.set_legacy_snapuserd(old_status.legacy_snapuserd());
         status.set_o_direct(old_status.o_direct());
         status.set_cow_op_merge_size(old_status.cow_op_merge_size());
+        status.set_num_worker_threads(old_status.num_worker_threads());
     }
     return WriteSnapshotUpdateStatus(lock, status);
 }
@@ -3524,6 +3534,9 @@ Return SnapshotManager::CreateUpdateSnapshots(const DeltaArchiveManifest& manife
         }
         status.set_cow_op_merge_size(
                 android::base::GetUintProperty<uint32_t>("ro.virtual_ab.cow_op_merge_size", 0));
+        status.set_num_worker_threads(
+                android::base::GetUintProperty<uint32_t>("ro.virtual_ab.num_worker_threads", 0));
+
     } else if (legacy_compression) {
         LOG(INFO) << "Virtual A/B using legacy snapuserd";
     } else {
@@ -3960,6 +3973,7 @@ bool SnapshotManager::Dump(std::ostream& os) {
     ss << "Using io_uring: " << update_status.io_uring_enabled() << std::endl;
     ss << "Using o_direct: " << update_status.o_direct() << std::endl;
     ss << "Cow op merge size (0 for uncapped): " << update_status.cow_op_merge_size() << std::endl;
+    ss << "Worker thread count: " << update_status.num_worker_threads() << std::endl;
     ss << "Using XOR compression: " << GetXorCompressionEnabledProperty() << std::endl;
     ss << "Current slot: " << device_->GetSlotSuffix() << std::endl;
     ss << "Boot indicator: booting from " << GetCurrentSlot() << " slot" << std::endl;
@@ -4576,8 +4590,7 @@ bool SnapshotManager::DeleteDeviceIfExists(const std::string& name,
         }
     }
 
-    LOG(ERROR) << "Device-mapper device " << name << "(" << full_path << ")"
-               << " still in use."
+    LOG(ERROR) << "Device-mapper device " << name << "(" << full_path << ")" << " still in use."
                << "  Probably a file descriptor was leaked or held open, or a loop device is"
                << " attached.";
     return false;
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
index dd2dd565907b..32e16cc80946 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_daemon.cpp
@@ -31,6 +31,7 @@ DEFINE_bool(user_snapshot, false, "If true, user-space snapshots are used");
 DEFINE_bool(io_uring, false, "If true, io_uring feature is enabled");
 DEFINE_bool(o_direct, false, "If true, enable direct reads on source device");
 DEFINE_int32(cow_op_merge_size, 0, "number of operations to be processed at once");
+DEFINE_int32(worker_count, 4, "number of worker threads used to serve I/O requests to dm-user");
 
 namespace android {
 namespace snapshot {
@@ -114,8 +115,9 @@ bool Daemon::StartServerForUserspaceSnapshots(int arg_start, int argc, char** ar
             LOG(ERROR) << "Malformed message, expected at least four sub-arguments.";
             return false;
         }
-        auto handler = user_server_.AddHandler(parts[0], parts[1], parts[2], parts[3],
-                                               FLAGS_o_direct, FLAGS_cow_op_merge_size);
+        auto handler =
+                user_server_.AddHandler(parts[0], parts[1], parts[2], parts[3], FLAGS_worker_count,
+                                        FLAGS_o_direct, FLAGS_cow_op_merge_size);
         if (!handler || !user_server_.StartHandler(parts[0])) {
             return false;
         }
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index 013df350bbad..3bb8a3037344 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -35,6 +35,7 @@
 #include <snapuserd/dm_user_block_server.h>
 #include <snapuserd/snapuserd_client.h>
 #include "snapuserd_server.h"
+#include "user-space-merge/snapuserd_core.h"
 
 namespace android {
 namespace snapshot {
@@ -125,7 +126,7 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
             return Sendmsg(fd, "fail");
         }
 
-        auto handler = AddHandler(out[1], out[2], out[3], out[4]);
+        auto handler = AddHandler(out[1], out[2], out[3], out[4], std::nullopt);
         if (!handler) {
             return Sendmsg(fd, "fail");
         }
@@ -341,12 +342,11 @@ void UserSnapshotServer::Interrupt() {
     SetTerminating();
 }
 
-std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string& misc_name,
-                                                              const std::string& cow_device_path,
-                                                              const std::string& backing_device,
-                                                              const std::string& base_path_merge,
-                                                              const bool o_direct,
-                                                              uint32_t cow_op_merge_size) {
+std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(
+        const std::string& misc_name, const std::string& cow_device_path,
+        const std::string& backing_device, const std::string& base_path_merge,
+        std::optional<uint32_t> num_worker_threads, const bool o_direct,
+        uint32_t cow_op_merge_size) {
     // We will need multiple worker threads only during
     // device boot after OTA. For all other purposes,
     // one thread is sufficient. We don't want to consume
@@ -355,7 +355,9 @@ std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string&
     //
     // During boot up, we need multiple threads primarily for
     // update-verification.
-    int num_worker_threads = kNumWorkerThreads;
+    if (!num_worker_threads.has_value()) {
+        num_worker_threads = kNumWorkerThreads;
+    }
     if (is_socket_present_) {
         num_worker_threads = 1;
     }
@@ -368,7 +370,7 @@ std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string&
     auto opener = block_server_factory_->CreateOpener(misc_name);
 
     return handlers_->AddHandler(misc_name, cow_device_path, backing_device, base_path_merge,
-                                 opener, num_worker_threads, io_uring_enabled_, o_direct,
+                                 opener, num_worker_threads.value(), io_uring_enabled_, o_direct,
                                  cow_op_merge_size);
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
index ceea36ae4638..f002e8d9a676 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.h
@@ -87,6 +87,7 @@ class UserSnapshotServer {
                                               const std::string& cow_device_path,
                                               const std::string& backing_device,
                                               const std::string& base_path_merge,
+                                              std::optional<uint32_t> num_worker_threads,
                                               bool o_direct = false,
                                               uint32_t cow_op_merge_size = 0);
     bool StartHandler(const std::string& misc_name);

From 6f451a9c8ceec473745bf7e6b67c9776cbb5e1a1 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 2 Oct 2024 19:35:21 -0700
Subject: [PATCH 1140/1487] init: Issue a wipe on boot if trade-in mode was
 active.

This modifies first-stage init to check for /metadata/tradeinmode/wipe
as soon as /metadata is mounted. If the file exists, we issue a request
to the bootloader to reboot to recovery and wipe /data. Since this also
wipes /metadata, the wipe indicator will be removed too.

In case some kind of failure happens in recovery, this also implements a
quick-and-dirty counter mechanism to fallback to the recovery menu.

Bug: 307713521
Test: touch /metadata/tradeinmode/wipe && adb reboot
Change-Id: I2d05903cadcdadf9c05f6736454db790a9e6b5bb
---
 init/Android.bp            |  1 +
 init/first_stage_mount.cpp | 57 ++++++++++++++++++++++++++++++++++++++
 rootdir/init.rc            |  1 +
 3 files changed, 59 insertions(+)

diff --git a/init/Android.bp b/init/Android.bp
index 18a79d6c4285..5e06000a4a96 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -390,6 +390,7 @@ init_first_stage_cc_defaults {
         "libsnapshot_init",
         "update_metadata-protos",
         "libprocinfo",
+        "libbootloader_message",
     ],
 
     static_executable: true,
diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index ece430b70e21..f303815b0d1b 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -32,9 +32,12 @@
 #include <android-base/chrono_utils.h>
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include <android-base/parseint.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
 #include <android/avf_cc_flags.h>
+#include <bootloader_message/bootloader_message.h>
+#include <cutils/android_reboot.h>
 #include <fs_avb/fs_avb.h>
 #include <fs_mgr.h>
 #include <fs_mgr_dm_linear.h>
@@ -46,6 +49,7 @@
 
 #include "block_dev_initializer.h"
 #include "devices.h"
+#include "reboot_utils.h"
 #include "result.h"
 #include "snapuserd_transition.h"
 #include "switch_root.h"
@@ -111,6 +115,8 @@ class FirstStageMountVBootV2 : public FirstStageMount {
     bool GetDmVerityDevices(std::set<std::string>* devices);
     bool SetUpDmVerity(FstabEntry* fstab_entry);
 
+    void RequestTradeInModeWipeIfNeeded();
+
     bool InitAvbHandle();
 
     bool need_dm_verity_;
@@ -263,6 +269,8 @@ bool FirstStageMountVBootV2::DoCreateDevices() {
 }
 
 bool FirstStageMountVBootV2::DoFirstStageMount() {
+    RequestTradeInModeWipeIfNeeded();
+
     if (!IsDmLinearEnabled() && fstab_.empty()) {
         // Nothing to mount.
         LOG(INFO) << "First stage mount skipped (missing/incompatible/empty fstab in device tree)";
@@ -883,6 +891,55 @@ bool FirstStageMountVBootV2::InitAvbHandle() {
     return true;
 }
 
+void FirstStageMountVBootV2::RequestTradeInModeWipeIfNeeded() {
+    static constexpr const char* kWipeIndicator = "/metadata/tradeinmode/wipe";
+    static constexpr size_t kWipeAttempts = 3;
+
+    if (access(kWipeIndicator, R_OK) == -1) {
+        return;
+    }
+
+    // Write a counter to the wipe indicator, to try and prevent boot loops if
+    // recovery fails to wipe data.
+    uint32_t counter = 0;
+    std::string contents;
+    if (ReadFileToString(kWipeIndicator, &contents)) {
+        android::base::ParseUint(contents, &counter);
+        contents = std::to_string(++counter);
+        if (android::base::WriteStringToFile(contents, kWipeIndicator)) {
+            sync();
+        } else {
+            PLOG(ERROR) << "Failed to update " << kWipeIndicator;
+        }
+    } else {
+        PLOG(ERROR) << "Failed to read " << kWipeIndicator;
+    }
+
+    std::string err;
+    auto misc_device = get_misc_blk_device(&err);
+    if (misc_device.empty()) {
+        LOG(FATAL) << "Could not find misc device: " << err;
+    }
+
+    auto misc_name = android::base::Basename(misc_device);
+    if (!block_dev_init_.InitDevices({misc_name})) {
+        LOG(FATAL) << "Could not find misc device: " << misc_device;
+    }
+
+    // If we've failed to wipe three times, don't include the wipe command. This
+    // will force us to boot into the recovery menu instead where a manual wipe
+    // can be attempted.
+    std::vector<std::string> options;
+    if (counter <= kWipeAttempts) {
+        options.emplace_back("--wipe_data");
+        options.emplace_back("--reason=tradeinmode");
+    }
+    if (!write_bootloader_message(options, &err)) {
+        LOG(FATAL) << "Could not issue wipe: " << err;
+    }
+    RebootSystem(ANDROID_RB_RESTART2, "recovery", "reboot,tradeinmode,wipe");
+}
+
 void SetInitAvbVersionInRecovery() {
     if (!IsRecoveryMode()) {
         LOG(INFO) << "Skipped setting INIT_AVB_VERSION (not in recovery mode)";
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 1acd637749f8..f43c71855bc7 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -644,6 +644,7 @@ on post-fs
     mkdir /metadata/ota 0750 root system
     mkdir /metadata/ota/snapshots 0750 root system
     mkdir /metadata/watchdog 0770 root system
+    mkdir /metadata/tradeinmode 0770 root system
 
     mkdir /metadata/apex 0700 root system
     mkdir /metadata/apex/sessions 0700 root system

From f29f1a2a3832aa33863e30c851e6f6565e78ad73 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= <arve@android.com>
Date: Wed, 25 Sep 2024 16:21:50 -0700
Subject: [PATCH 1141/1487] trusty-ut-ctrl: Allow stream mode

When using vsock in stream mode (or any other stream mode connection)
message boundaries are not preserved, so the original messages can get
both split and merged. The TEST_MESSAGE and TEST_TEXT messages don't
have a length field which makes it imposible to support every possible
message that can be sent over a channel that preserves message
boundaries. Since the current message header types don't contain any
printable character, we assume any of these characters in a message
payload means that two messages got merged, so we split them back up.
Additionally, if we receive a message that does not start with a valid
message header, we assume it is a continuation of the previous message.

Test: trusty-ut-ctrl -D VSOCK:2:1 com.android.libctest ^Z fg
Bug: 298705967
Change-Id: I0e470a23664268f86e4defd824c47be3479c8f25
---
 trusty/utils/trusty-ut-ctrl/ut-ctrl.c | 57 +++++++++++++++++++++------
 1 file changed, 44 insertions(+), 13 deletions(-)

diff --git a/trusty/utils/trusty-ut-ctrl/ut-ctrl.c b/trusty/utils/trusty-ut-ctrl/ut-ctrl.c
index 6cc66707e73c..31cfd4c79aae 100644
--- a/trusty/utils/trusty-ut-ctrl/ut-ctrl.c
+++ b/trusty/utils/trusty-ut-ctrl/ut-ctrl.c
@@ -95,12 +95,26 @@ enum test_message_header {
     TEST_FAILED = 1,
     TEST_MESSAGE = 2,
     TEST_TEXT = 3,
+    TEST_OPCODE_COUNT,
 };
 
+static int get_msg_len(const char* buf, int max_buf_len) {
+    int buf_len;
+    for (buf_len = 0; buf_len < max_buf_len; buf_len++) {
+        if ((unsigned char)buf[buf_len] < TEST_OPCODE_COUNT) {
+            break;
+        }
+    }
+    return buf_len;
+}
+
 static int run_trusty_unitest(const char* utapp) {
     int fd;
-    int rc;
-    char rx_buf[1024];
+    char read_buf[1024];
+    int read_len;
+    char* rx_buf;
+    int rx_buf_len;
+    int cmd = -1;
 
     /* connect to unitest app */
     fd = tipc_connect(dev_name, utapp);
@@ -110,22 +124,39 @@ static int run_trusty_unitest(const char* utapp) {
     }
 
     /* wait for test to complete */
+    rx_buf_len = 0;
     for (;;) {
-        rc = read(fd, rx_buf, sizeof(rx_buf));
-        if (rc <= 0 || rc >= (int)sizeof(rx_buf)) {
-            fprintf(stderr, "%s: Read failed: %d\n", __func__, rc);
-            tipc_close(fd);
-            return -1;
+        if (rx_buf_len == 0) {
+            read_len = read(fd, read_buf, sizeof(read_buf));
+            if (read_len <= 0 || read_len > (int)sizeof(read_buf)) {
+                fprintf(stderr, "%s: Read failed: %d, %s\n", __func__, read_len,
+                        read_len < 0 ? strerror(errno) : "");
+                tipc_close(fd);
+                return -1;
+            }
+            rx_buf = read_buf;
+            rx_buf_len = read_len;
+        }
+
+        int msg_len = get_msg_len(rx_buf, rx_buf_len);
+        if (msg_len == 0) {
+            cmd = rx_buf[0];
+            rx_buf++;
+            rx_buf_len--;
         }
 
-        if (rx_buf[0] == TEST_PASSED) {
+        if (cmd == TEST_PASSED) {
             break;
-        } else if (rx_buf[0] == TEST_FAILED) {
+        } else if (cmd == TEST_FAILED) {
             break;
-        } else if (rx_buf[0] == TEST_MESSAGE || rx_buf[0] == TEST_TEXT) {
-            write(STDOUT_FILENO, rx_buf + 1, rc - 1);
+        } else if (cmd == TEST_MESSAGE || cmd == TEST_TEXT) {
+            if (msg_len) {
+                write(STDOUT_FILENO, rx_buf, msg_len);
+                rx_buf += msg_len;
+                rx_buf_len -= msg_len;
+            }
         } else {
-            fprintf(stderr, "%s: Bad message header: %d\n", __func__, rx_buf[0]);
+            fprintf(stderr, "%s: Bad message header: %d\n", __func__, cmd);
             break;
         }
     }
@@ -133,7 +164,7 @@ static int run_trusty_unitest(const char* utapp) {
     /* close connection to unitest app */
     tipc_close(fd);
 
-    return rx_buf[0] == TEST_PASSED ? 0 : -1;
+    return cmd == TEST_PASSED ? 0 : -1;
 }
 
 int main(int argc, char** argv) {

From da77c2e1dc762a8d4930260ec6ec19447cce828c Mon Sep 17 00:00:00 2001
From: Rob Barnes <robbarnes@google.com>
Date: Wed, 18 Sep 2024 01:29:15 +0000
Subject: [PATCH 1142/1487] Change owner of ACPI BERT tables to system

Changes the owner of the following files to system:system:

* /sys/firmware/acpi/tables
* /sys/firmware/acpi/tables/BERT
* /sys/firmware/acpi/tables/data/BERT

This allows the bert_collector deamon to read these files for error reporting.

Bug: 357626966
Test: m && atest bert_collector_test

Change-Id: Iba3a169f1851566ee6fed6d41b538dae448bf811
---
 rootdir/init.rc | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 1acd637749f8..339f1bebadde 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1243,6 +1243,9 @@ on boot
     chown system system /sys/kernel/ipv4/tcp_rmem_min
     chown system system /sys/kernel/ipv4/tcp_rmem_def
     chown system system /sys/kernel/ipv4/tcp_rmem_max
+    chown system system /sys/firmware/acpi/tables
+    chown system system /sys/firmware/acpi/tables/BERT
+    chown system system /sys/firmware/acpi/tables/data/BERT
     chown root radio /proc/cmdline
     chown root system /proc/bootconfig
 

From ae4ce8ccc5933c8d1d557930021a0715bdaacf64 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 8 Aug 2024 16:11:21 +0000
Subject: [PATCH 1143/1487] libprocessgroup: Remove cgroup.rc file

The cgroup.rc file was introduced in 192aee782 ("libprocessgroup: Add
support for task profiles") back with the initial support for task
profiles. It was intended to optimize performance associated with cgroup
operations. However over time, supporting this file led to making
libprocessgroup code more complicated (such as the cgrouprc LLNDK
interface), and the file ended up getting mmaped into nearly every
process on Android even though only a handful of them actually use it.
Replacing this file with reading and parsing of cgroup information on
demand allows us to simplify and shrink libprocessgroup, and eliminates
thousands of unused mappings without negatively affecting boot time or
other performance metrics.

Bug: 349105928
Test: Verified with memcg v2 and MaxActivationDepth 1 on Cuttlefish, Raven, and Mokey
Change-Id: Ic3f01fdf7fda89a56ab80657e1cf4573156273e6
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   7 +-
 init/Android.bp                               |   1 -
 init/init.cpp                                 |   3 -
 libcutils/Android.bp                          |   2 +-
 libprocessgroup/Android.bp                    |   3 +-
 libprocessgroup/cgroup_map.cpp                |   4 +-
 libprocessgroup/cgrouprc/Android.bp           |   3 +-
 libprocessgroup/cgrouprc/a_cgroup_file.cpp    |  88 ++----
 libprocessgroup/cgrouprc/cgrouprc_internal.h  |   7 +-
 libprocessgroup/cgrouprc_format/Android.bp    |  13 -
 .../include/processgroup/processgroup.h       |   2 +-
 .../format/cgroup_file.h => internal.h}       |  23 +-
 libprocessgroup/setup/Android.bp              |   1 -
 libprocessgroup/setup/cgroup_descriptor.h     |  12 +-
 libprocessgroup/setup/cgroup_map_write.cpp    | 259 ++----------------
 libprocessgroup/util/Android.bp               |   8 +
 .../cgroup_controller.cpp                     |  12 +-
 libprocessgroup/util/cgroup_descriptor.cpp    |  38 +++
 .../include/processgroup}/cgroup_controller.h |  12 +-
 .../include/processgroup/cgroup_descriptor.h  |  45 +++
 .../util/include/processgroup/util.h          |  12 +-
 libprocessgroup/util/tests/util.cpp           |   2 -
 libprocessgroup/util/util.cpp                 | 197 ++++++++++++-
 23 files changed, 365 insertions(+), 389 deletions(-)
 rename libprocessgroup/{cgrouprc_format/include/processgroup/format/cgroup_file.h => internal.h} (54%)
 rename libprocessgroup/{cgrouprc_format => util}/cgroup_controller.cpp (90%)
 create mode 100644 libprocessgroup/util/cgroup_descriptor.cpp
 rename libprocessgroup/{cgrouprc_format/include/processgroup/format => util/include/processgroup}/cgroup_controller.h (87%)
 create mode 100644 libprocessgroup/util/include/processgroup/cgroup_descriptor.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 298fd9f3095b..083068b54bfe 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -85,9 +85,9 @@ cc_library_static {
         "libsnapshot_cow",
         "liburing",
         "libprocessgroup",
+        "libprocessgroup_util",
         "libjsoncpp",
         "libcgrouprc",
-        "libcgrouprc_format",
     ],
     include_dirs: ["bionic/libc/kernel"],
     export_include_dirs: ["include"],
@@ -129,9 +129,9 @@ cc_defaults {
         "libsnapshot_cow",
         "libsnapuserd",
         "libprocessgroup",
+        "libprocessgroup_util",
         "libjsoncpp",
         "libcgrouprc",
-        "libcgrouprc_format",
         "libsnapuserd_client",
         "libz",
         "liblz4",
@@ -221,9 +221,9 @@ cc_defaults {
         "libsnapshot_cow",
         "libsnapuserd",
         "libprocessgroup",
+        "libprocessgroup_util",
         "libjsoncpp",
         "libcgrouprc",
-        "libcgrouprc_format",
         "liburing",
         "libz",
     ],
@@ -319,7 +319,6 @@ cc_binary_host {
         "libprocessgroup",
         "libjsoncpp",
         "libcgrouprc",
-        "libcgrouprc_format",
         "liburing",
         "libz",
     ],
diff --git a/init/Android.bp b/init/Android.bp
index 18a79d6c4285..8da2e7c2eaf4 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -163,7 +163,6 @@ libinit_cc_defaults {
         "libavb",
         "libavf_cc_flags",
         "libbootloader_message",
-        "libcgrouprc_format",
         "liblmkd_utils",
         "liblz4",
         "libzstd",
diff --git a/init/init.cpp b/init/init.cpp
index 6c8089926ae8..17498da6dce4 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -636,9 +636,6 @@ static Result<void> SetupCgroupsAction(const BuiltinArguments&) {
         LOG(INFO) << "Cgroups support in kernel is not enabled";
         return {};
     }
-    // Have to create <CGROUPS_RC_DIR> using make_dir function
-    // for appropriate sepolicy to be set for it
-    make_dir(android::base::Dirname(CGROUPS_RC_PATH), 0711);
     if (!CgroupSetup()) {
         return ErrnoError() << "Failed to setup cgroups";
     }
diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index 3c3eeb6631f3..fc4c571b7ba0 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -301,7 +301,7 @@ cc_defaults {
         android: {
             static_executable: true,
             static_libs: [
-                "libcgrouprc_format",
+                "libprocessgroup_util",
             ] + test_libraries + always_static_test_libraries,
         },
         not_windows: {
diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index a60bfe97344a..d623a1152e4a 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -17,7 +17,7 @@ soong_config_module_type {
 
 libprocessgroup_flag_aware_cc_defaults {
     name: "libprocessgroup_build_flags_cc",
-    cpp_std: "gnu++20",
+    cpp_std: "gnu++23",
     soong_config_variables: {
         memcg_v2_force_enabled: {
             cflags: [
@@ -116,5 +116,6 @@ cc_test {
     ],
     static_libs: [
         "libgmock",
+        "libprocessgroup_util",
     ],
 }
diff --git a/libprocessgroup/cgroup_map.cpp b/libprocessgroup/cgroup_map.cpp
index fb01cfda9ff3..aeccfe89b91b 100644
--- a/libprocessgroup/cgroup_map.cpp
+++ b/libprocessgroup/cgroup_map.cpp
@@ -151,7 +151,7 @@ bool CgroupMap::LoadRcFile() {
 void CgroupMap::Print() const {
     if (!loaded_) {
         LOG(ERROR) << "CgroupMap::Print called for [" << getpid()
-                   << "] failed, RC file was not initialized properly";
+                   << "] failed, cgroups were not initialized properly";
         return;
     }
     LOG(INFO) << "File version = " << ACgroupFile_getVersion();
@@ -221,7 +221,7 @@ int CgroupMap::ActivateControllers(const std::string& path) const {
             if (__builtin_available(android 36, *)) {
                 max_activation_depth = ACgroupController_getMaxActivationDepth(controller);
             }
-            const int depth = util::GetCgroupDepth(ACgroupController_getPath(controller), path);
+            const int depth = GetCgroupDepth(ACgroupController_getPath(controller), path);
 
             if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
                 std::string str("+");
diff --git a/libprocessgroup/cgrouprc/Android.bp b/libprocessgroup/cgrouprc/Android.bp
index cb912476e26a..38b2fa31d4f3 100644
--- a/libprocessgroup/cgrouprc/Android.bp
+++ b/libprocessgroup/cgrouprc/Android.bp
@@ -49,7 +49,8 @@ cc_library {
         "libbase",
     ],
     static_libs: [
-        "libcgrouprc_format",
+        "libjsoncpp",
+        "libprocessgroup_util",
     ],
     stubs: {
         symbol_file: "libcgrouprc.map.txt",
diff --git a/libprocessgroup/cgrouprc/a_cgroup_file.cpp b/libprocessgroup/cgrouprc/a_cgroup_file.cpp
index e26d84114378..33c8376f4cb6 100644
--- a/libprocessgroup/cgrouprc/a_cgroup_file.cpp
+++ b/libprocessgroup/cgrouprc/a_cgroup_file.cpp
@@ -14,93 +14,51 @@
  * limitations under the License.
  */
 
-#include <sys/mman.h>
-#include <sys/stat.h>
-
-#include <memory>
+#include <iterator>
 
 #include <android-base/logging.h>
-#include <android-base/stringprintf.h>
-#include <android-base/unique_fd.h>
 #include <android/cgrouprc.h>
-#include <processgroup/processgroup.h>
+#include <processgroup/util.h>
 
 #include "cgrouprc_internal.h"
 
-using android::base::StringPrintf;
-using android::base::unique_fd;
-
-using android::cgrouprc::format::CgroupController;
-using android::cgrouprc::format::CgroupFile;
-
-static CgroupFile* LoadRcFile() {
-    struct stat sb;
-
-    unique_fd fd(TEMP_FAILURE_RETRY(open(CGROUPS_RC_PATH, O_RDONLY | O_CLOEXEC)));
-    if (fd < 0) {
-        PLOG(ERROR) << "open() failed for " << CGROUPS_RC_PATH;
-        return nullptr;
-    }
-
-    if (fstat(fd, &sb) < 0) {
-        PLOG(ERROR) << "fstat() failed for " << CGROUPS_RC_PATH;
-        return nullptr;
-    }
-
-    size_t file_size = sb.st_size;
-    if (file_size < sizeof(CgroupFile)) {
-        LOG(ERROR) << "Invalid file format " << CGROUPS_RC_PATH;
+static CgroupDescriptorMap* LoadDescriptors() {
+    CgroupDescriptorMap* descriptors = new CgroupDescriptorMap;
+    if (!ReadDescriptors(descriptors)) {
+        LOG(ERROR) << "Failed to load cgroup description file";
         return nullptr;
     }
-
-    CgroupFile* file_data = (CgroupFile*)mmap(nullptr, file_size, PROT_READ, MAP_SHARED, fd, 0);
-    if (file_data == MAP_FAILED) {
-        PLOG(ERROR) << "Failed to mmap " << CGROUPS_RC_PATH;
-        return nullptr;
-    }
-
-    if (file_data->version_ != CgroupFile::FILE_CURR_VERSION) {
-        LOG(ERROR) << CGROUPS_RC_PATH << " file version mismatch";
-        munmap(file_data, file_size);
-        return nullptr;
-    }
-
-    auto expected = sizeof(CgroupFile) + file_data->controller_count_ * sizeof(CgroupController);
-    if (file_size != expected) {
-        LOG(ERROR) << CGROUPS_RC_PATH << " file has invalid size, expected " << expected
-                   << ", actual " << file_size;
-        munmap(file_data, file_size);
-        return nullptr;
-    }
-
-    return file_data;
+    return descriptors;
 }
 
-static CgroupFile* GetInstance() {
+static const CgroupDescriptorMap* GetInstance() {
     // Deliberately leak this object (not munmap) to avoid a race between destruction on
     // process exit and concurrent access from another thread.
-    static auto* file = LoadRcFile();
-    return file;
+    static const CgroupDescriptorMap* descriptors = LoadDescriptors();
+    return descriptors;
 }
 
 uint32_t ACgroupFile_getVersion() {
-    auto file = GetInstance();
-    if (file == nullptr) return 0;
-    return file->version_;
+    static constexpr uint32_t FILE_VERSION_1 = 1;
+    auto descriptors = GetInstance();
+    if (descriptors == nullptr) return 0;
+    // There has only ever been one version, and there will be no more since cgroup.rc is no more
+    return FILE_VERSION_1;
 }
 
 uint32_t ACgroupFile_getControllerCount() {
-    auto file = GetInstance();
-    if (file == nullptr) return 0;
-    return file->controller_count_;
+    auto descriptors = GetInstance();
+    if (descriptors == nullptr) return 0;
+    return descriptors->size();
 }
 
 const ACgroupController* ACgroupFile_getController(uint32_t index) {
-    auto file = GetInstance();
-    if (file == nullptr) return nullptr;
-    CHECK(index < file->controller_count_);
+    auto descriptors = GetInstance();
+    if (descriptors == nullptr) return nullptr;
+    CHECK(index < descriptors->size());
     // Although the object is not actually an ACgroupController object, all ACgroupController_*
     // functions implicitly convert ACgroupController* back to CgroupController* before invoking
     // member functions.
-    return static_cast<ACgroupController*>(&file->controllers_[index]);
+    const CgroupController* p = std::next(descriptors->begin(), index)->second.controller();
+    return static_cast<const ACgroupController*>(p);
 }
diff --git a/libprocessgroup/cgrouprc/cgrouprc_internal.h b/libprocessgroup/cgrouprc/cgrouprc_internal.h
index cd02f0304f17..d517703467d3 100644
--- a/libprocessgroup/cgrouprc/cgrouprc_internal.h
+++ b/libprocessgroup/cgrouprc/cgrouprc_internal.h
@@ -16,9 +16,6 @@
 
 #pragma once
 
-#include <android/cgrouprc.h>
+#include <processgroup/cgroup_controller.h>
 
-#include <processgroup/format/cgroup_controller.h>
-#include <processgroup/format/cgroup_file.h>
-
-struct ACgroupController : android::cgrouprc::format::CgroupController {};
+struct ACgroupController : CgroupController {};
diff --git a/libprocessgroup/cgrouprc_format/Android.bp b/libprocessgroup/cgrouprc_format/Android.bp
index 059092419b87..6f9ab3e73e36 100644
--- a/libprocessgroup/cgrouprc_format/Android.bp
+++ b/libprocessgroup/cgrouprc_format/Android.bp
@@ -23,17 +23,4 @@ cc_library_static {
     vendor_ramdisk_available: true,
     recovery_available: true,
     native_bridge_supported: true,
-    srcs: [
-        "cgroup_controller.cpp",
-    ],
-    cflags: [
-        "-Wall",
-        "-Werror",
-    ],
-    export_include_dirs: [
-        "include",
-    ],
-    shared_libs: [
-        "libbase",
-    ],
 }
diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index ffffeb48b0c1..805775744e32 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -57,7 +57,7 @@ __BEGIN_DECLS
 
 bool SetProcessProfilesCached(uid_t uid, pid_t pid, const std::vector<std::string>& profiles);
 
-static constexpr const char* CGROUPS_RC_PATH = "/dev/cgroup_info/cgroup.rc";
+[[deprecated]] static constexpr const char* CGROUPS_RC_PATH = "/dev/cgroup_info/cgroup.rc";
 
 bool UsePerAppMemcg();
 
diff --git a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_file.h b/libprocessgroup/internal.h
similarity index 54%
rename from libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_file.h
rename to libprocessgroup/internal.h
index 2d9786fe6794..ef855790d6df 100644
--- a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_file.h
+++ b/libprocessgroup/internal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,23 +16,6 @@
 
 #pragma once
 
-#include <cstdint>
+#include <string>
 
-#include <processgroup/format/cgroup_controller.h>
-
-namespace android {
-namespace cgrouprc {
-namespace format {
-
-struct CgroupFile {
-    uint32_t version_;
-    uint32_t controller_count_;
-    CgroupController controllers_[];
-
-    static constexpr uint32_t FILE_VERSION_1 = 1;
-    static constexpr uint32_t FILE_CURR_VERSION = FILE_VERSION_1;
-};
-
-}  // namespace format
-}  // namespace cgrouprc
-}  // namespace android
+static const std::string CGROUP_V2_ROOT_DEFAULT = "/sys/fs/cgroup";
\ No newline at end of file
diff --git a/libprocessgroup/setup/Android.bp b/libprocessgroup/setup/Android.bp
index 1a4ad0118ac4..cc6c67cf4fb1 100644
--- a/libprocessgroup/setup/Android.bp
+++ b/libprocessgroup/setup/Android.bp
@@ -33,7 +33,6 @@ cc_library_shared {
         "libjsoncpp",
     ],
     static_libs: [
-        "libcgrouprc_format",
         "libprocessgroup_util",
     ],
     header_libs: [
diff --git a/libprocessgroup/setup/cgroup_descriptor.h b/libprocessgroup/setup/cgroup_descriptor.h
index 06ce186fde7a..1afd2ee9ceb4 100644
--- a/libprocessgroup/setup/cgroup_descriptor.h
+++ b/libprocessgroup/setup/cgroup_descriptor.h
@@ -21,10 +21,7 @@
 
 #include <sys/stat.h>
 
-#include <processgroup/format/cgroup_controller.h>
-
-namespace android {
-namespace cgrouprc {
+#include <processgroup/cgroup_controller.h>
 
 // Complete controller description for mounting cgroups
 class CgroupDescriptor {
@@ -33,7 +30,7 @@ class CgroupDescriptor {
                      mode_t mode, const std::string& uid, const std::string& gid, uint32_t flags,
                      uint32_t max_activation_depth);
 
-    const format::CgroupController* controller() const { return &controller_; }
+    const CgroupController* controller() const { return &controller_; }
     mode_t mode() const { return mode_; }
     std::string uid() const { return uid_; }
     std::string gid() const { return gid_; }
@@ -41,11 +38,8 @@ class CgroupDescriptor {
     void set_mounted(bool mounted);
 
   private:
-    format::CgroupController controller_;
+    CgroupController controller_;
     mode_t mode_ = 0;
     std::string uid_;
     std::string gid_;
 };
-
-}  // namespace cgrouprc
-}  // namespace android
diff --git a/libprocessgroup/setup/cgroup_map_write.cpp b/libprocessgroup/setup/cgroup_map_write.cpp
index bd418747555f..82116800821d 100644
--- a/libprocessgroup/setup/cgroup_map_write.cpp
+++ b/libprocessgroup/setup/cgroup_map_write.cpp
@@ -22,45 +22,28 @@
 #include <fcntl.h>
 #include <grp.h>
 #include <pwd.h>
-#include <sys/mman.h>
 #include <sys/mount.h>
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <time.h>
 #include <unistd.h>
 
 #include <optional>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
-#include <android-base/properties.h>
-#include <android-base/stringprintf.h>
-#include <android-base/unique_fd.h>
-#include <android/cgrouprc.h>
-#include <json/reader.h>
-#include <json/value.h>
-#include <processgroup/format/cgroup_file.h>
+#include <processgroup/cgroup_descriptor.h>
 #include <processgroup/processgroup.h>
 #include <processgroup/setup.h>
 #include <processgroup/util.h>
 
 #include "../build_flags.h"
-#include "cgroup_descriptor.h"
-
-using android::base::GetUintProperty;
-using android::base::StringPrintf;
-using android::base::unique_fd;
-
-namespace android {
-namespace cgrouprc {
+#include "../internal.h"
 
 static constexpr const char* CGROUPS_DESC_FILE = "/etc/cgroups.json";
 static constexpr const char* CGROUPS_DESC_VENDOR_FILE = "/vendor/etc/cgroups.json";
 
 static constexpr const char* TEMPLATE_CGROUPS_DESC_API_FILE = "/etc/task_profiles/cgroups_%u.json";
 
-static const std::string CGROUP_V2_ROOT_DEFAULT = "/sys/fs/cgroup";
-
 static bool ChangeDirModeAndOwner(const std::string& path, mode_t mode, const std::string& uid,
                                   const std::string& gid, bool permissive_mode = false) {
     uid_t pw_uid = -1;
@@ -148,149 +131,15 @@ static bool Mkdir(const std::string& path, mode_t mode, const std::string& uid,
     return true;
 }
 
-static void MergeCgroupToDescriptors(std::map<std::string, CgroupDescriptor>* descriptors,
-                                     const Json::Value& cgroup, const std::string& name,
-                                     const std::string& root_path, int cgroups_version) {
-    const std::string cgroup_path = cgroup["Path"].asString();
-    std::string path;
-
-    if (!root_path.empty()) {
-        path = root_path;
-        if (cgroup_path != ".") {
-            path += "/";
-            path += cgroup_path;
-        }
-    } else {
-        path = cgroup_path;
-    }
-
-    uint32_t controller_flags = 0;
-
-    if (cgroup["NeedsActivation"].isBool() && cgroup["NeedsActivation"].asBool()) {
-        controller_flags |= CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION;
-    }
-
-    if (cgroup["Optional"].isBool() && cgroup["Optional"].asBool()) {
-        controller_flags |= CGROUPRC_CONTROLLER_FLAG_OPTIONAL;
-    }
-
-    uint32_t max_activation_depth = UINT32_MAX;
-    if (cgroup.isMember("MaxActivationDepth")) {
-        max_activation_depth = cgroup["MaxActivationDepth"].asUInt();
-    }
-
-    CgroupDescriptor descriptor(
-            cgroups_version, name, path, std::strtoul(cgroup["Mode"].asString().c_str(), 0, 8),
-            cgroup["UID"].asString(), cgroup["GID"].asString(), controller_flags,
-            max_activation_depth);
-
-    auto iter = descriptors->find(name);
-    if (iter == descriptors->end()) {
-        descriptors->emplace(name, descriptor);
-    } else {
-        iter->second = descriptor;
-    }
-}
-
-static const bool force_memcg_v2 = android::libprocessgroup_flags::force_memcg_v2();
-
-static bool ReadDescriptorsFromFile(const std::string& file_name,
-                                    std::map<std::string, CgroupDescriptor>* descriptors) {
-    std::vector<CgroupDescriptor> result;
-    std::string json_doc;
-
-    if (!android::base::ReadFileToString(file_name, &json_doc)) {
-        PLOG(ERROR) << "Failed to read task profiles from " << file_name;
-        return false;
-    }
-
-    Json::CharReaderBuilder builder;
-    std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
-    Json::Value root;
-    std::string errorMessage;
-    if (!reader->parse(&*json_doc.begin(), &*json_doc.end(), &root, &errorMessage)) {
-        LOG(ERROR) << "Failed to parse cgroups description: " << errorMessage;
-        return false;
-    }
-
-    if (root.isMember("Cgroups")) {
-        const Json::Value& cgroups = root["Cgroups"];
-        for (Json::Value::ArrayIndex i = 0; i < cgroups.size(); ++i) {
-            std::string name = cgroups[i]["Controller"].asString();
-
-            if (force_memcg_v2 && name == "memory") continue;
-
-            MergeCgroupToDescriptors(descriptors, cgroups[i], name, "", 1);
-        }
-    }
-
-    bool memcgv2_present = false;
-    std::string root_path;
-    if (root.isMember("Cgroups2")) {
-        const Json::Value& cgroups2 = root["Cgroups2"];
-        root_path = cgroups2["Path"].asString();
-        MergeCgroupToDescriptors(descriptors, cgroups2, CGROUPV2_HIERARCHY_NAME, "", 2);
-
-        const Json::Value& childGroups = cgroups2["Controllers"];
-        for (Json::Value::ArrayIndex i = 0; i < childGroups.size(); ++i) {
-            std::string name = childGroups[i]["Controller"].asString();
-
-            if (force_memcg_v2 && name == "memory") memcgv2_present = true;
-
-            MergeCgroupToDescriptors(descriptors, childGroups[i], name, root_path, 2);
-        }
-    }
-
-    if (force_memcg_v2 && !memcgv2_present) {
-        LOG(INFO) << "Forcing memcg to v2 hierarchy";
-        Json::Value memcgv2;
-        memcgv2["Controller"] = "memory";
-        memcgv2["NeedsActivation"] = true;
-        memcgv2["Path"] = ".";
-        memcgv2["Optional"] = true;  // In case of cgroup_disabled=memory, so we can still boot
-        MergeCgroupToDescriptors(descriptors, memcgv2, "memory",
-                                 root_path.empty() ? CGROUP_V2_ROOT_DEFAULT : root_path, 2);
-    }
-
-    return true;
-}
-
-static bool ReadDescriptors(std::map<std::string, CgroupDescriptor>* descriptors) {
-    // load system cgroup descriptors
-    if (!ReadDescriptorsFromFile(CGROUPS_DESC_FILE, descriptors)) {
-        return false;
-    }
-
-    // load API-level specific system cgroups descriptors if available
-    unsigned int api_level = GetUintProperty<unsigned int>("ro.product.first_api_level", 0);
-    if (api_level > 0) {
-        std::string api_cgroups_path =
-                android::base::StringPrintf(TEMPLATE_CGROUPS_DESC_API_FILE, api_level);
-        if (!access(api_cgroups_path.c_str(), F_OK) || errno != ENOENT) {
-            if (!ReadDescriptorsFromFile(api_cgroups_path, descriptors)) {
-                return false;
-            }
-        }
-    }
-
-    // load vendor cgroup descriptors if the file exists
-    if (!access(CGROUPS_DESC_VENDOR_FILE, F_OK) &&
-        !ReadDescriptorsFromFile(CGROUPS_DESC_VENDOR_FILE, descriptors)) {
-        return false;
-    }
-
-    return true;
-}
-
 // To avoid issues in sdk_mac build
 #if defined(__ANDROID__)
 
-static bool IsOptionalController(const format::CgroupController* controller) {
+static bool IsOptionalController(const CgroupController* controller) {
     return controller->flags() & CGROUPRC_CONTROLLER_FLAG_OPTIONAL;
 }
 
 static bool MountV2CgroupController(const CgroupDescriptor& descriptor) {
-    const format::CgroupController* controller = descriptor.controller();
+    const CgroupController* controller = descriptor.controller();
 
     // /sys/fs/cgroup is created by cgroup2 with specific selinux permissions,
     // try to create again in case the mount point is changed
@@ -324,7 +173,7 @@ static bool MountV2CgroupController(const CgroupDescriptor& descriptor) {
 }
 
 static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
-    const format::CgroupController* controller = descriptor.controller();
+    const CgroupController* controller = descriptor.controller();
 
     if (!Mkdir(controller->path(), descriptor.mode(), descriptor.uid(), descriptor.gid())) {
         LOG(ERROR) << "Failed to create directory for " << controller->name() << " cgroup";
@@ -338,7 +187,7 @@ static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
         std::string path = controller->path();
         path += "/cgroup.subtree_control";
 
-        if (!base::WriteStringToFile(str, path)) {
+        if (!android::base::WriteStringToFile(str, path)) {
             if (IsOptionalController(controller)) {
                 PLOG(INFO) << "Failed to activate optional controller " << controller->name()
                            << " at " << path;
@@ -353,7 +202,7 @@ static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
 }
 
 static bool MountV1CgroupController(const CgroupDescriptor& descriptor) {
-    const format::CgroupController* controller = descriptor.controller();
+    const CgroupController* controller = descriptor.controller();
 
     // mkdir <path> [mode] [owner] [group]
     if (!Mkdir(controller->path(), descriptor.mode(), descriptor.uid(), descriptor.gid())) {
@@ -388,7 +237,7 @@ static bool MountV1CgroupController(const CgroupDescriptor& descriptor) {
 }
 
 static bool SetupCgroup(const CgroupDescriptor& descriptor) {
-    const format::CgroupController* controller = descriptor.controller();
+    const CgroupController* controller = descriptor.controller();
 
     if (controller->version() == 2) {
         if (!strcmp(controller->name(), CGROUPV2_HIERARCHY_NAME)) {
@@ -410,35 +259,6 @@ static bool SetupCgroup(const CgroupDescriptor&) {
 
 #endif
 
-static bool WriteRcFile(const std::map<std::string, CgroupDescriptor>& descriptors) {
-    unique_fd fd(TEMP_FAILURE_RETRY(open(CGROUPS_RC_PATH, O_CREAT | O_WRONLY | O_TRUNC | O_CLOEXEC,
-                                         S_IRUSR | S_IRGRP | S_IROTH)));
-    if (fd < 0) {
-        PLOG(ERROR) << "open() failed for " << CGROUPS_RC_PATH;
-        return false;
-    }
-
-    format::CgroupFile fl;
-    fl.version_ = format::CgroupFile::FILE_CURR_VERSION;
-    fl.controller_count_ = descriptors.size();
-    int ret = TEMP_FAILURE_RETRY(write(fd, &fl, sizeof(fl)));
-    if (ret < 0) {
-        PLOG(ERROR) << "write() failed for " << CGROUPS_RC_PATH;
-        return false;
-    }
-
-    for (const auto& [name, descriptor] : descriptors) {
-        ret = TEMP_FAILURE_RETRY(
-                write(fd, descriptor.controller(), sizeof(format::CgroupController)));
-        if (ret < 0) {
-            PLOG(ERROR) << "write() failed for " << CGROUPS_RC_PATH;
-            return false;
-        }
-    }
-
-    return true;
-}
-
 CgroupDescriptor::CgroupDescriptor(uint32_t version, const std::string& name,
                                    const std::string& path, mode_t mode, const std::string& uid,
                                    const std::string& gid, uint32_t flags,
@@ -458,9 +278,6 @@ void CgroupDescriptor::set_mounted(bool mounted) {
     controller_.set_flags(flags);
 }
 
-}  // namespace cgrouprc
-}  // namespace android
-
 static std::optional<bool> MGLRUDisabled() {
     const std::string file_name = "/sys/kernel/mm/lru_gen/enabled";
     std::string content;
@@ -472,9 +289,8 @@ static std::optional<bool> MGLRUDisabled() {
     return content == "0x0000";
 }
 
-static std::optional<bool> MEMCGDisabled(
-        const std::map<std::string, android::cgrouprc::CgroupDescriptor>& descriptors) {
-    std::string cgroup_v2_root = android::cgrouprc::CGROUP_V2_ROOT_DEFAULT;
+static std::optional<bool> MEMCGDisabled(const CgroupDescriptorMap& descriptors) {
+    std::string cgroup_v2_root = CGROUP_V2_ROOT_DEFAULT;
     const auto it = descriptors.find(CGROUPV2_HIERARCHY_NAME);
     if (it == descriptors.end()) {
         LOG(WARNING) << "No Cgroups2 path found in cgroups.json. Vendor has modified Android, and "
@@ -495,14 +311,10 @@ static std::optional<bool> MEMCGDisabled(
     return content.find("memory") == std::string::npos;
 }
 
-static bool CreateV2SubHierarchy(
-        const std::string& path,
-        const std::map<std::string, android::cgrouprc::CgroupDescriptor>& descriptors) {
-    using namespace android::cgrouprc;
-
+static bool CreateV2SubHierarchy(const std::string& path, const CgroupDescriptorMap& descriptors) {
     const auto cgv2_iter = descriptors.find(CGROUPV2_HIERARCHY_NAME);
     if (cgv2_iter == descriptors.end()) return false;
-    const android::cgrouprc::CgroupDescriptor cgv2_descriptor = cgv2_iter->second;
+    const CgroupDescriptor cgv2_descriptor = cgv2_iter->second;
 
     if (!Mkdir(path, cgv2_descriptor.mode(), cgv2_descriptor.uid(), cgv2_descriptor.gid())) {
         PLOG(ERROR) << "Failed to create directory for " << path;
@@ -512,10 +324,10 @@ static bool CreateV2SubHierarchy(
     // Activate all v2 controllers in path so they can be activated in
     // children as they are created.
     for (const auto& [name, descriptor] : descriptors) {
-        const format::CgroupController* controller = descriptor.controller();
+        const CgroupController* controller = descriptor.controller();
         std::uint32_t flags = controller->flags();
         std::uint32_t max_activation_depth = controller->max_activation_depth();
-        const int depth = util::GetCgroupDepth(controller->path(), path);
+        const int depth = GetCgroupDepth(controller->path(), path);
 
         if (controller->version() == 2 && name != CGROUPV2_HIERARCHY_NAME &&
             flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
@@ -535,22 +347,13 @@ static bool CreateV2SubHierarchy(
 }
 
 bool CgroupSetup() {
-    using namespace android::cgrouprc;
-
-    std::map<std::string, CgroupDescriptor> descriptors;
+    CgroupDescriptorMap descriptors;
 
     if (getpid() != 1) {
         LOG(ERROR) << "Cgroup setup can be done only by init process";
         return false;
     }
 
-    // Make sure we do this only one time. No need for std::call_once because
-    // init is a single-threaded process
-    if (access(CGROUPS_RC_PATH, F_OK) == 0) {
-        LOG(WARNING) << "Attempt to call CgroupSetup() more than once";
-        return true;
-    }
-
     // load cgroups.json file
     if (!ReadDescriptors(&descriptors)) {
         LOG(ERROR) << "Failed to load cgroup description file";
@@ -559,15 +362,18 @@ bool CgroupSetup() {
 
     // setup cgroups
     for (auto& [name, descriptor] : descriptors) {
-        if (SetupCgroup(descriptor)) {
-            descriptor.set_mounted(true);
-        } else {
+        if (descriptor.controller()->flags() & CGROUPRC_CONTROLLER_FLAG_MOUNTED) {
+            LOG(WARNING) << "Attempt to call CgroupSetup() more than once";
+            return true;
+        }
+
+        if (!SetupCgroup(descriptor)) {
             // issue a warning and proceed with the next cgroup
             LOG(WARNING) << "Failed to setup " << name << " cgroup";
         }
     }
 
-    if (force_memcg_v2) {
+    if (android::libprocessgroup_flags::force_memcg_v2()) {
         if (MGLRUDisabled().value_or(false)) {
             LOG(WARNING) << "Memcg forced to v2 hierarchy with MGLRU disabled! "
                          << "Global reclaim performance will suffer.";
@@ -593,26 +399,5 @@ bool CgroupSetup() {
         }
     }
 
-    // mkdir <CGROUPS_RC_DIR> 0711 system system
-    if (!Mkdir(android::base::Dirname(CGROUPS_RC_PATH), 0711, "system", "system")) {
-        LOG(ERROR) << "Failed to create directory for " << CGROUPS_RC_PATH << " file";
-        return false;
-    }
-
-    // Generate <CGROUPS_RC_FILE> file which can be directly mmapped into
-    // process memory. This optimizes performance, memory usage
-    // and limits infrormation shared with unprivileged processes
-    // to the minimum subset of information from cgroups.json
-    if (!WriteRcFile(descriptors)) {
-        LOG(ERROR) << "Failed to write " << CGROUPS_RC_PATH << " file";
-        return false;
-    }
-
-    // chmod 0644 <CGROUPS_RC_PATH>
-    if (fchmodat(AT_FDCWD, CGROUPS_RC_PATH, 0644, AT_SYMLINK_NOFOLLOW) < 0) {
-        PLOG(ERROR) << "fchmodat() failed";
-        return false;
-    }
-
     return true;
 }
diff --git a/libprocessgroup/util/Android.bp b/libprocessgroup/util/Android.bp
index 54ba69b4eb70..1c74d4ed52e1 100644
--- a/libprocessgroup/util/Android.bp
+++ b/libprocessgroup/util/Android.bp
@@ -37,8 +37,16 @@ cc_library_static {
         "include",
     ],
     srcs: [
+        "cgroup_controller.cpp",
+        "cgroup_descriptor.cpp",
         "util.cpp",
     ],
+    shared_libs: [
+        "libbase",
+    ],
+    static_libs: [
+        "libjsoncpp",
+    ],
     defaults: ["libprocessgroup_build_flags_cc"],
 }
 
diff --git a/libprocessgroup/cgrouprc_format/cgroup_controller.cpp b/libprocessgroup/util/cgroup_controller.cpp
similarity index 90%
rename from libprocessgroup/cgrouprc_format/cgroup_controller.cpp
rename to libprocessgroup/util/cgroup_controller.cpp
index 0dd909a29150..fb4168075db5 100644
--- a/libprocessgroup/cgrouprc_format/cgroup_controller.cpp
+++ b/libprocessgroup/util/cgroup_controller.cpp
@@ -14,11 +14,9 @@
  * limitations under the License.
  */
 
-#include <processgroup/format/cgroup_controller.h>
+#include <processgroup/cgroup_controller.h>
 
-namespace android {
-namespace cgrouprc {
-namespace format {
+#include <cstring>
 
 CgroupController::CgroupController(uint32_t version, uint32_t flags, const std::string& name,
                                    const std::string& path, uint32_t max_activation_depth)
@@ -54,8 +52,4 @@ const char* CgroupController::path() const {
 
 void CgroupController::set_flags(uint32_t flags) {
     flags_ = flags;
-}
-
-}  // namespace format
-}  // namespace cgrouprc
-}  // namespace android
+}
\ No newline at end of file
diff --git a/libprocessgroup/util/cgroup_descriptor.cpp b/libprocessgroup/util/cgroup_descriptor.cpp
new file mode 100644
index 000000000000..4d3347f348f0
--- /dev/null
+++ b/libprocessgroup/util/cgroup_descriptor.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <processgroup/cgroup_descriptor.h>
+
+#include <processgroup/util.h>  // For flag values
+
+CgroupDescriptor::CgroupDescriptor(uint32_t version, const std::string& name,
+                                   const std::string& path, mode_t mode, const std::string& uid,
+                                   const std::string& gid, uint32_t flags,
+                                   uint32_t max_activation_depth)
+    : controller_(version, flags, name, path, max_activation_depth),
+      mode_(mode),
+      uid_(uid),
+      gid_(gid) {}
+
+void CgroupDescriptor::set_mounted(bool mounted) {
+    uint32_t flags = controller_.flags();
+    if (mounted) {
+        flags |= CGROUPRC_CONTROLLER_FLAG_MOUNTED;
+    } else {
+        flags &= ~CGROUPRC_CONTROLLER_FLAG_MOUNTED;
+    }
+    controller_.set_flags(flags);
+}
diff --git a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h b/libprocessgroup/util/include/processgroup/cgroup_controller.h
similarity index 87%
rename from libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
rename to libprocessgroup/util/include/processgroup/cgroup_controller.h
index c0c1f6034fe4..fe6a829a0e83 100644
--- a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
+++ b/libprocessgroup/util/include/processgroup/cgroup_controller.h
@@ -20,11 +20,7 @@
 #include <cstdint>
 #include <string>
 
-namespace android {
-namespace cgrouprc {
-namespace format {
-
-// Minimal controller description to be mmapped into process address space
+// Minimal controller description
 struct CgroupController {
   public:
     CgroupController() = default;
@@ -48,8 +44,4 @@ struct CgroupController {
     uint32_t max_activation_depth_ = UINT32_MAX;
     char name_[CGROUP_NAME_BUF_SZ] = {};
     char path_[CGROUP_PATH_BUF_SZ] = {};
-};
-
-}  // namespace format
-}  // namespace cgrouprc
-}  // namespace android
+};
\ No newline at end of file
diff --git a/libprocessgroup/util/include/processgroup/cgroup_descriptor.h b/libprocessgroup/util/include/processgroup/cgroup_descriptor.h
new file mode 100644
index 000000000000..1afd2ee9ceb4
--- /dev/null
+++ b/libprocessgroup/util/include/processgroup/cgroup_descriptor.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+#include <sys/stat.h>
+
+#include <processgroup/cgroup_controller.h>
+
+// Complete controller description for mounting cgroups
+class CgroupDescriptor {
+  public:
+    CgroupDescriptor(uint32_t version, const std::string& name, const std::string& path,
+                     mode_t mode, const std::string& uid, const std::string& gid, uint32_t flags,
+                     uint32_t max_activation_depth);
+
+    const CgroupController* controller() const { return &controller_; }
+    mode_t mode() const { return mode_; }
+    std::string uid() const { return uid_; }
+    std::string gid() const { return gid_; }
+
+    void set_mounted(bool mounted);
+
+  private:
+    CgroupController controller_;
+    mode_t mode_ = 0;
+    std::string uid_;
+    std::string gid_;
+};
diff --git a/libprocessgroup/util/include/processgroup/util.h b/libprocessgroup/util/include/processgroup/util.h
index 8d013af55164..d592a63477d2 100644
--- a/libprocessgroup/util/include/processgroup/util.h
+++ b/libprocessgroup/util/include/processgroup/util.h
@@ -16,10 +16,18 @@
 
 #pragma once
 
+#include <map>
 #include <string>
 
-namespace util {
+#include "cgroup_descriptor.h"
+
+// Duplicated from cgrouprc.h. Don't depend on libcgrouprc here.
+#define CGROUPRC_CONTROLLER_FLAG_MOUNTED 0x1
+#define CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION 0x2
+#define CGROUPRC_CONTROLLER_FLAG_OPTIONAL 0x4
 
 unsigned int GetCgroupDepth(const std::string& controller_root, const std::string& cgroup_path);
 
-}  // namespace util
+using CgroupControllerName = std::string;
+using CgroupDescriptorMap = std::map<CgroupControllerName, CgroupDescriptor>;
+bool ReadDescriptors(CgroupDescriptorMap* descriptors);
diff --git a/libprocessgroup/util/tests/util.cpp b/libprocessgroup/util/tests/util.cpp
index 1de7d6f3fb36..6caef8ee3910 100644
--- a/libprocessgroup/util/tests/util.cpp
+++ b/libprocessgroup/util/tests/util.cpp
@@ -18,8 +18,6 @@
 
 #include "gtest/gtest.h"
 
-using util::GetCgroupDepth;
-
 TEST(EmptyInputs, bothEmpty) {
     EXPECT_EQ(GetCgroupDepth({}, {}), 0);
 }
diff --git a/libprocessgroup/util/util.cpp b/libprocessgroup/util/util.cpp
index 9b88a223a617..bff4c6f1ac35 100644
--- a/libprocessgroup/util/util.cpp
+++ b/libprocessgroup/util/util.cpp
@@ -18,9 +18,33 @@
 
 #include <algorithm>
 #include <iterator>
+#include <optional>
+#include <string_view>
+
+#include <mntent.h>
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/properties.h>
+#include <android-base/stringprintf.h>
+#include <json/reader.h>
+#include <json/value.h>
+
+#include "../build_flags.h"
+#include "../internal.h"
+
+using android::base::GetUintProperty;
 
 namespace {
 
+constexpr const char* CGROUPS_DESC_FILE = "/etc/cgroups.json";
+constexpr const char* CGROUPS_DESC_VENDOR_FILE = "/vendor/etc/cgroups.json";
+constexpr const char* TEMPLATE_CGROUPS_DESC_API_FILE = "/etc/task_profiles/cgroups_%u.json";
+
+// This should match the publicly declared value in processgroup.h,
+// but we don't want this library to depend on libprocessgroup.
+constexpr std::string CGROUPV2_HIERARCHY_NAME_INTERNAL = "cgroup2";
+
 const char SEP = '/';
 
 std::string DeduplicateAndTrimSeparators(const std::string& path) {
@@ -42,9 +66,135 @@ std::string DeduplicateAndTrimSeparators(const std::string& path) {
     return ret;
 }
 
+void MergeCgroupToDescriptors(CgroupDescriptorMap* descriptors, const Json::Value& cgroup,
+                              const std::string& name, const std::string& root_path,
+                              int cgroups_version) {
+    const std::string cgroup_path = cgroup["Path"].asString();
+    std::string path;
+
+    if (!root_path.empty()) {
+        path = root_path;
+        if (cgroup_path != ".") {
+            path += "/";
+            path += cgroup_path;
+        }
+    } else {
+        path = cgroup_path;
+    }
+
+    uint32_t controller_flags = 0;
+
+    if (cgroup["NeedsActivation"].isBool() && cgroup["NeedsActivation"].asBool()) {
+        controller_flags |= CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION;
+    }
+
+    if (cgroup["Optional"].isBool() && cgroup["Optional"].asBool()) {
+        controller_flags |= CGROUPRC_CONTROLLER_FLAG_OPTIONAL;
+    }
+
+    uint32_t max_activation_depth = UINT32_MAX;
+    if (cgroup.isMember("MaxActivationDepth")) {
+        max_activation_depth = cgroup["MaxActivationDepth"].asUInt();
+    }
+
+    CgroupDescriptor descriptor(
+            cgroups_version, name, path, std::strtoul(cgroup["Mode"].asString().c_str(), 0, 8),
+            cgroup["UID"].asString(), cgroup["GID"].asString(), controller_flags,
+            max_activation_depth);
+
+    auto iter = descriptors->find(name);
+    if (iter == descriptors->end()) {
+        descriptors->emplace(name, descriptor);
+    } else {
+        iter->second = descriptor;
+    }
+}
+
+bool ReadDescriptorsFromFile(const std::string& file_name, CgroupDescriptorMap* descriptors) {
+    static constexpr bool force_memcg_v2 = android::libprocessgroup_flags::force_memcg_v2();
+    std::vector<CgroupDescriptor> result;
+    std::string json_doc;
+
+    if (!android::base::ReadFileToString(file_name, &json_doc)) {
+        PLOG(ERROR) << "Failed to read task profiles from " << file_name;
+        return false;
+    }
+
+    Json::CharReaderBuilder builder;
+    std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+    Json::Value root;
+    std::string errorMessage;
+    if (!reader->parse(&*json_doc.begin(), &*json_doc.end(), &root, &errorMessage)) {
+        LOG(ERROR) << "Failed to parse cgroups description: " << errorMessage;
+        return false;
+    }
+
+    if (root.isMember("Cgroups")) {
+        const Json::Value& cgroups = root["Cgroups"];
+        for (Json::Value::ArrayIndex i = 0; i < cgroups.size(); ++i) {
+            std::string name = cgroups[i]["Controller"].asString();
+
+            if (force_memcg_v2 && name == "memory") continue;
+
+            MergeCgroupToDescriptors(descriptors, cgroups[i], name, "", 1);
+        }
+    }
+
+    bool memcgv2_present = false;
+    std::string root_path;
+    if (root.isMember("Cgroups2")) {
+        const Json::Value& cgroups2 = root["Cgroups2"];
+        root_path = cgroups2["Path"].asString();
+        MergeCgroupToDescriptors(descriptors, cgroups2, CGROUPV2_HIERARCHY_NAME_INTERNAL, "", 2);
+
+        const Json::Value& childGroups = cgroups2["Controllers"];
+        for (Json::Value::ArrayIndex i = 0; i < childGroups.size(); ++i) {
+            std::string name = childGroups[i]["Controller"].asString();
+
+            if (force_memcg_v2 && name == "memory") memcgv2_present = true;
+
+            MergeCgroupToDescriptors(descriptors, childGroups[i], name, root_path, 2);
+        }
+    }
+
+    if (force_memcg_v2 && !memcgv2_present) {
+        LOG(INFO) << "Forcing memcg to v2 hierarchy";
+        Json::Value memcgv2;
+        memcgv2["Controller"] = "memory";
+        memcgv2["NeedsActivation"] = true;
+        memcgv2["Path"] = ".";
+        memcgv2["Optional"] = true;  // In case of cgroup_disabled=memory, so we can still boot
+        MergeCgroupToDescriptors(descriptors, memcgv2, "memory",
+                                 root_path.empty() ? CGROUP_V2_ROOT_DEFAULT : root_path, 2);
+    }
+
+    return true;
+}
+
+using MountDir = std::string;
+using MountOpts = std::string;
+static std::optional<std::map<MountDir, MountOpts>> ReadCgroupV1Mounts() {
+    FILE* fp = setmntent("/proc/mounts", "r");
+    if (fp == nullptr) {
+        PLOG(ERROR) << "Failed to read mounts";
+        return std::nullopt;
+    }
+
+    std::map<MountDir, MountOpts> mounts;
+    const std::string_view CGROUP_V1_TYPE = "cgroup";
+    for (mntent* mentry = getmntent(fp); mentry != nullptr; mentry = getmntent(fp)) {
+        if (mentry->mnt_type && CGROUP_V1_TYPE == mentry->mnt_type &&
+            mentry->mnt_dir && mentry->mnt_opts) {
+            mounts[mentry->mnt_dir] = mentry->mnt_opts;
+        }
+    }
+    endmntent(fp);
+
+    return mounts;
+}
+
 }  // anonymous namespace
 
-namespace util {
 
 unsigned int GetCgroupDepth(const std::string& controller_root, const std::string& cgroup_path) {
     const std::string deduped_root = DeduplicateAndTrimSeparators(controller_root);
@@ -56,4 +206,47 @@ unsigned int GetCgroupDepth(const std::string& controller_root, const std::strin
     return std::count(deduped_path.begin() + deduped_root.size(), deduped_path.end(), SEP);
 }
 
-}  // namespace util
+bool ReadDescriptors(CgroupDescriptorMap* descriptors) {
+    // load system cgroup descriptors
+    if (!ReadDescriptorsFromFile(CGROUPS_DESC_FILE, descriptors)) {
+        return false;
+    }
+
+    // load API-level specific system cgroups descriptors if available
+    unsigned int api_level = GetUintProperty<unsigned int>("ro.product.first_api_level", 0);
+    if (api_level > 0) {
+        std::string api_cgroups_path =
+                android::base::StringPrintf(TEMPLATE_CGROUPS_DESC_API_FILE, api_level);
+        if (!access(api_cgroups_path.c_str(), F_OK) || errno != ENOENT) {
+            if (!ReadDescriptorsFromFile(api_cgroups_path, descriptors)) {
+                return false;
+            }
+        }
+    }
+
+    // load vendor cgroup descriptors if the file exists
+    if (!access(CGROUPS_DESC_VENDOR_FILE, F_OK) &&
+        !ReadDescriptorsFromFile(CGROUPS_DESC_VENDOR_FILE, descriptors)) {
+        return false;
+    }
+
+    // check for v1 mount/usability status
+    std::optional<std::map<MountDir, MountOpts>> v1Mounts;
+    for (auto& [name, descriptor] : *descriptors) {
+        const CgroupController* const controller = descriptor.controller();
+
+        if (controller->version() != 1) continue;
+
+        // Read only once, and only if we have at least one v1 controller
+        if (!v1Mounts) {
+            v1Mounts = ReadCgroupV1Mounts();
+            if (!v1Mounts) return false;
+        }
+
+        if (const auto it = v1Mounts->find(controller->path()); it != v1Mounts->end()) {
+            if (it->second.contains(controller->name())) descriptor.set_mounted(true);
+        }
+    }
+
+    return true;
+}

From 9d84103bdd07ef471362f815b53303e7ae008138 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 8 Aug 2024 16:27:00 +0000
Subject: [PATCH 1144/1487] libprocessgroup: Remove dependency on libcgrouprc

Read cgroup descriptors ourselves instead of going through the LLNDK
interface which performs the same thing.

Bug: 349105928
Change-Id: I94625ffd0d884d619eb3449e63a305ad5e1d77e3
---
 libprocessgroup/Android.bp     |  1 -
 libprocessgroup/cgroup_map.cpp | 97 +++++++++++++---------------------
 libprocessgroup/cgroup_map.h   | 13 +++--
 3 files changed, 44 insertions(+), 67 deletions(-)

diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index d623a1152e4a..8448a39a47c0 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -75,7 +75,6 @@ cc_library {
     double_loadable: true,
     shared_libs: [
         "libbase",
-        "libcgrouprc",
     ],
     static_libs: [
         "libjsoncpp",
diff --git a/libprocessgroup/cgroup_map.cpp b/libprocessgroup/cgroup_map.cpp
index aeccfe89b91b..8180ccf3ff2e 100644
--- a/libprocessgroup/cgroup_map.cpp
+++ b/libprocessgroup/cgroup_map.cpp
@@ -25,12 +25,10 @@
 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
-#include <android-base/strings.h>
 #include <cgroup_map.h>
 #include <processgroup/processgroup.h>
 #include <processgroup/util.h>
 
-using android::base::StartsWith;
 using android::base::StringPrintf;
 using android::base::WriteStringToFile;
 
@@ -40,17 +38,17 @@ static constexpr const char* CGROUP_TASKS_FILE_V2 = "/cgroup.threads";
 
 uint32_t CgroupControllerWrapper::version() const {
     CHECK(HasValue());
-    return ACgroupController_getVersion(controller_);
+    return controller_->version();
 }
 
 const char* CgroupControllerWrapper::name() const {
     CHECK(HasValue());
-    return ACgroupController_getName(controller_);
+    return controller_->name();
 }
 
 const char* CgroupControllerWrapper::path() const {
     CHECK(HasValue());
-    return ACgroupController_getPath(controller_);
+    return controller_->path();
 }
 
 bool CgroupControllerWrapper::HasValue() const {
@@ -62,7 +60,7 @@ bool CgroupControllerWrapper::IsUsable() {
 
     if (state_ == UNKNOWN) {
         if (__builtin_available(android 30, *)) {
-            uint32_t flags = ACgroupController_getFlags(controller_);
+            uint32_t flags = controller_->flags();
             state_ = (flags & CGROUPRC_CONTROLLER_FLAG_MOUNTED) != 0 ? USABLE : MISSING;
         } else {
             state_ = access(GetProcsFilePath("", 0, 0).c_str(), F_OK) == 0 ? USABLE : MISSING;
@@ -129,8 +127,8 @@ bool CgroupControllerWrapper::GetTaskGroup(pid_t tid, std::string* group) const
 }
 
 CgroupMap::CgroupMap() {
-    if (!LoadRcFile()) {
-        LOG(ERROR) << "CgroupMap::LoadRcFile called for [" << getpid() << "] failed";
+    if (!LoadDescriptors()) {
+        LOG(ERROR) << "CgroupMap::LoadDescriptors called for [" << getpid() << "] failed";
     }
 }
 
@@ -141,9 +139,9 @@ CgroupMap& CgroupMap::GetInstance() {
     return *instance;
 }
 
-bool CgroupMap::LoadRcFile() {
+bool CgroupMap::LoadDescriptors() {
     if (!loaded_) {
-        loaded_ = (ACgroupFile_getVersion() != 0);
+        loaded_ = ReadDescriptors(&descriptors_);
     }
     return loaded_;
 }
@@ -154,40 +152,27 @@ void CgroupMap::Print() const {
                    << "] failed, cgroups were not initialized properly";
         return;
     }
-    LOG(INFO) << "File version = " << ACgroupFile_getVersion();
-    LOG(INFO) << "File controller count = " << ACgroupFile_getControllerCount();
+    LOG(INFO) << "Controller count = " << descriptors_.size();
 
     LOG(INFO) << "Mounted cgroups:";
 
-    auto controller_count = ACgroupFile_getControllerCount();
-    for (uint32_t i = 0; i < controller_count; ++i) {
-        const ACgroupController* controller = ACgroupFile_getController(i);
-        if (__builtin_available(android 30, *)) {
-            LOG(INFO) << "\t" << ACgroupController_getName(controller) << " ver "
-                      << ACgroupController_getVersion(controller) << " path "
-                      << ACgroupController_getPath(controller) << " flags "
-                      << ACgroupController_getFlags(controller);
-        } else {
-            LOG(INFO) << "\t" << ACgroupController_getName(controller) << " ver "
-                      << ACgroupController_getVersion(controller) << " path "
-                      << ACgroupController_getPath(controller);
-        }
+    for (const auto& [name, descriptor] : descriptors_) {
+        LOG(INFO) << "\t" << descriptor.controller()->name() << " ver "
+                  << descriptor.controller()->version() << " path "
+                  << descriptor.controller()->path() << " flags "
+                  << descriptor.controller()->flags();
     }
 }
 
 CgroupControllerWrapper CgroupMap::FindController(const std::string& name) const {
     if (!loaded_) {
         LOG(ERROR) << "CgroupMap::FindController called for [" << getpid()
-                   << "] failed, RC file was not initialized properly";
+                   << "] failed, cgroups were not initialized properly";
         return CgroupControllerWrapper(nullptr);
     }
 
-    auto controller_count = ACgroupFile_getControllerCount();
-    for (uint32_t i = 0; i < controller_count; ++i) {
-        const ACgroupController* controller = ACgroupFile_getController(i);
-        if (name == ACgroupController_getName(controller)) {
-            return CgroupControllerWrapper(controller);
-        }
+    if (const auto it = descriptors_.find(name); it != descriptors_.end()) {
+        return CgroupControllerWrapper(it->second.controller());
     }
 
     return CgroupControllerWrapper(nullptr);
@@ -196,15 +181,13 @@ CgroupControllerWrapper CgroupMap::FindController(const std::string& name) const
 CgroupControllerWrapper CgroupMap::FindControllerByPath(const std::string& path) const {
     if (!loaded_) {
         LOG(ERROR) << "CgroupMap::FindControllerByPath called for [" << getpid()
-                   << "] failed, RC file was not initialized properly";
+                   << "] failed, cgroups were not initialized properly";
         return CgroupControllerWrapper(nullptr);
     }
 
-    auto controller_count = ACgroupFile_getControllerCount();
-    for (uint32_t i = 0; i < controller_count; ++i) {
-        const ACgroupController* controller = ACgroupFile_getController(i);
-        if (StartsWith(path, ACgroupController_getPath(controller))) {
-            return CgroupControllerWrapper(controller);
+    for (const auto& [name, descriptor] : descriptors_) {
+        if (path.starts_with(descriptor.controller()->path())) {
+            return CgroupControllerWrapper(descriptor.controller());
         }
     }
 
@@ -212,31 +195,23 @@ CgroupControllerWrapper CgroupMap::FindControllerByPath(const std::string& path)
 }
 
 int CgroupMap::ActivateControllers(const std::string& path) const {
-    if (__builtin_available(android 30, *)) {
-        auto controller_count = ACgroupFile_getControllerCount();
-        for (uint32_t i = 0; i < controller_count; ++i) {
-            const ACgroupController* controller = ACgroupFile_getController(i);
-            const uint32_t flags = ACgroupController_getFlags(controller);
-            uint32_t max_activation_depth = UINT32_MAX;
-            if (__builtin_available(android 36, *)) {
-                max_activation_depth = ACgroupController_getMaxActivationDepth(controller);
-            }
-            const int depth = GetCgroupDepth(ACgroupController_getPath(controller), path);
-
-            if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
-                std::string str("+");
-                str.append(ACgroupController_getName(controller));
-                if (!WriteStringToFile(str, path + "/cgroup.subtree_control")) {
-                    if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
-                        PLOG(WARNING) << "Activation of cgroup controller " << str
-                                      << " failed in path " << path;
-                    } else {
-                        return -errno;
-                    }
+    for (const auto& [name, descriptor] : descriptors_) {
+        const uint32_t flags = descriptor.controller()->flags();
+        const uint32_t max_activation_depth = descriptor.controller()->max_activation_depth();
+        const int depth = GetCgroupDepth(descriptor.controller()->path(), path);
+
+        if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
+            std::string str("+");
+            str.append(descriptor.controller()->name());
+            if (!WriteStringToFile(str, path + "/cgroup.subtree_control")) {
+                if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
+                    PLOG(WARNING) << "Activation of cgroup controller " << str
+                                  << " failed in path " << path;
+                } else {
+                    return -errno;
                 }
             }
         }
-        return 0;
     }
-    return -ENOSYS;
+    return 0;
 }
diff --git a/libprocessgroup/cgroup_map.h b/libprocessgroup/cgroup_map.h
index 364279414336..5ad59bddf0a5 100644
--- a/libprocessgroup/cgroup_map.h
+++ b/libprocessgroup/cgroup_map.h
@@ -18,15 +18,17 @@
 
 #include <sys/types.h>
 
+#include <cstdint>
 #include <string>
 
-#include <android/cgrouprc.h>
+#include <processgroup/cgroup_controller.h>
+#include <processgroup/util.h>
 
-// Convenient wrapper of an ACgroupController pointer.
+// Convenient wrapper of a CgroupController pointer.
 class CgroupControllerWrapper {
   public:
     // Does not own controller
-    explicit CgroupControllerWrapper(const ACgroupController* controller)
+    explicit CgroupControllerWrapper(const CgroupController* controller)
         : controller_(controller) {}
 
     uint32_t version() const;
@@ -47,7 +49,7 @@ class CgroupControllerWrapper {
         MISSING = 2,
     };
 
-    const ACgroupController* controller_ = nullptr;
+    const CgroupController* controller_ = nullptr; // CgroupMap owns the object behind this pointer
     ControllerState state_ = ControllerState::UNKNOWN;
 };
 
@@ -60,7 +62,8 @@ class CgroupMap {
 
   private:
     bool loaded_ = false;
+    CgroupDescriptorMap descriptors_;
     CgroupMap();
-    bool LoadRcFile();
+    bool LoadDescriptors();
     void Print() const;
 };

From c31c5a75c8c275ca33bb44ba1faaf0e1f327a692 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 13 Aug 2024 21:09:30 +0000
Subject: [PATCH 1145/1487] libprocessgroup: Remove
 ACgroupController_getMaxActivationDepth

This was targeted for API 36 which doesn't exist yet, so this was never
released. Now that libprocessgroup does not use the libcgrouprc
interfaces, this can be removed.

Bug: 349105928
Bug: 359609093
Change-Id: I2ea466c9e8bc54bf9178fa74b45e88f26d3e4c69
---
 libprocessgroup/cgrouprc/a_cgroup_controller.cpp    | 5 -----
 libprocessgroup/cgrouprc/include/android/cgrouprc.h | 8 --------
 libprocessgroup/cgrouprc/libcgrouprc.map.txt        | 7 -------
 3 files changed, 20 deletions(-)

diff --git a/libprocessgroup/cgrouprc/a_cgroup_controller.cpp b/libprocessgroup/cgrouprc/a_cgroup_controller.cpp
index 889b3becf1a2..5a326e55d4de 100644
--- a/libprocessgroup/cgrouprc/a_cgroup_controller.cpp
+++ b/libprocessgroup/cgrouprc/a_cgroup_controller.cpp
@@ -32,11 +32,6 @@ uint32_t ACgroupController_getFlags(const ACgroupController* controller) {
     return controller->flags();
 }
 
-uint32_t ACgroupController_getMaxActivationDepth(const ACgroupController* controller) {
-    CHECK(controller != nullptr);
-    return controller->max_activation_depth();
-}
-
 const char* ACgroupController_getName(const ACgroupController* controller) {
     CHECK(controller != nullptr);
     return controller->name();
diff --git a/libprocessgroup/cgrouprc/include/android/cgrouprc.h b/libprocessgroup/cgrouprc/include/android/cgrouprc.h
index 3a57df547d60..e704a36aac9d 100644
--- a/libprocessgroup/cgrouprc/include/android/cgrouprc.h
+++ b/libprocessgroup/cgrouprc/include/android/cgrouprc.h
@@ -78,14 +78,6 @@ __attribute__((warn_unused_result)) uint32_t ACgroupController_getVersion(const
 __attribute__((warn_unused_result, weak)) uint32_t ACgroupController_getFlags(
         const ACgroupController*) __INTRODUCED_IN(30);
 
-/**
- * Returns the maximum activation depth of the given controller.
- * Only applicable to cgroup v2 controllers.
- * Returns UINT32_MAX if no maximum activation depth is set.
- */
-__attribute__((warn_unused_result, weak)) uint32_t ACgroupController_getMaxActivationDepth(
-        const ACgroupController* controller) __INTRODUCED_IN(36);
-
 /**
  * Returns the name of the given controller.
  * If the given controller is null, return nullptr.
diff --git a/libprocessgroup/cgrouprc/libcgrouprc.map.txt b/libprocessgroup/cgrouprc/libcgrouprc.map.txt
index 30bd25f18dbd..b62b10f3b457 100644
--- a/libprocessgroup/cgrouprc/libcgrouprc.map.txt
+++ b/libprocessgroup/cgrouprc/libcgrouprc.map.txt
@@ -16,10 +16,3 @@ LIBCGROUPRC_30 { # introduced=30
   local:
     *;
 };
-
-LIBCGROUPRC_36 { # introduced=36
-  global:
-    ACgroupController_getMaxActivationDepth; # llndk=202504 systemapi
-  local:
-    *;
-};

From 5161033f660250858ac0088a70ec57f7b9b26745 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 8 Aug 2024 16:32:05 +0000
Subject: [PATCH 1146/1487] libprocessgroup: Combine all 3 ActivateControllers
 implementations into one

Remove this code duplication and use just one interface.

Bug: 349105928
Change-Id: Id8c7186d9665e9087a654f5781b7593b06349160
---
 libprocessgroup/cgroup_map.cpp                | 22 +---------
 libprocessgroup/cgroup_map.h                  |  2 +-
 libprocessgroup/processgroup.cpp              |  7 ++--
 libprocessgroup/setup/cgroup_map_write.cpp    | 42 +------------------
 .../util/include/processgroup/util.h          |  2 +
 libprocessgroup/util/util.cpp                 | 23 ++++++++++
 6 files changed, 33 insertions(+), 65 deletions(-)

diff --git a/libprocessgroup/cgroup_map.cpp b/libprocessgroup/cgroup_map.cpp
index 8180ccf3ff2e..32bef13a1abf 100644
--- a/libprocessgroup/cgroup_map.cpp
+++ b/libprocessgroup/cgroup_map.cpp
@@ -194,24 +194,6 @@ CgroupControllerWrapper CgroupMap::FindControllerByPath(const std::string& path)
     return CgroupControllerWrapper(nullptr);
 }
 
-int CgroupMap::ActivateControllers(const std::string& path) const {
-    for (const auto& [name, descriptor] : descriptors_) {
-        const uint32_t flags = descriptor.controller()->flags();
-        const uint32_t max_activation_depth = descriptor.controller()->max_activation_depth();
-        const int depth = GetCgroupDepth(descriptor.controller()->path(), path);
-
-        if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
-            std::string str("+");
-            str.append(descriptor.controller()->name());
-            if (!WriteStringToFile(str, path + "/cgroup.subtree_control")) {
-                if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
-                    PLOG(WARNING) << "Activation of cgroup controller " << str
-                                  << " failed in path " << path;
-                } else {
-                    return -errno;
-                }
-            }
-        }
-    }
-    return 0;
+bool CgroupMap::ActivateControllers(const std::string& path) const {
+    return ::ActivateControllers(path, descriptors_);
 }
diff --git a/libprocessgroup/cgroup_map.h b/libprocessgroup/cgroup_map.h
index 5ad59bddf0a5..fb99076452d6 100644
--- a/libprocessgroup/cgroup_map.h
+++ b/libprocessgroup/cgroup_map.h
@@ -58,7 +58,7 @@ class CgroupMap {
     static CgroupMap& GetInstance();
     CgroupControllerWrapper FindController(const std::string& name) const;
     CgroupControllerWrapper FindControllerByPath(const std::string& path) const;
-    int ActivateControllers(const std::string& path) const;
+    bool ActivateControllers(const std::string& path) const;
 
   private:
     bool loaded_ = false;
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 83a2258bf2fb..d3719eea39af 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -662,10 +662,9 @@ static int createProcessGroupInternal(uid_t uid, pid_t initialPid, std::string c
         return -errno;
     }
     if (activate_controllers) {
-        ret = CgroupMap::GetInstance().ActivateControllers(uid_path);
-        if (ret) {
-            LOG(ERROR) << "Failed to activate controllers in " << uid_path;
-            return ret;
+        if (!CgroupMap::GetInstance().ActivateControllers(uid_path)) {
+            PLOG(ERROR) << "Failed to activate controllers in " << uid_path;
+            return -errno;
         }
     }
 
diff --git a/libprocessgroup/setup/cgroup_map_write.cpp b/libprocessgroup/setup/cgroup_map_write.cpp
index 82116800821d..d05bf2408cee 100644
--- a/libprocessgroup/setup/cgroup_map_write.cpp
+++ b/libprocessgroup/setup/cgroup_map_write.cpp
@@ -180,25 +180,7 @@ static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
         return false;
     }
 
-    if (controller->flags() & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION &&
-        controller->max_activation_depth() > 0) {
-        std::string str = "+";
-        str += controller->name();
-        std::string path = controller->path();
-        path += "/cgroup.subtree_control";
-
-        if (!android::base::WriteStringToFile(str, path)) {
-            if (IsOptionalController(controller)) {
-                PLOG(INFO) << "Failed to activate optional controller " << controller->name()
-                           << " at " << path;
-                return true;
-            }
-            PLOG(ERROR) << "Failed to activate controller " << controller->name();
-            return false;
-        }
-    }
-
-    return true;
+    return ::ActivateControllers(controller->path(), {{controller->name(), descriptor}});
 }
 
 static bool MountV1CgroupController(const CgroupDescriptor& descriptor) {
@@ -323,27 +305,7 @@ static bool CreateV2SubHierarchy(const std::string& path, const CgroupDescriptor
 
     // Activate all v2 controllers in path so they can be activated in
     // children as they are created.
-    for (const auto& [name, descriptor] : descriptors) {
-        const CgroupController* controller = descriptor.controller();
-        std::uint32_t flags = controller->flags();
-        std::uint32_t max_activation_depth = controller->max_activation_depth();
-        const int depth = GetCgroupDepth(controller->path(), path);
-
-        if (controller->version() == 2 && name != CGROUPV2_HIERARCHY_NAME &&
-            flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
-            std::string str("+");
-            str += controller->name();
-            if (!android::base::WriteStringToFile(str, path + "/cgroup.subtree_control")) {
-                if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
-                    PLOG(WARNING) << "Activation of cgroup controller " << str << " failed in path "
-                                  << path;
-                } else {
-                    return false;
-                }
-            }
-        }
-    }
-    return true;
+    return ::ActivateControllers(path, descriptors);
 }
 
 bool CgroupSetup() {
diff --git a/libprocessgroup/util/include/processgroup/util.h b/libprocessgroup/util/include/processgroup/util.h
index d592a63477d2..2c7b32926754 100644
--- a/libprocessgroup/util/include/processgroup/util.h
+++ b/libprocessgroup/util/include/processgroup/util.h
@@ -31,3 +31,5 @@ unsigned int GetCgroupDepth(const std::string& controller_root, const std::strin
 using CgroupControllerName = std::string;
 using CgroupDescriptorMap = std::map<CgroupControllerName, CgroupDescriptor>;
 bool ReadDescriptors(CgroupDescriptorMap* descriptors);
+
+bool ActivateControllers(const std::string& path, const CgroupDescriptorMap& descriptors);
diff --git a/libprocessgroup/util/util.cpp b/libprocessgroup/util/util.cpp
index bff4c6f1ac35..14016751c77b 100644
--- a/libprocessgroup/util/util.cpp
+++ b/libprocessgroup/util/util.cpp
@@ -250,3 +250,26 @@ bool ReadDescriptors(CgroupDescriptorMap* descriptors) {
 
     return true;
 }
+
+bool ActivateControllers(const std::string& path, const CgroupDescriptorMap& descriptors) {
+    for (const auto& [name, descriptor] : descriptors) {
+        const uint32_t flags = descriptor.controller()->flags();
+        const uint32_t max_activation_depth = descriptor.controller()->max_activation_depth();
+        const unsigned int depth = GetCgroupDepth(descriptor.controller()->path(), path);
+
+        if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
+            std::string str("+");
+            str.append(descriptor.controller()->name());
+            if (!android::base::WriteStringToFile(str, path + "/cgroup.subtree_control")) {
+                if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
+                    PLOG(WARNING) << "Activation of cgroup controller " << str
+                                  << " failed in path " << path;
+                } else {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+

From 36ea62f1fd9dda7c733c229e84ab1da37db370c2 Mon Sep 17 00:00:00 2001
From: Tiffany Yang <ynaffit@google.com>
Date: Thu, 3 Oct 2024 23:52:54 +0000
Subject: [PATCH 1147/1487] Revert "init: Wait for /dev/hvc1 during ARCVM
 first-stage mount"

This reverts commit b885e4ad533ea4d12e18a0147d298be0cd8cec72.

Reason for revert: No longer needed (using virtio-blk instead)

Change-Id: I667f0d4f58060e781a5e9b21c778cd568b92971a
---
 init/first_stage_mount.cpp | 5 -----
 init/selinux.cpp           | 2 --
 init/util.h                | 5 -----
 3 files changed, 12 deletions(-)

diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index 927b45f22e4c..55cce6eaabbe 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -305,11 +305,6 @@ bool FirstStageMountVBootV2::InitDevices() {
             return false;
         }
     }
-
-    if (IsArcvm() && !block_dev_init_.InitHvcDevice("hvc1")) {
-        return false;
-    }
-
     return true;
 }
 
diff --git a/init/selinux.cpp b/init/selinux.cpp
index 01af2b64d2dd..c2d9b8d286f6 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -474,8 +474,6 @@ void SelinuxRestoreContext() {
     RestoreconIfExists(SnapshotManager::GetGlobalRollbackIndicatorPath().c_str(), 0);
     RestoreconIfExists("/metadata/gsi",
                        SELINUX_ANDROID_RESTORECON_RECURSE | SELINUX_ANDROID_RESTORECON_SKIP_SEHASH);
-
-    RestoreconIfExists("/dev/hvc1", 0);
 }
 
 int SelinuxKlogCallback(int type, const char* fmt, ...) {
diff --git a/init/util.h b/init/util.h
index 056539181d99..aa24123dfc9f 100644
--- a/init/util.h
+++ b/init/util.h
@@ -18,7 +18,6 @@
 
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <sys/unistd.h>
 
 #include <chrono>
 #include <functional>
@@ -109,10 +108,6 @@ inline constexpr bool IsMicrodroid() {
 #endif
 }
 
-inline bool IsArcvm() {
-    return !access("/is_arcvm", F_OK);
-}
-
 bool Has32BitAbi();
 
 std::string GetApexNameFromFileName(const std::string& path);

From 8d71220df28851a7dce351f86601958fdbc3e5ae Mon Sep 17 00:00:00 2001
From: Jusik Chung <jschung@google.com>
Date: Fri, 4 Oct 2024 02:21:37 +0000
Subject: [PATCH 1148/1487] Revert "init: Look for super partition only on a
 boot device"

This reverts commit 6f0ebcb5260a8e769e0e029596d21c0efabe361b.

Reason for revert: b/371393845 boot up failure of gcar emulator

Change-Id: I15e5bea609938cf5a1e347666b9a2abb287cb086
---
 init/block_dev_initializer.cpp |  6 +-----
 init/devices.cpp               | 22 ----------------------
 init/devices.h                 |  1 -
 3 files changed, 1 insertion(+), 28 deletions(-)

diff --git a/init/block_dev_initializer.cpp b/init/block_dev_initializer.cpp
index cabeb01090b0..8f5215856544 100644
--- a/init/block_dev_initializer.cpp
+++ b/init/block_dev_initializer.cpp
@@ -98,11 +98,7 @@ ListenerAction BlockDevInitializer::HandleUevent(const Uevent& uevent,
 
     LOG(VERBOSE) << __PRETTY_FUNCTION__ << ": found partition: " << name;
 
-    // Remove partition from the list only if it was found on boot device
-    if (device_handler_->IsBootDevice(uevent)) {
-        devices->erase(iter);
-    }
-
+    devices->erase(iter);
     device_handler_->HandleUevent(uevent);
     return devices->empty() ? ListenerAction::kStop : ListenerAction::kContinue;
 }
diff --git a/init/devices.cpp b/init/devices.cpp
index 6a3a64dd81f3..f2bb9d27607d 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -188,28 +188,6 @@ void SysfsPermissions::SetPermissions(const std::string& path) const {
     }
 }
 
-bool DeviceHandler::IsBootDevice(const Uevent& uevent) const {
-    std::string device;
-
-    if (FindPlatformDevice(uevent.path, &device)) {
-        // Skip /devices/platform or /devices/ if present
-        static constexpr std::string_view devices_platform_prefix = "/devices/platform/";
-        static constexpr std::string_view devices_prefix = "/devices/";
-
-        if (StartsWith(device, devices_platform_prefix)) {
-            device = device.substr(devices_platform_prefix.length());
-        } else if (StartsWith(device, devices_prefix)) {
-            device = device.substr(devices_prefix.length());
-        }
-    } else if (FindPciDevicePrefix(uevent.path, &device)) {
-    } else if (FindVbdDevicePrefix(uevent.path, &device)) {
-    } else {
-        return false;
-    }
-
-    return boot_devices_.find(device) != boot_devices_.end();
-}
-
 std::string DeviceHandler::GetPartitionNameForDevice(const std::string& query_device) {
     static const auto partition_map = [] {
         std::vector<std::pair<std::string, std::string>> partition_map;
diff --git a/init/devices.h b/init/devices.h
index 4df604d00cef..6da1232595b4 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -133,7 +133,6 @@ class DeviceHandler : public UeventHandler {
     // `androidboot.partition_map=vdb,metadata;vdc,userdata` maps `vdb` to `metadata` and `vdc` to
     // `userdata`.
     static std::string GetPartitionNameForDevice(const std::string& device);
-    bool IsBootDevice(const Uevent& uevent) const;
 
   private:
     void ColdbootDone() override;

From 50fd822149d305b8fb53f2d9f650bb246acaf0ae Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 4 Oct 2024 14:53:27 +0000
Subject: [PATCH 1149/1487] init: Remove schedtune support

Schedtune was an out of tree cgroup controller present in Android
kernels up to 4.19. It was replaced with uclamp and the cpu controller.
Now that 4.19 is EOL and unsupported, and schedtune is not present in
any supported Android kernels, remove the userspace support for
schedtune.

Bug: 362504801
Change-Id: Iab7b7295d1fb443209d5868ac5c65dca0aabfbab
---
 init/service_parser.cpp |  3 ---
 rootdir/init.rc         | 49 -----------------------------------------
 2 files changed, 52 deletions(-)

diff --git a/init/service_parser.cpp b/init/service_parser.cpp
index e6f3af6177f5..ec3b176d427f 100644
--- a/init/service_parser.cpp
+++ b/init/service_parser.cpp
@@ -538,12 +538,9 @@ Result<void> ServiceParser::ParseUser(std::vector<std::string>&& args) {
 // when we migrate to cgroups v2 while these hardcoded paths stay the same.
 static std::optional<const std::string> ConvertTaskFileToProfile(const std::string& file) {
     static const std::map<const std::string, const std::string> map = {
-            {"/dev/stune/top-app/tasks", "MaxPerformance"},
-            {"/dev/stune/foreground/tasks", "HighPerformance"},
             {"/dev/cpuset/camera-daemon/tasks", "CameraServiceCapacity"},
             {"/dev/cpuset/foreground/tasks", "ProcessCapacityHigh"},
             {"/dev/cpuset/system-background/tasks", "ServiceCapacityLow"},
-            {"/dev/stune/nnapi-hal/tasks", "NNApiHALPerformance"},
             {"/dev/blkio/background/tasks", "LowIoPriority"},
     };
     auto iter = map.find(file);
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 1acd637749f8..c8b725d1ee18 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -112,37 +112,6 @@ on init
     # Create socket dir for ot-daemon
     mkdir /dev/socket/ot-daemon 0770 thread_network thread_network
 
-    # Create energy-aware scheduler tuning nodes
-    mkdir /dev/stune/foreground
-    mkdir /dev/stune/background
-    mkdir /dev/stune/top-app
-    mkdir /dev/stune/rt
-    chown system system /dev/stune
-    chown system system /dev/stune/foreground
-    chown system system /dev/stune/background
-    chown system system /dev/stune/top-app
-    chown system system /dev/stune/rt
-    chown system system /dev/stune/tasks
-    chown system system /dev/stune/foreground/tasks
-    chown system system /dev/stune/background/tasks
-    chown system system /dev/stune/top-app/tasks
-    chown system system /dev/stune/rt/tasks
-    chown system system /dev/stune/cgroup.procs
-    chown system system /dev/stune/foreground/cgroup.procs
-    chown system system /dev/stune/background/cgroup.procs
-    chown system system /dev/stune/top-app/cgroup.procs
-    chown system system /dev/stune/rt/cgroup.procs
-    chmod 0664 /dev/stune/tasks
-    chmod 0664 /dev/stune/foreground/tasks
-    chmod 0664 /dev/stune/background/tasks
-    chmod 0664 /dev/stune/top-app/tasks
-    chmod 0664 /dev/stune/rt/tasks
-    chmod 0664 /dev/stune/cgroup.procs
-    chmod 0664 /dev/stune/foreground/cgroup.procs
-    chmod 0664 /dev/stune/background/cgroup.procs
-    chmod 0664 /dev/stune/top-app/cgroup.procs
-    chmod 0664 /dev/stune/rt/cgroup.procs
-
     # cpuctl hierarchy for devices using utilclamp
     mkdir /dev/cpuctl/foreground
     mkdir /dev/cpuctl/foreground_window
@@ -216,24 +185,6 @@ on init
     chmod 0664 /dev/cpuctl/camera-daemon/tasks
     chmod 0664 /dev/cpuctl/camera-daemon/cgroup.procs
 
-    # Create an stune group for camera-specific processes
-    mkdir /dev/stune/camera-daemon
-    chown system system /dev/stune/camera-daemon
-    chown system system /dev/stune/camera-daemon/tasks
-    chown system system /dev/stune/camera-daemon/cgroup.procs
-    chmod 0664 /dev/stune/camera-daemon/tasks
-    chmod 0664 /dev/stune/camera-daemon/cgroup.procs
-
-    # Create an stune group for NNAPI HAL processes
-    mkdir /dev/stune/nnapi-hal
-    chown system system /dev/stune/nnapi-hal
-    chown system system /dev/stune/nnapi-hal/tasks
-    chown system system /dev/stune/nnapi-hal/cgroup.procs
-    chmod 0664 /dev/stune/nnapi-hal/tasks
-    chmod 0664 /dev/stune/nnapi-hal/cgroup.procs
-    write /dev/stune/nnapi-hal/schedtune.boost 1
-    write /dev/stune/nnapi-hal/schedtune.prefer_idle 1
-
     # Create blkio group and apply initial settings.
     # This feature needs kernel to support it, and the
     # device's init.rc must actually set the correct values.

From 551c6018c84dc68716167b998da34651eab6aa3a Mon Sep 17 00:00:00 2001
From: Neill Kapron <nkapron@google.com>
Date: Fri, 4 Oct 2024 15:54:26 +0000
Subject: [PATCH 1150/1487] init/epoll: clean up reorder-init-list warning

This change cleans up the following build warning:

warning: ISO C++ requires field designators to be specified in
declaration order; field 'events' will be initialized after field
'handler' [-Wreorder-init-list]

Bug: none
Test: TH
Change-Id: I9fe566b452438dc9f00f782fc4435905227a60c9
Signed-off-by: Neill Kapron <nkapron@google.com>
---
 init/epoll.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/epoll.cpp b/init/epoll.cpp
index cd73a0c3dfe1..719a53271aed 100644
--- a/init/epoll.cpp
+++ b/init/epoll.cpp
@@ -47,8 +47,8 @@ Result<void> Epoll::RegisterHandler(int fd, Handler handler, uint32_t events) {
 
     auto [it, inserted] = epoll_handlers_.emplace(
             fd, Info{
-                        .events = events,
                         .handler = std::move(handler),
+                        .events = events,
                 });
     if (!inserted) {
         return Error() << "Cannot specify two epoll handlers for a given FD";

From 623682af2f7cd0052a157f459d74b5ebc9cfb2fe Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <jaegeuk@google.com>
Date: Sun, 6 Oct 2024 13:06:16 -0700
Subject: [PATCH 1151/1487] fiemap_writer_test: add block truncation and sync
 for safety

There is a delay to get inode evicted whic requires to deallocate blocks used
by the previous test. Let's secure the pinned space as much as possible.

Bug: 371822983
Change-Id: I4cc69fc61e348511bb027ca0a9dd277fffb20f7f
Signed-off-by: Jaegeuk Kim <jaegeuk@google.com>
---
 fs_mgr/libfiemap/fiemap_writer_test.cpp  | 6 +++++-
 fs_mgr/libfiemap/split_fiemap_writer.cpp | 3 +++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libfiemap/fiemap_writer_test.cpp b/fs_mgr/libfiemap/fiemap_writer_test.cpp
index c37329c36e40..115f53e8e554 100644
--- a/fs_mgr/libfiemap/fiemap_writer_test.cpp
+++ b/fs_mgr/libfiemap/fiemap_writer_test.cpp
@@ -66,7 +66,11 @@ class FiemapWriterTest : public ::testing::Test {
         testfile = gTestDir + "/"s + tinfo->name();
     }
 
-    void TearDown() override { unlink(testfile.c_str()); }
+    void TearDown() override {
+        truncate(testfile.c_str(), 0);
+        unlink(testfile.c_str());
+        sync();
+    }
 
     // name of the file we use for testing
     std::string testfile;
diff --git a/fs_mgr/libfiemap/split_fiemap_writer.cpp b/fs_mgr/libfiemap/split_fiemap_writer.cpp
index 0df61253c85b..1f32d2f99405 100644
--- a/fs_mgr/libfiemap/split_fiemap_writer.cpp
+++ b/fs_mgr/libfiemap/split_fiemap_writer.cpp
@@ -196,10 +196,13 @@ bool SplitFiemap::RemoveSplitFiles(const std::string& file_path, std::string* me
             if (access(file.c_str(), F_OK) != 0 && (errno == ENOENT || errno == ENAMETOOLONG)) {
                 continue;
             }
+            truncate(file.c_str(), 0);
             ok &= android::base::RemoveFileIfExists(file, message);
         }
     }
+    truncate(file_path.c_str(), 0);
     ok &= android::base::RemoveFileIfExists(file_path, message);
+    sync();
     return ok;
 }
 

From 3a7cb4c637afdb6084f2f9eecdaedd49e2c02cc2 Mon Sep 17 00:00:00 2001
From: Justin Yun <justinyun@google.com>
Date: Sun, 6 Oct 2024 13:43:59 +0900
Subject: [PATCH 1152/1487] Use __ANDROID_VENDOR_API__ for vendor API surface

Build system defines __ANDROID_VENDOR_API__ for non-system modules.
Use this flag to provide vendor API surface for vendor or product
variant modules.

Bug: 368559337
Test: atest AImageReaderWindowTest
Change-Id: I7da3d4ca9f92255a426af8d66b4391f3c1426759
---
 .../include_llndk/android/llndk-versioning.h         | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/libvendorsupport/include_llndk/android/llndk-versioning.h b/libvendorsupport/include_llndk/android/llndk-versioning.h
index 0402c28805c1..81d165f47918 100644
--- a/libvendorsupport/include_llndk/android/llndk-versioning.h
+++ b/libvendorsupport/include_llndk/android/llndk-versioning.h
@@ -25,15 +25,15 @@
     __attribute__((annotate("introduced_in_llndk=" #vendor_api_level)))
 #endif
 
-#if defined(__ANDROID_VNDK__)
-
+#if defined(__ANDROID_VENDOR_API__)
+// __ANDROID_VENDOR_API__ is defined only for vendor or product variant modules.
 // Use this macro as an `if` statement to call an API that are available to both NDK and LLNDK.
-// This returns true for the vendor modules if the vendor_api_level is less than or equal to the
-// ro.board.api_level.
+// This returns true for vendor or product modules if the vendor_api_level is less than or equal to
+// the ro.board.api_level.
 #define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
     constexpr(__ANDROID_VENDOR_API__ >= vendor_api_level)
 
-#else  // __ANDROID_VNDK__
+#else  // __ANDROID_VENDOR_API__
 
 // For non-vendor modules, API_LEVEL_AT_LEAST is replaced with __builtin_available(sdk_api_level) to
 // guard the API for __INTRODUCED_IN.
@@ -42,4 +42,4 @@
     (__builtin_available(android sdk_api_level, *))
 #endif
 
-#endif  // __ANDROID_VNDK__
+#endif  // __ANDROID_VENDOR_API__

From 42dbd2de872ffff2167723ae02a261d085c1c1ce Mon Sep 17 00:00:00 2001
From: Tej Singh <singhtejinder@google.com>
Date: Mon, 7 Oct 2024 18:14:22 -0700
Subject: [PATCH 1153/1487] Remove libstats*_lazy tests from MTS

libstatssocket_lazy_test and libstatspull_lazy_test test primaryly the
lazy libs that ship from the platform. As a result, they shouldn't be in
MTS

Bug: 363078348
Test: TH
Change-Id: Iac7e2797d9f8c432f00688a49d53aa2691a52789
---
 libstats/pull_lazy/Android.bp   | 2 +-
 libstats/socket_lazy/Android.bp | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/libstats/pull_lazy/Android.bp b/libstats/pull_lazy/Android.bp
index 65dce26a013c..71af17068787 100644
--- a/libstats/pull_lazy/Android.bp
+++ b/libstats/pull_lazy/Android.bp
@@ -32,7 +32,7 @@ cc_test {
         "-Wall",
         "-Werror",
     ],
-    test_suites: ["device-tests", "mts-statsd"],
+    test_suites: ["device-tests"],
     test_config: "libstatspull_lazy_test.xml",
     // TODO(b/153588990): Remove when the build system properly separates.
     // 32bit and 64bit architectures.
diff --git a/libstats/socket_lazy/Android.bp b/libstats/socket_lazy/Android.bp
index 241e87af3743..945a7c4942ac 100644
--- a/libstats/socket_lazy/Android.bp
+++ b/libstats/socket_lazy/Android.bp
@@ -36,7 +36,6 @@ cc_test {
     ],
     test_suites: [
         "device-tests",
-        "mts-statsd",
     ],
     test_config: "libstatssocket_lazy_test.xml",
     // TODO(b/153588990): Remove when the build system properly separates.

From e0ec952bae15d296006de86b80782551c144afa4 Mon Sep 17 00:00:00 2001
From: Shai Barack <shayba@google.com>
Date: Mon, 7 Oct 2024 15:25:28 +0000
Subject: [PATCH 1154/1487] Avoid unnecessary allocation in VectorImpl

When shrinking a vector, we might reallocate the buffer
if the current capacity is too large, or we might reuse
the existing buffer.
Never reallocate the buffer if the current capacity is
already at the minimum (i.e. we won't actually shrink by
reallocating).

Bug: 370649413
Change-Id: I665037ed2a8621a82f2b58bcc834934de0761f34
Flag: EXEMPT bugfix
Tested: see b/370649413#comment6
---
 libutils/binder/VectorImpl.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/libutils/binder/VectorImpl.cpp b/libutils/binder/VectorImpl.cpp
index d951b8bbbc3c..a62664f7b1a8 100644
--- a/libutils/binder/VectorImpl.cpp
+++ b/libutils/binder/VectorImpl.cpp
@@ -463,7 +463,8 @@ void VectorImpl::_shrink(size_t where, size_t amount)
     size_t new_size;
     LOG_ALWAYS_FATAL_IF(__builtin_sub_overflow(mCount, amount, &new_size));
 
-    if (new_size < (capacity() / 2)) {
+    const size_t prev_capacity = capacity();
+    if (new_size < (prev_capacity / 2) && prev_capacity > kMinVectorCapacity) {
         // NOTE: (new_size * 2) is safe because capacity didn't overflow and
         // new_size < (capacity / 2)).
         const size_t new_capacity = max(kMinVectorCapacity, new_size * 2);

From 972a2d30f8a3f260967b747592f4e8cdc560e01c Mon Sep 17 00:00:00 2001
From: "Priyanka Advani (xWF)" <padvani@google.com>
Date: Tue, 8 Oct 2024 18:54:37 +0000
Subject: [PATCH 1155/1487] Revert "libprocessgroup: Remove cgroup.rc file"

Revert submission 3212512

Reason for revert: Droidmonitor created revert due to b/372273614. Will be verifying through ABTD before submission.

Reverted changes: /q/submissionid:3212512

Change-Id: I37568516e973cb940f1229d52f94b8dc801da2ab
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   7 +-
 init/Android.bp                               |   1 +
 init/init.cpp                                 |   3 +
 libcutils/Android.bp                          |   2 +-
 libprocessgroup/Android.bp                    |   3 +-
 libprocessgroup/cgroup_map.cpp                |   4 +-
 libprocessgroup/cgrouprc/Android.bp           |   3 +-
 libprocessgroup/cgrouprc/a_cgroup_file.cpp    |  88 ++++--
 libprocessgroup/cgrouprc/cgrouprc_internal.h  |   7 +-
 libprocessgroup/cgrouprc_format/Android.bp    |  13 +
 .../cgroup_controller.cpp                     |  12 +-
 .../processgroup/format}/cgroup_controller.h  |  12 +-
 .../processgroup/format/cgroup_file.h}        |  23 +-
 .../include/processgroup/processgroup.h       |   2 +-
 libprocessgroup/setup/Android.bp              |   1 +
 libprocessgroup/setup/cgroup_descriptor.h     |  12 +-
 libprocessgroup/setup/cgroup_map_write.cpp    | 259 ++++++++++++++++--
 libprocessgroup/util/Android.bp               |   8 -
 libprocessgroup/util/cgroup_descriptor.cpp    |  38 ---
 .../include/processgroup/cgroup_descriptor.h  |  45 ---
 .../util/include/processgroup/util.h          |  12 +-
 libprocessgroup/util/tests/util.cpp           |   2 +
 libprocessgroup/util/util.cpp                 | 197 +------------
 23 files changed, 389 insertions(+), 365 deletions(-)
 rename libprocessgroup/{util => cgrouprc_format}/cgroup_controller.cpp (90%)
 rename libprocessgroup/{util/include/processgroup => cgrouprc_format/include/processgroup/format}/cgroup_controller.h (87%)
 rename libprocessgroup/{internal.h => cgrouprc_format/include/processgroup/format/cgroup_file.h} (54%)
 delete mode 100644 libprocessgroup/util/cgroup_descriptor.cpp
 delete mode 100644 libprocessgroup/util/include/processgroup/cgroup_descriptor.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 083068b54bfe..298fd9f3095b 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -85,9 +85,9 @@ cc_library_static {
         "libsnapshot_cow",
         "liburing",
         "libprocessgroup",
-        "libprocessgroup_util",
         "libjsoncpp",
         "libcgrouprc",
+        "libcgrouprc_format",
     ],
     include_dirs: ["bionic/libc/kernel"],
     export_include_dirs: ["include"],
@@ -129,9 +129,9 @@ cc_defaults {
         "libsnapshot_cow",
         "libsnapuserd",
         "libprocessgroup",
-        "libprocessgroup_util",
         "libjsoncpp",
         "libcgrouprc",
+        "libcgrouprc_format",
         "libsnapuserd_client",
         "libz",
         "liblz4",
@@ -221,9 +221,9 @@ cc_defaults {
         "libsnapshot_cow",
         "libsnapuserd",
         "libprocessgroup",
-        "libprocessgroup_util",
         "libjsoncpp",
         "libcgrouprc",
+        "libcgrouprc_format",
         "liburing",
         "libz",
     ],
@@ -319,6 +319,7 @@ cc_binary_host {
         "libprocessgroup",
         "libjsoncpp",
         "libcgrouprc",
+        "libcgrouprc_format",
         "liburing",
         "libz",
     ],
diff --git a/init/Android.bp b/init/Android.bp
index 8da2e7c2eaf4..18a79d6c4285 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -163,6 +163,7 @@ libinit_cc_defaults {
         "libavb",
         "libavf_cc_flags",
         "libbootloader_message",
+        "libcgrouprc_format",
         "liblmkd_utils",
         "liblz4",
         "libzstd",
diff --git a/init/init.cpp b/init/init.cpp
index 17498da6dce4..6c8089926ae8 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -636,6 +636,9 @@ static Result<void> SetupCgroupsAction(const BuiltinArguments&) {
         LOG(INFO) << "Cgroups support in kernel is not enabled";
         return {};
     }
+    // Have to create <CGROUPS_RC_DIR> using make_dir function
+    // for appropriate sepolicy to be set for it
+    make_dir(android::base::Dirname(CGROUPS_RC_PATH), 0711);
     if (!CgroupSetup()) {
         return ErrnoError() << "Failed to setup cgroups";
     }
diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index fc4c571b7ba0..3c3eeb6631f3 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -301,7 +301,7 @@ cc_defaults {
         android: {
             static_executable: true,
             static_libs: [
-                "libprocessgroup_util",
+                "libcgrouprc_format",
             ] + test_libraries + always_static_test_libraries,
         },
         not_windows: {
diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index d623a1152e4a..a60bfe97344a 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -17,7 +17,7 @@ soong_config_module_type {
 
 libprocessgroup_flag_aware_cc_defaults {
     name: "libprocessgroup_build_flags_cc",
-    cpp_std: "gnu++23",
+    cpp_std: "gnu++20",
     soong_config_variables: {
         memcg_v2_force_enabled: {
             cflags: [
@@ -116,6 +116,5 @@ cc_test {
     ],
     static_libs: [
         "libgmock",
-        "libprocessgroup_util",
     ],
 }
diff --git a/libprocessgroup/cgroup_map.cpp b/libprocessgroup/cgroup_map.cpp
index aeccfe89b91b..fb01cfda9ff3 100644
--- a/libprocessgroup/cgroup_map.cpp
+++ b/libprocessgroup/cgroup_map.cpp
@@ -151,7 +151,7 @@ bool CgroupMap::LoadRcFile() {
 void CgroupMap::Print() const {
     if (!loaded_) {
         LOG(ERROR) << "CgroupMap::Print called for [" << getpid()
-                   << "] failed, cgroups were not initialized properly";
+                   << "] failed, RC file was not initialized properly";
         return;
     }
     LOG(INFO) << "File version = " << ACgroupFile_getVersion();
@@ -221,7 +221,7 @@ int CgroupMap::ActivateControllers(const std::string& path) const {
             if (__builtin_available(android 36, *)) {
                 max_activation_depth = ACgroupController_getMaxActivationDepth(controller);
             }
-            const int depth = GetCgroupDepth(ACgroupController_getPath(controller), path);
+            const int depth = util::GetCgroupDepth(ACgroupController_getPath(controller), path);
 
             if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
                 std::string str("+");
diff --git a/libprocessgroup/cgrouprc/Android.bp b/libprocessgroup/cgrouprc/Android.bp
index 38b2fa31d4f3..cb912476e26a 100644
--- a/libprocessgroup/cgrouprc/Android.bp
+++ b/libprocessgroup/cgrouprc/Android.bp
@@ -49,8 +49,7 @@ cc_library {
         "libbase",
     ],
     static_libs: [
-        "libjsoncpp",
-        "libprocessgroup_util",
+        "libcgrouprc_format",
     ],
     stubs: {
         symbol_file: "libcgrouprc.map.txt",
diff --git a/libprocessgroup/cgrouprc/a_cgroup_file.cpp b/libprocessgroup/cgrouprc/a_cgroup_file.cpp
index 33c8376f4cb6..e26d84114378 100644
--- a/libprocessgroup/cgrouprc/a_cgroup_file.cpp
+++ b/libprocessgroup/cgrouprc/a_cgroup_file.cpp
@@ -14,51 +14,93 @@
  * limitations under the License.
  */
 
-#include <iterator>
+#include <sys/mman.h>
+#include <sys/stat.h>
+
+#include <memory>
 
 #include <android-base/logging.h>
+#include <android-base/stringprintf.h>
+#include <android-base/unique_fd.h>
 #include <android/cgrouprc.h>
-#include <processgroup/util.h>
+#include <processgroup/processgroup.h>
 
 #include "cgrouprc_internal.h"
 
-static CgroupDescriptorMap* LoadDescriptors() {
-    CgroupDescriptorMap* descriptors = new CgroupDescriptorMap;
-    if (!ReadDescriptors(descriptors)) {
-        LOG(ERROR) << "Failed to load cgroup description file";
+using android::base::StringPrintf;
+using android::base::unique_fd;
+
+using android::cgrouprc::format::CgroupController;
+using android::cgrouprc::format::CgroupFile;
+
+static CgroupFile* LoadRcFile() {
+    struct stat sb;
+
+    unique_fd fd(TEMP_FAILURE_RETRY(open(CGROUPS_RC_PATH, O_RDONLY | O_CLOEXEC)));
+    if (fd < 0) {
+        PLOG(ERROR) << "open() failed for " << CGROUPS_RC_PATH;
+        return nullptr;
+    }
+
+    if (fstat(fd, &sb) < 0) {
+        PLOG(ERROR) << "fstat() failed for " << CGROUPS_RC_PATH;
+        return nullptr;
+    }
+
+    size_t file_size = sb.st_size;
+    if (file_size < sizeof(CgroupFile)) {
+        LOG(ERROR) << "Invalid file format " << CGROUPS_RC_PATH;
         return nullptr;
     }
-    return descriptors;
+
+    CgroupFile* file_data = (CgroupFile*)mmap(nullptr, file_size, PROT_READ, MAP_SHARED, fd, 0);
+    if (file_data == MAP_FAILED) {
+        PLOG(ERROR) << "Failed to mmap " << CGROUPS_RC_PATH;
+        return nullptr;
+    }
+
+    if (file_data->version_ != CgroupFile::FILE_CURR_VERSION) {
+        LOG(ERROR) << CGROUPS_RC_PATH << " file version mismatch";
+        munmap(file_data, file_size);
+        return nullptr;
+    }
+
+    auto expected = sizeof(CgroupFile) + file_data->controller_count_ * sizeof(CgroupController);
+    if (file_size != expected) {
+        LOG(ERROR) << CGROUPS_RC_PATH << " file has invalid size, expected " << expected
+                   << ", actual " << file_size;
+        munmap(file_data, file_size);
+        return nullptr;
+    }
+
+    return file_data;
 }
 
-static const CgroupDescriptorMap* GetInstance() {
+static CgroupFile* GetInstance() {
     // Deliberately leak this object (not munmap) to avoid a race between destruction on
     // process exit and concurrent access from another thread.
-    static const CgroupDescriptorMap* descriptors = LoadDescriptors();
-    return descriptors;
+    static auto* file = LoadRcFile();
+    return file;
 }
 
 uint32_t ACgroupFile_getVersion() {
-    static constexpr uint32_t FILE_VERSION_1 = 1;
-    auto descriptors = GetInstance();
-    if (descriptors == nullptr) return 0;
-    // There has only ever been one version, and there will be no more since cgroup.rc is no more
-    return FILE_VERSION_1;
+    auto file = GetInstance();
+    if (file == nullptr) return 0;
+    return file->version_;
 }
 
 uint32_t ACgroupFile_getControllerCount() {
-    auto descriptors = GetInstance();
-    if (descriptors == nullptr) return 0;
-    return descriptors->size();
+    auto file = GetInstance();
+    if (file == nullptr) return 0;
+    return file->controller_count_;
 }
 
 const ACgroupController* ACgroupFile_getController(uint32_t index) {
-    auto descriptors = GetInstance();
-    if (descriptors == nullptr) return nullptr;
-    CHECK(index < descriptors->size());
+    auto file = GetInstance();
+    if (file == nullptr) return nullptr;
+    CHECK(index < file->controller_count_);
     // Although the object is not actually an ACgroupController object, all ACgroupController_*
     // functions implicitly convert ACgroupController* back to CgroupController* before invoking
     // member functions.
-    const CgroupController* p = std::next(descriptors->begin(), index)->second.controller();
-    return static_cast<const ACgroupController*>(p);
+    return static_cast<ACgroupController*>(&file->controllers_[index]);
 }
diff --git a/libprocessgroup/cgrouprc/cgrouprc_internal.h b/libprocessgroup/cgrouprc/cgrouprc_internal.h
index d517703467d3..cd02f0304f17 100644
--- a/libprocessgroup/cgrouprc/cgrouprc_internal.h
+++ b/libprocessgroup/cgrouprc/cgrouprc_internal.h
@@ -16,6 +16,9 @@
 
 #pragma once
 
-#include <processgroup/cgroup_controller.h>
+#include <android/cgrouprc.h>
 
-struct ACgroupController : CgroupController {};
+#include <processgroup/format/cgroup_controller.h>
+#include <processgroup/format/cgroup_file.h>
+
+struct ACgroupController : android::cgrouprc::format::CgroupController {};
diff --git a/libprocessgroup/cgrouprc_format/Android.bp b/libprocessgroup/cgrouprc_format/Android.bp
index 6f9ab3e73e36..059092419b87 100644
--- a/libprocessgroup/cgrouprc_format/Android.bp
+++ b/libprocessgroup/cgrouprc_format/Android.bp
@@ -23,4 +23,17 @@ cc_library_static {
     vendor_ramdisk_available: true,
     recovery_available: true,
     native_bridge_supported: true,
+    srcs: [
+        "cgroup_controller.cpp",
+    ],
+    cflags: [
+        "-Wall",
+        "-Werror",
+    ],
+    export_include_dirs: [
+        "include",
+    ],
+    shared_libs: [
+        "libbase",
+    ],
 }
diff --git a/libprocessgroup/util/cgroup_controller.cpp b/libprocessgroup/cgrouprc_format/cgroup_controller.cpp
similarity index 90%
rename from libprocessgroup/util/cgroup_controller.cpp
rename to libprocessgroup/cgrouprc_format/cgroup_controller.cpp
index fb4168075db5..0dd909a29150 100644
--- a/libprocessgroup/util/cgroup_controller.cpp
+++ b/libprocessgroup/cgrouprc_format/cgroup_controller.cpp
@@ -14,9 +14,11 @@
  * limitations under the License.
  */
 
-#include <processgroup/cgroup_controller.h>
+#include <processgroup/format/cgroup_controller.h>
 
-#include <cstring>
+namespace android {
+namespace cgrouprc {
+namespace format {
 
 CgroupController::CgroupController(uint32_t version, uint32_t flags, const std::string& name,
                                    const std::string& path, uint32_t max_activation_depth)
@@ -52,4 +54,8 @@ const char* CgroupController::path() const {
 
 void CgroupController::set_flags(uint32_t flags) {
     flags_ = flags;
-}
\ No newline at end of file
+}
+
+}  // namespace format
+}  // namespace cgrouprc
+}  // namespace android
diff --git a/libprocessgroup/util/include/processgroup/cgroup_controller.h b/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
similarity index 87%
rename from libprocessgroup/util/include/processgroup/cgroup_controller.h
rename to libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
index fe6a829a0e83..c0c1f6034fe4 100644
--- a/libprocessgroup/util/include/processgroup/cgroup_controller.h
+++ b/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
@@ -20,7 +20,11 @@
 #include <cstdint>
 #include <string>
 
-// Minimal controller description
+namespace android {
+namespace cgrouprc {
+namespace format {
+
+// Minimal controller description to be mmapped into process address space
 struct CgroupController {
   public:
     CgroupController() = default;
@@ -44,4 +48,8 @@ struct CgroupController {
     uint32_t max_activation_depth_ = UINT32_MAX;
     char name_[CGROUP_NAME_BUF_SZ] = {};
     char path_[CGROUP_PATH_BUF_SZ] = {};
-};
\ No newline at end of file
+};
+
+}  // namespace format
+}  // namespace cgrouprc
+}  // namespace android
diff --git a/libprocessgroup/internal.h b/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_file.h
similarity index 54%
rename from libprocessgroup/internal.h
rename to libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_file.h
index ef855790d6df..2d9786fe6794 100644
--- a/libprocessgroup/internal.h
+++ b/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_file.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 The Android Open Source Project
+ * 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.
@@ -16,6 +16,23 @@
 
 #pragma once
 
-#include <string>
+#include <cstdint>
 
-static const std::string CGROUP_V2_ROOT_DEFAULT = "/sys/fs/cgroup";
\ No newline at end of file
+#include <processgroup/format/cgroup_controller.h>
+
+namespace android {
+namespace cgrouprc {
+namespace format {
+
+struct CgroupFile {
+    uint32_t version_;
+    uint32_t controller_count_;
+    CgroupController controllers_[];
+
+    static constexpr uint32_t FILE_VERSION_1 = 1;
+    static constexpr uint32_t FILE_CURR_VERSION = FILE_VERSION_1;
+};
+
+}  // namespace format
+}  // namespace cgrouprc
+}  // namespace android
diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 805775744e32..ffffeb48b0c1 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -57,7 +57,7 @@ __BEGIN_DECLS
 
 bool SetProcessProfilesCached(uid_t uid, pid_t pid, const std::vector<std::string>& profiles);
 
-[[deprecated]] static constexpr const char* CGROUPS_RC_PATH = "/dev/cgroup_info/cgroup.rc";
+static constexpr const char* CGROUPS_RC_PATH = "/dev/cgroup_info/cgroup.rc";
 
 bool UsePerAppMemcg();
 
diff --git a/libprocessgroup/setup/Android.bp b/libprocessgroup/setup/Android.bp
index cc6c67cf4fb1..1a4ad0118ac4 100644
--- a/libprocessgroup/setup/Android.bp
+++ b/libprocessgroup/setup/Android.bp
@@ -33,6 +33,7 @@ cc_library_shared {
         "libjsoncpp",
     ],
     static_libs: [
+        "libcgrouprc_format",
         "libprocessgroup_util",
     ],
     header_libs: [
diff --git a/libprocessgroup/setup/cgroup_descriptor.h b/libprocessgroup/setup/cgroup_descriptor.h
index 1afd2ee9ceb4..06ce186fde7a 100644
--- a/libprocessgroup/setup/cgroup_descriptor.h
+++ b/libprocessgroup/setup/cgroup_descriptor.h
@@ -21,7 +21,10 @@
 
 #include <sys/stat.h>
 
-#include <processgroup/cgroup_controller.h>
+#include <processgroup/format/cgroup_controller.h>
+
+namespace android {
+namespace cgrouprc {
 
 // Complete controller description for mounting cgroups
 class CgroupDescriptor {
@@ -30,7 +33,7 @@ class CgroupDescriptor {
                      mode_t mode, const std::string& uid, const std::string& gid, uint32_t flags,
                      uint32_t max_activation_depth);
 
-    const CgroupController* controller() const { return &controller_; }
+    const format::CgroupController* controller() const { return &controller_; }
     mode_t mode() const { return mode_; }
     std::string uid() const { return uid_; }
     std::string gid() const { return gid_; }
@@ -38,8 +41,11 @@ class CgroupDescriptor {
     void set_mounted(bool mounted);
 
   private:
-    CgroupController controller_;
+    format::CgroupController controller_;
     mode_t mode_ = 0;
     std::string uid_;
     std::string gid_;
 };
+
+}  // namespace cgrouprc
+}  // namespace android
diff --git a/libprocessgroup/setup/cgroup_map_write.cpp b/libprocessgroup/setup/cgroup_map_write.cpp
index 82116800821d..bd418747555f 100644
--- a/libprocessgroup/setup/cgroup_map_write.cpp
+++ b/libprocessgroup/setup/cgroup_map_write.cpp
@@ -22,28 +22,45 @@
 #include <fcntl.h>
 #include <grp.h>
 #include <pwd.h>
+#include <sys/mman.h>
 #include <sys/mount.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <time.h>
 #include <unistd.h>
 
 #include <optional>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
-#include <processgroup/cgroup_descriptor.h>
+#include <android-base/properties.h>
+#include <android-base/stringprintf.h>
+#include <android-base/unique_fd.h>
+#include <android/cgrouprc.h>
+#include <json/reader.h>
+#include <json/value.h>
+#include <processgroup/format/cgroup_file.h>
 #include <processgroup/processgroup.h>
 #include <processgroup/setup.h>
 #include <processgroup/util.h>
 
 #include "../build_flags.h"
-#include "../internal.h"
+#include "cgroup_descriptor.h"
+
+using android::base::GetUintProperty;
+using android::base::StringPrintf;
+using android::base::unique_fd;
+
+namespace android {
+namespace cgrouprc {
 
 static constexpr const char* CGROUPS_DESC_FILE = "/etc/cgroups.json";
 static constexpr const char* CGROUPS_DESC_VENDOR_FILE = "/vendor/etc/cgroups.json";
 
 static constexpr const char* TEMPLATE_CGROUPS_DESC_API_FILE = "/etc/task_profiles/cgroups_%u.json";
 
+static const std::string CGROUP_V2_ROOT_DEFAULT = "/sys/fs/cgroup";
+
 static bool ChangeDirModeAndOwner(const std::string& path, mode_t mode, const std::string& uid,
                                   const std::string& gid, bool permissive_mode = false) {
     uid_t pw_uid = -1;
@@ -131,15 +148,149 @@ static bool Mkdir(const std::string& path, mode_t mode, const std::string& uid,
     return true;
 }
 
+static void MergeCgroupToDescriptors(std::map<std::string, CgroupDescriptor>* descriptors,
+                                     const Json::Value& cgroup, const std::string& name,
+                                     const std::string& root_path, int cgroups_version) {
+    const std::string cgroup_path = cgroup["Path"].asString();
+    std::string path;
+
+    if (!root_path.empty()) {
+        path = root_path;
+        if (cgroup_path != ".") {
+            path += "/";
+            path += cgroup_path;
+        }
+    } else {
+        path = cgroup_path;
+    }
+
+    uint32_t controller_flags = 0;
+
+    if (cgroup["NeedsActivation"].isBool() && cgroup["NeedsActivation"].asBool()) {
+        controller_flags |= CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION;
+    }
+
+    if (cgroup["Optional"].isBool() && cgroup["Optional"].asBool()) {
+        controller_flags |= CGROUPRC_CONTROLLER_FLAG_OPTIONAL;
+    }
+
+    uint32_t max_activation_depth = UINT32_MAX;
+    if (cgroup.isMember("MaxActivationDepth")) {
+        max_activation_depth = cgroup["MaxActivationDepth"].asUInt();
+    }
+
+    CgroupDescriptor descriptor(
+            cgroups_version, name, path, std::strtoul(cgroup["Mode"].asString().c_str(), 0, 8),
+            cgroup["UID"].asString(), cgroup["GID"].asString(), controller_flags,
+            max_activation_depth);
+
+    auto iter = descriptors->find(name);
+    if (iter == descriptors->end()) {
+        descriptors->emplace(name, descriptor);
+    } else {
+        iter->second = descriptor;
+    }
+}
+
+static const bool force_memcg_v2 = android::libprocessgroup_flags::force_memcg_v2();
+
+static bool ReadDescriptorsFromFile(const std::string& file_name,
+                                    std::map<std::string, CgroupDescriptor>* descriptors) {
+    std::vector<CgroupDescriptor> result;
+    std::string json_doc;
+
+    if (!android::base::ReadFileToString(file_name, &json_doc)) {
+        PLOG(ERROR) << "Failed to read task profiles from " << file_name;
+        return false;
+    }
+
+    Json::CharReaderBuilder builder;
+    std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+    Json::Value root;
+    std::string errorMessage;
+    if (!reader->parse(&*json_doc.begin(), &*json_doc.end(), &root, &errorMessage)) {
+        LOG(ERROR) << "Failed to parse cgroups description: " << errorMessage;
+        return false;
+    }
+
+    if (root.isMember("Cgroups")) {
+        const Json::Value& cgroups = root["Cgroups"];
+        for (Json::Value::ArrayIndex i = 0; i < cgroups.size(); ++i) {
+            std::string name = cgroups[i]["Controller"].asString();
+
+            if (force_memcg_v2 && name == "memory") continue;
+
+            MergeCgroupToDescriptors(descriptors, cgroups[i], name, "", 1);
+        }
+    }
+
+    bool memcgv2_present = false;
+    std::string root_path;
+    if (root.isMember("Cgroups2")) {
+        const Json::Value& cgroups2 = root["Cgroups2"];
+        root_path = cgroups2["Path"].asString();
+        MergeCgroupToDescriptors(descriptors, cgroups2, CGROUPV2_HIERARCHY_NAME, "", 2);
+
+        const Json::Value& childGroups = cgroups2["Controllers"];
+        for (Json::Value::ArrayIndex i = 0; i < childGroups.size(); ++i) {
+            std::string name = childGroups[i]["Controller"].asString();
+
+            if (force_memcg_v2 && name == "memory") memcgv2_present = true;
+
+            MergeCgroupToDescriptors(descriptors, childGroups[i], name, root_path, 2);
+        }
+    }
+
+    if (force_memcg_v2 && !memcgv2_present) {
+        LOG(INFO) << "Forcing memcg to v2 hierarchy";
+        Json::Value memcgv2;
+        memcgv2["Controller"] = "memory";
+        memcgv2["NeedsActivation"] = true;
+        memcgv2["Path"] = ".";
+        memcgv2["Optional"] = true;  // In case of cgroup_disabled=memory, so we can still boot
+        MergeCgroupToDescriptors(descriptors, memcgv2, "memory",
+                                 root_path.empty() ? CGROUP_V2_ROOT_DEFAULT : root_path, 2);
+    }
+
+    return true;
+}
+
+static bool ReadDescriptors(std::map<std::string, CgroupDescriptor>* descriptors) {
+    // load system cgroup descriptors
+    if (!ReadDescriptorsFromFile(CGROUPS_DESC_FILE, descriptors)) {
+        return false;
+    }
+
+    // load API-level specific system cgroups descriptors if available
+    unsigned int api_level = GetUintProperty<unsigned int>("ro.product.first_api_level", 0);
+    if (api_level > 0) {
+        std::string api_cgroups_path =
+                android::base::StringPrintf(TEMPLATE_CGROUPS_DESC_API_FILE, api_level);
+        if (!access(api_cgroups_path.c_str(), F_OK) || errno != ENOENT) {
+            if (!ReadDescriptorsFromFile(api_cgroups_path, descriptors)) {
+                return false;
+            }
+        }
+    }
+
+    // load vendor cgroup descriptors if the file exists
+    if (!access(CGROUPS_DESC_VENDOR_FILE, F_OK) &&
+        !ReadDescriptorsFromFile(CGROUPS_DESC_VENDOR_FILE, descriptors)) {
+        return false;
+    }
+
+    return true;
+}
+
 // To avoid issues in sdk_mac build
 #if defined(__ANDROID__)
 
-static bool IsOptionalController(const CgroupController* controller) {
+static bool IsOptionalController(const format::CgroupController* controller) {
     return controller->flags() & CGROUPRC_CONTROLLER_FLAG_OPTIONAL;
 }
 
 static bool MountV2CgroupController(const CgroupDescriptor& descriptor) {
-    const CgroupController* controller = descriptor.controller();
+    const format::CgroupController* controller = descriptor.controller();
 
     // /sys/fs/cgroup is created by cgroup2 with specific selinux permissions,
     // try to create again in case the mount point is changed
@@ -173,7 +324,7 @@ static bool MountV2CgroupController(const CgroupDescriptor& descriptor) {
 }
 
 static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
-    const CgroupController* controller = descriptor.controller();
+    const format::CgroupController* controller = descriptor.controller();
 
     if (!Mkdir(controller->path(), descriptor.mode(), descriptor.uid(), descriptor.gid())) {
         LOG(ERROR) << "Failed to create directory for " << controller->name() << " cgroup";
@@ -187,7 +338,7 @@ static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
         std::string path = controller->path();
         path += "/cgroup.subtree_control";
 
-        if (!android::base::WriteStringToFile(str, path)) {
+        if (!base::WriteStringToFile(str, path)) {
             if (IsOptionalController(controller)) {
                 PLOG(INFO) << "Failed to activate optional controller " << controller->name()
                            << " at " << path;
@@ -202,7 +353,7 @@ static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
 }
 
 static bool MountV1CgroupController(const CgroupDescriptor& descriptor) {
-    const CgroupController* controller = descriptor.controller();
+    const format::CgroupController* controller = descriptor.controller();
 
     // mkdir <path> [mode] [owner] [group]
     if (!Mkdir(controller->path(), descriptor.mode(), descriptor.uid(), descriptor.gid())) {
@@ -237,7 +388,7 @@ static bool MountV1CgroupController(const CgroupDescriptor& descriptor) {
 }
 
 static bool SetupCgroup(const CgroupDescriptor& descriptor) {
-    const CgroupController* controller = descriptor.controller();
+    const format::CgroupController* controller = descriptor.controller();
 
     if (controller->version() == 2) {
         if (!strcmp(controller->name(), CGROUPV2_HIERARCHY_NAME)) {
@@ -259,6 +410,35 @@ static bool SetupCgroup(const CgroupDescriptor&) {
 
 #endif
 
+static bool WriteRcFile(const std::map<std::string, CgroupDescriptor>& descriptors) {
+    unique_fd fd(TEMP_FAILURE_RETRY(open(CGROUPS_RC_PATH, O_CREAT | O_WRONLY | O_TRUNC | O_CLOEXEC,
+                                         S_IRUSR | S_IRGRP | S_IROTH)));
+    if (fd < 0) {
+        PLOG(ERROR) << "open() failed for " << CGROUPS_RC_PATH;
+        return false;
+    }
+
+    format::CgroupFile fl;
+    fl.version_ = format::CgroupFile::FILE_CURR_VERSION;
+    fl.controller_count_ = descriptors.size();
+    int ret = TEMP_FAILURE_RETRY(write(fd, &fl, sizeof(fl)));
+    if (ret < 0) {
+        PLOG(ERROR) << "write() failed for " << CGROUPS_RC_PATH;
+        return false;
+    }
+
+    for (const auto& [name, descriptor] : descriptors) {
+        ret = TEMP_FAILURE_RETRY(
+                write(fd, descriptor.controller(), sizeof(format::CgroupController)));
+        if (ret < 0) {
+            PLOG(ERROR) << "write() failed for " << CGROUPS_RC_PATH;
+            return false;
+        }
+    }
+
+    return true;
+}
+
 CgroupDescriptor::CgroupDescriptor(uint32_t version, const std::string& name,
                                    const std::string& path, mode_t mode, const std::string& uid,
                                    const std::string& gid, uint32_t flags,
@@ -278,6 +458,9 @@ void CgroupDescriptor::set_mounted(bool mounted) {
     controller_.set_flags(flags);
 }
 
+}  // namespace cgrouprc
+}  // namespace android
+
 static std::optional<bool> MGLRUDisabled() {
     const std::string file_name = "/sys/kernel/mm/lru_gen/enabled";
     std::string content;
@@ -289,8 +472,9 @@ static std::optional<bool> MGLRUDisabled() {
     return content == "0x0000";
 }
 
-static std::optional<bool> MEMCGDisabled(const CgroupDescriptorMap& descriptors) {
-    std::string cgroup_v2_root = CGROUP_V2_ROOT_DEFAULT;
+static std::optional<bool> MEMCGDisabled(
+        const std::map<std::string, android::cgrouprc::CgroupDescriptor>& descriptors) {
+    std::string cgroup_v2_root = android::cgrouprc::CGROUP_V2_ROOT_DEFAULT;
     const auto it = descriptors.find(CGROUPV2_HIERARCHY_NAME);
     if (it == descriptors.end()) {
         LOG(WARNING) << "No Cgroups2 path found in cgroups.json. Vendor has modified Android, and "
@@ -311,10 +495,14 @@ static std::optional<bool> MEMCGDisabled(const CgroupDescriptorMap& descriptors)
     return content.find("memory") == std::string::npos;
 }
 
-static bool CreateV2SubHierarchy(const std::string& path, const CgroupDescriptorMap& descriptors) {
+static bool CreateV2SubHierarchy(
+        const std::string& path,
+        const std::map<std::string, android::cgrouprc::CgroupDescriptor>& descriptors) {
+    using namespace android::cgrouprc;
+
     const auto cgv2_iter = descriptors.find(CGROUPV2_HIERARCHY_NAME);
     if (cgv2_iter == descriptors.end()) return false;
-    const CgroupDescriptor cgv2_descriptor = cgv2_iter->second;
+    const android::cgrouprc::CgroupDescriptor cgv2_descriptor = cgv2_iter->second;
 
     if (!Mkdir(path, cgv2_descriptor.mode(), cgv2_descriptor.uid(), cgv2_descriptor.gid())) {
         PLOG(ERROR) << "Failed to create directory for " << path;
@@ -324,10 +512,10 @@ static bool CreateV2SubHierarchy(const std::string& path, const CgroupDescriptor
     // Activate all v2 controllers in path so they can be activated in
     // children as they are created.
     for (const auto& [name, descriptor] : descriptors) {
-        const CgroupController* controller = descriptor.controller();
+        const format::CgroupController* controller = descriptor.controller();
         std::uint32_t flags = controller->flags();
         std::uint32_t max_activation_depth = controller->max_activation_depth();
-        const int depth = GetCgroupDepth(controller->path(), path);
+        const int depth = util::GetCgroupDepth(controller->path(), path);
 
         if (controller->version() == 2 && name != CGROUPV2_HIERARCHY_NAME &&
             flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
@@ -347,13 +535,22 @@ static bool CreateV2SubHierarchy(const std::string& path, const CgroupDescriptor
 }
 
 bool CgroupSetup() {
-    CgroupDescriptorMap descriptors;
+    using namespace android::cgrouprc;
+
+    std::map<std::string, CgroupDescriptor> descriptors;
 
     if (getpid() != 1) {
         LOG(ERROR) << "Cgroup setup can be done only by init process";
         return false;
     }
 
+    // Make sure we do this only one time. No need for std::call_once because
+    // init is a single-threaded process
+    if (access(CGROUPS_RC_PATH, F_OK) == 0) {
+        LOG(WARNING) << "Attempt to call CgroupSetup() more than once";
+        return true;
+    }
+
     // load cgroups.json file
     if (!ReadDescriptors(&descriptors)) {
         LOG(ERROR) << "Failed to load cgroup description file";
@@ -362,18 +559,15 @@ bool CgroupSetup() {
 
     // setup cgroups
     for (auto& [name, descriptor] : descriptors) {
-        if (descriptor.controller()->flags() & CGROUPRC_CONTROLLER_FLAG_MOUNTED) {
-            LOG(WARNING) << "Attempt to call CgroupSetup() more than once";
-            return true;
-        }
-
-        if (!SetupCgroup(descriptor)) {
+        if (SetupCgroup(descriptor)) {
+            descriptor.set_mounted(true);
+        } else {
             // issue a warning and proceed with the next cgroup
             LOG(WARNING) << "Failed to setup " << name << " cgroup";
         }
     }
 
-    if (android::libprocessgroup_flags::force_memcg_v2()) {
+    if (force_memcg_v2) {
         if (MGLRUDisabled().value_or(false)) {
             LOG(WARNING) << "Memcg forced to v2 hierarchy with MGLRU disabled! "
                          << "Global reclaim performance will suffer.";
@@ -399,5 +593,26 @@ bool CgroupSetup() {
         }
     }
 
+    // mkdir <CGROUPS_RC_DIR> 0711 system system
+    if (!Mkdir(android::base::Dirname(CGROUPS_RC_PATH), 0711, "system", "system")) {
+        LOG(ERROR) << "Failed to create directory for " << CGROUPS_RC_PATH << " file";
+        return false;
+    }
+
+    // Generate <CGROUPS_RC_FILE> file which can be directly mmapped into
+    // process memory. This optimizes performance, memory usage
+    // and limits infrormation shared with unprivileged processes
+    // to the minimum subset of information from cgroups.json
+    if (!WriteRcFile(descriptors)) {
+        LOG(ERROR) << "Failed to write " << CGROUPS_RC_PATH << " file";
+        return false;
+    }
+
+    // chmod 0644 <CGROUPS_RC_PATH>
+    if (fchmodat(AT_FDCWD, CGROUPS_RC_PATH, 0644, AT_SYMLINK_NOFOLLOW) < 0) {
+        PLOG(ERROR) << "fchmodat() failed";
+        return false;
+    }
+
     return true;
 }
diff --git a/libprocessgroup/util/Android.bp b/libprocessgroup/util/Android.bp
index 1c74d4ed52e1..54ba69b4eb70 100644
--- a/libprocessgroup/util/Android.bp
+++ b/libprocessgroup/util/Android.bp
@@ -37,16 +37,8 @@ cc_library_static {
         "include",
     ],
     srcs: [
-        "cgroup_controller.cpp",
-        "cgroup_descriptor.cpp",
         "util.cpp",
     ],
-    shared_libs: [
-        "libbase",
-    ],
-    static_libs: [
-        "libjsoncpp",
-    ],
     defaults: ["libprocessgroup_build_flags_cc"],
 }
 
diff --git a/libprocessgroup/util/cgroup_descriptor.cpp b/libprocessgroup/util/cgroup_descriptor.cpp
deleted file mode 100644
index 4d3347f348f0..000000000000
--- a/libprocessgroup/util/cgroup_descriptor.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (C) 2024 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <processgroup/cgroup_descriptor.h>
-
-#include <processgroup/util.h>  // For flag values
-
-CgroupDescriptor::CgroupDescriptor(uint32_t version, const std::string& name,
-                                   const std::string& path, mode_t mode, const std::string& uid,
-                                   const std::string& gid, uint32_t flags,
-                                   uint32_t max_activation_depth)
-    : controller_(version, flags, name, path, max_activation_depth),
-      mode_(mode),
-      uid_(uid),
-      gid_(gid) {}
-
-void CgroupDescriptor::set_mounted(bool mounted) {
-    uint32_t flags = controller_.flags();
-    if (mounted) {
-        flags |= CGROUPRC_CONTROLLER_FLAG_MOUNTED;
-    } else {
-        flags &= ~CGROUPRC_CONTROLLER_FLAG_MOUNTED;
-    }
-    controller_.set_flags(flags);
-}
diff --git a/libprocessgroup/util/include/processgroup/cgroup_descriptor.h b/libprocessgroup/util/include/processgroup/cgroup_descriptor.h
deleted file mode 100644
index 1afd2ee9ceb4..000000000000
--- a/libprocessgroup/util/include/processgroup/cgroup_descriptor.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <cstdint>
-#include <string>
-
-#include <sys/stat.h>
-
-#include <processgroup/cgroup_controller.h>
-
-// Complete controller description for mounting cgroups
-class CgroupDescriptor {
-  public:
-    CgroupDescriptor(uint32_t version, const std::string& name, const std::string& path,
-                     mode_t mode, const std::string& uid, const std::string& gid, uint32_t flags,
-                     uint32_t max_activation_depth);
-
-    const CgroupController* controller() const { return &controller_; }
-    mode_t mode() const { return mode_; }
-    std::string uid() const { return uid_; }
-    std::string gid() const { return gid_; }
-
-    void set_mounted(bool mounted);
-
-  private:
-    CgroupController controller_;
-    mode_t mode_ = 0;
-    std::string uid_;
-    std::string gid_;
-};
diff --git a/libprocessgroup/util/include/processgroup/util.h b/libprocessgroup/util/include/processgroup/util.h
index d592a63477d2..8d013af55164 100644
--- a/libprocessgroup/util/include/processgroup/util.h
+++ b/libprocessgroup/util/include/processgroup/util.h
@@ -16,18 +16,10 @@
 
 #pragma once
 
-#include <map>
 #include <string>
 
-#include "cgroup_descriptor.h"
-
-// Duplicated from cgrouprc.h. Don't depend on libcgrouprc here.
-#define CGROUPRC_CONTROLLER_FLAG_MOUNTED 0x1
-#define CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION 0x2
-#define CGROUPRC_CONTROLLER_FLAG_OPTIONAL 0x4
+namespace util {
 
 unsigned int GetCgroupDepth(const std::string& controller_root, const std::string& cgroup_path);
 
-using CgroupControllerName = std::string;
-using CgroupDescriptorMap = std::map<CgroupControllerName, CgroupDescriptor>;
-bool ReadDescriptors(CgroupDescriptorMap* descriptors);
+}  // namespace util
diff --git a/libprocessgroup/util/tests/util.cpp b/libprocessgroup/util/tests/util.cpp
index 6caef8ee3910..1de7d6f3fb36 100644
--- a/libprocessgroup/util/tests/util.cpp
+++ b/libprocessgroup/util/tests/util.cpp
@@ -18,6 +18,8 @@
 
 #include "gtest/gtest.h"
 
+using util::GetCgroupDepth;
+
 TEST(EmptyInputs, bothEmpty) {
     EXPECT_EQ(GetCgroupDepth({}, {}), 0);
 }
diff --git a/libprocessgroup/util/util.cpp b/libprocessgroup/util/util.cpp
index bff4c6f1ac35..9b88a223a617 100644
--- a/libprocessgroup/util/util.cpp
+++ b/libprocessgroup/util/util.cpp
@@ -18,33 +18,9 @@
 
 #include <algorithm>
 #include <iterator>
-#include <optional>
-#include <string_view>
-
-#include <mntent.h>
-
-#include <android-base/file.h>
-#include <android-base/logging.h>
-#include <android-base/properties.h>
-#include <android-base/stringprintf.h>
-#include <json/reader.h>
-#include <json/value.h>
-
-#include "../build_flags.h"
-#include "../internal.h"
-
-using android::base::GetUintProperty;
 
 namespace {
 
-constexpr const char* CGROUPS_DESC_FILE = "/etc/cgroups.json";
-constexpr const char* CGROUPS_DESC_VENDOR_FILE = "/vendor/etc/cgroups.json";
-constexpr const char* TEMPLATE_CGROUPS_DESC_API_FILE = "/etc/task_profiles/cgroups_%u.json";
-
-// This should match the publicly declared value in processgroup.h,
-// but we don't want this library to depend on libprocessgroup.
-constexpr std::string CGROUPV2_HIERARCHY_NAME_INTERNAL = "cgroup2";
-
 const char SEP = '/';
 
 std::string DeduplicateAndTrimSeparators(const std::string& path) {
@@ -66,135 +42,9 @@ std::string DeduplicateAndTrimSeparators(const std::string& path) {
     return ret;
 }
 
-void MergeCgroupToDescriptors(CgroupDescriptorMap* descriptors, const Json::Value& cgroup,
-                              const std::string& name, const std::string& root_path,
-                              int cgroups_version) {
-    const std::string cgroup_path = cgroup["Path"].asString();
-    std::string path;
-
-    if (!root_path.empty()) {
-        path = root_path;
-        if (cgroup_path != ".") {
-            path += "/";
-            path += cgroup_path;
-        }
-    } else {
-        path = cgroup_path;
-    }
-
-    uint32_t controller_flags = 0;
-
-    if (cgroup["NeedsActivation"].isBool() && cgroup["NeedsActivation"].asBool()) {
-        controller_flags |= CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION;
-    }
-
-    if (cgroup["Optional"].isBool() && cgroup["Optional"].asBool()) {
-        controller_flags |= CGROUPRC_CONTROLLER_FLAG_OPTIONAL;
-    }
-
-    uint32_t max_activation_depth = UINT32_MAX;
-    if (cgroup.isMember("MaxActivationDepth")) {
-        max_activation_depth = cgroup["MaxActivationDepth"].asUInt();
-    }
-
-    CgroupDescriptor descriptor(
-            cgroups_version, name, path, std::strtoul(cgroup["Mode"].asString().c_str(), 0, 8),
-            cgroup["UID"].asString(), cgroup["GID"].asString(), controller_flags,
-            max_activation_depth);
-
-    auto iter = descriptors->find(name);
-    if (iter == descriptors->end()) {
-        descriptors->emplace(name, descriptor);
-    } else {
-        iter->second = descriptor;
-    }
-}
-
-bool ReadDescriptorsFromFile(const std::string& file_name, CgroupDescriptorMap* descriptors) {
-    static constexpr bool force_memcg_v2 = android::libprocessgroup_flags::force_memcg_v2();
-    std::vector<CgroupDescriptor> result;
-    std::string json_doc;
-
-    if (!android::base::ReadFileToString(file_name, &json_doc)) {
-        PLOG(ERROR) << "Failed to read task profiles from " << file_name;
-        return false;
-    }
-
-    Json::CharReaderBuilder builder;
-    std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
-    Json::Value root;
-    std::string errorMessage;
-    if (!reader->parse(&*json_doc.begin(), &*json_doc.end(), &root, &errorMessage)) {
-        LOG(ERROR) << "Failed to parse cgroups description: " << errorMessage;
-        return false;
-    }
-
-    if (root.isMember("Cgroups")) {
-        const Json::Value& cgroups = root["Cgroups"];
-        for (Json::Value::ArrayIndex i = 0; i < cgroups.size(); ++i) {
-            std::string name = cgroups[i]["Controller"].asString();
-
-            if (force_memcg_v2 && name == "memory") continue;
-
-            MergeCgroupToDescriptors(descriptors, cgroups[i], name, "", 1);
-        }
-    }
-
-    bool memcgv2_present = false;
-    std::string root_path;
-    if (root.isMember("Cgroups2")) {
-        const Json::Value& cgroups2 = root["Cgroups2"];
-        root_path = cgroups2["Path"].asString();
-        MergeCgroupToDescriptors(descriptors, cgroups2, CGROUPV2_HIERARCHY_NAME_INTERNAL, "", 2);
-
-        const Json::Value& childGroups = cgroups2["Controllers"];
-        for (Json::Value::ArrayIndex i = 0; i < childGroups.size(); ++i) {
-            std::string name = childGroups[i]["Controller"].asString();
-
-            if (force_memcg_v2 && name == "memory") memcgv2_present = true;
-
-            MergeCgroupToDescriptors(descriptors, childGroups[i], name, root_path, 2);
-        }
-    }
-
-    if (force_memcg_v2 && !memcgv2_present) {
-        LOG(INFO) << "Forcing memcg to v2 hierarchy";
-        Json::Value memcgv2;
-        memcgv2["Controller"] = "memory";
-        memcgv2["NeedsActivation"] = true;
-        memcgv2["Path"] = ".";
-        memcgv2["Optional"] = true;  // In case of cgroup_disabled=memory, so we can still boot
-        MergeCgroupToDescriptors(descriptors, memcgv2, "memory",
-                                 root_path.empty() ? CGROUP_V2_ROOT_DEFAULT : root_path, 2);
-    }
-
-    return true;
-}
-
-using MountDir = std::string;
-using MountOpts = std::string;
-static std::optional<std::map<MountDir, MountOpts>> ReadCgroupV1Mounts() {
-    FILE* fp = setmntent("/proc/mounts", "r");
-    if (fp == nullptr) {
-        PLOG(ERROR) << "Failed to read mounts";
-        return std::nullopt;
-    }
-
-    std::map<MountDir, MountOpts> mounts;
-    const std::string_view CGROUP_V1_TYPE = "cgroup";
-    for (mntent* mentry = getmntent(fp); mentry != nullptr; mentry = getmntent(fp)) {
-        if (mentry->mnt_type && CGROUP_V1_TYPE == mentry->mnt_type &&
-            mentry->mnt_dir && mentry->mnt_opts) {
-            mounts[mentry->mnt_dir] = mentry->mnt_opts;
-        }
-    }
-    endmntent(fp);
-
-    return mounts;
-}
-
 }  // anonymous namespace
 
+namespace util {
 
 unsigned int GetCgroupDepth(const std::string& controller_root, const std::string& cgroup_path) {
     const std::string deduped_root = DeduplicateAndTrimSeparators(controller_root);
@@ -206,47 +56,4 @@ unsigned int GetCgroupDepth(const std::string& controller_root, const std::strin
     return std::count(deduped_path.begin() + deduped_root.size(), deduped_path.end(), SEP);
 }
 
-bool ReadDescriptors(CgroupDescriptorMap* descriptors) {
-    // load system cgroup descriptors
-    if (!ReadDescriptorsFromFile(CGROUPS_DESC_FILE, descriptors)) {
-        return false;
-    }
-
-    // load API-level specific system cgroups descriptors if available
-    unsigned int api_level = GetUintProperty<unsigned int>("ro.product.first_api_level", 0);
-    if (api_level > 0) {
-        std::string api_cgroups_path =
-                android::base::StringPrintf(TEMPLATE_CGROUPS_DESC_API_FILE, api_level);
-        if (!access(api_cgroups_path.c_str(), F_OK) || errno != ENOENT) {
-            if (!ReadDescriptorsFromFile(api_cgroups_path, descriptors)) {
-                return false;
-            }
-        }
-    }
-
-    // load vendor cgroup descriptors if the file exists
-    if (!access(CGROUPS_DESC_VENDOR_FILE, F_OK) &&
-        !ReadDescriptorsFromFile(CGROUPS_DESC_VENDOR_FILE, descriptors)) {
-        return false;
-    }
-
-    // check for v1 mount/usability status
-    std::optional<std::map<MountDir, MountOpts>> v1Mounts;
-    for (auto& [name, descriptor] : *descriptors) {
-        const CgroupController* const controller = descriptor.controller();
-
-        if (controller->version() != 1) continue;
-
-        // Read only once, and only if we have at least one v1 controller
-        if (!v1Mounts) {
-            v1Mounts = ReadCgroupV1Mounts();
-            if (!v1Mounts) return false;
-        }
-
-        if (const auto it = v1Mounts->find(controller->path()); it != v1Mounts->end()) {
-            if (it->second.contains(controller->name())) descriptor.set_mounted(true);
-        }
-    }
-
-    return true;
-}
+}  // namespace util

From aeca8793f533c243d0f9353bce5e276f48e01363 Mon Sep 17 00:00:00 2001
From: "Priyanka Advani (xWF)" <padvani@google.com>
Date: Tue, 8 Oct 2024 18:54:37 +0000
Subject: [PATCH 1156/1487] Revert "libprocessgroup: Remove
 ACgroupController_getMaxActivati..."

Revert submission 3212512

Reason for revert: Droidmonitor created revert due to b/372273614. Will be verifying through ABTD before submission.

Reverted changes: /q/submissionid:3212512

Change-Id: I0964d1300791334cdc9e98220324d934f7ba113e
---
 libprocessgroup/cgrouprc/a_cgroup_controller.cpp    | 5 +++++
 libprocessgroup/cgrouprc/include/android/cgrouprc.h | 8 ++++++++
 libprocessgroup/cgrouprc/libcgrouprc.map.txt        | 7 +++++++
 3 files changed, 20 insertions(+)

diff --git a/libprocessgroup/cgrouprc/a_cgroup_controller.cpp b/libprocessgroup/cgrouprc/a_cgroup_controller.cpp
index 5a326e55d4de..889b3becf1a2 100644
--- a/libprocessgroup/cgrouprc/a_cgroup_controller.cpp
+++ b/libprocessgroup/cgrouprc/a_cgroup_controller.cpp
@@ -32,6 +32,11 @@ uint32_t ACgroupController_getFlags(const ACgroupController* controller) {
     return controller->flags();
 }
 
+uint32_t ACgroupController_getMaxActivationDepth(const ACgroupController* controller) {
+    CHECK(controller != nullptr);
+    return controller->max_activation_depth();
+}
+
 const char* ACgroupController_getName(const ACgroupController* controller) {
     CHECK(controller != nullptr);
     return controller->name();
diff --git a/libprocessgroup/cgrouprc/include/android/cgrouprc.h b/libprocessgroup/cgrouprc/include/android/cgrouprc.h
index e704a36aac9d..3a57df547d60 100644
--- a/libprocessgroup/cgrouprc/include/android/cgrouprc.h
+++ b/libprocessgroup/cgrouprc/include/android/cgrouprc.h
@@ -78,6 +78,14 @@ __attribute__((warn_unused_result)) uint32_t ACgroupController_getVersion(const
 __attribute__((warn_unused_result, weak)) uint32_t ACgroupController_getFlags(
         const ACgroupController*) __INTRODUCED_IN(30);
 
+/**
+ * Returns the maximum activation depth of the given controller.
+ * Only applicable to cgroup v2 controllers.
+ * Returns UINT32_MAX if no maximum activation depth is set.
+ */
+__attribute__((warn_unused_result, weak)) uint32_t ACgroupController_getMaxActivationDepth(
+        const ACgroupController* controller) __INTRODUCED_IN(36);
+
 /**
  * Returns the name of the given controller.
  * If the given controller is null, return nullptr.
diff --git a/libprocessgroup/cgrouprc/libcgrouprc.map.txt b/libprocessgroup/cgrouprc/libcgrouprc.map.txt
index b62b10f3b457..30bd25f18dbd 100644
--- a/libprocessgroup/cgrouprc/libcgrouprc.map.txt
+++ b/libprocessgroup/cgrouprc/libcgrouprc.map.txt
@@ -16,3 +16,10 @@ LIBCGROUPRC_30 { # introduced=30
   local:
     *;
 };
+
+LIBCGROUPRC_36 { # introduced=36
+  global:
+    ACgroupController_getMaxActivationDepth; # llndk=202504 systemapi
+  local:
+    *;
+};

From 691ad736bb4088a634e2766334c17ae8a2bfbe79 Mon Sep 17 00:00:00 2001
From: "Priyanka Advani (xWF)" <padvani@google.com>
Date: Tue, 8 Oct 2024 18:54:37 +0000
Subject: [PATCH 1157/1487] Revert "libprocessgroup: Remove dependency on
 libcgrouprc"

Revert submission 3212512

Reason for revert: Droidmonitor created revert due to b/372273614. Will be verifying through ABTD before submission.

Reverted changes: /q/submissionid:3212512

Change-Id: I15c7763467cd9f65d4b389b2d4ccaff92012f21f
---
 libprocessgroup/Android.bp     |  1 +
 libprocessgroup/cgroup_map.cpp | 97 +++++++++++++++++++++-------------
 libprocessgroup/cgroup_map.h   | 13 ++---
 3 files changed, 67 insertions(+), 44 deletions(-)

diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index 8448a39a47c0..d623a1152e4a 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -75,6 +75,7 @@ cc_library {
     double_loadable: true,
     shared_libs: [
         "libbase",
+        "libcgrouprc",
     ],
     static_libs: [
         "libjsoncpp",
diff --git a/libprocessgroup/cgroup_map.cpp b/libprocessgroup/cgroup_map.cpp
index 8180ccf3ff2e..aeccfe89b91b 100644
--- a/libprocessgroup/cgroup_map.cpp
+++ b/libprocessgroup/cgroup_map.cpp
@@ -25,10 +25,12 @@
 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
+#include <android-base/strings.h>
 #include <cgroup_map.h>
 #include <processgroup/processgroup.h>
 #include <processgroup/util.h>
 
+using android::base::StartsWith;
 using android::base::StringPrintf;
 using android::base::WriteStringToFile;
 
@@ -38,17 +40,17 @@ static constexpr const char* CGROUP_TASKS_FILE_V2 = "/cgroup.threads";
 
 uint32_t CgroupControllerWrapper::version() const {
     CHECK(HasValue());
-    return controller_->version();
+    return ACgroupController_getVersion(controller_);
 }
 
 const char* CgroupControllerWrapper::name() const {
     CHECK(HasValue());
-    return controller_->name();
+    return ACgroupController_getName(controller_);
 }
 
 const char* CgroupControllerWrapper::path() const {
     CHECK(HasValue());
-    return controller_->path();
+    return ACgroupController_getPath(controller_);
 }
 
 bool CgroupControllerWrapper::HasValue() const {
@@ -60,7 +62,7 @@ bool CgroupControllerWrapper::IsUsable() {
 
     if (state_ == UNKNOWN) {
         if (__builtin_available(android 30, *)) {
-            uint32_t flags = controller_->flags();
+            uint32_t flags = ACgroupController_getFlags(controller_);
             state_ = (flags & CGROUPRC_CONTROLLER_FLAG_MOUNTED) != 0 ? USABLE : MISSING;
         } else {
             state_ = access(GetProcsFilePath("", 0, 0).c_str(), F_OK) == 0 ? USABLE : MISSING;
@@ -127,8 +129,8 @@ bool CgroupControllerWrapper::GetTaskGroup(pid_t tid, std::string* group) const
 }
 
 CgroupMap::CgroupMap() {
-    if (!LoadDescriptors()) {
-        LOG(ERROR) << "CgroupMap::LoadDescriptors called for [" << getpid() << "] failed";
+    if (!LoadRcFile()) {
+        LOG(ERROR) << "CgroupMap::LoadRcFile called for [" << getpid() << "] failed";
     }
 }
 
@@ -139,9 +141,9 @@ CgroupMap& CgroupMap::GetInstance() {
     return *instance;
 }
 
-bool CgroupMap::LoadDescriptors() {
+bool CgroupMap::LoadRcFile() {
     if (!loaded_) {
-        loaded_ = ReadDescriptors(&descriptors_);
+        loaded_ = (ACgroupFile_getVersion() != 0);
     }
     return loaded_;
 }
@@ -152,27 +154,40 @@ void CgroupMap::Print() const {
                    << "] failed, cgroups were not initialized properly";
         return;
     }
-    LOG(INFO) << "Controller count = " << descriptors_.size();
+    LOG(INFO) << "File version = " << ACgroupFile_getVersion();
+    LOG(INFO) << "File controller count = " << ACgroupFile_getControllerCount();
 
     LOG(INFO) << "Mounted cgroups:";
 
-    for (const auto& [name, descriptor] : descriptors_) {
-        LOG(INFO) << "\t" << descriptor.controller()->name() << " ver "
-                  << descriptor.controller()->version() << " path "
-                  << descriptor.controller()->path() << " flags "
-                  << descriptor.controller()->flags();
+    auto controller_count = ACgroupFile_getControllerCount();
+    for (uint32_t i = 0; i < controller_count; ++i) {
+        const ACgroupController* controller = ACgroupFile_getController(i);
+        if (__builtin_available(android 30, *)) {
+            LOG(INFO) << "\t" << ACgroupController_getName(controller) << " ver "
+                      << ACgroupController_getVersion(controller) << " path "
+                      << ACgroupController_getPath(controller) << " flags "
+                      << ACgroupController_getFlags(controller);
+        } else {
+            LOG(INFO) << "\t" << ACgroupController_getName(controller) << " ver "
+                      << ACgroupController_getVersion(controller) << " path "
+                      << ACgroupController_getPath(controller);
+        }
     }
 }
 
 CgroupControllerWrapper CgroupMap::FindController(const std::string& name) const {
     if (!loaded_) {
         LOG(ERROR) << "CgroupMap::FindController called for [" << getpid()
-                   << "] failed, cgroups were not initialized properly";
+                   << "] failed, RC file was not initialized properly";
         return CgroupControllerWrapper(nullptr);
     }
 
-    if (const auto it = descriptors_.find(name); it != descriptors_.end()) {
-        return CgroupControllerWrapper(it->second.controller());
+    auto controller_count = ACgroupFile_getControllerCount();
+    for (uint32_t i = 0; i < controller_count; ++i) {
+        const ACgroupController* controller = ACgroupFile_getController(i);
+        if (name == ACgroupController_getName(controller)) {
+            return CgroupControllerWrapper(controller);
+        }
     }
 
     return CgroupControllerWrapper(nullptr);
@@ -181,13 +196,15 @@ CgroupControllerWrapper CgroupMap::FindController(const std::string& name) const
 CgroupControllerWrapper CgroupMap::FindControllerByPath(const std::string& path) const {
     if (!loaded_) {
         LOG(ERROR) << "CgroupMap::FindControllerByPath called for [" << getpid()
-                   << "] failed, cgroups were not initialized properly";
+                   << "] failed, RC file was not initialized properly";
         return CgroupControllerWrapper(nullptr);
     }
 
-    for (const auto& [name, descriptor] : descriptors_) {
-        if (path.starts_with(descriptor.controller()->path())) {
-            return CgroupControllerWrapper(descriptor.controller());
+    auto controller_count = ACgroupFile_getControllerCount();
+    for (uint32_t i = 0; i < controller_count; ++i) {
+        const ACgroupController* controller = ACgroupFile_getController(i);
+        if (StartsWith(path, ACgroupController_getPath(controller))) {
+            return CgroupControllerWrapper(controller);
         }
     }
 
@@ -195,23 +212,31 @@ CgroupControllerWrapper CgroupMap::FindControllerByPath(const std::string& path)
 }
 
 int CgroupMap::ActivateControllers(const std::string& path) const {
-    for (const auto& [name, descriptor] : descriptors_) {
-        const uint32_t flags = descriptor.controller()->flags();
-        const uint32_t max_activation_depth = descriptor.controller()->max_activation_depth();
-        const int depth = GetCgroupDepth(descriptor.controller()->path(), path);
-
-        if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
-            std::string str("+");
-            str.append(descriptor.controller()->name());
-            if (!WriteStringToFile(str, path + "/cgroup.subtree_control")) {
-                if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
-                    PLOG(WARNING) << "Activation of cgroup controller " << str
-                                  << " failed in path " << path;
-                } else {
-                    return -errno;
+    if (__builtin_available(android 30, *)) {
+        auto controller_count = ACgroupFile_getControllerCount();
+        for (uint32_t i = 0; i < controller_count; ++i) {
+            const ACgroupController* controller = ACgroupFile_getController(i);
+            const uint32_t flags = ACgroupController_getFlags(controller);
+            uint32_t max_activation_depth = UINT32_MAX;
+            if (__builtin_available(android 36, *)) {
+                max_activation_depth = ACgroupController_getMaxActivationDepth(controller);
+            }
+            const int depth = GetCgroupDepth(ACgroupController_getPath(controller), path);
+
+            if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
+                std::string str("+");
+                str.append(ACgroupController_getName(controller));
+                if (!WriteStringToFile(str, path + "/cgroup.subtree_control")) {
+                    if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
+                        PLOG(WARNING) << "Activation of cgroup controller " << str
+                                      << " failed in path " << path;
+                    } else {
+                        return -errno;
+                    }
                 }
             }
         }
+        return 0;
     }
-    return 0;
+    return -ENOSYS;
 }
diff --git a/libprocessgroup/cgroup_map.h b/libprocessgroup/cgroup_map.h
index 5ad59bddf0a5..364279414336 100644
--- a/libprocessgroup/cgroup_map.h
+++ b/libprocessgroup/cgroup_map.h
@@ -18,17 +18,15 @@
 
 #include <sys/types.h>
 
-#include <cstdint>
 #include <string>
 
-#include <processgroup/cgroup_controller.h>
-#include <processgroup/util.h>
+#include <android/cgrouprc.h>
 
-// Convenient wrapper of a CgroupController pointer.
+// Convenient wrapper of an ACgroupController pointer.
 class CgroupControllerWrapper {
   public:
     // Does not own controller
-    explicit CgroupControllerWrapper(const CgroupController* controller)
+    explicit CgroupControllerWrapper(const ACgroupController* controller)
         : controller_(controller) {}
 
     uint32_t version() const;
@@ -49,7 +47,7 @@ class CgroupControllerWrapper {
         MISSING = 2,
     };
 
-    const CgroupController* controller_ = nullptr; // CgroupMap owns the object behind this pointer
+    const ACgroupController* controller_ = nullptr;
     ControllerState state_ = ControllerState::UNKNOWN;
 };
 
@@ -62,8 +60,7 @@ class CgroupMap {
 
   private:
     bool loaded_ = false;
-    CgroupDescriptorMap descriptors_;
     CgroupMap();
-    bool LoadDescriptors();
+    bool LoadRcFile();
     void Print() const;
 };

From 0fa49253a484fc0c99d067ade57a4978059b3a95 Mon Sep 17 00:00:00 2001
From: "Priyanka Advani (xWF)" <padvani@google.com>
Date: Tue, 8 Oct 2024 18:54:37 +0000
Subject: [PATCH 1158/1487] Revert "libprocessgroup: Combine all 3
 ActivateControllers imple..."

Revert submission 3212512

Reason for revert: Droidmonitor created revert due to b/372273614. Will be verifying through ABTD before submission.

Reverted changes: /q/submissionid:3212512

Change-Id: I3dadc0b7bccfe28bb067a93df2acf2c3ea0f9920
---
 libprocessgroup/cgroup_map.cpp                | 22 +++++++++-
 libprocessgroup/cgroup_map.h                  |  2 +-
 libprocessgroup/processgroup.cpp              |  7 ++--
 libprocessgroup/setup/cgroup_map_write.cpp    | 42 ++++++++++++++++++-
 .../util/include/processgroup/util.h          |  2 -
 libprocessgroup/util/util.cpp                 | 23 ----------
 6 files changed, 65 insertions(+), 33 deletions(-)

diff --git a/libprocessgroup/cgroup_map.cpp b/libprocessgroup/cgroup_map.cpp
index 32bef13a1abf..8180ccf3ff2e 100644
--- a/libprocessgroup/cgroup_map.cpp
+++ b/libprocessgroup/cgroup_map.cpp
@@ -194,6 +194,24 @@ CgroupControllerWrapper CgroupMap::FindControllerByPath(const std::string& path)
     return CgroupControllerWrapper(nullptr);
 }
 
-bool CgroupMap::ActivateControllers(const std::string& path) const {
-    return ::ActivateControllers(path, descriptors_);
+int CgroupMap::ActivateControllers(const std::string& path) const {
+    for (const auto& [name, descriptor] : descriptors_) {
+        const uint32_t flags = descriptor.controller()->flags();
+        const uint32_t max_activation_depth = descriptor.controller()->max_activation_depth();
+        const int depth = GetCgroupDepth(descriptor.controller()->path(), path);
+
+        if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
+            std::string str("+");
+            str.append(descriptor.controller()->name());
+            if (!WriteStringToFile(str, path + "/cgroup.subtree_control")) {
+                if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
+                    PLOG(WARNING) << "Activation of cgroup controller " << str
+                                  << " failed in path " << path;
+                } else {
+                    return -errno;
+                }
+            }
+        }
+    }
+    return 0;
 }
diff --git a/libprocessgroup/cgroup_map.h b/libprocessgroup/cgroup_map.h
index fb99076452d6..5ad59bddf0a5 100644
--- a/libprocessgroup/cgroup_map.h
+++ b/libprocessgroup/cgroup_map.h
@@ -58,7 +58,7 @@ class CgroupMap {
     static CgroupMap& GetInstance();
     CgroupControllerWrapper FindController(const std::string& name) const;
     CgroupControllerWrapper FindControllerByPath(const std::string& path) const;
-    bool ActivateControllers(const std::string& path) const;
+    int ActivateControllers(const std::string& path) const;
 
   private:
     bool loaded_ = false;
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index d3719eea39af..83a2258bf2fb 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -662,9 +662,10 @@ static int createProcessGroupInternal(uid_t uid, pid_t initialPid, std::string c
         return -errno;
     }
     if (activate_controllers) {
-        if (!CgroupMap::GetInstance().ActivateControllers(uid_path)) {
-            PLOG(ERROR) << "Failed to activate controllers in " << uid_path;
-            return -errno;
+        ret = CgroupMap::GetInstance().ActivateControllers(uid_path);
+        if (ret) {
+            LOG(ERROR) << "Failed to activate controllers in " << uid_path;
+            return ret;
         }
     }
 
diff --git a/libprocessgroup/setup/cgroup_map_write.cpp b/libprocessgroup/setup/cgroup_map_write.cpp
index d05bf2408cee..82116800821d 100644
--- a/libprocessgroup/setup/cgroup_map_write.cpp
+++ b/libprocessgroup/setup/cgroup_map_write.cpp
@@ -180,7 +180,25 @@ static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
         return false;
     }
 
-    return ::ActivateControllers(controller->path(), {{controller->name(), descriptor}});
+    if (controller->flags() & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION &&
+        controller->max_activation_depth() > 0) {
+        std::string str = "+";
+        str += controller->name();
+        std::string path = controller->path();
+        path += "/cgroup.subtree_control";
+
+        if (!android::base::WriteStringToFile(str, path)) {
+            if (IsOptionalController(controller)) {
+                PLOG(INFO) << "Failed to activate optional controller " << controller->name()
+                           << " at " << path;
+                return true;
+            }
+            PLOG(ERROR) << "Failed to activate controller " << controller->name();
+            return false;
+        }
+    }
+
+    return true;
 }
 
 static bool MountV1CgroupController(const CgroupDescriptor& descriptor) {
@@ -305,7 +323,27 @@ static bool CreateV2SubHierarchy(const std::string& path, const CgroupDescriptor
 
     // Activate all v2 controllers in path so they can be activated in
     // children as they are created.
-    return ::ActivateControllers(path, descriptors);
+    for (const auto& [name, descriptor] : descriptors) {
+        const CgroupController* controller = descriptor.controller();
+        std::uint32_t flags = controller->flags();
+        std::uint32_t max_activation_depth = controller->max_activation_depth();
+        const int depth = GetCgroupDepth(controller->path(), path);
+
+        if (controller->version() == 2 && name != CGROUPV2_HIERARCHY_NAME &&
+            flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
+            std::string str("+");
+            str += controller->name();
+            if (!android::base::WriteStringToFile(str, path + "/cgroup.subtree_control")) {
+                if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
+                    PLOG(WARNING) << "Activation of cgroup controller " << str << " failed in path "
+                                  << path;
+                } else {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
 }
 
 bool CgroupSetup() {
diff --git a/libprocessgroup/util/include/processgroup/util.h b/libprocessgroup/util/include/processgroup/util.h
index 2c7b32926754..d592a63477d2 100644
--- a/libprocessgroup/util/include/processgroup/util.h
+++ b/libprocessgroup/util/include/processgroup/util.h
@@ -31,5 +31,3 @@ unsigned int GetCgroupDepth(const std::string& controller_root, const std::strin
 using CgroupControllerName = std::string;
 using CgroupDescriptorMap = std::map<CgroupControllerName, CgroupDescriptor>;
 bool ReadDescriptors(CgroupDescriptorMap* descriptors);
-
-bool ActivateControllers(const std::string& path, const CgroupDescriptorMap& descriptors);
diff --git a/libprocessgroup/util/util.cpp b/libprocessgroup/util/util.cpp
index 14016751c77b..bff4c6f1ac35 100644
--- a/libprocessgroup/util/util.cpp
+++ b/libprocessgroup/util/util.cpp
@@ -250,26 +250,3 @@ bool ReadDescriptors(CgroupDescriptorMap* descriptors) {
 
     return true;
 }
-
-bool ActivateControllers(const std::string& path, const CgroupDescriptorMap& descriptors) {
-    for (const auto& [name, descriptor] : descriptors) {
-        const uint32_t flags = descriptor.controller()->flags();
-        const uint32_t max_activation_depth = descriptor.controller()->max_activation_depth();
-        const unsigned int depth = GetCgroupDepth(descriptor.controller()->path(), path);
-
-        if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
-            std::string str("+");
-            str.append(descriptor.controller()->name());
-            if (!android::base::WriteStringToFile(str, path + "/cgroup.subtree_control")) {
-                if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
-                    PLOG(WARNING) << "Activation of cgroup controller " << str
-                                  << " failed in path " << path;
-                } else {
-                    return false;
-                }
-            }
-        }
-    }
-    return true;
-}
-

From a09ee8ece68376835e7dc96e439ec4854b90e46c Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 8 Oct 2024 23:41:27 +0000
Subject: [PATCH 1159/1487] Reapply "libprocessgroup: Remove cgroup.rc file"

This reverts commit 972a2d30f8a3f260967b747592f4e8cdc560e01c.

Change-Id: Icdf2824675e515ea3656b1c58ac55160ecc337df
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   7 +-
 init/Android.bp                               |   1 -
 init/init.cpp                                 |   3 -
 libcutils/Android.bp                          |   2 +-
 libprocessgroup/Android.bp                    |   3 +-
 libprocessgroup/cgroup_map.cpp                |   4 +-
 libprocessgroup/cgrouprc/Android.bp           |   3 +-
 libprocessgroup/cgrouprc/a_cgroup_file.cpp    |  88 ++----
 libprocessgroup/cgrouprc/cgrouprc_internal.h  |   7 +-
 libprocessgroup/cgrouprc_format/Android.bp    |  13 -
 .../include/processgroup/processgroup.h       |   2 +-
 .../format/cgroup_file.h => internal.h}       |  23 +-
 libprocessgroup/setup/Android.bp              |   1 -
 libprocessgroup/setup/cgroup_descriptor.h     |  12 +-
 libprocessgroup/setup/cgroup_map_write.cpp    | 259 ++----------------
 libprocessgroup/util/Android.bp               |   8 +
 .../cgroup_controller.cpp                     |  12 +-
 libprocessgroup/util/cgroup_descriptor.cpp    |  38 +++
 .../include/processgroup}/cgroup_controller.h |  12 +-
 .../include/processgroup/cgroup_descriptor.h  |  45 +++
 .../util/include/processgroup/util.h          |  12 +-
 libprocessgroup/util/tests/util.cpp           |   2 -
 libprocessgroup/util/util.cpp                 | 197 ++++++++++++-
 23 files changed, 365 insertions(+), 389 deletions(-)
 rename libprocessgroup/{cgrouprc_format/include/processgroup/format/cgroup_file.h => internal.h} (54%)
 rename libprocessgroup/{cgrouprc_format => util}/cgroup_controller.cpp (90%)
 create mode 100644 libprocessgroup/util/cgroup_descriptor.cpp
 rename libprocessgroup/{cgrouprc_format/include/processgroup/format => util/include/processgroup}/cgroup_controller.h (87%)
 create mode 100644 libprocessgroup/util/include/processgroup/cgroup_descriptor.h

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 298fd9f3095b..083068b54bfe 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -85,9 +85,9 @@ cc_library_static {
         "libsnapshot_cow",
         "liburing",
         "libprocessgroup",
+        "libprocessgroup_util",
         "libjsoncpp",
         "libcgrouprc",
-        "libcgrouprc_format",
     ],
     include_dirs: ["bionic/libc/kernel"],
     export_include_dirs: ["include"],
@@ -129,9 +129,9 @@ cc_defaults {
         "libsnapshot_cow",
         "libsnapuserd",
         "libprocessgroup",
+        "libprocessgroup_util",
         "libjsoncpp",
         "libcgrouprc",
-        "libcgrouprc_format",
         "libsnapuserd_client",
         "libz",
         "liblz4",
@@ -221,9 +221,9 @@ cc_defaults {
         "libsnapshot_cow",
         "libsnapuserd",
         "libprocessgroup",
+        "libprocessgroup_util",
         "libjsoncpp",
         "libcgrouprc",
-        "libcgrouprc_format",
         "liburing",
         "libz",
     ],
@@ -319,7 +319,6 @@ cc_binary_host {
         "libprocessgroup",
         "libjsoncpp",
         "libcgrouprc",
-        "libcgrouprc_format",
         "liburing",
         "libz",
     ],
diff --git a/init/Android.bp b/init/Android.bp
index 18a79d6c4285..8da2e7c2eaf4 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -163,7 +163,6 @@ libinit_cc_defaults {
         "libavb",
         "libavf_cc_flags",
         "libbootloader_message",
-        "libcgrouprc_format",
         "liblmkd_utils",
         "liblz4",
         "libzstd",
diff --git a/init/init.cpp b/init/init.cpp
index 6c8089926ae8..17498da6dce4 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -636,9 +636,6 @@ static Result<void> SetupCgroupsAction(const BuiltinArguments&) {
         LOG(INFO) << "Cgroups support in kernel is not enabled";
         return {};
     }
-    // Have to create <CGROUPS_RC_DIR> using make_dir function
-    // for appropriate sepolicy to be set for it
-    make_dir(android::base::Dirname(CGROUPS_RC_PATH), 0711);
     if (!CgroupSetup()) {
         return ErrnoError() << "Failed to setup cgroups";
     }
diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index 3c3eeb6631f3..fc4c571b7ba0 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -301,7 +301,7 @@ cc_defaults {
         android: {
             static_executable: true,
             static_libs: [
-                "libcgrouprc_format",
+                "libprocessgroup_util",
             ] + test_libraries + always_static_test_libraries,
         },
         not_windows: {
diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index a60bfe97344a..d623a1152e4a 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -17,7 +17,7 @@ soong_config_module_type {
 
 libprocessgroup_flag_aware_cc_defaults {
     name: "libprocessgroup_build_flags_cc",
-    cpp_std: "gnu++20",
+    cpp_std: "gnu++23",
     soong_config_variables: {
         memcg_v2_force_enabled: {
             cflags: [
@@ -116,5 +116,6 @@ cc_test {
     ],
     static_libs: [
         "libgmock",
+        "libprocessgroup_util",
     ],
 }
diff --git a/libprocessgroup/cgroup_map.cpp b/libprocessgroup/cgroup_map.cpp
index fb01cfda9ff3..aeccfe89b91b 100644
--- a/libprocessgroup/cgroup_map.cpp
+++ b/libprocessgroup/cgroup_map.cpp
@@ -151,7 +151,7 @@ bool CgroupMap::LoadRcFile() {
 void CgroupMap::Print() const {
     if (!loaded_) {
         LOG(ERROR) << "CgroupMap::Print called for [" << getpid()
-                   << "] failed, RC file was not initialized properly";
+                   << "] failed, cgroups were not initialized properly";
         return;
     }
     LOG(INFO) << "File version = " << ACgroupFile_getVersion();
@@ -221,7 +221,7 @@ int CgroupMap::ActivateControllers(const std::string& path) const {
             if (__builtin_available(android 36, *)) {
                 max_activation_depth = ACgroupController_getMaxActivationDepth(controller);
             }
-            const int depth = util::GetCgroupDepth(ACgroupController_getPath(controller), path);
+            const int depth = GetCgroupDepth(ACgroupController_getPath(controller), path);
 
             if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
                 std::string str("+");
diff --git a/libprocessgroup/cgrouprc/Android.bp b/libprocessgroup/cgrouprc/Android.bp
index cb912476e26a..38b2fa31d4f3 100644
--- a/libprocessgroup/cgrouprc/Android.bp
+++ b/libprocessgroup/cgrouprc/Android.bp
@@ -49,7 +49,8 @@ cc_library {
         "libbase",
     ],
     static_libs: [
-        "libcgrouprc_format",
+        "libjsoncpp",
+        "libprocessgroup_util",
     ],
     stubs: {
         symbol_file: "libcgrouprc.map.txt",
diff --git a/libprocessgroup/cgrouprc/a_cgroup_file.cpp b/libprocessgroup/cgrouprc/a_cgroup_file.cpp
index e26d84114378..33c8376f4cb6 100644
--- a/libprocessgroup/cgrouprc/a_cgroup_file.cpp
+++ b/libprocessgroup/cgrouprc/a_cgroup_file.cpp
@@ -14,93 +14,51 @@
  * limitations under the License.
  */
 
-#include <sys/mman.h>
-#include <sys/stat.h>
-
-#include <memory>
+#include <iterator>
 
 #include <android-base/logging.h>
-#include <android-base/stringprintf.h>
-#include <android-base/unique_fd.h>
 #include <android/cgrouprc.h>
-#include <processgroup/processgroup.h>
+#include <processgroup/util.h>
 
 #include "cgrouprc_internal.h"
 
-using android::base::StringPrintf;
-using android::base::unique_fd;
-
-using android::cgrouprc::format::CgroupController;
-using android::cgrouprc::format::CgroupFile;
-
-static CgroupFile* LoadRcFile() {
-    struct stat sb;
-
-    unique_fd fd(TEMP_FAILURE_RETRY(open(CGROUPS_RC_PATH, O_RDONLY | O_CLOEXEC)));
-    if (fd < 0) {
-        PLOG(ERROR) << "open() failed for " << CGROUPS_RC_PATH;
-        return nullptr;
-    }
-
-    if (fstat(fd, &sb) < 0) {
-        PLOG(ERROR) << "fstat() failed for " << CGROUPS_RC_PATH;
-        return nullptr;
-    }
-
-    size_t file_size = sb.st_size;
-    if (file_size < sizeof(CgroupFile)) {
-        LOG(ERROR) << "Invalid file format " << CGROUPS_RC_PATH;
+static CgroupDescriptorMap* LoadDescriptors() {
+    CgroupDescriptorMap* descriptors = new CgroupDescriptorMap;
+    if (!ReadDescriptors(descriptors)) {
+        LOG(ERROR) << "Failed to load cgroup description file";
         return nullptr;
     }
-
-    CgroupFile* file_data = (CgroupFile*)mmap(nullptr, file_size, PROT_READ, MAP_SHARED, fd, 0);
-    if (file_data == MAP_FAILED) {
-        PLOG(ERROR) << "Failed to mmap " << CGROUPS_RC_PATH;
-        return nullptr;
-    }
-
-    if (file_data->version_ != CgroupFile::FILE_CURR_VERSION) {
-        LOG(ERROR) << CGROUPS_RC_PATH << " file version mismatch";
-        munmap(file_data, file_size);
-        return nullptr;
-    }
-
-    auto expected = sizeof(CgroupFile) + file_data->controller_count_ * sizeof(CgroupController);
-    if (file_size != expected) {
-        LOG(ERROR) << CGROUPS_RC_PATH << " file has invalid size, expected " << expected
-                   << ", actual " << file_size;
-        munmap(file_data, file_size);
-        return nullptr;
-    }
-
-    return file_data;
+    return descriptors;
 }
 
-static CgroupFile* GetInstance() {
+static const CgroupDescriptorMap* GetInstance() {
     // Deliberately leak this object (not munmap) to avoid a race between destruction on
     // process exit and concurrent access from another thread.
-    static auto* file = LoadRcFile();
-    return file;
+    static const CgroupDescriptorMap* descriptors = LoadDescriptors();
+    return descriptors;
 }
 
 uint32_t ACgroupFile_getVersion() {
-    auto file = GetInstance();
-    if (file == nullptr) return 0;
-    return file->version_;
+    static constexpr uint32_t FILE_VERSION_1 = 1;
+    auto descriptors = GetInstance();
+    if (descriptors == nullptr) return 0;
+    // There has only ever been one version, and there will be no more since cgroup.rc is no more
+    return FILE_VERSION_1;
 }
 
 uint32_t ACgroupFile_getControllerCount() {
-    auto file = GetInstance();
-    if (file == nullptr) return 0;
-    return file->controller_count_;
+    auto descriptors = GetInstance();
+    if (descriptors == nullptr) return 0;
+    return descriptors->size();
 }
 
 const ACgroupController* ACgroupFile_getController(uint32_t index) {
-    auto file = GetInstance();
-    if (file == nullptr) return nullptr;
-    CHECK(index < file->controller_count_);
+    auto descriptors = GetInstance();
+    if (descriptors == nullptr) return nullptr;
+    CHECK(index < descriptors->size());
     // Although the object is not actually an ACgroupController object, all ACgroupController_*
     // functions implicitly convert ACgroupController* back to CgroupController* before invoking
     // member functions.
-    return static_cast<ACgroupController*>(&file->controllers_[index]);
+    const CgroupController* p = std::next(descriptors->begin(), index)->second.controller();
+    return static_cast<const ACgroupController*>(p);
 }
diff --git a/libprocessgroup/cgrouprc/cgrouprc_internal.h b/libprocessgroup/cgrouprc/cgrouprc_internal.h
index cd02f0304f17..d517703467d3 100644
--- a/libprocessgroup/cgrouprc/cgrouprc_internal.h
+++ b/libprocessgroup/cgrouprc/cgrouprc_internal.h
@@ -16,9 +16,6 @@
 
 #pragma once
 
-#include <android/cgrouprc.h>
+#include <processgroup/cgroup_controller.h>
 
-#include <processgroup/format/cgroup_controller.h>
-#include <processgroup/format/cgroup_file.h>
-
-struct ACgroupController : android::cgrouprc::format::CgroupController {};
+struct ACgroupController : CgroupController {};
diff --git a/libprocessgroup/cgrouprc_format/Android.bp b/libprocessgroup/cgrouprc_format/Android.bp
index 059092419b87..6f9ab3e73e36 100644
--- a/libprocessgroup/cgrouprc_format/Android.bp
+++ b/libprocessgroup/cgrouprc_format/Android.bp
@@ -23,17 +23,4 @@ cc_library_static {
     vendor_ramdisk_available: true,
     recovery_available: true,
     native_bridge_supported: true,
-    srcs: [
-        "cgroup_controller.cpp",
-    ],
-    cflags: [
-        "-Wall",
-        "-Werror",
-    ],
-    export_include_dirs: [
-        "include",
-    ],
-    shared_libs: [
-        "libbase",
-    ],
 }
diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index ffffeb48b0c1..805775744e32 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -57,7 +57,7 @@ __BEGIN_DECLS
 
 bool SetProcessProfilesCached(uid_t uid, pid_t pid, const std::vector<std::string>& profiles);
 
-static constexpr const char* CGROUPS_RC_PATH = "/dev/cgroup_info/cgroup.rc";
+[[deprecated]] static constexpr const char* CGROUPS_RC_PATH = "/dev/cgroup_info/cgroup.rc";
 
 bool UsePerAppMemcg();
 
diff --git a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_file.h b/libprocessgroup/internal.h
similarity index 54%
rename from libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_file.h
rename to libprocessgroup/internal.h
index 2d9786fe6794..ef855790d6df 100644
--- a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_file.h
+++ b/libprocessgroup/internal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,23 +16,6 @@
 
 #pragma once
 
-#include <cstdint>
+#include <string>
 
-#include <processgroup/format/cgroup_controller.h>
-
-namespace android {
-namespace cgrouprc {
-namespace format {
-
-struct CgroupFile {
-    uint32_t version_;
-    uint32_t controller_count_;
-    CgroupController controllers_[];
-
-    static constexpr uint32_t FILE_VERSION_1 = 1;
-    static constexpr uint32_t FILE_CURR_VERSION = FILE_VERSION_1;
-};
-
-}  // namespace format
-}  // namespace cgrouprc
-}  // namespace android
+static const std::string CGROUP_V2_ROOT_DEFAULT = "/sys/fs/cgroup";
\ No newline at end of file
diff --git a/libprocessgroup/setup/Android.bp b/libprocessgroup/setup/Android.bp
index 1a4ad0118ac4..cc6c67cf4fb1 100644
--- a/libprocessgroup/setup/Android.bp
+++ b/libprocessgroup/setup/Android.bp
@@ -33,7 +33,6 @@ cc_library_shared {
         "libjsoncpp",
     ],
     static_libs: [
-        "libcgrouprc_format",
         "libprocessgroup_util",
     ],
     header_libs: [
diff --git a/libprocessgroup/setup/cgroup_descriptor.h b/libprocessgroup/setup/cgroup_descriptor.h
index 06ce186fde7a..1afd2ee9ceb4 100644
--- a/libprocessgroup/setup/cgroup_descriptor.h
+++ b/libprocessgroup/setup/cgroup_descriptor.h
@@ -21,10 +21,7 @@
 
 #include <sys/stat.h>
 
-#include <processgroup/format/cgroup_controller.h>
-
-namespace android {
-namespace cgrouprc {
+#include <processgroup/cgroup_controller.h>
 
 // Complete controller description for mounting cgroups
 class CgroupDescriptor {
@@ -33,7 +30,7 @@ class CgroupDescriptor {
                      mode_t mode, const std::string& uid, const std::string& gid, uint32_t flags,
                      uint32_t max_activation_depth);
 
-    const format::CgroupController* controller() const { return &controller_; }
+    const CgroupController* controller() const { return &controller_; }
     mode_t mode() const { return mode_; }
     std::string uid() const { return uid_; }
     std::string gid() const { return gid_; }
@@ -41,11 +38,8 @@ class CgroupDescriptor {
     void set_mounted(bool mounted);
 
   private:
-    format::CgroupController controller_;
+    CgroupController controller_;
     mode_t mode_ = 0;
     std::string uid_;
     std::string gid_;
 };
-
-}  // namespace cgrouprc
-}  // namespace android
diff --git a/libprocessgroup/setup/cgroup_map_write.cpp b/libprocessgroup/setup/cgroup_map_write.cpp
index bd418747555f..82116800821d 100644
--- a/libprocessgroup/setup/cgroup_map_write.cpp
+++ b/libprocessgroup/setup/cgroup_map_write.cpp
@@ -22,45 +22,28 @@
 #include <fcntl.h>
 #include <grp.h>
 #include <pwd.h>
-#include <sys/mman.h>
 #include <sys/mount.h>
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <time.h>
 #include <unistd.h>
 
 #include <optional>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
-#include <android-base/properties.h>
-#include <android-base/stringprintf.h>
-#include <android-base/unique_fd.h>
-#include <android/cgrouprc.h>
-#include <json/reader.h>
-#include <json/value.h>
-#include <processgroup/format/cgroup_file.h>
+#include <processgroup/cgroup_descriptor.h>
 #include <processgroup/processgroup.h>
 #include <processgroup/setup.h>
 #include <processgroup/util.h>
 
 #include "../build_flags.h"
-#include "cgroup_descriptor.h"
-
-using android::base::GetUintProperty;
-using android::base::StringPrintf;
-using android::base::unique_fd;
-
-namespace android {
-namespace cgrouprc {
+#include "../internal.h"
 
 static constexpr const char* CGROUPS_DESC_FILE = "/etc/cgroups.json";
 static constexpr const char* CGROUPS_DESC_VENDOR_FILE = "/vendor/etc/cgroups.json";
 
 static constexpr const char* TEMPLATE_CGROUPS_DESC_API_FILE = "/etc/task_profiles/cgroups_%u.json";
 
-static const std::string CGROUP_V2_ROOT_DEFAULT = "/sys/fs/cgroup";
-
 static bool ChangeDirModeAndOwner(const std::string& path, mode_t mode, const std::string& uid,
                                   const std::string& gid, bool permissive_mode = false) {
     uid_t pw_uid = -1;
@@ -148,149 +131,15 @@ static bool Mkdir(const std::string& path, mode_t mode, const std::string& uid,
     return true;
 }
 
-static void MergeCgroupToDescriptors(std::map<std::string, CgroupDescriptor>* descriptors,
-                                     const Json::Value& cgroup, const std::string& name,
-                                     const std::string& root_path, int cgroups_version) {
-    const std::string cgroup_path = cgroup["Path"].asString();
-    std::string path;
-
-    if (!root_path.empty()) {
-        path = root_path;
-        if (cgroup_path != ".") {
-            path += "/";
-            path += cgroup_path;
-        }
-    } else {
-        path = cgroup_path;
-    }
-
-    uint32_t controller_flags = 0;
-
-    if (cgroup["NeedsActivation"].isBool() && cgroup["NeedsActivation"].asBool()) {
-        controller_flags |= CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION;
-    }
-
-    if (cgroup["Optional"].isBool() && cgroup["Optional"].asBool()) {
-        controller_flags |= CGROUPRC_CONTROLLER_FLAG_OPTIONAL;
-    }
-
-    uint32_t max_activation_depth = UINT32_MAX;
-    if (cgroup.isMember("MaxActivationDepth")) {
-        max_activation_depth = cgroup["MaxActivationDepth"].asUInt();
-    }
-
-    CgroupDescriptor descriptor(
-            cgroups_version, name, path, std::strtoul(cgroup["Mode"].asString().c_str(), 0, 8),
-            cgroup["UID"].asString(), cgroup["GID"].asString(), controller_flags,
-            max_activation_depth);
-
-    auto iter = descriptors->find(name);
-    if (iter == descriptors->end()) {
-        descriptors->emplace(name, descriptor);
-    } else {
-        iter->second = descriptor;
-    }
-}
-
-static const bool force_memcg_v2 = android::libprocessgroup_flags::force_memcg_v2();
-
-static bool ReadDescriptorsFromFile(const std::string& file_name,
-                                    std::map<std::string, CgroupDescriptor>* descriptors) {
-    std::vector<CgroupDescriptor> result;
-    std::string json_doc;
-
-    if (!android::base::ReadFileToString(file_name, &json_doc)) {
-        PLOG(ERROR) << "Failed to read task profiles from " << file_name;
-        return false;
-    }
-
-    Json::CharReaderBuilder builder;
-    std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
-    Json::Value root;
-    std::string errorMessage;
-    if (!reader->parse(&*json_doc.begin(), &*json_doc.end(), &root, &errorMessage)) {
-        LOG(ERROR) << "Failed to parse cgroups description: " << errorMessage;
-        return false;
-    }
-
-    if (root.isMember("Cgroups")) {
-        const Json::Value& cgroups = root["Cgroups"];
-        for (Json::Value::ArrayIndex i = 0; i < cgroups.size(); ++i) {
-            std::string name = cgroups[i]["Controller"].asString();
-
-            if (force_memcg_v2 && name == "memory") continue;
-
-            MergeCgroupToDescriptors(descriptors, cgroups[i], name, "", 1);
-        }
-    }
-
-    bool memcgv2_present = false;
-    std::string root_path;
-    if (root.isMember("Cgroups2")) {
-        const Json::Value& cgroups2 = root["Cgroups2"];
-        root_path = cgroups2["Path"].asString();
-        MergeCgroupToDescriptors(descriptors, cgroups2, CGROUPV2_HIERARCHY_NAME, "", 2);
-
-        const Json::Value& childGroups = cgroups2["Controllers"];
-        for (Json::Value::ArrayIndex i = 0; i < childGroups.size(); ++i) {
-            std::string name = childGroups[i]["Controller"].asString();
-
-            if (force_memcg_v2 && name == "memory") memcgv2_present = true;
-
-            MergeCgroupToDescriptors(descriptors, childGroups[i], name, root_path, 2);
-        }
-    }
-
-    if (force_memcg_v2 && !memcgv2_present) {
-        LOG(INFO) << "Forcing memcg to v2 hierarchy";
-        Json::Value memcgv2;
-        memcgv2["Controller"] = "memory";
-        memcgv2["NeedsActivation"] = true;
-        memcgv2["Path"] = ".";
-        memcgv2["Optional"] = true;  // In case of cgroup_disabled=memory, so we can still boot
-        MergeCgroupToDescriptors(descriptors, memcgv2, "memory",
-                                 root_path.empty() ? CGROUP_V2_ROOT_DEFAULT : root_path, 2);
-    }
-
-    return true;
-}
-
-static bool ReadDescriptors(std::map<std::string, CgroupDescriptor>* descriptors) {
-    // load system cgroup descriptors
-    if (!ReadDescriptorsFromFile(CGROUPS_DESC_FILE, descriptors)) {
-        return false;
-    }
-
-    // load API-level specific system cgroups descriptors if available
-    unsigned int api_level = GetUintProperty<unsigned int>("ro.product.first_api_level", 0);
-    if (api_level > 0) {
-        std::string api_cgroups_path =
-                android::base::StringPrintf(TEMPLATE_CGROUPS_DESC_API_FILE, api_level);
-        if (!access(api_cgroups_path.c_str(), F_OK) || errno != ENOENT) {
-            if (!ReadDescriptorsFromFile(api_cgroups_path, descriptors)) {
-                return false;
-            }
-        }
-    }
-
-    // load vendor cgroup descriptors if the file exists
-    if (!access(CGROUPS_DESC_VENDOR_FILE, F_OK) &&
-        !ReadDescriptorsFromFile(CGROUPS_DESC_VENDOR_FILE, descriptors)) {
-        return false;
-    }
-
-    return true;
-}
-
 // To avoid issues in sdk_mac build
 #if defined(__ANDROID__)
 
-static bool IsOptionalController(const format::CgroupController* controller) {
+static bool IsOptionalController(const CgroupController* controller) {
     return controller->flags() & CGROUPRC_CONTROLLER_FLAG_OPTIONAL;
 }
 
 static bool MountV2CgroupController(const CgroupDescriptor& descriptor) {
-    const format::CgroupController* controller = descriptor.controller();
+    const CgroupController* controller = descriptor.controller();
 
     // /sys/fs/cgroup is created by cgroup2 with specific selinux permissions,
     // try to create again in case the mount point is changed
@@ -324,7 +173,7 @@ static bool MountV2CgroupController(const CgroupDescriptor& descriptor) {
 }
 
 static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
-    const format::CgroupController* controller = descriptor.controller();
+    const CgroupController* controller = descriptor.controller();
 
     if (!Mkdir(controller->path(), descriptor.mode(), descriptor.uid(), descriptor.gid())) {
         LOG(ERROR) << "Failed to create directory for " << controller->name() << " cgroup";
@@ -338,7 +187,7 @@ static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
         std::string path = controller->path();
         path += "/cgroup.subtree_control";
 
-        if (!base::WriteStringToFile(str, path)) {
+        if (!android::base::WriteStringToFile(str, path)) {
             if (IsOptionalController(controller)) {
                 PLOG(INFO) << "Failed to activate optional controller " << controller->name()
                            << " at " << path;
@@ -353,7 +202,7 @@ static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
 }
 
 static bool MountV1CgroupController(const CgroupDescriptor& descriptor) {
-    const format::CgroupController* controller = descriptor.controller();
+    const CgroupController* controller = descriptor.controller();
 
     // mkdir <path> [mode] [owner] [group]
     if (!Mkdir(controller->path(), descriptor.mode(), descriptor.uid(), descriptor.gid())) {
@@ -388,7 +237,7 @@ static bool MountV1CgroupController(const CgroupDescriptor& descriptor) {
 }
 
 static bool SetupCgroup(const CgroupDescriptor& descriptor) {
-    const format::CgroupController* controller = descriptor.controller();
+    const CgroupController* controller = descriptor.controller();
 
     if (controller->version() == 2) {
         if (!strcmp(controller->name(), CGROUPV2_HIERARCHY_NAME)) {
@@ -410,35 +259,6 @@ static bool SetupCgroup(const CgroupDescriptor&) {
 
 #endif
 
-static bool WriteRcFile(const std::map<std::string, CgroupDescriptor>& descriptors) {
-    unique_fd fd(TEMP_FAILURE_RETRY(open(CGROUPS_RC_PATH, O_CREAT | O_WRONLY | O_TRUNC | O_CLOEXEC,
-                                         S_IRUSR | S_IRGRP | S_IROTH)));
-    if (fd < 0) {
-        PLOG(ERROR) << "open() failed for " << CGROUPS_RC_PATH;
-        return false;
-    }
-
-    format::CgroupFile fl;
-    fl.version_ = format::CgroupFile::FILE_CURR_VERSION;
-    fl.controller_count_ = descriptors.size();
-    int ret = TEMP_FAILURE_RETRY(write(fd, &fl, sizeof(fl)));
-    if (ret < 0) {
-        PLOG(ERROR) << "write() failed for " << CGROUPS_RC_PATH;
-        return false;
-    }
-
-    for (const auto& [name, descriptor] : descriptors) {
-        ret = TEMP_FAILURE_RETRY(
-                write(fd, descriptor.controller(), sizeof(format::CgroupController)));
-        if (ret < 0) {
-            PLOG(ERROR) << "write() failed for " << CGROUPS_RC_PATH;
-            return false;
-        }
-    }
-
-    return true;
-}
-
 CgroupDescriptor::CgroupDescriptor(uint32_t version, const std::string& name,
                                    const std::string& path, mode_t mode, const std::string& uid,
                                    const std::string& gid, uint32_t flags,
@@ -458,9 +278,6 @@ void CgroupDescriptor::set_mounted(bool mounted) {
     controller_.set_flags(flags);
 }
 
-}  // namespace cgrouprc
-}  // namespace android
-
 static std::optional<bool> MGLRUDisabled() {
     const std::string file_name = "/sys/kernel/mm/lru_gen/enabled";
     std::string content;
@@ -472,9 +289,8 @@ static std::optional<bool> MGLRUDisabled() {
     return content == "0x0000";
 }
 
-static std::optional<bool> MEMCGDisabled(
-        const std::map<std::string, android::cgrouprc::CgroupDescriptor>& descriptors) {
-    std::string cgroup_v2_root = android::cgrouprc::CGROUP_V2_ROOT_DEFAULT;
+static std::optional<bool> MEMCGDisabled(const CgroupDescriptorMap& descriptors) {
+    std::string cgroup_v2_root = CGROUP_V2_ROOT_DEFAULT;
     const auto it = descriptors.find(CGROUPV2_HIERARCHY_NAME);
     if (it == descriptors.end()) {
         LOG(WARNING) << "No Cgroups2 path found in cgroups.json. Vendor has modified Android, and "
@@ -495,14 +311,10 @@ static std::optional<bool> MEMCGDisabled(
     return content.find("memory") == std::string::npos;
 }
 
-static bool CreateV2SubHierarchy(
-        const std::string& path,
-        const std::map<std::string, android::cgrouprc::CgroupDescriptor>& descriptors) {
-    using namespace android::cgrouprc;
-
+static bool CreateV2SubHierarchy(const std::string& path, const CgroupDescriptorMap& descriptors) {
     const auto cgv2_iter = descriptors.find(CGROUPV2_HIERARCHY_NAME);
     if (cgv2_iter == descriptors.end()) return false;
-    const android::cgrouprc::CgroupDescriptor cgv2_descriptor = cgv2_iter->second;
+    const CgroupDescriptor cgv2_descriptor = cgv2_iter->second;
 
     if (!Mkdir(path, cgv2_descriptor.mode(), cgv2_descriptor.uid(), cgv2_descriptor.gid())) {
         PLOG(ERROR) << "Failed to create directory for " << path;
@@ -512,10 +324,10 @@ static bool CreateV2SubHierarchy(
     // Activate all v2 controllers in path so they can be activated in
     // children as they are created.
     for (const auto& [name, descriptor] : descriptors) {
-        const format::CgroupController* controller = descriptor.controller();
+        const CgroupController* controller = descriptor.controller();
         std::uint32_t flags = controller->flags();
         std::uint32_t max_activation_depth = controller->max_activation_depth();
-        const int depth = util::GetCgroupDepth(controller->path(), path);
+        const int depth = GetCgroupDepth(controller->path(), path);
 
         if (controller->version() == 2 && name != CGROUPV2_HIERARCHY_NAME &&
             flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
@@ -535,22 +347,13 @@ static bool CreateV2SubHierarchy(
 }
 
 bool CgroupSetup() {
-    using namespace android::cgrouprc;
-
-    std::map<std::string, CgroupDescriptor> descriptors;
+    CgroupDescriptorMap descriptors;
 
     if (getpid() != 1) {
         LOG(ERROR) << "Cgroup setup can be done only by init process";
         return false;
     }
 
-    // Make sure we do this only one time. No need for std::call_once because
-    // init is a single-threaded process
-    if (access(CGROUPS_RC_PATH, F_OK) == 0) {
-        LOG(WARNING) << "Attempt to call CgroupSetup() more than once";
-        return true;
-    }
-
     // load cgroups.json file
     if (!ReadDescriptors(&descriptors)) {
         LOG(ERROR) << "Failed to load cgroup description file";
@@ -559,15 +362,18 @@ bool CgroupSetup() {
 
     // setup cgroups
     for (auto& [name, descriptor] : descriptors) {
-        if (SetupCgroup(descriptor)) {
-            descriptor.set_mounted(true);
-        } else {
+        if (descriptor.controller()->flags() & CGROUPRC_CONTROLLER_FLAG_MOUNTED) {
+            LOG(WARNING) << "Attempt to call CgroupSetup() more than once";
+            return true;
+        }
+
+        if (!SetupCgroup(descriptor)) {
             // issue a warning and proceed with the next cgroup
             LOG(WARNING) << "Failed to setup " << name << " cgroup";
         }
     }
 
-    if (force_memcg_v2) {
+    if (android::libprocessgroup_flags::force_memcg_v2()) {
         if (MGLRUDisabled().value_or(false)) {
             LOG(WARNING) << "Memcg forced to v2 hierarchy with MGLRU disabled! "
                          << "Global reclaim performance will suffer.";
@@ -593,26 +399,5 @@ bool CgroupSetup() {
         }
     }
 
-    // mkdir <CGROUPS_RC_DIR> 0711 system system
-    if (!Mkdir(android::base::Dirname(CGROUPS_RC_PATH), 0711, "system", "system")) {
-        LOG(ERROR) << "Failed to create directory for " << CGROUPS_RC_PATH << " file";
-        return false;
-    }
-
-    // Generate <CGROUPS_RC_FILE> file which can be directly mmapped into
-    // process memory. This optimizes performance, memory usage
-    // and limits infrormation shared with unprivileged processes
-    // to the minimum subset of information from cgroups.json
-    if (!WriteRcFile(descriptors)) {
-        LOG(ERROR) << "Failed to write " << CGROUPS_RC_PATH << " file";
-        return false;
-    }
-
-    // chmod 0644 <CGROUPS_RC_PATH>
-    if (fchmodat(AT_FDCWD, CGROUPS_RC_PATH, 0644, AT_SYMLINK_NOFOLLOW) < 0) {
-        PLOG(ERROR) << "fchmodat() failed";
-        return false;
-    }
-
     return true;
 }
diff --git a/libprocessgroup/util/Android.bp b/libprocessgroup/util/Android.bp
index 54ba69b4eb70..1c74d4ed52e1 100644
--- a/libprocessgroup/util/Android.bp
+++ b/libprocessgroup/util/Android.bp
@@ -37,8 +37,16 @@ cc_library_static {
         "include",
     ],
     srcs: [
+        "cgroup_controller.cpp",
+        "cgroup_descriptor.cpp",
         "util.cpp",
     ],
+    shared_libs: [
+        "libbase",
+    ],
+    static_libs: [
+        "libjsoncpp",
+    ],
     defaults: ["libprocessgroup_build_flags_cc"],
 }
 
diff --git a/libprocessgroup/cgrouprc_format/cgroup_controller.cpp b/libprocessgroup/util/cgroup_controller.cpp
similarity index 90%
rename from libprocessgroup/cgrouprc_format/cgroup_controller.cpp
rename to libprocessgroup/util/cgroup_controller.cpp
index 0dd909a29150..fb4168075db5 100644
--- a/libprocessgroup/cgrouprc_format/cgroup_controller.cpp
+++ b/libprocessgroup/util/cgroup_controller.cpp
@@ -14,11 +14,9 @@
  * limitations under the License.
  */
 
-#include <processgroup/format/cgroup_controller.h>
+#include <processgroup/cgroup_controller.h>
 
-namespace android {
-namespace cgrouprc {
-namespace format {
+#include <cstring>
 
 CgroupController::CgroupController(uint32_t version, uint32_t flags, const std::string& name,
                                    const std::string& path, uint32_t max_activation_depth)
@@ -54,8 +52,4 @@ const char* CgroupController::path() const {
 
 void CgroupController::set_flags(uint32_t flags) {
     flags_ = flags;
-}
-
-}  // namespace format
-}  // namespace cgrouprc
-}  // namespace android
+}
\ No newline at end of file
diff --git a/libprocessgroup/util/cgroup_descriptor.cpp b/libprocessgroup/util/cgroup_descriptor.cpp
new file mode 100644
index 000000000000..4d3347f348f0
--- /dev/null
+++ b/libprocessgroup/util/cgroup_descriptor.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <processgroup/cgroup_descriptor.h>
+
+#include <processgroup/util.h>  // For flag values
+
+CgroupDescriptor::CgroupDescriptor(uint32_t version, const std::string& name,
+                                   const std::string& path, mode_t mode, const std::string& uid,
+                                   const std::string& gid, uint32_t flags,
+                                   uint32_t max_activation_depth)
+    : controller_(version, flags, name, path, max_activation_depth),
+      mode_(mode),
+      uid_(uid),
+      gid_(gid) {}
+
+void CgroupDescriptor::set_mounted(bool mounted) {
+    uint32_t flags = controller_.flags();
+    if (mounted) {
+        flags |= CGROUPRC_CONTROLLER_FLAG_MOUNTED;
+    } else {
+        flags &= ~CGROUPRC_CONTROLLER_FLAG_MOUNTED;
+    }
+    controller_.set_flags(flags);
+}
diff --git a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h b/libprocessgroup/util/include/processgroup/cgroup_controller.h
similarity index 87%
rename from libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
rename to libprocessgroup/util/include/processgroup/cgroup_controller.h
index c0c1f6034fe4..fe6a829a0e83 100644
--- a/libprocessgroup/cgrouprc_format/include/processgroup/format/cgroup_controller.h
+++ b/libprocessgroup/util/include/processgroup/cgroup_controller.h
@@ -20,11 +20,7 @@
 #include <cstdint>
 #include <string>
 
-namespace android {
-namespace cgrouprc {
-namespace format {
-
-// Minimal controller description to be mmapped into process address space
+// Minimal controller description
 struct CgroupController {
   public:
     CgroupController() = default;
@@ -48,8 +44,4 @@ struct CgroupController {
     uint32_t max_activation_depth_ = UINT32_MAX;
     char name_[CGROUP_NAME_BUF_SZ] = {};
     char path_[CGROUP_PATH_BUF_SZ] = {};
-};
-
-}  // namespace format
-}  // namespace cgrouprc
-}  // namespace android
+};
\ No newline at end of file
diff --git a/libprocessgroup/util/include/processgroup/cgroup_descriptor.h b/libprocessgroup/util/include/processgroup/cgroup_descriptor.h
new file mode 100644
index 000000000000..1afd2ee9ceb4
--- /dev/null
+++ b/libprocessgroup/util/include/processgroup/cgroup_descriptor.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+#include <sys/stat.h>
+
+#include <processgroup/cgroup_controller.h>
+
+// Complete controller description for mounting cgroups
+class CgroupDescriptor {
+  public:
+    CgroupDescriptor(uint32_t version, const std::string& name, const std::string& path,
+                     mode_t mode, const std::string& uid, const std::string& gid, uint32_t flags,
+                     uint32_t max_activation_depth);
+
+    const CgroupController* controller() const { return &controller_; }
+    mode_t mode() const { return mode_; }
+    std::string uid() const { return uid_; }
+    std::string gid() const { return gid_; }
+
+    void set_mounted(bool mounted);
+
+  private:
+    CgroupController controller_;
+    mode_t mode_ = 0;
+    std::string uid_;
+    std::string gid_;
+};
diff --git a/libprocessgroup/util/include/processgroup/util.h b/libprocessgroup/util/include/processgroup/util.h
index 8d013af55164..d592a63477d2 100644
--- a/libprocessgroup/util/include/processgroup/util.h
+++ b/libprocessgroup/util/include/processgroup/util.h
@@ -16,10 +16,18 @@
 
 #pragma once
 
+#include <map>
 #include <string>
 
-namespace util {
+#include "cgroup_descriptor.h"
+
+// Duplicated from cgrouprc.h. Don't depend on libcgrouprc here.
+#define CGROUPRC_CONTROLLER_FLAG_MOUNTED 0x1
+#define CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION 0x2
+#define CGROUPRC_CONTROLLER_FLAG_OPTIONAL 0x4
 
 unsigned int GetCgroupDepth(const std::string& controller_root, const std::string& cgroup_path);
 
-}  // namespace util
+using CgroupControllerName = std::string;
+using CgroupDescriptorMap = std::map<CgroupControllerName, CgroupDescriptor>;
+bool ReadDescriptors(CgroupDescriptorMap* descriptors);
diff --git a/libprocessgroup/util/tests/util.cpp b/libprocessgroup/util/tests/util.cpp
index 1de7d6f3fb36..6caef8ee3910 100644
--- a/libprocessgroup/util/tests/util.cpp
+++ b/libprocessgroup/util/tests/util.cpp
@@ -18,8 +18,6 @@
 
 #include "gtest/gtest.h"
 
-using util::GetCgroupDepth;
-
 TEST(EmptyInputs, bothEmpty) {
     EXPECT_EQ(GetCgroupDepth({}, {}), 0);
 }
diff --git a/libprocessgroup/util/util.cpp b/libprocessgroup/util/util.cpp
index 9b88a223a617..bff4c6f1ac35 100644
--- a/libprocessgroup/util/util.cpp
+++ b/libprocessgroup/util/util.cpp
@@ -18,9 +18,33 @@
 
 #include <algorithm>
 #include <iterator>
+#include <optional>
+#include <string_view>
+
+#include <mntent.h>
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/properties.h>
+#include <android-base/stringprintf.h>
+#include <json/reader.h>
+#include <json/value.h>
+
+#include "../build_flags.h"
+#include "../internal.h"
+
+using android::base::GetUintProperty;
 
 namespace {
 
+constexpr const char* CGROUPS_DESC_FILE = "/etc/cgroups.json";
+constexpr const char* CGROUPS_DESC_VENDOR_FILE = "/vendor/etc/cgroups.json";
+constexpr const char* TEMPLATE_CGROUPS_DESC_API_FILE = "/etc/task_profiles/cgroups_%u.json";
+
+// This should match the publicly declared value in processgroup.h,
+// but we don't want this library to depend on libprocessgroup.
+constexpr std::string CGROUPV2_HIERARCHY_NAME_INTERNAL = "cgroup2";
+
 const char SEP = '/';
 
 std::string DeduplicateAndTrimSeparators(const std::string& path) {
@@ -42,9 +66,135 @@ std::string DeduplicateAndTrimSeparators(const std::string& path) {
     return ret;
 }
 
+void MergeCgroupToDescriptors(CgroupDescriptorMap* descriptors, const Json::Value& cgroup,
+                              const std::string& name, const std::string& root_path,
+                              int cgroups_version) {
+    const std::string cgroup_path = cgroup["Path"].asString();
+    std::string path;
+
+    if (!root_path.empty()) {
+        path = root_path;
+        if (cgroup_path != ".") {
+            path += "/";
+            path += cgroup_path;
+        }
+    } else {
+        path = cgroup_path;
+    }
+
+    uint32_t controller_flags = 0;
+
+    if (cgroup["NeedsActivation"].isBool() && cgroup["NeedsActivation"].asBool()) {
+        controller_flags |= CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION;
+    }
+
+    if (cgroup["Optional"].isBool() && cgroup["Optional"].asBool()) {
+        controller_flags |= CGROUPRC_CONTROLLER_FLAG_OPTIONAL;
+    }
+
+    uint32_t max_activation_depth = UINT32_MAX;
+    if (cgroup.isMember("MaxActivationDepth")) {
+        max_activation_depth = cgroup["MaxActivationDepth"].asUInt();
+    }
+
+    CgroupDescriptor descriptor(
+            cgroups_version, name, path, std::strtoul(cgroup["Mode"].asString().c_str(), 0, 8),
+            cgroup["UID"].asString(), cgroup["GID"].asString(), controller_flags,
+            max_activation_depth);
+
+    auto iter = descriptors->find(name);
+    if (iter == descriptors->end()) {
+        descriptors->emplace(name, descriptor);
+    } else {
+        iter->second = descriptor;
+    }
+}
+
+bool ReadDescriptorsFromFile(const std::string& file_name, CgroupDescriptorMap* descriptors) {
+    static constexpr bool force_memcg_v2 = android::libprocessgroup_flags::force_memcg_v2();
+    std::vector<CgroupDescriptor> result;
+    std::string json_doc;
+
+    if (!android::base::ReadFileToString(file_name, &json_doc)) {
+        PLOG(ERROR) << "Failed to read task profiles from " << file_name;
+        return false;
+    }
+
+    Json::CharReaderBuilder builder;
+    std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+    Json::Value root;
+    std::string errorMessage;
+    if (!reader->parse(&*json_doc.begin(), &*json_doc.end(), &root, &errorMessage)) {
+        LOG(ERROR) << "Failed to parse cgroups description: " << errorMessage;
+        return false;
+    }
+
+    if (root.isMember("Cgroups")) {
+        const Json::Value& cgroups = root["Cgroups"];
+        for (Json::Value::ArrayIndex i = 0; i < cgroups.size(); ++i) {
+            std::string name = cgroups[i]["Controller"].asString();
+
+            if (force_memcg_v2 && name == "memory") continue;
+
+            MergeCgroupToDescriptors(descriptors, cgroups[i], name, "", 1);
+        }
+    }
+
+    bool memcgv2_present = false;
+    std::string root_path;
+    if (root.isMember("Cgroups2")) {
+        const Json::Value& cgroups2 = root["Cgroups2"];
+        root_path = cgroups2["Path"].asString();
+        MergeCgroupToDescriptors(descriptors, cgroups2, CGROUPV2_HIERARCHY_NAME_INTERNAL, "", 2);
+
+        const Json::Value& childGroups = cgroups2["Controllers"];
+        for (Json::Value::ArrayIndex i = 0; i < childGroups.size(); ++i) {
+            std::string name = childGroups[i]["Controller"].asString();
+
+            if (force_memcg_v2 && name == "memory") memcgv2_present = true;
+
+            MergeCgroupToDescriptors(descriptors, childGroups[i], name, root_path, 2);
+        }
+    }
+
+    if (force_memcg_v2 && !memcgv2_present) {
+        LOG(INFO) << "Forcing memcg to v2 hierarchy";
+        Json::Value memcgv2;
+        memcgv2["Controller"] = "memory";
+        memcgv2["NeedsActivation"] = true;
+        memcgv2["Path"] = ".";
+        memcgv2["Optional"] = true;  // In case of cgroup_disabled=memory, so we can still boot
+        MergeCgroupToDescriptors(descriptors, memcgv2, "memory",
+                                 root_path.empty() ? CGROUP_V2_ROOT_DEFAULT : root_path, 2);
+    }
+
+    return true;
+}
+
+using MountDir = std::string;
+using MountOpts = std::string;
+static std::optional<std::map<MountDir, MountOpts>> ReadCgroupV1Mounts() {
+    FILE* fp = setmntent("/proc/mounts", "r");
+    if (fp == nullptr) {
+        PLOG(ERROR) << "Failed to read mounts";
+        return std::nullopt;
+    }
+
+    std::map<MountDir, MountOpts> mounts;
+    const std::string_view CGROUP_V1_TYPE = "cgroup";
+    for (mntent* mentry = getmntent(fp); mentry != nullptr; mentry = getmntent(fp)) {
+        if (mentry->mnt_type && CGROUP_V1_TYPE == mentry->mnt_type &&
+            mentry->mnt_dir && mentry->mnt_opts) {
+            mounts[mentry->mnt_dir] = mentry->mnt_opts;
+        }
+    }
+    endmntent(fp);
+
+    return mounts;
+}
+
 }  // anonymous namespace
 
-namespace util {
 
 unsigned int GetCgroupDepth(const std::string& controller_root, const std::string& cgroup_path) {
     const std::string deduped_root = DeduplicateAndTrimSeparators(controller_root);
@@ -56,4 +206,47 @@ unsigned int GetCgroupDepth(const std::string& controller_root, const std::strin
     return std::count(deduped_path.begin() + deduped_root.size(), deduped_path.end(), SEP);
 }
 
-}  // namespace util
+bool ReadDescriptors(CgroupDescriptorMap* descriptors) {
+    // load system cgroup descriptors
+    if (!ReadDescriptorsFromFile(CGROUPS_DESC_FILE, descriptors)) {
+        return false;
+    }
+
+    // load API-level specific system cgroups descriptors if available
+    unsigned int api_level = GetUintProperty<unsigned int>("ro.product.first_api_level", 0);
+    if (api_level > 0) {
+        std::string api_cgroups_path =
+                android::base::StringPrintf(TEMPLATE_CGROUPS_DESC_API_FILE, api_level);
+        if (!access(api_cgroups_path.c_str(), F_OK) || errno != ENOENT) {
+            if (!ReadDescriptorsFromFile(api_cgroups_path, descriptors)) {
+                return false;
+            }
+        }
+    }
+
+    // load vendor cgroup descriptors if the file exists
+    if (!access(CGROUPS_DESC_VENDOR_FILE, F_OK) &&
+        !ReadDescriptorsFromFile(CGROUPS_DESC_VENDOR_FILE, descriptors)) {
+        return false;
+    }
+
+    // check for v1 mount/usability status
+    std::optional<std::map<MountDir, MountOpts>> v1Mounts;
+    for (auto& [name, descriptor] : *descriptors) {
+        const CgroupController* const controller = descriptor.controller();
+
+        if (controller->version() != 1) continue;
+
+        // Read only once, and only if we have at least one v1 controller
+        if (!v1Mounts) {
+            v1Mounts = ReadCgroupV1Mounts();
+            if (!v1Mounts) return false;
+        }
+
+        if (const auto it = v1Mounts->find(controller->path()); it != v1Mounts->end()) {
+            if (it->second.contains(controller->name())) descriptor.set_mounted(true);
+        }
+    }
+
+    return true;
+}

From c76b6ada233ccc8ab83e054177df49791896765b Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 8 Oct 2024 23:41:31 +0000
Subject: [PATCH 1160/1487] Reapply "libprocessgroup: Remove dependency on
 libcgrouprc"

This reverts commit 691ad736bb4088a634e2766334c17ae8a2bfbe79.

Change-Id: I6615792c24b5c3151ba789248cfbdfefaf57a1e4
---
 libprocessgroup/Android.bp     |  1 -
 libprocessgroup/cgroup_map.cpp | 97 +++++++++++++---------------------
 libprocessgroup/cgroup_map.h   | 13 +++--
 3 files changed, 44 insertions(+), 67 deletions(-)

diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index d623a1152e4a..8448a39a47c0 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -75,7 +75,6 @@ cc_library {
     double_loadable: true,
     shared_libs: [
         "libbase",
-        "libcgrouprc",
     ],
     static_libs: [
         "libjsoncpp",
diff --git a/libprocessgroup/cgroup_map.cpp b/libprocessgroup/cgroup_map.cpp
index aeccfe89b91b..8180ccf3ff2e 100644
--- a/libprocessgroup/cgroup_map.cpp
+++ b/libprocessgroup/cgroup_map.cpp
@@ -25,12 +25,10 @@
 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
-#include <android-base/strings.h>
 #include <cgroup_map.h>
 #include <processgroup/processgroup.h>
 #include <processgroup/util.h>
 
-using android::base::StartsWith;
 using android::base::StringPrintf;
 using android::base::WriteStringToFile;
 
@@ -40,17 +38,17 @@ static constexpr const char* CGROUP_TASKS_FILE_V2 = "/cgroup.threads";
 
 uint32_t CgroupControllerWrapper::version() const {
     CHECK(HasValue());
-    return ACgroupController_getVersion(controller_);
+    return controller_->version();
 }
 
 const char* CgroupControllerWrapper::name() const {
     CHECK(HasValue());
-    return ACgroupController_getName(controller_);
+    return controller_->name();
 }
 
 const char* CgroupControllerWrapper::path() const {
     CHECK(HasValue());
-    return ACgroupController_getPath(controller_);
+    return controller_->path();
 }
 
 bool CgroupControllerWrapper::HasValue() const {
@@ -62,7 +60,7 @@ bool CgroupControllerWrapper::IsUsable() {
 
     if (state_ == UNKNOWN) {
         if (__builtin_available(android 30, *)) {
-            uint32_t flags = ACgroupController_getFlags(controller_);
+            uint32_t flags = controller_->flags();
             state_ = (flags & CGROUPRC_CONTROLLER_FLAG_MOUNTED) != 0 ? USABLE : MISSING;
         } else {
             state_ = access(GetProcsFilePath("", 0, 0).c_str(), F_OK) == 0 ? USABLE : MISSING;
@@ -129,8 +127,8 @@ bool CgroupControllerWrapper::GetTaskGroup(pid_t tid, std::string* group) const
 }
 
 CgroupMap::CgroupMap() {
-    if (!LoadRcFile()) {
-        LOG(ERROR) << "CgroupMap::LoadRcFile called for [" << getpid() << "] failed";
+    if (!LoadDescriptors()) {
+        LOG(ERROR) << "CgroupMap::LoadDescriptors called for [" << getpid() << "] failed";
     }
 }
 
@@ -141,9 +139,9 @@ CgroupMap& CgroupMap::GetInstance() {
     return *instance;
 }
 
-bool CgroupMap::LoadRcFile() {
+bool CgroupMap::LoadDescriptors() {
     if (!loaded_) {
-        loaded_ = (ACgroupFile_getVersion() != 0);
+        loaded_ = ReadDescriptors(&descriptors_);
     }
     return loaded_;
 }
@@ -154,40 +152,27 @@ void CgroupMap::Print() const {
                    << "] failed, cgroups were not initialized properly";
         return;
     }
-    LOG(INFO) << "File version = " << ACgroupFile_getVersion();
-    LOG(INFO) << "File controller count = " << ACgroupFile_getControllerCount();
+    LOG(INFO) << "Controller count = " << descriptors_.size();
 
     LOG(INFO) << "Mounted cgroups:";
 
-    auto controller_count = ACgroupFile_getControllerCount();
-    for (uint32_t i = 0; i < controller_count; ++i) {
-        const ACgroupController* controller = ACgroupFile_getController(i);
-        if (__builtin_available(android 30, *)) {
-            LOG(INFO) << "\t" << ACgroupController_getName(controller) << " ver "
-                      << ACgroupController_getVersion(controller) << " path "
-                      << ACgroupController_getPath(controller) << " flags "
-                      << ACgroupController_getFlags(controller);
-        } else {
-            LOG(INFO) << "\t" << ACgroupController_getName(controller) << " ver "
-                      << ACgroupController_getVersion(controller) << " path "
-                      << ACgroupController_getPath(controller);
-        }
+    for (const auto& [name, descriptor] : descriptors_) {
+        LOG(INFO) << "\t" << descriptor.controller()->name() << " ver "
+                  << descriptor.controller()->version() << " path "
+                  << descriptor.controller()->path() << " flags "
+                  << descriptor.controller()->flags();
     }
 }
 
 CgroupControllerWrapper CgroupMap::FindController(const std::string& name) const {
     if (!loaded_) {
         LOG(ERROR) << "CgroupMap::FindController called for [" << getpid()
-                   << "] failed, RC file was not initialized properly";
+                   << "] failed, cgroups were not initialized properly";
         return CgroupControllerWrapper(nullptr);
     }
 
-    auto controller_count = ACgroupFile_getControllerCount();
-    for (uint32_t i = 0; i < controller_count; ++i) {
-        const ACgroupController* controller = ACgroupFile_getController(i);
-        if (name == ACgroupController_getName(controller)) {
-            return CgroupControllerWrapper(controller);
-        }
+    if (const auto it = descriptors_.find(name); it != descriptors_.end()) {
+        return CgroupControllerWrapper(it->second.controller());
     }
 
     return CgroupControllerWrapper(nullptr);
@@ -196,15 +181,13 @@ CgroupControllerWrapper CgroupMap::FindController(const std::string& name) const
 CgroupControllerWrapper CgroupMap::FindControllerByPath(const std::string& path) const {
     if (!loaded_) {
         LOG(ERROR) << "CgroupMap::FindControllerByPath called for [" << getpid()
-                   << "] failed, RC file was not initialized properly";
+                   << "] failed, cgroups were not initialized properly";
         return CgroupControllerWrapper(nullptr);
     }
 
-    auto controller_count = ACgroupFile_getControllerCount();
-    for (uint32_t i = 0; i < controller_count; ++i) {
-        const ACgroupController* controller = ACgroupFile_getController(i);
-        if (StartsWith(path, ACgroupController_getPath(controller))) {
-            return CgroupControllerWrapper(controller);
+    for (const auto& [name, descriptor] : descriptors_) {
+        if (path.starts_with(descriptor.controller()->path())) {
+            return CgroupControllerWrapper(descriptor.controller());
         }
     }
 
@@ -212,31 +195,23 @@ CgroupControllerWrapper CgroupMap::FindControllerByPath(const std::string& path)
 }
 
 int CgroupMap::ActivateControllers(const std::string& path) const {
-    if (__builtin_available(android 30, *)) {
-        auto controller_count = ACgroupFile_getControllerCount();
-        for (uint32_t i = 0; i < controller_count; ++i) {
-            const ACgroupController* controller = ACgroupFile_getController(i);
-            const uint32_t flags = ACgroupController_getFlags(controller);
-            uint32_t max_activation_depth = UINT32_MAX;
-            if (__builtin_available(android 36, *)) {
-                max_activation_depth = ACgroupController_getMaxActivationDepth(controller);
-            }
-            const int depth = GetCgroupDepth(ACgroupController_getPath(controller), path);
-
-            if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
-                std::string str("+");
-                str.append(ACgroupController_getName(controller));
-                if (!WriteStringToFile(str, path + "/cgroup.subtree_control")) {
-                    if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
-                        PLOG(WARNING) << "Activation of cgroup controller " << str
-                                      << " failed in path " << path;
-                    } else {
-                        return -errno;
-                    }
+    for (const auto& [name, descriptor] : descriptors_) {
+        const uint32_t flags = descriptor.controller()->flags();
+        const uint32_t max_activation_depth = descriptor.controller()->max_activation_depth();
+        const int depth = GetCgroupDepth(descriptor.controller()->path(), path);
+
+        if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
+            std::string str("+");
+            str.append(descriptor.controller()->name());
+            if (!WriteStringToFile(str, path + "/cgroup.subtree_control")) {
+                if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
+                    PLOG(WARNING) << "Activation of cgroup controller " << str
+                                  << " failed in path " << path;
+                } else {
+                    return -errno;
                 }
             }
         }
-        return 0;
     }
-    return -ENOSYS;
+    return 0;
 }
diff --git a/libprocessgroup/cgroup_map.h b/libprocessgroup/cgroup_map.h
index 364279414336..5ad59bddf0a5 100644
--- a/libprocessgroup/cgroup_map.h
+++ b/libprocessgroup/cgroup_map.h
@@ -18,15 +18,17 @@
 
 #include <sys/types.h>
 
+#include <cstdint>
 #include <string>
 
-#include <android/cgrouprc.h>
+#include <processgroup/cgroup_controller.h>
+#include <processgroup/util.h>
 
-// Convenient wrapper of an ACgroupController pointer.
+// Convenient wrapper of a CgroupController pointer.
 class CgroupControllerWrapper {
   public:
     // Does not own controller
-    explicit CgroupControllerWrapper(const ACgroupController* controller)
+    explicit CgroupControllerWrapper(const CgroupController* controller)
         : controller_(controller) {}
 
     uint32_t version() const;
@@ -47,7 +49,7 @@ class CgroupControllerWrapper {
         MISSING = 2,
     };
 
-    const ACgroupController* controller_ = nullptr;
+    const CgroupController* controller_ = nullptr; // CgroupMap owns the object behind this pointer
     ControllerState state_ = ControllerState::UNKNOWN;
 };
 
@@ -60,7 +62,8 @@ class CgroupMap {
 
   private:
     bool loaded_ = false;
+    CgroupDescriptorMap descriptors_;
     CgroupMap();
-    bool LoadRcFile();
+    bool LoadDescriptors();
     void Print() const;
 };

From 47580ff76d9d9ecbaa9345a9aa02e95bd6bbce33 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 8 Oct 2024 23:41:33 +0000
Subject: [PATCH 1161/1487] Reapply "libprocessgroup: Remove
 ACgroupController_getMaxActivati..."

This reverts commit aeca8793f533c243d0f9353bce5e276f48e01363.

Change-Id: I06e7e651f0cabfd43b50a278baf36f31f6061a8f
---
 libprocessgroup/cgrouprc/a_cgroup_controller.cpp    | 5 -----
 libprocessgroup/cgrouprc/include/android/cgrouprc.h | 8 --------
 libprocessgroup/cgrouprc/libcgrouprc.map.txt        | 7 -------
 3 files changed, 20 deletions(-)

diff --git a/libprocessgroup/cgrouprc/a_cgroup_controller.cpp b/libprocessgroup/cgrouprc/a_cgroup_controller.cpp
index 889b3becf1a2..5a326e55d4de 100644
--- a/libprocessgroup/cgrouprc/a_cgroup_controller.cpp
+++ b/libprocessgroup/cgrouprc/a_cgroup_controller.cpp
@@ -32,11 +32,6 @@ uint32_t ACgroupController_getFlags(const ACgroupController* controller) {
     return controller->flags();
 }
 
-uint32_t ACgroupController_getMaxActivationDepth(const ACgroupController* controller) {
-    CHECK(controller != nullptr);
-    return controller->max_activation_depth();
-}
-
 const char* ACgroupController_getName(const ACgroupController* controller) {
     CHECK(controller != nullptr);
     return controller->name();
diff --git a/libprocessgroup/cgrouprc/include/android/cgrouprc.h b/libprocessgroup/cgrouprc/include/android/cgrouprc.h
index 3a57df547d60..e704a36aac9d 100644
--- a/libprocessgroup/cgrouprc/include/android/cgrouprc.h
+++ b/libprocessgroup/cgrouprc/include/android/cgrouprc.h
@@ -78,14 +78,6 @@ __attribute__((warn_unused_result)) uint32_t ACgroupController_getVersion(const
 __attribute__((warn_unused_result, weak)) uint32_t ACgroupController_getFlags(
         const ACgroupController*) __INTRODUCED_IN(30);
 
-/**
- * Returns the maximum activation depth of the given controller.
- * Only applicable to cgroup v2 controllers.
- * Returns UINT32_MAX if no maximum activation depth is set.
- */
-__attribute__((warn_unused_result, weak)) uint32_t ACgroupController_getMaxActivationDepth(
-        const ACgroupController* controller) __INTRODUCED_IN(36);
-
 /**
  * Returns the name of the given controller.
  * If the given controller is null, return nullptr.
diff --git a/libprocessgroup/cgrouprc/libcgrouprc.map.txt b/libprocessgroup/cgrouprc/libcgrouprc.map.txt
index 30bd25f18dbd..b62b10f3b457 100644
--- a/libprocessgroup/cgrouprc/libcgrouprc.map.txt
+++ b/libprocessgroup/cgrouprc/libcgrouprc.map.txt
@@ -16,10 +16,3 @@ LIBCGROUPRC_30 { # introduced=30
   local:
     *;
 };
-
-LIBCGROUPRC_36 { # introduced=36
-  global:
-    ACgroupController_getMaxActivationDepth; # llndk=202504 systemapi
-  local:
-    *;
-};

From 787ddbc8a57b34d8d74dfd19b47ab5c816ae2af3 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 8 Oct 2024 23:41:34 +0000
Subject: [PATCH 1162/1487] Reapply "libprocessgroup: Combine all 3
 ActivateControllers imple..."

This reverts commit 0fa49253a484fc0c99d067ade57a4978059b3a95.

Change-Id: I83121ff295caaabc0a2fd8a606ee2d52dacb0174
---
 libprocessgroup/cgroup_map.cpp                | 22 +---------
 libprocessgroup/cgroup_map.h                  |  2 +-
 libprocessgroup/processgroup.cpp              |  7 ++--
 libprocessgroup/setup/cgroup_map_write.cpp    | 42 +------------------
 .../util/include/processgroup/util.h          |  2 +
 libprocessgroup/util/util.cpp                 | 23 ++++++++++
 6 files changed, 33 insertions(+), 65 deletions(-)

diff --git a/libprocessgroup/cgroup_map.cpp b/libprocessgroup/cgroup_map.cpp
index 8180ccf3ff2e..32bef13a1abf 100644
--- a/libprocessgroup/cgroup_map.cpp
+++ b/libprocessgroup/cgroup_map.cpp
@@ -194,24 +194,6 @@ CgroupControllerWrapper CgroupMap::FindControllerByPath(const std::string& path)
     return CgroupControllerWrapper(nullptr);
 }
 
-int CgroupMap::ActivateControllers(const std::string& path) const {
-    for (const auto& [name, descriptor] : descriptors_) {
-        const uint32_t flags = descriptor.controller()->flags();
-        const uint32_t max_activation_depth = descriptor.controller()->max_activation_depth();
-        const int depth = GetCgroupDepth(descriptor.controller()->path(), path);
-
-        if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
-            std::string str("+");
-            str.append(descriptor.controller()->name());
-            if (!WriteStringToFile(str, path + "/cgroup.subtree_control")) {
-                if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
-                    PLOG(WARNING) << "Activation of cgroup controller " << str
-                                  << " failed in path " << path;
-                } else {
-                    return -errno;
-                }
-            }
-        }
-    }
-    return 0;
+bool CgroupMap::ActivateControllers(const std::string& path) const {
+    return ::ActivateControllers(path, descriptors_);
 }
diff --git a/libprocessgroup/cgroup_map.h b/libprocessgroup/cgroup_map.h
index 5ad59bddf0a5..fb99076452d6 100644
--- a/libprocessgroup/cgroup_map.h
+++ b/libprocessgroup/cgroup_map.h
@@ -58,7 +58,7 @@ class CgroupMap {
     static CgroupMap& GetInstance();
     CgroupControllerWrapper FindController(const std::string& name) const;
     CgroupControllerWrapper FindControllerByPath(const std::string& path) const;
-    int ActivateControllers(const std::string& path) const;
+    bool ActivateControllers(const std::string& path) const;
 
   private:
     bool loaded_ = false;
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 83a2258bf2fb..d3719eea39af 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -662,10 +662,9 @@ static int createProcessGroupInternal(uid_t uid, pid_t initialPid, std::string c
         return -errno;
     }
     if (activate_controllers) {
-        ret = CgroupMap::GetInstance().ActivateControllers(uid_path);
-        if (ret) {
-            LOG(ERROR) << "Failed to activate controllers in " << uid_path;
-            return ret;
+        if (!CgroupMap::GetInstance().ActivateControllers(uid_path)) {
+            PLOG(ERROR) << "Failed to activate controllers in " << uid_path;
+            return -errno;
         }
     }
 
diff --git a/libprocessgroup/setup/cgroup_map_write.cpp b/libprocessgroup/setup/cgroup_map_write.cpp
index 82116800821d..d05bf2408cee 100644
--- a/libprocessgroup/setup/cgroup_map_write.cpp
+++ b/libprocessgroup/setup/cgroup_map_write.cpp
@@ -180,25 +180,7 @@ static bool ActivateV2CgroupController(const CgroupDescriptor& descriptor) {
         return false;
     }
 
-    if (controller->flags() & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION &&
-        controller->max_activation_depth() > 0) {
-        std::string str = "+";
-        str += controller->name();
-        std::string path = controller->path();
-        path += "/cgroup.subtree_control";
-
-        if (!android::base::WriteStringToFile(str, path)) {
-            if (IsOptionalController(controller)) {
-                PLOG(INFO) << "Failed to activate optional controller " << controller->name()
-                           << " at " << path;
-                return true;
-            }
-            PLOG(ERROR) << "Failed to activate controller " << controller->name();
-            return false;
-        }
-    }
-
-    return true;
+    return ::ActivateControllers(controller->path(), {{controller->name(), descriptor}});
 }
 
 static bool MountV1CgroupController(const CgroupDescriptor& descriptor) {
@@ -323,27 +305,7 @@ static bool CreateV2SubHierarchy(const std::string& path, const CgroupDescriptor
 
     // Activate all v2 controllers in path so they can be activated in
     // children as they are created.
-    for (const auto& [name, descriptor] : descriptors) {
-        const CgroupController* controller = descriptor.controller();
-        std::uint32_t flags = controller->flags();
-        std::uint32_t max_activation_depth = controller->max_activation_depth();
-        const int depth = GetCgroupDepth(controller->path(), path);
-
-        if (controller->version() == 2 && name != CGROUPV2_HIERARCHY_NAME &&
-            flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
-            std::string str("+");
-            str += controller->name();
-            if (!android::base::WriteStringToFile(str, path + "/cgroup.subtree_control")) {
-                if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
-                    PLOG(WARNING) << "Activation of cgroup controller " << str << " failed in path "
-                                  << path;
-                } else {
-                    return false;
-                }
-            }
-        }
-    }
-    return true;
+    return ::ActivateControllers(path, descriptors);
 }
 
 bool CgroupSetup() {
diff --git a/libprocessgroup/util/include/processgroup/util.h b/libprocessgroup/util/include/processgroup/util.h
index d592a63477d2..2c7b32926754 100644
--- a/libprocessgroup/util/include/processgroup/util.h
+++ b/libprocessgroup/util/include/processgroup/util.h
@@ -31,3 +31,5 @@ unsigned int GetCgroupDepth(const std::string& controller_root, const std::strin
 using CgroupControllerName = std::string;
 using CgroupDescriptorMap = std::map<CgroupControllerName, CgroupDescriptor>;
 bool ReadDescriptors(CgroupDescriptorMap* descriptors);
+
+bool ActivateControllers(const std::string& path, const CgroupDescriptorMap& descriptors);
diff --git a/libprocessgroup/util/util.cpp b/libprocessgroup/util/util.cpp
index bff4c6f1ac35..14016751c77b 100644
--- a/libprocessgroup/util/util.cpp
+++ b/libprocessgroup/util/util.cpp
@@ -250,3 +250,26 @@ bool ReadDescriptors(CgroupDescriptorMap* descriptors) {
 
     return true;
 }
+
+bool ActivateControllers(const std::string& path, const CgroupDescriptorMap& descriptors) {
+    for (const auto& [name, descriptor] : descriptors) {
+        const uint32_t flags = descriptor.controller()->flags();
+        const uint32_t max_activation_depth = descriptor.controller()->max_activation_depth();
+        const unsigned int depth = GetCgroupDepth(descriptor.controller()->path(), path);
+
+        if (flags & CGROUPRC_CONTROLLER_FLAG_NEEDS_ACTIVATION && depth < max_activation_depth) {
+            std::string str("+");
+            str.append(descriptor.controller()->name());
+            if (!android::base::WriteStringToFile(str, path + "/cgroup.subtree_control")) {
+                if (flags & CGROUPRC_CONTROLLER_FLAG_OPTIONAL) {
+                    PLOG(WARNING) << "Activation of cgroup controller " << str
+                                  << " failed in path " << path;
+                } else {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+

From e69b2d427754fa1d9d2758c8068f0adda75095bf Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 8 Oct 2024 20:53:06 -0700
Subject: [PATCH 1163/1487] snapshotctl: Initialize snapshot pointer when
 reverting snapshots

Test: snapshotctl revert-snapshots
Bug: 368487904
Change-Id: I9743bf412d4bfcf508aeb046ec329568da4e2be1
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshotctl.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 97a8cb21054a..46de991d00b9 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -105,7 +105,7 @@ class MapSnapshots {
     bool FinishSnapshotWrites();
     bool UnmapCowImagePath(std::string& name);
     bool DeleteSnapshots();
-    bool CleanupSnapshot() { return sm_->PrepareDeviceToBootWithoutSnapshot(); }
+    bool CleanupSnapshot();
     bool BeginUpdate();
     bool ApplyUpdate();
 
@@ -495,6 +495,11 @@ bool MapSnapshots::UnmapCowImagePath(std::string& name) {
     return sm_->UnmapCowImage(name);
 }
 
+bool MapSnapshots::CleanupSnapshot() {
+    sm_ = SnapshotManager::New();
+    return sm_->PrepareDeviceToBootWithoutSnapshot();
+}
+
 bool MapSnapshots::DeleteSnapshots() {
     sm_ = SnapshotManager::New();
     lock_ = sm_->LockExclusive();

From 699faa849bee52c7671e7b5297715f7ac53bd022 Mon Sep 17 00:00:00 2001
From: Per Larsen <perlarsen@google.com>
Date: Wed, 9 Oct 2024 11:23:32 +0000
Subject: [PATCH 1164/1487] trusty: tipc-test: Fix D argument

The D flag requires an argument so it should be followed by a colon
in sopts. Adding the missing colon is necessary to prevent a segfault.

Test: path/to/tipc-test -D VSOCK:200:1
Bug None

Change-Id: I78119b7e42aba5d30b62d88ff5d94c01dbc2eb64
---
 trusty/libtrusty/tipc-test/tipc_test.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/libtrusty/tipc-test/tipc_test.c b/trusty/libtrusty/tipc-test/tipc_test.c
index 3cf0c05f939c..121837dc0ea3 100644
--- a/trusty/libtrusty/tipc-test/tipc_test.c
+++ b/trusty/libtrusty/tipc-test/tipc_test.c
@@ -67,7 +67,7 @@ static const char *main_ctrl_name = "com.android.ipc-unittest.ctrl";
 static const char* receiver_name = "com.android.trusty.memref.receiver";
 static const size_t memref_chunk_size = 4096;
 
-static const char* _sopts = "hsvDS:t:r:m:b:B:";
+static const char* _sopts = "hsvD:S:t:r:m:b:B:";
 /* clang-format off */
 static const struct option _lopts[] =  {
     {"help",    no_argument,       0, 'h'},

From 075008174220c3fcd28eb21b0215f3feb6678d35 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Wed, 9 Oct 2024 17:41:32 +0000
Subject: [PATCH 1165/1487] libprocessgroup: Remove prctl interface for setting
 timer slack

Support for the procfs timerslack interface has existed since linux 4.6.
All currently supported Android kernels are newer than 4.6, so remove
the userspace support for the prctl interface leaving just the use of
/proc/<tid>/timerslack_ns.

Bug: 372498744
Change-Id: Ib34cc6fbb4bab328cde51d60ac4e3b26a0d72851
---
 libprocessgroup/task_profiles.cpp | 32 +++++++------------------------
 libprocessgroup/task_profiles.h   |  2 --
 2 files changed, 7 insertions(+), 27 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 67ecc1d500a5..bdee9ae75231 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -203,33 +203,15 @@ bool SetClampsAction::ExecuteForTask(int) const {
 // To avoid issues in sdk_mac build
 #if defined(__ANDROID__)
 
-bool SetTimerSlackAction::IsTimerSlackSupported(pid_t tid) {
-    auto file = StringPrintf("/proc/%d/timerslack_ns", tid);
-
-    return (access(file.c_str(), W_OK) == 0);
-}
-
 bool SetTimerSlackAction::ExecuteForTask(pid_t tid) const {
-    static bool sys_supports_timerslack = IsTimerSlackSupported(tid);
-
-    // v4.6+ kernels support the /proc/<tid>/timerslack_ns interface.
-    // TODO: once we've backported this, log if the open(2) fails.
-    if (sys_supports_timerslack) {
-        auto file = StringPrintf("/proc/%d/timerslack_ns", tid);
-        if (!WriteStringToFile(std::to_string(slack_), file)) {
-            if (errno == ENOENT) {
-                // This happens when process is already dead
-                return true;
-            }
-            PLOG(ERROR) << "set_timerslack_ns write failed";
-        }
-    }
-
-    // TODO: Remove when /proc/<tid>/timerslack_ns interface is backported.
-    if (tid == 0 || tid == GetThreadId()) {
-        if (prctl(PR_SET_TIMERSLACK, slack_) == -1) {
-            PLOG(ERROR) << "set_timerslack_ns prctl failed";
+    const auto file = StringPrintf("/proc/%d/timerslack_ns", tid);
+    if (!WriteStringToFile(std::to_string(slack_), file)) {
+        if (errno == ENOENT) {
+            // This happens when process is already dead
+            return true;
         }
+        PLOG(ERROR) << "set_timerslack_ns write failed";
+        return false;
     }
 
     return true;
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index abb3ca5c37d6..2e31158d1af3 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -114,8 +114,6 @@ class SetTimerSlackAction : public ProfileAction {
 
   private:
     unsigned long slack_;
-
-    static bool IsTimerSlackSupported(pid_t tid);
 };
 
 // Set attribute profile element

From b53eb9dbc6b81a08e296147cd9619a9066b8c430 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Wed, 9 Oct 2024 22:46:33 +0000
Subject: [PATCH 1166/1487] libprocessgroup: Use pid_t for
 ProfileAction::ExecuteForTask

This was missed in commit 1c007996b ("libprocessgroup: Use pid_t
consistently for TIDs").

Change-Id: Idefc9e7c2161ab3163bd1a0cb68b899e10e9c8ed
---
 libprocessgroup/task_profiles.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index abb3ca5c37d6..8ff20789cef5 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -77,7 +77,7 @@ class ProfileAction {
 
     // Default implementations will fail
     virtual bool ExecuteForProcess(uid_t, pid_t) const { return false; }
-    virtual bool ExecuteForTask(int) const { return false; }
+    virtual bool ExecuteForTask(pid_t) const { return false; }
     virtual bool ExecuteForUID(uid_t) const { return false; }
 
     virtual void EnableResourceCaching(ResourceCacheType) {}

From cea66e89a1124cc52005e56458dbbe21042c6824 Mon Sep 17 00:00:00 2001
From: Inseob Kim <inseob@google.com>
Date: Thu, 10 Oct 2024 17:15:47 +0900
Subject: [PATCH 1167/1487] Add dirgroup for trusty genrule

Bug: 358302178
Test: m lk.elf.x86_64 lk.elf.arm64
Change-Id: Ic3e41c6a38aaa9dd87dbc4a0215c02d19b3063a0
---
 Android.bp | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Android.bp

diff --git a/Android.bp b/Android.bp
new file mode 100644
index 000000000000..c77a8033723e
--- /dev/null
+++ b/Android.bp
@@ -0,0 +1,5 @@
+dirgroup {
+    name: "trusty_dirgroup_system_core",
+    dirs: ["."],
+    visibility: ["//trusty/vendor/google/aosp/scripts"],
+}

From 3e4b58e9d461c2fd554e6b2c1f45f708a5663acf Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 10 Oct 2024 16:23:55 +0000
Subject: [PATCH 1168/1487] libprocessgroup: Remove unused prctl include

Fixes: 075008174 ("libprocessgroup: Remove prctl interface for setting timer slack")
Test: m
Bug: 372498744
Change-Id: Icb65d631cdc52b5f5434b33a593adf706314f66e
---
 libprocessgroup/task_profiles.cpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index bdee9ae75231..7f33d4a40ebe 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -37,11 +37,6 @@
 
 #include <build_flags.h>
 
-// To avoid issues in sdk_mac build
-#if defined(__ANDROID__)
-#include <sys/prctl.h>
-#endif
-
 using android::base::GetThreadId;
 using android::base::GetUintProperty;
 using android::base::StringPrintf;

From 2a030efe67428b7dbf5163397b5acbf79752b224 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 10 Oct 2024 21:34:45 +0000
Subject: [PATCH 1169/1487] libprocessgroup: Remove SetClamps action

The SetClamps profile action has always been a no-op. Remove the class
and parsing code for this action.

Bug: 372915523
Change-Id: Ic6e685aa992b83464dfb5e6446b622a57ed61db5
---
 libprocessgroup/profiles/task_profiles.json | 27 -------------------
 libprocessgroup/task_profiles.cpp           | 29 ---------------------
 libprocessgroup/task_profiles.h             | 13 ---------
 3 files changed, 69 deletions(-)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 411c38c809ba..feda3b49c108 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -571,33 +571,6 @@
       ]
     },
 
-    {
-      "Name": "PerfBoost",
-      "Actions": [
-        {
-          "Name": "SetClamps",
-          "Params":
-          {
-            "Boost": "50%",
-            "Clamp": "0"
-          }
-        }
-      ]
-    },
-    {
-      "Name": "PerfClamp",
-      "Actions": [
-        {
-          "Name": "SetClamps",
-          "Params":
-          {
-            "Boost": "0",
-            "Clamp": "30%"
-          }
-        }
-      ]
-    },
-
     {
       "Name": "LowMemoryUsage",
       "Actions": [
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 7f33d4a40ebe..ff0335592986 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -183,18 +183,6 @@ bool ProfileAttribute::GetPathForUID(uid_t uid, std::string* path) const {
     return true;
 }
 
-bool SetClampsAction::ExecuteForProcess(uid_t, pid_t) const {
-    // TODO: add support when kernel supports util_clamp
-    LOG(WARNING) << "SetClampsAction::ExecuteForProcess is not supported";
-    return false;
-}
-
-bool SetClampsAction::ExecuteForTask(int) const {
-    // TODO: add support when kernel supports util_clamp
-    LOG(WARNING) << "SetClampsAction::ExecuteForTask is not supported";
-    return false;
-}
-
 // To avoid issues in sdk_mac build
 #if defined(__ANDROID__)
 
@@ -902,23 +890,6 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                 } else {
                     LOG(WARNING) << "SetAttribute: unknown attribute: " << attr_name;
                 }
-            } else if (action_name == "SetClamps") {
-                std::string boost_value = params_val["Boost"].asString();
-                std::string clamp_value = params_val["Clamp"].asString();
-                char* end;
-                unsigned long boost;
-
-                boost = strtoul(boost_value.c_str(), &end, 10);
-                if (end > boost_value.c_str()) {
-                    unsigned long clamp = strtoul(clamp_value.c_str(), &end, 10);
-                    if (end > clamp_value.c_str()) {
-                        profile->Add(std::make_unique<SetClampsAction>(boost, clamp));
-                    } else {
-                        LOG(WARNING) << "SetClamps: invalid parameter " << clamp_value;
-                    }
-                } else {
-                    LOG(WARNING) << "SetClamps: invalid parameter: " << boost_value;
-                }
             } else if (action_name == "WriteFile") {
                 std::string attr_filepath = params_val["FilePath"].asString();
                 std::string attr_procfilepath = params_val["ProcFilePath"].asString();
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index e52ce38feabe..782b3ff0f58e 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -90,19 +90,6 @@ class ProfileAction {
 };
 
 // Profile actions
-class SetClampsAction : public ProfileAction {
-  public:
-    SetClampsAction(int boost, int clamp) noexcept : boost_(boost), clamp_(clamp) {}
-
-    const char* Name() const override { return "SetClamps"; }
-    bool ExecuteForProcess(uid_t uid, pid_t pid) const override;
-    bool ExecuteForTask(pid_t tid) const override;
-
-  protected:
-    int boost_;
-    int clamp_;
-};
-
 class SetTimerSlackAction : public ProfileAction {
   public:
     SetTimerSlackAction(unsigned long slack) noexcept : slack_(slack) {}

From 900ef7bf3a7a76de8d98ba155484d31c52d1f3c9 Mon Sep 17 00:00:00 2001
From: Yihan Dong <slotus@google.com>
Date: Sat, 12 Oct 2024 08:52:31 +0000
Subject: [PATCH 1170/1487] Add proposed trendy teams for VTS modules

Change-Id: I4f62c5105f51b37fe61efe3ea61a88036cfb4b96
Test: build locally
Bug: 368362374
---
 fs_mgr/libdm/Android.bp                 | 1 +
 fs_mgr/libfiemap/Android.bp             | 1 +
 fs_mgr/liblp/Android.bp                 | 1 +
 fs_mgr/libsnapshot/Android.bp           | 1 +
 fs_mgr/libsnapshot/snapuserd/Android.bp | 1 +
 libprocessgroup/profiles/Android.bp     | 1 +
 6 files changed, 6 insertions(+)

diff --git a/fs_mgr/libdm/Android.bp b/fs_mgr/libdm/Android.bp
index c3ca758aea7f..1efd7debcfd8 100644
--- a/fs_mgr/libdm/Android.bp
+++ b/fs_mgr/libdm/Android.bp
@@ -15,6 +15,7 @@
 //
 
 package {
+    default_team: "trendy_team_android_kernel",
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
diff --git a/fs_mgr/libfiemap/Android.bp b/fs_mgr/libfiemap/Android.bp
index c8d575630262..a6be58582b01 100644
--- a/fs_mgr/libfiemap/Android.bp
+++ b/fs_mgr/libfiemap/Android.bp
@@ -15,6 +15,7 @@
 //
 
 package {
+    default_team: "trendy_team_android_kernel",
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
diff --git a/fs_mgr/liblp/Android.bp b/fs_mgr/liblp/Android.bp
index 24eebdfb9192..b211e83dabdc 100644
--- a/fs_mgr/liblp/Android.bp
+++ b/fs_mgr/liblp/Android.bp
@@ -15,6 +15,7 @@
 //
 
 package {
+    default_team: "trendy_team_android_kernel",
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 50efb03bd01b..966696b05b2b 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -15,6 +15,7 @@
 //
 
 package {
+    default_team: "trendy_team_android_kernel",
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 298fd9f3095b..0314d252865a 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -15,6 +15,7 @@
 //
 
 package {
+    default_team: "trendy_team_android_kernel",
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
diff --git a/libprocessgroup/profiles/Android.bp b/libprocessgroup/profiles/Android.bp
index 1ec9f7f3b3c0..baa4546464d4 100644
--- a/libprocessgroup/profiles/Android.bp
+++ b/libprocessgroup/profiles/Android.bp
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 package {
+    default_team: "trendy_team_android_kernel",
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 

From 9081b85a1d36b563dbd864fec5ace67e59fa9c54 Mon Sep 17 00:00:00 2001
From: Yihan Dong <slotus@google.com>
Date: Sat, 12 Oct 2024 08:53:19 +0000
Subject: [PATCH 1171/1487] Add proposed trendy teams for VTS modules

Change-Id: Ic9eeddd1d7286f38806d4a422914964cf2a80073
Test: build locally
Bug: 368362374
---
 libcutils/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index 3c3eeb6631f3..db4e964ff4e4 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -1,4 +1,5 @@
 package {
+    default_team: "trendy_team_native_tools_libraries",
     default_applicable_licenses: ["system_core_libcutils_license"],
 }
 

From 44884d5c319647b499241386b750b7a763581541 Mon Sep 17 00:00:00 2001
From: Newton Lam <newtonlam@google.com>
Date: Mon, 14 Oct 2024 20:52:32 +0000
Subject: [PATCH 1172/1487] Use uint64_t instead of size_t when calculating
 extent size to avoid overflow

Change-Id: I22a77162d08fd7e82ffaa3e0c6c8adb6e956f7d1
---
 fs_mgr/liblp/super_layout_builder.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/liblp/super_layout_builder.cpp b/fs_mgr/liblp/super_layout_builder.cpp
index fd7416bb2e8e..bff26ea21d84 100644
--- a/fs_mgr/liblp/super_layout_builder.cpp
+++ b/fs_mgr/liblp/super_layout_builder.cpp
@@ -184,7 +184,7 @@ std::vector<SuperImageExtent> SuperLayoutBuilder::GetImageLayout() {
                 return {};
             }
 
-            size_t size = e.num_sectors * LP_SECTOR_SIZE;
+            uint64_t size = e.num_sectors * LP_SECTOR_SIZE;
             uint64_t super_offset = e.target_data * LP_SECTOR_SIZE;
             extents.emplace_back(super_offset, size, image_name, image_offset);
 

From 3984611601e9cc8c41b996e8e6dc543b383e0922 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Wed, 9 Oct 2024 22:40:26 +0000
Subject: [PATCH 1173/1487] libprocessgroup: Add SetSchedulerPolicy Action

Add a new profile action that allows users to set a scheduler policy and
priority for a thread when a profile with the action is applied. This
can be used with the POSIX policies specified in the sched_setscheduler
man page. A priority value is required for real-time policies. A nice
value may optionally be provided for normal policies.

If a normal policy is used and a nice value is provided, it will be
applied with setpriority() after the scheduler policy is applied. The
range of nice values that can be used in the task profiles JSON in this
case is [-20, 19].

If a real-time policy is used, the range of priorities that can be used
in the task profiles JSON is [1, 99] which will be mapped onto
[sched_get_priority_min(), sched_get_priority_max()] at runtime for the
the provided policy.

Here are some examples:

Use lowest-priority with FIFO policy:
"Actions": [
  {
    "Name": "SetSchedulerPolicy",
    "Params":
    {
      "Policy": "SCHED_FIFO",
      "Priority": 1
    }
  }
]

Use highest-priority (lowest nice) with standard NORMAL scheduler:
"Actions": [
  {
    "Name": "SetSchedulerPolicy",
    "Params":
    {
      "Policy": "SCHED_OTHER",
      "Nice": -20
    }
  }
]

Bug: 368072932
BYPASS_INCLUSIVE_LANGUAGE_REASON=false positive
Change-Id: I502ceb3913016e9f4e6b6322cc0eee905c9a5c9a
---
 libprocessgroup/task_profiles.cpp | 120 +++++++++++++++++++++++++++++-
 libprocessgroup/task_profiles.h   |  20 +++++
 2 files changed, 136 insertions(+), 4 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index 7f33d4a40ebe..110ef5267d65 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -17,11 +17,16 @@
 //#define LOG_NDEBUG 0
 #define LOG_TAG "libprocessgroup"
 
+#include <task_profiles.h>
+
+#include <map>
+#include <string>
+
 #include <dirent.h>
 #include <fcntl.h>
+#include <sched.h>
+#include <sys/resource.h>
 #include <unistd.h>
-#include <task_profiles.h>
-#include <string>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
@@ -30,13 +35,13 @@
 #include <android-base/strings.h>
 #include <android-base/threads.h>
 
+#include <build_flags.h>
+
 #include <cutils/android_filesystem_config.h>
 
 #include <json/reader.h>
 #include <json/value.h>
 
-#include <build_flags.h>
-
 using android::base::GetThreadId;
 using android::base::GetUintProperty;
 using android::base::StringPrintf;
@@ -649,6 +654,57 @@ bool WriteFileAction::IsValidForTask(int) const {
     return access(task_path_.c_str(), W_OK) == 0;
 }
 
+bool SetSchedulerPolicyAction::isNormalPolicy(int policy) {
+    return policy == SCHED_OTHER || policy == SCHED_BATCH || policy == SCHED_IDLE;
+}
+
+bool SetSchedulerPolicyAction::toPriority(int policy, int virtual_priority, int& priority_out) {
+    constexpr int VIRTUAL_PRIORITY_MIN = 1;
+    constexpr int VIRTUAL_PRIORITY_MAX = 99;
+
+    if (virtual_priority < VIRTUAL_PRIORITY_MIN || virtual_priority > VIRTUAL_PRIORITY_MAX) {
+        LOG(WARNING) << "SetSchedulerPolicy: invalid priority (" << virtual_priority
+                     << ") for policy (" << policy << ")";
+        return false;
+    }
+
+    const int min = sched_get_priority_min(policy);
+    if (min == -1) {
+        PLOG(ERROR) << "SetSchedulerPolicy: Cannot get min sched priority for policy " << policy;
+        return false;
+    }
+
+    const int max = sched_get_priority_max(policy);
+    if (max == -1) {
+        PLOG(ERROR) << "SetSchedulerPolicy: Cannot get max sched priority for policy " << policy;
+        return false;
+    }
+
+    priority_out = min + (virtual_priority - VIRTUAL_PRIORITY_MIN) * (max - min) /
+        (VIRTUAL_PRIORITY_MAX - VIRTUAL_PRIORITY_MIN);
+
+    return true;
+}
+
+bool SetSchedulerPolicyAction::ExecuteForTask(pid_t tid) const {
+    struct sched_param param = {};
+    param.sched_priority = isNormalPolicy(policy_) ? 0 : *priority_or_nice_;
+    if (sched_setscheduler(tid, policy_, &param) == -1) {
+        PLOG(WARNING) << "SetSchedulerPolicy: Failed to apply scheduler policy (" << policy_
+                      << ") with priority (" << *priority_or_nice_ << ") to tid " << tid;
+        return false;
+    }
+
+    if (isNormalPolicy(policy_) && priority_or_nice_ &&
+        setpriority(PRIO_PROCESS, tid, *priority_or_nice_) == -1) {
+        PLOG(WARNING) << "SetSchedulerPolicy: Failed to apply nice (" << *priority_or_nice_
+                      << ") to tid " << tid;
+        return false;
+    }
+
+    return true;
+}
+
 bool ApplyProfileAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
     for (const auto& profile : profiles_) {
         profile->ExecuteForProcess(uid, pid);
@@ -936,6 +992,62 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                     LOG(WARNING) << "WriteFile: invalid parameter: "
                                  << "empty value";
                 }
+            } else if (action_name == "SetSchedulerPolicy") {
+                const std::map<std::string, int> POLICY_MAP = {
+                    {"SCHED_OTHER", SCHED_OTHER},
+                    {"SCHED_BATCH", SCHED_BATCH},
+                    {"SCHED_IDLE", SCHED_IDLE},
+                    {"SCHED_FIFO", SCHED_FIFO},
+                    {"SCHED_RR", SCHED_RR},
+                };
+                const std::string policy_str = params_val["Policy"].asString();
+
+                const auto it = POLICY_MAP.find(policy_str);
+                if (it == POLICY_MAP.end()) {
+                    LOG(WARNING) << "SetSchedulerPolicy: invalid policy " << policy_str;
+                    continue;
+                }
+
+                const int policy = it->second;
+
+                if (SetSchedulerPolicyAction::isNormalPolicy(policy)) {
+                    if (params_val.isMember("Priority")) {
+                        LOG(WARNING) << "SetSchedulerPolicy: Normal policies (" << policy_str
+                                     << ") use Nice values, not Priority values";
+                    }
+
+                    if (params_val.isMember("Nice")) {
+                        // If present, this optional value will be passed in an additional syscall
+                        // to setpriority(), since the sched_priority value must be 0 for calls to
+                        // sched_setscheduler() with "normal" policies.
+                        const int nice = params_val["Nice"].asInt();
+
+                        const int LINUX_MIN_NICE = -20;
+                        const int LINUX_MAX_NICE = 19;
+                        if (nice < LINUX_MIN_NICE || nice > LINUX_MAX_NICE) {
+                            LOG(WARNING) << "SetSchedulerPolicy: Provided nice (" << nice
+                                         << ") appears out of range.";
+                        }
+                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy, nice));
+                    } else {
+                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy));
+                    }
+                } else {
+                    if (params_val.isMember("Nice")) {
+                        LOG(WARNING) << "SetSchedulerPolicy: Real-time policies (" << policy_str
+                                     << ") use Priority values, not Nice values";
+                    }
+
+                    // This is a "virtual priority" as described by `man 2 sched_get_priority_min`
+                    // that will be mapped onto the following range for the provided policy:
+                    // [sched_get_priority_min(), sched_get_priority_max()]
+                    const int virtual_priority = params_val["Priority"].asInt();
+
+                    int priority;
+                    if (SetSchedulerPolicyAction::toPriority(policy, virtual_priority, priority)) {
+                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy, priority));
+                    }
+                }
             } else {
                 LOG(WARNING) << "Unknown profile action: " << action_name;
             }
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index e52ce38feabe..ea948b58ed14 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -21,6 +21,7 @@
 #include <map>
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <span>
 #include <string>
 #include <string_view>
@@ -187,6 +188,25 @@ class WriteFileAction : public ProfileAction {
     CacheUseResult UseCachedFd(ResourceCacheType cache_type, const std::string& value) const;
 };
 
+// Set scheduler policy action
+class SetSchedulerPolicyAction : public ProfileAction {
+  public:
+    SetSchedulerPolicyAction(int policy)
+        : policy_(policy) {}
+    SetSchedulerPolicyAction(int policy, int priority_or_nice)
+        : policy_(policy), priority_or_nice_(priority_or_nice) {}
+
+    const char* Name() const override { return "SetSchedulerPolicy"; }
+    bool ExecuteForTask(pid_t tid) const override;
+
+    static bool isNormalPolicy(int policy);
+    static bool toPriority(int policy, int virtual_priority, int& priority_out);
+
+  private:
+    int policy_;
+    std::optional<int> priority_or_nice_;
+};
+
 class TaskProfile {
   public:
     TaskProfile(const std::string& name) : name_(name), res_cached_(false) {}

From a6af9bced3f7d7c25d62db36b404cf21b5fbf51d Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Tue, 15 Oct 2024 14:41:49 +0900
Subject: [PATCH 1174/1487] init: filter .##rc with preview SDK version

On a preview device (where codename is not "REL"), filtering .##rc files
will choose the highest versions reglardless of ro.build.version.sdk.

Bug: n/a
Test: add .36rc to an apex and see if init reads it.
Change-Id: Icd63cf70e45cc14504f839ce9492e1766147a40e
---
 init/apex_init_util.cpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/init/apex_init_util.cpp b/init/apex_init_util.cpp
index e5a7fbcc0b8c..809c805c42a3 100644
--- a/init/apex_init_util.cpp
+++ b/init/apex_init_util.cpp
@@ -101,14 +101,21 @@ std::set<std::string> GetApexListFrom(const std::string& apex_dir) {
     return apex_list;
 }
 
+static int GetCurrentSdk() {
+    bool is_preview = base::GetProperty("ro.build.version.codename", "") != "REL";
+    if (is_preview) {
+        return __ANDROID_API_FUTURE__;
+    }
+    return android::base::GetIntProperty("ro.build.version.sdk", __ANDROID_API_FUTURE__);
+}
+
 static Result<void> ParseRcScripts(const std::vector<std::string>& files) {
     if (files.empty()) {
         return {};
     }
     // APEXes can have versioned RC files. These should be filtered based on
     // SDK version.
-    int sdk = android::base::GetIntProperty("ro.build.version.sdk", INT_MAX);
-    if (sdk < 35) sdk = 35;  // aosp/main merges only into sdk=35+ (ie. __ANDROID_API_V__+)
+    static int sdk = GetCurrentSdk();
     auto filtered = FilterVersionedConfigs(files, sdk);
     if (filtered.empty()) {
         return {};

From 3aac36201bc75159cfa801f92765574ce1c77636 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Fri, 18 Oct 2024 21:51:45 +0000
Subject: [PATCH 1175/1487] Remove log spam.

When dumping, the code checks if a thread is running as a guest.
If it's not, the code always logs an error message if the header
data structure cannot be read. Don't print an error message in
this case.

Test: Crash and no longer see "failed to get the guest state header"
Test: message.
Change-Id: I6971b57b218a4f653682cfdc82118dc576d9e331
---
 debuggerd/crash_dump.cpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index c9235eeff524..15e8319a9780 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -470,14 +470,12 @@ static bool GetGuestRegistersFromCrashedProcess([[maybe_unused]] pid_t tid,
   }
 
   NativeBridgeGuestStateHeader header;
-  if (!process_memory->ReadFully(header_ptr, &header, sizeof(NativeBridgeGuestStateHeader))) {
-    PLOG(ERROR) << "failed to get the guest state header for thread " << tid;
-    return false;
-  }
-  if (header.signature != NATIVE_BRIDGE_GUEST_STATE_SIGNATURE) {
+  if (!process_memory->ReadFully(header_ptr, &header, sizeof(NativeBridgeGuestStateHeader)) ||
+      header.signature != NATIVE_BRIDGE_GUEST_STATE_SIGNATURE) {
     // Return when ptr points to unmapped memory or no valid guest state.
     return false;
   }
+
   auto guest_state_data_copy = std::make_unique<unsigned char[]>(header.guest_state_data_size);
   if (!process_memory->ReadFully(reinterpret_cast<uintptr_t>(header.guest_state_data),
                                  guest_state_data_copy.get(), header.guest_state_data_size)) {

From 5ad59a4cffaefd77c137fe5d2bddd43db67a75d7 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Fri, 18 Oct 2024 11:39:44 -0700
Subject: [PATCH 1176/1487] libsnapshot: Resume snapshot merge if snapshots are
 in second phase

If the device reboots when SnapshotUpdateStatus switches from
first phase to second phase, then track the transition
and resume the merge.

Bug: 374225913
Test: OTA on Pixel - Verify merge resumes when device reboots just after
first phase merge
Change-Id: I5f62a03852a4b012850b11d0c1e6b96ec0556278
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../include/libsnapshot/snapshot.h            |   1 +
 fs_mgr/libsnapshot/snapshot.cpp               |  29 +++-
 fs_mgr/libsnapshot/snapshot_test.cpp          | 140 ++++++++++++++++++
 3 files changed, 166 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index 8ff41dbcba9f..de20526310f6 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -442,6 +442,7 @@ class SnapshotManager final : public ISnapshotManager {
     FRIEND_TEST(SnapshotUpdateTest, QueryStatusError);
     FRIEND_TEST(SnapshotUpdateTest, SnapshotStatusFileWithoutCow);
     FRIEND_TEST(SnapshotUpdateTest, SpaceSwapUpdate);
+    FRIEND_TEST(SnapshotUpdateTest, InterruptMergeDuringPhaseUpdate);
     FRIEND_TEST(SnapshotUpdateTest, MapAllSnapshotsWithoutSlotSwitch);
     friend class SnapshotTest;
     friend class SnapshotUpdateTest;
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 05dec68d5766..acabd677075e 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -1343,10 +1343,25 @@ auto SnapshotManager::CheckTargetMergeState(LockedFile* lock, const std::string&
         }
 
         if (merge_status == "snapshot" &&
-            DecideMergePhase(snapshot_status) == MergePhase::SECOND_PHASE &&
-            update_status.merge_phase() == MergePhase::FIRST_PHASE) {
-            // The snapshot is not being merged because it's in the wrong phase.
-            return MergeResult(UpdateState::None);
+            DecideMergePhase(snapshot_status) == MergePhase::SECOND_PHASE) {
+            if (update_status.merge_phase() == MergePhase::FIRST_PHASE) {
+                // The snapshot is not being merged because it's in the wrong phase.
+                return MergeResult(UpdateState::None);
+            } else {
+                // update_status is already in second phase but the
+                // snapshot_status is still not set to SnapshotState::MERGING.
+                //
+                // Resume the merge at this point. see b/374225913
+                LOG(INFO) << "SwitchSnapshotToMerge: " << name << " after resuming merge";
+                auto code = SwitchSnapshotToMerge(lock, name);
+                if (code != MergeFailureCode::Ok) {
+                    LOG(ERROR) << "Failed to switch snapshot: " << name
+                               << " to merge during second phase";
+                    return MergeResult(UpdateState::MergeFailed,
+                                       MergeFailureCode::UnknownTargetType);
+                }
+                return MergeResult(UpdateState::Merging);
+            }
         }
 
         if (merge_status == "snapshot-merge") {
@@ -1442,8 +1457,14 @@ MergeFailureCode SnapshotManager::MergeSecondPhaseSnapshots(LockedFile* lock) {
         return MergeFailureCode::WriteStatus;
     }
 
+    auto current_slot_suffix = device_->GetSlotSuffix();
     MergeFailureCode result = MergeFailureCode::Ok;
     for (const auto& snapshot : snapshots) {
+        if (!android::base::EndsWith(snapshot, current_slot_suffix)) {
+            LOG(ERROR) << "Skipping invalid snapshot: " << snapshot
+                       << " during MergeSecondPhaseSnapshots";
+            continue;
+        }
         SnapshotStatus snapshot_status;
         if (!ReadSnapshotStatus(lock, snapshot, &snapshot_status)) {
             return MergeFailureCode::ReadStatus;
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 46c3a35e9d8f..3e5ae2afffa9 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -1607,6 +1607,146 @@ TEST_F(SnapshotUpdateTest, SpaceSwapUpdate) {
     }
 }
 
+// Test that shrinking and growing partitions at the same time is handled
+// correctly in VABC.
+TEST_F(SnapshotUpdateTest, InterruptMergeDuringPhaseUpdate) {
+    if (!snapuserd_required_) {
+        // b/179111359
+        GTEST_SKIP() << "Skipping snapuserd test";
+    }
+
+    auto old_sys_size = GetSize(sys_);
+    auto old_prd_size = GetSize(prd_);
+
+    // Grow |sys| but shrink |prd|.
+    SetSize(sys_, old_sys_size * 2);
+    sys_->set_estimate_cow_size(8_MiB);
+    SetSize(prd_, old_prd_size / 2);
+    prd_->set_estimate_cow_size(1_MiB);
+
+    AddOperationForPartitions();
+
+    ASSERT_TRUE(sm->BeginUpdate());
+    ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
+
+    // Check that the old partition sizes were saved correctly.
+    {
+        ASSERT_TRUE(AcquireLock());
+        auto local_lock = std::move(lock_);
+
+        SnapshotStatus status;
+        ASSERT_TRUE(sm->ReadSnapshotStatus(local_lock.get(), "prd_b", &status));
+        ASSERT_EQ(status.old_partition_size(), 3145728);
+        ASSERT_TRUE(sm->ReadSnapshotStatus(local_lock.get(), "sys_b", &status));
+        ASSERT_EQ(status.old_partition_size(), 3145728);
+    }
+
+    ASSERT_TRUE(WriteSnapshotAndHash(sys_));
+    ASSERT_TRUE(WriteSnapshotAndHash(vnd_));
+    ASSERT_TRUE(ShiftAllSnapshotBlocks("prd_b", old_prd_size));
+
+    sync();
+
+    // Assert that source partitions aren't affected.
+    for (const auto& name : {"sys_a", "vnd_a", "prd_a"}) {
+        ASSERT_TRUE(IsPartitionUnchanged(name));
+    }
+
+    ASSERT_TRUE(sm->FinishedSnapshotWrites(false));
+
+    // Simulate shutting down the device.
+    ASSERT_TRUE(UnmapAll());
+
+    // After reboot, init does first stage mount.
+    auto init = NewManagerForFirstStageMount("_b");
+    ASSERT_NE(init, nullptr);
+    ASSERT_TRUE(init->NeedSnapshotsInFirstStageMount());
+    ASSERT_TRUE(init->CreateLogicalAndSnapshotPartitions("super", snapshot_timeout_));
+
+    // Check that the target partitions have the same content.
+    for (const auto& name : {"sys_b", "vnd_b", "prd_b"}) {
+        ASSERT_TRUE(IsPartitionUnchanged(name));
+    }
+
+    // Initiate the merge and wait for it to be completed.
+    if (ShouldSkipLegacyMerging()) {
+        LOG(INFO) << "Skipping legacy merge in test";
+        return;
+    }
+    ASSERT_TRUE(init->InitiateMerge());
+    ASSERT_EQ(init->IsSnapuserdRequired(), snapuserd_required_);
+    {
+        // Check that the merge phase is FIRST_PHASE until at least one call
+        // to ProcessUpdateState() occurs.
+        ASSERT_TRUE(AcquireLock());
+        auto local_lock = std::move(lock_);
+        auto status = init->ReadSnapshotUpdateStatus(local_lock.get());
+        ASSERT_EQ(status.merge_phase(), MergePhase::FIRST_PHASE);
+    }
+
+    // Wait until prd_b merge is completed which is part of first phase
+    std::chrono::milliseconds timeout(6000);
+    auto start = std::chrono::steady_clock::now();
+    // Keep polling until the merge is complete or timeout is reached
+    while (true) {
+        // Query the merge status
+        const auto merge_status = init->snapuserd_client()->QuerySnapshotStatus("prd_b");
+        if (merge_status == "snapshot-merge-complete") {
+            break;
+        }
+
+        auto now = std::chrono::steady_clock::now();
+        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - start);
+
+        ASSERT_TRUE(elapsed < timeout);
+        // sleep for a second and allow merge to complete
+        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    }
+
+    // Now, forcefully update the snapshot-update status to SECOND PHASE
+    // This will not update the snapshot status of sys_b to MERGING
+    if (init->UpdateUsesUserSnapshots()) {
+        ASSERT_TRUE(AcquireLock());
+        auto local_lock = std::move(lock_);
+        auto status = init->ReadSnapshotUpdateStatus(local_lock.get());
+        status.set_merge_phase(MergePhase::SECOND_PHASE);
+        ASSERT_TRUE(init->WriteSnapshotUpdateStatus(local_lock.get(), status));
+    }
+
+    // Simulate shutting down the device and creating partitions again.
+    ASSERT_TRUE(UnmapAll());
+    ASSERT_TRUE(init->CreateLogicalAndSnapshotPartitions("super", snapshot_timeout_));
+
+    DeviceMapper::TargetInfo target;
+    ASSERT_TRUE(init->IsSnapshotDevice("prd_b", &target));
+
+    ASSERT_EQ(DeviceMapper::GetTargetType(target.spec), "user");
+    ASSERT_TRUE(init->IsSnapshotDevice("sys_b", &target));
+    ASSERT_EQ(DeviceMapper::GetTargetType(target.spec), "user");
+    ASSERT_TRUE(init->IsSnapshotDevice("vnd_b", &target));
+    ASSERT_EQ(DeviceMapper::GetTargetType(target.spec), "user");
+
+    // Complete the merge; "sys" and "vnd" should resume the merge
+    // even though merge was interrupted after update_status was updated to
+    // SECOND_PHASE
+    ASSERT_EQ(UpdateState::MergeCompleted, init->ProcessUpdateState());
+
+    // Make sure the second phase ran and deleted snapshots.
+    {
+        ASSERT_TRUE(AcquireLock());
+        auto local_lock = std::move(lock_);
+        std::vector<std::string> snapshots;
+        ASSERT_TRUE(init->ListSnapshots(local_lock.get(), &snapshots));
+        ASSERT_TRUE(snapshots.empty());
+    }
+
+    // Check that the target partitions have the same content after the merge.
+    for (const auto& name : {"sys_b", "vnd_b", "prd_b"}) {
+        ASSERT_TRUE(IsPartitionUnchanged(name))
+                << "Content of " << name << " changes after the merge";
+    }
+}
+
 // Test that if new system partitions uses empty space in super, that region is not snapshotted.
 TEST_F(SnapshotUpdateTest, DirectWriteEmptySpace) {
     GTEST_SKIP() << "b/141889746";

From cbe09a8058076836f9023bf8869c4ad74cbfbc2b Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Mon, 21 Oct 2024 17:10:34 +0000
Subject: [PATCH 1177/1487] Remove carlosgalo from libprocessgroup OWNERS

Change-Id: I37cac7694491a7efe16e835776dcd8be7335eabe
---
 libprocessgroup/OWNERS | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/libprocessgroup/OWNERS b/libprocessgroup/OWNERS
index d5aa7211a162..accd7dfccb51 100644
--- a/libprocessgroup/OWNERS
+++ b/libprocessgroup/OWNERS
@@ -1,4 +1,3 @@
 # Bug component: 1293033
 surenb@google.com
-tjmercier@google.com
-carlosgalo@google.com
+tjmercier@google.com
\ No newline at end of file

From 5331393cb152a7eed05ee958b88c722518044714 Mon Sep 17 00:00:00 2001
From: Spandan Das <spandandas@google.com>
Date: Mon, 21 Oct 2024 22:00:11 +0000
Subject: [PATCH 1178/1487] Mark the phony shell_and_utilities_vendor as
 vendor: true

As part of the make to soong conversion, we are currently autogenerating
android_filesystem soong modules for each partition (system, system_ext,
vendor, ...), with the goal to eventually substitute the kati built
partitions. In order to generate the deps of these partitions, we are
currently using a heuristic to classify the modules in
`PRODUCT_PACKAGES` with the associated partition.

Mark the phony module `shell_and_utilities_vendor` as
`vendor: true` to help with this conversion heursitic.

Bug: 374371755
Test: verified that /bin/awk is present in the autogenerated soong-built
vendor partition

Change-Id: I0a99275fb03fbb9adeb1502734759f433585ef25
---
 shell_and_utilities/Android.bp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/shell_and_utilities/Android.bp b/shell_and_utilities/Android.bp
index d5893de63d37..1f5c1795c4dd 100644
--- a/shell_and_utilities/Android.bp
+++ b/shell_and_utilities/Android.bp
@@ -58,6 +58,7 @@ phony {
         "toolbox_vendor",
         "toybox_vendor",
     ],
+    vendor: true,
 }
 
 // shell and utilities for first stage console. The list of binaries are

From a190ecb6f16b025a9c0c82f4c15ef5f759cd7e97 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Mon, 21 Oct 2024 23:01:56 +0000
Subject: [PATCH 1179/1487] RefBase: document leak memory case

We should fix the leak, but it introduces the possibility
that something is use this. Instead, document best practice
(not to allocate RefBase objects on the stack).

Fixes: 295340906
Test: N/A
Change-Id: Ife7a561f790dc687fb99b73729818e61834fa272
---
 libutils/binder/RefBase.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libutils/binder/RefBase.cpp b/libutils/binder/RefBase.cpp
index 2d2e40b7e3b5..4291f1e21146 100644
--- a/libutils/binder/RefBase.cpp
+++ b/libutils/binder/RefBase.cpp
@@ -787,7 +787,7 @@ RefBase::~RefBase()
             // sp<T>(T*) constructor, assuming that if the object is around, it is already
             // owned by an sp<>.
             ALOGW("RefBase: Explicit destruction, weak count = %d (in %p). Use sp<> to manage this "
-                  "object.",
+                  "object. Note - if weak count is 0, this leaks mRefs (weakref_impl).",
                   mRefs->mWeak.load(), this);
 
 #if ANDROID_UTILS_CALLSTACK_ENABLED

From 68c2cbf2befa57a9477df27c3c699fdb46f9d5b0 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 21 Oct 2024 10:04:01 -0700
Subject: [PATCH 1180/1487] libsnapshot: Fix MapAllSnapshotsWithoutSlotSwitch
 test

IsUserspaceSnapshotUpdateInProgress() would return dm partitions
which are backed by verity; this check is invalid for tests.

Bug: 369964380
Test: vts_libsnapshot_test64 --gtest_filter=SnapshotUpdateTest.MapAllSnapshotsWithoutSlotSwitch
Change-Id: I7d207c472077042ea07b65bf81b64c9c240ae8c7
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshot_test.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 3e5ae2afffa9..1a0d559792f1 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2658,9 +2658,6 @@ TEST_F(SnapshotUpdateTest, MapAllSnapshotsWithoutSlotSwitch) {
     // Remove the indicators
     ASSERT_TRUE(sm->PrepareDeviceToBootWithoutSnapshot());
 
-    // Ensure snapshots are still mounted
-    ASSERT_TRUE(sm->IsUserspaceSnapshotUpdateInProgress());
-
     // Cleanup snapshots
     ASSERT_TRUE(sm->UnmapAllSnapshots());
 }

From 09c18c17fd00a60f50e8958eddf6b4e4b9dd9760 Mon Sep 17 00:00:00 2001
From: Cole Faust <colefaust@google.com>
Date: Tue, 22 Oct 2024 16:31:05 -0700
Subject: [PATCH 1181/1487] Remove dependencies on the 1-variant fallback

When adding a dependencies, if the variants don't match, but the
dependency only has 1 variant anyways, soong will always use that
variant. This makes it hard to add new variants to soong, because the
1-variant fallback stops being used and you start getting missing
variant errors. Make changes to bp files such that all dependencies
correctly specify the variant to use.

Bug: 372091092
Flag: EXEMPT refactor
Test: m nothing
Change-Id: I35a5ac0e6b63080f692be6597edf5f213c4e7acb
---
 debuggerd/test_permissive_mte/Android.bp |  2 +-
 init/test_upgrade_mte/Android.bp         | 35 +++++++++++++++---------
 2 files changed, 23 insertions(+), 14 deletions(-)

diff --git a/debuggerd/test_permissive_mte/Android.bp b/debuggerd/test_permissive_mte/Android.bp
index 0ad32439d6ba..f333242cc7a8 100644
--- a/debuggerd/test_permissive_mte/Android.bp
+++ b/debuggerd/test_permissive_mte/Android.bp
@@ -39,7 +39,7 @@ java_test_host {
         "src/**/PermissiveMteTest.java",
         ":libtombstone_proto-src",
     ],
-    data: [":mte_crash"],
+    device_first_data: [":mte_crash"],
     test_config: "AndroidTest.xml",
     test_suites: ["general-tests"],
 }
diff --git a/init/test_upgrade_mte/Android.bp b/init/test_upgrade_mte/Android.bp
index 1bfc76c69e7e..dfea325a2633 100644
--- a/init/test_upgrade_mte/Android.bp
+++ b/init/test_upgrade_mte/Android.bp
@@ -17,25 +17,34 @@ package {
 }
 
 cc_binary {
-  name: "mte_upgrade_test_helper",
-  srcs: ["mte_upgrade_test_helper.cpp"],
-  sanitize: {
-    memtag_heap: true,
-    diag: {
-      memtag_heap: false,
+    name: "mte_upgrade_test_helper",
+    srcs: ["mte_upgrade_test_helper.cpp"],
+    sanitize: {
+        memtag_heap: true,
+        diag: {
+            memtag_heap: false,
+        },
     },
-  },
-  init_rc: [
-    "mte_upgrade_test.rc",
-  ],
+    init_rc: [
+        "mte_upgrade_test.rc",
+    ],
 }
 
 java_test_host {
     name: "mte_upgrade_test",
     libs: ["tradefed"],
-    static_libs: ["frameworks-base-hostutils", "cts-install-lib-host"],
-    srcs:  ["src/**/MteUpgradeTest.java", ":libtombstone_proto-src"],
-    data: [":mte_upgrade_test_helper", "mte_upgrade_test.rc" ],
+    static_libs: [
+        "frameworks-base-hostutils",
+        "cts-install-lib-host",
+    ],
+    srcs: [
+        "src/**/MteUpgradeTest.java",
+        ":libtombstone_proto-src",
+    ],
+    device_first_data: [
+        ":mte_upgrade_test_helper",
+        "mte_upgrade_test.rc",
+    ],
     test_config: "AndroidTest.xml",
     test_suites: ["general-tests"],
 }

From 77dc1e7df326b126b7a40e836c9b8efa5d76e2e5 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 21 Oct 2024 10:04:01 -0700
Subject: [PATCH 1182/1487] libsnapshot: Fix MapAllSnapshotsWithoutSlotSwitch
 test

IsUserspaceSnapshotUpdateInProgress() would return dm partitions
which are backed by verity; this check is invalid for tests.

Bug: 369964380
Test: vts_libsnapshot_test64 --gtest_filter=SnapshotUpdateTest.MapAllSnapshotsWithoutSlotSwitch
Change-Id: I7d207c472077042ea07b65bf81b64c9c240ae8c7
Signed-off-by: Akilesh Kailash <akailash@google.com>
(cherry picked from commit 68c2cbf2befa57a9477df27c3c699fdb46f9d5b0)
---
 fs_mgr/libsnapshot/snapshot_test.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index bf16b0fb3db5..ba86a51de9b0 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -2513,9 +2513,6 @@ TEST_F(SnapshotUpdateTest, MapAllSnapshotsWithoutSlotSwitch) {
     // Remove the indicators
     ASSERT_TRUE(sm->PrepareDeviceToBootWithoutSnapshot());
 
-    // Ensure snapshots are still mounted
-    ASSERT_TRUE(sm->IsUserspaceSnapshotUpdateInProgress());
-
     // Cleanup snapshots
     ASSERT_TRUE(sm->UnmapAllSnapshots());
 }

From 03f7133b0efe03ff0f144f1731c11bdd5098691f Mon Sep 17 00:00:00 2001
From: Karuna Wadhera <kwadhera@google.com>
Date: Wed, 23 Oct 2024 04:05:49 +0000
Subject: [PATCH 1183/1487] Pin KeyMint dependency to correct/specific version

libkeymint depends on the latest version of the HAL, which will soon be
bumped to v4. Since this implementation won't immediately be upgraded,
and this dependency seems unused, remove it.

Bug: 369375199
Test: Treehugger
Change-Id: I5e952595bb4d4d8a283b286b5054576394788f16
---
 trusty/keymaster/Android.bp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/trusty/keymaster/Android.bp b/trusty/keymaster/Android.bp
index aca59b6c6290..cb078299e24a 100644
--- a/trusty/keymaster/Android.bp
+++ b/trusty/keymaster/Android.bp
@@ -105,19 +105,17 @@ cc_binary {
         "keymint/TrustySharedSecret.cpp",
         "keymint/service.cpp",
     ],
-    defaults: [
-        "keymint_use_latest_hal_aidl_ndk_shared",
-    ],
     shared_libs: [
+        "android.hardware.security.keymint-V3-ndk",
         "android.hardware.security.rkp-V3-ndk",
         "android.hardware.security.secureclock-V1-ndk",
         "android.hardware.security.sharedsecret-V1-ndk",
-        "lib_android_keymaster_keymint_utils",
+        "lib_android_keymaster_keymint_utils_V3",
         "libbase",
         "libbinder_ndk",
         "libhardware",
         "libkeymaster_messages",
-        "libkeymint",
+        "libkeymasterconfig",
         "liblog",
         "libtrusty",
         "libutils",

From 5bfb93678fa26e9763699669e6bbf1c2c6a7478d Mon Sep 17 00:00:00 2001
From: Konrad Adamczyk <konrada@google.com>
Date: Thu, 24 Oct 2024 07:28:25 +0000
Subject: [PATCH 1184/1487] Revert^2 "init: Look for super partition only on a
 boot device"

This reverts commit 8d71220df28851a7dce351f86601958fdbc3e5ae.

Reason for revert: Fix for gcar emulator (basically all QEMU-based emulators) landed at aosp/3315253 and aosp/3160116.

Change-Id: If4eddd3f7e224c31019ad3bd752e2375c7567780
---
 init/block_dev_initializer.cpp |  6 +++++-
 init/devices.cpp               | 22 ++++++++++++++++++++++
 init/devices.h                 |  1 +
 3 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/init/block_dev_initializer.cpp b/init/block_dev_initializer.cpp
index 8f5215856544..cabeb01090b0 100644
--- a/init/block_dev_initializer.cpp
+++ b/init/block_dev_initializer.cpp
@@ -98,7 +98,11 @@ ListenerAction BlockDevInitializer::HandleUevent(const Uevent& uevent,
 
     LOG(VERBOSE) << __PRETTY_FUNCTION__ << ": found partition: " << name;
 
-    devices->erase(iter);
+    // Remove partition from the list only if it was found on boot device
+    if (device_handler_->IsBootDevice(uevent)) {
+        devices->erase(iter);
+    }
+
     device_handler_->HandleUevent(uevent);
     return devices->empty() ? ListenerAction::kStop : ListenerAction::kContinue;
 }
diff --git a/init/devices.cpp b/init/devices.cpp
index f2bb9d27607d..6a3a64dd81f3 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -188,6 +188,28 @@ void SysfsPermissions::SetPermissions(const std::string& path) const {
     }
 }
 
+bool DeviceHandler::IsBootDevice(const Uevent& uevent) const {
+    std::string device;
+
+    if (FindPlatformDevice(uevent.path, &device)) {
+        // Skip /devices/platform or /devices/ if present
+        static constexpr std::string_view devices_platform_prefix = "/devices/platform/";
+        static constexpr std::string_view devices_prefix = "/devices/";
+
+        if (StartsWith(device, devices_platform_prefix)) {
+            device = device.substr(devices_platform_prefix.length());
+        } else if (StartsWith(device, devices_prefix)) {
+            device = device.substr(devices_prefix.length());
+        }
+    } else if (FindPciDevicePrefix(uevent.path, &device)) {
+    } else if (FindVbdDevicePrefix(uevent.path, &device)) {
+    } else {
+        return false;
+    }
+
+    return boot_devices_.find(device) != boot_devices_.end();
+}
+
 std::string DeviceHandler::GetPartitionNameForDevice(const std::string& query_device) {
     static const auto partition_map = [] {
         std::vector<std::pair<std::string, std::string>> partition_map;
diff --git a/init/devices.h b/init/devices.h
index 6da1232595b4..4df604d00cef 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -133,6 +133,7 @@ class DeviceHandler : public UeventHandler {
     // `androidboot.partition_map=vdb,metadata;vdc,userdata` maps `vdb` to `metadata` and `vdc` to
     // `userdata`.
     static std::string GetPartitionNameForDevice(const std::string& device);
+    bool IsBootDevice(const Uevent& uevent) const;
 
   private:
     void ColdbootDone() override;

From 9b9233f4c1c31819fcd0fbc761f3b7ba6bd94344 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 1 Oct 2024 11:01:08 -0700
Subject: [PATCH 1185/1487] libdm: Redact keys from dm-crypt targets when
 calling GetTable.

Ignore-AOSP-First: security fix
Bug: 368069390
Test: libdm_test
Change-Id: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
Merged-In: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
(cherry picked from commit bc067ef9f0408f3b7c4f5dcae3b6aec51f386e4d)
---
 fs_mgr/libdm/dm.cpp      | 14 ++++++++++++++
 fs_mgr/libdm/dm_test.cpp | 28 ++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+)

diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index 1e8c14fe2c01..c6f9192ae265 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -540,6 +540,17 @@ bool DeviceMapper::GetTableInfo(const std::string& name, std::vector<TargetInfo>
     return GetTable(name, DM_STATUS_TABLE_FLAG, table);
 }
 
+void RedactTableInfo(const struct dm_target_spec& spec, std::string* data) {
+    if (DeviceMapper::GetTargetType(spec) == "crypt") {
+        auto parts = android::base::Split(*data, " ");
+        if (parts.size() < 2) {
+            return;
+        }
+        parts[1] = "redacted";
+        *data = android::base::Join(parts, " ");
+    }
+}
+
 // private methods of DeviceMapper
 bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
                             std::vector<TargetInfo>* table) {
@@ -578,6 +589,9 @@ bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
             // Note: we use c_str() to eliminate any extra trailing 0s.
             data = std::string(&buffer[data_offset], next_cursor - data_offset).c_str();
         }
+        if (flags & DM_STATUS_TABLE_FLAG) {
+            RedactTableInfo(*spec, &data);
+        }
         table->emplace_back(*spec, data);
         cursor = next_cursor;
     }
diff --git a/fs_mgr/libdm/dm_test.cpp b/fs_mgr/libdm/dm_test.cpp
index c522eafae058..08edbe832d82 100644
--- a/fs_mgr/libdm/dm_test.cpp
+++ b/fs_mgr/libdm/dm_test.cpp
@@ -757,3 +757,31 @@ TEST_F(DmTest, GetNameAndUuid) {
     ASSERT_EQ(name, test_name_);
     ASSERT_FALSE(uuid.empty());
 }
+
+TEST_F(DmTest, RedactDmCrypt) {
+    static constexpr uint64_t kImageSize = 65536;
+    unique_fd temp_file(CreateTempFile("file_1", kImageSize));
+    ASSERT_GE(temp_file, 0);
+
+    LoopDevice loop(temp_file, 10s);
+    ASSERT_TRUE(loop.valid());
+
+    static constexpr const char* kAlgorithm = "aes-cbc-essiv:sha256";
+    static constexpr const char* kKey = "0e64ef514e6a1315b1f6390cb57c9e6a";
+
+    auto target = std::make_unique<DmTargetCrypt>(0, kImageSize / 512, kAlgorithm, kKey, 0,
+                                                  loop.device(), 0);
+    target->AllowDiscards();
+
+    DmTable table;
+    table.AddTarget(std::move(target));
+
+    auto& dm = DeviceMapper::Instance();
+    std::string crypt_path;
+    ASSERT_TRUE(dm.CreateDevice(test_name_, table, &crypt_path, 10s));
+
+    std::vector<DeviceMapper::TargetInfo> targets;
+    ASSERT_TRUE(dm.GetTableInfo(test_name_, &targets));
+    ASSERT_EQ(targets.size(), 1);
+    EXPECT_EQ(targets[0].data.find(kKey), std::string::npos);
+}

From 7ae15190df95ca1c02741b17835cea51ccaf6657 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 1 Oct 2024 11:01:08 -0700
Subject: [PATCH 1186/1487] libdm: Redact keys from dm-crypt targets when
 calling GetTable.

Ignore-AOSP-First: security fix
Bug: 368069390
Test: libdm_test
Change-Id: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
Merged-In: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
(cherry picked from commit bc067ef9f0408f3b7c4f5dcae3b6aec51f386e4d)
---
 fs_mgr/libdm/dm.cpp      | 14 ++++++++++++++
 fs_mgr/libdm/dm_test.cpp | 28 ++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+)

diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index 1e8c14fe2c01..c6f9192ae265 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -540,6 +540,17 @@ bool DeviceMapper::GetTableInfo(const std::string& name, std::vector<TargetInfo>
     return GetTable(name, DM_STATUS_TABLE_FLAG, table);
 }
 
+void RedactTableInfo(const struct dm_target_spec& spec, std::string* data) {
+    if (DeviceMapper::GetTargetType(spec) == "crypt") {
+        auto parts = android::base::Split(*data, " ");
+        if (parts.size() < 2) {
+            return;
+        }
+        parts[1] = "redacted";
+        *data = android::base::Join(parts, " ");
+    }
+}
+
 // private methods of DeviceMapper
 bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
                             std::vector<TargetInfo>* table) {
@@ -578,6 +589,9 @@ bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
             // Note: we use c_str() to eliminate any extra trailing 0s.
             data = std::string(&buffer[data_offset], next_cursor - data_offset).c_str();
         }
+        if (flags & DM_STATUS_TABLE_FLAG) {
+            RedactTableInfo(*spec, &data);
+        }
         table->emplace_back(*spec, data);
         cursor = next_cursor;
     }
diff --git a/fs_mgr/libdm/dm_test.cpp b/fs_mgr/libdm/dm_test.cpp
index c522eafae058..08edbe832d82 100644
--- a/fs_mgr/libdm/dm_test.cpp
+++ b/fs_mgr/libdm/dm_test.cpp
@@ -757,3 +757,31 @@ TEST_F(DmTest, GetNameAndUuid) {
     ASSERT_EQ(name, test_name_);
     ASSERT_FALSE(uuid.empty());
 }
+
+TEST_F(DmTest, RedactDmCrypt) {
+    static constexpr uint64_t kImageSize = 65536;
+    unique_fd temp_file(CreateTempFile("file_1", kImageSize));
+    ASSERT_GE(temp_file, 0);
+
+    LoopDevice loop(temp_file, 10s);
+    ASSERT_TRUE(loop.valid());
+
+    static constexpr const char* kAlgorithm = "aes-cbc-essiv:sha256";
+    static constexpr const char* kKey = "0e64ef514e6a1315b1f6390cb57c9e6a";
+
+    auto target = std::make_unique<DmTargetCrypt>(0, kImageSize / 512, kAlgorithm, kKey, 0,
+                                                  loop.device(), 0);
+    target->AllowDiscards();
+
+    DmTable table;
+    table.AddTarget(std::move(target));
+
+    auto& dm = DeviceMapper::Instance();
+    std::string crypt_path;
+    ASSERT_TRUE(dm.CreateDevice(test_name_, table, &crypt_path, 10s));
+
+    std::vector<DeviceMapper::TargetInfo> targets;
+    ASSERT_TRUE(dm.GetTableInfo(test_name_, &targets));
+    ASSERT_EQ(targets.size(), 1);
+    EXPECT_EQ(targets[0].data.find(kKey), std::string::npos);
+}

From b544df0e15b43391867e864c575b9f4dbd3c242d Mon Sep 17 00:00:00 2001
From: Will McVicker <willmcvicker@google.com>
Date: Mon, 21 Oct 2024 15:19:53 -0700
Subject: [PATCH 1187/1487] Add support to update the DTB when flashing a
 vendor_boot ramdisk

When updating the vendor_boot ramdisk, there may be device tree
dependencies that require updating the device tree with the new ramdisk
which contains the first stage init kernel modules. This patch adds the
support to use the `--dtb /path/to/dtb` option to update the DTB when
updating the vendor_boot ramdisk. To do so, run the command:

  fastboot flash --dtb /path/to/dtb.img \
      vendor_boot:<RAMDISK_NAME> /path/to/ramdisk

Test: fastboot_vendor_boot_img_utils_test
Test: Verifed updating the dtb with the above command on r4
Bug: 368308832
Change-Id: Iaa1867fe64054971a698497a2e3486424fed19fe
---
 fastboot/Android.bp                     |  1 +
 fastboot/fastboot.cpp                   | 26 +++++++-
 fastboot/fuzzer/fastboot_fuzzer.cpp     |  4 +-
 fastboot/testdata/Android.bp            |  8 +++
 fastboot/vendor_boot_img_utils.cpp      | 59 +++++++++++++-----
 fastboot/vendor_boot_img_utils.h        |  2 +-
 fastboot/vendor_boot_img_utils_test.cpp | 82 ++++++++++++++++++++-----
 7 files changed, 147 insertions(+), 35 deletions(-)

diff --git a/fastboot/Android.bp b/fastboot/Android.bp
index bfe0768f884e..b61fbd4df826 100644
--- a/fastboot/Android.bp
+++ b/fastboot/Android.bp
@@ -430,6 +430,7 @@ cc_test_host {
     ],
     data: [
         ":fastboot_test_dtb",
+        ":fastboot_test_dtb_replace",
         ":fastboot_test_bootconfig",
         ":fastboot_test_vendor_ramdisk_none",
         ":fastboot_test_vendor_ramdisk_platform",
diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 6b9e493ebdab..156dc3b33408 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -552,6 +552,12 @@ static int show_help() {
             "                            Secondary images may be flashed to inactive slot.\n"
             " flash PARTITION [FILENAME] Flash given partition, using the image from\n"
             "                            $ANDROID_PRODUCT_OUT if no filename is given.\n"
+            " flash vendor_boot:RAMDISK [FILENAME]\n"
+            "                            Flash vendor_boot ramdisk, fetching the existing\n"
+            "                            vendor_boot image and repackaging it with the new\n"
+            "                            ramdisk.\n"
+            " --dtb DTB                  If set with flash vendor_boot:RAMDISK, then\n"
+            "                            update the vendor_boot image with provided DTB.\n"
             "\n"
             "basics:\n"
             " devices [-l]               List devices in bootloader (-l: with device paths).\n"
@@ -1020,6 +1026,8 @@ static uint64_t get_uint_var(const char* var_name, fastboot::IFastBootDriver* fb
 }
 
 int64_t get_sparse_limit(int64_t size, const FlashingPlan* fp) {
+    if (!fp) return 0;
+
     int64_t limit = int64_t(fp->sparse_limit);
     if (limit == 0) {
         // Unlimited, so see what the target device's limit is.
@@ -1465,6 +1473,7 @@ static void do_fetch(const std::string& partition, const std::string& slot_overr
 static std::string repack_ramdisk(const char* pname, struct fastboot_buffer* buf,
                                   fastboot::IFastBootDriver* fb) {
     std::string_view pname_sv{pname};
+    struct fastboot_buffer dtb_buf = {.sz = 0, .fd = unique_fd(-1)};
 
     if (!android::base::StartsWith(pname_sv, "vendor_boot:") &&
         !android::base::StartsWith(pname_sv, "vendor_boot_a:") &&
@@ -1480,10 +1489,25 @@ static std::string repack_ramdisk(const char* pname, struct fastboot_buffer* buf
     std::string partition(pname_sv.substr(0, pname_sv.find(':')));
     std::string ramdisk(pname_sv.substr(pname_sv.find(':') + 1));
 
+    if (!g_dtb_path.empty()) {
+        if (!load_buf(g_dtb_path.c_str(), &dtb_buf, nullptr)) {
+            die("cannot load '%s': %s", g_dtb_path.c_str(), strerror(errno));
+        }
+
+        if (dtb_buf.type != FB_BUFFER_FD) {
+            die("Flashing sparse vendor ramdisk image with dtb is not supported.");
+        }
+        if (dtb_buf.sz <= 0) {
+            die("repack_ramdisk() sees invalid dtb size: %" PRId64, buf->sz);
+        }
+        verbose("Updating DTB with %s", pname_sv.data());
+    }
+
     unique_fd vendor_boot(make_temporary_fd("vendor boot repack"));
     uint64_t vendor_boot_size = fetch_partition(partition, vendor_boot, fb);
     auto repack_res = replace_vendor_ramdisk(vendor_boot, vendor_boot_size, ramdisk, buf->fd,
-                                             static_cast<uint64_t>(buf->sz));
+                                             static_cast<uint64_t>(buf->sz), dtb_buf.fd,
+                                             static_cast<uint64_t>(dtb_buf.sz));
     if (!repack_res.ok()) {
         die("%s", repack_res.error().message().c_str());
     }
diff --git a/fastboot/fuzzer/fastboot_fuzzer.cpp b/fastboot/fuzzer/fastboot_fuzzer.cpp
index 60940fe3d49d..4594a8ab4403 100644
--- a/fastboot/fuzzer/fastboot_fuzzer.cpp
+++ b/fastboot/fuzzer/fastboot_fuzzer.cpp
@@ -15,6 +15,7 @@
  *
  */
 #include <android-base/file.h>
+#include <android-base/unique_fd.h>
 #include "fastboot.h"
 #include "socket.h"
 #include "socket_mock_fuzz.h"
@@ -25,6 +26,7 @@
 #include <fuzzer/FuzzedDataProvider.h>
 
 using namespace std;
+using android::base::unique_fd;
 
 const size_t kYearMin = 2000;
 const size_t kYearMax = 2127;
@@ -255,7 +257,7 @@ void FastbootFuzzer::InvokeVendorBootImgUtils(const uint8_t* data, size_t size)
     uint64_t ramdisk_size =
             fdp_->ConsumeBool() ? content_ramdisk_fd.size() : fdp_->ConsumeIntegral<uint64_t>();
     (void)replace_vendor_ramdisk(vendor_boot_fd, vendor_boot_size, ramdisk_name, ramdisk_fd,
-                                 ramdisk_size);
+                                 ramdisk_size, unique_fd(-1), 0);
     close(vendor_boot_fd);
     close(ramdisk_fd);
 }
diff --git a/fastboot/testdata/Android.bp b/fastboot/testdata/Android.bp
index a490fe270ca0..47bf0959e7ba 100644
--- a/fastboot/testdata/Android.bp
+++ b/fastboot/testdata/Android.bp
@@ -40,6 +40,14 @@ genrule {
     cmd: "$(location fastboot_gen_rand) --seed dtb --length 1024 > $(out)",
 }
 
+// Fake dtb image for replacement.
+genrule {
+    name: "fastboot_test_dtb_replace",
+    defaults: ["fastboot_test_data_gen_defaults"],
+    out: ["dtb_replace.img"],
+    cmd: "$(location fastboot_gen_rand) --seed dtb --length 2048 > $(out)",
+}
+
 // Fake bootconfig image.
 genrule {
     name: "fastboot_test_bootconfig",
diff --git a/fastboot/vendor_boot_img_utils.cpp b/fastboot/vendor_boot_img_utils.cpp
index 9f05253c086d..da547f1bf432 100644
--- a/fastboot/vendor_boot_img_utils.cpp
+++ b/fastboot/vendor_boot_img_utils.cpp
@@ -209,7 +209,8 @@ inline uint32_t round_up(uint32_t value, uint32_t page_size) {
 
 // Replace the vendor ramdisk as a whole.
 [[nodiscard]] Result<std::string> replace_default_vendor_ramdisk(const std::string& vendor_boot,
-                                                                 const std::string& new_ramdisk) {
+                                                                 const std::string& new_ramdisk,
+                                                                 const std::string& new_dtb) {
     if (auto res = check_vendor_boot_hdr(vendor_boot, 3); !res.ok()) return res.error();
     auto hdr = reinterpret_cast<const vendor_boot_img_hdr_v3*>(vendor_boot.data());
     auto hdr_size = get_vendor_boot_header_size(hdr);
@@ -244,8 +245,19 @@ inline uint32_t round_up(uint32_t value, uint32_t page_size) {
         return res.error();
     if (auto res = updater.CheckOffset(o + p, o + new_p); !res.ok()) return res.error();
 
-    // Copy DTB (Q bytes).
-    if (auto res = updater.Copy(q); !res.ok()) return res.error();
+    // Copy DTB (Q bytes). Replace if a new one was provided.
+    new_hdr->dtb_size = !new_dtb.empty() ? new_dtb.size() : hdr->dtb_size;
+    const uint32_t new_q = round_up(new_hdr->dtb_size, new_hdr->page_size);
+    if (new_dtb.empty()) {
+        if (auto res = updater.Copy(q); !res.ok()) return res.error();
+    } else {
+        if (auto res = updater.Replace(hdr->dtb_size, new_dtb); !res.ok()) return res.error();
+        if (auto res = updater.Skip(q - hdr->dtb_size, new_q - new_hdr->dtb_size); !res.ok())
+            return res.error();
+    }
+    if (auto res = updater.CheckOffset(o + p + q, o + new_p + new_q); !res.ok()) {
+        return res.error();
+    }
 
     if (new_hdr->header_version >= 4) {
         auto hdr_v4 = static_cast<const vendor_boot_img_hdr_v4*>(hdr);
@@ -256,7 +268,7 @@ inline uint32_t round_up(uint32_t value, uint32_t page_size) {
         auto new_hdr_v4 = static_cast<const vendor_boot_img_hdr_v4*>(new_hdr);
         auto new_r = round_up(new_hdr_v4->vendor_ramdisk_table_size, new_hdr->page_size);
         if (auto res = updater.Skip(r, new_r); !res.ok()) return res.error();
-        if (auto res = updater.CheckOffset(o + p + q + r, o + new_p + q + new_r); !res.ok())
+        if (auto res = updater.CheckOffset(o + p + q + r, o + new_p + new_q + new_r); !res.ok())
             return res.error();
 
         // Replace table with single entry representing the full ramdisk.
@@ -303,7 +315,8 @@ inline uint32_t round_up(uint32_t value, uint32_t page_size) {
 // replace it with the content of |new_ramdisk|.
 [[nodiscard]] Result<std::string> replace_vendor_ramdisk_fragment(const std::string& ramdisk_name,
                                                                   const std::string& vendor_boot,
-                                                                  const std::string& new_ramdisk) {
+                                                                  const std::string& new_ramdisk,
+                                                                  const std::string& new_dtb) {
     if (auto res = check_vendor_boot_hdr(vendor_boot, 4); !res.ok()) return res.error();
     auto hdr = reinterpret_cast<const vendor_boot_img_hdr_v4*>(vendor_boot.data());
     auto hdr_size = get_vendor_boot_header_size(hdr);
@@ -368,8 +381,19 @@ inline uint32_t round_up(uint32_t value, uint32_t page_size) {
         return res.error();
     if (auto res = updater.CheckOffset(o + p, o + new_p); !res.ok()) return res.error();
 
-    // Copy DTB (Q bytes).
-    if (auto res = updater.Copy(q); !res.ok()) return res.error();
+    // Copy DTB (Q bytes). Replace if a new one was provided.
+    new_hdr->dtb_size = !new_dtb.empty() ? new_dtb.size() : hdr->dtb_size;
+    const uint32_t new_q = round_up(new_hdr->dtb_size, new_hdr->page_size);
+    if (new_dtb.empty()) {
+        if (auto res = updater.Copy(q); !res.ok()) return res.error();
+    } else {
+        if (auto res = updater.Replace(hdr->dtb_size, new_dtb); !res.ok()) return res.error();
+        if (auto res = updater.Skip(q - hdr->dtb_size, new_q - new_hdr->dtb_size); !res.ok())
+            return res.error();
+    }
+    if (auto res = updater.CheckOffset(o + p + q, o + new_p + new_q); !res.ok()) {
+        return res.error();
+    }
 
     // Copy table, but with corresponding entries modified, including:
     // - ramdisk_size of the entry replaced
@@ -392,7 +416,7 @@ inline uint32_t round_up(uint32_t value, uint32_t page_size) {
                                             hdr->vendor_ramdisk_table_entry_size);
         !res.ok())
         return res.error();
-    if (auto res = updater.CheckOffset(o + p + q + r, o + new_p + q + r); !res.ok())
+    if (auto res = updater.CheckOffset(o + p + q + r, o + new_p + new_q + r); !res.ok())
         return res.error();
 
     // Copy bootconfig (S bytes).
@@ -404,11 +428,11 @@ inline uint32_t round_up(uint32_t value, uint32_t page_size) {
 
 }  // namespace
 
-[[nodiscard]] Result<void> replace_vendor_ramdisk(android::base::borrowed_fd vendor_boot_fd,
-                                                  uint64_t vendor_boot_size,
-                                                  const std::string& ramdisk_name,
-                                                  android::base::borrowed_fd new_ramdisk_fd,
-                                                  uint64_t new_ramdisk_size) {
+[[nodiscard]] Result<void> replace_vendor_ramdisk(
+        android::base::borrowed_fd vendor_boot_fd, uint64_t vendor_boot_size,
+        const std::string& ramdisk_name, android::base::borrowed_fd new_ramdisk_fd,
+        uint64_t new_ramdisk_size, android::base::borrowed_fd new_dtb_fd, uint64_t new_dtb_size) {
+    Result<std::string> new_dtb = {""};
     if (new_ramdisk_size > std::numeric_limits<uint32_t>::max()) {
         return Errorf("New vendor ramdisk is too big");
     }
@@ -417,12 +441,17 @@ inline uint32_t round_up(uint32_t value, uint32_t page_size) {
     if (!vendor_boot.ok()) return vendor_boot.error();
     auto new_ramdisk = load_file(new_ramdisk_fd, new_ramdisk_size, "new vendor ramdisk");
     if (!new_ramdisk.ok()) return new_ramdisk.error();
+    if (new_dtb_size > 0 && new_dtb_fd >= 0) {
+        new_dtb = load_file(new_dtb_fd, new_dtb_size, "new dtb");
+        if (!new_dtb.ok()) return new_dtb.error();
+    }
 
     Result<std::string> new_vendor_boot;
     if (ramdisk_name == "default") {
-        new_vendor_boot = replace_default_vendor_ramdisk(*vendor_boot, *new_ramdisk);
+        new_vendor_boot = replace_default_vendor_ramdisk(*vendor_boot, *new_ramdisk, *new_dtb);
     } else {
-        new_vendor_boot = replace_vendor_ramdisk_fragment(ramdisk_name, *vendor_boot, *new_ramdisk);
+        new_vendor_boot =
+                replace_vendor_ramdisk_fragment(ramdisk_name, *vendor_boot, *new_ramdisk, *new_dtb);
     }
     if (!new_vendor_boot.ok()) return new_vendor_boot.error();
     if (auto res = store_file(vendor_boot_fd, *new_vendor_boot, "new vendor boot image"); !res.ok())
diff --git a/fastboot/vendor_boot_img_utils.h b/fastboot/vendor_boot_img_utils.h
index 0b702bc4dd4b..0ca78dae2660 100644
--- a/fastboot/vendor_boot_img_utils.h
+++ b/fastboot/vendor_boot_img_utils.h
@@ -31,4 +31,4 @@
 [[nodiscard]] android::base::Result<void> replace_vendor_ramdisk(
         android::base::borrowed_fd vendor_boot_fd, uint64_t vendor_boot_size,
         const std::string& ramdisk_name, android::base::borrowed_fd new_ramdisk_fd,
-        uint64_t new_ramdisk_size);
+        uint64_t new_ramdisk_size, android::base::borrowed_fd new_dtb_fd, uint64_t new_dtb_size);
diff --git a/fastboot/vendor_boot_img_utils_test.cpp b/fastboot/vendor_boot_img_utils_test.cpp
index 81072705d6dc..841e532ac621 100644
--- a/fastboot/vendor_boot_img_utils_test.cpp
+++ b/fastboot/vendor_boot_img_utils_test.cpp
@@ -241,6 +241,7 @@ RepackVendorBootImgTestEnv* env = nullptr;
 
 struct RepackVendorBootImgTestParam {
     std::string vendor_boot_file_name;
+    std::string dtb_file_name;
     uint32_t expected_header_version;
     friend std::ostream& operator<<(std::ostream& os, const RepackVendorBootImgTestParam& param) {
         return os << param.vendor_boot_file_name;
@@ -252,22 +253,50 @@ class RepackVendorBootImgTest : public ::testing::TestWithParam<RepackVendorBoot
     virtual void SetUp() {
         vboot = std::make_unique<ReadWriteTestFileHandle>(GetParam().vendor_boot_file_name);
         ASSERT_RESULT_OK(vboot->Open());
+
+        if (!GetParam().dtb_file_name.empty()) {
+            dtb_replacement = std::make_unique<ReadOnlyTestFileHandle>(GetParam().dtb_file_name);
+            ASSERT_RESULT_OK(dtb_replacement->Open());
+        }
     }
     std::unique_ptr<TestFileHandle> vboot;
+    std::unique_ptr<TestFileHandle> dtb_replacement;
 };
 
 TEST_P(RepackVendorBootImgTest, InvalidSize) {
-    EXPECT_ERROR(replace_vendor_ramdisk(vboot->fd(), vboot->size() + 1, "default",
-                                        env->replace->fd(), env->replace->size()),
-                 HasSubstr("Size of vendor boot does not match"));
-    EXPECT_ERROR(replace_vendor_ramdisk(vboot->fd(), vboot->size(), "default", env->replace->fd(),
-                                        env->replace->size() + 1),
-                 HasSubstr("Size of new vendor ramdisk does not match"));
+    EXPECT_ERROR(
+            replace_vendor_ramdisk(vboot->fd(), vboot->size() + 1, "default", env->replace->fd(),
+                                   env->replace->size(),
+                                   !GetParam().dtb_file_name.empty() ? dtb_replacement->fd()
+                                                                     : android::base::unique_fd(-1),
+                                   !GetParam().dtb_file_name.empty() ? dtb_replacement->size() : 0),
+            HasSubstr("Size of vendor boot does not match"));
+    EXPECT_ERROR(
+            replace_vendor_ramdisk(vboot->fd(), vboot->size(), "default", env->replace->fd(),
+                                   env->replace->size() + 1,
+                                   !GetParam().dtb_file_name.empty() ? dtb_replacement->fd()
+                                                                     : android::base::unique_fd(-1),
+                                   !GetParam().dtb_file_name.empty() ? dtb_replacement->size() : 0),
+            HasSubstr("Size of new vendor ramdisk does not match"));
+    if (!GetParam().dtb_file_name.empty()) {
+        EXPECT_ERROR(replace_vendor_ramdisk(vboot->fd(), vboot->size(), "default",
+                                            env->replace->fd(), env->replace->size(),
+                                            dtb_replacement->fd(), dtb_replacement->size() + 1),
+                     HasSubstr("Size of new dtb does not match"));
+    }
+    EXPECT_ERROR(
+            replace_vendor_ramdisk(
+                    vboot->fd(), vboot->size(), "default", env->replace->fd(), env->replace->size(),
+                    android::base::unique_fd(std::numeric_limits<int32_t>::max()), 1),
+            HasSubstr("Can't seek to the beginning of new dtb image"));
 }
 
 TEST_P(RepackVendorBootImgTest, ReplaceUnknown) {
-    auto res = replace_vendor_ramdisk(vboot->fd(), vboot->size(), "unknown", env->replace->fd(),
-                                      env->replace->size());
+    auto res = replace_vendor_ramdisk(
+            vboot->fd(), vboot->size(), "unknown", env->replace->fd(), env->replace->size(),
+            !GetParam().dtb_file_name.empty() ? dtb_replacement->fd()
+                                              : android::base::unique_fd(-1),
+            !GetParam().dtb_file_name.empty() ? dtb_replacement->size() : 0);
     if (GetParam().expected_header_version == 3) {
         EXPECT_ERROR(res, Eq("Require vendor boot header V4 but is V3"));
     } else if (GetParam().expected_header_version == 4) {
@@ -279,8 +308,11 @@ TEST_P(RepackVendorBootImgTest, ReplaceDefault) {
     auto old_content = vboot->Read();
     ASSERT_RESULT_OK(old_content);
 
-    ASSERT_RESULT_OK(replace_vendor_ramdisk(vboot->fd(), vboot->size(), "default",
-                                            env->replace->fd(), env->replace->size()));
+    ASSERT_RESULT_OK(replace_vendor_ramdisk(
+            vboot->fd(), vboot->size(), "default", env->replace->fd(), env->replace->size(),
+            !GetParam().dtb_file_name.empty() ? dtb_replacement->fd()
+                                              : android::base::unique_fd(-1),
+            !GetParam().dtb_file_name.empty() ? dtb_replacement->size() : 0));
     EXPECT_RESULT(vboot->fsize(), vboot->size()) << "File size should not change after repack";
 
     auto new_content_res = vboot->Read();
@@ -291,14 +323,23 @@ TEST_P(RepackVendorBootImgTest, ReplaceDefault) {
     ASSERT_EQ(0, memcmp(VENDOR_BOOT_MAGIC, hdr->magic, VENDOR_BOOT_MAGIC_SIZE));
     ASSERT_EQ(GetParam().expected_header_version, hdr->header_version);
     EXPECT_EQ(hdr->vendor_ramdisk_size, env->replace->size());
-    EXPECT_EQ(hdr->dtb_size, env->dtb->size());
+    if (GetParam().dtb_file_name.empty()) {
+        EXPECT_EQ(hdr->dtb_size, env->dtb->size());
+    } else {
+        EXPECT_EQ(hdr->dtb_size, dtb_replacement->size());
+    }
 
     auto o = round_up(sizeof(vendor_boot_img_hdr_v3), hdr->page_size);
     auto p = round_up(hdr->vendor_ramdisk_size, hdr->page_size);
     auto q = round_up(hdr->dtb_size, hdr->page_size);
 
     EXPECT_THAT(new_content.substr(o, p), IsPadded(env->replace_content));
-    EXPECT_THAT(new_content.substr(o + p, q), IsPadded(env->dtb_content));
+    if (GetParam().dtb_file_name.empty()) {
+        EXPECT_THAT(new_content.substr(o + p, q), IsPadded(env->dtb_content));
+    } else {
+        auto dtb_content_res = dtb_replacement->Read();
+        EXPECT_THAT(new_content.substr(o + p, q), IsPadded(*dtb_content_res));
+    }
 
     if (hdr->header_version < 4) return;
 
@@ -321,11 +362,17 @@ TEST_P(RepackVendorBootImgTest, ReplaceDefault) {
 
 INSTANTIATE_TEST_SUITE_P(
         RepackVendorBootImgTest, RepackVendorBootImgTest,
-        ::testing::Values(RepackVendorBootImgTestParam{"vendor_boot_v3.img", 3},
-                          RepackVendorBootImgTestParam{"vendor_boot_v4_with_frag.img", 4},
-                          RepackVendorBootImgTestParam{"vendor_boot_v4_without_frag.img", 4}),
+        ::testing::Values(RepackVendorBootImgTestParam{"vendor_boot_v3.img", "", 3},
+                          RepackVendorBootImgTestParam{"vendor_boot_v4_with_frag.img", "", 4},
+                          RepackVendorBootImgTestParam{"vendor_boot_v4_without_frag.img", "", 4},
+                          RepackVendorBootImgTestParam{"vendor_boot_v4_with_frag.img",
+                                                       "dtb_replace.img", 4},
+                          RepackVendorBootImgTestParam{"vendor_boot_v4_without_frag.img",
+                                                       "dtb_replace.img", 4}),
         [](const auto& info) {
-            return android::base::StringReplace(info.param.vendor_boot_file_name, ".", "_", false);
+            std::string test_name =
+                    android::base::StringReplace(info.param.vendor_boot_file_name, ".", "_", false);
+            return test_name + (!info.param.dtb_file_name.empty() ? "_replace_dtb" : "");
         });
 
 std::string_view GetRamdiskName(const vendor_ramdisk_table_entry_v4* entry) {
@@ -368,7 +415,8 @@ TEST_P(RepackVendorBootImgTestV4, Replace) {
     ASSERT_RESULT_OK(old_content);
 
     ASSERT_RESULT_OK(replace_vendor_ramdisk(vboot->fd(), vboot->size(), replace_ramdisk_name,
-                                            env->replace->fd(), env->replace->size()));
+                                            env->replace->fd(), env->replace->size(),
+                                            android::base::unique_fd(-1), 0));
     EXPECT_RESULT(vboot->fsize(), vboot->size()) << "File size should not change after repack";
 
     auto new_content_res = vboot->Read();

From ec0f7774c659d204cfd36b0407dbf7f6dc5be762 Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Thu, 24 Oct 2024 15:59:44 -0700
Subject: [PATCH 1188/1487] fs_mgr: avoid std::vector<const T>

std::vector<const T> uses std::allocator<const T>, which is an
undocumented libc++ extension to the C++ standard library. The extension
was removed in llvm.org/PR96319. Use an ordinary non-const T instead.

Bug: http://b/349681543
Bug: http://b/375478563
Test: m libfs_mgr
Flag: EXEMPT, refactor to fix build failure
Change-Id: I759526c7507824dca0e2e4f5cb2bf3c58dece1d8
---
 fs_mgr/fs_mgr.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index fbd990b96fbd..cae8bbe40a78 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -2213,11 +2213,11 @@ bool fs_mgr_mount_overlayfs_fstab_entry(const FstabEntry& entry) {
 
 #if ALLOW_ADBD_DISABLE_VERITY == 0
     // Allowlist the mount point if user build.
-    static const std::vector<const std::string> kAllowedPaths = {
+    static const std::vector<std::string> kAllowedPaths = {
             "/odm",         "/odm_dlkm",   "/oem",    "/product",
             "/system_dlkm", "/system_ext", "/vendor", "/vendor_dlkm",
     };
-    static const std::vector<const std::string> kAllowedPrefixes = {
+    static const std::vector<std::string> kAllowedPrefixes = {
             "/mnt/product/",
             "/mnt/vendor/",
     };

From ac474ff7a0745308dd8f67b66d405f2f78bd9413 Mon Sep 17 00:00:00 2001
From: Grzegorz Jaszczyk <jaszczyk@google.com>
Date: Sun, 13 Oct 2024 14:55:38 +0000
Subject: [PATCH 1189/1487] firmware_handler: extract part responsible for
 running ext program to lib

As a preparation for upcoming commit, extract part which is responsible
for external program execution to libmodprobe so it can be later
re-used not only for firmware handler but also for dynamic module
options handler within libmodprobe.

RunExternalHandler is moved entirely to separate library with two
changes:
- Setting env needed previously by firmware handler was made generic and
  now external handler can get envs_map containing pairs of env and its
  value which needs to be set.
- "Firmware" was removed from one of the log since now it can be used in
  different context (s/External Firmware Handler/External Handler/)

Bug: 335619610
Test: `atest CtsInitTestCases` passed, especially:
      [105/129] ueventd_parser#ExternalFirmwareHandlers: PASSED (0ms)
      [106/129] ueventd_parser#ExternalFirmwareHandlersDuplicate: PASSED (0ms)

Change-Id: Ie07cee763278f224bd3c0acfbe06c44eb36d0a81
---
 init/firmware_handler.cpp                   | 104 ++--------------
 init/firmware_handler.h                     |   2 -
 libmodprobe/Android.bp                      |   2 +
 libmodprobe/exthandler.cpp                  | 131 ++++++++++++++++++++
 libmodprobe/include/exthandler/exthandler.h |  23 ++++
 5 files changed, 164 insertions(+), 98 deletions(-)
 create mode 100644 libmodprobe/exthandler.cpp
 create mode 100644 libmodprobe/include/exthandler/exthandler.h

diff --git a/init/firmware_handler.cpp b/init/firmware_handler.cpp
index 01957eff06f8..dcfda52d6723 100644
--- a/init/firmware_handler.cpp
+++ b/init/firmware_handler.cpp
@@ -38,6 +38,8 @@
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 
+#include "exthandler/exthandler.h"
+
 using android::base::ReadFdToString;
 using android::base::Socketpair;
 using android::base::Split;
@@ -136,100 +138,6 @@ FirmwareHandler::FirmwareHandler(std::vector<std::string> firmware_directories,
     : firmware_directories_(std::move(firmware_directories)),
       external_firmware_handlers_(std::move(external_firmware_handlers)) {}
 
-Result<std::string> FirmwareHandler::RunExternalHandler(const std::string& handler, uid_t uid,
-                                                        gid_t gid, const Uevent& uevent) const {
-    unique_fd child_stdout;
-    unique_fd parent_stdout;
-    if (!Socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, &child_stdout, &parent_stdout)) {
-        return ErrnoError() << "Socketpair() for stdout failed";
-    }
-
-    unique_fd child_stderr;
-    unique_fd parent_stderr;
-    if (!Socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, &child_stderr, &parent_stderr)) {
-        return ErrnoError() << "Socketpair() for stderr failed";
-    }
-
-    signal(SIGCHLD, SIG_DFL);
-
-    auto pid = fork();
-    if (pid < 0) {
-        return ErrnoError() << "fork() failed";
-    }
-
-    if (pid == 0) {
-        setenv("FIRMWARE", uevent.firmware.c_str(), 1);
-        setenv("DEVPATH", uevent.path.c_str(), 1);
-        parent_stdout.reset();
-        parent_stderr.reset();
-        close(STDOUT_FILENO);
-        close(STDERR_FILENO);
-        dup2(child_stdout.get(), STDOUT_FILENO);
-        dup2(child_stderr.get(), STDERR_FILENO);
-
-        auto args = Split(handler, " ");
-        std::vector<char*> c_args;
-        for (auto& arg : args) {
-            c_args.emplace_back(arg.data());
-        }
-        c_args.emplace_back(nullptr);
-
-        if (gid != 0) {
-            if (setgid(gid) != 0) {
-                fprintf(stderr, "setgid() failed: %s", strerror(errno));
-                _exit(EXIT_FAILURE);
-            }
-        }
-
-        if (setuid(uid) != 0) {
-            fprintf(stderr, "setuid() failed: %s", strerror(errno));
-            _exit(EXIT_FAILURE);
-        }
-
-        execv(c_args[0], c_args.data());
-        fprintf(stderr, "exec() failed: %s", strerror(errno));
-        _exit(EXIT_FAILURE);
-    }
-
-    child_stdout.reset();
-    child_stderr.reset();
-
-    int status;
-    pid_t waited_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
-    if (waited_pid == -1) {
-        return ErrnoError() << "waitpid() failed";
-    }
-
-    std::string stdout_content;
-    if (!ReadFdToString(parent_stdout.get(), &stdout_content)) {
-        return ErrnoError() << "ReadFdToString() for stdout failed";
-    }
-
-    std::string stderr_content;
-    if (ReadFdToString(parent_stderr.get(), &stderr_content)) {
-        auto messages = Split(stderr_content, "\n");
-        for (const auto& message : messages) {
-            if (!message.empty()) {
-                LOG(ERROR) << "External Firmware Handler: " << message;
-            }
-        }
-    } else {
-        LOG(ERROR) << "ReadFdToString() for stderr failed";
-    }
-
-    if (WIFEXITED(status)) {
-        if (WEXITSTATUS(status) == EXIT_SUCCESS) {
-            return Trim(stdout_content);
-        } else {
-            return Error() << "exited with status " << WEXITSTATUS(status);
-        }
-    } else if (WIFSIGNALED(status)) {
-        return Error() << "killed by signal " << WTERMSIG(status);
-    }
-
-    return Error() << "unexpected exit status " << status;
-}
-
 std::string FirmwareHandler::GetFirmwarePath(const Uevent& uevent) const {
     for (const auto& external_handler : external_firmware_handlers_) {
         if (external_handler.match(uevent.path)) {
@@ -237,11 +145,15 @@ std::string FirmwareHandler::GetFirmwarePath(const Uevent& uevent) const {
                       << "' for devpath: '" << uevent.path << "' firmware: '" << uevent.firmware
                       << "'";
 
+            std::unordered_map<std::string, std::string> envs_map;
+            envs_map["FIRMWARE"] = uevent.firmware;
+            envs_map["DEVPATH"] = uevent.path;
+
             auto result = RunExternalHandler(external_handler.handler_path, external_handler.uid,
-                                             external_handler.gid, uevent);
+                                             external_handler.gid, envs_map);
             if (!result.ok() && NeedsRerunExternalHandler()) {
                 auto res = RunExternalHandler(external_handler.handler_path, external_handler.uid,
-                                              external_handler.gid, uevent);
+                                              external_handler.gid, envs_map);
                 result = std::move(res);
             }
             if (!result.ok()) {
diff --git a/init/firmware_handler.h b/init/firmware_handler.h
index fceb392db5bd..e5d3538096ee 100644
--- a/init/firmware_handler.h
+++ b/init/firmware_handler.h
@@ -54,8 +54,6 @@ class FirmwareHandler : public UeventHandler {
     friend void FirmwareTestWithExternalHandler(const std::string& test_name,
                                                 bool expect_new_firmware);
 
-    Result<std::string> RunExternalHandler(const std::string& handler, uid_t uid, gid_t gid,
-                                           const Uevent& uevent) const;
     std::string GetFirmwarePath(const Uevent& uevent) const;
     void ProcessFirmwareEvent(const std::string& path, const std::string& firmware) const;
     bool ForEachFirmwareDirectory(std::function<bool(const std::string&)> handler) const;
diff --git a/libmodprobe/Android.bp b/libmodprobe/Android.bp
index 12906cc39e33..78b4c83e3cef 100644
--- a/libmodprobe/Android.bp
+++ b/libmodprobe/Android.bp
@@ -13,6 +13,7 @@ cc_library_static {
     vendor_ramdisk_available: true,
     host_supported: true,
     srcs: [
+        "exthandler.cpp",
         "libmodprobe.cpp",
         "libmodprobe_ext.cpp",
     ],
@@ -30,6 +31,7 @@ cc_test {
     ],
     local_include_dirs: ["include/"],
     srcs: [
+        "exthandler.cpp",
         "libmodprobe_test.cpp",
         "libmodprobe.cpp",
         "libmodprobe_ext_test.cpp",
diff --git a/libmodprobe/exthandler.cpp b/libmodprobe/exthandler.cpp
new file mode 100644
index 000000000000..f48c25976ade
--- /dev/null
+++ b/libmodprobe/exthandler.cpp
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <exthandler/exthandler.h>
+
+#include <android-base/chrono_utils.h>
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/parseint.h>
+#include <android-base/strings.h>
+#include <android-base/unique_fd.h>
+#include <fnmatch.h>
+#include <grp.h>
+#include <pwd.h>
+#include <sys/wait.h>
+
+using android::base::ErrnoError;
+using android::base::Error;
+using android::base::ReadFdToString;
+using android::base::Result;
+using android::base::Split;
+using android::base::Trim;
+using android::base::unique_fd;
+
+Result<std::string> RunExternalHandler(const std::string& handler, uid_t uid, gid_t gid,
+                                       std::unordered_map<std::string, std::string>& envs_map) {
+    unique_fd child_stdout;
+    unique_fd parent_stdout;
+    if (!Socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, &child_stdout, &parent_stdout)) {
+        return ErrnoError() << "Socketpair() for stdout failed";
+    }
+
+    unique_fd child_stderr;
+    unique_fd parent_stderr;
+    if (!Socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, &child_stderr, &parent_stderr)) {
+        return ErrnoError() << "Socketpair() for stderr failed";
+    }
+
+    signal(SIGCHLD, SIG_DFL);
+
+    auto pid = fork();
+    if (pid < 0) {
+        return ErrnoError() << "fork() failed";
+    }
+
+    if (pid == 0) {
+        for (auto it = envs_map.begin(); it != envs_map.end(); ++it) {
+            setenv(it->first.c_str(), it->second.c_str(), 1);
+        }
+        parent_stdout.reset();
+        parent_stderr.reset();
+        close(STDOUT_FILENO);
+        close(STDERR_FILENO);
+        dup2(child_stdout.get(), STDOUT_FILENO);
+        dup2(child_stderr.get(), STDERR_FILENO);
+
+        auto args = Split(handler, " ");
+        std::vector<char*> c_args;
+        for (auto& arg : args) {
+            c_args.emplace_back(arg.data());
+        }
+        c_args.emplace_back(nullptr);
+
+        if (gid != 0) {
+            if (setgid(gid) != 0) {
+                fprintf(stderr, "setgid() failed: %s", strerror(errno));
+                _exit(EXIT_FAILURE);
+            }
+        }
+
+        if (setuid(uid) != 0) {
+            fprintf(stderr, "setuid() failed: %s", strerror(errno));
+            _exit(EXIT_FAILURE);
+        }
+
+        execv(c_args[0], c_args.data());
+        fprintf(stderr, "exec() failed: %s", strerror(errno));
+        _exit(EXIT_FAILURE);
+    }
+
+    child_stdout.reset();
+    child_stderr.reset();
+
+    int status;
+    pid_t waited_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
+    if (waited_pid == -1) {
+        return ErrnoError() << "waitpid() failed";
+    }
+
+    std::string stdout_content;
+    if (!ReadFdToString(parent_stdout.get(), &stdout_content)) {
+        return ErrnoError() << "ReadFdToString() for stdout failed";
+    }
+
+    std::string stderr_content;
+    if (ReadFdToString(parent_stderr.get(), &stderr_content)) {
+        auto messages = Split(stderr_content, "\n");
+        for (const auto& message : messages) {
+            if (!message.empty()) {
+                LOG(ERROR) << "External Handler: " << message;
+            }
+        }
+    } else {
+        LOG(ERROR) << "ReadFdToString() for stderr failed";
+    }
+
+    if (WIFEXITED(status)) {
+        if (WEXITSTATUS(status) == EXIT_SUCCESS) {
+            return Trim(stdout_content);
+        } else {
+            return Error() << "exited with status " << WEXITSTATUS(status);
+        }
+    } else if (WIFSIGNALED(status)) {
+        return Error() << "killed by signal " << WTERMSIG(status);
+    }
+
+    return Error() << "unexpected exit status " << status;
+}
diff --git a/libmodprobe/include/exthandler/exthandler.h b/libmodprobe/include/exthandler/exthandler.h
new file mode 100644
index 000000000000..232aa95a4835
--- /dev/null
+++ b/libmodprobe/include/exthandler/exthandler.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <android-base/result.h>
+#include <string>
+
+android::base::Result<std::string> RunExternalHandler(
+        const std::string& handler, uid_t uid, gid_t gid,
+        std::unordered_map<std::string, std::string>& envs_map);

From 3063d84e9c0162ba74670f4eb6ef276ceb03c644 Mon Sep 17 00:00:00 2001
From: Grzegorz Jaszczyk <jaszczyk@google.com>
Date: Thu, 6 Jun 2024 15:27:08 +0000
Subject: [PATCH 1190/1487] libmodprobe: add support for dynamic module options

Hitherto libmodprobe was supporting modules.options which allows passing
extra module options. This commit extends that support and beside
`options`, modules.options can now contain `dyn_options` entries.

Syntax example:
dyn_options snd_sof_pci system "/vendor/bin/mod_options --sof-fw"

This allows to determine extra module options, with help of external
program, at runtime which can be useful for unibuilds, supporting
various device flavors and therefore requiring different module options.

Using external program to customize modules parameters are inspired by
Android's external firmware handler:
https://android.googlesource.com/platform/system/core/+/master/init/README.ueventd.md#firmware-loading
and the same RunExternalHandler is reused for both dynamic module
handling and firmware handling.

Bug: 335619610
Test: Test audio on systems using snd_sof_pci module and verify
correctness of custom module parameters.

Change-Id: Ibd1a942d4ea022519676435ed525cd7c3e720d31
---
 libmodprobe/include/modprobe/modprobe.h |  1 +
 libmodprobe/libmodprobe.cpp             | 61 +++++++++++++++++++++++++
 2 files changed, 62 insertions(+)

diff --git a/libmodprobe/include/modprobe/modprobe.h b/libmodprobe/include/modprobe/modprobe.h
index d7a90c488f08..7b691b13acec 100644
--- a/libmodprobe/include/modprobe/modprobe.h
+++ b/libmodprobe/include/modprobe/modprobe.h
@@ -59,6 +59,7 @@ class Modprobe {
     bool ParseSoftdepCallback(const std::vector<std::string>& args);
     bool ParseLoadCallback(const std::vector<std::string>& args);
     bool ParseOptionsCallback(const std::vector<std::string>& args);
+    bool ParseDynOptionsCallback(const std::vector<std::string>& args);
     bool ParseBlocklistCallback(const std::vector<std::string>& args);
     void ParseKernelCmdlineOptions();
     void ParseCfg(const std::string& cfg, std::function<bool(const std::vector<std::string>&)> f);
diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index 8cc0b9b2e07b..bdd114c4b798 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -17,8 +17,11 @@
 #include <modprobe/modprobe.h>
 
 #include <fnmatch.h>
+#include <grp.h>
+#include <pwd.h>
 #include <sys/stat.h>
 #include <sys/syscall.h>
+#include <sys/wait.h>
 
 #include <algorithm>
 #include <map>
@@ -30,9 +33,12 @@
 #include <android-base/chrono_utils.h>
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include <android-base/parseint.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 
+#include "exthandler/exthandler.h"
+
 std::string Modprobe::MakeCanonical(const std::string& module_path) {
     auto start = module_path.find_last_of('/');
     if (start == std::string::npos) {
@@ -164,6 +170,10 @@ bool Modprobe::ParseOptionsCallback(const std::vector<std::string>& args) {
     auto it = args.begin();
     const std::string& type = *it++;
 
+    if (type == "dyn_options") {
+        return ParseDynOptionsCallback(std::vector<std::string>(it, args.end()));
+    }
+
     if (type != "options") {
         LOG(ERROR) << "non-options line encountered in modules.options";
         return false;
@@ -197,6 +207,57 @@ bool Modprobe::ParseOptionsCallback(const std::vector<std::string>& args) {
     return true;
 }
 
+bool Modprobe::ParseDynOptionsCallback(const std::vector<std::string>& args) {
+    auto it = args.begin();
+    int arg_size = 3;
+
+    if (args.size() < arg_size) {
+        LOG(ERROR) << "dyn_options lines in modules.options must have at least" << arg_size
+                   << " entries, not " << args.size();
+        return false;
+    }
+
+    const std::string& module = *it++;
+
+    const std::string& canonical_name = MakeCanonical(module);
+    if (canonical_name.empty()) {
+        return false;
+    }
+
+    const std::string& pwnam = *it++;
+    passwd* pwd = getpwnam(pwnam.c_str());
+    if (!pwd) {
+        LOG(ERROR) << "invalid handler uid'" << pwnam << "'";
+        return false;
+    }
+
+    std::string handler_with_args =
+            android::base::Join(std::vector<std::string>(it, args.end()), ' ');
+    handler_with_args.erase(std::remove(handler_with_args.begin(), handler_with_args.end(), '\"'),
+                            handler_with_args.end());
+
+    LOG(DEBUG) << "Launching external module options handler: '" << handler_with_args
+               << " for module: " << module;
+
+    // There is no need to set envs for external module options handler - pass
+    // empty map.
+    std::unordered_map<std::string, std::string> envs_map;
+    auto result = RunExternalHandler(handler_with_args, pwd->pw_uid, 0, envs_map);
+    if (!result.ok()) {
+        LOG(ERROR) << "External module handler failed: " << result.error();
+        return false;
+    }
+
+    LOG(INFO) << "Dynamic options for module: " << module << " are '" << *result << "'";
+
+    auto [unused, inserted] = this->module_options_.emplace(canonical_name, *result);
+    if (!inserted) {
+        LOG(ERROR) << "multiple options lines present for module " << module;
+        return false;
+    }
+    return true;
+}
+
 bool Modprobe::ParseBlocklistCallback(const std::vector<std::string>& args) {
     auto it = args.begin();
     const std::string& type = *it++;

From 77ee43a9fe56db6042d9f91d75cab703f04180e7 Mon Sep 17 00:00:00 2001
From: Daeho Jeong <daehojeong@google.com>
Date: Mon, 21 Oct 2024 13:51:14 -0700
Subject: [PATCH 1191/1487] support f2fs device aliasing feature

We can hold the storage space of one of f2fs multi-device for data
partition, while allowing the space to be used by another purpose.
f2fs will create a sequential and pinned file as a placeholder and it
can be deallocated and returned back to data partition after it is done
with using it. We can create the file, as we define the device with
"exp_alias:" tag in the fstab.

Bug: 336319772
Test: add a device with "exp_alias" tag in fstab
Change-Id: If55730cedd21ec5a40137d2eb723a97df498c9cb
Signed-off-by: Daeho Jeong <daehojeong@google.com>
---
 fs_mgr/fs_mgr.cpp                     |  6 ++++--
 fs_mgr/fs_mgr_format.cpp              | 16 ++++++++++++----
 fs_mgr/libfstab/fstab.cpp             |  1 +
 fs_mgr/libfstab/include/fstab/fstab.h |  1 +
 4 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index fbd990b96fbd..fc105d67d3cb 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -1603,7 +1603,8 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                                    attempted_entry.fs_type,
                                    attempted_entry.fs_mgr_flags.is_zoned ? "true" : "false",
                                    std::to_string(attempted_entry.length),
-                                   android::base::Join(attempted_entry.user_devices, ' ')},
+                                   android::base::Join(attempted_entry.user_devices, ' '),
+                                   android::base::Join(attempted_entry.device_aliased, ' ')},
                                   nullptr)) {
                         LERROR << "Encryption failed";
                         set_type_property(encryptable);
@@ -1655,7 +1656,8 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
                                formattable_entry->fs_type,
                                formattable_entry->fs_mgr_flags.is_zoned ? "true" : "false",
                                std::to_string(formattable_entry->length),
-                               android::base::Join(formattable_entry->user_devices, ' ')},
+                               android::base::Join(formattable_entry->user_devices, ' '),
+                               android::base::Join(formattable_entry->device_aliased, ' ')},
                               nullptr)) {
                     LERROR << "Encryption failed";
                 } else {
diff --git a/fs_mgr/fs_mgr_format.cpp b/fs_mgr/fs_mgr_format.cpp
index 0dde1d3748df..57e35a275a82 100644
--- a/fs_mgr/fs_mgr_format.cpp
+++ b/fs_mgr/fs_mgr_format.cpp
@@ -32,6 +32,7 @@
 #include <selinux/android.h>
 #include <selinux/label.h>
 #include <selinux/selinux.h>
+#include <filesystem>
 #include <string>
 
 #include "fs_mgr_priv.h"
@@ -126,7 +127,8 @@ static int format_ext4(const std::string& fs_blkdev, const std::string& fs_mnt_p
 
 static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool needs_projid,
                        bool needs_casefold, bool fs_compress, bool is_zoned,
-                       const std::vector<std::string>& user_devices) {
+                       const std::vector<std::string>& user_devices,
+                       const std::vector<int>& device_aliased) {
     if (!dev_sz) {
         int rc = get_dev_sz(fs_blkdev, &dev_sz);
         if (rc) {
@@ -164,9 +166,15 @@ static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool needs
     if (is_zoned) {
         args.push_back("-m");
     }
-    for (auto& device : user_devices) {
+    for (size_t i = 0; i < user_devices.size(); i++) {
+        std::string device_name = user_devices[i];
+
         args.push_back("-c");
-        args.push_back(device.c_str());
+        if (device_aliased[i]) {
+            std::filesystem::path path = device_name;
+            device_name += "@" + path.filename().string();
+        }
+        args.push_back(device_name.c_str());
     }
 
     if (user_devices.empty()) {
@@ -191,7 +199,7 @@ int fs_mgr_do_format(const FstabEntry& entry) {
     if (entry.fs_type == "f2fs") {
         return format_f2fs(entry.blk_device, entry.length, needs_projid, needs_casefold,
                            entry.fs_mgr_flags.fs_compress, entry.fs_mgr_flags.is_zoned,
-                           entry.user_devices);
+                           entry.user_devices, entry.device_aliased);
     } else if (entry.fs_type == "ext4") {
         return format_ext4(entry.blk_device, entry.mount_point, needs_projid,
                            entry.fs_mgr_flags.ext_meta_csum);
diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index d344b2d198fc..6e4cae18f57e 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -173,6 +173,7 @@ void ParseUserDevices(const std::string& arg, FstabEntry* entry) {
         entry->fs_mgr_flags.is_zoned = true;
     }
     entry->user_devices.push_back(param[1]);
+    entry->device_aliased.push_back(param[0] == "exp_alias" ? 1 : 0);
 }
 
 bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
diff --git a/fs_mgr/libfstab/include/fstab/fstab.h b/fs_mgr/libfstab/include/fstab/fstab.h
index 21fe01726a9f..070dd9178666 100644
--- a/fs_mgr/libfstab/include/fstab/fstab.h
+++ b/fs_mgr/libfstab/include/fstab/fstab.h
@@ -33,6 +33,7 @@ namespace fs_mgr {
 struct FstabEntry {
     std::string blk_device;
     std::vector<std::string> user_devices;
+    std::vector<int> device_aliased;
     std::string logical_partition_name;
     std::string mount_point;
     std::string fs_type;

From 9611c18aa286a55de54f46e54e1296f98e0d9194 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 25 Oct 2024 17:11:02 +0000
Subject: [PATCH 1192/1487] Don't use android::base::StartsWith / EndsWith

These libbase functions now directly pass through to the standard
library. [1] Use the standard library directly, and eliminate this
dependency on libbase.

[1] https://r.android.com/c/platform/system/libbase/+/3315082

Change-Id: I83d79ffa2658f30ae09a7f27cedf14e62b5df41d
---
 libprocessgroup/processgroup.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index d3719eea39af..95221594b6be 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -37,19 +37,18 @@
 #include <mutex>
 #include <set>
 #include <string>
+#include <string_view>
 #include <thread>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/properties.h>
 #include <android-base/stringprintf.h>
-#include <android-base/strings.h>
 #include <cutils/android_filesystem_config.h>
 #include <processgroup/processgroup.h>
 #include <task_profiles.h>
 
 using android::base::GetBoolProperty;
-using android::base::StartsWith;
 using android::base::StringPrintf;
 using android::base::WriteStringToFile;
 
@@ -255,7 +254,7 @@ static bool RemoveEmptyUidCgroups(const std::string& uid_path) {
                 continue;
             }
 
-            if (!StartsWith(dir->d_name, "pid_")) {
+            if (!std::string_view(dir->d_name).starts_with("pid_")) {
                 continue;
             }
 
@@ -296,7 +295,7 @@ void removeAllEmptyProcessGroups() {
                     continue;
                 }
 
-                if (!StartsWith(dir->d_name, "uid_")) {
+                if (!std::string_view(dir->d_name).starts_with("uid_")) {
                     continue;
                 }
 

From d94e6c537fd8283a33d899d627ff154cc2af2d10 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 1 Oct 2024 11:01:08 -0700
Subject: [PATCH 1193/1487] libdm: Redact keys from dm-crypt targets when
 calling GetTable.

Ignore-AOSP-First: security fix
Bug: 368069390
Test: libdm_test
Change-Id: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
Merged-In: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
---
 fs_mgr/libdm/dm.cpp      | 14 ++++++++++++++
 fs_mgr/libdm/dm_test.cpp | 29 +++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index 4034e30ab9e6..6da7b48b60e0 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -512,6 +512,17 @@ bool DeviceMapper::GetTableInfo(const std::string& name, std::vector<TargetInfo>
     return GetTable(name, DM_STATUS_TABLE_FLAG, table);
 }
 
+void RedactTableInfo(const struct dm_target_spec& spec, std::string* data) {
+    if (DeviceMapper::GetTargetType(spec) == "crypt") {
+        auto parts = android::base::Split(*data, " ");
+        if (parts.size() < 2) {
+            return;
+        }
+        parts[1] = "redacted";
+        *data = android::base::Join(parts, " ");
+    }
+}
+
 // private methods of DeviceMapper
 bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
                             std::vector<TargetInfo>* table) {
@@ -550,6 +561,9 @@ bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
             // Note: we use c_str() to eliminate any extra trailing 0s.
             data = std::string(&buffer[data_offset], next_cursor - data_offset).c_str();
         }
+        if (flags & DM_STATUS_TABLE_FLAG) {
+            RedactTableInfo(*spec, &data);
+        }
         table->emplace_back(*spec, data);
         cursor = next_cursor;
     }
diff --git a/fs_mgr/libdm/dm_test.cpp b/fs_mgr/libdm/dm_test.cpp
index 541f254cbc71..f4c9784da8fc 100644
--- a/fs_mgr/libdm/dm_test.cpp
+++ b/fs_mgr/libdm/dm_test.cpp
@@ -690,3 +690,32 @@ TEST(libdm, CreateEmptyDevice) {
     // Empty device should be in suspended state.
     ASSERT_EQ(DmDeviceState::SUSPENDED, dm.GetState("empty-device"));
 }
+
+TEST(libdm, RedactDmCrypt) {
+    static constexpr uint64_t kImageSize = 65536;
+    static constexpr const char* kTestName = "RedactDmCrypt";
+    unique_fd temp_file(CreateTempFile("file_1", kImageSize));
+    ASSERT_GE(temp_file, 0);
+
+    LoopDevice loop(temp_file, 10s);
+    ASSERT_TRUE(loop.valid());
+
+    static constexpr const char* kAlgorithm = "aes-cbc-essiv:sha256";
+    static constexpr const char* kKey = "0e64ef514e6a1315b1f6390cb57c9e6a";
+
+    auto target = std::make_unique<DmTargetCrypt>(0, kImageSize / 512, kAlgorithm, kKey, 0,
+                                                  loop.device(), 0);
+    target->AllowDiscards();
+
+    DmTable table;
+    table.AddTarget(std::move(target));
+
+    auto& dm = DeviceMapper::Instance();
+    std::string crypt_path;
+    ASSERT_TRUE(dm.CreateDevice(kTestName, table, &crypt_path, 10s));
+
+    std::vector<DeviceMapper::TargetInfo> targets;
+    ASSERT_TRUE(dm.GetTableInfo(kTestName, &targets));
+    ASSERT_EQ(targets.size(), 1);
+    EXPECT_EQ(targets[0].data.find(kKey), std::string::npos);
+}

From 390be0ae38d85d4ea755d39b28b0b6dc338b356e Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 1 Oct 2024 11:01:08 -0700
Subject: [PATCH 1194/1487] libdm: Redact keys from dm-crypt targets when
 calling GetTable.

Ignore-AOSP-First: security fix
Bug: 368069390
Test: libdm_test
Change-Id: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
Merged-In: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
---
 fs_mgr/libdm/dm.cpp      | 14 ++++++++++++++
 fs_mgr/libdm/dm_test.cpp | 29 +++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index 4034e30ab9e6..6da7b48b60e0 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -512,6 +512,17 @@ bool DeviceMapper::GetTableInfo(const std::string& name, std::vector<TargetInfo>
     return GetTable(name, DM_STATUS_TABLE_FLAG, table);
 }
 
+void RedactTableInfo(const struct dm_target_spec& spec, std::string* data) {
+    if (DeviceMapper::GetTargetType(spec) == "crypt") {
+        auto parts = android::base::Split(*data, " ");
+        if (parts.size() < 2) {
+            return;
+        }
+        parts[1] = "redacted";
+        *data = android::base::Join(parts, " ");
+    }
+}
+
 // private methods of DeviceMapper
 bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
                             std::vector<TargetInfo>* table) {
@@ -550,6 +561,9 @@ bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
             // Note: we use c_str() to eliminate any extra trailing 0s.
             data = std::string(&buffer[data_offset], next_cursor - data_offset).c_str();
         }
+        if (flags & DM_STATUS_TABLE_FLAG) {
+            RedactTableInfo(*spec, &data);
+        }
         table->emplace_back(*spec, data);
         cursor = next_cursor;
     }
diff --git a/fs_mgr/libdm/dm_test.cpp b/fs_mgr/libdm/dm_test.cpp
index 541f254cbc71..f4c9784da8fc 100644
--- a/fs_mgr/libdm/dm_test.cpp
+++ b/fs_mgr/libdm/dm_test.cpp
@@ -690,3 +690,32 @@ TEST(libdm, CreateEmptyDevice) {
     // Empty device should be in suspended state.
     ASSERT_EQ(DmDeviceState::SUSPENDED, dm.GetState("empty-device"));
 }
+
+TEST(libdm, RedactDmCrypt) {
+    static constexpr uint64_t kImageSize = 65536;
+    static constexpr const char* kTestName = "RedactDmCrypt";
+    unique_fd temp_file(CreateTempFile("file_1", kImageSize));
+    ASSERT_GE(temp_file, 0);
+
+    LoopDevice loop(temp_file, 10s);
+    ASSERT_TRUE(loop.valid());
+
+    static constexpr const char* kAlgorithm = "aes-cbc-essiv:sha256";
+    static constexpr const char* kKey = "0e64ef514e6a1315b1f6390cb57c9e6a";
+
+    auto target = std::make_unique<DmTargetCrypt>(0, kImageSize / 512, kAlgorithm, kKey, 0,
+                                                  loop.device(), 0);
+    target->AllowDiscards();
+
+    DmTable table;
+    table.AddTarget(std::move(target));
+
+    auto& dm = DeviceMapper::Instance();
+    std::string crypt_path;
+    ASSERT_TRUE(dm.CreateDevice(kTestName, table, &crypt_path, 10s));
+
+    std::vector<DeviceMapper::TargetInfo> targets;
+    ASSERT_TRUE(dm.GetTableInfo(kTestName, &targets));
+    ASSERT_EQ(targets.size(), 1);
+    EXPECT_EQ(targets[0].data.find(kKey), std::string::npos);
+}

From e68f6cd6c0a925fea1bbe7537f6029ef9b0e142c Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 1 Oct 2024 11:01:08 -0700
Subject: [PATCH 1195/1487] libdm: Redact keys from dm-crypt targets when
 calling GetTable.

Ignore-AOSP-First: security fix
Bug: 368069390
Test: libdm_test
Change-Id: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
Merged-In: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
---
 fs_mgr/libdm/dm.cpp      | 14 ++++++++++++++
 fs_mgr/libdm/dm_test.cpp | 29 +++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index b1d5b397ab67..762e83c30463 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -512,6 +512,17 @@ bool DeviceMapper::GetTableInfo(const std::string& name, std::vector<TargetInfo>
     return GetTable(name, DM_STATUS_TABLE_FLAG, table);
 }
 
+void RedactTableInfo(const struct dm_target_spec& spec, std::string* data) {
+    if (DeviceMapper::GetTargetType(spec) == "crypt") {
+        auto parts = android::base::Split(*data, " ");
+        if (parts.size() < 2) {
+            return;
+        }
+        parts[1] = "redacted";
+        *data = android::base::Join(parts, " ");
+    }
+}
+
 // private methods of DeviceMapper
 bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
                             std::vector<TargetInfo>* table) {
@@ -550,6 +561,9 @@ bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
             // Note: we use c_str() to eliminate any extra trailing 0s.
             data = std::string(&buffer[data_offset], next_cursor - data_offset).c_str();
         }
+        if (flags & DM_STATUS_TABLE_FLAG) {
+            RedactTableInfo(*spec, &data);
+        }
         table->emplace_back(*spec, data);
         cursor = next_cursor;
     }
diff --git a/fs_mgr/libdm/dm_test.cpp b/fs_mgr/libdm/dm_test.cpp
index 541f254cbc71..f4c9784da8fc 100644
--- a/fs_mgr/libdm/dm_test.cpp
+++ b/fs_mgr/libdm/dm_test.cpp
@@ -690,3 +690,32 @@ TEST(libdm, CreateEmptyDevice) {
     // Empty device should be in suspended state.
     ASSERT_EQ(DmDeviceState::SUSPENDED, dm.GetState("empty-device"));
 }
+
+TEST(libdm, RedactDmCrypt) {
+    static constexpr uint64_t kImageSize = 65536;
+    static constexpr const char* kTestName = "RedactDmCrypt";
+    unique_fd temp_file(CreateTempFile("file_1", kImageSize));
+    ASSERT_GE(temp_file, 0);
+
+    LoopDevice loop(temp_file, 10s);
+    ASSERT_TRUE(loop.valid());
+
+    static constexpr const char* kAlgorithm = "aes-cbc-essiv:sha256";
+    static constexpr const char* kKey = "0e64ef514e6a1315b1f6390cb57c9e6a";
+
+    auto target = std::make_unique<DmTargetCrypt>(0, kImageSize / 512, kAlgorithm, kKey, 0,
+                                                  loop.device(), 0);
+    target->AllowDiscards();
+
+    DmTable table;
+    table.AddTarget(std::move(target));
+
+    auto& dm = DeviceMapper::Instance();
+    std::string crypt_path;
+    ASSERT_TRUE(dm.CreateDevice(kTestName, table, &crypt_path, 10s));
+
+    std::vector<DeviceMapper::TargetInfo> targets;
+    ASSERT_TRUE(dm.GetTableInfo(kTestName, &targets));
+    ASSERT_EQ(targets.size(), 1);
+    EXPECT_EQ(targets[0].data.find(kKey), std::string::npos);
+}

From 96fc434b6cb5cc08c045d1610e19398bb29f8657 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Sat, 26 Oct 2024 00:34:51 +0000
Subject: [PATCH 1196/1487] libprocessgroup: Remove ifdefery around
 SetTimerSlackAction::ExecuteForTask

This appears to have been due to the use of prctl, which apparently
caused issues for mac builds. Now that use of prctl has been removed, it
doesn't look like we need this anymore.

Fixes: 075008174 ("libprocessgroup: Remove prctl interface for setting timer slack")
Test: m
Bug: 372498744
Change-Id: I8a43951f30d7dd838591a8ba225d712742d7cd4a
---
 libprocessgroup/task_profiles.cpp | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index cc675b3feba1..c96feb3140f4 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -188,9 +188,6 @@ bool ProfileAttribute::GetPathForUID(uid_t uid, std::string* path) const {
     return true;
 }
 
-// To avoid issues in sdk_mac build
-#if defined(__ANDROID__)
-
 bool SetTimerSlackAction::ExecuteForTask(pid_t tid) const {
     const auto file = StringPrintf("/proc/%d/timerslack_ns", tid);
     if (!WriteStringToFile(std::to_string(slack_), file)) {
@@ -205,14 +202,6 @@ bool SetTimerSlackAction::ExecuteForTask(pid_t tid) const {
     return true;
 }
 
-#else
-
-bool SetTimerSlackAction::ExecuteForTask(int) const {
-    return true;
-};
-
-#endif
-
 bool SetAttributeAction::WriteValueToFile(const std::string& path) const {
     if (!WriteStringToFile(value_, path)) {
         if (access(path.c_str(), F_OK) < 0) {

From c9e000c7acf8b9a011491424c3e9b6d667c58221 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 1 Oct 2024 11:01:08 -0700
Subject: [PATCH 1197/1487] libdm: Redact keys from dm-crypt targets when
 calling GetTable.

Ignore-AOSP-First: security fix
Bug: 368069390
Test: libdm_test
Change-Id: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
Merged-In: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
---
 fs_mgr/libdm/dm.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index e43c00b44266..dbee8a3775d4 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -494,6 +494,17 @@ bool DeviceMapper::GetTableInfo(const std::string& name, std::vector<TargetInfo>
     return GetTable(name, DM_STATUS_TABLE_FLAG, table);
 }
 
+void RedactTableInfo(const struct dm_target_spec& spec, std::string* data) {
+    if (DeviceMapper::GetTargetType(spec) == "crypt") {
+        auto parts = android::base::Split(*data, " ");
+        if (parts.size() < 2) {
+            return;
+        }
+        parts[1] = "redacted";
+        *data = android::base::Join(parts, " ");
+    }
+}
+
 // private methods of DeviceMapper
 bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
                             std::vector<TargetInfo>* table) {
@@ -532,6 +543,9 @@ bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
             // Note: we use c_str() to eliminate any extra trailing 0s.
             data = std::string(&buffer[data_offset], next_cursor - data_offset).c_str();
         }
+        if (flags & DM_STATUS_TABLE_FLAG) {
+            RedactTableInfo(*spec, &data);
+        }
         table->emplace_back(*spec, data);
         cursor = next_cursor;
     }

From c434d801d65372dd12d9bc8bd7717ef08f3fa984 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 1 Oct 2024 11:01:08 -0700
Subject: [PATCH 1198/1487] libdm: Redact keys from dm-crypt targets when
 calling GetTable.

Ignore-AOSP-First: security fix
Bug: 368069390
Test: libdm_test
Change-Id: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
Merged-In: I40b9a0129e58b1a0f116ca29f0ee66f91a27a73d
---
 fs_mgr/libdm/dm.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/fs_mgr/libdm/dm.cpp b/fs_mgr/libdm/dm.cpp
index e43c00b44266..dbee8a3775d4 100644
--- a/fs_mgr/libdm/dm.cpp
+++ b/fs_mgr/libdm/dm.cpp
@@ -494,6 +494,17 @@ bool DeviceMapper::GetTableInfo(const std::string& name, std::vector<TargetInfo>
     return GetTable(name, DM_STATUS_TABLE_FLAG, table);
 }
 
+void RedactTableInfo(const struct dm_target_spec& spec, std::string* data) {
+    if (DeviceMapper::GetTargetType(spec) == "crypt") {
+        auto parts = android::base::Split(*data, " ");
+        if (parts.size() < 2) {
+            return;
+        }
+        parts[1] = "redacted";
+        *data = android::base::Join(parts, " ");
+    }
+}
+
 // private methods of DeviceMapper
 bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
                             std::vector<TargetInfo>* table) {
@@ -532,6 +543,9 @@ bool DeviceMapper::GetTable(const std::string& name, uint32_t flags,
             // Note: we use c_str() to eliminate any extra trailing 0s.
             data = std::string(&buffer[data_offset], next_cursor - data_offset).c_str();
         }
+        if (flags & DM_STATUS_TABLE_FLAG) {
+            RedactTableInfo(*spec, &data);
+        }
         table->emplace_back(*spec, data);
         cursor = next_cursor;
     }

From dea6f7c2a53b0fc970f28d8c45bfc390ef69cff2 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 28 Oct 2024 19:47:09 -0700
Subject: [PATCH 1199/1487] Fix overlayfs on page cf page agnostic builds.

Hardcode 4096 block size for f2fs on x86/64.

Bug: 375531898
Test: adb_remount_test.sh
Change-Id: I9b55f7caf1b77f235168664be2f310bb3bb0d179
---
 fs_mgr/fs_mgr.cpp                   | 8 ++++++++
 fs_mgr/fs_mgr_overlayfs_control.cpp | 4 +---
 fs_mgr/include/fs_mgr.h             | 3 +++
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index fbd990b96fbd..e39ffe70c7aa 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -2314,6 +2314,14 @@ std::string fs_mgr_get_context(const std::string& mount_point) {
     return context;
 }
 
+int fs_mgr_f2fs_ideal_block_size() {
+#if defined(__i386__) || defined(__x86_64__)
+    return 4096;
+#else
+    return getpagesize();
+#endif
+}
+
 namespace android {
 namespace fs_mgr {
 
diff --git a/fs_mgr/fs_mgr_overlayfs_control.cpp b/fs_mgr/fs_mgr_overlayfs_control.cpp
index 08ad80caaa2e..489b32e7e75b 100644
--- a/fs_mgr/fs_mgr_overlayfs_control.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_control.cpp
@@ -387,10 +387,8 @@ bool MakeScratchFilesystem(const std::string& scratch_device) {
     auto command = ""s;
     if (!access(kMkF2fs, X_OK) && fs_mgr_filesystem_available("f2fs")) {
         fs_type = "f2fs";
-        command = kMkF2fs + " -w "s;
-        command += std::to_string(getpagesize());
         command = kMkF2fs + " -b "s;
-        command += std::to_string(getpagesize());
+        command += std::to_string(fs_mgr_f2fs_ideal_block_size());
         command += " -f -d1 -l" + android::base::Basename(kScratchMountPoint);
     } else if (!access(kMkExt4, X_OK) && fs_mgr_filesystem_available("ext4")) {
         fs_type = "ext4";
diff --git a/fs_mgr/include/fs_mgr.h b/fs_mgr/include/fs_mgr.h
index 9cfa93f7877b..79690874e2e7 100644
--- a/fs_mgr/include/fs_mgr.h
+++ b/fs_mgr/include/fs_mgr.h
@@ -137,3 +137,6 @@ bool fs_mgr_mount_overlayfs_fstab_entry(const android::fs_mgr::FstabEntry& entry
 // File name used to track if encryption was interrupted, leading to a known bad fs state
 std::string fs_mgr_metadata_encryption_in_progress_file_name(
         const android::fs_mgr::FstabEntry& entry);
+
+// Returns the ideal block size for make_f2fs. Returns -1 on failure.
+int fs_mgr_f2fs_ideal_block_size();

From 03429acceeb0f7a0316075fd66ac6270be403ebe Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Tue, 29 Oct 2024 16:28:33 +0900
Subject: [PATCH 1200/1487] init: mount tracefs before apexd-bootstrap

This removes the error log when apexd-bootstrap starts:

  cutils-trace: Error opening trace file: No such file or directory (2)

Bug: 376150518
Test: boot-time trace shows apexd-bootstrap
  see https://source.android.com/docs/core/perf/boot-times#systrace
Change-Id: I5feaece50663a602b61377cee034060fd30217f9
---
 rootdir/init.rc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 12d9c4377ab1..5bb64cc60086 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -70,6 +70,9 @@ on early-init
 
     start ueventd
 
+    # Mount tracefs (with GID=AID_READTRACEFS)
+    mount tracefs tracefs /sys/kernel/tracing gid=3012
+
     # Run apexd-bootstrap so that APEXes that provide critical libraries
     # become available. Note that this is executed as exec_start to ensure that
     # the libraries are available to the processes started after this statement.
@@ -80,9 +83,6 @@ on early-init
     mkdir /dev/boringssl 0755 root root
     mkdir /dev/boringssl/selftest 0755 root root
 
-    # Mount tracefs (with GID=AID_READTRACEFS)
-    mount tracefs tracefs /sys/kernel/tracing gid=3012
-
     # create sys dirctory
     mkdir /dev/sys 0755 system system
     mkdir /dev/sys/fs 0755 system system

From 132b1ecdfdd5a5573010c083c3078e654f010844 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 29 Oct 2024 22:12:01 +0000
Subject: [PATCH 1201/1487] Switch mkbootfs to C++.

Minimum changes just to get it to compile as C++, no real cleanup.

Change-Id: I8ff3fa35a07cdc9a6a246e79e33581e5d6598833
---
 mkbootfs/Android.bp                   |  2 +-
 mkbootfs/{mkbootfs.c => mkbootfs.cpp} | 18 ++++++++----------
 2 files changed, 9 insertions(+), 11 deletions(-)
 rename mkbootfs/{mkbootfs.c => mkbootfs.cpp} (97%)

diff --git a/mkbootfs/Android.bp b/mkbootfs/Android.bp
index cd2a6245af20..e0191f0dcc64 100644
--- a/mkbootfs/Android.bp
+++ b/mkbootfs/Android.bp
@@ -6,7 +6,7 @@ package {
 
 cc_binary_host {
     name: "mkbootfs",
-    srcs: ["mkbootfs.c"],
+    srcs: ["mkbootfs.cpp"],
     cflags: ["-Werror"],
     static_libs: [
         "libbase",
diff --git a/mkbootfs/mkbootfs.c b/mkbootfs/mkbootfs.cpp
similarity index 97%
rename from mkbootfs/mkbootfs.c
rename to mkbootfs/mkbootfs.cpp
index 84a0a4eeeb2b..65cf497acb65 100644
--- a/mkbootfs/mkbootfs.c
+++ b/mkbootfs/mkbootfs.cpp
@@ -75,7 +75,7 @@ static void fix_stat(const char *path, struct stat *s)
     }
 }
 
-static void _eject(struct stat *s, char *out, int olen, char *data, unsigned datasize)
+static void _eject(struct stat *s, const char *out, int olen, char *data, unsigned datasize)
 {
     // Nothing is special about this value, just picked something in the
     // approximate range that was being used already, and avoiding small
@@ -151,9 +151,10 @@ static void _archive_dir(char *in, char *out, int ilen, int olen)
     DIR* d = opendir(in);
     if (d == NULL) err(1, "cannot open directory '%s'", in);
 
+    // TODO: switch to std::vector
     int size = 32;
     int entries = 0;
-    char** names = malloc(size * sizeof(char*));
+    char** names = (char**) malloc(size * sizeof(char*));
     if (names == NULL) {
       errx(1, "failed to allocate dir names array (size %d)", size);
     }
@@ -167,7 +168,7 @@ static void _archive_dir(char *in, char *out, int ilen, int olen)
 
         if (entries >= size) {
           size *= 2;
-          names = realloc(names, size * sizeof(char*));
+          names = (char**) realloc(names, size * sizeof(char*));
           if (names == NULL) {
             errx(1, "failed to reallocate dir names array (size %d)", size);
           }
@@ -445,15 +446,12 @@ int main(int argc, char *argv[])
     int num_dirs = argc - optind;
     argv += optind;
 
-    while(num_dirs-- > 0){
+    while (num_dirs-- > 0){
         char *x = strchr(*argv, '=');
-        if(x != 0) {
-            *x++ = 0;
-        } else {
-            x = "";
+        if (x != nullptr) {
+            *x++ = '\0';
         }
-
-        archive(*argv, x);
+        archive(*argv, x ?: "");
 
         argv++;
     }

From 930f77b02c8ba5a7bb8e54653455f9885d90748a Mon Sep 17 00:00:00 2001
From: Siarhei Vishniakou <svv@google.com>
Date: Tue, 15 Oct 2024 13:21:19 -0700
Subject: [PATCH 1202/1487] Set input thread priority to RT

To improve input latency, set the critical input threads to RT priority.
This will use RT priority on AOSP devices by default. OEMs can still
choose to customize what "input policy" means for their device, which
may not necessarily mean RT.

For example, on device with multiple small / big cores, input task
affinity could be changed to prioritize big cores + higher CPU frequency
/ voltage, but still keep the standard / default input thread priority.

With this patch, I'm finding that sometimes, one of the critical input
threads has priority 100 instead of the expected 98. Still looking into
that specific issue, but the issue is already present with the existing
"input policy" code.

Bug: 330719044
Flag: com.android.input.flags.enable_input_policy_profile
Test: took perfetto trace and checked the priority on InputDispatcher
and InputReader threads.

Change-Id: I75b6a726f0d066f16bdec26f6cf90721479d17ff
---
 libprocessgroup/profiles/task_profiles.json | 15 +++++-
 libprocessgroup/task_profiles.cpp           | 56 +++++++++++++++------
 2 files changed, 54 insertions(+), 17 deletions(-)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index feda3b49c108..d61939f296c4 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -202,6 +202,19 @@
         }
       ]
     },
+    {
+      "Name": "RealTimeInputScheduling",
+      "Actions": [
+        {
+          "Name": "SetSchedulerPolicy",
+          "Params":
+          {
+            "Policy": "SCHED_FIFO",
+            "Priority": "98"
+          }
+        }
+      ]
+    },
     {
       "Name": "CameraServicePerformance",
       "Actions": [
@@ -704,7 +717,7 @@
     },
     {
       "Name": "InputPolicy",
-      "Profiles": [ "MaxPerformance", "ProcessCapacityMax", "TimerSlackNormal" ]
+      "Profiles": [ "RealTimeInputScheduling", "MaxPerformance", "ProcessCapacityMax", "TimerSlackNormal" ]
     }
   ]
 }
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index cc675b3feba1..f3594e345bd1 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -20,6 +20,7 @@
 #include <task_profiles.h>
 
 #include <map>
+#include <optional>
 #include <string>
 
 #include <dirent.h>
@@ -54,6 +55,7 @@ static constexpr const char* TASK_PROFILE_DB_VENDOR_FILE = "/vendor/etc/task_pro
 
 static constexpr const char* TEMPLATE_TASK_PROFILE_API_FILE =
         "/etc/task_profiles/task_profiles_%u.json";
+namespace {
 
 class FdCacheHelper {
   public:
@@ -64,8 +66,11 @@ class FdCacheHelper {
     };
 
     static void Cache(const std::string& path, android::base::unique_fd& fd);
+
     static void Drop(android::base::unique_fd& fd);
+
     static void Init(const std::string& path, android::base::unique_fd& fd);
+
     static bool IsCached(const android::base::unique_fd& fd) { return fd > FDS_INACCESSIBLE; }
 
   private:
@@ -116,6 +121,17 @@ bool FdCacheHelper::IsAppDependentPath(const std::string& path) {
     return path.find("<uid>", 0) != std::string::npos || path.find("<pid>", 0) != std::string::npos;
 }
 
+std::optional<long> readLong(const std::string& str) {
+    char* end;
+    const long result = strtol(str.c_str(), &end, 10);
+    if (end > str.c_str()) {
+        return result;
+    }
+    return std::nullopt;
+}
+
+}  // namespace
+
 IProfileAttribute::~IProfileAttribute() = default;
 
 const std::string& ProfileAttribute::file_name() const {
@@ -924,15 +940,12 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                     LOG(WARNING) << "JoinCgroup: controller " << controller_name << " is not found";
                 }
             } else if (action_name == "SetTimerSlack") {
-                std::string slack_value = params_val["Slack"].asString();
-                char* end;
-                unsigned long slack;
-
-                slack = strtoul(slack_value.c_str(), &end, 10);
-                if (end > slack_value.c_str()) {
-                    profile->Add(std::make_unique<SetTimerSlackAction>(slack));
+                const std::string slack_string = params_val["Slack"].asString();
+                std::optional<long> slack = readLong(slack_string);
+                if (slack && *slack >= 0) {
+                    profile->Add(std::make_unique<SetTimerSlackAction>(*slack));
                 } else {
-                    LOG(WARNING) << "SetTimerSlack: invalid parameter: " << slack_value;
+                    LOG(WARNING) << "SetTimerSlack: invalid parameter: " << slack_string;
                 }
             } else if (action_name == "SetAttribute") {
                 std::string attr_name = params_val["Name"].asString();
@@ -991,15 +1004,19 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                         // If present, this optional value will be passed in an additional syscall
                         // to setpriority(), since the sched_priority value must be 0 for calls to
                         // sched_setscheduler() with "normal" policies.
-                        const int nice = params_val["Nice"].asInt();
+                        const std::string nice_string = params_val["Nice"].asString();
+                        const std::optional<int> nice = readLong(nice_string);
 
+                        if (!nice) {
+                            LOG(FATAL) << "Invalid nice value specified: " << nice_string;
+                        }
                         const int LINUX_MIN_NICE = -20;
                         const int LINUX_MAX_NICE = 19;
-                        if (nice < LINUX_MIN_NICE || nice > LINUX_MAX_NICE) {
-                            LOG(WARNING) << "SetSchedulerPolicy: Provided nice (" << nice
+                        if (*nice < LINUX_MIN_NICE || *nice > LINUX_MAX_NICE) {
+                            LOG(WARNING) << "SetSchedulerPolicy: Provided nice (" << *nice
                                          << ") appears out of range.";
                         }
-                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy, nice));
+                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy, *nice));
                     } else {
                         profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy));
                     }
@@ -1012,11 +1029,18 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                     // This is a "virtual priority" as described by `man 2 sched_get_priority_min`
                     // that will be mapped onto the following range for the provided policy:
                     // [sched_get_priority_min(), sched_get_priority_max()]
-                    const int virtual_priority = params_val["Priority"].asInt();
 
-                    int priority;
-                    if (SetSchedulerPolicyAction::toPriority(policy, virtual_priority, priority)) {
-                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy, priority));
+                    const std::string priority_string = params_val["Priority"].asString();
+                    std::optional<long> virtual_priority = readLong(priority_string);
+                    if (virtual_priority && *virtual_priority > 0) {
+                        int priority;
+                        if (SetSchedulerPolicyAction::toPriority(policy, *virtual_priority,
+                                                                 priority)) {
+                            profile->Add(
+                                    std::make_unique<SetSchedulerPolicyAction>(policy, priority));
+                        }
+                    } else {
+                        LOG(WARNING) << "Invalid priority value: " << priority_string;
                     }
                 }
             } else {

From 5d5c732a3b374c7992dfa79b6d62ea9f95119a0d Mon Sep 17 00:00:00 2001
From: Alice Wang <aliceywang@google.com>
Date: Wed, 30 Oct 2024 09:44:27 +0000
Subject: [PATCH 1203/1487] Rename KM VM related system properties

To organize it under trusty and distinguish it from
Widevine VM.

Bug: 368502791
Test: launch_cvd --secure_hals=guest_keymint_trusty_insecure
Test: atest VtsAidlSharedSecretTargetTest
Change-Id: I48e43b9709e59b1cb9e1ba9113d5ef894469f485
---
 ...ity.keymint-service.rust.trusty.system.nonsecure.rc |  4 ++--
 trusty/utils/rpmb_dev/rpmb_dev.system.rc               | 10 +++++-----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
index 2799188c4408..ca6132e5eeb3 100644
--- a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
+++ b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
@@ -12,6 +12,6 @@ service system.keymint.rust-trusty.nonsecure \
 # TODO(b/357821690): Start the KeyMint HALs when the KeyMint VM is ready once the Trusty VM
 # has a mechanism to notify the host.
 on late-fs && property:ro.hardware.security.keymint.trusty.system=1 && \
-   property:trusty_vm_system.vm_cid=*
-    setprop system.keymint.trusty_ipc_dev VSOCK:${trusty_vm_system.vm_cid}:1
+   property:trusty.security_vm.vm_cid=*
+    setprop system.keymint.trusty_ipc_dev VSOCK:${trusty.security_vm.vm_cid}:1
     start system.keymint.rust-trusty.nonsecure
diff --git a/trusty/utils/rpmb_dev/rpmb_dev.system.rc b/trusty/utils/rpmb_dev/rpmb_dev.system.rc
index b78c4e2a10da..52419ed184d8 100644
--- a/trusty/utils/rpmb_dev/rpmb_dev.system.rc
+++ b/trusty/utils/rpmb_dev/rpmb_dev.system.rc
@@ -24,7 +24,7 @@ service rpmb_mock_system /system_ext/bin/rpmb_dev.system \
 
 # storageproxyd
 on late-fs && \
-    property:trusty_vm_system_nonsecure.ready=1 && \
+    property:trusty.security_vm.nonsecure_vm_ready=1 && \
     property:storageproxyd_system.trusty_ipc_dev=*
     wait /dev/socket/rpmb_mock_system
     start storageproxyd_system
@@ -32,8 +32,8 @@ on late-fs && \
 
 # RPMB Mock
 on post-fs && \
-    property:trusty_vm_system_nonsecure.ready=1 && \
-    property:trusty_vm_system.vm_cid=*
+    property:trusty.security_vm.nonsecure_vm_ready=1 && \
+    property:trusty.security_vm.vm_cid=*
     # Create a persistent location for the RPMB data
     # (work around lack of RPMb block device on CF).
     # file contexts secure_storage_rpmb_system_file
@@ -49,12 +49,12 @@ on post-fs && \
     mkdir /mnt/secure_storage_persist_system 0770 system system
     symlink /metadata/secure_storage_persist_system \
             /mnt/secure_storage_persist_system/persist
-    setprop storageproxyd_system.trusty_ipc_dev VSOCK:${trusty_vm_system.vm_cid}:1
+    setprop storageproxyd_system.trusty_ipc_dev VSOCK:${trusty.security_vm.vm_cid}:1
     exec_start rpmb_mock_init_system
     start rpmb_mock_system
 
 on post-fs-data && \
-    property:trusty_vm_system_nonsecure.ready=1 && \
+    property:trusty.security_vm.nonsecure_vm_ready=1 && \
     property:storageproxyd_system.trusty_ipc_dev=*
     # file contexts secure_storage_system_file
     mkdir /data/secure_storage_system 0770 root system

From 5fd1be1a5a90f4e53d6e7f6bd8562d1940271773 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Wed, 14 Aug 2024 02:54:40 +0000
Subject: [PATCH 1204/1487] Revert^4 "Set block device as RO/RW before mount"

This reverts commit 1df3536b955fd4c0ee4c7b760beea29c1a1bdec5.

Previous land got reverted because of selinux denial, which is
already taken care of in aosp/3314877

Reason for revert: b/349507086

Change-Id: Id642b4d8726c72f324e369d8506c78eacea331e3
---
 fs_mgr/fs_mgr.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 5156754a8538..ea2e3a8c754b 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -826,6 +826,9 @@ static int __mount(const std::string& source, const std::string& target, const F
     if (read_only) {
         mountflags |= MS_RDONLY;
     }
+    if (!fs_mgr_set_blk_ro(source, read_only)) {
+        PLOG(ERROR) << "Failed to set " << source << " as " << (read_only ? "RO" : "RW");
+    }
     int ret = 0;
     int save_errno = 0;
     int gc_allowance = 0;
@@ -880,9 +883,6 @@ static int __mount(const std::string& source, const std::string& target, const F
     }
     PINFO << __FUNCTION__ << "(source=" << source << source_missing << ",target=" << target
           << target_missing << ",type=" << entry.fs_type << ")=" << ret;
-    if ((ret == 0) && (mountflags & MS_RDONLY) != 0) {
-        fs_mgr_set_blk_ro(source);
-    }
     if (ret == 0) {
         android::base::SetProperty("ro.boottime.init.mount." + Basename(target),
                                    std::to_string(t.duration().count()));

From e7f1d41237f2504a0aeb8bcf62c8954b48f282c5 Mon Sep 17 00:00:00 2001
From: terryguan <terryguan@google.com>
Date: Tue, 29 Oct 2024 13:20:46 -0700
Subject: [PATCH 1205/1487] read() can return fewer bytes than requested

Sometimes read returns fewer bytes than requested. read() only read at
most 0x7ffff000 bytes.

Bug: 376247649
Test: manual, make mkbootfs, mkbootfs out/target/product../VENDOR_BOOT
Change-Id: I8cbbae40c5f5c6c54d19bf77e9a801ed3390ed48
---
 mkbootfs/mkbootfs.cpp | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/mkbootfs/mkbootfs.cpp b/mkbootfs/mkbootfs.cpp
index 65cf497acb65..a45c6a20a064 100644
--- a/mkbootfs/mkbootfs.cpp
+++ b/mkbootfs/mkbootfs.cpp
@@ -19,6 +19,9 @@
 #include <private/android_filesystem_config.h>
 #include <private/fs_config.h>
 
+#include <android-base/file.h>
+#include <string>
+
 /* NOTES
 **
 ** - see https://www.kernel.org/doc/Documentation/early-userspace/buffer-format.txt
@@ -212,20 +215,12 @@ static void _archive(char *in, char *out, int ilen, int olen)
     if(lstat(in, &s)) err(1, "could not stat '%s'", in);
 
     if(S_ISREG(s.st_mode)){
-        int fd = open(in, O_RDONLY);
-        if(fd < 0) err(1, "cannot open '%s' for read", in);
-
-        char* tmp = (char*) malloc(s.st_size);
-        if(tmp == 0) errx(1, "cannot allocate %zd bytes", s.st_size);
-
-        if(read(fd, tmp, s.st_size) != s.st_size) {
-            err(1, "cannot read %zd bytes", s.st_size);
+        std::string content;
+        if (!android::base::ReadFileToString(in, &content)) {
+            err(1, "cannot read '%s'", in);
         }
 
-        _eject(&s, out, olen, tmp, s.st_size);
-
-        free(tmp);
-        close(fd);
+        _eject(&s, out, olen, content.data(), content.size());
     } else if(S_ISDIR(s.st_mode)) {
         _eject(&s, out, olen, 0, 0);
         _archive_dir(in, out, ilen, olen);

From 39a1730a82a6517f2c4e2ee34edb0ac83bbbb58a Mon Sep 17 00:00:00 2001
From: Peter Collingbourne <pcc@google.com>
Date: Thu, 7 Mar 2024 17:50:10 -0800
Subject: [PATCH 1206/1487] Make pbtombstone a host tool.

This is preparation for the next patch, which adds host-side
symbolization capabilities to pbtombstone.

Bug: 328531087
Change-Id: Id5813ae6b121af784643b1ed76084e49fdca118b
---
 debuggerd/Android.bp                          |  16 +--
 debuggerd/debuggerd_test.cpp                  |   3 +-
 .../include/libdebuggerd/tombstone.h          |   4 -
 .../libdebuggerd/tombstone_proto_to_text.h    |  26 +++++
 .../include/libdebuggerd/utility.h            |   7 --
 .../include/libdebuggerd/utility_host.h       |  31 ++++++
 debuggerd/libdebuggerd/scudo.cpp              |   1 +
 .../test/tombstone_proto_to_text_test.cpp     |   1 +
 debuggerd/libdebuggerd/tombstone.cpp          |   1 +
 debuggerd/libdebuggerd/tombstone_proto.cpp    |   1 +
 .../libdebuggerd/tombstone_proto_to_text.cpp  |  39 +++----
 debuggerd/libdebuggerd/utility.cpp            |   1 +
 debuggerd/libdebuggerd/utility_host.cpp       | 101 ++++++++++++++++++
 debuggerd/pbtombstone.cpp                     |   2 +-
 debuggerd/proto/Android.bp                    |   1 +
 15 files changed, 186 insertions(+), 49 deletions(-)
 create mode 100644 debuggerd/libdebuggerd/include/libdebuggerd/tombstone_proto_to_text.h
 create mode 100644 debuggerd/libdebuggerd/include/libdebuggerd/utility_host.h
 create mode 100644 debuggerd/libdebuggerd/utility_host.cpp

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index c365cac523cc..d4dc9a340ad3 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -200,22 +200,18 @@ cc_library {
     ramdisk_available: true,
     recovery_available: true,
     vendor_ramdisk_available: true,
+    host_supported: true,
 
     local_include_dirs: ["libdebuggerd/include"],
     export_include_dirs: ["libdebuggerd/include"],
 
     srcs: [
         "libdebuggerd/tombstone_proto_to_text.cpp",
-    ],
-
-    header_libs: [
-        "bionic_libc_platform_headers",
+        "libdebuggerd/utility_host.cpp",
     ],
 
     static_libs: [
         "libbase",
-        "liblog_for_runtime_apex",
-        "libunwindstack",
     ],
 
     whole_static_libs: [
@@ -223,6 +219,10 @@ cc_library {
         "libprotobuf-cpp-lite",
     ],
 
+    shared_libs: [
+        "liblog",
+    ],
+
     apex_available: [
         "//apex_available:platform",
         "com.android.runtime",
@@ -331,15 +331,15 @@ cc_library_static {
 
 cc_binary {
     name: "pbtombstone",
+    host_supported: true,
     defaults: ["debuggerd_defaults"],
     srcs: ["pbtombstone.cpp"],
     static_libs: [
         "libbase",
-        "libdebuggerd",
+        "libdebuggerd_tombstone_proto_to_text",
         "liblog",
         "libprotobuf-cpp-lite",
         "libtombstone_proto",
-        "libunwindstack",
     ],
 }
 
diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index e33cea5c868b..13c8d70b5041 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -70,6 +70,7 @@
 #include "crash_test.h"
 #include "debuggerd/handler.h"
 #include "gtest/gtest.h"
+#include "libdebuggerd/utility_host.h"
 #include "protocol.h"
 #include "tombstoned/tombstoned.h"
 #include "util.h"
@@ -741,8 +742,6 @@ TEST_F(CrasherTest, mte_multiple_causes) {
 }
 
 #if defined(__aarch64__)
-constexpr size_t kTagGranuleSize = 16;
-
 static uintptr_t CreateTagMapping() {
   // Some of the MTE tag dump tests assert that there is an inaccessible page to the left and right
   // of the PROT_MTE page, so map three pages and set the two guard pages to PROT_NONE.
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
index 074b0957a91c..39989c3a3c82 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone.h
@@ -67,10 +67,6 @@ void engrave_tombstone_proto(Tombstone* tombstone, unwindstack::AndroidUnwinder*
                              const Architecture* guest_arch,
                              unwindstack::AndroidUnwinder* guest_unwinder);
 
-bool tombstone_proto_to_text(
-    const Tombstone& tombstone,
-    std::function<void(const std::string& line, bool should_log)> callback);
-
 void fill_in_backtrace_frame(BacktraceFrame* f, const unwindstack::FrameData& frame);
 void set_human_readable_cause(Cause* cause, uint64_t fault_addr);
 #if defined(__aarch64__)
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone_proto_to_text.h b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone_proto_to_text.h
new file mode 100644
index 000000000000..515a15f0a92b
--- /dev/null
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone_proto_to_text.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <functional>
+#include <string>
+
+class Tombstone;
+
+bool tombstone_proto_to_text(
+    const Tombstone& tombstone,
+    std::function<void(const std::string& line, bool should_log)> callback);
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/utility.h b/debuggerd/libdebuggerd/include/libdebuggerd/utility.h
index 26c2cd44a85f..b86c13d0806a 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/utility.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/utility.h
@@ -91,10 +91,3 @@ bool signal_has_si_addr(const siginfo_t*);
 void get_signal_sender(char* buf, size_t n, const siginfo_t*);
 const char* get_signame(const siginfo_t*);
 const char* get_sigcode(const siginfo_t*);
-
-// Number of bytes per MTE granule.
-constexpr size_t kTagGranuleSize = 16;
-
-// Number of rows and columns to display in an MTE tag dump.
-constexpr size_t kNumTagColumns = 16;
-constexpr size_t kNumTagRows = 16;
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/utility_host.h b/debuggerd/libdebuggerd/include/libdebuggerd/utility_host.h
new file mode 100644
index 000000000000..43fb8bdc1687
--- /dev/null
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/utility_host.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2024, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+#include <stddef.h>
+
+std::string describe_tagged_addr_ctrl(long ctrl);
+std::string describe_pac_enabled_keys(long keys);
+
+// Number of bytes per MTE granule.
+constexpr size_t kTagGranuleSize = 16;
+
+// Number of rows and columns to display in an MTE tag dump.
+constexpr size_t kNumTagColumns = 16;
+constexpr size_t kNumTagRows = 16;
diff --git a/debuggerd/libdebuggerd/scudo.cpp b/debuggerd/libdebuggerd/scudo.cpp
index 4ee87c841ccb..71d5fcfa73ba 100644
--- a/debuggerd/libdebuggerd/scudo.cpp
+++ b/debuggerd/libdebuggerd/scudo.cpp
@@ -18,6 +18,7 @@
 
 #include "libdebuggerd/scudo.h"
 #include "libdebuggerd/tombstone.h"
+#include "libdebuggerd/utility_host.h"
 
 #include "unwindstack/AndroidUnwinder.h"
 #include "unwindstack/Memory.h"
diff --git a/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
index 4fd26430187e..3fdb71d48f99 100644
--- a/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
+++ b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
@@ -22,6 +22,7 @@
 #include <android-base/test_utils.h>
 
 #include "libdebuggerd/tombstone.h"
+#include "libdebuggerd/tombstone_proto_to_text.h"
 #include "tombstone.pb.h"
 
 using CallbackType = std::function<void(const std::string& line, bool should_log)>;
diff --git a/debuggerd/libdebuggerd/tombstone.cpp b/debuggerd/libdebuggerd/tombstone.cpp
index 0ce55738a2a4..d483b9889181 100644
--- a/debuggerd/libdebuggerd/tombstone.cpp
+++ b/debuggerd/libdebuggerd/tombstone.cpp
@@ -17,6 +17,7 @@
 #define LOG_TAG "DEBUG"
 
 #include "libdebuggerd/tombstone.h"
+#include "libdebuggerd/tombstone_proto_to_text.h"
 
 #include <errno.h>
 #include <signal.h>
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index ed4fd5369899..d59358c65f4f 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -69,6 +69,7 @@
 
 #include "libdebuggerd/open_files_list.h"
 #include "libdebuggerd/utility.h"
+#include "libdebuggerd/utility_host.h"
 #include "util.h"
 
 #include "tombstone.pb.h"
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index c3f94700f43b..611e237b46d7 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 
-#include <libdebuggerd/tombstone.h>
+#include <libdebuggerd/tombstone_proto_to_text.h>
+#include <libdebuggerd/utility_host.h>
 
 #include <inttypes.h>
 
@@ -30,8 +31,6 @@
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
-#include <bionic/macros.h>
-#include <sys/prctl.h>
 
 #include "tombstone.pb.h"
 
@@ -57,28 +56,6 @@ static std::string describe_end(long value, std::string& desc) {
   return desc.empty() ? "" : " (" + desc.substr(2) + ")";
 }
 
-static std::string describe_tagged_addr_ctrl(long value) {
-  std::string desc;
-  DESCRIBE_FLAG(PR_TAGGED_ADDR_ENABLE);
-  DESCRIBE_FLAG(PR_MTE_TCF_SYNC);
-  DESCRIBE_FLAG(PR_MTE_TCF_ASYNC);
-  if (value & PR_MTE_TAG_MASK) {
-    desc += StringPrintf(", mask 0x%04lx", (value & PR_MTE_TAG_MASK) >> PR_MTE_TAG_SHIFT);
-    value &= ~PR_MTE_TAG_MASK;
-  }
-  return describe_end(value, desc);
-}
-
-static std::string describe_pac_enabled_keys(long value) {
-  std::string desc;
-  DESCRIBE_FLAG(PR_PAC_APIAKEY);
-  DESCRIBE_FLAG(PR_PAC_APIBKEY);
-  DESCRIBE_FLAG(PR_PAC_APDAKEY);
-  DESCRIBE_FLAG(PR_PAC_APDBKEY);
-  DESCRIBE_FLAG(PR_PAC_APGAKEY);
-  return describe_end(value, desc);
-}
-
 static const char* abi_string(const Architecture& arch) {
   switch (arch) {
     case Architecture::ARM32:
@@ -113,6 +90,13 @@ static int pointer_width(const Tombstone& tombstone) {
   }
 }
 
+static uint64_t untag_address(Architecture arch, uint64_t addr) {
+  if (arch == Architecture::ARM64) {
+    return addr & ((1ULL << 56) - 1);
+  }
+  return addr;
+}
+
 static void print_thread_header(CallbackType callback, const Tombstone& tombstone,
                                 const Thread& thread, bool should_log) {
   const char* process_name = "<unknown>";
@@ -321,7 +305,8 @@ static void print_tag_dump(CallbackType callback, const Tombstone& tombstone) {
 
   size_t tag_index = 0;
   size_t num_tags = tags.length();
-  uintptr_t fault_granule = untag_address(signal.fault_address()) & ~(kTagGranuleSize - 1);
+  uintptr_t fault_granule =
+      untag_address(tombstone.arch(), signal.fault_address()) & ~(kTagGranuleSize - 1);
   for (size_t row = 0; tag_index < num_tags; ++row) {
     uintptr_t row_addr =
         (memory_dump.begin_address() + row * kNumTagColumns * kTagGranuleSize) & kRowStartMask;
@@ -369,7 +354,7 @@ static void print_memory_maps(CallbackType callback, const Tombstone& tombstone)
 
   const Signal& signal_info = tombstone.signal_info();
   bool has_fault_address = signal_info.has_fault_address();
-  uint64_t fault_address = untag_address(signal_info.fault_address());
+  uint64_t fault_address = untag_address(tombstone.arch(), signal_info.fault_address());
   bool preamble_printed = false;
   bool printed_fault_address_marker = false;
   for (const auto& map : tombstone.memory_mappings()) {
diff --git a/debuggerd/libdebuggerd/utility.cpp b/debuggerd/libdebuggerd/utility.cpp
index 742ac7c2701a..b5a93b7db503 100644
--- a/debuggerd/libdebuggerd/utility.cpp
+++ b/debuggerd/libdebuggerd/utility.cpp
@@ -17,6 +17,7 @@
 #define LOG_TAG "DEBUG"
 
 #include "libdebuggerd/utility.h"
+#include "libdebuggerd/utility_host.h"
 
 #include <errno.h>
 #include <signal.h>
diff --git a/debuggerd/libdebuggerd/utility_host.cpp b/debuggerd/libdebuggerd/utility_host.cpp
new file mode 100644
index 000000000000..72a560cfee73
--- /dev/null
+++ b/debuggerd/libdebuggerd/utility_host.cpp
@@ -0,0 +1,101 @@
+/*
+ * Copyright 2024, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "libdebuggerd/utility_host.h"
+
+#include <sys/prctl.h>
+
+#include <string>
+
+#include <android-base/stringprintf.h>
+
+using android::base::StringPrintf;
+
+#ifndef PR_MTE_TAG_SHIFT
+#define PR_MTE_TAG_SHIFT 3
+#endif
+
+#ifndef PR_MTE_TAG_MASK
+#define PR_MTE_TAG_MASK (0xffffUL << PR_MTE_TAG_SHIFT)
+#endif
+
+#ifndef PR_MTE_TCF_ASYNC
+#define PR_MTE_TCF_ASYNC (1UL << 2)
+#endif
+
+#ifndef PR_MTE_TCF_SYNC
+#define PR_MTE_TCF_SYNC (1UL << 1)
+#endif
+
+#ifndef PR_PAC_APIAKEY
+#define PR_PAC_APIAKEY (1UL << 0)
+#endif
+
+#ifndef PR_PAC_APIBKEY
+#define PR_PAC_APIBKEY (1UL << 1)
+#endif
+
+#ifndef PR_PAC_APDAKEY
+#define PR_PAC_APDAKEY (1UL << 2)
+#endif
+
+#ifndef PR_PAC_APDBKEY
+#define PR_PAC_APDBKEY (1UL << 3)
+#endif
+
+#ifndef PR_PAC_APGAKEY
+#define PR_PAC_APGAKEY (1UL << 4)
+#endif
+
+#ifndef PR_TAGGED_ADDR_ENABLE
+#define PR_TAGGED_ADDR_ENABLE (1UL << 0)
+#endif
+
+#define DESCRIBE_FLAG(flag) \
+  if (value & flag) {       \
+    desc += ", ";           \
+    desc += #flag;          \
+    value &= ~flag;         \
+  }
+
+static std::string describe_end(long value, std::string& desc) {
+  if (value) {
+    desc += StringPrintf(", unknown 0x%lx", value);
+  }
+  return desc.empty() ? "" : " (" + desc.substr(2) + ")";
+}
+
+std::string describe_tagged_addr_ctrl(long value) {
+  std::string desc;
+  DESCRIBE_FLAG(PR_TAGGED_ADDR_ENABLE);
+  DESCRIBE_FLAG(PR_MTE_TCF_SYNC);
+  DESCRIBE_FLAG(PR_MTE_TCF_ASYNC);
+  if (value & PR_MTE_TAG_MASK) {
+    desc += StringPrintf(", mask 0x%04lx", (value & PR_MTE_TAG_MASK) >> PR_MTE_TAG_SHIFT);
+    value &= ~PR_MTE_TAG_MASK;
+  }
+  return describe_end(value, desc);
+}
+
+std::string describe_pac_enabled_keys(long value) {
+  std::string desc;
+  DESCRIBE_FLAG(PR_PAC_APIAKEY);
+  DESCRIBE_FLAG(PR_PAC_APIBKEY);
+  DESCRIBE_FLAG(PR_PAC_APDAKEY);
+  DESCRIBE_FLAG(PR_PAC_APDBKEY);
+  DESCRIBE_FLAG(PR_PAC_APGAKEY);
+  return describe_end(value, desc);
+}
diff --git a/debuggerd/pbtombstone.cpp b/debuggerd/pbtombstone.cpp
index 7527e31e1ffd..dcb7c6c214b5 100644
--- a/debuggerd/pbtombstone.cpp
+++ b/debuggerd/pbtombstone.cpp
@@ -20,7 +20,7 @@
 #include <unistd.h>
 
 #include <android-base/unique_fd.h>
-#include <libdebuggerd/tombstone.h>
+#include <libdebuggerd/tombstone_proto_to_text.h>
 
 #include "tombstone.pb.h"
 
diff --git a/debuggerd/proto/Android.bp b/debuggerd/proto/Android.bp
index 7b9e780ccf0c..70deb3cdda48 100644
--- a/debuggerd/proto/Android.bp
+++ b/debuggerd/proto/Android.bp
@@ -38,6 +38,7 @@ cc_library_static {
     ramdisk_available: true,
     recovery_available: true,
     vendor_ramdisk_available: true,
+    host_supported: true,
 }
 
 java_library_static {

From cf9f0870e4fa9504cd2e124456cdb8bdd44dd49f Mon Sep 17 00:00:00 2001
From: Peter Collingbourne <pcc@google.com>
Date: Thu, 7 Mar 2024 17:56:14 -0800
Subject: [PATCH 1207/1487] Add support for tombstone symbolization to
 pbtombstone.

This patch teaches pbtombstone to use llvm-symbolizer to symbolize
stack traces and augment the protobuf tombstones with the symbol
information, before printing tombstones with the symbolized stack
traces included.

The main advantage of adding this information to the tombstone
as opposed to having developers use the stack tool is that stack
does not print all of the information in the original tombstone,
which means that both reports may be required to understand a crash.
Furthermore, stack traces printed by stack are not correlated with
the stack traces in the tombstone, making the report harder to read,
especially with GWP-ASan and MTE which may produce multiple stack
traces for the crashing thread.

Although we could teach stack to print more information, this would
continue to be fragile because stack relies on parsing textual
tombstones. Switching stack to read proto tombstones would be
tantamount to a full rewrite and would require duplicating the C++
proto-to-text logic that we already have in Python. It seems better
to reuse the C++ code for the proto-based symbolization tool.

llvm-symbolizer will look up the symbol files by build ID using a
.build-id directory following the standard here:
https://fedoraproject.org/wiki/RolandMcGrath/BuildID

It will look for .build-id directories under paths specified with
--debug-file-directory, which pbtombstone will pass through to
llvm-symbolizer using its own --debug-file-directory flag. The
intent is that tools for platform developers will pass the flag
--debug-file-directory $ANDROID_PRODUCT_OUT/symbols to pbtombstone.
Soong will start creating .build-id under symbols after a corresponding
Soong CL lands.

Bug: 328531087
Change-Id: Ia4676821cf980c69487cf11aefa2a02dc0c1626f
---
 debuggerd/Android.bp                          |   5 +-
 .../libdebuggerd/tombstone_proto_to_text.h    |   4 +-
 .../test/tombstone_proto_to_text_test.cpp     |  16 +-
 debuggerd/libdebuggerd/tombstone.cpp          |   9 +-
 .../libdebuggerd/tombstone_proto_to_text.cpp  |  47 ++---
 debuggerd/pbtombstone.cpp                     |  42 ++++-
 debuggerd/tombstone_symbolize.cpp             | 160 ++++++++++++++++++
 debuggerd/tombstone_symbolize.h               |  42 +++++
 8 files changed, 291 insertions(+), 34 deletions(-)
 create mode 100644 debuggerd/tombstone_symbolize.cpp
 create mode 100644 debuggerd/tombstone_symbolize.h

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index d4dc9a340ad3..3257a2c50710 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -333,7 +333,10 @@ cc_binary {
     name: "pbtombstone",
     host_supported: true,
     defaults: ["debuggerd_defaults"],
-    srcs: ["pbtombstone.cpp"],
+    srcs: [
+        "pbtombstone.cpp",
+        "tombstone_symbolize.cpp",
+    ],
     static_libs: [
         "libbase",
         "libdebuggerd_tombstone_proto_to_text",
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone_proto_to_text.h b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone_proto_to_text.h
index 515a15f0a92b..2de9723447a4 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/tombstone_proto_to_text.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/tombstone_proto_to_text.h
@@ -19,8 +19,10 @@
 #include <functional>
 #include <string>
 
+class BacktraceFrame;
 class Tombstone;
 
 bool tombstone_proto_to_text(
     const Tombstone& tombstone,
-    std::function<void(const std::string& line, bool should_log)> callback);
+    std::function<void(const std::string& line, bool should_log)> callback,
+    std::function<void(const BacktraceFrame& frame)> symbolize);
diff --git a/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
index 3fdb71d48f99..aad209a063a8 100644
--- a/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
+++ b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
@@ -61,12 +61,16 @@ class TombstoneProtoToTextTest : public ::testing::Test {
 
   void ProtoToString() {
     text_ = "";
-    EXPECT_TRUE(
-        tombstone_proto_to_text(*tombstone_, [this](const std::string& line, bool should_log) {
+    EXPECT_TRUE(tombstone_proto_to_text(
+        *tombstone_,
+        [this](const std::string& line, bool should_log) {
           if (should_log) {
             text_ += "LOG ";
           }
           text_ += line + '\n';
+        },
+        [&](const BacktraceFrame& frame) {
+          text_ += "SYMBOLIZE " + frame.build_id() + " " + std::to_string(frame.pc()) + "\n";
         }));
   }
 
@@ -163,3 +167,11 @@ TEST_F(TombstoneProtoToTextTest, stack_record) {
   EXPECT_MATCH(text_, "stack_record fp:0x1 tag:0xb pc:foo\\.so\\+0x567 \\(BuildId: ABC123\\)");
   EXPECT_MATCH(text_, "stack_record fp:0x2 tag:0xc pc:bar\\.so\\+0x678");
 }
+
+TEST_F(TombstoneProtoToTextTest, symbolize) {
+  BacktraceFrame* frame = main_thread_->add_current_backtrace();
+  frame->set_pc(12345);
+  frame->set_build_id("0123456789abcdef");
+  ProtoToString();
+  EXPECT_MATCH(text_, "\\(BuildId: 0123456789abcdef\\)\\nSYMBOLIZE 0123456789abcdef 12345\\n");
+}
diff --git a/debuggerd/libdebuggerd/tombstone.cpp b/debuggerd/libdebuggerd/tombstone.cpp
index d483b9889181..30c6fe4c50c2 100644
--- a/debuggerd/libdebuggerd/tombstone.cpp
+++ b/debuggerd/libdebuggerd/tombstone.cpp
@@ -146,7 +146,10 @@ void engrave_tombstone(unique_fd output_fd, unique_fd proto_fd,
   log.tfd = output_fd.get();
   log.amfd_data = amfd_data;
 
-  tombstone_proto_to_text(tombstone, [&log](const std::string& line, bool should_log) {
-    _LOG(&log, should_log ? logtype::HEADER : logtype::LOGS, "%s\n", line.c_str());
-  });
+  tombstone_proto_to_text(
+      tombstone,
+      [&log](const std::string& line, bool should_log) {
+        _LOG(&log, should_log ? logtype::HEADER : logtype::LOGS, "%s\n", line.c_str());
+      },
+      [](const BacktraceFrame&) {});
 }
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index 611e237b46d7..fedafc0c33fb 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -41,6 +41,7 @@ using android::base::StringPrintf;
 #define CBL(...) CB(true, __VA_ARGS__)
 #define CBS(...) CB(false, __VA_ARGS__)
 using CallbackType = std::function<void(const std::string& line, bool should_log)>;
+using SymbolizeCallbackType = std::function<void(const BacktraceFrame& frame)>;
 
 #define DESCRIBE_FLAG(flag) \
   if (value & flag) {       \
@@ -184,7 +185,8 @@ static void print_thread_registers(CallbackType callback, const Tombstone& tombs
   print_register_row(callback, word_size, special_row, should_log);
 }
 
-static void print_backtrace(CallbackType callback, const Tombstone& tombstone,
+static void print_backtrace(CallbackType callback, SymbolizeCallbackType symbolize,
+                            const Tombstone& tombstone,
                             const google::protobuf::RepeatedPtrField<BacktraceFrame>& backtrace,
                             bool should_log) {
   int index = 0;
@@ -209,11 +211,14 @@ static void print_backtrace(CallbackType callback, const Tombstone& tombstone,
     }
     line += function + build_id;
     CB(should_log, "%s", line.c_str());
+
+    symbolize(frame);
   }
 }
 
-static void print_thread_backtrace(CallbackType callback, const Tombstone& tombstone,
-                                   const Thread& thread, bool should_log) {
+static void print_thread_backtrace(CallbackType callback, SymbolizeCallbackType symbolize,
+                                   const Tombstone& tombstone, const Thread& thread,
+                                   bool should_log) {
   CBS("");
   CB(should_log, "%d total frames", thread.current_backtrace().size());
   CB(should_log, "backtrace:");
@@ -221,7 +226,7 @@ static void print_thread_backtrace(CallbackType callback, const Tombstone& tombs
     CB(should_log, "  NOTE: %s",
        android::base::Join(thread.backtrace_note(), "\n  NOTE: ").c_str());
   }
-  print_backtrace(callback, tombstone, thread.current_backtrace(), should_log);
+  print_backtrace(callback, symbolize, tombstone, thread.current_backtrace(), should_log);
 }
 
 static void print_thread_memory_dump(CallbackType callback, const Tombstone& tombstone,
@@ -274,10 +279,11 @@ static void print_thread_memory_dump(CallbackType callback, const Tombstone& tom
   }
 }
 
-static void print_thread(CallbackType callback, const Tombstone& tombstone, const Thread& thread) {
+static void print_thread(CallbackType callback, SymbolizeCallbackType symbolize,
+                         const Tombstone& tombstone, const Thread& thread) {
   print_thread_header(callback, tombstone, thread, false);
   print_thread_registers(callback, tombstone, thread, false);
-  print_thread_backtrace(callback, tombstone, thread, false);
+  print_thread_backtrace(callback, symbolize, tombstone, thread, false);
   print_thread_memory_dump(callback, tombstone, thread);
 }
 
@@ -433,8 +439,8 @@ static std::string oct_encode(const std::string& data) {
   return oct_encoded;
 }
 
-static void print_main_thread(CallbackType callback, const Tombstone& tombstone,
-                              const Thread& thread) {
+static void print_main_thread(CallbackType callback, SymbolizeCallbackType symbolize,
+                              const Tombstone& tombstone, const Thread& thread) {
   print_thread_header(callback, tombstone, thread, true);
 
   const Signal& signal_info = tombstone.signal_info();
@@ -488,7 +494,7 @@ static void print_main_thread(CallbackType callback, const Tombstone& tombstone,
     CBL("      in this process. The stack trace below is the first system call or context");
     CBL("      switch that was executed after the memory corruption happened.");
   }
-  print_thread_backtrace(callback, tombstone, thread, true);
+  print_thread_backtrace(callback, symbolize, tombstone, thread, true);
 
   if (tombstone.causes_size() > 1) {
     CBS("");
@@ -521,13 +527,13 @@ static void print_main_thread(CallbackType callback, const Tombstone& tombstone,
       if (heap_object.deallocation_backtrace_size() != 0) {
         CBS("");
         CBL("deallocated by thread %" PRIu64 ":", heap_object.deallocation_tid());
-        print_backtrace(callback, tombstone, heap_object.deallocation_backtrace(), true);
+        print_backtrace(callback, symbolize, tombstone, heap_object.deallocation_backtrace(), true);
       }
 
       if (heap_object.allocation_backtrace_size() != 0) {
         CBS("");
         CBL("allocated by thread %" PRIu64 ":", heap_object.allocation_tid());
-        print_backtrace(callback, tombstone, heap_object.allocation_backtrace(), true);
+        print_backtrace(callback, symbolize, tombstone, heap_object.allocation_backtrace(), true);
       }
     }
   }
@@ -576,8 +582,9 @@ void print_logs(CallbackType callback, const Tombstone& tombstone, int tail) {
   }
 }
 
-static void print_guest_thread(CallbackType callback, const Tombstone& tombstone,
-                               const Thread& guest_thread, pid_t tid, bool should_log) {
+static void print_guest_thread(CallbackType callback, SymbolizeCallbackType symbolize,
+                               const Tombstone& tombstone, const Thread& guest_thread, pid_t tid,
+                               bool should_log) {
   CBS("--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---");
   CBS("Guest thread information for tid: %d", tid);
   print_thread_registers(callback, tombstone, guest_thread, should_log);
@@ -585,12 +592,13 @@ static void print_guest_thread(CallbackType callback, const Tombstone& tombstone
   CBS("");
   CB(true, "%d total frames", guest_thread.current_backtrace().size());
   CB(true, "backtrace:");
-  print_backtrace(callback, tombstone, guest_thread.current_backtrace(), should_log);
+  print_backtrace(callback, symbolize, tombstone, guest_thread.current_backtrace(), should_log);
 
   print_thread_memory_dump(callback, tombstone, guest_thread);
 }
 
-bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback) {
+bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback,
+                             SymbolizeCallbackType symbolize) {
   CBL("*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***");
   CBL("Build fingerprint: '%s'", tombstone.build_fingerprint().c_str());
   CBL("Revision: '%s'", tombstone.revision().c_str());
@@ -618,14 +626,15 @@ bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback)
 
   const auto& main_thread = main_thread_it->second;
 
-  print_main_thread(callback, tombstone, main_thread);
+  print_main_thread(callback, symbolize, tombstone, main_thread);
 
   print_logs(callback, tombstone, 50);
 
   const auto& guest_threads = tombstone.guest_threads();
   auto main_guest_thread_it = guest_threads.find(tombstone.tid());
   if (main_guest_thread_it != threads.end()) {
-    print_guest_thread(callback, tombstone, main_guest_thread_it->second, tombstone.tid(), true);
+    print_guest_thread(callback, symbolize, tombstone, main_guest_thread_it->second,
+                       tombstone.tid(), true);
   }
 
   // protobuf's map is unordered, so sort the keys first.
@@ -638,10 +647,10 @@ bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback)
 
   for (const auto& tid : thread_ids) {
     CBS("--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---");
-    print_thread(callback, tombstone, threads.find(tid)->second);
+    print_thread(callback, symbolize, tombstone, threads.find(tid)->second);
     auto guest_thread_it = guest_threads.find(tid);
     if (guest_thread_it != guest_threads.end()) {
-      print_guest_thread(callback, tombstone, guest_thread_it->second, tid, false);
+      print_guest_thread(callback, symbolize, tombstone, guest_thread_it->second, tid, false);
     }
   }
 
diff --git a/debuggerd/pbtombstone.cpp b/debuggerd/pbtombstone.cpp
index dcb7c6c214b5..0902b386f50e 100644
--- a/debuggerd/pbtombstone.cpp
+++ b/debuggerd/pbtombstone.cpp
@@ -16,32 +16,55 @@
 
 #include <err.h>
 #include <fcntl.h>
+#include <getopt.h>
 #include <stdio.h>
 #include <unistd.h>
 
+#include <string>
+#include <vector>
+
 #include <android-base/unique_fd.h>
 #include <libdebuggerd/tombstone_proto_to_text.h>
 
 #include "tombstone.pb.h"
+#include "tombstone_symbolize.h"
 
 using android::base::unique_fd;
 
 [[noreturn]] void usage(bool error) {
-  fprintf(stderr, "usage: pbtombstone TOMBSTONE.PB\n");
+  fprintf(stderr, "usage: pbtombstone [OPTION] TOMBSTONE.PB\n");
   fprintf(stderr, "Convert a protobuf tombstone to text.\n");
+  fprintf(stderr, "Arguments:\n");
+  fprintf(stderr, "  -h, --help                   print this message\n");
+  fprintf(stderr, "  --debug-file-directory PATH  specify the path to a symbols directory\n");
   exit(error);
 }
 
-int main(int argc, const char* argv[]) {
-  if (argc != 2) {
-    usage(true);
+int main(int argc, char* argv[]) {
+  std::vector<std::string> debug_file_directories;
+  static struct option long_options[] = {
+      {"debug-file-directory", required_argument, 0, 0},
+      {"help", no_argument, 0, 'h'},
+      {},
+  };
+  int c;
+  while ((c = getopt_long(argc, argv, "h", long_options, 0)) != -1) {
+    switch (c) {
+      case 0:
+        debug_file_directories.push_back(optarg);
+        break;
+
+      case 'h':
+        usage(false);
+        break;
+    }
   }
 
-  if (strcmp("-h", argv[1]) == 0 || strcmp("--help", argv[1]) == 0) {
-    usage(false);
+  if (optind != argc-1) {
+    usage(true);
   }
 
-  unique_fd fd(open(argv[1], O_RDONLY | O_CLOEXEC));
+  unique_fd fd(open(argv[optind], O_RDONLY | O_CLOEXEC));
   if (fd == -1) {
     err(1, "failed to open tombstone '%s'", argv[1]);
   }
@@ -51,8 +74,11 @@ int main(int argc, const char* argv[]) {
     err(1, "failed to parse tombstone");
   }
 
+  Symbolizer sym;
+  sym.Start(debug_file_directories);
   bool result = tombstone_proto_to_text(
-      tombstone, [](const std::string& line, bool) { printf("%s\n", line.c_str()); });
+      tombstone, [](const std::string& line, bool) { printf("%s\n", line.c_str()); },
+      [&](const BacktraceFrame& frame) { symbolize_backtrace_frame(frame, sym); });
 
   if (!result) {
     errx(1, "tombstone was malformed");
diff --git a/debuggerd/tombstone_symbolize.cpp b/debuggerd/tombstone_symbolize.cpp
new file mode 100644
index 000000000000..07735d0ee25f
--- /dev/null
+++ b/debuggerd/tombstone_symbolize.cpp
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tombstone_symbolize.h"
+
+#include <fcntl.h>
+#include <inttypes.h>
+#include <unistd.h>
+
+#include <string>
+#include <vector>
+
+#include "android-base/stringprintf.h"
+#include "android-base/unique_fd.h"
+
+#include "tombstone.pb.h"
+
+using android::base::StringPrintf;
+using android::base::unique_fd;
+
+bool Symbolizer::Start(const std::vector<std::string>& debug_file_directories) {
+  unique_fd parent_in, parent_out, child_in, child_out;
+  if (!Pipe(&parent_in, &child_out) || !Pipe(&child_in, &parent_out)) {
+    return false;
+  }
+
+  std::vector<const char *> args;
+  args.push_back("llvm-symbolizer");
+  for (const std::string &dir : debug_file_directories) {
+    args.push_back("--debug-file-directory");
+    args.push_back(dir.c_str());
+  }
+  args.push_back(0);
+
+  int pid = fork();
+  if (pid == -1) {
+    return false;
+  } else if (pid == 0) {
+    parent_in.reset();
+    parent_out.reset();
+
+    dup2(child_in.get(), STDIN_FILENO);
+    dup2(child_out.get(), STDOUT_FILENO);
+
+    execvp("llvm-symbolizer", const_cast<char *const *>(args.data()));
+
+    fprintf(stderr, "unable to start llvm-symbolizer: %s\n", strerror(errno));
+    _exit(1);
+  } else {
+    child_in.reset();
+    child_out.reset();
+
+    // TODO: Check that llvm-symbolizer started up successfully.
+    // There used to be an easy way to do this, but it was removed in:
+    // https://github.com/llvm/llvm-project/commit/1792852f86dc75efa1f44d46b1a0daf386d64afa
+
+    in_fd = std::move(parent_in);
+    out_fd = std::move(parent_out);
+    return true;
+  }
+}
+
+std::string Symbolizer::read_response() {
+  std::string resp;
+
+  while (resp.size() < 2 || resp[resp.size() - 2] != '\n' || resp[resp.size() - 1] != '\n') {
+    char buf[4096];
+    ssize_t size = read(in_fd, buf, 4096);
+    if (size <= 0) {
+      return "";
+    }
+    resp.append(buf, size);
+  }
+
+  return resp;
+}
+
+std::vector<Symbolizer::Frame> Symbolizer::SymbolizeCode(std::string path, uint64_t rel_pc) {
+  std::string request = StringPrintf("CODE %s 0x%" PRIx64 "\n", path.c_str(), rel_pc);
+  if (write(out_fd, request.c_str(), request.size()) != static_cast<ssize_t>(request.size())) {
+    return {};
+  }
+
+  std::string response = read_response();
+  if (response.empty()) {
+    return {};
+  }
+
+  std::vector<Symbolizer::Frame> frames;
+
+  size_t frame_start = 0;
+  while (frame_start < response.size() - 1) {
+    Symbolizer::Frame frame;
+
+    size_t second_line_start = response.find('\n', frame_start) + 1;
+    if (second_line_start == std::string::npos + 1) {
+      return {};
+    }
+
+    size_t third_line_start = response.find('\n', second_line_start) + 1;
+    if (third_line_start == std::string::npos + 1) {
+      return {};
+    }
+
+    frame.function_name = response.substr(frame_start, second_line_start - frame_start - 1);
+
+    size_t column_number_start = response.rfind(':', third_line_start);
+    if (column_number_start == std::string::npos) {
+      return {};
+    }
+
+    size_t line_number_start = response.rfind(':', column_number_start - 1);
+    if (line_number_start == std::string::npos) {
+      return {};
+    }
+
+    frame.file = response.substr(second_line_start, line_number_start - second_line_start);
+
+    errno = 0;
+    frame.line = strtoull(response.c_str() + line_number_start + 1, 0, 10);
+    frame.column = strtoull(response.c_str() + column_number_start + 1, 0, 10);
+    if (errno != 0) {
+      return {};
+    }
+
+    frames.push_back(frame);
+
+    frame_start = third_line_start;
+  }
+
+  if (frames.size() == 1 && frames[0].file == "??") {
+    return {};
+  }
+
+  return frames;
+}
+
+void symbolize_backtrace_frame(const BacktraceFrame& frame, Symbolizer& sym) {
+  if (frame.build_id().empty()) {
+    return;
+  }
+
+  for (Symbolizer::Frame f : sym.SymbolizeCode("BUILDID:" + frame.build_id(), frame.rel_pc())) {
+    printf("          %s:%" PRId64 ":%" PRId64 " (%s)\n", f.file.c_str(), f.line, f.column,
+           f.function_name.c_str());
+  }
+}
diff --git a/debuggerd/tombstone_symbolize.h b/debuggerd/tombstone_symbolize.h
new file mode 100644
index 000000000000..c22d677eed3b
--- /dev/null
+++ b/debuggerd/tombstone_symbolize.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "android-base/unique_fd.h"
+
+class BacktraceFrame;
+
+class Symbolizer {
+  android::base::unique_fd in_fd, out_fd;
+
+  std::string read_response();
+
+ public:
+  bool Start(const std::vector<std::string>& debug_file_directories);
+
+  struct Frame {
+    std::string function_name, file;
+    uint64_t line, column;
+  };
+
+  std::vector<Frame> SymbolizeCode(std::string path, uint64_t rel_pc);
+};
+
+void symbolize_backtrace_frame(const BacktraceFrame& frame, Symbolizer& sym);

From 5cc1ca1762cc0e4aa955fb50e41fcd810d0641ae Mon Sep 17 00:00:00 2001
From: Konrad Adamczyk <konrada@google.com>
Date: Thu, 31 Oct 2024 08:25:54 +0000
Subject: [PATCH 1208/1487] Revert^3 "init: Look for super partition only on a
 boot device"

This reverts commit 5bfb93678fa26e9763699669e6bbf1c2c6a7478d.

Reason for revert: b/376468452 and trusty boot up on arm64. This CL is causing a lot of troubles (now only on emulator, but may affect more devices in field) and shall be reverted. Desktop team will handle support for selecting single boot source (while having more than one) as part of boot_part_uuid support (at aosp/3318438).

Change-Id: I2804c119631f592d0862f3472ffe18dbb23b17e5
---
 init/block_dev_initializer.cpp |  6 +-----
 init/devices.cpp               | 22 ----------------------
 init/devices.h                 |  1 -
 3 files changed, 1 insertion(+), 28 deletions(-)

diff --git a/init/block_dev_initializer.cpp b/init/block_dev_initializer.cpp
index cabeb01090b0..8f5215856544 100644
--- a/init/block_dev_initializer.cpp
+++ b/init/block_dev_initializer.cpp
@@ -98,11 +98,7 @@ ListenerAction BlockDevInitializer::HandleUevent(const Uevent& uevent,
 
     LOG(VERBOSE) << __PRETTY_FUNCTION__ << ": found partition: " << name;
 
-    // Remove partition from the list only if it was found on boot device
-    if (device_handler_->IsBootDevice(uevent)) {
-        devices->erase(iter);
-    }
-
+    devices->erase(iter);
     device_handler_->HandleUevent(uevent);
     return devices->empty() ? ListenerAction::kStop : ListenerAction::kContinue;
 }
diff --git a/init/devices.cpp b/init/devices.cpp
index 6a3a64dd81f3..f2bb9d27607d 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -188,28 +188,6 @@ void SysfsPermissions::SetPermissions(const std::string& path) const {
     }
 }
 
-bool DeviceHandler::IsBootDevice(const Uevent& uevent) const {
-    std::string device;
-
-    if (FindPlatformDevice(uevent.path, &device)) {
-        // Skip /devices/platform or /devices/ if present
-        static constexpr std::string_view devices_platform_prefix = "/devices/platform/";
-        static constexpr std::string_view devices_prefix = "/devices/";
-
-        if (StartsWith(device, devices_platform_prefix)) {
-            device = device.substr(devices_platform_prefix.length());
-        } else if (StartsWith(device, devices_prefix)) {
-            device = device.substr(devices_prefix.length());
-        }
-    } else if (FindPciDevicePrefix(uevent.path, &device)) {
-    } else if (FindVbdDevicePrefix(uevent.path, &device)) {
-    } else {
-        return false;
-    }
-
-    return boot_devices_.find(device) != boot_devices_.end();
-}
-
 std::string DeviceHandler::GetPartitionNameForDevice(const std::string& query_device) {
     static const auto partition_map = [] {
         std::vector<std::pair<std::string, std::string>> partition_map;
diff --git a/init/devices.h b/init/devices.h
index 4df604d00cef..6da1232595b4 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -133,7 +133,6 @@ class DeviceHandler : public UeventHandler {
     // `androidboot.partition_map=vdb,metadata;vdc,userdata` maps `vdb` to `metadata` and `vdc` to
     // `userdata`.
     static std::string GetPartitionNameForDevice(const std::string& device);
-    bool IsBootDevice(const Uevent& uevent) const;
 
   private:
     void ColdbootDone() override;

From a5560db8cc7d0e61e080b7c4bd7696a0daf3d0f2 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 31 Oct 2024 09:59:19 -0700
Subject: [PATCH 1209/1487] libsnapshot: Add script to test snapshot updates

$time ./system/core/fs_mgr/libsnapshot/apply-update.sh --update-static-partitions

Update completed

real	1m19.850s
user	0m10.319s
sys	0m7.448s

Dynamic parition update only:

$time ./system/core/fs_mgr/libsnapshot/apply-update.sh

Update completed

real	0m19.032s
user	0m10.480s
sys	0m7.462s

Bug: 329255363
Test: apply-update.sh

Change-Id: I2af4fe022e35b2b813ff83e2084d22295b3057dc
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/scripts/apply-update.sh | 77 ++++++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100755 fs_mgr/libsnapshot/scripts/apply-update.sh

diff --git a/fs_mgr/libsnapshot/scripts/apply-update.sh b/fs_mgr/libsnapshot/scripts/apply-update.sh
new file mode 100755
index 000000000000..90b0119a2e5b
--- /dev/null
+++ b/fs_mgr/libsnapshot/scripts/apply-update.sh
@@ -0,0 +1,77 @@
+#!/bin/bash
+
+# This is a debug script to quicky test end-to-end flow
+# of snapshot updates without going through update-engine.
+#
+# Usage:
+#
+#  To update both dynamic and static partitions:
+#
+# ./system/core/fs_mgr/libsnapshot/apply_update.sh [--update-static-partitions] [--wipe]
+#
+# --update-static-partitions: This will update bootloader and static A/B
+# partitions
+# --wipe: Allows data wipe as part of update flow
+#
+#  To update dynamic partitions only (this should be used when static
+#  partitions are present in both the slots):
+#
+#  ./system/core/fs_mgr/libsnapshot/apply_update.sh
+#
+#
+
+rm -f $OUT/*.patch
+
+# Compare images and create snapshot patches. Currently, this
+# just compares two identical images in $OUT. In general, any source
+# and target images could be passed to create snapshot patches. However,
+# care must be taken to ensure source images are already present on the device.
+#
+# create_snapshot is a host side binary. Build it with `m create_snapshot`
+create_snapshot --source=$OUT/system.img --target=$OUT/system.img &
+create_snapshot --source=$OUT/product.img --target=$OUT/product.img &
+create_snapshot --source=$OUT/vendor.img --target=$OUT/vendor.img &
+create_snapshot --source=$OUT/system_ext.img --target=$OUT/system_ext.img &
+create_snapshot --source=$OUT/vendor_dlkm.img --target=$OUT/vendor_dlkm.img &
+create_snapshot --source=$OUT/system_dlkm.img --target=$OUT/system_dlkm.img &
+
+echo "Waiting for snapshot patch creation"
+wait $(jobs -p)
+echo "Snapshot patch creation completed"
+
+mv *.patch $OUT/
+
+adb root
+adb wait-for-device
+adb shell mkdir -p /data/update/
+adb push $OUT/*.patch /data/update/
+
+if [[ "$2" == "--wipe" ]]; then
+  adb shell snapshotctl apply-update /data/update/ -w
+else
+  adb shell snapshotctl apply-update /data/update/
+fi
+
+# Check if the --update-static-partitions option is provided.
+# For quick developer workflow, there is no need to repeatedly
+# apply static partitions.
+if [[ "$1" == "--update-static-partitions" ]]; then
+  adb reboot bootloader
+  sleep 5
+  if [[ "$2" == "--wipe" ]]; then
+      fastboot -w
+  fi
+  fastboot flash bootloader $OUT/bootloader.img
+  sleep 1
+  fastboot reboot bootloader
+  sleep 1
+  fastboot flash radio $OUT/radio.img
+  sleep 1
+  fastboot reboot bootloader
+  sleep 1
+  fastboot flashall --exclude-dynamic-partitions --disable-super-optimization
+else
+  adb reboot
+fi
+
+echo "Update completed"

From de6707df0c0decfeb92a1e73a64d3a610e16d061 Mon Sep 17 00:00:00 2001
From: Liana Kazanova <lkazanova@google.com>
Date: Thu, 31 Oct 2024 18:43:18 +0000
Subject: [PATCH 1210/1487] Revert "Set input thread priority to RT"

This reverts commit 930f77b02c8ba5a7bb8e54653455f9885d90748a.

Reason for revert: DroidMonitor: Potential culprit for http://b/376665573 - verifying through ABTD before revert submission. This is part of the standard investigation process, and does not mean your CL will be reverted.

Change-Id: I9b9914703946f1eb4e40e779aa9cb5154ea108d3
---
 libprocessgroup/profiles/task_profiles.json | 15 +-----
 libprocessgroup/task_profiles.cpp           | 56 ++++++---------------
 2 files changed, 17 insertions(+), 54 deletions(-)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index d61939f296c4..feda3b49c108 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -202,19 +202,6 @@
         }
       ]
     },
-    {
-      "Name": "RealTimeInputScheduling",
-      "Actions": [
-        {
-          "Name": "SetSchedulerPolicy",
-          "Params":
-          {
-            "Policy": "SCHED_FIFO",
-            "Priority": "98"
-          }
-        }
-      ]
-    },
     {
       "Name": "CameraServicePerformance",
       "Actions": [
@@ -717,7 +704,7 @@
     },
     {
       "Name": "InputPolicy",
-      "Profiles": [ "RealTimeInputScheduling", "MaxPerformance", "ProcessCapacityMax", "TimerSlackNormal" ]
+      "Profiles": [ "MaxPerformance", "ProcessCapacityMax", "TimerSlackNormal" ]
     }
   ]
 }
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index f3594e345bd1..cc675b3feba1 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -20,7 +20,6 @@
 #include <task_profiles.h>
 
 #include <map>
-#include <optional>
 #include <string>
 
 #include <dirent.h>
@@ -55,7 +54,6 @@ static constexpr const char* TASK_PROFILE_DB_VENDOR_FILE = "/vendor/etc/task_pro
 
 static constexpr const char* TEMPLATE_TASK_PROFILE_API_FILE =
         "/etc/task_profiles/task_profiles_%u.json";
-namespace {
 
 class FdCacheHelper {
   public:
@@ -66,11 +64,8 @@ class FdCacheHelper {
     };
 
     static void Cache(const std::string& path, android::base::unique_fd& fd);
-
     static void Drop(android::base::unique_fd& fd);
-
     static void Init(const std::string& path, android::base::unique_fd& fd);
-
     static bool IsCached(const android::base::unique_fd& fd) { return fd > FDS_INACCESSIBLE; }
 
   private:
@@ -121,17 +116,6 @@ bool FdCacheHelper::IsAppDependentPath(const std::string& path) {
     return path.find("<uid>", 0) != std::string::npos || path.find("<pid>", 0) != std::string::npos;
 }
 
-std::optional<long> readLong(const std::string& str) {
-    char* end;
-    const long result = strtol(str.c_str(), &end, 10);
-    if (end > str.c_str()) {
-        return result;
-    }
-    return std::nullopt;
-}
-
-}  // namespace
-
 IProfileAttribute::~IProfileAttribute() = default;
 
 const std::string& ProfileAttribute::file_name() const {
@@ -940,12 +924,15 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                     LOG(WARNING) << "JoinCgroup: controller " << controller_name << " is not found";
                 }
             } else if (action_name == "SetTimerSlack") {
-                const std::string slack_string = params_val["Slack"].asString();
-                std::optional<long> slack = readLong(slack_string);
-                if (slack && *slack >= 0) {
-                    profile->Add(std::make_unique<SetTimerSlackAction>(*slack));
+                std::string slack_value = params_val["Slack"].asString();
+                char* end;
+                unsigned long slack;
+
+                slack = strtoul(slack_value.c_str(), &end, 10);
+                if (end > slack_value.c_str()) {
+                    profile->Add(std::make_unique<SetTimerSlackAction>(slack));
                 } else {
-                    LOG(WARNING) << "SetTimerSlack: invalid parameter: " << slack_string;
+                    LOG(WARNING) << "SetTimerSlack: invalid parameter: " << slack_value;
                 }
             } else if (action_name == "SetAttribute") {
                 std::string attr_name = params_val["Name"].asString();
@@ -1004,19 +991,15 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                         // If present, this optional value will be passed in an additional syscall
                         // to setpriority(), since the sched_priority value must be 0 for calls to
                         // sched_setscheduler() with "normal" policies.
-                        const std::string nice_string = params_val["Nice"].asString();
-                        const std::optional<int> nice = readLong(nice_string);
+                        const int nice = params_val["Nice"].asInt();
 
-                        if (!nice) {
-                            LOG(FATAL) << "Invalid nice value specified: " << nice_string;
-                        }
                         const int LINUX_MIN_NICE = -20;
                         const int LINUX_MAX_NICE = 19;
-                        if (*nice < LINUX_MIN_NICE || *nice > LINUX_MAX_NICE) {
-                            LOG(WARNING) << "SetSchedulerPolicy: Provided nice (" << *nice
+                        if (nice < LINUX_MIN_NICE || nice > LINUX_MAX_NICE) {
+                            LOG(WARNING) << "SetSchedulerPolicy: Provided nice (" << nice
                                          << ") appears out of range.";
                         }
-                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy, *nice));
+                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy, nice));
                     } else {
                         profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy));
                     }
@@ -1029,18 +1012,11 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                     // This is a "virtual priority" as described by `man 2 sched_get_priority_min`
                     // that will be mapped onto the following range for the provided policy:
                     // [sched_get_priority_min(), sched_get_priority_max()]
+                    const int virtual_priority = params_val["Priority"].asInt();
 
-                    const std::string priority_string = params_val["Priority"].asString();
-                    std::optional<long> virtual_priority = readLong(priority_string);
-                    if (virtual_priority && *virtual_priority > 0) {
-                        int priority;
-                        if (SetSchedulerPolicyAction::toPriority(policy, *virtual_priority,
-                                                                 priority)) {
-                            profile->Add(
-                                    std::make_unique<SetSchedulerPolicyAction>(policy, priority));
-                        }
-                    } else {
-                        LOG(WARNING) << "Invalid priority value: " << priority_string;
+                    int priority;
+                    if (SetSchedulerPolicyAction::toPriority(policy, virtual_priority, priority)) {
+                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy, priority));
                     }
                 }
             } else {

From a3cf826de61ce3eafa4410092e5ae6ed83b932b1 Mon Sep 17 00:00:00 2001
From: Siarhei Vishniakou <svv@google.com>
Date: Thu, 31 Oct 2024 22:38:50 +0000
Subject: [PATCH 1211/1487] Set input thread priority to RT - try 2

This reverts commit de6707df0c0decfeb92a1e73a64d3a610e16d061.

Reason for revert: changing code without modifying JSON file now

Original description:

To improve input latency, set the critical input threads to RT priority.
This will use RT priority on AOSP devices by default. OEMs can still
choose to customize what "input policy" means for their device, which
may not necessarily mean RT.

For example, on device with multiple small / big cores, input task
affinity could be changed to prioritize big cores + higher CPU frequency
/ voltage, but still keep the standard / default input thread priority.

With this patch, I'm finding that sometimes, one of the critical input
threads has priority 100 instead of the expected 98. Still looking into
that specific issue, but the issue is already present with the existing
"input policy" code.

Bug: 330719044
Flag: com.android.input.flags.enable_input_policy_profile
Test: took perfetto trace and checked the priority on InputDispatcher
and InputReader threads.

Change-Id: I3dabf4da0398324cf542e701c103551343b883cf
---
 libprocessgroup/task_profiles.cpp | 56 ++++++++++++++++++++++---------
 1 file changed, 40 insertions(+), 16 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index cc675b3feba1..f3594e345bd1 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -20,6 +20,7 @@
 #include <task_profiles.h>
 
 #include <map>
+#include <optional>
 #include <string>
 
 #include <dirent.h>
@@ -54,6 +55,7 @@ static constexpr const char* TASK_PROFILE_DB_VENDOR_FILE = "/vendor/etc/task_pro
 
 static constexpr const char* TEMPLATE_TASK_PROFILE_API_FILE =
         "/etc/task_profiles/task_profiles_%u.json";
+namespace {
 
 class FdCacheHelper {
   public:
@@ -64,8 +66,11 @@ class FdCacheHelper {
     };
 
     static void Cache(const std::string& path, android::base::unique_fd& fd);
+
     static void Drop(android::base::unique_fd& fd);
+
     static void Init(const std::string& path, android::base::unique_fd& fd);
+
     static bool IsCached(const android::base::unique_fd& fd) { return fd > FDS_INACCESSIBLE; }
 
   private:
@@ -116,6 +121,17 @@ bool FdCacheHelper::IsAppDependentPath(const std::string& path) {
     return path.find("<uid>", 0) != std::string::npos || path.find("<pid>", 0) != std::string::npos;
 }
 
+std::optional<long> readLong(const std::string& str) {
+    char* end;
+    const long result = strtol(str.c_str(), &end, 10);
+    if (end > str.c_str()) {
+        return result;
+    }
+    return std::nullopt;
+}
+
+}  // namespace
+
 IProfileAttribute::~IProfileAttribute() = default;
 
 const std::string& ProfileAttribute::file_name() const {
@@ -924,15 +940,12 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                     LOG(WARNING) << "JoinCgroup: controller " << controller_name << " is not found";
                 }
             } else if (action_name == "SetTimerSlack") {
-                std::string slack_value = params_val["Slack"].asString();
-                char* end;
-                unsigned long slack;
-
-                slack = strtoul(slack_value.c_str(), &end, 10);
-                if (end > slack_value.c_str()) {
-                    profile->Add(std::make_unique<SetTimerSlackAction>(slack));
+                const std::string slack_string = params_val["Slack"].asString();
+                std::optional<long> slack = readLong(slack_string);
+                if (slack && *slack >= 0) {
+                    profile->Add(std::make_unique<SetTimerSlackAction>(*slack));
                 } else {
-                    LOG(WARNING) << "SetTimerSlack: invalid parameter: " << slack_value;
+                    LOG(WARNING) << "SetTimerSlack: invalid parameter: " << slack_string;
                 }
             } else if (action_name == "SetAttribute") {
                 std::string attr_name = params_val["Name"].asString();
@@ -991,15 +1004,19 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                         // If present, this optional value will be passed in an additional syscall
                         // to setpriority(), since the sched_priority value must be 0 for calls to
                         // sched_setscheduler() with "normal" policies.
-                        const int nice = params_val["Nice"].asInt();
+                        const std::string nice_string = params_val["Nice"].asString();
+                        const std::optional<int> nice = readLong(nice_string);
 
+                        if (!nice) {
+                            LOG(FATAL) << "Invalid nice value specified: " << nice_string;
+                        }
                         const int LINUX_MIN_NICE = -20;
                         const int LINUX_MAX_NICE = 19;
-                        if (nice < LINUX_MIN_NICE || nice > LINUX_MAX_NICE) {
-                            LOG(WARNING) << "SetSchedulerPolicy: Provided nice (" << nice
+                        if (*nice < LINUX_MIN_NICE || *nice > LINUX_MAX_NICE) {
+                            LOG(WARNING) << "SetSchedulerPolicy: Provided nice (" << *nice
                                          << ") appears out of range.";
                         }
-                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy, nice));
+                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy, *nice));
                     } else {
                         profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy));
                     }
@@ -1012,11 +1029,18 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                     // This is a "virtual priority" as described by `man 2 sched_get_priority_min`
                     // that will be mapped onto the following range for the provided policy:
                     // [sched_get_priority_min(), sched_get_priority_max()]
-                    const int virtual_priority = params_val["Priority"].asInt();
 
-                    int priority;
-                    if (SetSchedulerPolicyAction::toPriority(policy, virtual_priority, priority)) {
-                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy, priority));
+                    const std::string priority_string = params_val["Priority"].asString();
+                    std::optional<long> virtual_priority = readLong(priority_string);
+                    if (virtual_priority && *virtual_priority > 0) {
+                        int priority;
+                        if (SetSchedulerPolicyAction::toPriority(policy, *virtual_priority,
+                                                                 priority)) {
+                            profile->Add(
+                                    std::make_unique<SetSchedulerPolicyAction>(policy, priority));
+                        }
+                    } else {
+                        LOG(WARNING) << "Invalid priority value: " << priority_string;
                     }
                 }
             } else {

From b1f0c1bfdafbac5f816346cb19ac6323ee8e4c25 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 1 Nov 2024 21:02:49 +0000
Subject: [PATCH 1212/1487] libsnapshot: Update libprocessgroup dependencies

Bug: 349105928
Change-Id: I0a795c185ae453b86e0373e6786bd77a0d265b01
---
 fs_mgr/libsnapshot/snapuserd/Android.bp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index e4d2d0458292..06c27e71b192 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -88,7 +88,6 @@ cc_library_static {
         "libprocessgroup",
         "libprocessgroup_util",
         "libjsoncpp",
-        "libcgrouprc",
     ],
     include_dirs: ["bionic/libc/kernel"],
     export_include_dirs: ["include"],
@@ -132,7 +131,6 @@ cc_defaults {
         "libprocessgroup",
         "libprocessgroup_util",
         "libjsoncpp",
-        "libcgrouprc",
         "libsnapuserd_client",
         "libz",
         "liblz4",
@@ -224,7 +222,6 @@ cc_defaults {
         "libprocessgroup",
         "libprocessgroup_util",
         "libjsoncpp",
-        "libcgrouprc",
         "liburing",
         "libz",
     ],
@@ -319,7 +316,6 @@ cc_binary_host {
         "libsnapuserd",
         "libprocessgroup",
         "libjsoncpp",
-        "libcgrouprc",
         "liburing",
         "libz",
     ],

From 8a45aaaf128018703546dc5b423778895826e947 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 1 Nov 2024 21:04:39 +0000
Subject: [PATCH 1213/1487] libprocessgroup: Update libprocessgroup
 dependencies

Bug: 349105928
Change-Id: Iee047ccafe4c71eaf9c614fbe9a68585645a16f8
---
 libprocessgroup/Android.bp       | 1 -
 libprocessgroup/setup/Android.bp | 1 -
 2 files changed, 2 deletions(-)

diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index 8448a39a47c0..1e76e766fc42 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -110,7 +110,6 @@ cc_test {
     ],
     shared_libs: [
         "libbase",
-        "libcgrouprc",
         "libprocessgroup",
     ],
     static_libs: [
diff --git a/libprocessgroup/setup/Android.bp b/libprocessgroup/setup/Android.bp
index cc6c67cf4fb1..25737f5b2379 100644
--- a/libprocessgroup/setup/Android.bp
+++ b/libprocessgroup/setup/Android.bp
@@ -29,7 +29,6 @@ cc_library_shared {
     ],
     shared_libs: [
         "libbase",
-        "libcgrouprc",
         "libjsoncpp",
     ],
     static_libs: [

From 0b678adb6adf559e11191f3803be6dbd7194c9db Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 1 Nov 2024 21:06:30 +0000
Subject: [PATCH 1214/1487] libcutils: Update libprocessgroup dependencies

Bug: 349105928
Change-Id: I9d9230e415724657f9d49a09861f1046fbe4dc55
---
 libcutils/Android.bp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index 3471de0f4446..10392889d8a4 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -279,7 +279,6 @@ test_libraries = [
     "liblog",
     "libbase",
     "libprocessgroup",
-    "libcgrouprc",
 ]
 
 cc_test {

From 454167f5bd4504d5394536461eb6ddd3f4e0d9bc Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Sat, 2 Nov 2024 23:43:22 -0700
Subject: [PATCH 1215/1487] libsnapuserd: Handle empty response from server

If server disconnects, then handle the empty response.

Bug: 377068272
Test: Full OTA
Change-Id: Ic48204c457ef924ba9a3c1ae84a3317fb1ccda04
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
index ddefb9f91f19..7c820f32b494 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
@@ -311,6 +311,11 @@ double SnapuserdClient::GetMergePercent() {
     }
     std::string response = Receivemsg();
 
+    // If server socket disconnects most likely because of device reboot,
+    // then we just return 0.
+    if (response.empty()) {
+        return 0.0;
+    }
     return std::stod(response);
 }
 

From 1de3ab901368c510c906d3d4e4b9a912af05e7e8 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Tue, 5 Nov 2024 18:04:32 +0000
Subject: [PATCH 1216/1487] Revert^5 "Set block device as RO/RW before mount"

This reverts commit 5fd1be1a5a90f4e53d6e7f6bd8562d1940271773.

Reason for revert: b/377081806

Change-Id: I9c5761f6193979795e4350c9c7f89f18b9a868fd
---
 fs_mgr/fs_mgr.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index ea2e3a8c754b..5156754a8538 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -826,9 +826,6 @@ static int __mount(const std::string& source, const std::string& target, const F
     if (read_only) {
         mountflags |= MS_RDONLY;
     }
-    if (!fs_mgr_set_blk_ro(source, read_only)) {
-        PLOG(ERROR) << "Failed to set " << source << " as " << (read_only ? "RO" : "RW");
-    }
     int ret = 0;
     int save_errno = 0;
     int gc_allowance = 0;
@@ -883,6 +880,9 @@ static int __mount(const std::string& source, const std::string& target, const F
     }
     PINFO << __FUNCTION__ << "(source=" << source << source_missing << ",target=" << target
           << target_missing << ",type=" << entry.fs_type << ")=" << ret;
+    if ((ret == 0) && (mountflags & MS_RDONLY) != 0) {
+        fs_mgr_set_blk_ro(source);
+    }
     if (ret == 0) {
         android::base::SetProperty("ro.boottime.init.mount." + Basename(target),
                                    std::to_string(t.duration().count()));

From 519d3f8b368ae87d12814480066a8eb3c8f63216 Mon Sep 17 00:00:00 2001
From: Douglas Anderson <dianders@google.com>
Date: Wed, 16 Oct 2024 09:23:06 -0700
Subject: [PATCH 1217/1487] fs_mgr: Add getter for androidboot.boot_part_uuid

In order to make booting from some media types (like USB) more robust,
the bootloader will be extended to support passing the partition UUID
that it loaded the kernel from. It can pass this via kernel
commandline or via bootconfig. Add a way to get this.

Bug: 316324155
Test: Use the getter in a future change

Change-Id: Iab04742c0f2666db18dc48bcaaa2869eba405748
---
 fs_mgr/libfstab/fstab.cpp             | 16 ++++++++++++++++
 fs_mgr/libfstab/include/fstab/fstab.h | 10 ++++++++++
 2 files changed, 26 insertions(+)

diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index 6e4cae18f57e..43547eaf4176 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -950,6 +950,22 @@ std::set<std::string> GetBootDevices() {
     return ExtraBootDevices(fstab);
 }
 
+std::string GetBootPartUuid() {
+    std::string boot_part_uuid;
+
+    if (GetBootconfig("androidboot.boot_part_uuid", &boot_part_uuid)) {
+        return boot_part_uuid;
+    }
+
+    ImportKernelCmdline([&](std::string key, std::string value) {
+        if (key == "androidboot.boot_part_uuid") {
+            boot_part_uuid = value;
+        }
+    });
+
+    return boot_part_uuid;
+}
+
 std::string GetVerityDeviceName(const FstabEntry& entry) {
     std::string base_device;
     if (entry.mount_point == "/") {
diff --git a/fs_mgr/libfstab/include/fstab/fstab.h b/fs_mgr/libfstab/include/fstab/fstab.h
index 070dd9178666..0ff3188d4212 100644
--- a/fs_mgr/libfstab/include/fstab/fstab.h
+++ b/fs_mgr/libfstab/include/fstab/fstab.h
@@ -126,6 +126,16 @@ void TransformFstabForDsu(Fstab* fstab, const std::string& dsu_slot,
 
 std::set<std::string> GetBootDevices();
 
+// Get the Partition UUID the kernel loaded from if the bootloader passed it.
+//
+// If the kernel's Partition UUID is provided then we can use this to help
+// identify which block device contains the filesystems we care about.
+//
+// NOTE: Nothing secures a UUID other than the convention that two disks
+// aren't supposed to both have the same UUID. We still need other mechanisms
+// to ensure we've got the right disk.
+std::string GetBootPartUuid();
+
 // Return the name of the dm-verity device for the given fstab entry. This does
 // not check whether the device is valid or exists; it merely returns the
 // expected name.

From e53e50e3fa8e73b86163806d6f8eeb9eadf28bb7 Mon Sep 17 00:00:00 2001
From: Douglas Anderson <dianders@google.com>
Date: Wed, 16 Oct 2024 13:51:44 -0700
Subject: [PATCH 1218/1487] init: Add partition_uuid to Uevent

As of commit upstream Linux kernel commit 74f4a8dc0dd8 ("block: add
partition uuid into uevent as "PARTUUID""), it's easy to include the
partition UUID in the Uevent structure. Add it in so that other parts
of the init code can make decisions based on the partition UUID.

If this code is run on older kernels we'll never see the partition
UUID and it will be left blank.

Bug: 316324155
Test: Run w/ a newer kernel and see partition_uuid populated.
Change-Id: I48a52aa006c05023f7f1cc5cc0ab5c1f1ec37455
---
 init/uevent.h            | 1 +
 init/uevent_listener.cpp | 5 ++++-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/init/uevent.h b/init/uevent.h
index dc35fd968d3e..c8ca52aaf517 100644
--- a/init/uevent.h
+++ b/init/uevent.h
@@ -28,6 +28,7 @@ struct Uevent {
     std::string subsystem;
     std::string firmware;
     std::string partition_name;
+    std::string partition_uuid;
     std::string device_name;
     std::string modalias;
     int partition_num;
diff --git a/init/uevent_listener.cpp b/init/uevent_listener.cpp
index 5da67777d1f8..97f3de64025e 100644
--- a/init/uevent_listener.cpp
+++ b/init/uevent_listener.cpp
@@ -66,6 +66,9 @@ static void ParseEvent(const char* msg, Uevent* uevent) {
         } else if (!strncmp(msg, "PARTNAME=", 9)) {
             msg += 9;
             uevent->partition_name = msg;
+        } else if (!strncmp(msg, "PARTUUID=", 9)) {
+            msg += 9;
+            uevent->partition_uuid = msg;
         } else if (!strncmp(msg, "DEVNAME=", 8)) {
             msg += 8;
             uevent->device_name = msg;
@@ -82,7 +85,7 @@ static void ParseEvent(const char* msg, Uevent* uevent) {
     if (LOG_UEVENTS) {
         LOG(INFO) << "event { '" << uevent->action << "', '" << uevent->path << "', '"
                   << uevent->subsystem << "', '" << uevent->firmware << "', " << uevent->major
-                  << ", " << uevent->minor << " }";
+                  << ", " << uevent->minor << ", " << uevent->partition_uuid << " }";
     }
 }
 

From 9f760f8d4185d231ef2d085d2a7664046250d7e5 Mon Sep 17 00:00:00 2001
From: Douglas Anderson <dianders@google.com>
Date: Tue, 15 Oct 2024 14:22:02 -0700
Subject: [PATCH 1219/1487] init: Reorder GetBlockDeviceSymlinks() so
 FindDmDevice() is first

By moving FindDmDevice() it's easier to unify the code with the
IsBootDevice() function. In this case the order doesn't matter since
anything with the uevent path "/devices/virtual/block/dm-" (the only
devices FindDmDevice() looks at) won't match any of the other sections
of the if/then/else test.

Bug: 316324155
Test: Build & boot

Change-Id: I819eb60aa5077f0eb2c2f2783b152e43a52ba8b7
---
 init/devices.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/init/devices.cpp b/init/devices.cpp
index f2bb9d27607d..0af843f1074c 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -376,7 +376,13 @@ std::vector<std::string> DeviceHandler::GetBlockDeviceSymlinks(const Uevent& uev
     std::string partition;
     std::string uuid;
 
-    if (FindPlatformDevice(uevent.path, &device)) {
+    if (FindDmDevice(uevent, &partition, &uuid)) {
+        std::vector<std::string> symlinks = {"/dev/block/mapper/" + partition};
+        if (!uuid.empty()) {
+            symlinks.emplace_back("/dev/block/mapper/by-uuid/" + uuid);
+        }
+        return symlinks;
+    } else if (FindPlatformDevice(uevent.path, &device)) {
         // Skip /devices/platform or /devices/ if present
         static constexpr std::string_view devices_platform_prefix = "/devices/platform/";
         static constexpr std::string_view devices_prefix = "/devices/";
@@ -392,12 +398,6 @@ std::vector<std::string> DeviceHandler::GetBlockDeviceSymlinks(const Uevent& uev
         type = "pci";
     } else if (FindVbdDevicePrefix(uevent.path, &device)) {
         type = "vbd";
-    } else if (FindDmDevice(uevent, &partition, &uuid)) {
-        std::vector<std::string> symlinks = {"/dev/block/mapper/" + partition};
-        if (!uuid.empty()) {
-            symlinks.emplace_back("/dev/block/mapper/by-uuid/" + uuid);
-        }
-        return symlinks;
     } else {
         return {};
     }

From 06c4e96fd87cd488aabf5e657a2870a707b9f105 Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Tue, 5 Nov 2024 16:49:26 +0900
Subject: [PATCH 1220/1487] Deprecating libvendorsupport_llndk_headers

Versioned LLNDK symbols are guarded with __builtin_available.

Bug: 362658565
Test: m --no-skip-soong-tests
Change-Id: I0fb3bc87b74da62b8a8fba0c5bb6a3373e6a55dc
---
 libvendorsupport/Android.bp                   | 29 ------------
 .../include_llndk/android/llndk-versioning.h  | 45 -------------------
 2 files changed, 74 deletions(-)
 delete mode 100644 libvendorsupport/include_llndk/android/llndk-versioning.h

diff --git a/libvendorsupport/Android.bp b/libvendorsupport/Android.bp
index a22737c06967..f9a889b94a34 100644
--- a/libvendorsupport/Android.bp
+++ b/libvendorsupport/Android.bp
@@ -35,32 +35,3 @@ cc_library {
         "libbase",
     ],
 }
-
-cc_library_headers {
-    name: "libvendorsupport_llndk_headers",
-    host_supported: true,
-    vendor_available: true,
-    recovery_available: true,
-    ramdisk_available: true,
-    vendor_ramdisk_available: true,
-    native_bridge_supported: true,
-
-    export_include_dirs: ["include_llndk"],
-    llndk: {
-        llndk_headers: true,
-    },
-
-    apex_available: [
-        "//apex_available:platform",
-        "//apex_available:anyapex",
-    ],
-    min_sdk_version: "apex_inherit",
-
-    system_shared_libs: [],
-    stl: "none",
-
-    // This header library is used for libc and must be available to any sdk
-    // versions.
-    // Setting sdk_version to the lowest version allows the dependencies.
-    sdk_version: "1",
-}
diff --git a/libvendorsupport/include_llndk/android/llndk-versioning.h b/libvendorsupport/include_llndk/android/llndk-versioning.h
deleted file mode 100644
index 81d165f47918..000000000000
--- a/libvendorsupport/include_llndk/android/llndk-versioning.h
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (C) 2024 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-// LLNDK (https://source.android.com/docs/core/architecture/vndk/build-system#ll-ndk) is similar to
-// NDK, but uses its own versioning of YYYYMM format for vendor builds. The LLNDK symbols are
-// enabled when the vendor api level is equal to or newer than the ro.board.api_level. These symbols
-// must be annotated in map.txt files with the `# llndk=YYYYMM` annotation. They also must be marked
-// with `__INTRODUCED_IN_LLNDK(YYYYMM)` in the header files. It leaves a no-op annotation for ABI
-// analysis.
-#if !defined(__INTRODUCED_IN_LLNDK)
-#define __INTRODUCED_IN_LLNDK(vendor_api_level) \
-    __attribute__((annotate("introduced_in_llndk=" #vendor_api_level)))
-#endif
-
-#if defined(__ANDROID_VENDOR_API__)
-// __ANDROID_VENDOR_API__ is defined only for vendor or product variant modules.
-// Use this macro as an `if` statement to call an API that are available to both NDK and LLNDK.
-// This returns true for vendor or product modules if the vendor_api_level is less than or equal to
-// the ro.board.api_level.
-#define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
-    constexpr(__ANDROID_VENDOR_API__ >= vendor_api_level)
-
-#else  // __ANDROID_VENDOR_API__
-
-// For non-vendor modules, API_LEVEL_AT_LEAST is replaced with __builtin_available(sdk_api_level) to
-// guard the API for __INTRODUCED_IN.
-#if !defined(API_LEVEL_AT_LEAST)
-#define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
-    (__builtin_available(android sdk_api_level, *))
-#endif
-
-#endif  // __ANDROID_VENDOR_API__

From 01af5431f7b4353706527477aaa3118476e5b8a2 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 5 Nov 2024 22:22:12 -0800
Subject: [PATCH 1221/1487] snapuserd: typecast cow_op->new_block to uint64_t

On 32-bit devices, cow_op->new_block * BLOCK_SZ can overflow.

Bug: 376978542
Test: snapuserd_test on 32-bit device
1: Initiate merge on partition > 4GB.
2: Verify no overflow.

Change-Id: I4efc24891e0b330505ddf59b7db7716f054cf9c4
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../libsnapshot/snapuserd/user-space-merge/merge_worker.cpp   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index e2c58741a885..486548cadb5b 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -55,7 +55,7 @@ int MergeWorker::PrepareMerge(uint64_t* source_offset, int* pending_ops,
                 break;
             }
 
-            *source_offset = cow_op->new_block * BLOCK_SZ;
+            *source_offset = static_cast<uint64_t>(cow_op->new_block) * BLOCK_SZ;
             if (!checkOrderedOp) {
                 replace_zero_vec->push_back(cow_op);
                 if (cow_op->type() == kCowReplaceOp) {
@@ -74,7 +74,7 @@ int MergeWorker::PrepareMerge(uint64_t* source_offset, int* pending_ops,
                     break;
                 }
 
-                uint64_t next_offset = op->new_block * BLOCK_SZ;
+                uint64_t next_offset = static_cast<uint64_t>(op->new_block) * BLOCK_SZ;
                 if (next_offset != (*source_offset + nr_consecutive * BLOCK_SZ)) {
                     break;
                 }

From a2bd0e6b5db1023638e351cb1c55870b4fb8af8f Mon Sep 17 00:00:00 2001
From: Siarhei Vishniakou <svv@google.com>
Date: Wed, 6 Nov 2024 16:57:37 +0000
Subject: [PATCH 1222/1487] Set input thread priority to RT - try 3

This partially reverts commit de6707df0c0decfeb92a1e73a64d3a610e16d061.

Reason for revert: code change landed, now modifying JSON file only

Original description:

To improve input latency, set the critical input threads to RT priority.
This will use RT priority on AOSP devices by default. OEMs can still
choose to customize what "input policy" means for their device, which
may not necessarily mean RT.

For example, on device with multiple small / big cores, input task
affinity could be changed to prioritize big cores + higher CPU frequency
/ voltage, but still keep the standard / default input thread priority.

With this patch, I'm finding that sometimes, one of the critical input
threads has priority 100 instead of the expected 98. Still looking into
that specific issue, but the issue is already present with the existing
"input policy" code.

Bug: 330719044
Flag: com.android.input.flags.enable_input_policy_profile
Test: took perfetto trace and checked the priority on InputDispatcher
and InputReader threads.

Change-Id: I7d8a941f36ad9e4b75a7a0f4c5d81895256d6919
---
 libprocessgroup/profiles/task_profiles.json | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index feda3b49c108..d61939f296c4 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -202,6 +202,19 @@
         }
       ]
     },
+    {
+      "Name": "RealTimeInputScheduling",
+      "Actions": [
+        {
+          "Name": "SetSchedulerPolicy",
+          "Params":
+          {
+            "Policy": "SCHED_FIFO",
+            "Priority": "98"
+          }
+        }
+      ]
+    },
     {
       "Name": "CameraServicePerformance",
       "Actions": [
@@ -704,7 +717,7 @@
     },
     {
       "Name": "InputPolicy",
-      "Profiles": [ "MaxPerformance", "ProcessCapacityMax", "TimerSlackNormal" ]
+      "Profiles": [ "RealTimeInputScheduling", "MaxPerformance", "ProcessCapacityMax", "TimerSlackNormal" ]
     }
   ]
 }

From 743e8f16a731d45850505dd20c2936e6ac430a91 Mon Sep 17 00:00:00 2001
From: Douglas Anderson <dianders@google.com>
Date: Wed, 6 Nov 2024 09:24:50 -0800
Subject: [PATCH 1223/1487] init: Use ConsumePrefix() instead of open coding in
 GetBlockDeviceSymlinks()

In GetBlockDeviceSymlinks() we may need to strip the
"/devices/platform/" or "/devices/" from a string. Use the helper
ConsumePrefix() to do this, which is more convenient and readable.

This change is intended to be a no-op and just a cleanup.

Bug: 316324155
Test: Build and boot
Change-Id: I1adb1906ec37ff8f6f505abc5f26e1e3b157e608
---
 init/devices.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/init/devices.cpp b/init/devices.cpp
index 0af843f1074c..3054d3a565dc 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -45,6 +45,7 @@
 using namespace std::chrono_literals;
 
 using android::base::Basename;
+using android::base::ConsumePrefix;
 using android::base::Dirname;
 using android::base::ReadFileToString;
 using android::base::Readlink;
@@ -386,11 +387,10 @@ std::vector<std::string> DeviceHandler::GetBlockDeviceSymlinks(const Uevent& uev
         // Skip /devices/platform or /devices/ if present
         static constexpr std::string_view devices_platform_prefix = "/devices/platform/";
         static constexpr std::string_view devices_prefix = "/devices/";
+        std::string_view str = device;
 
-        if (StartsWith(device, devices_platform_prefix)) {
-            device = device.substr(devices_platform_prefix.length());
-        } else if (StartsWith(device, devices_prefix)) {
-            device = device.substr(devices_prefix.length());
+        if (ConsumePrefix(&str, devices_platform_prefix) || ConsumePrefix(&str, devices_prefix)) {
+            device = str;
         }
 
         type = "platform";

From 9481f976031d58946aa78bb82ee780d28a8267ff Mon Sep 17 00:00:00 2001
From: Douglas Anderson <dianders@google.com>
Date: Wed, 6 Nov 2024 09:28:07 -0800
Subject: [PATCH 1224/1487] init: Factor GetBlockDeviceInfo() out of
 GetBlockDeviceSymlinks()

Later code will want to use GetBlockDeviceInfo(), so factor it out to
a helper function. This change is intended to be a no-op.

Bug: 316324155
Test: Build & boot
Change-Id: If5d63f39efcd84a07eb8c6fa4f28bda45c4cbe5c
---
 init/devices.cpp | 57 ++++++++++++++++++++++++++++++------------------
 init/devices.h   |  7 ++++++
 2 files changed, 43 insertions(+), 21 deletions(-)

diff --git a/init/devices.cpp b/init/devices.cpp
index 3054d3a565dc..b067e0f4df8b 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -189,6 +189,34 @@ void SysfsPermissions::SetPermissions(const std::string& path) const {
     }
 }
 
+BlockDeviceInfo DeviceHandler::GetBlockDeviceInfo(const std::string& uevent_path) const {
+    BlockDeviceInfo info;
+
+    if (FindPlatformDevice(uevent_path, &info.str)) {
+        // Skip /devices/platform or /devices/ if present
+        static constexpr std::string_view devices_platform_prefix = "/devices/platform/";
+        static constexpr std::string_view devices_prefix = "/devices/";
+        std::string_view str = info.str;
+
+        if (ConsumePrefix(&str, devices_platform_prefix) || ConsumePrefix(&str, devices_prefix)) {
+            info.str = str;
+        }
+        info.type = "platform";
+    } else if (FindPciDevicePrefix(uevent_path, &info.str)) {
+        info.type = "pci";
+    } else if (FindVbdDevicePrefix(uevent_path, &info.str)) {
+        info.type = "vbd";
+    } else {
+        // Re-clear device to be extra certain in case one of the FindXXX()
+        // functions returned false but still modified it.
+        info.str = "";
+    }
+
+    info.is_boot_device = boot_devices_.find(info.str) != boot_devices_.end();
+
+    return info;
+}
+
 std::string DeviceHandler::GetPartitionNameForDevice(const std::string& query_device) {
     static const auto partition_map = [] {
         std::vector<std::pair<std::string, std::string>> partition_map;
@@ -372,8 +400,7 @@ void SanitizePartitionName(std::string* string) {
 }
 
 std::vector<std::string> DeviceHandler::GetBlockDeviceSymlinks(const Uevent& uevent) const {
-    std::string device;
-    std::string type;
+    BlockDeviceInfo info;
     std::string partition;
     std::string uuid;
 
@@ -383,32 +410,20 @@ std::vector<std::string> DeviceHandler::GetBlockDeviceSymlinks(const Uevent& uev
             symlinks.emplace_back("/dev/block/mapper/by-uuid/" + uuid);
         }
         return symlinks;
-    } else if (FindPlatformDevice(uevent.path, &device)) {
-        // Skip /devices/platform or /devices/ if present
-        static constexpr std::string_view devices_platform_prefix = "/devices/platform/";
-        static constexpr std::string_view devices_prefix = "/devices/";
-        std::string_view str = device;
+    }
 
-        if (ConsumePrefix(&str, devices_platform_prefix) || ConsumePrefix(&str, devices_prefix)) {
-            device = str;
-        }
+    info = GetBlockDeviceInfo(uevent.path);
 
-        type = "platform";
-    } else if (FindPciDevicePrefix(uevent.path, &device)) {
-        type = "pci";
-    } else if (FindVbdDevicePrefix(uevent.path, &device)) {
-        type = "vbd";
-    } else {
+    if (info.type.empty()) {
         return {};
     }
 
     std::vector<std::string> links;
 
-    LOG(VERBOSE) << "found " << type << " device " << device;
+    LOG(VERBOSE) << "found " << info.type << " device " << info.str;
 
-    auto link_path = "/dev/block/" + type + "/" + device;
+    auto link_path = "/dev/block/" + info.type + "/" + info.str;
 
-    bool is_boot_device = boot_devices_.find(device) != boot_devices_.end();
     if (!uevent.partition_name.empty()) {
         std::string partition_name_sanitized(uevent.partition_name);
         SanitizePartitionName(&partition_name_sanitized);
@@ -418,10 +433,10 @@ std::vector<std::string> DeviceHandler::GetBlockDeviceSymlinks(const Uevent& uev
         }
         links.emplace_back(link_path + "/by-name/" + partition_name_sanitized);
         // Adds symlink: /dev/block/by-name/<partition_name>.
-        if (is_boot_device) {
+        if (info.is_boot_device) {
             links.emplace_back("/dev/block/by-name/" + partition_name_sanitized);
         }
-    } else if (is_boot_device) {
+    } else if (info.is_boot_device) {
         // If we don't have a partition name but we are a partition on a boot device, create a
         // symlink of /dev/block/by-name/<device_name> for symmetry.
         links.emplace_back("/dev/block/by-name/" + uevent.device_name);
diff --git a/init/devices.h b/init/devices.h
index 6da1232595b4..82cb56ec09c7 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -116,6 +116,12 @@ class Subsystem {
     std::string dir_name_ = "/dev";
 };
 
+struct BlockDeviceInfo {
+    std::string str;
+    std::string type;
+    bool is_boot_device;
+};
+
 class DeviceHandler : public UeventHandler {
   public:
     friend class DeviceHandlerTester;
@@ -136,6 +142,7 @@ class DeviceHandler : public UeventHandler {
 
   private:
     void ColdbootDone() override;
+    BlockDeviceInfo GetBlockDeviceInfo(const std::string& uevent_path) const;
     bool FindPlatformDevice(std::string path, std::string* platform_device_path) const;
     std::tuple<mode_t, uid_t, gid_t> GetDevicePermissions(
         const std::string& path, const std::vector<std::string>& links) const;

From 6519e6d67f68e846c0516e40bd2529330ce60468 Mon Sep 17 00:00:00 2001
From: Douglas Anderson <dianders@google.com>
Date: Tue, 22 Oct 2024 14:09:26 -0700
Subject: [PATCH 1225/1487] init: Break FindPlatformDevice() into a helper
 function

We want to use the logic for FindPlatformDevice() in a future change
to look for devices that have USB parents. Break out a helper
function.

This change is intended to be a no-op and just a reorganization.

Bug: 316324155
Test: See boot devices still found
Change-Id: Ic5a57a89339c43dea1334644be9386637169c61c
---
 init/devices.cpp | 25 +++++++++++++++++--------
 init/devices.h   |  2 ++
 2 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/init/devices.cpp b/init/devices.cpp
index b067e0f4df8b..a2a1d3e1c540 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -247,11 +247,12 @@ std::string DeviceHandler::GetPartitionNameForDevice(const std::string& query_de
     return {};
 }
 
-// Given a path that may start with a platform device, find the parent platform device by finding a
-// parent directory with a 'subsystem' symlink that points to the platform bus.
-// If it doesn't start with a platform device, return false
-bool DeviceHandler::FindPlatformDevice(std::string path, std::string* platform_device_path) const {
-    platform_device_path->clear();
+// Given a path to a device that may have a parent in the passed set of
+// subsystems, find the parent device that's in the passed set of subsystems.
+// If we don't find a parent in the passed set of subsystems, return false.
+bool DeviceHandler::FindSubsystemDevice(std::string path, std::string* device_path,
+                                        const std::set<std::string>& subsystem_paths) const {
+    device_path->clear();
 
     // Uevents don't contain the mount point, so we need to add it here.
     path.insert(0, sysfs_mount_point_);
@@ -261,11 +262,10 @@ bool DeviceHandler::FindPlatformDevice(std::string path, std::string* platform_d
     while (directory != "/" && directory != ".") {
         std::string subsystem_link_path;
         if (Realpath(directory + "/subsystem", &subsystem_link_path) &&
-            (subsystem_link_path == sysfs_mount_point_ + "/bus/platform" ||
-             subsystem_link_path == sysfs_mount_point_ + "/bus/amba")) {
+            subsystem_paths.find(subsystem_link_path) != subsystem_paths.end()) {
             // We need to remove the mount point that we added above before returning.
             directory.erase(0, sysfs_mount_point_.size());
-            *platform_device_path = directory;
+            *device_path = directory;
             return true;
         }
 
@@ -279,6 +279,15 @@ bool DeviceHandler::FindPlatformDevice(std::string path, std::string* platform_d
     return false;
 }
 
+bool DeviceHandler::FindPlatformDevice(std::string path, std::string* platform_device_path) const {
+    const std::set<std::string> subsystem_paths = {
+            sysfs_mount_point_ + "/bus/platform",
+            sysfs_mount_point_ + "/bus/amba",
+    };
+
+    return FindSubsystemDevice(path, platform_device_path, subsystem_paths);
+}
+
 void DeviceHandler::FixupSysPermissions(const std::string& upath,
                                         const std::string& subsystem) const {
     // upaths omit the "/sys" that paths in this list
diff --git a/init/devices.h b/init/devices.h
index 82cb56ec09c7..7eee87a12b3c 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -143,6 +143,8 @@ class DeviceHandler : public UeventHandler {
   private:
     void ColdbootDone() override;
     BlockDeviceInfo GetBlockDeviceInfo(const std::string& uevent_path) const;
+    bool FindSubsystemDevice(std::string path, std::string* device_path,
+                             const std::set<std::string>& subsystem_paths) const;
     bool FindPlatformDevice(std::string path, std::string* platform_device_path) const;
     std::tuple<mode_t, uid_t, gid_t> GetDevicePermissions(
         const std::string& path, const std::vector<std::string>& links) const;

From 3de05fcff6df96c20dbfec3a7d78afecd25b005e Mon Sep 17 00:00:00 2001
From: Douglas Anderson <dianders@google.com>
Date: Tue, 22 Oct 2024 14:13:19 -0700
Subject: [PATCH 1226/1487] init: Move the stripping of "/devices" and
 "/devices/platform/" to a helper

A future change will want the same stripping when looking for USB boot
devices. Move the stripping down to the helper.

This change is intended to be a no-op and just a reorganization.

Bug: 316324155
Test: See boot devices still found
Change-Id: I025d9d68fedf652055454cbd93e15f480b6056dd
---
 init/devices.cpp | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/init/devices.cpp b/init/devices.cpp
index a2a1d3e1c540..501657ac64c9 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -193,14 +193,6 @@ BlockDeviceInfo DeviceHandler::GetBlockDeviceInfo(const std::string& uevent_path
     BlockDeviceInfo info;
 
     if (FindPlatformDevice(uevent_path, &info.str)) {
-        // Skip /devices/platform or /devices/ if present
-        static constexpr std::string_view devices_platform_prefix = "/devices/platform/";
-        static constexpr std::string_view devices_prefix = "/devices/";
-        std::string_view str = info.str;
-
-        if (ConsumePrefix(&str, devices_platform_prefix) || ConsumePrefix(&str, devices_prefix)) {
-            info.str = str;
-        }
         info.type = "platform";
     } else if (FindPciDevicePrefix(uevent_path, &info.str)) {
         info.type = "pci";
@@ -265,7 +257,17 @@ bool DeviceHandler::FindSubsystemDevice(std::string path, std::string* device_pa
             subsystem_paths.find(subsystem_link_path) != subsystem_paths.end()) {
             // We need to remove the mount point that we added above before returning.
             directory.erase(0, sysfs_mount_point_.size());
-            *device_path = directory;
+
+            // Skip /devices/platform or /devices/ if present
+            static constexpr std::string_view devices_platform_prefix = "/devices/platform/";
+            static constexpr std::string_view devices_prefix = "/devices/";
+            std::string_view sv = directory;
+
+            if (!ConsumePrefix(&sv, devices_platform_prefix)) {
+                ConsumePrefix(&sv, devices_prefix);
+            }
+            *device_path = sv;
+
             return true;
         }
 

From e9de3100619c37107c112ecc88e50cfbb210d803 Mon Sep 17 00:00:00 2001
From: Douglas Anderson <dianders@google.com>
Date: Tue, 22 Oct 2024 14:34:30 -0700
Subject: [PATCH 1227/1487] init: Add the ability to find the boot device by
 partition UUID

The current mechanism for specifying boot devices on Android systems
involves passing a set of "boot_devices" though command line,
bootconfig, or device tree.

The bootdevices are specified as strings and, in general, need to
match a sysfs path but without the "/sys/devices" or
"/sys/devices/platform" prefix. The sysfs path is generally the path
to the closest parent of the block device that is a "platform" device.

As an example, if the sysfs path of the expected boot device is:
  /sys/devices/platform/soc@0/7c4000.mmc/mmc_host/mmc1/mmc1:0001/block/mmcblk1

The bootloader would specify it as "soc@0/7c4000.mmc" since:
* We strip off "/sys/devices/platform/"
* As we move up directories, we don't find one whose subsystem is
  "platform" until we get up to
  "/sys/devices/platform/soc@0/7c4000.mmc".

The current mechanism is a bit brittle. Specifically:
* The sysfs path isn't _really_ stable and can change across kernel
  upgrades. For instance, during one kernel upgrade the device tree
  for a product changed so that the root node changed from "soc" to
  "soc@0" and this changed all sysfs paths. In the past device tree
  folks have asserted that we shouldn't rely on dts node names to stay
  consistent, yet those node names are used to construct sysfs paths.
* For some devices, like USB, the path of the closest "platform"
  device tends to be the path of the USB controller. This means that
  if two USB disks are plugged in we can't guarantee which one will be
  identified as the boot device.

Add a new method of finding the boot device by passing the partition
UUID that we loaded the kernel from. Using the partition UUID to
identify the boot device is standard on Linux. You can see this
because when you're not using an initramfs you can use the syntax
"root=PARTUUID=<valid-uuid-id>[/PARTNROFF=n]" to specify the root.
Using the same idea for Android's boot code makes sense.

With this new method for finding the boot device, we can make the code
much more specific about matching sysfs paths. Once we find the sysfs
path for the kernel we can make sure that all of the other boot
partition share the same "scsi" or "mmc" parent instead of going all
the way to the closest platform device. In the above example, this
means that we'd make sure that all boot devices are found under this
sysfs node:
  /sys/devices/platform/soc@0/7c4000.mmc/mmc_host/mmc1/mmc1:0001/block/mmcblk1
...instead of just making sure they are under:
  /sys/devices/platform/soc@0/7c4000.mmc

There is the question of what we should do if the bootloader passes
_both_ an old style "boot_devices" and also a partition UUID. In this
case, we'll issue a warning and then ignore the old "boot_devices".
Considering it a warning rather than an error could allow switching to
the "boot_part_uuid" method even if an old bootloader is still
hardcoding some old "boot_devices".

NOTE: Using partition UUID won't cause any security problems even
though someone _could_ plug in an external device crafted to have the
same UUID as the normal boot device's kernel partition. We already
have "verity" in the system making sure our filesystems are not
tampered with and this would also protect us from booting a tampered
disk. That means that the worst someone could do in this case would be
to confuse the system and make the device non-bootable. Chromebooks
have been using the partition UUID to find the root filesystems for
years and this has never been a problem.

NOTE: this new method relies on the commit ("init: Add partition_uuid
to Uevent") which in turn relies upstream kernel commit 74f4a8dc0dd8
("block: add partition uuid into uevent as "PARTUUID"").

Bug: 316324155
Test: Use partition UUID to boot

Change-Id: If824cb700ca3696a442a28e6ad02d7c522c3b495
---
 init/README.ueventd.md         | 27 +++++++++++
 init/block_dev_initializer.cpp | 44 ++++++++++++++++-
 init/block_dev_initializer.h   |  1 +
 init/devices.cpp               | 89 ++++++++++++++++++++++++++++++++--
 init/devices.h                 | 10 +++-
 init/first_stage_mount.cpp     |  4 ++
 init/ueventd.cpp               | 21 ++++++--
 7 files changed, 185 insertions(+), 11 deletions(-)

diff --git a/init/README.ueventd.md b/init/README.ueventd.md
index 7d00195eb56a..aac4acb6aae0 100644
--- a/init/README.ueventd.md
+++ b/init/README.ueventd.md
@@ -39,6 +39,33 @@ for the node path:
      `device_id` is `uevent MINOR % 128 + 1`.
   3. All other devices are created as `/dev/<basename uevent DEVPATH>`
 
+Whether a device is considered a "boot device" is a bit complicated.
+
+ - The recommended way to specify the boot device is to provide the "partition UUID" containing the
+   kernel (or, really, any parition on the boot device) and then boot device is the block device
+   containing that partition. This is passed via `androidboot.boot_part_uuid` which can be provided
+   either via the kernel bootconfig or via the kernel commandline. As an example, you could set
+   `androidboot.boot_part_uuid=12345678-abcd-ef01-0234-6789abcdef01`.
+ - Though using `boot_part_uuid` is preferred, you can also specify the boot device via
+   `androidboot.boot_device` or `androidboot.boot_devices`. These can be passed via the kernel
+   bootconfig or the kernel command line. It is also possible to pass this via device tree by
+   creating a `boot_devices` property in the Android firmware node. In most cases the `boot_device`
+   is the sysfs path (without the `/sys/devices` or `/sys/devices/platform` prefix) to the closest
+   parent of the block device that's on the "platform" bus. As an example, if the block device is
+   `/sys/devices/platform/soc@0/7c4000.mmc/mmc_host/mmc1/mmc1:0001/block/mmcblk1` then the
+   `boot_device` is `soc@0/7c4000.mmc` since we strip off the `/sys/devices/platform` and nothing
+   past the `7c4000.mmc` directory represents a device on the "platform" bus. In the case that none
+   of the parents are on the "platform" bus there are special rules for block devices under PCI
+   and VBD (Virtual Block Device). NOTE: sysfs paths for block devices are not guaranteed to be
+   stable between kernel versions, which is one of the reasons why it is suggested to use
+   `boot_part_uuid` instead of `boot_devices`. ALSO NOTE: If more than one device matches (either
+   because multiple `boot_devices` were listed or because there was more than one block device
+   under the found sysfs directory) and these multiple matching devices provide some of the same
+   named partitions then the behavior is unspecified.
+ - There is a further fallback to determine "boot devices" via the vstab, but providing at least
+   `boot_devices` has been required since Android 12 so this further fallback will not be described
+   here.
+
 The permissions can be modified using a ueventd.rc script and a line that beings with `/dev`. These
 lines take the format of
 
diff --git a/init/block_dev_initializer.cpp b/init/block_dev_initializer.cpp
index 8f5215856544..4ca5b8f0e383 100644
--- a/init/block_dev_initializer.cpp
+++ b/init/block_dev_initializer.cpp
@@ -33,7 +33,49 @@ BlockDevInitializer::BlockDevInitializer() : uevent_listener_(16 * 1024 * 1024)
     auto boot_devices = android::fs_mgr::GetBootDevices();
     device_handler_ = std::make_unique<DeviceHandler>(
             std::vector<Permissions>{}, std::vector<SysfsPermissions>{}, std::vector<Subsystem>{},
-            std::move(boot_devices), false);
+            std::move(boot_devices), android::fs_mgr::GetBootPartUuid(), false);
+}
+
+// If boot_part_uuid is specified, use it to set boot_devices
+//
+// When `androidboot.boot_part_uuid` is specified then that's the partition UUID
+// of the kernel. Look for that partition and then set `boot_devices` to be
+// exactly one item: the block device containing that partition.
+//
+// NOTE that `boot_part_uuid` is only specified on newer devices. Older devices
+// specified `boot_devices` directly.
+bool BlockDevInitializer::InitBootDevicesFromPartUuid() {
+    bool uuid_check_done = false;
+
+    auto boot_part_callback = [&, this](const Uevent& uevent) -> ListenerAction {
+        uuid_check_done = device_handler_->CheckUeventForBootPartUuid(uevent);
+        return uuid_check_done ? ListenerAction::kStop : ListenerAction::kContinue;
+    };
+
+    // Re-run already arrived uevents looking for the boot partition UUID.
+    //
+    // NOTE: If we're not using the boot partition UUID to find the boot
+    // device then the first uevent we analyze will cause us to stop looking
+    // and set `uuid_check_done`. This will shortcut all of the UUID logic.
+    // Replaying one uevent is not expected to be slow.
+    uevent_listener_.RegenerateUevents(boot_part_callback);
+
+    // If we're not done looking, poll for uevents for longer
+    if (!uuid_check_done) {
+        Timer t;
+        uevent_listener_.Poll(boot_part_callback, 10s);
+        LOG(INFO) << "Wait for boot partition returned after " << t;
+    }
+
+    // Give a nicer error message if we were expecting to find the kernel boot
+    // partition but didn't. Later code would fail too but the message there
+    // is a bit further from the root cause of the problem.
+    if (!uuid_check_done) {
+        LOG(ERROR) << __PRETTY_FUNCTION__ << ": boot partition not found after polling timeout.";
+        return false;
+    }
+
+    return true;
 }
 
 bool BlockDevInitializer::InitDeviceMapper() {
diff --git a/init/block_dev_initializer.h b/init/block_dev_initializer.h
index cb1d365559a4..25107c97f5b2 100644
--- a/init/block_dev_initializer.h
+++ b/init/block_dev_initializer.h
@@ -29,6 +29,7 @@ class BlockDevInitializer final {
   public:
     BlockDevInitializer();
 
+    bool InitBootDevicesFromPartUuid();
     bool InitDeviceMapper();
     bool InitDmUser(const std::string& name);
     bool InitDevices(std::set<std::string> devices);
diff --git a/init/devices.cpp b/init/devices.cpp
index 501657ac64c9..0b1e13dba249 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -192,7 +192,22 @@ void SysfsPermissions::SetPermissions(const std::string& path) const {
 BlockDeviceInfo DeviceHandler::GetBlockDeviceInfo(const std::string& uevent_path) const {
     BlockDeviceInfo info;
 
-    if (FindPlatformDevice(uevent_path, &info.str)) {
+    if (!boot_part_uuid_.empty()) {
+        // Only use the more specific "MMC" or "SCSI" match if a partition UUID
+        // was passed. Old bootloaders that aren't passing the partition UUID
+        // instead pass the path to the closest "platform" device. It would
+        // break them if we chose this deeper (more specific) path.
+        //
+        // When we have a UUID we _want_ the more specific path since it can
+        // handle, for instance, differentiating two USB disks that are on
+        // the same USB controller. Using the closest platform device would
+        // classify them both the same by using the path to the USB controller.
+        if (FindMmcDevice(uevent_path, &info.str)) {
+            info.type = "mmc";
+        } else if (FindScsiDevice(uevent_path, &info.str)) {
+            info.type = "scsi";
+        }
+    } else if (FindPlatformDevice(uevent_path, &info.str)) {
         info.type = "platform";
     } else if (FindPciDevicePrefix(uevent_path, &info.str)) {
         info.type = "pci";
@@ -290,6 +305,22 @@ bool DeviceHandler::FindPlatformDevice(std::string path, std::string* platform_d
     return FindSubsystemDevice(path, platform_device_path, subsystem_paths);
 }
 
+bool DeviceHandler::FindMmcDevice(std::string path, std::string* mmc_device_path) const {
+    const std::set<std::string> subsystem_paths = {
+            sysfs_mount_point_ + "/bus/mmc",
+    };
+
+    return FindSubsystemDevice(path, mmc_device_path, subsystem_paths);
+}
+
+bool DeviceHandler::FindScsiDevice(std::string path, std::string* scsi_device_path) const {
+    const std::set<std::string> subsystem_paths = {
+            sysfs_mount_point_ + "/bus/scsi",
+    };
+
+    return FindSubsystemDevice(path, scsi_device_path, subsystem_paths);
+}
+
 void DeviceHandler::FixupSysPermissions(const std::string& upath,
                                         const std::string& subsystem) const {
     // upaths omit the "/sys" that paths in this list
@@ -567,6 +598,48 @@ void DeviceHandler::HandleAshmemUevent(const Uevent& uevent) {
     }
 }
 
+// Check Uevents looking for the kernel's boot partition UUID
+//
+// When we can stop checking uevents (either because we're done or because
+// we weren't looking for the kernel's boot partition UUID) then return
+// true. Return false if we're not done yet.
+bool DeviceHandler::CheckUeventForBootPartUuid(const Uevent& uevent) {
+    // If we aren't using boot_part_uuid then we're done.
+    if (boot_part_uuid_.empty()) {
+        return true;
+    }
+
+    // Finding the boot partition is a one-time thing that we do at init
+    // time, not steady state. This is because the boot partition isn't
+    // allowed to go away or change. Once we found the boot partition we don't
+    // expect to run again.
+    if (found_boot_part_uuid_) {
+        LOG(WARNING) << __PRETTY_FUNCTION__
+                     << " shouldn't run after kernel boot partition is found";
+        return true;
+    }
+
+    // We only need to look at newly-added block devices. Note that if someone
+    // is replaying events all existing devices will get "add"ed.
+    if (uevent.subsystem != "block" || uevent.action != "add") {
+        return false;
+    }
+
+    // If it's not the partition we care about then move on.
+    if (uevent.partition_uuid != boot_part_uuid_) {
+        return false;
+    }
+
+    auto device = GetBlockDeviceInfo(uevent.path);
+
+    LOG(INFO) << "Boot device " << device.str << " found via partition UUID";
+    found_boot_part_uuid_ = true;
+    boot_devices_.clear();
+    boot_devices_.insert(device.str);
+
+    return true;
+}
+
 void DeviceHandler::HandleUevent(const Uevent& uevent) {
     if (uevent.action == "add" || uevent.action == "change" || uevent.action == "bind" ||
         uevent.action == "online") {
@@ -629,17 +702,25 @@ void DeviceHandler::ColdbootDone() {
 DeviceHandler::DeviceHandler(std::vector<Permissions> dev_permissions,
                              std::vector<SysfsPermissions> sysfs_permissions,
                              std::vector<Subsystem> subsystems, std::set<std::string> boot_devices,
-                             bool skip_restorecon)
+                             std::string boot_part_uuid, bool skip_restorecon)
     : dev_permissions_(std::move(dev_permissions)),
       sysfs_permissions_(std::move(sysfs_permissions)),
       subsystems_(std::move(subsystems)),
       boot_devices_(std::move(boot_devices)),
+      boot_part_uuid_(boot_part_uuid),
       skip_restorecon_(skip_restorecon),
-      sysfs_mount_point_("/sys") {}
+      sysfs_mount_point_("/sys") {
+    // If both a boot partition UUID and a list of boot devices are
+    // specified then we ignore the boot_devices in favor of boot_part_uuid.
+    if (boot_devices_.size() && !boot_part_uuid.empty()) {
+        LOG(WARNING) << "Both boot_devices and boot_part_uuid provided; ignoring bootdevices";
+        boot_devices_.clear();
+    }
+}
 
 DeviceHandler::DeviceHandler()
     : DeviceHandler(std::vector<Permissions>{}, std::vector<SysfsPermissions>{},
-                    std::vector<Subsystem>{}, std::set<std::string>{}, false) {}
+                    std::vector<Subsystem>{}, std::set<std::string>{}, "", false) {}
 
 }  // namespace init
 }  // namespace android
diff --git a/init/devices.h b/init/devices.h
index 7eee87a12b3c..cac52bc171e2 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -128,10 +128,12 @@ class DeviceHandler : public UeventHandler {
 
     DeviceHandler();
     DeviceHandler(std::vector<Permissions> dev_permissions,
-                  std::vector<SysfsPermissions> sysfs_permissions, std::vector<Subsystem> subsystems,
-                  std::set<std::string> boot_devices, bool skip_restorecon);
+                  std::vector<SysfsPermissions> sysfs_permissions,
+                  std::vector<Subsystem> subsystems, std::set<std::string> boot_devices,
+                  std::string boot_part_uuid, bool skip_restorecon);
     virtual ~DeviceHandler() = default;
 
+    bool CheckUeventForBootPartUuid(const Uevent& uevent);
     void HandleUevent(const Uevent& uevent) override;
 
     // `androidboot.partition_map` allows associating a partition name for a raw block device
@@ -146,6 +148,8 @@ class DeviceHandler : public UeventHandler {
     bool FindSubsystemDevice(std::string path, std::string* device_path,
                              const std::set<std::string>& subsystem_paths) const;
     bool FindPlatformDevice(std::string path, std::string* platform_device_path) const;
+    bool FindMmcDevice(std::string path, std::string* mmc_device_path) const;
+    bool FindScsiDevice(std::string path, std::string* scsi_device_path) const;
     std::tuple<mode_t, uid_t, gid_t> GetDevicePermissions(
         const std::string& path, const std::vector<std::string>& links) const;
     void MakeDevice(const std::string& path, bool block, int major, int minor,
@@ -160,6 +164,8 @@ class DeviceHandler : public UeventHandler {
     std::vector<SysfsPermissions> sysfs_permissions_;
     std::vector<Subsystem> subsystems_;
     std::set<std::string> boot_devices_;
+    std::string boot_part_uuid_;
+    bool found_boot_part_uuid_;
     bool skip_restorecon_;
     std::string sysfs_mount_point_;
 };
diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index 4f1af3038d45..aa6b551662fa 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -288,6 +288,10 @@ static bool IsMicrodroidStrictBoot() {
 }
 
 bool FirstStageMountVBootV2::InitDevices() {
+    if (!block_dev_init_.InitBootDevicesFromPartUuid()) {
+        return false;
+    }
+
     std::set<std::string> devices;
     GetSuperDeviceName(&devices);
 
diff --git a/init/ueventd.cpp b/init/ueventd.cpp
index 3f0d0e95ba08..286e4726668d 100644
--- a/init/ueventd.cpp
+++ b/init/ueventd.cpp
@@ -353,10 +353,25 @@ int ueventd_main(int argc, char** argv) {
 
     auto ueventd_configuration = GetConfiguration();
 
-    uevent_handlers.emplace_back(std::make_unique<DeviceHandler>(
+    UeventListener uevent_listener(ueventd_configuration.uevent_socket_rcvbuf_size);
+
+    // Right after making DeviceHandler, replay all events looking for which
+    // block device has the boot partition. This lets us make symlinks
+    // for all of the other partitions on the same disk. Note that by the time
+    // we get here we know that the boot partition has already shown up (if
+    // we're looking for it) so just regenerating events is enough to know
+    // we'll see it.
+    std::unique_ptr<DeviceHandler> device_handler = std::make_unique<DeviceHandler>(
             std::move(ueventd_configuration.dev_permissions),
             std::move(ueventd_configuration.sysfs_permissions),
-            std::move(ueventd_configuration.subsystems), android::fs_mgr::GetBootDevices(), true));
+            std::move(ueventd_configuration.subsystems), android::fs_mgr::GetBootDevices(),
+            android::fs_mgr::GetBootPartUuid(), true);
+    uevent_listener.RegenerateUevents([&](const Uevent& uevent) -> ListenerAction {
+        bool uuid_check_done = device_handler->CheckUeventForBootPartUuid(uevent);
+        return uuid_check_done ? ListenerAction::kStop : ListenerAction::kContinue;
+    });
+
+    uevent_handlers.emplace_back(std::move(device_handler));
     uevent_handlers.emplace_back(std::make_unique<FirmwareHandler>(
             std::move(ueventd_configuration.firmware_directories),
             std::move(ueventd_configuration.external_firmware_handlers)));
@@ -365,8 +380,6 @@ int ueventd_main(int argc, char** argv) {
         std::vector<std::string> base_paths = {"/odm/lib/modules", "/vendor/lib/modules"};
         uevent_handlers.emplace_back(std::make_unique<ModaliasHandler>(base_paths));
     }
-    UeventListener uevent_listener(ueventd_configuration.uevent_socket_rcvbuf_size);
-
     if (!android::base::GetBoolProperty(kColdBootDoneProp, false)) {
         ColdBoot cold_boot(uevent_listener, uevent_handlers,
                            ueventd_configuration.enable_parallel_restorecon,

From eb3d280f1ee89dd42bffaf1ec6fd200f9f8d7b3e Mon Sep 17 00:00:00 2001
From: Douglas Anderson <dianders@google.com>
Date: Tue, 5 Nov 2024 09:15:25 -0800
Subject: [PATCH 1228/1487] init: Look for partition only on a boot device if
 using boot_part_uuid

The current code waits for boot partitions to show up by waiting to
see a uevent with the right partition name. However, nothing in the
waiting code validates that the partition that showed up is actually
on the boot device. That means that the current code can be confused
if there is another block device in the system (possibly connected via
USB) that has a partition name matching one of the system ones.

It can be noted that the problem is specifically just that the
"waiting" part returns too early. Later parts of the system,
specifically the parts of the system that create the
"/dev/block/by-name" symlinks, do properly look at the list of "boot
devices". This means that the problem we're fixing is that later code,
which assumes that the boot partitions have already initialized, can
fail to find an initialized partition.

To make it concrete, imagine that you have two block devices in your
system: the builtin emmc and an external USB disk. Let's say you're
booting over USB and "boot_devices" properly lists only USB. Both the
"emmc" and "USB" block devices are properly formatted Android disks
and have the full slew of partitions. At boot time, you can see:
1. We get to the point where we need to wait for the "boot" source
   (USB) to show up.
2. We see the eMMC show up.
3. The eMMC has all the needed partitions, so we consider our wait
   done. ...but eMMC isn't in the list of "boot devices" so we don't
   create the "/dev/block/by-name" symlinks.
4. Later code assumes that the "/dev/block/by-name" symlinks are
   already setup and fails.
5. The device fails to boot.

Fix it so that the wait makes sure that the partitions are on the boot
device.

Unfortunately, it appears that in some cases products (especially
emulators) aren't setting the "boot devices" and/or are not making
sure all boot partitions are on the same device. Limit the fix to only
devices using the new "boot_part_uuid" to make sure we don't break old
code.

NOTE: this is effectively the same change as a previous one ("init:
Look for super partition only on a boot device") but with the added
fix to only enable the check when using "boot_part_uuid".

Bug: 309244873
Bug: 349144493
Bug: 316324155
Test: Boot isn't confused when two boot devices are present
Change-Id: Iaae453ed661307f485cdf4dde86294105cae9b2d
---
 init/block_dev_initializer.cpp | 34 +++++++++++++++++++++++++++++++++-
 init/devices.cpp               | 11 +++++++++++
 init/devices.h                 |  2 ++
 3 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/init/block_dev_initializer.cpp b/init/block_dev_initializer.cpp
index 4ca5b8f0e383..7f83037ae7cc 100644
--- a/init/block_dev_initializer.cpp
+++ b/init/block_dev_initializer.cpp
@@ -140,11 +140,43 @@ ListenerAction BlockDevInitializer::HandleUevent(const Uevent& uevent,
 
     LOG(VERBOSE) << __PRETTY_FUNCTION__ << ": found partition: " << name;
 
-    devices->erase(iter);
+    // Remove the partition from the list of partitions we're waiting for.
+    //
+    // Partitions that we're waiting for here are expected to be on the boot
+    // device, so only remove from the list if they're on the boot device.
+    // This prevents us from being confused if there are multiple disks (some
+    // perhaps connected via USB) that have matching partition names.
+    //
+    // ...but...
+    //
+    // Some products (especialy emulators) don't seem to set up boot_devices
+    // or possibly not all the partitions that we need to wait for are on the
+    // specified boot device. Thus, only require partitions to be on the boot
+    // device in "strict" mode, which should be used on newer systems.
+    if (device_handler_->IsBootDevice(uevent) || !device_handler_->IsBootDeviceStrict()) {
+        devices->erase(iter);
+    }
+
     device_handler_->HandleUevent(uevent);
     return devices->empty() ? ListenerAction::kStop : ListenerAction::kContinue;
 }
 
+// Wait for partitions that are expected to be on the "boot device" to initialize.
+//
+// Wait (for up to 10 seconds) for partitions passed in `devices` to show up.
+// All block devices found while waiting will be initialized, which includes
+// creating symlinks for them in /dev/block. Once all `devices` are found we'll
+// return success (true). If any devices aren't found we'll return failure
+// (false). As devices are found they will be removed from `devices`.
+//
+// The contents of `devices` is the names of the partitions. This can be:
+// - The `partition_name` reported by a uevent, or the final component in the
+//   `path` reported by a uevent if the `partition_name` is blank.
+// - The result of DeviceHandler::GetPartitionNameForDevice() on the
+//   `device_name` reported by a uevent.
+//
+// NOTE: on newer systems partitions _must_ be on the "boot device". See
+// comments inside HandleUevent().
 bool BlockDevInitializer::InitDevices(std::set<std::string> devices) {
     auto uevent_callback = [&, this](const Uevent& uevent) -> ListenerAction {
         return HandleUevent(uevent, &devices);
diff --git a/init/devices.cpp b/init/devices.cpp
index 0b1e13dba249..4de1e20305e9 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -224,6 +224,17 @@ BlockDeviceInfo DeviceHandler::GetBlockDeviceInfo(const std::string& uevent_path
     return info;
 }
 
+bool DeviceHandler::IsBootDeviceStrict() const {
+    // When using the newer "boot_part_uuid" to specify the boot device then
+    // we require all core system partitions to be on the boot device.
+    return !boot_part_uuid_.empty();
+}
+
+bool DeviceHandler::IsBootDevice(const Uevent& uevent) const {
+    auto device = GetBlockDeviceInfo(uevent.path);
+    return device.is_boot_device;
+}
+
 std::string DeviceHandler::GetPartitionNameForDevice(const std::string& query_device) {
     static const auto partition_map = [] {
         std::vector<std::pair<std::string, std::string>> partition_map;
diff --git a/init/devices.h b/init/devices.h
index cac52bc171e2..8b6cf6cb1820 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -141,6 +141,8 @@ class DeviceHandler : public UeventHandler {
     // `androidboot.partition_map=vdb,metadata;vdc,userdata` maps `vdb` to `metadata` and `vdc` to
     // `userdata`.
     static std::string GetPartitionNameForDevice(const std::string& device);
+    bool IsBootDeviceStrict() const;
+    bool IsBootDevice(const Uevent& uevent) const;
 
   private:
     void ColdbootDone() override;

From 52da71d47b8af5d3796cb0b4bb626de66a0a8435 Mon Sep 17 00:00:00 2001
From: Liana Kazanova <lkazanova@google.com>
Date: Wed, 6 Nov 2024 21:42:29 +0000
Subject: [PATCH 1229/1487] Revert "Set input thread priority to RT - try 3"

This reverts commit a2bd0e6b5db1023638e351cb1c55870b4fb8af8f.

Reason for revert:DroidMonitor: Potential culprit for http://b/377739155 - verifying through ABTD before revert submission. This is part of the standard investigation process, and does not mean your CL will be reverted.

Change-Id: I4c2b686aaf291db819d37711d4427d0094ca2295
---
 libprocessgroup/profiles/task_profiles.json | 15 +--------------
 1 file changed, 1 insertion(+), 14 deletions(-)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index d61939f296c4..feda3b49c108 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -202,19 +202,6 @@
         }
       ]
     },
-    {
-      "Name": "RealTimeInputScheduling",
-      "Actions": [
-        {
-          "Name": "SetSchedulerPolicy",
-          "Params":
-          {
-            "Policy": "SCHED_FIFO",
-            "Priority": "98"
-          }
-        }
-      ]
-    },
     {
       "Name": "CameraServicePerformance",
       "Actions": [
@@ -717,7 +704,7 @@
     },
     {
       "Name": "InputPolicy",
-      "Profiles": [ "RealTimeInputScheduling", "MaxPerformance", "ProcessCapacityMax", "TimerSlackNormal" ]
+      "Profiles": [ "MaxPerformance", "ProcessCapacityMax", "TimerSlackNormal" ]
     }
   ]
 }

From e5a2af34b3231a13f509993aeced19c3d3509aa8 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 7 Nov 2024 13:24:01 -0800
Subject: [PATCH 1230/1487] Increase the test timeout

Bug: 338329603
Test: Build success
Change-Id: I97008dbe112d87ef2f4bff5605beb41cc4b1fac7
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapuserd/Android.bp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 06c27e71b192..97cfe761677f 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -169,7 +169,7 @@ cc_binary {
     recovery_available: true,
 }
 
-// This target will install to /system/bin/snapuserd_ramdisk 
+// This target will install to /system/bin/snapuserd_ramdisk
 // It will also create a symblink on /system/bin/snapuserd that point to
 // /system/bin/snapuserd_ramdisk .
 // This way, init can check if generic ramdisk copy exists.
@@ -265,6 +265,10 @@ cc_test {
                 name: "force-no-test-error",
                 value: "false",
             },
+            {
+                name: "native-test-timeout",
+                value: "15m",
+            },
         ],
     },
 }

From ce6f7330ad2d335d780bf20d6516048325da0d87 Mon Sep 17 00:00:00 2001
From: Hung Nguyen <hungmn@google.com>
Date: Thu, 7 Nov 2024 13:15:20 -0800
Subject: [PATCH 1231/1487] Increase zram size percentage limit

To allow experimenting with zram size larger than device memory size.

Bug: 368286978
Test: atest CtsFsMgrTestCases

Change-Id: I47a4a4e6af39571d13e4622d110c92936008127e
---
 fs_mgr/libfstab/fstab.cpp    | 2 +-
 fs_mgr/tests/fs_mgr_test.cpp | 8 +++++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index 6e4cae18f57e..1db716974378 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -262,7 +262,7 @@ bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
             if (!arg.empty() && arg.back() == '%') {
                 arg.pop_back();
                 int val;
-                if (ParseInt(arg, &val, 0, 100)) {
+                if (ParseInt(arg, &val, 0, 200)) {
                     entry->zram_size = CalculateZramSize(val);
                 } else {
                     LWARNING << "Warning: zramsize= flag malformed: " << arg;
diff --git a/fs_mgr/tests/fs_mgr_test.cpp b/fs_mgr/tests/fs_mgr_test.cpp
index 6522c02e8dfd..6e050cf4b5d1 100644
--- a/fs_mgr/tests/fs_mgr_test.cpp
+++ b/fs_mgr/tests/fs_mgr_test.cpp
@@ -710,6 +710,7 @@ source none2       swap   defaults      zramsize=blah%
 source none3       swap   defaults      zramsize=5%
 source none4       swap   defaults      zramsize=105%
 source none5       swap   defaults      zramsize=%
+source none6       swap   defaults      zramsize=210%
 )fs";
     ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
 
@@ -742,12 +743,17 @@ source none5       swap   defaults      zramsize=%
 
     EXPECT_EQ("none4", entry->mount_point);
     EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
-    EXPECT_EQ(0, entry->zram_size);
+    EXPECT_NE(0, entry->zram_size);
     entry++;
 
     EXPECT_EQ("none5", entry->mount_point);
     EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
     EXPECT_EQ(0, entry->zram_size);
+    entry++;
+
+    EXPECT_EQ("none6", entry->mount_point);
+    EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
+    EXPECT_EQ(0, entry->zram_size);
 }
 
 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_FileEncryption) {

From 76afb4a2c2fb50ad6785e02dbaab724efc090bbe Mon Sep 17 00:00:00 2001
From: Inseob Kim <inseob@google.com>
Date: Wed, 6 Nov 2024 17:07:04 +0900
Subject: [PATCH 1232/1487] Add BOARD_GENFS_LABELS_VERSION

If it's 202504 or later, /sys/class/udc will be labeled as sysfs_udc. If
it's not set, /sys/class/udc will stay at the label sysfs. This is to
support GRF vendors older than 202504.

202404 or old vendors can choose either way. If they want to customize
permissions to /sys/class/udc, they can turn off
BOARD_GENFS_LABELS_VERSION and assign their own label to /sys/class/udc
/sys/class/udc with vendor sepolicy.

202504 or newer vendors must set BOARD_GENFS_LABELS_VERSION to a version
greater than or equal to 202504.

For now there's only one node /sys/class/udc, but more labels can be
added until 202504 freeze.

Bug: 361985697
Test: boot with and without BOARD_GENFS_LABELS_VERSION
Change-Id: I1a28109119368f1475628be85dd8d990c824922e
---
 init/selinux.cpp | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/init/selinux.cpp b/init/selinux.cpp
index c2d9b8d286f6..5ced0b81ae31 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -190,6 +190,22 @@ bool GetVendorMappingVersion(std::string* plat_vers) {
     return true;
 }
 
+int GetVendorGenfsVersion() {
+    std::string line;
+    if (!ReadFirstLine("/vendor/etc/selinux/genfs_labels_version.txt", &line)) {
+        PLOG(ERROR) << "Failed to read /vendor/etc/selinux/genfs_labels_version.txt; assuming it's "
+                       "202404";
+        return 202404;
+    }
+    int version;
+    if (!ParseInt(line, &version)) {
+        PLOG(ERROR) << "Failed to parse the genfs labels version " << line
+                    << "; assuming it's 202404";
+        return 202404;
+    }
+    return version;
+}
+
 constexpr const char plat_policy_cil_file[] = "/system/etc/selinux/plat_sepolicy.cil";
 
 bool IsSplitPolicyDevice() {
@@ -324,6 +340,15 @@ bool OpenSplitPolicy(PolicyFile* policy_file) {
     }
     const std::string version_as_string = std::to_string(SEPOLICY_VERSION);
 
+    std::vector<std::string> genfs_cil_files;
+
+    int vendor_genfs_version = GetVendorGenfsVersion();
+    std::string genfs_cil_file =
+            std::format("/system/etc/selinux/plat_sepolicy_genfs_{}.cil", vendor_genfs_version);
+    if (access(genfs_cil_file.c_str(), F_OK) != 0) {
+        genfs_cil_file.clear();
+    }
+
     // clang-format off
     std::vector<const char*> compile_args {
         "/system/bin/secilc",
@@ -364,6 +389,9 @@ bool OpenSplitPolicy(PolicyFile* policy_file) {
     if (!odm_policy_cil_file.empty()) {
         compile_args.push_back(odm_policy_cil_file.c_str());
     }
+    if (!genfs_cil_file.empty()) {
+        compile_args.push_back(genfs_cil_file.c_str());
+    }
     compile_args.push_back(nullptr);
 
     if (!ForkExecveAndWaitForCompletion(compile_args[0], (char**)compile_args.data())) {

From ab8f9717f1cb70afd28d67cee61996ef223aa10e Mon Sep 17 00:00:00 2001
From: "Priyanka Advani (xWF)" <padvani@google.com>
Date: Fri, 8 Nov 2024 17:37:24 +0000
Subject: [PATCH 1233/1487] Revert "Deprecating libvendorsupport_llndk_headers"

Revert submission 3334193-no-llndk-versioning

Reason for revert: Droidmonitor created revert  due to b/378038995. Will be verifying through ABTD before submission.

Reverted changes: /q/submissionid:3334193-no-llndk-versioning

Change-Id: Id8d85be1930bef68f94cee66a0fe29278de48d64
---
 libvendorsupport/Android.bp                   | 29 ++++++++++++
 .../include_llndk/android/llndk-versioning.h  | 45 +++++++++++++++++++
 2 files changed, 74 insertions(+)
 create mode 100644 libvendorsupport/include_llndk/android/llndk-versioning.h

diff --git a/libvendorsupport/Android.bp b/libvendorsupport/Android.bp
index f9a889b94a34..a22737c06967 100644
--- a/libvendorsupport/Android.bp
+++ b/libvendorsupport/Android.bp
@@ -35,3 +35,32 @@ cc_library {
         "libbase",
     ],
 }
+
+cc_library_headers {
+    name: "libvendorsupport_llndk_headers",
+    host_supported: true,
+    vendor_available: true,
+    recovery_available: true,
+    ramdisk_available: true,
+    vendor_ramdisk_available: true,
+    native_bridge_supported: true,
+
+    export_include_dirs: ["include_llndk"],
+    llndk: {
+        llndk_headers: true,
+    },
+
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    min_sdk_version: "apex_inherit",
+
+    system_shared_libs: [],
+    stl: "none",
+
+    // This header library is used for libc and must be available to any sdk
+    // versions.
+    // Setting sdk_version to the lowest version allows the dependencies.
+    sdk_version: "1",
+}
diff --git a/libvendorsupport/include_llndk/android/llndk-versioning.h b/libvendorsupport/include_llndk/android/llndk-versioning.h
new file mode 100644
index 000000000000..81d165f47918
--- /dev/null
+++ b/libvendorsupport/include_llndk/android/llndk-versioning.h
@@ -0,0 +1,45 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+// LLNDK (https://source.android.com/docs/core/architecture/vndk/build-system#ll-ndk) is similar to
+// NDK, but uses its own versioning of YYYYMM format for vendor builds. The LLNDK symbols are
+// enabled when the vendor api level is equal to or newer than the ro.board.api_level. These symbols
+// must be annotated in map.txt files with the `# llndk=YYYYMM` annotation. They also must be marked
+// with `__INTRODUCED_IN_LLNDK(YYYYMM)` in the header files. It leaves a no-op annotation for ABI
+// analysis.
+#if !defined(__INTRODUCED_IN_LLNDK)
+#define __INTRODUCED_IN_LLNDK(vendor_api_level) \
+    __attribute__((annotate("introduced_in_llndk=" #vendor_api_level)))
+#endif
+
+#if defined(__ANDROID_VENDOR_API__)
+// __ANDROID_VENDOR_API__ is defined only for vendor or product variant modules.
+// Use this macro as an `if` statement to call an API that are available to both NDK and LLNDK.
+// This returns true for vendor or product modules if the vendor_api_level is less than or equal to
+// the ro.board.api_level.
+#define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
+    constexpr(__ANDROID_VENDOR_API__ >= vendor_api_level)
+
+#else  // __ANDROID_VENDOR_API__
+
+// For non-vendor modules, API_LEVEL_AT_LEAST is replaced with __builtin_available(sdk_api_level) to
+// guard the API for __INTRODUCED_IN.
+#if !defined(API_LEVEL_AT_LEAST)
+#define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
+    (__builtin_available(android sdk_api_level, *))
+#endif
+
+#endif  // __ANDROID_VENDOR_API__

From 3c700588c75d29a78679260bc9847b22b852f724 Mon Sep 17 00:00:00 2001
From: Ted Bauer <tedbauer@google.com>
Date: Fri, 8 Nov 2024 17:15:46 +0000
Subject: [PATCH 1234/1487] Start aconfigd_system processes in init.rc

aconfigd_system is replacing aconfigd. Which one executes is toggled
by RO flag enable_system_aconfigd_rust, introduced in https://android-review.googlesource.com/q/topic:%22switch-to-aconfigd-system%22.

Bug: 378079539
Test: m
Change-Id: I6a04c38e9ef22da2b230046ddace73d6f7e39652
---
 rootdir/init.rc | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 5bb64cc60086..617e60a0ff9c 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -614,6 +614,9 @@ on post-fs
     mkdir /metadata/aconfig/boot 0775 root system
 
     mkdir /metadata/aconfig_test_missions 0775 root system
+
+    # See flag enable_system_aconfigd_rust, which toggles these processes.
+    exec_start system_aconfigd_platform_init
     exec_start aconfigd-platform-init
 
 on late-fs
@@ -1002,7 +1005,16 @@ on post-fs-data
     # Wait for apexd to finish activating APEXes before starting more processes.
     wait_for_prop apexd.status activated
     perform_apex_config
+
+    # See flag enable_system_aconfigd_rust, which toggles these processes.
     exec_start aconfigd-mainline-init
+    exec_start system_aconfigd_mainline_init
+
+    # system_aconfigd_socket_service is replacing aconfigd:
+    #   - A flag (enable_system_aconfigd_rust) toggles which socket executes.
+    #   - When enabled, aconfigd is a no-op, system_aconfigd_socket_service executes.
+    #   - Conversely, when disabled, aconfigd executes, and system_aconfigd_socket_service is a no-op.
+    start system_aconfigd_socket_service
     start aconfigd
 
     # Create directories for boot animation.

From 46afe22f9da648487d6e8b7c8a3f35cc15a3412b Mon Sep 17 00:00:00 2001
From: Douglas Anderson <dianders@google.com>
Date: Fri, 8 Nov 2024 14:38:41 -0800
Subject: [PATCH 1235/1487] init: Avoid extra string copies when finding
 devices by using const refs

Now that FindPlatformDevice() isn't modifying the path argument, and
is just passing it on to FindSubsystemDevice(), take this argument by
const reference. That should avoid an unnecessary string copy.

Bug: 316324155
Test: Compile
Change-Id: I1d92a322d0c311ee46a117dd9d650896ec02520f
---
 init/devices.cpp | 7 ++++---
 init/devices.h   | 6 +++---
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/init/devices.cpp b/init/devices.cpp
index 4de1e20305e9..2cdececf6ca0 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -307,7 +307,8 @@ bool DeviceHandler::FindSubsystemDevice(std::string path, std::string* device_pa
     return false;
 }
 
-bool DeviceHandler::FindPlatformDevice(std::string path, std::string* platform_device_path) const {
+bool DeviceHandler::FindPlatformDevice(const std::string& path,
+                                       std::string* platform_device_path) const {
     const std::set<std::string> subsystem_paths = {
             sysfs_mount_point_ + "/bus/platform",
             sysfs_mount_point_ + "/bus/amba",
@@ -316,7 +317,7 @@ bool DeviceHandler::FindPlatformDevice(std::string path, std::string* platform_d
     return FindSubsystemDevice(path, platform_device_path, subsystem_paths);
 }
 
-bool DeviceHandler::FindMmcDevice(std::string path, std::string* mmc_device_path) const {
+bool DeviceHandler::FindMmcDevice(const std::string& path, std::string* mmc_device_path) const {
     const std::set<std::string> subsystem_paths = {
             sysfs_mount_point_ + "/bus/mmc",
     };
@@ -324,7 +325,7 @@ bool DeviceHandler::FindMmcDevice(std::string path, std::string* mmc_device_path
     return FindSubsystemDevice(path, mmc_device_path, subsystem_paths);
 }
 
-bool DeviceHandler::FindScsiDevice(std::string path, std::string* scsi_device_path) const {
+bool DeviceHandler::FindScsiDevice(const std::string& path, std::string* scsi_device_path) const {
     const std::set<std::string> subsystem_paths = {
             sysfs_mount_point_ + "/bus/scsi",
     };
diff --git a/init/devices.h b/init/devices.h
index 8b6cf6cb1820..67a3d00b1d47 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -149,9 +149,9 @@ class DeviceHandler : public UeventHandler {
     BlockDeviceInfo GetBlockDeviceInfo(const std::string& uevent_path) const;
     bool FindSubsystemDevice(std::string path, std::string* device_path,
                              const std::set<std::string>& subsystem_paths) const;
-    bool FindPlatformDevice(std::string path, std::string* platform_device_path) const;
-    bool FindMmcDevice(std::string path, std::string* mmc_device_path) const;
-    bool FindScsiDevice(std::string path, std::string* scsi_device_path) const;
+    bool FindPlatformDevice(const std::string& path, std::string* platform_device_path) const;
+    bool FindMmcDevice(const std::string& path, std::string* mmc_device_path) const;
+    bool FindScsiDevice(const std::string& path, std::string* scsi_device_path) const;
     std::tuple<mode_t, uid_t, gid_t> GetDevicePermissions(
         const std::string& path, const std::vector<std::string>& links) const;
     void MakeDevice(const std::string& path, bool block, int major, int minor,

From dbb080d9bfacb5c57e64470c8817333291991fd9 Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Sat, 9 Nov 2024 02:41:06 +0000
Subject: [PATCH 1236/1487] Revert^2 "Deprecating
 libvendorsupport_llndk_headers"

ab8f9717f1cb70afd28d67cee61996ef223aa10e

Change-Id: Ie981692be554942df762a4c9be7c250b0b202f31
---
 libvendorsupport/Android.bp                   | 29 ------------
 .../include_llndk/android/llndk-versioning.h  | 45 -------------------
 2 files changed, 74 deletions(-)
 delete mode 100644 libvendorsupport/include_llndk/android/llndk-versioning.h

diff --git a/libvendorsupport/Android.bp b/libvendorsupport/Android.bp
index a22737c06967..f9a889b94a34 100644
--- a/libvendorsupport/Android.bp
+++ b/libvendorsupport/Android.bp
@@ -35,32 +35,3 @@ cc_library {
         "libbase",
     ],
 }
-
-cc_library_headers {
-    name: "libvendorsupport_llndk_headers",
-    host_supported: true,
-    vendor_available: true,
-    recovery_available: true,
-    ramdisk_available: true,
-    vendor_ramdisk_available: true,
-    native_bridge_supported: true,
-
-    export_include_dirs: ["include_llndk"],
-    llndk: {
-        llndk_headers: true,
-    },
-
-    apex_available: [
-        "//apex_available:platform",
-        "//apex_available:anyapex",
-    ],
-    min_sdk_version: "apex_inherit",
-
-    system_shared_libs: [],
-    stl: "none",
-
-    // This header library is used for libc and must be available to any sdk
-    // versions.
-    // Setting sdk_version to the lowest version allows the dependencies.
-    sdk_version: "1",
-}
diff --git a/libvendorsupport/include_llndk/android/llndk-versioning.h b/libvendorsupport/include_llndk/android/llndk-versioning.h
deleted file mode 100644
index 81d165f47918..000000000000
--- a/libvendorsupport/include_llndk/android/llndk-versioning.h
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (C) 2024 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-// LLNDK (https://source.android.com/docs/core/architecture/vndk/build-system#ll-ndk) is similar to
-// NDK, but uses its own versioning of YYYYMM format for vendor builds. The LLNDK symbols are
-// enabled when the vendor api level is equal to or newer than the ro.board.api_level. These symbols
-// must be annotated in map.txt files with the `# llndk=YYYYMM` annotation. They also must be marked
-// with `__INTRODUCED_IN_LLNDK(YYYYMM)` in the header files. It leaves a no-op annotation for ABI
-// analysis.
-#if !defined(__INTRODUCED_IN_LLNDK)
-#define __INTRODUCED_IN_LLNDK(vendor_api_level) \
-    __attribute__((annotate("introduced_in_llndk=" #vendor_api_level)))
-#endif
-
-#if defined(__ANDROID_VENDOR_API__)
-// __ANDROID_VENDOR_API__ is defined only for vendor or product variant modules.
-// Use this macro as an `if` statement to call an API that are available to both NDK and LLNDK.
-// This returns true for vendor or product modules if the vendor_api_level is less than or equal to
-// the ro.board.api_level.
-#define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
-    constexpr(__ANDROID_VENDOR_API__ >= vendor_api_level)
-
-#else  // __ANDROID_VENDOR_API__
-
-// For non-vendor modules, API_LEVEL_AT_LEAST is replaced with __builtin_available(sdk_api_level) to
-// guard the API for __INTRODUCED_IN.
-#if !defined(API_LEVEL_AT_LEAST)
-#define API_LEVEL_AT_LEAST(sdk_api_level, vendor_api_level) \
-    (__builtin_available(android sdk_api_level, *))
-#endif
-
-#endif  // __ANDROID_VENDOR_API__

From fc7ec65a00b6105ceeac872da875d4c9e5936942 Mon Sep 17 00:00:00 2001
From: Hung Nguyen <hungmn@google.com>
Date: Sat, 9 Nov 2024 23:05:32 -0800
Subject: [PATCH 1237/1487] Add AID for memory management daemon

Bug: 370509309
Bug: 375432464
Test: adb shell id -(u|g) mmd

Change-Id: I02440604b1947abc70235bfac132473e8bafa90d
---
 libcutils/include/private/android_filesystem_config.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libcutils/include/private/android_filesystem_config.h b/libcutils/include/private/android_filesystem_config.h
index b0bddf501674..2aaafbe2410d 100644
--- a/libcutils/include/private/android_filesystem_config.h
+++ b/libcutils/include/private/android_filesystem_config.h
@@ -143,6 +143,7 @@
 #define AID_PRNG_SEEDER 1092         /* PRNG seeder daemon */
 #define AID_UPROBESTATS 1093         /* uid for uprobestats */
 #define AID_CROS_EC 1094             /* uid for accessing ChromeOS EC (cros_ec) */
+#define AID_MMD 1095                 /* uid for memory management daemon */
 // Additions to this file must be made in AOSP, *not* in internal branches.
 // You will also need to update expect_ids() in bionic/tests/grp_pwd_test.cpp.
 

From f1eaa75168352a3bd3cc6ffb0733d09a4b028f8b Mon Sep 17 00:00:00 2001
From: Dennis Shen <dzshen@google.com>
Date: Mon, 11 Nov 2024 17:44:14 +0000
Subject: [PATCH 1238/1487] move aconfigd platform init service from init.rc
 into aconfigd.rc

Bug: 378079539
Test: m
Change-Id: I10c306468bf3efe3b5186851cb09b576b143512a
---
 rootdir/init.rc | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 617e60a0ff9c..6bff34aa1f03 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -608,17 +608,6 @@ on post-fs
 
     mkdir /metadata/staged-install 0770 root system
 
-    mkdir /metadata/aconfig 0775 root system
-    mkdir /metadata/aconfig/flags 0770 root system
-    mkdir /metadata/aconfig/maps 0775 root system
-    mkdir /metadata/aconfig/boot 0775 root system
-
-    mkdir /metadata/aconfig_test_missions 0775 root system
-
-    # See flag enable_system_aconfigd_rust, which toggles these processes.
-    exec_start system_aconfigd_platform_init
-    exec_start aconfigd-platform-init
-
 on late-fs
     # Ensure that tracefs has the correct permissions.
     # This does not work correctly if it is called in post-fs.

From e8ff8b494a342ae758ec03bcd27b784d4a4168a2 Mon Sep 17 00:00:00 2001
From: Karuna Wadhera <kwadhera@google.com>
Date: Sun, 10 Nov 2024 23:42:57 +0000
Subject: [PATCH 1239/1487] Set the proper FEATURE_HARDWARE_KEYSTORE version

The binary implements V3 of the KeyMint HAL, so the feature version
should match.

Bug: 369375199
Bug: 378384123
Test: treehugger
Change-Id: Ib26ac73cf6593d9a50f7a019129c6e5e237ae2cd
---
 trusty/keymaster/Android.bp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/keymaster/Android.bp b/trusty/keymaster/Android.bp
index cb078299e24a..5a1e4202d585 100644
--- a/trusty/keymaster/Android.bp
+++ b/trusty/keymaster/Android.bp
@@ -121,7 +121,7 @@ cc_binary {
         "libutils",
     ],
     required: [
-        "android.hardware.hardware_keystore.xml",
+        "android.hardware.hardware_keystore_V3.xml",
     ],
 }
 

From 5969d69248c8216bde0c905fa2a4ea0987c5ae8a Mon Sep 17 00:00:00 2001
From: David Drysdale <drysdale@google.com>
Date: Mon, 11 Nov 2024 17:52:45 +0000
Subject: [PATCH 1240/1487] Declare previous version when using frozen HALs

The KeyMint HAL has been updated to v4, but frozen builds (e.g. 25Q1)
remain on the previous version.  The core AIDL version is handled
automatically, but we also have a package manager flag whose value
is (100 * HAL-version).  Use `RELEASE_AIDL_USE_UNFROZEN` to switch
between `required` configs for that.

Test: TreeHugger
Bug: 377808462
Bug: 378026324
Change-Id: Id042bee2a81e8563e1029ea7bb43452715e3edee
---
 trusty/keymint/Android.bp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/trusty/keymint/Android.bp b/trusty/keymint/Android.bp
index 5cdd381e1a2e..36efb1b892bd 100644
--- a/trusty/keymint/Android.bp
+++ b/trusty/keymint/Android.bp
@@ -42,9 +42,10 @@ rust_binary {
     defaults: ["android.hardware.security.keymint-service.rust.trusty.default"],
     init_rc: ["android.hardware.security.keymint-service.rust.trusty.rc"],
     vintf_fragments: ["android.hardware.security.keymint-service.rust.trusty.xml"],
-    required: [
-        "android.hardware.hardware_keystore.xml",
-    ],
+    required: select(release_flag("RELEASE_AIDL_USE_UNFROZEN"), {
+        true: ["android.hardware.hardware_keystore.xml"],
+        default: ["android.hardware.hardware_keystore_V3.xml"],
+    }),
 }
 
 rust_binary {

From 6facd1bfd3d9e2672215630d944228e983d95986 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Fri, 8 Nov 2024 15:23:53 -0800
Subject: [PATCH 1241/1487] Test stack buffer size calculation.

Bug: 378140560
Change-Id: Idca03cac925bc0d8bd574817391c4eaca11f2bff
---
 .../test/mte_stack_record_test.cpp            | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/debuggerd/libdebuggerd/test/mte_stack_record_test.cpp b/debuggerd/libdebuggerd/test/mte_stack_record_test.cpp
index 4b788f3b7aed..bcda0ca5d25a 100644
--- a/debuggerd/libdebuggerd/test/mte_stack_record_test.cpp
+++ b/debuggerd/libdebuggerd/test/mte_stack_record_test.cpp
@@ -26,6 +26,8 @@
 #include "unwindstack/Memory.h"
 
 #include <android-base/test_utils.h>
+#include <procinfo/process_map.h>
+
 #include "gtest/gtest.h"
 
 #include "libdebuggerd/tombstone.h"
@@ -82,6 +84,33 @@ TEST(MteStackHistoryUnwindTest, TestOne) {
   EXPECT_EQ(e.tag(), 1ULL);
 }
 
+static std::optional<android::procinfo::MapInfo> FindMapping(void* data) {
+  std::optional<android::procinfo::MapInfo> result;
+  android::procinfo::ReadMapFile(
+      "/proc/self/maps", [&result, data](const android::procinfo::MapInfo& info) {
+        auto data_int = reinterpret_cast<uint64_t>(data) & ((1ULL << 56ULL) - 1ULL);
+        if (info.start <= data_int && data_int < info.end) {
+          result = info;
+        }
+      });
+  return result;
+}
+
+TEST_P(MteStackHistoryTest, TestFree) {
+  int size_cls = GetParam();
+  size_t size = stack_mte_ringbuffer_size(size_cls);
+  void* data = stack_mte_ringbuffer_allocate(size_cls, nullptr);
+  EXPECT_EQ(stack_mte_ringbuffer_size_from_pointer(reinterpret_cast<uintptr_t>(data)), size);
+  auto before = FindMapping(data);
+  ASSERT_TRUE(before.has_value());
+  EXPECT_EQ(before->end - before->start, size);
+  stack_mte_free_ringbuffer(reinterpret_cast<uintptr_t>(data));
+  for (size_t i = 0; i < size; i += page_size()) {
+    auto after = FindMapping(static_cast<char*>(data) + i);
+    EXPECT_TRUE(!after.has_value() || after->name != before->name);
+  }
+}
+
 TEST_P(MteStackHistoryTest, TestEmpty) {
   int size_cls = GetParam();
   size_t size = stack_mte_ringbuffer_size(size_cls);

From 945dd526edd47dc5121764dc88927ef934893027 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 12 Nov 2024 15:25:09 +0000
Subject: [PATCH 1242/1487] Stop explicitly adding bionic subdirectories to the
 include path.

Change-Id: I24776f1008ca5f030cd8c94147d9630519ef6a24
---
 fastboot/Android.bp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/fastboot/Android.bp b/fastboot/Android.bp
index b61fbd4df826..d3e058150c17 100644
--- a/fastboot/Android.bp
+++ b/fastboot/Android.bp
@@ -201,7 +201,6 @@ cc_binary {
         "update_metadata-protos",
         "liburing",
     ],
-    include_dirs: ["bionic/libc/kernel"],
 
     header_libs: [
         "avb_headers",

From 5f216ffdc35266acf175db0e73e952f2bca80c39 Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Sun, 6 Oct 2024 05:40:40 +0000
Subject: [PATCH 1243/1487] trusty: utils: rpmb_dev: add wv secure storage
 init.rc

Bug: 371777025
Change-Id: Id4f26509568dac1045e0b2ba58a045874555a303
Test: cuttlefish with trusty-vm enablement apex, run WV VTS
---
 trusty/utils/rpmb_dev/Android.bp            |  9 +++
 trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc | 62 +++++++++++++++++++++
 2 files changed, 71 insertions(+)
 create mode 100644 trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc

diff --git a/trusty/utils/rpmb_dev/Android.bp b/trusty/utils/rpmb_dev/Android.bp
index 13f151d2e84e..ef23cc50f520 100644
--- a/trusty/utils/rpmb_dev/Android.bp
+++ b/trusty/utils/rpmb_dev/Android.bp
@@ -49,3 +49,12 @@ cc_binary {
         "rpmb_dev.system.rc",
     ],
 }
+
+cc_binary {
+    name: "rpmb_dev.wv.system",
+    defaults: ["rpmb_dev.cc_defaults"],
+    system_ext_specific: true,
+    init_rc: [
+        "rpmb_dev.wv.system.rc",
+    ],
+}
diff --git a/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc b/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
new file mode 100644
index 000000000000..3e7f8b44fc23
--- /dev/null
+++ b/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
@@ -0,0 +1,62 @@
+service storageproxyd_wv_system /system_ext/bin/storageproxyd.system \
+        -d ${storageproxyd_wv_system.trusty_ipc_dev:-/dev/trusty-ipc-dev0} \
+        -r /dev/socket/rpmb_mock_wv_system \
+        -p /data/secure_storage_wv_system \
+        -t sock
+    disabled
+    class hal
+    user system
+    group system
+
+service rpmb_mock_init_wv_system /system_ext/bin/rpmb_dev.wv.system \
+        --dev /mnt/secure_storage_rpmb_wv_system/persist/RPMB_DATA --init --size 2048
+    disabled
+    user system
+    group system
+    oneshot
+
+service rpmb_mock_wv_system /system_ext/bin/rpmb_dev.wv.system \
+        --dev /mnt/secure_storage_rpmb_wv_system/persist/RPMB_DATA \
+        --sock rpmb_mock_wv_system
+    disabled
+    user system
+    group system
+    socket rpmb_mock_wv_system stream 660 system system
+
+# storageproxyd
+on boot && \
+    property:trusty.widevine_vm.nonsecure_vm_ready=1 && \
+    property:storageproxyd_wv_system.trusty_ipc_dev=*
+    wait /dev/socket/rpmb_mock_wv_system
+    enable storageproxyd_wv_system
+
+
+# RPMB Mock
+on early-boot && \
+    property:ro.hardware.security.trusty.widevine_vm.system=1 && \
+    property:trusty.widevine_vm.vm_cid=* && \
+    property:ro.boot.vendor.apex.com.android.services.widevine=\
+com.android.services.widevine.cf_guest_trusty_nonsecure
+    # Create a persistent location for the RPMB data
+    # (work around lack of RPMb block device on CF).
+    # file contexts secure_storage_rpmb_system_file
+    # (only used on Cuttlefish as this is non secure)
+    mkdir /metadata/secure_storage_rpmb_wv_system 0770 system system
+    mkdir /mnt/secure_storage_rpmb_wv_system 0770 system system
+    symlink /metadata/secure_storage_rpmb_wv_system \
+            /mnt/secure_storage_rpmb_wv_system/persist
+    # Create a system persist directory in /metadata
+    # (work around lack of dedicated system persist partition).
+    # file contexts secure_storage_persist_system_file
+    mkdir /metadata/secure_storage_persist_wv_system 0770 system system
+    mkdir /mnt/secure_storage_persist_wv_system 0770 system system
+    symlink /metadata/secure_storage_persist_wv_system \
+            /mnt/secure_storage_persist_wv_system/persist
+    # file contexts secure_storage_system_file
+    mkdir /data/secure_storage_wv_system 0770 root system
+    symlink /mnt/secure_storage_persist_wv_system/persist \
+            /data/secure_storage_wv_system/persist
+    chown root system /data/secure_storage_wv_system/persist
+    setprop storageproxyd_wv_system.trusty_ipc_dev VSOCK:${trusty.widevine_vm.vm_cid}:1
+    exec_start rpmb_mock_init_wv_system
+    start rpmb_mock_wv_system

From 4be70e7db3f681e11ae804ea399275fc148134d3 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Tue, 12 Nov 2024 20:46:08 +0000
Subject: [PATCH 1244/1487] Remove mitchp from OWNERS file

Change-Id: Ifb0e1598f3908fcc2206a2b51611b996f8b48cb8
---
 init/test_upgrade_mte/OWNERS | 1 -
 1 file changed, 1 deletion(-)

diff --git a/init/test_upgrade_mte/OWNERS b/init/test_upgrade_mte/OWNERS
index 79625dfb160f..c95d3cfd00e2 100644
--- a/init/test_upgrade_mte/OWNERS
+++ b/init/test_upgrade_mte/OWNERS
@@ -1,5 +1,4 @@
 fmayer@google.com
 
 eugenis@google.com
-mitchp@google.com
 pcc@google.com

From 64148e33d195e82f00062d0db4166f42e6a28f83 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 12 Nov 2024 23:57:50 +0000
Subject: [PATCH 1245/1487] libprocessgroup: Remove libcgrouprc_format

This is no longer depended on anywhere.

Bug: 349105928
Change-Id: I7aba0a0d4e8a851edfc5e43daa1d9b5553adcdc3
---
 libprocessgroup/cgrouprc_format/Android.bp | 26 ----------------------
 1 file changed, 26 deletions(-)
 delete mode 100644 libprocessgroup/cgrouprc_format/Android.bp

diff --git a/libprocessgroup/cgrouprc_format/Android.bp b/libprocessgroup/cgrouprc_format/Android.bp
deleted file mode 100644
index 6f9ab3e73e36..000000000000
--- a/libprocessgroup/cgrouprc_format/Android.bp
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (C) 2019 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package {
-    default_applicable_licenses: ["Android-Apache-2.0"],
-}
-
-cc_library_static {
-    name: "libcgrouprc_format",
-    host_supported: true,
-    ramdisk_available: true,
-    vendor_ramdisk_available: true,
-    recovery_available: true,
-    native_bridge_supported: true,
-}

From 9ad453ffae7e03b1b3711d9a41ff6c5f8b3d6bc9 Mon Sep 17 00:00:00 2001
From: Siarhei Vishniakou <svv@google.com>
Date: Wed, 13 Nov 2024 00:55:32 +0000
Subject: [PATCH 1246/1487] Set input thread priority to RT - try 4

This reverts commit 52da71d47b8af5d3796cb0b4bb626de66a0a8435.

Reason for revert: camera was using its own stale copy of libprocessgroup, and now has revved up its version that includes the new parsing code. So this time the json file update should work OK.

Original description:

To improve input latency, set the critical input threads to RT priority.
This will use RT priority on AOSP devices by default. OEMs can still
choose to customize what "input policy" means for their device, which
may not necessarily mean RT.

For example, on device with multiple small / big cores, input task
affinity could be changed to prioritize big cores + higher CPU frequency
/ voltage, but still keep the standard / default input thread priority.

Note: there is an open issue where the thread priority is not remaining constant. See b/378761104.

Bug: 330719044
Bug: 378761104
Flag: com.android.input.flags.enable_input_policy_profile
Test: took perfetto trace and checked the priority on InputDispatcher
and InputReader threads.

Change-Id: I449be0eeeac989222f5deefa62615478bd65b968
---
 libprocessgroup/profiles/task_profiles.json | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index feda3b49c108..28902efe807d 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -202,6 +202,19 @@
         }
       ]
     },
+    {
+      "Name": "RealTimeInputScheduling",
+      "Actions": [
+        {
+          "Name": "SetSchedulerPolicy",
+          "Params":
+          {
+            "Policy": "SCHED_FIFO",
+            "Priority": "2"
+          }
+        }
+      ]
+    },
     {
       "Name": "CameraServicePerformance",
       "Actions": [
@@ -704,7 +717,7 @@
     },
     {
       "Name": "InputPolicy",
-      "Profiles": [ "MaxPerformance", "ProcessCapacityMax", "TimerSlackNormal" ]
+      "Profiles": [ "RealTimeInputScheduling", "MaxPerformance", "ProcessCapacityMax", "TimerSlackNormal" ]
     }
   ]
 }

From ac810ad71850e52d9d2d6c7cde22bbb78852eb33 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 12 Nov 2024 10:16:40 -0800
Subject: [PATCH 1247/1487] Move snapuserd_test to presubmit-large group

Bug: 338329603
Test: Build
Change-Id: I20d722a797093e40eb653a418a1963acf8c4292b
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/TEST_MAPPING | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index 192232d6c4b0..0b922c871495 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -27,7 +27,9 @@
     },
     {
       "name": "cow_api_test"
-    },
+    }
+  ],
+  "presubmit-large": [
     {
       "name": "snapuserd_test"
     }

From 1b5a7addd9eca8b5593fc8b24c86ec41d9904966 Mon Sep 17 00:00:00 2001
From: "Priyanka Advani (xWF)" <padvani@google.com>
Date: Wed, 13 Nov 2024 20:12:45 +0000
Subject: [PATCH 1248/1487] Revert "Move snapuserd_test to presubmit-large
 group"

This reverts commit ac810ad71850e52d9d2d6c7cde22bbb78852eb33.

Reason for revert: Droidmonitor created revert due to b/378924658. Will be verifying ABTD before submission.

Change-Id: Icb08a969ba13d863832a90d224f96fe60af9de4b
---
 fs_mgr/TEST_MAPPING | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index 0b922c871495..192232d6c4b0 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -27,9 +27,7 @@
     },
     {
       "name": "cow_api_test"
-    }
-  ],
-  "presubmit-large": [
+    },
     {
       "name": "snapuserd_test"
     }

From cbb59dd2408e77d2cb8b80112ec9903d4cb68109 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Thu, 14 Nov 2024 03:54:13 +0000
Subject: [PATCH 1249/1487] Add source of unwind when fatal error.

Sometimes the only log left is the errors messages. This means that
the information about why the unwind part of debuggerd is being called.
Therefore, add a little bit of extra information in the error message
to indicate why the unwind was triggered.

Bug: 377050125

Test: Forced the exec of the crash dump to fail and verified that the
Test: message is crash for a crash and unwind for debuggerd -b <PID>
Test: and debuggerd <PID>.
Change-Id: I0632ed9118c79caf4dabe6f174b25066fa9058fc
---
 debuggerd/handler/debuggerd_handler.cpp | 31 +++++++++++++++++--------
 1 file changed, 21 insertions(+), 10 deletions(-)

diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index ddc3244f19f8..88278ca667e8 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -389,6 +389,13 @@ static DebuggerdDumpType get_dump_type(const debugger_thread_info* thread_info)
   return kDebuggerdTombstoneProto;
 }
 
+static const char* get_unwind_type(const debugger_thread_info* thread_info) {
+  if (thread_info->siginfo->si_signo == BIONIC_SIGNAL_DEBUGGER) {
+    return "Unwind request";
+  }
+  return "Crash due to signal";
+}
+
 static int debuggerd_dispatch_pseudothread(void* arg) {
   debugger_thread_info* thread_info = static_cast<debugger_thread_info*>(arg);
 
@@ -502,8 +509,8 @@ static int debuggerd_dispatch_pseudothread(void* arg) {
 
     execle(CRASH_DUMP_PATH, CRASH_DUMP_NAME, main_tid, pseudothread_tid, debuggerd_dump_type,
            nullptr, nullptr);
-    async_safe_format_log(ANDROID_LOG_FATAL, "libc", "failed to exec crash_dump helper: %s",
-                          strerror(errno));
+    async_safe_format_log(ANDROID_LOG_FATAL, "libc", "%s: failed to exec crash_dump helper: %s",
+                          get_unwind_type(thread_info), strerror(errno));
     return 1;
   }
 
@@ -524,26 +531,30 @@ static int debuggerd_dispatch_pseudothread(void* arg) {
   } else {
     // Something went wrong, log it.
     if (rc == -1) {
-      async_safe_format_log(ANDROID_LOG_FATAL, "libc", "read of IPC pipe failed: %s",
-                            strerror(errno));
+      async_safe_format_log(ANDROID_LOG_FATAL, "libc", "%s: read of IPC pipe failed: %s",
+                            get_unwind_type(thread_info), strerror(errno));
     } else if (rc == 0) {
       async_safe_format_log(ANDROID_LOG_FATAL, "libc",
-                            "crash_dump helper failed to exec, or was killed");
+                            "%s: crash_dump helper failed to exec, or was killed",
+                            get_unwind_type(thread_info));
     } else if (rc != 1) {
       async_safe_format_log(ANDROID_LOG_FATAL, "libc",
-                            "read of IPC pipe returned unexpected value: %zd", rc);
+                            "%s: read of IPC pipe returned unexpected value: %zd",
+                            get_unwind_type(thread_info), rc);
     } else if (buf[0] != '\1') {
-      async_safe_format_log(ANDROID_LOG_FATAL, "libc", "crash_dump helper reported failure");
+      async_safe_format_log(ANDROID_LOG_FATAL, "libc", "%s: crash_dump helper reported failure",
+                            get_unwind_type(thread_info));
     }
   }
 
   // Don't leave a zombie child.
   int status;
   if (TEMP_FAILURE_RETRY(waitpid(crash_dump_pid, &status, 0)) == -1) {
-    async_safe_format_log(ANDROID_LOG_FATAL, "libc", "failed to wait for crash_dump helper: %s",
-                          strerror(errno));
+    async_safe_format_log(ANDROID_LOG_FATAL, "libc", "%s: failed to wait for crash_dump helper: %s",
+                          get_unwind_type(thread_info), strerror(errno));
   } else if (WIFSTOPPED(status) || WIFSIGNALED(status)) {
-    async_safe_format_log(ANDROID_LOG_FATAL, "libc", "crash_dump helper crashed or stopped");
+    async_safe_format_log(ANDROID_LOG_FATAL, "libc", "%s: crash_dump helper crashed or stopped",
+                          get_unwind_type(thread_info));
   }
 
   if (success) {

From 16693fae255a5a25dbb22ac5d48c7c1997099ff4 Mon Sep 17 00:00:00 2001
From: Alice Wang <aliceywang@google.com>
Date: Fri, 8 Nov 2024 12:19:10 +0000
Subject: [PATCH 1250/1487] Rename system property to enable KeyMint VM

This allows us to regroup Widevine VM under the same trusty
group.

Bug: 368502791
Test: launch_cvd --secure_hals=guest_keymint_trusty_insecure
Test: atest VtsAidlSharedSecretTargetTest
Change-Id: Ica76a896e99f70a64af229bda68622a2ce0dea1f
---
 ...are.security.keymint-service.rust.trusty.system.nonsecure.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
index ca6132e5eeb3..410e10a61e4e 100644
--- a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
+++ b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
@@ -11,7 +11,7 @@ service system.keymint.rust-trusty.nonsecure \
 # Only starts the non-secure KeyMint HALs when the KeyMint VM feature is enabled
 # TODO(b/357821690): Start the KeyMint HALs when the KeyMint VM is ready once the Trusty VM
 # has a mechanism to notify the host.
-on late-fs && property:ro.hardware.security.keymint.trusty.system=1 && \
+on late-fs && property:ro.hardware.trusty.security_vm.keymint.enabled=1 && \
    property:trusty.security_vm.vm_cid=*
     setprop system.keymint.trusty_ipc_dev VSOCK:${trusty.security_vm.vm_cid}:1
     start system.keymint.rust-trusty.nonsecure

From a4e852d032bdfd0febcbcb8a2a53dd4b85b3c027 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 14 Nov 2024 18:14:26 +0000
Subject: [PATCH 1251/1487] Stop explicitly adding bionic subdirectories to the
 include path.

Change-Id: I9961fa6ac957d8613f93fa33731da797f9ba8615
---
 fs_mgr/libsnapshot/snapuserd/Android.bp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 97cfe761677f..639116e8d9f4 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -89,7 +89,6 @@ cc_library_static {
         "libprocessgroup_util",
         "libjsoncpp",
     ],
-    include_dirs: ["bionic/libc/kernel"],
     export_include_dirs: ["include"],
     header_libs: [
         "libcutils_headers",
@@ -144,7 +143,6 @@ cc_defaults {
         "libstorage_literals_headers",
     ],
 
-    include_dirs: ["bionic/libc/kernel"],
     system_shared_libs: [],
 
     // snapuserd is started during early boot by first-stage init. At that
@@ -226,7 +224,6 @@ cc_defaults {
         "libz",
     ],
     include_dirs: [
-        "bionic/libc/kernel",
         ".",
     ],
     header_libs: [
@@ -324,7 +321,6 @@ cc_binary_host {
         "libz",
     ],
     include_dirs: [
-        "bionic/libc/kernel",
         ".",
     ],
     header_libs: [

From 03a14f5284b80dea659d2003cf8404f569f7d344 Mon Sep 17 00:00:00 2001
From: David Drysdale <drysdale@google.com>
Date: Thu, 14 Nov 2024 16:37:58 +0000
Subject: [PATCH 1252/1487] Declare support for v4 of KeyMint HAL

Bug: 377744414
Bug: 369375199
Test: vts_treble_vintf_vendor_test
Change-Id: I1fc04834819cc9291d89a6ee6803cbc5d5d91437
---
 .../android.hardware.security.keymint-service.rust.trusty.xml   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.xml b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.xml
index 3dc9c88ea8cf..f74d212855ab 100644
--- a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.xml
+++ b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.xml
@@ -1,7 +1,7 @@
 <manifest version="1.0" type="device">
     <hal format="aidl">
         <name>android.hardware.security.keymint</name>
-        <version>3</version>
+        <version>4</version>
         <fqname>IKeyMintDevice/default</fqname>
     </hal>
     <hal format="aidl">

From 9d062088260a9a50dd91d22869089c625c8628d6 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 14 Nov 2024 10:39:19 -0800
Subject: [PATCH 1253/1487] Fix failure in CowTest#InvalidMergeOrderTest.

This is failing on hwasan builds due to a typo in the test method. The
actual writer logic is unaffected.

Bug: 377298650
Test: valgrind cow_api_test
Change-Id: I5c3f32ae57bf90b9fd29c7446bf34bdcb004328c
---
 fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
index ce80cd705305..b7bc2c8b7023 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
@@ -1487,7 +1487,7 @@ TEST_F(CowTest, InvalidMergeOrderTest) {
     writer = std::make_unique<CowWriterV2>(options, GetCowFd());
     ASSERT_TRUE(writer->Initialize());
     ASSERT_TRUE(writer->AddCopy(2, 1));
-    ASSERT_TRUE(writer->AddXorBlocks(3, &data, data.size(), 1, 1));
+    ASSERT_TRUE(writer->AddXorBlocks(3, data.data(), data.size(), 1, 1));
     ASSERT_TRUE(writer->Finalize());
     ASSERT_TRUE(reader.Parse(cow_->fd));
     ASSERT_FALSE(reader.VerifyMergeOps());

From dd8edea8593f81f0abc0080d6aa503f6ffaa064d Mon Sep 17 00:00:00 2001
From: Douglas Anderson <dianders@google.com>
Date: Thu, 14 Nov 2024 13:53:54 -0800
Subject: [PATCH 1254/1487] init: Add NVME support to the `boot_part_uuid`
 method of managing boot devices

NVME devices have a subsystem of "class/nvme". Add that to the list of
subsystems we check so we can identify them properly.

Bug: 316324155
Test: Boot on a device with nvme
Change-Id: I2ab3f6890f62f525dba150a0368c666a1c4c875e
---
 init/devices.cpp | 18 +++++++++++++++---
 init/devices.h   |  1 +
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/init/devices.cpp b/init/devices.cpp
index 2cdececf6ca0..fafa58f455a7 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -193,9 +193,11 @@ BlockDeviceInfo DeviceHandler::GetBlockDeviceInfo(const std::string& uevent_path
     BlockDeviceInfo info;
 
     if (!boot_part_uuid_.empty()) {
-        // Only use the more specific "MMC" or "SCSI" match if a partition UUID
-        // was passed. Old bootloaders that aren't passing the partition UUID
-        // instead pass the path to the closest "platform" device. It would
+        // Only use the more specific "MMC" / "NVME" / "SCSI" match if a
+        // partition UUID was passed.
+        //
+        // Old bootloaders that aren't passing the partition UUID instead
+        // pass the path to the closest "platform" device. It would
         // break them if we chose this deeper (more specific) path.
         //
         // When we have a UUID we _want_ the more specific path since it can
@@ -204,6 +206,8 @@ BlockDeviceInfo DeviceHandler::GetBlockDeviceInfo(const std::string& uevent_path
         // classify them both the same by using the path to the USB controller.
         if (FindMmcDevice(uevent_path, &info.str)) {
             info.type = "mmc";
+        } else if (FindNvmeDevice(uevent_path, &info.str)) {
+            info.type = "nvme";
         } else if (FindScsiDevice(uevent_path, &info.str)) {
             info.type = "scsi";
         }
@@ -325,6 +329,14 @@ bool DeviceHandler::FindMmcDevice(const std::string& path, std::string* mmc_devi
     return FindSubsystemDevice(path, mmc_device_path, subsystem_paths);
 }
 
+bool DeviceHandler::FindNvmeDevice(const std::string& path, std::string* nvme_device_path) const {
+    const std::set<std::string> subsystem_paths = {
+            sysfs_mount_point_ + "/class/nvme",
+    };
+
+    return FindSubsystemDevice(path, nvme_device_path, subsystem_paths);
+}
+
 bool DeviceHandler::FindScsiDevice(const std::string& path, std::string* scsi_device_path) const {
     const std::set<std::string> subsystem_paths = {
             sysfs_mount_point_ + "/bus/scsi",
diff --git a/init/devices.h b/init/devices.h
index 67a3d00b1d47..b8f8e542f078 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -151,6 +151,7 @@ class DeviceHandler : public UeventHandler {
                              const std::set<std::string>& subsystem_paths) const;
     bool FindPlatformDevice(const std::string& path, std::string* platform_device_path) const;
     bool FindMmcDevice(const std::string& path, std::string* mmc_device_path) const;
+    bool FindNvmeDevice(const std::string& path, std::string* nvme_device_path) const;
     bool FindScsiDevice(const std::string& path, std::string* scsi_device_path) const;
     std::tuple<mode_t, uid_t, gid_t> GetDevicePermissions(
         const std::string& path, const std::vector<std::string>& links) const;

From 148c2531eef1881a5034615f8248bef2d0d92d7c Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 14 Nov 2024 22:43:16 +0000
Subject: [PATCH 1255/1487] libprocessgroup: Remove CGROUPS_RC_PATH

/dev/cgroup_info/cgroup.rc doesn't exist anymore!

Bug: 349105928
Change-Id: I2f49fab15d083f0c1617989ccf96ca843f998140
---
 libprocessgroup/include/processgroup/processgroup.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 805775744e32..85796ea8e911 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -57,8 +57,6 @@ __BEGIN_DECLS
 
 bool SetProcessProfilesCached(uid_t uid, pid_t pid, const std::vector<std::string>& profiles);
 
-[[deprecated]] static constexpr const char* CGROUPS_RC_PATH = "/dev/cgroup_info/cgroup.rc";
-
 bool UsePerAppMemcg();
 
 // Drop the fd cache of cgroup path. It is used for when resource caching is enabled and a process

From 9e5f74d4e466b00777667b147ca8eac77ea26805 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Wed, 7 Aug 2024 16:41:32 +0000
Subject: [PATCH 1256/1487] libprocessgroup: Remove CGROUPV2_CONTROLLER_NAME

This was deprecated a year ago, and should no longer be used.

Change-Id: I19c75e50fd3cc86734fa9cc7f3d883260b2484ca
---
 libprocessgroup/include/processgroup/processgroup.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 85796ea8e911..02f7c25086fb 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -27,7 +27,6 @@
 __BEGIN_DECLS
 
 static constexpr const char* CGROUPV2_HIERARCHY_NAME = "cgroup2";
-[[deprecated]] static constexpr const char* CGROUPV2_CONTROLLER_NAME = "cgroup2";
 
 bool CgroupsAvailable();
 bool CgroupGetControllerPath(const std::string& cgroup_name, std::string* path);

From b6071f19c318fd19ed37d9fa4ba0cf77d7d32d13 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Wed, 7 Aug 2024 16:35:55 +0000
Subject: [PATCH 1257/1487] libprocessgroup: Convert CGROUPV2_HIERARCHY_NAME to
 std::string

Almost everywhere CGROUPV2_HIERARCHY_NAME is used a std::string is
required, so change its type to avoid temporaries.

Change-Id: I4466838c510f2eb8212fc71999cdaa47359ce9c3
---
 libprocessgroup/include/processgroup/processgroup.h | 2 +-
 libprocessgroup/setup/cgroup_map_write.cpp          | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 02f7c25086fb..d27b56895046 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -26,7 +26,7 @@
 
 __BEGIN_DECLS
 
-static constexpr const char* CGROUPV2_HIERARCHY_NAME = "cgroup2";
+static constexpr std::string CGROUPV2_HIERARCHY_NAME = "cgroup2";
 
 bool CgroupsAvailable();
 bool CgroupGetControllerPath(const std::string& cgroup_name, std::string* path);
diff --git a/libprocessgroup/setup/cgroup_map_write.cpp b/libprocessgroup/setup/cgroup_map_write.cpp
index d05bf2408cee..c4e1fb68044e 100644
--- a/libprocessgroup/setup/cgroup_map_write.cpp
+++ b/libprocessgroup/setup/cgroup_map_write.cpp
@@ -222,7 +222,7 @@ static bool SetupCgroup(const CgroupDescriptor& descriptor) {
     const CgroupController* controller = descriptor.controller();
 
     if (controller->version() == 2) {
-        if (!strcmp(controller->name(), CGROUPV2_HIERARCHY_NAME)) {
+        if (controller->name() == CGROUPV2_HIERARCHY_NAME) {
             return MountV2CgroupController(descriptor);
         } else {
             return ActivateV2CgroupController(descriptor);

From fdf4432356ddb597f46cfb7b047ab4e0bb808ba2 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 14 Nov 2024 23:04:10 +0000
Subject: [PATCH 1258/1487] libprocessgroup: Remove __BEGIN_DECLS and
 __END_DECLS

These macros have been useless in this file since commit 82b72a566
("libprocessgroup: Add support for task profiles") in 2018 which added
C++ includes, and C++ types and keywords inside an extern "C" block.

Change-Id: Iae1cbfcc5cb974034d88fb466b79088496190940
---
 libprocessgroup/include/processgroup/processgroup.h | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index d27b56895046..6a026a717b4c 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -16,7 +16,6 @@
 
 #pragma once
 
-#include <sys/cdefs.h>
 #include <sys/types.h>
 #include <initializer_list>
 #include <span>
@@ -24,8 +23,6 @@
 #include <string_view>
 #include <vector>
 
-__BEGIN_DECLS
-
 static constexpr std::string CGROUPV2_HIERARCHY_NAME = "cgroup2";
 
 bool CgroupsAvailable();
@@ -39,8 +36,6 @@ bool SetTaskProfiles(pid_t tid, const std::vector<std::string>& profiles,
 bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles);
 bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles);
 
-__END_DECLS
-
 bool SetTaskProfiles(pid_t tid, std::initializer_list<std::string_view> profiles,
                      bool use_fd_cache = false);
 bool SetProcessProfiles(uid_t uid, pid_t pid, std::initializer_list<std::string_view> profiles);
@@ -50,7 +45,6 @@ bool SetTaskProfiles(pid_t tid, std::span<const std::string_view> profiles,
 bool SetProcessProfiles(uid_t uid, pid_t pid, std::span<const std::string_view> profiles);
 #endif
 
-__BEGIN_DECLS
 
 #ifndef __ANDROID_VNDK__
 
@@ -96,5 +90,3 @@ bool getAttributePathForTask(const std::string& attr_name, pid_t tid, std::strin
 bool isProfileValidForProcess(const std::string& profile_name, uid_t uid, pid_t pid);
 
 #endif // __ANDROID_VNDK__
-
-__END_DECLS

From 5996d608af75755f0c1964e62fe69482761efd24 Mon Sep 17 00:00:00 2001
From: Chan Wang <chanwang@google.com>
Date: Thu, 14 Nov 2024 13:25:37 +0000
Subject: [PATCH 1259/1487] Use the new 'partition' field in 'ApexInfo' to
 identify vendor apexes

A new field 'partition' was added to `ApexInfo` recently which stores
pre-installed partition information as string (e.g. 'SYSTEM') in
aosp/3335753. Using 'partition' field for Subcontext vendor apex
initialization because the existing field `preinstalledModulePath` won't
be populated for brand-new apex (a new type we introduced recently).

Bug: 377111286

Test: atest CtsInitTestCases
Change-Id: I8970b3cb5884bdb949035f5bdc5b2e18618cc9cc
---
 init/init.cpp                 |  3 +--
 init/subcontext.cpp           | 11 ++++++++---
 init/subcontext.h             |  6 +++++-
 init/subcontext_benchmark.cpp |  2 +-
 init/subcontext_test.cpp      | 15 ++++++++++++++-
 5 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/init/init.cpp b/init/init.cpp
index 17498da6dce4..5b0b0ddee12d 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -315,8 +315,7 @@ Parser CreateApexConfigParser(ActionManager& action_manager, ServiceList& servic
         if (apex_info_list.has_value()) {
             std::vector<std::string> subcontext_apexes;
             for (const auto& info : apex_info_list->getApexInfo()) {
-                if (info.hasPreinstalledModulePath() &&
-                    subcontext->PathMatchesSubcontext(info.getPreinstalledModulePath())) {
+                if (subcontext->PartitionMatchesSubcontext(info.getPartition())) {
                     subcontext_apexes.push_back(info.getModuleName());
                 }
             }
diff --git a/init/subcontext.cpp b/init/subcontext.cpp
index 6a095fb7ba88..3fe448fe342e 100644
--- a/init/subcontext.cpp
+++ b/init/subcontext.cpp
@@ -263,6 +263,10 @@ bool Subcontext::PathMatchesSubcontext(const std::string& path) const {
     return false;
 }
 
+bool Subcontext::PartitionMatchesSubcontext(const std::string& partition) const {
+    return std::find(partitions_.begin(), partitions_.end(), partition) != partitions_.end();
+}
+
 void Subcontext::SetApexList(std::vector<std::string>&& apex_list) {
     apex_list_ = std::move(apex_list);
 }
@@ -352,12 +356,13 @@ void InitializeSubcontext() {
     }
 
     if (SelinuxGetVendorAndroidVersion() >= __ANDROID_API_P__) {
-        subcontext.reset(
-                new Subcontext(std::vector<std::string>{"/vendor", "/odm"}, kVendorContext));
+        subcontext.reset(new Subcontext(std::vector<std::string>{"/vendor", "/odm"},
+                                        std::vector<std::string>{"VENDOR", "ODM"}, kVendorContext));
     }
 }
+
 void InitializeHostSubcontext(std::vector<std::string> vendor_prefixes) {
-    subcontext.reset(new Subcontext(vendor_prefixes, kVendorContext, /*host=*/true));
+    subcontext.reset(new Subcontext(vendor_prefixes, {}, kVendorContext, /*host=*/true));
 }
 
 Subcontext* GetSubcontext() {
diff --git a/init/subcontext.h b/init/subcontext.h
index 93ebacea27c0..23c4a241c98f 100644
--- a/init/subcontext.h
+++ b/init/subcontext.h
@@ -36,8 +36,10 @@ static constexpr const char kTestContext[] = "test-test-test";
 
 class Subcontext {
   public:
-    Subcontext(std::vector<std::string> path_prefixes, std::string_view context, bool host = false)
+    Subcontext(std::vector<std::string> path_prefixes, std::vector<std::string> partitions,
+               std::string_view context, bool host = false)
         : path_prefixes_(std::move(path_prefixes)),
+          partitions_(std::move(partitions)),
           context_(context.begin(), context.end()),
           pid_(0) {
         if (!host) {
@@ -49,6 +51,7 @@ class Subcontext {
     Result<std::vector<std::string>> ExpandArgs(const std::vector<std::string>& args);
     void Restart();
     bool PathMatchesSubcontext(const std::string& path) const;
+    bool PartitionMatchesSubcontext(const std::string& partition) const;
     void SetApexList(std::vector<std::string>&& apex_list);
 
     const std::string& context() const { return context_; }
@@ -59,6 +62,7 @@ class Subcontext {
     Result<SubcontextReply> TransmitMessage(const SubcontextCommand& subcontext_command);
 
     std::vector<std::string> path_prefixes_;
+    std::vector<std::string> partitions_;
     std::vector<std::string> apex_list_;
     std::string context_;
     pid_t pid_;
diff --git a/init/subcontext_benchmark.cpp b/init/subcontext_benchmark.cpp
index ccef2f36ac3c..172ee3173484 100644
--- a/init/subcontext_benchmark.cpp
+++ b/init/subcontext_benchmark.cpp
@@ -33,7 +33,7 @@ static void BenchmarkSuccess(benchmark::State& state) {
         return;
     }
 
-    auto subcontext = Subcontext({"path"}, context);
+    auto subcontext = Subcontext({"path"}, {"partition"}, context);
     free(context);
 
     while (state.KeepRunning()) {
diff --git a/init/subcontext_test.cpp b/init/subcontext_test.cpp
index da1f4555036b..85a2f2a944a4 100644
--- a/init/subcontext_test.cpp
+++ b/init/subcontext_test.cpp
@@ -41,7 +41,7 @@ namespace init {
 
 template <typename F>
 void RunTest(F&& test_function) {
-    auto subcontext = Subcontext({"dummy_path"}, kTestContext);
+    auto subcontext = Subcontext({"dummy_path"}, {"dummy_partition"}, kTestContext);
     ASSERT_NE(0, subcontext.pid());
 
     test_function(subcontext);
@@ -177,6 +177,19 @@ TEST(subcontext, ExpandArgsFailure) {
     });
 }
 
+TEST(subcontext, PartitionMatchesSubcontext) {
+    RunTest([](auto& subcontext) {
+        static auto& existent_partition = "dummy_partition";
+        static auto& non_existent_partition = "not_dummy_partition";
+
+        auto existent_result = subcontext.PartitionMatchesSubcontext(existent_partition);
+        auto non_existent_result = subcontext.PartitionMatchesSubcontext(non_existent_partition);
+
+        ASSERT_TRUE(existent_result);
+        ASSERT_FALSE(non_existent_result);
+    });
+}
+
 BuiltinFunctionMap BuildTestFunctionMap() {
     // For CheckDifferentPid
     auto do_return_pids_as_error = [](const BuiltinArguments& args) -> Result<void> {

From d02b74411b968a5e5792e25861f2c58f895f2bf5 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 14 Nov 2024 11:17:32 -0800
Subject: [PATCH 1260/1487] snapuserd: Change error message to verbose

These error logs gets printed even when I/O gracefully
terminates which might be confusing.

Bug: 377819507
Test: Build
Change-Id: I93d4ec2203566e75195215babc0042370be43ccb
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../libsnapshot/snapuserd/user-space-merge/merge_worker.cpp | 1 -
 .../snapuserd/user-space-merge/snapuserd_readahead.cpp      | 2 +-
 .../snapuserd/user-space-merge/snapuserd_transitions.cpp    | 6 ++++--
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index 486548cadb5b..a0c5c6658822 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -582,7 +582,6 @@ bool MergeWorker::Run() {
     pthread_setname_np(pthread_self(), "MergeWorker");
 
     if (!snapuserd_->WaitForMergeBegin()) {
-        SNAP_LOG(ERROR) << "Merge terminated early...";
         return true;
     }
     auto merge_thread_priority = android::base::GetUintProperty<uint32_t>(
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index 9a1d441c46a1..3007d45f4b76 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -702,7 +702,7 @@ bool ReadAhead::ReadAheadIOStart() {
     // window. If there is a crash during this time frame, merge should resume
     // based on the contents of the scratch space.
     if (!snapuserd_->WaitForMergeReady()) {
-        SNAP_LOG(ERROR) << "ReadAhead failed to wait for merge ready";
+        SNAP_LOG(VERBOSE) << "ReadAhead failed to wait for merge ready";
         return false;
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
index 2ad4ea1c29d6..714c64124fbd 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
@@ -202,7 +202,7 @@ bool SnapshotHandler::WaitForMergeBegin() {
     cv.wait(lock, [this]() -> bool { return MergeInitiated() || IsMergeBeginError(io_state_); });
 
     if (IsMergeBeginError(io_state_)) {
-        SNAP_LOG(ERROR) << "WaitForMergeBegin failed with state: " << io_state_;
+        SNAP_LOG(VERBOSE) << "WaitForMergeBegin failed with state: " << io_state_;
         return false;
     }
 
@@ -276,7 +276,9 @@ bool SnapshotHandler::WaitForMergeReady() {
         if (io_state_ == MERGE_IO_TRANSITION::MERGE_FAILED ||
             io_state_ == MERGE_IO_TRANSITION::MERGE_COMPLETE ||
             io_state_ == MERGE_IO_TRANSITION::IO_TERMINATED) {
-            SNAP_LOG(ERROR) << "Wait for merge ready failed: " << io_state_;
+            if (io_state_ == MERGE_IO_TRANSITION::MERGE_FAILED) {
+                SNAP_LOG(ERROR) << "Wait for merge ready failed: " << io_state_;
+            }
             return false;
         }
         return true;

From 6a5db6838514d92d9d2361810f9b96d5039e2801 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Fri, 15 Nov 2024 01:06:55 +0000
Subject: [PATCH 1261/1487] Remove non-UTF8 characters from string fields.

The string type in the tombstone proto does not support non-UTF8
characters. Therefore, use the oct_encode function to encode the
abort_message field and message field from LogMessage.

Fix up stl includes, add ones that were missing and remove those not
being used.

Add new unit test to verify that the abort and log messages are
sanitized.

Bug: 279496937
Bug: 377940849
Bug: 378185483

Test: All unit tests pass.
Test: Ran pbtombstone on a crash with non-UTF8 characters and verified
Test: it processes properly after this change and fails before the change.
Change-Id: I3554d56caf9fcbfc410b4d554f6c3b4888b37e28
---
 debuggerd/debuggerd_test.cpp                  | 27 +++++++++++++++++++
 .../include/libdebuggerd/utility_host.h       |  2 ++
 debuggerd/libdebuggerd/tombstone_proto.cpp    |  9 +++++--
 .../libdebuggerd/tombstone_proto_to_text.cpp  | 26 +++---------------
 debuggerd/libdebuggerd/utility_host.cpp       | 23 ++++++++++++++++
 5 files changed, 62 insertions(+), 25 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 13c8d70b5041..5bdc946463ec 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -3302,3 +3302,30 @@ TEST_F(CrasherTest, log_with_newline) {
   ASSERT_MATCH(result, ":\\s*This line has a newline.");
   ASSERT_MATCH(result, ":\\s*This is on the next line.");
 }
+
+TEST_F(CrasherTest, log_with_non_utf8) {
+  StartProcess([]() { LOG(FATAL) << "Invalid UTF-8: \xA0\xB0\xC0\xD0 and some other data."; });
+
+  unique_fd output_fd;
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  int intercept_result;
+  FinishIntercept(&intercept_result);
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  // Verify the abort message is sanitized properly.
+  size_t pos = result.find(
+      "Abort message: 'Invalid UTF-8: "
+      "\x5C\x32\x34\x30\x5C\x32\x36\x30\x5C\x33\x30\x30\x5C\x33\x32\x30 and some other data.'");
+  EXPECT_TRUE(pos != std::string::npos) << "Couldn't find sanitized abort message: " << result;
+
+  // Make sure that the log message is sanitized properly too.
+  EXPECT_TRUE(
+      result.find("Invalid UTF-8: \x5C\x32\x34\x30\x5C\x32\x36\x30\x5C\x33\x30\x30\x5C\x33\x32\x30 "
+                  "and some other data.",
+                  pos + 30) != std::string::npos)
+      << "Couldn't find sanitized log message: " << result;
+}
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/utility_host.h b/debuggerd/libdebuggerd/include/libdebuggerd/utility_host.h
index 43fb8bdc1687..df22e017ce3f 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/utility_host.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/utility_host.h
@@ -29,3 +29,5 @@ constexpr size_t kTagGranuleSize = 16;
 // Number of rows and columns to display in an MTE tag dump.
 constexpr size_t kNumTagColumns = 16;
 constexpr size_t kNumTagRows = 16;
+
+std::string oct_encode(const std::string& data);
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index d59358c65f4f..ef303f065c8b 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -34,10 +34,13 @@
 #include <sys/sysinfo.h>
 #include <time.h>
 
+#include <map>
 #include <memory>
 #include <optional>
 #include <set>
 #include <string>
+#include <utility>
+#include <vector>
 
 #include <async_safe/log.h>
 
@@ -463,7 +466,8 @@ static void dump_abort_message(Tombstone* tombstone,
   }
   msg.resize(index);
 
-  tombstone->set_abort_message(msg);
+  // Make sure only UTF8 characters are present since abort_message is a string.
+  tombstone->set_abort_message(oct_encode(msg));
 }
 
 static void dump_open_fds(Tombstone* tombstone, const OpenFilesList* open_files) {
@@ -771,7 +775,8 @@ static void dump_log_file(Tombstone* tombstone, const char* logger, pid_t pid) {
       log_msg->set_tid(log_entry.entry.tid);
       log_msg->set_priority(prio);
       log_msg->set_tag(tag);
-      log_msg->set_message(msg);
+      // Make sure only UTF8 characters are present since message is a string.
+      log_msg->set_message(oct_encode(msg));
     } while ((msg = nl));
   }
   android_logger_list_free(logger_list);
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index fedafc0c33fb..e885c5a73b14 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -19,9 +19,9 @@
 
 #include <inttypes.h>
 
-#include <charconv>
+#include <algorithm>
 #include <functional>
-#include <limits>
+#include <optional>
 #include <set>
 #include <string>
 #include <unordered_set>
@@ -32,6 +32,7 @@
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 
+#include "libdebuggerd/utility_host.h"
 #include "tombstone.pb.h"
 
 using android::base::StringAppendF;
@@ -418,27 +419,6 @@ static void print_memory_maps(CallbackType callback, const Tombstone& tombstone)
   }
 }
 
-static std::string oct_encode(const std::string& data) {
-  std::string oct_encoded;
-  oct_encoded.reserve(data.size());
-
-  // N.B. the unsigned here is very important, otherwise e.g. \255 would render as
-  // \-123 (and overflow our buffer).
-  for (unsigned char c : data) {
-    if (isprint(c)) {
-      oct_encoded += c;
-    } else {
-      std::string oct_digits("\\\0\0\0", 4);
-      // char is encodable in 3 oct digits
-      static_assert(std::numeric_limits<unsigned char>::max() <= 8 * 8 * 8);
-      auto [ptr, ec] = std::to_chars(oct_digits.data() + 1, oct_digits.data() + 4, c, 8);
-      oct_digits.resize(ptr - oct_digits.data());
-      oct_encoded += oct_digits;
-    }
-  }
-  return oct_encoded;
-}
-
 static void print_main_thread(CallbackType callback, SymbolizeCallbackType symbolize,
                               const Tombstone& tombstone, const Thread& thread) {
   print_thread_header(callback, tombstone, thread, true);
diff --git a/debuggerd/libdebuggerd/utility_host.cpp b/debuggerd/libdebuggerd/utility_host.cpp
index 72a560cfee73..4efa03c8cbb7 100644
--- a/debuggerd/libdebuggerd/utility_host.cpp
+++ b/debuggerd/libdebuggerd/utility_host.cpp
@@ -18,6 +18,8 @@
 
 #include <sys/prctl.h>
 
+#include <charconv>
+#include <limits>
 #include <string>
 
 #include <android-base/stringprintf.h>
@@ -99,3 +101,24 @@ std::string describe_pac_enabled_keys(long value) {
   DESCRIBE_FLAG(PR_PAC_APGAKEY);
   return describe_end(value, desc);
 }
+
+std::string oct_encode(const std::string& data) {
+  std::string oct_encoded;
+  oct_encoded.reserve(data.size());
+
+  // N.B. the unsigned here is very important, otherwise e.g. \255 would render as
+  // \-123 (and overflow our buffer).
+  for (unsigned char c : data) {
+    if (isprint(c)) {
+      oct_encoded += c;
+    } else {
+      std::string oct_digits("\\\0\0\0", 4);
+      // char is encodable in 3 oct digits
+      static_assert(std::numeric_limits<unsigned char>::max() <= 8 * 8 * 8);
+      auto [ptr, ec] = std::to_chars(oct_digits.data() + 1, oct_digits.data() + 4, c, 8);
+      oct_digits.resize(ptr - oct_digits.data());
+      oct_encoded += oct_digits;
+    }
+  }
+  return oct_encoded;
+}

From 28b2556e90dcad4e2ecaabb2e8f5413986dce1de Mon Sep 17 00:00:00 2001
From: Aeric <aeric.lin@nothing.tech>
Date: Mon, 18 Nov 2024 17:30:46 +0800
Subject: [PATCH 1262/1487] Fix typo of snapuserd_verify.h

"advisible" should be "advisable"
"fucntionality" should be "functionality"

Bug: 379603290
Test: build pass
Change-Id: I6c95f2b186f479ba51df8603ce87c0522e91bf64
---
 .../libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h
index 7c990851522e..b300a700093c 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h
@@ -62,8 +62,8 @@ class UpdateVerify {
      * (/proc/pressure/{cpu,memory}; and monitoring the Inactive(file) and
      * Active(file) pages from /proc/meminfo.
      *
-     * Additionally, for low memory devices, it is advisible to use O_DIRECT
-     * fucntionality for source block device.
+     * Additionally, for low memory devices, it is advisable to use O_DIRECT
+     * functionality for source block device.
      */
     int kMinThreadsToVerify = 1;
     int kMaxThreadsToVerify = 3;

From 6105d9dc8aeec5ef54092854121cd6ff5859f3a4 Mon Sep 17 00:00:00 2001
From: Gabriel Biren <gbiren@google.com>
Date: Mon, 18 Nov 2024 20:24:58 +0000
Subject: [PATCH 1263/1487] Create the mainline supplicant directory during
 initialization.

Bug: 365585450
Test: Manual test - verify that the mainline
      supplicant can add/remove interfaces
Change-Id: Ib41b361a8b032c04586f108be9d1933214934286
---
 rootdir/init.rc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 617e60a0ff9c..eeafd4c85e3a 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -781,6 +781,8 @@ on post-fs-data
     mkdir /data/misc/shared_relro 0771 shared_relro shared_relro
     mkdir /data/misc/systemkeys 0700 system system
     mkdir /data/misc/wifi 0770 wifi wifi
+    mkdir /data/misc/wifi/mainline_supplicant 0770 wifi wifi
+    mkdir /data/misc/wifi/mainline_supplicant/sockets 0770 wifi wifi
     mkdir /data/misc/wifi/sockets 0770 wifi wifi
     mkdir /data/misc/wifi/wpa_supplicant 0770 wifi wifi
     mkdir /data/misc/ethernet 0770 system system

From f1d00f0f2a897f76060b5083b9b0f9c051b16c51 Mon Sep 17 00:00:00 2001
From: Neill Kapron <nkapron@google.com>
Date: Tue, 19 Nov 2024 02:13:33 +0000
Subject: [PATCH 1264/1487] libcutils: create rust bindings for android ids

For work on the new rust based bpfloader, we need access to the IDs in
android_filesystem_config.h for owner/group permissions of pinned bpf
programs and maps. Create android_ids crate to expose this
information to rust.

Bug: 359646531
Test: Manual
Change-Id: Iee827d8a80a82fbee02a76280668071713625abf
Signed-off-by: Neill Kapron <nkapron@google.com>
---
 libcutils/Android.bp          | 11 +++++++++++
 libcutils/rust/aid_bindings.h | 16 ++++++++++++++++
 2 files changed, 27 insertions(+)
 create mode 100644 libcutils/rust/aid_bindings.h

diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index 10392889d8a4..ec9b754931ee 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -21,6 +21,17 @@ filegroup {
     srcs: ["include/private/android_filesystem_config.h"],
 }
 
+rust_bindgen {
+    name: "libandroid_ids",
+    crate_name: "android_ids",
+    source_stem: "bindings",
+    wrapper_src: "rust/aid_bindings.h",
+    header_libs: ["libcutils_headers"],
+    visibility: [
+        "//system/bpf/loader",
+    ],
+}
+
 cc_defaults {
     name: "libcutils_defaults",
     cflags: [
diff --git a/libcutils/rust/aid_bindings.h b/libcutils/rust/aid_bindings.h
new file mode 100644
index 000000000000..1b175a26f46e
--- /dev/null
+++ b/libcutils/rust/aid_bindings.h
@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <private/android_filesystem_config.h>

From 668ffc395d0c83c9e9cdcca972e35e936a5f85f0 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 18 Nov 2024 19:23:45 -0800
Subject: [PATCH 1265/1487] snapuserd: Use GTEST_SKIP in snapuserd_test.

The test harness treats an early exit as a failure, so use GTEST_SKIP()
instead.

Bug: 379242140
Test: vts_snapuserd_test
Change-Id: I25351bb7ebf65e6c56865662d297feb4a1f635b3
---
 .../user-space-merge/snapuserd_test.cpp       | 42 +++++++++++++++----
 1 file changed, 34 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 4dfb9bf4ef17..469fd091a47e 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -82,6 +82,8 @@ class SnapuserdTestBase : public ::testing::TestWithParam<TestParam> {
 
     unique_fd GetCowFd() { return unique_fd{dup(cow_system_->fd)}; }
 
+    bool ShouldSkipSetUp();
+
     std::unique_ptr<ITestHarness> harness_;
     size_t size_ = 10_MiB;
     int total_base_size_ = 0;
@@ -97,6 +99,10 @@ class SnapuserdTestBase : public ::testing::TestWithParam<TestParam> {
 };
 
 void SnapuserdTestBase::SetUp() {
+    if (ShouldSkipSetUp()) {
+        GTEST_SKIP() << "snapuserd not supported on this device";
+    }
+
 #if __ANDROID__
     harness_ = std::make_unique<DmUserTestHarness>();
 #else
@@ -104,6 +110,16 @@ void SnapuserdTestBase::SetUp() {
 #endif
 }
 
+bool SnapuserdTestBase::ShouldSkipSetUp() {
+#ifdef __ANDROID__
+    if (!android::snapshot::CanUseUserspaceSnapshots() ||
+        android::snapshot::IsVendorFromAndroid12()) {
+        return true;
+    }
+#endif
+    return false;
+}
+
 void SnapuserdTestBase::TearDown() {
     cow_system_ = nullptr;
 }
@@ -302,6 +318,9 @@ class SnapuserdTest : public SnapuserdTestBase {
 };
 
 void SnapuserdTest::SetUp() {
+    if (ShouldSkipSetUp()) {
+        GTEST_SKIP() << "snapuserd not supported on this device";
+    }
     ASSERT_NO_FATAL_FAILURE(SnapuserdTestBase::SetUp());
     handlers_ = std::make_unique<SnapshotHandlerManager>();
 }
@@ -312,6 +331,9 @@ void SnapuserdTest::TearDown() {
 }
 
 void SnapuserdTest::Shutdown() {
+    if (!handlers_) {
+        return;
+    }
     if (dmuser_dev_) {
         ASSERT_TRUE(dmuser_dev_->Destroy());
     }
@@ -1181,6 +1203,9 @@ void SnapuserdVariableBlockSizeTest::ReadSnapshotWithVariableBlockSize() {
 }
 
 void SnapuserdVariableBlockSizeTest::SetUp() {
+    if (ShouldSkipSetUp()) {
+        GTEST_SKIP() << "snapuserd not supported on this device";
+    }
     ASSERT_NO_FATAL_FAILURE(SnapuserdTest::SetUp());
 }
 
@@ -1244,6 +1269,9 @@ void HandlerTest::InitializeDevice() {
 }
 
 void HandlerTest::SetUp() {
+    if (ShouldSkipSetUp()) {
+        GTEST_SKIP() << "snapuserd not supported on this device";
+    }
     ASSERT_NO_FATAL_FAILURE(SnapuserdTestBase::SetUp());
     ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
     ASSERT_NO_FATAL_FAILURE(SetUpV2Cow());
@@ -1251,6 +1279,9 @@ void HandlerTest::SetUp() {
 }
 
 void HandlerTest::TearDown() {
+    if (ShouldSkipSetUp()) {
+        return;
+    }
     ASSERT_TRUE(factory_.DeleteQueue(system_device_ctrl_name_));
     ASSERT_TRUE(handler_thread_.get());
     SnapuserdTestBase::TearDown();
@@ -1326,6 +1357,9 @@ class HandlerTestV3 : public HandlerTest {
 };
 
 void HandlerTestV3::SetUp() {
+    if (ShouldSkipSetUp()) {
+        GTEST_SKIP() << "snapuserd not supported on this device";
+    }
     ASSERT_NO_FATAL_FAILURE(SnapuserdTestBase::SetUp());
     ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
     ASSERT_NO_FATAL_FAILURE(SetUpV3Cow());
@@ -1530,14 +1564,6 @@ INSTANTIATE_TEST_SUITE_P(Io, HandlerTest, ::testing::ValuesIn(GetTestConfigs()))
 int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
-#ifdef __ANDROID__
-    if (!android::snapshot::CanUseUserspaceSnapshots() ||
-        android::snapshot::IsVendorFromAndroid12()) {
-        std::cerr << "snapuserd_test not supported on this device\n";
-        return 0;
-    }
-#endif
-
     gflags::ParseCommandLineFlags(&argc, &argv, false);
 
     return RUN_ALL_TESTS();

From d17d5c585efe81d2e8a048efb919c2b7faabcb4a Mon Sep 17 00:00:00 2001
From: Eric Caruso <ejcaruso@google.com>
Date: Mon, 28 Oct 2024 15:30:11 -0400
Subject: [PATCH 1266/1487] ueventd: add support for driver section in
 ueventd.rc

Allow ueventd configuration to specify what to do with
devices based on driver. This responds to bind events and
treats them similarly to add events.

The format of the driver stanza is exactly the same as
that of the subsystem stanza.

Bug: 376900376
Test: set up cbc_mbim driver stanza and ensure it properly
  creates and destroys device nodes when a USB device with
  that driver appears and disappears or is bound and unbound

Change-Id: I31f5c91bd074d14075b74fe7beefaa6ac07a7ac9
---
 init/README.ueventd.md         | 16 +++++---
 init/block_dev_initializer.cpp |  3 +-
 init/devices.cpp               | 72 ++++++++++++++++++++++++++++++++--
 init/devices.h                 | 15 ++++++-
 init/uevent.h                  |  1 +
 init/uevent_listener.cpp       |  4 ++
 init/ueventd.cpp               |  4 +-
 init/ueventd_parser.cpp        |  2 +
 init/ueventd_parser.h          |  1 +
 init/ueventd_parser_test.cpp   | 56 +++++++++++++++++++++-----
 10 files changed, 151 insertions(+), 23 deletions(-)

diff --git a/init/README.ueventd.md b/init/README.ueventd.md
index aac4acb6aae0..0e84c6f5fc63 100644
--- a/init/README.ueventd.md
+++ b/init/README.ueventd.md
@@ -76,17 +76,17 @@ For example
 When `/dev/null` is created, its mode will be set to `0666`, its user to `root` and its group to
 `root`.
 
-The path can be modified using a ueventd.rc script and a `subsystem` section. There are three to set
-for a subsystem: the subsystem name, which device name to use, and which directory to place the
-device in. The section takes the below format of
+The path can be modified using a ueventd.rc script and a `subsystem` and/or `driver` section.
+There are three options to set for a subsystem or driver: the name, which device name to use,
+and which directory to place the device in. The section takes the below format of
 
     subsystem <subsystem_name>
       devname uevent_devname|uevent_devpath
       [dirname <directory>]
 
-`subsystem_name` is used to match uevent `SUBSYSTEM` value
+`subsystem_name` is used to match the uevent `SUBSYSTEM` value.
 
-`devname` takes one of three options
+`devname` takes one of three options:
   1. `uevent_devname` specifies that the name of the node will be the uevent `DEVNAME`
   2. `uevent_devpath` specifies that the name of the node will be basename uevent `DEVPATH`
   3. `sys_name` specifies that the name of the node will be the contents of `/sys/DEVPATH/name`
@@ -99,9 +99,13 @@ For example
     subsystem sound
       devname uevent_devpath
       dirname /dev/snd
-Indicates that all uevents with `SUBSYSTEM=sound` will create nodes as `/dev/snd/<basename uevent
+indicates that all uevents with `SUBSYSTEM=sound` will create nodes as `/dev/snd/<basename uevent
 DEVPATH>`.
 
+The `driver` section has the exact same structure as a `subsystem` section, but
+will instead match the `DRIVER` value in a `bind`/`unbind` uevent. However, the
+`driver` section will be ignored for block devices.
+
 ## /sys
 ----
 Ueventd by default takes no action for `/sys`, however it can be instructed to set permissions for
diff --git a/init/block_dev_initializer.cpp b/init/block_dev_initializer.cpp
index 7f83037ae7cc..deb68e9ac2fc 100644
--- a/init/block_dev_initializer.cpp
+++ b/init/block_dev_initializer.cpp
@@ -33,7 +33,8 @@ BlockDevInitializer::BlockDevInitializer() : uevent_listener_(16 * 1024 * 1024)
     auto boot_devices = android::fs_mgr::GetBootDevices();
     device_handler_ = std::make_unique<DeviceHandler>(
             std::vector<Permissions>{}, std::vector<SysfsPermissions>{}, std::vector<Subsystem>{},
-            std::move(boot_devices), android::fs_mgr::GetBootPartUuid(), false);
+            std::vector<Subsystem>{}, std::move(boot_devices), android::fs_mgr::GetBootPartUuid(),
+            false);
 }
 
 // If boot_part_uuid is specified, use it to set boot_devices
diff --git a/init/devices.cpp b/init/devices.cpp
index fafa58f455a7..aeaa4313393f 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -345,6 +345,26 @@ bool DeviceHandler::FindScsiDevice(const std::string& path, std::string* scsi_de
     return FindSubsystemDevice(path, scsi_device_path, subsystem_paths);
 }
 
+void DeviceHandler::TrackDeviceUevent(const Uevent& uevent) {
+    // No need to track any events if we won't bother handling any bind events
+    // later.
+    if (drivers_.size() == 0) return;
+
+    // Only track add, and not for block devices. We don't track remove because
+    // unbind events may arrive after remove events, so unbind will be the
+    // trigger to untrack those events.
+    if ((uevent.action != "add") || uevent.subsystem == "block" ||
+        (uevent.major < 0 || uevent.minor < 0)) {
+        return;
+    }
+
+    std::string path = sysfs_mount_point_ + uevent.path + "/device";
+    std::string device;
+    if (!Realpath(path, &device)) return;
+
+    tracked_uevents_.emplace_back(uevent, device);
+}
+
 void DeviceHandler::FixupSysPermissions(const std::string& upath,
                                         const std::string& subsystem) const {
     // upaths omit the "/sys" that paths in this list
@@ -664,12 +684,53 @@ bool DeviceHandler::CheckUeventForBootPartUuid(const Uevent& uevent) {
     return true;
 }
 
+void DeviceHandler::HandleBindInternal(std::string driver_name, std::string action,
+                                       const Uevent& uevent) {
+    if (uevent.subsystem == "block") {
+        LOG(FATAL) << "Tried to handle bind event for block device";
+    }
+
+    // Get tracked uevents for all devices that have this uevent's path as
+    // their canonical device path. Then handle those again if their driver
+    // is one of the ones we're interested in.
+    const auto driver = std::find(drivers_.cbegin(), drivers_.cend(), driver_name);
+    if (driver == drivers_.cend()) return;
+
+    std::string bind_path = sysfs_mount_point_ + uevent.path;
+    for (const TrackedUevent& tracked : tracked_uevents_) {
+        if (tracked.canonical_device_path != bind_path) continue;
+
+        LOG(VERBOSE) << "Propagating " << uevent.action << " as " << action << " for "
+                     << uevent.path;
+
+        std::string devpath = driver->ParseDevPath(tracked.uevent);
+        mkdir_recursive(Dirname(devpath), 0755);
+        HandleDevice(action, devpath, false, tracked.uevent.major, tracked.uevent.minor,
+                     std::vector<std::string>{});
+    }
+}
+
 void DeviceHandler::HandleUevent(const Uevent& uevent) {
     if (uevent.action == "add" || uevent.action == "change" || uevent.action == "bind" ||
         uevent.action == "online") {
         FixupSysPermissions(uevent.path, uevent.subsystem);
     }
 
+    if (uevent.action == "bind") {
+        bound_drivers_[uevent.path] = uevent.driver;
+        HandleBindInternal(uevent.driver, "add", uevent);
+        return;
+    } else if (uevent.action == "unbind") {
+        if (bound_drivers_.count(uevent.path) == 0) return;
+        HandleBindInternal(bound_drivers_[uevent.path], "remove", uevent);
+
+        std::string sys_path = sysfs_mount_point_ + uevent.path;
+        std::erase_if(tracked_uevents_, [&sys_path](const TrackedUevent& tracked) {
+            return sys_path == tracked.canonical_device_path;
+        });
+        return;
+    }
+
     // if it's not a /dev device, nothing to do
     if (uevent.major < 0 || uevent.minor < 0) return;
 
@@ -677,6 +738,8 @@ void DeviceHandler::HandleUevent(const Uevent& uevent) {
     std::vector<std::string> links;
     bool block = false;
 
+    TrackDeviceUevent(uevent);
+
     if (uevent.subsystem == "block") {
         block = true;
         devpath = "/dev/block/" + Basename(uevent.path);
@@ -725,10 +788,12 @@ void DeviceHandler::ColdbootDone() {
 
 DeviceHandler::DeviceHandler(std::vector<Permissions> dev_permissions,
                              std::vector<SysfsPermissions> sysfs_permissions,
-                             std::vector<Subsystem> subsystems, std::set<std::string> boot_devices,
-                             std::string boot_part_uuid, bool skip_restorecon)
+                             std::vector<Subsystem> drivers, std::vector<Subsystem> subsystems,
+                             std::set<std::string> boot_devices, std::string boot_part_uuid,
+                             bool skip_restorecon)
     : dev_permissions_(std::move(dev_permissions)),
       sysfs_permissions_(std::move(sysfs_permissions)),
+      drivers_(std::move(drivers)),
       subsystems_(std::move(subsystems)),
       boot_devices_(std::move(boot_devices)),
       boot_part_uuid_(boot_part_uuid),
@@ -744,7 +809,8 @@ DeviceHandler::DeviceHandler(std::vector<Permissions> dev_permissions,
 
 DeviceHandler::DeviceHandler()
     : DeviceHandler(std::vector<Permissions>{}, std::vector<SysfsPermissions>{},
-                    std::vector<Subsystem>{}, std::set<std::string>{}, "", false) {}
+                    std::vector<Subsystem>{}, std::vector<Subsystem>{}, std::set<std::string>{}, "",
+                    false) {}
 
 }  // namespace init
 }  // namespace android
diff --git a/init/devices.h b/init/devices.h
index b8f8e542f078..69a244978800 100644
--- a/init/devices.h
+++ b/init/devices.h
@@ -21,6 +21,7 @@
 #include <sys/types.h>
 
 #include <algorithm>
+#include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ -128,7 +129,7 @@ class DeviceHandler : public UeventHandler {
 
     DeviceHandler();
     DeviceHandler(std::vector<Permissions> dev_permissions,
-                  std::vector<SysfsPermissions> sysfs_permissions,
+                  std::vector<SysfsPermissions> sysfs_permissions, std::vector<Subsystem> drivers,
                   std::vector<Subsystem> subsystems, std::set<std::string> boot_devices,
                   std::string boot_part_uuid, bool skip_restorecon);
     virtual ~DeviceHandler() = default;
@@ -145,6 +146,11 @@ class DeviceHandler : public UeventHandler {
     bool IsBootDevice(const Uevent& uevent) const;
 
   private:
+    struct TrackedUevent {
+        Uevent uevent;
+        std::string canonical_device_path;
+    };
+
     void ColdbootDone() override;
     BlockDeviceInfo GetBlockDeviceInfo(const std::string& uevent_path) const;
     bool FindSubsystemDevice(std::string path, std::string* device_path,
@@ -163,14 +169,21 @@ class DeviceHandler : public UeventHandler {
     void FixupSysPermissions(const std::string& upath, const std::string& subsystem) const;
     void HandleAshmemUevent(const Uevent& uevent);
 
+    void TrackDeviceUevent(const Uevent& uevent);
+    void HandleBindInternal(std::string driver_name, std::string action, const Uevent& uevent);
+
     std::vector<Permissions> dev_permissions_;
     std::vector<SysfsPermissions> sysfs_permissions_;
+    std::vector<Subsystem> drivers_;
     std::vector<Subsystem> subsystems_;
     std::set<std::string> boot_devices_;
     std::string boot_part_uuid_;
     bool found_boot_part_uuid_;
     bool skip_restorecon_;
     std::string sysfs_mount_point_;
+
+    std::vector<TrackedUevent> tracked_uevents_;
+    std::map<std::string, std::string> bound_drivers_;
 };
 
 // Exposed for testing
diff --git a/init/uevent.h b/init/uevent.h
index c8ca52aaf517..e7ed2266e5ec 100644
--- a/init/uevent.h
+++ b/init/uevent.h
@@ -26,6 +26,7 @@ struct Uevent {
     std::string action;
     std::string path;
     std::string subsystem;
+    std::string driver;
     std::string firmware;
     std::string partition_name;
     std::string partition_uuid;
diff --git a/init/uevent_listener.cpp b/init/uevent_listener.cpp
index 97f3de64025e..d329c174fa91 100644
--- a/init/uevent_listener.cpp
+++ b/init/uevent_listener.cpp
@@ -36,6 +36,7 @@ static void ParseEvent(const char* msg, Uevent* uevent) {
     uevent->action.clear();
     uevent->path.clear();
     uevent->subsystem.clear();
+    uevent->driver.clear();
     uevent->firmware.clear();
     uevent->partition_name.clear();
     uevent->device_name.clear();
@@ -51,6 +52,9 @@ static void ParseEvent(const char* msg, Uevent* uevent) {
         } else if (!strncmp(msg, "SUBSYSTEM=", 10)) {
             msg += 10;
             uevent->subsystem = msg;
+        } else if (!strncmp(msg, "DRIVER=", 7)) {
+            msg += 7;
+            uevent->driver = msg;
         } else if (!strncmp(msg, "FIRMWARE=", 9)) {
             msg += 9;
             uevent->firmware = msg;
diff --git a/init/ueventd.cpp b/init/ueventd.cpp
index 286e4726668d..cb6b851d6850 100644
--- a/init/ueventd.cpp
+++ b/init/ueventd.cpp
@@ -364,8 +364,8 @@ int ueventd_main(int argc, char** argv) {
     std::unique_ptr<DeviceHandler> device_handler = std::make_unique<DeviceHandler>(
             std::move(ueventd_configuration.dev_permissions),
             std::move(ueventd_configuration.sysfs_permissions),
-            std::move(ueventd_configuration.subsystems), android::fs_mgr::GetBootDevices(),
-            android::fs_mgr::GetBootPartUuid(), true);
+            std::move(ueventd_configuration.drivers), std::move(ueventd_configuration.subsystems),
+            android::fs_mgr::GetBootDevices(), android::fs_mgr::GetBootPartUuid(), true);
     uevent_listener.RegenerateUevents([&](const Uevent& uevent) -> ListenerAction {
         bool uuid_check_done = device_handler->CheckUeventForBootPartUuid(uevent);
         return uuid_check_done ? ListenerAction::kStop : ListenerAction::kContinue;
diff --git a/init/ueventd_parser.cpp b/init/ueventd_parser.cpp
index 4395d8838386..097ef09d7ba7 100644
--- a/init/ueventd_parser.cpp
+++ b/init/ueventd_parser.cpp
@@ -264,6 +264,8 @@ UeventdConfiguration ParseConfig(const std::vector<std::string>& configs) {
     parser.AddSectionParser("import", std::make_unique<ImportParser>(&parser));
     parser.AddSectionParser("subsystem",
                             std::make_unique<SubsystemParser>(&ueventd_configuration.subsystems));
+    parser.AddSectionParser("driver",
+                            std::make_unique<SubsystemParser>(&ueventd_configuration.drivers));
 
     using namespace std::placeholders;
     parser.AddSingleLineParser(
diff --git a/init/ueventd_parser.h b/init/ueventd_parser.h
index 81f4e9d545e6..ffe6072dfe7d 100644
--- a/init/ueventd_parser.h
+++ b/init/ueventd_parser.h
@@ -27,6 +27,7 @@ namespace init {
 
 struct UeventdConfiguration {
     std::vector<Subsystem> subsystems;
+    std::vector<Subsystem> drivers;
     std::vector<SysfsPermissions> sysfs_permissions;
     std::vector<Permissions> dev_permissions;
     std::vector<std::string> firmware_directories;
diff --git a/init/ueventd_parser_test.cpp b/init/ueventd_parser_test.cpp
index 41924e2359e5..6d910398a635 100644
--- a/init/ueventd_parser_test.cpp
+++ b/init/ueventd_parser_test.cpp
@@ -106,7 +106,32 @@ subsystem test_devpath_dirname
             {"test_devname2", Subsystem::DEVNAME_UEVENT_DEVNAME, "/dev"},
             {"test_devpath_dirname", Subsystem::DEVNAME_UEVENT_DEVPATH, "/dev/graphics"}};
 
-    TestUeventdFile(ueventd_file, {subsystems, {}, {}, {}, {}, {}});
+    TestUeventdFile(ueventd_file, {subsystems, {}, {}, {}, {}, {}, {}});
+}
+
+TEST(ueventd_parser, Drivers) {
+    auto ueventd_file = R"(
+driver test_devname
+    devname uevent_devname
+
+driver test_devpath_no_dirname
+    devname uevent_devpath
+
+driver test_devname2
+    devname uevent_devname
+
+driver test_devpath_dirname
+    devname uevent_devpath
+    dirname /dev/graphics
+)";
+
+    auto drivers = std::vector<Subsystem>{
+            {"test_devname", Subsystem::DEVNAME_UEVENT_DEVNAME, "/dev"},
+            {"test_devpath_no_dirname", Subsystem::DEVNAME_UEVENT_DEVPATH, "/dev"},
+            {"test_devname2", Subsystem::DEVNAME_UEVENT_DEVNAME, "/dev"},
+            {"test_devpath_dirname", Subsystem::DEVNAME_UEVENT_DEVPATH, "/dev/graphics"}};
+
+    TestUeventdFile(ueventd_file, {{}, drivers, {}, {}, {}, {}, {}, {}});
 }
 
 TEST(ueventd_parser, Permissions) {
@@ -132,7 +157,7 @@ TEST(ueventd_parser, Permissions) {
             {"/sys/devices/virtual/*/input", "poll_delay", 0660, AID_ROOT, AID_INPUT, true},
     };
 
-    TestUeventdFile(ueventd_file, {{}, sysfs_permissions, permissions, {}, {}, {}});
+    TestUeventdFile(ueventd_file, {{}, {}, sysfs_permissions, permissions, {}, {}, {}});
 }
 
 TEST(ueventd_parser, FirmwareDirectories) {
@@ -148,7 +173,7 @@ firmware_directories /more
             "/more",
     };
 
-    TestUeventdFile(ueventd_file, {{}, {}, {}, firmware_directories, {}, {}});
+    TestUeventdFile(ueventd_file, {{}, {}, {}, {}, firmware_directories, {}, {}});
 }
 
 TEST(ueventd_parser, ExternalFirmwareHandlers) {
@@ -214,7 +239,7 @@ external_firmware_handler /devices/path/firmware/something004.bin radio radio "/
             },
     };
 
-    TestUeventdFile(ueventd_file, {{}, {}, {}, {}, external_firmware_handlers, {}});
+    TestUeventdFile(ueventd_file, {{}, {}, {}, {}, {}, external_firmware_handlers, {}});
 }
 
 TEST(ueventd_parser, ExternalFirmwareHandlersDuplicate) {
@@ -232,7 +257,7 @@ external_firmware_handler devpath root handler_path2
             },
     };
 
-    TestUeventdFile(ueventd_file, {{}, {}, {}, {}, external_firmware_handlers, {}});
+    TestUeventdFile(ueventd_file, {{}, {}, {}, {}, {}, external_firmware_handlers, {}});
 }
 
 TEST(ueventd_parser, ParallelRestoreconDirs) {
@@ -246,7 +271,7 @@ parallel_restorecon_dir /sys/devices
             "/sys/devices",
     };
 
-    TestUeventdFile(ueventd_file, {{}, {}, {}, {}, {}, parallel_restorecon_dirs});
+    TestUeventdFile(ueventd_file, {{}, {}, {}, {}, {}, {}, parallel_restorecon_dirs});
 }
 
 TEST(ueventd_parser, UeventSocketRcvbufSize) {
@@ -255,7 +280,7 @@ uevent_socket_rcvbuf_size 8k
 uevent_socket_rcvbuf_size 8M
 )";
 
-    TestUeventdFile(ueventd_file, {{}, {}, {}, {}, {}, {}, false, 8 * 1024 * 1024});
+    TestUeventdFile(ueventd_file, {{}, {}, {}, {}, {}, {}, {}, false, 8 * 1024 * 1024});
 }
 
 TEST(ueventd_parser, EnabledDisabledLines) {
@@ -265,7 +290,7 @@ parallel_restorecon enabled
 modalias_handling disabled
 )";
 
-    TestUeventdFile(ueventd_file, {{}, {}, {}, {}, {}, {}, false, 0, true});
+    TestUeventdFile(ueventd_file, {{}, {}, {}, {}, {}, {}, {}, false, 0, true});
 
     auto ueventd_file2 = R"(
 parallel_restorecon enabled
@@ -273,7 +298,7 @@ modalias_handling enabled
 parallel_restorecon disabled
 )";
 
-    TestUeventdFile(ueventd_file2, {{}, {}, {}, {}, {}, {}, true, 0, false});
+    TestUeventdFile(ueventd_file2, {{}, {}, {}, {}, {}, {}, {}, true, 0, false});
 }
 
 TEST(ueventd_parser, AllTogether) {
@@ -286,6 +311,9 @@ firmware_directories /first/ /second /third
 subsystem test_devname
     devname uevent_devname
 
+driver d_test_devpath
+    devname uevent_devpath
+
 /dev/graphics/*           0660   root       graphics
 
 subsystem test_devpath_no_dirname
@@ -303,6 +331,10 @@ subsystem test_devpath_dirname
     devname uevent_devpath
     dirname /dev/graphics
 
+driver d_test_devname_dirname
+    devname uevent_devname
+    dirname /dev/sound
+
 /dev/*/test               0660   root       system
 /sys/devices/virtual/*/input   poll_delay  0660  root   input    no_fnm_pathname
 firmware_directories /more
@@ -325,6 +357,10 @@ parallel_restorecon_dir /sys/devices
             {"test_devname2", Subsystem::DEVNAME_UEVENT_DEVNAME, "/dev"},
             {"test_devpath_dirname", Subsystem::DEVNAME_UEVENT_DEVPATH, "/dev/graphics"}};
 
+    auto drivers = std::vector<Subsystem>{
+            {"d_test_devpath", Subsystem::DEVNAME_UEVENT_DEVPATH, "/dev"},
+            {"d_test_devname_dirname", Subsystem::DEVNAME_UEVENT_DEVNAME, "/dev/graphics"}};
+
     auto permissions = std::vector<Permissions>{
             {"/dev/rtc0", 0640, AID_SYSTEM, AID_SYSTEM, false},
             {"/dev/graphics/*", 0660, AID_ROOT, AID_GRAPHICS, false},
@@ -356,7 +392,7 @@ parallel_restorecon_dir /sys/devices
     size_t uevent_socket_rcvbuf_size = 6 * 1024 * 1024;
 
     TestUeventdFile(ueventd_file,
-                    {subsystems, sysfs_permissions, permissions, firmware_directories,
+                    {subsystems, drivers, sysfs_permissions, permissions, firmware_directories,
                      external_firmware_handlers, parallel_restorecon_dirs, true,
                      uevent_socket_rcvbuf_size, true});
 }

From 44461354fda5b30194b04672bff0d954646d0b63 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Mon, 18 Nov 2024 19:23:45 -0800
Subject: [PATCH 1267/1487] snapuserd: Use GTEST_SKIP in snapuserd_test.

The test harness treats an early exit as a failure, so use GTEST_SKIP()
instead.

Bug: 379242140
Test: vts_snapuserd_test
Change-Id: I25351bb7ebf65e6c56865662d297feb4a1f635b3
(cherry picked from commit 668ffc395d0c83c9e9cdcca972e35e936a5f85f0)
---
 .../user-space-merge/snapuserd_test.cpp       | 42 +++++++++++++++----
 1 file changed, 34 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 271090fa581a..bd835e280add 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -81,6 +81,8 @@ class SnapuserdTestBase : public ::testing::TestWithParam<TestParam> {
 
     unique_fd GetCowFd() { return unique_fd{dup(cow_system_->fd)}; }
 
+    bool ShouldSkipSetUp();
+
     std::unique_ptr<ITestHarness> harness_;
     size_t size_ = 10_MiB;
     int total_base_size_ = 0;
@@ -96,6 +98,10 @@ class SnapuserdTestBase : public ::testing::TestWithParam<TestParam> {
 };
 
 void SnapuserdTestBase::SetUp() {
+    if (ShouldSkipSetUp()) {
+        GTEST_SKIP() << "snapuserd not supported on this device";
+    }
+
 #if __ANDROID__
     harness_ = std::make_unique<DmUserTestHarness>();
 #else
@@ -103,6 +109,16 @@ void SnapuserdTestBase::SetUp() {
 #endif
 }
 
+bool SnapuserdTestBase::ShouldSkipSetUp() {
+#ifdef __ANDROID__
+    if (!android::snapshot::CanUseUserspaceSnapshots() ||
+        android::snapshot::IsVendorFromAndroid12()) {
+        return true;
+    }
+#endif
+    return false;
+}
+
 void SnapuserdTestBase::TearDown() {
     cow_system_ = nullptr;
 }
@@ -301,6 +317,9 @@ class SnapuserdTest : public SnapuserdTestBase {
 };
 
 void SnapuserdTest::SetUp() {
+    if (ShouldSkipSetUp()) {
+        GTEST_SKIP() << "snapuserd not supported on this device";
+    }
     ASSERT_NO_FATAL_FAILURE(SnapuserdTestBase::SetUp());
     handlers_ = std::make_unique<SnapshotHandlerManager>();
 }
@@ -311,6 +330,9 @@ void SnapuserdTest::TearDown() {
 }
 
 void SnapuserdTest::Shutdown() {
+    if (!handlers_) {
+        return;
+    }
     if (dmuser_dev_) {
         ASSERT_TRUE(dmuser_dev_->Destroy());
     }
@@ -1180,6 +1202,9 @@ void SnapuserdVariableBlockSizeTest::ReadSnapshotWithVariableBlockSize() {
 }
 
 void SnapuserdVariableBlockSizeTest::SetUp() {
+    if (ShouldSkipSetUp()) {
+        GTEST_SKIP() << "snapuserd not supported on this device";
+    }
     ASSERT_NO_FATAL_FAILURE(SnapuserdTest::SetUp());
 }
 
@@ -1243,6 +1268,9 @@ void HandlerTest::InitializeDevice() {
 }
 
 void HandlerTest::SetUp() {
+    if (ShouldSkipSetUp()) {
+        GTEST_SKIP() << "snapuserd not supported on this device";
+    }
     ASSERT_NO_FATAL_FAILURE(SnapuserdTestBase::SetUp());
     ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
     ASSERT_NO_FATAL_FAILURE(SetUpV2Cow());
@@ -1250,6 +1278,9 @@ void HandlerTest::SetUp() {
 }
 
 void HandlerTest::TearDown() {
+    if (ShouldSkipSetUp()) {
+        return;
+    }
     ASSERT_TRUE(factory_.DeleteQueue(system_device_ctrl_name_));
     ASSERT_TRUE(handler_thread_.get());
     SnapuserdTestBase::TearDown();
@@ -1325,6 +1356,9 @@ class HandlerTestV3 : public HandlerTest {
 };
 
 void HandlerTestV3::SetUp() {
+    if (ShouldSkipSetUp()) {
+        GTEST_SKIP() << "snapuserd not supported on this device";
+    }
     ASSERT_NO_FATAL_FAILURE(SnapuserdTestBase::SetUp());
     ASSERT_NO_FATAL_FAILURE(CreateBaseDevice());
     ASSERT_NO_FATAL_FAILURE(SetUpV3Cow());
@@ -1528,14 +1562,6 @@ INSTANTIATE_TEST_SUITE_P(Io, HandlerTest, ::testing::ValuesIn(GetTestConfigs()))
 int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
-#ifdef __ANDROID__
-    if (!android::snapshot::CanUseUserspaceSnapshots() ||
-        android::snapshot::IsVendorFromAndroid12()) {
-        std::cerr << "snapuserd_test not supported on this device\n";
-        return 0;
-    }
-#endif
-
     gflags::ParseCommandLineFlags(&argc, &argv, false);
 
     return RUN_ALL_TESTS();

From 6028880ac00210661da0c9fa6a10324e1bfb41d3 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 12 Nov 2024 10:16:40 -0800
Subject: [PATCH 1268/1487] Move snapuserd_test to postsubmit

Bug: 338329603
Test: Build
Change-Id: Ibee6be732078ea7e11fe7348772837b9b2699fbf
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/TEST_MAPPING | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index 192232d6c4b0..13af1e2a3929 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -27,7 +27,9 @@
     },
     {
       "name": "cow_api_test"
-    },
+    }
+  ],
+  "postsubmit": [
     {
       "name": "snapuserd_test"
     }

From fdaaef95238d1de873040482938585cb01f724d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= <maze@google.com>
Date: Tue, 19 Nov 2024 19:24:54 +0000
Subject: [PATCH 1269/1487] Revert "libprocessgroup: Remove __BEGIN_DECLS and
 __END_DECLS"

This reverts commit fdf4432356ddb597f46cfb7b047ab4e0bb808ba2.

Reason for revert: b/379796721

Change-Id: I34cdc69d5b8d11446da02106b7bd593a8c8151c3
---
 libprocessgroup/include/processgroup/processgroup.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 6a026a717b4c..d27b56895046 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <sys/cdefs.h>
 #include <sys/types.h>
 #include <initializer_list>
 #include <span>
@@ -23,6 +24,8 @@
 #include <string_view>
 #include <vector>
 
+__BEGIN_DECLS
+
 static constexpr std::string CGROUPV2_HIERARCHY_NAME = "cgroup2";
 
 bool CgroupsAvailable();
@@ -36,6 +39,8 @@ bool SetTaskProfiles(pid_t tid, const std::vector<std::string>& profiles,
 bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles);
 bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles);
 
+__END_DECLS
+
 bool SetTaskProfiles(pid_t tid, std::initializer_list<std::string_view> profiles,
                      bool use_fd_cache = false);
 bool SetProcessProfiles(uid_t uid, pid_t pid, std::initializer_list<std::string_view> profiles);
@@ -45,6 +50,7 @@ bool SetTaskProfiles(pid_t tid, std::span<const std::string_view> profiles,
 bool SetProcessProfiles(uid_t uid, pid_t pid, std::span<const std::string_view> profiles);
 #endif
 
+__BEGIN_DECLS
 
 #ifndef __ANDROID_VNDK__
 
@@ -90,3 +96,5 @@ bool getAttributePathForTask(const std::string& attr_name, pid_t tid, std::strin
 bool isProfileValidForProcess(const std::string& profile_name, uid_t uid, pid_t pid);
 
 #endif // __ANDROID_VNDK__
+
+__END_DECLS

From 267207a1720927acfb575ea348a7067631be2c41 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 12 Nov 2024 14:26:46 -0800
Subject: [PATCH 1270/1487] use V4 Health HAL

use health HAL v4 for fastbootd, healthd, and storaged

Ignore-AOSP-First: deprecated_ota_test compilation
Bug: 371322457
Test: th
Change-Id: Ia941d67a5248641246a7298487c6a13fe92d8d66
---
 fastboot/Android.bp |  2 +-
 healthd/Android.bp  | 19 +++++++++++--------
 storaged/Android.bp |  4 ++--
 3 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/fastboot/Android.bp b/fastboot/Android.bp
index d3e058150c17..4d9898758b1c 100644
--- a/fastboot/Android.bp
+++ b/fastboot/Android.bp
@@ -170,7 +170,7 @@ cc_binary {
         "android.hardware.fastboot@1.1",
         "android.hardware.fastboot-V1-ndk",
         "android.hardware.health@2.0",
-        "android.hardware.health-V3-ndk",
+        "android.hardware.health-V4-ndk",
         "libasyncio",
         "libbase",
         "libbinder_ndk",
diff --git a/healthd/Android.bp b/healthd/Android.bp
index e158e07e4d52..7eb6edde1ec2 100644
--- a/healthd/Android.bp
+++ b/healthd/Android.bp
@@ -4,7 +4,10 @@ package {
 
 cc_defaults {
     name: "libbatterymonitor_defaults",
-    cflags: ["-Wall", "-Werror"],
+    cflags: [
+        "-Wall",
+        "-Werror",
+    ],
     vendor_available: true,
     recovery_available: true,
     export_include_dirs: ["include"],
@@ -76,7 +79,7 @@ cc_library_static {
     defaults: ["libbatterymonitor_defaults"],
     srcs: ["BatteryMonitor.cpp"],
     static_libs: [
-        "android.hardware.health-V3-ndk",
+        "android.hardware.health-V4-ndk",
     ],
     whole_static_libs: [
         // Need to translate HIDL to AIDL to support legacy APIs in
@@ -165,12 +168,12 @@ cc_library_static {
     defaults: ["libhealthd_charger_ui_defaults"],
 
     static_libs: [
-        "android.hardware.health-V3-ndk",
+        "android.hardware.health-V4-ndk",
         "android.hardware.health-translate-ndk",
     ],
 
     export_static_lib_headers: [
-        "android.hardware.health-V3-ndk",
+        "android.hardware.health-V4-ndk",
     ],
 }
 
@@ -242,7 +245,7 @@ cc_defaults {
     static_libs: [
         // common
         "android.hardware.health@1.0-convert",
-        "android.hardware.health-V3-ndk",
+        "android.hardware.health-V4-ndk",
         "libbatterymonitor",
         "libcharger_sysprop",
         "libhealthd_charger_nops",
@@ -287,8 +290,8 @@ cc_binary {
                 "libminui",
                 "libsuspend",
             ],
-        }
-    }
+        },
+    },
 }
 
 cc_test {
@@ -307,7 +310,7 @@ cc_test {
     defaults: ["charger_defaults"],
     srcs: [
         "AnimationParser_test.cpp",
-        "healthd_mode_charger_test.cpp"
+        "healthd_mode_charger_test.cpp",
     ],
     static_libs: [
         "android.hardware.health@1.0",
diff --git a/storaged/Android.bp b/storaged/Android.bp
index 357c0e601ed3..335874280d5e 100644
--- a/storaged/Android.bp
+++ b/storaged/Android.bp
@@ -24,7 +24,7 @@ cc_defaults {
     shared_libs: [
         "android.hardware.health@1.0",
         "android.hardware.health@2.0",
-        "android.hardware.health-V3-ndk",
+        "android.hardware.health-V4-ndk",
         "libbase",
         "libbinder",
         "libbinder_ndk",
@@ -47,7 +47,7 @@ cc_defaults {
         "-Wall",
         "-Werror",
         "-Wextra",
-        "-Wno-unused-parameter"
+        "-Wno-unused-parameter",
     ],
 }
 

From ae8313f8e694eeb019211066229ace7720dbe304 Mon Sep 17 00:00:00 2001
From: Vikram Auradkar <auradkar@google.com>
Date: Mon, 11 Nov 2024 15:27:34 -0800
Subject: [PATCH 1271/1487] libprefetch: library to prefetch data using
 tracing.

1: This supports "mem" tracing only.
2: Replay option is modified to use "pread" instead
of readahead.

A simple utility binary "prefetch" is built which links to the library.

The binary allows record, replay and verifying the generated
metadata.

Bug: 362507272
Test: cargo test passes all unit tests.

Verify record, replay and dump options:

./prefetch record --duration 10 --path /data/test/trace-test
./prefetch replay --path /data/test/trace-test
./prefetch dump /data/test/trace-test --format csv

Change-Id: I1661e49183c6120d2878510e609571fe6d608bb5
Signed-off-by: Vikram Auradkar <auradkar@google.com>
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 init/libprefetch/prefetch/Android.bp          |  80 ++
 init/libprefetch/prefetch/Cargo.lock          | 743 ++++++++++++++
 init/libprefetch/prefetch/Cargo.toml          |  51 +
 init/libprefetch/prefetch/OWNERS              |   3 +
 init/libprefetch/prefetch/prefetch.rc         |  13 +
 init/libprefetch/prefetch/src/args.rs         | 108 ++
 .../prefetch/src/args/args_argh.rs            | 217 ++++
 init/libprefetch/prefetch/src/error.rs        | 187 ++++
 init/libprefetch/prefetch/src/format.rs       | 823 +++++++++++++++
 init/libprefetch/prefetch/src/lib.rs          | 186 ++++
 init/libprefetch/prefetch/src/main.rs         |  41 +
 init/libprefetch/prefetch/src/replay.rs       | 762 ++++++++++++++
 init/libprefetch/prefetch/src/tracer/mem.rs   | 897 ++++++++++++++++
 init/libprefetch/prefetch/src/tracer/mod.rs   | 965 ++++++++++++++++++
 14 files changed, 5076 insertions(+)
 create mode 100644 init/libprefetch/prefetch/Android.bp
 create mode 100644 init/libprefetch/prefetch/Cargo.lock
 create mode 100644 init/libprefetch/prefetch/Cargo.toml
 create mode 100644 init/libprefetch/prefetch/OWNERS
 create mode 100644 init/libprefetch/prefetch/prefetch.rc
 create mode 100644 init/libprefetch/prefetch/src/args.rs
 create mode 100644 init/libprefetch/prefetch/src/args/args_argh.rs
 create mode 100644 init/libprefetch/prefetch/src/error.rs
 create mode 100644 init/libprefetch/prefetch/src/format.rs
 create mode 100644 init/libprefetch/prefetch/src/lib.rs
 create mode 100644 init/libprefetch/prefetch/src/main.rs
 create mode 100644 init/libprefetch/prefetch/src/replay.rs
 create mode 100644 init/libprefetch/prefetch/src/tracer/mem.rs
 create mode 100644 init/libprefetch/prefetch/src/tracer/mod.rs

diff --git a/init/libprefetch/prefetch/Android.bp b/init/libprefetch/prefetch/Android.bp
new file mode 100644
index 000000000000..778ea8a8c4ce
--- /dev/null
+++ b/init/libprefetch/prefetch/Android.bp
@@ -0,0 +1,80 @@
+//
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package {
+    default_team: "trendy_team_android_kernel",
+    default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+rust_library_rlib {
+    name: "libprefetch_rs",
+    crate_name: "prefetch_rs",
+    srcs: ["src/lib.rs"],
+    rustlibs: [
+        "libandroid_logger",
+        "libargh",
+        "libchrono",
+        "libcrc32fast",
+        "libcsv",
+        "liblibc",
+        "liblog_rust",
+        "liblru_cache",
+        "libnix",
+        "librand",
+        "librayon",
+        "libregex",
+        "libserde_cbor",
+        "libserde_json",
+        "libserde",
+        "libthiserror",
+        "libwalkdir",
+        "librustutils",
+    ],
+    prefer_rlib: true,
+    features: [
+        "derive",
+        "error-context",
+        "help",
+        "std",
+        "usage",
+        "use_argh",
+    ],
+}
+
+rust_binary {
+    name: "prefetch",
+    crate_name: "prefetch",
+    srcs: ["src/main.rs"],
+    rustlibs: [
+        "libprefetch_rs",
+        "liblog_rust",
+        "libandroid_logger",
+    ],
+    prefer_rlib: true,
+    features: [
+        "default",
+        "derive",
+        "error-context",
+        "help",
+        "std",
+        "usage",
+        "use_argh",
+    ],
+    init_rc: [
+        "prefetch.rc",
+    ],
+}
+
+// TODO: Add rust_test to enable unit testing - b/378554334
diff --git a/init/libprefetch/prefetch/Cargo.lock b/init/libprefetch/prefetch/Cargo.lock
new file mode 100644
index 000000000000..d6b214d26554
--- /dev/null
+++ b/init/libprefetch/prefetch/Cargo.lock
@@ -0,0 +1,743 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7404febffaa47dac81aa44dba71523c9d069b1bdc50a77db41195149e17f68e5"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "android_log-sys"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85965b6739a430150bdd138e2374a98af0c3ee0d030b3bb7fc3bddff58d0102e"
+
+[[package]]
+name = "android_logger"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9ed09b18365ed295d722d0b5ed59c01b79a826ff2d2a8f73d5ecca8e6fb2f66"
+dependencies = [
+ "android_log-sys",
+ "env_logger",
+ "lazy_static",
+ "log",
+]
+
+[[package]]
+name = "argh"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab257697eb9496bf75526f0217b5ed64636a9cfafa78b8365c71bd283fcef93e"
+dependencies = [
+ "argh_derive",
+ "argh_shared",
+]
+
+[[package]]
+name = "argh_derive"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b382dbd3288e053331f03399e1db106c9fb0d8562ad62cb04859ae926f324fa6"
+dependencies = [
+ "argh_shared",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "argh_shared"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5693f39141bda5760ecc4111ab08da40565d1771038c4a0250f03457ec707531"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi 0.1.19",
+ "libc",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "bincode"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b92615d57e4048e480bd7e3c2d7f6ec252819fffec95efbc30ec7c68744aa66c"
+dependencies = [
+ "byteorder",
+ "serde",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+
+[[package]]
+name = "bstr"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a40b47ad93e1a5404e6c18dec46b628214fee441c70f4ab5d6942142cc268a3d"
+dependencies = [
+ "lazy_static",
+ "memchr",
+ "regex-automata",
+ "serde",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
+
+[[package]]
+name = "chrono"
+version = "0.4.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
+dependencies = [
+ "libc",
+ "num-integer",
+ "num-traits",
+ "serde",
+ "time",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "176dc175b78f56c0f321911d9c8eb2b77a78a4860b9c19db83835fea1a46649b"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
+
+[[package]]
+name = "csv"
+version = "1.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1"
+dependencies = [
+ "bstr",
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "either"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
+
+[[package]]
+name = "env_logger"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "fuchsia-cprng"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
+
+[[package]]
+name = "getrandom"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "half"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d3d0e0f38255e7fa3cf31335b3a56f05febd18025f4db5ef7a0cfb4f8da651f"
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "itoa"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
+
+[[package]]
+name = "kernel32-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.162"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18d287de67fe55fd7e1581fe933d965a5a9477b38e949cfa9f8574ef01506398"
+
+[[package]]
+name = "linked-hash-map"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "lru-cache"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
+dependencies = [
+ "linked-hash-map",
+]
+
+[[package]]
+name = "memchr"
+version = "2.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"
+
+[[package]]
+name = "nix"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+dependencies = [
+ "hermit-abi 0.3.4",
+ "libc",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "prefetch"
+version = "0.1.0"
+dependencies = [
+ "android_logger",
+ "argh",
+ "bincode",
+ "chrono",
+ "crc32fast",
+ "csv",
+ "env_logger",
+ "libc",
+ "log",
+ "lru-cache",
+ "memchr",
+ "nix",
+ "proc-macro2",
+ "quote",
+ "rand 0.8.5",
+ "rayon",
+ "rayon-core",
+ "regex",
+ "serde",
+ "serde_cbor",
+ "serde_derive",
+ "serde_json",
+ "tempfile",
+ "thiserror",
+ "thiserror-impl",
+ "walkdir",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a152013215dca273577e18d2bf00fa862b89b24169fb78c4c95aeb07992c9cec"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.3.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64ac302d8f83c0c1974bf758f6b041c6c8ada916fbb44a609158ca8b064cc76c"
+dependencies = [
+ "libc",
+ "rand 0.4.6",
+]
+
+[[package]]
+name = "rand"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293"
+dependencies = [
+ "fuchsia-cprng",
+ "libc",
+ "rand_core 0.3.1",
+ "rdrand",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
+dependencies = [
+ "rand_core 0.4.2",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rayon"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b0d8e0819fadc20c74ea8373106ead0600e3a67ef1fe8da56e39b9ae7275674"
+dependencies = [
+ "autocfg",
+ "crossbeam-deque",
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ab346ac5921dc62ffa9f89b7a773907511cdfa5490c572ae9be1be33e8afa4a"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-utils",
+ "lazy_static",
+ "num_cpus",
+]
+
+[[package]]
+name = "rdrand"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
+dependencies = [
+ "rand_core 0.3.1",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.1.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
+
+[[package]]
+name = "regex"
+version = "1.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a26af418b574bd56588335b3a3659a65725d4e636eb1016c2f9e3b38c7cc759"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+
+[[package]]
+name = "ryu"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.123"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92d5161132722baa40d802cc70b15262b98258453e85e5d1d365c757c73869ae"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_cbor"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
+dependencies = [
+ "half",
+ "serde",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.123"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9391c295d64fc0abb2c556bad848f33cb8296276b1ad2677d1ae1ace4f258f31"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.62"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea1c6153794552ea7cf7cf63b1231a25de00ec90db326ba6264440fa08e31486"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d010a1623fbd906d51d650a9916aaefc05ffa0e4053ff7fe601167f3e715d194"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "tempfile"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11ce2fe9db64b842314052e2421ac61a73ce41b898dc8e3750398b219c5fc1e0"
+dependencies = [
+ "kernel32-sys",
+ "libc",
+ "rand 0.3.23",
+ "redox_syscall",
+ "winapi 0.2.8",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0f4a65597094d4483ddaed134f409b2cb7c1beccf25201a9f73c719254fa98e"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7765189610d8241a44529806d6fd1f2e0a08734313a35d5b3a556f92b381f3c0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "time"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
+dependencies = [
+ "libc",
+ "wasi 0.10.0+wasi-snapshot-preview1",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+
+[[package]]
+name = "walkdir"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.10.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "winapi"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-build"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
+dependencies = [
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/init/libprefetch/prefetch/Cargo.toml b/init/libprefetch/prefetch/Cargo.toml
new file mode 100644
index 000000000000..7da4fc68ba44
--- /dev/null
+++ b/init/libprefetch/prefetch/Cargo.toml
@@ -0,0 +1,51 @@
+[package]
+name = "prefetch"
+version = "0.1.0"
+edition = "2018"
+default-run = "prefetch"
+
+[lib]
+name = "prefetch_rs"
+path = "src/lib.rs"
+
+[[bin]]
+name = "prefetch"
+path = "src/main.rs"
+
+[features]
+default = ["use_argh"]
+use_argh = ["argh"]
+
+[dependencies]
+argh = { version = "0.1.10", optional = true }
+chrono = { version = "=0.4.19", features = ["serde"] }
+crc32fast = "1.2.1"
+csv = "=1.1.6"
+libc = "0.2.82"
+log = "=0.4.14"
+lru-cache = "0.1.2"
+memchr = "=2.3.4"
+nix = {version = "0.28", features = ["fs", "time", "feature", "mman", "uio"]}
+proc-macro2 = "=1.0.26"
+quote = "=1.0.9"
+rand = "0.8.3"
+rayon = "=1.5.0"
+rayon-core = "=1.9.0"
+regex = "1.4.5"
+serde = { version = "*", features = ["derive"] }
+serde_cbor = "0.11.2"
+serde_derive = "=1.0.123"
+serde_json = "=1.0.62"
+thiserror = "=1.0.24"
+thiserror-impl = "1.0.24"
+walkdir = "2.3.2"
+
+# crates required for android builds
+[target.'cfg(target_os = "android")'.dependencies]
+android_logger = "0.10.1"
+
+# crates not present in android builds
+[target.'cfg(not(target_os = "android"))'.dependencies]
+bincode = "=0.9.0"
+env_logger = "=0.8.4"
+tempfile = "2.2.0"
diff --git a/init/libprefetch/prefetch/OWNERS b/init/libprefetch/prefetch/OWNERS
new file mode 100644
index 000000000000..a1b54bf5cc8d
--- /dev/null
+++ b/init/libprefetch/prefetch/OWNERS
@@ -0,0 +1,3 @@
+akailash@google.com
+auradkar@google.com
+takayas@google.com
diff --git a/init/libprefetch/prefetch/prefetch.rc b/init/libprefetch/prefetch/prefetch.rc
new file mode 100644
index 000000000000..9f2cb7f46cdb
--- /dev/null
+++ b/init/libprefetch/prefetch/prefetch.rc
@@ -0,0 +1,13 @@
+service prefetch_record /system/bin/prefetch record --duration ${ro.prefetch_boot.duration_s:-0}
+    class main
+    user root
+    group root system
+    disabled
+    oneshot
+
+service prefetch_replay /system/bin/prefetch replay --io-depth ${ro.prefetch_boot.io_depth:-2} --max-fds ${ro.prefetch_boot.max_fds:-128}
+    class main
+    user root
+    group root system
+    disabled
+    oneshot
diff --git a/init/libprefetch/prefetch/src/args.rs b/init/libprefetch/prefetch/src/args.rs
new file mode 100644
index 000000000000..4c1e689193fd
--- /dev/null
+++ b/init/libprefetch/prefetch/src/args.rs
@@ -0,0 +1,108 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pub(crate) static DEFAULT_IO_DEPTH: u16 = 2;
+pub(crate) static DEFAULT_MAX_FDS: u16 = 128;
+pub(crate) static DEFAULT_EXIT_ON_ERROR: bool = false;
+
+mod args_argh;
+use args_argh as args_internal;
+
+use std::path::Path;
+use std::path::PathBuf;
+use std::process::exit;
+
+pub use args_internal::OutputFormat;
+pub use args_internal::ReplayArgs;
+pub use args_internal::TracerType;
+pub use args_internal::{DumpArgs, MainArgs, RecordArgs, SubCommands};
+use serde::Deserialize;
+use serde::Serialize;
+
+use crate::Error;
+use log::error;
+
+// Deserialized form of the config file
+#[derive(Clone, Debug, Default, Deserialize, Serialize, Eq, PartialEq)]
+pub struct ConfigFile {
+    // Files to be excluded in prefetch. These files might have been
+    // added in the record file while recording,but we do not want to
+    // replay these files. These can be two types of files:
+    // 1) installation-specific files (e.g. files in /data) and
+    // 2) large files which we do not want to load in replay (e.g. APK files).
+    pub files_to_exclude_regex: Vec<String>,
+    // Files that are not in the record file, but need to be loaded during replay
+    pub additional_replay_files: Vec<String>,
+}
+
+fn verify_and_fix(args: &mut MainArgs) -> Result<(), Error> {
+    match &mut args.nested {
+        SubCommands::Record(arg) => {
+            if arg.debug && arg.int_path.is_none() {
+                arg.int_path = Some(PathBuf::from(format!("{}.int", arg.path.to_str().unwrap())));
+            }
+
+            if let Some(p) = &arg.int_path {
+                ensure_path_doesnt_exist(p)?;
+            }
+        }
+        SubCommands::Replay(arg) => {
+            ensure_path_exists(&arg.path)?;
+            if !arg.config_path.as_os_str().is_empty() {
+                ensure_path_exists(&arg.config_path)?;
+            }
+        }
+        SubCommands::Dump(arg) => {
+            ensure_path_exists(&arg.path)?;
+        }
+    }
+    Ok(())
+}
+
+/// Returns error if the given path at `p` exist.
+pub(crate) fn ensure_path_doesnt_exist(p: &Path) -> Result<(), Error> {
+    if p.exists() {
+        Err(Error::InvalidArgs {
+            arg_name: "path".to_string(),
+            arg_value: p.display().to_string(),
+            error: "Path already exists".to_string(),
+        })
+    } else {
+        Ok(())
+    }
+}
+
+/// Returns error if the given path at `p` doesn't exist.
+pub(crate) fn ensure_path_exists(p: &Path) -> Result<(), Error> {
+    if p.is_file() {
+        Ok(())
+    } else {
+        Err(Error::InvalidArgs {
+            arg_name: "path".to_string(),
+            arg_value: p.display().to_string(),
+            error: "Path does not exist".to_string(),
+        })
+    }
+}
+
+/// Builds `MainArgs` from command line arguments. On error prints error/help message
+/// and exits.
+pub fn args_from_env() -> MainArgs {
+    let mut args = args_internal::args_from_env();
+    if let Err(e) = verify_and_fix(&mut args) {
+        error!("failed to verify args: {}", e);
+        exit(1);
+    }
+    args
+}
diff --git a/init/libprefetch/prefetch/src/args/args_argh.rs b/init/libprefetch/prefetch/src/args/args_argh.rs
new file mode 100644
index 000000000000..8ac95fce7a0c
--- /dev/null
+++ b/init/libprefetch/prefetch/src/args/args_argh.rs
@@ -0,0 +1,217 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::{option::Option, path::PathBuf, result::Result::Ok, str::FromStr};
+
+use argh::FromArgs;
+use serde::Deserialize;
+
+use crate::args::DEFAULT_EXIT_ON_ERROR;
+use crate::args::DEFAULT_IO_DEPTH;
+use crate::args::DEFAULT_MAX_FDS;
+use crate::Error;
+
+/// prefetch-rs
+#[derive(Eq, PartialEq, Debug, Default, FromArgs)]
+pub struct MainArgs {
+    /// subcommands
+    #[argh(subcommand)]
+    pub nested: SubCommands,
+}
+
+/// Sub commands for prefetch functions
+#[derive(Eq, PartialEq, Debug, FromArgs)]
+#[argh(subcommand)]
+pub enum SubCommands {
+    /// Records prefetch data.
+    Record(RecordArgs),
+    /// Replays from prefetch data
+    Replay(ReplayArgs),
+    /// Dump prefetch data in human readable format
+    Dump(DumpArgs),
+}
+
+impl Default for SubCommands {
+    fn default() -> Self {
+        Self::Dump(DumpArgs::default())
+    }
+}
+
+fn default_path() -> PathBuf {
+    PathBuf::from("/metadata/prefetch/prefetch.pack")
+}
+
+fn parse_tracing_instance(value: &str) -> Result<Option<String>, String> {
+    Ok(Some(value.to_string()))
+}
+
+#[derive(Eq, PartialEq, Debug, Default, FromArgs)]
+/// Records prefect data.
+#[argh(subcommand, name = "record")]
+pub struct RecordArgs {
+    /// duration in seconds to record the data
+    ///
+    /// On Android, if duration count is set to zero, recording
+    /// will continue until the property sys.boot_completed = 1.
+    #[argh(option)]
+    pub duration: u16,
+
+    /// file path where the records will be written to
+    ///
+    /// A new file is created at the given path. If the path exists, it
+    /// will be overwritten
+    #[argh(option, default = "default_path()")]
+    pub path: PathBuf,
+
+    /// when set an intermediate file will be created that provides more information
+    /// about collected data.
+    #[argh(option, default = "false")]
+    pub debug: bool,
+
+    /// file path where the intermediate file will be written to
+    ///
+    /// A new file is created at the given path. Errors out if the file
+    /// already exists.
+    #[argh(option)]
+    pub int_path: Option<PathBuf>,
+
+    /// size of the trace buffer which holds trace events. We need larger
+    /// buffer on a system that has faster disks or has large number of events
+    /// enabled. Defaults to TRACE_BUFFER_SIZE_KIB KiB.
+    #[argh(option, long = "trace-buffer-size")]
+    pub trace_buffer_size_kib: Option<u64>,
+
+    /// trace subsystem to use. "mem" subsystem is set by default.
+    #[argh(option, default = "Default::default()")]
+    pub tracing_subsystem: TracerType,
+
+    /// if true enables all the needed trace events. And at the end it restores
+    /// the values of those events.
+    /// If false, assumes that user has setup the needed trace events.
+    #[argh(option, default = "true")]
+    pub setup_tracing: bool,
+
+    /// if specified, works on a tracing instance (like /sys/kernel/tracing/instance/my_instance)
+    /// rather than using on shared global instance (i.e. /sys/kernel/tracing)."
+    #[argh(
+        option,
+        default = "Some(\"prefetch\".to_string())",
+        from_str_fn(parse_tracing_instance)
+    )]
+    pub tracing_instance: Option<String>,
+}
+
+/// Type of tracing subsystem to use.
+#[derive(Deserialize, Clone, Eq, PartialEq, Debug)]
+pub enum TracerType {
+    /// mem tracing subsystem relies on when a file's in-memory page gets added to the fs cache.
+    Mem,
+}
+
+impl FromStr for TracerType {
+    type Err = Error;
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        Ok(match s.to_lowercase().as_str() {
+            "mem" => Self::Mem,
+            _ => {
+                return Err(Error::InvalidArgs {
+                    arg_name: "tracing_subsystem".to_owned(),
+                    arg_value: s.to_owned(),
+                    error: "unknown value".to_owned(),
+                })
+            }
+        })
+    }
+}
+
+impl Default for TracerType {
+    fn default() -> Self {
+        Self::Mem
+    }
+}
+
+#[derive(Eq, PartialEq, Debug, Default, FromArgs)]
+/// Prefetch data from the recorded file.
+#[argh(subcommand, name = "replay")]
+pub struct ReplayArgs {
+    /// file path from where the records will be read
+    #[argh(option, default = "default_path()")]
+    pub path: PathBuf,
+
+    /// IO depth. Number of IO that can go in parallel.
+    #[argh(option, long = "io-depth", default = "DEFAULT_IO_DEPTH")]
+    pub io_depth: u16,
+
+    /// max number of open fds to cache
+    #[argh(option, arg_name = "max-fds", default = "DEFAULT_MAX_FDS")]
+    pub max_fds: u16,
+
+    /// if true, command exits on encountering any error.
+    ///
+    /// This defaults to false as there is not harm prefetching if we encounter
+    /// non-fatal errors.
+    #[argh(option, default = "DEFAULT_EXIT_ON_ERROR")]
+    pub exit_on_error: bool,
+
+    /// file path from where the prefetch config file will be read
+    #[argh(option, default = "PathBuf::new()")]
+    pub config_path: PathBuf,
+}
+
+/// dump records file in given format
+#[derive(Eq, PartialEq, Debug, Default, FromArgs)]
+#[argh(subcommand, name = "dump")]
+pub struct DumpArgs {
+    /// file path from where the records will be read
+    #[argh(option)]
+    pub path: PathBuf,
+    /// output format. One of json or csv.
+    /// Note: In csv format, few fields are excluded from the output.
+    #[argh(option)]
+    pub format: OutputFormat,
+}
+
+#[derive(Deserialize, Eq, PartialEq, Debug)]
+pub enum OutputFormat {
+    Json,
+    Csv,
+}
+
+impl FromStr for OutputFormat {
+    type Err = Error;
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        Ok(match s.to_lowercase().as_str() {
+            "csv" => Self::Csv,
+            "json" => Self::Json,
+            _ => {
+                return Err(Error::InvalidArgs {
+                    arg_name: "format".to_owned(),
+                    arg_value: s.to_owned(),
+                    error: "unknown value".to_owned(),
+                })
+            }
+        })
+    }
+}
+
+impl Default for OutputFormat {
+    fn default() -> Self {
+        Self::Json
+    }
+}
+
+/// Build args struct from command line arguments
+pub fn args_from_env() -> MainArgs {
+    argh::from_env()
+}
diff --git a/init/libprefetch/prefetch/src/error.rs b/init/libprefetch/prefetch/src/error.rs
new file mode 100644
index 000000000000..8dd938a7e1ac
--- /dev/null
+++ b/init/libprefetch/prefetch/src/error.rs
@@ -0,0 +1,187 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use thiserror::Error;
+
+use crate::{format::FileId, InodeInfo};
+
+/// Enumerates all possible errors returned by this library.
+#[derive(Debug, Error)]
+pub enum Error {
+    /// Represents a failure to open a file.
+    #[error("Open error: {path}: {source}")]
+    Open {
+        /// The IO error
+        source: std::io::Error,
+        /// Path on which the operation failed.
+        path: String,
+    },
+
+    /// Represents a failure to create a file.
+    #[error("Create error. {path} {source}")]
+    Create {
+        /// The IO error
+        source: std::io::Error,
+        /// Path on which the operation failed.
+        path: String,
+    },
+
+    /// Represents a failure to read trace file.
+    #[error("Read error. {error}")]
+    Read {
+        /// Detailed error message.
+        error: String,
+    },
+
+    /// Represents a failure to write to a file.
+    #[error("Write error. {source}")]
+    Write {
+        /// The IO error
+        source: std::io::Error,
+
+        /// file path
+        path: String,
+    },
+
+    /// Represents a failure to delete a file.
+    #[error("Delete error. {path} {source}")]
+    Delete {
+        /// The IO error
+        source: std::io::Error,
+        /// Path on which the operation failed.
+        path: String,
+    },
+
+    /// Represents a failure to stat a file.
+    #[error("Stat error. {path} {source}")]
+    Stat {
+        /// The IO error
+        source: std::io::Error,
+        /// Path on which the operation failed.
+        path: String,
+    },
+
+    /// Represents a failure to stat a file.
+    #[error("clone failed. {id} {source}")]
+    FileClone {
+        /// The IO error
+        source: std::io::Error,
+        /// File id for which we could not clone the file.
+        id: FileId,
+    },
+
+    /// Represents a failure to mmap a file.
+    #[error("mmap failed. {path} {error}")]
+    Mmap {
+        /// Detailed error message.
+        error: String,
+        /// Path on which the operation failed.
+        path: String,
+    },
+
+    /// Represents a failure to munmap a file.
+    #[error("munmap failed. {length} {error}")]
+    Munmap {
+        /// Detailed error message.
+        error: String,
+        /// Size of file which this munmap failed
+        length: usize,
+    },
+
+    /// Represents all other cases of `std::io::Error`.
+    ///
+    #[error(transparent)]
+    IoError(
+        /// The IO error
+        #[from]
+        std::io::Error,
+    ),
+
+    /// Represents a failure to map FileId to path
+    ///
+    #[error("Failed to map id to path: {id}")]
+    IdNoFound {
+        /// File id for which path lookup failed.
+        id: FileId,
+    },
+
+    /// Indicates that the file is skipped for prefetching
+    /// because it is in the exclude files list.
+    ///
+    #[error("Skipped prefetching file from path: {path}")]
+    SkipPrefetch {
+        /// Path to file for which prefetching is skipped.
+        path: String,
+    },
+
+    /// Represents spurious InodeInfo or missing Record.
+    ///
+    #[error(
+        "Stale inode(s) info found.\n\
+            missing_file_ids: {missing_file_ids:#?}\n\
+            stale_inodes: {stale_inodes:#?} \n\
+            missing_paths:{missing_paths:#?}"
+    )]
+    StaleInode {
+        /// FileIds for which InodeInfo is missing.
+        missing_file_ids: Vec<FileId>,
+
+        /// InodeInfos for which no records exist.
+        stale_inodes: Vec<InodeInfo>,
+
+        /// InodeInfos in which no paths were found.
+        missing_paths: Vec<InodeInfo>,
+    },
+
+    /// Represents a failure to serialize records file.
+    #[error("Serialize error: {error}")]
+    Serialize {
+        /// Detailed error message.
+        error: String,
+    },
+
+    /// Represents a failure to deserialize records file.
+    #[error("Deserialize error: {error}")]
+    Deserialize {
+        /// Detailed error message.
+        error: String,
+    },
+
+    /// Represents a failure from thread pool.
+    #[error("Thread pool error: {error}")]
+    ThreadPool {
+        /// Detailed error message.
+        error: String,
+    },
+
+    /// Represents a failure to setup file.
+    #[error("Failed to setup prefetch: {error}")]
+    Custom {
+        /// Detailed error message.
+        error: String,
+    },
+
+    /// Represents a failure to parse args.
+    #[error("Failed to parse arg:{arg_name} value:{arg_value} error:{error}")]
+    InvalidArgs {
+        /// Arg name.
+        arg_name: String,
+
+        /// Arg value.
+        arg_value: String,
+
+        /// Detailed error message.
+        error: String,
+    },
+}
diff --git a/init/libprefetch/prefetch/src/format.rs b/init/libprefetch/prefetch/src/format.rs
new file mode 100644
index 000000000000..ac89a74ebcd7
--- /dev/null
+++ b/init/libprefetch/prefetch/src/format.rs
@@ -0,0 +1,823 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::cmp::{max, min};
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::fmt;
+use std::fmt::Display;
+use std::fs::{File, Metadata, OpenOptions};
+use std::hash::Hash;
+use std::io::Write;
+use std::ops::{Deref, DerefMut};
+use std::os::unix::fs::MetadataExt;
+use std::time::SystemTime;
+
+use crc32fast::Hasher;
+use log::debug;
+use regex::Regex;
+use serde::Deserializer;
+use serde::Serialize;
+use serde::{Deserialize, Serializer};
+
+use crate::error::Error;
+
+static MAGIC_UUID: [u8; 16] = [
+    0x10, 0x54, 0x3c, 0xb8, 0x60, 0xdb, 0x49, 0x45, 0xa1, 0xd5, 0xde, 0xa7, 0xd2, 0x3b, 0x05, 0x49,
+];
+static MAJOR_VERSION: u16 = 0;
+static MINOR_VERSION: u16 = 1;
+
+/// Represents inode number which is unique within a filesystem.
+pub(crate) type InodeNumber = u64;
+
+/// Represents device number which is unique for given block device.
+pub(crate) type DeviceNumber = u64;
+
+/// Convenience name for string that represents a path.
+pub(crate) type PathString = String;
+
+/// Represents unique file id across filesystems.
+#[derive(Clone, Debug, Deserialize, Eq, Hash, Default, PartialEq, PartialOrd, Ord, Serialize)]
+pub struct FileId(pub u64);
+
+impl Display for FileId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+fn serialize_hashmap<S, K: Ord + Serialize + Clone, V: Serialize + Clone>(
+    value: &HashMap<K, V>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let mut btree = BTreeMap::new();
+    for (k, v) in value {
+        btree.insert(k.clone(), v.clone());
+    }
+    btree.serialize(serializer)
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+pub(crate) struct SerializableHashMap<
+    K: Ord + Serialize + Clone + Hash + PartialEq,
+    V: Serialize + Clone,
+> {
+    #[serde(serialize_with = "serialize_hashmap")]
+    pub map: HashMap<K, V>,
+}
+
+impl<K, V> Deref for SerializableHashMap<K, V>
+where
+    K: Ord + Serialize + Clone + Hash + PartialEq,
+    V: Serialize + Clone,
+{
+    type Target = HashMap<K, V>;
+    fn deref(&self) -> &Self::Target {
+        &self.map
+    }
+}
+
+impl<K, V> DerefMut for SerializableHashMap<K, V>
+where
+    K: Ord + Serialize + Clone + Hash + PartialEq,
+    V: Serialize + Clone,
+{
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.map
+    }
+}
+
+/// The InodeInfo is unique per (device, inode) combination. It is
+/// used to verify that we are prefetching a file for which we generated
+/// the records for.
+/// `Record` refers to this information with a unique `FileId`.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+pub struct InodeInfo {
+    // Inode number of the file.
+    pub(crate) inode_number: InodeNumber,
+
+    // File size in bytes.
+    pub(crate) file_size: u64,
+
+    // Helps to get to a file from a Record. The field is used to get to the file
+    // that needs to be prefetched.
+    //
+    // This struct is built by getting data from trace lines and querying filesystem
+    // for other fields about the file/inode.
+    //
+    // One instance per file to be prefetched. A file/inode can have multiple paths.
+    // We store multiple paths so that we can still get to it if some of the
+    // paths get deleted.
+    //
+    // See comments for `Record`.
+    #[serde(deserialize_with = "check_inode_info_paths")]
+    pub(crate) paths: Vec<PathString>,
+
+    // Block device number on which the file is located.
+    pub(crate) device_number: DeviceNumber,
+}
+
+impl InodeInfo {
+    /// Returns InodeInfo.
+    pub fn new(
+        inode_number: InodeNumber,
+        file_size: u64,
+        paths: Vec<String>,
+        device_number: DeviceNumber,
+    ) -> Self {
+        Self { inode_number, file_size, paths, device_number }
+    }
+}
+
+// Helps us check block alignment.
+//
+// A records file can have multiple FsInfos.
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+pub struct FsInfo {
+    // This is filesystem block size and is not underlying device's block size
+    pub(crate) block_size: u64,
+}
+
+/// Prefetch record.
+/// Each record translates to one filesystem `read()` request.
+///
+/// Tracer builds `Record` by parsing trace lines or by querying filesystem.
+///
+/// Multiple `Record`s can belong to a single InodeInfo. For example if there were two
+/// reads for file `/data/my.apk` which is assigned FileId 10 at offsets 0 and 8k of length
+/// 1 byte each then we will have two `Records` in `RecordsFile` that look like
+/// `Record {file_id: 10, offset: 0, length: 1, timestamp: t1}`
+/// `Record {file_id: 10, offset: 8192, length: 1, timestamp: t2}`
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+pub struct Record {
+    /// Points to the file that should be fetched./ file_id is unique per `InodeInfo`
+    /// in a `RecordsFile`
+    pub file_id: FileId,
+
+    /// start offset to fetch data from. This is FsInfo.block_size aligned.
+    pub offset: u64,
+
+    /// length of the read. This is generally rounded up to Fs.Info.block_size
+    /// except when the rounding up crosses `InodeInfo.file_size`
+    pub length: u64,
+
+    /// Timestamp in nanoseconds since the start when the data was loaded.
+    pub timestamp: u64,
+}
+
+impl Record {
+    /// Returns a new record if two records belong to same file and overlap.
+    fn overlaps(&self, other: &Self) -> Option<Self> {
+        if self.file_id == other.file_id {
+            let self_start = self.offset;
+            let self_end = self.offset + self.length;
+            let other_start = other.offset;
+            let other_end = other.offset + other.length;
+
+            if (self_start <= other_end) && (self_end >= other_start) {
+                let offset = min(self_start, other_start);
+                let length = max(self_end, other_end) - offset;
+                return Some(Self {
+                    file_id: self.file_id.clone(),
+                    offset,
+                    length,
+                    timestamp: min(self.timestamp, other.timestamp),
+                });
+            }
+        }
+        None
+    }
+}
+
+fn group_record_by_file_id(records: Vec<Record>) -> Vec<Record> {
+    let mut map: HashMap<FileId, BTreeMap<u64, Record>> = HashMap::new();
+
+    for record in &records {
+        let recs = map.entry(record.file_id.clone()).or_default();
+        recs.entry(record.offset).or_insert_with(|| record.clone());
+    }
+
+    let mut grouped = vec![];
+    for record in &records {
+        if let Some(inode) = map.get(&record.file_id) {
+            for rec in inode.values() {
+                grouped.push(rec.clone());
+            }
+        }
+        let _ = map.remove(&record.file_id);
+    }
+
+    grouped
+}
+
+/// When records are coalesced, because their file ids match and IO offsets overlap, the least
+/// timestamp of the coalesced records is retained.
+pub(crate) fn coalesce_records(records: Vec<Record>, group_by_file_id: bool) -> Vec<Record> {
+    let records = if group_by_file_id { group_record_by_file_id(records) } else { records };
+
+    let mut coalesced = vec![];
+    let mut current: Option<Record> = None;
+    for r in records {
+        current = match current {
+            None => Some(r),
+            Some(c) => {
+                let merged = c.overlaps(&r);
+                match merged {
+                    None => {
+                        coalesced.push(c);
+                        Some(r)
+                    }
+                    Some(m) => Some(m),
+                }
+            }
+        }
+    }
+    if let Some(r) = current {
+        coalesced.push(r);
+    }
+    coalesced
+}
+
+// Records file header.
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+pub struct Header {
+    /// magic number as uuid to identify the header/format.
+    #[serde(deserialize_with = "check_magic")]
+    magic: [u8; 16],
+
+    // major version number.
+    #[serde(deserialize_with = "check_major_number")]
+    major_number: u16,
+
+    // minor version number.
+    #[serde(deserialize_with = "check_minor_number")]
+    minor_number: u16,
+
+    /// timestamp when the records file was generated.
+    date: SystemTime,
+
+    /// Checksum of the `RecordsFile` with `digest` being empty vector.
+    digest: u32,
+}
+
+fn check_version_number<'de, D>(
+    deserializer: D,
+    expected: u16,
+    version_type: &str,
+) -> Result<u16, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let found = u16::deserialize(deserializer)?;
+    if expected != found {
+        return Err(serde::de::Error::custom(format!(
+            "Failed to parse {} version. Expected: {} Found: {}",
+            version_type, expected, found
+        )));
+    }
+    Ok(found)
+}
+
+fn check_major_number<'de, D>(deserializer: D) -> Result<u16, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    check_version_number(deserializer, MAJOR_VERSION, "major")
+}
+
+fn check_minor_number<'de, D>(deserializer: D) -> Result<u16, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    check_version_number(deserializer, MINOR_VERSION, "minor")
+}
+
+fn check_magic<'de, D>(deserializer: D) -> Result<[u8; 16], D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let found: [u8; 16] = <[u8; 16]>::deserialize(deserializer)?;
+    if found != MAGIC_UUID {
+        return Err(serde::de::Error::custom(format!(
+            "Failed to parse magic number. Expected: {:?} Found: {:?}",
+            MAGIC_UUID, found
+        )));
+    }
+    Ok(found)
+}
+
+fn check_inode_info_paths<'de, D>(deserializer: D) -> Result<Vec<PathString>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let parsed: Vec<PathString> = Vec::deserialize(deserializer)?;
+    if parsed.is_empty() {
+        return Err(serde::de::Error::custom("No paths found for in InodeInfo"));
+    }
+    Ok(parsed)
+}
+
+// Helper inner struct of RecordsFile meant to verify checksum.
+#[derive(Clone, Debug, Default, Deserialize, Serialize, Eq, PartialEq)]
+pub(crate) struct RecordsFileInner {
+    // One instance per mounted block device.
+    pub(crate) filesystems: SerializableHashMap<DeviceNumber, FsInfo>,
+
+    /// Helps to get to a file path from a given `FileId`.
+    /// One instance per file to be prefetched.
+    pub(crate) inode_map: SerializableHashMap<FileId, InodeInfo>,
+
+    /// Helps to get to a file and offset to be replayed..
+    ///
+    // The records are chronologically arranged meaning the data that
+    // needs first is at the beginning of the vector and the data that
+    // needs last is at the end.
+    //
+    // One instance per part of the file that needs to be prefetched.
+    pub records: Vec<Record>,
+}
+
+/// Deserialized form of records file.
+#[derive(Clone, Debug, Default, Deserialize, Serialize, Eq, PartialEq)]
+#[serde(remote = "Self")]
+pub struct RecordsFile {
+    /// Helps the prefetch tool to parse rest of the file
+    pub header: Header,
+
+    /// Helps the prefetch tool to verify checksum.
+    pub(crate) inner: RecordsFileInner,
+}
+
+impl RecordsFile {
+    /// Given file id, looks up path of the file and returns open File handle.
+    pub fn open_file(&self, id: FileId, exclude_files_regex: &[Regex]) -> Result<File, Error> {
+        if let Some(inode) = self.inner.inode_map.get(&id) {
+            let path = inode.paths.first().unwrap();
+
+            for regex in exclude_files_regex {
+                if regex.is_match(path) {
+                    return Err(Error::SkipPrefetch { path: path.to_owned() });
+                }
+            }
+            debug!("Opening {} file {}", id.0, path);
+            OpenOptions::new()
+                .read(true)
+                .write(false)
+                .open(path)
+                .map_err(|source| Error::Open { source, path: path.to_owned() })
+        } else {
+            Err(Error::IdNoFound { id })
+        }
+    }
+
+    /// Inserts given record in RecordsFile
+    pub fn insert_record(&mut self, records: Record) {
+        self.inner.records.push(records);
+    }
+
+    /// Inserts given InodeInfo into in RecordsFile.
+    pub fn insert_or_update_inode_info(&mut self, id: FileId, info: InodeInfo) {
+        if let Some(inode) = self.inner.inode_map.get_mut(&id) {
+            if let Some(first_path) = info.paths.first() {
+                inode.paths.push(first_path.clone());
+            }
+        } else {
+            self.inner.inode_map.insert(id, info);
+        }
+    }
+
+    /// Verifies the integrity of records file.
+    ///
+    /// check saves us from serializing a improperly built record file or replaying an inconsistent
+    /// `RecordFile`.
+    ///
+    /// Note: check only works on the `RecordsFile` and doesn't access filesystem. We limit the
+    /// scope so that we avoid issuing filesystem operations(directory lookup, stats) twice - once
+    /// during check and once during replaying.
+    pub fn check(&self) -> Result<(), Error> {
+        let mut unique_files = HashSet::new();
+        let mut missing_file_ids = vec![];
+
+        for record in &self.inner.records {
+            if !self.inner.inode_map.contains_key(&record.file_id) {
+                missing_file_ids.push(record.file_id.clone());
+            }
+            unique_files.insert(record.file_id.clone());
+        }
+
+        let mut stale_inodes = vec![];
+        let mut missing_paths = vec![];
+        for (file_id, inode_info) in &self.inner.inode_map.map {
+            if inode_info.paths.is_empty() {
+                missing_paths.push(inode_info.clone());
+            }
+            if !unique_files.contains(file_id) {
+                stale_inodes.push(inode_info.clone());
+            }
+        }
+
+        if !stale_inodes.is_empty() || !missing_paths.is_empty() || !missing_file_ids.is_empty() {
+            return Err(Error::StaleInode { stale_inodes, missing_paths, missing_file_ids });
+        }
+
+        Ok(())
+    }
+
+    /// Builds InodeInfo from args and inserts inode info in RecordsFile.
+    pub fn insert_or_update_inode(&mut self, id: FileId, stat: &Metadata, path: PathString) {
+        self.insert_or_update_inode_info(
+            id,
+            InodeInfo {
+                inode_number: stat.ino(),
+                file_size: stat.len(),
+                paths: vec![path],
+                device_number: stat.dev(),
+            },
+        )
+    }
+
+    /// Serialize records in the form of csv.
+    pub fn serialize_records_to_csv(&self, writer: &mut dyn Write) -> Result<(), Error> {
+        let mut wtr = csv::Writer::from_writer(writer);
+
+        #[derive(Serialize)]
+        struct TempRecord<'a> {
+            timestamp: u64,
+            file: &'a PathString,
+            offset: u64,
+            length: u64,
+            file_size: u64,
+        }
+
+        for record in &self.inner.records {
+            if let Some(inode_info) = self.inner.inode_map.get(&record.file_id) {
+                let mut inode_info = inode_info.clone();
+                inode_info.paths.sort();
+
+                if let Some(first_path) = inode_info.paths.first().cloned() {
+                    // Clone the &String inside Option
+                    let record = TempRecord {
+                        timestamp: record.timestamp,
+                        file: &first_path, // Now you have &String
+                        offset: record.offset,
+                        length: record.length,
+                        file_size: inode_info.file_size,
+                    };
+                    wtr.serialize(&record)
+                        .map_err(|e| Error::Serialize { error: e.to_string() })?;
+                }
+            }
+        }
+        wtr.flush()?;
+        Ok(())
+    }
+
+    fn compute_digest(&mut self) -> Result<u32, Error> {
+        self.header.digest = Default::default();
+        let serialized = serde_cbor::to_vec(self)
+            .map_err(|source| Error::Serialize { error: source.to_string() })?;
+
+        let mut hasher = Hasher::new();
+        hasher.update(&serialized);
+
+        Ok(hasher.finalize())
+    }
+
+    /// Convenience wrapper around serialize that adds checksum/digest to the file
+    /// to verify file consistency during replay/deserialize.
+    pub fn add_checksum_and_serialize(&mut self) -> Result<Vec<u8>, Error> {
+        self.header.digest = self.compute_digest()?;
+
+        serde_cbor::to_vec(self).map_err(|source| Error::Serialize { error: source.to_string() })
+    }
+}
+
+impl Default for Header {
+    fn default() -> Self {
+        Self {
+            major_number: MAJOR_VERSION,
+            minor_number: MINOR_VERSION,
+            date: SystemTime::now(),
+            digest: 0,
+            magic: MAGIC_UUID,
+        }
+    }
+}
+
+// Wrapper around deserialize to check any inconsistencies in the file format.
+impl<'de> Deserialize<'de> for RecordsFile {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let rf = Self::deserialize(deserializer)?;
+
+        rf.check().map_err(|e| {
+            serde::de::Error::custom(format!("failed to validate records file: {}", e))
+        })?;
+
+        let mut zero_digest = rf.clone();
+        zero_digest.header.digest = 0;
+        let digest =
+            zero_digest.compute_digest().map_err(|e| serde::de::Error::custom(format!("{}", e)))?;
+
+        if digest != rf.header.digest {
+            return Err(serde::de::Error::custom(format!(
+                "file consistency check failed. Expected: {}. Found: {}",
+                digest, rf.header.digest
+            )));
+        }
+
+        Ok(rf)
+    }
+}
+
+// Wrapper around serialize to check any inconsistencies in the file format before serializing
+impl Serialize for RecordsFile {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.check().map(|_| self).map_err(|e| {
+            serde::ser::Error::custom(format!("failed to validate records file: {}", e))
+        })?;
+        Self::serialize(self, serializer)
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+
+    use std::assert_eq;
+
+    use super::*;
+
+    #[test]
+    fn test_major_version_mismatch() {
+        let mut rf = RecordsFile::default();
+
+        rf.header.major_number += 1;
+
+        let serialized: Result<RecordsFile, serde_cbor::Error> =
+            serde_cbor::from_slice(&serde_cbor::to_vec(&rf).unwrap());
+
+        assert_eq!(
+            serialized.unwrap_err().to_string(),
+            format!(
+                "Failed to parse major version. Expected: {} Found: {}",
+                MAJOR_VERSION,
+                MAJOR_VERSION + 1
+            )
+        );
+    }
+
+    #[test]
+    fn test_minor_version_mismatch() {
+        let mut rf = RecordsFile::default();
+
+        rf.header.minor_number += 1;
+
+        let serialized: Result<RecordsFile, serde_cbor::Error> =
+            serde_cbor::from_slice(&serde_cbor::to_vec(&rf).unwrap());
+
+        assert_eq!(
+            serialized.unwrap_err().to_string(),
+            format!(
+                "Failed to parse minor version. Expected: {} Found: {}",
+                MINOR_VERSION,
+                MINOR_VERSION + 1
+            )
+        );
+    }
+
+    #[test]
+    fn deserialize_inode_info_without_path() {
+        let inode = InodeInfo { inode_number: 1, file_size: 10, paths: vec![], device_number: 1 };
+        let serialized = serde_cbor::to_vec(&inode).unwrap();
+        let deserialized: Result<InodeInfo, serde_cbor::Error> =
+            serde_cbor::from_slice(&serialized);
+        assert_eq!(
+            deserialized.unwrap_err().to_string(),
+            "No paths found for in InodeInfo".to_owned()
+        );
+    }
+    #[test]
+    fn test_serialize_records_to_csv() {
+        let mut rf = RecordsFile::default();
+        let file_count = 4;
+        for i in 0..file_count {
+            rf.insert_or_update_inode_info(
+                FileId(i),
+                InodeInfo {
+                    inode_number: i,
+                    file_size: i * 10,
+                    paths: vec![format!("/hello/{}", i)],
+                    device_number: i + 10,
+                },
+            )
+        }
+        for i in 0..10 {
+            rf.insert_record(Record {
+                file_id: FileId(i % file_count),
+                offset: i * 3,
+                length: i + 4,
+                timestamp: i * file_count,
+            });
+        }
+
+        let mut buf = vec![];
+        rf.serialize_records_to_csv(&mut buf).unwrap();
+
+        let data = String::from_utf8(buf).unwrap();
+        assert_eq!(
+            data,
+            "timestamp,file,offset,length,file_size\n\
+            0,/hello/0,0,4,0\n\
+            4,/hello/1,3,5,10\n\
+            8,/hello/2,6,6,20\n\
+            12,/hello/3,9,7,30\n\
+            16,/hello/0,12,8,0\n\
+            20,/hello/1,15,9,10\n\
+            24,/hello/2,18,10,20\n\
+            28,/hello/3,21,11,30\n\
+            32,/hello/0,24,12,0\n\
+            36,/hello/1,27,13,10\n"
+        );
+    }
+
+    fn new_record(file: u64, offset: u64, length: u64, timestamp: u64) -> Record {
+        Record { file_id: FileId(file), offset, length, timestamp }
+    }
+
+    #[test]
+    fn test_coalesced_without_group() {
+        let non_coalescable_same_inode =
+            vec![new_record(1, 2, 3, 4), new_record(1, 6, 3, 5), new_record(1, 10, 3, 6)];
+        assert_eq!(
+            coalesce_records(non_coalescable_same_inode.clone(), false),
+            non_coalescable_same_inode
+        );
+
+        let non_coalescable_different_inode =
+            vec![new_record(1, 2, 3, 4), new_record(2, 5, 3, 5), new_record(3, 8, 3, 6)];
+        assert_eq!(
+            coalesce_records(non_coalescable_different_inode.clone(), false),
+            non_coalescable_different_inode
+        );
+
+        let some_coalesced =
+            vec![new_record(1, 2, 3, 4), new_record(1, 5, 3, 5), new_record(3, 8, 3, 6)];
+        assert_eq!(
+            coalesce_records(some_coalesced, false),
+            vec![new_record(1, 2, 6, 4), new_record(3, 8, 3, 6),]
+        );
+
+        let coalesced_into_one =
+            vec![new_record(1, 2, 3, 4), new_record(1, 5, 3, 5), new_record(1, 8, 3, 6)];
+        assert_eq!(coalesce_records(coalesced_into_one, false), vec![new_record(1, 2, 9, 4)]);
+
+        let no_grouping_or_coalescing =
+            vec![new_record(1, 2, 3, 4), new_record(3, 8, 3, 5), new_record(1, 5, 3, 6)];
+        assert_eq!(
+            coalesce_records(no_grouping_or_coalescing, false),
+            vec![new_record(1, 2, 3, 4), new_record(3, 8, 3, 5), new_record(1, 5, 3, 6),]
+        );
+    }
+
+    #[test]
+    fn test_coalesced_with_grouping() {
+        let non_coalescable_same_inode =
+            vec![new_record(1, 2, 3, 4), new_record(1, 6, 3, 5), new_record(1, 10, 3, 6)];
+        assert_eq!(
+            coalesce_records(non_coalescable_same_inode.clone(), true),
+            non_coalescable_same_inode
+        );
+
+        let non_coalescable_different_inode =
+            vec![new_record(1, 2, 3, 4), new_record(2, 5, 3, 5), new_record(3, 8, 3, 6)];
+        assert_eq!(
+            coalesce_records(non_coalescable_different_inode.clone(), true),
+            non_coalescable_different_inode
+        );
+
+        let some_coalesced =
+            vec![new_record(1, 2, 3, 4), new_record(1, 5, 3, 5), new_record(3, 8, 3, 6)];
+        assert_eq!(
+            coalesce_records(some_coalesced, true),
+            vec![new_record(1, 2, 6, 4), new_record(3, 8, 3, 6),]
+        );
+
+        let coalesced_into_one =
+            vec![new_record(1, 2, 3, 4), new_record(1, 5, 3, 5), new_record(1, 8, 3, 6)];
+        assert_eq!(coalesce_records(coalesced_into_one, true), vec![new_record(1, 2, 9, 4)]);
+
+        let some_grouped_coalesced =
+            vec![new_record(1, 2, 3, 4), new_record(3, 8, 3, 5), new_record(1, 5, 3, 6)];
+        assert_eq!(
+            coalesce_records(some_grouped_coalesced, true),
+            vec![new_record(1, 2, 6, 4), new_record(3, 8, 3, 5),]
+        );
+    }
+
+    #[test]
+    fn check_missing_records() {
+        let mut rf = RecordsFile::default();
+        rf.inner.inode_map.insert(
+            FileId(0),
+            InodeInfo {
+                inode_number: 0,
+                file_size: 1,
+                paths: vec!["hello".to_owned()],
+                device_number: 2,
+            },
+        );
+        rf.insert_record(Record { file_id: FileId(0), offset: 10, length: 20, timestamp: 30 });
+
+        rf.inner.inode_map.insert(
+            FileId(1),
+            InodeInfo {
+                inode_number: 1,
+                file_size: 2,
+                paths: vec!["world".to_owned()],
+                device_number: 3,
+            },
+        );
+        let e = rf.check().unwrap_err();
+        assert_eq!(
+            e.to_string(),
+            "Stale inode(s) info found.\n\
+                missing_file_ids: []\n\
+                stale_inodes: [\n    \
+                    InodeInfo {\n        \
+                        inode_number: 1,\n        \
+                        file_size: 2,\n        \
+                        paths: [\n            \"world\",\n        ],\n        \
+                        device_number: 3,\n    },\n] \n\
+                missing_paths:[]"
+        );
+    }
+
+    #[test]
+    fn check_missing_file() {
+        let mut rf = RecordsFile::default();
+        rf.inner.inode_map.insert(
+            FileId(0),
+            InodeInfo {
+                inode_number: 0,
+                file_size: 1,
+                paths: vec!["hello".to_owned()],
+                device_number: 2,
+            },
+        );
+        rf.insert_record(Record { file_id: FileId(0), offset: 10, length: 20, timestamp: 30 });
+        rf.insert_record(Record { file_id: FileId(1), offset: 10, length: 20, timestamp: 30 });
+
+        let e = rf.check().unwrap_err();
+        assert_eq!(
+            e.to_string(),
+            "Stale inode(s) info found.\n\
+                missing_file_ids: [\n    \
+                    FileId(\n        1,\n    ),\n]\n\
+                stale_inodes: [] \n\
+                missing_paths:[]"
+        );
+    }
+
+    #[test]
+    fn check_missing_paths() {
+        let mut rf = RecordsFile::default();
+        rf.inner.inode_map.insert(
+            FileId(0),
+            InodeInfo { inode_number: 0, file_size: 1, paths: vec![], device_number: 2 },
+        );
+        rf.insert_record(Record { file_id: FileId(0), offset: 10, length: 20, timestamp: 30 });
+
+        let e = rf.check().unwrap_err();
+        assert_eq!(
+            e.to_string(),
+            "Stale inode(s) info found.\n\
+                missing_file_ids: []\n\
+                stale_inodes: [] \n\
+                missing_paths:[\n    \
+                    InodeInfo {\n        \
+                        inode_number: 0,\n        \
+                        file_size: 1,\n        \
+                        paths: [],\n        \
+                        device_number: 2,\n    },\n]"
+        );
+    }
+}
diff --git a/init/libprefetch/prefetch/src/lib.rs b/init/libprefetch/prefetch/src/lib.rs
new file mode 100644
index 000000000000..4b56b13ee108
--- /dev/null
+++ b/init/libprefetch/prefetch/src/lib.rs
@@ -0,0 +1,186 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! A library to prefetch files on the file system to optimize startup times
+//!
+
+mod args;
+mod error;
+mod format;
+mod replay;
+mod tracer;
+
+use std::fs::File;
+use std::fs::OpenOptions;
+use std::io;
+use std::io::Write;
+use std::os::unix::fs::PermissionsExt;
+use std::string::ToString;
+use std::thread;
+use std::time::Duration;
+
+#[cfg(target_os = "android")]
+use log::Level;
+#[cfg(target_os = "linux")]
+use log::LevelFilter;
+
+pub use args::args_from_env;
+use args::OutputFormat;
+pub use args::ReplayArgs;
+pub use args::{DumpArgs, MainArgs, RecordArgs, SubCommands};
+pub use error::Error;
+pub use format::FileId;
+pub use format::InodeInfo;
+pub use format::Record;
+pub use format::RecordsFile;
+use log::info;
+#[cfg(target_os = "android")]
+use log::warn;
+pub use replay::Replay;
+pub use tracer::nanoseconds_since_boot;
+
+#[cfg(target_os = "android")]
+use rustutils::system_properties;
+#[cfg(target_os = "android")]
+use rustutils::system_properties::error::PropertyWatcherError;
+#[cfg(target_os = "android")]
+use rustutils::system_properties::PropertyWatcher;
+
+#[cfg(target_os = "android")]
+fn wait_for_property_true(property_name: &str) -> Result<(), PropertyWatcherError> {
+    let mut prop = PropertyWatcher::new(property_name)?;
+    loop {
+        prop.wait(None)?;
+        if system_properties::read_bool(property_name, false)? {
+            break;
+        }
+    }
+    Ok(())
+}
+
+/// Records prefetch data for the given configuration
+pub fn record(args: &RecordArgs) -> Result<(), Error> {
+    let (mut tracer, exit_tx) = tracer::Tracer::create(
+        args.trace_buffer_size_kib,
+        args.tracing_subsystem.clone(),
+        args.tracing_instance.clone(),
+        args.setup_tracing,
+    )?;
+    let duration = Duration::from_secs(args.duration as u64);
+
+    let thd = thread::spawn(move || {
+        if !duration.is_zero() {
+            info!("Record start - waiting for duration: {:?}", duration);
+            thread::sleep(duration);
+        } else {
+            #[cfg(target_os = "android")]
+            wait_for_property_true("sys.boot_completed").unwrap_or_else(|e| {
+                warn!("failed to wait for sys.boot_completed with error: {}", e)
+            });
+        }
+
+        // We want to unwrap here on failure to send this signal. Otherwise
+        // tracer will continue generating huge records data.
+        exit_tx.send(()).unwrap();
+    });
+
+    let mut rf = tracer.trace(args.int_path.as_ref())?;
+    thd.join()
+        .map_err(|_| Error::ThreadPool { error: "Failed to join timeout thread".to_string() })?;
+
+    let mut out_file =
+        OpenOptions::new().write(true).create(true).truncate(true).open(&args.path).map_err(
+            |source| Error::Create { source, path: args.path.to_str().unwrap().to_owned() },
+        )?;
+
+    std::fs::set_permissions(&args.path, std::fs::Permissions::from_mode(0o644))
+        .map_err(|source| Error::Create { source, path: args.path.to_str().unwrap().to_owned() })?;
+
+    out_file
+        .write_all(&rf.add_checksum_and_serialize()?)
+        .map_err(|source| Error::Write { path: args.path.to_str().unwrap().to_owned(), source })?;
+    Ok(())
+}
+
+/// Replays prefetch data for the given configuration
+pub fn replay(args: &ReplayArgs) -> Result<(), Error> {
+    let replay = Replay::new(args)?;
+    replay.replay()
+}
+
+/// Dumps prefetch data in the human readable form
+pub fn dump(args: &DumpArgs) -> Result<(), Error> {
+    let reader = File::open(&args.path)
+        .map_err(|source| Error::Open { source, path: args.path.to_str().unwrap().to_string() })?;
+    let rf: RecordsFile =
+        serde_cbor::from_reader(reader).map_err(|e| Error::Deserialize { error: e.to_string() })?;
+    match args.format {
+        OutputFormat::Json => println!(
+            "{:#}",
+            serde_json::to_string_pretty(&rf)
+                .map_err(|e| Error::Serialize { error: e.to_string() })?
+        ),
+        OutputFormat::Csv => rf.serialize_records_to_csv(&mut io::stdout())?,
+    }
+    Ok(())
+}
+
+/// An alias of android_logger::Level to use log level across android and linux.
+#[cfg(target_os = "android")]
+pub type LogLevel = Level;
+
+/// An alias of log::LevelFilter to use log level across android and linux.
+#[cfg(not(target_os = "android"))]
+pub type LogLevel = LevelFilter;
+
+/// Convenience logging initializer that is shared between the prefetch tool and c wrapper library
+#[cfg(target_os = "android")]
+pub fn init_logging(_level: LogLevel) {
+    android_logger::init_once(
+        android_logger::Config::default().with_max_level(log::LevelFilter::Info).format(
+            |f, record| {
+                write!(
+                    f,
+                    "{} prefetch_rs: {}:{} {}: {}",
+                    nanoseconds_since_boot(),
+                    record.file().unwrap_or("unknown_file"),
+                    record.line().unwrap_or(0),
+                    record.level(),
+                    record.args()
+                )
+            },
+        ),
+    )
+}
+
+/// Convenience logging initializer that is shared between the prefetch tool and c wrapper library
+#[cfg(target_os = "linux")]
+pub fn init_logging(level: LogLevel) {
+    let mut builder = env_logger::Builder::from_default_env();
+
+    builder
+        .filter(None, level)
+        .format(|buf, record| {
+            writeln!(
+                buf,
+                "{} prefetch_rs: {}:{} {}: {}",
+                nanoseconds_since_boot(),
+                record.file().unwrap_or("unknown_file"),
+                record.line().unwrap_or(0),
+                record.level(),
+                record.args()
+            )
+        })
+        .init();
+}
diff --git a/init/libprefetch/prefetch/src/main.rs b/init/libprefetch/prefetch/src/main.rs
new file mode 100644
index 000000000000..046e07edab89
--- /dev/null
+++ b/init/libprefetch/prefetch/src/main.rs
@@ -0,0 +1,41 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! A utility wrapper around libprefetch that allows to record, replay and dump
+//! prefetch data.
+
+use log::error;
+
+use prefetch_rs::args_from_env;
+use prefetch_rs::dump;
+use prefetch_rs::init_logging;
+use prefetch_rs::record;
+use prefetch_rs::replay;
+use prefetch_rs::LogLevel;
+use prefetch_rs::MainArgs;
+use prefetch_rs::SubCommands;
+
+fn main() {
+    init_logging(LogLevel::Debug);
+    let args: MainArgs = args_from_env();
+    let ret = match &args.nested {
+        SubCommands::Record(args) => record(args),
+        SubCommands::Replay(args) => replay(args),
+        SubCommands::Dump(args) => dump(args),
+    };
+
+    if let Err(err) = ret {
+        error!("{:?} command failed: {:?}", args, err);
+    }
+}
diff --git a/init/libprefetch/prefetch/src/replay.rs b/init/libprefetch/prefetch/src/replay.rs
new file mode 100644
index 000000000000..b68d74762c9e
--- /dev/null
+++ b/init/libprefetch/prefetch/src/replay.rs
@@ -0,0 +1,762 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::clone::Clone;
+use std::convert::TryInto;
+use std::fmt::Display;
+use std::mem::replace;
+use std::os::unix::io::AsRawFd;
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::sync::RwLock;
+use std::thread;
+
+use log::debug;
+use log::error;
+use log::warn;
+use lru_cache::LruCache;
+use nix::errno::Errno;
+use nix::fcntl::posix_fadvise;
+use regex::Regex;
+
+use crate::args::ConfigFile;
+use crate::format::Record;
+use crate::format::{FileId, RecordsFile};
+use crate::Error;
+use crate::ReplayArgs;
+use libc::{c_void, off64_t, pread64};
+use std::fs::File;
+
+const READ_SZ: usize = 1024 * 1024;
+
+struct ScopedLog<T: Display + Sized> {
+    msg: T,
+    thd_id: usize,
+}
+
+fn scoped_log<T: Display + Sized>(ctx: usize, msg: T) -> ScopedLog<T> {
+    let thd_id = ctx;
+    debug!("{} {} start", thd_id, msg);
+    ScopedLog { msg, thd_id }
+}
+
+impl<T: Display> Drop for ScopedLog<T> {
+    fn drop(&mut self) {
+        debug!("{} {} end", self.thd_id, self.msg);
+    }
+}
+
+fn readahead(
+    id: usize,
+    file: Arc<File>,
+    record: &Record,
+    buffer: &mut [u8; READ_SZ],
+) -> Result<(), Error> {
+    debug!("readahead {:?}", record);
+    let _dbg = scoped_log(id, "readahead");
+
+    let mut current_offset: off64_t = record
+        .offset
+        .try_into()
+        .map_err(|_| Error::Read { error: "Failed to convert offset".to_string() })?;
+    let mut remaining_data: usize = record
+        .length
+        .try_into()
+        .map_err(|_| Error::Read { error: "Failed to convert length".to_string() })?;
+
+    while remaining_data > 0 {
+        let read_size = std::cmp::min(READ_SZ, remaining_data);
+
+        // SAFETY: This is safe because
+        // - the file is known to exist and opened
+        // - buffer is allocated upfront and is guaranteed by the fact it comes from a mutable slice reference.
+        // - read_size is guaranteed not to exceed length of the buffer.
+        let bytes_read = unsafe {
+            pread64(file.as_raw_fd(), buffer.as_mut_ptr() as *mut c_void, read_size, current_offset)
+        };
+
+        if bytes_read == -1 {
+            return Err(Error::Read { error: format!("readahead failed: {}", Errno::last_raw()) });
+        }
+
+        if bytes_read == 0 {
+            break; // End of file reached
+        }
+
+        current_offset += bytes_read as off64_t;
+        remaining_data -= bytes_read as usize;
+    }
+
+    // TODO: Try readahead() syscall or async I/O
+    Ok(())
+}
+
+fn worker_internal(
+    id: usize,
+    state: Arc<Mutex<SharedState>>,
+    records_file: Arc<RwLock<RecordsFile>>,
+    exit_on_error: bool,
+    exclude_files_regex: Vec<Regex>,
+    buffer: &mut [u8],
+) -> Result<(), Error> {
+    loop {
+        let index = {
+            let mut state = state.lock().unwrap();
+            if state.result.is_err() {
+                return Ok(());
+            }
+            state.next_record()
+        };
+
+        let record = {
+            let rf = records_file.read().unwrap();
+            if index >= rf.inner.records.len() {
+                return Ok(());
+            }
+            rf.inner.records.get(index).unwrap().clone()
+        };
+
+        let _dbg = scoped_log(id, "record_replay");
+
+        let file = state.lock().unwrap().fds.get_mut(&record.file_id).map(|f| f.clone());
+
+        let file = match file {
+            Some(file) => file,
+            None => {
+                let file = Arc::new({
+                    let file = records_file
+                        .read()
+                        .unwrap()
+                        .open_file(record.file_id.clone(), &exclude_files_regex);
+                    if let Err(e) = file {
+                        if exit_on_error {
+                            return Err(e);
+                        } else {
+                            match e {
+                                Error::SkipPrefetch { path } => {
+                                    debug!("Skipping file during replay: {}", path);
+                                }
+                                _ => error!(
+                                    "Failed to open file id: {} with {}",
+                                    record.file_id.clone(),
+                                    e.to_string()
+                                ),
+                            }
+                            continue;
+                        }
+                    }
+
+                    let file = file.unwrap();
+                    // We do not want the filesystem be intelligent and prefetch more than what this
+                    // code is reading. So turn off prefetch.
+
+                    if let Err(e) = posix_fadvise(
+                        file.as_raw_fd(),
+                        0,
+                        0,
+                        nix::fcntl::PosixFadviseAdvice::POSIX_FADV_RANDOM,
+                    ) {
+                        warn!(
+                            "Failed to turn off filesystem read ahead for file id: {} with {}",
+                            record.file_id.clone(),
+                            e.to_string()
+                        );
+                    }
+                    file
+                });
+                let cache_file = file.clone();
+                state.lock().unwrap().fds.insert(record.file_id.clone(), cache_file);
+                file
+            }
+        };
+        if let Err(e) = readahead(id, file, &record, buffer.try_into().unwrap()) {
+            if exit_on_error {
+                return Err(e);
+            } else {
+                error!(
+                    "readahead failed on file id: {} with: {}",
+                    record.file_id.clone(),
+                    e.to_string()
+                );
+                continue;
+            }
+        }
+    }
+}
+
+fn worker(
+    id: usize,
+    state: Arc<Mutex<SharedState>>,
+    records_file: Arc<RwLock<RecordsFile>>,
+    exit_on_error: bool,
+    exclude_files_regex: Vec<Regex>,
+    buffer: &mut [u8],
+) {
+    let _dbg = scoped_log(id, "read_loop");
+    let result = worker_internal(
+        id,
+        state.clone(),
+        records_file,
+        exit_on_error,
+        exclude_files_regex,
+        buffer,
+    );
+    if result.is_err() {
+        error!("worker failed with {:?}", result);
+        let mut state = state.lock().unwrap();
+        if state.result.is_ok() {
+            state.result = result;
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SharedState {
+    fds: LruCache<FileId, Arc<File>>,
+    records_index: usize,
+    result: Result<(), Error>,
+}
+
+impl SharedState {
+    fn next_record(&mut self) -> usize {
+        let ret = self.records_index;
+        self.records_index += 1;
+        ret
+    }
+}
+
+/// Runtime, in-memory, representation of records file structure.
+#[derive(Debug)]
+pub struct Replay {
+    records_file: Arc<RwLock<RecordsFile>>,
+    io_depth: u16,
+    exit_on_error: bool,
+    state: Arc<Mutex<SharedState>>,
+    exclude_files_regex: Vec<Regex>,
+}
+
+impl Replay {
+    /// Creates Replay from input `args`.
+    pub fn new(args: &ReplayArgs) -> Result<Self, Error> {
+        let _dbg = scoped_log(1, "new");
+        let reader: File = File::open(&args.path).map_err(|source| Error::Open {
+            source,
+            path: args.path.to_str().unwrap().to_owned(),
+        })?;
+        let rf: RecordsFile = serde_cbor::from_reader(reader)
+            .map_err(|error| Error::Deserialize { error: error.to_string() })?;
+
+        let mut exclude_files_regex: Vec<Regex> = Vec::new();
+        // The path to the configuration file is optional in the command.
+        // If the path is provided, the configuration file will be read.
+        if !&args.config_path.as_os_str().is_empty() {
+            let config_reader = File::open(&args.config_path).map_err(|source| Error::Open {
+                source,
+                path: args.path.to_str().unwrap().to_owned(),
+            })?;
+            let cf: ConfigFile = serde_json::from_reader(config_reader)
+                .map_err(|error| Error::Deserialize { error: error.to_string() })?;
+
+            for file_to_exclude in &cf.files_to_exclude_regex {
+                exclude_files_regex.push(Regex::new(file_to_exclude).unwrap());
+            }
+        }
+
+        Ok(Self {
+            records_file: Arc::new(RwLock::new(rf)),
+            io_depth: args.io_depth,
+            exit_on_error: args.exit_on_error,
+            state: Arc::new(Mutex::new(SharedState {
+                fds: LruCache::new(args.max_fds.into()),
+                records_index: 0,
+                result: Ok(()),
+            })),
+            exclude_files_regex,
+        })
+    }
+
+    /// Replay records.
+    pub fn replay(self) -> Result<(), Error> {
+        let _dbg = scoped_log(1, "replay");
+        let mut threads = vec![];
+        for i in 0..self.io_depth {
+            let i_clone = i as usize;
+            let state = self.state.clone();
+            let records_file = self.records_file.clone();
+            let exit_on_error = self.exit_on_error;
+            let exclude_files_regex = self.exclude_files_regex.clone();
+
+            let mut buffer = Box::new([0u8; READ_SZ]);
+
+            threads.push(thread::Builder::new().spawn(move || {
+                worker(
+                    i_clone,
+                    state,
+                    records_file,
+                    exit_on_error,
+                    exclude_files_regex,
+                    buffer.as_mut_slice(),
+                )
+            }));
+        }
+        for thread in threads {
+            thread.unwrap().join().unwrap();
+        }
+        replace(&mut self.state.lock().unwrap().result, Ok(()))
+    }
+}
+
+// WARNING: flaky tests.
+// In these tests we create files, invalidate their caches and then replay.
+// Verify that after reply the same portions of data is in memory.
+//
+// Since these tests to rely on presence or absence of data in cache, the
+// files used by the tests should not be in tmp filesystem. So we use relative
+// path as target directory. There is no guarantee that this target directory
+// is not on temp filesystem but chances are better than using target directory
+// in tempfs.
+//
+// Tests can be flaky if the system under tests is running low on memory. The
+// tests create file using O_DIRECT so that no data is left in file cache.
+// Though this is sufficient to avoid caching, but other processes reading these
+// files(like anti-virus) or some other system processes might change the state
+// of the cache. Or it may happen that the filesystem evicts the file before
+// we verify that read ahead worked as intended.
+#[cfg(test)]
+pub mod tests {
+    use std::{
+        assert,
+        io::Write,
+        ops::Range,
+        path::{Path, PathBuf},
+        time::Duration,
+    };
+
+    use crate::format::DeviceNumber;
+    use crate::format::FsInfo;
+    use crate::format::InodeNumber;
+    use crate::nanoseconds_since_boot;
+    use nix::sys::mman::MapFlags;
+    use nix::sys::mman::ProtFlags;
+    use serde::Deserialize;
+    use serde::Serialize;
+    use std::collections::HashMap;
+    use std::fs::OpenOptions;
+    use std::num::NonZeroUsize;
+    use std::os::fd::AsFd;
+    use std::os::unix::fs::symlink;
+    use std::os::unix::fs::MetadataExt;
+    use std::ptr::NonNull;
+    use tempfile::NamedTempFile;
+
+    use super::*;
+    use crate::tracer::{
+        page_size,
+        tests::{copy_uncached_files_and_record_from, setup_test_dir},
+    };
+
+    static MB: u64 = 1024 * 1024;
+    static KB: u64 = 1024;
+
+    fn random_write(file: &mut NamedTempFile, base: u64) -> Range<u64> {
+        let start: u64 = base + (rand::random::<u64>() % (base / 2)) as u64;
+        let len: u64 = rand::random::<u64>() % (32 * KB);
+        let buf = vec![5; len as usize];
+        nix::sys::uio::pwrite(file.as_fd(), &buf, start as i64).unwrap();
+        start..(start + len)
+    }
+
+    pub(crate) fn create_file(
+        path: Option<&Path>,
+        align: Option<u64>,
+    ) -> (NamedTempFile, Vec<Range<u64>>) {
+        let mut file = if let Some(path) = path {
+            NamedTempFile::new_in(path).unwrap()
+        } else {
+            NamedTempFile::new().unwrap()
+        };
+        let range1 = random_write(&mut file, 32 * KB);
+        let range2 = random_write(&mut file, 128 * KB);
+        let range3 = random_write(&mut file, 4 * MB);
+        if let Some(align) = align {
+            let orig_size = file.metadata().unwrap().len();
+            let aligned_size = orig_size + (align - (orig_size % align));
+            file.set_len(aligned_size).unwrap();
+        }
+        (file, vec![range1, range2, range3])
+    }
+
+    pub(crate) fn generate_cached_files_and_record(
+        path: Option<&Path>,
+        create_symlink: bool,
+        align: Option<u64>,
+    ) -> (RecordsFile, Vec<(NamedTempFile, Vec<Range<u64>>)>) {
+        let file1 = create_file(path, align);
+        let file2 = create_file(path, align);
+        let file3 = create_file(path, align);
+
+        let mut f: RecordsFileBuilder = Default::default();
+        f.add_file(file1.0.path().to_str().unwrap());
+        f.add_file(file2.0.path().to_str().unwrap());
+        f.add_file(file3.0.path().to_str().unwrap());
+        if create_symlink {
+            let symlink_path = format!("{}-symlink", file1.0.path().to_str().unwrap());
+            symlink(file1.0.path().file_name().unwrap(), &symlink_path).unwrap();
+
+            f.add_file(&symlink_path);
+        }
+        let rf = f.build().unwrap();
+        (rf, vec![file1, file2, file3])
+    }
+
+    /// RecordsFileBuilder is primarily used for testing purpose. This
+    /// is a thin wrapper around "Record". This gives the ability
+    /// to test Records functionality. The flow of this test is as follows:
+    ///
+    /// 1: generate_cached_files_and_record -> This will create temporary files of different length
+    /// and builds the "RecordFile" format.
+    /// 2: For each of the file path create, a "RecordsFile" is generated.
+    ///    a: mmap the file based on the length.
+    ///    b: call mincore() to get the residency of pages in memory for the given
+    ///    length.
+    ///    c: Iterate over the buffer of pages returned by mincore(). If a page
+    ///    is not resident in RAM, construct the "Record" structure.
+    /// 3: build() function will finally return a constructed Prefetch Record which
+    /// contains all the "Record" structure required for "Replay".
+    #[derive(Debug, Default, Deserialize, Serialize)]
+    pub struct RecordsFileBuilder {
+        // Temporarily holds paths of all files opened by other processes.
+        pub(crate) paths: HashMap<String, FileId>,
+
+        // Read inode numbers
+        inode_numbers: HashMap<(DeviceNumber, InodeNumber), FileId>,
+    }
+
+    impl RecordsFileBuilder {
+        pub fn add_file(&mut self, path: &str) {
+            if self.paths.contains_key(path) {
+                return;
+            }
+
+            self.paths.insert(path.to_owned(), FileId(self.paths.len() as u64));
+        }
+
+        pub fn build(&mut self) -> Result<RecordsFile, Error> {
+            let mut rf = RecordsFile::default();
+            for (path, mut id) in self.paths.drain() {
+                let stat = Path::new(&path)
+                    .metadata()
+                    .map_err(|source| Error::Stat { source, path: path.clone() })?;
+
+                rf.inner
+                    .filesystems
+                    .entry(stat.dev())
+                    .or_insert(FsInfo { block_size: stat.blksize() });
+
+                if let Some(orig_id) = self.inode_numbers.get(&(stat.dev(), stat.ino())) {
+                    let inode = rf.inner.inode_map.get_mut(orig_id).unwrap();
+                    inode.paths.push(path.clone());
+
+                    // There may be multiple paths for the file so from those path we may have multiple
+                    // ids. Override the id.
+                    id = orig_id.clone();
+                } else {
+                    self.inode_numbers.insert((stat.dev(), stat.ino()), id.clone());
+                    rf.insert_or_update_inode(id.clone(), &stat, path.clone());
+                }
+                if let Some(mmap) = Mmap::create(&path, id)? {
+                    mmap.get_records(&mut rf.inner.records)?;
+                }
+            }
+            Ok(rf)
+        }
+    }
+
+    #[derive(Debug)]
+    pub(crate) struct Mmap {
+        map_addr: *mut c_void,
+        length: usize,
+        #[allow(dead_code)]
+        file: File,
+        file_id: FileId,
+    }
+
+    impl Mmap {
+        pub fn create(path: &str, file_id: FileId) -> Result<Option<Self>, Error> {
+            let file = OpenOptions::new()
+                .read(true)
+                .write(false)
+                .open(path)
+                .map_err(|source| Error::Open { source, path: path.to_owned() })?;
+
+            let length = file
+                .metadata()
+                .map_err(|source| Error::Stat { source, path: path.to_owned() })?
+                .len() as usize;
+
+            if length == 0 {
+                return Ok(None);
+            }
+
+            // SAFETY: This is safe because
+            // - the length is checked for zero
+            // - offset is set to 0
+            let map_addr = unsafe {
+                nix::sys::mman::mmap(
+                    None,
+                    NonZeroUsize::new(length).unwrap(),
+                    ProtFlags::PROT_READ,
+                    MapFlags::MAP_SHARED,
+                    file.as_fd(),
+                    0,
+                )
+                .map_err(|source| Error::Mmap {
+                    error: source.to_string(),
+                    path: path.to_owned(),
+                })?
+            };
+
+            Ok(Some(Self { map_addr: map_addr.as_ptr(), length, file, file_id }))
+        }
+
+        /// Construct the "Record" file based on pages resident in RAM.
+        pub(crate) fn get_records(&self, records: &mut Vec<Record>) -> Result<(), Error> {
+            let page_size = page_size()?;
+            let page_count = (self.length + page_size - 1) / page_size;
+            let mut buf: Vec<u8> = vec![0_u8; page_count];
+            // SAFETY: This is safe because
+            // - the file is mapped
+            // - buf points to a valid and sufficiently large memory region with the
+            //   requirement of (length+PAGE_SIZE-1) / PAGE_SIZE bytes
+            let ret = unsafe { libc::mincore(self.map_addr, self.length, buf.as_mut_ptr()) };
+            if ret < 0 {
+                return Err(Error::Custom {
+                    error: format!("failed to query resident pages: {}", Errno::last_raw()),
+                });
+            }
+            let mut i = 0;
+
+            let mut offset_length: Option<(u64, u64)> = None;
+            for (index, resident) in buf.iter().enumerate() {
+                if *resident != 0 {
+                    if let Some((_, length)) = &mut offset_length {
+                        *length += page_size as u64;
+                    } else {
+                        offset_length = Some((index as u64 * page_size as u64, page_size as u64));
+                    }
+                } else if let Some((offset, length)) = offset_length {
+                    i += 1;
+                    records.push(Record {
+                        file_id: self.file_id.clone(),
+                        offset,
+                        length,
+                        timestamp: nanoseconds_since_boot(),
+                    });
+
+                    offset_length = None;
+                }
+            }
+
+            if let Some((offset, length)) = offset_length {
+                i += 1;
+                records.push(Record {
+                    file_id: self.file_id.clone(),
+                    offset,
+                    length,
+                    timestamp: nanoseconds_since_boot(),
+                });
+            }
+            debug!("records found: {} for {:?}", i, self);
+
+            Ok(())
+        }
+    }
+
+    impl Drop for Mmap {
+        fn drop(&mut self) {
+            // SAFETY: This is safe because
+            // - addr is mapped and is multiple of page_size
+            let ret = unsafe {
+                nix::sys::mman::munmap(NonNull::new(self.map_addr).unwrap(), self.length)
+            };
+            if let Err(e) = ret {
+                error!(
+                    "failed to munmap {:p} {} with {}",
+                    self.map_addr,
+                    self.length,
+                    e.to_string()
+                );
+            }
+        }
+    }
+
+    // Please see comment above RecordsFileBuilder.
+    fn rebuild_records_file(files: &[(PathBuf, Vec<Range<u64>>)]) -> RecordsFile {
+        // Validate that caches are dropped
+        let mut f: RecordsFileBuilder = Default::default();
+        for (path, _) in files {
+            f.add_file(path.to_str().unwrap());
+        }
+        f.build().unwrap()
+    }
+
+    fn ensure_files_not_cached(files: &mut [(PathBuf, Vec<Range<u64>>)]) {
+        assert!(rebuild_records_file(files).inner.records.is_empty());
+    }
+
+    fn has_record(records: &[Record], key: &Record) -> bool {
+        for r in records {
+            if r.offset == key.offset && r.length == key.length {
+                return true;
+            }
+        }
+        false
+    }
+
+    fn compare_records(old: &[Record], new: &[Record]) {
+        for key in new {
+            if !has_record(old, key) {
+                panic!("Failed to file {:?} in {:?}", key, old);
+            }
+        }
+    }
+
+    fn create_test_config_file(files_to_exclude_regex: Vec<String>) -> String {
+        let cfg = ConfigFile { files_to_exclude_regex, ..Default::default() };
+        serde_json::to_string(&cfg).unwrap()
+    }
+
+    // TODO: Split this into individual tests for better readability.
+    // b/378554334
+    fn test_replay_internal(
+        create_symlink: bool,
+        exit_on_error: bool,
+        inject_error: bool,
+        exclude_all_files: bool,
+        empty_exclude_file_list: bool,
+    ) {
+        let page_size = page_size().unwrap() as u64;
+        let test_base_dir = setup_test_dir();
+        let (rf, mut files) =
+            generate_cached_files_and_record(None, create_symlink, Some(page_size));
+
+        // Here "uncached_files" emulate the files after reboot when none of those files data is in cache.
+        let (mut uncached_rf, mut uncached_files) =
+            copy_uncached_files_and_record_from(Path::new(&test_base_dir), &mut files, &rf);
+
+        // Injects error(s) in the form of invalid filename
+        if inject_error {
+            if let Some(v) = uncached_rf.inner.inode_map.values_mut().next() {
+                for path in &mut v.paths {
+                    path.push('-');
+                }
+            }
+        }
+
+        let mut file = NamedTempFile::new().unwrap();
+        file.write_all(&uncached_rf.add_checksum_and_serialize().unwrap()).unwrap();
+        let mut config_file = NamedTempFile::new().unwrap();
+
+        let mut files_to_exclude: Vec<String> = Vec::new();
+        if exclude_all_files {
+            // Exclude files from replay by adding them in config
+            for v in uncached_rf.inner.inode_map.values_mut() {
+                for path in &mut v.paths {
+                    files_to_exclude.push(path.to_string())
+                }
+            }
+        } else if empty_exclude_file_list {
+            files_to_exclude.extend(vec![]);
+        } else {
+            // Exclude file1 and file2 during replay
+            files_to_exclude.extend(vec!["file1".to_owned(), "file2".to_owned()]);
+        }
+
+        // Create a config json to exclude files during replay
+        let config_file_contents = create_test_config_file(files_to_exclude);
+        config_file.write_all(config_file_contents.as_bytes()).unwrap();
+
+        ensure_files_not_cached(&mut uncached_files);
+
+        let replay = Replay::new(&ReplayArgs {
+            path: file.path().to_owned(),
+            io_depth: 32,
+            max_fds: 128,
+            exit_on_error,
+            config_path: config_file.path().to_owned(),
+        })
+        .unwrap();
+
+        let result = replay.replay();
+        // Sleep a bit so that readaheads are complete.
+        thread::sleep(Duration::from_secs(1));
+
+        if exit_on_error && inject_error {
+            result.expect_err("Failure was expected");
+        } else if exclude_all_files {
+            let new_rf = rebuild_records_file(&uncached_files);
+            assert!(new_rf.inner.records.is_empty());
+        } else {
+            result.unwrap();
+
+            // At this point, we have prefetched data for uncached file bringing same set of
+            // data in memory as the original cached files.
+            // If we record prefetch data for new files, we should get same records files
+            // (offset and lengths) except that the file names should be different.
+            // This block verifies it.
+            // Note: `new_rf` is for uncached_files. But, [un]fortunately, those "uncached_files"
+            // are now cached after we replayed the records.
+            let new_rf = rebuild_records_file(&uncached_files);
+            assert!(!new_rf.inner.records.is_empty());
+            assert_eq!(rf.inner.inode_map.len(), new_rf.inner.inode_map.len());
+            assert_eq!(rf.inner.records.len(), new_rf.inner.records.len());
+            compare_records(&rf.inner.records, &new_rf.inner.records);
+        }
+    }
+
+    #[test]
+    fn test_replay() {
+        test_replay_internal(true, false, false, false, false);
+    }
+
+    #[test]
+    fn test_replay_strict() {
+        test_replay_internal(true, true, false, false, false);
+    }
+
+    #[test]
+    fn test_replay_no_symlink() {
+        test_replay_internal(false, false, false, false, false);
+    }
+
+    #[test]
+    fn test_replay_no_symlink_strict() {
+        test_replay_internal(false, true, false, false, false);
+    }
+
+    #[test]
+    fn test_replay_fails_on_error() {
+        test_replay_internal(true, true, true, false, false);
+    }
+
+    #[test]
+    fn test_replay_exclude_all_files() {
+        test_replay_internal(true, false, false, true, false);
+    }
+
+    #[test]
+    fn test_replay_empty_exclude_files_list() {
+        test_replay_internal(true, false, false, false, true);
+    }
+}
diff --git a/init/libprefetch/prefetch/src/tracer/mem.rs b/init/libprefetch/prefetch/src/tracer/mem.rs
new file mode 100644
index 000000000000..f69ae807b12f
--- /dev/null
+++ b/init/libprefetch/prefetch/src/tracer/mem.rs
@@ -0,0 +1,897 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! See top level documentation for `crate::tracer`.
+
+use std::collections::hash_map::Iter;
+use std::fs::symlink_metadata;
+use std::io::{ErrorKind, Write};
+use std::iter::Iterator;
+use std::mem::take;
+use std::os::unix::fs::MetadataExt;
+use std::{
+    collections::{HashMap, HashSet},
+    fs::read_to_string,
+    option::Option,
+    path::{Path, PathBuf},
+};
+
+use log::{debug, error, info, warn};
+use regex::Regex;
+use serde::Deserialize;
+use serde::Serialize;
+use walkdir::{DirEntry, WalkDir};
+
+use crate::format::{coalesce_records, FsInfo};
+use crate::tracer::{page_size, TracerConfigs};
+use crate::{
+    format::{DeviceNumber, InodeNumber},
+    tracer::{TraceSubsystem, EXCLUDE_PATHS},
+    Error, FileId, Record, RecordsFile,
+};
+
+static MOUNTINFO_PATH: &str = "/proc/self/mountinfo";
+
+// Trace events to enable
+// Paths are relative to trace mount point
+static TRACE_EVENTS: &[&str] =
+    &["events/filemap/mm_filemap_add_to_page_cache/enable", "tracing_on"];
+
+// Filesystem types to ignore
+static EXCLUDED_FILESYSTEM_TYPES: &[&str] = &[
+    "binder",
+    "bpf",
+    "cgroup",
+    "cgroup2",
+    "configfs",
+    "devpts",
+    "fuse", // No emulated storage
+    "fusectl",
+    "proc",
+    "pstore",
+    "selinuxfs",
+    "sysfs",
+    "tmpfs", // Check for apex mount points
+    "tracefs",
+    "functionfs", // adb, fastboot
+    "f2fs",       // Skip /data mounts
+];
+
+#[cfg(target_os = "linux")]
+type MajorMinorType = u32;
+#[cfg(target_os = "android")]
+type MajorMinorType = i32;
+
+// TODO(b/302056482): Once we uprev nix crate, we can use the function exported by the crate.
+fn major(dev: DeviceNumber) -> MajorMinorType {
+    (((dev >> 32) & 0xffff_f000) | ((dev >> 8) & 0x0000_0fff)) as MajorMinorType
+}
+
+// TODO(b/302056482): Once we uprev nix crate, we can use the function exported by the crate.
+fn minor(dev: DeviceNumber) -> MajorMinorType {
+    (((dev >> 12) & 0xffff_ff00) | ((dev) & 0x0000_00ff)) as MajorMinorType
+}
+
+// TODO(b/302056482): Once we uprev nix crate, we can use the function exported by the crate.
+fn makedev(major: MajorMinorType, minor: MajorMinorType) -> DeviceNumber {
+    let major = major as DeviceNumber;
+    let minor = minor as DeviceNumber;
+    ((major & 0xffff_f000) << 32)
+        | ((major & 0x0000_0fff) << 8)
+        | ((minor & 0xffff_ff00) << 12)
+        | (minor & 0x0000_00ff)
+}
+
+fn build_device_number(major: &str, minor: &str) -> Result<DeviceNumber, Error> {
+    Ok(makedev(
+        major.parse::<MajorMinorType>().map_err(|e| Error::Custom {
+            error: format!("Failed to parse major number from {} with {}", major, e),
+        })?,
+        minor.parse::<MajorMinorType>().map_err(|e| Error::Custom {
+            error: format!("Failed to parse major number from {} with {}", major, e),
+        })?,
+    ))
+}
+
+// Returns timestamp in nanoseconds
+fn build_timestamp(seconds: &str, microseconds: &str) -> Result<u64, Error> {
+    let seconds = seconds.parse::<u64>().map_err(|e| Error::Custom {
+        error: format!("Failed to parse seconds from {} with {}", seconds, e),
+    })?;
+    let microseconds = microseconds.parse::<u64>().map_err(|e| Error::Custom {
+        error: format!("Failed to parse microseconds from {} with {}", seconds, e),
+    })?;
+    Ok((seconds * 1_000_000_000) + (microseconds * 1_000))
+}
+
+#[cfg(not(target_os = "android"))]
+fn is_highly_privileged_path(_path: &Path) -> bool {
+    false
+}
+
+#[cfg(target_os = "android")]
+fn is_highly_privileged_path(path: &Path) -> bool {
+    // Following directories contain a mix of files with and without access to stat/read.
+    // We do not completely exclude these directories as there is still a lot of
+    // file we can issue readahead on. Some of the files on which readahead fails include
+    // - /system/bin/run-as
+    // - /data/data/com.android.storagemanager
+    // - /system/apex/com.android.art/bin/dex2oat32
+    // - /data/user/0/com.android.systemui
+    //
+    // - TODO: /system/apex: Apex files in read-only partition may be read during boot.
+    // However, some files may not have access. Double check the record files
+    // to filter out the exact path.
+    let privileged_paths = [
+        "/data/data",
+        "/data/user/0",
+        "/data/user_de/0",
+        "/system/bin/",
+        "/system/etc/selinux/",
+        "/system/system_ext/etc/selinux/",
+        "/system/product/etc/selinux/",
+        "/system/vendor/etc/selinux/",
+        "/system_ext/etc/selinux/",
+        "/product/etc/selinux/",
+        "/vendor/etc/selinux/",
+        "/system/xbin",
+        "/system/etc/",
+        "/data/",
+        "/postinstall/",
+        "/mnt/",
+        "/metadata/",
+    ];
+    for privileged in privileged_paths {
+        if path.to_str().unwrap().starts_with(privileged) {
+            return true;
+        }
+    }
+    false
+}
+
+enum DeviceState {
+    Include((DeviceNumber, PathBuf)),
+    Exclude(DeviceNumber),
+}
+
+/// Utility struct that helps to include and exclude devices and mount points that need and don't
+/// need prefetching.
+#[derive(Debug, Deserialize, Serialize)]
+struct MountInfo {
+    // Map of device number to mount points
+    included_devices: HashMap<DeviceNumber, PathBuf>,
+
+    // Devices that we don't want to prefetch - like devices backing tempfs and sysfs
+    excluded_devices: HashSet<DeviceNumber>,
+}
+
+impl MountInfo {
+    // Parses file at `path` to build `Self`.`
+    fn create(path: &str) -> Result<Self, Error> {
+        let buf = read_to_string(path)
+            .map_err(|e| Error::Read { error: format!("Reading {} failed with: {}", path, e) })?;
+        Self::with_buf(&buf)
+    }
+
+    // Parses string in `buf` to build `Self`.
+    fn with_buf(buf: &str) -> Result<Self, Error> {
+        let regex = Self::get_regex()?;
+        let mut included_devices: HashMap<DeviceNumber, PathBuf> = HashMap::new();
+        let mut excluded_devices = HashSet::new();
+        let excluded_filesystem_types: HashSet<String> =
+            EXCLUDED_FILESYSTEM_TYPES.iter().map(|s| String::from(*s)).collect();
+        for line in buf.lines() {
+            if let Some(state) = Self::parse_line(&regex, &excluded_filesystem_types, line)? {
+                match state {
+                    DeviceState::Include((device, path)) => {
+                        included_devices.insert(device, path);
+                    }
+                    DeviceState::Exclude(device) => {
+                        excluded_devices.insert(device);
+                    }
+                }
+            }
+        }
+
+        Ok(Self { included_devices, excluded_devices })
+    }
+
+    fn parse_line(
+        re: &Regex,
+        excluded_filesystem_types: &HashSet<String>,
+        line: &str,
+    ) -> Result<Option<DeviceState>, Error> {
+        let caps = match re.captures(line) {
+            Some(caps) => caps,
+            None => {
+                return Ok(None);
+            }
+        };
+        if &caps["relative_path"] != "/" {
+            return Ok(None);
+        }
+
+        let mount_point = &caps["mount_point"];
+        let mnt_pnt_with_slash = format!("{}/", mount_point);
+        let device_number = build_device_number(&caps["major"], &caps["minor"])?;
+        let fs_type = &caps["fs_type"];
+
+        if excluded_filesystem_types.contains(fs_type) {
+            info!(
+                "excluding fs type: {} for {} mount-point {} slash {}",
+                fs_type, line, mount_point, mnt_pnt_with_slash
+            );
+            return Ok(Some(DeviceState::Exclude(device_number)));
+        }
+
+        for excluded in EXCLUDE_PATHS {
+            if mnt_pnt_with_slash.starts_with(excluded) {
+                info!(
+                    "exclude-paths fs type: {} for {} mount-point {} slash {}",
+                    fs_type, line, mount_point, mnt_pnt_with_slash
+                );
+                return Ok(Some(DeviceState::Exclude(device_number)));
+            }
+        }
+
+        Ok(Some(DeviceState::Include((device_number, PathBuf::from(mount_point)))))
+    }
+
+    fn get_regex() -> Result<Regex, Error> {
+        Regex::new(concat!(
+            r"^\s*(?P<id_unknown1>\S+)",
+            r"\s+(?P<id_unknown2>\S+)",
+            r"\s+(?P<major>[0-9]+):(?P<minor>[0-9]+)",
+            r"\s+(?P<relative_path>\S+)",
+            r"\s+(?P<mount_point>\S+)",
+            r"\s+(?P<mount_opt>\S+)",
+            r"\s+(?P<shared>\S+)",
+            r"\s+\S+",
+            r"\s+(?P<fs_type>\S+)",
+            r"\s+(?P<device_path>\S+)"
+        ))
+        .map_err(|e| Error::Custom {
+            error: format!("create regex for parsing mountinfo failed with: {}", e),
+        })
+    }
+
+    fn is_excluded(&self, device: &DeviceNumber) -> bool {
+        self.excluded_devices.contains(device)
+    }
+
+    fn get_included(&self) -> Iter<DeviceNumber, PathBuf> {
+        self.included_devices.iter()
+    }
+}
+
+#[derive(Default, PartialEq, Debug, Eq, Hash)]
+struct TraceLineInfo {
+    device: DeviceNumber,
+    inode: InodeNumber,
+    offset: u64,
+    timestamp: u64,
+}
+
+impl TraceLineInfo {
+    pub fn from_trace_line(re: &Regex, line: &str) -> Result<Option<Self>, Error> {
+        let caps = match re.captures(line) {
+            Some(caps) => caps,
+            None => return Ok(None),
+        };
+        let major = &caps["major"];
+        let minor = &caps["minor"];
+        let ino = &caps["ino"];
+        let offset = &caps["offset"];
+        let timestamp = build_timestamp(&caps["seconds"], &caps["microseconds"])?;
+        Ok(Some(TraceLineInfo {
+            device: build_device_number(major, minor)?,
+            inode: u64::from_str_radix(ino, 16).map_err(|e| Error::Custom {
+                error: format!("failed parsing inode: {} : {}", ino, e),
+            })?,
+            offset: offset.parse::<u64>().map_err(|e| Error::Custom {
+                error: format!("failed parsing offset: {} : {}", offset, e),
+            })?,
+            timestamp,
+        }))
+    }
+
+    #[cfg(test)]
+    pub fn from_fields(
+        major: MajorMinorType,
+        minor: MajorMinorType,
+        inode: u64,
+        offset: u64,
+        timestamp: u64,
+    ) -> Self {
+        Self { device: makedev(major, minor), inode, offset, timestamp }
+    }
+
+    // Convenience function to create regex. Used once per life of `record` but multiple times in
+    // case of tests.
+    pub fn get_trace_line_regex() -> Result<Regex, Error> {
+        // TODO: Fix this Regex expression for 5.15 kernels. This expression
+        // works only on 6.1+. Prior to 6.1, "<page>" was present in the output.
+        Regex::new(concat!(
+            r"^\s+(?P<cmd_pid>\S+)",
+            r"\s+(?P<cpu>\S+)",
+            r"\s+(?P<irq_stuff>\S+)",
+            r"\s+(?P<seconds>[0-9]+)\.(?P<microseconds>[0-9]+):",
+            r"\s+mm_filemap_add_to_page_cache:",
+            r"\s+dev\s+(?P<major>[0-9]+):(?P<minor>[0-9]+)",
+            r"\s+ino\s+(?P<ino>\S+)",
+            //r"\s+(?P<page>\S+)",
+            r"\s+(?P<pfn>\S+)",
+            r"\s+ofs=(?P<offset>[0-9]+)"
+        ))
+        .map_err(|e| Error::Custom {
+            error: format!("create regex for tracing failed with: {}", e),
+        })
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct MissingFile {
+    major_no: MajorMinorType,
+    minor_no: MajorMinorType,
+    inode: InodeNumber,
+    records: Vec<Record>,
+}
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+struct DebugInfo {
+    // Check all inodes for which paths don't exists. These are the files which
+    // * got deleted before we got to them
+    // * are filesystem internal files that fs access only via inode numbers.
+    missing_files: HashMap<FileId, MissingFile>,
+
+    // Number of bytes read that belongs to directory type inodes.
+    directory_read_bytes: u64,
+
+    // Number of bytes read from files for which we could not find a path in
+    // the filesystems.
+    missing_path_bytes: u64,
+
+    // Paths for which the current process doesn't have read permission.
+    privileged_paths: Vec<PathBuf>,
+}
+
+#[derive(Debug, Serialize)]
+pub(crate) struct MemTraceSubsystem {
+    device_inode_map: HashMap<DeviceNumber, HashMap<InodeNumber, FileId>>,
+    // Count of all InodeNumber held by `device_inode_map`. This is handy to assign unique
+    // FileId.
+    inode_count: u64,
+
+    // `Record`s built from parsing read trace lines.
+    records: Vec<Record>,
+
+    // Regex to parse lines from trace_pipe.
+    #[serde(skip_serializing)]
+    regex: Regex,
+
+    // Mounted devices/filesystems either at the time of parsing trace file or at the time
+    // of building RecordsFile from parsed lines.
+    mount_info: MountInfo,
+
+    // A copy of TracerConfigs
+    tracer_configs: Option<TracerConfigs>,
+
+    // system page size stored to avoid frequent syscall to get the page size.
+    page_size: u64,
+
+    // The fields of the debug_info are populated when build_records_file is called (after lines
+    // are parsed from the trace file/pipe).
+    debug_info: DebugInfo,
+}
+
+impl MemTraceSubsystem {
+    pub fn update_configs(configs: &mut TracerConfigs) {
+        for path in EXCLUDE_PATHS {
+            configs.excluded_paths.push(path.to_owned().to_string());
+        }
+
+        for event in TRACE_EVENTS {
+            configs.trace_events.push(event.to_owned().to_string());
+        }
+        configs.mountinfo_path = Some(MOUNTINFO_PATH.to_string());
+    }
+
+    pub fn create_with_configs(tracer_configs: TracerConfigs) -> Result<Self, Error> {
+        static INITIAL_RECORDS_CAPACITY: usize = 100_000;
+        debug!("TracerConfig: {:#?}", tracer_configs);
+
+        let regex = TraceLineInfo::get_trace_line_regex()?;
+        let mount_info = MountInfo::create(tracer_configs.mountinfo_path.as_ref().unwrap())?;
+        debug!("mountinfo: {:#?}", mount_info);
+
+        Ok(Self {
+            device_inode_map: HashMap::new(),
+            inode_count: 0,
+            // For one product of android, we see around 50k records. To avoid a lot allocations
+            // and copying of records, we create a vec of this size.
+            //
+            // We do this to reduces chances of losing data, however unlikely, coming over
+            // `trace_pipe`.
+            //
+            // Note: Once we are done reading trace lines, we are less pedantic about allocations
+            // and mem copies.
+            records: Vec::with_capacity(INITIAL_RECORDS_CAPACITY),
+            regex,
+            mount_info,
+            tracer_configs: Some(tracer_configs),
+            page_size: page_size()? as u64,
+            debug_info: DebugInfo {
+                missing_files: HashMap::new(),
+                directory_read_bytes: 0,
+                missing_path_bytes: 0,
+                privileged_paths: vec![],
+            },
+        })
+    }
+
+    fn new_file_id(&mut self) -> FileId {
+        let id = self.inode_count;
+        self.inode_count += 1;
+        FileId(id)
+    }
+
+    fn get_trace_info(&self, line: &str) -> Result<Option<TraceLineInfo>, Error> {
+        TraceLineInfo::from_trace_line(&self.regex, line)
+    }
+
+    // Returns true if the file or directory is on a device which is excluded from walking.
+    // If the path was excluded because the current process doesn't have privileged to read it,
+    // the path gets added to `privileged` list.
+    fn is_excluded(&self, entry: &DirEntry, device: u64, privileged: &mut Vec<PathBuf>) -> bool {
+        // We skip paths that are reside on excluded devices here. This is ok because a
+        // non-excluded mount point will have a separate entry in MountInfo. For example
+        // - `/` has ext4
+        // - `/tmp` has tempfs
+        // - `/tmp/mnt` has ext4 that we are interested in.
+        // MountInfo will have three entries - `/`, `/tmp/` and `/tmp/mnt`. Skipping walking
+        // `/tmp` while walking `/` is ok as next `mount_info.get_included()` will return
+        // `/tmp/mnt` path.
+        //
+        //
+        // We skip links here as they can refer to mount points across
+        // filesystems. If that path is valid and access are valid, then
+        // we should have entry by the file's <device, inode> pair.
+        //
+        //
+        // We skip devices that don't match current walking device because we eventually
+        // walk other devices.
+        match symlink_metadata(entry.path()) {
+            Ok(lstat) => {
+                if self.mount_info.is_excluded(&lstat.dev())
+                    || lstat.dev() != device
+                    || lstat.file_type().is_symlink()
+                {
+                    return true;
+                }
+            }
+            Err(e) => {
+                error!("stat on {} failed with {}", entry.path().to_str().unwrap(), e);
+
+                // We treat EACCES special because on some platforms, like android, process needs to
+                // have very special set of permissions to access some inodes.
+                // We ignore errors in such cases *after* making an effort to get to them.
+                if e.kind() == ErrorKind::PermissionDenied
+                    && is_highly_privileged_path(entry.path())
+                {
+                    privileged.push(entry.path().to_owned());
+                    return true;
+                }
+            }
+        }
+
+        // On error, we return false because if lstat has failed, it will fail following operations
+        // including stat.
+        false
+    }
+}
+
+impl TraceSubsystem for MemTraceSubsystem {
+    fn add_line(&mut self, line: &str) -> Result<(), Error> {
+        if let Some(info) = self.get_trace_info(line)? {
+            if self.mount_info.is_excluded(&info.device) {
+                return Ok(());
+            }
+
+            self.device_inode_map.entry(info.device).or_default();
+
+            let file_id = if let Some(id) =
+                self.device_inode_map.get_mut(&info.device).unwrap().get(&info.inode)
+            {
+                id.clone()
+            } else {
+                self.new_file_id()
+            };
+            self.device_inode_map
+                .get_mut(&info.device)
+                .unwrap()
+                .insert(info.inode, file_id.clone());
+
+            self.records.push(Record {
+                file_id,
+                offset: info.offset,
+                length: self.page_size,
+                timestamp: info.timestamp,
+            });
+        }
+
+        Ok(())
+    }
+
+    fn build_records_file(&mut self) -> Result<RecordsFile, Error> {
+        // reset debug_info in case build_records_file was called twice.
+        self.debug_info = DebugInfo::default();
+        let mut rf = RecordsFile::default();
+        let mut directories = HashSet::new();
+
+        // TODO(b/302194377): We are holding all privileged_paths in this variable and then
+        // transferring it to `self.debug_info.privileged_paths` later. We can avoid this step
+        // if we directly update `self.debug_info.privileged_paths`. To do so, we need to refactor
+        // code to make borrow not complain at several places - ex. immutably borrowing
+        // `self.mount_info` in outer loop and then mutably borrowing
+        // `self.debug_info.privileged_paths`.
+        let mut privileged_paths = vec![];
+
+        // Reload mount_info. When we created mount_info for the first time, maybe
+        // the system was in early boot phase. Reload the mount_info so as to get
+        // current/new mount points.
+        if let Some(tracer_config) = &self.tracer_configs {
+            self.mount_info = MountInfo::create(tracer_config.mountinfo_path.as_ref().unwrap())?;
+            debug!("reloaded mountinfo: {:#?}", self.mount_info);
+        }
+
+        for (device, root_path) in self.mount_info.get_included() {
+            let inode_map = if let Some(map) = self.device_inode_map.get(device) {
+                map
+            } else {
+                continue;
+            };
+
+            if inode_map.is_empty() {
+                return Err(Error::Custom {
+                    error: format!("Unexpected empty records for {:?}", root_path),
+                });
+            }
+
+            let mut block_size = 0;
+            let walker = WalkDir::new(root_path).into_iter();
+
+            for entry in
+                walker.filter_entry(|e| !self.is_excluded(e, *device, &mut privileged_paths))
+            {
+                let path = match entry {
+                    Ok(entry) => entry.path().to_owned(),
+                    Err(e) => {
+                        error!("walking directory failed: {} {}", root_path.to_str().unwrap(), e);
+                        continue;
+                    }
+                };
+
+                let stat = match path.metadata() {
+                    Ok(stat) => stat,
+                    Err(e) => {
+                        error!("stat on {} failed with {}", path.to_str().unwrap(), e);
+                        continue;
+                    }
+                };
+
+                block_size = stat.blksize();
+
+                let file_id = if let Some(id) = inode_map.get(&stat.ino()) {
+                    id.clone()
+                } else {
+                    continue;
+                };
+
+                // We cannot issue a normal readahead on directories. So we skip those records that
+                // belong to directories.
+                if stat.file_type().is_dir() {
+                    info!(
+                        "skipping directory readahead record for file_id:{file_id} ino:{} path:{} ",
+                        stat.ino(),
+                        path.to_str().unwrap()
+                    );
+                    directories.insert(file_id.clone());
+                    continue;
+                }
+
+                rf.insert_or_update_inode(file_id, &stat, path.to_str().unwrap().to_owned());
+            }
+
+            rf.inner.filesystems.insert(*device, FsInfo { block_size });
+        }
+
+        self.debug_info.privileged_paths.append(&mut privileged_paths);
+
+        for (device, inode_map) in &self.device_inode_map {
+            for (inode, file_id) in inode_map {
+                if !rf.inner.inode_map.contains_key(file_id) {
+                    let major_no: MajorMinorType = major(*device);
+                    let minor_no: MajorMinorType = minor(*device);
+                    self.debug_info.missing_files.insert(
+                        file_id.clone(),
+                        MissingFile { major_no, minor_no, inode: *inode, records: vec![] },
+                    );
+                }
+            }
+        }
+
+        // Remove all records that belong to directories or for which we did not find paths.
+        let mut records = vec![];
+        for record in take(&mut self.records) {
+            if directories.contains(&record.file_id) {
+                self.debug_info.directory_read_bytes += record.length;
+            } else if let Some(missing_file) =
+                self.debug_info.missing_files.get_mut(&record.file_id)
+            {
+                self.debug_info.missing_path_bytes += record.length;
+                missing_file.records.push(record);
+            } else {
+                records.push(record);
+            }
+        }
+
+        warn!(
+            "Recorded {} bytes worth of data read from directories",
+            self.debug_info.directory_read_bytes
+        );
+        warn!(
+            "Recorded {} bytes worth of data read from files that don't have paths",
+            self.debug_info.missing_path_bytes
+        );
+
+        rf.inner.records = coalesce_records(records, true);
+
+        Ok(rf)
+    }
+
+    fn serialize(&self, write: &mut dyn Write) -> Result<(), Error> {
+        write
+            .write_all(
+                &serde_json::to_vec(&self)
+                    .map_err(|e| Error::Serialize { error: e.to_string() })?,
+            )
+            .map_err(|source| Error::Write { path: "intermediate file".to_owned(), source })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use nix::sys::stat::{major, minor};
+    use std::assert_eq;
+    use std::path::Path;
+
+    use crate::tracer::tests::{copy_uncached_files_and_record_from, setup_test_dir};
+
+    use crate::replay::tests::generate_cached_files_and_record;
+
+    use super::*;
+
+    static TRACE_BUFFER: &str = r#"
+ Settingide-502  [001] ....   484.360292: mm_filemap_add_to_page_CACHE: dev 254:6 ino cf1 page=68d477 pfn=59833 ofs=32768
+ Settingide-502  [001] ....   484.360311: mm_filemap_add_to_page_cache: dev 254:6 ino cf1 page=759458 pfn=59827 ofs=57344
+ BOX_ENTDED-3071 [001] ....   485.276715: mm_filemap_add_to_pag_ecache: dev 254:6 ino 1 page=00cc1c pfn=81748 ofs=13574144
+ BOX_ENTDED-3071 [001] ....   485.276990: mm_filemap_add_to_page_cache: dev 254:6 ino cf2 page=36540b pfn=60952 ofs=0
+ .gms.peent-843  [001] ....   485.545516: mm_filemap_add_to_page_cache: dev 254:6 ino 1 page=002e8b pfn=58928 ofs=13578240
+ .gms.peent-843  [001] ....   485.545820: mm_filemap_add_to_page_cache: dev 254:6 ino cf3 page=6233ce pfn=58108 ofs=0
+      an.bg-459  [001] ....   494.029396: mm_filemap_add_to_page_cache: dev 254:3 ino 7cf page=c5b5c7 pfn=373933 ofs=1310720
+      an.bg-459  [001] ....   494.029398: mm_filemap_add_to_page_cache: dev 254:3 ino 7cf page=b8b9ec pfn=410074 ofs=1314816
+       "#;
+
+    fn sample_mem_traces() -> (String, Vec<Option<TraceLineInfo>>) {
+        (
+            TRACE_BUFFER.to_owned(),
+            vec![
+                None,
+                None,
+                Some(TraceLineInfo::from_fields(254, 6, 0xcf1, 57344, 484360311000)),
+                None,
+                Some(TraceLineInfo::from_fields(254, 6, 0xcf2, 0, 485276990000)),
+                Some(TraceLineInfo::from_fields(254, 6, 0x1, 13578240, 485545516000)),
+                Some(TraceLineInfo::from_fields(254, 6, 0xcf3, 0, 485545820000)),
+                Some(TraceLineInfo::from_fields(254, 3, 0x7cf, 1310720, 494029396000)),
+                Some(TraceLineInfo::from_fields(254, 3, 0x7cf, 1314816, 494029398000)),
+                None,
+            ],
+        )
+    }
+
+    #[test]
+    fn test_parse_trace_line() {
+        let (buf, res) = sample_mem_traces();
+        let re = TraceLineInfo::get_trace_line_regex().unwrap();
+        for (index, line) in buf.lines().enumerate() {
+            let found = TraceLineInfo::from_trace_line(&re, line).unwrap();
+            let expected = res.get(index).unwrap();
+            assert_eq!(found.is_some(), expected.is_some());
+            if found.is_some() {
+                assert_eq!(found.unwrap(), *expected.as_ref().unwrap());
+            }
+        }
+    }
+
+    #[test]
+    fn test_add_line() {
+        let test_base_dir = setup_test_dir();
+        let (rf, mut files) =
+            generate_cached_files_and_record(None, true, Some(page_size().unwrap() as u64));
+        let (_uncached_rf, uncached_files) =
+            copy_uncached_files_and_record_from(Path::new(&test_base_dir), &mut files, &rf);
+        let mut mount_include = HashMap::new();
+
+        let included_dev = uncached_files.get(0).unwrap().0.metadata().unwrap().dev();
+        let included_inode1 = uncached_files.get(0).unwrap().0.metadata().unwrap().ino();
+        let included_inode2 = uncached_files.get(1).unwrap().0.metadata().unwrap().ino();
+        let included_major = major(included_dev);
+        let included_minor = minor(included_dev);
+        mount_include.insert(included_dev, std::fs::canonicalize(test_base_dir).unwrap());
+        let mut mount_exclude = HashSet::new();
+        mount_exclude.insert(0);
+
+        let mut mem_tracer = MemTraceSubsystem {
+            device_inode_map: HashMap::new(),
+            inode_count: 0,
+            records: vec![],
+            regex: TraceLineInfo::get_trace_line_regex().unwrap(),
+            mount_info: MountInfo {
+                included_devices: mount_include,
+                excluded_devices: mount_exclude,
+            },
+            tracer_configs: None,
+            page_size: page_size().unwrap() as u64,
+            debug_info: DebugInfo {
+                missing_files: HashMap::new(),
+                directory_read_bytes: 0,
+                missing_path_bytes: 0,
+                privileged_paths: vec![],
+            },
+        };
+
+        let pg_size = page_size().unwrap();
+        // Format is major, minor, inode, offset
+        let inputs = vec![
+            (0, 0, 2, 10), // to be excluded. bad device.
+            (included_major, included_minor, included_inode1, 0),
+            (included_major, included_minor, included_inode1, 3 * pg_size),
+            // duplicate read
+            (included_major, included_minor, included_inode1, 3 * pg_size),
+            (0, 0, included_inode1, 10), // to be excluded. bad device.
+            (included_major, included_minor, included_inode1, 2 * pg_size), // contiguous
+            // non-contiguous
+            (included_major, included_minor, included_inode1, 12 * pg_size),
+            // same offset different inode
+            (included_major, included_minor, included_inode2, 3 * pg_size),
+            // Contiguous offset different inode
+            (included_major, included_minor, included_inode2, pg_size),
+        ];
+
+        for (i, (major, minor, inode, offset)) in inputs.iter().enumerate() {
+            // used to timestamp the log line.
+            let seconds = i;
+            // used to timestamp the log line.
+            let microseconds = i;
+            for operation in &["mm_filemap_add_to_page_cache", "some_other_operation"] {
+                let line = format!(
+                    " BOX_ENTRY_ADDED-3071    [001] ....   {}.{}: {}: \
+                    dev {}:{} ino {:x} page=00000000f936540b pfn=60952 ofs={}",
+                    seconds, microseconds, operation, major, minor, inode, offset
+                );
+                mem_tracer.add_line(&line).unwrap();
+            }
+        }
+        assert_eq!(mem_tracer.records.len(), 7);
+        assert_eq!(mem_tracer.device_inode_map.len(), 1);
+        assert_eq!(mem_tracer.device_inode_map.get(&included_dev).unwrap().len(), 2);
+        assert!(mem_tracer
+            .device_inode_map
+            .get(&included_dev)
+            .unwrap()
+            .contains_key(&included_inode1));
+        assert!(mem_tracer
+            .device_inode_map
+            .get(&included_dev)
+            .unwrap()
+            .contains_key(&included_inode2));
+    }
+
+    fn new_record(file: u64, offset: u64, length: u64, timestamp: u64) -> Record {
+        Record { file_id: FileId(file), offset, length, timestamp }
+    }
+
+    #[test]
+    fn test_get_records_file() {
+        let test_base_dir = setup_test_dir();
+        let (rf, mut files) =
+            generate_cached_files_and_record(None, true, Some(page_size().unwrap() as u64));
+        let (_uncached_rf, uncached_files) =
+            copy_uncached_files_and_record_from(Path::new(&test_base_dir), &mut files, &rf);
+        let mut mount_include = HashMap::new();
+
+        let included_dev = uncached_files.get(0).unwrap().0.metadata().unwrap().dev();
+        let included_inode1 = uncached_files.get(0).unwrap().0.metadata().unwrap().ino();
+        let included_inode2 = uncached_files.get(1).unwrap().0.metadata().unwrap().ino();
+        let included_major = major(included_dev);
+        let included_minor = minor(included_dev);
+        mount_include.insert(included_dev, std::fs::canonicalize(test_base_dir).unwrap());
+        let mut mount_exclude = HashSet::new();
+        mount_exclude.insert(0);
+
+        let mut mem_tracer = MemTraceSubsystem {
+            device_inode_map: HashMap::new(),
+            inode_count: 0,
+            records: vec![],
+            regex: TraceLineInfo::get_trace_line_regex().unwrap(),
+            mount_info: MountInfo {
+                included_devices: mount_include,
+                excluded_devices: mount_exclude,
+            },
+            tracer_configs: None,
+            page_size: page_size().unwrap() as u64,
+            debug_info: DebugInfo {
+                missing_files: HashMap::new(),
+                directory_read_bytes: 0,
+                missing_path_bytes: 0,
+                privileged_paths: vec![],
+            },
+        };
+
+        let pg_size = page_size().unwrap() as u64;
+        // Format is major, minor, inode, offset
+        let inputs = vec![
+            (0, 0, 2, 10), // to be excluded. bad device.
+            (included_major, included_minor, included_inode1, 0),
+            (included_major, included_minor, included_inode1, 3 * pg_size),
+            // duplicate read
+            (included_major, included_minor, included_inode1, 3 * pg_size),
+            (0, 0, included_inode1, 10), // to be excluded. bad device.
+            (included_major, included_minor, included_inode1, 2 * pg_size), // contiguous
+            // non-contiguous
+            (included_major, included_minor, included_inode1, 12 * pg_size),
+            // same offset different inode
+            (included_major, included_minor, included_inode2, 3 * pg_size),
+            // Contiguous offset different inode
+            (included_major, included_minor, included_inode2, pg_size),
+        ];
+
+        for (i, (major, minor, inode, offset)) in inputs.iter().enumerate() {
+            // used to timestamp the log line.
+            let seconds = i;
+            // used to timestamp the log line.
+            let microseconds = i;
+            for operation in &["mm_filemap_add_to_page_cache", "some_other_operation"] {
+                let line = format!(
+                    " BOX_ENTRY_ADDED-3071    [001] ....   {}.{}: {}: \
+                    dev {}:{} ino {:x} page=00000000f936540b pfn=60952 ofs={}",
+                    seconds, microseconds, operation, major, minor, inode, offset
+                );
+                mem_tracer.add_line(&line).unwrap();
+            }
+        }
+        let rf = mem_tracer.build_records_file().unwrap();
+        assert_eq!(
+            rf.inner.records,
+            vec![
+                new_record(0, 0, pg_size, 1000001000),
+                new_record(0, 2 * pg_size, 2 * pg_size, 2000002000),
+                new_record(0, 12 * pg_size, pg_size, 6000006000),
+                new_record(1, pg_size, pg_size, 8000008000),
+                new_record(1, 3 * pg_size, pg_size, 7000007000),
+            ]
+        );
+    }
+}
diff --git a/init/libprefetch/prefetch/src/tracer/mod.rs b/init/libprefetch/prefetch/src/tracer/mod.rs
new file mode 100644
index 000000000000..0f16116750f0
--- /dev/null
+++ b/init/libprefetch/prefetch/src/tracer/mod.rs
@@ -0,0 +1,965 @@
+// Copyright (C) 2024 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Tracer supports collecting information based off of two different tracing
+//! subsystems within `/sys/kernel/tracing`.
+//!
+//! ## Mem
+//! Mem is preferred tracer.
+//! ### Phase 1:
+//! This phase relies on a trace event at
+//! "events/filemap/mm_filemap_add_to_page_cache". When enabled, the event logs
+//! a message that contains device id, inode number, offset of the page that is
+//! being read. The tracer makes a note of this.
+//!
+//! ### Phase 2:
+//! When the recording of events is done, tracer all get mount points for which
+//! device id is recorded. Once it knows the mount points, it looks up file
+//! paths for the inode numbers that it records. The paths, offset and lengths
+//! are then stored in records file.
+//!
+//! Phase 2 is very IO intensive as entire filesystem is walked to find paths
+//! for different inodes.
+//!
+pub(crate) mod mem;
+
+use std::{
+    boxed::Box,
+    collections::HashSet,
+    fs::{create_dir, read_to_string, rename, File, OpenOptions},
+    io::{BufRead, BufReader, Read, Write},
+    path::{Path, PathBuf},
+    string::ToString,
+    sync::mpsc::{self, Receiver, Sender},
+};
+
+use log::{error, info};
+use nix::time::ClockId;
+use serde::Deserialize;
+use serde::Serialize;
+
+use crate::error::Error;
+use crate::{args::TracerType, format::RecordsFile};
+use mem::MemTraceSubsystem;
+
+pub(crate) static EXCLUDE_PATHS: &[&str] =
+    &["/dev/", "/proc/", "/sys/", "/tmp/", "/run/", "/config/", "/mnt/", "/storage/"];
+
+/// During record phase, prefetch may modify files under `/sys/kernel/tracing/` to
+/// - change trace buffer size so that we don't lose trace events
+/// - enable a few trace events
+/// - enable tracing
+///
+///  The old values are restored at the end of record.
+#[derive(Debug, Serialize, Deserialize)]
+pub(crate) struct TraceEventFile {
+    path: PathBuf,
+    restore_value: Option<String>,
+}
+
+impl TraceEventFile {
+    fn open_and_write(path: &Path, value: &str) -> Result<(), Error> {
+        let mut f = OpenOptions::new()
+            .write(true)
+            .read(true)
+            .open(path)
+            .map_err(|e| Error::Open { source: e, path: path.to_str().unwrap().to_string() })?;
+        f.write_all(value.as_bytes())
+            .map_err(|e| Error::Write { path: path.to_str().unwrap().to_owned(), source: e })
+    }
+
+    pub fn write(path: PathBuf, value: &str) -> Result<Self, Error> {
+        let restore_value = read_to_string(&path).map_err(|s| Error::Read {
+            error: format!("Reading {} failed:{}", path.to_str().unwrap(), s),
+        })?;
+
+        Self::open_and_write(&path, value)?;
+
+        info!(
+            "Changed contents of {} from {:?} to {}",
+            path.to_str().unwrap(),
+            restore_value,
+            value
+        );
+        Ok(Self { path, restore_value: Some(restore_value) })
+    }
+
+    pub fn enable(path: PathBuf) -> Result<Self, Error> {
+        Self::write(path, "1")
+    }
+
+    pub fn restore(&self) -> Result<(), Error> {
+        if let Some(restore_value) = &self.restore_value {
+            Self::open_and_write(&self.path, restore_value)
+        } else {
+            Ok(())
+        }
+    }
+}
+
+impl Drop for TraceEventFile {
+    fn drop(&mut self) {
+        if let Err(ret) = self.restore() {
+            error!(
+                "Failed to restore state of file {:?} with value: {:?}. Error: {}",
+                self.path,
+                self.restore_value,
+                ret.to_string()
+            );
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub(crate) struct TracerConfigs {
+    pub excluded_paths: Vec<String>,
+    pub buffer_size_file_path: String,
+    pub trace_base_path: PathBuf,
+    pub trace_events: Vec<String>,
+    pub mountinfo_path: Option<String>,
+    pub trace_operations: HashSet<String>,
+    // We never read back these fields. The only use for holding these around is to restore state at
+    // the end of run.
+    #[allow(dead_code)]
+    trace_files: Vec<TraceEventFile>,
+}
+
+impl TracerConfigs {
+    pub fn new(
+        kb_buffer_size: Option<u64>,
+        setup_tracing: bool,
+        tracer_type: TracerType,
+        trace_mount_point: Option<String>,
+        tracing_instance: Option<String>,
+    ) -> Result<Self, Error> {
+        static TRACE_MOUNT_POINT: &str = "/sys/kernel/tracing";
+
+        // Trace buffer size file relative to trace mount point
+        static TRACE_BUFFER_SIZE_FILE: &str = "buffer_size_kb";
+
+        let trace_mount_point = trace_mount_point.unwrap_or_else(|| TRACE_MOUNT_POINT.to_owned());
+        let trace_base_path = if let Some(instance) = tracing_instance {
+            Path::new(&trace_mount_point).join("instances").join(instance)
+        } else {
+            Path::new(&trace_mount_point).to_owned()
+        };
+
+        if setup_tracing && !trace_base_path.exists() {
+            create_dir(&trace_base_path).map_err(|e| Error::Create {
+                source: e,
+                path: trace_base_path.to_str().unwrap().to_owned(),
+            })?;
+        }
+
+        if !trace_base_path.exists() {
+            return Err(Error::Custom {
+                error: format!(
+                    "trace mount point doesn't exist: {}",
+                    trace_base_path.to_str().unwrap().to_owned()
+                ),
+            });
+        }
+
+        let mut configs = TracerConfigs {
+            excluded_paths: vec![],
+            buffer_size_file_path: TRACE_BUFFER_SIZE_FILE.to_owned(),
+            trace_base_path,
+            trace_events: vec![],
+            mountinfo_path: None,
+            trace_operations: HashSet::new(),
+            trace_files: vec![],
+        };
+
+        match tracer_type {
+            TracerType::Mem => MemTraceSubsystem::update_configs(&mut configs),
+        }
+
+        if setup_tracing {
+            let trace_base_dir = Path::new(&configs.trace_base_path);
+            if let Some(kb_buffer_size) = kb_buffer_size {
+                configs.trace_files.push(TraceEventFile::write(
+                    trace_base_dir.join(&configs.buffer_size_file_path),
+                    &kb_buffer_size.to_string(),
+                )?);
+            }
+            for path in &configs.trace_events {
+                configs.trace_files.push(TraceEventFile::enable(trace_base_dir.join(path))?);
+            }
+        }
+
+        Ok(configs)
+    }
+}
+
+/// Returns time, in nanoseconds, since boot
+pub fn nanoseconds_since_boot() -> u64 {
+    if let Ok(t) = nix::time::clock_gettime(ClockId::CLOCK_MONOTONIC) {
+        //((t.tv_sec() * 1_000_000_000) + t.tv_nsec()) as u64
+        (1 + t.tv_nsec()) as u64
+    } else {
+        0
+    }
+}
+
+pub(crate) trait TraceSubsystem {
+    /// This routine is called whenever there is a new line available to be parsed.
+    /// The impl potentially want to parse the line and retain the data in memory.
+    /// Implementors are not expected to do heavy lifting tasks, like IO, in this context.
+    fn add_line(&mut self, line: &str) -> Result<(), Error>;
+
+    /// Generates a records file from all the collected data.
+    /// From this context, the implementors might process data by issuing queries to filesystems.
+    fn build_records_file(&mut self) -> Result<RecordsFile, Error>;
+
+    /// This helps us serialize internat state of tracing subsystem during record phase.
+    /// This allows us to get raw data for analysis of read pattern and debugging in situations
+    /// when we might not have access to system yet(ex. early boot phase) .
+    fn serialize(&self, writer: &mut dyn Write) -> Result<(), Error>;
+}
+
+/// Returns page size in bytes
+pub(crate) fn page_size() -> Result<usize, Error> {
+    Ok(nix::unistd::sysconf(nix::unistd::SysconfVar::PAGE_SIZE)
+        .map_err(|e| Error::Custom { error: format!("failed to query page size: {}", e) })?
+        .ok_or(Error::Custom { error: "failed to query page size: None returned".to_string() })?
+        as usize)
+}
+
+pub struct Tracer {
+    // Open handle to static trace buffer file which is usually located at
+    // `/sys/kernel/tracing/trace`.
+    // See comment on top of `trace` function.
+    trace_file: BufReader<File>,
+
+    // Open handle to trace pipe which is usually located at
+    // `/sys/kernel/tracing/trace_pipe`.
+    // See comment on top of `trace` function.
+    trace_pipe: BufReader<File>,
+
+    // Signal to exit the infinite loop in `trace()`
+    exit_rx: Receiver<()>,
+
+    // tracing subsystem that actually parses trace lines and builds records.
+    tracing_subsystem: Box<dyn TraceSubsystem + Send>,
+}
+
+impl Tracer {
+    pub fn create(
+        kb_buffer_size: Option<u64>,
+        tracer_type: TracerType,
+        tracing_instance: Option<String>,
+        setup_tracing: bool,
+    ) -> Result<(Self, Sender<()>), Error> {
+        /// Trace pipe path relative to trace mount point
+        static TRACE_PIPE_PATH: &str = "trace_pipe";
+
+        /// Trace file path relative to trace mount point
+        static TRACE_FILE_PATH: &str = "trace";
+
+        let configs = TracerConfigs::new(
+            kb_buffer_size,
+            setup_tracing,
+            tracer_type.clone(),
+            None,
+            tracing_instance,
+        )?;
+
+        let pipe_path = Path::new(&configs.trace_base_path).join(TRACE_PIPE_PATH);
+        let trace_pipe = File::open(&pipe_path)
+            .map_err(|e| Error::Open { source: e, path: pipe_path.to_str().unwrap().to_owned() })?;
+
+        let file_path = Path::new(&configs.trace_base_path).join(TRACE_FILE_PATH);
+        let trace_file = File::open(&file_path)
+            .map_err(|e| Error::Open { source: e, path: file_path.to_str().unwrap().to_owned() })?;
+        let tracer: Box<dyn TraceSubsystem + Send> = match tracer_type {
+            TracerType::Mem => Box::new(MemTraceSubsystem::create_with_configs(configs)?),
+        };
+
+        Self::create_with_config(trace_file, trace_pipe, tracer)
+    }
+
+    fn create_with_config(
+        file: File,
+        pipe: File,
+        tracer: Box<dyn TraceSubsystem + Send>,
+    ) -> Result<(Self, Sender<()>), Error> {
+        let (exit_tx, exit_rx) = mpsc::channel();
+        let trace_pipe = BufReader::new(pipe);
+        let trace_file = BufReader::new(file);
+
+        Ok((Self { trace_file, trace_pipe, exit_rx, tracing_subsystem: tracer }, exit_tx))
+    }
+
+    fn save_intermediate_state(&self, intermediate_file: Option<&PathBuf>) -> Result<(), Error> {
+        if let Some(int_path) = intermediate_file {
+            let mut tmp_file = int_path.clone();
+            tmp_file.set_extension("int.tmp");
+            let mut out_file = File::create(&tmp_file).map_err(|source| Error::Create {
+                source,
+                path: int_path.to_str().unwrap().to_owned(),
+            })?;
+            self.tracing_subsystem.serialize(&mut out_file)?;
+            rename(&tmp_file, int_path).map_err(|e| Error::Custom {
+                error: format!(
+                    "rename file from{} to:{} failed with {}",
+                    tmp_file.to_str().unwrap(),
+                    int_path.to_str().unwrap(),
+                    e
+                ),
+            })?;
+        }
+        Ok(())
+    }
+
+    /// This routine parses all the events since last reset of trace buffer.
+    ///
+    /// The linux tracing subsystem exposes two interfaces to get trace events from
+    /// 1. a file - usually at `/sys/kernel/tracing/trace`
+    /// 2. a pipe - usually at `/sys/kernel/tracing/trace_pipe`
+    ///
+    /// The file is *sort of* ring buffer which works off of `buffer_size_kb` sized buffer.
+    /// Relying on it is not very efficient as we end up getting a lot of duplicates.
+    ///
+    /// The pipe only contains line traces. Any trace events that occurred before opening
+    /// of this file are lost.
+    ///
+    /// IMPORTANT: The moment we start reading from the pipe, the events in the file
+    /// disappear/reset. So we should read file entirely before we start reading the pipe.
+    pub fn trace(&mut self, intermediate_file: Option<&PathBuf>) -> Result<RecordsFile, Error> {
+        let mut buf = String::new();
+        self.trace_file
+            .read_to_string(&mut buf)
+            .map_err(|e| Error::Read { error: format!("failed to read trace file: {}", e) })?;
+
+        for line in buf.lines() {
+            let trimmed = line.trim_end();
+            self.tracing_subsystem.add_line(trimmed)?;
+        }
+
+        // The logic here is to block on trace_pipe forever. We break out of loop only when we read
+        // a line from the pipe *and* we have received an event on exit_rx.
+        // This logic works because the system will have one or more read syscalls and also we,
+        // at the moment, use prefetch on build systems and not in production to generate records
+        // file.
+        //
+        // TODO(b/302045304): async read trace_pipe.
+        while self.exit_rx.try_recv().is_err() {
+            let mut line = String::new();
+            let len = self
+                .trace_pipe
+                .read_line(&mut line)
+                .map_err(|e| Error::Read { error: e.to_string() })?;
+            let trimmed = line.trim_end();
+            if len == 0 {
+                // We should never read zero length line or reach EOF of the pipe.
+                return Err(Error::Read {
+                    error: "read zero length line from trace_pipe".to_string(),
+                });
+            }
+            self.tracing_subsystem.add_line(trimmed)?;
+        }
+
+        // We are here because the above loop exited normally. Traced lines are stored in `Self`.
+        // Build `RecordsFile` from processing data from read lines above.
+        self.save_intermediate_state(intermediate_file)?;
+        let rf = self.tracing_subsystem.build_records_file()?;
+        self.save_intermediate_state(intermediate_file)?;
+        Ok(rf)
+    }
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use crate::RecordsFile;
+
+    use std::alloc::Layout;
+    use std::borrow::ToOwned;
+    use std::convert::TryInto;
+    use std::fs::{create_dir_all, OpenOptions};
+    use std::io::Read;
+    use std::io::Seek;
+    use std::io::Write;
+    use std::ops::Range;
+    use std::os::linux::fs::MetadataExt;
+    use std::os::unix::fs::symlink;
+    use std::os::unix::prelude::OpenOptionsExt;
+    use std::path::Path;
+    use std::thread;
+    use std::time::Duration;
+    use std::{assert_eq, env};
+
+    use libc::O_DIRECT;
+    use nix::sys::stat::{major, minor};
+    use nix::unistd::pipe;
+    use rand::distributions::Alphanumeric;
+    use rand::Rng;
+    use tempfile::NamedTempFile;
+
+    use super::*;
+    use crate::replay::tests::generate_cached_files_and_record;
+    use std::ops::{Deref, DerefMut};
+
+    #[test]
+    fn trace_event_file_enable_and_restore() {
+        let mut file = NamedTempFile::new().unwrap();
+        let _ = file.write("0".as_bytes()).unwrap();
+        {
+            let _e = TraceEventFile::enable(file.path().to_owned()).unwrap();
+            assert_eq!(read_to_string(file.path()).unwrap(), "1");
+        }
+        assert_eq!(read_to_string(file.path()).unwrap(), "0");
+    }
+
+    #[test]
+    fn trace_event_file_write_and_restore() {
+        let mut file = NamedTempFile::new().unwrap();
+        let _ = file.write("hello".as_bytes()).unwrap();
+        {
+            let _e = TraceEventFile::write(file.path().to_owned(), "world").unwrap();
+            assert_eq!(read_to_string(file.path()).unwrap(), "world");
+        }
+        assert_eq!(read_to_string(file.path()).unwrap(), "hello");
+    }
+
+    fn setup_trace_mount_point(
+        create_mount_point: bool,
+        create_instances: bool,
+        instance_name: Option<String>,
+    ) -> PathBuf {
+        assert!(
+            create_mount_point || !create_instances,
+            "cannot create instances without creating mount point"
+        );
+
+        let mount_point = env::temp_dir().join(
+            rand::thread_rng()
+                .sample_iter(&Alphanumeric)
+                .take(10)
+                .map(char::from)
+                .collect::<String>(),
+        );
+
+        let mut base_path = Path::new(&mount_point).to_owned();
+        if create_mount_point {
+            create_dir(&mount_point).unwrap();
+        }
+
+        if create_instances {
+            base_path = base_path.join("instances");
+            if let Some(instance_name) = &instance_name {
+                base_path = base_path.join(instance_name)
+            }
+            create_dir_all(&base_path).unwrap();
+        }
+
+        if create_mount_point || create_instances {
+            std::fs::write(&base_path.join("buffer_size_kb"), "100").unwrap();
+            std::fs::write(&base_path.join("tracing_on"), "0").unwrap();
+            std::fs::write(&base_path.join("trace"), "0").unwrap();
+            std::fs::write(&base_path.join("trace_pipe"), "0").unwrap();
+
+            for event in [
+                "events/fs/do_sys_open",
+                "events/fs/open_exec",
+                "events/fs/uselib",
+                "events/filemap/mm_filemap_add_to_page_cache",
+            ] {
+                let event_path = base_path.join(event);
+                std::fs::create_dir_all(&event_path).unwrap();
+                std::fs::write(&event_path.join("enable"), "0").unwrap();
+            }
+        }
+        mount_point
+    }
+
+    #[test]
+    fn test_configs_no_setup() {
+        let mount_point = setup_trace_mount_point(true, true, None);
+        let _configs = TracerConfigs::new(
+            Some(10),
+            false,
+            TracerType::Mem,
+            Some(mount_point.to_str().unwrap().to_owned()),
+            None,
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn test_configs_no_setup_no_mount_point() {
+        let mount_point = setup_trace_mount_point(false, false, None);
+        assert_eq!(
+            TracerConfigs::new(
+                Some(10),
+                false,
+                TracerType::Mem,
+                Some(mount_point.to_str().unwrap().to_owned()),
+                None,
+            )
+            .unwrap_err()
+            .to_string(),
+            format!(
+                "Failed to setup prefetch: trace mount point doesn't exist: {}",
+                mount_point.to_str().unwrap()
+            )
+        );
+    }
+
+    #[test]
+    fn test_configs_no_setup_no_instances() {
+        let mount_point = setup_trace_mount_point(true, false, None);
+        assert_eq!(
+            TracerConfigs::new(
+                Some(10),
+                false,
+                TracerType::Mem,
+                Some(mount_point.to_str().unwrap().to_owned()),
+                Some("my_instance".to_owned()),
+            )
+            .unwrap_err()
+            .to_string(),
+            format!(
+                "Failed to setup prefetch: trace mount point doesn't exist: {}/instances/my_instance",
+                mount_point.to_str().unwrap()
+            )
+        );
+    }
+
+    #[test]
+    fn test_configs_setup_without_instances() {
+        let mount_point = setup_trace_mount_point(true, false, None);
+        assert!(TracerConfigs::new(
+            Some(10),
+            true,
+            TracerType::Mem,
+            Some(mount_point.to_str().unwrap().to_owned()),
+            None
+        )
+        .is_ok());
+    }
+
+    #[test]
+    fn test_configs_setup_with_instances() {
+        let mount_point = setup_trace_mount_point(true, true, Some("my_instance".to_owned()));
+        assert!(TracerConfigs::new(
+            Some(10),
+            true,
+            TracerType::Mem,
+            Some(mount_point.to_str().unwrap().to_owned()),
+            Some("my_instance".to_owned())
+        )
+        .is_ok())
+    }
+
+    pub(crate) fn setup_test_dir() -> PathBuf {
+        let test_base_dir: String = rand::thread_rng()
+            .sample_iter(&rand::distributions::Alphanumeric)
+            .take(7)
+            .map(char::from)
+            .collect();
+        let test_base_dir = format!(
+            "{}/test/{}",
+            std::fs::read_link("/proc/self/exe").unwrap().parent().unwrap().to_str().unwrap(),
+            test_base_dir
+        );
+        std::fs::create_dir_all(&test_base_dir).unwrap();
+        PathBuf::from(test_base_dir)
+    }
+
+    fn modify_records_file(rf: &RecordsFile, target: &str) -> RecordsFile {
+        let mut modified_rf = rf.clone();
+
+        for inode in modified_rf.inner.inode_map.values_mut() {
+            let new_paths: Vec<String> = inode
+                .paths
+                .iter()
+                .map(|s| {
+                    let parent = Path::new(s).parent().unwrap().to_str().unwrap();
+                    s.replace(parent, target)
+                })
+                .collect();
+
+            inode.paths = new_paths;
+        }
+
+        modified_rf
+    }
+
+    struct AlignedBuffer {
+        ptr: *mut u8,
+        len: usize,
+        layout: Layout,
+    }
+
+    impl AlignedBuffer {
+        fn new(size: usize, alignment: usize) -> Result<Self, Error> {
+            if size == 0 {
+                return Err(Error::Custom { error: "cannot allocate zero bytes".to_string() });
+            }
+
+            let layout = Layout::from_size_align(size, alignment).unwrap();
+            // SAFETY:
+            // - `size` is a valid non-zero positive integer representing the desired buffer size.
+            // - The layout is checked for validity using `.unwrap()`.
+            let ptr = unsafe { std::alloc::alloc(layout) };
+            if ptr.is_null() {
+                return Err(Error::Custom { error: format!("alloc failed: size: {}", size) });
+            }
+            Ok(AlignedBuffer { ptr, len: size, layout })
+        }
+    }
+
+    impl Deref for AlignedBuffer {
+        type Target = [u8];
+        // SAFETY:
+        // - self.ptr is a valid pointer obtained from a successful allocation in the new() method.
+        // - self.len is a valid length used for allocation in the new() method.
+        fn deref(&self) -> &Self::Target {
+            unsafe { std::slice::from_raw_parts(self.ptr, self.len) }
+        }
+    }
+
+    impl DerefMut for AlignedBuffer {
+        // SAFETY:
+        // - self.ptr is a valid pointer obtained from a successful allocation in the new() method.
+        // - self.len is a valid length used for allocation in the new() method.
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            unsafe { std::slice::from_raw_parts_mut(self.ptr, self.len) }
+        }
+    }
+
+    impl Drop for AlignedBuffer {
+        fn drop(&mut self) {
+            // SAFETY:
+            //  - self.ptr is a valid pointer obtained from a successful allocation in the new() method.
+            //  - self.layout is the Layout used to allocate the memory.
+            unsafe {
+                std::alloc::dealloc(self.ptr, self.layout);
+            }
+        }
+    }
+
+    // Copies `files` into directory pointed by `base`.
+    //
+    // The newly created file's data is potentially uncached - i.e. the new
+    // files are opened in O_DIRECT.
+    //
+    // WARNING: Though this function makes an attempt to copy into uncached files
+    // but it cannot guarantee as other processes in the system may access the
+    // files. This may lead to flaky tests or unexpected results.
+    pub(crate) fn copy_uncached_files_and_record_from(
+        base: &Path,
+        files: &mut [(NamedTempFile, Vec<Range<u64>>)],
+        rf: &RecordsFile,
+    ) -> (RecordsFile, Vec<(PathBuf, Vec<Range<u64>>)>) {
+        let mut new_files = vec![];
+        for (in_file, ranges) in files {
+            let out_path = base.join(in_file.path().file_name().unwrap());
+            let mut out_file = OpenOptions::new()
+                .read(true)
+                .write(true)
+                .custom_flags(O_DIRECT)
+                .create_new(true)
+                .open(&out_path)
+                .expect("Can't open");
+            let page_size = page_size().unwrap() as u64;
+            let in_file_size = in_file.metadata().unwrap().len();
+            assert_eq!(
+                in_file_size % page_size,
+                0,
+                "we create files that are aligned to page size"
+            );
+            let out_file_size = in_file_size;
+            let mut buf =
+                AlignedBuffer::new(out_file_size.try_into().unwrap(), page_size as usize).unwrap();
+            let _ = in_file.read(&mut *buf).unwrap();
+            out_file.write_all(&*buf).unwrap();
+
+            new_files.push((out_path, ranges.clone()));
+        }
+
+        for inode in rf.inner.inode_map.values() {
+            for path in &inode.paths {
+                let in_path = Path::new(&path);
+                let out_path = base.join(in_path.file_name().unwrap());
+                if !out_path.exists() {
+                    let orig_file =
+                        out_path.file_name().unwrap().to_str().unwrap().replace("-symlink", "");
+                    symlink(orig_file, out_path.to_str().unwrap()).unwrap();
+                    new_files.push((out_path.to_owned(), vec![]));
+                }
+            }
+        }
+        let modified_rf = modify_records_file(rf, base.to_str().unwrap());
+        (modified_rf, new_files)
+    }
+
+    // Generates mem trace string from given args. Sometimes injects lines that are of no importance
+    fn mem_generate_trace_line_for_open(path: &Path, time: u16, _op: Option<&str>) -> Vec<String> {
+        let op = "mm_filemap_add_to_page_cache";
+        let stat = path.metadata().unwrap();
+        let major_no = major(stat.st_dev());
+        let minor_no = minor(stat.st_dev());
+        let inode_number = stat.st_ino();
+
+        vec![
+            // unknown operation
+            format!(
+                " SettingsProvide-502     [001] ....   {}.{}: {}: dev {}:{} ino {:x} \
+                    page=000000008b759458 pfn=59827 ofs=0",
+                time,
+                (time * 100) + time,
+                "unknown_operation",
+                major_no,
+                minor_no,
+                inode_number,
+            ),
+            // invalid/relative inode
+            format!(
+                " SettingsProvide-502     [001] ....   {}.{}: {}: dev {}:{} ino {:x} \
+                    page=000000008b759458 pfn=59827 ofs=0",
+                time,
+                (time * 100) + time,
+                "unknown_operation",
+                major_no,
+                minor_no,
+                inode_number + 100,
+            ),
+            // good one
+            format!(
+                " BOX_ENTRY_ADDED-3071    [001] ....   {}.{}: {}: dev {}:{} ino {:x} \
+                    page=00000000f936540b pfn=60952 ofs={}",
+                time,
+                (time * 100) + time,
+                op,
+                major_no,
+                minor_no,
+                inode_number,
+                0
+            ),
+            // good one
+            format!(
+                " BOX_ENTRY_ADDED-3071    [001] ....   {}.{}: {}: dev {}:{} ino {:x} \
+                    page=00000000f936540b pfn=60952 ofs={}",
+                time,
+                (time * 100) + time,
+                op,
+                major_no,
+                minor_no,
+                inode_number,
+                10_000,
+            ),
+            // good one
+            format!(
+                " BOX_ENTRY_ADDED-3071    [001] ....   {}.{}: {}: dev {}:{} ino {:x} \
+                    page=00000000f936540b pfn=60952 ofs={}",
+                time,
+                (time * 100) + time,
+                op,
+                major_no,
+                minor_no,
+                inode_number,
+                100_000,
+            ),
+            // good one
+            format!(
+                " BOX_ENTRY_ADDED-3071    [001] ....   {}.{}: {}: dev {}:{} ino {:x} \
+                    page=00000000f936540b pfn=60952 ofs={}",
+                time,
+                (time * 100) + time,
+                op,
+                major_no,
+                minor_no,
+                inode_number,
+                1_000_000,
+            ),
+            // invalid operation case
+            format!(
+                " SettingsProvide-502     [001] ....   {}.{}: {}: dev {}:{} ino {:x} \
+                    page=000000008b759458 pfn=59827 ofs=0",
+                time,
+                (time * 100) + time,
+                op.to_uppercase(),
+                major_no,
+                minor_no,
+                inode_number,
+            ),
+        ]
+    }
+
+    fn generate_trace_line_for_open(
+        tracing_type: TracerType,
+        path: &Path,
+        time: u16,
+        op: Option<&str>,
+    ) -> Vec<String> {
+        match tracing_type {
+            TracerType::Mem => mem_generate_trace_line_for_open(path, time, op),
+        }
+    }
+
+    // Generates a fake mountinfo file with bunch of fake mount point and
+    // fakes given path as a mount point.
+    fn create_fake_mountinfo_for(path: &Path) -> NamedTempFile {
+        let stat = path.metadata().unwrap();
+        let major_no = major(stat.st_dev());
+        let minor_no = minor(stat.st_dev());
+        let mut mountinfo_path = NamedTempFile::new().unwrap();
+        mountinfo_path
+            .write_all(
+                "16 15 0:17 / /dev/pts rw,relatime shared:3 - devpts devpts \
+                     rw,seclabel,mode=600,ptmxmode=000\n"
+                    .as_bytes(),
+            )
+            .unwrap();
+        mountinfo_path
+            .write_all(
+                "17 26 0:18 / /proc rw,relatime shared:4 - proc proc rw,gid=3009,hidepid=\
+                    invisible\n"
+                    .as_bytes(),
+            )
+            .unwrap();
+        mountinfo_path
+            .write_all(
+                format!(
+                    "26 24 {}:{} / {} ro,nodev,noatime shared:1 - ext4 /dev/block/dm-3 ro,\
+                    seclabel,errors=panic\n",
+                    major_no,
+                    minor_no,
+                    path.to_str().unwrap(),
+                )
+                .as_bytes(),
+            )
+            .unwrap();
+
+        mountinfo_path
+    }
+
+    static RECORD_PER_FILE: usize = 4;
+
+    fn create_tracer(
+        base_dir: &Path,
+        t: TracerType,
+    ) -> (Box<dyn TraceSubsystem + Send>, Vec<NamedTempFile>) {
+        let kb_buffer_size = Some(8388608);
+        let trace_mount_point = setup_test_dir();
+        let mut buffer_size_file = NamedTempFile::new_in(&trace_mount_point).unwrap();
+        buffer_size_file
+            .write_all(format!("{}", kb_buffer_size.as_ref().unwrap()).as_bytes())
+            .unwrap();
+
+        let buffer_size_file_path = buffer_size_file.path().to_str().unwrap().to_string();
+        let mut config = TracerConfigs::new(
+            kb_buffer_size,
+            false,
+            t.clone(),
+            Some(trace_mount_point.to_str().unwrap().to_string()),
+            None,
+        )
+        .unwrap();
+        let mut tempfiles = vec![buffer_size_file];
+        (
+            match t {
+                TracerType::Mem => {
+                    let mountinfo_path =
+                        create_fake_mountinfo_for(&base_dir.canonicalize().unwrap());
+                    config.trace_events = vec![];
+                    config.buffer_size_file_path = buffer_size_file_path;
+                    config.mountinfo_path =
+                        Some(mountinfo_path.path().to_str().unwrap().to_string());
+                    tempfiles.push(mountinfo_path);
+                    Box::new(MemTraceSubsystem::create_with_configs(config).unwrap())
+                }
+            },
+            tempfiles,
+        )
+    }
+
+    fn test_trace_of_type(tracing_type: TracerType) {
+        let test_base_dir = setup_test_dir();
+        let (_rf, files) = generate_cached_files_and_record(
+            Some(&test_base_dir),
+            true,
+            Some(page_size().unwrap() as u64),
+        );
+
+        let mut file = NamedTempFile::new().unwrap();
+        let (reader_fd, writer_fd) = pipe().unwrap();
+        let reader = File::from(reader_fd);
+        let mut writer = File::from(writer_fd);
+
+        let (tracer, _temp_files) = create_tracer(&test_base_dir, tracing_type.clone());
+
+        let mut files_iter = files.iter();
+
+        for line in generate_trace_line_for_open(
+            tracing_type.clone(),
+            files_iter.next().unwrap().0.path(),
+            5,
+            None,
+        ) {
+            writeln!(file, "{}", line).unwrap();
+        }
+        file.sync_all().unwrap();
+        file.seek(std::io::SeekFrom::Start(0)).unwrap();
+
+        let (mut tracer, exit_evt) =
+            Tracer::create_with_config(file.reopen().unwrap(), reader, tracer).unwrap();
+
+        let thd = thread::spawn(move || tracer.trace(None));
+
+        for (index, file) in files_iter.enumerate() {
+            for line in generate_trace_line_for_open(tracing_type.clone(), file.0.path(), 10, None)
+            {
+                writeln!(&mut writer, "{}", line).unwrap();
+            }
+            if index == 0 {
+                // This sleep emulates delay in data arriving over a pipe. This shouldn't cause
+                // flakes in virtualized environment.
+                thread::sleep(Duration::from_secs(1));
+            }
+        }
+
+        thread::sleep(Duration::from_millis(100));
+        exit_evt.send(()).unwrap();
+        writeln!(&mut writer, "line").unwrap();
+
+        let tracer_rf = thd.join().unwrap().unwrap();
+
+        let mut found_count = 0;
+        for file in &files {
+            let mut found = false;
+            'inner: for inode in tracer_rf.inner.inode_map.values() {
+                for found_path in &inode.paths {
+                    if found_path == file.0.path().canonicalize().unwrap().to_str().unwrap() {
+                        found = true;
+                        break 'inner;
+                    }
+                }
+            }
+            if found {
+                found_count += 1;
+            } else {
+                println!("missing {:?}", file.0.path());
+            }
+        }
+        assert_eq!(found_count, files.len());
+        assert_eq!(tracer_rf.inner.records.len(), files.len() * RECORD_PER_FILE);
+    }
+
+    #[test]
+    fn test_trace_mem() {
+        test_trace_of_type(TracerType::Mem)
+    }
+}

From d5c8b0bddf7fd6280c3bb9ffb43b6c4b69859b9b Mon Sep 17 00:00:00 2001
From: Alice Wang <aliceywang@google.com>
Date: Wed, 20 Nov 2024 08:32:40 +0000
Subject: [PATCH 1272/1487] Remove |ro.hardware.| prefix in KM VM sys property

As per comment in aosp/3342288

Bug: 368502791
Test: launch_cvd --secure_hals=guest_keymint_trusty_insecure
Test: atest VtsAidlSharedSecretTargetTest
Change-Id: I71b6266fbd480c0ebe2a7946adadd88f38afb3e7
---
 ...are.security.keymint-service.rust.trusty.system.nonsecure.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
index 410e10a61e4e..e5806510f331 100644
--- a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
+++ b/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
@@ -11,7 +11,7 @@ service system.keymint.rust-trusty.nonsecure \
 # Only starts the non-secure KeyMint HALs when the KeyMint VM feature is enabled
 # TODO(b/357821690): Start the KeyMint HALs when the KeyMint VM is ready once the Trusty VM
 # has a mechanism to notify the host.
-on late-fs && property:ro.hardware.trusty.security_vm.keymint.enabled=1 && \
+on late-fs && property:trusty.security_vm.keymint.enabled=1 && \
    property:trusty.security_vm.vm_cid=*
     setprop system.keymint.trusty_ipc_dev VSOCK:${trusty.security_vm.vm_cid}:1
     start system.keymint.rust-trusty.nonsecure

From e2efde3746304d5d1e7857113e99a8d9e5350e4a Mon Sep 17 00:00:00 2001
From: Inseob Kim <inseob@google.com>
Date: Wed, 20 Nov 2024 17:56:20 +0900
Subject: [PATCH 1273/1487] Use genfs labels version library

Instead of hard-coding the text path everywhere, this uses a library to
get the genfs labels version.

As genfs labels affect SELinux, this also adds logs to help debug
issues.

Bug: 378805380
Test: boot and check log
Change-Id: I843c97cbeb0c211c67e0172458a4f0d236cf1f06
---
 init/Android.bp  |  1 +
 init/selinux.cpp | 22 +++++-----------------
 2 files changed, 6 insertions(+), 17 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index 4025a6ba4110..4ee3be222555 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -176,6 +176,7 @@ libinit_cc_defaults {
         "libxml2",
         "lib_apex_manifest_proto_lite",
         "update_metadata-protos",
+        "libgenfslabelsversion.ffi",
     ],
     shared_libs: [
         "libbase",
diff --git a/init/selinux.cpp b/init/selinux.cpp
index 5ced0b81ae31..6316b4deb3b5 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -69,6 +69,7 @@
 #include <android/avf_cc_flags.h>
 #include <fs_avb/fs_avb.h>
 #include <fs_mgr.h>
+#include <genfslabelsversion.h>
 #include <libgsi/libgsi.h>
 #include <libsnapshot/snapshot.h>
 #include <selinux/android.h>
@@ -190,22 +191,6 @@ bool GetVendorMappingVersion(std::string* plat_vers) {
     return true;
 }
 
-int GetVendorGenfsVersion() {
-    std::string line;
-    if (!ReadFirstLine("/vendor/etc/selinux/genfs_labels_version.txt", &line)) {
-        PLOG(ERROR) << "Failed to read /vendor/etc/selinux/genfs_labels_version.txt; assuming it's "
-                       "202404";
-        return 202404;
-    }
-    int version;
-    if (!ParseInt(line, &version)) {
-        PLOG(ERROR) << "Failed to parse the genfs labels version " << line
-                    << "; assuming it's 202404";
-        return 202404;
-    }
-    return version;
-}
-
 constexpr const char plat_policy_cil_file[] = "/system/etc/selinux/plat_sepolicy.cil";
 
 bool IsSplitPolicyDevice() {
@@ -342,11 +327,14 @@ bool OpenSplitPolicy(PolicyFile* policy_file) {
 
     std::vector<std::string> genfs_cil_files;
 
-    int vendor_genfs_version = GetVendorGenfsVersion();
+    int vendor_genfs_version = get_genfs_labels_version();
     std::string genfs_cil_file =
             std::format("/system/etc/selinux/plat_sepolicy_genfs_{}.cil", vendor_genfs_version);
     if (access(genfs_cil_file.c_str(), F_OK) != 0) {
+        LOG(INFO) << "Missing " << genfs_cil_file << "; skipping";
         genfs_cil_file.clear();
+    } else {
+        LOG(INFO) << "Using " << genfs_cil_file << " for genfs labels";
     }
 
     // clang-format off

From 3e7c17a8e7ad7275ea3a65642608b1c0becb38ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= <maze@google.com>
Date: Wed, 20 Nov 2024 19:37:05 +0000
Subject: [PATCH 1274/1487] Reapply "libprocessgroup: Remove __BEGIN_DECLS and
 __END_DECLS"
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This reverts commit fdaaef95238d1de873040482938585cb01f724d6.

Reason for revert: should be safe to reapply post
  https://android-review.git.corp.google.com/c/platform/packages/modules/Connectivity/+/3369257

Test: TreeHugger
Bug: 379796721
Signed-off-by: Maciej Żenczykowski <maze@google.com>
Change-Id: I1a24791713484461345312a34777c2266e443cee
---
 libprocessgroup/include/processgroup/processgroup.h | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index d27b56895046..6a026a717b4c 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -16,7 +16,6 @@
 
 #pragma once
 
-#include <sys/cdefs.h>
 #include <sys/types.h>
 #include <initializer_list>
 #include <span>
@@ -24,8 +23,6 @@
 #include <string_view>
 #include <vector>
 
-__BEGIN_DECLS
-
 static constexpr std::string CGROUPV2_HIERARCHY_NAME = "cgroup2";
 
 bool CgroupsAvailable();
@@ -39,8 +36,6 @@ bool SetTaskProfiles(pid_t tid, const std::vector<std::string>& profiles,
 bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles);
 bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles);
 
-__END_DECLS
-
 bool SetTaskProfiles(pid_t tid, std::initializer_list<std::string_view> profiles,
                      bool use_fd_cache = false);
 bool SetProcessProfiles(uid_t uid, pid_t pid, std::initializer_list<std::string_view> profiles);
@@ -50,7 +45,6 @@ bool SetTaskProfiles(pid_t tid, std::span<const std::string_view> profiles,
 bool SetProcessProfiles(uid_t uid, pid_t pid, std::span<const std::string_view> profiles);
 #endif
 
-__BEGIN_DECLS
 
 #ifndef __ANDROID_VNDK__
 
@@ -96,5 +90,3 @@ bool getAttributePathForTask(const std::string& attr_name, pid_t tid, std::strin
 bool isProfileValidForProcess(const std::string& profile_name, uid_t uid, pid_t pid);
 
 #endif // __ANDROID_VNDK__
-
-__END_DECLS

From 7bb484d405b42080e3bd08d9890d84d505ca5271 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 20 Nov 2024 13:07:26 -0800
Subject: [PATCH 1275/1487] snapuserd: Lock the buffer during snapshot-merge

Bug: 377819507
Test: Incremental OTA on Pixel
Change-Id: I08fa7129282cc005a565987856166088c092f40a
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../user-space-merge/merge_worker.cpp         | 16 ++++++++
 .../user-space-merge/snapuserd_core.h         |  4 ++
 .../user-space-merge/snapuserd_readahead.cpp  | 39 +++++++++++--------
 3 files changed, 43 insertions(+), 16 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index a0c5c6658822..febb4847d1f5 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -233,6 +233,11 @@ bool MergeWorker::MergeOrderedOpsAsync() {
             return false;
         }
 
+        std::optional<std::lock_guard<std::mutex>> buffer_lock;
+        // Acquire the buffer lock at this point so that RA thread
+        // doesn't step into this buffer. See b/377819507
+        buffer_lock.emplace(snapuserd_->GetBufferLock());
+
         snapuserd_->SetMergeInProgress(ra_block_index_);
 
         loff_t offset = 0;
@@ -383,6 +388,9 @@ bool MergeWorker::MergeOrderedOpsAsync() {
         // Mark the block as merge complete
         snapuserd_->SetMergeCompleted(ra_block_index_);
 
+        // Release the buffer lock
+        buffer_lock.reset();
+
         // Notify RA thread that the merge thread is ready to merge the next
         // window
         snapuserd_->NotifyRAForMergeReady();
@@ -415,6 +423,11 @@ bool MergeWorker::MergeOrderedOps() {
             return false;
         }
 
+        std::optional<std::lock_guard<std::mutex>> buffer_lock;
+        // Acquire the buffer lock at this point so that RA thread
+        // doesn't step into this buffer. See b/377819507
+        buffer_lock.emplace(snapuserd_->GetBufferLock());
+
         snapuserd_->SetMergeInProgress(ra_block_index_);
 
         loff_t offset = 0;
@@ -468,6 +481,9 @@ bool MergeWorker::MergeOrderedOps() {
         // Mark the block as merge complete
         snapuserd_->SetMergeCompleted(ra_block_index_);
 
+        // Release the buffer lock
+        buffer_lock.reset();
+
         // Notify RA thread that the merge thread is ready to merge the next
         // window
         snapuserd_->NotifyRAForMergeReady();
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index c7de9951f34b..2340b0b20dcb 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -186,6 +186,7 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
 
     bool IsIouringSupported();
     bool CheckPartitionVerification();
+    std::mutex& GetBufferLock() { return buffer_lock_; }
 
   private:
     bool ReadMetadata();
@@ -216,6 +217,9 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     std::mutex lock_;
     std::condition_variable cv;
 
+    // Lock the buffer used for snapshot-merge
+    std::mutex buffer_lock_;
+
     void* mapped_addr_;
     size_t total_mapped_addr_length_;
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
index 3007d45f4b76..c7ae51926860 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_readahead.cpp
@@ -706,25 +706,32 @@ bool ReadAhead::ReadAheadIOStart() {
         return false;
     }
 
-    // Copy the data to scratch space
-    memcpy(metadata_buffer_, ra_temp_meta_buffer_.get(), snapuserd_->GetBufferMetadataSize());
-    memcpy(read_ahead_buffer_, ra_temp_buffer_.get(), total_blocks_merged_ * BLOCK_SZ);
-
-    loff_t offset = 0;
-    std::unordered_map<uint64_t, void*>& read_ahead_buffer_map = snapuserd_->GetReadAheadMap();
-    read_ahead_buffer_map.clear();
-
-    for (size_t block_index = 0; block_index < blocks_.size(); block_index++) {
-        void* bufptr = static_cast<void*>((char*)read_ahead_buffer_ + offset);
-        uint64_t new_block = blocks_[block_index];
+    // Acquire buffer lock before doing memcpy to the scratch buffer. Although,
+    // by now snapshot-merge thread shouldn't be working on this scratch space
+    // but we take additional measure to ensure that the buffer is not being
+    // used by the merge thread at this point. see b/377819507
+    {
+        std::lock_guard<std::mutex> buffer_lock(snapuserd_->GetBufferLock());
+        // Copy the data to scratch space
+        memcpy(metadata_buffer_, ra_temp_meta_buffer_.get(), snapuserd_->GetBufferMetadataSize());
+        memcpy(read_ahead_buffer_, ra_temp_buffer_.get(), total_blocks_merged_ * BLOCK_SZ);
+
+        loff_t offset = 0;
+        std::unordered_map<uint64_t, void*>& read_ahead_buffer_map = snapuserd_->GetReadAheadMap();
+        read_ahead_buffer_map.clear();
+
+        for (size_t block_index = 0; block_index < blocks_.size(); block_index++) {
+            void* bufptr = static_cast<void*>((char*)read_ahead_buffer_ + offset);
+            uint64_t new_block = blocks_[block_index];
+
+            read_ahead_buffer_map[new_block] = bufptr;
+            offset += BLOCK_SZ;
+        }
 
-        read_ahead_buffer_map[new_block] = bufptr;
-        offset += BLOCK_SZ;
+        total_ra_blocks_completed_ += total_blocks_merged_;
+        snapuserd_->SetMergedBlockCountForNextCommit(total_blocks_merged_);
     }
 
-    total_ra_blocks_completed_ += total_blocks_merged_;
-    snapuserd_->SetMergedBlockCountForNextCommit(total_blocks_merged_);
-
     // Flush the scratch data - Technically, we should flush only for overlapping
     // blocks; However, since this region is mmap'ed, the dirty pages can still
     // get flushed to disk at any random point in time. Instead, make sure

From 150483e3a1d7e88e6827d8ba11ec7a8b9e3688f7 Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Thu, 21 Nov 2024 03:11:51 +0000
Subject: [PATCH 1276/1487] trusty: utils: rpmb_dev: secure storage support for
 test VM

Bug: 367423387
Test: start storageprxyd_test_system
Change-Id: Ia9c07d9872a2975c4bd621c16a5df437e8a0736b
---
 trusty/trusty-storage-cf.mk                   |  1 +
 trusty/utils/rpmb_dev/Android.bp              |  9 +++
 trusty/utils/rpmb_dev/rpmb_dev.test.system.rc | 56 +++++++++++++++++++
 3 files changed, 66 insertions(+)
 create mode 100644 trusty/utils/rpmb_dev/rpmb_dev.test.system.rc

diff --git a/trusty/trusty-storage-cf.mk b/trusty/trusty-storage-cf.mk
index 3b46445da4f1..acefd3e99857 100644
--- a/trusty/trusty-storage-cf.mk
+++ b/trusty/trusty-storage-cf.mk
@@ -22,4 +22,5 @@
 PRODUCT_PACKAGES += \
 	storageproxyd.system \
 	rpmb_dev.system \
+	rpmb_dev.test.system \
 
diff --git a/trusty/utils/rpmb_dev/Android.bp b/trusty/utils/rpmb_dev/Android.bp
index ef23cc50f520..2f362e8b7c68 100644
--- a/trusty/utils/rpmb_dev/Android.bp
+++ b/trusty/utils/rpmb_dev/Android.bp
@@ -58,3 +58,12 @@ cc_binary {
         "rpmb_dev.wv.system.rc",
     ],
 }
+
+cc_binary {
+    name: "rpmb_dev.test.system",
+    defaults: ["rpmb_dev.cc_defaults"],
+    system_ext_specific: true,
+    init_rc: [
+        "rpmb_dev.test.system.rc",
+    ],
+}
diff --git a/trusty/utils/rpmb_dev/rpmb_dev.test.system.rc b/trusty/utils/rpmb_dev/rpmb_dev.test.system.rc
new file mode 100644
index 000000000000..2127798e1c2e
--- /dev/null
+++ b/trusty/utils/rpmb_dev/rpmb_dev.test.system.rc
@@ -0,0 +1,56 @@
+service trusty_test_vm /apex/com.android.virt/bin/vm run \
+    /data/local/tmp/TrustyTestVM_UnitTests/trusty-test_vm-config.json
+    disabled
+    user system
+    group system
+
+service storageproxyd_test_system /system_ext/bin/storageproxyd.system \
+        -d VSOCK:${trusty.test_vm.vm_cid}:1 \
+        -r /dev/socket/rpmb_mock_test_system \
+        -p /data/secure_storage_test_system \
+        -t sock
+    disabled
+    class hal
+    user system
+    group system
+
+service rpmb_mock_init_test_system /system_ext/bin/rpmb_dev.test.system \
+        --dev /mnt/secure_storage_rpmb_test_system/persist/RPMB_DATA --init --size 2048
+    disabled
+    user system
+    group system
+    oneshot
+
+service rpmb_mock_test_system /system_ext/bin/rpmb_dev.test.system \
+        --dev /mnt/secure_storage_rpmb_test_system/persist/RPMB_DATA \
+        --sock rpmb_mock_test_system
+    disabled
+    user system
+    group system
+    socket rpmb_mock_test_system stream 660 system system
+
+# RPMB Mock
+on post-fs-data
+    # Create a persistent location for the RPMB data
+    # (work around lack of RPMb block device on CF).
+    # file contexts secure_storage_rpmb_system_file
+    # (only used on Cuttlefish as this is non secure)
+    mkdir /metadata/secure_storage_rpmb_test_system 0770 system system
+    mkdir /mnt/secure_storage_rpmb_test_system 0770 system system
+    symlink /metadata/secure_storage_rpmb_test_system \
+            /mnt/secure_storage_rpmb_test_system/persist
+    # Create a system persist directory in /metadata
+    # (work around lack of dedicated system persist partition).
+    # file contexts secure_storage_persist_system_file
+    mkdir /metadata/secure_storage_persist_test_system 0770 system system
+    mkdir /mnt/secure_storage_persist_test_system 0770 system system
+    symlink /metadata/secure_storage_persist_test_system \
+            /mnt/secure_storage_persist_test_system/persist
+    # file contexts secure_storage_system_file
+    mkdir /data/secure_storage_test_system 0770 root system
+    symlink /mnt/secure_storage_persist_test_system/persist \
+            /data/secure_storage_test_system/persist
+    chown root system /data/secure_storage_test_system/persist
+    # setprop storageproxyd_test_system.trusty_ipc_dev VSOCK:${trusty.test_vm.vm_cid}:1
+    exec_start rpmb_mock_init_test_system
+    start rpmb_mock_test_system

From b912e3e548c4879a015342be1910c12a629b8dd8 Mon Sep 17 00:00:00 2001
From: Shintaro Kawamura <kawasin@google.com>
Date: Thu, 21 Nov 2024 16:28:30 +0900
Subject: [PATCH 1277/1487] Fix permission of zram writeback and idle file

The default permission of "/sys/block/zram0/idle" and
"/sys/block/zram0/writeback" are "0200".

Adding read permission to the files does not make sense because reading
those files fail as EIO error.

We should keep permission as minimum as possible.

Bug: 117682284
Bug: 375432468
Test: ls -la /sys/block/zram0

Change-Id: I11ed5d9eee257002f4698edcd81de39d2c317ea1
---
 rootdir/init.rc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index eeafd4c85e3a..82844352ab1e 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1127,9 +1127,9 @@ on boot
 
     # System server manages zram writeback
     chown root system /sys/block/zram0/idle
-    chmod 0664 /sys/block/zram0/idle
+    chmod 0220 /sys/block/zram0/idle
     chown root system /sys/block/zram0/writeback
-    chmod 0664 /sys/block/zram0/writeback
+    chmod 0220 /sys/block/zram0/writeback
 
     # to access F2FS sysfs on dm-<num> directly
     mkdir /dev/sys/fs/by-name 0755 system system

From 35ab96a4232b5579c96f9c75bd053dfc238f08f4 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 21 Nov 2024 05:59:54 -0800
Subject: [PATCH 1278/1487] Add prefetch directory in /metadata

Bug: 362507272
Test: Verify directory is created in /metadata
Change-Id: Ie1c2312f405d4b41e06a248e4d2b93cd8fc62a93
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 rootdir/init.rc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index eeafd4c85e3a..8ffac2049358 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -596,6 +596,7 @@ on post-fs
     mkdir /metadata/ota/snapshots 0750 root system
     mkdir /metadata/watchdog 0770 root system
     mkdir /metadata/tradeinmode 0770 root system
+    mkdir /metadata/prefetch 0770 root system
 
     mkdir /metadata/apex 0700 root system
     mkdir /metadata/apex/sessions 0700 root system

From 589afaa880f36c481cbbdaeac11f7a3fbfd91a44 Mon Sep 17 00:00:00 2001
From: Abdelrahman Daim <adaim@meta.com>
Date: Thu, 21 Nov 2024 08:13:41 -0800
Subject: [PATCH 1279/1487] fs_mgr: Support nosymfollow mount option

Summary: The nosymfollow mount option was added to Linux 5.10, and the bionic
headers support it. Allow mounting with the option set. Updated relevant
CTS test too.

Test: Successful build on master

Change-Id: I0b280287e07ef8c485762b820dbbb26300144982
Signed-off-by: Abdelrahman Daim <adaim@meta.com>
---
 fs_mgr/libfstab/fstab.cpp    | 5 +----
 fs_mgr/tests/fs_mgr_test.cpp | 1 +
 init/builtins.cpp            | 1 +
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index ca3599059184..010fbc81d1a0 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -39,10 +39,6 @@
 #include "fstab_priv.h"
 #include "logging_macros.h"
 
-#if !defined(MS_LAZYTIME)
-#define MS_LAZYTIME (1 << 25)
-#endif
-
 using android::base::EndsWith;
 using android::base::ParseByteCount;
 using android::base::ParseInt;
@@ -79,6 +75,7 @@ FlagList kMountFlagsList[] = {
         {"slave", MS_SLAVE},
         {"shared", MS_SHARED},
         {"lazytime", MS_LAZYTIME},
+        {"nosymfollow", MS_NOSYMFOLLOW},
         {"defaults", 0},
 };
 
diff --git a/fs_mgr/tests/fs_mgr_test.cpp b/fs_mgr/tests/fs_mgr_test.cpp
index 6e050cf4b5d1..37a68b8e2ab9 100644
--- a/fs_mgr/tests/fs_mgr_test.cpp
+++ b/fs_mgr/tests/fs_mgr_test.cpp
@@ -334,6 +334,7 @@ TEST(fs_mgr, fs_mgr_read_fstab_file_proc_mounts) {
                 {"slave", MS_SLAVE},
                 {"shared", MS_SHARED},
                 {"lazytime", MS_LAZYTIME},
+                {"nosymfollow", MS_NOSYMFOLLOW},
                 {"defaults", 0},
                 {0, 0},
         };
diff --git a/init/builtins.cpp b/init/builtins.cpp
index c4af5b503423..38aed9c64c52 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -471,6 +471,7 @@ static struct {
     { "private",    MS_PRIVATE },
     { "slave",      MS_SLAVE },
     { "shared",     MS_SHARED },
+    { "nosymfollow", MS_NOSYMFOLLOW },
     { "defaults",   0 },
     { 0,            0 },
 };

From 0701fed364e57ba7cb085c297ffe4641449c3d86 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 21 Nov 2024 18:46:28 +0000
Subject: [PATCH 1280/1487] Remove no longer necessary MS_LAZYTIME definitions.

Change-Id: Idf2d947509731715f895518b541d55d55187c43d
---
 fs_mgr/libfstab/fstab.cpp    | 4 ----
 fs_mgr/tests/fs_mgr_test.cpp | 4 ----
 2 files changed, 8 deletions(-)

diff --git a/fs_mgr/libfstab/fstab.cpp b/fs_mgr/libfstab/fstab.cpp
index ca3599059184..01e0e3d875be 100644
--- a/fs_mgr/libfstab/fstab.cpp
+++ b/fs_mgr/libfstab/fstab.cpp
@@ -39,10 +39,6 @@
 #include "fstab_priv.h"
 #include "logging_macros.h"
 
-#if !defined(MS_LAZYTIME)
-#define MS_LAZYTIME (1 << 25)
-#endif
-
 using android::base::EndsWith;
 using android::base::ParseByteCount;
 using android::base::ParseInt;
diff --git a/fs_mgr/tests/fs_mgr_test.cpp b/fs_mgr/tests/fs_mgr_test.cpp
index 6e050cf4b5d1..8004977c9381 100644
--- a/fs_mgr/tests/fs_mgr_test.cpp
+++ b/fs_mgr/tests/fs_mgr_test.cpp
@@ -37,10 +37,6 @@
 using namespace android::fs_mgr;
 using namespace testing;
 
-#if !defined(MS_LAZYTIME)
-#define MS_LAZYTIME (1 << 25)
-#endif
-
 namespace {
 
 const std::string cmdline =

From f00efa024227358d477999cb67d6b73a5967007e Mon Sep 17 00:00:00 2001
From: Wei Li <weiwli@google.com>
Date: Fri, 22 Nov 2024 06:55:05 +0000
Subject: [PATCH 1281/1487] Remove system/core/METADATA

This directory doesn't contain third-party code and it doesn't need a METADATA file.

Bug: 380376695
Test: CIs
Change-Id: Ie197786da09304476fb002b178c2a77d424f5a53
---
 METADATA | 3 ---
 1 file changed, 3 deletions(-)
 delete mode 100644 METADATA

diff --git a/METADATA b/METADATA
deleted file mode 100644
index d97975ca3b99..000000000000
--- a/METADATA
+++ /dev/null
@@ -1,3 +0,0 @@
-third_party {
-  license_type: NOTICE
-}

From ef3a2c05fe2050defce701d6c72024366ca216d5 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 20 Nov 2024 15:14:29 -0800
Subject: [PATCH 1282/1487] libprefetch: Start prefetch service based on build

1: Check the presence of the file 'prefetch_ready'. If it doesn't
 exist then the device is booting for the first time after wipe.
 Thus, we would just create the file and exit as we do not want
 to initiate the record after data wipe primiarly because boot
 after data wipe is long and the I/O pattern during first boot may not actually match
 with subsequent boot.

2: If the file 'prefetch_ready' is present:

   a: Compare the build-finger-print of the device with the one record format
   is associated with by reading the file 'build_finger_print'. If they match,
   start the prefetch_replay.

   b: If they don't match, then the device was updated through OTA. Hence, start
   a fresh record and delete the build-finger-print file. This should also cover
   the case of device rollback.

   c: If the build-finger-print file doesn't exist, then just restart the record
   from scratch.

Bug: 362507272
Test: Prefetch record/replay
Change-Id: I90b861ba9381ddba6ab7dedb9930a735e55b0e5d
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 init/libprefetch/prefetch/prefetch.rc         |  16 +++
 init/libprefetch/prefetch/src/arch/android.rs | 118 ++++++++++++++++++
 init/libprefetch/prefetch/src/args.rs         |   4 +
 .../prefetch/src/args/args_argh.rs            |  37 ++++++
 init/libprefetch/prefetch/src/lib.rs          |  38 +++---
 init/libprefetch/prefetch/src/main.rs         |   4 +
 6 files changed, 195 insertions(+), 22 deletions(-)
 create mode 100644 init/libprefetch/prefetch/src/arch/android.rs

diff --git a/init/libprefetch/prefetch/prefetch.rc b/init/libprefetch/prefetch/prefetch.rc
index 9f2cb7f46cdb..fb3fb3b6a3bb 100644
--- a/init/libprefetch/prefetch/prefetch.rc
+++ b/init/libprefetch/prefetch/prefetch.rc
@@ -1,3 +1,16 @@
+on init && property:ro.prefetch_boot.enabled=true
+    start prefetch
+
+service prefetch /system/bin/prefetch start
+    class main
+    user root
+    group root system
+    disabled
+    oneshot
+
+on property:ro.prefetch_boot.record=true
+    start prefetch_record
+
 service prefetch_record /system/bin/prefetch record --duration ${ro.prefetch_boot.duration_s:-0}
     class main
     user root
@@ -5,6 +18,9 @@ service prefetch_record /system/bin/prefetch record --duration ${ro.prefetch_boo
     disabled
     oneshot
 
+on property:ro.prefetch_boot.replay=true
+    start prefetch_replay
+
 service prefetch_replay /system/bin/prefetch replay --io-depth ${ro.prefetch_boot.io_depth:-2} --max-fds ${ro.prefetch_boot.max_fds:-128}
     class main
     user root
diff --git a/init/libprefetch/prefetch/src/arch/android.rs b/init/libprefetch/prefetch/src/arch/android.rs
new file mode 100644
index 000000000000..c765e38d723e
--- /dev/null
+++ b/init/libprefetch/prefetch/src/arch/android.rs
@@ -0,0 +1,118 @@
+use crate::Error;
+use crate::RecordArgs;
+use crate::StartArgs;
+use log::info;
+use log::warn;
+use std::fs::File;
+use std::fs::OpenOptions;
+use std::io::Write;
+use std::time::Duration;
+
+use rustutils::system_properties::error::PropertyWatcherError;
+use rustutils::system_properties::PropertyWatcher;
+
+const PREFETCH_RECORD_PROPERTY: &str = "ro.prefetch_boot.record";
+const PREFETCH_REPLAY_PROPERTY: &str = "ro.prefetch_boot.replay";
+const PREFETCH_RECORD_PROPERTY_STOP: &str = "ro.prefetch_boot.record_stop";
+
+fn wait_for_property_true(
+    property_name: &str,
+    timeout: Option<Duration>,
+) -> Result<(), PropertyWatcherError> {
+    let mut prop = PropertyWatcher::new(property_name)?;
+    prop.wait_for_value("1", timeout)?;
+    Ok(())
+}
+
+/// Wait for record to stop
+pub fn wait_for_record_stop() {
+    wait_for_property_true(PREFETCH_RECORD_PROPERTY_STOP, None).unwrap_or_else(|e| {
+        warn!("failed to wait for {} with error: {}", PREFETCH_RECORD_PROPERTY_STOP, e)
+    });
+}
+
+fn start_prefetch_service(property_name: &str) -> Result<(), Error> {
+    match rustutils::system_properties::write(property_name, "true") {
+        Ok(_) => {}
+        Err(_) => {
+            return Err(Error::Custom { error: "Failed to start prefetch service".to_string() });
+        }
+    }
+    Ok(())
+}
+
+/// Start prefetch service
+///
+/// 1: Check the presence of the file 'prefetch_ready'. If it doesn't
+/// exist then the device is booting for the first time after wipe.
+/// Thus, we would just create the file and exit as we do not want
+/// to initiate the record after data wipe primiarly because boot
+/// after data wipe is long and the I/O pattern during first boot may not actually match
+/// with subsequent boot.
+///
+/// 2: If the file 'prefetch_ready' is present:
+///
+///   a: Compare the build-finger-print of the device with the one record format
+///   is associated with by reading the file 'build_finger_print'. If they match,
+///   start the prefetch_replay.
+///
+///   b: If they don't match, then the device was updated through OTA. Hence, start
+///   a fresh record and delete the build-finger-print file. This should also cover
+///   the case of device rollback.
+///
+///   c: If the build-finger-print file doesn't exist, then just restart the record
+///   from scratch.
+pub fn start_prefetch(args: &StartArgs) -> Result<(), Error> {
+    if !args.path.exists() {
+        match File::create(args.path.clone()) {
+            Ok(_) => {}
+            Err(_) => {
+                return Err(Error::Custom { error: "File Creation failed".to_string() });
+            }
+        }
+        return Ok(());
+    }
+
+    if args.build_fingerprint_path.exists() {
+        let device_build_fingerprint = rustutils::system_properties::read("ro.build.fingerprint")
+            .map_err(|e| Error::Custom {
+            error: format!("Failed to read ro.build.fingerprint: {}", e),
+        })?;
+        let pack_build_fingerprint = std::fs::read_to_string(&args.build_fingerprint_path)?;
+        if pack_build_fingerprint.trim() == device_build_fingerprint.as_deref().unwrap_or_default()
+        {
+            info!("Start replay");
+            start_prefetch_service(PREFETCH_REPLAY_PROPERTY)?;
+        } else {
+            info!("Start record");
+            std::fs::remove_file(&args.build_fingerprint_path)?;
+            start_prefetch_service(PREFETCH_RECORD_PROPERTY)?;
+        }
+    } else {
+        info!("Start record");
+        start_prefetch_service(PREFETCH_RECORD_PROPERTY)?;
+    }
+    Ok(())
+}
+
+/// Write build finger print to associate prefetch pack file
+pub fn write_build_fingerprint(args: &RecordArgs) -> Result<(), Error> {
+    let mut build_fingerprint_file = OpenOptions::new()
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(&args.build_fingerprint_path)
+        .map_err(|source| Error::Create {
+            source,
+            path: args.build_fingerprint_path.to_str().unwrap().to_owned(),
+        })?;
+
+    let device_build_fingerprint =
+        rustutils::system_properties::read("ro.build.fingerprint").unwrap_or_default();
+    let device_build_fingerprint = device_build_fingerprint.unwrap_or_default();
+
+    build_fingerprint_file.write_all(device_build_fingerprint.as_bytes())?;
+    build_fingerprint_file.sync_all()?;
+
+    Ok(())
+}
diff --git a/init/libprefetch/prefetch/src/args.rs b/init/libprefetch/prefetch/src/args.rs
index 4c1e689193fd..e534210b5125 100644
--- a/init/libprefetch/prefetch/src/args.rs
+++ b/init/libprefetch/prefetch/src/args.rs
@@ -25,6 +25,8 @@ use std::process::exit;
 
 pub use args_internal::OutputFormat;
 pub use args_internal::ReplayArgs;
+#[cfg(target_os = "android")]
+pub use args_internal::StartArgs;
 pub use args_internal::TracerType;
 pub use args_internal::{DumpArgs, MainArgs, RecordArgs, SubCommands};
 use serde::Deserialize;
@@ -66,6 +68,8 @@ fn verify_and_fix(args: &mut MainArgs) -> Result<(), Error> {
         SubCommands::Dump(arg) => {
             ensure_path_exists(&arg.path)?;
         }
+        #[cfg(target_os = "android")]
+        SubCommands::Start(_arg) => return Ok(()),
     }
     Ok(())
 }
diff --git a/init/libprefetch/prefetch/src/args/args_argh.rs b/init/libprefetch/prefetch/src/args/args_argh.rs
index 8ac95fce7a0c..65084eeaada4 100644
--- a/init/libprefetch/prefetch/src/args/args_argh.rs
+++ b/init/libprefetch/prefetch/src/args/args_argh.rs
@@ -40,6 +40,38 @@ pub enum SubCommands {
     Replay(ReplayArgs),
     /// Dump prefetch data in human readable format
     Dump(DumpArgs),
+    /// Start prefetch service if possible
+    /// If the pack file is present, then prefetch replay is started
+    /// If the pack file is absent or if the build fingerprint
+    /// of the current pack file is different, then prefetch record is started.
+    #[cfg(target_os = "android")]
+    Start(StartArgs),
+}
+
+#[cfg(target_os = "android")]
+fn default_ready_path() -> PathBuf {
+    PathBuf::from("/metadata/prefetch/prefetch_ready")
+}
+
+#[cfg(target_os = "android")]
+fn default_build_finger_print_path() -> PathBuf {
+    PathBuf::from("/metadata/prefetch/build_finger_print")
+}
+
+#[cfg(target_os = "android")]
+#[derive(Eq, PartialEq, Debug, Default, FromArgs)]
+/// Start prefetch service based on if pack file is present.
+#[argh(subcommand, name = "start")]
+pub struct StartArgs {
+    /// file path to check if prefetch_ready is present.
+    ///
+    /// A new file is created at the given path if it's not present.
+    #[argh(option, default = "default_ready_path()")]
+    pub path: PathBuf,
+
+    /// file path where build fingerprint is stored
+    #[argh(option, default = "default_build_finger_print_path()")]
+    pub build_fingerprint_path: PathBuf,
 }
 
 impl Default for SubCommands {
@@ -110,6 +142,11 @@ pub struct RecordArgs {
         from_str_fn(parse_tracing_instance)
     )]
     pub tracing_instance: Option<String>,
+
+    #[cfg(target_os = "android")]
+    /// store build_finger_print to tie the pack format
+    #[argh(option, default = "default_build_finger_print_path()")]
+    pub build_fingerprint_path: PathBuf,
 }
 
 /// Type of tracing subsystem to use.
diff --git a/init/libprefetch/prefetch/src/lib.rs b/init/libprefetch/prefetch/src/lib.rs
index 4b56b13ee108..6564c4bc6d34 100644
--- a/init/libprefetch/prefetch/src/lib.rs
+++ b/init/libprefetch/prefetch/src/lib.rs
@@ -20,6 +20,10 @@ mod error;
 mod format;
 mod replay;
 mod tracer;
+#[cfg(target_os = "android")]
+mod arch {
+    pub mod android;
+}
 
 use std::fs::File;
 use std::fs::OpenOptions;
@@ -38,6 +42,8 @@ use log::LevelFilter;
 pub use args::args_from_env;
 use args::OutputFormat;
 pub use args::ReplayArgs;
+#[cfg(target_os = "android")]
+pub use args::StartArgs;
 pub use args::{DumpArgs, MainArgs, RecordArgs, SubCommands};
 pub use error::Error;
 pub use format::FileId;
@@ -45,29 +51,11 @@ pub use format::InodeInfo;
 pub use format::Record;
 pub use format::RecordsFile;
 use log::info;
-#[cfg(target_os = "android")]
-use log::warn;
 pub use replay::Replay;
 pub use tracer::nanoseconds_since_boot;
 
 #[cfg(target_os = "android")]
-use rustutils::system_properties;
-#[cfg(target_os = "android")]
-use rustutils::system_properties::error::PropertyWatcherError;
-#[cfg(target_os = "android")]
-use rustutils::system_properties::PropertyWatcher;
-
-#[cfg(target_os = "android")]
-fn wait_for_property_true(property_name: &str) -> Result<(), PropertyWatcherError> {
-    let mut prop = PropertyWatcher::new(property_name)?;
-    loop {
-        prop.wait(None)?;
-        if system_properties::read_bool(property_name, false)? {
-            break;
-        }
-    }
-    Ok(())
-}
+pub use arch::android::*;
 
 /// Records prefetch data for the given configuration
 pub fn record(args: &RecordArgs) -> Result<(), Error> {
@@ -85,11 +73,10 @@ pub fn record(args: &RecordArgs) -> Result<(), Error> {
             thread::sleep(duration);
         } else {
             #[cfg(target_os = "android")]
-            wait_for_property_true("sys.boot_completed").unwrap_or_else(|e| {
-                warn!("failed to wait for sys.boot_completed with error: {}", e)
-            });
+            wait_for_record_stop();
         }
 
+        info!("Prefetch record exiting");
         // We want to unwrap here on failure to send this signal. Otherwise
         // tracer will continue generating huge records data.
         exit_tx.send(()).unwrap();
@@ -107,9 +94,16 @@ pub fn record(args: &RecordArgs) -> Result<(), Error> {
     std::fs::set_permissions(&args.path, std::fs::Permissions::from_mode(0o644))
         .map_err(|source| Error::Create { source, path: args.path.to_str().unwrap().to_owned() })?;
 
+    // Write the record file
     out_file
         .write_all(&rf.add_checksum_and_serialize()?)
         .map_err(|source| Error::Write { path: args.path.to_str().unwrap().to_owned(), source })?;
+    out_file.sync_all()?;
+
+    // Write build-finger-print file
+    #[cfg(target_os = "android")]
+    write_build_fingerprint(args)?;
+
     Ok(())
 }
 
diff --git a/init/libprefetch/prefetch/src/main.rs b/init/libprefetch/prefetch/src/main.rs
index 046e07edab89..eab826f250df 100644
--- a/init/libprefetch/prefetch/src/main.rs
+++ b/init/libprefetch/prefetch/src/main.rs
@@ -22,6 +22,8 @@ use prefetch_rs::dump;
 use prefetch_rs::init_logging;
 use prefetch_rs::record;
 use prefetch_rs::replay;
+#[cfg(target_os = "android")]
+use prefetch_rs::start_prefetch;
 use prefetch_rs::LogLevel;
 use prefetch_rs::MainArgs;
 use prefetch_rs::SubCommands;
@@ -33,6 +35,8 @@ fn main() {
         SubCommands::Record(args) => record(args),
         SubCommands::Replay(args) => replay(args),
         SubCommands::Dump(args) => dump(args),
+        #[cfg(target_os = "android")]
+        SubCommands::Start(args) => start_prefetch(args),
     };
 
     if let Err(err) = ret {

From fef2dff80a7e44cf23decf0629c7d2dba27bac0b Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Mon, 25 Nov 2024 08:32:05 +0000
Subject: [PATCH 1283/1487] Remove /data/apex/hashtree directory

This directory is no longer used.

Bug: 184914612
Change-Id: Iaa094e2df39c363fe0a5ffd4b27b5c3075bb4f7f
Test: (device doesn't have the directory)
---
 rootdir/init.rc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 6771c5fdee59..f00479ece086 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -736,7 +736,6 @@ on post-fs-data
     mkdir /data/apex/active 0755 root system
     mkdir /data/apex/backup 0700 root system
     mkdir /data/apex/decompressed 0755 root system encryption=Require
-    mkdir /data/apex/hashtree 0700 root system
     mkdir /data/apex/sessions 0700 root system
     mkdir /data/app-staging 0751 system system encryption=DeleteIfNecessary
     mkdir /data/apex/ota_reserved 0700 root system encryption=Require

From 487584da236d931c4b67d5aaaaf686a6e23a1f4b Mon Sep 17 00:00:00 2001
From: David Drysdale <drysdale@google.com>
Date: Mon, 25 Nov 2024 12:38:54 +0000
Subject: [PATCH 1284/1487] Move Trusty C++ KeyMint to v4

- Declare v4 HAL.
- Declare version 400 in Package Manager (when unfrozen).
- Link to current (V4 when unfrozen) versions of support libraries.
- Add `setAdditionalAttestationInfo()` method to HAL service.
- Add `SetAdditionalAttestationInfo()` method to implementation, using
  the common message types.
- Add Trusty-specific message code for the
  `SET_ADDITIONAL_ATTESTATION_INFO` message exchange.

Test: VtsAidlKeyMintTargetTest (new test fails until TA updated too)
Bug: 369375199
Change-Id: I4699aea3ab8a0723a5c2bc1493f7bbb69cdfd6df
---
 trusty/keymaster/Android.bp                        | 11 ++++++-----
 trusty/keymaster/TrustyKeymaster.cpp               |  7 +++++++
 .../include/trusty_keymaster/TrustyKeyMintDevice.h |  1 +
 .../include/trusty_keymaster/TrustyKeymaster.h     |  2 ++
 .../include/trusty_keymaster/ipc/keymaster_ipc.h   |  1 +
 trusty/keymaster/keymint/TrustyKeyMintDevice.cpp   | 14 ++++++++++++++
 ...id.hardware.security.keymint-service.trusty.xml |  2 +-
 7 files changed, 32 insertions(+), 6 deletions(-)

diff --git a/trusty/keymaster/Android.bp b/trusty/keymaster/Android.bp
index 5a1e4202d585..8ebfc1aeba52 100644
--- a/trusty/keymaster/Android.bp
+++ b/trusty/keymaster/Android.bp
@@ -106,11 +106,11 @@ cc_binary {
         "keymint/service.cpp",
     ],
     shared_libs: [
-        "android.hardware.security.keymint-V3-ndk",
+        "android.hardware.security.keymint-V4-ndk",
         "android.hardware.security.rkp-V3-ndk",
         "android.hardware.security.secureclock-V1-ndk",
         "android.hardware.security.sharedsecret-V1-ndk",
-        "lib_android_keymaster_keymint_utils_V3",
+        "lib_android_keymaster_keymint_utils",
         "libbase",
         "libbinder_ndk",
         "libhardware",
@@ -120,9 +120,10 @@ cc_binary {
         "libtrusty",
         "libutils",
     ],
-    required: [
-        "android.hardware.hardware_keystore_V3.xml",
-    ],
+    required: select(release_flag("RELEASE_AIDL_USE_UNFROZEN"), {
+        true: ["android.hardware.hardware_keystore.xml"],
+        default: ["android.hardware.hardware_keystore_V3.xml"],
+    }),
 }
 
 prebuilt_etc {
diff --git a/trusty/keymaster/TrustyKeymaster.cpp b/trusty/keymaster/TrustyKeymaster.cpp
index b118a2001ca2..723229d03e23 100644
--- a/trusty/keymaster/TrustyKeymaster.cpp
+++ b/trusty/keymaster/TrustyKeymaster.cpp
@@ -295,6 +295,13 @@ GetRootOfTrustResponse TrustyKeymaster::GetRootOfTrust(const GetRootOfTrustReque
     return response;
 }
 
+SetAdditionalAttestationInfoResponse TrustyKeymaster::SetAdditionalAttestationInfo(
+        const SetAdditionalAttestationInfoRequest& request) {
+    SetAdditionalAttestationInfoResponse response(message_version());
+    ForwardCommand(KM_SET_ADDITIONAL_ATTESTATION_INFO, request, &response);
+    return response;
+}
+
 GetHwInfoResponse TrustyKeymaster::GetHwInfo() {
     GetHwInfoResponse response(message_version());
     ForwardCommand(KM_GET_HW_INFO, GetHwInfoRequest(message_version()), &response);
diff --git a/trusty/keymaster/include/trusty_keymaster/TrustyKeyMintDevice.h b/trusty/keymaster/include/trusty_keymaster/TrustyKeyMintDevice.h
index c8d8932c429b..5e876d3d35e3 100644
--- a/trusty/keymaster/include/trusty_keymaster/TrustyKeyMintDevice.h
+++ b/trusty/keymaster/include/trusty_keymaster/TrustyKeyMintDevice.h
@@ -85,6 +85,7 @@ class TrustyKeyMintDevice : public BnKeyMintDevice {
     ScopedAStatus getRootOfTrust(const array<uint8_t, 16>& challenge,
                                  vector<uint8_t>* rootOfTrust) override;
     ScopedAStatus sendRootOfTrust(const vector<uint8_t>& rootOfTrust) override;
+    ScopedAStatus setAdditionalAttestationInfo(const vector<KeyParameter>& info) override;
 
   protected:
     std::shared_ptr<TrustyKeymaster> impl_;
diff --git a/trusty/keymaster/include/trusty_keymaster/TrustyKeymaster.h b/trusty/keymaster/include/trusty_keymaster/TrustyKeymaster.h
index c50178bcfa2e..65d7217e0175 100644
--- a/trusty/keymaster/include/trusty_keymaster/TrustyKeymaster.h
+++ b/trusty/keymaster/include/trusty_keymaster/TrustyKeymaster.h
@@ -70,6 +70,8 @@ class TrustyKeymaster {
     ConfigureVendorPatchlevelResponse ConfigureVendorPatchlevel(
             const ConfigureVendorPatchlevelRequest& request);
     GetRootOfTrustResponse GetRootOfTrust(const GetRootOfTrustRequest& request);
+    SetAdditionalAttestationInfoResponse SetAdditionalAttestationInfo(
+            const SetAdditionalAttestationInfoRequest& request);
     GetHwInfoResponse GetHwInfo();
 
     uint32_t message_version() const { return message_version_; }
diff --git a/trusty/keymaster/include/trusty_keymaster/ipc/keymaster_ipc.h b/trusty/keymaster/include/trusty_keymaster/ipc/keymaster_ipc.h
index 822e93334fb2..721315d6f7ef 100644
--- a/trusty/keymaster/include/trusty_keymaster/ipc/keymaster_ipc.h
+++ b/trusty/keymaster/include/trusty_keymaster/ipc/keymaster_ipc.h
@@ -62,6 +62,7 @@ enum keymaster_command : uint32_t {
     KM_GET_ROOT_OF_TRUST            = (34 << KEYMASTER_REQ_SHIFT),
     KM_GET_HW_INFO                  = (35 << KEYMASTER_REQ_SHIFT),
     KM_GENERATE_CSR_V2              = (36 << KEYMASTER_REQ_SHIFT),
+    KM_SET_ADDITIONAL_ATTESTATION_INFO = (37 << KEYMASTER_REQ_SHIFT),
 
     // Bootloader/provisioning calls.
     KM_SET_BOOT_PARAMS = (0x1000 << KEYMASTER_REQ_SHIFT),
diff --git a/trusty/keymaster/keymint/TrustyKeyMintDevice.cpp b/trusty/keymaster/keymint/TrustyKeyMintDevice.cpp
index fec4c60fe19d..154597f99272 100644
--- a/trusty/keymaster/keymint/TrustyKeyMintDevice.cpp
+++ b/trusty/keymaster/keymint/TrustyKeyMintDevice.cpp
@@ -349,4 +349,18 @@ ScopedAStatus TrustyKeyMintDevice::sendRootOfTrust(const vector<uint8_t>& /* roo
     return kmError2ScopedAStatus(KM_ERROR_UNIMPLEMENTED);
 }
 
+ScopedAStatus TrustyKeyMintDevice::setAdditionalAttestationInfo(const vector<KeyParameter>& info) {
+    keymaster::SetAdditionalAttestationInfoRequest request(impl_->message_version());
+    request.info.Reinitialize(KmParamSet(info));
+
+    keymaster::SetAdditionalAttestationInfoResponse response =
+            impl_->SetAdditionalAttestationInfo(request);
+
+    if (response.error != KM_ERROR_OK) {
+        return kmError2ScopedAStatus(response.error);
+    } else {
+        return ScopedAStatus::ok();
+    }
+}
+
 }  // namespace aidl::android::hardware::security::keymint::trusty
diff --git a/trusty/keymaster/keymint/android.hardware.security.keymint-service.trusty.xml b/trusty/keymaster/keymint/android.hardware.security.keymint-service.trusty.xml
index 3dc9c88ea8cf..f74d212855ab 100644
--- a/trusty/keymaster/keymint/android.hardware.security.keymint-service.trusty.xml
+++ b/trusty/keymaster/keymint/android.hardware.security.keymint-service.trusty.xml
@@ -1,7 +1,7 @@
 <manifest version="1.0" type="device">
     <hal format="aidl">
         <name>android.hardware.security.keymint</name>
-        <version>3</version>
+        <version>4</version>
         <fqname>IKeyMintDevice/default</fqname>
     </hal>
     <hal format="aidl">

From cadad290a79d5b0a30add935aaadab7c1b1ef5e9 Mon Sep 17 00:00:00 2001
From: Eric Biggers <ebiggers@google.com>
Date: Tue, 26 Nov 2024 02:56:24 +0000
Subject: [PATCH 1285/1487] Fix the dm-verity Merkle tree caches to not expire
 so quickly

Bug: 335233956
Test: cat /sys/module/dm_bufio/parameters/max_age_seconds
Change-Id: I20e4df7dd3eb2ac1f462510e900568e946195faf
---
 rootdir/init.rc | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index f00479ece086..58f0495e6825 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -54,6 +54,10 @@ on early-init
     mkdir /linkerconfig/bootstrap 0755
     mkdir /linkerconfig/default 0755
 
+    # Greatly extend dm-verity's Merkle tree cache timeout.  The default timeout
+    # is much too short and is unnecessary, given that there is also a shrinker.
+    write /sys/module/dm_bufio/parameters/max_age_seconds 86400
+
     # Disable dm-verity hash prefetching, since it doesn't help performance
     # Read more in b/136247322
     write /sys/module/dm_verity/parameters/prefetch_cluster 0

From 9731ea7b673edc3a0c914a1bdb3ef81152b61158 Mon Sep 17 00:00:00 2001
From: Eric Lin <ericth@google.com>
Date: Tue, 26 Nov 2024 04:24:56 +0000
Subject: [PATCH 1286/1487] Update comments to point to the new location of
 event.logtags.

event.logtags was moved from system/core/logcat to system/logging/logcat in Android 12 by aosp/1454058.

Change-Id: Ia3cedee549145eddb0484ec589a9599a156bea14
BUG: 168791309
Flag: DOCS_ONLY
Test: Local build
---
 libsysutils/EventLogTags.logtags | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libsysutils/EventLogTags.logtags b/libsysutils/EventLogTags.logtags
index 713f8cd6b753..bb06d3433fff 100644
--- a/libsysutils/EventLogTags.logtags
+++ b/libsysutils/EventLogTags.logtags
@@ -1,4 +1,4 @@
-# See system/core/logcat/event.logtags for a description of the format of this file.
+# See system/logging/logcat/event.logtags for a description of the format of this file.
 
 # FrameworkListener dispatchCommand overflow
 78001 exp_det_dispatchCommand_overflow

From 3df083a4985b5ff88c597db9a586afed6fa3ac96 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 25 Nov 2024 21:46:56 -0800
Subject: [PATCH 1287/1487] libprefetch: rename property name

Bug: 362507272
Test: Build
Change-Id: I39627fdcbbe5458e6fbc9dfaa1aa620844d56f8b
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 init/libprefetch/prefetch/src/arch/android.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/init/libprefetch/prefetch/src/arch/android.rs b/init/libprefetch/prefetch/src/arch/android.rs
index c765e38d723e..3404e42b1403 100644
--- a/init/libprefetch/prefetch/src/arch/android.rs
+++ b/init/libprefetch/prefetch/src/arch/android.rs
@@ -11,8 +11,8 @@ use std::time::Duration;
 use rustutils::system_properties::error::PropertyWatcherError;
 use rustutils::system_properties::PropertyWatcher;
 
-const PREFETCH_RECORD_PROPERTY: &str = "ro.prefetch_boot.record";
-const PREFETCH_REPLAY_PROPERTY: &str = "ro.prefetch_boot.replay";
+const PREFETCH_RECORD_PROPERTY: &str = "prefetch_boot.record";
+const PREFETCH_REPLAY_PROPERTY: &str = "prefetch_boot.replay";
 const PREFETCH_RECORD_PROPERTY_STOP: &str = "ro.prefetch_boot.record_stop";
 
 fn wait_for_property_true(

From 52d2446b4e8c208066b4208780b4b0117102c53d Mon Sep 17 00:00:00 2001
From: Dennis Shen <dzshen@google.com>
Date: Tue, 26 Nov 2024 15:26:52 +0000
Subject: [PATCH 1288/1487] Deprecate cc_binary aconfigd and the controlling
 flag

cc_binary aconfigd is replaced with rust_binary aconfigd-system. The
replacement is flag guarded and is already in TF full for more than a
week. Thus delete the flag and deprecate old cc_binary aconfigd.

Test: m
Change-Id: Ib128adc2ef8178e02222f77e6b89bcc7ac83c1da
---
 rootdir/init.rc | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 6771c5fdee59..6f32ccca4f65 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1009,16 +1009,8 @@ on post-fs-data
     wait_for_prop apexd.status activated
     perform_apex_config
 
-    # See flag enable_system_aconfigd_rust, which toggles these processes.
-    exec_start aconfigd-mainline-init
     exec_start system_aconfigd_mainline_init
-
-    # system_aconfigd_socket_service is replacing aconfigd:
-    #   - A flag (enable_system_aconfigd_rust) toggles which socket executes.
-    #   - When enabled, aconfigd is a no-op, system_aconfigd_socket_service executes.
-    #   - Conversely, when disabled, aconfigd executes, and system_aconfigd_socket_service is a no-op.
     start system_aconfigd_socket_service
-    start aconfigd
 
     # Create directories for boot animation.
     mkdir /data/misc/bootanim 0755 system system

From 27dd6f8e62fc587fe7e4c298501ea43888a59914 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Tue, 26 Nov 2024 23:44:17 +0000
Subject: [PATCH 1289/1487] libutils OWNERS for shayba@

For Looper work, but not scoped down to this
unless you want it to be.

Bug: N/A
Test: N/A
Change-Id: I14bf8d21af357ef7b9151cca49b0cf40dde0e3ca
---
 libutils/OWNERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libutils/OWNERS b/libutils/OWNERS
index 40164aae0c50..4ce689304506 100644
--- a/libutils/OWNERS
+++ b/libutils/OWNERS
@@ -1 +1,2 @@
+shayba@google.com
 smoreland@google.com

From 8366faad18cc853a5bcd44992d6ec1facb1d8833 Mon Sep 17 00:00:00 2001
From: Akhilesh Sanikop <akhilesh.sanikop@ittiam.com>
Date: Fri, 29 Nov 2024 15:02:21 +0530
Subject: [PATCH 1290/1487] gatekeeperd_service_fuzzer: Add signal() to handle
 SIGPIPE

Adding signal handler to avoid abort() due to
broken pipe.

Test: ./gatekeeperd_service_fuzzer
Bug: 376201407
Change-Id: Ifca08860d11f56eb8e0d490c6b6956f8774cfa70
---
 gatekeeperd/fuzzer/GateKeeperServiceFuzzer.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/gatekeeperd/fuzzer/GateKeeperServiceFuzzer.cpp b/gatekeeperd/fuzzer/GateKeeperServiceFuzzer.cpp
index bc0d5fe053aa..a3cc3f32c717 100644
--- a/gatekeeperd/fuzzer/GateKeeperServiceFuzzer.cpp
+++ b/gatekeeperd/fuzzer/GateKeeperServiceFuzzer.cpp
@@ -22,6 +22,8 @@ using android::fuzzService;
 using android::GateKeeperProxy;
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+    // TODO(b/183141167): need to rewrite 'dump' to avoid SIGPIPE.
+    signal(SIGPIPE, SIG_IGN);
     auto gatekeeperService = new GateKeeperProxy();
     fuzzService(gatekeeperService, FuzzedDataProvider(data, size));
     return 0;

From f26b13aeb1a9baec66dc592adee82cac626fcf46 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 26 Nov 2024 00:43:59 +0000
Subject: [PATCH 1291/1487] libprocessgroup: Remove recovery_available from
 libcgrouprc

...which no longer appears to be required.

Bug: 349105928
Change-Id: I0ad1f44912fdaf98c05b60402c0166c535155775
---
 libprocessgroup/cgrouprc/Android.bp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/libprocessgroup/cgrouprc/Android.bp b/libprocessgroup/cgrouprc/Android.bp
index 38b2fa31d4f3..c157d9b18a75 100644
--- a/libprocessgroup/cgrouprc/Android.bp
+++ b/libprocessgroup/cgrouprc/Android.bp
@@ -21,7 +21,6 @@ cc_library {
     host_supported: true,
     ramdisk_available: true,
     vendor_ramdisk_available: true,
-    recovery_available: true,
     // Do not ever mark this as vendor_available; otherwise, vendor modules
     // that links to the static library will behave unexpectedly. All on-device
     // modules should use libprocessgroup which links to the LL-NDK library

From 62f8723f6764a3d45a48b772691c1e677e90e259 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 26 Nov 2024 00:44:41 +0000
Subject: [PATCH 1292/1487] libprocessgroup: Remove vendor_ramdisk_available
 from libcgrouprc

...which no longer appears to be required.

Bug: 349105928
Change-Id: I9fc71f9cf3238dcc935da63ce1a3b0b69d9cccc1
---
 libprocessgroup/cgrouprc/Android.bp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/libprocessgroup/cgrouprc/Android.bp b/libprocessgroup/cgrouprc/Android.bp
index c157d9b18a75..4007a2344c7f 100644
--- a/libprocessgroup/cgrouprc/Android.bp
+++ b/libprocessgroup/cgrouprc/Android.bp
@@ -20,7 +20,6 @@ cc_library {
     name: "libcgrouprc",
     host_supported: true,
     ramdisk_available: true,
-    vendor_ramdisk_available: true,
     // Do not ever mark this as vendor_available; otherwise, vendor modules
     // that links to the static library will behave unexpectedly. All on-device
     // modules should use libprocessgroup which links to the LL-NDK library

From 8972ce18d2d8cf1177654c60194083dde00ae617 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 26 Nov 2024 00:44:58 +0000
Subject: [PATCH 1293/1487] libprocessgroup: Remove ramdisk_available from
 libcgrouprc

...which no longer appears to be required.

Bug: 349105928
Change-Id: I0586f76147d9519ef6a520a10164e1b0f5e5c9b8
---
 libprocessgroup/cgrouprc/Android.bp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/libprocessgroup/cgrouprc/Android.bp b/libprocessgroup/cgrouprc/Android.bp
index 4007a2344c7f..9e46b8e7c1d6 100644
--- a/libprocessgroup/cgrouprc/Android.bp
+++ b/libprocessgroup/cgrouprc/Android.bp
@@ -19,7 +19,6 @@ package {
 cc_library {
     name: "libcgrouprc",
     host_supported: true,
-    ramdisk_available: true,
     // Do not ever mark this as vendor_available; otherwise, vendor modules
     // that links to the static library will behave unexpectedly. All on-device
     // modules should use libprocessgroup which links to the LL-NDK library

From 00a32314acb08eef5c76439d4535789fe23ed0b0 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 2 Dec 2024 10:58:46 -0800
Subject: [PATCH 1294/1487] libsnapshot: Cleanup temp metadata during rollback

Bug: 380471512
Test: Test rollback and check metadata is cleared
Change-Id: I4ebd5d9842409fa32c58bb482ffc0066817a5a05
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshot.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index acabd677075e..ecf567eb8462 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -2404,6 +2404,9 @@ bool SnapshotManager::NeedSnapshotsInFirstStageMount() {
                 PLOG(ERROR) << "Unable to write rollback indicator: " << path;
             } else {
                 LOG(INFO) << "Rollback detected, writing rollback indicator to " << path;
+                if (device_->IsTempMetadata()) {
+                    CleanupScratchOtaMetadataIfPresent();
+                }
             }
         }
         LOG(INFO) << "Not booting from new slot. Will not mount snapshots.";

From ee7a713757314366023e855a76ff17943b6b9296 Mon Sep 17 00:00:00 2001
From: "Isaac J. Manjarres" <isaacmanjarres@google.com>
Date: Tue, 3 Dec 2024 09:42:56 -0800
Subject: [PATCH 1295/1487] ashmem: Ensure all memfds have non-executable
 permissions by default

Currently, memfds are created with executable permissions, meaning that
one can load a binary into a memfd buffer and use fexecve() to run said
binary. This is not desirable for security reasons, and also does not
match with the behavior that the ashmem driver currently supports.

When the ashmem driver is in use, /dev/ashmem* does not have executable
permissions, so fexecve() cannot be used on those buffers. Linux kernels
6.3+ offer MFD_NOEXEC_SEAL as part of the memfd interface, which allows
one to create memfds with non-executable permissions. Furthermore, the
executable permissions cannot be changed on these memfds.

This matches the expected behavior that ashmem provided, so allow memfd
usage only if MFD_NOEXEC_SEAL is supported, and create memfds with
non-executable permissions by default.

Bug: 111903542
Change-Id: Ibb2c2be3c118ead44fc12bcd2b63dcf6f83c9b03
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
---
 libcutils/ashmem-dev.cpp | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index 46b8ef2635e4..cebfa5d12b60 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -114,8 +114,14 @@ static bool __has_memfd_support() {
     // Check if kernel support exists, otherwise fall back to ashmem.
     // This code needs to build on old API levels, so we can't use the libc
     // wrapper.
+    //
+    // MFD_NOEXEC_SEAL is used to match the semantics of the ashmem device,
+    // which did not have executable permissions. This also seals the executable
+    // permissions of the buffer (i.e. they cannot be changed by fchmod()).
+    //
+    // MFD_NOEXEC_SEAL implies MFD_ALLOW_SEALING.
     android::base::unique_fd fd(
-            syscall(__NR_memfd_create, "test_android_memfd", MFD_CLOEXEC | MFD_ALLOW_SEALING));
+            syscall(__NR_memfd_create, "test_android_memfd", MFD_CLOEXEC | MFD_NOEXEC_SEAL));
     if (fd == -1) {
         ALOGE("memfd_create failed: %s, no memfd support.\n", strerror(errno));
         return false;
@@ -289,7 +295,13 @@ int ashmem_valid(int fd)
 static int memfd_create_region(const char* name, size_t size) {
     // This code needs to build on old API levels, so we can't use the libc
     // wrapper.
-    android::base::unique_fd fd(syscall(__NR_memfd_create, name, MFD_CLOEXEC | MFD_ALLOW_SEALING));
+    //
+    // MFD_NOEXEC_SEAL to match the semantics of the ashmem device, which did
+    // not have executable permissions. This also seals the executable
+    // permissions of the buffer (i.e. they cannot be changed by fchmod()).
+    //
+    // MFD_NOEXEC_SEAL implies MFD_ALLOW_SEALING.
+    android::base::unique_fd fd(syscall(__NR_memfd_create, name, MFD_CLOEXEC | MFD_NOEXEC_SEAL));
 
     if (fd == -1) {
         ALOGE("memfd_create(%s, %zd) failed: %s\n", name, size, strerror(errno));

From 7a1cf9a52d526ed265ce0a3c2ea380fb65e58bcc Mon Sep 17 00:00:00 2001
From: Matt Gilbride <mattgilbride@google.com>
Date: Tue, 3 Dec 2024 22:44:52 +0000
Subject: [PATCH 1296/1487] Update trusty to use secretkeeper hal V1

The HAL has been updated to V2, but the trusty prebuilt implementation
does not yet have that code. Update trusty secretkeeper build to use V1
specifically instead of latest until the prebuilt has those changes.

Bug: 372223451
Test: TH
Change-Id: Ic2e9b578b50685d71b5597d8d34ac7ee36b6ddc9
---
 trusty/secretkeeper/Android.bp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/trusty/secretkeeper/Android.bp b/trusty/secretkeeper/Android.bp
index 6523edaf6942..d399bf86d005 100644
--- a/trusty/secretkeeper/Android.bp
+++ b/trusty/secretkeeper/Android.bp
@@ -27,18 +27,16 @@ rust_binary {
         "src/hal_main.rs",
     ],
     rustlibs: [
+        "android.hardware.security.secretkeeper-V1-rust",
         "libandroid_logger",
         "libauthgraph_hal",
         "libauthgraph_wire",
         "libbinder_rs",
         "liblibc",
         "liblog_rust",
-        "libsecretkeeper_hal",
+        "libsecretkeeper_hal_v1",
         "libtrusty-rs",
     ],
-    defaults: [
-        "secretkeeper_use_latest_hal_aidl_rust",
-    ],
     prefer_rlib: true,
 }
 

From 683e3c07614f452baf3e18f67a1140988709b0f2 Mon Sep 17 00:00:00 2001
From: Dennis Shen <dzshen@google.com>
Date: Thu, 26 Sep 2024 13:36:18 +0000
Subject: [PATCH 1297/1487] Start aconfigd socket defined in configinfra
 mainline module

Context: to have better future updatability. The responsiblity of
managing mainline module storage files and a socket service for flag
overrides will be moved to the configinfra mainline module. Later,
aconfigd on /system will only be repsopnsbile for managing platform
partition storage files.

Bug: b/369810972
Test: m, launch avd and then inspect the logcat log to confirm the
service is launched.

Change-Id: I490e5aa432fa4afa236689ad0999e5602f7d297e
---
 rootdir/init.rc | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index e487797aa520..ae6a6588b62e 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -1004,6 +1004,11 @@ on post-fs-data
     exec_start system_aconfigd_mainline_init
     start system_aconfigd_socket_service
 
+    # start mainline aconfigd init, after transition, the above system_aconfigd_mainline_init
+    # will be deprecated
+    exec_start mainline_aconfigd_init
+    start mainline_aconfigd_socket_service
+
     # Create directories for boot animation.
     mkdir /data/misc/bootanim 0755 system system
 

From 96a0dfc395a1ae8f721433f5bd3deae8c0adef4e Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 26 Nov 2024 00:37:21 +0000
Subject: [PATCH 1298/1487] libprocessgroup: Remove host_supported from
 libcgrouprc

...which no longer appears to be required.

Bug: 349105928
Change-Id: I55b664e0ca2599c894dd15a55f55f5401e91e2fd
---
 libprocessgroup/cgrouprc/Android.bp                 | 1 -
 libprocessgroup/cgrouprc/include/android/cgrouprc.h | 5 -----
 2 files changed, 6 deletions(-)

diff --git a/libprocessgroup/cgrouprc/Android.bp b/libprocessgroup/cgrouprc/Android.bp
index 9e46b8e7c1d6..d5214c14ed86 100644
--- a/libprocessgroup/cgrouprc/Android.bp
+++ b/libprocessgroup/cgrouprc/Android.bp
@@ -18,7 +18,6 @@ package {
 
 cc_library {
     name: "libcgrouprc",
-    host_supported: true,
     // Do not ever mark this as vendor_available; otherwise, vendor modules
     // that links to the static library will behave unexpectedly. All on-device
     // modules should use libprocessgroup which links to the LL-NDK library
diff --git a/libprocessgroup/cgrouprc/include/android/cgrouprc.h b/libprocessgroup/cgrouprc/include/android/cgrouprc.h
index e704a36aac9d..6fc2659c15b0 100644
--- a/libprocessgroup/cgrouprc/include/android/cgrouprc.h
+++ b/libprocessgroup/cgrouprc/include/android/cgrouprc.h
@@ -21,11 +21,6 @@
 
 __BEGIN_DECLS
 
-// For host builds, __INTRODUCED_IN is not defined.
-#ifndef __INTRODUCED_IN
-#define __INTRODUCED_IN(x)
-#endif
-
 struct ACgroupController;
 typedef struct ACgroupController ACgroupController;
 

From 27821d81c5f9e910cb4c5502d6d2c385b0bf7579 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 5 Dec 2024 18:24:56 +0000
Subject: [PATCH 1299/1487] libprocessgroup: Remove getAttributePathForTask

getAttributePathForTask has always directly called
CgroupGetAttributePathForTask, and there is no reason for callers not to
use CgroupGetAttributePathForTask.

Change-Id: Id1533fc0d9ecec96dacb5ebf0f32b799660fbf88
---
 libprocessgroup/include/processgroup/processgroup.h | 6 ++----
 libprocessgroup/processgroup.cpp                    | 4 ----
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 6a026a717b4c..28b17c1981ea 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -29,6 +29,8 @@ bool CgroupsAvailable();
 bool CgroupGetControllerPath(const std::string& cgroup_name, std::string* path);
 bool CgroupGetControllerFromPath(const std::string& path, std::string* cgroup_name);
 bool CgroupGetAttributePath(const std::string& attr_name, std::string* path);
+// Provides the path for an attribute in a specific process group
+// Returns false in case of error, true in case of success
 bool CgroupGetAttributePathForTask(const std::string& attr_name, pid_t tid, std::string* path);
 
 bool SetTaskProfiles(pid_t tid, const std::vector<std::string>& profiles,
@@ -81,10 +83,6 @@ bool setProcessGroupLimit(uid_t uid, pid_t initialPid, int64_t limitInBytes);
 
 void removeAllEmptyProcessGroups(void);
 
-// Provides the path for an attribute in a specific process group
-// Returns false in case of error, true in case of success
-bool getAttributePathForTask(const std::string& attr_name, pid_t tid, std::string* path);
-
 // Check if a profile can be applied without failing.
 // Returns true if it can be applied without failing, false otherwise
 bool isProfileValidForProcess(const std::string& profile_name, uid_t uid, pid_t pid);
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 95221594b6be..53168e3e7069 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -746,10 +746,6 @@ bool setProcessGroupLimit(uid_t, pid_t pid, int64_t limit_in_bytes) {
     return SetProcessGroupValue(pid, "MemLimit", limit_in_bytes);
 }
 
-bool getAttributePathForTask(const std::string& attr_name, pid_t tid, std::string* path) {
-    return CgroupGetAttributePathForTask(attr_name, tid, path);
-}
-
 bool isProfileValidForProcess(const std::string& profile_name, uid_t uid, pid_t pid) {
     const TaskProfile* tp = TaskProfiles::GetInstance().GetProfile(profile_name);
 

From 44eca61ab95b304d4cf6a2cc89b2fb4ce1d5aa29 Mon Sep 17 00:00:00 2001
From: Jihoon Kang <jihoonkang@google.com>
Date: Wed, 4 Dec 2024 23:23:22 +0000
Subject: [PATCH 1300/1487] Replace partition-specific toybox make module with
 soong modules

toybox no longer sets recovery_available
property, thus this make module is no longer generated. Thus,
replace the entry with the soong modules to prevent missing
dependencies make error.

This change also specifies `recovery` property in
shell_and_utilities_recovery to allow soong generated recovery partition
to correctly install the dependencies of the phony module.

Test: m nothing
Bug: 381888358
Change-Id: I314e8031d23a9f579101ca1d5499969af4e3a9d3
---
 shell_and_utilities/Android.bp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/shell_and_utilities/Android.bp b/shell_and_utilities/Android.bp
index 1f5c1795c4dd..0a1f7c5a29af 100644
--- a/shell_and_utilities/Android.bp
+++ b/shell_and_utilities/Android.bp
@@ -43,9 +43,10 @@ phony {
     required: [
         "sh.recovery",
         "toolbox.recovery",
-        "toybox.recovery",
+        "toybox_recovery",
         "ziptool.recovery",
     ],
+    recovery: true,
 }
 
 phony {

From a7911182fcc59dae38a8e7439776aeee06b742ef Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Mon, 2 Dec 2024 21:04:08 +0000
Subject: [PATCH 1301/1487] Add support for getting TLS on all arches.

The guest support was refactored and in that change, all arm32 support
was removed. Add the ability for a thread to run as an arm32 guest.

In addition, add code to handle getting the TLS data on all different
arches.

Test: Unit tests pass.
Test: Ran on a device that supports an arm32 guest and verified that
Test: the tombstone has the guest set properly.
Change-Id: I6ab61f91e59bdc0981d590aeb6c509632b1cc03a
---
 debuggerd/crash_dump.cpp | 68 ++++++++++++++++++++++++++++++----------
 1 file changed, 51 insertions(+), 17 deletions(-)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 15e8319a9780..00b861a96942 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -22,9 +22,14 @@
 #include <sys/ptrace.h>
 #include <sys/types.h>
 #include <sys/un.h>
+#include <sys/user.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
+#if defined(__i386__)
+#include <asm/ldt.h>
+#endif
+
 #include <cstdint>
 #include <limits>
 #include <map>
@@ -430,18 +435,12 @@ static bool PtracePeek(int request, pid_t tid, uintptr_t addr, void* data, std::
   return true;
 }
 
-static bool GetGuestRegistersFromCrashedProcess([[maybe_unused]] pid_t tid,
-                                                NativeBridgeGuestRegs* guest_regs) {
+static bool GetGuestRegistersFromCrashedProcess(pid_t tid, NativeBridgeGuestRegs* guest_regs) {
   auto process_memory = unwindstack::Memory::CreateProcessMemoryCached(tid);
 
   uintptr_t header_ptr = 0;
   uintptr_t base = 0;
-#if defined(__x86_64__)
-  if (!PtracePeek(PTRACE_PEEKUSER, tid, offsetof(user_regs_struct, fs_base), nullptr,
-                  "failed to read thread register for thread " + std::to_string(tid), &base)) {
-    return false;
-  }
-#elif defined(__aarch64__)
+#if defined(__aarch64__)
   // base is implicitly casted to uint64_t.
   struct iovec pt_iov {
     .iov_base = &base, .iov_len = sizeof(base),
@@ -451,6 +450,26 @@ static bool GetGuestRegistersFromCrashedProcess([[maybe_unused]] pid_t tid,
     PLOG(ERROR) << "failed to read thread register for thread " << tid;
     return false;
   }
+#elif defined(__arm__)
+  if (ptrace(PTRACE_GET_THREAD_AREA, tid, nullptr, &base) == 0) {
+    PLOG(ERROR) << "failed to get thread area for thread " << tid;
+    return false;
+  }
+#elif defined(__i386__)
+  struct user_regs_struct regs;
+  struct iovec pt_iov = {.iov_base = &regs, .iov_len = sizeof(regs)};
+  if (ptrace(PTRACE_GETREGSET, tid, NT_PRSTATUS, &pt_iov) != 0) {
+    PLOG(ERROR) << "failed to get registers for thread " << tid;
+    return false;
+  }
+
+  struct user_desc desc;
+  desc.entry_number = regs.xgs >> 3;
+  if (ptrace(PTRACE_GET_THREAD_AREA, tid, desc.entry_number, &desc) != 0) {
+    PLOG(ERROR) << "failed to get thread area for thread " << tid;
+    return false;
+  }
+  base = desc.base_addr;
 #elif defined(__riscv)
   struct user_regs_struct regs;
   struct iovec pt_iov = {.iov_base = &regs, .iov_len = sizeof(regs)};
@@ -459,6 +478,11 @@ static bool GetGuestRegistersFromCrashedProcess([[maybe_unused]] pid_t tid,
     return false;
   }
   base = reinterpret_cast<uintptr_t>(regs.tp);
+#elif defined(__x86_64__)
+  if (!PtracePeek(PTRACE_PEEKUSER, tid, offsetof(user_regs_struct, fs_base), nullptr,
+                  "failed to read thread register for thread " + std::to_string(tid), &base)) {
+    return false;
+  }
 #else
   // TODO(b/339287219): Add case for Riscv host.
   return false;
@@ -487,9 +511,7 @@ static bool GetGuestRegistersFromCrashedProcess([[maybe_unused]] pid_t tid,
   return true;
 }
 
-static void ReadGuestRegisters([[maybe_unused]] std::unique_ptr<unwindstack::Regs>* regs,
-                               pid_t tid) {
-  // TODO: remove [[maybe_unused]], when the ARM32 case is removed from the native bridge support.
+static void ReadGuestRegisters(std::unique_ptr<unwindstack::Regs>* regs, pid_t tid) {
   NativeBridgeGuestRegs guest_regs;
   if (!GetGuestRegistersFromCrashedProcess(tid, &guest_regs)) {
     return;
@@ -521,6 +543,17 @@ static void ReadGuestRegisters([[maybe_unused]] std::unique_ptr<unwindstack::Reg
       g_guest_arch = Architecture::RISCV64;
       break;
     }
+#else
+    case NATIVE_BRIDGE_ARCH_ARM: {
+      unwindstack::arm_user_regs arm_user_regs = {};
+      regs->reset(unwindstack::RegsArm::Read(&arm_user_regs));
+      for (size_t i = 0; i < unwindstack::ARM_REG_LAST; i++) {
+        arm_user_regs.regs[i] = guest_regs.regs_arm.r[i];
+      }
+
+      g_guest_arch = Architecture::ARM32;
+      break;
+    }
 #endif
     default:
       break;
@@ -796,16 +829,17 @@ int main(int argc, char** argv) {
       ATRACE_NAME("engrave_tombstone");
       unwindstack::ArchEnum regs_arch = unwindstack::ARCH_UNKNOWN;
       switch (g_guest_arch) {
-        case Architecture::ARM64: {
+        case Architecture::ARM32:
+          regs_arch = unwindstack::ARCH_ARM;
+          break;
+        case Architecture::ARM64:
           regs_arch = unwindstack::ARCH_ARM64;
           break;
-        }
-        case Architecture::RISCV64: {
+        case Architecture::RISCV64:
           regs_arch = unwindstack::ARCH_RISCV64;
           break;
-        }
-        default: {
-        }
+        default:
+          break;
       }
       if (regs_arch == unwindstack::ARCH_UNKNOWN) {
         engrave_tombstone(std::move(g_output_fd), std::move(g_proto_fd), &unwinder, thread_info,

From 09e7cea7c1b611dd1fffc2d2d3fec94bee4e5218 Mon Sep 17 00:00:00 2001
From: Jihoon Kang <jihoonkang@google.com>
Date: Fri, 6 Dec 2024 01:51:35 +0000
Subject: [PATCH 1302/1487] Define toolbox.recovery

By removing `recovery_available` property from "toolbox" and defining a
dedicated recovery-specific module for "toolbox". `recovery_available`
property should be used to allow the reverse dependencies recovery
modules to depend on the module, not to install the module to the
recovery partition.

Test: m soong_generated_recovery_filesystem_test
Bug: 381888358
Change-Id: I8e1bbf56aaf5ba4a761d84e60afa420ba6f825b9
---
 toolbox/Android.bp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/toolbox/Android.bp b/toolbox/Android.bp
index 120cc6e16113..3142542989f4 100644
--- a/toolbox/Android.bp
+++ b/toolbox/Android.bp
@@ -68,10 +68,16 @@ cc_defaults {
 cc_binary {
     name: "toolbox",
     defaults: ["toolbox_binary_defaults"],
-    recovery_available: true,
     vendor_ramdisk_available: true,
 }
 
+cc_binary {
+    name: "toolbox.recovery",
+    defaults: ["toolbox_binary_defaults"],
+    recovery: true,
+    stem: "toolbox",
+}
+
 cc_binary {
     name: "toolbox_vendor",
     stem: "toolbox",

From fdd861ef7e3490ab3c0fa9766ca12a5ce2c7376e Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 6 Dec 2024 17:52:29 +0000
Subject: [PATCH 1303/1487] debuggerd: Use libprocessgroup to unfreeze

Cgroup v2 paths are owned by libprocessgroup. Those paths can change
based on build flags, so paths generated outside of libprocessgroup may
not always be correct.

Bug: 382693152
Test: adb shell debuggerd -b <pid>
Change-Id: I7e486ab6f4068d0fae1be033a91b9a307f54ed42
---
 debuggerd/Android.bp    |  1 +
 debuggerd/debuggerd.cpp | 11 +++--------
 2 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 3257a2c50710..0e62ceb8f61b 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -505,6 +505,7 @@ cc_binary {
         "libbase",
         "libdebuggerd_client",
         "liblog",
+        "libprocessgroup",
         "libprocinfo",
     ],
 
diff --git a/debuggerd/debuggerd.cpp b/debuggerd/debuggerd.cpp
index 0d4b91f75700..7a2500c60afc 100644
--- a/debuggerd/debuggerd.cpp
+++ b/debuggerd/debuggerd.cpp
@@ -23,11 +23,11 @@
 #include <string_view>
 #include <thread>
 
-#include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/parseint.h>
 #include <android-base/unique_fd.h>
 #include <debuggerd/client.h>
+#include <processgroup/processgroup.h>
 #include <procinfo/process.h>
 #include "util.h"
 
@@ -92,13 +92,8 @@ int main(int argc, char* argv[]) {
   }
 
   // unfreeze if pid is frozen.
-  const std::string freeze_file = android::base::StringPrintf(
-      "/sys/fs/cgroup/uid_%d/pid_%d/cgroup.freeze", proc_info.uid, proc_info.pid);
-  if (std::string freeze_status;
-      android::base::ReadFileToString(freeze_file, &freeze_status) && freeze_status[0] == '1') {
-    android::base::WriteStringToFile("0", freeze_file);
-    // we don't restore the frozen state as this is considered a benign change.
-  }
+  SetProcessProfiles(proc_info.uid, proc_info.pid, {"Unfrozen"});
+  // we don't restore the frozen state as this is considered a benign change.
 
   unique_fd output_fd(fcntl(STDOUT_FILENO, F_DUPFD_CLOEXEC, 0));
   if (output_fd.get() == -1) {

From 2e581b68c6f171989b656d79457acf0e71364cab Mon Sep 17 00:00:00 2001
From: Jihoon Kang <jihoonkang@google.com>
Date: Fri, 6 Dec 2024 23:18:18 +0000
Subject: [PATCH 1304/1487] Define reboot.recovery and watchdogd.recovery

By removing the "recovery_available" property from "reboot" and
"watchdogd" modules.
"recovery_available" property should be used to allow the reverse
dependencies recovery modules to depend on the module, not to
install the module to the recovery partition.

Test: m soong_generated_recovery_filesystem_test
Bug: 381888358
Change-Id: I48014774714957885f3ad648ac302cc3c13687ae
---
 reboot/Android.bp    | 21 ++++++++++++++++++---
 watchdogd/Android.bp | 21 ++++++++++++++++++---
 2 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/reboot/Android.bp b/reboot/Android.bp
index 7b243bd56791..1cca82457c54 100644
--- a/reboot/Android.bp
+++ b/reboot/Android.bp
@@ -4,10 +4,25 @@ package {
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
-cc_binary {
-    name: "reboot",
+cc_defaults {
+    name: "reboot_defaults",
     srcs: ["reboot.c"],
     shared_libs: ["libcutils"],
     cflags: ["-Werror"],
-    recovery_available: true,
+}
+
+cc_binary {
+    name: "reboot",
+    defaults: [
+        "reboot_defaults",
+    ],
+}
+
+cc_binary {
+    name: "reboot.recovery",
+    defaults: [
+        "reboot_defaults",
+    ],
+    recovery: true,
+    stem: "reboot",
 }
diff --git a/watchdogd/Android.bp b/watchdogd/Android.bp
index 03882082f56c..bc7ffb656f16 100644
--- a/watchdogd/Android.bp
+++ b/watchdogd/Android.bp
@@ -2,9 +2,8 @@ package {
     default_applicable_licenses: ["Android-Apache-2.0"],
 }
 
-cc_binary {
-    name: "watchdogd",
-    recovery_available: true,
+cc_defaults {
+    name: "watchdogd_defaults",
     srcs: ["watchdogd.cpp"],
     cflags: [
         "-Wall",
@@ -16,3 +15,19 @@ cc_binary {
         misc_undefined: ["signed-integer-overflow"],
     },
 }
+
+cc_binary {
+    name: "watchdogd",
+    defaults: [
+        "watchdogd_defaults",
+    ],
+}
+
+cc_binary {
+    name: "watchdogd.recovery",
+    defaults: [
+        "watchdogd_defaults",
+    ],
+    recovery: true,
+    stem: "watchdogd",
+}

From 9b5c6fdce8a142b281ccca5da0a8edbe0a3bd2df Mon Sep 17 00:00:00 2001
From: Jihoon Kang <jihoonkang@google.com>
Date: Fri, 6 Dec 2024 23:33:42 +0000
Subject: [PATCH 1305/1487] Define init_second_stage.recovery

By removing `recovery_available` property from "init_second_stage"
and defining a dedicated recovery-specific module for
"init_second_stage". `recovery_available` property should be used
to allow the reverse dependencies recovery modules to depend on
the module, not to install the module to the recovery partition.

Test: m soong_generated_recovery_filesystem_test
Bug: 381888358
Change-Id: Ie9b93b8453bc1e40f7a28e57f498313d3bc4cedb
---
 init/Android.bp | 65 ++++++++++++++++++++++++-------------------------
 1 file changed, 32 insertions(+), 33 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index 4ee3be222555..ed19b4b865d0 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -268,7 +268,6 @@ phony {
 
 cc_defaults {
     name: "init_second_stage_defaults",
-    recovery_available: true,
     stem: "init",
     defaults: ["init_defaults"],
     srcs: ["main.cpp"],
@@ -280,37 +279,38 @@ cc_binary {
     defaults: ["init_second_stage_defaults"],
     static_libs: ["libinit"],
     visibility: ["//visibility:any_system_partition"],
-    target: {
-        platform: {
-            required: [
-                "init.rc",
-                "ueventd.rc",
-                "e2fsdroid",
-                "extra_free_kbytes",
-                "make_f2fs",
-                "mke2fs",
-                "sload_f2fs",
-            ],
-        },
-        recovery: {
-            cflags: ["-DRECOVERY"],
-            exclude_static_libs: [
-                "libxml2",
-            ],
-            exclude_shared_libs: [
-                "libbinder",
-                "libutils",
-            ],
-            required: [
-                "init_recovery.rc",
-                "ueventd.rc.recovery",
-                "e2fsdroid.recovery",
-                "make_f2fs.recovery",
-                "mke2fs.recovery",
-                "sload_f2fs.recovery",
-            ],
-        },
-    },
+    required: [
+        "init.rc",
+        "ueventd.rc",
+        "e2fsdroid",
+        "extra_free_kbytes",
+        "make_f2fs",
+        "mke2fs",
+        "sload_f2fs",
+    ],
+}
+
+cc_binary {
+    name: "init_second_stage.recovery",
+    defaults: ["init_second_stage_defaults"],
+    static_libs: ["libinit"],
+    recovery: true,
+    cflags: ["-DRECOVERY"],
+    exclude_static_libs: [
+        "libxml2",
+    ],
+    exclude_shared_libs: [
+        "libbinder",
+        "libutils",
+    ],
+    required: [
+        "init_recovery.rc",
+        "ueventd.rc.recovery",
+        "e2fsdroid.recovery",
+        "make_f2fs.recovery",
+        "mke2fs.recovery",
+        "sload_f2fs.recovery",
+    ],
 }
 
 cc_binary {
@@ -319,7 +319,6 @@ cc_binary {
         "avf_build_flags_cc",
         "init_second_stage_defaults",
     ],
-    recovery_available: false,
     static_libs: ["libinit.microdroid"],
     cflags: ["-DMICRODROID=1"],
     no_full_install: true,

From f9b38f91ac869e1f9eb9e76120aa695ba26540aa Mon Sep 17 00:00:00 2001
From: Jihoon Kang <jihoonkang@google.com>
Date: Fri, 6 Dec 2024 23:53:38 +0000
Subject: [PATCH 1306/1487] Define ueventd.rc.recovery

By removing `recovery_available` property from "ueventd.rc" and
defining a dedicated recovery-specific module for "ueventd.rc".
`recovery_available` property should be used to allow the reverse
dependencies recovery modules to depend on the module, not to
install the module to the recovery partition.

Test: m soong_generated_recovery_filesystem_test
Bug: 381888358
Change-Id: I6921cae72a1757e065003efc9d77241625f645e9
---
 rootdir/Android.bp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 44acbbae4b4d..4debbbece9a2 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -47,7 +47,12 @@ prebuilt_etc {
 prebuilt_etc {
     name: "ueventd.rc",
     src: "ueventd.rc",
-    recovery_available: true,
+}
+
+prebuilt_etc {
+    name: "ueventd.rc.recovery",
+    src: "ueventd.rc",
+    recovery: true,
 }
 
 filegroup {

From d189b8755ad42c334c2ac1c21319d4570a15c4af Mon Sep 17 00:00:00 2001
From: "Pechetty Sravani (xWF)" <pechetty@google.com>
Date: Mon, 9 Dec 2024 02:46:21 +0000
Subject: [PATCH 1307/1487] Revert "Define ueventd.rc.recovery"

This reverts commit f9b38f91ac869e1f9eb9e76120aa695ba26540aa.

Reason for revert: <Froidmonitor created revert due to b/382795480.Will be verified through ABTD for standard invesigation.>

Change-Id: Ib6f759fc3dee7800acf9a2c1e24eea2962730167
---
 rootdir/Android.bp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 4debbbece9a2..44acbbae4b4d 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -47,12 +47,7 @@ prebuilt_etc {
 prebuilt_etc {
     name: "ueventd.rc",
     src: "ueventd.rc",
-}
-
-prebuilt_etc {
-    name: "ueventd.rc.recovery",
-    src: "ueventd.rc",
-    recovery: true,
+    recovery_available: true,
 }
 
 filegroup {

From 96bdd33c1a105fd11d80124fd846149d1f376d64 Mon Sep 17 00:00:00 2001
From: Orlando Arbildo <oarbildo@google.com>
Date: Mon, 2 Dec 2024 21:10:50 +0000
Subject: [PATCH 1308/1487] trusty: utils: rpmb_dev: modify wv secure storage
 init.rc

Changing property name for widevine VM property to follow
system properties naming convention.

Bug: 371777025
Test: cuttlefish with trusty-vm enablement apex, run WV VTS
Change-Id: I0ff9e037bd76672173cd713960105babeac5f7f9
---
 trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc b/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
index 3e7f8b44fc23..003b6fe6501b 100644
--- a/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
+++ b/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
@@ -33,7 +33,7 @@ on boot && \
 
 # RPMB Mock
 on early-boot && \
-    property:ro.hardware.security.trusty.widevine_vm.system=1 && \
+    property:trusty.widevine_vm.enabled=1 && \
     property:trusty.widevine_vm.vm_cid=* && \
     property:ro.boot.vendor.apex.com.android.services.widevine=\
 com.android.services.widevine.cf_guest_trusty_nonsecure

From 744b469715da660bb3e9eb638f444439d36666d1 Mon Sep 17 00:00:00 2001
From: Jihoon Kang <jihoonkang@google.com>
Date: Fri, 6 Dec 2024 23:53:38 +0000
Subject: [PATCH 1309/1487] Revert^2 "Define ueventd.rc.recovery"

By removing `recovery_available` property from "ueventd.rc" and
defining a dedicated recovery-specific module for "ueventd.rc".
`recovery_available` property should be used to allow the reverse
dependencies recovery modules to depend on the module, not to
install the module to the recovery partition.

Test: m soong_generated_recovery_filesystem_test
Bug: 381888358
Change-Id: Ief4f4937baa1f624948850f3e0293458ea3c2c20
---
 rootdir/Android.bp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 44acbbae4b4d..d3db2ff1f0f7 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -47,7 +47,13 @@ prebuilt_etc {
 prebuilt_etc {
     name: "ueventd.rc",
     src: "ueventd.rc",
-    recovery_available: true,
+}
+
+prebuilt_etc {
+    name: "ueventd.rc.recovery",
+    src: "ueventd.rc",
+    recovery: true,
+    filename: "ueventd.rc",
 }
 
 filegroup {

From 69210a64000ef8a6bc24d6428cc29b5d8d41f8cd Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Fri, 6 Dec 2024 09:35:21 -0800
Subject: [PATCH 1310/1487] Do not encode newline characters for abort/log.

The isprint call will return false for chars such as newlines, which
means that the values '\n' and '\t' get encoded which was not the
intent of encodeding the abort and log messages. Add two oct_encode
versions, one that encodes all non-ascii values and only non-printable
ascii values for abort and log data. The other encoding function encodes
all chars that fail isprint() which is used for extra crash data.

Add new unit tests to verify that characters like newlines are not
encoded in the right places.

Bug: 381259755

Test: All unit tests pass.
Change-Id: I682f10e13a2e80ddfa7e87dfdf8181342eb22374
---
 debuggerd/debuggerd_test.cpp                  | 77 ++++++++++++++++---
 .../include/libdebuggerd/utility_host.h       |  5 +-
 debuggerd/libdebuggerd/tombstone_proto.cpp    |  4 +-
 .../libdebuggerd/tombstone_proto_to_text.cpp  |  5 +-
 debuggerd/libdebuggerd/utility_host.cpp       | 17 +++-
 5 files changed, 90 insertions(+), 18 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 5bdc946463ec..04a7df8231a1 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -3303,8 +3303,44 @@ TEST_F(CrasherTest, log_with_newline) {
   ASSERT_MATCH(result, ":\\s*This is on the next line.");
 }
 
-TEST_F(CrasherTest, log_with_non_utf8) {
-  StartProcess([]() { LOG(FATAL) << "Invalid UTF-8: \xA0\xB0\xC0\xD0 and some other data."; });
+TEST_F(CrasherTest, log_with_non_printable_ascii_verify_encoded) {
+  static const std::string kEncodedStr =
+      "\x5C\x31"
+      "\x5C\x32"
+      "\x5C\x33"
+      "\x5C\x34"
+      "\x5C\x35"
+      "\x5C\x36"
+      "\x5C\x37"
+      "\x5C\x31\x30"
+      "\x5C\x31\x36"
+      "\x5C\x31\x37"
+      "\x5C\x32\x30"
+      "\x5C\x32\x31"
+      "\x5C\x32\x32"
+      "\x5C\x32\x33"
+      "\x5C\x32\x34"
+      "\x5C\x32\x35"
+      "\x5C\x32\x36"
+      "\x5C\x32\x37"
+      "\x5C\x33\x30"
+      "\x5C\x33\x31"
+      "\x5C\x33\x32"
+      "\x5C\x33\x33"
+      "\x5C\x33\x34"
+      "\x5C\x33\x35"
+      "\x5C\x33\x36"
+      "\x5C\x33\x37"
+      "\x5C\x31\x37\x37"
+      "\x5C\x32\x34\x30"
+      "\x5C\x32\x36\x30"
+      "\x5C\x33\x30\x30"
+      "\x5C\x33\x32\x30";
+  StartProcess([]() {
+    LOG(FATAL) << "Encoded: "
+                  "\x1\x2\x3\x4\x5\x6\x7\x8\xe\xf\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b"
+                  "\x1c\x1d\x1e\x1f\x7f\xA0\xB0\xC0\xD0 after";
+  });
 
   unique_fd output_fd;
   StartIntercept(&output_fd);
@@ -3317,15 +3353,38 @@ TEST_F(CrasherTest, log_with_non_utf8) {
   std::string result;
   ConsumeFd(std::move(output_fd), &result);
   // Verify the abort message is sanitized properly.
-  size_t pos = result.find(
-      "Abort message: 'Invalid UTF-8: "
-      "\x5C\x32\x34\x30\x5C\x32\x36\x30\x5C\x33\x30\x30\x5C\x33\x32\x30 and some other data.'");
+  size_t pos = result.find(std::string("Abort message: 'Encoded: ") + kEncodedStr + " after'");
   EXPECT_TRUE(pos != std::string::npos) << "Couldn't find sanitized abort message: " << result;
 
   // Make sure that the log message is sanitized properly too.
-  EXPECT_TRUE(
-      result.find("Invalid UTF-8: \x5C\x32\x34\x30\x5C\x32\x36\x30\x5C\x33\x30\x30\x5C\x33\x32\x30 "
-                  "and some other data.",
-                  pos + 30) != std::string::npos)
+  EXPECT_TRUE(result.find(std::string("Encoded: ") + kEncodedStr + " after", pos + 1) !=
+              std::string::npos)
+      << "Couldn't find sanitized log message: " << result;
+}
+
+TEST_F(CrasherTest, log_with_with_special_printable_ascii) {
+  static const std::string kMsg = "Not encoded: \t\v\f\r\n after";
+  StartProcess([]() { LOG(FATAL) << kMsg; });
+
+  unique_fd output_fd;
+  StartIntercept(&output_fd);
+  FinishCrasher();
+  AssertDeath(SIGABRT);
+  int intercept_result;
+  FinishIntercept(&intercept_result);
+  ASSERT_EQ(1, intercept_result) << "tombstoned reported failure";
+
+  std::string result;
+  ConsumeFd(std::move(output_fd), &result);
+  // Verify the abort message does not remove characters that are UTF8 but
+  // are, technically, not printable.
+  size_t pos = result.find(std::string("Abort message: '") + kMsg + "'");
+  EXPECT_TRUE(pos != std::string::npos) << "Couldn't find abort message: " << result;
+
+  // Make sure that the log message is handled properly too.
+  // The logger automatically splits a newline message into two pieces.
+  pos = result.find("Not encoded: \t\v\f\r", pos + kMsg.size());
+  EXPECT_TRUE(pos != std::string::npos) << "Couldn't find log message: " << result;
+  EXPECT_TRUE(result.find(" after", pos + 1) != std::string::npos)
       << "Couldn't find sanitized log message: " << result;
 }
diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/utility_host.h b/debuggerd/libdebuggerd/include/libdebuggerd/utility_host.h
index df22e017ce3f..819a99d2d942 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/utility_host.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/utility_host.h
@@ -30,4 +30,7 @@ constexpr size_t kTagGranuleSize = 16;
 constexpr size_t kNumTagColumns = 16;
 constexpr size_t kNumTagRows = 16;
 
-std::string oct_encode(const std::string& data);
+// Encode all non-ascii values and also ascii values that are not printable.
+std::string oct_encode_non_ascii_printable(const std::string& data);
+// Encode any value that fails isprint(), includes encoding chars like '\n' and '\t'.
+std::string oct_encode_non_printable(const std::string& data);
diff --git a/debuggerd/libdebuggerd/tombstone_proto.cpp b/debuggerd/libdebuggerd/tombstone_proto.cpp
index ef303f065c8b..d3ac49a17f8d 100644
--- a/debuggerd/libdebuggerd/tombstone_proto.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto.cpp
@@ -467,7 +467,7 @@ static void dump_abort_message(Tombstone* tombstone,
   msg.resize(index);
 
   // Make sure only UTF8 characters are present since abort_message is a string.
-  tombstone->set_abort_message(oct_encode(msg));
+  tombstone->set_abort_message(oct_encode_non_ascii_printable(msg));
 }
 
 static void dump_open_fds(Tombstone* tombstone, const OpenFilesList* open_files) {
@@ -776,7 +776,7 @@ static void dump_log_file(Tombstone* tombstone, const char* logger, pid_t pid) {
       log_msg->set_priority(prio);
       log_msg->set_tag(tag);
       // Make sure only UTF8 characters are present since message is a string.
-      log_msg->set_message(oct_encode(msg));
+      log_msg->set_message(oct_encode_non_ascii_printable(msg));
     } while ((msg = nl));
   }
   android_logger_list_free(logger_list);
diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index e885c5a73b14..0474ae7a1105 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -17,6 +17,7 @@
 #include <libdebuggerd/tombstone_proto_to_text.h>
 #include <libdebuggerd/utility_host.h>
 
+#include <ctype.h>
 #include <inttypes.h>
 
 #include <algorithm>
@@ -463,8 +464,8 @@ static void print_main_thread(CallbackType callback, SymbolizeCallbackType symbo
   }
 
   for (const auto& crash_detail : tombstone.crash_details()) {
-    std::string oct_encoded_name = oct_encode(crash_detail.name());
-    std::string oct_encoded_data = oct_encode(crash_detail.data());
+    std::string oct_encoded_name = oct_encode_non_printable(crash_detail.name());
+    std::string oct_encoded_data = oct_encode_non_printable(crash_detail.data());
     CBL("Extra crash detail: %s: '%s'", oct_encoded_name.c_str(), oct_encoded_data.c_str());
   }
 
diff --git a/debuggerd/libdebuggerd/utility_host.cpp b/debuggerd/libdebuggerd/utility_host.cpp
index 4efa03c8cbb7..d87f4fb8e1a7 100644
--- a/debuggerd/libdebuggerd/utility_host.cpp
+++ b/debuggerd/libdebuggerd/utility_host.cpp
@@ -16,6 +16,7 @@
 
 #include "libdebuggerd/utility_host.h"
 
+#include <ctype.h>
 #include <sys/prctl.h>
 
 #include <charconv>
@@ -102,23 +103,31 @@ std::string describe_pac_enabled_keys(long value) {
   return describe_end(value, desc);
 }
 
-std::string oct_encode(const std::string& data) {
+static std::string oct_encode(const std::string& data, bool (*should_encode_func)(int)) {
   std::string oct_encoded;
   oct_encoded.reserve(data.size());
 
   // N.B. the unsigned here is very important, otherwise e.g. \255 would render as
   // \-123 (and overflow our buffer).
   for (unsigned char c : data) {
-    if (isprint(c)) {
-      oct_encoded += c;
-    } else {
+    if (should_encode_func(c)) {
       std::string oct_digits("\\\0\0\0", 4);
       // char is encodable in 3 oct digits
       static_assert(std::numeric_limits<unsigned char>::max() <= 8 * 8 * 8);
       auto [ptr, ec] = std::to_chars(oct_digits.data() + 1, oct_digits.data() + 4, c, 8);
       oct_digits.resize(ptr - oct_digits.data());
       oct_encoded += oct_digits;
+    } else {
+      oct_encoded += c;
     }
   }
   return oct_encoded;
 }
+
+std::string oct_encode_non_ascii_printable(const std::string& data) {
+  return oct_encode(data, [](int c) { return !isgraph(c) && !isspace(c); });
+}
+
+std::string oct_encode_non_printable(const std::string& data) {
+  return oct_encode(data, [](int c) { return !isprint(c); });
+}

From 64ee4a6b4ca5e054965261a34b657426e16ebcee Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Wed, 11 Dec 2024 00:26:22 +0000
Subject: [PATCH 1311/1487] init: Remove /acct

The cpuacct controller has not been mounted at /acct since 2018 with
commit 192aee782 ("libprocessgroup: Add support for task profiles").

Test: atest FrameworksMockingServicesTests:AppChildProcessTest
Test: atest CtsAppTestCases:ActivityManagerTest
Change-Id: I411741232dde59acd2e3af33e0e89230f7a133a8
---
 rootdir/create_root_structure.mk | 2 +-
 rootdir/init.rc                  | 2 --
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/rootdir/create_root_structure.mk b/rootdir/create_root_structure.mk
index 1daf239b4d70..d0be89769c9a 100644
--- a/rootdir/create_root_structure.mk
+++ b/rootdir/create_root_structure.mk
@@ -27,7 +27,7 @@ endif
 #
 # create some directories (some are mount points) and symlinks
 LOCAL_POST_INSTALL_CMD := mkdir -p $(addprefix $(TARGET_ROOT_OUT)/, \
-    dev proc sys system data data_mirror odm oem acct config storage mnt apex bootstrap-apex debug_ramdisk \
+    dev proc sys system data data_mirror odm oem config storage mnt apex bootstrap-apex debug_ramdisk \
     linkerconfig second_stage_resources postinstall tmp $(BOARD_ROOT_EXTRA_FOLDERS)); \
     ln -sf /system/bin $(TARGET_ROOT_OUT)/bin; \
     ln -sf /system/etc $(TARGET_ROOT_OUT)/etc; \
diff --git a/rootdir/init.rc b/rootdir/init.rc
index ae6a6588b62e..957860f9c50b 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -27,8 +27,6 @@ on early-init
     # Set the security context of /postinstall if present.
     restorecon /postinstall
 
-    mkdir /acct/uid
-
     # memory.pressure_level used by lmkd
     chown root system /dev/memcg/memory.pressure_level
     chmod 0040 /dev/memcg/memory.pressure_level

From 0a6eca2d9aad6136502f81b7364059a188355c93 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Tue, 10 Dec 2024 18:18:13 -0800
Subject: [PATCH 1312/1487] Fix use before set bug in arm32 guest.

I accidentally set the unwind register object using the uninitialized
arm registers. Actually set using the arm registers that contains
valid data.

Test: All unit tests pass.
Test: Ran on an arm32 guest host and verified the guest unwind is valid.
Change-Id: I20a2b6675648df1c627af80aa708071109bdf099
---
 debuggerd/crash_dump.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 00b861a96942..7d3830c5404d 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -546,10 +546,10 @@ static void ReadGuestRegisters(std::unique_ptr<unwindstack::Regs>* regs, pid_t t
 #else
     case NATIVE_BRIDGE_ARCH_ARM: {
       unwindstack::arm_user_regs arm_user_regs = {};
-      regs->reset(unwindstack::RegsArm::Read(&arm_user_regs));
       for (size_t i = 0; i < unwindstack::ARM_REG_LAST; i++) {
         arm_user_regs.regs[i] = guest_regs.regs_arm.r[i];
       }
+      regs->reset(unwindstack::RegsArm::Read(&arm_user_regs));
 
       g_guest_arch = Architecture::ARM32;
       break;

From 8d8ecf633d07b84555038ede53b8a483316bc4fe Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 12 Dec 2024 01:10:31 +0000
Subject: [PATCH 1313/1487] libprocessgroup: Explicit field presence for
 MaxActivationDepth

https://protobuf.dev/programming-guides/field_presence/

Explicit field presence is required to support a MaxActivationDepth
value of 0 (the implicit default) for the libprocessgroup_proto_test.
Other non-zero values work fine.

All (positive) values of MaxActivationDepth work correctly at runtime.
This is a test-only fix.

Test: atest libprocessgroup_proto_test
Bug: 346584259
Bug: 377579705
Fixes: 28b37f270 ("libprocessgroup: Add MaxActivationDepth")
Change-Id: Ic3acc85790e1c84bef3f2bb50399011f28339c3b
---
 libprocessgroup/profiles/cgroups.proto | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libprocessgroup/profiles/cgroups.proto b/libprocessgroup/profiles/cgroups.proto
index d2fd472d15a7..1a78e9df246e 100644
--- a/libprocessgroup/profiles/cgroups.proto
+++ b/libprocessgroup/profiles/cgroups.proto
@@ -36,7 +36,7 @@ message Cgroup {
 // https://developers.google.com/protocol-buffers/docs/proto3#default
     bool needs_activation = 6 [json_name = "NeedsActivation"];
     bool is_optional = 7 [json_name = "Optional"];
-    uint32 max_activation_depth = 8 [json_name = "MaxActivationDepth"];
+    optional uint32 max_activation_depth = 8 [json_name = "MaxActivationDepth"];
 }
 
 // Next: 6

From 5fa48a84b53aa60d76ba85dd449d470128b48742 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 22 Nov 2024 21:28:53 +0000
Subject: [PATCH 1314/1487] libprocessgroup: memcg default version 1 -> 2

The default memcg version is 1 in cgroups.json. Update the default to
version 2. Vendor overrides of cgroups.json [1] (to use v1 with the v2
default here) remain supported for kernels which still support memcg v1,
but core features of v1 have already been deprecated and removed from
recent kernels, and it is expected v1 will eventually be removed from
the kernel entirely. So v1 users should migrate to v2 as soon as
possible.

This change activates memcg only in the root, but we may update this to
enable per-application memcgs by default in the future. Vendors may
override this default with their own cgroups.json to get per-application
memcgs by adjusting the value of MaxActivationDepth.

[1] https://source.android.com/docs/core/perf/cgroups#per-api-level-task-profiles

Test: (cuttlefish) adb shell grep memory /sys/fs/cgroup/cgroup.controllers
Bug: 377579705
Change-Id: I5b985fb4348b92d49022760331c0adf113bcdf04
---
 libprocessgroup/profiles/cgroups.json | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/libprocessgroup/profiles/cgroups.json b/libprocessgroup/profiles/cgroups.json
index 3e4393df2078..dbf736aa0915 100644
--- a/libprocessgroup/profiles/cgroups.json
+++ b/libprocessgroup/profiles/cgroups.json
@@ -20,14 +20,6 @@
       "Mode": "0755",
       "UID": "system",
       "GID": "system"
-    },
-    {
-      "Controller": "memory",
-      "Path": "/dev/memcg",
-      "Mode": "0700",
-      "UID": "root",
-      "GID": "system",
-      "Optional": true
     }
   ],
   "Cgroups2": {
@@ -39,6 +31,13 @@
       {
         "Controller": "freezer",
         "Path": "."
+      },
+      {
+        "Controller": "memory",
+        "Path": ".",
+        "NeedsActivation": true,
+        "MaxActivationDepth": 0,
+        "Optional": true
       }
     ]
   }

From c897b0a86dade94af198e26950701d7beff0ba1f Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Wed, 11 Dec 2024 23:07:19 +0000
Subject: [PATCH 1315/1487] libprocessgroup: Support memcg v1 per-app with
 PRODUCT_CGROUP_V2_SYS_APP_ISOLATION_ENABLED

We are enabling PRODUCT_CGROUP_V2_SYS_APP_ISOLATION_ENABLED by default
and also temporarily retaining support for overriding the new memcg v2
default back to v1. That means the default
PRODUCT_CGROUP_V2_SYS_APP_ISOLATION_ENABLED must work correctly with v1
per-application memcg paths, which is not currently the case. This
change uses knowledge about whether paths being generated are for a v1
cgroup or a v2 cgroup so that the common ConvertUid{Pid}ToPath functions
can continue to be used for both v1 and v2 cases.

Memcg v1 support will eventually be removed, so this change can be
reverted when that happens.

Test: boot cf_gwear_x86-trunk_staging-userdebug with
      PRODUCT_CGROUP_V2_SYS_APP_ISOLATION_ENABLED = true.
      cf_gwear_x86-trunk_staging-userdebug sets ro.config.low_ram
      causing v1 per-app memcgs to be used.
Bug: 377579705
Change-Id: Iec26c02fd261bdec80a7e49fce4dc207d1996b1b
---
 libprocessgroup/processgroup.cpp  | 23 ++++++++++++-----------
 libprocessgroup/task_profiles.cpp | 12 ++++++------
 libprocessgroup/task_profiles.h   |  4 ++--
 3 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 95221594b6be..f83e04258da8 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -85,7 +85,8 @@ static bool CgroupKillAvailable() {
         CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &cg_kill);
         // cgroup.kill is not on the root cgroup, so check a non-root cgroup that should always
         // exist
-        cg_kill = ConvertUidToPath(cg_kill.c_str(), AID_ROOT) + '/' + PROCESSGROUP_CGROUP_KILL_FILE;
+        cg_kill = ConvertUidToPath(cg_kill.c_str(), AID_ROOT, true) + '/' +
+            PROCESSGROUP_CGROUP_KILL_FILE;
         cgroup_kill_available = access(cg_kill.c_str(), F_OK) == 0;
     });
 
@@ -224,14 +225,14 @@ bool SetUserProfiles(uid_t uid, const std::vector<std::string>& profiles) {
                                                        false);
 }
 
-static int RemoveCgroup(const char* cgroup, uid_t uid, pid_t pid) {
-    auto path = ConvertUidPidToPath(cgroup, uid, pid);
+static int RemoveCgroup(const char* cgroup, uid_t uid, pid_t pid, bool v2_path) {
+    auto path = ConvertUidPidToPath(cgroup, uid, pid, v2_path);
     int ret = TEMP_FAILURE_RETRY(rmdir(path.c_str()));
 
     if (!ret && uid >= AID_ISOLATED_START && uid <= AID_ISOLATED_END) {
         // Isolated UIDs are unlikely to be reused soon after removal,
         // so free up the kernel resources for the UID level cgroup.
-        path = ConvertUidToPath(cgroup, uid);
+        path = ConvertUidToPath(cgroup, uid, v2_path);
         ret = TEMP_FAILURE_RETRY(rmdir(path.c_str()));
     }
 
@@ -368,7 +369,7 @@ bool sendSignalToProcessGroup(uid_t uid, pid_t initialPid, int signal) {
     if (CgroupsAvailable()) {
         std::string hierarchy_root_path, cgroup_v2_path;
         CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
-        cgroup_v2_path = ConvertUidPidToPath(hierarchy_root_path.c_str(), uid, initialPid);
+        cgroup_v2_path = ConvertUidPidToPath(hierarchy_root_path.c_str(), uid, initialPid, true);
 
         if (signal == SIGKILL && CgroupKillAvailable()) {
             LOG(VERBOSE) << "Using " << PROCESSGROUP_CGROUP_KILL_FILE << " to SIGKILL "
@@ -539,7 +540,7 @@ static int KillProcessGroup(
     CgroupGetControllerPath(CGROUPV2_HIERARCHY_NAME, &hierarchy_root_path);
 
     const std::string cgroup_v2_path =
-            ConvertUidPidToPath(hierarchy_root_path.c_str(), uid, initialPid);
+            ConvertUidPidToPath(hierarchy_root_path.c_str(), uid, initialPid, true);
 
     const std::string eventsfile = cgroup_v2_path + '/' + PROCESSGROUP_CGROUP_EVENTS_FILE;
     android::base::unique_fd events_fd(open(eventsfile.c_str(), O_RDONLY));
@@ -605,7 +606,7 @@ static int KillProcessGroup(
                          << " after " << kill_duration.count() << " ms";
         }
 
-        ret = RemoveCgroup(hierarchy_root_path.c_str(), uid, initialPid);
+        ret = RemoveCgroup(hierarchy_root_path.c_str(), uid, initialPid, true);
         if (ret)
             PLOG(ERROR) << "Unable to remove cgroup " << cgroup_v2_path;
         else
@@ -616,9 +617,9 @@ static int KillProcessGroup(
             // memcg v2.
             std::string memcg_apps_path;
             if (CgroupGetMemcgAppsPath(&memcg_apps_path) &&
-                (ret = RemoveCgroup(memcg_apps_path.c_str(), uid, initialPid)) < 0) {
+                (ret = RemoveCgroup(memcg_apps_path.c_str(), uid, initialPid, false)) < 0) {
                 const auto memcg_v1_cgroup_path =
-                        ConvertUidPidToPath(memcg_apps_path.c_str(), uid, initialPid);
+                        ConvertUidPidToPath(memcg_apps_path.c_str(), uid, initialPid, false);
                 PLOG(ERROR) << "Unable to remove memcg v1 cgroup " << memcg_v1_cgroup_path;
             }
         }
@@ -640,7 +641,7 @@ int killProcessGroupOnce(uid_t uid, pid_t initialPid, int signal) {
 
 static int createProcessGroupInternal(uid_t uid, pid_t initialPid, std::string cgroup,
                                       bool activate_controllers) {
-    auto uid_path = ConvertUidToPath(cgroup.c_str(), uid);
+    auto uid_path = ConvertUidToPath(cgroup.c_str(), uid, activate_controllers);
 
     struct stat cgroup_stat;
     mode_t cgroup_mode = 0750;
@@ -667,7 +668,7 @@ static int createProcessGroupInternal(uid_t uid, pid_t initialPid, std::string c
         }
     }
 
-    auto uid_pid_path = ConvertUidPidToPath(cgroup.c_str(), uid, initialPid);
+    auto uid_pid_path = ConvertUidPidToPath(cgroup.c_str(), uid, initialPid, activate_controllers);
 
     if (!MkdirAndChown(uid_pid_path, cgroup_mode, cgroup_uid, cgroup_gid)) {
         PLOG(ERROR) << "Failed to make and chown " << uid_pid_path;
diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index dc6c8c07f2c1..c03c25727f35 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -150,8 +150,8 @@ static bool isSystemApp(uid_t uid) {
     return uid < AID_APP_START;
 }
 
-std::string ConvertUidToPath(const char* root_cgroup_path, uid_t uid) {
-    if (android::libprocessgroup_flags::cgroup_v2_sys_app_isolation()) {
+std::string ConvertUidToPath(const char* root_cgroup_path, uid_t uid, bool v2_path) {
+    if (android::libprocessgroup_flags::cgroup_v2_sys_app_isolation() && v2_path) {
         if (isSystemApp(uid))
             return StringPrintf("%s/system/uid_%u", root_cgroup_path, uid);
         else
@@ -160,14 +160,14 @@ std::string ConvertUidToPath(const char* root_cgroup_path, uid_t uid) {
     return StringPrintf("%s/uid_%u", root_cgroup_path, uid);
 }
 
-std::string ConvertUidPidToPath(const char* root_cgroup_path, uid_t uid, pid_t pid) {
-    const std::string uid_path = ConvertUidToPath(root_cgroup_path, uid);
+std::string ConvertUidPidToPath(const char* root_cgroup_path, uid_t uid, pid_t pid, bool v2_path) {
+    const std::string uid_path = ConvertUidToPath(root_cgroup_path, uid, v2_path);
     return StringPrintf("%s/pid_%d", uid_path.c_str(), pid);
 }
 
 bool ProfileAttribute::GetPathForProcess(uid_t uid, pid_t pid, std::string* path) const {
     if (controller()->version() == 2) {
-        const std::string cgroup_path = ConvertUidPidToPath(controller()->path(), uid, pid);
+        const std::string cgroup_path = ConvertUidPidToPath(controller()->path(), uid, pid, true);
         *path = cgroup_path + "/" + file_name();
         return true;
     }
@@ -199,7 +199,7 @@ bool ProfileAttribute::GetPathForUID(uid_t uid, std::string* path) const {
         return true;
     }
 
-    const std::string cgroup_path = ConvertUidToPath(controller()->path(), uid);
+    const std::string cgroup_path = ConvertUidToPath(controller()->path(), uid, true);
     *path = cgroup_path + "/" + file_name();
     return true;
 }
diff --git a/libprocessgroup/task_profiles.h b/libprocessgroup/task_profiles.h
index d0b50436c0c3..b1d611514a4c 100644
--- a/libprocessgroup/task_profiles.h
+++ b/libprocessgroup/task_profiles.h
@@ -258,5 +258,5 @@ class TaskProfiles {
     std::map<std::string, std::unique_ptr<IProfileAttribute>, std::less<>> attributes_;
 };
 
-std::string ConvertUidToPath(const char* root_cgroup_path, uid_t uid);
-std::string ConvertUidPidToPath(const char* root_cgroup_path, uid_t uid, pid_t pid);
+std::string ConvertUidToPath(const char* root_cgroup_path, uid_t uid, bool v2_path);
+std::string ConvertUidPidToPath(const char* root_cgroup_path, uid_t uid, pid_t pid, bool v2_path);

From fdd8f755e652c8201cc9bcc019e217986757f19b Mon Sep 17 00:00:00 2001
From: Cole Faust <colefaust@google.com>
Date: Fri, 13 Dec 2024 15:05:43 -0800
Subject: [PATCH 1316/1487] Remove system_linker_config module

The linker.config.pb on the system image has some system-specific
build steps. The system_linker_config module was just one of the
steps, but the rest of the steps depend on installed files, which
are only known to the filesystem modules, so they happen there.
Move this first initial step to the filesystem level as well for
consistency.

Bug: 384091387
Test: Diff'd out/target/product/vsoc_x86_64/system/etc/linker.config.pb before and after this cl
Change-Id: Ia3a613eee730778a6bd3aeb196c53cee0eb576bf
---
 rootdir/Android.bp | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index d3db2ff1f0f7..121652ccac67 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -61,13 +61,6 @@ filegroup {
     srcs: ["etc/linker.config.json"],
 }
 
-// TODO(b/147210213) Generate list of libraries during build and fill in at build time
-linker_config {
-    name: "system_linker_config",
-    src: ":system_linker_config_json_file",
-    installable: false,
-}
-
 // TODO(b/185211376) Scope the native APIs that microdroid will provide to the app payload
 prebuilt_etc {
     name: "public.libraries.android.txt",

From 835a86216226663c6b0a1ff0ca38b24eab54e2bc Mon Sep 17 00:00:00 2001
From: Ryan Savitski <rsavitski@google.com>
Date: Mon, 16 Dec 2024 18:14:54 +0000
Subject: [PATCH 1317/1487] init: add "shared_kallsyms" option for tracing
 daemons

The perfetto tracing daemons can currently symbolise kernel addresses
within ftrace & perf_event data on debuggable builds, but not on release
builds. This is due to concerns with side-effects of changing the
kptr_restrict sysctl at runtime, as it affects more than just
/proc/kallsyms. The sysctl also controls vsprintf behaviour in the
kernel (affecting printk and e.g. /proc/vmallocinfo), as well as other
procfs files such as /proc/modules. This patch adds a special case to
init to allow for kernel address symbolisation on release builds without
any additional kptr_restrict changes.

The key observations are:
* symbol visibility through an opened /proc/kallsyms fd is fixed for the
  lifetime of that fd as it's cached in the kernel seq_file structure.
* second_stage init is responsible for changing the kptr_restrict from
  the on-boot Linux default (0) to the Android's default of 2. init is
  therefore uniquely positioned to open /proc/kallsyms while addresses
  are still visible to itself (due to CAP_SYSLOG).

This patch makes second_stage init open /proc/kallsyms and save that fd
as a static, which is then duplicated and passed to services specifying
a new "shared_kallsyms" option. Permissions are enforced by selinux,
since the service domains needs to be allowed to read files with the
`proc_kallsyms` label.

See go/perfetto-kallsyms-user for more details.

Test: atest CtsPerfettoTestCases
Test: manual tracing on panther-trunk_staging-user{,debug}
Bug: 383513654
Change-Id: I7bc707521349b7f50a32283642927bc4982dd9a1
---
 init/README.md          | 11 +++++++++++
 init/init.cpp           |  8 ++++++++
 init/service.cpp        | 38 ++++++++++++++++++++++++++++++++++++++
 init/service.h          |  3 +++
 init/service_parser.cpp |  6 ++++++
 init/service_parser.h   |  1 +
 6 files changed, 67 insertions(+)

diff --git a/init/README.md b/init/README.md
index 560c5280fe6c..653dadd34c0e 100644
--- a/init/README.md
+++ b/init/README.md
@@ -369,6 +369,17 @@ runs the service.
 `setenv <name> <value>`
 > Set the environment variable _name_ to _value_ in the launched process.
 
+`shared_kallsyms`
+> If set, init will behave as if the service specified "file /proc/kallsyms r",
+  except the service will receive a duplicate of a single fd that init saved
+  during early second\_stage. This fd retains address visibility even after the
+  systemwide kptr\_restrict sysctl is set to its steady state on Android. The
+  ability to read from this fd is still constrained by selinux permissions,
+  which need to be granted separately and are gated by a neverallow.
+  Because of performance gotchas of concurrent use of this shared fd, all uses
+  need to coordinate via provisional flock(LOCK\_EX) locks on separately opened
+  /proc/kallsyms fds (since locking requires distinct open file descriptions).
+
 `shutdown <shutdown_behavior>`
 > Set shutdown behavior of the service process. When this is not specified,
   the service is killed during shutdown process by using SIGTERM and SIGKILL.
diff --git a/init/init.cpp b/init/init.cpp
index 5b0b0ddee12d..b6ba6a85893b 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -1055,6 +1055,14 @@ int SecondStageMain(int argc, char** argv) {
         }
     }
 
+    // This needs to happen before SetKptrRestrictAction, as we are trying to
+    // open /proc/kallsyms while still being allowed to see the full addresses
+    // (since init holds CAP_SYSLOG, and Linux boots with kptr_restrict=0). The
+    // address visibility through the saved fd (more specifically, the backing
+    // open file description) will then be remembered by the kernel for the rest
+    // of its lifetime, even after we raise the kptr_restrict.
+    Service::OpenAndSaveStaticKallsymsFd();
+
     am.QueueBuiltinAction(SetupCgroupsAction, "SetupCgroups");
     am.QueueBuiltinAction(SetKptrRestrictAction, "SetKptrRestrict");
     am.QueueBuiltinAction(TestPerfEventSelinuxAction, "TestPerfEventSelinux");
diff --git a/init/service.cpp b/init/service.cpp
index d76a5d5e0d3c..56300205d293 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -34,6 +34,7 @@
 #include <android-base/scopeguard.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
+#include <cutils/android_get_control_file.h>
 #include <cutils/sockets.h>
 #include <processgroup/processgroup.h>
 #include <selinux/selinux.h>
@@ -672,6 +673,14 @@ Result<void> Service::Start() {
         }
     }
 
+    if (shared_kallsyms_file_) {
+        if (auto result = CreateSharedKallsymsFd(); result.ok()) {
+            descriptors.emplace_back(std::move(*result));
+        } else {
+            LOG(INFO) << "Could not obtain a copy of /proc/kallsyms: " << result.error();
+        }
+    }
+
     pid_t pid = -1;
     if (namespaces_.flags) {
         pid = clone(nullptr, nullptr, namespaces_.flags | SIGCHLD, nullptr);
@@ -835,6 +844,35 @@ unique_fd Service::CreateSigchldFd() {
     return unique_fd(signalfd(-1, &mask, SFD_CLOEXEC));
 }
 
+void Service::OpenAndSaveStaticKallsymsFd() {
+    Result<Descriptor> result = CreateSharedKallsymsFd();
+    if (!result.ok()) {
+      LOG(ERROR) << result.error();
+    }
+}
+
+// This function is designed to be called in two situations:
+// 1) early during second_stage init, to open and save the shared fd as a
+//    static (see OpenAndSaveStaticKallsymsFd).
+// 2) whenever a service requesting a copy of the fd is being started, at which
+//    point it will get a duplicated copy of the static fd.
+Result<Descriptor> Service::CreateSharedKallsymsFd() {
+    static constexpr char kallsyms_path[] = "/proc/kallsyms";
+    static int static_fd = open(kallsyms_path, O_RDONLY | O_NONBLOCK | O_CLOEXEC);
+    if (static_fd < 0) {
+        return ErrnoError() << "failed to open " << kallsyms_path;
+    }
+
+    unique_fd fd{fcntl(static_fd, F_DUPFD_CLOEXEC, /*min_fd=*/3)};
+    if (fd < 0) {
+        return ErrnoError() << "failed fcntl(F_DUPFD_CLOEXEC)";
+    }
+
+    // Use the same environment variable as if the service specified
+    // "file /proc/kallsyms r".
+    return Descriptor(std::string(ANDROID_FILE_ENV_PREFIX) + kallsyms_path, std::move(fd));
+}
+
 void Service::SetStartedInFirstStage(pid_t pid) {
     LOG(INFO) << "adding first-stage service '" << name_ << "'...";
 
diff --git a/init/service.h b/init/service.h
index ae75553d3213..7193d7eb1b33 100644
--- a/init/service.h
+++ b/init/service.h
@@ -158,6 +158,7 @@ class Service {
         static int sigchld_fd = CreateSigchldFd().release();
         return sigchld_fd;
     }
+    static void OpenAndSaveStaticKallsymsFd();
 
   private:
     void NotifyStateChange(const std::string& new_state) const;
@@ -171,6 +172,7 @@ class Service {
                     InterprocessFifo setsid_finished);
     void SetMountNamespace();
     static ::android::base::unique_fd CreateSigchldFd();
+    static Result<Descriptor> CreateSharedKallsymsFd();
 
     static unsigned long next_start_order_;
     static bool is_exec_service_running_;
@@ -188,6 +190,7 @@ class Service {
     std::optional<std::string> fatal_reboot_target_;  // reboot target of fatal handler
     bool was_last_exit_ok_ =
             true;  // true if the service never exited, or exited with status code 0
+    bool shared_kallsyms_file_ = false; // pass the service a pre-opened fd to /proc/kallsyms
 
     std::optional<CapSet> capabilities_;
     ProcessAttributes proc_attr_;
diff --git a/init/service_parser.cpp b/init/service_parser.cpp
index ec3b176d427f..4c31718dda10 100644
--- a/init/service_parser.cpp
+++ b/init/service_parser.cpp
@@ -309,6 +309,11 @@ Result<void> ServiceParser::ParseOverride(std::vector<std::string>&& args) {
     return {};
 }
 
+Result<void> ServiceParser::ParseSharedKallsyms(std::vector<std::string>&& args) {
+    service_->shared_kallsyms_file_ = true;
+    return {};
+}
+
 Result<void> ServiceParser::ParseMemcgSwappiness(std::vector<std::string>&& args) {
     if (!ParseInt(args[1], &service_->swappiness_, 0)) {
         return Error() << "swappiness value must be equal or greater than 0";
@@ -603,6 +608,7 @@ const KeywordMap<ServiceParser::OptionParser>& ServiceParser::GetParserMap() con
         {"rlimit",                  {3,     3,    &ServiceParser::ParseProcessRlimit}},
         {"seclabel",                {1,     1,    &ServiceParser::ParseSeclabel}},
         {"setenv",                  {2,     2,    &ServiceParser::ParseSetenv}},
+        {"shared_kallsyms",         {0,     0,    &ServiceParser::ParseSharedKallsyms}},
         {"shutdown",                {1,     1,    &ServiceParser::ParseShutdown}},
         {"sigstop",                 {0,     0,    &ServiceParser::ParseSigstop}},
         {"socket",                  {3,     6,    &ServiceParser::ParseSocket}},
diff --git a/init/service_parser.h b/init/service_parser.h
index f06cfc47d9f5..e42b62b5cc6e 100644
--- a/init/service_parser.h
+++ b/init/service_parser.h
@@ -67,6 +67,7 @@ class ServiceParser : public SectionParser {
     Result<void> ParseRestartPeriod(std::vector<std::string>&& args);
     Result<void> ParseSeclabel(std::vector<std::string>&& args);
     Result<void> ParseSetenv(std::vector<std::string>&& args);
+    Result<void> ParseSharedKallsyms(std::vector<std::string>&& args);
     Result<void> ParseShutdown(std::vector<std::string>&& args);
     Result<void> ParseSigstop(std::vector<std::string>&& args);
     Result<void> ParseSocket(std::vector<std::string>&& args);

From c4956b0e4ed9d5dc191fb279eeddc18e5d28189e Mon Sep 17 00:00:00 2001
From: Victor Hsieh <victorhsieh@google.com>
Date: Mon, 16 Dec 2024 10:58:32 -0800
Subject: [PATCH 1318/1487] Remove fsverity_init reference from init

Test: TH
Bug: 277916185
Change-Id: Ibdfe7c0b47a10a5412e962eb88320379b06c34d6
---
 rootdir/Android.bp | 1 -
 rootdir/init.rc    | 3 ---
 2 files changed, 4 deletions(-)

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index d3db2ff1f0f7..d5874cfc83b9 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -37,7 +37,6 @@ prebuilt_etc {
     src: "init.rc",
     sub_dir: "init/hw",
     required: [
-        "fsverity_init",
         "platform-bootclasspath",
         "init.boringssl.zygote64.rc",
         "init.boringssl.zygote64_32.rc",
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 957860f9c50b..883ed9c8cabb 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -620,9 +620,6 @@ on late-fs
     # HALs required before storage encryption can get unlocked (FBE)
     class_start early_hal
 
-    # Load trusted keys from dm-verity protected partitions
-    exec -- /system/bin/fsverity_init --load-verified-keys
-
 # Only enable the bootreceiver tracing instance for kernels 5.10 and above.
 on late-fs && property:ro.kernel.version=4.19
     setprop bootreceiver.enable 0

From 11beec4b4dc12ff2099374e06d4854940432ecf4 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Tue, 17 Dec 2024 14:22:56 -0800
Subject: [PATCH 1319/1487] Clarify 16kb page mode indication

This is about previous states of the device, emphasize it since it came up in a bug.

Change-Id: Ib264c4995a34abdae434403c831106de201110eb
---
 debuggerd/libdebuggerd/tombstone_proto_to_text.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
index 0474ae7a1105..11841b290d5f 100644
--- a/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
+++ b/debuggerd/libdebuggerd/tombstone_proto_to_text.cpp
@@ -594,7 +594,7 @@ bool tombstone_proto_to_text(const Tombstone& tombstone, CallbackType callback,
   if (tombstone.page_size() != 4096) {
     CBL("Page size: %d bytes", tombstone.page_size());
   } else if (tombstone.has_been_16kb_mode()) {
-    CBL("Has been in 16kb mode: yes");
+    CBL("Has been in 16 KB mode before: yes");
   }
 
   // Process header

From 08afd2159bddb1ab2a99143c56376bb81fea1a98 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Tue, 26 Nov 2024 11:12:14 -0800
Subject: [PATCH 1320/1487] vts_libsnapshot_test: Address flake in scratch
 metadata test.

Clean up a previous failed/interrupted test run before proceeding with
the test.

Bug: 377398696
Test: manual test
Change-Id: I7479ebc06bff6738597702a568ac66c2a2b7ab22
---
 fs_mgr/libsnapshot/scratch_super.cpp | 24 +++++++++++++++++-------
 fs_mgr/libsnapshot/snapshot_test.cpp |  1 +
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/fs_mgr/libsnapshot/scratch_super.cpp b/fs_mgr/libsnapshot/scratch_super.cpp
index 93c4bbd994d0..203690536854 100644
--- a/fs_mgr/libsnapshot/scratch_super.cpp
+++ b/fs_mgr/libsnapshot/scratch_super.cpp
@@ -25,6 +25,13 @@
 #include <sys/vfs.h>
 #include <unistd.h>
 
+#include <algorithm>
+#include <filesystem>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/macros.h>
@@ -41,12 +48,6 @@
 #include <fstab/fstab.h>
 #include <liblp/builder.h>
 #include <storage_literals/storage_literals.h>
-#include <algorithm>
-#include <filesystem>
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
 
 #include "device_info.h"
 #include "scratch_super.h"
@@ -60,9 +61,18 @@ namespace android {
 namespace snapshot {
 
 static bool UmountScratch() {
+    Fstab fstab;
+    if (!ReadFstabFromProcMounts(&fstab)) {
+        LOG(ERROR) << "Cannot read /proc/mounts";
+        return false;
+    }
+    if (GetEntryForMountPoint(&fstab, kOtaMetadataMount) == nullptr) {
+        return true;
+    }
+
     auto ota_dir = std::string(kOtaMetadataMount) + "/" + "ota";
-    std::error_code ec;
 
+    std::error_code ec;
     if (std::filesystem::remove_all(ota_dir, ec) == static_cast<std::uintmax_t>(-1)) {
         LOG(ERROR) << "Failed to remove OTA directory: " << ec.message();
         return false;
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 1a0d559792f1..8e62d935c06a 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -1345,6 +1345,7 @@ class SnapshotUpdateTest : public SnapshotTest {
 
 TEST_F(SnapshotUpdateTest, SuperOtaMetadataTest) {
     auto info = new TestDeviceInfo(fake_super);
+    ASSERT_TRUE(CleanupScratchOtaMetadataIfPresent(info));
     ASSERT_TRUE(CreateScratchOtaMetadataOnSuper(info));
     std::string scratch_device = GetScratchOtaMetadataPartition();
     ASSERT_NE(scratch_device, "");

From f39fe821b703abd5a675145c3366f333bdd4bd31 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Tue, 17 Dec 2024 13:47:04 -0800
Subject: [PATCH 1321/1487] Revert "Add adb-remount-sh to presubmit &
 kernel-presubmit group."

This test does not clean up remounts properly, and cause unittests to fail.

This reverts commit 3360d387d205ce3f89b311c20f25adbcec1bebbc.

Reason for revert: b/384756313

Change-Id: I8eccfdfe07b688bdd1e37cc858cbd9fbdd10dadc
---
 fs_mgr/TEST_MAPPING | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/fs_mgr/TEST_MAPPING b/fs_mgr/TEST_MAPPING
index 192232d6c4b0..32e8b88e1833 100644
--- a/fs_mgr/TEST_MAPPING
+++ b/fs_mgr/TEST_MAPPING
@@ -33,9 +33,6 @@
     }
   ],
   "kernel-presubmit": [
-    {
-      "name": "adb-remount-sh"
-    },
     {
       "name": "libdm_test"
     },

From 2f4e53e608101bc821c43dbbe5df7e0f292c6f46 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 10 Dec 2024 23:28:58 +0000
Subject: [PATCH 1322/1487] libprocessgroup: Add
 CgroupGetAttributePathForProcess and CgroupProcs attribute

ActivityManager monitors process forks with cgroup.procs in cgroup v2.
It currently generates its own paths to application cgroups, but v2
cgroup paths are owned by libprocessgroup. Those paths can change based
on build flags, so paths generated outside of libprocessgroup may not
always be correct.

Bug: 382693152
Bug: 381488882
Test: atest FrameworksMockingServicesTests:AppChildProcessTest
Test: atest CtsAppTestCases:ActivityManagerTest
Ignore-AOSP-first: Needed for framework changes which is run out of ag/
Change-Id: I005a114bf2610361098b7303a27dd7456eb469c8
Merged-In: I005a114bf2610361098b7303a27dd7456eb469c8
---
 .../include/processgroup/processgroup.h         |  2 ++
 libprocessgroup/processgroup.cpp                | 17 +++++++++++++++++
 libprocessgroup/profiles/task_profiles.json     |  5 +++++
 3 files changed, 24 insertions(+)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 28b17c1981ea..98179e88b8f2 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -32,6 +32,8 @@ bool CgroupGetAttributePath(const std::string& attr_name, std::string* path);
 // Provides the path for an attribute in a specific process group
 // Returns false in case of error, true in case of success
 bool CgroupGetAttributePathForTask(const std::string& attr_name, pid_t tid, std::string* path);
+bool CgroupGetAttributePathForProcess(std::string_view attr_name, uid_t uid, pid_t pid,
+                                      std::string &path);
 
 bool SetTaskProfiles(pid_t tid, const std::vector<std::string>& profiles,
                      bool use_fd_cache = false);
diff --git a/libprocessgroup/processgroup.cpp b/libprocessgroup/processgroup.cpp
index 53168e3e7069..f78fed0ef1ae 100644
--- a/libprocessgroup/processgroup.cpp
+++ b/libprocessgroup/processgroup.cpp
@@ -154,6 +154,23 @@ bool CgroupGetAttributePathForTask(const std::string& attr_name, pid_t tid, std:
     return true;
 }
 
+bool CgroupGetAttributePathForProcess(std::string_view attr_name, uid_t uid, pid_t pid,
+                                      std::string &path) {
+    const TaskProfiles& tp = TaskProfiles::GetInstance();
+    const IProfileAttribute* attr = tp.GetAttribute(attr_name);
+
+    if (attr == nullptr) {
+        return false;
+    }
+
+    if (!attr->GetPathForProcess(uid, pid, &path)) {
+        LOG(ERROR) << "Failed to find cgroup for uid " << uid << " pid " << pid;
+        return false;
+    }
+
+    return true;
+}
+
 bool UsePerAppMemcg() {
     bool low_ram_device = GetBoolProperty("ro.config.low_ram", false);
     return GetBoolProperty("ro.config.per_app_memcg", low_ram_device);
diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 28902efe807d..720cb304c8ba 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -81,6 +81,11 @@
       "Name": "FreezerState",
       "Controller": "freezer",
       "File": "cgroup.freeze"
+    },
+    {
+      "Name": "CgroupProcs",
+      "Controller": "cgroup2",
+      "File": "cgroup.procs"
     }
   ],
 

From c8a5c5792214cae8eb5b51b1b566f6553f856614 Mon Sep 17 00:00:00 2001
From: Fabien Sanglard <sanglardf@google.com>
Date: Wed, 18 Dec 2024 13:18:42 -0800
Subject: [PATCH 1323/1487] Add sanglardf as OWNER

Change-Id: I0c6e3bb37b36694abdf85450b748f07b4e6ef54a
---
 fastboot/OWNERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fastboot/OWNERS b/fastboot/OWNERS
index 3dec07e2d595..2444081f7a78 100644
--- a/fastboot/OWNERS
+++ b/fastboot/OWNERS
@@ -1,5 +1,6 @@
 dvander@google.com
 elsk@google.com
 enh@google.com
+sanglardf@google.com
 zhangkelvin@google.com
 

From 8f942fd4c6e010c3cfdbea0b067e9b30e4c2e809 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Fri, 13 Dec 2024 23:36:45 -0800
Subject: [PATCH 1324/1487] libsnapshot: Skip tests if update is in progress

Bug: 380992658
Test: vts_libsnapshot_test when update is in progress
Change-Id: Ib58ddcb9789b8502883a6b5322cae7dd7defdfbf
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshot_test.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 1a0d559792f1..544428475e60 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -3071,6 +3071,18 @@ int main(int argc, char** argv) {
     ::testing::AddGlobalTestEnvironment(new ::android::snapshot::SnapshotTestEnvironment());
     gflags::ParseCommandLineFlags(&argc, &argv, false);
 
+    // During incremental flashing, snapshot updates are in progress.
+    //
+    // When snapshot update is in-progress, snapuserd daemon
+    // will be up and running. These tests will start and stop the daemon
+    // thereby interfering with the update and snapshot-merge progress.
+    // Hence, wait until the update is complete.
+    auto sm = android::snapshot::SnapshotManager::New();
+    while (sm->IsUserspaceSnapshotUpdateInProgress()) {
+        LOG(INFO) << "Snapshot update is in progress. Waiting...";
+        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    }
+
     bool vab_legacy = false;
     if (FLAGS_force_mode == "vab-legacy") {
         vab_legacy = true;

From 3f81c491d325c1f2be337a2cdc56b418ec686fcb Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 20 Dec 2024 07:12:18 -0800
Subject: [PATCH 1325/1487] Clarify what this file is used for.

(And also "who does what", even if we can't say that in a way the computers understand.)

Change-Id: Ieaed05ecb241d764335f27db97fe382e6e674eee
---
 janitors/OWNERS | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/janitors/OWNERS b/janitors/OWNERS
index c25d9e465b0b..b3171515155a 100644
--- a/janitors/OWNERS
+++ b/janitors/OWNERS
@@ -1,7 +1,19 @@
-# OWNERS file for projects that don't really have owners so much as volunteer janitors.
+# go/android-3p requires that all external projects have the "janitors" in
+# their OWNERS files.
+
+# These are also the "owners" for projects that don't really have owners
+# so much as volunteer janitors.
+
+# General maintenance.
+sadafebrahimi@google.com
+
+# C/C++.
 ccross@google.com
 cferris@google.com
-dwillemsen@google.com
 enh@google.com
+
+# Java.
 maco@google.com
-sadafebrahimi@google.com
+
+# Python.
+dwillemsen@google.com

From a7efb2362029ea51dd83a6f159cb2b229d31a001 Mon Sep 17 00:00:00 2001
From: Ryan Prichard <rprichard@google.com>
Date: Fri, 20 Dec 2024 14:01:38 -0800
Subject: [PATCH 1326/1487] Declare main outside of extern "C" block

The C++ standard doesn't allow a linkage-specification for main,
https://eel.is/c++draft/basic.start.main#3.sentence-5:

"The main function shall not be declared with a linkage-specification
([dcl.link])."

Bug: http://b/379133546
Test: treehugger
Change-Id: I0a6809b9671089fad24094e903edbb7a6704fbca
---
 debuggerd/crasher/crasher.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/debuggerd/crasher/crasher.cpp b/debuggerd/crasher/crasher.cpp
index 05143ed05530..c3dd92b43c2f 100644
--- a/debuggerd/crasher/crasher.cpp
+++ b/debuggerd/crasher/crasher.cpp
@@ -402,6 +402,8 @@ noinline int do_action(const char* arg) {
     return EXIT_SUCCESS;
 }
 
+}  // extern "C"
+
 int main(int argc, char** argv) {
 #if defined(STATIC_CRASHER)
     debuggerd_callbacks_t callbacks = {
@@ -427,5 +429,3 @@ int main(int argc, char** argv) {
 
     return usage();
 }
-
-};

From 5d4c19be4326e9c1c8f89381adc1e92157690605 Mon Sep 17 00:00:00 2001
From: Alessio Balsini <balsini@google.com>
Date: Wed, 11 Dec 2024 12:23:42 +0000
Subject: [PATCH 1327/1487] Non-root access to /proc/allocinfo

Change group and permissions to the /proc/allocinfo file, so that the
file is readable from non-root.

Bug: 384777823
Test: adb shell dumpstate
Change-Id: Icf5331cb68e4b706d4eaf11ee2576234c2d7789f
Signed-off-by: Alessio Balsini <balsini@google.com>
---
 rootdir/init.rc | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 883ed9c8cabb..f1670ae04a33 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -569,6 +569,9 @@ on post-fs
     chown root log /proc/vmallocinfo
     chmod 0440 /proc/vmallocinfo
 
+    chown root log /proc/allocinfo
+    chmod 0440 /proc/allocinfo
+
     chown root log /proc/slabinfo
     chmod 0440 /proc/slabinfo
 

From 419269b8f1f4b3dd9929fc959fc3fdd7aab4f0b1 Mon Sep 17 00:00:00 2001
From: Jack Chen <zenghuchen@google.com>
Date: Fri, 20 Dec 2024 13:29:17 -0800
Subject: [PATCH 1328/1487] init: Supplement description to property action
 usage

Early set properties in DT or over the command-lines do not trigger
property-change events until boot stage.

Bug: 383738769
Test: After changing the action command line to tie to `early-boot`
event, the action is triggered earlier
Signed-off-by: Jack Chen <zenghuchen@google.com>
Merged-In: I000fcbf09f35cbaccc7517a3962fa4889b1d90be
Change-Id: I000fcbf09f35cbaccc7517a3962fa4889b1d90be
---
 init/README.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/init/README.md b/init/README.md
index 653dadd34c0e..251fe987964a 100644
--- a/init/README.md
+++ b/init/README.md
@@ -486,6 +486,12 @@ at three times:
    2. Any time that property a transitions to value b, while property c already equals d.
    3. Any time that property c transitions to value d, while property a already equals b.
 
+Note that, for bootloader-provided properties (ro.boot.*), their action cannot be
+auto-triggered until `boot` stage. If they need to be triggered earlier, like at `early-boot`
+stage, they should be tied to the `event`. For example:
+
+`on early-boot && property:a=b`.
+
 
 Trigger Sequence
 ----------------

From f97da3c6a8e0e7cb0dc8a03640aa99bfcdf34ea7 Mon Sep 17 00:00:00 2001
From: Elliot Berman <elliot.berman@oss.qualcomm.com>
Date: Mon, 30 Dec 2024 15:38:03 -0800
Subject: [PATCH 1329/1487] Add fs_config entry for first_stage.sh

First stage init will not run first_stage.sh if it's not executable,
even if androidboot.first_stage_init=1. If mkbootfs is used to package
the ramdisk, this results in a ramdisk with a first_stage.sh that isn't
executable. Add default entry for first_stage.sh with executable bits
set.

Bug: 386837572
Change-Id: Ic7f50141cca678003177252dc760d06c39f91e80
Signed-off-by: Elliot Berman <elliot.berman@oss.qualcomm.com>
---
 libcutils/fs_config.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libcutils/fs_config.cpp b/libcutils/fs_config.cpp
index 2e4b9b475df4..00a111439105 100644
--- a/libcutils/fs_config.cpp
+++ b/libcutils/fs_config.cpp
@@ -205,6 +205,7 @@ static const struct fs_path_config android_files[] = {
     { 00755, AID_ROOT,      AID_ROOT,      0, "first_stage_ramdisk/system/bin/fsck.f2fs" },
     // generic defaults
     { 00755, AID_ROOT,      AID_ROOT,      0, "bin/*" },
+    { 00755, AID_ROOT,      AID_ROOT,      0, "first_stage.sh"},
     { 00640, AID_ROOT,      AID_SHELL,     0, "fstab.*" },
     { 00750, AID_ROOT,      AID_SHELL,     0, "init*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "*.rc" },

From fb9e1c4554d7869995a1c197eb3ee60a0db3d025 Mon Sep 17 00:00:00 2001
From: Lee Shombert <shombert@google.com>
Date: Thu, 2 Jan 2025 12:33:21 -0800
Subject: [PATCH 1330/1487] Increase sysprop timeout

Change the sysprop socket timeout from 2000ms to 5000ms.  This has no
effect when there are no timeouts.  However, this improves reliability
in lower-end systems are under heavy system load.

This has no effect on sysprop errors that are not timeouts.  In
particular, it does not affect the timing when there are permission
errors or attempts to update a read-only property (both of these
errors are seen quite frequently in logs).

Flag: EXEMPT bug-fix
Bug: 383751329
Test: presubmit
Change-Id: Ibc70db1f6c565e0a8651d9026854d66db36418dd
---
 init/property_service.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/property_service.cpp b/init/property_service.cpp
index f2606e3c5888..31af94e590c5 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -595,7 +595,7 @@ uint32_t HandlePropertySetNoSocket(const std::string& name, const std::string& v
 }
 
 static void handle_property_set_fd(int fd) {
-    static constexpr uint32_t kDefaultSocketTimeout = 2000; /* ms */
+    static constexpr uint32_t kDefaultSocketTimeout = 5000; /* ms */
 
     int s = accept4(fd, nullptr, nullptr, SOCK_CLOEXEC);
     if (s == -1) {

From eae40347755b0b7bc9628416e93c7c1c358179a9 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 2 Jan 2025 21:19:33 +0000
Subject: [PATCH 1331/1487] vts_libprocessgroup: Add vts_libprocessgroup

Test kernel UAPI surrounding memory control groups version 2. These are
not accessible to normal apps but can be used by Android native
libraries in some configurations.

Bug: 331795334
Bug: 384285412
Test: atest vts_libprocessgroup (with and without -extra_kernel_cmdline cgroup_disable=memory)
Change-Id: Ic08649f3d39bbce0fd93da1767250a88f2501ef9
---
 libprocessgroup/vts/Android.bp              |  15 ++
 libprocessgroup/vts/vts_libprocessgroup.cpp | 175 ++++++++++++++++++++
 2 files changed, 190 insertions(+)
 create mode 100644 libprocessgroup/vts/Android.bp
 create mode 100644 libprocessgroup/vts/vts_libprocessgroup.cpp

diff --git a/libprocessgroup/vts/Android.bp b/libprocessgroup/vts/Android.bp
new file mode 100644
index 000000000000..1ec49a45fc7a
--- /dev/null
+++ b/libprocessgroup/vts/Android.bp
@@ -0,0 +1,15 @@
+package {
+    default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+cc_test {
+    name: "vts_libprocessgroup",
+    srcs: ["vts_libprocessgroup.cpp"],
+    shared_libs: ["libbase"],
+    static_libs: ["libgmock"],
+    require_root: true,
+    test_suites: [
+        "general-tests",
+        "vts",
+    ],
+}
diff --git a/libprocessgroup/vts/vts_libprocessgroup.cpp b/libprocessgroup/vts/vts_libprocessgroup.cpp
new file mode 100644
index 000000000000..af0b0afe3749
--- /dev/null
+++ b/libprocessgroup/vts/vts_libprocessgroup.cpp
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2025 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 <cerrno>
+#include <chrono>
+#include <cstdio>
+#include <filesystem>
+#include <future>
+#include <iostream>
+#include <optional>
+#include <random>
+#include <string>
+#include <vector>
+
+#include <unistd.h>
+
+#include <android-base/file.h>
+#include <android-base/strings.h>
+using android::base::ReadFileToString;
+using android::base::Split;
+using android::base::WriteStringToFile;
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+namespace {
+
+const std::string CGROUP_V2_ROOT_PATH = "/sys/fs/cgroup";
+
+std::optional<bool> isMemcgV2Enabled() {
+    if (std::string proc_cgroups; ReadFileToString("/proc/cgroups", &proc_cgroups)) {
+        const std::vector<std::string> lines = Split(proc_cgroups, "\n");
+        for (const std::string& line : lines) {
+            if (line.starts_with("memory")) {
+                const bool enabled = line.back() == '1';
+                if (!enabled) return false;
+
+                const std::vector<std::string> memcg_tokens = Split(line, "\t");
+                return memcg_tokens[1] == "0";  // 0 == default hierarchy == v2
+            }
+        }
+        // We know for sure it's not enabled, either because it is mounted as v1 (cgroups.json
+        // override) which would be detected above, or because it was intentionally disabled via
+        // kernel command line (cgroup_disable=memory), or because it's not built in to the kernel
+        // (CONFIG_MEMCG is not set).
+        return false;
+    }
+
+    // Problems accessing /proc/cgroups (sepolicy?) Try checking the root cgroup.controllers file.
+    perror("Warning: Could not read /proc/cgroups");
+    if (std::string controllers;
+        ReadFileToString(CGROUP_V2_ROOT_PATH + "/cgroup.controllers", &controllers)) {
+        return controllers.find("memory") != std::string::npos;
+    }
+
+    std::cerr << "Error: Could not read " << CGROUP_V2_ROOT_PATH
+              << "/cgroup.controllers: " << std::strerror(errno) << std::endl;
+    return std::nullopt;
+}
+
+std::optional<bool> checkRootSubtreeState() {
+    if (std::string controllers;
+        ReadFileToString(CGROUP_V2_ROOT_PATH + "/cgroup.subtree_control", &controllers)) {
+        return controllers.find("memory") != std::string::npos;
+    }
+    std::cerr << "Error: Could not read " << CGROUP_V2_ROOT_PATH
+              << "/cgroup.subtree_control: " << std::strerror(errno) << std::endl;
+    return std::nullopt;
+}
+
+}  // anonymous namespace
+
+
+class MemcgV2Test : public testing::Test {
+  protected:
+    void SetUp() override {
+        std::optional<bool> memcgV2Enabled = isMemcgV2Enabled();
+        ASSERT_NE(memcgV2Enabled, std::nullopt);
+        if (!*memcgV2Enabled) GTEST_SKIP() << "Memcg v2 not enabled";
+    }
+};
+
+class MemcgV2SubdirTest : public testing::Test {
+  protected:
+    std::optional<std::string> mRandDir;
+
+    void SetUp() override {
+        std::optional<bool> memcgV2Enabled = isMemcgV2Enabled();
+        ASSERT_NE(memcgV2Enabled, std::nullopt);
+        if (!*memcgV2Enabled) GTEST_SKIP() << "Memcg v2 not enabled";
+
+        mRootSubtreeState = checkRootSubtreeState();
+        ASSERT_NE(mRootSubtreeState, std::nullopt);
+
+        if (!*mRootSubtreeState) {
+            ASSERT_TRUE(
+                    WriteStringToFile("+memory", CGROUP_V2_ROOT_PATH + "/cgroup.subtree_control"))
+                    << "Could not enable memcg under root: " << std::strerror(errno);
+        }
+
+        // Make a new, temporary, randomly-named v2 cgroup in which we will attempt to activate
+        // memcg
+        std::random_device rd;
+        std::uniform_int_distribution dist(static_cast<int>('A'), static_cast<int>('Z'));
+        std::string randName = CGROUP_V2_ROOT_PATH + "/vts_libprocessgroup.";
+        for (int i = 0; i < 10; ++i) randName.append(1, static_cast<char>(dist(rd)));
+        ASSERT_TRUE(std::filesystem::create_directory(randName));
+        mRandDir = randName;  // For cleanup in TearDown
+
+        std::string subtree_controllers;
+        ASSERT_TRUE(ReadFileToString(*mRandDir + "/cgroup.controllers", &subtree_controllers));
+        ASSERT_NE(subtree_controllers.find("memory"), std::string::npos)
+                << "Memcg was not activated in child cgroup";
+    }
+
+    void TearDown() override {
+        if (mRandDir) {
+            if (!std::filesystem::remove(*mRandDir)) {
+                std::cerr << "Could not remove temporary memcg v2 test directory" << std::endl;
+            }
+        }
+
+        if (!*mRootSubtreeState) {
+            if (!WriteStringToFile("-memory", CGROUP_V2_ROOT_PATH + "/cgroup.subtree_control")) {
+                std::cerr << "Could not disable memcg under root: " << std::strerror(errno)
+                          << std::endl;
+            }
+        }
+    }
+
+  private:
+    std::optional<bool> mRootSubtreeState;
+};
+
+
+TEST_F(MemcgV2SubdirTest, CanActivateMemcgV2Subtree) {
+    ASSERT_TRUE(WriteStringToFile("+memory", *mRandDir + "/cgroup.subtree_control"))
+            << "Could not enable memcg under child cgroup subtree";
+}
+
+// Test for fix: mm: memcg: use larger batches for proactive reclaim
+// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=287d5fedb377ddc232b216b882723305b27ae31a
+TEST_F(MemcgV2Test, ProactiveReclaimDoesntTakeForever) {
+    // Not all kernels have memory.reclaim
+    const std::filesystem::path reclaim(CGROUP_V2_ROOT_PATH + "/memory.reclaim");
+    if (!std::filesystem::exists(reclaim)) GTEST_SKIP() << "memory.reclaim not found";
+
+    // Use the total device memory as the amount to reclaim
+    const long numPages = sysconf(_SC_PHYS_PAGES);
+    const long pageSize = sysconf(_SC_PAGE_SIZE);
+    ASSERT_GT(numPages, 0);
+    ASSERT_GT(pageSize, 0);
+    const unsigned long long totalMem =
+            static_cast<unsigned long long>(numPages) * static_cast<unsigned long long>(pageSize);
+
+    auto fut = std::async(std::launch::async,
+                          [&]() { WriteStringToFile(std::to_string(totalMem), reclaim); });
+
+    // This is a test for completion within the timeout. The command is likely to "fail" since we
+    // are asking to reclaim all device memory.
+    ASSERT_NE(fut.wait_for(std::chrono::seconds(20)), std::future_status::timeout);
+}

From 2170b7cd7f45a779d3b7be389bbe4d12997c1fc8 Mon Sep 17 00:00:00 2001
From: Karuna Wadhera <kwadhera@google.com>
Date: Sat, 28 Dec 2024 00:33:55 +0000
Subject: [PATCH 1332/1487] Run module code only after KeyMints receive module
 info

In order to prevent updateable APEX modules from interfering in module
measurement, have `perform_apex_config` wait for the new system
property `keystore.module_hash.sent` to be set to true before running.
Keystore sets `keystore.module_hash.sent` to true after receiving a
non-error response to `setAdditionalAttestationInfo` from all V4+
KeyMints.

Since Keystore waits for `apexd.status` to be set to
`activated` (before calling `setAdditionalAttestationInfo`),
`perform_apex_config` no longer needs to (once flagging is removed).

Note that boot will hang if sending module info fails (as we'll be stuck
on the wait). Preventing boot from continuing is an intended consequence
- an error here likely indicates a more general issue with Keystore or
  KeyMint (and one that likely isn't specific to an individual device).

Bug: 369375199
Test: Manual (boots)
Change-Id: Id67c674643762b1fdbba42a407c21756a78ea18d
---
 rootdir/init.rc | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index f1670ae04a33..0b45e73c77b1 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -995,8 +995,11 @@ on post-fs-data
     mkdir /data/misc/stats-service/ 0770 statsd system
     mkdir /data/misc/train-info/ 0770 statsd system
 
-    # Wait for apexd to finish activating APEXes before starting more processes.
+    # TODO(b/369375199): Remove once attest modules flagging is removed.
     wait_for_prop apexd.status activated
+    # Wait for KeyMints to receive APEX module info before starting code from updateable APEXes.
+    # This is to prevent APEX modules from interfering in module measurement.
+    wait_for_prop keystore.module_hash.sent true
     perform_apex_config
 
     exec_start system_aconfigd_mainline_init

From 2dac5d89a0f024a2d0cc46a80ba4ee13472f1681 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Fri, 3 Jan 2025 18:13:46 +0000
Subject: [PATCH 1333/1487] libprocessgroup: Remove
 PRODUCT_MEMCG_V2_FORCE_ENABLED

Commit f8901767e ("Add build flag to force memcg to the v2 cgroup
hierarchy") added the ability to ignore cgroups.json for the memory
controller, and force it to v2 when the PRODUCT_MEMCG_V2_FORCE_ENABLED
build flag is true. However the memory controller is now v2 by default
since commit 5fa48a84b ("libprocessgroup: memcg default version 1 -> 2")
so this build flag is no longer needed.

Bug: 327480673
Bug: 377579705
Change-Id: I46f45a44c01b2244eed2232ac091ef20c42cac41
---
 libprocessgroup/Android.bp                 |  6 ---
 libprocessgroup/build_flags.h              |  8 ----
 libprocessgroup/setup/cgroup_map_write.cpp | 47 ----------------------
 libprocessgroup/util/Android.bp            |  2 +-
 libprocessgroup/util/util.cpp              | 19 ---------
 5 files changed, 1 insertion(+), 81 deletions(-)

diff --git a/libprocessgroup/Android.bp b/libprocessgroup/Android.bp
index 1e76e766fc42..6725acc8db55 100644
--- a/libprocessgroup/Android.bp
+++ b/libprocessgroup/Android.bp
@@ -7,7 +7,6 @@ soong_config_module_type {
     module_type: "cc_defaults",
     config_namespace: "ANDROID",
     bool_variables: [
-        "memcg_v2_force_enabled",
         "cgroup_v2_sys_app_isolation",
     ],
     properties: [
@@ -19,11 +18,6 @@ libprocessgroup_flag_aware_cc_defaults {
     name: "libprocessgroup_build_flags_cc",
     cpp_std: "gnu++23",
     soong_config_variables: {
-        memcg_v2_force_enabled: {
-            cflags: [
-                "-DMEMCG_V2_FORCE_ENABLED=true",
-            ],
-        },
         cgroup_v2_sys_app_isolation: {
             cflags: [
                 "-DCGROUP_V2_SYS_APP_ISOLATION=true",
diff --git a/libprocessgroup/build_flags.h b/libprocessgroup/build_flags.h
index bc3e7dff178f..d0948c35ecac 100644
--- a/libprocessgroup/build_flags.h
+++ b/libprocessgroup/build_flags.h
@@ -16,20 +16,12 @@
 
 #pragma once
 
-#ifndef MEMCG_V2_FORCE_ENABLED
-#define MEMCG_V2_FORCE_ENABLED false
-#endif
-
 #ifndef CGROUP_V2_SYS_APP_ISOLATION
 #define CGROUP_V2_SYS_APP_ISOLATION false
 #endif
 
 namespace android::libprocessgroup_flags {
 
-inline consteval bool force_memcg_v2() {
-    return MEMCG_V2_FORCE_ENABLED;
-}
-
 inline consteval bool cgroup_v2_sys_app_isolation() {
     return CGROUP_V2_SYS_APP_ISOLATION;
 }
diff --git a/libprocessgroup/setup/cgroup_map_write.cpp b/libprocessgroup/setup/cgroup_map_write.cpp
index c4e1fb68044e..0d1739e99437 100644
--- a/libprocessgroup/setup/cgroup_map_write.cpp
+++ b/libprocessgroup/setup/cgroup_map_write.cpp
@@ -27,9 +27,6 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-#include <optional>
-
-#include <android-base/file.h>
 #include <android-base/logging.h>
 #include <processgroup/cgroup_descriptor.h>
 #include <processgroup/processgroup.h>
@@ -260,39 +257,6 @@ void CgroupDescriptor::set_mounted(bool mounted) {
     controller_.set_flags(flags);
 }
 
-static std::optional<bool> MGLRUDisabled() {
-    const std::string file_name = "/sys/kernel/mm/lru_gen/enabled";
-    std::string content;
-    if (!android::base::ReadFileToString(file_name, &content)) {
-        PLOG(ERROR) << "Failed to read MGLRU state from " << file_name;
-        return {};
-    }
-
-    return content == "0x0000";
-}
-
-static std::optional<bool> MEMCGDisabled(const CgroupDescriptorMap& descriptors) {
-    std::string cgroup_v2_root = CGROUP_V2_ROOT_DEFAULT;
-    const auto it = descriptors.find(CGROUPV2_HIERARCHY_NAME);
-    if (it == descriptors.end()) {
-        LOG(WARNING) << "No Cgroups2 path found in cgroups.json. Vendor has modified Android, and "
-                     << "kernel memory use will be higher than intended.";
-    } else if (it->second.controller()->path() != cgroup_v2_root) {
-        cgroup_v2_root = it->second.controller()->path();
-    }
-
-    const std::string file_name = cgroup_v2_root + "/cgroup.controllers";
-    std::string content;
-    if (!android::base::ReadFileToString(file_name, &content)) {
-        PLOG(ERROR) << "Failed to read cgroup controllers from " << file_name;
-        return {};
-    }
-
-    // If we've forced memcg to v2 and it's not available, then it could only have been disabled
-    // on the kernel command line (GKI sets CONFIG_MEMCG).
-    return content.find("memory") == std::string::npos;
-}
-
 static bool CreateV2SubHierarchy(const std::string& path, const CgroupDescriptorMap& descriptors) {
     const auto cgv2_iter = descriptors.find(CGROUPV2_HIERARCHY_NAME);
     if (cgv2_iter == descriptors.end()) return false;
@@ -335,17 +299,6 @@ bool CgroupSetup() {
         }
     }
 
-    if (android::libprocessgroup_flags::force_memcg_v2()) {
-        if (MGLRUDisabled().value_or(false)) {
-            LOG(WARNING) << "Memcg forced to v2 hierarchy with MGLRU disabled! "
-                         << "Global reclaim performance will suffer.";
-        }
-        if (MEMCGDisabled(descriptors).value_or(false)) {
-            LOG(WARNING) << "Memcg forced to v2 hierarchy while memcg is disabled by kernel "
-                         << "command line!";
-        }
-    }
-
     // System / app isolation.
     // This really belongs in early-init in init.rc, but we cannot use the flag there.
     if (android::libprocessgroup_flags::cgroup_v2_sys_app_isolation()) {
diff --git a/libprocessgroup/util/Android.bp b/libprocessgroup/util/Android.bp
index 1c74d4ed52e1..266a53f1e49b 100644
--- a/libprocessgroup/util/Android.bp
+++ b/libprocessgroup/util/Android.bp
@@ -21,6 +21,7 @@ package {
 
 cc_library_static {
     name: "libprocessgroup_util",
+    cpp_std: "gnu++23",
     vendor_available: true,
     product_available: true,
     ramdisk_available: true,
@@ -47,7 +48,6 @@ cc_library_static {
     static_libs: [
         "libjsoncpp",
     ],
-    defaults: ["libprocessgroup_build_flags_cc"],
 }
 
 cc_test {
diff --git a/libprocessgroup/util/util.cpp b/libprocessgroup/util/util.cpp
index 14016751c77b..c772bc5e4982 100644
--- a/libprocessgroup/util/util.cpp
+++ b/libprocessgroup/util/util.cpp
@@ -111,7 +111,6 @@ void MergeCgroupToDescriptors(CgroupDescriptorMap* descriptors, const Json::Valu
 }
 
 bool ReadDescriptorsFromFile(const std::string& file_name, CgroupDescriptorMap* descriptors) {
-    static constexpr bool force_memcg_v2 = android::libprocessgroup_flags::force_memcg_v2();
     std::vector<CgroupDescriptor> result;
     std::string json_doc;
 
@@ -133,14 +132,10 @@ bool ReadDescriptorsFromFile(const std::string& file_name, CgroupDescriptorMap*
         const Json::Value& cgroups = root["Cgroups"];
         for (Json::Value::ArrayIndex i = 0; i < cgroups.size(); ++i) {
             std::string name = cgroups[i]["Controller"].asString();
-
-            if (force_memcg_v2 && name == "memory") continue;
-
             MergeCgroupToDescriptors(descriptors, cgroups[i], name, "", 1);
         }
     }
 
-    bool memcgv2_present = false;
     std::string root_path;
     if (root.isMember("Cgroups2")) {
         const Json::Value& cgroups2 = root["Cgroups2"];
@@ -150,24 +145,10 @@ bool ReadDescriptorsFromFile(const std::string& file_name, CgroupDescriptorMap*
         const Json::Value& childGroups = cgroups2["Controllers"];
         for (Json::Value::ArrayIndex i = 0; i < childGroups.size(); ++i) {
             std::string name = childGroups[i]["Controller"].asString();
-
-            if (force_memcg_v2 && name == "memory") memcgv2_present = true;
-
             MergeCgroupToDescriptors(descriptors, childGroups[i], name, root_path, 2);
         }
     }
 
-    if (force_memcg_v2 && !memcgv2_present) {
-        LOG(INFO) << "Forcing memcg to v2 hierarchy";
-        Json::Value memcgv2;
-        memcgv2["Controller"] = "memory";
-        memcgv2["NeedsActivation"] = true;
-        memcgv2["Path"] = ".";
-        memcgv2["Optional"] = true;  // In case of cgroup_disabled=memory, so we can still boot
-        MergeCgroupToDescriptors(descriptors, memcgv2, "memory",
-                                 root_path.empty() ? CGROUP_V2_ROOT_DEFAULT : root_path, 2);
-    }
-
     return true;
 }
 

From 645e51208688f95004b647e45345d3ea5dd26126 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Fri, 3 Jan 2025 21:28:58 +0000
Subject: [PATCH 1334/1487] CtsInitTestCases: additional debug info in failure

Likely race, but not reproing locally, so adding debug info we can
see in the infra what the issue is.

Bug: 379469103
Test: atest CtsInitTestCases
Change-Id: Ie30a1b7d4458edac41f75bdd42084efd6af52939
---
 init/oneshot_on_test.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/init/oneshot_on_test.cpp b/init/oneshot_on_test.cpp
index 650f0650b249..b039ac233740 100644
--- a/init/oneshot_on_test.cpp
+++ b/init/oneshot_on_test.cpp
@@ -39,11 +39,13 @@ TEST(init, oneshot_on) {
 
     // Bootanim exits quickly when the device is fully booted, so check that it goes back to the
     // 'restarting' state that non-oneshot services enter once they've restarted.
-    EXPECT_TRUE(WaitForProperty("init.svc.bootanim", "restarting", 10s));
+    EXPECT_TRUE(WaitForProperty("init.svc.bootanim", "restarting", 10s))
+            << "Value is: " << GetProperty("init.svc.bootanim", "");
 
     SetProperty("ctl.oneshot_on", "bootanim");
     SetProperty("ctl.start", "bootanim");
 
     // Now that oneshot is enabled again, bootanim should transition into the 'stopped' state.
-    EXPECT_TRUE(WaitForProperty("init.svc.bootanim", "stopped", 10s));
+    EXPECT_TRUE(WaitForProperty("init.svc.bootanim", "stopped", 10s))
+            << "Value is: " << GetProperty("init.svc.bootanim", "");
 }

From 52e5252fc9a951315bf435db2163b8415b831749 Mon Sep 17 00:00:00 2001
From: Orlando Arbildo <oarbildo@google.com>
Date: Sat, 21 Dec 2024 00:12:33 +0000
Subject: [PATCH 1335/1487] trusty: utils: rpmb_dev: modify wv secure storage
 init.rc

Changing property name for widevine VM apex property to use
the current widevine apex.

Bug: 371777025
Test: aosp build/trusty VM test
Change-Id: I07ec9026767a66abbc280571413be398d875ffe7
---
 trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc | 17 ++---------------
 1 file changed, 2 insertions(+), 15 deletions(-)

diff --git a/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc b/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
index 003b6fe6501b..4e42d46be568 100644
--- a/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
+++ b/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
@@ -1,5 +1,5 @@
 service storageproxyd_wv_system /system_ext/bin/storageproxyd.system \
-        -d ${storageproxyd_wv_system.trusty_ipc_dev:-/dev/trusty-ipc-dev0} \
+        -d VSOCK:${trusty.widevine_vm.vm_cid}:1 \
         -r /dev/socket/rpmb_mock_wv_system \
         -p /data/secure_storage_wv_system \
         -t sock
@@ -23,20 +23,8 @@ service rpmb_mock_wv_system /system_ext/bin/rpmb_dev.wv.system \
     group system
     socket rpmb_mock_wv_system stream 660 system system
 
-# storageproxyd
-on boot && \
-    property:trusty.widevine_vm.nonsecure_vm_ready=1 && \
-    property:storageproxyd_wv_system.trusty_ipc_dev=*
-    wait /dev/socket/rpmb_mock_wv_system
-    enable storageproxyd_wv_system
-
-
 # RPMB Mock
-on early-boot && \
-    property:trusty.widevine_vm.enabled=1 && \
-    property:trusty.widevine_vm.vm_cid=* && \
-    property:ro.boot.vendor.apex.com.android.services.widevine=\
-com.android.services.widevine.cf_guest_trusty_nonsecure
+on early-boot
     # Create a persistent location for the RPMB data
     # (work around lack of RPMb block device on CF).
     # file contexts secure_storage_rpmb_system_file
@@ -57,6 +45,5 @@ com.android.services.widevine.cf_guest_trusty_nonsecure
     symlink /mnt/secure_storage_persist_wv_system/persist \
             /data/secure_storage_wv_system/persist
     chown root system /data/secure_storage_wv_system/persist
-    setprop storageproxyd_wv_system.trusty_ipc_dev VSOCK:${trusty.widevine_vm.vm_cid}:1
     exec_start rpmb_mock_init_wv_system
     start rpmb_mock_wv_system

From ba18f501c8de34111343e695c855dc074c37db08 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Mon, 6 Jan 2025 21:47:45 +0000
Subject: [PATCH 1336/1487] libprocessgroup: Better error checking for string
 -> int conversion

There are a few calls to strtol which don't check errno for conversion
failures. android::base::ParseInt does a better job with the error
checking so switch over to that from readLong.

Change-Id: I812922bf16414608ff226b45b147a9ec3213d01e
---
 libprocessgroup/task_profiles.cpp | 34 +++++++++++--------------------
 1 file changed, 12 insertions(+), 22 deletions(-)

diff --git a/libprocessgroup/task_profiles.cpp b/libprocessgroup/task_profiles.cpp
index c03c25727f35..89ca7f1b4e94 100644
--- a/libprocessgroup/task_profiles.cpp
+++ b/libprocessgroup/task_profiles.cpp
@@ -20,7 +20,6 @@
 #include <task_profiles.h>
 
 #include <map>
-#include <optional>
 #include <string>
 
 #include <dirent.h>
@@ -31,6 +30,7 @@
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include <android-base/parseint.h>
 #include <android-base/properties.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
@@ -121,15 +121,6 @@ bool FdCacheHelper::IsAppDependentPath(const std::string& path) {
     return path.find("<uid>", 0) != std::string::npos || path.find("<pid>", 0) != std::string::npos;
 }
 
-std::optional<long> readLong(const std::string& str) {
-    char* end;
-    const long result = strtol(str.c_str(), &end, 10);
-    if (end > str.c_str()) {
-        return result;
-    }
-    return std::nullopt;
-}
-
 }  // namespace
 
 IProfileAttribute::~IProfileAttribute() = default;
@@ -930,9 +921,8 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                 }
             } else if (action_name == "SetTimerSlack") {
                 const std::string slack_string = params_val["Slack"].asString();
-                std::optional<long> slack = readLong(slack_string);
-                if (slack && *slack >= 0) {
-                    profile->Add(std::make_unique<SetTimerSlackAction>(*slack));
+                if (long slack; android::base::ParseInt(slack_string, &slack) && slack >= 0) {
+                    profile->Add(std::make_unique<SetTimerSlackAction>(slack));
                 } else {
                     LOG(WARNING) << "SetTimerSlack: invalid parameter: " << slack_string;
                 }
@@ -994,18 +984,17 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                         // to setpriority(), since the sched_priority value must be 0 for calls to
                         // sched_setscheduler() with "normal" policies.
                         const std::string nice_string = params_val["Nice"].asString();
-                        const std::optional<int> nice = readLong(nice_string);
-
-                        if (!nice) {
+                        int nice;
+                        if (!android::base::ParseInt(nice_string, &nice)) {
                             LOG(FATAL) << "Invalid nice value specified: " << nice_string;
                         }
                         const int LINUX_MIN_NICE = -20;
                         const int LINUX_MAX_NICE = 19;
-                        if (*nice < LINUX_MIN_NICE || *nice > LINUX_MAX_NICE) {
-                            LOG(WARNING) << "SetSchedulerPolicy: Provided nice (" << *nice
+                        if (nice < LINUX_MIN_NICE || nice > LINUX_MAX_NICE) {
+                            LOG(WARNING) << "SetSchedulerPolicy: Provided nice (" << nice
                                          << ") appears out of range.";
                         }
-                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy, *nice));
+                        profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy, nice));
                     } else {
                         profile->Add(std::make_unique<SetSchedulerPolicyAction>(policy));
                     }
@@ -1020,10 +1009,11 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
                     // [sched_get_priority_min(), sched_get_priority_max()]
 
                     const std::string priority_string = params_val["Priority"].asString();
-                    std::optional<long> virtual_priority = readLong(priority_string);
-                    if (virtual_priority && *virtual_priority > 0) {
+                    if (long virtual_priority;
+                        android::base::ParseInt(priority_string, &virtual_priority) &&
+                        virtual_priority > 0) {
                         int priority;
-                        if (SetSchedulerPolicyAction::toPriority(policy, *virtual_priority,
+                        if (SetSchedulerPolicyAction::toPriority(policy, virtual_priority,
                                                                  priority)) {
                             profile->Add(
                                     std::make_unique<SetSchedulerPolicyAction>(policy, priority));

From b1da9dc655caf1a70f8f0244404207c8ec491ed4 Mon Sep 17 00:00:00 2001
From: "Priyanka Advani (xWF)" <padvani@google.com>
Date: Mon, 6 Jan 2025 14:21:38 -0800
Subject: [PATCH 1337/1487] Revert "Run module code only after KeyMints receive
 module info"

Reason for revert: Droidmonitor created revert due to b/388085199. Will be verifying through ABTD before submission. (The issue is due to Trusty pre-builts not being updated recently enough.)

Change-Id: I1bf243481ac6862b4fce19c7940eacb4a8c0671c
---
 rootdir/init.rc | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 0b45e73c77b1..f1670ae04a33 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -995,11 +995,8 @@ on post-fs-data
     mkdir /data/misc/stats-service/ 0770 statsd system
     mkdir /data/misc/train-info/ 0770 statsd system
 
-    # TODO(b/369375199): Remove once attest modules flagging is removed.
+    # Wait for apexd to finish activating APEXes before starting more processes.
     wait_for_prop apexd.status activated
-    # Wait for KeyMints to receive APEX module info before starting code from updateable APEXes.
-    # This is to prevent APEX modules from interfering in module measurement.
-    wait_for_prop keystore.module_hash.sent true
     perform_apex_config
 
     exec_start system_aconfigd_mainline_init

From 2dc0a19e97a38bd2ae66784e1f13eb3409e6453f Mon Sep 17 00:00:00 2001
From: Karuna Wadhera <kwadhera@google.com>
Date: Mon, 6 Jan 2025 14:59:21 -0800
Subject: [PATCH 1338/1487] Revert^2 "Run module code only after KeyMints
 receive module info"

This reverts commit b1da9dc655caf1a70f8f0244404207c8ec491ed4.

Reason for revert: Re-submitting the original change once Trusty pre-builts are updated.

Change-Id: Iaf3f535dd5640d8302aeec376b3afaa5b9859f55
---
 rootdir/init.rc | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index f1670ae04a33..0b45e73c77b1 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -995,8 +995,11 @@ on post-fs-data
     mkdir /data/misc/stats-service/ 0770 statsd system
     mkdir /data/misc/train-info/ 0770 statsd system
 
-    # Wait for apexd to finish activating APEXes before starting more processes.
+    # TODO(b/369375199): Remove once attest modules flagging is removed.
     wait_for_prop apexd.status activated
+    # Wait for KeyMints to receive APEX module info before starting code from updateable APEXes.
+    # This is to prevent APEX modules from interfering in module measurement.
+    wait_for_prop keystore.module_hash.sent true
     perform_apex_config
 
     exec_start system_aconfigd_mainline_init

From b2a64ccfe666c757e9f35fd1f92380367f1086e2 Mon Sep 17 00:00:00 2001
From: "cloud.you" <cloud.you@realtek.com>
Date: Tue, 7 Jan 2025 07:12:25 +0000
Subject: [PATCH 1339/1487] Fixed failure of clearing loopback device

Loopback device is already cleared when resetting ZRAM_BACK_DEV,
ZRAM_BACK_DEV is changed to "none" from "/dev/block/loopXX".
So it needs to read ZRAM_BACK_DEV again before checking it.

Bug: 388158025
Test:
- Boot up device with zram writeback enabled
- adb root
- adb reboot userspace

Change-Id: Ib7b648f6a50eb3ef4d3b0268ed9e11d8c6e0a181
---
 init/reboot.cpp | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/init/reboot.cpp b/init/reboot.cpp
index ef9db9fdae30..d6e37f73162b 100644
--- a/init/reboot.cpp
+++ b/init/reboot.cpp
@@ -486,8 +486,7 @@ static Result<void> KillZramBackingDevice() {
         return ErrnoError() << "Failed to read " << ZRAM_BACK_DEV;
     }
 
-    // cut the last "\n"
-    backing_dev.erase(backing_dev.length() - 1);
+    android::base::Trim(backing_dev);
 
     if (android::base::StartsWith(backing_dev, "none")) {
         LOG(INFO) << "No zram backing device configured";
@@ -508,6 +507,12 @@ static Result<void> KillZramBackingDevice() {
                        << " failed";
     }
 
+    if (!android::base::ReadFileToString(ZRAM_BACK_DEV, &backing_dev)) {
+        return ErrnoError() << "Failed to read " << ZRAM_BACK_DEV;
+    }
+
+    android::base::Trim(backing_dev);
+
     if (!android::base::StartsWith(backing_dev, "/dev/block/loop")) {
         LOG(INFO) << backing_dev << " is not a loop device. Exiting early";
         return {};

From 2a760959c48682245c1236219f2e0dbc1c0377a5 Mon Sep 17 00:00:00 2001
From: "Isaac J. Manjarres" <isaacmanjarres@google.com>
Date: Thu, 26 Dec 2024 18:14:24 -0800
Subject: [PATCH 1340/1487] ashmem: Allow for restricting mapping permissions
 multiple times

The existing logic applies F_SEAL_SEAL when applying
F_SEAL_FUTURE_WRITE. This makes it so that no other seals can be applied
on a file.

This could be problematic in the future when executable mappings are
sealed through their own separate seal. For example, setting the buffer
to be mappable as RW would add the executable seal, and changing the
buffer to be mappable as RO would add the write seal. This would fail
if the first seal addition prevented any new seals from being added.

Therefore, only add seals when setting the protection mask for a buffer,
and do not prevent the addition of new seals.

Bug: 111903542
Change-Id: I1b765ba784991d5a3f4d1b866016cb17d3a33aaa
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
---
 libcutils/ashmem-dev.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index cebfa5d12b60..6cb79865d2fb 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -390,8 +390,8 @@ static int memfd_set_prot_region(int fd, int prot) {
     }
 
     /* We would only allow read-only for any future file operations */
-    if (fcntl(fd, F_ADD_SEALS, F_SEAL_FUTURE_WRITE | F_SEAL_SEAL) == -1) {
-        ALOGE("memfd_set_prot_region(%d, %d): F_SEAL_FUTURE_WRITE | F_SEAL_SEAL seal failed: %s\n",
+    if (fcntl(fd, F_ADD_SEALS, F_SEAL_FUTURE_WRITE) == -1) {
+        ALOGE("memfd_set_prot_region(%d, %d): F_SEAL_FUTURE_WRITE seal failed: %s\n",
               fd, prot, strerror(errno));
         return -1;
     }

From d3bf149eb286d85bfac19254793dbd0732ff3506 Mon Sep 17 00:00:00 2001
From: Khyber Sen <khyber@google.com>
Date: Sat, 4 Jan 2025 08:07:00 +0000
Subject: [PATCH 1341/1487] Reapply "rpc_binder: Change `trusty_tipc_fuzzer` to
 support multiple connections and messages"

This reverts commit b1105589b752d9c85769c8265e8f051b95ce8d96.

This redoes change I9692e4d0295052a8da2204f63be9e52939e70ac3,
fixing the crash and simplifying the logic so it's
more obvious something similar won't happen again.

Bug: 380142627
Bug: 319144781
Test: build.py qemu-generic-arm64-fuzz-test-debug &&
    ./build-root/build-qemu-generic-arm64-fuzz-test-debug/run.py &&
    lunch aosp_lynx-trunk_staging-userdebug &&
    m trusty_binder_rpc_fuzzer_multi_connection &&
    adb root &&
    adb sync data &&
    adb shell /data/fuzz/arm64/trusty_binder_rpc_fuzzer_multi_connection/trusty_binder_rpc_fuzzer_multi_connection -seed=1727807641/data/fuzz/arm64/trusty_binder_rpc_fuzzer_multi_connection/input
Change-Id: I049e94c87083a4e212aaf7edb1eca421dc1e76ed
---
 trusty/fuzz/tipc_fuzzer.cpp | 95 ++++++++++++++++++++++++++++++-------
 1 file changed, 77 insertions(+), 18 deletions(-)

diff --git a/trusty/fuzz/tipc_fuzzer.cpp b/trusty/fuzz/tipc_fuzzer.cpp
index f265cedb698f..d5e23e0086e2 100644
--- a/trusty/fuzz/tipc_fuzzer.cpp
+++ b/trusty/fuzz/tipc_fuzzer.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include <android-base/result.h>
+#include <fuzzer/FuzzedDataProvider.h>
 #include <stdlib.h>
 #include <trusty/coverage/coverage.h>
 #include <trusty/coverage/uuid.h>
@@ -23,6 +25,7 @@
 #include <iostream>
 #include <memory>
 
+using android::base::Result;
 using android::trusty::coverage::CoverageRecord;
 using android::trusty::fuzz::ExtraCounters;
 using android::trusty::fuzz::TrustyApp;
@@ -41,7 +44,12 @@ using android::trusty::fuzz::TrustyApp;
 #error "Binary file name must be parameterized using -DTRUSTY_APP_FILENAME."
 #endif
 
-static TrustyApp kTrustyApp(TIPC_DEV, TRUSTY_APP_PORT);
+#ifdef TRUSTY_APP_MAX_CONNECTIONS
+constexpr size_t MAX_CONNECTIONS = TRUSTY_APP_MAX_CONNECTIONS;
+#else
+constexpr size_t MAX_CONNECTIONS = 1;
+#endif
+
 static std::unique_ptr<CoverageRecord> record;
 
 extern "C" int LLVMFuzzerInitialize(int* /* argc */, char*** /* argv */) {
@@ -53,7 +61,8 @@ extern "C" int LLVMFuzzerInitialize(int* /* argc */, char*** /* argv */) {
     }
 
     /* Make sure lazy-loaded TAs have started and connected to coverage service. */
-    auto ret = kTrustyApp.Connect();
+    TrustyApp ta(TIPC_DEV, TRUSTY_APP_PORT);
+    auto ret = ta.Connect();
     if (!ret.ok()) {
         std::cerr << ret.error() << std::endl;
         exit(-1);
@@ -73,24 +82,74 @@ extern "C" int LLVMFuzzerInitialize(int* /* argc */, char*** /* argv */) {
     return 0;
 }
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-    static uint8_t buf[TIPC_MAX_MSG_SIZE];
-
-    ExtraCounters counters(record.get());
-    counters.Reset();
-
-    auto ret = kTrustyApp.Write(data, size);
-    if (ret.ok()) {
-        ret = kTrustyApp.Read(&buf, sizeof(buf));
+void abortResult(Result<void> result) {
+    if (result.ok()) {
+        return;
     }
+    std::cerr << result.error() << std::endl;
+    android::trusty::fuzz::Abort();
+}
 
-    // Reconnect to ensure that the service is still up
-    kTrustyApp.Disconnect();
-    ret = kTrustyApp.Connect();
-    if (!ret.ok()) {
-        std::cerr << ret.error() << std::endl;
-        android::trusty::fuzz::Abort();
+void testOneInput(FuzzedDataProvider& provider) {
+    std::vector<TrustyApp> trustyApps;
+
+    while (provider.remaining_bytes() > 0) {
+        static_assert(MAX_CONNECTIONS >= 1);
+
+        // Either
+        // 1. Add a new TA and connect.
+        // 2. Remove a TA.
+        // 3. Send a random message to a random TA.
+        const std::function<void()> options[] = {
+                // Add a new TA and connect.
+                [&]() {
+                    if (trustyApps.size() >= MAX_CONNECTIONS) {
+                        return;
+                    }
+                    auto& ta = trustyApps.emplace_back(TIPC_DEV, TRUSTY_APP_PORT);
+                    abortResult(ta.Connect());
+                },
+                // Remove a TA.
+                [&]() {
+                    if (trustyApps.empty()) {
+                        return;
+                    }
+                    trustyApps.pop_back();
+                },
+                // Send a random message to a random TA.
+                [&]() {
+                    if (trustyApps.empty()) {
+                        return;
+                    }
+
+                    // Choose a random TA.
+                    const auto i =
+                            provider.ConsumeIntegralInRange<size_t>(0, trustyApps.size() - 1);
+                    std::swap(trustyApps[i], trustyApps.back());
+                    auto& ta = trustyApps.back();
+
+                    // Send a random message.
+                    const auto data = provider.ConsumeRandomLengthString();
+                    abortResult(ta.Write(data.data(), data.size()));
+
+                    std::array<uint8_t, TIPC_MAX_MSG_SIZE> buf;
+                    abortResult(ta.Read(buf.data(), buf.size()));
+
+                    // Reconnect to ensure that the service is still up.
+                    ta.Disconnect();
+                    abortResult(ta.Connect());
+                },
+        };
+
+        provider.PickValueInArray(options)();
     }
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+    ExtraCounters counters(record.get());
+    counters.Reset();
 
-    return ret.ok() ? 0 : -1;
+    FuzzedDataProvider provider(data, size);
+    testOneInput(provider);
+    return 0;
 }

From 83ecf0e3fced064a4ab1d7ec59b35adae01f9539 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Mon, 16 Dec 2024 22:56:05 -0800
Subject: [PATCH 1342/1487] snapshotctl: Verify data blocks

1: Extract hash values from verity merkel tree
2: Verify data blocks with the merkel tree hash value

$snapshotctl dump-verity-hash /data/verity-hash/ -verify

verity hash value will be stored in the file for each partition

Bug: 371304627
Test: snapshotctl dump-verity-hash /data/verity-hash -verify
Change-Id: Ic93092422d0cec5d20c2177033a91e57e242fe3f
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/Android.bp                 |   4 +
 .../android/snapshot/snapshot.proto           |  11 +
 fs_mgr/libsnapshot/snapshotctl.cpp            | 261 +++++++++++++++++-
 3 files changed, 275 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 966696b05b2b..850e248d1765 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -374,11 +374,15 @@ cc_binary {
     srcs: [
         "snapshotctl.cpp",
         "scratch_super.cpp",
+        "android/snapshot/snapshot.proto",
     ],
     static_libs: [
         "libbrotli",
         "libfstab",
         "libz",
+        "libavb",
+        "libfs_avb",
+        "libcrypto_static",
         "update_metadata-protos",
     ],
     shared_libs: [
diff --git a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
index 5fb71a37b71a..6f3125131a5f 100644
--- a/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
+++ b/fs_mgr/libsnapshot/android/snapshot/snapshot.proto
@@ -283,3 +283,14 @@ message SnapshotMergeReport {
     // Size of v3 operation buffer. Needs to be determined during writer initialization
     uint64 estimated_op_count_max = 14;
 }
+
+message VerityHash {
+  // Partition name
+  string partition_name = 1;
+
+  // Salt used for verity hashes
+  string salt = 2;
+
+  // sha256 hash values of each block in the image
+  repeated bytes block_hash = 3;
+}
diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 46de991d00b9..e1a3310c30ef 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -30,12 +30,15 @@
 #include <android-base/unique_fd.h>
 
 #include <android-base/chrono_utils.h>
+#include <android-base/hex.h>
 #include <android-base/parseint.h>
 #include <android-base/properties.h>
 #include <android-base/scopeguard.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
+#include <android/snapshot/snapshot.pb.h>
 
+#include <fs_avb/fs_avb_util.h>
 #include <fs_mgr.h>
 #include <fs_mgr_dm_linear.h>
 #include <fstab/fstab.h>
@@ -44,9 +47,13 @@
 #include <libsnapshot/snapshot.h>
 #include <storage_literals/storage_literals.h>
 
+#include <openssl/sha.h>
+
 #include "partition_cow_creator.h"
 #include "scratch_super.h"
 
+#include "utility.h"
+
 #ifdef SNAPSHOTCTL_USERDEBUG_OR_ENG
 #include <BootControlClient.h>
 #endif
@@ -89,7 +96,12 @@ int Usage() {
                  "  apply-update\n"
                  "    Apply the incremental OTA update wherein the snapshots are\n"
                  "    directly written to COW block device. This will bypass update-engine\n"
-                 "    and the device will be ready to boot from the target build.\n";
+                 "    and the device will be ready to boot from the target build.\n"
+                 "  dump-verity-hash <directory where verity merkel tree hashes are stored> "
+                 "[-verify]\n"
+                 "    Dump the verity merkel tree hashes at the specified path\n"
+                 "    -verify: Verify the dynamic partition blocks by comparing it with verity "
+                 "merkel tree\n";
     return EX_USAGE;
 }
 
@@ -631,6 +643,252 @@ bool ApplyUpdate(int argc, char** argv) {
     return true;
 }
 
+static bool GetBlockHashFromMerkelTree(android::base::borrowed_fd image_fd, uint64_t image_size,
+                                       uint32_t data_block_size, uint32_t hash_block_size,
+                                       uint64_t tree_offset,
+                                       std::vector<std::string>& out_block_hash) {
+    uint32_t padded_digest_size = 32;
+    if (image_size % data_block_size != 0) {
+        LOG(ERROR) << "Image_size: " << image_size
+                   << " not a multiple of data block size: " << data_block_size;
+        return false;
+    }
+
+    // vector of level-size and offset
+    std::vector<std::pair<uint64_t, uint64_t>> levels;
+    uint64_t data_block_count = image_size / data_block_size;
+    uint32_t digests_per_block = hash_block_size / padded_digest_size;
+    uint32_t level_block_count = data_block_count;
+    while (level_block_count > 1) {
+        uint32_t next_level_block_count =
+                (level_block_count + digests_per_block - 1) / digests_per_block;
+        levels.emplace_back(std::make_pair(next_level_block_count * hash_block_size, 0));
+        level_block_count = next_level_block_count;
+    }
+    // root digest
+    levels.emplace_back(std::make_pair(0, 0));
+    // initialize offset
+    for (auto level = std::prev(levels.end()); level != levels.begin(); level--) {
+        std::prev(level)->second = level->second + level->first;
+    }
+
+    // We just want level 0
+    auto level = levels.begin();
+    std::string hash_block(hash_block_size, '\0');
+    uint64_t block_offset = tree_offset + level->second;
+    uint64_t t_read_blocks = 0;
+    uint64_t blockidx = 0;
+    uint64_t num_hash_blocks = level->first / hash_block_size;
+    while ((t_read_blocks < num_hash_blocks) && (blockidx < data_block_count)) {
+        if (!android::base::ReadFullyAtOffset(image_fd, hash_block.data(), hash_block.size(),
+                                              block_offset)) {
+            LOG(ERROR) << "Failed to read tree block at offset: " << block_offset;
+            return false;
+        }
+
+        for (uint32_t offset = 0; offset < hash_block.size(); offset += padded_digest_size) {
+            std::string single_hash = hash_block.substr(offset, padded_digest_size);
+            out_block_hash.emplace_back(single_hash);
+
+            blockidx += 1;
+            if (blockidx >= data_block_count) {
+                break;
+            }
+        }
+
+        block_offset += hash_block_size;
+        t_read_blocks += 1;
+    }
+    return true;
+}
+
+static bool CalculateDigest(const void* buffer, size_t size, const void* salt, uint32_t salt_length,
+                            uint8_t* digest) {
+    SHA256_CTX ctx;
+    if (SHA256_Init(&ctx) != 1) {
+        return false;
+    }
+    if (SHA256_Update(&ctx, salt, salt_length) != 1) {
+        return false;
+    }
+    if (SHA256_Update(&ctx, buffer, size) != 1) {
+        return false;
+    }
+    if (SHA256_Final(digest, &ctx) != 1) {
+        return false;
+    }
+    return true;
+}
+
+bool verify_data_blocks(android::base::borrowed_fd fd, const std::vector<std::string>& block_hash,
+                        std::unique_ptr<android::fs_mgr::FsAvbHashtreeDescriptor>& descriptor,
+                        const std::vector<uint8_t>& salt) {
+    uint64_t data_block_count = descriptor->image_size / descriptor->data_block_size;
+    uint64_t foffset = 0;
+    uint64_t blk = 0;
+
+    std::string hash_block(descriptor->hash_block_size, '\0');
+    while (blk < data_block_count) {
+        if (!android::base::ReadFullyAtOffset(fd, hash_block.data(), descriptor->hash_block_size,
+                                              foffset)) {
+            LOG(ERROR) << "Failed to read from offset: " << foffset;
+            return false;
+        }
+
+        std::string digest(32, '\0');
+        CalculateDigest(hash_block.data(), descriptor->hash_block_size, salt.data(), salt.size(),
+                        reinterpret_cast<uint8_t*>(digest.data()));
+        if (digest != block_hash[blk]) {
+            LOG(ERROR) << "Hash mismatch for block: " << blk << " Expected: " << block_hash[blk]
+                       << " Received: " << digest;
+            return false;
+        }
+
+        foffset += descriptor->hash_block_size;
+        blk += 1;
+    }
+
+    return true;
+}
+
+bool DumpVerityHash(int argc, char** argv) {
+    android::base::InitLogging(argv, &android::base::KernelLogger);
+
+    if (::getuid() != 0) {
+        LOG(ERROR) << "Not running as root. Try \"adb root\" first.";
+        return EXIT_FAILURE;
+    }
+
+    if (argc < 3) {
+        std::cerr
+                << " dump-verity-hash <directory location where verity hash is saved> {-verify}\n";
+        return false;
+    }
+
+    bool verification_required = false;
+    std::string hash_file_path = argv[2];
+    bool metadata_on_super = false;
+    if (argc == 4) {
+        if (argv[3] == "-verify"s) {
+            verification_required = true;
+        }
+    }
+
+    auto& dm = android::dm::DeviceMapper::Instance();
+    auto dm_block_devices = dm.FindDmPartitions();
+    if (dm_block_devices.empty()) {
+        LOG(ERROR) << "No dm-enabled block device is found.";
+        return false;
+    }
+
+    android::fs_mgr::Fstab fstab;
+    if (!ReadDefaultFstab(&fstab)) {
+        LOG(ERROR) << "Failed to read fstab";
+        return false;
+    }
+
+    for (const auto& pair : dm_block_devices) {
+        std::string partition_name = pair.first;
+        android::fs_mgr::FstabEntry* fstab_entry =
+                GetEntryForMountPoint(&fstab, "/" + partition_name);
+        auto vbmeta = LoadAndVerifyVbmeta(*fstab_entry, "", nullptr, nullptr, nullptr);
+        if (vbmeta == nullptr) {
+            LOG(ERROR) << "LoadAndVerifyVbmetaByPath failed for partition: " << partition_name;
+            return false;
+        }
+
+        auto descriptor =
+                android::fs_mgr::GetHashtreeDescriptor(partition_name, std::move(*vbmeta));
+        if (descriptor == nullptr) {
+            LOG(ERROR) << "GetHashtreeDescriptor failed for partition: " << partition_name;
+            return false;
+        }
+
+        std::string device_path = fstab_entry->blk_device;
+        if (!dm.GetDmDevicePathByName(fstab_entry->blk_device, &device_path)) {
+            LOG(ERROR) << "Failed to resolve logical device path for: " << fstab_entry->blk_device;
+            return false;
+        }
+
+        android::base::unique_fd fd(open(device_path.c_str(), O_RDONLY));
+        if (fd < 0) {
+            LOG(ERROR) << "Failed to open file: " << device_path;
+            return false;
+        }
+        std::vector<std::string> block_hash;
+        if (!GetBlockHashFromMerkelTree(fd, descriptor->image_size, descriptor->data_block_size,
+                                        descriptor->hash_block_size, descriptor->tree_offset,
+                                        block_hash)) {
+            LOG(ERROR) << "GetBlockHashFromMerkelTree failed";
+            return false;
+        }
+
+        uint64_t dev_sz = lseek(fd, 0, SEEK_END);
+        uint64_t fec_size = dev_sz - descriptor->image_size;
+        if (fec_size % descriptor->data_block_size != 0) {
+            LOG(ERROR) << "fec_size: " << fec_size
+                       << " isn't multiple of: " << descriptor->data_block_size;
+            return false;
+        }
+
+        std::vector<uint8_t> salt;
+        const std::string& salt_str = descriptor->salt;
+        bool ok = android::base::HexToBytes(salt_str, &salt);
+        if (!ok) {
+            LOG(ERROR) << "HexToBytes conversion failed";
+            return false;
+        }
+        uint64_t file_offset = descriptor->image_size;
+        std::vector<uint8_t> hash_block(descriptor->hash_block_size, 0);
+        while (file_offset < dev_sz) {
+            if (!android::base::ReadFullyAtOffset(fd, hash_block.data(),
+                                                  descriptor->hash_block_size, file_offset)) {
+                LOG(ERROR) << "Failed to read tree block at offset: " << file_offset;
+                return false;
+            }
+            std::string digest(32, '\0');
+            CalculateDigest(hash_block.data(), descriptor->hash_block_size, salt.data(),
+                            salt.size(), reinterpret_cast<uint8_t*>(digest.data()));
+            block_hash.push_back(digest);
+            file_offset += descriptor->hash_block_size;
+            fec_size -= descriptor->hash_block_size;
+        }
+
+        if (fec_size != 0) {
+            LOG(ERROR) << "Checksum calculation pending: " << fec_size;
+            return false;
+        }
+
+        if (verification_required) {
+            if (!verify_data_blocks(fd, block_hash, descriptor, salt)) {
+                LOG(ERROR) << "verify_data_blocks failed";
+                return false;
+            }
+        }
+
+        VerityHash verity_hash;
+        verity_hash.set_partition_name(partition_name);
+        verity_hash.set_salt(salt_str);
+        for (auto hash : block_hash) {
+            verity_hash.add_block_hash(hash.data(), hash.size());
+        }
+        std::string hash_file = hash_file_path + "/" + partition_name + ".pb";
+        std::string content;
+        if (!verity_hash.SerializeToString(&content)) {
+            LOG(ERROR) << "Unable to serialize verity_hash";
+            return false;
+        }
+        if (!WriteStringToFileAtomic(content, hash_file)) {
+            PLOG(ERROR) << "Unable to write VerityHash to " << hash_file;
+            return false;
+        }
+
+        LOG(INFO) << partition_name
+                  << ": GetBlockHashFromMerkelTree success. Num Blocks: " << block_hash.size();
+    }
+    return true;
+}
+
 bool MapPrecreatedSnapshots(int argc, char** argv) {
     android::base::InitLogging(argv, &android::base::KernelLogger);
 
@@ -827,6 +1085,7 @@ static std::map<std::string, std::function<bool(int, char**)>> kCmdMap = {
         {"unmap-snapshots", UnMapPrecreatedSnapshots},
         {"delete-snapshots", DeletePrecreatedSnapshots},
         {"revert-snapshots", RemovePrecreatedSnapshots},
+        {"dump-verity-hash", DumpVerityHash},
 #endif
         {"unmap", UnmapCmdHandler},
         // clang-format on

From 97f18afaf1a630f71609bb65b9ae424c3f6910c4 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Wed, 8 Jan 2025 15:07:52 +0800
Subject: [PATCH 1343/1487] modprobe: Always log failures to the kernel logger

Failure to load modules are often critical, so made more sense to always
log such failures to the kernel logger and system logger.

Bug: 383081955
Test: Presubmit
Change-Id: Ie154d9dfef0e20d3df56f3034d465aa8c797ed5b
---
 toolbox/modprobe.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index 13026ac30aa8..fa6297d807f8 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -52,7 +52,7 @@ void print_usage(void) {
     LOG(INFO) << "  -h, --help: Print this help";
     LOG(INFO) << "  -l, --list: List modules matching pattern";
     LOG(INFO) << "  -r, --remove: Remove MODULE (multiple modules may be specified)";
-    LOG(INFO) << "  -s, --syslog: print to syslog also";
+    LOG(INFO) << "  -s, --syslog: print to syslog also (deprecated)";
     LOG(INFO) << "  -q, --quiet: disable messages";
     LOG(INFO) << "  -v, --verbose: enable more messages, even more with a second -v";
     LOG(INFO);
@@ -76,12 +76,10 @@ std::string stripComments(const std::string& str) {
     /* NOTREACHED */
 }
 
-auto syslog = false;
-
 void MyLogger(android::base::LogId id, android::base::LogSeverity severity, const char* tag,
               const char* file, unsigned int line, const char* message) {
     android::base::StdioLogger(id, severity, tag, file, line, message);
-    if (syslog && message[0]) {
+    if (message[0]) {
         android::base::KernelLogger(id, severity, tag, file, line, message);
     }
 }
@@ -200,7 +198,6 @@ extern "C" int modprobe_main(int argc, char** argv) {
                 mode = RemoveModulesMode;
                 break;
             case 's':
-                syslog = true;
                 break;
             case 'v':
                 if (android::base::GetMinimumLogSeverity() <= android::base::DEBUG) {

From d07b423eaede653705b2c3785b5bffd046d38a5d Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Sat, 21 Dec 2024 00:14:50 -0800
Subject: [PATCH 1344/1487] create_snapshot: Derive source hash from device

Verity hash extracted from device merkel tree is stored
in a file. Use that to derive the source hash

Bug: 371304627
Test: create_snapshot --source=system.pb --target=$OUT/system.img --merkel_tree
Change-Id: I670318496054d5aa9f81efa5954e4fdd28bc3e19
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/Android.bp                 |  12 +-
 .../libsnapshot_cow/create_cow.cpp            | 127 +++++++++++++++---
 2 files changed, 122 insertions(+), 17 deletions(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index 850e248d1765..b5b976ab7e4b 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -492,7 +492,10 @@ cc_binary {
     host_supported: true,
     device_supported: false,
 
-    srcs: ["libsnapshot_cow/create_cow.cpp"],
+    srcs: [
+        "libsnapshot_cow/create_cow.cpp",
+        "android/snapshot/snapshot.proto",
+    ],
 
     cflags: [
         "-Wall",
@@ -502,14 +505,21 @@ cc_binary {
     static_libs: [
         "liblog",
         "libbase",
+        "libfstab",
         "libext4_utils",
         "libsnapshot_cow",
         "libcrypto",
         "libbrotli",
         "libz",
+        "libdm",
         "liblz4",
         "libzstd",
         "libgflags",
+        "libavb",
+        "libext2_uuid",
+        "libfs_avb",
+        "libcrypto",
+        "libprotobuf-cpp-lite",
     ],
     shared_libs: [
     ],
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
index 5497b7232944..fd4e7da0d381 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
@@ -8,6 +8,7 @@
 
 #include <condition_variable>
 #include <cstring>
+#include <fstream>
 #include <future>
 #include <iostream>
 #include <limits>
@@ -17,26 +18,27 @@
 #include <unordered_map>
 #include <vector>
 
+#include <android-base/chrono_utils.h>
 #include <android-base/file.h>
+#include <android-base/hex.h>
 #include <android-base/logging.h>
+#include <android-base/scopeguard.h>
 #include <android-base/stringprintf.h>
+#include <android-base/strings.h>
 #include <android-base/unique_fd.h>
+#include <android/snapshot/snapshot.pb.h>
 #include <ext4_utils/ext4_utils.h>
-#include <storage_literals/storage_literals.h>
-
-#include <android-base/chrono_utils.h>
-#include <android-base/scopeguard.h>
-#include <android-base/strings.h>
-
+#include <fs_avb/fs_avb_util.h>
 #include <gflags/gflags.h>
 #include <libsnapshot/cow_writer.h>
-
 #include <openssl/sha.h>
+#include <storage_literals/storage_literals.h>
 
 DEFINE_string(source, "", "Source partition image");
 DEFINE_string(target, "", "Target partition image");
 DEFINE_string(compression, "lz4",
               "Compression algorithm. Default is set to lz4. Available options: lz4, zstd, gz");
+DEFINE_bool(merkel_tree, false, "If true, source image hash is obtained from verity merkel tree");
 
 namespace android {
 namespace snapshot {
@@ -51,7 +53,8 @@ using android::snapshot::ICowWriter;
 class CreateSnapshot {
   public:
     CreateSnapshot(const std::string& src_file, const std::string& target_file,
-                   const std::string& patch_file, const std::string& compression);
+                   const std::string& patch_file, const std::string& compression,
+                   const bool& merkel_tree);
     bool CreateSnapshotPatch();
 
   private:
@@ -108,6 +111,14 @@ class CreateSnapshot {
     bool WriteOrderedSnapshots();
     bool WriteNonOrderedSnapshots();
     bool VerifyMergeOrder();
+
+    bool CalculateDigest(const void* buffer, size_t size, const void* salt, uint32_t salt_length,
+                         uint8_t* digest);
+    bool ParseSourceMerkelTree();
+
+    bool use_merkel_tree_ = false;
+    std::vector<uint8_t> target_salt_;
+    std::vector<uint8_t> source_salt_;
 };
 
 void CreateSnapshotLogger(android::base::LogId, android::base::LogSeverity severity, const char*,
@@ -120,8 +131,12 @@ void CreateSnapshotLogger(android::base::LogId, android::base::LogSeverity sever
 }
 
 CreateSnapshot::CreateSnapshot(const std::string& src_file, const std::string& target_file,
-                               const std::string& patch_file, const std::string& compression)
-    : src_file_(src_file), target_file_(target_file), patch_file_(patch_file) {
+                               const std::string& patch_file, const std::string& compression,
+                               const bool& merkel_tree)
+    : src_file_(src_file),
+      target_file_(target_file),
+      patch_file_(patch_file),
+      use_merkel_tree_(merkel_tree) {
     if (!compression.empty()) {
         compression_ = compression;
     }
@@ -156,7 +171,76 @@ bool CreateSnapshot::FindSourceBlockHash() {
     if (!PrepareParse(src_file_, false)) {
         return false;
     }
-    return ParsePartition();
+
+    if (use_merkel_tree_) {
+        return ParseSourceMerkelTree();
+    } else {
+        return ParsePartition();
+    }
+}
+
+bool CreateSnapshot::CalculateDigest(const void* buffer, size_t size, const void* salt,
+                                     uint32_t salt_length, uint8_t* digest) {
+    SHA256_CTX ctx;
+    if (SHA256_Init(&ctx) != 1) {
+        return false;
+    }
+    if (SHA256_Update(&ctx, salt, salt_length) != 1) {
+        return false;
+    }
+    if (SHA256_Update(&ctx, buffer, size) != 1) {
+        return false;
+    }
+    if (SHA256_Final(digest, &ctx) != 1) {
+        return false;
+    }
+    return true;
+}
+
+bool CreateSnapshot::ParseSourceMerkelTree() {
+    std::string fname = android::base::Basename(target_file_.c_str());
+    std::string partitionName = fname.substr(0, fname.find(".img"));
+
+    auto vbmeta = android::fs_mgr::LoadAndVerifyVbmetaByPath(
+            target_file_, partitionName, "", true, false, false, nullptr, nullptr, nullptr);
+    if (vbmeta == nullptr) {
+        LOG(ERROR) << "LoadAndVerifyVbmetaByPath failed for partition: " << partitionName;
+        return false;
+    }
+    auto descriptor = android::fs_mgr::GetHashtreeDescriptor(partitionName, std::move(*vbmeta));
+    if (descriptor == nullptr) {
+        LOG(ERROR) << "GetHashtreeDescriptor failed for partition: " << partitionName;
+        return false;
+    }
+
+    std::fstream input(src_file_, std::ios::in | std::ios::binary);
+    VerityHash hash;
+    if (!hash.ParseFromIstream(&input)) {
+        LOG(ERROR) << "Failed to parse message.";
+        return false;
+    }
+
+    std::string source_salt = hash.salt();
+    source_salt.erase(std::remove(source_salt.begin(), source_salt.end(), '\0'), source_salt.end());
+    if (!android::base::HexToBytes(source_salt, &source_salt_)) {
+        LOG(ERROR) << "HexToBytes conversion failed for source salt: " << source_salt;
+        return false;
+    }
+
+    std::string target_salt = descriptor->salt;
+    if (!android::base::HexToBytes(target_salt, &target_salt_)) {
+        LOG(ERROR) << "HexToBytes conversion failed for target salt: " << target_salt;
+        return false;
+    }
+
+    std::vector<uint8_t> digest(32, 0);
+    for (int i = 0; i < hash.block_hash_size(); i++) {
+        CalculateDigest(hash.block_hash(i).data(), hash.block_hash(i).size(), target_salt_.data(),
+                        target_salt_.size(), digest.data());
+        source_block_hash_[ToHexString(digest.data(), 32)] = i;
+    }
+
+    return true;
 }
 
 /*
@@ -386,10 +470,21 @@ bool CreateSnapshot::ReadBlocks(off_t offset, const int skip_blocks, const uint6
         while (num_blocks) {
             const void* bufptr = (char*)buffer.get() + buffer_offset;
             uint64_t blkindex = foffset / BLOCK_SZ;
-
-            uint8_t checksum[32];
-            SHA256(bufptr, BLOCK_SZ, checksum);
-            std::string hash = ToHexString(checksum, sizeof(checksum));
+            std::string hash;
+
+            if (create_snapshot_patch_ && use_merkel_tree_) {
+                std::vector<uint8_t> digest(32, 0);
+                CalculateDigest(bufptr, BLOCK_SZ, target_salt_.data(), target_salt_.size(),
+                                digest.data());
+                std::vector<uint8_t> final_digest(32, 0);
+                CalculateDigest(digest.data(), digest.size(), source_salt_.data(),
+                                source_salt_.size(), final_digest.data());
+                hash = ToHexString(final_digest.data(), final_digest.size());
+            } else {
+                uint8_t checksum[32];
+                SHA256(bufptr, BLOCK_SZ, checksum);
+                hash = ToHexString(checksum, sizeof(checksum));
+            }
 
             if (create_snapshot_patch_) {
                 PrepareMergeBlock(bufptr, blkindex, hash);
@@ -497,7 +592,7 @@ int main(int argc, char* argv[]) {
     auto parts = android::base::Split(fname, ".");
     std::string snapshotfile = parts[0] + ".patch";
     android::snapshot::CreateSnapshot snapshot(FLAGS_source, FLAGS_target, snapshotfile,
-                                               FLAGS_compression);
+                                               FLAGS_compression, FLAGS_merkel_tree);
 
     if (!snapshot.CreateSnapshotPatch()) {
         LOG(ERROR) << "Snapshot creation failed";

From 447ab6965754132d94ba822c9fedf1c655c87d84 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Sat, 21 Dec 2024 00:18:19 -0800
Subject: [PATCH 1345/1487] Apply-update: Script to apply updates to device

<Development workflow for any project in the platform and build with 'm' to create the images>

Build:

$m apply_update

$ apply_update --help

Update the device to the current build in $OUT:
$ apply_update

Update the device, but skip flashing static partitions (see --help):
$ apply_update --skip-static-partitions

Update the device and wipe user data:
$ apply_update --wipe

Performance:

a: Default update without any paramenters: Update takes ~30-40 seconds.
b: With --skip-static-partitions its < 20 seconds

Bug: 371304627
Test: Test development workflow:

1: m libsnapshot && m -j
   apply_update

2: m snapshotctl && m -j
   apply_update --wipe

3: m virtmgr && m -j
   apply_update --skip-static-partitions

4: m crosvm && m -j
   apply_update --skip-static-partitions

Change-Id: Iff2c774ef83bc67601cc978e2e3ceea355a5482f
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/scripts/Android.bp      |   5 +
 fs_mgr/libsnapshot/scripts/apply-update.sh | 259 ++++++++++++++++-----
 2 files changed, 206 insertions(+), 58 deletions(-)

diff --git a/fs_mgr/libsnapshot/scripts/Android.bp b/fs_mgr/libsnapshot/scripts/Android.bp
index 829f5bc921a6..b99da937744f 100644
--- a/fs_mgr/libsnapshot/scripts/Android.bp
+++ b/fs_mgr/libsnapshot/scripts/Android.bp
@@ -29,3 +29,8 @@ python_binary_host {
         "snapshot_proto_python",
     ],
 }
+
+sh_binary_host {
+    name: "apply_update",
+    src: "apply-update.sh",
+}
diff --git a/fs_mgr/libsnapshot/scripts/apply-update.sh b/fs_mgr/libsnapshot/scripts/apply-update.sh
index 90b0119a2e5b..0b10721a44ef 100755
--- a/fs_mgr/libsnapshot/scripts/apply-update.sh
+++ b/fs_mgr/libsnapshot/scripts/apply-update.sh
@@ -1,77 +1,220 @@
 #!/bin/bash
 
-# This is a debug script to quicky test end-to-end flow
-# of snapshot updates without going through update-engine.
+# Copyright 2024 Google Inc. All rights reserved.
 #
-# Usage:
-#
-#  To update both dynamic and static partitions:
-#
-# ./system/core/fs_mgr/libsnapshot/apply_update.sh [--update-static-partitions] [--wipe]
-#
-# --update-static-partitions: This will update bootloader and static A/B
-# partitions
-# --wipe: Allows data wipe as part of update flow
-#
-#  To update dynamic partitions only (this should be used when static
-#  partitions are present in both the slots):
-#
-#  ./system/core/fs_mgr/libsnapshot/apply_update.sh
+# 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.
 
-rm -f $OUT/*.patch
+# apply_update.sh: Script to update the device in incremental way
 
-# Compare images and create snapshot patches. Currently, this
-# just compares two identical images in $OUT. In general, any source
-# and target images could be passed to create snapshot patches. However,
-# care must be taken to ensure source images are already present on the device.
-#
-# create_snapshot is a host side binary. Build it with `m create_snapshot`
-create_snapshot --source=$OUT/system.img --target=$OUT/system.img &
-create_snapshot --source=$OUT/product.img --target=$OUT/product.img &
-create_snapshot --source=$OUT/vendor.img --target=$OUT/vendor.img &
-create_snapshot --source=$OUT/system_ext.img --target=$OUT/system_ext.img &
-create_snapshot --source=$OUT/vendor_dlkm.img --target=$OUT/vendor_dlkm.img &
-create_snapshot --source=$OUT/system_dlkm.img --target=$OUT/system_dlkm.img &
-
-echo "Waiting for snapshot patch creation"
-wait $(jobs -p)
-echo "Snapshot patch creation completed"
+# Ensure OUT directory exists
+if [ -z "$OUT" ]; then
+  echo "Error: OUT environment variable not set." >&2
+  exit 1
+fi
 
-mv *.patch $OUT/
+DEVICE_PATH="/data/verity-hash"
+HOST_PATH="$OUT/verity-hash"
 
-adb root
-adb wait-for-device
-adb shell mkdir -p /data/update/
-adb push $OUT/*.patch /data/update/
+# Create the log file path
+log_file="$HOST_PATH/snapshot.log"
 
-if [[ "$2" == "--wipe" ]]; then
-  adb shell snapshotctl apply-update /data/update/ -w
-else
-  adb shell snapshotctl apply-update /data/update/
-fi
+# Function to log messages to both console and log file
+log_message() {
+    message="$1"
+    echo "$message"  # Print to stdout
+    echo "$(date '+%Y-%m-%d %H:%M:%S') - $message" >> "$log_file"  # Append to log file with timestamp
+}
 
-# Check if the --update-static-partitions option is provided.
-# For quick developer workflow, there is no need to repeatedly
-# apply static partitions.
-if [[ "$1" == "--update-static-partitions" ]]; then
-  adb reboot bootloader
-  sleep 5
-  if [[ "$2" == "--wipe" ]]; then
-      fastboot -w
+# Function to check for create_snapshot and build if needed
+ensure_create_snapshot() {
+  if ! command -v create_snapshot &> /dev/null; then
+    log_message "create_snapshot not found. Building..."
+    m create_snapshot
+    if [[ $? -ne 0 ]]; then
+      log_message "Error: Failed to build create_snapshot."
+      exit 1
+    fi
   fi
-  fastboot flash bootloader $OUT/bootloader.img
-  sleep 1
+}
+
+ensure_create_snapshot
+
+# Function to flash static partitions
+flash_static_partitions() {
+  local wipe_flag="$1"
+
+  fastboot flash bootloader "$OUT"/bootloader.img
   fastboot reboot bootloader
   sleep 1
-  fastboot flash radio $OUT/radio.img
-  sleep 1
+  fastboot flash radio "$OUT"/radio.img
   fastboot reboot bootloader
   sleep 1
-  fastboot flashall --exclude-dynamic-partitions --disable-super-optimization
+  fastboot flashall --exclude-dynamic-partitions --disable-super-optimization --skip-reboot
+
+  if (( wipe_flag )); then
+      log_message "Wiping device..."
+      fastboot -w
+  fi
+  fastboot reboot
+}
+
+# Function to display the help message
+show_help() {
+  cat << EOF
+Usage: $0 [OPTIONS]
+
+This script updates an Android device with incremental flashing, optionally wiping data and flashing static partitions.
+
+Options:
+  --skip-static-partitions  Skip flashing static partitions (bootloader, radio, boot, vbmeta, dtbo and other static A/B partitions).
+                           * Requires manual update of static partitions on both A/B slots
+                             *before* using this flag.
+                           * Speeds up the update process and development iteration.
+                           * Ideal for development focused on the Android platform (AOSP,
+                             git_main).
+                           * Safe usage: First update static partitions on both slots, then
+                             use this flag for faster development iterations.
+                             Ex:
+                                1: Run this on both the slots - This will update the kernel and other static partitions:
+                                   $fastboot flashall --exclude-dynamic-partitions --disable-super-optimization --skip-reboot
+
+                                2: Update bootloader on both the slots:
+                                    $fastboot flash bootloader $OUT/bootloader.img --slot=all
+
+                                3: Update radio on both the slots:
+                                    $fastboot flash radio $OUT/radio.img --slot=all
+                            Now, the script can safely use this flag for update purpose.
+
+  --wipe                   Wipe user data during the update.
+  --help                   Display this help message.
+
+Environment Variables:
+  OUT                      Path to the directory containing build output.
+                           This is required for the script to function correctly.
+
+Examples:
+  <Development workflow for any project in the platform and build with 'm' to create the images>
+
+  Update the device:
+  $0
+
+  Update the device, but skip flashing static partitions (see above for the usage):
+  $0 --skip-static-partitions
+
+  Update the device and wipe user data:
+  $0 --wipe
+
+  Display this help message:
+  $0 --help
+EOF
+}
+
+skip_static_partitions=0
+wipe_flag=0
+help_flag=0
+
+# Parse arguments
+for arg in "$@"; do
+  case "$arg" in
+    --skip-static-partitions)
+      skip_static_partitions=1
+      ;;
+    --wipe)
+      wipe_flag=1
+      ;;
+    --help)
+      help_flag=1
+      ;;
+    *)
+      echo "Unknown argument: $arg" >&2
+      help_flag=1
+      ;;
+  esac
+done
+
+# Check if help flag is set
+if (( help_flag )); then
+  show_help
+  exit 0
+fi
+
+rm -rf $HOST_PATH
+
+adb root
+adb wait-for-device
+
+adb shell rm -rf $DEVICE_PATH
+adb shell mkdir -p $DEVICE_PATH
+
+echo "Extracting device source hash from dynamic partitions"
+adb shell snapshotctl dump-verity-hash $DEVICE_PATH
+adb pull -q $DEVICE_PATH $OUT/
+
+log_message "Entering directory:"
+
+# Navigate to the verity-hash directory
+cd "$HOST_PATH" || { log_message "Error: Could not navigate to $HOST_PATH"; exit 1; }
+
+pwd
+
+# Iterate over all .pb files using a for loop
+for pb_file in *.pb; do
+  # Extract the base filename without the .pb extension
+  base_filename="${pb_file%.*}"
+
+  # Construct the source and target file names
+  source_file="$pb_file"
+  target_file="$OUT/$base_filename.img"
+
+  # Construct the create_snapshot command using an array
+  snapshot_args=(
+    "create_snapshot"
+    "--source" "$source_file"
+    "--target" "$target_file"
+    "--merkel_tree"
+  )
+
+  # Log the command about to be executed
+  log_message "Running: ${snapshot_args[*]}"
+
+  "${snapshot_args[@]}" >> "$log_file" 2>&1 &
+done
+
+log_message "Waiting for snapshot patch creation"
+
+# Wait for all background processes to complete
+wait $(jobs -p)
+
+log_message "Snapshot patches created successfully"
+
+adb push -q $HOST_PATH/*.patch $DEVICE_PATH
+
+log_message "Applying update"
+
+if (( wipe_flag )); then
+  adb shell snapshotctl apply-update $DEVICE_PATH -w
+else
+  adb shell snapshotctl apply-update $DEVICE_PATH
+fi
+
+if (( skip_static_partitions )); then
+    log_message "Rebooting device - Skipping flashing static partitions"
+    adb reboot
 else
-  adb reboot
+    log_message "Rebooting device to bootloader"
+    adb reboot bootloader
+    log_message "Waiting to enter fastboot bootloader"
+    flash_static_partitions "$wipe_flag"
 fi
 
-echo "Update completed"
+log_message "Update completed"

From c044283bd774eac5e74d7d6080ae4d33ed951e02 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Wed, 8 Jan 2025 15:11:54 +0800
Subject: [PATCH 1346/1487] Add toolbox_ramdisk

Intended to be installed in the generic ramdisk.
This may be executed in init_first_stage where there is no dynamic
linker, so it must be -static linked.

Bug: 383081955
Test: Presubmit
Test: Verify kernel modules are loaded in klog
Change-Id: I1b4e25970c35e6c0cce8be0edeab909e18ae46ba
---
 toolbox/Android.bp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/toolbox/Android.bp b/toolbox/Android.bp
index 3142542989f4..5169aa1b28b2 100644
--- a/toolbox/Android.bp
+++ b/toolbox/Android.bp
@@ -84,3 +84,22 @@ cc_binary {
     vendor: true,
     defaults: ["toolbox_binary_defaults"],
 }
+
+// This one is installed in the generic ramdisk, and can be executed during
+// init-first-stage.
+// As there are no dynamic linker available, this must be statically linked.
+cc_binary {
+    name: "toolbox_ramdisk",
+    defaults: ["toolbox_binary_defaults"],
+    ramdisk: true,
+    static_executable: true,
+    system_shared_libs: [],
+    exclude_shared_libs: [
+        "libbase",
+        "liblog",
+    ],
+    static_libs: [
+        "libbase",
+        "liblog",
+    ],
+}

From f518d466b13c1327e03f3a6de505368d4f1b1b7e Mon Sep 17 00:00:00 2001
From: "Isaac J. Manjarres" <isaacmanjarres@google.com>
Date: Thu, 26 Dec 2024 11:34:21 -0800
Subject: [PATCH 1347/1487] ashmem: Only use memfd if the kernel has
 ashmem-memfd compat support

There are still old applications that have not migrated to using
libcutils, and allocate shared memory buffers by directly allocating
them from "/dev/ashmem", and then using the ashmem ioctl commands
to operate on the buffer.

This works well on a system where all shared memory buffers are ashmem
buffers. However, in a system where there could be a mix of ashmem and
memfd buffers (e.g. if sys.use_memfd == true), this could be a problem
as ashmem ioctl commands on memfds will fail if the kernel does not
have support for ashmem-memfd compatibility.

Therefore, check for ashmem-memfd compatiblity before deciding if memfd
is usable.

Bug: 111903542
Change-Id: I760e57b31b53cdd4cfbf94cb35a6fb47b089bb1b
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
---
 libcutils/ashmem-dev.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index 6cb79865d2fb..615ef5e2fae6 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -132,6 +132,16 @@ static bool __has_memfd_support() {
         return false;
     }
 
+    /*
+     * Ensure that the kernel supports ashmem ioctl commands on memfds. If not,
+     * fall back to using ashmem.
+     */
+    if (TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_SET_SIZE, getpagesize())) < 0) {
+        ALOGE("ioctl(ASHMEM_SET_SIZE) failed: %s, no ashmem-memfd compat support.\n",
+              strerror(errno));
+        return false;
+    }
+
     if (debug_log) {
         ALOGD("memfd: device has memfd support, using it\n");
     }

From 773fe7648fa1d51ed63910374e2a22796c32e023 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Thu, 2 Jan 2025 18:53:03 +0000
Subject: [PATCH 1348/1487] Ensure CancelUpdate() always works in recovery.

This adds a new helper function, TryCancelUpdate(), and refactors the
update cancellation logic. It now takes a "force" parameter, which if is
set and the device is in recovery, overrides all conditions that would
cause cancellation to fail.

In addition the cancellation logic has been consolidated to avoid
duplication of code and error checks. Removal of invalid snapshots is
now automatic for all success cases.

Test: vts_libsnapshot_test
Bug: 352538505
Change-Id: I612d4eb3c4f6436838c9b2f1e38bf644e99c6ad0
---
 fs_mgr/libfiemap/binder.cpp                   |   4 +
 fs_mgr/libfiemap/image_manager.cpp            |  17 +++
 .../include/libfiemap/image_manager.h         |   5 +
 .../include/libsnapshot/mock_snapshot.h       |   1 +
 .../include/libsnapshot/snapshot.h            |  24 +++-
 .../include/libsnapshot/snapshot_stub.h       |   1 +
 fs_mgr/libsnapshot/snapshot.cpp               | 134 ++++++++++++------
 fs_mgr/libsnapshot/snapshot_stub.cpp          |   5 +
 fs_mgr/libsnapshot/snapshot_test.cpp          |  33 +++++
 fs_mgr/libsnapshot/utility.cpp                |  16 +++
 fs_mgr/libsnapshot/utility.h                  |   2 +
 11 files changed, 193 insertions(+), 49 deletions(-)

diff --git a/fs_mgr/libfiemap/binder.cpp b/fs_mgr/libfiemap/binder.cpp
index 439aac9695aa..8c5fb09b9d73 100644
--- a/fs_mgr/libfiemap/binder.cpp
+++ b/fs_mgr/libfiemap/binder.cpp
@@ -62,6 +62,7 @@ class ImageManagerBinder final : public IImageManager {
                                   std::string* dev) override;
     FiemapStatus ZeroFillNewImage(const std::string& name, uint64_t bytes) override;
     bool RemoveAllImages() override;
+    bool DisableAllImages() override;
     bool DisableImage(const std::string& name) override;
     bool RemoveDisabledImages() override;
     bool GetMappedImageDevice(const std::string& name, std::string* device) override;
@@ -194,6 +195,9 @@ bool ImageManagerBinder::RemoveAllImages() {
     }
     return true;
 }
+bool ImageManagerBinder::DisableAllImages() {
+    return true;
+}
 
 bool ImageManagerBinder::DisableImage(const std::string& name) {
     auto status = manager_->disableImage(name);
diff --git a/fs_mgr/libfiemap/image_manager.cpp b/fs_mgr/libfiemap/image_manager.cpp
index a5da6e3429c9..bc61d15bce99 100644
--- a/fs_mgr/libfiemap/image_manager.cpp
+++ b/fs_mgr/libfiemap/image_manager.cpp
@@ -655,6 +655,23 @@ bool ImageManager::RemoveAllImages() {
     return ok && RemoveAllMetadata(metadata_dir_);
 }
 
+bool ImageManager::DisableAllImages() {
+    if (!MetadataExists(metadata_dir_)) {
+        return true;
+    }
+    auto metadata = OpenMetadata(metadata_dir_);
+    if (!metadata) {
+        return false;
+    }
+
+    bool ok = true;
+    for (const auto& partition : metadata->partitions) {
+        auto partition_name = GetPartitionName(partition);
+        ok &= DisableImage(partition_name);
+    }
+    return ok;
+}
+
 bool ImageManager::Validate() {
     auto metadata = OpenMetadata(metadata_dir_);
     if (!metadata) {
diff --git a/fs_mgr/libfiemap/include/libfiemap/image_manager.h b/fs_mgr/libfiemap/include/libfiemap/image_manager.h
index 0619c96a37d6..78e3080d7671 100644
--- a/fs_mgr/libfiemap/include/libfiemap/image_manager.h
+++ b/fs_mgr/libfiemap/include/libfiemap/image_manager.h
@@ -127,6 +127,10 @@ class IImageManager {
     // Find and remove all images and metadata for this manager.
     virtual bool RemoveAllImages() = 0;
 
+    // Finds and marks all images for deletion upon next reboot. This is used during recovery since
+    // we cannot mount /data
+    virtual bool DisableAllImages() = 0;
+
     virtual bool UnmapImageIfExists(const std::string& name);
 
     // Returns whether DisableImage() was called.
@@ -158,6 +162,7 @@ class ImageManager final : public IImageManager {
     bool MapImageWithDeviceMapper(const IPartitionOpener& opener, const std::string& name,
                                   std::string* dev) override;
     bool RemoveAllImages() override;
+    bool DisableAllImages() override;
     bool DisableImage(const std::string& name) override;
     bool RemoveDisabledImages() override;
     bool GetMappedImageDevice(const std::string& name, std::string* device) override;
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot.h
index ca45d2fad88f..5ad988519bc0 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot.h
@@ -63,6 +63,7 @@ class MockSnapshotManager : public ISnapshotManager {
     MOCK_METHOD(ISnapshotMergeStats*, GetSnapshotMergeStatsInstance, (), (override));
     MOCK_METHOD(std::string, ReadSourceBuildFingerprint, (), (override));
     MOCK_METHOD(void, SetMergeStatsFeatures, (ISnapshotMergeStats*), (override));
+    MOCK_METHOD(bool, IsCancelUpdateSafe, (), (override));
 };
 
 }  // namespace android::snapshot
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index de20526310f6..165ecef79c25 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -88,6 +88,13 @@ enum class CreateResult : unsigned int {
     NOT_CREATED,
 };
 
+enum class CancelResult : unsigned int {
+    OK,
+    ERROR,
+    LIVE_SNAPSHOTS,
+    NEEDS_MERGE,
+};
+
 class ISnapshotManager {
   public:
     // Dependency injection for testing.
@@ -125,6 +132,10 @@ class ISnapshotManager {
     // Cancel an update; any snapshots will be deleted. This is allowed if the
     // state == Initiated, None, or Unverified (before rebooting to the new
     // slot).
+    //
+    // In recovery, it will cancel an update even if a merge is in progress.
+    // Thus, it should only be called if a new OTA will be sideloaded. The
+    // safety can be checked via IsCancelUpdateSafe().
     virtual bool CancelUpdate() = 0;
 
     // Mark snapshot writes as having completed. After this, new snapshots cannot
@@ -301,6 +312,9 @@ class ISnapshotManager {
 
     // Return the associated ISnapshotMergeStats instance. Never null.
     virtual ISnapshotMergeStats* GetSnapshotMergeStatsInstance() = 0;
+
+    // Return whether cancelling an update is safe. This is for use in recovery.
+    virtual bool IsCancelUpdateSafe() = 0;
 };
 
 class SnapshotManager final : public ISnapshotManager {
@@ -390,6 +404,7 @@ class SnapshotManager final : public ISnapshotManager {
     bool UnmapAllSnapshots() override;
     std::string ReadSourceBuildFingerprint() override;
     void SetMergeStatsFeatures(ISnapshotMergeStats* stats) override;
+    bool IsCancelUpdateSafe() override;
 
     // We can't use WaitForFile during first-stage init, because ueventd is not
     // running and therefore will not automatically create symlinks. Instead,
@@ -444,6 +459,7 @@ class SnapshotManager final : public ISnapshotManager {
     FRIEND_TEST(SnapshotUpdateTest, SpaceSwapUpdate);
     FRIEND_TEST(SnapshotUpdateTest, InterruptMergeDuringPhaseUpdate);
     FRIEND_TEST(SnapshotUpdateTest, MapAllSnapshotsWithoutSlotSwitch);
+    FRIEND_TEST(SnapshotUpdateTest, CancelInRecovery);
     friend class SnapshotTest;
     friend class SnapshotUpdateTest;
     friend class FlashAfterUpdateTest;
@@ -743,12 +759,8 @@ class SnapshotManager final : public ISnapshotManager {
     // Unmap a dm-user device for user space snapshots
     bool UnmapUserspaceSnapshotDevice(LockedFile* lock, const std::string& snapshot_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);
+    CancelResult TryCancelUpdate();
+    CancelResult IsCancelUpdateSafe(UpdateState state);
 
     // Helper for CreateUpdateSnapshots.
     // Creates all underlying images, COW partitions and snapshot files. Does not initialize them.
diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot_stub.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot_stub.h
index 1c9b40368eb0..e586bbd5a42e 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot_stub.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot_stub.h
@@ -60,6 +60,7 @@ class SnapshotManagerStub : public ISnapshotManager {
     bool UnmapAllSnapshots() override;
     std::string ReadSourceBuildFingerprint() override;
     void SetMergeStatsFeatures(ISnapshotMergeStats* stats) override;
+    bool IsCancelUpdateSafe() override;
 };
 
 }  // namespace android::snapshot
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index ecf567eb8462..83787df456d9 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -191,14 +191,18 @@ static std::string GetSourceDeviceName(const std::string& partition_name) {
 }
 
 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;
+    switch (TryCancelUpdate()) {
+        case CancelResult::OK:
+            break;
+        case CancelResult::NEEDS_MERGE: {
+            LOG(INFO) << "Wait for merge (if any) before beginning a new update.";
+            auto state = ProcessUpdateState();
+            LOG(INFO) << "Merged with end state: " << state;
+            break;
+        }
+        default:
+            LOG(ERROR) << "Cannot begin update, existing update cannot be cancelled.";
+            return false;
     }
 
     auto file = LockExclusive();
@@ -223,49 +227,82 @@ bool SnapshotManager::BeginUpdate() {
 }
 
 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;
+    return TryCancelUpdate() == CancelResult::OK;
 }
 
-bool SnapshotManager::TryCancelUpdate(bool* needs_merge) {
-    *needs_merge = false;
+CancelResult SnapshotManager::TryCancelUpdate() {
+    auto lock = LockExclusive();
+    if (!lock) return CancelResult::ERROR;
 
-    auto file = LockExclusive();
-    if (!file) return false;
+    UpdateState state = ReadUpdateState(lock.get());
+    CancelResult result = IsCancelUpdateSafe(state);
 
-    if (IsSnapshotWithoutSlotSwitch()) {
-        LOG(ERROR) << "Cannot cancel the snapshots as partitions are mounted off the snapshots on "
-                      "current slot.";
-        return false;
+    if (result != CancelResult::OK && device_->IsRecovery()) {
+        LOG(ERROR) << "Cancel result " << result << " will be overridden in recovery.";
+        result = CancelResult::OK;
     }
 
-    UpdateState state = ReadUpdateState(file.get());
-    if (state == UpdateState::None) {
-        RemoveInvalidSnapshots(file.get());
+    switch (result) {
+        case CancelResult::OK:
+            LOG(INFO) << "Cancelling update from state: " << state;
+            RemoveAllUpdateState(lock.get());
+            RemoveInvalidSnapshots(lock.get());
+            break;
+        case CancelResult::NEEDS_MERGE:
+            LOG(ERROR) << "Cannot cancel an update while a merge is in progress.";
+            break;
+        case CancelResult::LIVE_SNAPSHOTS:
+            LOG(ERROR) << "Cannot cancel an update while snapshots are live.";
+            break;
+        case CancelResult::ERROR:
+            // Error was already reported.
+            break;
+    }
+    return result;
+}
+
+bool SnapshotManager::IsCancelUpdateSafe() {
+    // This may be called in recovery, so ensure we have /metadata.
+    auto mount = EnsureMetadataMounted();
+    if (!mount || !mount->HasDevice()) {
         return true;
     }
 
-    if (state == UpdateState::Initiated) {
-        LOG(INFO) << "Update has been initiated, now canceling";
-        return RemoveAllUpdateState(file.get());
+    auto lock = LockExclusive();
+    if (!lock) {
+        return false;
     }
 
-    if (state == UpdateState::Unverified) {
-        // We completed an update, but it can still be canceled if we haven't booted into it.
-        auto slot = GetCurrentSlot();
-        if (slot != Slot::Target) {
-            LOG(INFO) << "Canceling previously completed updates (if any)";
-            return RemoveAllUpdateState(file.get());
+    UpdateState state = ReadUpdateState(lock.get());
+    return IsCancelUpdateSafe(state) == CancelResult::OK;
+}
+
+CancelResult SnapshotManager::IsCancelUpdateSafe(UpdateState state) {
+    if (IsSnapshotWithoutSlotSwitch()) {
+        return CancelResult::LIVE_SNAPSHOTS;
+    }
+
+    switch (state) {
+        case UpdateState::Merging:
+        case UpdateState::MergeNeedsReboot:
+        case UpdateState::MergeFailed:
+            return CancelResult::NEEDS_MERGE;
+        case UpdateState::Unverified: {
+            // We completed an update, but it can still be canceled if we haven't booted into it.
+            auto slot = GetCurrentSlot();
+            if (slot == Slot::Target) {
+                return CancelResult::LIVE_SNAPSHOTS;
+            }
+            return CancelResult::OK;
         }
+        case UpdateState::None:
+        case UpdateState::Initiated:
+        case UpdateState::Cancelled:
+            return CancelResult::OK;
+        default:
+            LOG(ERROR) << "Unknown state: " << state;
+            return CancelResult::ERROR;
     }
-    *needs_merge = true;
-    return true;
 }
 
 std::string SnapshotManager::ReadUpdateSourceSlotSuffix() {
@@ -2054,11 +2091,22 @@ bool SnapshotManager::RemoveAllSnapshots(LockedFile* lock) {
     }
 
     if (ok || !has_mapped_cow_images) {
-        // Delete any image artifacts as a precaution, in case an update is
-        // being cancelled due to some corrupted state in an lp_metadata file.
-        // Note that we do not do this if some cow images are still mapped,
-        // since we must not remove backing storage if it's in use.
-        if (!EnsureImageManager() || !images_->RemoveAllImages()) {
+        if (!EnsureImageManager()) {
+            return false;
+        }
+
+        if (device_->IsRecovery()) {
+            // If a device is in recovery, we need to mark the snapshots for cleanup
+            // upon next reboot, since we cannot delete them here.
+            if (!images_->DisableAllImages()) {
+                LOG(ERROR) << "Could not remove all snapshot artifacts in recovery";
+                return false;
+            }
+        } else if (!images_->RemoveAllImages()) {
+            // Delete any image artifacts as a precaution, in case an update is
+            // being cancelled due to some corrupted state in an lp_metadata file.
+            // Note that we do not do this if some cow images are still mapped,
+            // since we must not remove backing storage if it's in use.
             LOG(ERROR) << "Could not remove all snapshot artifacts";
             return false;
         }
diff --git a/fs_mgr/libsnapshot/snapshot_stub.cpp b/fs_mgr/libsnapshot/snapshot_stub.cpp
index 93541020e51a..8edd44f8b483 100644
--- a/fs_mgr/libsnapshot/snapshot_stub.cpp
+++ b/fs_mgr/libsnapshot/snapshot_stub.cpp
@@ -188,4 +188,9 @@ void SnapshotManagerStub::SetMergeStatsFeatures(ISnapshotMergeStats*) {
     LOG(ERROR) << __FUNCTION__ << " should never be called.";
 }
 
+bool SnapshotManagerStub::IsCancelUpdateSafe() {
+    LOG(ERROR) << __FUNCTION__ << " should never be called.";
+    return false;
+}
+
 }  // namespace android::snapshot
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index 931de894345e..e04e429e3ddc 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -701,6 +701,7 @@ TEST_F(SnapshotTest, Merge) {
     }
 
     // We should not be able to cancel an update now.
+    ASSERT_EQ(sm->TryCancelUpdate(), CancelResult::NEEDS_MERGE);
     ASSERT_FALSE(sm->CancelUpdate());
 
     ASSERT_EQ(sm->ProcessUpdateState(), UpdateState::MergeCompleted);
@@ -2325,6 +2326,38 @@ TEST_F(SnapshotUpdateTest, DataWipeRequiredInPackage) {
     }
 }
 
+// Cancel an OTA in recovery.
+TEST_F(SnapshotUpdateTest, CancelInRecovery) {
+    AddOperationForPartitions();
+    // Execute the update.
+    ASSERT_TRUE(sm->BeginUpdate());
+    ASSERT_TRUE(sm->CreateUpdateSnapshots(manifest_));
+
+    // Write some data to target partitions.
+    ASSERT_TRUE(WriteSnapshots());
+
+    ASSERT_TRUE(sm->FinishedSnapshotWrites(true /* wipe */));
+
+    // Simulate shutting down the device.
+    ASSERT_TRUE(UnmapAll());
+
+    // Simulate a reboot into recovery.
+    auto test_device = new TestDeviceInfo(fake_super, "_b");
+    test_device->set_recovery(true);
+    auto new_sm = NewManagerForFirstStageMount(test_device);
+
+    EXPECT_EQ(new_sm->GetUpdateState(), UpdateState::Unverified);
+    ASSERT_FALSE(new_sm->IsCancelUpdateSafe());
+    ASSERT_TRUE(new_sm->CancelUpdate());
+
+    ASSERT_TRUE(new_sm->EnsureImageManager());
+    auto im = new_sm->image_manager();
+    ASSERT_NE(im, nullptr);
+    ASSERT_TRUE(im->IsImageDisabled("sys_b"));
+    ASSERT_TRUE(im->IsImageDisabled("vnd_b"));
+    ASSERT_TRUE(im->IsImageDisabled("prd_b"));
+}
+
 // Test update package that requests data wipe.
 TEST_F(SnapshotUpdateTest, DataWipeWithStaleSnapshots) {
     AddOperationForPartitions();
diff --git a/fs_mgr/libsnapshot/utility.cpp b/fs_mgr/libsnapshot/utility.cpp
index 7eaaca95bccf..30510d076b64 100644
--- a/fs_mgr/libsnapshot/utility.cpp
+++ b/fs_mgr/libsnapshot/utility.cpp
@@ -205,6 +205,22 @@ std::ostream& operator<<(std::ostream& os, const Now&) {
     return os << std::put_time(&now, "%Y%m%d-%H%M%S");
 }
 
+std::ostream& operator<<(std::ostream& os, CancelResult result) {
+    switch (result) {
+        case CancelResult::OK:
+            return os << "ok";
+        case CancelResult::ERROR:
+            return os << "error";
+        case CancelResult::LIVE_SNAPSHOTS:
+            return os << "live_snapshots";
+        case CancelResult::NEEDS_MERGE:
+            return os << "needs_merge";
+        default:
+            LOG(ERROR) << "Unknown cancel result: " << static_cast<uint32_t>(result);
+            return os;
+    }
+}
+
 void AppendExtent(RepeatedPtrField<chromeos_update_engine::Extent>* extents, uint64_t start_block,
                   uint64_t num_blocks) {
     if (extents->size() > 0) {
diff --git a/fs_mgr/libsnapshot/utility.h b/fs_mgr/libsnapshot/utility.h
index 7dae942b354d..30c75c0f5222 100644
--- a/fs_mgr/libsnapshot/utility.h
+++ b/fs_mgr/libsnapshot/utility.h
@@ -123,6 +123,8 @@ bool FsyncDirectory(const char* dirname);
 struct Now {};
 std::ostream& operator<<(std::ostream& os, const Now&);
 
+std::ostream& operator<<(std::ostream& os, CancelResult);
+
 // Append to |extents|. Merged into the last element if possible.
 void AppendExtent(google::protobuf::RepeatedPtrField<chromeos_update_engine::Extent>* extents,
                   uint64_t start_block, uint64_t num_blocks);

From 3d009836dc246c77efdcfcad023666dbaafe7cec Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 8 Jan 2025 14:07:49 -0800
Subject: [PATCH 1349/1487] Add missing <algorithm> include for std::sort.

Change-Id: I9b7e85e433b32bf76f69f1486a217bdc843e7169
---
 property_service/libpropertyinfoserializer/trie_serializer.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/property_service/libpropertyinfoserializer/trie_serializer.cpp b/property_service/libpropertyinfoserializer/trie_serializer.cpp
index adeed1bf7c3f..f1632cdd4c91 100644
--- a/property_service/libpropertyinfoserializer/trie_serializer.cpp
+++ b/property_service/libpropertyinfoserializer/trie_serializer.cpp
@@ -16,6 +16,8 @@
 
 #include "trie_serializer.h"
 
+#include <algorithm>
+
 namespace android {
 namespace properties {
 

From da4ac7cac66894a8493d52f2ebcdfa0cfc321f95 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 8 Jan 2025 15:17:26 -0800
Subject: [PATCH 1350/1487] Modernize logging slightly.

Any trailing `\n` gets stripped, and `%m` is a more convenient way to say `strerror(errno)`.

Change-Id: Id06bca51de4ae04b2e71eaeae0d8a174d1cffe14
---
 libcutils/ashmem-dev.cpp | 37 ++++++++++++++++++-------------------
 1 file changed, 18 insertions(+), 19 deletions(-)

diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index 615ef5e2fae6..adf7e3742590 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -106,7 +106,7 @@ static bool __has_memfd_support() {
      */
     if (!android::base::GetBoolProperty("sys.use_memfd", false)) {
         if (debug_log) {
-            ALOGD("sys.use_memfd=false so memfd disabled\n");
+            ALOGD("sys.use_memfd=false so memfd disabled");
         }
         return false;
     }
@@ -123,12 +123,12 @@ static bool __has_memfd_support() {
     android::base::unique_fd fd(
             syscall(__NR_memfd_create, "test_android_memfd", MFD_CLOEXEC | MFD_NOEXEC_SEAL));
     if (fd == -1) {
-        ALOGE("memfd_create failed: %s, no memfd support.\n", strerror(errno));
+        ALOGE("memfd_create failed: %m, no memfd support");
         return false;
     }
 
     if (fcntl(fd, F_ADD_SEALS, F_SEAL_FUTURE_WRITE) == -1) {
-        ALOGE("fcntl(F_ADD_SEALS) failed: %s, no memfd support.\n", strerror(errno));
+        ALOGE("fcntl(F_ADD_SEALS) failed: %m, no memfd support");
         return false;
     }
 
@@ -137,13 +137,13 @@ static bool __has_memfd_support() {
      * fall back to using ashmem.
      */
     if (TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_SET_SIZE, getpagesize())) < 0) {
-        ALOGE("ioctl(ASHMEM_SET_SIZE) failed: %s, no ashmem-memfd compat support.\n",
-              strerror(errno));
+        ALOGE("ioctl(ASHMEM_SET_SIZE, %d) failed: %m, no ashmem-memfd compat support",
+              getpagesize());
         return false;
     }
 
     if (debug_log) {
-        ALOGD("memfd: device has memfd support, using it\n");
+        ALOGD("memfd: device has memfd support, using it");
     }
     return true;
 }
@@ -161,7 +161,7 @@ static std::string get_ashmem_device_path() {
     static const std::string boot_id_path = "/proc/sys/kernel/random/boot_id";
     std::string boot_id;
     if (!android::base::ReadFileToString(boot_id_path, &boot_id)) {
-        ALOGE("Failed to read %s: %s.\n", boot_id_path.c_str(), strerror(errno));
+        ALOGE("Failed to read %s: %m", boot_id_path.c_str());
         return "";
     };
     boot_id = android::base::Trim(boot_id);
@@ -283,7 +283,7 @@ static bool memfd_is_ashmem(int fd) {
 
     if (__ashmem_is_ashmem(fd, 0) == 0) {
         if (!fd_check_error_once) {
-            ALOGE("memfd: memfd expected but ashmem fd used - please use libcutils.\n");
+            ALOGE("memfd: memfd expected but ashmem fd used - please use libcutils");
             fd_check_error_once = true;
         }
 
@@ -314,12 +314,12 @@ static int memfd_create_region(const char* name, size_t size) {
     android::base::unique_fd fd(syscall(__NR_memfd_create, name, MFD_CLOEXEC | MFD_NOEXEC_SEAL));
 
     if (fd == -1) {
-        ALOGE("memfd_create(%s, %zd) failed: %s\n", name, size, strerror(errno));
+        ALOGE("memfd_create(%s, %zd) failed: %m", name, size);
         return -1;
     }
 
     if (ftruncate(fd, size) == -1) {
-        ALOGE("ftruncate(%s, %zd) failed for memfd creation: %s\n", name, size, strerror(errno));
+        ALOGE("ftruncate(%s, %zd) failed for memfd creation: %m", name, size);
         return -1;
     }
 
@@ -330,7 +330,7 @@ static int memfd_create_region(const char* name, size_t size) {
     }
 
     if (debug_log) {
-        ALOGE("memfd_create(%s, %zd) success. fd=%d\n", name, size, fd.get());
+        ALOGE("memfd_create(%s, %zd) success. fd=%d", name, size, fd.get());
     }
     return fd.release();
 }
@@ -382,7 +382,7 @@ int ashmem_create_region(const char *name, size_t size)
 static int memfd_set_prot_region(int fd, int prot) {
     int seals = fcntl(fd, F_GET_SEALS);
     if (seals == -1) {
-        ALOGE("memfd_set_prot_region(%d, %d): F_GET_SEALS failed: %s\n", fd, prot, strerror(errno));
+        ALOGE("memfd_set_prot_region(%d, %d): F_GET_SEALS failed: %m", fd, prot);
         return -1;
     }
 
@@ -391,7 +391,7 @@ static int memfd_set_prot_region(int fd, int prot) {
          * has been previously marked as read-only before, if so return error
          */
         if (seals & F_SEAL_FUTURE_WRITE) {
-            ALOGE("memfd_set_prot_region(%d, %d): region is write protected\n", fd, prot);
+            ALOGE("memfd_set_prot_region(%d, %d): region is write protected", fd, prot);
             errno = EINVAL;  // inline with ashmem error code, if already in
                              // read-only mode
             return -1;
@@ -401,8 +401,7 @@ static int memfd_set_prot_region(int fd, int prot) {
 
     /* We would only allow read-only for any future file operations */
     if (fcntl(fd, F_ADD_SEALS, F_SEAL_FUTURE_WRITE) == -1) {
-        ALOGE("memfd_set_prot_region(%d, %d): F_SEAL_FUTURE_WRITE seal failed: %s\n",
-              fd, prot, strerror(errno));
+        ALOGE("memfd_set_prot_region(%d, %d): F_SEAL_FUTURE_WRITE seal failed: %m", fd, prot);
         return -1;
     }
 
@@ -421,7 +420,7 @@ int ashmem_set_prot_region(int fd, int prot)
 int ashmem_pin_region(int fd, size_t offset, size_t len)
 {
     if (!pin_deprecation_warn || debug_log) {
-        ALOGE("Pinning is deprecated since Android Q. Please use trim or other methods.\n");
+        ALOGE("Pinning is deprecated since Android Q. Please use trim or other methods.");
         pin_deprecation_warn = true;
     }
 
@@ -437,7 +436,7 @@ int ashmem_pin_region(int fd, size_t offset, size_t len)
 int ashmem_unpin_region(int fd, size_t offset, size_t len)
 {
     if (!pin_deprecation_warn || debug_log) {
-        ALOGE("Pinning is deprecated since Android Q. Please use trim or other methods.\n");
+        ALOGE("Pinning is deprecated since Android Q. Please use trim or other methods.");
         pin_deprecation_warn = true;
     }
 
@@ -456,12 +455,12 @@ int ashmem_get_size_region(int fd)
         struct stat sb;
 
         if (fstat(fd, &sb) == -1) {
-            ALOGE("ashmem_get_size_region(%d): fstat failed: %s\n", fd, strerror(errno));
+            ALOGE("ashmem_get_size_region(%d): fstat failed: %m", fd);
             return -1;
         }
 
         if (debug_log) {
-            ALOGD("ashmem_get_size_region(%d): %d\n", fd, static_cast<int>(sb.st_size));
+            ALOGD("ashmem_get_size_region(%d): %d", fd, static_cast<int>(sb.st_size));
         }
 
         return sb.st_size;

From 16974aa4262e5c006215d0775c609fcba0c3d116 Mon Sep 17 00:00:00 2001
From: "Chaitanya Cheemala (xWF)" <ccheemala@google.com>
Date: Thu, 9 Jan 2025 02:01:41 -0800
Subject: [PATCH 1351/1487] Revert "modprobe: Always log failures to the kernel
 logger"

This reverts commit 97f18afaf1a630f71609bb65b9ae424c3f6910c4.

Reason for revert: Likely culprit for b/388717752  - verifying through ABTD before revert submission. This is part of the standard investigation process, and does not mean your CL will be reverted.

Change-Id: I8eac70278e969063082be62a6ecf057df7b9581e
---
 toolbox/modprobe.cpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index fa6297d807f8..13026ac30aa8 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -52,7 +52,7 @@ void print_usage(void) {
     LOG(INFO) << "  -h, --help: Print this help";
     LOG(INFO) << "  -l, --list: List modules matching pattern";
     LOG(INFO) << "  -r, --remove: Remove MODULE (multiple modules may be specified)";
-    LOG(INFO) << "  -s, --syslog: print to syslog also (deprecated)";
+    LOG(INFO) << "  -s, --syslog: print to syslog also";
     LOG(INFO) << "  -q, --quiet: disable messages";
     LOG(INFO) << "  -v, --verbose: enable more messages, even more with a second -v";
     LOG(INFO);
@@ -76,10 +76,12 @@ std::string stripComments(const std::string& str) {
     /* NOTREACHED */
 }
 
+auto syslog = false;
+
 void MyLogger(android::base::LogId id, android::base::LogSeverity severity, const char* tag,
               const char* file, unsigned int line, const char* message) {
     android::base::StdioLogger(id, severity, tag, file, line, message);
-    if (message[0]) {
+    if (syslog && message[0]) {
         android::base::KernelLogger(id, severity, tag, file, line, message);
     }
 }
@@ -198,6 +200,7 @@ extern "C" int modprobe_main(int argc, char** argv) {
                 mode = RemoveModulesMode;
                 break;
             case 's':
+                syslog = true;
                 break;
             case 'v':
                 if (android::base::GetMinimumLogSeverity() <= android::base::DEBUG) {

From ead68b848161fa8cb2610eec9610fa8c40091eb6 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Thu, 9 Jan 2025 05:09:39 -0800
Subject: [PATCH 1352/1487] Revert^2 "modprobe: Always log failures to the
 kernel logger"

This reverts commit 16974aa4262e5c006215d0775c609fcba0c3d116.

Reason for revert: original breakage fixed

Change-Id: I9b4c62a462cfeb57300b0037465d636da1479c44
---
 toolbox/modprobe.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index 13026ac30aa8..fa6297d807f8 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -52,7 +52,7 @@ void print_usage(void) {
     LOG(INFO) << "  -h, --help: Print this help";
     LOG(INFO) << "  -l, --list: List modules matching pattern";
     LOG(INFO) << "  -r, --remove: Remove MODULE (multiple modules may be specified)";
-    LOG(INFO) << "  -s, --syslog: print to syslog also";
+    LOG(INFO) << "  -s, --syslog: print to syslog also (deprecated)";
     LOG(INFO) << "  -q, --quiet: disable messages";
     LOG(INFO) << "  -v, --verbose: enable more messages, even more with a second -v";
     LOG(INFO);
@@ -76,12 +76,10 @@ std::string stripComments(const std::string& str) {
     /* NOTREACHED */
 }
 
-auto syslog = false;
-
 void MyLogger(android::base::LogId id, android::base::LogSeverity severity, const char* tag,
               const char* file, unsigned int line, const char* message) {
     android::base::StdioLogger(id, severity, tag, file, line, message);
-    if (syslog && message[0]) {
+    if (message[0]) {
         android::base::KernelLogger(id, severity, tag, file, line, message);
     }
 }
@@ -200,7 +198,6 @@ extern "C" int modprobe_main(int argc, char** argv) {
                 mode = RemoveModulesMode;
                 break;
             case 's':
-                syslog = true;
                 break;
             case 'v':
                 if (android::base::GetMinimumLogSeverity() <= android::base::DEBUG) {

From f90fbd6df0281885f571f75350c6a76a80b77540 Mon Sep 17 00:00:00 2001
From: Alyssa Haroldsen <kupiakos@google.com>
Date: Wed, 4 Dec 2024 23:32:39 +0000
Subject: [PATCH 1353/1487] Add a sysprop-as-API for Trusty Android properties

This provides access to the Android system properties that Trusty
defines. It does not grant any access to these properties from within
Trusty itself.

Bug: 382335252
Test: Use libtrustyproperties_rust in a rust_binary, call
Test: `trustyproperties::trustproperties::vm_cid()`
Change-Id: I7426eeaf6bee5cdb1eb644044a50953063440906
---
 trusty/sysprops/Android.bp                    | 15 +++++
 .../sysprop/trusty/security_vm.sysprop        | 67 +++++++++++++++++++
 .../api/trusty-properties-current.txt         | 11 +++
 .../sysprops/api/trusty-properties-latest.txt | 11 +++
 trusty/sysprops/example.rs                    | 11 +++
 5 files changed, 115 insertions(+)
 create mode 100644 trusty/sysprops/Android.bp
 create mode 100644 trusty/sysprops/android/sysprop/trusty/security_vm.sysprop
 create mode 100644 trusty/sysprops/api/trusty-properties-current.txt
 create mode 100644 trusty/sysprops/api/trusty-properties-latest.txt
 create mode 100644 trusty/sysprops/example.rs

diff --git a/trusty/sysprops/Android.bp b/trusty/sysprops/Android.bp
new file mode 100644
index 000000000000..ec27f517fef7
--- /dev/null
+++ b/trusty/sysprops/Android.bp
@@ -0,0 +1,15 @@
+sysprop_library {
+    name: "trusty-properties",
+    srcs: ["android/sysprop/trusty/security_vm.sysprop"],
+    property_owner: "Platform",
+    api_packages: ["android.sysprop.trusty"],
+    apex_available: [
+        "//apex_available:platform",
+    ],
+}
+
+rust_binary {
+    name: "trusty-properties-example",
+    srcs: ["example.rs"],
+    rustlibs: ["libtrusty_properties_rust"],
+}
diff --git a/trusty/sysprops/android/sysprop/trusty/security_vm.sysprop b/trusty/sysprops/android/sysprop/trusty/security_vm.sysprop
new file mode 100644
index 000000000000..a079ecf1e37c
--- /dev/null
+++ b/trusty/sysprops/android/sysprop/trusty/security_vm.sysprop
@@ -0,0 +1,67 @@
+# Copyright (C) 2025 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.
+
+# This module accesses properties regarding the Trusty VM that runs apps
+# used to provide security for the system, such as Keymint or Gatekeeper.
+
+module: "android.sysprop.trusty.security_vm"
+owner: Platform
+
+# The default Context Identifier to connect to Trusty over vsock.
+prop {
+    api_name: "vm_cid"
+    prop_name: "trusty.security_vm.vm_cid"
+    type: Integer
+    scope: Internal
+    access: Readonly
+}
+
+# Signals when a nonsecure VM is ready.
+#
+# This is used to launch dependent HALs.
+#
+# Trusty security VMs come in two flavors: non-secure and secure.
+#
+# 1. Non-secure VMs run on emulated environments like Cuttlefish, which lack
+#    pVM firmware and TEE support. Consequently, KeyMint's root-of-trust data
+#    is passed into the VM from the host's HAL, and an RPMB proxy provides
+#    secure storage.
+# 2. Secure VMs run on physical devices. Here, pVM firmware handles the
+#    transfer of root-of-trust data via DeviceTree, and a TEE provides secure
+#    storage.
+prop {
+    api_name: "nonsecure_vm_ready"
+    prop_name: "trusty.security_vm.nonsecure_vm_ready"
+    type: Boolean
+    scope: Internal
+    access: Readonly
+}
+
+# The Trusty Security VM is enabled.
+prop {
+    api_name: "enabled"
+    prop_name: "trusty.security_vm.enabled"
+    type: Boolean
+    scope: Public
+    access: Readonly
+}
+
+# KeyMint is enabled in the Trusty Security VM.
+prop {
+    api_name: "keymint_enabled"
+    prop_name: "trusty.security_vm.keymint.enabled"
+    type: Boolean
+    scope: Public
+    access: Readonly
+}
diff --git a/trusty/sysprops/api/trusty-properties-current.txt b/trusty/sysprops/api/trusty-properties-current.txt
new file mode 100644
index 000000000000..aa792fcef24f
--- /dev/null
+++ b/trusty/sysprops/api/trusty-properties-current.txt
@@ -0,0 +1,11 @@
+props {
+  module: "android.sysprop.trusty.security_vm"
+  prop {
+    api_name: "enabled"
+    prop_name: "trusty.security_vm.enabled"
+  }
+  prop {
+    api_name: "keymint_enabled"
+    prop_name: "trusty.security_vm.keymint.enabled"
+  }
+}
diff --git a/trusty/sysprops/api/trusty-properties-latest.txt b/trusty/sysprops/api/trusty-properties-latest.txt
new file mode 100644
index 000000000000..aa792fcef24f
--- /dev/null
+++ b/trusty/sysprops/api/trusty-properties-latest.txt
@@ -0,0 +1,11 @@
+props {
+  module: "android.sysprop.trusty.security_vm"
+  prop {
+    api_name: "enabled"
+    prop_name: "trusty.security_vm.enabled"
+  }
+  prop {
+    api_name: "keymint_enabled"
+    prop_name: "trusty.security_vm.keymint.enabled"
+  }
+}
diff --git a/trusty/sysprops/example.rs b/trusty/sysprops/example.rs
new file mode 100644
index 000000000000..f21e779e8a66
--- /dev/null
+++ b/trusty/sysprops/example.rs
@@ -0,0 +1,11 @@
+//! Example showing how to access the `trusty.security_vm.vm_cid` system property with Rust.
+
+use trusty_properties::security_vm;
+
+fn main() {
+    match security_vm::vm_cid() {
+        Ok(Some(cid)) => println!("CID: {cid}"),
+        Ok(None) => println!("CID property not set"),
+        Err(e) => println!("Error: {e:?}"),
+    }
+}

From 65d14177a5d4ff10401a92521394aec3cb71c6d0 Mon Sep 17 00:00:00 2001
From: William Escande <wescande@google.com>
Date: Thu, 9 Jan 2025 14:38:09 -0800
Subject: [PATCH 1354/1487] Modify apex_available to Bluetooth apex

Bluetooth apex name has changed from com.android.btservices to
com.android.bt. We now need to update the reference in the code.

Updating apex_available in bp and other reference from within the code

Bug: 383863941
Flag: Exempt build infra
Test: m .
Change-Id: I905e2087439229cee18f2ee571947252e1dc1763
---
 libstats/expresslog/Android.bp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libstats/expresslog/Android.bp b/libstats/expresslog/Android.bp
index f70252afc777..ad86d87c1fb3 100644
--- a/libstats/expresslog/Android.bp
+++ b/libstats/expresslog/Android.bp
@@ -51,7 +51,7 @@ cc_library {
     min_sdk_version: "33",
     apex_available: [
         "//apex_available:platform",
-        "com.android.btservices",
+        "com.android.bt",
     ],
 }
 
@@ -85,7 +85,7 @@ cc_library_static {
     min_sdk_version: "33",
     apex_available: [
         "//apex_available:platform",
-        "com.android.btservices",
+        "com.android.bt",
     ],
 }
 

From 21ac1a020fc69e8df6c7579bbd10d40a28030e03 Mon Sep 17 00:00:00 2001
From: "Priyanka Advani (xWF)" <padvani@google.com>
Date: Fri, 10 Jan 2025 11:18:06 -0800
Subject: [PATCH 1355/1487] Revert "Add toolbox_ramdisk"

Revert submission 3421399-modprobe.static.ramdisk

Reason for revert: Droidmonitor created revert due to b/389116741. Will be verifying through ABTD before submission.

Reverted changes: /q/submissionid:3421399-modprobe.static.ramdisk

Change-Id: Ie512440227f09964a6f36753b4cf01dc4db4f8df
---
 toolbox/Android.bp | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/toolbox/Android.bp b/toolbox/Android.bp
index 5169aa1b28b2..3142542989f4 100644
--- a/toolbox/Android.bp
+++ b/toolbox/Android.bp
@@ -84,22 +84,3 @@ cc_binary {
     vendor: true,
     defaults: ["toolbox_binary_defaults"],
 }
-
-// This one is installed in the generic ramdisk, and can be executed during
-// init-first-stage.
-// As there are no dynamic linker available, this must be statically linked.
-cc_binary {
-    name: "toolbox_ramdisk",
-    defaults: ["toolbox_binary_defaults"],
-    ramdisk: true,
-    static_executable: true,
-    system_shared_libs: [],
-    exclude_shared_libs: [
-        "libbase",
-        "liblog",
-    ],
-    static_libs: [
-        "libbase",
-        "liblog",
-    ],
-}

From 19848dbcf46b7948eb67b302e97016cf8cfa6a39 Mon Sep 17 00:00:00 2001
From: Owner Cleanup Bot
 <swarming-tasks@owners-cleanup-prod.google.com.iam.gserviceaccount.com>
Date: Sun, 12 Jan 2025 08:59:28 -0800
Subject: [PATCH 1356/1487] [owners] Remove eugenis@google.com from
 init/test_upgrade_mte/OWNERS

This suggested change is automatically generated based on group
memberships and affiliations.
If this change is unnecessary or in error, vote the lowest CR value
(i.e. reject the CL) and the bot will abandon it. Vote the highest CR to
approve this change. You may also abandon this change.

See the owner's recent activity for context:
https://android-review.googlesource.com/q/eugenis@google.com

To report an issue, file a bug in the Infra>Codereview component.

Change-Id: I77972bf618d4b7aeb1fe0c1c38ccee56443e41cf
---
 init/test_upgrade_mte/OWNERS | 1 -
 1 file changed, 1 deletion(-)

diff --git a/init/test_upgrade_mte/OWNERS b/init/test_upgrade_mte/OWNERS
index c95d3cfd00e2..a49d9cedf04f 100644
--- a/init/test_upgrade_mte/OWNERS
+++ b/init/test_upgrade_mte/OWNERS
@@ -1,4 +1,3 @@
 fmayer@google.com
 
-eugenis@google.com
 pcc@google.com

From 3d7ae43e24debef892ca501df2d1f12fc223d116 Mon Sep 17 00:00:00 2001
From: Yi-Yo Chiang <yochiang@google.com>
Date: Sun, 12 Jan 2025 21:53:37 -0800
Subject: [PATCH 1357/1487] Revert^2 "Add toolbox_ramdisk"

21ac1a020fc69e8df6c7579bbd10d40a28030e03

Change-Id: Ia78dea4472584e6fd2ac631b67630b12f8af3cd0
---
 toolbox/Android.bp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/toolbox/Android.bp b/toolbox/Android.bp
index 3142542989f4..5169aa1b28b2 100644
--- a/toolbox/Android.bp
+++ b/toolbox/Android.bp
@@ -84,3 +84,22 @@ cc_binary {
     vendor: true,
     defaults: ["toolbox_binary_defaults"],
 }
+
+// This one is installed in the generic ramdisk, and can be executed during
+// init-first-stage.
+// As there are no dynamic linker available, this must be statically linked.
+cc_binary {
+    name: "toolbox_ramdisk",
+    defaults: ["toolbox_binary_defaults"],
+    ramdisk: true,
+    static_executable: true,
+    system_shared_libs: [],
+    exclude_shared_libs: [
+        "libbase",
+        "liblog",
+    ],
+    static_libs: [
+        "libbase",
+        "liblog",
+    ],
+}

From 1004ca8be7479509821859436406a66f30c1f719 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 13 Jan 2025 07:33:08 -0800
Subject: [PATCH 1358/1487] Add missing <stdlib.h> for
 calloc()/free()/strtoul().

Change-Id: I22bf6e72b065142cfea5da8aff699043e8a8196b
---
 libpackagelistparser/packagelistparser.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libpackagelistparser/packagelistparser.cpp b/libpackagelistparser/packagelistparser.cpp
index 638cc43fe9cb..5517b68c6600 100644
--- a/libpackagelistparser/packagelistparser.cpp
+++ b/libpackagelistparser/packagelistparser.cpp
@@ -21,6 +21,7 @@
 #include <errno.h>
 #include <inttypes.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <sys/limits.h>
 

From d5b10fc9d6cf4ace3d185d60467c74cd28dd21a2 Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Mon, 13 Jan 2025 17:20:14 -0800
Subject: [PATCH 1359/1487] Skip guest register getting on arm32.

Currently, there is no support for a guest architecture when running
in an arm 32 bit process. So always return false in that case instead
of spamming the log with useless messages.

Bug: 384944467

Test: debuggerd tests pass with no extraneous error messages.
Change-Id: I8152f1e76031e8b765c4c594b0bbc6800ab60c9e
---
 debuggerd/crash_dump.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index 7d3830c5404d..92d81b326db0 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -451,10 +451,8 @@ static bool GetGuestRegistersFromCrashedProcess(pid_t tid, NativeBridgeGuestRegs
     return false;
   }
 #elif defined(__arm__)
-  if (ptrace(PTRACE_GET_THREAD_AREA, tid, nullptr, &base) == 0) {
-    PLOG(ERROR) << "failed to get thread area for thread " << tid;
-    return false;
-  }
+  // Arm doesn't support any guest architectures yet.
+  return false;
 #elif defined(__i386__)
   struct user_regs_struct regs;
   struct iovec pt_iov = {.iov_base = &regs, .iov_len = sizeof(regs)};

From 0168b2a55d82230e5fbf5db12642f9b1fc326506 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 6 Jan 2025 06:38:00 -0800
Subject: [PATCH 1360/1487] Global clang-tidy's dead, and not coming back.

Change-Id: I99f8e032b2ddc6fce1f876b9642785c788bc4b9e
---
 debuggerd/crasher/Android.bp             |  1 -
 debuggerd/test_permissive_mte/Android.bp |  1 -
 fastboot/Android.bp                      |  6 ------
 libsysutils/Android.bp                   | 12 ------------
 4 files changed, 20 deletions(-)

diff --git a/debuggerd/crasher/Android.bp b/debuggerd/crasher/Android.bp
index 4c6a400a1d7b..3af806b43151 100644
--- a/debuggerd/crasher/Android.bp
+++ b/debuggerd/crasher/Android.bp
@@ -15,7 +15,6 @@ cc_defaults {
         "-fstack-protector-all",
         "-Wno-date-time",
     ],
-    tidy: false, // crasher.cpp tests many memory access errors
     srcs: ["crasher.cpp"],
     arch: {
         arm: {
diff --git a/debuggerd/test_permissive_mte/Android.bp b/debuggerd/test_permissive_mte/Android.bp
index f333242cc7a8..4403b8a94c67 100644
--- a/debuggerd/test_permissive_mte/Android.bp
+++ b/debuggerd/test_permissive_mte/Android.bp
@@ -18,7 +18,6 @@ package {
 
 cc_binary {
     name: "mte_crash",
-    tidy: false,
     srcs: ["mte_crash.cpp"],
     sanitize: {
         memtag_heap: true,
diff --git a/fastboot/Android.bp b/fastboot/Android.bp
index d3e058150c17..6e47a0825bf0 100644
--- a/fastboot/Android.bp
+++ b/fastboot/Android.bp
@@ -307,12 +307,6 @@ cc_library_host_static {
 
     generated_headers: ["platform_tools_version"],
 
-    tidy_flags: [
-        // DO NOT add quotes around header-filter flag regex argument,
-        // because build/soong will add quotes around the whole flag.
-        "-header-filter=(system/core/fastboot/|development/host/windows/usb/api/)",
-    ],
-
     target: {
         windows: {
             srcs: ["usb_windows.cpp"],
diff --git a/libsysutils/Android.bp b/libsysutils/Android.bp
index 842db4033b61..18a6aa6552cd 100644
--- a/libsysutils/Android.bp
+++ b/libsysutils/Android.bp
@@ -32,18 +32,6 @@ cc_library {
 
     export_include_dirs: ["include"],
 
-    tidy: true,
-    tidy_checks: [
-        "-*",
-        "cert-*",
-        "clang-analyzer-security*",
-        "android-*",
-    ],
-    tidy_checks_as_errors: [
-        "cert-*",
-        "clang-analyzer-security*",
-        "android-*",
-    ],
     apex_available: [
         "//apex_available:anyapex",
         "//apex_available:platform",

From 237db1e7c476487ccd9409c6119739afeecec6ec Mon Sep 17 00:00:00 2001
From: Takaya Saeki <takayas@google.com>
Date: Tue, 17 Dec 2024 09:33:31 +0000
Subject: [PATCH 1361/1487] libprefetch: fix property names in the .rc script

Current property names in .rc do not match what libprefetch actually
expects. In addition, the name of the property to stop the record starts
with `ro.` while it is expected to be modified. This commit fixes these
problems. Since prefetch was not working due to mismatching names, this
fix should not introduce a breaking change.


Bug: 380766679
Test: Test prefetch works on a Cuttlefish
Change-Id: I588b6f555fa9797a1a089aa983bcdc47bbb5e17e
Signed-off-by: Takaya Saeki <takayas@google.com>
---
 init/libprefetch/prefetch/prefetch.rc         | 4 ++--
 init/libprefetch/prefetch/src/arch/android.rs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/init/libprefetch/prefetch/prefetch.rc b/init/libprefetch/prefetch/prefetch.rc
index fb3fb3b6a3bb..dee37bb49e47 100644
--- a/init/libprefetch/prefetch/prefetch.rc
+++ b/init/libprefetch/prefetch/prefetch.rc
@@ -8,7 +8,7 @@ service prefetch /system/bin/prefetch start
     disabled
     oneshot
 
-on property:ro.prefetch_boot.record=true
+on property:prefetch_boot.record=true
     start prefetch_record
 
 service prefetch_record /system/bin/prefetch record --duration ${ro.prefetch_boot.duration_s:-0}
@@ -18,7 +18,7 @@ service prefetch_record /system/bin/prefetch record --duration ${ro.prefetch_boo
     disabled
     oneshot
 
-on property:ro.prefetch_boot.replay=true
+on property:prefetch_boot.replay=true
     start prefetch_replay
 
 service prefetch_replay /system/bin/prefetch replay --io-depth ${ro.prefetch_boot.io_depth:-2} --max-fds ${ro.prefetch_boot.max_fds:-128}
diff --git a/init/libprefetch/prefetch/src/arch/android.rs b/init/libprefetch/prefetch/src/arch/android.rs
index 3404e42b1403..a11767e152f4 100644
--- a/init/libprefetch/prefetch/src/arch/android.rs
+++ b/init/libprefetch/prefetch/src/arch/android.rs
@@ -13,7 +13,7 @@ use rustutils::system_properties::PropertyWatcher;
 
 const PREFETCH_RECORD_PROPERTY: &str = "prefetch_boot.record";
 const PREFETCH_REPLAY_PROPERTY: &str = "prefetch_boot.replay";
-const PREFETCH_RECORD_PROPERTY_STOP: &str = "ro.prefetch_boot.record_stop";
+const PREFETCH_RECORD_PROPERTY_STOP: &str = "prefetch_boot.record_stop";
 
 fn wait_for_property_true(
     property_name: &str,

From 179c81b3bb5b94bfe86fa9c522fb7dc81247490e Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 14 Jan 2025 23:52:15 +0000
Subject: [PATCH 1362/1487] libprocessgroup: Remove
 MemcgV2Test#ProactiveReclaimDoesntTakeForever

Post-boot CPU activity is interfering with this VTS test, causing the
20s threshold to be exceeded on some devices. The platform does not
(yet) use root memory.reclaim, so remove the test for now. If it's
brought back, we need to add a strategy to wait until post-boot CPU
activity has declined before reclaiming.

Bug: 389749646
Test: atest vts_libprocessgroup
Change-Id: I0a185db96591a22eb7377ae7866135c99c0339ad
---
 libprocessgroup/vts/vts_libprocessgroup.cpp | 37 ---------------------
 1 file changed, 37 deletions(-)

diff --git a/libprocessgroup/vts/vts_libprocessgroup.cpp b/libprocessgroup/vts/vts_libprocessgroup.cpp
index af0b0afe3749..e51fa3daae47 100644
--- a/libprocessgroup/vts/vts_libprocessgroup.cpp
+++ b/libprocessgroup/vts/vts_libprocessgroup.cpp
@@ -15,18 +15,14 @@
  */
 
 #include <cerrno>
-#include <chrono>
 #include <cstdio>
 #include <filesystem>
-#include <future>
 #include <iostream>
 #include <optional>
 #include <random>
 #include <string>
 #include <vector>
 
-#include <unistd.h>
-
 #include <android-base/file.h>
 #include <android-base/strings.h>
 using android::base::ReadFileToString;
@@ -83,16 +79,6 @@ std::optional<bool> checkRootSubtreeState() {
 
 }  // anonymous namespace
 
-
-class MemcgV2Test : public testing::Test {
-  protected:
-    void SetUp() override {
-        std::optional<bool> memcgV2Enabled = isMemcgV2Enabled();
-        ASSERT_NE(memcgV2Enabled, std::nullopt);
-        if (!*memcgV2Enabled) GTEST_SKIP() << "Memcg v2 not enabled";
-    }
-};
-
 class MemcgV2SubdirTest : public testing::Test {
   protected:
     std::optional<std::string> mRandDir;
@@ -150,26 +136,3 @@ TEST_F(MemcgV2SubdirTest, CanActivateMemcgV2Subtree) {
     ASSERT_TRUE(WriteStringToFile("+memory", *mRandDir + "/cgroup.subtree_control"))
             << "Could not enable memcg under child cgroup subtree";
 }
-
-// Test for fix: mm: memcg: use larger batches for proactive reclaim
-// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=287d5fedb377ddc232b216b882723305b27ae31a
-TEST_F(MemcgV2Test, ProactiveReclaimDoesntTakeForever) {
-    // Not all kernels have memory.reclaim
-    const std::filesystem::path reclaim(CGROUP_V2_ROOT_PATH + "/memory.reclaim");
-    if (!std::filesystem::exists(reclaim)) GTEST_SKIP() << "memory.reclaim not found";
-
-    // Use the total device memory as the amount to reclaim
-    const long numPages = sysconf(_SC_PHYS_PAGES);
-    const long pageSize = sysconf(_SC_PAGE_SIZE);
-    ASSERT_GT(numPages, 0);
-    ASSERT_GT(pageSize, 0);
-    const unsigned long long totalMem =
-            static_cast<unsigned long long>(numPages) * static_cast<unsigned long long>(pageSize);
-
-    auto fut = std::async(std::launch::async,
-                          [&]() { WriteStringToFile(std::to_string(totalMem), reclaim); });
-
-    // This is a test for completion within the timeout. The command is likely to "fail" since we
-    // are asking to reclaim all device memory.
-    ASSERT_NE(fut.wait_for(std::chrono::seconds(20)), std::future_status::timeout);
-}

From 2cc72c0e46aa254186bead99e88ab044403e470d Mon Sep 17 00:00:00 2001
From: Khyber Sen <khyber@google.com>
Date: Mon, 13 Jan 2025 07:30:31 +0000
Subject: [PATCH 1363/1487] rpc_binder: weigh sending a message to a TA more
 heavily in `trusty_tipc_fuzzer`

Instead of equally weighing
1. adding a new TA
2. removing a TA
3. sending a message to a TA
weigh 3. more heavily, 20%-20%-60% so that
more time is spent fuzzing sending actual messages.

Test: build.py qemu-generic-arm64-fuzz-test-debug &&
    ./build-root/build-qemu-generic-arm64-fuzz-test-debug/run.py &&
    lunch qemu_trusty_arm64-trunk_staging-userdebug &&
    m trusty_binder_fuzzer_multi_connection &&
    adb root &&
    adb sync data &&
    adb shell /data/fuzz/arm64/trusty_binder_fuzzer_multi_connection/trusty_binder_fuzzer_multi_connection

Change-Id: I5a24fef059ded2a706d5c9229469f89ce90d6c5e
---
 trusty/fuzz/tipc_fuzzer.cpp | 81 ++++++++++++++++++-------------------
 1 file changed, 40 insertions(+), 41 deletions(-)

diff --git a/trusty/fuzz/tipc_fuzzer.cpp b/trusty/fuzz/tipc_fuzzer.cpp
index d5e23e0086e2..f9f6c8c2ac83 100644
--- a/trusty/fuzz/tipc_fuzzer.cpp
+++ b/trusty/fuzz/tipc_fuzzer.cpp
@@ -97,48 +97,47 @@ void testOneInput(FuzzedDataProvider& provider) {
         static_assert(MAX_CONNECTIONS >= 1);
 
         // Either
-        // 1. Add a new TA and connect.
-        // 2. Remove a TA.
-        // 3. Send a random message to a random TA.
+        // 1. (20%) Add a new TA and connect.
+        // 2. (20%) Remove a TA.
+        // 3. (60%) Send a random message to a random TA.
+        auto add_ta = [&]() {
+            if (trustyApps.size() >= MAX_CONNECTIONS) {
+                return;
+            }
+            auto& ta = trustyApps.emplace_back(TIPC_DEV, TRUSTY_APP_PORT);
+            abortResult(ta.Connect());
+        };
+        auto remove_ta = [&]() {
+            if (trustyApps.empty()) {
+                return;
+            }
+            trustyApps.pop_back();
+        };
+        auto send_message = [&]() {
+            if (trustyApps.empty()) {
+                return;
+            }
+
+            // Choose a random TA.
+            const auto i = provider.ConsumeIntegralInRange<size_t>(0, trustyApps.size() - 1);
+            std::swap(trustyApps[i], trustyApps.back());
+            auto& ta = trustyApps.back();
+
+            // Send a random message.
+            const auto data = provider.ConsumeRandomLengthString();
+            abortResult(ta.Write(data.data(), data.size()));
+
+            std::array<uint8_t, TIPC_MAX_MSG_SIZE> buf;
+            abortResult(ta.Read(buf.data(), buf.size()));
+
+            // Reconnect to ensure that the service is still up.
+            ta.Disconnect();
+            abortResult(ta.Connect());
+        };
         const std::function<void()> options[] = {
-                // Add a new TA and connect.
-                [&]() {
-                    if (trustyApps.size() >= MAX_CONNECTIONS) {
-                        return;
-                    }
-                    auto& ta = trustyApps.emplace_back(TIPC_DEV, TRUSTY_APP_PORT);
-                    abortResult(ta.Connect());
-                },
-                // Remove a TA.
-                [&]() {
-                    if (trustyApps.empty()) {
-                        return;
-                    }
-                    trustyApps.pop_back();
-                },
-                // Send a random message to a random TA.
-                [&]() {
-                    if (trustyApps.empty()) {
-                        return;
-                    }
-
-                    // Choose a random TA.
-                    const auto i =
-                            provider.ConsumeIntegralInRange<size_t>(0, trustyApps.size() - 1);
-                    std::swap(trustyApps[i], trustyApps.back());
-                    auto& ta = trustyApps.back();
-
-                    // Send a random message.
-                    const auto data = provider.ConsumeRandomLengthString();
-                    abortResult(ta.Write(data.data(), data.size()));
-
-                    std::array<uint8_t, TIPC_MAX_MSG_SIZE> buf;
-                    abortResult(ta.Read(buf.data(), buf.size()));
-
-                    // Reconnect to ensure that the service is still up.
-                    ta.Disconnect();
-                    abortResult(ta.Connect());
-                },
+                add_ta,                                    // 1x: 20%
+                remove_ta,                                 // 1x: 20%
+                send_message, send_message, send_message,  // 3x: 60%
         };
 
         provider.PickValueInArray(options)();

From c0c5921b708fad333af28ae8326e7a5c4d28ad5f Mon Sep 17 00:00:00 2001
From: Wei Li <weiwli@google.com>
Date: Wed, 15 Jan 2025 13:18:28 -0800
Subject: [PATCH 1364/1487] Track the symlink /root/adb_keys in the build
 system properly

Bug: 389985381
Test: build/soong/tests/sbom_test.sh
Change-Id: I0f98cef01979fa3cd11f1460bbad395558afecef
---
 rootdir/create_root_structure.mk | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/rootdir/create_root_structure.mk b/rootdir/create_root_structure.mk
index d0be89769c9a..15d78a67b13f 100644
--- a/rootdir/create_root_structure.mk
+++ b/rootdir/create_root_structure.mk
@@ -41,7 +41,8 @@ ALL_ROOTDIR_SYMLINKS := \
   $(TARGET_ROOT_OUT)/etc \
   $(TARGET_ROOT_OUT)/bugreports \
   $(TARGET_ROOT_OUT)/d \
-  $(TARGET_ROOT_OUT)/sdcard
+  $(TARGET_ROOT_OUT)/sdcard \
+  $(TARGET_ROOT_OUT)/adb_keys \
 
 ifdef BOARD_USES_VENDORIMAGE
   LOCAL_POST_INSTALL_CMD += ; mkdir -p $(TARGET_ROOT_OUT)/vendor

From 86c1d55226dc3a5cab91382ac50a428d56d67f04 Mon Sep 17 00:00:00 2001
From: "Isaac J. Manjarres" <isaacmanjarres@google.com>
Date: Wed, 15 Jan 2025 14:06:32 -0800
Subject: [PATCH 1365/1487] ashmem_test: Cleanup and document fork tests

The tests that fork a child process and have the child process update
use ASSERT_EXIT() to fork and wait for the child process to terminate.
However, from looking at the code at a first pass, that is not entirely
obvious.

Therefore, document the fork tests and simplify some of the logic in
the tests.

No functional change.

Bug: 111903542
Change-Id: Iac923ccad9cea0fc7d823c6e2c46c47fbf6c0282
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
---
 libcutils/ashmem_test.cpp | 28 +++++++++++++++++++++++++---
 1 file changed, 25 insertions(+), 3 deletions(-)

diff --git a/libcutils/ashmem_test.cpp b/libcutils/ashmem_test.cpp
index ccbb8c97760f..e78934f16f04 100644
--- a/libcutils/ashmem_test.cpp
+++ b/libcutils/ashmem_test.cpp
@@ -84,6 +84,11 @@ TEST(AshmemTest, ForkTest) {
     ASSERT_EQ(0, memcmp(region1, data.data(), size));
     EXPECT_EQ(0, munmap(region1, size));
 
+    // This part of the test forks a separate process via ASSERT_EXIT() and
+    // clears the ashmem buffer.
+    //
+    // This is to ensure that updates to the contents of the buffer are visible
+    // across processes with a reference to the buffer.
     ASSERT_EXIT(
         {
             if (!ashmem_valid(fd)) {
@@ -206,15 +211,25 @@ TEST(AshmemTest, ForkProtTest) {
     int protFlags[] = { PROT_READ, PROT_WRITE };
     for (size_t i = 0; i < arraysize(protFlags); i++) {
         ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
+
+        // This part of the test forks a process via ASSERT_EXIT()
+        // and has the child process change the mapping permissions of the
+        // buffer.
+        //
+        // The intent of this is to ensure that updates to the buffer's
+        // mapping permissions are visible across processes that reference the
+        // buffer.
+        //
+        // In this case, the parent process attempts to map the buffer with a
+        // permission that is denied, which should fail.
         ASSERT_EXIT(
             {
                 if (!ashmem_valid(fd)) {
                     _exit(3);
-                } else if (ashmem_set_prot_region(fd, protFlags[i]) >= 0) {
-                    _exit(0);
-                } else {
+                } else if (ashmem_set_prot_region(fd, protFlags[i]) == -1) {
                     _exit(1);
                 }
+                _exit(0);
             },
             ::testing::ExitedWithCode(0), "");
         ASSERT_NO_FATAL_FAILURE(TestProtDenied(fd, size, protFlags[1-i]));
@@ -237,6 +252,13 @@ TEST(AshmemTest, ForkMultiRegionTest) {
         EXPECT_EQ(0, munmap(region, size));
     }
 
+    // This part of the test creates a child process via ASSERT_EXIT()
+    // that clears each of the ashmem buffers that were created earlier.
+    //
+    // The intent of this is for the parent process to check each region to make
+    // sure that the updates from the child process are visible, thereby showing
+    // that updates across multiple shared buffers are visible across multiple
+    // processes.
     ASSERT_EXIT({
         for (int i = 0; i < nRegions; i++) {
             if (!ashmem_valid(fd[i])) {

From 95c357244c36d62c3bc67db3ff70ce43e07e9765 Mon Sep 17 00:00:00 2001
From: "Isaac J. Manjarres" <isaacmanjarres@google.com>
Date: Fri, 27 Dec 2024 13:36:35 -0800
Subject: [PATCH 1366/1487] ashmem_test: Remove tests that remove read access

Memfds are always readable, and there is no way to restrict them
from being mapped as readable. There is also no known usecase for
which read access needs to be revoked. Therefore, remove tests that
rely on being able to remove read-access to ashmem buffers, since
those will fail when ashmem moves to using memfd.

Bug: 111903542
Change-Id: I9ef7c82f9dcf641b0bad997b7ca3d06f0344fb32
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
---
 libcutils/ashmem_test.cpp | 55 ++++++++++++++++-----------------------
 1 file changed, 23 insertions(+), 32 deletions(-)

diff --git a/libcutils/ashmem_test.cpp b/libcutils/ashmem_test.cpp
index e78934f16f04..9876914a1141 100644
--- a/libcutils/ashmem_test.cpp
+++ b/libcutils/ashmem_test.cpp
@@ -187,12 +187,6 @@ TEST(AshmemTest, ProtTest) {
     ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ, &region));
     EXPECT_EQ(0, munmap(region, size));
 
-    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_WRITE));
-    TestProtDenied(fd, size, PROT_READ);
-    TestProtIs(fd, PROT_WRITE);
-    ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_WRITE, &region));
-    EXPECT_EQ(0, munmap(region, size));
-
     ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
     TestProtIs(fd, PROT_READ | PROT_WRITE);
     ASSERT_EQ(0, ashmem_set_prot_region(fd, PROT_READ));
@@ -208,32 +202,29 @@ TEST(AshmemTest, ForkProtTest) {
     unique_fd fd;
     const size_t size = getpagesize();
 
-    int protFlags[] = { PROT_READ, PROT_WRITE };
-    for (size_t i = 0; i < arraysize(protFlags); i++) {
-        ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
-
-        // This part of the test forks a process via ASSERT_EXIT()
-        // and has the child process change the mapping permissions of the
-        // buffer.
-        //
-        // The intent of this is to ensure that updates to the buffer's
-        // mapping permissions are visible across processes that reference the
-        // buffer.
-        //
-        // In this case, the parent process attempts to map the buffer with a
-        // permission that is denied, which should fail.
-        ASSERT_EXIT(
-            {
-                if (!ashmem_valid(fd)) {
-                    _exit(3);
-                } else if (ashmem_set_prot_region(fd, protFlags[i]) == -1) {
-                    _exit(1);
-                }
-                _exit(0);
-            },
-            ::testing::ExitedWithCode(0), "");
-        ASSERT_NO_FATAL_FAILURE(TestProtDenied(fd, size, protFlags[1-i]));
-    }
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
+
+    // This part of the test forks a process via ASSERT_EXIT()
+    // and has the child process change the mapping permissions of the
+    // buffer to read-only.
+    //
+    // The intent of this is to ensure that updates to the buffer's
+    // mapping permissions are visible across processes that reference the
+    // buffer.
+    //
+    // In this case, the parent process attempts to map the buffer with write
+    // permission, which should fail.
+    ASSERT_EXIT(
+        {
+            if (!ashmem_valid(fd)) {
+                _exit(3);
+            } else if (ashmem_set_prot_region(fd, PROT_READ) == -1) {
+                _exit(1);
+            }
+            _exit(0);
+        },
+        ::testing::ExitedWithCode(0), "");
+    ASSERT_NO_FATAL_FAILURE(TestProtDenied(fd, size, PROT_WRITE));
 }
 
 TEST(AshmemTest, ForkMultiRegionTest) {

From 05af2766b70eeae61eaf1729847d3eb2a647a8eb Mon Sep 17 00:00:00 2001
From: "Isaac J. Manjarres" <isaacmanjarres@google.com>
Date: Wed, 15 Jan 2025 14:28:41 -0800
Subject: [PATCH 1367/1487] ashmem_test: Always include PROT_EXEC as an
 expected permission

Memfds can always be mapped with PROT_EXEC. There is no support for
removing that, and there is no known reason to support it. Therefore,
update the tests to always expect PROT_EXEC as part of the mapping
permissions.

Bug: 111903542
Change-Id: Ia8bd5d47e012e24045d7ea02f63fe1b15e41e933
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
---
 libcutils/ashmem_test.cpp | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/libcutils/ashmem_test.cpp b/libcutils/ashmem_test.cpp
index 9876914a1141..7abc370b6066 100644
--- a/libcutils/ashmem_test.cpp
+++ b/libcutils/ashmem_test.cpp
@@ -181,20 +181,22 @@ TEST(AshmemTest, ProtTest) {
     const size_t size = getpagesize();
     void *region;
 
-    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ));
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_EXEC));
     TestProtDenied(fd, size, PROT_WRITE);
-    TestProtIs(fd, PROT_READ);
+    TestProtIs(fd, PROT_READ | PROT_EXEC);
     ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ, &region));
     EXPECT_EQ(0, munmap(region, size));
 
-    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
-    TestProtIs(fd, PROT_READ | PROT_WRITE);
-    ASSERT_EQ(0, ashmem_set_prot_region(fd, PROT_READ));
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE |
+                                             PROT_EXEC));
+    TestProtIs(fd, PROT_READ | PROT_WRITE | PROT_EXEC);
+    ASSERT_EQ(0, ashmem_set_prot_region(fd, PROT_READ | PROT_EXEC));
     errno = 0;
-    ASSERT_EQ(-1, ashmem_set_prot_region(fd, PROT_READ | PROT_WRITE))
+    ASSERT_EQ(-1, ashmem_set_prot_region(fd, PROT_READ | PROT_WRITE |
+                                         PROT_EXEC))
         << "kernel shouldn't allow adding protection bits";
     EXPECT_EQ(EINVAL, errno);
-    TestProtIs(fd, PROT_READ);
+    TestProtIs(fd, PROT_READ | PROT_EXEC);
     TestProtDenied(fd, size, PROT_WRITE);
 }
 

From e28d3d1a9be50c6f3fde6540f054dcce9d09f0fd Mon Sep 17 00:00:00 2001
From: sashwinbalaji <sashwinbalaji@google.com>
Date: Thu, 16 Jan 2025 09:55:58 +0800
Subject: [PATCH 1368/1487] bootstat: Add NTC PMIC shutdown reason.

Add "reboot,ntc,pmic,sub" to kBootReasonMap

Bug: 385228865
Test: Trigger shutdown and validate adb shell bootstat -p
Change-Id: Ic67d3cd915e79eb1ce7feb3e900d387e9d02d641
---
 bootstat/bootstat.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bootstat/bootstat.cpp b/bootstat/bootstat.cpp
index d476d36a936f..687ffe42b266 100644
--- a/bootstat/bootstat.cpp
+++ b/bootstat/bootstat.cpp
@@ -469,6 +469,7 @@ const std::map<std::string, int32_t> kBootReasonMap = {
     {"reboot,ocp,pmic,if", 237},
     {"reboot,fship", 238},
     {"reboot,ocp,.*", 239},
+    {"reboot,ntc,pmic,sub", 240},
 };
 
 // Converts a string value representing the reason the system booted to an

From 09c52ca4be68141c2948492bc5ed10cc6088da87 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 16 Jan 2025 19:16:39 -0800
Subject: [PATCH 1369/1487] libsnapshot: Set compile_multilib to "first"

vts_libsnapshot_test32 fails as library android.hardware.boot@1.0.so
isn't built for 32-bit.

This will still test on 32-bit platforms.

Bug: 388929904
Test: vts_libsnapshot_test
Change-Id: I16d37095f3057b12c101a80e1493fa659ead3e3b
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/Android.bp | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/fs_mgr/libsnapshot/Android.bp b/fs_mgr/libsnapshot/Android.bp
index b5b976ab7e4b..af1991a7fc06 100644
--- a/fs_mgr/libsnapshot/Android.bp
+++ b/fs_mgr/libsnapshot/Android.bp
@@ -308,17 +308,15 @@ cc_test {
         "vts",
         "general-tests",
     ],
-    compile_multilib: "both",
-    multilib: {
-        lib32: {
-            suffix: "32",
-        },
-        lib64: {
-            suffix: "64",
-        },
-    },
+    compile_multilib: "first",
     test_options: {
         min_shipping_api_level: 30,
+        test_runner_options: [
+            {
+                name: "force-no-test-error",
+                value: "false",
+            },
+        ],
     },
 }
 

From cc226cb6938befe42cdbf291949a056c6c81a6a7 Mon Sep 17 00:00:00 2001
From: "Isaac J. Manjarres" <isaacmanjarres@google.com>
Date: Fri, 17 Jan 2025 11:28:09 -0800
Subject: [PATCH 1370/1487] ashmem_test: Rewrite fork tests to use fork()
 explicitly

The fork tests use the ASSERT_EXIT() macro to spawn a child process
that maniuplates ashmem buffers. However, using ASSERT_EXIT() makes
the child process creation non-obvious.

Therefore, make the tests easier to understand by using fork()
explicitly to capture what is going on in each test.

No functional change.

Bug: 390672531
Change-Id: I84d3c17d229a1036030eea40e159664b8eeb3af7
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
---
 libcutils/ashmem_test.cpp | 108 ++++++++++++++++++++------------------
 1 file changed, 57 insertions(+), 51 deletions(-)

diff --git a/libcutils/ashmem_test.cpp b/libcutils/ashmem_test.cpp
index 7abc370b6066..b0a552fbd6c8 100644
--- a/libcutils/ashmem_test.cpp
+++ b/libcutils/ashmem_test.cpp
@@ -69,6 +69,15 @@ void FillData(std::vector<uint8_t>& data) {
     }
 }
 
+static void waitForChildProcessExit(pid_t pid) {
+    int exitStatus;
+    pid_t childPid = waitpid(pid, &exitStatus, 0);
+
+    ASSERT_GT(childPid, 0);
+    ASSERT_TRUE(WIFEXITED(exitStatus));
+    ASSERT_EQ(0, WEXITSTATUS(exitStatus));
+}
+
 TEST(AshmemTest, ForkTest) {
     const size_t size = getpagesize();
     std::vector<uint8_t> data(size);
@@ -84,28 +93,30 @@ TEST(AshmemTest, ForkTest) {
     ASSERT_EQ(0, memcmp(region1, data.data(), size));
     EXPECT_EQ(0, munmap(region1, size));
 
-    // This part of the test forks a separate process via ASSERT_EXIT() and
-    // clears the ashmem buffer.
-    //
-    // This is to ensure that updates to the contents of the buffer are visible
-    // across processes with a reference to the buffer.
-    ASSERT_EXIT(
-        {
-            if (!ashmem_valid(fd)) {
-                _exit(3);
-            }
-            void* region2 = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-            if (region2 == MAP_FAILED) {
-                _exit(1);
-            }
-            if (memcmp(region2, data.data(), size) != 0) {
-                _exit(2);
-            }
-            memset(region2, 0, size);
-            munmap(region2, size);
-            _exit(0);
-        },
-        ::testing::ExitedWithCode(0), "");
+
+    pid_t pid = fork();
+    if (!pid) {
+        if (!ashmem_valid(fd)) {
+            _exit(3);
+        }
+
+        void *region2 = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+        if (region2 == MAP_FAILED) {
+            _exit(1);
+        } else if (memcmp(region2, data.data(), size) != 0){
+            _exit(2);
+        }
+
+        // Clear the ashmem buffer here to ensure that updates to the contents
+        // of the buffer are visible across processes with a reference to the
+        // buffer.
+        memset(region2, 0, size);
+        munmap(region2, size);
+        _exit(0);
+    } else {
+        ASSERT_GT(pid, 0);
+        ASSERT_NO_FATAL_FAILURE(waitForChildProcessExit(pid));
+    }
 
     memset(data.data(), 0, size);
     void *region2;
@@ -206,26 +217,22 @@ TEST(AshmemTest, ForkProtTest) {
 
     ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
 
-    // This part of the test forks a process via ASSERT_EXIT()
-    // and has the child process change the mapping permissions of the
-    // buffer to read-only.
-    //
-    // The intent of this is to ensure that updates to the buffer's
-    // mapping permissions are visible across processes that reference the
-    // buffer.
-    //
-    // In this case, the parent process attempts to map the buffer with write
-    // permission, which should fail.
-    ASSERT_EXIT(
-        {
-            if (!ashmem_valid(fd)) {
-                _exit(3);
-            } else if (ashmem_set_prot_region(fd, PROT_READ) == -1) {
-                _exit(1);
-            }
-            _exit(0);
-        },
-        ::testing::ExitedWithCode(0), "");
+    pid_t pid = fork();
+    if (!pid) {
+        // Change buffer mapping permissions to read-only to ensure that
+        // updates to the buffer's mapping permissions are visible across
+        // processes that reference the buffer.
+        if (!ashmem_valid(fd)) {
+            _exit(3);
+        } else if (ashmem_set_prot_region(fd, PROT_READ) == -1) {
+            _exit(1);
+        }
+        _exit(0);
+    } else {
+        ASSERT_GT(pid, 0);
+        ASSERT_NO_FATAL_FAILURE(waitForChildProcessExit(pid));
+    }
+
     ASSERT_NO_FATAL_FAILURE(TestProtDenied(fd, size, PROT_WRITE));
 }
 
@@ -245,14 +252,10 @@ TEST(AshmemTest, ForkMultiRegionTest) {
         EXPECT_EQ(0, munmap(region, size));
     }
 
-    // This part of the test creates a child process via ASSERT_EXIT()
-    // that clears each of the ashmem buffers that were created earlier.
-    //
-    // The intent of this is for the parent process to check each region to make
-    // sure that the updates from the child process are visible, thereby showing
-    // that updates across multiple shared buffers are visible across multiple
-    // processes.
-    ASSERT_EXIT({
+    pid_t pid = fork();
+    if (!pid) {
+        // Clear each ashmem buffer in the context of the child process to
+        // ensure that the updates are visible to the parent process later.
         for (int i = 0; i < nRegions; i++) {
             if (!ashmem_valid(fd[i])) {
                 _exit(3);
@@ -269,7 +272,10 @@ TEST(AshmemTest, ForkMultiRegionTest) {
             munmap(region, size);
         }
         _exit(0);
-    }, ::testing::ExitedWithCode(0), "");
+    } else {
+        ASSERT_GT(pid, 0);
+        ASSERT_NO_FATAL_FAILURE(waitForChildProcessExit(pid));
+    }
 
     memset(data.data(), 0, size);
     for (int i = 0; i < nRegions; i++) {

From 9af27a47d6d7969eaf1e16f1bd5c2ba6d35dd27b Mon Sep 17 00:00:00 2001
From: Newton Lam <newtonlam@google.com>
Date: Fri, 17 Jan 2025 20:53:21 -0800
Subject: [PATCH 1371/1487] Add create_snapshot flag to specific output file
 path.

Test: Ran create_snapshot with and without new output_dir flag
Bug: 383346328
Change-Id: I10373e12ac290fc63b734f55824bf895f212da56
---
 fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
index fd4e7da0d381..4f8bfd2c7595 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
@@ -36,6 +36,10 @@
 
 DEFINE_string(source, "", "Source partition image");
 DEFINE_string(target, "", "Target partition image");
+DEFINE_string(
+        output_dir, "",
+        "Output directory to write the patch file to. Defaults to current working directory if "
+        "not set.");
 DEFINE_string(compression, "lz4",
               "Compression algorithm. Default is set to lz4. Available options: lz4, zstd, gz");
 DEFINE_bool(merkel_tree, false, "If true, source image hash is obtained from verity merkel tree");
@@ -569,12 +573,15 @@ SYNOPSIS
 
     source.img -> Source partition image
     target.img -> Target partition image
-    compressoin -> compression algorithm. Default set to lz4. Supported types are gz, lz4, zstd.
+    compression -> compression algorithm. Default set to lz4. Supported types are gz, lz4, zstd.
+    merkel_tree -> If true, source image hash is obtained from verity merkel tree.
+    output_dir -> Output directory to write the patch file to. Defaults to current working directory if not set.
 
 EXAMPLES
 
    $ create_snapshot $SOURCE_BUILD/system.img $TARGET_BUILD/system.img
    $ create_snapshot $SOURCE_BUILD/product.img $TARGET_BUILD/product.img --compression="zstd"
+   $ create_snapshot $SOURCE_BUILD/product.img $TARGET_BUILD/product.img --merkel_tree --output_dir=/tmp/create_snapshot_output
 
 )";
 
@@ -591,6 +598,9 @@ int main(int argc, char* argv[]) {
     std::string fname = android::base::Basename(FLAGS_target.c_str());
     auto parts = android::base::Split(fname, ".");
     std::string snapshotfile = parts[0] + ".patch";
+    if (!FLAGS_output_dir.empty()) {
+        snapshotfile = FLAGS_output_dir + "/" + snapshotfile;
+    }
     android::snapshot::CreateSnapshot snapshot(FLAGS_source, FLAGS_target, snapshotfile,
                                                FLAGS_compression, FLAGS_merkel_tree);
 

From 301c8bdd8d21825a594c1e20335a956a0592a7b5 Mon Sep 17 00:00:00 2001
From: "Chaitanya Cheemala (xWF)" <ccheemala@google.com>
Date: Tue, 21 Jan 2025 01:12:55 -0800
Subject: [PATCH 1372/1487] Revert "Revert^2 "modprobe: Always log failures to
 the kernel lo..."

Revert submission 3442704-modprobe-kmsg-sepolicy

Reason for revert: Likely culprit for b/391279588  - verifying through ABTD before revert submission. This is part of the standard investigation process, and does not mean your CL will be reverted.

Reverted changes: /q/submissionid:3442704-modprobe-kmsg-sepolicy

Change-Id: Ibf0e47c9775de71cdbb9f4b5e4aac8da3acc5d04
---
 toolbox/modprobe.cpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index fa6297d807f8..13026ac30aa8 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -52,7 +52,7 @@ void print_usage(void) {
     LOG(INFO) << "  -h, --help: Print this help";
     LOG(INFO) << "  -l, --list: List modules matching pattern";
     LOG(INFO) << "  -r, --remove: Remove MODULE (multiple modules may be specified)";
-    LOG(INFO) << "  -s, --syslog: print to syslog also (deprecated)";
+    LOG(INFO) << "  -s, --syslog: print to syslog also";
     LOG(INFO) << "  -q, --quiet: disable messages";
     LOG(INFO) << "  -v, --verbose: enable more messages, even more with a second -v";
     LOG(INFO);
@@ -76,10 +76,12 @@ std::string stripComments(const std::string& str) {
     /* NOTREACHED */
 }
 
+auto syslog = false;
+
 void MyLogger(android::base::LogId id, android::base::LogSeverity severity, const char* tag,
               const char* file, unsigned int line, const char* message) {
     android::base::StdioLogger(id, severity, tag, file, line, message);
-    if (message[0]) {
+    if (syslog && message[0]) {
         android::base::KernelLogger(id, severity, tag, file, line, message);
     }
 }
@@ -198,6 +200,7 @@ extern "C" int modprobe_main(int argc, char** argv) {
                 mode = RemoveModulesMode;
                 break;
             case 's':
+                syslog = true;
                 break;
             case 'v':
                 if (android::base::GetMinimumLogSeverity() <= android::base::DEBUG) {

From ff1cdb3d3fdd35f7df7b50c64bc7a702483bbdc7 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 21 Jan 2025 17:01:36 -0500
Subject: [PATCH 1373/1487] Fix C++23 build.

Mostly missing #includes, but some incomplete types given to
std::unique_ptr too.

Change-Id: I50583874dca32607eeb48b5d640822a3417ff530
---
 .../libdebuggerd/include/libdebuggerd/open_files_list.h     | 1 +
 fastboot/fuzzy_fastboot/main.cpp                            | 1 +
 fastboot/fuzzy_fastboot/test_utils.cpp                      | 2 ++
 fastboot/fuzzy_fastboot/transport_sniffer.cpp               | 1 +
 fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp                | 1 +
 fs_mgr/liblp/fuzzer/liblp_super_layout_builder_fuzzer.cpp   | 1 +
 fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp           | 1 +
 fs_mgr/libsnapshot/snapuserd/testing/dm_user_harness.h      | 4 ++--
 .../snapuserd/user-space-merge/handler_manager.h            | 1 +
 init/capabilities.h                                         | 1 +
 init/property_service.cpp                                   | 6 ++----
 init/ueventd_test.cpp                                       | 1 +
 libcutils/android_get_control_file_test.cpp                 | 1 +
 libcutils/ashmem_base_test.cpp                              | 2 ++
 libmodprobe/include/modprobe/modprobe.h                     | 1 +
 libstats/bootstrap/BootstrapClientInternal.h                | 2 ++
 toolbox/getprop.cpp                                         | 1 +
 trusty/storage/proxy/watchdog.cpp                           | 1 +
 18 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/debuggerd/libdebuggerd/include/libdebuggerd/open_files_list.h b/debuggerd/libdebuggerd/include/libdebuggerd/open_files_list.h
index d47f2ddf6d6b..12a425e95bf2 100644
--- a/debuggerd/libdebuggerd/include/libdebuggerd/open_files_list.h
+++ b/debuggerd/libdebuggerd/include/libdebuggerd/open_files_list.h
@@ -20,6 +20,7 @@
 #include <sys/types.h>
 
 #include <map>
+#include <memory>
 #include <optional>
 #include <string>
 #include <utility>
diff --git a/fastboot/fuzzy_fastboot/main.cpp b/fastboot/fuzzy_fastboot/main.cpp
index 79f3939fe583..9eabbd3116ee 100644
--- a/fastboot/fuzzy_fastboot/main.cpp
+++ b/fastboot/fuzzy_fastboot/main.cpp
@@ -33,6 +33,7 @@
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <algorithm>
 #include <chrono>
 #include <cstdlib>
 #include <fstream>
diff --git a/fastboot/fuzzy_fastboot/test_utils.cpp b/fastboot/fuzzy_fastboot/test_utils.cpp
index 9ad98be60acf..b80db2357b7d 100644
--- a/fastboot/fuzzy_fastboot/test_utils.cpp
+++ b/fastboot/fuzzy_fastboot/test_utils.cpp
@@ -28,6 +28,8 @@
 #include "test_utils.h"
 #include <fcntl.h>
 #include <termios.h>
+#include <algorithm>
+#include <iterator>
 #include <sstream>
 
 namespace fastboot {
diff --git a/fastboot/fuzzy_fastboot/transport_sniffer.cpp b/fastboot/fuzzy_fastboot/transport_sniffer.cpp
index 0aef350052e1..fffa9a230471 100644
--- a/fastboot/fuzzy_fastboot/transport_sniffer.cpp
+++ b/fastboot/fuzzy_fastboot/transport_sniffer.cpp
@@ -3,6 +3,7 @@
 #include <sys/select.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <algorithm>
 #include <iomanip>
 #include <sstream>
 
diff --git a/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp b/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
index 162c9fc34c29..2e5933280bb6 100644
--- a/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
+++ b/fs_mgr/liblp/fuzzer/liblp_builder_fuzzer.cpp
@@ -15,6 +15,7 @@
  *
  */
 
+#include <functional>
 #include <fuzzer/FuzzedDataProvider.h>
 #include <liblp/builder.h>
 #include <liblp/property_fetcher.h>
diff --git a/fs_mgr/liblp/fuzzer/liblp_super_layout_builder_fuzzer.cpp b/fs_mgr/liblp/fuzzer/liblp_super_layout_builder_fuzzer.cpp
index a6642d7ba9af..a93e68e233a3 100644
--- a/fs_mgr/liblp/fuzzer/liblp_super_layout_builder_fuzzer.cpp
+++ b/fs_mgr/liblp/fuzzer/liblp_super_layout_builder_fuzzer.cpp
@@ -17,6 +17,7 @@
 
 #include <android-base/unique_fd.h>
 #include <fcntl.h>
+#include <functional>
 #include <fuzzer/FuzzedDataProvider.h>
 #include <liblp/metadata_format.h>
 #include <liblp/super_layout_builder.h>
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 651649948133..127735d0147b 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -17,6 +17,7 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <algorithm>
 #include <optional>
 #include <unordered_map>
 #include <unordered_set>
diff --git a/fs_mgr/libsnapshot/snapuserd/testing/dm_user_harness.h b/fs_mgr/libsnapshot/snapuserd/testing/dm_user_harness.h
index cf26bed037c1..507e8f3ff329 100644
--- a/fs_mgr/libsnapshot/snapuserd/testing/dm_user_harness.h
+++ b/fs_mgr/libsnapshot/snapuserd/testing/dm_user_harness.h
@@ -19,13 +19,13 @@
 #include "harness.h"
 #include "temp_device.h"
 
+#include <snapuserd/dm_user_block_server.h>
+
 namespace android {
 namespace snapshot {
 
 using android::base::unique_fd;
 
-class DmUserBlockServerFactory;
-
 class DmUserDevice final : public IUserDevice {
   public:
     explicit DmUserDevice(std::unique_ptr<Tempdevice>&& dev);
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
index ecf5d5c38bda..c6301d46cad0 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
@@ -15,6 +15,7 @@
 #pragma once
 
 #include <memory>
+#include <mutex>
 #include <queue>
 #include <string>
 #include <thread>
diff --git a/init/capabilities.h b/init/capabilities.h
index fc80c9864f7a..b71d2cb6882a 100644
--- a/init/capabilities.h
+++ b/init/capabilities.h
@@ -18,6 +18,7 @@
 #include <sys/capability.h>
 
 #include <bitset>
+#include <memory>
 #include <string>
 #include <type_traits>
 
diff --git a/init/property_service.cpp b/init/property_service.cpp
index 31af94e590c5..83e9a0da35c3 100644
--- a/init/property_service.cpp
+++ b/init/property_service.cpp
@@ -103,8 +103,6 @@ using android::properties::PropertyInfoEntry;
 namespace android {
 namespace init {
 
-class PersistWriteThread;
-
 constexpr auto FINGERPRINT_PROP = "ro.build.fingerprint";
 constexpr auto LEGACY_FINGERPRINT_PROP = "ro.build.legacy.fingerprint";
 constexpr auto ID_PROP = "ro.build.id";
@@ -122,8 +120,6 @@ static std::mutex selinux_check_access_lock;
 static std::thread property_service_thread;
 static std::thread property_service_for_system_thread;
 
-static std::unique_ptr<PersistWriteThread> persist_write_thread;
-
 static PropertyInfoAreaFile property_info_area;
 
 struct PropertyAuditData {
@@ -384,6 +380,8 @@ class PersistWriteThread {
     std::deque<std::tuple<std::string, std::string, SocketConnection>> work_;
 };
 
+static std::unique_ptr<PersistWriteThread> persist_write_thread;
+
 static std::optional<uint32_t> PropertySet(const std::string& name, const std::string& value,
                                            SocketConnection* socket, std::string* error) {
     size_t valuelen = value.size();
diff --git a/init/ueventd_test.cpp b/init/ueventd_test.cpp
index 1ac6d8ee0764..5921ece8389d 100644
--- a/init/ueventd_test.cpp
+++ b/init/ueventd_test.cpp
@@ -19,6 +19,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
+#include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <string>
diff --git a/libcutils/android_get_control_file_test.cpp b/libcutils/android_get_control_file_test.cpp
index 8de85307deee..e57af5ee4c8a 100644
--- a/libcutils/android_get_control_file_test.cpp
+++ b/libcutils/android_get_control_file_test.cpp
@@ -21,6 +21,7 @@
 #include <sys/types.h>
 #include <time.h>
 
+#include <algorithm>
 #include <string>
 
 #include <android-base/file.h>
diff --git a/libcutils/ashmem_base_test.cpp b/libcutils/ashmem_base_test.cpp
index c9b14e58335e..d60a97334b22 100644
--- a/libcutils/ashmem_base_test.cpp
+++ b/libcutils/ashmem_base_test.cpp
@@ -16,6 +16,8 @@
 
 #include <gtest/gtest.h>
 
+#include <algorithm>
+
 #include <unistd.h>
 
 #include <android-base/mapped_file.h>
diff --git a/libmodprobe/include/modprobe/modprobe.h b/libmodprobe/include/modprobe/modprobe.h
index 7b691b13acec..d33e17dddef0 100644
--- a/libmodprobe/include/modprobe/modprobe.h
+++ b/libmodprobe/include/modprobe/modprobe.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <functional>
 #include <mutex>
 #include <set>
 #include <string>
diff --git a/libstats/bootstrap/BootstrapClientInternal.h b/libstats/bootstrap/BootstrapClientInternal.h
index 96238dade14b..7879d01f6b6b 100644
--- a/libstats/bootstrap/BootstrapClientInternal.h
+++ b/libstats/bootstrap/BootstrapClientInternal.h
@@ -18,6 +18,8 @@
 
 #include <android/os/IStatsBootstrapAtomService.h>
 
+#include <mutex>
+
 namespace android {
 namespace os {
 namespace stats {
diff --git a/toolbox/getprop.cpp b/toolbox/getprop.cpp
index ca345cb071c5..7c3d94c1b5d6 100644
--- a/toolbox/getprop.cpp
+++ b/toolbox/getprop.cpp
@@ -17,6 +17,7 @@
 #include <getopt.h>
 #include <sys/system_properties.h>
 
+#include <algorithm>
 #include <iostream>
 #include <string>
 #include <vector>
diff --git a/trusty/storage/proxy/watchdog.cpp b/trusty/storage/proxy/watchdog.cpp
index 6c09e2639685..f042fdcab45e 100644
--- a/trusty/storage/proxy/watchdog.cpp
+++ b/trusty/storage/proxy/watchdog.cpp
@@ -18,6 +18,7 @@
 
 #include <chrono>
 #include <cstdint>
+#include <mutex>
 #include <optional>
 #include <thread>
 #include <vector>

From 42f952be33340a22ea4f572fcb2aab8b43f4038d Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 22 Jan 2025 14:07:00 -0800
Subject: [PATCH 1374/1487] Skip bootloader update

Bug: N/A
Test: apply_update --skip_bootloader
Change-Id: Ia77714b17697e9592231d714bba0c2a3d27a3de2
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/scripts/apply-update.sh | 23 ++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/fs_mgr/libsnapshot/scripts/apply-update.sh b/fs_mgr/libsnapshot/scripts/apply-update.sh
index 0b10721a44ef..2a5a8a283345 100755
--- a/fs_mgr/libsnapshot/scripts/apply-update.sh
+++ b/fs_mgr/libsnapshot/scripts/apply-update.sh
@@ -52,13 +52,16 @@ ensure_create_snapshot
 # Function to flash static partitions
 flash_static_partitions() {
   local wipe_flag="$1"
-
-  fastboot flash bootloader "$OUT"/bootloader.img
-  fastboot reboot bootloader
-  sleep 1
-  fastboot flash radio "$OUT"/radio.img
-  fastboot reboot bootloader
-  sleep 1
+  local flash_bootloader="$2"
+
+  if (( flash_bootloader )); then
+    fastboot flash bootloader "$OUT"/bootloader.img
+    fastboot reboot bootloader
+    sleep 1
+    fastboot flash radio "$OUT"/radio.img
+    fastboot reboot bootloader
+    sleep 1
+  fi
   fastboot flashall --exclude-dynamic-partitions --disable-super-optimization --skip-reboot
 
   if (( wipe_flag )); then
@@ -120,6 +123,7 @@ EOF
 }
 
 skip_static_partitions=0
+flash_bootloader=1
 wipe_flag=0
 help_flag=0
 
@@ -132,6 +136,9 @@ for arg in "$@"; do
     --wipe)
       wipe_flag=1
       ;;
+    --skip_bootloader)
+      flash_bootloader=0
+      ;;
     --help)
       help_flag=1
       ;;
@@ -214,7 +221,7 @@ else
     log_message "Rebooting device to bootloader"
     adb reboot bootloader
     log_message "Waiting to enter fastboot bootloader"
-    flash_static_partitions "$wipe_flag"
+    flash_static_partitions "$wipe_flag" "$flash_bootloader"
 fi
 
 log_message "Update completed"

From caf853008c09eb9adaf00366be5cdad38277dc37 Mon Sep 17 00:00:00 2001
From: Karuna Wadhera <kwadhera@google.com>
Date: Wed, 22 Jan 2025 22:28:44 +0000
Subject: [PATCH 1375/1487] Always use V4 FEATURE_HARDWARE_KEYSTORE XML file

This is possible because the interfaces have been frozen.

Bug: 380020528
Bug: 369375199
Test: Treehugger
Change-Id: I3b64710b29a2c0d4462fd735d412587e26a31aeb
---
 trusty/keymaster/Android.bp | 7 +++----
 trusty/keymint/Android.bp   | 5 +----
 2 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/trusty/keymaster/Android.bp b/trusty/keymaster/Android.bp
index 8ebfc1aeba52..f2c284a9a263 100644
--- a/trusty/keymaster/Android.bp
+++ b/trusty/keymaster/Android.bp
@@ -120,10 +120,9 @@ cc_binary {
         "libtrusty",
         "libutils",
     ],
-    required: select(release_flag("RELEASE_AIDL_USE_UNFROZEN"), {
-        true: ["android.hardware.hardware_keystore.xml"],
-        default: ["android.hardware.hardware_keystore_V3.xml"],
-    }),
+    required: [
+        "android.hardware.hardware_keystore.xml",
+    ],
 }
 
 prebuilt_etc {
diff --git a/trusty/keymint/Android.bp b/trusty/keymint/Android.bp
index 36efb1b892bd..caaaac2b7c51 100644
--- a/trusty/keymint/Android.bp
+++ b/trusty/keymint/Android.bp
@@ -42,10 +42,7 @@ rust_binary {
     defaults: ["android.hardware.security.keymint-service.rust.trusty.default"],
     init_rc: ["android.hardware.security.keymint-service.rust.trusty.rc"],
     vintf_fragments: ["android.hardware.security.keymint-service.rust.trusty.xml"],
-    required: select(release_flag("RELEASE_AIDL_USE_UNFROZEN"), {
-        true: ["android.hardware.hardware_keystore.xml"],
-        default: ["android.hardware.hardware_keystore_V3.xml"],
-    }),
+    required: ["android.hardware.hardware_keystore.xml"],
 }
 
 rust_binary {

From ccce03d8305434836cb6a860bd0e34b1aa82f153 Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Thu, 23 Jan 2025 13:04:41 +0900
Subject: [PATCH 1376/1487] Make sure symlinks created by ueventd are correctly
 labeled

Bug: 391078491
Test: `ls -alZ /dev/block/by-name | grep "boot_[ab]"` in cuttlefish.
lrwxrwxrwx 1 root root u:object_r:boot_block_device:s0        15 2025-01-23 13:03 boot_a -> /dev/block/vda2
lrwxrwxrwx 1 root root u:object_r:boot_block_device:s0        15 2025-01-23 13:03 boot_b -> /dev/block/vda3
lrwxrwxrwx 1 root root u:object_r:boot_block_device:s0        15 2025-01-23 13:03 init_boot_a -> /dev/block/vda4
lrwxrwxrwx 1 root root u:object_r:boot_block_device:s0        15 2025-01-23 13:03 init_boot_b -> /dev/block/vda5
lrwxrwxrwx 1 root root u:object_r:boot_block_device:s0        15 2025-01-23 13:03 vendor_boot_a -> /dev/block/vda6
lrwxrwxrwx 1 root root u:object_r:boot_block_device:s0        15 2025-01-23 13:03 vendor_boot_b -> /dev/block/vda7

Previously it was
lrwxrwxrwx 1 root root u:object_r:boot_block_device:s0        15 2025-01-21 13:36 boot_a -> /dev/block/vda2
lrwxrwxrwx 1 root root u:object_r:block_device:s0             15 2025-01-21 13:36 boot_b -> /dev/block/vda3
lrwxrwxrwx 1 root root u:object_r:boot_block_device:s0        15 2025-01-21 13:36 init_boot_a -> /dev/block/vda4
lrwxrwxrwx 1 root root u:object_r:block_device:s0             15 2025-01-21 13:36 init_boot_b -> /dev/block/vda5
lrwxrwxrwx 1 root root u:object_r:boot_block_device:s0        15 2025-01-23 13:03 vendor_boot_a -> /dev/block/vda6
lrwxrwxrwx 1 root root u:object_r:block_device:s0             15 2025-01-23 13:03 vendor_boot_b -> /dev/block/vda7

Change-Id: I448514cbf44f1f86c7f3493de23ede4690c7c4ac
---
 init/devices.cpp | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/init/devices.cpp b/init/devices.cpp
index aeaa4313393f..cead72616727 100644
--- a/init/devices.cpp
+++ b/init/devices.cpp
@@ -599,7 +599,22 @@ void DeviceHandler::HandleDevice(const std::string& action, const std::string& d
                 PLOG(ERROR) << "Failed to create directory " << Dirname(link);
             }
 
-            if (symlink(target.c_str(), link.c_str())) {
+            // Create symlink and make sure it's correctly labeled
+            std::string secontext;
+            // Passing 0 for mode should work.
+            if (SelabelLookupFileContext(link, 0, &secontext) && !secontext.empty()) {
+                setfscreatecon(secontext.c_str());
+            }
+
+            int rc = symlink(target.c_str(), link.c_str());
+
+            if (!secontext.empty()) {
+                int save_errno = errno;
+                setfscreatecon(nullptr);
+                errno = save_errno;
+            }
+
+            if (rc < 0) {
                 if (errno != EEXIST) {
                     PLOG(ERROR) << "Failed to symlink " << devpath << " to " << link;
                 } else if (std::string link_path;

From e60c029f6f2b1a7ef63d9e317150d5bc1279e640 Mon Sep 17 00:00:00 2001
From: Aaron Knobloch <aknobloch@google.com>
Date: Wed, 22 Jan 2025 20:40:36 -0800
Subject: [PATCH 1377/1487] Avoid clobbering `errno` from `realpath` call in
 `__mount`

The __mount logic calls `realpath`, which can set errno in some cases (e.g. if a file is not found or the input string is malformed). The __mount algorithm here is attempting to use errno as signal of the `mount` syscall's success, which is not accurate if the value is clobbered.

This CL fixes the issue by clearing the errno explicitly just before the `mount` call. This ensures that any errno set is from the `mount` call itself. The existing `save_errno` field handles the logic for reading the previous invocation's errno value.

Bug: b/379929394
Change-Id: I840171079a71a1e7927fcc30d6c0863fab6c7e00
---
 fs_mgr/fs_mgr.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 9f52f4483b6d..88e26cffa601 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -858,6 +858,10 @@ static int __mount(const std::string& source, const std::string& target, const F
         if (!android::base::Realpath(source, &real_source)) {
             real_source = source;
         }
+
+        // Clear errno prior to calling `mount`, to avoid clobbering with any errno that
+        // may have been set from prior calls (e.g. realpath).
+        errno = 0;
         ret = mount(real_source.c_str(), target.c_str(), entry.fs_type.c_str(), mountflags,
                     opts.c_str());
         save_errno = errno;

From 940f0755af05d87f82a3ec10046eadfca9f317a7 Mon Sep 17 00:00:00 2001
From: Atneya Nair <atneya@google.com>
Date: Wed, 22 Jan 2025 21:51:18 -0800
Subject: [PATCH 1378/1487] [String8] Add string_view ctor

For convenience add a std::string_view ctor to String8.

This allows for easy std::string to String8 conversion.

Test: compiles
Test: atest libutils_binder_test
Bug: none
Flag: EXEMPT trivial
Change-Id: I188362e4045891e1a68ea433a47e08d27490f473
---
 libutils/binder/String8_test.cpp        | 8 ++++++++
 libutils/binder/include/utils/String8.h | 6 ++++++
 2 files changed, 14 insertions(+)

diff --git a/libutils/binder/String8_test.cpp b/libutils/binder/String8_test.cpp
index fc3c329412d4..ff9bc8d55967 100644
--- a/libutils/binder/String8_test.cpp
+++ b/libutils/binder/String8_test.cpp
@@ -176,3 +176,11 @@ TEST_F(String8Test, comparisons) {
     EXPECT_TRUE(pair1 < pair2);
     EXPECT_FALSE(pair1 > pair2);
 }
+
+TEST_F(String8Test, SvCtor) {
+    const char* expected = "abc";
+    std::string s{expected};
+    EXPECT_STREQ(String8{s}.c_str(), expected);
+    EXPECT_STREQ(String8{std::string_view{s}}.c_str(), expected);
+    EXPECT_STREQ(String8{expected}.c_str(), expected);
+}
diff --git a/libutils/binder/include/utils/String8.h b/libutils/binder/include/utils/String8.h
index e0d7588f6a19..11415a1c464a 100644
--- a/libutils/binder/include/utils/String8.h
+++ b/libutils/binder/include/utils/String8.h
@@ -57,6 +57,9 @@ class String8
                                 String8(const String8& o);
     explicit                    String8(const char* o);
     explicit                    String8(const char* o, size_t numChars);
+#ifdef HAS_STRING_VIEW
+    explicit                    String8(std::string_view o);
+#endif
 
     explicit                    String8(const String16& o);
     explicit                    String8(const char16_t* o);
@@ -374,6 +377,9 @@ inline String8::operator const char*() const
 }
 
 #ifdef HAS_STRING_VIEW
+
+inline String8::String8(std::string_view o) : String8(o.data(), o.length()) { }
+
 inline String8::operator std::string_view() const
 {
     return {mString, length()};

From 4d28e890d441cdf8df226de616bf609670117148 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Thu, 16 Jan 2025 11:22:15 -0800
Subject: [PATCH 1379/1487] fastboot: add documentation

add exclude-dynamic partitions command to show_help

Test: th
Change-Id: I3941080382c258fa418f413a25fdbaef4b70ce76
---
 fastboot/fastboot.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 156dc3b33408..1c52da2382ad 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -638,7 +638,10 @@ static int show_help() {
             " --disable-verification     Sets disable-verification when flashing vbmeta.\n"
             " --disable-super-optimization\n"
             "                            Disables optimizations on flashing super partition.\n"
-            " --disable-fastboot-info    Will collects tasks from image list rather than $OUT/fastboot-info.txt.\n"
+            " --exclude-dynamic-partitions\n"
+            "                            Excludes flashing of dynamic partitions.\n"
+            " --disable-fastboot-info    Will collects tasks from image list rather than \n"
+            "                            $OUT/fastboot-info.txt.\n"
             " --fs-options=OPTION[,OPTION]\n"
             "                            Enable filesystem features. OPTION supports casefold, projid, compress\n"
             // TODO: remove --unbuffered?

From 84e315c6745ccf3ab8b88e2fb5c895390209710d Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 24 Jan 2025 06:52:05 -0800
Subject: [PATCH 1380/1487] <string_view> is always available.

Change-Id: I68e86a67487bc9473dbcd6f7d87509c5621ab52b
---
 libutils/binder/include/utils/String16.h | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/libutils/binder/include/utils/String16.h b/libutils/binder/include/utils/String16.h
index 867dbac34a0d..20de647eefac 100644
--- a/libutils/binder/include/utils/String16.h
+++ b/libutils/binder/include/utils/String16.h
@@ -19,16 +19,12 @@
 
 #include <iostream>
 #include <string>
+#include <string_view>
 
 #include <utils/Errors.h>
 #include <utils/String8.h>
 #include <utils/TypeHelpers.h>
 
-#if __has_include(<string_view>)
-#include <string_view>
-#define HAS_STRING_VIEW
-#endif
-
 #if __cplusplus >= 202002L
 #include <compare>
 #endif
@@ -125,11 +121,9 @@ class String16
 
     inline                      operator const char16_t*() const;
 
-#ifdef HAS_STRING_VIEW
     // Implicit cast to std::u16string is not implemented on purpose - u16string_view is much
     // lighter and if one needs, they can still create u16string from u16string_view.
     inline                      operator std::u16string_view() const;
-#endif
 
     // Static and non-static String16 behave the same for the users, so
     // this method isn't of much use for the users. It is public for testing.
@@ -414,6 +408,4 @@ inline String16::operator std::u16string_view() const
 
 // ---------------------------------------------------------------------------
 
-#undef HAS_STRING_VIEW
-
 #endif // ANDROID_STRING16_H

From 20acaada1ad32506a9758740bf84433472da0bc8 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 24 Jan 2025 06:53:25 -0800
Subject: [PATCH 1381/1487] <string> is always available.

Change-Id: Ib4bde5521c1e02b7d90b85548b7ed4479c7d8d0d
---
 libutils/binder/include/utils/String8.h | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/libutils/binder/include/utils/String8.h b/libutils/binder/include/utils/String8.h
index 11415a1c464a..4a23df7bfac2 100644
--- a/libutils/binder/include/utils/String8.h
+++ b/libutils/binder/include/utils/String8.h
@@ -18,6 +18,7 @@
 #define ANDROID_STRING8_H
 
 #include <iostream>
+#include <string>
 
 #include <utils/Errors.h>
 #include <utils/Unicode.h>
@@ -26,11 +27,6 @@
 #include <string.h> // for strcmp
 #include <stdarg.h>
 
-#if __has_include(<string>)
-#include <string>
-#define HAS_STRING
-#endif
-
 #if __has_include(<string_view>)
 #include <string_view>
 #define HAS_STRING_VIEW
@@ -390,7 +386,6 @@ inline String8::operator std::string_view() const
 
 // ---------------------------------------------------------------------------
 
-#undef HAS_STRING
 #undef HAS_STRING_VIEW
 
 #endif // ANDROID_STRING8_H

From 3cf4bff967605efd4f5b9936f8643d8ac3c1d43b Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 24 Jan 2025 10:23:27 -0800
Subject: [PATCH 1382/1487] <string_view> is always available.

Change-Id: I1e2cc66ffc5a6cd354986bd653d0046e990b721f
---
 libutils/binder/include/utils/String8.h | 15 +--------------
 1 file changed, 1 insertion(+), 14 deletions(-)

diff --git a/libutils/binder/include/utils/String8.h b/libutils/binder/include/utils/String8.h
index 4a23df7bfac2..404f8a0280c9 100644
--- a/libutils/binder/include/utils/String8.h
+++ b/libutils/binder/include/utils/String8.h
@@ -19,6 +19,7 @@
 
 #include <iostream>
 #include <string>
+#include <string_view>
 
 #include <utils/Errors.h>
 #include <utils/Unicode.h>
@@ -27,11 +28,6 @@
 #include <string.h> // for strcmp
 #include <stdarg.h>
 
-#if __has_include(<string_view>)
-#include <string_view>
-#define HAS_STRING_VIEW
-#endif
-
 #if __cplusplus >= 202002L
 #include <compare>
 #endif
@@ -53,9 +49,7 @@ class String8
                                 String8(const String8& o);
     explicit                    String8(const char* o);
     explicit                    String8(const char* o, size_t numChars);
-#ifdef HAS_STRING_VIEW
     explicit                    String8(std::string_view o);
-#endif
 
     explicit                    String8(const String16& o);
     explicit                    String8(const char16_t* o);
@@ -125,9 +119,7 @@ class String8
 
     inline                      operator const char*() const;
 
-#ifdef HAS_STRING_VIEW
     inline explicit             operator std::string_view() const;
-#endif
 
             char*               lockBuffer(size_t size);
             void                unlockBuffer();
@@ -372,20 +364,15 @@ inline String8::operator const char*() const
     return mString;
 }
 
-#ifdef HAS_STRING_VIEW
-
 inline String8::String8(std::string_view o) : String8(o.data(), o.length()) { }
 
 inline String8::operator std::string_view() const
 {
     return {mString, length()};
 }
-#endif
 
 }  // namespace android
 
 // ---------------------------------------------------------------------------
 
-#undef HAS_STRING_VIEW
-
 #endif // ANDROID_STRING8_H

From 2c04424338ee0e4aa13b39839084e469d19f54b5 Mon Sep 17 00:00:00 2001
From: "Isaac J. Manjarres" <isaacmanjarres@google.com>
Date: Fri, 27 Dec 2024 15:19:41 -0800
Subject: [PATCH 1383/1487] ashmem_test: Split tests out into their own
 functions

In the future, after memfd is enabled, we want to make sure that
the existing tests work on ashmem fds, as those may still be used
by older applications. Therefore, split out the logic in the tests
so that the fd allocation can be done differently. This will allow
us to either allocate an fd through the libcutils library or from
the ashmem-memfd compatibility driver directly.

While we're here, do some stylistic clean up, such as marking
functions only used in this file as static.

No functional change.

Bug: 111903542
Change-Id: I2e06742333b093703f263c44c8e4f9e88e21a920
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
---
 libcutils/ashmem_test.cpp | 105 ++++++++++++++++++++++++--------------
 1 file changed, 68 insertions(+), 37 deletions(-)

diff --git a/libcutils/ashmem_test.cpp b/libcutils/ashmem_test.cpp
index b0a552fbd6c8..96f20db9f624 100644
--- a/libcutils/ashmem_test.cpp
+++ b/libcutils/ashmem_test.cpp
@@ -31,7 +31,7 @@
 
 using android::base::unique_fd;
 
-void TestCreateRegion(size_t size, unique_fd &fd, int prot) {
+static void TestCreateRegion(size_t size, unique_fd &fd, int prot) {
     fd = unique_fd(ashmem_create_region(nullptr, size));
     ASSERT_TRUE(fd >= 0);
     ASSERT_TRUE(ashmem_valid(fd));
@@ -44,26 +44,26 @@ void TestCreateRegion(size_t size, unique_fd &fd, int prot) {
     ASSERT_EQ(FD_CLOEXEC, (fcntl(fd, F_GETFD) & FD_CLOEXEC));
 }
 
-void TestMmap(const unique_fd& fd, size_t size, int prot, void** region, off_t off = 0) {
+static void TestMmap(const unique_fd& fd, size_t size, int prot, void** region, off_t off = 0) {
     ASSERT_TRUE(fd >= 0);
     ASSERT_TRUE(ashmem_valid(fd));
     *region = mmap(nullptr, size, prot, MAP_SHARED, fd, off);
     ASSERT_NE(MAP_FAILED, *region);
 }
 
-void TestProtDenied(const unique_fd &fd, size_t size, int prot) {
+static void TestProtDenied(const unique_fd &fd, size_t size, int prot) {
     ASSERT_TRUE(fd >= 0);
     ASSERT_TRUE(ashmem_valid(fd));
     EXPECT_EQ(MAP_FAILED, mmap(nullptr, size, prot, MAP_SHARED, fd, 0));
 }
 
-void TestProtIs(const unique_fd& fd, int prot) {
+static void TestProtIs(const unique_fd& fd, int prot) {
     ASSERT_TRUE(fd >= 0);
     ASSERT_TRUE(ashmem_valid(fd));
     EXPECT_EQ(prot, ioctl(fd, ASHMEM_GET_PROT_MASK));
 }
 
-void FillData(std::vector<uint8_t>& data) {
+static void FillData(std::vector<uint8_t>& data) {
     for (size_t i = 0; i < data.size(); i++) {
         data[i] = i & 0xFF;
     }
@@ -78,15 +78,11 @@ static void waitForChildProcessExit(pid_t pid) {
     ASSERT_EQ(0, WEXITSTATUS(exitStatus));
 }
 
-TEST(AshmemTest, ForkTest) {
-    const size_t size = getpagesize();
+static void ForkTest(const unique_fd &fd, size_t size) {
+    void* region1 = nullptr;
     std::vector<uint8_t> data(size);
     FillData(data);
 
-    unique_fd fd;
-    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
-
-    void* region1 = nullptr;
     ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ | PROT_WRITE, &region1));
 
     memcpy(region1, data.data(), size);
@@ -125,16 +121,12 @@ TEST(AshmemTest, ForkTest) {
     EXPECT_EQ(0, munmap(region2, size));
 }
 
-TEST(AshmemTest, FileOperationsTest) {
-    unique_fd fd;
+static void FileOperationsTest(const unique_fd &fd, size_t size) {
     void* region = nullptr;
 
-    // Allocate a 4-page buffer, but leave page-sized holes on either side
     const size_t pageSize = getpagesize();
-    const size_t size = pageSize * 4;
     const size_t dataSize = pageSize * 2;
     const size_t holeSize = pageSize;
-    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
     ASSERT_NO_FATAL_FAILURE(TestMmap(fd, dataSize, PROT_READ | PROT_WRITE, &region, holeSize));
 
     std::vector<uint8_t> data(dataSize);
@@ -187,19 +179,16 @@ TEST(AshmemTest, FileOperationsTest) {
     EXPECT_EQ(0, munmap(region, dataSize));
 }
 
-TEST(AshmemTest, ProtTest) {
-    unique_fd fd;
-    const size_t size = getpagesize();
+static void ProtTestROBuffer(const unique_fd &fd, size_t size) {
     void *region;
 
-    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_EXEC));
     TestProtDenied(fd, size, PROT_WRITE);
     TestProtIs(fd, PROT_READ | PROT_EXEC);
     ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ, &region));
     EXPECT_EQ(0, munmap(region, size));
+}
 
-    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE |
-                                             PROT_EXEC));
+static void ProtTestRWBuffer(const unique_fd &fd, size_t size) {
     TestProtIs(fd, PROT_READ | PROT_WRITE | PROT_EXEC);
     ASSERT_EQ(0, ashmem_set_prot_region(fd, PROT_READ | PROT_EXEC));
     errno = 0;
@@ -211,12 +200,7 @@ TEST(AshmemTest, ProtTest) {
     TestProtDenied(fd, size, PROT_WRITE);
 }
 
-TEST(AshmemTest, ForkProtTest) {
-    unique_fd fd;
-    const size_t size = getpagesize();
-
-    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
-
+static void ForkProtTest(const unique_fd &fd, size_t size) {
     pid_t pid = fork();
     if (!pid) {
         // Change buffer mapping permissions to read-only to ensure that
@@ -236,17 +220,13 @@ TEST(AshmemTest, ForkProtTest) {
     ASSERT_NO_FATAL_FAILURE(TestProtDenied(fd, size, PROT_WRITE));
 }
 
-TEST(AshmemTest, ForkMultiRegionTest) {
-    const size_t size = getpagesize();
+static void ForkMultiRegionTest(unique_fd fds[], int nRegions, size_t size) {
     std::vector<uint8_t> data(size);
     FillData(data);
 
-    constexpr int nRegions = 16;
-    unique_fd fd[nRegions];
     for (int i = 0; i < nRegions; i++) {
-        ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd[i], PROT_READ | PROT_WRITE));
         void* region = nullptr;
-        ASSERT_NO_FATAL_FAILURE(TestMmap(fd[i], size, PROT_READ | PROT_WRITE, &region));
+        ASSERT_NO_FATAL_FAILURE(TestMmap(fds[i], size, PROT_READ | PROT_WRITE, &region));
         memcpy(region, data.data(), size);
         ASSERT_EQ(0, memcmp(region, data.data(), size));
         EXPECT_EQ(0, munmap(region, size));
@@ -257,10 +237,10 @@ TEST(AshmemTest, ForkMultiRegionTest) {
         // Clear each ashmem buffer in the context of the child process to
         // ensure that the updates are visible to the parent process later.
         for (int i = 0; i < nRegions; i++) {
-            if (!ashmem_valid(fd[i])) {
+            if (!ashmem_valid(fds[i])) {
                 _exit(3);
             }
-            void *region = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd[i], 0);
+            void *region = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fds[i], 0);
             if (region == MAP_FAILED) {
                 _exit(1);
             }
@@ -280,8 +260,59 @@ TEST(AshmemTest, ForkMultiRegionTest) {
     memset(data.data(), 0, size);
     for (int i = 0; i < nRegions; i++) {
         void *region;
-        ASSERT_NO_FATAL_FAILURE(TestMmap(fd[i], size, PROT_READ | PROT_WRITE, &region));
+        ASSERT_NO_FATAL_FAILURE(TestMmap(fds[i], size, PROT_READ | PROT_WRITE, &region));
         ASSERT_EQ(0, memcmp(region, data.data(), size));
         EXPECT_EQ(0, munmap(region, size));
     }
+
+}
+
+TEST(AshmemTest, ForkTest) {
+    const size_t size = getpagesize();
+    unique_fd fd;
+
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
+    ASSERT_NO_FATAL_FAILURE(ForkTest(fd, size));
+}
+
+TEST(AshmemTest, FileOperationsTest) {
+    const size_t pageSize = getpagesize();
+    // Allocate a 4-page buffer, but leave page-sized holes on either side in
+    // the test.
+    const size_t size = pageSize * 4;
+    unique_fd fd;
+
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
+    ASSERT_NO_FATAL_FAILURE(FileOperationsTest(fd, size));
+}
+
+TEST(AshmemTest, ProtTest) {
+    unique_fd fd;
+    const size_t size = getpagesize();
+
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_EXEC));
+    ASSERT_NO_FATAL_FAILURE(ProtTestROBuffer(fd, size));
+
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE | PROT_EXEC));
+    ASSERT_NO_FATAL_FAILURE(ProtTestRWBuffer(fd, size));
+}
+
+TEST(AshmemTest, ForkProtTest) {
+    unique_fd fd;
+    const size_t size = getpagesize();
+
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
+    ASSERT_NO_FATAL_FAILURE(ForkProtTest(fd, size));
+}
+
+TEST(AshmemTest, ForkMultiRegionTest) {
+    const size_t size = getpagesize();
+    constexpr int nRegions = 16;
+    unique_fd fds[nRegions];
+
+    for (int i = 0; i < nRegions; i++) {
+        ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fds[i], PROT_READ | PROT_WRITE));
+    }
+
+    ASSERT_NO_FATAL_FAILURE(ForkMultiRegionTest(fds, nRegions, size));
 }

From b5c8ca3a10a4688b9c1b24ddd7c3aceaace07102 Mon Sep 17 00:00:00 2001
From: Aditya Kumar <appujee@google.com>
Date: Wed, 29 Jan 2025 12:10:33 -0800
Subject: [PATCH 1384/1487] Include sys/types.h for uid_t

```
system/core/libmodprobe/include/exthandler/exthandler.h:22:37: error: unknown type name 'uid_t'; did you mean 'pid_t'?
```

Bug: 190084016
Change-Id: Iff7cb5e34474f00f200edbaf4895713576b0a6fc
---
 libmodprobe/include/exthandler/exthandler.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libmodprobe/include/exthandler/exthandler.h b/libmodprobe/include/exthandler/exthandler.h
index 232aa95a4835..a619f8104041 100644
--- a/libmodprobe/include/exthandler/exthandler.h
+++ b/libmodprobe/include/exthandler/exthandler.h
@@ -17,6 +17,7 @@
 #pragma once
 #include <android-base/result.h>
 #include <string>
+#include <sys/types.h>
 
 android::base::Result<std::string> RunExternalHandler(
         const std::string& handler, uid_t uid, gid_t gid,

From 789b5093f700a5872ab14b9003529a4f02f5bef2 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Wed, 29 Jan 2025 13:40:17 -0800
Subject: [PATCH 1385/1487] create_snapshot: Reorder digest calculation

Bug: 371304627
Test: create_snapshot between two builds on the host
Change-Id: I1c8908e5842b4725a10db66e83af1fbdad3652d1
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
index 4f8bfd2c7595..b15e6ab9cbf4 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
@@ -478,11 +478,12 @@ bool CreateSnapshot::ReadBlocks(off_t offset, const int skip_blocks, const uint6
 
             if (create_snapshot_patch_ && use_merkel_tree_) {
                 std::vector<uint8_t> digest(32, 0);
-                CalculateDigest(bufptr, BLOCK_SZ, target_salt_.data(), target_salt_.size(),
+                CalculateDigest(bufptr, BLOCK_SZ, source_salt_.data(), source_salt_.size(),
                                 digest.data());
                 std::vector<uint8_t> final_digest(32, 0);
-                CalculateDigest(digest.data(), digest.size(), source_salt_.data(),
-                                source_salt_.size(), final_digest.data());
+                CalculateDigest(digest.data(), digest.size(), target_salt_.data(),
+                                target_salt_.size(), final_digest.data());
+
                 hash = ToHexString(final_digest.data(), final_digest.size());
             } else {
                 uint8_t checksum[32];

From 6bb52890667d7f12a7f2a5e7b9d0560113273650 Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Wed, 29 Jan 2025 19:43:48 -0800
Subject: [PATCH 1386/1487] Replace use of overlayfs' override_creds with
 overlay_remounter

This new solution does not require the use of non-upstreamed
override_creds patches.

Test: system/core/fs_mgr/tests/adb-remount-test.sh
Bug: 388912628
Change-Id: I2bc86a7171c014f88786c6ab97c8788ad024b264
---
 fs_mgr/fs_mgr.cpp                       |  5 ++
 fs_mgr/include/fs_mgr_overlayfs.h       |  6 +++
 init/Android.bp                         |  7 ++-
 init/first_stage_init.cpp               |  2 +-
 init/selinux.cpp                        | 65 ++++++++++++++++++++++++
 overlay_remounter/Android.bp            | 34 +++++++++++++
 overlay_remounter/overlay_remounter.cpp | 66 +++++++++++++++++++++++++
 7 files changed, 183 insertions(+), 2 deletions(-)
 create mode 100644 overlay_remounter/Android.bp
 create mode 100644 overlay_remounter/overlay_remounter.cpp

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 88e26cffa601..40a3a9198b5f 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -2335,6 +2335,11 @@ OverlayfsCheckResult CheckOverlayfs() {
     if (!fs_mgr_filesystem_available("overlay")) {
         return {.supported = false};
     }
+
+    if (!use_override_creds) {
+        return {.supported = true};
+    }
+
     struct utsname uts;
     if (uname(&uts) == -1) {
         return {.supported = false};
diff --git a/fs_mgr/include/fs_mgr_overlayfs.h b/fs_mgr/include/fs_mgr_overlayfs.h
index bf68b2c81362..a232bf179c43 100644
--- a/fs_mgr/include/fs_mgr_overlayfs.h
+++ b/fs_mgr/include/fs_mgr_overlayfs.h
@@ -43,5 +43,11 @@ void MapScratchPartitionIfNeeded(Fstab* fstab,
 // overlays if any partition is flashed or updated.
 void TeardownAllOverlayForMountPoint(const std::string& mount_point = {});
 
+// Are we using overlayfs's non-upstreamed override_creds feature?
+// b/388912628 removes the need for override_creds
+// Once this bug is fixed and has had enough soak time, remove this variable and hard code to false
+// where it used
+constexpr bool use_override_creds = true;
+
 }  // namespace fs_mgr
 }  // namespace android
diff --git a/init/Android.bp b/init/Android.bp
index ed19b4b865d0..dbdf80b0367f 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -136,6 +136,8 @@ libinit_cc_defaults {
                 "-DWORLD_WRITABLE_KMSG=1",
                 "-UDUMP_ON_UMOUNT_FAILURE",
                 "-DDUMP_ON_UMOUNT_FAILURE=1",
+                "-UALLOW_REMOUNT_OVERLAYS",
+                "-DALLOW_REMOUNT_OVERLAYS=1",
             ],
         },
         eng: {
@@ -263,7 +265,10 @@ phony {
     name: "init",
     required: [
         "init_second_stage",
-    ],
+    ] + select(product_variable("debuggable"), {
+        true: ["overlay_remounter"],
+        false: [],
+    }),
 }
 
 cc_defaults {
diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index e06a6459314f..6bb0ad79df44 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -402,7 +402,7 @@ int FirstStageMain(int argc, char** argv) {
 
     // /second_stage_resources is used to preserve files from first to second
     // stage init
-    CHECKCALL(mount("tmpfs", kSecondStageRes, "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
+    CHECKCALL(mount("tmpfs", kSecondStageRes, "tmpfs", MS_NOSUID | MS_NODEV,
                     "mode=0755,uid=0,gid=0"));
 
     if (IsMicrodroid() && android::virtualization::IsOpenDiceChangesFlagEnabled()) {
diff --git a/init/selinux.cpp b/init/selinux.cpp
index 6316b4deb3b5..8bdf5b6a28a4 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -69,6 +69,7 @@
 #include <android/avf_cc_flags.h>
 #include <fs_avb/fs_avb.h>
 #include <fs_mgr.h>
+#include <fs_mgr_overlayfs.h>
 #include <genfslabelsversion.h>
 #include <libgsi/libgsi.h>
 #include <libsnapshot/snapshot.h>
@@ -77,6 +78,7 @@
 #include "block_dev_initializer.h"
 #include "debug_ramdisk.h"
 #include "reboot_utils.h"
+#include "second_stage_resources.h"
 #include "snapuserd_transition.h"
 #include "util.h"
 
@@ -698,6 +700,65 @@ void LoadSelinuxPolicyAndroid() {
     }
 }
 
+#ifdef ALLOW_REMOUNT_OVERLAYS
+void SetupOverlays() {
+    if (android::fs_mgr::use_override_creds) return;
+
+    bool has_overlays = false;
+    std::string contents;
+    auto result = android::base::ReadFileToString("/proc/mounts", &contents, true);
+
+    auto lines = android::base::Split(contents, "\n");
+    for (auto const& line : lines)
+        if (android::base::StartsWith(line, "overlay")) {
+            has_overlays = true;
+            break;
+        }
+
+    if (!has_overlays) return;
+
+    // After adb remount, we mount all r/o volumes with overlayfs to allow writing.
+    // However, since overlayfs performs its file operations in the context of the
+    // mounting process, this will not work as is - init is in the kernel domain in
+    // first stage, which has very limited permissions.
+
+    // In order to fix this, we need to unmount remount all these volumes from a process
+    // with sufficient privileges to be able to perform these operations. The
+    // overlay_remounter domain has those privileges on debuggable devices.
+    // We will call overlay_remounter which will do the unmounts/mounts.
+    // But for that to work, the volumes must not be busy, so we need to copy
+    // overlay_remounter from system to a ramdisk and run it from there.
+
+    const char* kOverlayRemounter = "overlay_remounter";
+    auto or_src = std::filesystem::path("/system/xbin/") / kOverlayRemounter;
+    auto or_dest = std::filesystem::path(kSecondStageRes) / kOverlayRemounter;
+    std::error_code ec;
+    std::filesystem::copy(or_src, or_dest, ec);
+    if (ec) {
+        LOG(FATAL) << "Failed to copy " << or_src << " to " << or_dest << " " << ec.message();
+    }
+
+    if (selinux_android_restorecon(or_dest.c_str(), 0) == -1) {
+        PLOG(FATAL) << "restorecon of " << or_dest << " failed";
+    }
+    auto dest = unique_fd(open(or_dest.c_str(), O_RDONLY | O_CLOEXEC));
+    if (dest.get() == -1) {
+        PLOG(FATAL) << "Failed to reopen " << or_dest;
+    }
+    if (unlink(or_dest.c_str()) == -1) {
+        PLOG(FATAL) << "Failed to unlink " << or_dest;
+    }
+    const char* args[] = {or_dest.c_str(), nullptr};
+    fexecve(dest.get(), const_cast<char**>(args), nullptr);
+
+    // execv() only returns if an error happened, in which case we
+    // panic and never return from this function.
+    PLOG(FATAL) << "execv(\"" << or_dest << "\") failed";
+}
+#else
+void SetupOverlays() {}
+#endif
+
 int SetupSelinux(char** argv) {
     SetStdioToDevNull(argv);
     InitKernelLogging(argv);
@@ -738,6 +799,10 @@ int SetupSelinux(char** argv) {
 
     setenv(kEnvSelinuxStartedAt, std::to_string(start_time.time_since_epoch().count()).c_str(), 1);
 
+    // SetupOverlays does not return if overlays exist, instead it execs overlay_remounter
+    // which then execs second stage init
+    SetupOverlays();
+
     const char* path = "/system/bin/init";
     const char* args[] = {path, "second_stage", nullptr};
     execv(path, const_cast<char**>(args));
diff --git a/overlay_remounter/Android.bp b/overlay_remounter/Android.bp
new file mode 100644
index 000000000000..d74f7da5bfa2
--- /dev/null
+++ b/overlay_remounter/Android.bp
@@ -0,0 +1,34 @@
+//
+// Copyright (C) 2025 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_binary {
+    name: "overlay_remounter",
+    srcs: [
+        "overlay_remounter.cpp",
+    ],
+    cflags: [
+        "-D_FILE_OFFSET_BITS=64",
+        "-Wall",
+        "-Werror",
+    ],
+    static_libs: [
+        "libbase",
+        "liblog",
+    ],
+    system_shared_libs: [],
+    static_executable: true,
+    install_in_xbin: true,
+}
diff --git a/overlay_remounter/overlay_remounter.cpp b/overlay_remounter/overlay_remounter.cpp
new file mode 100644
index 000000000000..ddf97faa8bab
--- /dev/null
+++ b/overlay_remounter/overlay_remounter.cpp
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2025 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 <sys/mount.h>
+#include <unistd.h>
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/strings.h>
+
+int main(int /*argc*/, char** argv) {
+    android::base::InitLogging(argv, &android::base::KernelLogger);
+    LOG(INFO) << "Overlay remounter will remount all overlay mount points in the overlay_remounter "
+                 "domain";
+
+    // Remount ouerlayfs
+    std::string contents;
+    auto result = android::base::ReadFileToString("/proc/mounts", &contents, true);
+
+    auto lines = android::base::Split(contents, "\n");
+    for (auto const& line : lines) {
+        if (!android::base::StartsWith(line, "overlay")) {
+            continue;
+        }
+        auto bits = android::base::Split(line, " ");
+        if (int result = umount(bits[1].c_str()); result == -1) {
+            PLOG(FATAL) << "umount FAILED: " << bits[1];
+        }
+        std::string options;
+        for (auto const& option : android::base::Split(bits[3], ",")) {
+            if (option == "ro" || option == "seclabel" || option == "noatime") continue;
+            if (!options.empty()) options += ',';
+            options += option;
+        }
+        result = mount("overlay", bits[1].c_str(), "overlay", MS_RDONLY | MS_NOATIME,
+                       options.c_str());
+        if (result == 0) {
+            LOG(INFO) << "mount succeeded: " << bits[1] << " " << options;
+        } else {
+            PLOG(FATAL) << "mount FAILED: " << bits[1] << " " << bits[3];
+        }
+    }
+
+    const char* path = "/system/bin/init";
+    const char* args[] = {path, "second_stage", nullptr};
+    execv(path, const_cast<char**>(args));
+
+    // execv() only returns if an error happened, in which case we
+    // panic and never return from this function.
+    PLOG(FATAL) << "execv(\"" << path << "\") failed";
+
+    return 1;
+}

From 9bd45cf3c809b24a4e2376edef26bfb2a29f0921 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Tue, 28 Jan 2025 21:53:24 +0000
Subject: [PATCH 1387/1487] libprocessgroup: Deprecate
 setProcessGroupSwappiness

Per memcg swappiness is not supported in memcg v2 which is now the
default. This function will be removed in the future, so generate
compiler warnings for any existing users.

Bug: 393020526
Change-Id: I687e18ced54d26230a3da1e1e2893100a993089d
---
 libprocessgroup/include/processgroup/processgroup.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libprocessgroup/include/processgroup/processgroup.h b/libprocessgroup/include/processgroup/processgroup.h
index 98179e88b8f2..0aa14ba44163 100644
--- a/libprocessgroup/include/processgroup/processgroup.h
+++ b/libprocessgroup/include/processgroup/processgroup.h
@@ -79,6 +79,7 @@ int createProcessGroup(uid_t uid, pid_t initialPid, bool memControl = false);
 
 // Set various properties of a process group. For these functions to work, the process group must
 // have been created by passing memControl=true to createProcessGroup.
+[[deprecated("Unsupported in memcg v2")]]
 bool setProcessGroupSwappiness(uid_t uid, pid_t initialPid, int swappiness);
 bool setProcessGroupSoftLimit(uid_t uid, pid_t initialPid, int64_t softLimitInBytes);
 bool setProcessGroupLimit(uid_t uid, pid_t initialPid, int64_t limitInBytes);

From 50fdec65a36fd4ba392343017cba62cba3f66c3a Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 30 Jan 2025 17:32:32 +0000
Subject: [PATCH 1388/1487] init: Warn about future deprecation of
 memcg.swappiness

This memcg feature is not supported in v2, which is now the default.
While memcg v1 is still currently supported, we don't think there are
any existing users which depend on this swappiness behavior. Let's warn
about it's future deprecation now.

Bug: 393020526
Change-Id: Ia2c6a77cb88bb97248e395ce9d60fd81af5384e8
---
 init/service_parser.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/init/service_parser.cpp b/init/service_parser.cpp
index 4c31718dda10..bd6930065e81 100644
--- a/init/service_parser.cpp
+++ b/init/service_parser.cpp
@@ -315,6 +315,7 @@ Result<void> ServiceParser::ParseSharedKallsyms(std::vector<std::string>&& args)
 }
 
 Result<void> ServiceParser::ParseMemcgSwappiness(std::vector<std::string>&& args) {
+    LOG(WARNING) << "memcg.swappiness is unsupported with memcg v2 and will be deprecated";
     if (!ParseInt(args[1], &service_->swappiness_, 0)) {
         return Error() << "swappiness value must be equal or greater than 0";
     }

From 762c299f02e063a6a39b91f4a02cc0c1a1ea4e6b Mon Sep 17 00:00:00 2001
From: Shintaro Kawamura <kawasin@google.com>
Date: Wed, 29 Jan 2025 21:06:07 +0900
Subject: [PATCH 1389/1487] rust: make statspull_bindgen visible to
 "//packages/modules"

New statslog rust libraries depend on libstatspull_bindgen.

For example, libstatslog_dns_resolver_rust will start depending on
statspull_bindgen by aosp/3467325.

Bug: 392816523
Test: m

Change-Id: Ib3130f5d5efcd7085140880dd79da49db2f21b60
---
 libstats/pull_rust/Android.bp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libstats/pull_rust/Android.bp b/libstats/pull_rust/Android.bp
index 2a8939edbc60..ae00e75750f1 100644
--- a/libstats/pull_rust/Android.bp
+++ b/libstats/pull_rust/Android.bp
@@ -24,7 +24,7 @@ rust_bindgen {
     crate_name: "statspull_bindgen",
     visibility: [
         "//frameworks/proto_logging/stats/stats_log_api_gen",
-        "//packages/modules/Virtualization/libs/statslog_virtualization",
+        "//packages/modules:__subpackages__",
     ],
     source_stem: "bindings",
     bindgen_flags: [

From 58ee8f44499c4be14556d3dcf905d79c1e25494b Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Fri, 31 Jan 2025 10:50:56 -0800
Subject: [PATCH 1390/1487] Enable: Replace use of overlayfs' override_creds
 with overlay_remounter

Turn on flag

This new solution does not require the use of non-upstreamed
override_creds patches.

Test: system/core/fs_mgr/tests/adb-remount-test.sh
Bug: 388912628
Change-Id: Ie35126cef39cd1d7e5e6c52cbd58fca2445b0563
---
 fs_mgr/include/fs_mgr_overlayfs.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/include/fs_mgr_overlayfs.h b/fs_mgr/include/fs_mgr_overlayfs.h
index a232bf179c43..253013bdf544 100644
--- a/fs_mgr/include/fs_mgr_overlayfs.h
+++ b/fs_mgr/include/fs_mgr_overlayfs.h
@@ -47,7 +47,7 @@ void TeardownAllOverlayForMountPoint(const std::string& mount_point = {});
 // b/388912628 removes the need for override_creds
 // Once this bug is fixed and has had enough soak time, remove this variable and hard code to false
 // where it used
-constexpr bool use_override_creds = true;
+constexpr bool use_override_creds = false;
 
 }  // namespace fs_mgr
 }  // namespace android

From 6f7341bb7ce0fd8f6564aa23dc0b3c6706efb856 Mon Sep 17 00:00:00 2001
From: Jason Chiu <jasoncschiu@google.com>
Date: Tue, 21 Jan 2025 20:02:53 +0800
Subject: [PATCH 1391/1487] bootstat: update bootreason for shipmode

Bug: 349723310
Test: verify bootreason with shipmode
Change-Id: I9128c0935e16f7ee0e6ebba01e41f96438340dde
Signed-off-by: Jason Chiu <jasoncschiu@google.com>
---
 bootstat/bootstat.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bootstat/bootstat.cpp b/bootstat/bootstat.cpp
index 687ffe42b266..3c8c4b4f19e9 100644
--- a/bootstat/bootstat.cpp
+++ b/bootstat/bootstat.cpp
@@ -467,7 +467,7 @@ const std::map<std::string, int32_t> kBootReasonMap = {
     {"reboot,longkey,master_dc", 235},
     {"reboot,ocp2,pmic,if", 236},
     {"reboot,ocp,pmic,if", 237},
-    {"reboot,fship", 238},
+    {"reboot,fship.*", 238},
     {"reboot,ocp,.*", 239},
     {"reboot,ntc,pmic,sub", 240},
 };

From 3c105f1990595e0cb8b73333ce26dadb070f87e1 Mon Sep 17 00:00:00 2001
From: Leif Martensson <leif.martensson@sony.com>
Date: Mon, 16 Oct 2023 14:35:48 +0200
Subject: [PATCH 1392/1487] Add read permission for shutdown checkpoints files

Enables for diagnostic apps to read the shutdown checkpoints files

Test: N/A
Bug: 306198106
Change-Id: Idae6d3d0c941a90db0e176e8dcaa70574d807267
---
 rootdir/init.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index f1670ae04a33..734197bcc8aa 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -902,7 +902,7 @@ on post-fs-data
     mkdir /data/system/users 0775 system system
     # Mkdir and set SELinux security contexts for shutdown-checkpoints.
     # TODO(b/270286197): remove these after couple releases.
-    mkdir /data/system/shutdown-checkpoints 0700 system system
+    mkdir /data/system/shutdown-checkpoints 0755 system system
     restorecon_recursive /data/system/shutdown-checkpoints
 
     # Create the parent directories of the user CE and DE storage directories.

From 17ffb458fbb42f20922d08d46c14351e0260f2be Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Mon, 3 Feb 2025 20:46:11 +0000
Subject: [PATCH 1393/1487] RefBase: better hints for debugging

Recommendation to enable best-practice compiler flags when seeing errors
that show memory is not handled correctly. Oftentimes, implicit
assignment of refcounts on these objects is the cause of these failures.

Bug: 393013610
Test: N/A
Change-Id: I6c6ef13a0ac11884e02d608dedc7bb6892c3a583
---
 libutils/binder/RefBase.cpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/libutils/binder/RefBase.cpp b/libutils/binder/RefBase.cpp
index 4291f1e21146..bf803e72b76d 100644
--- a/libutils/binder/RefBase.cpp
+++ b/libutils/binder/RefBase.cpp
@@ -492,7 +492,10 @@ void RefBase::decStrong(const void* id) const
 #if PRINT_REFS
     ALOGD("decStrong of %p from %p: cnt=%d\n", this, id, c);
 #endif
-    LOG_ALWAYS_FATAL_IF(BAD_STRONG(c), "decStrong() called on %p too many times",
+    LOG_ALWAYS_FATAL_IF(
+            BAD_STRONG(c),
+            "decStrong() called on %p too many times, possible memory corruption. Consider "
+            "compiling with ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION for better errors",
             refs);
     if (c == 1) {
         std::atomic_thread_fence(std::memory_order_acquire);
@@ -576,7 +579,10 @@ void RefBase::weakref_type::decWeak(const void* id)
     weakref_impl* const impl = static_cast<weakref_impl*>(this);
     impl->removeWeakRef(id);
     const int32_t c = impl->mWeak.fetch_sub(1, std::memory_order_release);
-    LOG_ALWAYS_FATAL_IF(BAD_WEAK(c), "decWeak called on %p too many times",
+    LOG_ALWAYS_FATAL_IF(
+            BAD_WEAK(c),
+            "decWeak called on %p too many times, possible memory corruption. Consider compiling "
+            "with ANDROID_UTILS_REF_BASE_DISABLE_IMPLICIT_CONSTRUCTION for better errors",
             this);
     if (c != 1) return;
     atomic_thread_fence(std::memory_order_acquire);

From 4987b8f6bfdd2e45302d3f1c49630015c12b9d12 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 4 Feb 2025 09:31:58 -0800
Subject: [PATCH 1394/1487] Trim OWNERS.

Change-Id: Ib79f8a3c7a7156523b2e732d44a962c0ee606e50
---
 bootstat/OWNERS | 1 -
 1 file changed, 1 deletion(-)

diff --git a/bootstat/OWNERS b/bootstat/OWNERS
index f66b309bb24b..9e70e7dcf653 100644
--- a/bootstat/OWNERS
+++ b/bootstat/OWNERS
@@ -1,2 +1 @@
-jhawkins@google.com
 dvander@google.com

From 5ad6526e64ce9acfd9c595ca94326d9a8f78e17c Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Tue, 4 Feb 2025 10:40:44 -0800
Subject: [PATCH 1395/1487] Test that moving files doesn't break adb remount

Bug: 394290609
Test: adb-remount-test.sh
Change-Id: Ia81dfaa17eb5e53e1edad2ad87394fa0c71e0215
---
 fs_mgr/tests/adb-remount-test.sh | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/fs_mgr/tests/adb-remount-test.sh b/fs_mgr/tests/adb-remount-test.sh
index 526c761d3654..139ac923aa17 100755
--- a/fs_mgr/tests/adb-remount-test.sh
+++ b/fs_mgr/tests/adb-remount-test.sh
@@ -1360,6 +1360,14 @@ cat "${system_build_prop_original}" - <<EOF >"${system_build_prop_modified}"
 # Properties added by adb remount test
 test.adb.remount.system.build.prop=true
 EOF
+
+# Move /system/build.prop to make sure we can move and then replace files
+# Note that as of kernel 6.1 mv creates the char_file that whites out the lower
+# file with different selabels than rm does
+# See b/394290609
+adb shell mv /system/build.prop /system/build.prop.backup >/dev/null ||
+  die "adb shell rm /system/build.prop"
+
 adb push "${system_build_prop_modified}" /system/build.prop >/dev/null ||
   die "adb push /system/build.prop"
 adb pull /system/build.prop "${system_build_prop_fromdevice}" >/dev/null ||

From a5ad507eb4e2378bac6a648d41b10acde76f6b87 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 4 Feb 2025 14:26:13 -0800
Subject: [PATCH 1396/1487] fastboot: update-super help text

Bug: 393978923
Test: th
Change-Id: I7d51eab0ba27a487b853037a62b0884726da58dd
---
 fastboot/fastboot.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 156dc3b33408..a3d8b987b0e4 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -588,6 +588,12 @@ static int show_help() {
             "                            Delete a logical partition with the given name.\n"
             " resize-logical-partition NAME SIZE\n"
             "                            Change the size of the named logical partition.\n"
+            " update-super NAME\n"
+            "                            Merges changes to the super partition metadata.\n"
+            "                            If a merge isn't possible (for example, the format\n"
+            "                            on the device is an unsupported version), then this\n"
+            "                            command fails. An optional wipe parameter overwrites\n"
+            "                            the device's metadata, rather than performing a merge.\n"
             " snapshot-update cancel     On devices that support snapshot-based updates, cancel\n"
             "                            an in-progress update. This may make the device\n"
             "                            unbootable until it is reflashed.\n"

From 731f07251f2f77147f2e27e838c63303dd2684c6 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 4 Feb 2025 15:07:35 -0800
Subject: [PATCH 1397/1487] libsnapshot: Increase the size of scratch to 2MB

Bug: 394150111
Test: apply_update
Change-Id: I4db0232f4552dc58c88f2e8d5a29cef18f5399ce
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/scratch_super.cpp | 2 +-
 fs_mgr/libsnapshot/scratch_super.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs_mgr/libsnapshot/scratch_super.cpp b/fs_mgr/libsnapshot/scratch_super.cpp
index 203690536854..2d1912394feb 100644
--- a/fs_mgr/libsnapshot/scratch_super.cpp
+++ b/fs_mgr/libsnapshot/scratch_super.cpp
@@ -396,7 +396,7 @@ std::string MapScratchOtaMetadataPartition(const std::string& scratch_device) {
 }
 
 // Entry point to create a scratch device on super partition
-// This will create a 1MB space in super. The space will be
+// This will create a 2MB space in super. The space will be
 // from the current active slot. Ext4 filesystem will be created
 // on this scratch device and all the OTA related directories
 // will be created.
diff --git a/fs_mgr/libsnapshot/scratch_super.h b/fs_mgr/libsnapshot/scratch_super.h
index 3e6fe702fd76..7a16f97d97e4 100644
--- a/fs_mgr/libsnapshot/scratch_super.h
+++ b/fs_mgr/libsnapshot/scratch_super.h
@@ -20,7 +20,7 @@ namespace snapshot {
 constexpr char kMkExt4[] = "/system/bin/mke2fs";
 constexpr char kOtaMetadataFileContext[] = "u:object_r:ota_metadata_file:s0";
 constexpr char kOtaMetadataMount[] = "/mnt/scratch_ota_metadata_super";
-const size_t kOtaMetadataPartitionSize = uint64_t(1 * 1024 * 1024);
+const size_t kOtaMetadataPartitionSize = uint64_t(2 * 1024 * 1024);
 constexpr char kPhysicalDevice[] = "/dev/block/by-name/";
 
 bool IsScratchOtaMetadataOnSuper();

From 85baa828684cfcedb155bcd03916500c4402f2df Mon Sep 17 00:00:00 2001
From: Jason Chiu <jasoncschiu@google.com>
Date: Wed, 5 Feb 2025 09:57:44 +0800
Subject: [PATCH 1398/1487] bootstat: add achant and markcheng as owner

Test: none
Change-Id: Ie4c218fe51b13407137c4374fe641f1818124fac
Signed-off-by: Jason Chiu <jasoncschiu@google.com>
---
 bootstat/OWNERS | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/bootstat/OWNERS b/bootstat/OWNERS
index 9e70e7dcf653..71b4e0b1cfa8 100644
--- a/bootstat/OWNERS
+++ b/bootstat/OWNERS
@@ -1 +1,3 @@
 dvander@google.com
+achant@google.com
+markcheng@google.com

From 5013516dc1f7b7b5c55249cbdb41b742a9c46790 Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Wed, 5 Feb 2025 13:30:30 -0800
Subject: [PATCH 1399/1487] Restore userxattr for overlayfs mounts

This was mistakenly removed while removing usercreds

Bug: 394441256
Test: system/core/fs_mgr/tests/adb-remount-test.sh and manual
confirmation from bug reporter that bug has gone
Change-Id: I80934faf4f4f70d9988edfacf879b9fa89b02eb1
---
 fs_mgr/fs_mgr.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 40a3a9198b5f..275bc8061361 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -2337,7 +2337,7 @@ OverlayfsCheckResult CheckOverlayfs() {
     }
 
     if (!use_override_creds) {
-        return {.supported = true};
+        return {.supported = true, ",userxattr"};
     }
 
     struct utsname uts;

From 2199299a45b7e40022374f6f9b5c2084db18dcd0 Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Mon, 27 Jan 2025 05:15:00 +0000
Subject: [PATCH 1400/1487] trusty: keymint: add rules for deploying keymint in
 vendor apex

two rules are defined to be used in vendor apex:
- one for keymint in Trusty TEE
- one for keymint in Trusty AVF VM

Bug: 392769828
Test: lunch qemu-generic-arm64-gicv3-test-debug
Change-Id: I049f4aec38e6d16d6a64faeb54a8701db6f296ba
---
 trusty/keymaster/Android.bp                   | 41 +++++++++++++----
 ...security.keymint-service.trusty_tee.cpp.rc | 11 +++++
 trusty/keymint/Android.bp                     | 44 +++++++++++++++++--
 ....hardware_keystore.rust.trusty-keymint.xml | 18 --------
 ...urity.keymint-service.trusty_system_vm.rc} | 12 ++---
 ...urity.keymint-service.trusty_system_vm.xml | 20 +++++++++
 ...are.security.keymint-service.trusty_tee.rc | 11 +++++
 trusty/keymint/trusty-keymint-apex.mk         | 29 ++++++++++++
 trusty/keymint/trusty-keymint.mk              | 15 +++----
 trusty/trusty-base.mk                         |  8 +++-
 10 files changed, 163 insertions(+), 46 deletions(-)
 create mode 100644 trusty/keymaster/keymint/android.hardware.security.keymint-service.trusty_tee.cpp.rc
 delete mode 100644 trusty/keymint/android.hardware.hardware_keystore.rust.trusty-keymint.xml
 rename trusty/keymint/{android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc => android.hardware.security.keymint-service.trusty_system_vm.rc} (51%)
 create mode 100644 trusty/keymint/android.hardware.security.keymint-service.trusty_system_vm.xml
 create mode 100644 trusty/keymint/android.hardware.security.keymint-service.trusty_tee.rc
 create mode 100644 trusty/keymint/trusty-keymint-apex.mk

diff --git a/trusty/keymaster/Android.bp b/trusty/keymaster/Android.bp
index f2c284a9a263..31187f5b827b 100644
--- a/trusty/keymaster/Android.bp
+++ b/trusty/keymaster/Android.bp
@@ -80,13 +80,9 @@ cc_binary {
     vintf_fragments: ["4.0/android.hardware.keymaster@4.0-service.trusty.xml"],
 }
 
-cc_binary {
-    name: "android.hardware.security.keymint-service.trusty",
+cc_defaults {
+    name: "android.hardware.security.keymint-service.trusty.defaults",
     relative_install_path: "hw",
-    init_rc: ["keymint/android.hardware.security.keymint-service.trusty.rc"],
-    vintf_fragments: [
-        "keymint/android.hardware.security.keymint-service.trusty.xml",
-    ],
     vendor: true,
     cflags: [
         "-Wall",
@@ -120,9 +116,38 @@ cc_binary {
         "libtrusty",
         "libutils",
     ],
-    required: [
-        "android.hardware.hardware_keystore.xml",
+}
+
+// keymint hal binary for keymint in Trusty TEE prebuilt
+cc_binary {
+    name: "android.hardware.security.keymint-service.trusty",
+    defaults: ["android.hardware.security.keymint-service.trusty.defaults"],
+    init_rc: ["keymint/android.hardware.security.keymint-service.trusty.rc"],
+    vintf_fragments: [
+        "keymint/android.hardware.security.keymint-service.trusty.xml",
     ],
+    required: ["android.hardware.hardware_keystore.xml"],
+}
+
+// Keymint hal service in vendor, enabled by vendor apex.
+// This service is disabled by default and does not package a VINTF fragment.
+// This service can be enabled at boot via vendor apex:
+// - at boot, mount a vendor apex for module `com.android.hardware.keymint`
+// - have the vendor init.rc file enable the service when the associated
+//   apex is selected
+// - have the vendor apex package the vintf fragment and the required permissions
+cc_binary {
+    name: "android.hardware.security.keymint-service.trusty_tee.cpp",
+    defaults: ["android.hardware.security.keymint-service.trusty.defaults"],
+    init_rc: ["keymint/android.hardware.security.keymint-service.trusty_tee.cpp.rc"],
+}
+
+// vintf fragment packaged in vendor apex
+prebuilt_etc {
+    name: "android.hardware.security.keymint-service.trusty.xml",
+    sub_dir: "vintf",
+    vendor: true,
+    src: "keymint/android.hardware.security.keymint-service.trusty.xml",
 }
 
 prebuilt_etc {
diff --git a/trusty/keymaster/keymint/android.hardware.security.keymint-service.trusty_tee.cpp.rc b/trusty/keymaster/keymint/android.hardware.security.keymint-service.trusty_tee.cpp.rc
new file mode 100644
index 000000000000..61ae8ae14ee0
--- /dev/null
+++ b/trusty/keymaster/keymint/android.hardware.security.keymint-service.trusty_tee.cpp.rc
@@ -0,0 +1,11 @@
+# service started when selecting `com.android.hardware.keymint.trusty_tee.cpp` vendor apex
+service vendor.keymint-service.trusty_tee.cpp \
+  /vendor/bin/hw/android.hardware.security.keymint-service.trusty_tee.cpp \
+    --dev ${ro.hardware.trusty_ipc_dev.keymint:-/dev/trusty-ipc-dev0}
+    disabled
+    class early_hal
+    user nobody
+    group drmrpc
+    # The keymint service is not allowed to restart.
+    # If it crashes, a device restart is required.
+    oneshot
diff --git a/trusty/keymint/Android.bp b/trusty/keymint/Android.bp
index caaaac2b7c51..d1cd71bca0bf 100644
--- a/trusty/keymint/Android.bp
+++ b/trusty/keymint/Android.bp
@@ -36,6 +36,7 @@ rust_defaults {
     prefer_rlib: true,
 }
 
+// keymint hal binary for keymint in Trusty TEE (legacy approach not using apex)
 rust_binary {
     name: "android.hardware.security.keymint-service.rust.trusty",
     vendor: true,
@@ -45,13 +46,50 @@ rust_binary {
     required: ["android.hardware.hardware_keystore.xml"],
 }
 
+// Keymint hal service in vendor, enabled by vendor apex.
+// This service is disabled by default and does not package a VINTF fragment.
+// This service can be enabled at boot via vendor apex:
+// - at boot, mount a vendor apex for module `com.android.hardware.keymint`
+// - have the vendor apex init.rc file to start the service when the apex is selected
+// - have the vendor apex package the vintf fragment
 rust_binary {
-    name: "android.hardware.security.keymint-service.rust.trusty.system.nonsecure",
+    name: "android.hardware.security.keymint-service.trusty_tee",
+    vendor: true,
+    defaults: ["android.hardware.security.keymint-service.rust.trusty.default"],
+    init_rc: ["android.hardware.security.keymint-service.trusty_tee.rc"],
+}
+
+// Keymint hal service in system_ext, interacting with the Trusty Security VM.
+// This service is disabled by default and does not package a VINTF fragment.
+// This service can be enabled at boot via vendor apex:
+// - at boot, mount a vendor apex for module `com.android.hardware.keymint`
+// - have the vendor apex init.rc file to start the service when the apex is selected
+// - have the vendor apex package the vintf fragment
+rust_binary {
+    name: "android.hardware.security.keymint-service.trusty_system_vm",
     system_ext_specific: true,
     defaults: ["android.hardware.security.keymint-service.rust.trusty.default"],
-    init_rc: ["android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc"],
-    features: ["nonsecure"],
+    init_rc: ["android.hardware.security.keymint-service.trusty_system_vm.rc"],
+    features: select(soong_config_variable("trusty_system_vm", "placeholder_trusted_hal"), {
+        true: ["nonsecure"],
+        default: [],
+    }),
     rustlibs: [
         "libkmr_hal_nonsecure",
     ],
 }
+
+// vintf fragment packaged in vendor apex
+prebuilt_etc {
+    name: "android.hardware.security.keymint-service.rust.trusty.xml",
+    sub_dir: "vintf",
+    vendor: true,
+    src: "android.hardware.security.keymint-service.rust.trusty.xml",
+}
+
+prebuilt_etc {
+    name: "android.hardware.security.keymint-service.trusty_system_vm.xml",
+    sub_dir: "vintf",
+    vendor: true,
+    src: "android.hardware.security.keymint-service.trusty_system_vm.xml",
+}
diff --git a/trusty/keymint/android.hardware.hardware_keystore.rust.trusty-keymint.xml b/trusty/keymint/android.hardware.hardware_keystore.rust.trusty-keymint.xml
deleted file mode 100644
index cd656b25703d..000000000000
--- a/trusty/keymint/android.hardware.hardware_keystore.rust.trusty-keymint.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2021 The Android Open Source Project
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
--->
-<permissions>
-  <feature name="android.hardware.hardware_keystore" version="300" />
-</permissions>
diff --git a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc b/trusty/keymint/android.hardware.security.keymint-service.trusty_system_vm.rc
similarity index 51%
rename from trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
rename to trusty/keymint/android.hardware.security.keymint-service.trusty_system_vm.rc
index e5806510f331..2e8ad008c65e 100644
--- a/trusty/keymint/android.hardware.security.keymint-service.rust.trusty.system.nonsecure.rc
+++ b/trusty/keymint/android.hardware.security.keymint-service.trusty_system_vm.rc
@@ -1,6 +1,7 @@
-service system.keymint.rust-trusty.nonsecure \
-  /system_ext/bin/hw/android.hardware.security.keymint-service.rust.trusty.system.nonsecure \
-  --dev ${system.keymint.trusty_ipc_dev:-/dev/trusty-ipc-dev0}
+# service started when selecting `com.android.hardware.keymint.trusty_system_vm` vendor apex
+service system.keymint-service.trusty_system_vm \
+  /system_ext/bin/hw/android.hardware.security.keymint-service.trusty_system_vm \
+  --dev ${system.keymint.trusty_ipc_dev}
     disabled
     user nobody
     group drmrpc
@@ -8,10 +9,9 @@ service system.keymint.rust-trusty.nonsecure \
     # If it crashes, a device restart is required.
     oneshot
 
-# Only starts the non-secure KeyMint HALs when the KeyMint VM feature is enabled
 # TODO(b/357821690): Start the KeyMint HALs when the KeyMint VM is ready once the Trusty VM
 # has a mechanism to notify the host.
-on late-fs && property:trusty.security_vm.keymint.enabled=1 && \
+on post-fs && property:trusty.security_vm.keymint.enabled=1 && \
    property:trusty.security_vm.vm_cid=*
     setprop system.keymint.trusty_ipc_dev VSOCK:${trusty.security_vm.vm_cid}:1
-    start system.keymint.rust-trusty.nonsecure
+    start system.keymint-service.trusty_system_vm
diff --git a/trusty/keymint/android.hardware.security.keymint-service.trusty_system_vm.xml b/trusty/keymint/android.hardware.security.keymint-service.trusty_system_vm.xml
new file mode 100644
index 000000000000..c35c843b6ee1
--- /dev/null
+++ b/trusty/keymint/android.hardware.security.keymint-service.trusty_system_vm.xml
@@ -0,0 +1,20 @@
+<manifest version="1.0" type="device">
+    <hal format="aidl" updatable-via-system="true">
+        <name>android.hardware.security.keymint</name>
+        <version>4</version>
+        <fqname>IKeyMintDevice/default</fqname>
+    </hal>
+    <hal format="aidl" updatable-via-system="true">
+        <name>android.hardware.security.secureclock</name>
+        <fqname>ISecureClock/default</fqname>
+    </hal>
+    <hal format="aidl" updatable-via-system="true">
+        <name>android.hardware.security.sharedsecret</name>
+        <fqname>ISharedSecret/default</fqname>
+    </hal>
+    <hal format="aidl" updatable-via-system="true">
+        <name>android.hardware.security.keymint</name>
+        <version>3</version>
+        <fqname>IRemotelyProvisionedComponent/default</fqname>
+    </hal>
+</manifest>
diff --git a/trusty/keymint/android.hardware.security.keymint-service.trusty_tee.rc b/trusty/keymint/android.hardware.security.keymint-service.trusty_tee.rc
new file mode 100644
index 000000000000..694c9ce19653
--- /dev/null
+++ b/trusty/keymint/android.hardware.security.keymint-service.trusty_tee.rc
@@ -0,0 +1,11 @@
+# service started when selecting `com.android.hardware.keymint.trusty_tee` vendor apex
+service vendor.keymint-service.trusty_tee \
+  /vendor/bin/hw/android.hardware.security.keymint-service.trusty_tee \
+    --dev ${ro.hardware.trusty_ipc_dev.keymint:-/dev/trusty-ipc-dev0}
+    disabled
+    class early_hal
+    user nobody
+    group drmrpc
+    # The keymint service is not allowed to restart.
+    # If it crashes, a device restart is required.
+    oneshot
diff --git a/trusty/keymint/trusty-keymint-apex.mk b/trusty/keymint/trusty-keymint-apex.mk
new file mode 100644
index 000000000000..8b7f4d05a590
--- /dev/null
+++ b/trusty/keymint/trusty-keymint-apex.mk
@@ -0,0 +1,29 @@
+#
+# Copyright (C) 2024 The Android Open-Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+#
+# This makefile should be included by devices that choose to integrate
+# Keymint HAL via vendor apex
+
+PRODUCT_PACKAGES += \
+    android.hardware.security.keymint-service.trusty_tee.cpp \
+    android.hardware.security.keymint-service.trusty_tee \
+
+ifeq ($(findstring $(TRUSTY_SYSTEM_VM),enabled),enabled)
+    PRODUCT_PACKAGES += \
+        android.hardware.security.keymint-service.trusty_system_vm \
+
+endif
diff --git a/trusty/keymint/trusty-keymint.mk b/trusty/keymint/trusty-keymint.mk
index d5791eab2011..43cc186e7075 100644
--- a/trusty/keymint/trusty-keymint.mk
+++ b/trusty/keymint/trusty-keymint.mk
@@ -21,19 +21,14 @@
 # Allow KeyMint HAL service implementation selection at build time. This must be
 # synchronized with the TA implementation included in Trusty. Possible values:
 #
-# - Rust implementation for Trusty VM (requires Trusty VM support):
+# - Rust implementation for Trusty TEE
 #   export TRUSTY_KEYMINT_IMPL=rust
-#   export TRUSTY_SYSTEM_VM=nonsecure
-# - Rust implementation for Trusty TEE (no Trusty VM support):
-#   export TRUSTY_KEYMINT_IMPL=rust
-# - C++ implementation (default): (any other value or unset TRUSTY_KEYMINT_IMPL)
+# - C++ implementation (default):
+#   any other value or unset TRUSTY_KEYMINT_IMPL
 
 ifeq ($(TRUSTY_KEYMINT_IMPL),rust)
-    ifeq ($(TRUSTY_SYSTEM_VM),nonsecure)
-        LOCAL_KEYMINT_PRODUCT_PACKAGE := android.hardware.security.keymint-service.rust.trusty.system.nonsecure
-    else
-        LOCAL_KEYMINT_PRODUCT_PACKAGE := android.hardware.security.keymint-service.rust.trusty
-    endif
+    LOCAL_KEYMINT_PRODUCT_PACKAGE := android.hardware.security.keymint-service.rust.trusty
+
 else
     # Default to the C++ implementation
     LOCAL_KEYMINT_PRODUCT_PACKAGE := android.hardware.security.keymint-service.trusty
diff --git a/trusty/trusty-base.mk b/trusty/trusty-base.mk
index 9d810dcb7fc6..fcde61d68e77 100644
--- a/trusty/trusty-base.mk
+++ b/trusty/trusty-base.mk
@@ -22,7 +22,13 @@
 # For gatekeeper, we include the generic -service and -impl to use legacy
 # HAL loading of gatekeeper.trusty.
 
-$(call inherit-product, system/core/trusty/keymint/trusty-keymint.mk)
+ifeq ($(KEYMINT_HAL_VENDOR_APEX_SELECT),true)
+    $(call inherit-product, system/core/trusty/keymint/trusty-keymint-apex.mk)
+
+else
+    $(call inherit-product, system/core/trusty/keymint/trusty-keymint.mk)
+
+endif
 
 ifeq ($(SECRETKEEPER_ENABLED),true)
     LOCAL_SECRETKEEPER_PRODUCT_PACKAGE := android.hardware.security.secretkeeper.trusty

From ab8c8a1b31f8ecb7f407abb8ee3b83f4606453cc Mon Sep 17 00:00:00 2001
From: Jason Chiu <jasoncschiu@google.com>
Date: Tue, 21 Jan 2025 10:46:15 +0800
Subject: [PATCH 1401/1487] bootstat: refine sys.boot.reason if device boot up
 from shipmode

- skip BootReasonStrToReason() if device boot up from shipmode
- skip BootReasonAddToHistory() if device boot up from shipmode
  and system_boot_reason is factory_reset or ota

Bug: 349723310
Test: verify sys.boot.reason work as expected if
      device boot up from shipmode
Change-Id: I4279deae8c14977c684b5b77035f16fb1b20ed71
Signed-off-by: Jason Chiu <jasoncschiu@google.com>
---
 bootstat/bootstat.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/bootstat/bootstat.cpp b/bootstat/bootstat.cpp
index 3c8c4b4f19e9..96c5b8146291 100644
--- a/bootstat/bootstat.cpp
+++ b/bootstat/bootstat.cpp
@@ -913,6 +913,19 @@ const char bootloader_reboot_reason_property[] = "ro.boot.bootreason";
 void BootReasonAddToHistory(const std::string& system_boot_reason) {
   if (system_boot_reason.empty()) return;
   LOG(INFO) << "Canonical boot reason: " << system_boot_reason;
+
+  // skip system_boot_reason(factory_reset, ota) shift since device boot up from shipmode
+  const auto bootloader_boot_reason =
+      android::base::GetProperty(bootloader_reboot_reason_property, "");
+  const char reg_fship[] = ".*fship.*";
+  if (std::regex_search(bootloader_boot_reason, std::regex(reg_fship)) != 0) {
+    if (system_boot_reason == "reboot,factory_reset" || system_boot_reason == "reboot,ota") {
+      LOG(INFO) << "skip boot reason (" << system_boot_reason
+                << ") shift since device boot up from shipmode.";
+      return;
+    }
+  }
+
   auto old_system_boot_reason = android::base::GetProperty(system_reboot_reason_property, "");
   if (!android::base::SetProperty(system_reboot_reason_property, system_boot_reason)) {
     android::base::SetProperty(system_reboot_reason_property,
@@ -954,6 +967,14 @@ void BootReasonAddToHistory(const std::string& system_boot_reason) {
 std::string BootReasonStrToReason(const std::string& boot_reason) {
   auto ret = android::base::GetProperty(system_reboot_reason_property, "");
   std::string reason(boot_reason);
+
+  // skip BootReasonStrToReason() if device boot up from shipmode
+  const char reg_fship[] = ".*fship.*";
+  if (reason == ret && std::regex_search(reason, std::regex(reg_fship)) != 0) {
+    LOG(INFO) << "skip boot reason enhancement if device boot up from shipmode";
+    return ret;
+  }
+
   // If sys.boot.reason == ro.boot.bootreason, let's re-evaluate
   if (reason == ret) ret = "";
 

From ef58a1d20a892a63a87c99ec8f05689b4c9ea599 Mon Sep 17 00:00:00 2001
From: Will McVicker <willmcvicker@google.com>
Date: Thu, 30 Jan 2025 16:53:07 -0800
Subject: [PATCH 1402/1487] toolbox/modprobe: update kernel version directory
 filter

For android15-6.6 and later kernels, for 4kb page size kernel variants
include the substring "-4k". The 16kb page size kernels omit this
substring. So update modprobe to check for the `-4k` substring when the
kernel modules are under the folder `/lib/modules/$UTS_RELEASE` for
android15-6.6 and later.

This fixes loading pkvm modules when booting kernel images packaged from
the kernel tree. For Android platform images, the kernel modules are
directly under `/lib/modules` and therefore _pgagnostic targets are not
affected by this.

Test: boot sb3 with v6.1
Test: boot sb3 with v6.12 and 16kb pages
Bug: 340631213
Change-Id: I657ec9cf5cefd7d9831a7f5d2453fb21acc6d3be
---
 toolbox/modprobe.cpp | 29 +++++++++++++++++++++++++++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/toolbox/modprobe.cpp b/toolbox/modprobe.cpp
index 13026ac30aa8..fe49ec811eca 100644
--- a/toolbox/modprobe.cpp
+++ b/toolbox/modprobe.cpp
@@ -23,6 +23,7 @@
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
+#include <android-base/macros.h>
 #include <android-base/strings.h>
 #include <android-base/stringprintf.h>
 #include <modprobe/modprobe.h>
@@ -87,6 +88,17 @@ void MyLogger(android::base::LogId id, android::base::LogSeverity severity, cons
 }
 
 static bool ModDirMatchesKernelPageSize(const char* mod_dir) {
+    static const unsigned int kernel_pgsize_kb = getpagesize() / 1024;
+    unsigned int mod_pgsize_kb = 16;  // 16k default since android15-6.6
+
+    if (mod_dir && strstr(mod_dir, "-4k") != NULL) {
+        mod_pgsize_kb = 4;
+    }
+
+    return kernel_pgsize_kb == mod_pgsize_kb;
+}
+
+static bool ModDirMatchesKernelPageSizeLegacy(const char* mod_dir) {
     static const unsigned int kernel_pgsize_kb = getpagesize() / 1024;
     const char* mod_sfx = strrchr(mod_dir, '_');
     unsigned int mod_pgsize_kb;
@@ -102,7 +114,7 @@ static bool ModDirMatchesKernelPageSize(const char* mod_dir) {
 
 // Find directories in format of "/lib/modules/x.y.z-*".
 static int KernelVersionNameFilter(const dirent* de) {
-    unsigned int major, minor;
+    static unsigned int major, minor;
     static std::string kernel_version;
     utsname uts;
 
@@ -115,7 +127,20 @@ static int KernelVersionNameFilter(const dirent* de) {
     }
 
     if (android::base::StartsWith(de->d_name, kernel_version)) {
-        return ModDirMatchesKernelPageSize(de->d_name);
+        // Check for GKI to avoid breaking non-GKI Android devices.
+        if (UNLIKELY(strstr(de->d_name, "-android") == NULL)) {
+            // For non-GKI, just match when the major and minor versions match.
+            return 1;
+        }
+
+        // For android15-6.6 and later, GKI adds `-4k` to the UTS release
+        // string to identify 4kb page size kernels. If there is no page size
+        // suffix, then the kernel page size is 16kb.
+        if (major > 6 || (major == 6 && minor >= 6)) {
+            return ModDirMatchesKernelPageSize(de->d_name);
+        } else {
+            return ModDirMatchesKernelPageSizeLegacy(de->d_name);
+        }
     }
     return 0;
 }

From 74cc6c4faabd60533bc8590561b21f011292caea Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Mon, 10 Feb 2025 03:01:08 +0000
Subject: [PATCH 1403/1487] trusty: keymint: trusty-keymint-apex.mk: fix
 condition

Bug: 392489757
Test: launch_cvd --secure_hals=guest_keymint_trusty_insecure
Change-Id: Icb3210012d04b13eec54858d3304c64eb9a0c4a8
---
 trusty/keymint/trusty-keymint-apex.mk | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/keymint/trusty-keymint-apex.mk b/trusty/keymint/trusty-keymint-apex.mk
index 8b7f4d05a590..7c44fbc7d34d 100644
--- a/trusty/keymint/trusty-keymint-apex.mk
+++ b/trusty/keymint/trusty-keymint-apex.mk
@@ -22,7 +22,7 @@ PRODUCT_PACKAGES += \
     android.hardware.security.keymint-service.trusty_tee.cpp \
     android.hardware.security.keymint-service.trusty_tee \
 
-ifeq ($(findstring $(TRUSTY_SYSTEM_VM),enabled),enabled)
+ifeq ($(findstring enabled, $(TRUSTY_SYSTEM_VM)),enabled)
     PRODUCT_PACKAGES += \
         android.hardware.security.keymint-service.trusty_system_vm \
 

From 9c4b0eeea83d64788c91c3619f86f0836c89dfef Mon Sep 17 00:00:00 2001
From: Christopher Ferris <cferris@google.com>
Date: Mon, 10 Feb 2025 14:16:42 -0800
Subject: [PATCH 1404/1487] Fix potential flaky debuggerd tests.

Some of the tests rely on the fact that a map created for the test
will be listed in the maps part of a tombstone as distinct. However,
if there was an unnamed map that starts right before the test map,
it appears in the tombstone map list as a single larger map and
causes tests to fail. To fix this, name the maps with prctl to
guarantee that these are distinct and will not result in a
combined map in the tombstone.

Bug: 395295765

Test: All unit tests pass.
Change-Id: Ib8a7c6dbfbc810f67fe5e5b9cb7802bbbec2cbba
---
 debuggerd/debuggerd_test.cpp | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 04a7df8231a1..858956a80bd2 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -2788,6 +2788,10 @@ TEST_F(CrasherTest, fault_address_between_maps) {
   void* start_ptr =
       mmap(nullptr, 3 * getpagesize(), PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   ASSERT_NE(MAP_FAILED, start_ptr);
+  // Add a name to guarantee that this map is distinct and not combined in the map listing.
+  EXPECT_EQ(
+      prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, start_ptr, 3 * getpagesize(), "debuggerd map start"),
+      0);
   // Unmap the page in the middle.
   void* middle_ptr =
       reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(start_ptr) + getpagesize());
@@ -2834,6 +2838,8 @@ TEST_F(CrasherTest, fault_address_in_map) {
   // Create a map before the fork so it will be present in the child.
   void* ptr = mmap(nullptr, getpagesize(), 0, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   ASSERT_NE(MAP_FAILED, ptr);
+  // Add a name to guarantee that this map is distinct and not combined in the map listing.
+  EXPECT_EQ(prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, ptr, getpagesize(), "debuggerd map"), 0);
 
   StartProcess([ptr]() {
     ASSERT_EQ(0, crash_call(reinterpret_cast<uintptr_t>(ptr)));
@@ -2905,7 +2911,7 @@ TEST_F(CrasherTest, verify_dex_pc_with_function_name) {
         mmap(nullptr, sizeof(kDexData), PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
     ASSERT_TRUE(ptr != MAP_FAILED);
     memcpy(ptr, kDexData, sizeof(kDexData));
-    prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, ptr, sizeof(kDexData), "dex");
+    EXPECT_EQ(prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, ptr, sizeof(kDexData), "dex"), 0);
 
     JITCodeEntry dex_entry = {.symfile_addr = reinterpret_cast<uintptr_t>(ptr),
                               .symfile_size = sizeof(kDexData)};
@@ -3006,12 +3012,18 @@ TEST_F(CrasherTest, verify_map_format) {
   // Create multiple maps to make sure that the map data is formatted properly.
   void* none_map = mmap(nullptr, getpagesize(), 0, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   ASSERT_NE(MAP_FAILED, none_map);
+  // Add names to guarantee that the maps are distinct and not combined in the map listing.
+  EXPECT_EQ(prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, none_map, getpagesize(), "debuggerd map none"),
+            0);
   void* r_map = mmap(nullptr, getpagesize(), PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   ASSERT_NE(MAP_FAILED, r_map);
+  EXPECT_EQ(prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, r_map, getpagesize(), "debuggerd map r"), 0);
   void* w_map = mmap(nullptr, getpagesize(), PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  EXPECT_EQ(prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, w_map, getpagesize(), "debuggerd map w"), 0);
   ASSERT_NE(MAP_FAILED, w_map);
   void* x_map = mmap(nullptr, getpagesize(), PROT_EXEC, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   ASSERT_NE(MAP_FAILED, x_map);
+  EXPECT_EQ(prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, x_map, getpagesize(), "debuggerd map x"), 0);
 
   TemporaryFile tf;
   ASSERT_EQ(0x2000, lseek(tf.fd, 0x2000, SEEK_SET));
@@ -3046,7 +3058,7 @@ TEST_F(CrasherTest, verify_map_format) {
   std::string match_str;
   // Verify none.
   match_str = android::base::StringPrintf(
-      "    %s-%s ---         0      %x\\n",
+      "    %s-%s ---         0      %x  \\[anon:debuggerd map none\\]\\n",
       format_map_pointer(reinterpret_cast<uintptr_t>(none_map)).c_str(),
       format_map_pointer(reinterpret_cast<uintptr_t>(none_map) + getpagesize() - 1).c_str(),
       getpagesize());
@@ -3054,7 +3066,7 @@ TEST_F(CrasherTest, verify_map_format) {
 
   // Verify read-only.
   match_str = android::base::StringPrintf(
-      "    %s-%s r--         0      %x\\n",
+      "    %s-%s r--         0      %x  \\[anon:debuggerd map r\\]\\n",
       format_map_pointer(reinterpret_cast<uintptr_t>(r_map)).c_str(),
       format_map_pointer(reinterpret_cast<uintptr_t>(r_map) + getpagesize() - 1).c_str(),
       getpagesize());
@@ -3062,7 +3074,7 @@ TEST_F(CrasherTest, verify_map_format) {
 
   // Verify write-only.
   match_str = android::base::StringPrintf(
-      "    %s-%s -w-         0      %x\\n",
+      "    %s-%s -w-         0      %x  \\[anon:debuggerd map w\\]\\n",
       format_map_pointer(reinterpret_cast<uintptr_t>(w_map)).c_str(),
       format_map_pointer(reinterpret_cast<uintptr_t>(w_map) + getpagesize() - 1).c_str(),
       getpagesize());
@@ -3070,7 +3082,7 @@ TEST_F(CrasherTest, verify_map_format) {
 
   // Verify exec-only.
   match_str = android::base::StringPrintf(
-      "    %s-%s --x         0      %x\\n",
+      "    %s-%s --x         0      %x  \\[anon:debuggerd map x\\]\\n",
       format_map_pointer(reinterpret_cast<uintptr_t>(x_map)).c_str(),
       format_map_pointer(reinterpret_cast<uintptr_t>(x_map) + getpagesize() - 1).c_str(),
       getpagesize());

From 9441fe979291d6b4e7db3c3742d1ef913d831cae Mon Sep 17 00:00:00 2001
From: luanzhuang <luanzhuang@xiaomi.corp-partner.google.com>
Date: Tue, 11 Feb 2025 09:56:55 +0800
Subject: [PATCH 1405/1487] Remove unused local variables -- path

Bug: none

Change-Id: I7d96c83a53a4fd1fc6ba662bebc13f80e82ff234
Signed-off-by: luanzhuang <luanzhuang@xiaomi.corp-partner.google.com>
---
 debuggerd/tombstoned/tombstoned.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/debuggerd/tombstoned/tombstoned.cpp b/debuggerd/tombstoned/tombstoned.cpp
index 2c7237934ec6..dd20dc5dffac 100644
--- a/debuggerd/tombstoned/tombstoned.cpp
+++ b/debuggerd/tombstoned/tombstoned.cpp
@@ -144,7 +144,6 @@ class CrashQueue {
   CrashArtifact create_temporary_file() const {
     CrashArtifact result;
 
-    std::optional<std::string> path;
     result.fd.reset(openat(dir_fd_, ".", O_WRONLY | O_APPEND | O_TMPFILE | O_CLOEXEC, 0660));
     if (result.fd == -1) {
       PLOG(FATAL) << "failed to create temporary tombstone in " << dir_path_;

From 622633e7fee0a20f1c2ce1ddabce76b5b9ef74e7 Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Tue, 11 Feb 2025 07:48:58 -0800
Subject: [PATCH 1406/1487] Fix new adb remount/overlayfs solution for older
 kernels

Bug: 395860950
Test: system/core/fs_mgr/tests/adb-remount-test.sh and manual
confirmation from bug reporter that bug has gone

Change-Id: Ia27b5ee8c0c2cffff37f2c652d8cdc41e1f22a32
---
 fs_mgr/fs_mgr.cpp | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index 275bc8061361..a30d9c01fadf 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -2336,10 +2336,6 @@ OverlayfsCheckResult CheckOverlayfs() {
         return {.supported = false};
     }
 
-    if (!use_override_creds) {
-        return {.supported = true, ",userxattr"};
-    }
-
     struct utsname uts;
     if (uname(&uts) == -1) {
         return {.supported = false};
@@ -2348,6 +2344,14 @@ OverlayfsCheckResult CheckOverlayfs() {
     if (sscanf(uts.release, "%d.%d", &major, &minor) != 2) {
         return {.supported = false};
     }
+
+    if (!use_override_creds) {
+        if (major > 5 || (major == 5 && minor >= 15)) {
+            return {.supported = true, ",userxattr"};
+        }
+        return {.supported = true};
+    }
+
     // Overlayfs available in the kernel, and patched for override_creds?
     if (access("/sys/module/overlay/parameters/override_creds", F_OK) == 0) {
         auto mount_flags = ",override_creds=off"s;

From 27a825f11e2ce545acb8d1b09fce386f7f8e91f2 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 11 Feb 2025 13:56:16 -0800
Subject: [PATCH 1407/1487] libsnapuserd: Pause/Resume Snapshot merge

Add API to support pause and resume of snapshot merge

Bug: 386142969
Test: Reboot device when snapshot merge is in progress
Change-Id: I6d1e36895a6b1b14a4e915d16afbd844a14f6175
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../include/snapuserd/snapuserd_client.h      |  3 ++
 .../snapuserd/snapuserd_client.cpp            |  9 +++++
 .../user-space-merge/handler_manager.cpp      | 20 ++++++++++
 .../user-space-merge/handler_manager.h        |  8 ++++
 .../user-space-merge/merge_worker.cpp         |  3 ++
 .../user-space-merge/snapuserd_core.h         |  8 ++++
 .../user-space-merge/snapuserd_server.cpp     |  3 ++
 .../user-space-merge/snapuserd_test.cpp       | 20 ++++++++++
 .../snapuserd_transitions.cpp                 | 39 ++++++++++++++++++-
 9 files changed, 112 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h
index ede92dd973b4..453627c0f1ec 100644
--- a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h
@@ -108,6 +108,9 @@ class SnapuserdClient {
 
     // Notify init that snapuserd daemon is ready post selinux transition
     void NotifyTransitionDaemonIsReady();
+
+    // Pause Merge threads
+    bool PauseMerge();
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
index 7c820f32b494..0497c6566067 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
@@ -52,6 +52,7 @@ bool EnsureSnapuserdStarted() {
             return false;
         }
     }
+
     if (!android::base::WaitForProperty("snapuserd.ready", "true", 10s)) {
         LOG(ERROR) << "Timed out waiting for snapuserd to be ready.";
         return false;
@@ -389,5 +390,13 @@ void SnapuserdClient::NotifyTransitionDaemonIsReady() {
     }
 }
 
+bool SnapuserdClient::PauseMerge() {
+    if (!Sendmsg("pause_merge")) {
+        LOG(ERROR) << "Failed to pause snapshot merge.";
+        return false;
+    }
+    return true;
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
index fdd9cce0cbc3..cf507e32d545 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.cpp
@@ -383,5 +383,25 @@ auto SnapshotHandlerManager::FindHandler(std::lock_guard<std::mutex>* proof_of_l
     return dm_users_.end();
 }
 
+void SnapshotHandlerManager::PauseMerge() {
+    std::lock_guard<std::mutex> guard(lock_);
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        if (!(*iter)->ThreadTerminated()) {
+            (*iter)->snapuserd()->PauseMergeThreads();
+        }
+    }
+}
+
+void SnapshotHandlerManager::ResumeMerge() {
+    std::lock_guard<std::mutex> guard(lock_);
+
+    for (auto iter = dm_users_.begin(); iter != dm_users_.end(); iter++) {
+        if (!(*iter)->ThreadTerminated()) {
+            (*iter)->snapuserd()->ResumeMergeThreads();
+        }
+    }
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
index c6301d46cad0..89f3461345f5 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/handler_manager.h
@@ -86,6 +86,12 @@ class ISnapshotHandlerManager {
 
     // Disable partition verification
     virtual void DisableVerification() = 0;
+
+    // Pause Merge threads
+    virtual void PauseMerge() = 0;
+
+    // Resume Merge threads
+    virtual void ResumeMerge() = 0;
 };
 
 class SnapshotHandlerManager final : public ISnapshotHandlerManager {
@@ -107,6 +113,8 @@ class SnapshotHandlerManager final : public ISnapshotHandlerManager {
     double GetMergePercentage() override;
     bool GetVerificationStatus() override;
     void DisableVerification() override { perform_verification_ = false; }
+    void PauseMerge() override;
+    void ResumeMerge() override;
 
   private:
     bool StartHandler(const std::shared_ptr<HandlerThread>& handler);
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
index febb4847d1f5..660082f73c92 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/merge_worker.cpp
@@ -191,6 +191,9 @@ bool MergeWorker::MergeReplaceZeroOps() {
                                "down merge";
             return false;
         }
+
+        // Safe to check if there is a pause request.
+        snapuserd_->PauseMergeIfRequired();
     }
 
     // Any left over ops not flushed yet.
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
index 2340b0b20dcb..924539fe38c4 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h
@@ -175,6 +175,9 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     bool MergeInitiated() { return merge_initiated_; }
     bool MergeMonitored() { return merge_monitored_; }
     double GetMergePercentage() { return merge_completion_percentage_; }
+    void PauseMergeThreads();
+    void ResumeMergeThreads();
+    void PauseMergeIfRequired();
 
     // Merge Block State Transitions
     void SetMergeCompleted(size_t block_index);
@@ -255,6 +258,11 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
     uint32_t cow_op_merge_size_ = 0;
     std::unique_ptr<UpdateVerify> update_verify_;
     std::shared_ptr<IBlockServerOpener> block_server_opener_;
+
+    // Pause merge threads
+    bool pause_merge_ = false;
+    std::mutex pause_merge_lock_;
+    std::condition_variable pause_merge_cv_;
 };
 
 std::ostream& operator<<(std::ostream& os, MERGE_IO_TRANSITION value);
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index 3bb8a3037344..a40617bc3655 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -227,6 +227,9 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
             return Sendmsg(fd, "fail");
         }
         return Sendmsg(fd, "success");
+    } else if (cmd == "pause_merge") {
+        handlers_->PauseMerge();
+        return true;
     } else {
         LOG(ERROR) << "Received unknown message type from client";
         Sendmsg(fd, "fail");
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
index 469fd091a47e..0790a193538e 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_test.cpp
@@ -934,6 +934,26 @@ TEST_P(SnapuserdTest, Snapshot_MERGE_IO_TEST_1) {
     read_future.wait();
 }
 
+TEST_P(SnapuserdTest, Snapshot_MERGE_PAUSE_RESUME) {
+    if (!harness_->HasUserDevice()) {
+        GTEST_SKIP() << "Skipping snapshot read; not supported";
+    }
+    ASSERT_NO_FATAL_FAILURE(SetupDefault());
+    // Start the merge
+    ASSERT_TRUE(StartMerge());
+    std::this_thread::sleep_for(300ms);
+    // Pause merge
+    handlers_->PauseMerge();
+    // Issue I/O after pausing the merge and validate
+    auto read_future =
+            std::async(std::launch::async, &SnapuserdTest::ReadSnapshotDeviceAndValidate, this);
+    // Resume the merge
+    handlers_->ResumeMerge();
+    CheckMergeCompletion();
+    ValidateMerge();
+    read_future.wait();
+}
+
 TEST_P(SnapuserdTest, Snapshot_Merge_Resume) {
     ASSERT_NO_FATAL_FAILURE(SetupDefault());
     ASSERT_NO_FATAL_FAILURE(MergeInterrupt());
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
index 714c64124fbd..90705f77949b 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_transitions.cpp
@@ -257,6 +257,19 @@ bool SnapshotHandler::ReadAheadIOCompleted(bool sync) {
     return true;
 }
 
+void SnapshotHandler::PauseMergeIfRequired() {
+    {
+        std::unique_lock<std::mutex> lock(pause_merge_lock_);
+        while (pause_merge_) {
+            SNAP_LOG(INFO) << "Merge thread paused";
+            pause_merge_cv_.wait(lock);
+            if (!pause_merge_) {
+                SNAP_LOG(INFO) << "Merge thread resumed";
+            }
+        }
+    }
+}
+
 // Invoked by RA thread - Waits for merge thread to finish merging
 // RA Block N - RA thread would be ready will with Block N+1 but
 // will wait to merge thread to finish Block N. Once Block N
@@ -281,8 +294,13 @@ bool SnapshotHandler::WaitForMergeReady() {
             }
             return false;
         }
-        return true;
     }
+
+    // This is a safe place to check if the RA thread should be
+    // paused. Since the scratch space isn't flushed yet, it is safe
+    // to wait here until resume is invoked.
+    PauseMergeIfRequired();
+    return true;
 }
 
 // Invoked by Merge thread - Notify RA thread about Merge completion
@@ -297,6 +315,11 @@ void SnapshotHandler::NotifyRAForMergeReady() {
     }
 
     cv.notify_all();
+
+    // This is a safe place to check if the merge thread should be
+    // paused. The data from the scratch space is merged to disk and is safe
+    // to wait.
+    PauseMergeIfRequired();
 }
 
 // The following transitions are mostly in the failure paths
@@ -393,6 +416,20 @@ void SnapshotHandler::MarkMergeComplete() {
     merge_complete_ = true;
 }
 
+void SnapshotHandler::PauseMergeThreads() {
+    {
+        std::lock_guard<std::mutex> lock(pause_merge_lock_);
+        pause_merge_ = true;
+    }
+}
+
+void SnapshotHandler::ResumeMergeThreads() {
+    {
+        std::lock_guard<std::mutex> lock(pause_merge_lock_);
+        pause_merge_ = false;
+    }
+}
+
 std::string SnapshotHandler::GetMergeStatus() {
     bool merge_not_initiated = false;
     bool merge_monitored = false;

From d48e75a1a407a890a7ee3103aa5eede276968f2f Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 11 Feb 2025 14:12:45 -0800
Subject: [PATCH 1408/1487] libsnapshot: Pause snapshot merge during shutdown

If the device is mounted off snapshots, initiate the snapshot-merge
pause.

Additionally, try to umount the partitions which are mounted off snapshots.

Bug: 386142969
Test: Reboot device when snapshot merge is in progress and verify merge
threads are paused
Change-Id: Ide9e33157432e3a8d4e6ba7d4d414270505b8941
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../include/libsnapshot/snapshot.h            | 13 +++++++---
 fs_mgr/libsnapshot/snapshot.cpp               | 22 +++++++++++++----
 fs_mgr/libsnapshot/snapshot_test.cpp          |  6 +++--
 init/reboot.cpp                               | 24 +++++++++++++++++--
 4 files changed, 54 insertions(+), 11 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index 165ecef79c25..e613d541462a 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -418,9 +418,16 @@ class SnapshotManager final : public ISnapshotManager {
     // first-stage to decide whether to launch snapuserd.
     bool IsSnapuserdRequired();
 
-    // This is primarily used to device reboot. If OTA update is in progress,
-    // init will avoid killing processes
-    bool IsUserspaceSnapshotUpdateInProgress();
+    // This is primarily invoked during device reboot after an OTA update.
+    //
+    // a: Check if the partitions are mounted off snapshots.
+    //
+    // b: Store all dynamic partitions which are mounted off snapshots. This
+    // is used to unmount the partition.
+    bool IsUserspaceSnapshotUpdateInProgress(std::vector<std::string>& dynamic_partitions);
+
+    // Pause the snapshot merge.
+    bool PauseSnapshotMerge();
 
     enum class SnapshotDriver {
         DM_SNAPSHOT,
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 83787df456d9..d4561972ad8f 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -4687,7 +4687,17 @@ std::string SnapshotManager::ReadSourceBuildFingerprint() {
     return status.source_build_fingerprint();
 }
 
-bool SnapshotManager::IsUserspaceSnapshotUpdateInProgress() {
+bool SnapshotManager::PauseSnapshotMerge() {
+    auto snapuserd_client = SnapuserdClient::TryConnect(kSnapuserdSocket, 5s);
+    if (snapuserd_client) {
+        // Pause the snapshot-merge
+        return snapuserd_client->PauseMerge();
+    }
+    return false;
+}
+
+bool SnapshotManager::IsUserspaceSnapshotUpdateInProgress(
+        std::vector<std::string>& dynamic_partitions) {
     // We cannot grab /metadata/ota lock here as this
     // is in reboot path. See b/308900853
     //
@@ -4701,18 +4711,22 @@ bool SnapshotManager::IsUserspaceSnapshotUpdateInProgress() {
         LOG(ERROR) << "No dm-enabled block device is found.";
         return false;
     }
+
+    bool is_ota_in_progress = false;
     for (auto& partition : dm_block_devices) {
         std::string partition_name = partition.first + current_suffix;
         DeviceMapper::TargetInfo snap_target;
         if (!GetSingleTarget(partition_name, TableQuery::Status, &snap_target)) {
-            return false;
+            continue;
         }
         auto type = DeviceMapper::GetTargetType(snap_target.spec);
+        // Partition is mounted off snapshots
         if (type == "user") {
-            return true;
+            dynamic_partitions.emplace_back("/" + partition.first);
+            is_ota_in_progress = true;
         }
     }
-    return false;
+    return is_ota_in_progress;
 }
 
 bool SnapshotManager::BootFromSnapshotsWithoutSlotSwitch() {
diff --git a/fs_mgr/libsnapshot/snapshot_test.cpp b/fs_mgr/libsnapshot/snapshot_test.cpp
index e04e429e3ddc..7719a295c4cb 100644
--- a/fs_mgr/libsnapshot/snapshot_test.cpp
+++ b/fs_mgr/libsnapshot/snapshot_test.cpp
@@ -3112,8 +3112,10 @@ int main(int argc, char** argv) {
     // thereby interfering with the update and snapshot-merge progress.
     // Hence, wait until the update is complete.
     auto sm = android::snapshot::SnapshotManager::New();
-    while (sm->IsUserspaceSnapshotUpdateInProgress()) {
-        LOG(INFO) << "Snapshot update is in progress. Waiting...";
+    std::vector<std::string> snapshot_partitions;
+    while (sm->IsUserspaceSnapshotUpdateInProgress(snapshot_partitions)) {
+        LOG(INFO) << "Waiting for: " << snapshot_partitions.size()
+                  << " partitions to finish snapshot-merge";
         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
     }
 
diff --git a/init/reboot.cpp b/init/reboot.cpp
index d6e37f73162b..8b1097409a8f 100644
--- a/init/reboot.cpp
+++ b/init/reboot.cpp
@@ -394,6 +394,21 @@ void RebootMonitorThread(unsigned int cmd, const std::string& reboot_target,
     }
 }
 
+static void UmountDynamicPartitions(const std::vector<std::string>& dynamic_partitions) {
+    for (auto device : dynamic_partitions) {
+        // Cannot unmount /system
+        if (device == "/system") {
+            continue;
+        }
+        int r = umount2(device.c_str(), MNT_FORCE);
+        if (r == 0) {
+            LOG(INFO) << "Umounted success: " << device;
+        } else {
+            PLOG(WARNING) << "Cannot umount: " << device;
+        }
+    }
+}
+
 /* Try umounting all emulated file systems R/W block device cfile systems.
  * This will just try umount and give it up if it fails.
  * For fs like ext4, this is ok as file system will be marked as unclean shutdown
@@ -408,14 +423,18 @@ static UmountStat TryUmountAndFsck(unsigned int cmd, bool run_fsck,
     Timer t;
     std::vector<MountEntry> block_devices;
     std::vector<MountEntry> emulated_devices;
+    std::vector<std::string> dynamic_partitions;
 
     if (run_fsck && !FindPartitionsToUmount(&block_devices, &emulated_devices, false)) {
         return UMOUNT_STAT_ERROR;
     }
     auto sm = snapshot::SnapshotManager::New();
     bool ota_update_in_progress = false;
-    if (sm->IsUserspaceSnapshotUpdateInProgress()) {
-        LOG(INFO) << "OTA update in progress";
+    if (sm->IsUserspaceSnapshotUpdateInProgress(dynamic_partitions)) {
+        LOG(INFO) << "OTA update in progress. Pause snapshot merge";
+        if (!sm->PauseSnapshotMerge()) {
+            LOG(ERROR) << "Snapshot-merge pause failed";
+        }
         ota_update_in_progress = true;
     }
     UmountStat stat = UmountPartitions(timeout - t.duration());
@@ -435,6 +454,7 @@ static UmountStat TryUmountAndFsck(unsigned int cmd, bool run_fsck,
         // still not doing fsck when all processes are killed.
         //
         if (ota_update_in_progress) {
+            UmountDynamicPartitions(dynamic_partitions);
             return stat;
         }
         KillAllProcesses();

From 01f60e4b5e9d0ab9a143ac2de01de288ca75bfe2 Mon Sep 17 00:00:00 2001
From: "Isaac J. Manjarres" <isaacmanjarres@google.com>
Date: Wed, 5 Feb 2025 01:08:20 -0800
Subject: [PATCH 1409/1487] ashmem: Test for ASHMEM_GET_SIZE for ashmem-memfd
 compatibility

ASHMEM_SET_SIZE will return  an error in the ashmem-memfd compatibility
logic, but ASHMEM_GET_SIZE will work as expected, so exercise that ioctl
command when testing for ashmem-memfd compatibility.

Bug: 111903542
Change-Id: I3a042063082fdf6d8d836ad9b37becc318e8d89d
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
---
 libcutils/ashmem-dev.cpp | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index adf7e3742590..768db81bf95e 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -120,8 +120,11 @@ static bool __has_memfd_support() {
     // permissions of the buffer (i.e. they cannot be changed by fchmod()).
     //
     // MFD_NOEXEC_SEAL implies MFD_ALLOW_SEALING.
+    const char *test_buf_name = "test_android_memfd";
+    size_t buf_size = getpagesize();
+
     android::base::unique_fd fd(
-            syscall(__NR_memfd_create, "test_android_memfd", MFD_CLOEXEC | MFD_NOEXEC_SEAL));
+            syscall(__NR_memfd_create, test_buf_name, MFD_CLOEXEC | MFD_NOEXEC_SEAL));
     if (fd == -1) {
         ALOGE("memfd_create failed: %m, no memfd support");
         return false;
@@ -132,13 +135,20 @@ static bool __has_memfd_support() {
         return false;
     }
 
+    if (ftruncate(fd, buf_size) == -1) {
+        ALOGE("ftruncate(%s, %zd) failed to set memfd buffer size: %m, no memfd support",
+              test_buf_name, buf_size);
+        return false;
+    }
+
     /*
      * Ensure that the kernel supports ashmem ioctl commands on memfds. If not,
      * fall back to using ashmem.
      */
-    if (TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_SET_SIZE, getpagesize())) < 0) {
-        ALOGE("ioctl(ASHMEM_SET_SIZE, %d) failed: %m, no ashmem-memfd compat support",
-              getpagesize());
+    int ashmem_size = TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_GET_SIZE, 0));
+    if (ashmem_size != static_cast<int>(buf_size)) {
+        ALOGE("ioctl(ASHMEM_GET_SIZE): %d != buf_size: %zd , no ashmem-memfd compat support",
+              ashmem_size, buf_size);
         return false;
     }
 

From 26371694d32e2440c8071ce532aa8261adfaf9c8 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 13 Feb 2025 15:40:24 -0800
Subject: [PATCH 1410/1487] init: umount dynamic partitions during shutdown

If the device is mounted off snapshots, try to unmount
dynamic partitions.

Bug: 386142969
Test: Reboot device mounted off snapshots and verify partitions
are unmounted
Change-Id: Idc8d65750f0d336d12e6dfe78f16dc911b0dea3c
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 init/reboot.cpp | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/init/reboot.cpp b/init/reboot.cpp
index 8b1097409a8f..d7ad861fb6f7 100644
--- a/init/reboot.cpp
+++ b/init/reboot.cpp
@@ -394,7 +394,8 @@ void RebootMonitorThread(unsigned int cmd, const std::string& reboot_target,
     }
 }
 
-static void UmountDynamicPartitions(const std::vector<std::string>& dynamic_partitions) {
+static bool UmountDynamicPartitions(const std::vector<std::string>& dynamic_partitions) {
+    bool ret = true;
     for (auto device : dynamic_partitions) {
         // Cannot unmount /system
         if (device == "/system") {
@@ -405,8 +406,10 @@ static void UmountDynamicPartitions(const std::vector<std::string>& dynamic_part
             LOG(INFO) << "Umounted success: " << device;
         } else {
             PLOG(WARNING) << "Cannot umount: " << device;
+            ret = false;
         }
     }
+    return ret;
 }
 
 /* Try umounting all emulated file systems R/W block device cfile systems.
@@ -454,7 +457,17 @@ static UmountStat TryUmountAndFsck(unsigned int cmd, bool run_fsck,
         // still not doing fsck when all processes are killed.
         //
         if (ota_update_in_progress) {
-            UmountDynamicPartitions(dynamic_partitions);
+            bool umount_dynamic_partitions = UmountDynamicPartitions(dynamic_partitions);
+            LOG(INFO) << "Sending SIGTERM to all process";
+            // Send SIGTERM to all processes except init
+            WriteStringToFile("e", PROC_SYSRQ);
+            // Wait for processes to terminate
+            std::this_thread::sleep_for(1s);
+            // Try one more attempt to umount other partitions which failed
+            // earlier
+            if (!umount_dynamic_partitions) {
+                UmountDynamicPartitions(dynamic_partitions);
+            }
             return stat;
         }
         KillAllProcesses();

From 5b395ce2cc2f02cccc46d026d451dee9066ce0f3 Mon Sep 17 00:00:00 2001
From: Neha Jain <jainne@google.com>
Date: Fri, 14 Feb 2025 00:18:46 -0800
Subject: [PATCH 1411/1487] Revert^3 "Run module code only after KeyMints
 receive module info"

This reverts commit 2dc0a19e97a38bd2ae66784e1f13eb3409e6453f.

Reason for revert: b/396538691

Change-Id: Ia1a124bcbb419c266cf3ae27699967615d5d0d84
---
 rootdir/init.rc | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 0b45e73c77b1..f1670ae04a33 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -995,11 +995,8 @@ on post-fs-data
     mkdir /data/misc/stats-service/ 0770 statsd system
     mkdir /data/misc/train-info/ 0770 statsd system
 
-    # TODO(b/369375199): Remove once attest modules flagging is removed.
+    # Wait for apexd to finish activating APEXes before starting more processes.
     wait_for_prop apexd.status activated
-    # Wait for KeyMints to receive APEX module info before starting code from updateable APEXes.
-    # This is to prevent APEX modules from interfering in module measurement.
-    wait_for_prop keystore.module_hash.sent true
     perform_apex_config
 
     exec_start system_aconfigd_mainline_init

From f9befac69378ca8d918b7947f5d06ab5c24c37ac Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Wed, 12 Feb 2025 12:11:20 -0800
Subject: [PATCH 1412/1487] Remove space check from overlayfs test

This check means that drives are remounted with overlayfs more or less
at random, which means that overlayfs_remounter selinux policy will have
to be very permissive to support all possible remounts.

Test: system/core/fs_mgr/tests/adb-remount-test.sh, confirmation from
reporter that this does indeed fix their issue

Bug: 394657884
Change-Id: I2b340f5df1a609ad5b8e2214bbe7afddec23ca31
---
 fs_mgr/fs_mgr_overlayfs_mount.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index b63b9e7aa0fb..69d316125a8b 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -194,9 +194,8 @@ static bool fs_mgr_is_read_only_f2fs(const std::string& dev) {
 
 static bool fs_mgr_overlayfs_enabled(FstabEntry* entry) {
     // readonly filesystem, can not be mount -o remount,rw
-    // for squashfs, erofs or if free space is (near) zero making such a remount
-    // virtually useless, or if there are shared blocks that prevent remount,rw
-    if (!fs_mgr_filesystem_has_space(entry->mount_point)) {
+    // for squashfs, erofs, or if there are shared blocks that prevent remount,rw
+    if (entry->fs_type == "erofs" || entry->fs_type == "squashfs") {
         return true;
     }
 

From d435894e9f6b6ef876e51eef07761d27eff98fd7 Mon Sep 17 00:00:00 2001
From: Steven Moreland <smoreland@google.com>
Date: Sat, 15 Feb 2025 00:45:21 +0000
Subject: [PATCH 1413/1487] RefBase: document 0 strong count, wp<>::promote

Explanation within. This shows the errorprone behavior
of the implicit wp<> constructor and justifies why we
recommend wp<>::fromExisting.

Bug: 393013610
Test: libutils_binder_test
Change-Id: I323b2902f0ae58da8512bdbc80377b5c5865294d
---
 libutils/binder/RefBase_test.cpp | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/libutils/binder/RefBase_test.cpp b/libutils/binder/RefBase_test.cpp
index 65d40a2a1823..36d1a4a389d6 100644
--- a/libutils/binder/RefBase_test.cpp
+++ b/libutils/binder/RefBase_test.cpp
@@ -265,6 +265,37 @@ TEST(RefBase, AssertWeakRefExistsDeath) {
     delete foo;
 }
 
+TEST(RefBase, NoStrongCountPromoteFromWeak) {
+    bool isDeleted;
+    Foo* foo = new Foo(&isDeleted);
+
+    wp<Foo> weakFoo = wp<Foo>(foo);
+
+    EXPECT_FALSE(isDeleted);
+
+    {
+        sp<Foo> strongFoo = weakFoo.promote();
+        EXPECT_EQ(strongFoo, foo);
+    }
+
+    // this shows the justification of wp<>::fromExisting.
+    // if you construct a wp<>, for instance in a constructor, and it is
+    // accidentally promoted, that promoted sp<> will exclusively own
+    // the object. If that happens during the initialization of the
+    // object or in this scope, as you can see 'Foo* foo' is unowned,
+    // then we are left with a deleted object, and we could not put it
+    // into an sp<>.
+    //
+    // Consider the other implementation, where we disallow promoting
+    // a wp<> if there are no strong counts. If we return null, then
+    // the object would be unpromotable even though it hasn't been deleted.
+    // This is also errorprone.
+    //
+    // attemptIncStrong aborting in this case is a backwards incompatible
+    // change due to frequent use of wp<T>(this) in the constructor.
+    EXPECT_TRUE(isDeleted);
+}
+
 TEST(RefBase, DoubleOwnershipDeath) {
     bool isDeleted;
     auto foo = sp<Foo>::make(&isDeleted);

From cf1376b288657dc4496bcfd90910cbd7997dfc79 Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Sat, 15 Feb 2025 13:26:38 +0000
Subject: [PATCH 1414/1487] trusty: keymint: provision boot_info to Keymint
 Rust in TEE

Provision boot_info from keymint HAL to the Keymint Rust TA
in TEE. This is a nonsecure workaround until
this can be done by the bootloader.

Bug: 395896949
Test: lunch qemu_trusty_arm64-trunk_staging-userdebug

Change-Id: Ie69e2fe028dc4cd848383fc2da540602a42a48ff
---
 trusty/keymint/Android.bp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/trusty/keymint/Android.bp b/trusty/keymint/Android.bp
index d1cd71bca0bf..80e58f979bca 100644
--- a/trusty/keymint/Android.bp
+++ b/trusty/keymint/Android.bp
@@ -57,6 +57,13 @@ rust_binary {
     vendor: true,
     defaults: ["android.hardware.security.keymint-service.rust.trusty.default"],
     init_rc: ["android.hardware.security.keymint-service.trusty_tee.rc"],
+    features: select(soong_config_variable("trusty_system_vm", "placeholder_trusted_hal"), {
+        true: ["nonsecure"],
+        default: [],
+    }),
+    rustlibs: [
+        "libkmr_hal_nonsecure",
+    ],
 }
 
 // Keymint hal service in system_ext, interacting with the Trusty Security VM.

From 152f24388b4ba0ffe827a51376cf993aa41a7d9f Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Thu, 23 Jan 2025 01:32:03 +0000
Subject: [PATCH 1415/1487] trusty: trusty-storage.mk: add support for Trusty
 VMs

update the trusty-storage makefile with the
necessary Trusty VM artifacts.

Bug: 391210895
Test: qemu_trusty_arm64-trunk_staging-userdebug
Change-Id: I7c4e0611e7b695d478f11a08a7cee8dd1d756148
---
 trusty/trusty-storage.mk | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/trusty/trusty-storage.mk b/trusty/trusty-storage.mk
index 3f263167cae3..5bfbf1ecfdda 100644
--- a/trusty/trusty-storage.mk
+++ b/trusty/trusty-storage.mk
@@ -14,5 +14,30 @@
 # limitations under the License.
 #
 
+#
+# Trusty TEE packages
+#
+
+# below statement adds the singleton storage daemon in vendor,
+# storageproxyd vendor interacts with the Secure Storage TA in the
+# Trustzone Trusty TEE
 PRODUCT_PACKAGES += \
 	storageproxyd \
+
+#
+# Trusty VM packages
+#
+ifeq ($(TRUSTY_SYSTEM_VM),enabled_with_placeholder_trusted_hal)
+
+# with placeholder Trusted HALs, the Trusty VMs are standalone (i.e. they don't access
+# remote Trusted HAL services) and thus require their own secure storage.
+# (one secure storage emulation for each Trusty VM - security VM, test VM and WV VM)
+# in secure mode, the secure storage is the services by Trusty in Trustzone
+# and requires a single storageproxyd in vendor.
+PRODUCT_PACKAGES += \
+	storageproxyd.system \
+	rpmb_dev.test.system \
+	rpmb_dev.system \
+	# rpmb_dev.wv.system \
+
+endif

From adadcfef3bd4ea100d1bfb74b4b42996ed58f5e7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= <maze@google.com>
Date: Sat, 15 Feb 2025 23:13:45 -0800
Subject: [PATCH 1416/1487] OWNERS: codewiz left Google, replace with maze.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Test: N/A
Signed-off-by: Maciej Żenczykowski <maze@google.com>
Change-Id: I1c6f77f6201c900511b16f8f4682c862aa386a4b
---
 libsysutils/src/OWNERS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libsysutils/src/OWNERS b/libsysutils/src/OWNERS
index c65a40dc37d2..3244fe8f8d2e 100644
--- a/libsysutils/src/OWNERS
+++ b/libsysutils/src/OWNERS
@@ -1,2 +1,2 @@
-per-file OWNERS,Netlink* = codewiz@google.com, jchalard@google.com, lorenzo@google.com, satk@google.com
+per-file OWNERS,Netlink* = jchalard@google.com, lorenzo@google.com, maze@google.com, satk@google.com
 

From 589c992ec2fc5ee5a78dd379e0d007e3febfb4b8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= <maze@google.com>
Date: Sat, 15 Feb 2025 23:27:55 -0800
Subject: [PATCH 1417/1487] Simplify ULOG parsing code now that all kernels are
 64-bit.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Test: TreeHugger
Signed-off-by: Maciej Żenczykowski <maze@google.com>
Change-Id: Ida581e3e9eff55dfd4b9f4c91db85095818723a4
---
 libsysutils/src/NetlinkEvent.cpp | 121 ++++++-------------------------
 1 file changed, 24 insertions(+), 97 deletions(-)

diff --git a/libsysutils/src/NetlinkEvent.cpp b/libsysutils/src/NetlinkEvent.cpp
index 55bbe46e1a85..47586db07109 100644
--- a/libsysutils/src/NetlinkEvent.cpp
+++ b/libsysutils/src/NetlinkEvent.cpp
@@ -37,108 +37,44 @@
 #include <sys/utsname.h>
 
 #include <android-base/parseint.h>
-#include <bpf/KernelUtils.h>
 #include <log/log.h>
 #include <sysutils/NetlinkEvent.h>
 
 using android::base::ParseInt;
-using android::bpf::isKernel64Bit;
-
-/* From kernel's net/netfilter/xt_quota2.c */
-const int LOCAL_QLOG_NL_EVENT = 112;
-const int LOCAL_NFLOG_PACKET = NFNL_SUBSYS_ULOG << 8 | NFULNL_MSG_PACKET;
-
-/******************************************************************************
- * WARNING: HERE BE DRAGONS!                                                  *
- *                                                                            *
- * This is here to provide for compatibility with both 32 and 64-bit kernels  *
- * from 32-bit userspace.                                                     *
- *                                                                            *
- * The kernel definition of this struct uses types (like long) that are not   *
- * the same across 32-bit and 64-bit builds, and there is no compatibility    *
- * layer to fix it up before it reaches userspace.                            *
- * As such we need to detect the bit-ness of the kernel and deal with it.     *
- *                                                                            *
- ******************************************************************************/
 
-/*
- * This is the verbatim kernel declaration from net/netfilter/xt_quota2.c,
- * it is *NOT* of a well defined layout and is included here for compile
- * time assertions only.
- *
- * It got there from deprecated ipt_ULOG.h to parse QLOG_NL_EVENT.
- */
-#define ULOG_MAC_LEN 80
-#define ULOG_PREFIX_LEN 32
-typedef struct ulog_packet_msg {
-    unsigned long mark;
-    long timestamp_sec;
-    long timestamp_usec;
-    unsigned int hook;
-    char indev_name[IFNAMSIZ];
-    char outdev_name[IFNAMSIZ];
-    size_t data_len;
-    char prefix[ULOG_PREFIX_LEN];
-    unsigned char mac_len;
-    unsigned char mac[ULOG_MAC_LEN];
-    unsigned char payload[0];
-} ulog_packet_msg_t;
-
-// On Linux int is always 32 bits, while sizeof(long) == sizeof(void*),
-// thus long on a 32-bit Linux kernel is 32-bits, like int always is
-typedef int long32;
-typedef unsigned int ulong32;
-static_assert(sizeof(long32) == 4);
-static_assert(sizeof(ulong32) == 4);
-
-// Here's the same structure definition with the assumption the kernel
-// is compiled for 32-bits.
-typedef struct {
-    ulong32 mark;
-    long32 timestamp_sec;
-    long32 timestamp_usec;
-    unsigned int hook;
-    char indev_name[IFNAMSIZ];
-    char outdev_name[IFNAMSIZ];
-    ulong32 data_len;
-    char prefix[ULOG_PREFIX_LEN];
-    unsigned char mac_len;
-    unsigned char mac[ULOG_MAC_LEN];
-    unsigned char payload[0];
-} ulog_packet_msg32_t;
-
-// long on a 64-bit kernel is 64-bits with 64-bit alignment,
-// while long long is 64-bit but may have 32-bit aligment.
+// 'long' on a 32-bit kernel is 32-bits with 32-bit alignment,
+// and on a 64-bit kernel is 64-bits with 64-bit alignment,
+// while 'long long' is always 64-bit it may have 32-bit aligment (x86 structs).
 typedef long long __attribute__((__aligned__(8))) long64;
 typedef unsigned long long __attribute__((__aligned__(8))) ulong64;
 static_assert(sizeof(long64) == 8);
 static_assert(sizeof(ulong64) == 8);
 
-// Here's the same structure definition with the assumption the kernel
-// is compiled for 64-bits.
+// From kernel's net/netfilter/xt_quota2.c
+// It got there from deprecated ipt_ULOG.h to parse QLOG_NL_EVENT.
+constexpr int LOCAL_QLOG_NL_EVENT = 112;
+constexpr int LOCAL_NFLOG_PACKET = NFNL_SUBSYS_ULOG << 8 | NFULNL_MSG_PACKET;
+
+constexpr int ULOG_MAC_LEN = 80;
+constexpr int ULOG_PREFIX_LEN = 32;
+
+// This structure layout assumes we're running on a 64-bit kernel.
 typedef struct {
-    ulong64 mark;
-    long64 timestamp_sec;
-    long64 timestamp_usec;
+    ulong64 mark;  // kernel: unsigned long
+    long64 timestamp_sec;  // kernel: long
+    long64 timestamp_usec;  // kernel: long
     unsigned int hook;
     char indev_name[IFNAMSIZ];
     char outdev_name[IFNAMSIZ];
-    ulong64 data_len;
+    ulong64 data_len;  // kernel: size_t, a.k.a. unsigned long
     char prefix[ULOG_PREFIX_LEN];
     unsigned char mac_len;
     unsigned char mac[ULOG_MAC_LEN];
     unsigned char payload[0];
-} ulog_packet_msg64_t;
-
-// One expects the 32-bit version to be smaller than the 64-bit version.
-static_assert(sizeof(ulog_packet_msg32_t) < sizeof(ulog_packet_msg64_t));
-// And either way the 'native' version should match either the 32 or 64 bit one.
-static_assert(sizeof(ulog_packet_msg_t) == sizeof(ulog_packet_msg32_t) ||
-              sizeof(ulog_packet_msg_t) == sizeof(ulog_packet_msg64_t));
+} ulog_packet_msg_t;
 
-// In practice these sizes are always simply (for both x86 and arm):
-static_assert(sizeof(ulog_packet_msg32_t) == 168);
-static_assert(sizeof(ulog_packet_msg64_t) == 192);
+// In practice, for both x86 and arm, we have
+static_assert(sizeof(ulog_packet_msg_t) == 192);
 
 /******************************************************************************/
 
@@ -356,20 +292,11 @@ bool NetlinkEvent::parseIfAddrMessage(const struct nlmsghdr *nh) {
  * Parse a QLOG_NL_EVENT message.
  */
 bool NetlinkEvent::parseUlogPacketMessage(const struct nlmsghdr *nh) {
-    const char* alert;
-    const char* devname;
-
-    if (isKernel64Bit()) {
-        ulog_packet_msg64_t* pm64 = (ulog_packet_msg64_t*)NLMSG_DATA(nh);
-        if (!checkRtNetlinkLength(nh, sizeof(*pm64))) return false;
-        alert = pm64->prefix;
-        devname = pm64->indev_name[0] ? pm64->indev_name : pm64->outdev_name;
-    } else {
-        ulog_packet_msg32_t* pm32 = (ulog_packet_msg32_t*)NLMSG_DATA(nh);
-        if (!checkRtNetlinkLength(nh, sizeof(*pm32))) return false;
-        alert = pm32->prefix;
-        devname = pm32->indev_name[0] ? pm32->indev_name : pm32->outdev_name;
-    }
+    ulog_packet_msg_t* pm = (ulog_packet_msg_t*)NLMSG_DATA(nh);
+    if (!checkRtNetlinkLength(nh, sizeof(*pm))) return false;
+
+    const char* alert = pm->prefix;
+    const char* devname = pm->indev_name[0] ? pm->indev_name : pm->outdev_name;
 
     asprintf(&mParams[0], "ALERT_NAME=%s", alert);
     asprintf(&mParams[1], "INTERFACE=%s", devname);

From 9a22de5281f69f2b7554783e2dafd7bf89cb15d7 Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Tue, 18 Feb 2025 10:32:48 -0800
Subject: [PATCH 1418/1487] Fix tests for new overlayfs

adb remount used to remount every full or almost full partition.
However, this is not possible with new overlayfs because it would
require a very permissive overlay_remounter policy.

Make component of test that specifically looks for that logging only

Bug: 397158623
Test: system/core/fs_mgr/tests/adb-remount-test.sh on Pixel 6
Change-Id: I0a1d8088fa0a3ce880111254366468268c6bffb9
---
 fs_mgr/tests/adb-remount-test.sh | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/tests/adb-remount-test.sh b/fs_mgr/tests/adb-remount-test.sh
index 139ac923aa17..df9635e426f9 100755
--- a/fs_mgr/tests/adb-remount-test.sh
+++ b/fs_mgr/tests/adb-remount-test.sh
@@ -1320,7 +1320,10 @@ if ${overlayfs_needed}; then
   for d in ${D}; do
     if adb_sh tune2fs -l "${d}" </dev/null 2>&1 | grep -q "Filesystem features:.*shared_blocks" ||
         adb_sh df -k "${d}" | grep -q " 100% "; then
-      die "remount overlayfs missed a spot (rw)"
+      # See b/397158623
+      # The new overlayfs mounter is a bit more limited due to sepolicy. Since we know of no use
+      # cases for these mounts, disabling for now
+      LOG OK "remount overlayfs missed a spot (rw)"
     fi
   done
 else

From d718c687d25cc5247b4c34010678332031d442a4 Mon Sep 17 00:00:00 2001
From: Daniel Zheng <zhengdaniel@google.com>
Date: Tue, 18 Feb 2025 18:44:43 +0000
Subject: [PATCH 1419/1487] remove update-super

This change reverts aosp/3475386. update-super was never a user facing
command so it shouldn't appear on the help doc.

Test: th
Change-Id: I19cea1fd95177961f52ca48af37f381901be0a50
---
 fastboot/fastboot.cpp | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index 3f8a41571563..1c52da2382ad 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -588,12 +588,6 @@ static int show_help() {
             "                            Delete a logical partition with the given name.\n"
             " resize-logical-partition NAME SIZE\n"
             "                            Change the size of the named logical partition.\n"
-            " update-super NAME\n"
-            "                            Merges changes to the super partition metadata.\n"
-            "                            If a merge isn't possible (for example, the format\n"
-            "                            on the device is an unsupported version), then this\n"
-            "                            command fails. An optional wipe parameter overwrites\n"
-            "                            the device's metadata, rather than performing a merge.\n"
             " snapshot-update cancel     On devices that support snapshot-based updates, cancel\n"
             "                            an in-progress update. This may make the device\n"
             "                            unbootable until it is reflashed.\n"

From 515f5b5e5a60380a71c090cceee58b5090d958c1 Mon Sep 17 00:00:00 2001
From: Andrei Ciubotariu <aciubotariu@google.com>
Date: Wed, 12 Feb 2025 21:31:23 -0800
Subject: [PATCH 1420/1487] BatteryMonitor: Ensure batteryHealthData has value
 when needed

Since batteryHealthData is annotated in the AIDL with @nullable,
ensure that the std::optional that encloses it has a value when
a field needs to be assigned to batteryHealthData.

If no batteryHealthData updates are needed, the optional remains
"valueless".

Bug: 396737015
Test: Manual
Flag: EXEMPT bugfix
Change-Id: Ica6f20656a566054d7cbaaf339813be6e0e93b78
---
 healthd/BatteryMonitor.cpp | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp
index b8bb58682a2e..b0a14bb836af 100644
--- a/healthd/BatteryMonitor.cpp
+++ b/healthd/BatteryMonitor.cpp
@@ -131,6 +131,7 @@ static void initHealthInfo(HealthInfo* health_info) {
                     (int64_t)HealthInfo::BATTERY_CHARGE_TIME_TO_FULL_NOW_SECONDS_UNSUPPORTED,
             .batteryStatus = BatteryStatus::UNKNOWN,
             .batteryHealth = BatteryHealth::UNKNOWN,
+            .batteryHealthData = std::nullopt,
     };
 }
 
@@ -360,6 +361,14 @@ static bool isScopedPowerSupply(const char* name) {
     return (readFromFile(path, &scope) > 0 && scope == kScopeDevice);
 }
 
+static BatteryHealthData *ensureBatteryHealthData(HealthInfo *info) {
+    if (!info->batteryHealthData.has_value()) {
+        return &info->batteryHealthData.emplace();
+    }
+
+    return &info->batteryHealthData.value();
+}
+
 void BatteryMonitor::updateValues(void) {
     initHealthInfo(mHealthInfo.get());
 
@@ -402,15 +411,15 @@ void BatteryMonitor::updateValues(void) {
         mBatteryHealthStatus = getIntField(mHealthdConfig->batteryHealthStatusPath);
 
     if (!mHealthdConfig->batteryStateOfHealthPath.empty())
-        mHealthInfo->batteryHealthData->batteryStateOfHealth =
+        ensureBatteryHealthData(mHealthInfo.get())->batteryStateOfHealth =
                 getIntField(mHealthdConfig->batteryStateOfHealthPath);
 
     if (!mHealthdConfig->batteryManufacturingDatePath.empty())
-        mHealthInfo->batteryHealthData->batteryManufacturingDateSeconds =
+        ensureBatteryHealthData(mHealthInfo.get())->batteryManufacturingDateSeconds =
                 getIntField(mHealthdConfig->batteryManufacturingDatePath);
 
     if (!mHealthdConfig->batteryFirstUsageDatePath.empty())
-        mHealthInfo->batteryHealthData->batteryFirstUsageSeconds =
+        ensureBatteryHealthData(mHealthInfo.get())->batteryFirstUsageSeconds =
                 getIntField(mHealthdConfig->batteryFirstUsageDatePath);
 
     mHealthInfo->batteryTemperatureTenthsCelsius =

From fc07ec48a40498e478df01214006743c3558753c Mon Sep 17 00:00:00 2001
From: Yifan Hong <elsk@google.com>
Date: Wed, 19 Feb 2025 17:03:24 -0800
Subject: [PATCH 1421/1487] Update healthd OWNERS to point to health HAL
 owners.

Change-Id: Iaa9ede666c387515a63d8255bb99ec8a7151f2ed
Test: N/A
Bug: N/A
---
 healthd/OWNERS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/healthd/OWNERS b/healthd/OWNERS
index e64c33d1ac39..c436ba2afdf1 100644
--- a/healthd/OWNERS
+++ b/healthd/OWNERS
@@ -1 +1 @@
-elsk@google.com
+include platform/hardware/interfaces:/health/OWNERS

From 6cc21dff5822381e5deb81881223bead4dffc0ab Mon Sep 17 00:00:00 2001
From: Hyeeun Jun <hyeeun.jun@samsung.corp-partner.google.com>
Date: Wed, 25 Oct 2023 14:09:48 +0900
Subject: [PATCH 1422/1487] Prevent app fuse from indefinitely trying if it
 gets ENOBUFS

When there is not enough memory to allocate the appfuse socket,
ENOBUFS error could occur repeatly, and the retry will not be ended.
Limit the retry count to prevent infinite repetition.

Limited this to take only 5 seconds which is still quite high but still
better than running indefinitely. We can reduce this further later on.

Test: Manual
Bug: 312503249
Bug: 369519866
Change-Id: I928b7b5e6d0a53831c2b35d48aeb9440e8f6564a
---
 libappfuse/FuseBuffer.cc | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/libappfuse/FuseBuffer.cc b/libappfuse/FuseBuffer.cc
index 1915f22ba2cd..269f300b9ba6 100644
--- a/libappfuse/FuseBuffer.cc
+++ b/libappfuse/FuseBuffer.cc
@@ -35,6 +35,8 @@ namespace fuse {
 namespace {
 
 constexpr useconds_t kRetrySleepForWriting = 1000;  // 1 ms
+// This makes the total wait time to allocate a buffer 5 seconds
+const int kNumberOfRetriesForWriting = 5000;
 
 template <typename T>
 bool CheckHeaderLength(const FuseMessage<T>* self, const char* name, size_t max_size) {
@@ -92,6 +94,7 @@ ResultOrAgain WriteInternal(const FuseMessage<T>* self, int fd, int sockflag, co
 
     const char* const buf = reinterpret_cast<const char*>(self);
     const auto& header = static_cast<const T*>(self)->header;
+    int retry = kNumberOfRetriesForWriting;
 
     while (true) {
         int result;
@@ -110,8 +113,14 @@ ResultOrAgain WriteInternal(const FuseMessage<T>* self, int fd, int sockflag, co
                 case ENOBUFS:
                     // When returning ENOBUFS, epoll still reports the FD is writable. Just usleep
                     // and retry again.
-                    usleep(kRetrySleepForWriting);
-                    continue;
+                    if (retry > 0) {
+                        usleep(kRetrySleepForWriting);
+                        retry--;
+                        continue;
+                    } else {
+                        LOG(ERROR) << "Failed to write a FUSE message: ENOBUFS retries are failed";
+                        return ResultOrAgain::kFailure;
+                    }
                 case EAGAIN:
                     return ResultOrAgain::kAgain;
                 default:

From bfc8cdcdc34dfe22e49a84d3ad49e271dc3706d0 Mon Sep 17 00:00:00 2001
From: Owner Cleanup Bot
 <swarming-tasks@owners-cleanup-prod.google.com.iam.gserviceaccount.com>
Date: Thu, 20 Feb 2025 07:50:50 -0800
Subject: [PATCH 1423/1487] [owners] Remove salyzyn@google.com from
 storaged/OWNERS

This suggested change is automatically generated based on group
memberships and affiliations.

Please approve this change and vote the highest CR. This will keep the OWNERs
file tidy.  We ask that you do not ignore this change and approve it
unless you know a reason the OWNER should remain.  It can always be
reverted if needed.

If this change is in error, vote the lowest CR value (i.e. reject the CL)
and the bot will abandon it.

See the owner's recent review activity for context:
https://android-review.googlesource.com/q/salyzyn@google.com

To report an issue, file a bug in the Infra>Codereview component.

Change-Id: I3b882a909101bb3e97a3d09a10a04c77efbb89b8
---
 storaged/OWNERS | 1 -
 1 file changed, 1 deletion(-)

diff --git a/storaged/OWNERS b/storaged/OWNERS
index d033f0000b95..9e70e7dcf653 100644
--- a/storaged/OWNERS
+++ b/storaged/OWNERS
@@ -1,2 +1 @@
-salyzyn@google.com
 dvander@google.com

From c5d4f427a3ff79249573788ca8164eec084a1f34 Mon Sep 17 00:00:00 2001
From: Owner Cleanup Bot
 <swarming-tasks@owners-cleanup-prod.google.com.iam.gserviceaccount.com>
Date: Thu, 20 Feb 2025 07:50:59 -0800
Subject: [PATCH 1424/1487] [owners] Remove salyzyn@google.com from llkd/OWNERS

This suggested change is automatically generated based on group
memberships and affiliations.

Please approve this change and vote the highest CR. This will keep the OWNERs
file tidy.  We ask that you do not ignore this change and approve it
unless you know a reason the OWNER should remain.  It can always be
reverted if needed.

If this change is in error, vote the lowest CR value (i.e. reject the CL)
and the bot will abandon it.

See the owner's recent review activity for context:
https://android-review.googlesource.com/q/salyzyn@google.com

To report an issue, file a bug in the Infra>Codereview component.

Change-Id: Id7b034639d593b512c4f5e660671071c15fd28db
---
 llkd/OWNERS | 1 -
 1 file changed, 1 deletion(-)

diff --git a/llkd/OWNERS b/llkd/OWNERS
index b6af537ef480..b15bb48705f2 100644
--- a/llkd/OWNERS
+++ b/llkd/OWNERS
@@ -1,2 +1 @@
-salyzyn@google.com
 surenb@google.com

From d8cbe6ec6b491203ef671306de6fa6454c2ba7c8 Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Thu, 20 Feb 2025 16:15:25 +0000
Subject: [PATCH 1425/1487] trusty: trusty-storage.mk: enable storageproxy for
 widevine vm

Bug: 371777025
Test: lunch qemu_trusty_arm64-trunk_staging-userdebug
Change-Id: Ib1b15a3a02942c779c042bdd504849ee79c2d2c3
---
 trusty/trusty-storage.mk | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trusty/trusty-storage.mk b/trusty/trusty-storage.mk
index 5bfbf1ecfdda..d2bc0b18c271 100644
--- a/trusty/trusty-storage.mk
+++ b/trusty/trusty-storage.mk
@@ -38,6 +38,6 @@ PRODUCT_PACKAGES += \
 	storageproxyd.system \
 	rpmb_dev.test.system \
 	rpmb_dev.system \
-	# rpmb_dev.wv.system \
+	rpmb_dev.wv.system \
 
 endif

From a33cdc99d43989dae18c93d3fa6077b9c638eda4 Mon Sep 17 00:00:00 2001
From: Kelvin Zhang <zhangkelvin@google.com>
Date: Thu, 20 Feb 2025 10:18:50 -0800
Subject: [PATCH 1426/1487] Add a function to determine cow op size

This is useful for update-engine to run on-device size estimates.
For example, when user wants to turn off compression parameter
on demand.

Test: th
Change-Id: I1e9cca88dff2492feeada3edcf0da2eb5f9430cc
---
 fs_mgr/libsnapshot/include/libsnapshot/cow_format.h | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
index 991e17cbbe0a..66f9a8327762 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/cow_format.h
@@ -329,6 +329,16 @@ struct BufferState {
     uint8_t read_ahead_state;
 } __attribute__((packed));
 
+constexpr size_t GetCowOpSize(size_t version) {
+    if (version == 3) {
+        return sizeof(CowOperationV3);
+    } else if (version == 2 || version == 1) {
+        return sizeof(CowOperationV2);
+    } else {
+        return 0;
+    }
+}
+
 // 2MB Scratch space used for read-ahead
 static constexpr uint64_t BUFFER_REGION_DEFAULT_SIZE = (1ULL << 21);
 

From 59f249ae7dc5bb3a827ceb7ed638ad500e43fe94 Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Thu, 20 Feb 2025 19:02:00 +0900
Subject: [PATCH 1427/1487] Rewrite the description about triggers

The most important change is the emphasis on the fact that `on
property:a=b` is not executed until `boot` is finished.

Bug: N/A
Test: N/A
Change-Id: I7fd88e6042490e2d47544b75dca444f74a6d7dcf
---
 init/README.md | 78 ++++++++++++++++++++++++++++++++------------------
 1 file changed, 50 insertions(+), 28 deletions(-)

diff --git a/init/README.md b/init/README.md
index 251fe987964a..89e20a427db0 100644
--- a/init/README.md
+++ b/init/README.md
@@ -454,44 +454,66 @@ runs the service.
 
 Triggers
 --------
-Triggers are strings which can be used to match certain kinds of
-events and used to cause an action to occur.
+Triggers of an action specifies one or more conditions when satisfied
+execute the commands in the action. A trigger encodes a single atomic
+condition, and multiple triggers can be combined using the `&&`
+operator to form a bigger AND condition.
 
-Triggers are subdivided into event triggers and property triggers.
+There are two types of triggers: event triggers and action triggers.
+An action can have multiple property triggers but may have only one
+event trigger.
 
-Event triggers are strings triggered by the 'trigger' command or by
-the QueueEventTrigger() function within the init executable.  These
-take the form of a simple string such as 'boot' or 'late-init'.
+An event trigger takes the simple form of `<event>` where `<event>` is
+the name of a boot stage like `early-init` or `boot`. This trigger
+is satisfied when init reaches the stage via the `trigger` command or
+by the `QueueEventTrigger()` function in the init executable.
 
-Property triggers are strings triggered when a named property changes
-value to a given new value or when a named property changes value to
-any new value.  These take the form of 'property:<name>=<value>' and
-'property:<name>=\*' respectively.  Property triggers are additionally
-evaluated and triggered accordingly during the initial boot phase of
-init.
+A property trigger takes the form of `property:<name>=<value>`. This
+trigger is satisfied when the property of name `<name>` is found to
+have the value of `<value>` when the check is made. The `<value>` part
+can be `\*` to match with any value.
 
-An Action can have multiple property triggers but may only have one
-event trigger.
+The check for property trigger is made in the following cases:
 
-For example:
-`on boot && property:a=b` defines an action that is only executed when
-the 'boot' event trigger happens and the property a equals b at the moment. This
-will NOT be executed when the property a transitions to value b after the `boot`
-event was triggered.
+* All property triggers get checked at least once when the `boot`
+  event is finished (i.e. when the last command under `on boot ...` is
+finished).
+
+* After the one-time check, `property:a=b` is checked when property `a`
+  is newly created, or when the property is set to a new value.
+
+* Property triggers are also checked when other triggers in the same
+  action are checked. For example, `property:a=b && property:c=d` is
+checked not only when property `a` gets a new value, but also when
+property `c` gets a new value (and of course when the one-time check
+is made).
+
+* Before the one-time check, `property:a=b` without an event trigger
+  is NOT checked, even if property `a` gets a new value. Care must be
+taken since this is a non-intuitive behavior, which unfortunately
+can't be changed due to compatibility concerns.
+
+Some examples:
+
+`on property:a=b` is executed in two cases:
 
-`on property:a=b && property:c=d` defines an action that is executed
-at three times:
+1. during the one-time check if property `a` is `b` at the moment.
+2. if property `a` is set to or changed to `b` after the one-time
+   check, but not before then.
 
-   1. During initial boot if property a=b and property c=d.
-   2. Any time that property a transitions to value b, while property c already equals d.
-   3. Any time that property c transitions to value d, while property a already equals b.
+`on property:a=b && property:c=d` is executed in three cases:
 
-Note that, for bootloader-provided properties (ro.boot.*), their action cannot be
-auto-triggered until `boot` stage. If they need to be triggered earlier, like at `early-boot`
-stage, they should be tied to the `event`. For example:
+1. during the one-time check if property `a` is `b` and property `c`
+   is `d` at the moment.
+2. (after the one-time check) property `a` becomes `b` while property
+   `c` already equals to `d`.
+3. (after the one-time check) property `c` becomes `d` while property
+   `a` already equals to `b`.
 
-`on early-boot && property:a=b`.
+`on property:a=b && post-fs` is executed in one case only:
 
+1. `post-fs` is triggered while property `a` already equals to `b`.
+   This is NOT executed when property `a` becomes `b` AFTER `post-fs`.
 
 Trigger Sequence
 ----------------

From 425c646ffff486d1da817302af8d18e9deed3112 Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Fri, 21 Feb 2025 10:55:29 +0000
Subject: [PATCH 1428/1487] trusty: utils: rpmb_dev: rpmb_dev.wv.system.rc:
 update init sequence

Bug: 371777025
Test: lunch qemu_trusty_arm64-trunk_staging-userdebug
Change-Id: Ic2419b32bbc9ad596c322c7f0325461440e9e0e0
---
 trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc b/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
index 4e42d46be568..05d9d3d23115 100644
--- a/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
+++ b/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
@@ -4,7 +4,6 @@ service storageproxyd_wv_system /system_ext/bin/storageproxyd.system \
         -p /data/secure_storage_wv_system \
         -t sock
     disabled
-    class hal
     user system
     group system
 
@@ -47,3 +46,8 @@ on early-boot
     chown root system /data/secure_storage_wv_system/persist
     exec_start rpmb_mock_init_wv_system
     start rpmb_mock_wv_system
+
+on post-fs-data && \
+    property:trusty.widevine_vm.nonsecure_vm_ready=1 && \
+    property:trusty.widevine_vm.vm_cid=*
+    start storageproxyd_wv_system storage

From 7bcc189be65ffdbfec6146cc3b974fa1a03a7aa6 Mon Sep 17 00:00:00 2001
From: Paul Lawrence <paullawrence@google.com>
Date: Fri, 21 Feb 2025 06:31:48 -0800
Subject: [PATCH 1429/1487] Preserve environment when launching
 overlay_remounter

fexecve does not preserve the environment by default. The environment is
used to pass certain information to second stage init. Specifically
whether force debuggable is set is passed this way.

Test: Run following steps

vendor/google/tools/flashall --wipe --force_debuggable
adb shell getprop ro.adb.secure
adb root && adb remount && adb reboot
adb shell getprop ro.adb.secure

Without this change, the first getprop would return 0 and the second 1
With this change, both return 0

Bug: 397402912
Change-Id: I4722bd0c2960dd695dc096d8c59c259d12c28a65
---
 init/selinux.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/selinux.cpp b/init/selinux.cpp
index 8bdf5b6a28a4..2a27c1d58832 100644
--- a/init/selinux.cpp
+++ b/init/selinux.cpp
@@ -749,7 +749,7 @@ void SetupOverlays() {
         PLOG(FATAL) << "Failed to unlink " << or_dest;
     }
     const char* args[] = {or_dest.c_str(), nullptr};
-    fexecve(dest.get(), const_cast<char**>(args), nullptr);
+    fexecve(dest.get(), const_cast<char**>(args), environ);
 
     // execv() only returns if an error happened, in which case we
     // panic and never return from this function.

From 78c270776289acf652f74313ec578123eb408009 Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Mon, 24 Feb 2025 15:02:42 +0000
Subject: [PATCH 1430/1487] trusty: utils: rpmb_dev: rpmb_dev.wv.system.rc: fix
 typo

Bug: 371777025
Test: lunch qemu_trusty_arm64-trunk_staging-userdebug
Change-Id: I9978576c156b45c22e8ef336a337cb08945de1c2
---
 trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc b/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
index 05d9d3d23115..ac18f8134d47 100644
--- a/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
+++ b/trusty/utils/rpmb_dev/rpmb_dev.wv.system.rc
@@ -50,4 +50,5 @@ on early-boot
 on post-fs-data && \
     property:trusty.widevine_vm.nonsecure_vm_ready=1 && \
     property:trusty.widevine_vm.vm_cid=*
-    start storageproxyd_wv_system storage
+    start storageproxyd_wv_system
+

From d6cba21f8b56f71bf4a57f957037d60b0425757a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= <maze@google.com>
Date: Mon, 24 Feb 2025 11:21:20 -0800
Subject: [PATCH 1431/1487] Use OWNERS_core_networking as OWNERS for Netlink
 utils
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Test: N/A
Signed-off-by: Maciej Żenczykowski <maze@google.com>
Change-Id: Ib9de6fb74207cc15d54746973cd37f20b8b2211c
---
 libsysutils/src/OWNERS | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/libsysutils/src/OWNERS b/libsysutils/src/OWNERS
index 3244fe8f8d2e..a3e4c703f01e 100644
--- a/libsysutils/src/OWNERS
+++ b/libsysutils/src/OWNERS
@@ -1,2 +1 @@
-per-file OWNERS,Netlink* = jchalard@google.com, lorenzo@google.com, maze@google.com, satk@google.com
-
+per-file OWNERS,Netlink* = file:platform/packages/modules/Connectivity:main:/OWNERS_core_networking

From c026325ede55b6f336fcb1757a4c925c1373dd4f Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 24 Feb 2025 14:23:04 -0800
Subject: [PATCH 1432/1487] libcutils: clean up the ashmem code a bit.

Less duplication, more modern idioms.

Change-Id: Ic6f36a35abf0c8b99f23ec9d59d76a4fd6b091ca
---
 libcutils/ashmem-dev.cpp | 174 ++++++++++++++-------------------------
 1 file changed, 61 insertions(+), 113 deletions(-)

diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index 768db81bf95e..b4f1d7fe62d3 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -76,8 +76,8 @@ static pthread_mutex_t __ashmem_lock = PTHREAD_MUTEX_INITIALIZER;
  * debugging.
  */
 
-static bool debug_log = false;            /* set to true for verbose logging and other debug  */
-static bool pin_deprecation_warn = true; /* Log the pin deprecation warning only once */
+/* set to true for verbose logging and other debug  */
+static bool debug_log = false;
 
 /* Determine if vendor processes would be ok with memfd in the system:
  *
@@ -120,11 +120,9 @@ static bool __has_memfd_support() {
     // permissions of the buffer (i.e. they cannot be changed by fchmod()).
     //
     // MFD_NOEXEC_SEAL implies MFD_ALLOW_SEALING.
-    const char *test_buf_name = "test_android_memfd";
-    size_t buf_size = getpagesize();
 
     android::base::unique_fd fd(
-            syscall(__NR_memfd_create, test_buf_name, MFD_CLOEXEC | MFD_NOEXEC_SEAL));
+            syscall(__NR_memfd_create, "test_android_memfd", MFD_CLOEXEC | MFD_NOEXEC_SEAL));
     if (fd == -1) {
         ALOGE("memfd_create failed: %m, no memfd support");
         return false;
@@ -135,9 +133,9 @@ static bool __has_memfd_support() {
         return false;
     }
 
+    size_t buf_size = getpagesize();
     if (ftruncate(fd, buf_size) == -1) {
-        ALOGE("ftruncate(%s, %zd) failed to set memfd buffer size: %m, no memfd support",
-              test_buf_name, buf_size);
+        ALOGE("ftruncate(%zd) failed to set memfd buffer size: %m, no memfd support", buf_size);
         return false;
     }
 
@@ -159,11 +157,7 @@ static bool __has_memfd_support() {
 }
 
 static bool has_memfd_support() {
-    /* memfd_supported is the initial global per-process state of what is known
-     * about memfd.
-     */
     static bool memfd_supported = __has_memfd_support();
-
     return memfd_supported;
 }
 
@@ -173,75 +167,64 @@ static std::string get_ashmem_device_path() {
     if (!android::base::ReadFileToString(boot_id_path, &boot_id)) {
         ALOGE("Failed to read %s: %m", boot_id_path.c_str());
         return "";
-    };
+    }
     boot_id = android::base::Trim(boot_id);
 
     return "/dev/ashmem" + boot_id;
 }
 
 /* logistics of getting file descriptor for ashmem */
-static int __ashmem_open_locked()
-{
+static int __ashmem_open_locked() {
     static const std::string ashmem_device_path = get_ashmem_device_path();
 
     if (ashmem_device_path.empty()) {
         return -1;
     }
 
-    int fd = TEMP_FAILURE_RETRY(open(ashmem_device_path.c_str(), O_RDWR | O_CLOEXEC));
-
+    android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(ashmem_device_path.c_str(), O_RDWR | O_CLOEXEC)));
+    int errno1 = errno;
     // fallback for APEX w/ use_vendor on Q, which would have still used /dev/ashmem
-    if (fd < 0) {
-        int saved_errno = errno;
-        fd = TEMP_FAILURE_RETRY(open("/dev/ashmem", O_RDWR | O_CLOEXEC));
-        if (fd < 0) {
+    // TODO: remove this?
+    if (!fd.ok()) {
+        fd.reset(TEMP_FAILURE_RETRY(open("/dev/ashmem", O_RDWR | O_CLOEXEC)));
+        int errno2 = errno;
+        if (!fd.ok()) {
             /* Q launching devices and newer must not reach here since they should have been
              * able to open ashmem_device_path */
-            ALOGE("Unable to open ashmem device %s (error = %s) and /dev/ashmem(error = %s)",
-                  ashmem_device_path.c_str(), strerror(saved_errno), strerror(errno));
-            return fd;
+            ALOGE("Unable to open ashmem device %s (%s) and /dev/ashmem (%s)",
+                  ashmem_device_path.c_str(), strerror(errno1), strerror(errno2));
+            return -1;
         }
     }
+
     struct stat st;
-    int ret = TEMP_FAILURE_RETRY(fstat(fd, &st));
-    if (ret < 0) {
-        int save_errno = errno;
-        close(fd);
-        errno = save_errno;
-        return ret;
+    if (TEMP_FAILURE_RETRY(fstat(fd, &st)) == -1) {
+        return -1;
     }
     if (!S_ISCHR(st.st_mode) || !st.st_rdev) {
-        close(fd);
         errno = ENOTTY;
         return -1;
     }
 
     __ashmem_rdev = st.st_rdev;
-    return fd;
+    return fd.release();
 }
 
-static int __ashmem_open()
-{
-    int fd;
-
+static int __ashmem_open() {
     pthread_mutex_lock(&__ashmem_lock);
-    fd = __ashmem_open_locked();
+    int fd = __ashmem_open_locked();
     pthread_mutex_unlock(&__ashmem_lock);
-
     return fd;
 }
 
 /* Make sure file descriptor references ashmem, negative number means false */
-static int __ashmem_is_ashmem(int fd, int fatal)
-{
-    dev_t rdev;
+static int __ashmem_is_ashmem(int fd, bool fatal) {
     struct stat st;
-
     if (fstat(fd, &st) < 0) {
         return -1;
     }
 
-    rdev = 0; /* Too much complexity to sniff __ashmem_rdev */
+    dev_t rdev = 0; /* Too much complexity to sniff __ashmem_rdev */
     if (S_ISCHR(st.st_mode) && st.st_rdev) {
         pthread_mutex_lock(&__ashmem_lock);
         rdev = __ashmem_rdev;
@@ -282,16 +265,15 @@ static int __ashmem_is_ashmem(int fd, int fatal)
     return -1;
 }
 
-static int __ashmem_check_failure(int fd, int result)
-{
-    if (result == -1 && errno == ENOTTY) __ashmem_is_ashmem(fd, 1);
+static int __ashmem_check_failure(int fd, int result) {
+    if (result == -1 && errno == ENOTTY) __ashmem_is_ashmem(fd, true);
     return result;
 }
 
-static bool memfd_is_ashmem(int fd) {
+static bool is_ashmem_fd(int fd) {
     static bool fd_check_error_once = false;
 
-    if (__ashmem_is_ashmem(fd, 0) == 0) {
+    if (__ashmem_is_ashmem(fd, false) == 0) {
         if (!fd_check_error_once) {
             ALOGE("memfd: memfd expected but ashmem fd used - please use libcutils");
             fd_check_error_once = true;
@@ -303,13 +285,16 @@ static bool memfd_is_ashmem(int fd) {
     return false;
 }
 
-int ashmem_valid(int fd)
-{
-    if (has_memfd_support() && !memfd_is_ashmem(fd)) {
+static bool is_memfd_fd(int fd) {
+    return has_memfd_support() && !is_ashmem_fd(fd);
+}
+
+int ashmem_valid(int fd) {
+    if (is_memfd_fd(fd)) {
         return 1;
     }
 
-    return __ashmem_is_ashmem(fd, 0) >= 0;
+    return __ashmem_is_ashmem(fd, false) >= 0;
 }
 
 static int memfd_create_region(const char* name, size_t size) {
@@ -352,41 +337,20 @@ static int memfd_create_region(const char* name, size_t size) {
  * `name' is an optional label to give the region (visible in /proc/pid/maps)
  * `size' is the size of the region, in page-aligned bytes
  */
-int ashmem_create_region(const char *name, size_t size)
-{
-    int ret, save_errno;
+int ashmem_create_region(const char* name, size_t size) {
+    if (name == NULL) name = "none";
 
     if (has_memfd_support()) {
-        return memfd_create_region(name ? name : "none", size);
-    }
-
-    int fd = __ashmem_open();
-    if (fd < 0) {
-        return fd;
+        return memfd_create_region(name, size);
     }
 
-    if (name) {
-        char buf[ASHMEM_NAME_LEN] = {0};
-
-        strlcpy(buf, name, sizeof(buf));
-        ret = TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_SET_NAME, buf));
-        if (ret < 0) {
-            goto error;
-        }
-    }
-
-    ret = TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_SET_SIZE, size));
-    if (ret < 0) {
-        goto error;
+    android::base::unique_fd fd(__ashmem_open());
+    if (!fd.ok() ||
+        TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_SET_NAME, name) < 0) ||
+        TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_SET_SIZE, size) < 0)) {
+        return -1;
     }
-
-    return fd;
-
-error:
-    save_errno = errno;
-    close(fd);
-    errno = save_errno;
-    return ret;
+    return fd.release();
 }
 
 static int memfd_set_prot_region(int fd, int prot) {
@@ -418,61 +382,45 @@ static int memfd_set_prot_region(int fd, int prot) {
     return 0;
 }
 
-int ashmem_set_prot_region(int fd, int prot)
-{
-    if (has_memfd_support() && !memfd_is_ashmem(fd)) {
+int ashmem_set_prot_region(int fd, int prot) {
+    if (is_memfd_fd(fd)) {
         return memfd_set_prot_region(fd, prot);
     }
 
     return __ashmem_check_failure(fd, TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_SET_PROT_MASK, prot)));
 }
 
-int ashmem_pin_region(int fd, size_t offset, size_t len)
-{
-    if (!pin_deprecation_warn || debug_log) {
+static int do_pin(int op, int fd, size_t offset, size_t length) {
+    static bool already_warned_about_pin_deprecation = false;
+    if (!already_warned_about_pin_deprecation || debug_log) {
         ALOGE("Pinning is deprecated since Android Q. Please use trim or other methods.");
-        pin_deprecation_warn = true;
+        already_warned_about_pin_deprecation = true;
     }
 
-    if (has_memfd_support() && !memfd_is_ashmem(fd)) {
+    if (is_memfd_fd(fd)) {
         return 0;
     }
 
     // TODO: should LP64 reject too-large offset/len?
-    ashmem_pin pin = { static_cast<uint32_t>(offset), static_cast<uint32_t>(len) };
-    return __ashmem_check_failure(fd, TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_PIN, &pin)));
+    ashmem_pin pin = { static_cast<uint32_t>(offset), static_cast<uint32_t>(length) };
+    return __ashmem_check_failure(fd, TEMP_FAILURE_RETRY(ioctl(fd, op, &pin)));
 }
 
-int ashmem_unpin_region(int fd, size_t offset, size_t len)
-{
-    if (!pin_deprecation_warn || debug_log) {
-        ALOGE("Pinning is deprecated since Android Q. Please use trim or other methods.");
-        pin_deprecation_warn = true;
-    }
-
-    if (has_memfd_support() && !memfd_is_ashmem(fd)) {
-        return 0;
-    }
+int ashmem_pin_region(int fd, size_t offset, size_t length) {
+    return do_pin(ASHMEM_PIN, fd, offset, length);
+}
 
-    // TODO: should LP64 reject too-large offset/len?
-    ashmem_pin pin = { static_cast<uint32_t>(offset), static_cast<uint32_t>(len) };
-    return __ashmem_check_failure(fd, TEMP_FAILURE_RETRY(ioctl(fd, ASHMEM_UNPIN, &pin)));
+int ashmem_unpin_region(int fd, size_t offset, size_t length) {
+    return do_pin(ASHMEM_UNPIN, fd, offset, length);
 }
 
-int ashmem_get_size_region(int fd)
-{
-    if (has_memfd_support() && !memfd_is_ashmem(fd)) {
+int ashmem_get_size_region(int fd) {
+    if (is_memfd_fd(fd)) {
         struct stat sb;
-
         if (fstat(fd, &sb) == -1) {
             ALOGE("ashmem_get_size_region(%d): fstat failed: %m", fd);
             return -1;
         }
-
-        if (debug_log) {
-            ALOGD("ashmem_get_size_region(%d): %d", fd, static_cast<int>(sb.st_size));
-        }
-
         return sb.st_size;
     }
 

From e49a9df8368b597142df425c2066409d349e3589 Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@google.com>
Date: Wed, 26 Feb 2025 01:05:31 +0000
Subject: [PATCH 1433/1487] libsnapshot: Don't call RemoveAllSnapshots on
 normal boot.

This change was made when hardening recovery against libsnapshot bugs,
but was too aggressive. It's causing gsid to start, and due to an issue
in libgsid, get retained indefinitely. Dial it back a bit.

Bug: 397325642
Test: boot, ps -A | grep gsid
Change-Id: If013eb1d9082ca1f98bc4f3a26209af38b07e1cc
---
 fs_mgr/libsnapshot/snapshot.cpp | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index 83787df456d9..5aa4cd3dc968 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -351,9 +351,14 @@ bool SnapshotManager::RemoveAllUpdateState(LockedFile* lock, const std::function
 
     LOG(INFO) << "Removing all update state.";
 
-    if (!RemoveAllSnapshots(lock)) {
-        LOG(ERROR) << "Could not remove all snapshots";
-        return false;
+    if (ReadUpdateState(lock) != UpdateState::None) {
+        // Only call this if we're actually cancelling an update. It's not
+        // expected to yield anything otherwise, and firing up gsid on normal
+        // boot is expensive.
+        if (!RemoveAllSnapshots(lock)) {
+            LOG(ERROR) << "Could not remove all snapshots";
+            return false;
+        }
     }
 
     // It's okay if these fail:

From 1b75aba47ee8c6ebd2bb3a2ae059aff5a73a7c1b Mon Sep 17 00:00:00 2001
From: Dmitriy Filchenko <dmitriyf@google.com>
Date: Wed, 17 Jan 2024 17:54:02 +0000
Subject: [PATCH 1434/1487] trusty: Add TRUSTY_SEND_SECURE_OR_SHARE

Add new TRUSTY_SEND_SECURE_OR_SHARE mode which checks whether the buffer
is already secure. If it is, proceed as with TRUSTY_SEND_SECURE. If not,
proceed as with TRUSTY_SHARE.

Bug: 319300676
Test: Added cases to tipc-test, ran on QEMU
Change-Id: I1103e79bf0e3c66f1f986c2e5d0f9a0654361d12
---
 trusty/libtrusty/include/trusty/ipc.h  |  29 ++++---
 trusty/libtrusty/tipc-test/tipc_test.c | 108 ++++++++++++++++---------
 2 files changed, 87 insertions(+), 50 deletions(-)

diff --git a/trusty/libtrusty/include/trusty/ipc.h b/trusty/libtrusty/include/trusty/ipc.h
index 04e84c650470..4a19692312a4 100644
--- a/trusty/libtrusty/include/trusty/ipc.h
+++ b/trusty/libtrusty/include/trusty/ipc.h
@@ -23,19 +23,21 @@
 
 /**
  * enum transfer_kind - How to send an fd to Trusty
- * @TRUSTY_SHARE:       Memory will be accessible by Linux and Trusty. On ARM it
- *                      will be mapped as nonsecure. Suitable for shared memory.
- *                      The paired fd must be a "dma_buf".
- * @TRUSTY_LEND:        Memory will be accessible only to Trusty. On ARM it will
- *                      be transitioned to "Secure" memory if Trusty is in
- *                      TrustZone. This transfer kind is suitable for donating
- *                      video buffers or other similar resources. The paired fd
- *                      may need to come from a platform-specific allocator for
- *                      memory that may be transitioned to "Secure".
- * @TRUSTY_SEND_SECURE: Send memory that is already "Secure". Memory will be
- *                      accessible only to Trusty. The paired fd may need to
- *                      come from a platform-specific allocator that returns
- *                      "Secure" buffers.
+ * @TRUSTY_SHARE:                Memory will be accessible by Linux and Trusty. On ARM it
+ *                               will be mapped as nonsecure. Suitable for shared memory.
+ *                               The paired fd must be a "dma_buf".
+ * @TRUSTY_LEND:                 Memory will be accessible only to Trusty. On ARM it will
+ *                               be transitioned to "Secure" memory if Trusty is in
+ *                               TrustZone. This transfer kind is suitable for donating
+ *                               video buffers or other similar resources. The paired fd
+ *                               may need to come from a platform-specific allocator for
+ *                               memory that may be transitioned to "Secure".
+ * @TRUSTY_SEND_SECURE:          Send memory that is already "Secure". Memory will be
+ *                               accessible only to Trusty. The paired fd may need to
+ *                               come from a platform-specific allocator that returns
+ *                               "Secure" buffers.
+ * @TRUSTY_SEND_SECURE_OR_SHARE: Acts as TRUSTY_SEND_SECURE if the memory is already
+ *                               "Secure" and as TRUSTY_SHARE otherwise.
  *
  * Describes how the user would like the resource in question to be sent to
  * Trusty. Options may be valid only for certain kinds of fds.
@@ -44,6 +46,7 @@ enum transfer_kind {
     TRUSTY_SHARE = 0,
     TRUSTY_LEND = 1,
     TRUSTY_SEND_SECURE = 2,
+    TRUSTY_SEND_SECURE_OR_SHARE = 3,
 };
 
 /**
diff --git a/trusty/libtrusty/tipc-test/tipc_test.c b/trusty/libtrusty/tipc-test/tipc_test.c
index 121837dc0ea3..9910aeeb5f2a 100644
--- a/trusty/libtrusty/tipc-test/tipc_test.c
+++ b/trusty/libtrusty/tipc-test/tipc_test.c
@@ -55,6 +55,8 @@
 "}"
 /* clang-format on */
 
+#define countof(arr) (sizeof(arr) / sizeof(arr[0]))
+
 static const char *uuid_name = "com.android.ipc-unittest.srv.uuid";
 static const char *echo_name = "com.android.ipc-unittest.srv.echo";
 static const char *ta_only_name = "com.android.ipc-unittest.srv.ta_only";
@@ -904,12 +906,14 @@ static int readv_test(const struct tipc_test_params* params) {
 
 static int send_fd_test(const struct tipc_test_params* params) {
     int ret;
-    int dma_buf = -1;
+    int dma_buf[] = {-1, -1, -1};
     int fd = -1;
-    volatile char* buf = MAP_FAILED;
+    volatile char* buf[countof(dma_buf)] = {MAP_FAILED, MAP_FAILED, MAP_FAILED};
     BufferAllocator* allocator = NULL;
+    uint i;
 
     const size_t num_chunks = 10;
+    const size_t buf_size = memref_chunk_size * num_chunks;
 
     fd = tipc_connect(params->dev_name, receiver_name);
     if (fd < 0) {
@@ -925,56 +929,86 @@ static int send_fd_test(const struct tipc_test_params* params) {
         goto cleanup;
     }
 
-    size_t buf_size = memref_chunk_size * num_chunks;
-    dma_buf = DmabufHeapAlloc(allocator, "system", buf_size, 0, 0 /* legacy align */);
-    if (dma_buf < 0) {
-        ret = dma_buf;
-        fprintf(stderr, "Failed to create dma-buf fd of size %zu err (%d)\n", buf_size, ret);
-        goto cleanup;
-    }
-
-    buf = mmap(0, buf_size, PROT_READ | PROT_WRITE, MAP_SHARED, dma_buf, 0);
-    if (buf == MAP_FAILED) {
-        fprintf(stderr, "Failed to map dma-buf: %s\n", strerror(errno));
-        ret = -1;
-        goto cleanup;
+    for (i = 0; i < countof(dma_buf); i++) {
+        ret = DmabufHeapAlloc(allocator, "system", buf_size, 0, 0 /* legacy align */);
+        if (ret < 0) {
+            fprintf(stderr, "Failed to create dma-buf fd of size %zu err (%d)\n", buf_size, ret);
+            goto cleanup;
+        }
+        dma_buf[i] = ret;
     }
 
-    strcpy((char*)buf, "From NS");
+    for (i = 0; i < countof(dma_buf); i++) {
+        buf[i] = mmap(0, buf_size, PROT_READ | PROT_WRITE, MAP_SHARED, dma_buf[i], 0);
+        if (buf[i] == MAP_FAILED) {
+            fprintf(stderr, "Failed to map dma-buf: %s\n", strerror(errno));
+            ret = -1;
+            goto cleanup;
+        }
 
-    struct trusty_shm shm = {
-            .fd = dma_buf,
-            .transfer = TRUSTY_SHARE,
+        strcpy((char*)buf[i], "From NS");
+    }
+
+    struct trusty_shm shm[] = {
+            {
+                    .fd = dma_buf[0],
+                    .transfer = TRUSTY_SHARE,
+            },
+            {
+                    .fd = dma_buf[0],
+                    .transfer = TRUSTY_SEND_SECURE_OR_SHARE,
+            },
+            {
+                    .fd = dma_buf[1],
+                    .transfer = TRUSTY_LEND,
+            },
+            {
+                    .fd = dma_buf[1],
+                    .transfer = TRUSTY_SEND_SECURE_OR_SHARE,
+            },
+            {
+                    .fd = dma_buf[2],
+                    .transfer = TRUSTY_SEND_SECURE_OR_SHARE,
+            },
     };
 
-    ssize_t rc = tipc_send(fd, NULL, 0, &shm, 1);
-    if (rc < 0) {
-        fprintf(stderr, "tipc_send failed: %zd\n", rc);
-        ret = rc;
-        goto cleanup;
+    for (i = 0; i < countof(shm); i++) {
+        ssize_t rc = tipc_send(fd, NULL, 0, &shm[i], 1);
+        if (rc < 0) {
+            fprintf(stderr, "tipc_send failed: %zd\n", rc);
+            ret = rc;
+            goto cleanup;
+        }
+        char c;
+        read(fd, &c, 1);
     }
-    char c;
-    read(fd, &c, 1);
-    tipc_close(fd);
 
     ret = 0;
-    for (size_t skip = 0; skip < num_chunks; skip++) {
-        int cmp = strcmp("Hello from Trusty!",
-                         (const char*)&buf[skip * memref_chunk_size]) ? (-1) : 0;
-        if (cmp)
-            fprintf(stderr, "Failed: Unexpected content at page %zu in dmabuf\n", skip);
-        ret |= cmp;
+    for (i = 0; i < countof(buf); i++) {
+        for (size_t skip = 0; skip < num_chunks; skip++) {
+            int cmp = strcmp("Hello from Trusty!", (const char*)&buf[i][skip * memref_chunk_size])
+                              ? (-1)
+                              : 0;
+            if (cmp) fprintf(stderr, "Failed: Unexpected content at page %zu in dmabuf\n", skip);
+            ret |= cmp;
+        }
     }
 
 cleanup:
-    if (buf != MAP_FAILED) {
-        munmap((char*)buf, buf_size);
+    for (i = 0; i < countof(dma_buf); i++) {
+        if (buf[i] != MAP_FAILED) {
+            munmap((char*)buf[i], buf_size);
+        }
+        if (dma_buf[i] >= 0) {
+            close(dma_buf[i]);
+        }
     }
-    close(dma_buf);
     if (allocator) {
         FreeDmabufHeapBufferAllocator(allocator);
     }
-    tipc_close(fd);
+    if (fd >= 0) {
+        tipc_close(fd);
+    }
     return ret;
 }
 

From 1d4dc2f4bcfc104a5d0114d0d3fce278f601d208 Mon Sep 17 00:00:00 2001
From: Shintaro Kawamura <kawasin@google.com>
Date: Fri, 31 Jan 2025 20:27:57 +0900
Subject: [PATCH 1435/1487] fs_mgr: Skip zram setup on swapon_all if mmd zram
 management is enabled

mmd will be launched as a new zram management system which deprecates
the old zram management using swapon_all. The new mmd and swapon_all are
mutually exclusive.

On devices which enables both mmd_enabled AConfig flag and
"mmd.zram.enabled" system property, swapon_all command should skip
setting up zram and let mmd set up zram.

After mmd is launched swapon_all will show deprecation warning logs for
zram setup.

Bug: 393481329
Bug: 396063022
Test: manual

Change-Id: I0ca5db51a82a829157e92d2b58259add3d9bb3d5
---
 fs_mgr/fs_mgr.cpp | 82 +++++++++++++++++++++++++++++++++++++++++++++++
 init/README.md    | 10 ++++++
 2 files changed, 92 insertions(+)

diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp
index a30d9c01fadf..204e690936d0 100644
--- a/fs_mgr/fs_mgr.cpp
+++ b/fs_mgr/fs_mgr.cpp
@@ -2023,6 +2023,84 @@ static bool PrepareZramBackingDevice(off64_t size) {
     return InstallZramDevice(loop_device);
 }
 
+// Check whether it is in recovery mode or not.
+//
+// This is a copy from util.h in libinit.
+//
+// You need to check ALL relevant executables calling this function has access to
+// "/system/bin/recovery" (including SELinux permissions and UNIX permissions).
+static bool IsRecovery() {
+    return access("/system/bin/recovery", F_OK) == 0;
+}
+
+// Decides whether swapon_all should skip setting up zram.
+//
+// swapon_all is deprecated to setup zram after mmd is launched. swapon_all command should skip
+// setting up zram if mmd is enabled by AConfig flag and mmd is configured to set up zram.
+static bool ShouldSkipZramSetup() {
+    if (IsRecovery()) {
+        // swapon_all continue to support zram setup in recovery mode after mmd launch.
+        return false;
+    }
+
+    // Since AConfig does not support to load the status from init, we use the system property
+    // "mmd.enabled_aconfig" copied from AConfig by `mmd --set-property` command to check whether
+    // mmd is enabled or not.
+    //
+    // aconfig_prop can have either of:
+    //
+    // * "true": mmd is enabled by AConfig
+    // * "false": mmd is disabled by AConfig
+    // * "": swapon_all is executed before `mmd --set-property`
+    //
+    // During mmd being launched, we request OEMs, who decided to use mmd to set up zram, to execute
+    // swapon_all after "mmd.enabled_aconfig" system property is initialized. Init can wait the
+    // "mmd.enabled_aconfig" initialization by `property:mmd.enabled_aconfig=*` trigger.
+    //
+    // After mmd is launched, we deprecate swapon_all command for setting up zram but recommend to
+    // use `mmd --setup-zram`. It means that the system should call swapon_all with fstab with no
+    // zram entry or the system should never call swapon_all.
+    //
+    // As a transition, OEMs can use the deprecated swapon_all to set up zram for several versions
+    // after mmd is launched. swapon_all command will show warning logs during the transition
+    // period.
+    const std::string aconfig_prop = android::base::GetProperty("mmd.enabled_aconfig", "");
+    const bool is_zram_managed_by_mmd = android::base::GetBoolProperty("mmd.zram.enabled", false);
+    if (aconfig_prop == "true" && is_zram_managed_by_mmd) {
+        // Skip zram setup since zram is managed by mmd.
+        //
+        // We expect swapon_all is not called when mmd is enabled by AConfig flag.
+        // TODO: b/394484720 - Make this log as warning after mmd is launched.
+        LINFO << "Skip setting up zram because mmd sets up zram instead.";
+        return true;
+    }
+
+    if (aconfig_prop == "false") {
+        // It is expected to swapon_all command to set up zram before mmd is launched.
+        LOG(DEBUG) << "mmd is not launched yet. swapon_all setup zram.";
+    } else if (is_zram_managed_by_mmd) {
+        // This branch is for aconfig_prop == ""
+
+        // On the system which uses mmd to setup zram, swapon_all must be executed after
+        // mmd.enabled_aconfig is initialized.
+        LERROR << "swapon_all must be called after mmd.enabled_aconfig system "
+                  "property is initialized";
+        // Since we don't know whether mmd is enabled on the system or not, we fall back to enable
+        // zram from swapon_all conservatively. Both swapon_all and `mmd --setup-zram` command
+        // trying to set up zram does not break the system but just either ends up failing.
+    } else {
+        // We show the warning log for swapon_all deprecation on both aconfig_prop is "true" and ""
+        // cases.
+        // If mmd is enabled, swapon_all is already deprecated.
+        // If aconfig_prop is "", we don't know whether mmd is launched or not. But we show the
+        // deprecation warning log conservatively.
+        LWARNING << "mmd is recommended to set up zram over swapon_all command with "
+                    "fstab entry.";
+    }
+
+    return false;
+}
+
 bool fs_mgr_swapon_all(const Fstab& fstab) {
     bool ret = true;
     for (const auto& entry : fstab) {
@@ -2032,6 +2110,10 @@ bool fs_mgr_swapon_all(const Fstab& fstab) {
         }
 
         if (entry.zram_size > 0) {
+            if (ShouldSkipZramSetup()) {
+                continue;
+            }
+
             if (!PrepareZramBackingDevice(entry.zram_backingdev_size)) {
                 LERROR << "Failure of zram backing device file for '" << entry.blk_device << "'";
             }
diff --git a/init/README.md b/init/README.md
index 89e20a427db0..c9742ad54228 100644
--- a/init/README.md
+++ b/init/README.md
@@ -785,6 +785,16 @@ provides the `aidl_lazy_test_1` interface.
   fstab.${ro.hardware} or fstab.${ro.hardware.platform} will be scanned for
   under /odm/etc, /vendor/etc, or / at runtime, in that order.
 
+> swapon_all is deprecated and will do nothing if `mmd_enabled` AConfig flag
+  in `system_performance` namespace and `mmd.zram.enabled` sysprop are enabled.
+  OEMs, who decided to use mmd to manage zram, must remove zram entry from fstab
+  or remove swapon_all call from their init script.
+
+> swapon_all continues to support setting up non-zram swap devices.
+
+> swapon_all on recovery mode continues to support setting up zram because mmd
+  does not support the recovery mode.
+
 `swapoff <path>`
 > Stops swapping to the file or block device specified by path.
 

From 9124914c2de8f9c9f49f886a1793bcbb3b7b565b Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 20 Feb 2025 13:16:54 -0800
Subject: [PATCH 1436/1487] init: Shutdown services and umount partitions

This would gracefully terminate the services which are preventing partition unmount.

All the pending services which weren't terminated will receive SIGTERM.

With this patch:

1: Unmount partitions cleanly and not fallback to killing all processes
   because of timeout.

2: During user requested device poweroff, fsck would be run as partitions are successfully unmounted.

3: The shutdown / reboot cycle cuts down to ~4 seconds compared to 6 seconds improving the end-to-end reboot.

Bug: 398083419
Test: adb reboot / power-off cycles on Pixel

Average shutdown time after 15 reboot cycles:
With this patch: 4.169 seconds
Without this patch: 6.3 seconds

Change-Id: Idf22145cbc86d090e4982f3e22ef76f92ddd92e5
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 init/reboot.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/init/reboot.cpp b/init/reboot.cpp
index d7ad861fb6f7..a26149f77e16 100644
--- a/init/reboot.cpp
+++ b/init/reboot.cpp
@@ -268,6 +268,19 @@ static void DumpUmountDebuggingInfo() {
 }
 
 static UmountStat UmountPartitions(std::chrono::milliseconds timeout) {
+    // Terminate (SIGTERM) the services before unmounting partitions.
+    // If the processes block the signal, then partitions will eventually fail
+    // to unmount and then we fallback to SIGKILL the services.
+    //
+    // Hence, give the services a chance for a graceful shutdown before sending SIGKILL.
+    for (const auto& s : ServiceList::GetInstance()) {
+        if (s->IsShutdownCritical()) {
+            LOG(INFO) << "Shutdown service: " << s->name();
+            s->Terminate();
+        }
+    }
+    ReapAnyOutstandingChildren();
+
     Timer t;
     /* data partition needs all pending writes to be completed and all emulated partitions
      * umounted.If the current waiting is not good enough, give
@@ -815,6 +828,7 @@ static void DoReboot(unsigned int cmd, const std::string& reason, const std::str
     if (IsDataMounted("f2fs")) {
         uint32_t flag = F2FS_GOING_DOWN_FULLSYNC;
         unique_fd fd(TEMP_FAILURE_RETRY(open("/data", O_RDONLY)));
+        LOG(INFO) << "Invoking F2FS_IOC_SHUTDOWN during shutdown";
         int ret = ioctl(fd.get(), F2FS_IOC_SHUTDOWN, &flag);
         if (ret) {
             PLOG(ERROR) << "Shutdown /data: ";

From f01026f963b8689f6b0e046cb7cbe04b86a830fe Mon Sep 17 00:00:00 2001
From: Jooyung Han <jooyung@google.com>
Date: Thu, 27 Feb 2025 17:44:17 +0900
Subject: [PATCH 1437/1487] init.rc: remove /data/apex/sessions

Since Android R, apexd uses /metadata/apex/sessions.

Bug: 373550515
Test: ApexTestCases (no regression)
Change-Id: Ia13b4656e8234b4588f83de46b28275a3c75e8c9
---
 rootdir/init.rc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 734197bcc8aa..54493d5f8368 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -727,7 +727,6 @@ on post-fs-data
     mkdir /data/apex/active 0755 root system
     mkdir /data/apex/backup 0700 root system
     mkdir /data/apex/decompressed 0755 root system encryption=Require
-    mkdir /data/apex/sessions 0700 root system
     mkdir /data/app-staging 0751 system system encryption=DeleteIfNecessary
     mkdir /data/apex/ota_reserved 0700 root system encryption=Require
     setprop apexd.status ""

From 27b3c9f770dcce5b6ccb2d8114536d20368e6a5c Mon Sep 17 00:00:00 2001
From: Owner Cleanup Bot
 <swarming-tasks@owners-cleanup-prod.google.com.iam.gserviceaccount.com>
Date: Thu, 27 Feb 2025 09:25:24 -0800
Subject: [PATCH 1438/1487] [owners] Remove subrahmanyaman@google.com from
 gatekeeperd/OWNERS

This suggested change is automatically generated based on group
memberships and affiliations.

Please approve this change and vote the highest CR. This will keep the OWNERs
file tidy.  We ask that you do not ignore this change and approve it
unless you know a reason the OWNER should remain.  It can always be
reverted if needed.

If this change is in error, vote the lowest CR value (i.e. reject the CL)
and the bot will abandon it.

See the owner's recent review activity for context:
https://android-review.googlesource.com/q/subrahmanyaman@google.com

To report an issue, file a bug in the Infra>Codereview component.

Change-Id: I3b5b4b0645ffdac3efe55a91d12b9a4b88392823
---
 gatekeeperd/OWNERS | 1 -
 1 file changed, 1 deletion(-)

diff --git a/gatekeeperd/OWNERS b/gatekeeperd/OWNERS
index 04cd19e257ec..7d822e663e1e 100644
--- a/gatekeeperd/OWNERS
+++ b/gatekeeperd/OWNERS
@@ -1,5 +1,4 @@
 # Bug component: 1124862
 drysdale@google.com
 oarbildo@google.com
-subrahmanyaman@google.com
 swillden@google.com

From 1b40fce401e2c7b6d2540caa3d6ff45e5af94f34 Mon Sep 17 00:00:00 2001
From: Jing Wang <jwangh@google.com>
Date: Wed, 11 Dec 2024 10:43:38 -0800
Subject: [PATCH 1439/1487] init: Add a boot monitor for the second stage init

The boot monitor detects early boot lock-up issues before RescueParty starts.

Test:
fastboot oem cmdline set androidboot.boot_timeout=30
fastboot oem cmdline set androidboot.boot_timeout=180

Bug: 383565535
Change-Id: I67d69eac211423c946f0ea62acd0dff525593ea7
Signed-off-by: Jing Wang <jwangh@google.com>
---
 init/init.cpp | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/init/init.cpp b/init/init.cpp
index b6ba6a85893b..920b926dcd26 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -100,6 +100,8 @@ using namespace std::string_literals;
 using android::base::boot_clock;
 using android::base::ConsumePrefix;
 using android::base::GetProperty;
+using android::base::GetIntProperty;
+using android::base::GetBoolProperty;
 using android::base::ReadFileToString;
 using android::base::SetProperty;
 using android::base::StringPrintf;
@@ -108,6 +110,8 @@ using android::base::Trim;
 using android::base::unique_fd;
 using android::fs_mgr::AvbHandle;
 using android::snapshot::SnapshotManager;
+using android::base::WaitForProperty;
+using android::base::WriteStringToFile;
 
 namespace android {
 namespace init {
@@ -919,6 +923,34 @@ static Result<void> ConnectEarlyStageSnapuserdAction(const BuiltinArguments& arg
     return {};
 }
 
+static void SecondStageBootMonitor(int timeout_sec) {
+    auto cur_time = boot_clock::now().time_since_epoch();
+    int cur_sec = std::chrono::duration_cast<std::chrono::seconds>(cur_time).count();
+    int extra_sec = timeout_sec <= cur_sec? 0 : timeout_sec - cur_sec;
+    auto boot_timeout = std::chrono::seconds(extra_sec);
+
+    LOG(INFO) << "Started BootMonitorThread, expiring in "
+              << timeout_sec
+              << " seconds from boot-up";
+
+    if (!WaitForProperty("sys.boot_completed", "1", boot_timeout)) {
+        LOG(ERROR) << "BootMonitorThread: boot didn't complete in "
+                   << timeout_sec
+                   << " seconds. Trigger a panic!";
+
+        // add a short delay for logs to be flushed out.
+        std::this_thread::sleep_for(200ms);
+
+        // trigger a kernel panic
+        WriteStringToFile("c", PROC_SYSRQ);
+    }
+}
+
+static void StartSecondStageBootMonitor(int timeout_sec) {
+    std::thread monitor_thread(&SecondStageBootMonitor, timeout_sec);
+    monitor_thread.detach();
+}
+
 int SecondStageMain(int argc, char** argv) {
     if (REBOOT_BOOTLOADER_ON_PANIC) {
         InstallRebootSignalHandlers();
@@ -1010,6 +1042,14 @@ int SecondStageMain(int argc, char** argv) {
     InstallInitNotifier(&epoll);
     StartPropertyService(&property_fd);
 
+    // If boot_timeout property has been set in a debug build, start the boot monitor
+    if (GetBoolProperty("ro.debuggable", false)) {
+        int timeout = GetIntProperty("ro.boot.boot_timeout", 0);
+        if (timeout > 0) {
+            StartSecondStageBootMonitor(timeout);
+        }
+    }
+
     // Make the time that init stages started available for bootstat to log.
     RecordStageBoottimes(start_time);
 

From 9c830c45921c7220183bc791ea9b749f03868b6c Mon Sep 17 00:00:00 2001
From: Karuna Wadhera <kwadhera@google.com>
Date: Fri, 14 Feb 2025 07:41:04 -0800
Subject: [PATCH 1440/1487] Revert^4 "Run module code only after KeyMints
 receive module info"

This reverts commit 5b395ce2cc2f02cccc46d026d451dee9066ce0f3.

Reason for revert: This change should no longer cause boot issues. Manual testing on a variety of builds and form factors was conducted in b/399702162. See the original change aosp/3433145's description for change details.

Change-Id: If1aee09e94976630da8714dfae1bd16b8056586d
---
 rootdir/init.rc | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index f1670ae04a33..0b45e73c77b1 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -995,8 +995,11 @@ on post-fs-data
     mkdir /data/misc/stats-service/ 0770 statsd system
     mkdir /data/misc/train-info/ 0770 statsd system
 
-    # Wait for apexd to finish activating APEXes before starting more processes.
+    # TODO(b/369375199): Remove once attest modules flagging is removed.
     wait_for_prop apexd.status activated
+    # Wait for KeyMints to receive APEX module info before starting code from updateable APEXes.
+    # This is to prevent APEX modules from interfering in module measurement.
+    wait_for_prop keystore.module_hash.sent true
     perform_apex_config
 
     exec_start system_aconfigd_mainline_init

From 29d02f5451b476056ad3c7f9c2f707d58eed96c8 Mon Sep 17 00:00:00 2001
From: Weston Carvalho <westoncarvalho@google.com>
Date: Wed, 19 Feb 2025 14:51:27 -0600
Subject: [PATCH 1441/1487] storageproxyd: Remove duplicate interface
 definition

Now that trusty is part of the android manifest, we don't need to
duplicate the storage interface header.

Bug: None
Test: m
Change-Id: Ibcf97c8099f8227861460989b6f11108c5f7c0f9
---
 trusty/storage/interface/Android.bp           |  26 --
 .../include/trusty/interface/storage.h        | 313 ------------------
 .../storage/lib/include/trusty/lib/storage.h  |   2 +-
 trusty/storage/proxy/ipc.h                    |   2 +-
 trusty/storage/proxy/rpmb.h                   |   2 +-
 trusty/storage/proxy/storage.h                |   2 +-
 6 files changed, 4 insertions(+), 343 deletions(-)
 delete mode 100644 trusty/storage/interface/Android.bp
 delete mode 100644 trusty/storage/interface/include/trusty/interface/storage.h

diff --git a/trusty/storage/interface/Android.bp b/trusty/storage/interface/Android.bp
deleted file mode 100644
index 769f53d8eb7d..000000000000
--- a/trusty/storage/interface/Android.bp
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// Copyright (C) 2015 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.
-//
-
-package {
-    default_applicable_licenses: ["Android-Apache-2.0"],
-}
-
-cc_library_static {
-    name: "libtrustystorageinterface",
-    vendor_available: true,
-    system_ext_specific: true,
-    export_include_dirs: ["include"],
-}
diff --git a/trusty/storage/interface/include/trusty/interface/storage.h b/trusty/storage/interface/include/trusty/interface/storage.h
deleted file mode 100644
index 32916074bb67..000000000000
--- a/trusty/storage/interface/include/trusty/interface/storage.h
+++ /dev/null
@@ -1,313 +0,0 @@
-/*
- * Copyright (C) 2015-2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *		http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <stdint.h>
-
-/*
- * Storage port names
- * @STORAGE_CLIENT_TD_PORT:     Port used by clients that require tamper and
- *                              rollback detection.
- * @STORAGE_CLIENT_TDEA_PORT:   Port used by clients that require storage before
- *                              the non-secure os has booted.
- * @STORAGE_CLIENT_TP_PORT:     Port used by clients that require tamper proof
- *                              storage. Note that non-secure code can prevent
-                                read and write operations from succeeding, but
-                                it cannot modify on-disk data.
- * @STORAGE_DISK_PROXY_PORT:    Port used by non-secure proxy server
- */
-#define STORAGE_CLIENT_TD_PORT     "com.android.trusty.storage.client.td"
-#define STORAGE_CLIENT_TDEA_PORT   "com.android.trusty.storage.client.tdea"
-#define STORAGE_CLIENT_TP_PORT     "com.android.trusty.storage.client.tp"
-#define STORAGE_DISK_PROXY_PORT    "com.android.trusty.storage.proxy"
-
-enum storage_cmd {
-	STORAGE_REQ_SHIFT = 1,
-	STORAGE_RESP_BIT  = 1,
-
-	STORAGE_RESP_MSG_ERR   = STORAGE_RESP_BIT,
-
-	STORAGE_FILE_DELETE    = 1 << STORAGE_REQ_SHIFT,
-	STORAGE_FILE_OPEN      = 2 << STORAGE_REQ_SHIFT,
-	STORAGE_FILE_CLOSE     = 3 << STORAGE_REQ_SHIFT,
-	STORAGE_FILE_READ      = 4 << STORAGE_REQ_SHIFT,
-	STORAGE_FILE_WRITE     = 5 << STORAGE_REQ_SHIFT,
-	STORAGE_FILE_GET_SIZE  = 6 << STORAGE_REQ_SHIFT,
-	STORAGE_FILE_SET_SIZE  = 7 << STORAGE_REQ_SHIFT,
-
-	STORAGE_RPMB_SEND      = 8 << STORAGE_REQ_SHIFT,
-
-	/* transaction support */
-	STORAGE_END_TRANSACTION = 9 << STORAGE_REQ_SHIFT,
-
-	STORAGE_FILE_GET_MAX_SIZE = 12 << STORAGE_REQ_SHIFT,
-};
-
-/**
- * enum storage_err - error codes for storage protocol
- * @STORAGE_NO_ERROR:           all OK
- * @STORAGE_ERR_GENERIC:        unknown error. Can occur when there's an internal server
- *                              error, e.g. the server runs out of memory or is in a bad state.
- * @STORAGE_ERR_NOT_VALID:      input not valid. May occur if the arguments passed
- *                              into the command are not valid, for example if the file handle
- *                              passed in is not a valid one.
- * @STORAGE_ERR_UNIMPLEMENTED:  the command passed in is not recognized
- * @STORAGE_ERR_ACCESS:         the file is not accessible in the requested mode
- * @STORAGE_ERR_NOT_FOUND:      the file was not found
- * @STORAGE_ERR_EXIST           the file exists when it shouldn't as in with OPEN_CREATE | OPEN_EXCLUSIVE.
- * @STORAGE_ERR_TRANSACT        returned by various operations to indicate that current transaction
- *                              is in error state. Such state could be only cleared by sending
- *                              STORAGE_END_TRANSACTION message.
- * @STORAGE_ERR_SYNC_FAILURE    indicates that the current operation failed to sync
- *                              to disk. Only returned if STORAGE_MSG_FLAG_PRE_COMMIT or
- *                              STORAGE_MSG_FLAG_POST_COMMIT was set for the request.
- */
-enum storage_err {
-	STORAGE_NO_ERROR          = 0,
-	STORAGE_ERR_GENERIC       = 1,
-	STORAGE_ERR_NOT_VALID     = 2,
-	STORAGE_ERR_UNIMPLEMENTED = 3,
-	STORAGE_ERR_ACCESS        = 4,
-	STORAGE_ERR_NOT_FOUND     = 5,
-	STORAGE_ERR_EXIST         = 6,
-	STORAGE_ERR_TRANSACT      = 7,
-	STORAGE_ERR_SYNC_FAILURE  = 8,
-};
-
-/**
- * storage_delete_flag - flags for controlling delete semantics
- */
-enum storage_file_delete_flag {
-	STORAGE_FILE_DELETE_MASK = 0,
-};
-
-/**
- * storage_file_flag - Flags to control 'open' semantics.
- * @STORAGE_FILE_OPEN_CREATE:           if this file does not exist, create it.
- * @STORAGE_FILE_OPEN_CREATE_EXCLUSIVE: causes STORAGE_FILE_OPEN_CREATE to fail if the file
- *                                      already exists. Only meaningful if used in combination
- *                                      with STORAGE_FILE_OPEN_CREATE.
- * @STORAGE_FILE_OPEN_TRUNCATE:         if this file already exists, discard existing content
- *                                      and open it as a new file. No change in semantics if the
- *                                      file does not exist.
- * @STORAGE_FILE_OPEN_MASK:             mask for all open flags supported in current protocol.
- *                                      All other bits must be set to 0.
- */
-enum storage_file_open_flag {
-	STORAGE_FILE_OPEN_CREATE             = (1 << 0),
-	STORAGE_FILE_OPEN_CREATE_EXCLUSIVE   = (1 << 1),
-	STORAGE_FILE_OPEN_TRUNCATE           = (1 << 2),
-	STORAGE_FILE_OPEN_MASK               = STORAGE_FILE_OPEN_CREATE |
-					       STORAGE_FILE_OPEN_TRUNCATE |
-					       STORAGE_FILE_OPEN_CREATE_EXCLUSIVE,
-};
-
-/**
- * enum storage_msg_flag - protocol-level flags in struct storage_msg
- * @STORAGE_MSG_FLAG_BATCH:                 if set, command belongs to a batch transaction.
- *                                          No response will be sent by the server until
- *                                          it receives a command with this flag unset, at
- *                                          which point a cumulative result for all messages
- *                                          sent with STORAGE_MSG_FLAG_BATCH will be sent.
- *                                          This is only supported by the non-secure disk proxy
- *                                          server.
- * @STORAGE_MSG_FLAG_PRE_COMMIT:            if set, indicates that server need to commit
- *                                          pending changes before processing this message.
- * @STORAGE_MSG_FLAG_POST_COMMIT:           if set, indicates that server need to commit
- *                                          pending changes after processing this message.
- * @STORAGE_MSG_FLAG_TRANSACT_COMPLETE:     if set, indicates that server need to commit
- *                                          current transaction after processing this message.
- *                                          It is an alias for STORAGE_MSG_FLAG_POST_COMMIT.
- * @STORAGE_MSG_FLAG_PRE_COMMIT_CHECKPOINT: if set, indicates that server needs to ensure
- *                                          that there is not a pending checkpoint for
- *                                          userdata before processing this message.
- */
-enum storage_msg_flag {
-    STORAGE_MSG_FLAG_BATCH = 0x1,
-    STORAGE_MSG_FLAG_PRE_COMMIT = 0x2,
-    STORAGE_MSG_FLAG_POST_COMMIT = 0x4,
-    STORAGE_MSG_FLAG_TRANSACT_COMPLETE = STORAGE_MSG_FLAG_POST_COMMIT,
-    STORAGE_MSG_FLAG_PRE_COMMIT_CHECKPOINT = 0x8,
-};
-
-/*
- * The following declarations are the message-specific contents of
- * the 'payload' element inside struct storage_msg.
- */
-
-/**
- * struct storage_file_delete_req - request format for STORAGE_FILE_DELETE
- * @flags: currently unused, must be set to 0.
- * @name:  the name of the file
- */
-struct storage_file_delete_req {
-	uint32_t flags;
-	char name[0];
-};
-
-/**
- * struct storage_file_open_req - request format for STORAGE_FILE_OPEN
- * @flags: any of enum storage_file_flag or'ed together
- * @name:  the name of the file
- */
-struct storage_file_open_req {
-	uint32_t flags;
-	char     name[0];
-};
-
-/**
- * struct storage_file_open_resp - response format for STORAGE_FILE_OPEN
- * @handle: opaque handle to the opened file. Only present on success.
- */
-struct storage_file_open_resp {
-	uint32_t handle;
-};
-
-/**
- * struct storage_file_close_req - request format for STORAGE_FILE_CLOSE
- * @handle: the handle for the file to close
- */
-struct storage_file_close_req {
-	uint32_t handle;
-};
-
-/**
- * struct storage_file_get_max_size_req - request format for
- *                                        STORAGE_FILE_GET_MAX_SIZE
- * @handle: the handle for the file whose max size is requested
- */
-struct storage_file_get_max_size_req {
-	uint32_t handle;
-};
-
-/**
- * struct storage_file_get_max_size_resp - response format for
- *                                         STORAGE_FILE_GET_MAX_SIZE
- * @max_size:   the maximum size of the file
- */
-struct storage_file_get_max_size_resp {
-	uint64_t max_size;
-};
-
-/**
- * struct storage_file_read_req - request format for STORAGE_FILE_READ
- * @handle: the handle for the file from which to read
- * @size:   the quantity of bytes to read from the file
- * @offset: the offset in the file from whence to read
- */
-struct storage_file_read_req {
-	uint32_t handle;
-	uint32_t size;
-	uint64_t offset;
-};
-
-/**
- * struct storage_file_read_resp - response format for STORAGE_FILE_READ
- * @data: beginning of data retrieved from file
- */
-struct storage_file_read_resp {
-	uint8_t data[0];
-};
-
-/**
- * struct storage_file_write_req - request format for STORAGE_FILE_WRITE
- * @handle:     the handle for the file to write to
- * @offset:     the offset in the file from whence to write
- * @__reserved: unused, must be set to 0.
- * @data:       beginning of the data to be written
- */
-struct storage_file_write_req {
-	uint64_t offset;
-	uint32_t handle;
-	uint32_t __reserved;
-	uint8_t  data[0];
-};
-
-/**
- * struct storage_file_get_size_req - request format for STORAGE_FILE_GET_SIZE
- * @handle: handle for which the size is requested
- */
-struct storage_file_get_size_req {
-	uint32_t handle;
-};
-
-/**
- * struct storage_file_get_size_resp - response format for STORAGE_FILE_GET_SIZE
- * @size:   the size of the file
- */
-struct storage_file_get_size_resp {
-	uint64_t size;
-};
-
-/**
- * struct storage_file_set_size_req - request format for STORAGE_FILE_SET_SIZE
- * @handle: the file handle
- * @size:   the desired size of the file
- */
-struct storage_file_set_size_req {
-	uint64_t size;
-	uint32_t handle;
-};
-
-/**
- * struct storage_rpmb_send_req - request format for STORAGE_RPMB_SEND
- * @reliable_write_size:        size in bytes of reliable write region
- * @write_size:                 size in bytes of write region
- * @read_size:                  number of bytes to read for a read request
- * @__reserved:                 unused, must be set to 0
- * @payload:                    start of reliable write region, followed by
- *                              write region.
- *
- * Only used in proxy<->server interface.
- */
-struct storage_rpmb_send_req {
-	uint32_t reliable_write_size;
-	uint32_t write_size;
-	uint32_t read_size;
-	uint32_t __reserved;
-	uint8_t  payload[0];
-};
-
-/**
- * struct storage_rpmb_send_resp: response type for STORAGE_RPMB_SEND
- * @data: the data frames frames retrieved from the MMC.
- */
-struct storage_rpmb_send_resp {
-	uint8_t data[0];
-};
-
-/**
- * struct storage_msg - generic req/resp format for all storage commands
- * @cmd:        one of enum storage_cmd
- * @op_id:      client chosen operation identifier for an instance
- *              of a command or atomic grouping of commands (transaction).
- * @flags:      one or many of enum storage_msg_flag or'ed together.
- * @size:       total size of the message including this header
- * @result:     one of enum storage_err
- * @__reserved: unused, must be set to 0.
- * @payload:    beginning of command specific message format
- */
-struct storage_msg {
-	uint32_t cmd;
-	uint32_t op_id;
-	uint32_t flags;
-	uint32_t size;
-	int32_t  result;
-	uint32_t __reserved;
-	uint8_t  payload[0];
-};
-
diff --git a/trusty/storage/lib/include/trusty/lib/storage.h b/trusty/storage/lib/include/trusty/lib/storage.h
index b8ddf67d871b..4335619827d0 100644
--- a/trusty/storage/lib/include/trusty/lib/storage.h
+++ b/trusty/storage/lib/include/trusty/lib/storage.h
@@ -16,8 +16,8 @@
 
 #pragma once
 
+#include <interface/storage/storage.h>
 #include <stdint.h>
-#include <trusty/interface/storage.h>
 
 #define STORAGE_MAX_NAME_LENGTH_BYTES 159
 
diff --git a/trusty/storage/proxy/ipc.h b/trusty/storage/proxy/ipc.h
index 2e366bbb99ce..020f121619ac 100644
--- a/trusty/storage/proxy/ipc.h
+++ b/trusty/storage/proxy/ipc.h
@@ -15,8 +15,8 @@
  */
 #pragma once
 
+#include <interface/storage/storage.h>
 #include <stdint.h>
-#include <trusty/interface/storage.h>
 
 int ipc_connect(const char *device, const char *service_name);
 void ipc_disconnect(void);
diff --git a/trusty/storage/proxy/rpmb.h b/trusty/storage/proxy/rpmb.h
index 04bdf9a6a677..1761eecc0030 100644
--- a/trusty/storage/proxy/rpmb.h
+++ b/trusty/storage/proxy/rpmb.h
@@ -15,8 +15,8 @@
  */
 #pragma once
 
+#include <interface/storage/storage.h>
 #include <stdint.h>
-#include <trusty/interface/storage.h>
 
 #include "watchdog.h"
 
diff --git a/trusty/storage/proxy/storage.h b/trusty/storage/proxy/storage.h
index 6dbfe3706076..f46f78532d47 100644
--- a/trusty/storage/proxy/storage.h
+++ b/trusty/storage/proxy/storage.h
@@ -15,8 +15,8 @@
  */
 #pragma once
 
+#include <interface/storage/storage.h>
 #include <stdint.h>
-#include <trusty/interface/storage.h>
 
 /* Defined in watchdog.h */
 struct watcher;

From f7b2fc8117d44a26866f87392acbc5ad5c54d7a7 Mon Sep 17 00:00:00 2001
From: Cole Faust <colefaust@google.com>
Date: Fri, 28 Feb 2025 16:34:06 -0800
Subject: [PATCH 1442/1487] Cleanup python version properties

Now that python 2 is fully removed, there's no need for
version-specific properties. Remove them.

Also remove usages of embedded_launcher: true, as that
is the new default value.

Bug: 399954452
Test: Presubmits
Change-Id: If2ec8f8e489653eb3d2a1959f378b89f5556dcb6
---
 libsparse/Android.bp          | 5 -----
 trusty/test/driver/Android.bp | 6 ------
 2 files changed, 11 deletions(-)

diff --git a/libsparse/Android.bp b/libsparse/Android.bp
index 44907a1f0770..1d67cbe28dd1 100644
--- a/libsparse/Android.bp
+++ b/libsparse/Android.bp
@@ -89,11 +89,6 @@ python_binary_host {
     name: "simg_dump",
     main: "simg_dump.py",
     srcs: ["simg_dump.py"],
-    version: {
-        py3: {
-            embedded_launcher: true,
-        },
-    },
 }
 
 cc_fuzz {
diff --git a/trusty/test/driver/Android.bp b/trusty/test/driver/Android.bp
index b813a04ccb66..3faa878a2eb6 100644
--- a/trusty/test/driver/Android.bp
+++ b/trusty/test/driver/Android.bp
@@ -23,10 +23,4 @@ python_test {
         "**/*.py",
     ],
     test_suites: ["general-tests"],
-    version: {
-        py3: {
-            embedded_launcher: true,
-            enabled: true,
-        },
-    },
 }

From 3d36041050125298be1735da06b6bde7a929d5a9 Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Sat, 1 Mar 2025 11:20:24 +0000
Subject: [PATCH 1443/1487] trusty: utils: trusty-ut-ctrl: declare
 trusty-ut-ctrl.system as cc_test

cc_test is preferred for this test utility for it to
be packaged in the test package instead of impacting
the system_ext partition.

Bug: 367423387
Test: atest TrustyVMUnitTests
Change-Id: If9fb87e33b24be02bbccec47513a295d18fdad72
---
 trusty/utils/trusty-ut-ctrl/Android.bp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/trusty/utils/trusty-ut-ctrl/Android.bp b/trusty/utils/trusty-ut-ctrl/Android.bp
index c255614b0c75..dbd8016496ee 100644
--- a/trusty/utils/trusty-ut-ctrl/Android.bp
+++ b/trusty/utils/trusty-ut-ctrl/Android.bp
@@ -39,8 +39,8 @@ cc_binary {
     vendor: true,
 }
 
-cc_binary {
+cc_test {
     name: "trusty-ut-ctrl.system",
     defaults: ["trusty-ut-ctrl.defaults"],
-    system_ext_specific: true,
+    gtest: false,
 }

From 63998043531eb2fa7ed0a2027dfe3d2bc239cdcf Mon Sep 17 00:00:00 2001
From: Armelle Laine <armellel@google.com>
Date: Mon, 3 Mar 2025 05:21:53 +0000
Subject: [PATCH 1444/1487] trusty: utils: rpmb_dev: rpmb_dev.test.system.rc:
 support test_vm_os

Bug: 400066193
Test: atest TrustyVMUnitTests
Change-Id: I852c9d161c0cc01c096167145d90f66ff4b6fd8a
---
 trusty/utils/rpmb_dev/rpmb_dev.test.system.rc | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/trusty/utils/rpmb_dev/rpmb_dev.test.system.rc b/trusty/utils/rpmb_dev/rpmb_dev.test.system.rc
index 2127798e1c2e..c85dd12f262f 100644
--- a/trusty/utils/rpmb_dev/rpmb_dev.test.system.rc
+++ b/trusty/utils/rpmb_dev/rpmb_dev.test.system.rc
@@ -1,11 +1,15 @@
-service trusty_test_vm /apex/com.android.virt/bin/vm run \
-    /data/local/tmp/TrustyTestVM_UnitTests/trusty-test_vm-config.json
+service storageproxyd_test_vm /system_ext/bin/storageproxyd.system \
+        -d VSOCK:${trusty.test_vm.vm_cid}:1 \
+        -r /dev/socket/rpmb_mock_test_system \
+        -p /data/secure_storage_test_system \
+        -t sock
     disabled
+    class hal
     user system
     group system
 
-service storageproxyd_test_system /system_ext/bin/storageproxyd.system \
-        -d VSOCK:${trusty.test_vm.vm_cid}:1 \
+service storageproxyd_test_vm_os /system_ext/bin/storageproxyd.system \
+        -d VSOCK:${trusty.test_vm_os.vm_cid}:1 \
         -r /dev/socket/rpmb_mock_test_system \
         -p /data/secure_storage_test_system \
         -t sock

From 6d4e75a593f594268535b964c732f9c4c51d3612 Mon Sep 17 00:00:00 2001
From: "Isaac J. Manjarres" <isaacmanjarres@google.com>
Date: Mon, 3 Mar 2025 14:07:06 -0800
Subject: [PATCH 1445/1487] ashmem: Remove backwards compatibility for R APEXes
 running on Q

Mainline modules aren't supported on Q anymore, so remove the relevant
code for it.

Bug: 400506628
Change-Id: Iaaf29b49ef757d1753e8b30b5979832f21be80e2
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
---
 libcutils/ashmem-dev.cpp | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index b4f1d7fe62d3..cfc2d3a5a068 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -182,19 +182,9 @@ static int __ashmem_open_locked() {
     }
 
     android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(ashmem_device_path.c_str(), O_RDWR | O_CLOEXEC)));
-    int errno1 = errno;
-    // fallback for APEX w/ use_vendor on Q, which would have still used /dev/ashmem
-    // TODO: remove this?
     if (!fd.ok()) {
-        fd.reset(TEMP_FAILURE_RETRY(open("/dev/ashmem", O_RDWR | O_CLOEXEC)));
-        int errno2 = errno;
-        if (!fd.ok()) {
-            /* Q launching devices and newer must not reach here since they should have been
-             * able to open ashmem_device_path */
-            ALOGE("Unable to open ashmem device %s (%s) and /dev/ashmem (%s)",
-                  ashmem_device_path.c_str(), strerror(errno1), strerror(errno2));
-            return -1;
-        }
+        ALOGE("Unable to open ashmem device: %m");
+        return -1;
     }
 
     struct stat st;

From 91e33fb214efefba6b250a88f1d133968631446c Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 4 Mar 2025 10:02:32 -0800
Subject: [PATCH 1446/1487] snapshotctl: Support pause/resume of snapshot merge

Add Resume snapshot-merge API.

Bug: 400723109
Test: snapshotctl pause-merge
snapshotctl resume-merge

Change-Id: I92dd3325f2e26127303a828fa01b7632fa730c50
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 .../libsnapshot/include/libsnapshot/snapshot.h   |  3 +++
 fs_mgr/libsnapshot/snapshot.cpp                  |  9 +++++++++
 fs_mgr/libsnapshot/snapshotctl.cpp               | 16 ++++++++++++++++
 .../include/snapuserd/snapuserd_client.h         |  3 +++
 .../libsnapshot/snapuserd/snapuserd_client.cpp   |  8 ++++++++
 .../user-space-merge/snapuserd_server.cpp        |  3 +++
 6 files changed, 42 insertions(+)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
index e613d541462a..8a8100cba973 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot.h
@@ -429,6 +429,9 @@ class SnapshotManager final : public ISnapshotManager {
     // Pause the snapshot merge.
     bool PauseSnapshotMerge();
 
+    // Resume the snapshot merge.
+    bool ResumeSnapshotMerge();
+
     enum class SnapshotDriver {
         DM_SNAPSHOT,
         DM_USER,
diff --git a/fs_mgr/libsnapshot/snapshot.cpp b/fs_mgr/libsnapshot/snapshot.cpp
index d4561972ad8f..b614aab268f3 100644
--- a/fs_mgr/libsnapshot/snapshot.cpp
+++ b/fs_mgr/libsnapshot/snapshot.cpp
@@ -4696,6 +4696,15 @@ bool SnapshotManager::PauseSnapshotMerge() {
     return false;
 }
 
+bool SnapshotManager::ResumeSnapshotMerge() {
+    auto snapuserd_client = SnapuserdClient::TryConnect(kSnapuserdSocket, 5s);
+    if (snapuserd_client) {
+        // Resume the snapshot-merge
+        return snapuserd_client->ResumeMerge();
+    }
+    return false;
+}
+
 bool SnapshotManager::IsUserspaceSnapshotUpdateInProgress(
         std::vector<std::string>& dynamic_partitions) {
     // We cannot grab /metadata/ota lock here as this
diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index e1a3310c30ef..32c8e37612f7 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -83,6 +83,10 @@ int Usage() {
                  "    Deprecated.\n"
                  "  map\n"
                  "    Map all partitions at /dev/block/mapper\n"
+                 "  pause-merge\n"
+                 "    Pause snapshot merge\n"
+                 "  resume-merge\n"
+                 "    Resume snapshot merge\n"
                  "  map-snapshots <directory where snapshot patches are present>\n"
                  "    Map all snapshots based on patches present in the directory\n"
                  "  unmap-snapshots\n"
@@ -539,6 +543,16 @@ bool UnmapCmdHandler(int, char** argv) {
     return SnapshotManager::New()->UnmapAllSnapshots();
 }
 
+bool PauseSnapshotMerge(int, char** argv) {
+    android::base::InitLogging(argv, TeeLogger(LogdLogger(), &StderrLogger));
+    return SnapshotManager::New()->PauseSnapshotMerge();
+}
+
+bool ResumeSnapshotMerge(int, char** argv) {
+    android::base::InitLogging(argv, TeeLogger(LogdLogger(), &StderrLogger));
+    return SnapshotManager::New()->ResumeSnapshotMerge();
+}
+
 bool MergeCmdHandler(int /*argc*/, char** argv) {
     android::base::InitLogging(argv, TeeLogger(LogdLogger(), &StderrLogger));
     LOG(WARNING) << "Deprecated. Call update_engine_client --merge instead.";
@@ -1088,6 +1102,8 @@ static std::map<std::string, std::function<bool(int, char**)>> kCmdMap = {
         {"dump-verity-hash", DumpVerityHash},
 #endif
         {"unmap", UnmapCmdHandler},
+        {"pause-merge", PauseSnapshotMerge},
+        {"resume-merge", ResumeSnapshotMerge},
         // clang-format on
 };
 
diff --git a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h
index 453627c0f1ec..39850c08acbd 100644
--- a/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h
+++ b/fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_client.h
@@ -111,6 +111,9 @@ class SnapuserdClient {
 
     // Pause Merge threads
     bool PauseMerge();
+
+    // Resume Merge threads
+    bool ResumeMerge();
 };
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
index 0497c6566067..d0ff7f78dfd9 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
@@ -398,5 +398,13 @@ bool SnapuserdClient::PauseMerge() {
     return true;
 }
 
+bool SnapuserdClient::ResumeMerge() {
+    if (!Sendmsg("resume_merge")) {
+        LOG(ERROR) << "Failed to resume snapshot merge.";
+        return false;
+    }
+    return true;
+}
+
 }  // namespace snapshot
 }  // namespace android
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index a40617bc3655..a2813bf34b27 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -230,6 +230,9 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
     } else if (cmd == "pause_merge") {
         handlers_->PauseMerge();
         return true;
+    } else if (cmd == "resume_merge") {
+        handlers_->ResumeMerge();
+        return true;
     } else {
         LOG(ERROR) << "Received unknown message type from client";
         Sendmsg(fd, "fail");

From 8eeceb69f1c8b6dc56da53112f4b91128e63e930 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 4 Mar 2025 13:34:25 -0800
Subject: [PATCH 1447/1487] libsnapuserd: Handle error message

Bug: 400723109
Test: snapshotctl pause-merge
snapshotctl resume-merge

Change-Id: Ifbcbc14c9be69f849ad9680414614ca4851cfec2
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp           | 6 ++++--
 .../snapuserd/user-space-merge/snapuserd_server.cpp         | 4 ++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
index d0ff7f78dfd9..693fe39b6101 100644
--- a/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/snapuserd_client.cpp
@@ -395,7 +395,8 @@ bool SnapuserdClient::PauseMerge() {
         LOG(ERROR) << "Failed to pause snapshot merge.";
         return false;
     }
-    return true;
+    std::string response = Receivemsg();
+    return response == "success";
 }
 
 bool SnapuserdClient::ResumeMerge() {
@@ -403,7 +404,8 @@ bool SnapuserdClient::ResumeMerge() {
         LOG(ERROR) << "Failed to resume snapshot merge.";
         return false;
     }
-    return true;
+    std::string response = Receivemsg();
+    return response == "success";
 }
 
 }  // namespace snapshot
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
index a2813bf34b27..372b2f2f7c81 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp
@@ -229,10 +229,10 @@ bool UserSnapshotServer::Receivemsg(android::base::borrowed_fd fd, const std::st
         return Sendmsg(fd, "success");
     } else if (cmd == "pause_merge") {
         handlers_->PauseMerge();
-        return true;
+        return Sendmsg(fd, "success");
     } else if (cmd == "resume_merge") {
         handlers_->ResumeMerge();
-        return true;
+        return Sendmsg(fd, "success");
     } else {
         LOG(ERROR) << "Received unknown message type from client";
         Sendmsg(fd, "fail");

From 9c228ce317d43b6a26ee252499bb25b9cf7a8701 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 4 Mar 2025 14:41:16 -0800
Subject: [PATCH 1448/1487] apply-update: Add option to boot device off
 snapshots

$apply_update --boot_snapshot

~20 seconds to boot off the snapshots

To revert back to original state:
`adb shell snapshotctl revert-snapshots`

Bug: 400723109
Test: apply_update --boot_snapshot
Change-Id: Ia71c93b606149f0f0824085b50a9dc9e76ac5d2a
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/scripts/apply-update.sh | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/fs_mgr/libsnapshot/scripts/apply-update.sh b/fs_mgr/libsnapshot/scripts/apply-update.sh
index 2a5a8a283345..92bff3b93511 100755
--- a/fs_mgr/libsnapshot/scripts/apply-update.sh
+++ b/fs_mgr/libsnapshot/scripts/apply-update.sh
@@ -99,6 +99,8 @@ Options:
                             Now, the script can safely use this flag for update purpose.
 
   --wipe                   Wipe user data during the update.
+  --boot_snapshot          Boot the device off snapshots - No data wipe is supported
+                              To revert back to original state - `adb shell snapshotctl revert-snapshots`
   --help                   Display this help message.
 
 Environment Variables:
@@ -123,6 +125,7 @@ EOF
 }
 
 skip_static_partitions=0
+boot_snapshot=0
 flash_bootloader=1
 wipe_flag=0
 help_flag=0
@@ -139,6 +142,9 @@ for arg in "$@"; do
     --skip_bootloader)
       flash_bootloader=0
       ;;
+    --boot_snapshot)
+      boot_snapshot=1
+      ;;
     --help)
       help_flag=1
       ;;
@@ -208,7 +214,9 @@ adb push -q $HOST_PATH/*.patch $DEVICE_PATH
 
 log_message "Applying update"
 
-if (( wipe_flag )); then
+if (( boot_snapshot)); then
+  adb shell snapshotctl map-snapshots $DEVICE_PATH
+elif (( wipe_flag )); then
   adb shell snapshotctl apply-update $DEVICE_PATH -w
 else
   adb shell snapshotctl apply-update $DEVICE_PATH

From 54e1aacb40c2b92461d529eefcf047e4c7e2afb3 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 5 Mar 2025 09:35:10 -0800
Subject: [PATCH 1449/1487] Stop using deprecated (and removed in C23)
 ATOMIC_VAR_INIT().

Change-Id: I608532fc80bc768aab04c55675656157e7949835
---
 libsync/sync.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libsync/sync.c b/libsync/sync.c
index b8c48c7f7602..c4c4472be663 100644
--- a/libsync/sync.c
+++ b/libsync/sync.c
@@ -117,7 +117,7 @@ enum uapi_version {
     UAPI_MODERN,
     UAPI_LEGACY
 };
-static atomic_int g_uapi_version = ATOMIC_VAR_INIT(UAPI_UNKNOWN);
+static atomic_int g_uapi_version = UAPI_UNKNOWN;
 
 // ---------------------------------------------------------------------------
 

From 78541b718d631348eb494e18ca55be219bd709dc Mon Sep 17 00:00:00 2001
From: "Isaac J. Manjarres" <isaacmanjarres@google.com>
Date: Mon, 3 Mar 2025 16:06:58 -0800
Subject: [PATCH 1450/1487] ashmem: Expose has_memfd_support() for ashmem-tests
 to use

has_memfd_support() can be used to determine if memfds support ashmem
ioctl commands. This will be useful for the ashmem test suite, as it
can use that information to determine if it should test the
implementation of the memfd-ashmem ioctls.

Therefore, expose has_memfd_support() but only for ashmem-tests to use.
Ashmem clients do not need/must not use this function.

Bug: 111903542
Change-Id: If1378f73ddbba9a94c45375357ebf56fb0170b51
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
---
 libcutils/ashmem-dev.cpp    |  4 +++-
 libcutils/ashmem-internal.h | 19 +++++++++++++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)
 create mode 100644 libcutils/ashmem-internal.h

diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index cfc2d3a5a068..388a1e8b461c 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -44,6 +44,8 @@
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 
+#include "ashmem-internal.h"
+
 /* ashmem identity */
 static dev_t __ashmem_rdev;
 /*
@@ -156,7 +158,7 @@ static bool __has_memfd_support() {
     return true;
 }
 
-static bool has_memfd_support() {
+bool has_memfd_support() {
     static bool memfd_supported = __has_memfd_support();
     return memfd_supported;
 }
diff --git a/libcutils/ashmem-internal.h b/libcutils/ashmem-internal.h
new file mode 100644
index 000000000000..7bd037b71619
--- /dev/null
+++ b/libcutils/ashmem-internal.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+bool has_memfd_support();

From 2eb0e91233b4b0ce42ce46d5d8a2a7d7d589880a Mon Sep 17 00:00:00 2001
From: "Isaac J. Manjarres" <isaacmanjarres@google.com>
Date: Mon, 3 Mar 2025 17:55:35 -0800
Subject: [PATCH 1451/1487] ashmem_test: Add tests for memfd-ashmem
 compatibility layer

Run tests to evaluate the implementation of the memfd-ashmem
compatibility layer. These tests will only be run if the memfd-ashmem
compatibility support is present.

Bug: 111903542
Change-Id: I318417769e5256b45f060073893a88af8a68ecfc
Signed-off-by: Isaac J. Manjarres <isaacmanjarres@google.com>
---
 libcutils/ashmem_test.cpp | 118 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 118 insertions(+)

diff --git a/libcutils/ashmem_test.cpp b/libcutils/ashmem_test.cpp
index 96f20db9f624..2bf274c95cf2 100644
--- a/libcutils/ashmem_test.cpp
+++ b/libcutils/ashmem_test.cpp
@@ -29,6 +29,8 @@
 #include <cutils/ashmem.h>
 #include <gtest/gtest.h>
 
+#include "ashmem-internal.h"
+
 using android::base::unique_fd;
 
 static void TestCreateRegion(size_t size, unique_fd &fd, int prot) {
@@ -316,3 +318,119 @@ TEST(AshmemTest, ForkMultiRegionTest) {
 
     ASSERT_NO_FATAL_FAILURE(ForkMultiRegionTest(fds, nRegions, size));
 }
+
+class AshmemTestMemfdAshmemCompat : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    if (!has_memfd_support()){
+        GTEST_SKIP() << "No memfd support; skipping memfd-ashmem compat tests";
+    }
+  }
+};
+
+TEST_F(AshmemTestMemfdAshmemCompat, SetNameTest) {
+    unique_fd fd;
+
+    // ioctl() should fail, since memfd names cannot be changed after the buffer has been created.
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(getpagesize(), fd, PROT_READ | PROT_WRITE |
+                                                                PROT_EXEC));
+    ASSERT_LT(ioctl(fd, ASHMEM_SET_NAME, "invalid-command"), 0);
+}
+
+TEST_F(AshmemTestMemfdAshmemCompat, GetNameTest) {
+    unique_fd fd;
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(getpagesize(), fd, PROT_READ | PROT_WRITE |
+                                                                PROT_EXEC));
+
+    char testBuf[ASHMEM_NAME_LEN];
+    ASSERT_EQ(0, ioctl(fd, ASHMEM_GET_NAME, &testBuf));
+    // ashmem_create_region(nullptr, ...) creates memfds with the name "none".
+    ASSERT_STREQ(testBuf, "none");
+}
+
+TEST_F(AshmemTestMemfdAshmemCompat, SetSizeTest) {
+    unique_fd fd;
+
+    // ioctl() should fail, since libcutils sets and seals the buffer size after creating it.
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(getpagesize(), fd, PROT_READ | PROT_WRITE |
+                                                                PROT_EXEC));
+    ASSERT_LT(ioctl(fd, ASHMEM_SET_SIZE, 2 * getpagesize()), 0);
+}
+
+TEST_F(AshmemTestMemfdAshmemCompat, GetSizeTest) {
+    unique_fd fd;
+    size_t bufSize = getpagesize();
+
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(bufSize, fd, PROT_READ | PROT_WRITE | PROT_EXEC));
+    ASSERT_EQ(static_cast<int>(bufSize), ioctl(fd, ASHMEM_GET_SIZE, 0));
+}
+
+TEST_F(AshmemTestMemfdAshmemCompat, ProtMaskTest) {
+    unique_fd fd;
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(getpagesize(), fd, PROT_READ | PROT_WRITE |
+                                                                PROT_EXEC));
+
+    // We can only change PROT_WRITE for memfds since memfd implements ashmem's prot_mask through
+    // file seals, and only write seals exist.
+    //
+    // All memfd files start off as being writable (i.e. PROT_WRITE is part of the prot_mask).
+    // Test to ensure that the implementation only clears the PROT_WRITE bit when requested.
+    ASSERT_EQ(0, ioctl(fd, ASHMEM_SET_PROT_MASK, PROT_READ | PROT_WRITE | PROT_EXEC));
+    int prot = ioctl(fd, ASHMEM_GET_PROT_MASK, 0);
+    ASSERT_NE(prot, -1);
+    ASSERT_TRUE(prot & PROT_WRITE) << prot;
+
+    ASSERT_EQ(0, ioctl(fd, ASHMEM_SET_PROT_MASK, PROT_READ | PROT_EXEC));
+    prot = ioctl(fd, ASHMEM_GET_PROT_MASK, 0);
+    ASSERT_NE(prot, -1);
+    ASSERT_TRUE(!(prot & PROT_WRITE)) << prot;
+
+    // The shim layer should implement clearing PROT_WRITE via file seals, so check the file
+    // seals to ensure that F_SEAL_FUTURE_WRITE is set.
+    int seals = fcntl(fd, F_GET_SEALS, 0);
+    ASSERT_NE(seals, -1);
+    ASSERT_TRUE(seals & F_SEAL_FUTURE_WRITE) << seals;
+
+    // Similarly, ensure that file seals affect prot_mask
+    unique_fd fd2;
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(getpagesize(), fd2, PROT_READ | PROT_WRITE |
+                                                                PROT_EXEC));
+    ASSERT_EQ(0, fcntl(fd2, F_ADD_SEALS, F_SEAL_FUTURE_WRITE));
+    prot = ioctl(fd2, ASHMEM_GET_PROT_MASK, 0);
+    ASSERT_NE(prot, -1);
+    ASSERT_TRUE(!(prot & PROT_WRITE)) << prot;
+
+    // And finally, ensure that adding back permissions fails
+    ASSERT_LT(ioctl(fd2, ASHMEM_SET_PROT_MASK, PROT_READ | PROT_WRITE | PROT_EXEC), 0);
+}
+
+TEST_F(AshmemTestMemfdAshmemCompat, FileIDTest) {
+    unique_fd fd;
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(getpagesize(), fd, PROT_READ | PROT_WRITE |
+                                                                PROT_EXEC));
+
+    unsigned long ino;
+    ASSERT_EQ(0, ioctl(fd, ASHMEM_GET_FILE_ID, &ino));
+    struct stat st;
+    ASSERT_EQ(0, fstat(fd, &st));
+    ASSERT_EQ(ino, st.st_ino);
+}
+
+TEST_F(AshmemTestMemfdAshmemCompat, UnpinningTest) {
+    unique_fd fd;
+    size_t bufSize = getpagesize();
+    ASSERT_NO_FATAL_FAILURE(TestCreateRegion(getpagesize(), fd, PROT_READ | PROT_WRITE |
+                                                                PROT_EXEC));
+
+    struct ashmem_pin pin = {
+        .offset = 0,
+        .len = static_cast<uint32_t>(bufSize),
+    };
+    ASSERT_EQ(0, ioctl(fd, ASHMEM_UNPIN, &pin));
+    // ASHMEM_UNPIN should just be a nop
+    ASSERT_EQ(ASHMEM_IS_PINNED, ioctl(fd, ASHMEM_GET_PIN_STATUS, 0));
+
+    // This shouldn't do anything; when we pin the page, it shouldn't have been purged.
+    ASSERT_EQ(0, ioctl(fd, ASHMEM_PURGE_ALL_CACHES, 0));
+    ASSERT_EQ(ASHMEM_NOT_PURGED, ioctl(fd, ASHMEM_PIN, &pin));
+}
\ No newline at end of file

From a0c570bfd1e0a5ca49caef2da0c169adba9cdc74 Mon Sep 17 00:00:00 2001
From: Soichiro Fujii <soichirof@google.com>
Date: Tue, 4 Mar 2025 10:41:43 +0900
Subject: [PATCH 1452/1487] libprefetch: replay/record checks if they can run
 on its own

Currently, prefetch `record` or `replay` command is executed
when the respective property is set, which is done by `start`
command. However, due to the timing of which property trigger
gets executed, this results in prefetch not starting neither
`record` or `replay` until the very end of boot phase.

Instead of going through `start` to determine which command
to run using property, each command will check whether they
can execute on their own. this way we can tweak exactly when
we want to run each commands.

Bug: 380766679
Test: Builds
Test: On cuttlefish, observe replay correctly exiting when
replay condition is not met.
Test: On cuttlefish, observe record correctly exiting when
record condition is not met.

Change-Id: Iad926450f00984d703f72c9c7b1876a0b3d3ecfd
---
 init/libprefetch/prefetch/prefetch.rc         | 42 +++++++++++--------
 init/libprefetch/prefetch/src/arch/android.rs | 38 +++++++++++++++++
 .../prefetch/src/args/args_argh.rs            | 12 ++++++
 init/libprefetch/prefetch/src/lib.rs          | 14 +++++++
 4 files changed, 89 insertions(+), 17 deletions(-)

diff --git a/init/libprefetch/prefetch/prefetch.rc b/init/libprefetch/prefetch/prefetch.rc
index dee37bb49e47..bdcbbc670b03 100644
--- a/init/libprefetch/prefetch/prefetch.rc
+++ b/init/libprefetch/prefetch/prefetch.rc
@@ -1,28 +1,36 @@
-on init && property:ro.prefetch_boot.enabled=true
-    start prefetch
-
-service prefetch /system/bin/prefetch start
-    class main
-    user root
-    group root system
-    disabled
-    oneshot
-
-on property:prefetch_boot.record=true
-    start prefetch_record
+# Reads data from disk in advance and populates page cache
+# to speed up subsequent disk access.
+#
+# Record:
+#   start by `start prefetch_record` at appropriate timing.
+#   stop by setting `prefetch_boot.record_stop` to 1.
+#   set --duration to only capture for a certain duration instead.
+#
+# Replay:
+#   start by `start prefetch_replay` at appropriate timing.
+#   it will depend on several files generated from record.
+#
+#   replay is I/O intensive. make sure you pick appropriate
+#   timing to run each, so that you can maximize the page cache
+#   hit for subsequent disk access.
+#
+# Example:
+#   on early-init && property:ro.prefetch_boot.enabled=true
+#     start prefetch_replay
+#
+#   on init && property:ro.prefetch_boot.enabled=true
+#     start prefetch_record
+#
+#   on property:sys.boot_completed=1 && property:ro.prefetch_boot.enabled=true
+#     setprop prefetch_boot.record_stop 1
 
 service prefetch_record /system/bin/prefetch record --duration ${ro.prefetch_boot.duration_s:-0}
-    class main
     user root
     group root system
     disabled
     oneshot
 
-on property:prefetch_boot.replay=true
-    start prefetch_replay
-
 service prefetch_replay /system/bin/prefetch replay --io-depth ${ro.prefetch_boot.io_depth:-2} --max-fds ${ro.prefetch_boot.max_fds:-128}
-    class main
     user root
     group root system
     disabled
diff --git a/init/libprefetch/prefetch/src/arch/android.rs b/init/libprefetch/prefetch/src/arch/android.rs
index a11767e152f4..90db6c936b6f 100644
--- a/init/libprefetch/prefetch/src/arch/android.rs
+++ b/init/libprefetch/prefetch/src/arch/android.rs
@@ -6,6 +6,7 @@ use log::warn;
 use std::fs::File;
 use std::fs::OpenOptions;
 use std::io::Write;
+use std::path::Path;
 use std::time::Duration;
 
 use rustutils::system_properties::error::PropertyWatcherError;
@@ -41,6 +42,43 @@ fn start_prefetch_service(property_name: &str) -> Result<(), Error> {
     Ok(())
 }
 
+/// Checks if we can perform replay phase.
+/// Ensure that the pack file exists and is up-to-date, returns false otherwise.
+pub fn can_perform_replay(pack_path: &Path, fingerprint_path: &Path) -> Result<bool, Error> {
+    if !pack_path.exists() || !fingerprint_path.exists() {
+        return Ok(false);
+    }
+
+    let saved_fingerprint = std::fs::read_to_string(fingerprint_path)?;
+
+    let current_device_fingerprint = rustutils::system_properties::read("ro.build.fingerprint")
+        .map_err(|e| Error::Custom {
+            error: format!("Failed to read ro.build.fingerprint: {}", e),
+        })?;
+
+    Ok(current_device_fingerprint.is_some_and(|fp| fp == saved_fingerprint.trim()))
+}
+
+/// Checks if we can perform record phase.
+/// Ensure that following conditions hold:
+///   - File specified in ready_path exists. otherwise, create a new file and return false.
+///   - can_perform_replay is false.
+pub fn ensure_record_is_ready(
+    ready_path: &Path,
+    pack_path: &Path,
+    fingerprint_path: &Path,
+) -> Result<bool, Error> {
+    if !ready_path.exists() {
+        File::create(ready_path)
+            .map_err(|_| Error::Custom { error: "File Creation failed".to_string() })?;
+
+        return Ok(false);
+    }
+
+    let can_replay = can_perform_replay(pack_path, fingerprint_path)?;
+    Ok(!can_replay)
+}
+
 /// Start prefetch service
 ///
 /// 1: Check the presence of the file 'prefetch_ready'. If it doesn't
diff --git a/init/libprefetch/prefetch/src/args/args_argh.rs b/init/libprefetch/prefetch/src/args/args_argh.rs
index 65084eeaada4..b047d0f0e0a2 100644
--- a/init/libprefetch/prefetch/src/args/args_argh.rs
+++ b/init/libprefetch/prefetch/src/args/args_argh.rs
@@ -147,6 +147,13 @@ pub struct RecordArgs {
     /// store build_finger_print to tie the pack format
     #[argh(option, default = "default_build_finger_print_path()")]
     pub build_fingerprint_path: PathBuf,
+
+    #[cfg(target_os = "android")]
+    /// file path to check if prefetch_ready is present.
+    ///
+    /// A new file is created at the given path if it's not present.
+    #[argh(option, default = "default_ready_path()")]
+    pub ready_path: PathBuf,
 }
 
 /// Type of tracing subsystem to use.
@@ -204,6 +211,11 @@ pub struct ReplayArgs {
     /// file path from where the prefetch config file will be read
     #[argh(option, default = "PathBuf::new()")]
     pub config_path: PathBuf,
+
+    #[cfg(target_os = "android")]
+    /// store build_finger_print to tie the pack format
+    #[argh(option, default = "default_build_finger_print_path()")]
+    pub build_fingerprint_path: PathBuf,
 }
 
 /// dump records file in given format
diff --git a/init/libprefetch/prefetch/src/lib.rs b/init/libprefetch/prefetch/src/lib.rs
index 6564c4bc6d34..8286ef4407e6 100644
--- a/init/libprefetch/prefetch/src/lib.rs
+++ b/init/libprefetch/prefetch/src/lib.rs
@@ -59,6 +59,13 @@ pub use arch::android::*;
 
 /// Records prefetch data for the given configuration
 pub fn record(args: &RecordArgs) -> Result<(), Error> {
+    #[cfg(target_os = "android")]
+    if !ensure_record_is_ready(&args.ready_path, &args.path, &args.build_fingerprint_path)? {
+        info!("Cannot perform record -- skipping");
+        return Ok(());
+    }
+
+    info!("Starting record.");
     let (mut tracer, exit_tx) = tracer::Tracer::create(
         args.trace_buffer_size_kib,
         args.tracing_subsystem.clone(),
@@ -109,6 +116,13 @@ pub fn record(args: &RecordArgs) -> Result<(), Error> {
 
 /// Replays prefetch data for the given configuration
 pub fn replay(args: &ReplayArgs) -> Result<(), Error> {
+    #[cfg(target_os = "android")]
+    if !can_perform_replay(&args.path, &args.build_fingerprint_path)? {
+        info!("Cannot perform replay -- exiting.");
+        return Ok(());
+    }
+
+    info!("Starting replay.");
     let replay = Replay::new(args)?;
     replay.replay()
 }

From 178e031ad05e5b4f4c1988e260a11f510607b4e5 Mon Sep 17 00:00:00 2001
From: Soichiro Fujii <soichirof@google.com>
Date: Tue, 4 Mar 2025 18:25:23 +0900
Subject: [PATCH 1453/1487] libprefetch: Remove `start` command

This command evaluates the current state of device
and sets either `record` or `replay` property depending
on the result.

As these checks are now performed by its respective
commands by their own, `start` is now obsolete and can
be removed.

Bug: 380766679
Test: Build
Test: on cuttlefish, observe that record only starts when
the same condition originally checked in start is met.
Test: on cuttlefish, observe that replay only starts when
the same condition originally checked in start is met.

Change-Id: Idb791187b1c8d3c69a1d7f662a4b74413f6819a2
---
 init/libprefetch/prefetch/src/arch/android.rs | 68 -------------------
 init/libprefetch/prefetch/src/args.rs         |  4 --
 .../prefetch/src/args/args_argh.rs            | 22 ------
 init/libprefetch/prefetch/src/lib.rs          |  2 -
 init/libprefetch/prefetch/src/main.rs         |  4 --
 5 files changed, 100 deletions(-)

diff --git a/init/libprefetch/prefetch/src/arch/android.rs b/init/libprefetch/prefetch/src/arch/android.rs
index 90db6c936b6f..a87502dfd8bf 100644
--- a/init/libprefetch/prefetch/src/arch/android.rs
+++ b/init/libprefetch/prefetch/src/arch/android.rs
@@ -1,7 +1,5 @@
 use crate::Error;
 use crate::RecordArgs;
-use crate::StartArgs;
-use log::info;
 use log::warn;
 use std::fs::File;
 use std::fs::OpenOptions;
@@ -12,8 +10,6 @@ use std::time::Duration;
 use rustutils::system_properties::error::PropertyWatcherError;
 use rustutils::system_properties::PropertyWatcher;
 
-const PREFETCH_RECORD_PROPERTY: &str = "prefetch_boot.record";
-const PREFETCH_REPLAY_PROPERTY: &str = "prefetch_boot.replay";
 const PREFETCH_RECORD_PROPERTY_STOP: &str = "prefetch_boot.record_stop";
 
 fn wait_for_property_true(
@@ -32,16 +28,6 @@ pub fn wait_for_record_stop() {
     });
 }
 
-fn start_prefetch_service(property_name: &str) -> Result<(), Error> {
-    match rustutils::system_properties::write(property_name, "true") {
-        Ok(_) => {}
-        Err(_) => {
-            return Err(Error::Custom { error: "Failed to start prefetch service".to_string() });
-        }
-    }
-    Ok(())
-}
-
 /// Checks if we can perform replay phase.
 /// Ensure that the pack file exists and is up-to-date, returns false otherwise.
 pub fn can_perform_replay(pack_path: &Path, fingerprint_path: &Path) -> Result<bool, Error> {
@@ -79,60 +65,6 @@ pub fn ensure_record_is_ready(
     Ok(!can_replay)
 }
 
-/// Start prefetch service
-///
-/// 1: Check the presence of the file 'prefetch_ready'. If it doesn't
-/// exist then the device is booting for the first time after wipe.
-/// Thus, we would just create the file and exit as we do not want
-/// to initiate the record after data wipe primiarly because boot
-/// after data wipe is long and the I/O pattern during first boot may not actually match
-/// with subsequent boot.
-///
-/// 2: If the file 'prefetch_ready' is present:
-///
-///   a: Compare the build-finger-print of the device with the one record format
-///   is associated with by reading the file 'build_finger_print'. If they match,
-///   start the prefetch_replay.
-///
-///   b: If they don't match, then the device was updated through OTA. Hence, start
-///   a fresh record and delete the build-finger-print file. This should also cover
-///   the case of device rollback.
-///
-///   c: If the build-finger-print file doesn't exist, then just restart the record
-///   from scratch.
-pub fn start_prefetch(args: &StartArgs) -> Result<(), Error> {
-    if !args.path.exists() {
-        match File::create(args.path.clone()) {
-            Ok(_) => {}
-            Err(_) => {
-                return Err(Error::Custom { error: "File Creation failed".to_string() });
-            }
-        }
-        return Ok(());
-    }
-
-    if args.build_fingerprint_path.exists() {
-        let device_build_fingerprint = rustutils::system_properties::read("ro.build.fingerprint")
-            .map_err(|e| Error::Custom {
-            error: format!("Failed to read ro.build.fingerprint: {}", e),
-        })?;
-        let pack_build_fingerprint = std::fs::read_to_string(&args.build_fingerprint_path)?;
-        if pack_build_fingerprint.trim() == device_build_fingerprint.as_deref().unwrap_or_default()
-        {
-            info!("Start replay");
-            start_prefetch_service(PREFETCH_REPLAY_PROPERTY)?;
-        } else {
-            info!("Start record");
-            std::fs::remove_file(&args.build_fingerprint_path)?;
-            start_prefetch_service(PREFETCH_RECORD_PROPERTY)?;
-        }
-    } else {
-        info!("Start record");
-        start_prefetch_service(PREFETCH_RECORD_PROPERTY)?;
-    }
-    Ok(())
-}
-
 /// Write build finger print to associate prefetch pack file
 pub fn write_build_fingerprint(args: &RecordArgs) -> Result<(), Error> {
     let mut build_fingerprint_file = OpenOptions::new()
diff --git a/init/libprefetch/prefetch/src/args.rs b/init/libprefetch/prefetch/src/args.rs
index e534210b5125..4c1e689193fd 100644
--- a/init/libprefetch/prefetch/src/args.rs
+++ b/init/libprefetch/prefetch/src/args.rs
@@ -25,8 +25,6 @@ use std::process::exit;
 
 pub use args_internal::OutputFormat;
 pub use args_internal::ReplayArgs;
-#[cfg(target_os = "android")]
-pub use args_internal::StartArgs;
 pub use args_internal::TracerType;
 pub use args_internal::{DumpArgs, MainArgs, RecordArgs, SubCommands};
 use serde::Deserialize;
@@ -68,8 +66,6 @@ fn verify_and_fix(args: &mut MainArgs) -> Result<(), Error> {
         SubCommands::Dump(arg) => {
             ensure_path_exists(&arg.path)?;
         }
-        #[cfg(target_os = "android")]
-        SubCommands::Start(_arg) => return Ok(()),
     }
     Ok(())
 }
diff --git a/init/libprefetch/prefetch/src/args/args_argh.rs b/init/libprefetch/prefetch/src/args/args_argh.rs
index b047d0f0e0a2..d2251e6a5dde 100644
--- a/init/libprefetch/prefetch/src/args/args_argh.rs
+++ b/init/libprefetch/prefetch/src/args/args_argh.rs
@@ -40,12 +40,6 @@ pub enum SubCommands {
     Replay(ReplayArgs),
     /// Dump prefetch data in human readable format
     Dump(DumpArgs),
-    /// Start prefetch service if possible
-    /// If the pack file is present, then prefetch replay is started
-    /// If the pack file is absent or if the build fingerprint
-    /// of the current pack file is different, then prefetch record is started.
-    #[cfg(target_os = "android")]
-    Start(StartArgs),
 }
 
 #[cfg(target_os = "android")]
@@ -58,22 +52,6 @@ fn default_build_finger_print_path() -> PathBuf {
     PathBuf::from("/metadata/prefetch/build_finger_print")
 }
 
-#[cfg(target_os = "android")]
-#[derive(Eq, PartialEq, Debug, Default, FromArgs)]
-/// Start prefetch service based on if pack file is present.
-#[argh(subcommand, name = "start")]
-pub struct StartArgs {
-    /// file path to check if prefetch_ready is present.
-    ///
-    /// A new file is created at the given path if it's not present.
-    #[argh(option, default = "default_ready_path()")]
-    pub path: PathBuf,
-
-    /// file path where build fingerprint is stored
-    #[argh(option, default = "default_build_finger_print_path()")]
-    pub build_fingerprint_path: PathBuf,
-}
-
 impl Default for SubCommands {
     fn default() -> Self {
         Self::Dump(DumpArgs::default())
diff --git a/init/libprefetch/prefetch/src/lib.rs b/init/libprefetch/prefetch/src/lib.rs
index 8286ef4407e6..ea84c595b2b6 100644
--- a/init/libprefetch/prefetch/src/lib.rs
+++ b/init/libprefetch/prefetch/src/lib.rs
@@ -42,8 +42,6 @@ use log::LevelFilter;
 pub use args::args_from_env;
 use args::OutputFormat;
 pub use args::ReplayArgs;
-#[cfg(target_os = "android")]
-pub use args::StartArgs;
 pub use args::{DumpArgs, MainArgs, RecordArgs, SubCommands};
 pub use error::Error;
 pub use format::FileId;
diff --git a/init/libprefetch/prefetch/src/main.rs b/init/libprefetch/prefetch/src/main.rs
index eab826f250df..046e07edab89 100644
--- a/init/libprefetch/prefetch/src/main.rs
+++ b/init/libprefetch/prefetch/src/main.rs
@@ -22,8 +22,6 @@ use prefetch_rs::dump;
 use prefetch_rs::init_logging;
 use prefetch_rs::record;
 use prefetch_rs::replay;
-#[cfg(target_os = "android")]
-use prefetch_rs::start_prefetch;
 use prefetch_rs::LogLevel;
 use prefetch_rs::MainArgs;
 use prefetch_rs::SubCommands;
@@ -35,8 +33,6 @@ fn main() {
         SubCommands::Record(args) => record(args),
         SubCommands::Replay(args) => replay(args),
         SubCommands::Dump(args) => dump(args),
-        #[cfg(target_os = "android")]
-        SubCommands::Start(args) => start_prefetch(args),
     };
 
     if let Err(err) = ret {

From 7b1de50e3c798221481f97412a1f9d0d76c963ed Mon Sep 17 00:00:00 2001
From: Isaac Manjarres <isaacmanjarres@google.com>
Date: Thu, 6 Mar 2025 05:56:40 -0800
Subject: [PATCH 1454/1487] Revert "ashmem: Ensure all memfds have
 non-executable permissions by default"

This reverts commit ee7a713757314366023e855a76ff17943b6b9296.

Reason for revert: We would like to evaluate switching libcutils to
memfd against older kernels that don't support MFD_NOEXEC_SEAL, so
temporarily revert it. MFD_NOEXEC_SEAL will be brought back when
testing has concluded.

Bug: 401214539
Bug: 111903542
Change-Id: I2cf76e3545ac46a65b54889f9030ad44cb1e4d27
---
 libcutils/ashmem-dev.cpp | 17 ++---------------
 1 file changed, 2 insertions(+), 15 deletions(-)

diff --git a/libcutils/ashmem-dev.cpp b/libcutils/ashmem-dev.cpp
index cfc2d3a5a068..5fbe8a1c34fa 100644
--- a/libcutils/ashmem-dev.cpp
+++ b/libcutils/ashmem-dev.cpp
@@ -114,15 +114,8 @@ static bool __has_memfd_support() {
     // Check if kernel support exists, otherwise fall back to ashmem.
     // This code needs to build on old API levels, so we can't use the libc
     // wrapper.
-    //
-    // MFD_NOEXEC_SEAL is used to match the semantics of the ashmem device,
-    // which did not have executable permissions. This also seals the executable
-    // permissions of the buffer (i.e. they cannot be changed by fchmod()).
-    //
-    // MFD_NOEXEC_SEAL implies MFD_ALLOW_SEALING.
-
     android::base::unique_fd fd(
-            syscall(__NR_memfd_create, "test_android_memfd", MFD_CLOEXEC | MFD_NOEXEC_SEAL));
+            syscall(__NR_memfd_create, "test_android_memfd", MFD_CLOEXEC | MFD_ALLOW_SEALING));
     if (fd == -1) {
         ALOGE("memfd_create failed: %m, no memfd support");
         return false;
@@ -290,13 +283,7 @@ int ashmem_valid(int fd) {
 static int memfd_create_region(const char* name, size_t size) {
     // This code needs to build on old API levels, so we can't use the libc
     // wrapper.
-    //
-    // MFD_NOEXEC_SEAL to match the semantics of the ashmem device, which did
-    // not have executable permissions. This also seals the executable
-    // permissions of the buffer (i.e. they cannot be changed by fchmod()).
-    //
-    // MFD_NOEXEC_SEAL implies MFD_ALLOW_SEALING.
-    android::base::unique_fd fd(syscall(__NR_memfd_create, name, MFD_CLOEXEC | MFD_NOEXEC_SEAL));
+    android::base::unique_fd fd(syscall(__NR_memfd_create, name, MFD_CLOEXEC | MFD_ALLOW_SEALING));
 
     if (fd == -1) {
         ALOGE("memfd_create(%s, %zd) failed: %m", name, size);

From 77e36c890d0cc15fe41a80e4d4bd7dee7cf9b546 Mon Sep 17 00:00:00 2001
From: Marcin Radomski <dextero@google.com>
Date: Wed, 5 Mar 2025 19:11:31 +0000
Subject: [PATCH 1455/1487] init: restore mounts under /sys after
 enter_namespace

Entering a network namespace requires remounting sysfs to update contents of
/sys/class/net whose contents depend on the network namespace of the process
that mounted it rather than the effective network namespace of the reading
process.

A side effect of the remounting is unmounting all filesystems mounted under
/sys. In particular, unmounting tracefs (/sys/kernel/tracing) prevents
collecting ATrace traces from any init service that uses `enter_namespace
net`.

This CL makes init iterate over all current mounts and remount anything
under /sys/ after it remounts /sys for the service being started.

A minor change is to pass "sysfs" rather than the empty string as the
block device argument to mount. Otherwise, /proc/$PID/mounts inside the
process in network namespace contains a sysfs entry with no block device
name, which confuses the Fstab parser into thinking that /sys is the
block device, which made the included test fail.

Bug: 399071958
Test: th (test included)
Test: manual check: capture perfetto trace for a process started inside
Test: a network namespace, see ATrace traces showing up that weren't
Test: there before
Change-Id: Icc1e763dff115a06ac23b37f14cfbdd328bbe659
---
 init/Android.bp        |  1 +
 init/service_test.cpp  | 70 ++++++++++++++++++++++++++++++++++++++++++
 init/service_utils.cpp | 22 +++++++++++--
 3 files changed, 91 insertions(+), 2 deletions(-)

diff --git a/init/Android.bp b/init/Android.bp
index dbdf80b0367f..b209c47c94b2 100644
--- a/init/Android.bp
+++ b/init/Android.bp
@@ -599,6 +599,7 @@ cc_defaults {
     ],
     static_libs: [
         "libbase",
+        "libfstab",
         "libselinux",
         "libpropertyinfoserializer",
         "libpropertyinfoparser",
diff --git a/init/service_test.cpp b/init/service_test.cpp
index 53b53ed5a332..d75d4f1ecb91 100644
--- a/init/service_test.cpp
+++ b/init/service_test.cpp
@@ -27,6 +27,7 @@
 #include <android-base/file.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
+#include <fstab/fstab.h>
 #include <selinux/selinux.h>
 #include <sys/signalfd.h>
 #include "lmkd_service.h"
@@ -280,5 +281,74 @@ service $name /system/bin/yes
 
 INSTANTIATE_TEST_SUITE_P(service, ServiceStopTest, testing::Values(false, true));
 
+// Entering a network namespace requires remounting sysfs to update contents of
+// /sys/class/net whose contents depend on the network namespace of the process
+// that mounted it rather than the effective network namespace of the reading
+// process.
+//
+// A side effect of the remounting is unmounting all filesystems mounted under
+// /sys, like tracefs. Verify that init doesn't leave them unmounted by
+// accident.
+TEST(service, enter_namespace_net_preserves_mounts) {
+    if (getuid() != 0) {
+        GTEST_SKIP() << "Must be run as root.";
+        return;
+    }
+
+    struct ScopedNetNs {
+        std::string name;
+        ScopedNetNs(std::string n) : name(n) {
+            EXPECT_EQ(system(("/system/bin/ip netns add " + name).c_str()), 0);
+        }
+        ~ScopedNetNs() { EXPECT_EQ(system(("/system/bin/ip netns delete " + name).c_str()), 0); }
+    };
+    const ScopedNetNs netns("test_ns");
+
+    static constexpr std::string_view kServiceName = "ServiceA";
+    static constexpr std::string_view kScriptTemplate = R"init(
+service $name /system/bin/yes
+    user shell
+    group shell
+    seclabel $selabel
+    enter_namespace net /mnt/run/$ns_name
+)init";
+
+    std::string script = StringReplace(kScriptTemplate, "$name", kServiceName, false);
+    script = StringReplace(script, "$selabel", GetSecurityContext(), false);
+    script = StringReplace(script, "$ns_name", netns.name, false);
+
+    ServiceList& service_list = ServiceList::GetInstance();
+    Parser parser;
+    parser.AddSectionParser("service", std::make_unique<ServiceParser>(&service_list, nullptr));
+
+    TemporaryFile tf;
+    ASSERT_GE(tf.fd, 0);
+    ASSERT_TRUE(WriteStringToFd(script, tf.fd));
+    ASSERT_TRUE(parser.ParseConfig(tf.path));
+
+    Service* const service = ServiceList::GetInstance().FindService(kServiceName);
+    ASSERT_NE(service, nullptr);
+    ASSERT_RESULT_OK(service->Start());
+    ASSERT_TRUE(service->IsRunning());
+
+    android::fs_mgr::Fstab root_mounts;
+    ASSERT_TRUE(ReadFstabFromFile("/proc/mounts", &root_mounts));
+
+    android::fs_mgr::Fstab ns_mounts;
+    ASSERT_TRUE(ReadFstabFromFile(StringReplace("/proc/$pid/mounts", "$pid",
+                                                std::to_string(service->pid()), /*all=*/false),
+                                  &ns_mounts));
+
+    for (const auto& expected_mount : root_mounts) {
+        auto it = std::find_if(ns_mounts.begin(), ns_mounts.end(), [&](const auto& ns_mount) {
+            return ns_mount.mount_point == expected_mount.mount_point;
+        });
+        EXPECT_TRUE(it != ns_mounts.end()) << StringPrintf(
+                "entering network namespace unmounted %s", expected_mount.mount_point.c_str());
+    }
+
+    ServiceList::GetInstance().RemoveService(*service);
+}
+
 }  // namespace init
 }  // namespace android
diff --git a/init/service_utils.cpp b/init/service_utils.cpp
index 0e19bcc58c25..f8821a042e29 100644
--- a/init/service_utils.cpp
+++ b/init/service_utils.cpp
@@ -18,11 +18,11 @@
 
 #include <fcntl.h>
 #include <grp.h>
-#include <map>
 #include <sys/mount.h>
 #include <sys/prctl.h>
 #include <sys/wait.h>
 #include <unistd.h>
+#include <map>
 
 #include <android-base/file.h>
 #include <android-base/logging.h>
@@ -31,6 +31,7 @@
 #include <android-base/strings.h>
 #include <cutils/android_get_control_file.h>
 #include <cutils/sockets.h>
+#include <fstab/fstab.h>
 #include <processgroup/processgroup.h>
 
 #include "mount_namespace.h"
@@ -82,12 +83,29 @@ Result<void> SetUpMountNamespace(bool remount_proc, bool remount_sys) {
         }
     }
     if (remount_sys) {
+        android::fs_mgr::Fstab mounts;
+        if (!ReadFstabFromFile("/proc/mounts", &mounts)) {
+            LOG(ERROR) << "Could not read /proc/mounts";
+        }
         if (umount2("/sys", MNT_DETACH) == -1) {
             return ErrnoError() << "Could not umount(/sys)";
         }
-        if (mount("", "/sys", "sysfs", kSafeFlags, "") == -1) {
+        if (mount("sysfs", "/sys", "sysfs", kSafeFlags, "") == -1) {
             return ErrnoError() << "Could not mount(/sys)";
         }
+        // Unmounting /sys also unmounts all nested mounts like tracefs.
+        //
+        // Look up the filesystems that were mounted under /sys before we wiped
+        // it and attempt to restore them.
+        for (const auto& entry : mounts) {
+            if (entry.mount_point.starts_with("/sys/")) {
+                if (mount(entry.blk_device.c_str(), entry.mount_point.c_str(),
+                          entry.fs_type.c_str(), entry.flags, "")) {
+                    LOG(WARNING) << "Could not mount(" << entry.mount_point
+                                 << ") after switching netns: " << ErrnoError().str();
+                }
+            }
+        }
     }
     return {};
 }

From 31da755b716eeb1eb5c94950f239fccf4301b62b Mon Sep 17 00:00:00 2001
From: Soichiro Fujii <soichirof@google.com>
Date: Fri, 7 Mar 2025 14:09:57 +0900
Subject: [PATCH 1456/1487] libprefetch: Increase default fd count to 1024

Maximum capacity of 128 fds for replaying pack file
found to be too small. increasing it to 1024 should
be safe for most devices.

Bug: 380766679
Test: Builds
Test: run on devices, observe no performance regression
Change-Id: I4ee818dd5a9eb87b1a852c616ebda1bf5813d0da
---
 init/libprefetch/prefetch/prefetch.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/init/libprefetch/prefetch/prefetch.rc b/init/libprefetch/prefetch/prefetch.rc
index bdcbbc670b03..56fb82744972 100644
--- a/init/libprefetch/prefetch/prefetch.rc
+++ b/init/libprefetch/prefetch/prefetch.rc
@@ -30,7 +30,7 @@ service prefetch_record /system/bin/prefetch record --duration ${ro.prefetch_boo
     disabled
     oneshot
 
-service prefetch_replay /system/bin/prefetch replay --io-depth ${ro.prefetch_boot.io_depth:-2} --max-fds ${ro.prefetch_boot.max_fds:-128}
+service prefetch_replay /system/bin/prefetch replay --io-depth ${ro.prefetch_boot.io_depth:-2} --max-fds ${ro.prefetch_boot.max_fds:-1024}
     user root
     group root system
     disabled

From 8e650d38744df6ff84de1ad9f4a175f3c8070206 Mon Sep 17 00:00:00 2001
From: Soichiro Fujii <soichirof@google.com>
Date: Fri, 7 Mar 2025 16:53:14 +0900
Subject: [PATCH 1457/1487] libprefetch: check `ro.prefetch_boot.enabled`
 internally

Checking this value on the prefetch internally prevents
it from starting unless you explicitly enable the feature.

Bug: 380766679
Test: Builds
Test: Build emulator image with `ro.prefetch_boot.enabled 0`.
observe prefetch record exiting even when other condition meets.

Change-Id: Iadce8bd77a6b5299f33efdf5e195e715798f5104
---
 init/libprefetch/prefetch/src/arch/android.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/init/libprefetch/prefetch/src/arch/android.rs b/init/libprefetch/prefetch/src/arch/android.rs
index a87502dfd8bf..7d446ba5dfdd 100644
--- a/init/libprefetch/prefetch/src/arch/android.rs
+++ b/init/libprefetch/prefetch/src/arch/android.rs
@@ -12,6 +12,12 @@ use rustutils::system_properties::PropertyWatcher;
 
 const PREFETCH_RECORD_PROPERTY_STOP: &str = "prefetch_boot.record_stop";
 
+fn is_prefetch_enabled() -> Result<bool, Error> {
+    rustutils::system_properties::read_bool("ro.prefetch_boot.enabled", false).map_err(|e| {
+        Error::Custom { error: format!("Failed to read ro.prefetch_boot.enabled: {}", e) }
+    })
+}
+
 fn wait_for_property_true(
     property_name: &str,
     timeout: Option<Duration>,
@@ -31,6 +37,10 @@ pub fn wait_for_record_stop() {
 /// Checks if we can perform replay phase.
 /// Ensure that the pack file exists and is up-to-date, returns false otherwise.
 pub fn can_perform_replay(pack_path: &Path, fingerprint_path: &Path) -> Result<bool, Error> {
+    if !is_prefetch_enabled()? {
+        return Ok(false);
+    }
+
     if !pack_path.exists() || !fingerprint_path.exists() {
         return Ok(false);
     }
@@ -54,6 +64,10 @@ pub fn ensure_record_is_ready(
     pack_path: &Path,
     fingerprint_path: &Path,
 ) -> Result<bool, Error> {
+    if !is_prefetch_enabled()? {
+        return Ok(false);
+    }
+
     if !ready_path.exists() {
         File::create(ready_path)
             .map_err(|_| Error::Custom { error: "File Creation failed".to_string() })?;

From 635e5b4f3c7c34d9d327bcccc61c35a0f44feb95 Mon Sep 17 00:00:00 2001
From: Shintaro Kawamura <kawasin@google.com>
Date: Thu, 6 Mar 2025 16:21:12 +0900
Subject: [PATCH 1458/1487] Add init-mmd-prop.rc in case mmd is not built

The build flag RELEASE_MEMORY_MANAGEMENT_DAEMON will be eventually
enabled. If mmd is not built into the image, init-mmd-prop.rc sets
"mmd.enabled_aconfig" sysprop to unblock swapon_all execution.

Devices launching mmd in Trunkfood and Nextfood are supposed to execute
swapon_all command on "on property:mmd.enabled_aconfig=*" trigger.

On devices with mmd enabled, we need `mmd.enabled_aconfig` sysprop to be
empty by default, to let swapon_all command wait until aconfig flag
value is loaded to the system property.

Bug: 393481329
Test: manual

Change-Id: Iaba4cee2b5006a10403d5e03532bed008ab80019
---
 rootdir/Android.bp       |  6 ++++++
 rootdir/init-mmd-prop.rc | 19 +++++++++++++++++++
 2 files changed, 25 insertions(+)
 create mode 100644 rootdir/init-mmd-prop.rc

diff --git a/rootdir/Android.bp b/rootdir/Android.bp
index 3204a9f016c4..c0d31d964a5e 100644
--- a/rootdir/Android.bp
+++ b/rootdir/Android.bp
@@ -117,6 +117,12 @@ prebuilt_etc {
     sub_dir: "init",
 }
 
+prebuilt_etc {
+    name: "init-mmd-prop.rc",
+    src: "init-mmd-prop.rc",
+    sub_dir: "init",
+}
+
 prebuilt_etc {
     name: "asan.options",
     src: "asan.options",
diff --git a/rootdir/init-mmd-prop.rc b/rootdir/init-mmd-prop.rc
new file mode 100644
index 000000000000..6e9191c27523
--- /dev/null
+++ b/rootdir/init-mmd-prop.rc
@@ -0,0 +1,19 @@
+on property:sys.boot_completed=1
+    # When mmd package is not included in the image, we need to initialize
+    # `mmd.enabled_aconfig` sysprop instead of `mmd --set-property`.
+    #
+    # This is because of the consideration for devices in Trunkfood and Nextfood
+    # under mmd being launched via AConfig flag. The devices set up zram with
+    # mmd if `mmd_enabled` AConfig flag is enabled, otherwise set up zram with
+    # swapon_all init command. Since AConfig does not support any init script
+    # integration, we use `mmd.enabled_aconfig` copied by `mmd --set-property`
+    # instead of AConfig flag itself and we need mmd.enabled_aconfig to be empty
+    # by default, to let swapon_all command wait until aconfig flag value is
+    # loaded to the system property.
+    # Devices in Trunkfood and Nextfood needs to execute swapon_all command on
+    # `on property:mmd.enabled_aconfig=*` trigger. So initializing
+    # `mmd.enabled_aconfig` sysprop is required on images without mmd package.
+    #
+    # Note that this init file must not be in the image if mmd is built into the
+    # image.
+    setprop mmd.enabled_aconfig false
\ No newline at end of file

From 981d145117e8992842cdddee555c57e60c7a220a Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 10 Mar 2025 09:05:06 -0800
Subject: [PATCH 1459/1487] Explicitly mention a confusing proto3 infelicity.

This controversial choice is a popular topic of discussion on protobuf forums, but there's nothing we can do beyond document it.

Bug: http://b/401182697
Change-Id: I6edf28ca586c2e20c0f6bb5bdc09734d4d166b58
---
 debuggerd/proto/tombstone.proto | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/debuggerd/proto/tombstone.proto b/debuggerd/proto/tombstone.proto
index 444c9732f084..9deeeec9e185 100644
--- a/debuggerd/proto/tombstone.proto
+++ b/debuggerd/proto/tombstone.proto
@@ -15,6 +15,15 @@ option java_outer_classname = "TombstoneProtos";
 // NOTE TO OEMS:
 // If you add custom fields to this proto, do not use numbers in the reserved range.
 
+// NOTE TO CONSUMERS:
+// With proto3 -- unlike proto2 -- HasValue is unreliable for any field
+// where the default value for that type is also a valid value for the field.
+// This means, for example, that a boolean that is false or an integer that
+// is zero will appear to be missing --- but because they're not actually
+// marked as `optional` in this schema, consumers should just use values
+// without first checking whether or not they're "present".
+// https://protobuf.dev/programming-guides/proto3/#default
+
 message CrashDetail {
   bytes name = 1;
   bytes data = 2;

From 19e26545f51a550ba37d7ade1a78195b1b1e7bc4 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 10 Mar 2025 12:32:35 -0700
Subject: [PATCH 1460/1487] Test that uid 0 isn't dropped in proto to text
 conversion.

Bug: http://b/401182697
Change-Id: I0bbb11d1babfcf19a98cacb14f16487006182e0b
---
 debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
index aad209a063a8..988ca0cd1257 100644
--- a/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
+++ b/debuggerd/libdebuggerd/test/tombstone_proto_to_text_test.cpp
@@ -175,3 +175,8 @@ TEST_F(TombstoneProtoToTextTest, symbolize) {
   ProtoToString();
   EXPECT_MATCH(text_, "\\(BuildId: 0123456789abcdef\\)\\nSYMBOLIZE 0123456789abcdef 12345\\n");
 }
+
+TEST_F(TombstoneProtoToTextTest, uid) {
+  ProtoToString();
+  EXPECT_MATCH(text_, "\\nLOG uid: 0\\n");
+}

From 08bde8b3e6ef53e6df8324573c094cc2196a26c1 Mon Sep 17 00:00:00 2001
From: Florian Mayer <fmayer@google.com>
Date: Fri, 7 Mar 2025 16:36:56 -0800
Subject: [PATCH 1461/1487] Do not assume MTE is always on if supported

Test: atest debuggerd_test on hwasan build w/ https://r.android.com/3531684
Change-Id: I036c67f39e0ff5a6d7f5b218fdeb75f4e4956523
---
 debuggerd/debuggerd_test.cpp | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/debuggerd/debuggerd_test.cpp b/debuggerd/debuggerd_test.cpp
index 858956a80bd2..34f2c450c60b 100644
--- a/debuggerd/debuggerd_test.cpp
+++ b/debuggerd/debuggerd_test.cpp
@@ -335,7 +335,7 @@ TEST_F(CrasherTest, smoke) {
   ConsumeFd(std::move(output_fd), &result);
   ASSERT_MATCH(result, R"(signal 11 \(SIGSEGV\), code 1 \(SEGV_MAPERR\), fault addr 0x0+dead)");
 
-  if (mte_supported()) {
+  if (mte_supported() && mte_enabled()) {
     // Test that the default TAGGED_ADDR_CTRL value is set.
     ASSERT_MATCH(result, R"(tagged_addr_ctrl: 000000000007fff3)"
                          R"( \(PR_TAGGED_ADDR_ENABLE, PR_MTE_TCF_SYNC, mask 0xfffe\))");
@@ -443,7 +443,7 @@ INSTANTIATE_TEST_SUITE_P(Sizes, SizeParamCrasherTest, testing::Values(0, 16, 131
 
 TEST_P(SizeParamCrasherTest, mte_uaf) {
 #if defined(__aarch64__)
-  if (!mte_supported()) {
+  if (!mte_supported() || !mte_enabled()) {
     GTEST_SKIP() << "Requires MTE";
   }
 
@@ -490,7 +490,7 @@ TEST_P(SizeParamCrasherTest, mte_uaf) {
 
 TEST_P(SizeParamCrasherTest, mte_oob_uaf) {
 #if defined(__aarch64__)
-  if (!mte_supported()) {
+  if (!mte_supported() || !mte_enabled()) {
     GTEST_SKIP() << "Requires MTE";
   }
 
@@ -522,7 +522,7 @@ TEST_P(SizeParamCrasherTest, mte_oob_uaf) {
 
 TEST_P(SizeParamCrasherTest, mte_overflow) {
 #if defined(__aarch64__)
-  if (!mte_supported()) {
+  if (!mte_supported() || !mte_enabled()) {
     GTEST_SKIP() << "Requires MTE";
   }
 
@@ -565,7 +565,7 @@ TEST_P(SizeParamCrasherTest, mte_overflow) {
 
 TEST_P(SizeParamCrasherTest, mte_underflow) {
 #if defined(__aarch64__)
-  if (!mte_supported()) {
+  if (!mte_supported() || !mte_enabled()) {
     GTEST_SKIP() << "Requires MTE";
   }
 
@@ -614,7 +614,7 @@ TEST_F(CrasherTest, DISABLED_mte_illegal_setjmp) {
   //     unsubtle chaos is sure to result.
   // https://man7.org/linux/man-pages/man3/longjmp.3.html
 #if defined(__aarch64__)
-  if (!mte_supported()) {
+  if (!mte_supported() || !mte_enabled()) {
     GTEST_SKIP() << "Requires MTE";
   }
 
@@ -648,7 +648,7 @@ TEST_F(CrasherTest, DISABLED_mte_illegal_setjmp) {
 
 TEST_F(CrasherTest, mte_async) {
 #if defined(__aarch64__)
-  if (!mte_supported()) {
+  if (!mte_supported() || !mte_enabled()) {
     GTEST_SKIP() << "Requires MTE";
   }
 
@@ -678,7 +678,7 @@ TEST_F(CrasherTest, mte_async) {
 
 TEST_F(CrasherTest, mte_multiple_causes) {
 #if defined(__aarch64__)
-  if (!mte_supported()) {
+  if (!mte_supported() || !mte_enabled()) {
     GTEST_SKIP() << "Requires MTE";
   }
 
@@ -764,7 +764,7 @@ static uintptr_t CreateTagMapping() {
 
 TEST_F(CrasherTest, mte_register_tag_dump) {
 #if defined(__aarch64__)
-  if (!mte_supported()) {
+  if (!mte_supported() || !mte_enabled()) {
     GTEST_SKIP() << "Requires MTE";
   }
 
@@ -797,7 +797,7 @@ TEST_F(CrasherTest, mte_register_tag_dump) {
 
 TEST_F(CrasherTest, mte_fault_tag_dump_front_truncated) {
 #if defined(__aarch64__)
-  if (!mte_supported()) {
+  if (!mte_supported() || !mte_enabled()) {
     GTEST_SKIP() << "Requires MTE";
   }
 
@@ -828,7 +828,7 @@ TEST_F(CrasherTest, mte_fault_tag_dump_front_truncated) {
 
 TEST_F(CrasherTest, mte_fault_tag_dump) {
 #if defined(__aarch64__)
-  if (!mte_supported()) {
+  if (!mte_supported() || !mte_enabled()) {
     GTEST_SKIP() << "Requires MTE";
   }
 
@@ -862,7 +862,7 @@ TEST_F(CrasherTest, mte_fault_tag_dump) {
 
 TEST_F(CrasherTest, mte_fault_tag_dump_rear_truncated) {
 #if defined(__aarch64__)
-  if (!mte_supported()) {
+  if (!mte_supported() || !mte_enabled()) {
     GTEST_SKIP() << "Requires MTE";
   }
 

From fc1521251ac00600545b671cc6f8a8b8e841f5b8 Mon Sep 17 00:00:00 2001
From: "Liana Kazanova (xWF)" <lkazanova@google.com>
Date: Mon, 10 Mar 2025 15:07:13 -0700
Subject: [PATCH 1462/1487] Revert^5 "Run module code only after KeyMints
 receive module info"

This reverts commit 9c830c45921c7220183bc791ea9b749f03868b6c.

Reason for revert: DroidMonitor: Potential culprit for http://b/402202667 - verifying through ABTD before revert submission. This is part of the standard investigation process, and does not mean your CL will be reverted.

Change-Id: I45a04b41866f37c924e486d2cfe024327760fd67
---
 rootdir/init.rc | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/rootdir/init.rc b/rootdir/init.rc
index 0b45e73c77b1..f1670ae04a33 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -995,11 +995,8 @@ on post-fs-data
     mkdir /data/misc/stats-service/ 0770 statsd system
     mkdir /data/misc/train-info/ 0770 statsd system
 
-    # TODO(b/369375199): Remove once attest modules flagging is removed.
+    # Wait for apexd to finish activating APEXes before starting more processes.
     wait_for_prop apexd.status activated
-    # Wait for KeyMints to receive APEX module info before starting code from updateable APEXes.
-    # This is to prevent APEX modules from interfering in module measurement.
-    wait_for_prop keystore.module_hash.sent true
     perform_apex_config
 
     exec_start system_aconfigd_mainline_init

From fae5e95a95a006dd1778c43a5da84854833220f7 Mon Sep 17 00:00:00 2001
From: "Andrei Homescu (xWF)" <ahomescu@google.com>
Date: Mon, 10 Mar 2025 15:05:09 -0700
Subject: [PATCH 1463/1487] Revert tests from "trusty: Add
 TRUSTY_SEND_SECURE_OR_SHARE"

This reverts the tests from commit 1b75aba47ee8c6ebd2bb3a2ae059aff5a73a7c1b.

Reason for revert: Broken, needs more work

Change-Id: I904041c774f336934b7f1a2d3fbf4a97753402a8
---
 trusty/libtrusty/tipc-test/tipc_test.c | 108 +++++++++----------------
 1 file changed, 37 insertions(+), 71 deletions(-)

diff --git a/trusty/libtrusty/tipc-test/tipc_test.c b/trusty/libtrusty/tipc-test/tipc_test.c
index 9910aeeb5f2a..121837dc0ea3 100644
--- a/trusty/libtrusty/tipc-test/tipc_test.c
+++ b/trusty/libtrusty/tipc-test/tipc_test.c
@@ -55,8 +55,6 @@
 "}"
 /* clang-format on */
 
-#define countof(arr) (sizeof(arr) / sizeof(arr[0]))
-
 static const char *uuid_name = "com.android.ipc-unittest.srv.uuid";
 static const char *echo_name = "com.android.ipc-unittest.srv.echo";
 static const char *ta_only_name = "com.android.ipc-unittest.srv.ta_only";
@@ -906,14 +904,12 @@ static int readv_test(const struct tipc_test_params* params) {
 
 static int send_fd_test(const struct tipc_test_params* params) {
     int ret;
-    int dma_buf[] = {-1, -1, -1};
+    int dma_buf = -1;
     int fd = -1;
-    volatile char* buf[countof(dma_buf)] = {MAP_FAILED, MAP_FAILED, MAP_FAILED};
+    volatile char* buf = MAP_FAILED;
     BufferAllocator* allocator = NULL;
-    uint i;
 
     const size_t num_chunks = 10;
-    const size_t buf_size = memref_chunk_size * num_chunks;
 
     fd = tipc_connect(params->dev_name, receiver_name);
     if (fd < 0) {
@@ -929,86 +925,56 @@ static int send_fd_test(const struct tipc_test_params* params) {
         goto cleanup;
     }
 
-    for (i = 0; i < countof(dma_buf); i++) {
-        ret = DmabufHeapAlloc(allocator, "system", buf_size, 0, 0 /* legacy align */);
-        if (ret < 0) {
-            fprintf(stderr, "Failed to create dma-buf fd of size %zu err (%d)\n", buf_size, ret);
-            goto cleanup;
-        }
-        dma_buf[i] = ret;
+    size_t buf_size = memref_chunk_size * num_chunks;
+    dma_buf = DmabufHeapAlloc(allocator, "system", buf_size, 0, 0 /* legacy align */);
+    if (dma_buf < 0) {
+        ret = dma_buf;
+        fprintf(stderr, "Failed to create dma-buf fd of size %zu err (%d)\n", buf_size, ret);
+        goto cleanup;
     }
 
-    for (i = 0; i < countof(dma_buf); i++) {
-        buf[i] = mmap(0, buf_size, PROT_READ | PROT_WRITE, MAP_SHARED, dma_buf[i], 0);
-        if (buf[i] == MAP_FAILED) {
-            fprintf(stderr, "Failed to map dma-buf: %s\n", strerror(errno));
-            ret = -1;
-            goto cleanup;
-        }
+    buf = mmap(0, buf_size, PROT_READ | PROT_WRITE, MAP_SHARED, dma_buf, 0);
+    if (buf == MAP_FAILED) {
+        fprintf(stderr, "Failed to map dma-buf: %s\n", strerror(errno));
+        ret = -1;
+        goto cleanup;
+    }
+
+    strcpy((char*)buf, "From NS");
 
-        strcpy((char*)buf[i], "From NS");
-    }
-
-    struct trusty_shm shm[] = {
-            {
-                    .fd = dma_buf[0],
-                    .transfer = TRUSTY_SHARE,
-            },
-            {
-                    .fd = dma_buf[0],
-                    .transfer = TRUSTY_SEND_SECURE_OR_SHARE,
-            },
-            {
-                    .fd = dma_buf[1],
-                    .transfer = TRUSTY_LEND,
-            },
-            {
-                    .fd = dma_buf[1],
-                    .transfer = TRUSTY_SEND_SECURE_OR_SHARE,
-            },
-            {
-                    .fd = dma_buf[2],
-                    .transfer = TRUSTY_SEND_SECURE_OR_SHARE,
-            },
+    struct trusty_shm shm = {
+            .fd = dma_buf,
+            .transfer = TRUSTY_SHARE,
     };
 
-    for (i = 0; i < countof(shm); i++) {
-        ssize_t rc = tipc_send(fd, NULL, 0, &shm[i], 1);
-        if (rc < 0) {
-            fprintf(stderr, "tipc_send failed: %zd\n", rc);
-            ret = rc;
-            goto cleanup;
-        }
-        char c;
-        read(fd, &c, 1);
+    ssize_t rc = tipc_send(fd, NULL, 0, &shm, 1);
+    if (rc < 0) {
+        fprintf(stderr, "tipc_send failed: %zd\n", rc);
+        ret = rc;
+        goto cleanup;
     }
+    char c;
+    read(fd, &c, 1);
+    tipc_close(fd);
 
     ret = 0;
-    for (i = 0; i < countof(buf); i++) {
-        for (size_t skip = 0; skip < num_chunks; skip++) {
-            int cmp = strcmp("Hello from Trusty!", (const char*)&buf[i][skip * memref_chunk_size])
-                              ? (-1)
-                              : 0;
-            if (cmp) fprintf(stderr, "Failed: Unexpected content at page %zu in dmabuf\n", skip);
-            ret |= cmp;
-        }
+    for (size_t skip = 0; skip < num_chunks; skip++) {
+        int cmp = strcmp("Hello from Trusty!",
+                         (const char*)&buf[skip * memref_chunk_size]) ? (-1) : 0;
+        if (cmp)
+            fprintf(stderr, "Failed: Unexpected content at page %zu in dmabuf\n", skip);
+        ret |= cmp;
     }
 
 cleanup:
-    for (i = 0; i < countof(dma_buf); i++) {
-        if (buf[i] != MAP_FAILED) {
-            munmap((char*)buf[i], buf_size);
-        }
-        if (dma_buf[i] >= 0) {
-            close(dma_buf[i]);
-        }
+    if (buf != MAP_FAILED) {
+        munmap((char*)buf, buf_size);
     }
+    close(dma_buf);
     if (allocator) {
         FreeDmabufHeapBufferAllocator(allocator);
     }
-    if (fd >= 0) {
-        tipc_close(fd);
-    }
+    tipc_close(fd);
     return ret;
 }
 

From 3f89c663093febb590dda56022f6dd44a8b81478 Mon Sep 17 00:00:00 2001
From: Karuna Wadhera <kwadhera@google.com>
Date: Tue, 11 Mar 2025 00:19:42 +0000
Subject: [PATCH 1464/1487] Bootchart updates

Test: Change was tested when bootcharting aosp/3433145
Change-Id: I8ed2f03b692788565e11ee8169a379f7b387b1b5
---
 init/README.md             | 19 +++----------------
 init/compare-bootcharts.py |  2 +-
 2 files changed, 4 insertions(+), 17 deletions(-)

diff --git a/init/README.md b/init/README.md
index 251fe987964a..219581996448 100644
--- a/init/README.md
+++ b/init/README.md
@@ -939,26 +939,13 @@ Init records some boot timing information in system properties.
 
 Bootcharting
 ------------
-This version of init contains code to perform "bootcharting": generating log
-files that can be later processed by the tools provided by <http://www.bootchart.org/>.
+Bootchart provides CPU and I/O load breakdown of all processes for the whole system.
+Refer to the instructions at
+ <https://source.android.com/docs/core/perf/boot-times#bootchart>.
 
 On the emulator, use the -bootchart _timeout_ option to boot with bootcharting
 activated for _timeout_ seconds.
 
-On a device:
-
-    adb shell 'touch /data/bootchart/enabled'
-
-Don't forget to delete this file when you're done collecting data!
-
-The log files are written to /data/bootchart/. A script is provided to
-retrieve them and create a bootchart.tgz file that can be used with the
-bootchart command-line utility:
-
-    sudo apt-get install pybootchartgui
-    # grab-bootchart.sh uses $ANDROID_SERIAL.
-    $ANDROID_BUILD_TOP/system/core/init/grab-bootchart.sh
-
 One thing to watch for is that the bootchart will show init as if it started
 running at 0s. You'll have to look at dmesg to work out when the kernel
 actually started init.
diff --git a/init/compare-bootcharts.py b/init/compare-bootcharts.py
index 009b63999a40..b299b7d1b670 100755
--- a/init/compare-bootcharts.py
+++ b/init/compare-bootcharts.py
@@ -47,7 +47,7 @@
 def analyze_process_maps(process_map1, process_map2, jiffy_record):
     # List interesting processes here
     processes_of_interest = [
-        '/init',
+        '/system/bin/init',
         '/system/bin/surfaceflinger',
         '/system/bin/bootanimation',
         'zygote64',

From 3d75ea011a026fc6103fffa5a2e9d086ad1d7b11 Mon Sep 17 00:00:00 2001
From: "xiaomei.li" <xiaomei.li@unisoc.com>
Date: Tue, 11 Mar 2025 09:54:21 +0800
Subject: [PATCH 1465/1487] The unit of memory.soft_limit_in_bytes(memcg v1) or
 memory.low(memcg v2) should be 'M', 'MB' is the invalid argument.

Bug: 402259910
Change-Id: I683bfd21dc287e98bc3d0d272729368b406af7f3
---
 libprocessgroup/profiles/task_profiles.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libprocessgroup/profiles/task_profiles.json b/libprocessgroup/profiles/task_profiles.json
index 720cb304c8ba..42cdb919508a 100644
--- a/libprocessgroup/profiles/task_profiles.json
+++ b/libprocessgroup/profiles/task_profiles.json
@@ -597,7 +597,7 @@
           "Params":
           {
             "Name": "MemSoftLimit",
-            "Value": "16MB"
+            "Value": "16M"
           }
         },
         {
@@ -619,7 +619,7 @@
           "Params":
           {
             "Name": "MemSoftLimit",
-            "Value": "512MB"
+            "Value": "512M"
           }
         },
         {

From ec6e99816272712ccfb29375446b13654f3a7fe8 Mon Sep 17 00:00:00 2001
From: Marcin Radomski <dextero@google.com>
Date: Tue, 11 Mar 2025 19:06:33 +0000
Subject: [PATCH 1466/1487] init: fix SELinux denials on remounting from new
 netns

Never mount /sys/kernel/debug/tracing. This is the *one* mount that is
special within Linux kernel: for backward compatibility tracefs gets
auto-mounted there whenever one mounts debugfs [1].

The auto-mounting logic used to be guarded by an Android-specific kernel
config flag in some older Android kernels 5.10 [2], but that patch was
not cherry picked into newer kernels, so the automounting happens
whether we want it or not.

Attempting to mount the filesystem here will cause SELinux denials,
because unlike *all other* filesystems in Android, it's not init who
mounted it so there's no policy that would allow it.

This caused test failures in CI on
aosp_cf_x86_64_auto-trunk_staging-userdebug [3].

[1] https://lore.kernel.org/lkml/20150204143755.694479564@goodmis.org/
[2] https://android-review.googlesource.com/c/kernel/common/+/1664712
[3] https://android-build.corp.google.com/test_investigate/invocation/I06400010375485931/test/TR91729660607423480/

Bug: 399071958
Test: abtd run of aosp_cf_x86_64_auto-trunk
Change-Id: I6692d2b11d26fdcc8ed6411776a955a6d97d9e29
---
 init/service_utils.cpp | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/init/service_utils.cpp b/init/service_utils.cpp
index f8821a042e29..8d9a046a3043 100644
--- a/init/service_utils.cpp
+++ b/init/service_utils.cpp
@@ -98,7 +98,17 @@ Result<void> SetUpMountNamespace(bool remount_proc, bool remount_sys) {
         // Look up the filesystems that were mounted under /sys before we wiped
         // it and attempt to restore them.
         for (const auto& entry : mounts) {
-            if (entry.mount_point.starts_with("/sys/")) {
+            // Never mount /sys/kernel/debug/tracing. This is the *one* mount
+            // that is special within Linux kernel: for backward compatibility
+            // tracefs gets auto-mounted there whenever one mounts debugfs [1].
+            //
+            // Attempting to mount the filesystem here will cause SELinux
+            // denials, because unlike *all other* filesystems in Android, it's
+            // not init who mounted it so there's no policy that would allow it.
+            //
+            // [1] https://lore.kernel.org/lkml/20150204143755.694479564@goodmis.org/
+            if (entry.mount_point.starts_with("/sys/") &&
+                entry.mount_point != "/sys/kernel/debug/tracing") {
                 if (mount(entry.blk_device.c_str(), entry.mount_point.c_str(),
                           entry.fs_type.c_str(), entry.flags, "")) {
                     LOG(WARNING) << "Could not mount(" << entry.mount_point

From e69593fee70258ecab79fb32d9736d951dff5a4b Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Thu, 6 Mar 2025 15:17:22 -0800
Subject: [PATCH 1467/1487] Verify partitions using registered buffers

1: Single thread per partition is used for verification but with a
   default queue depth of 4
2: Since the buffers are pre-registered, buffer allocation will
   not be from CMA memory.

Partition verification when every block is a COPY operation:

Partition: system_dlkm Duration : 123 ms
Partition: vendor_dlkm Duration : 135 ms
Partition: system_ext Duration : 1421 ms
Partition: system Size: 945278976 Duration : 2834 ms
Partition: vendor Size: 998957056 Duration : 2881 ms
Partition: product Size: 3941609472 Duration : 6246 ms

Bug: 400674947
Test: Boot device off snapshots and verify partition verification is
successful. OTA on Pixel
Change-Id: Ife88c13e7ef00a46aef55e755ae841e33bc7e913
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapuserd/Android.bp       |   4 +
 .../user-space-merge/snapuserd_verify.cpp     | 145 ++++++++++++------
 .../user-space-merge/snapuserd_verify.h       |  28 ++--
 3 files changed, 118 insertions(+), 59 deletions(-)

diff --git a/fs_mgr/libsnapshot/snapuserd/Android.bp b/fs_mgr/libsnapshot/snapuserd/Android.bp
index 639116e8d9f4..9972bc76d1ab 100644
--- a/fs_mgr/libsnapshot/snapuserd/Android.bp
+++ b/fs_mgr/libsnapshot/snapuserd/Android.bp
@@ -88,6 +88,7 @@ cc_library_static {
         "libprocessgroup",
         "libprocessgroup_util",
         "libjsoncpp",
+        "liburing_cpp",
     ],
     export_include_dirs: ["include"],
     header_libs: [
@@ -136,6 +137,7 @@ cc_defaults {
         "libext4_utils",
         "liburing",
         "libzstd",
+        "liburing_cpp",
     ],
 
     header_libs: [
@@ -222,6 +224,7 @@ cc_defaults {
         "libjsoncpp",
         "liburing",
         "libz",
+        "liburing_cpp",
     ],
     include_dirs: [
         ".",
@@ -319,6 +322,7 @@ cc_binary_host {
         "libjsoncpp",
         "liburing",
         "libz",
+        "liburing_cpp",
     ],
     include_dirs: [
         ".",
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp
index 957c6a8a783a..97f8df49d255 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.cpp
@@ -22,6 +22,7 @@
 
 #include "android-base/properties.h"
 #include "snapuserd_core.h"
+#include "utility.h"
 
 namespace android {
 namespace snapshot {
@@ -104,43 +105,108 @@ bool UpdateVerify::VerifyBlocks(const std::string& partition_name,
         return false;
     }
 
-    loff_t file_offset = offset;
-    auto verify_block_size = android::base::GetUintProperty<uint>("ro.virtual_ab.verify_block_size",
-                                                                  kBlockSizeVerify);
-    const uint64_t read_sz = verify_block_size;
+    int queue_depth = std::max(queue_depth_, 1);
+    int verify_block_size = verify_block_size_;
+
+    // Smaller partitions don't need a bigger queue-depth.
+    // This is required for low-memory devices.
+    if (dev_sz < threshold_size_) {
+        queue_depth = std::max(queue_depth / 2, 1);
+        verify_block_size >>= 2;
+    }
 
-    void* addr;
-    ssize_t page_size = getpagesize();
-    if (posix_memalign(&addr, page_size, read_sz) < 0) {
-        SNAP_PLOG(ERROR) << "posix_memalign failed "
-                         << " page_size: " << page_size << " read_sz: " << read_sz;
+    if (!IsBlockAligned(verify_block_size)) {
+        verify_block_size = EXT4_ALIGN(verify_block_size, BLOCK_SZ);
+    }
+
+    std::unique_ptr<io_uring_cpp::IoUringInterface> ring =
+            io_uring_cpp::IoUringInterface::CreateLinuxIoUring(queue_depth, 0);
+    if (ring.get() == nullptr) {
+        PLOG(ERROR) << "Verify: io_uring_queue_init failed for queue_depth: " << queue_depth;
         return false;
     }
 
-    std::unique_ptr<void, decltype(&::free)> buffer(addr, ::free);
+    std::unique_ptr<struct iovec[]> vecs = std::make_unique<struct iovec[]>(queue_depth);
+    std::vector<std::unique_ptr<void, decltype(&::free)>> buffers;
+    for (int i = 0; i < queue_depth; i++) {
+        void* addr;
+        ssize_t page_size = getpagesize();
+        if (posix_memalign(&addr, page_size, verify_block_size) < 0) {
+            LOG(ERROR) << "posix_memalign failed";
+            return false;
+        }
 
-    uint64_t bytes_read = 0;
+        buffers.emplace_back(addr, ::free);
+        vecs[i].iov_base = addr;
+        vecs[i].iov_len = verify_block_size;
+    }
 
-    while (true) {
-        size_t to_read = std::min((dev_sz - file_offset), read_sz);
+    auto ret = ring->RegisterBuffers(vecs.get(), queue_depth);
+    if (!ret.IsOk()) {
+        SNAP_LOG(ERROR) << "io_uring_register_buffers failed: " << ret.ErrCode();
+        return false;
+    }
 
-        if (!android::base::ReadFullyAtOffset(fd.get(), buffer.get(), to_read, file_offset)) {
-            SNAP_PLOG(ERROR) << "Failed to read block from block device: " << dm_block_device
-                             << " partition-name: " << partition_name
-                             << " at offset: " << file_offset << " read-size: " << to_read
-                             << " block-size: " << dev_sz;
-            return false;
+    loff_t file_offset = offset;
+    const uint64_t read_sz = verify_block_size;
+    uint64_t total_read = 0;
+    int num_submitted = 0;
+
+    SNAP_LOG(DEBUG) << "VerifyBlocks: queue_depth: " << queue_depth
+                    << " verify_block_size: " << verify_block_size << " dev_sz: " << dev_sz
+                    << " file_offset: " << file_offset << " skip_blocks: " << skip_blocks;
+
+    while (file_offset < dev_sz) {
+        for (size_t i = 0; i < queue_depth; i++) {
+            uint64_t to_read = std::min((dev_sz - file_offset), read_sz);
+            if (to_read <= 0) break;
+
+            const auto sqe =
+                    ring->PrepReadFixed(fd.get(), vecs[i].iov_base, to_read, file_offset, i);
+            if (!sqe.IsOk()) {
+                SNAP_PLOG(ERROR) << "PrepReadFixed failed";
+                return false;
+            }
+            file_offset += (skip_blocks * to_read);
+            total_read += to_read;
+            num_submitted += 1;
+            if (file_offset >= dev_sz) {
+                break;
+            }
         }
 
-        bytes_read += to_read;
-        file_offset += (skip_blocks * verify_block_size);
-        if (file_offset >= dev_sz) {
+        if (num_submitted == 0) {
             break;
         }
+
+        const auto io_submit = ring->SubmitAndWait(num_submitted);
+        if (!io_submit.IsOk()) {
+            SNAP_LOG(ERROR) << "SubmitAndWait failed: " << io_submit.ErrMsg()
+                            << " for: " << num_submitted << " entries.";
+            return false;
+        }
+
+        SNAP_LOG(DEBUG) << "io_uring_submit: " << total_read << "num_submitted: " << num_submitted
+                        << "ret: " << ret;
+
+        const auto cqes = ring->PopCQE(num_submitted);
+        if (cqes.IsErr()) {
+            SNAP_LOG(ERROR) << "PopCqe failed for: " << num_submitted
+                            << " error: " << cqes.GetError().ErrMsg();
+            return false;
+        }
+        for (const auto& cqe : cqes.GetResult()) {
+            if (cqe.res < 0) {
+                SNAP_LOG(ERROR) << "I/O failed: cqe->res: " << cqe.res;
+                return false;
+            }
+            num_submitted -= 1;
+        }
     }
 
-    SNAP_LOG(DEBUG) << "Verification success with bytes-read: " << bytes_read
-                    << " dev_sz: " << dev_sz << " partition_name: " << partition_name;
+    SNAP_LOG(DEBUG) << "Verification success with io_uring: "
+                    << " dev_sz: " << dev_sz << " partition_name: " << partition_name
+                    << " total_read: " << total_read;
 
     return true;
 }
@@ -175,21 +241,14 @@ bool UpdateVerify::VerifyPartition(const std::string& partition_name,
         return false;
     }
 
-    /*
-     * Not all partitions are of same size. Some partitions are as small as
-     * 100Mb. We can just finish them in a single thread. For bigger partitions
-     * such as product, 4 threads are sufficient enough.
-     *
-     * TODO: With io_uring SQ_POLL support, we can completely cut this
-     * down to just single thread for all partitions and potentially verify all
-     * the partitions with zero syscalls. Additionally, since block layer
-     * supports polling, IO_POLL could be used which will further cut down
-     * latency.
-     */
+    if (!KernelSupportsIoUring()) {
+        SNAP_LOG(INFO) << "Kernel does not support io_uring. Skipping verification.\n";
+        // This will fallback to update_verifier to do the verification.
+        return false;
+    }
+
     int num_threads = kMinThreadsToVerify;
-    auto verify_threshold_size = android::base::GetUintProperty<uint>(
-            "ro.virtual_ab.verify_threshold_size", kThresholdSize);
-    if (dev_sz > verify_threshold_size) {
+    if (dev_sz > threshold_size_) {
         num_threads = kMaxThreadsToVerify;
     }
 
@@ -197,13 +256,11 @@ bool UpdateVerify::VerifyPartition(const std::string& partition_name,
     off_t start_offset = 0;
     const int skip_blocks = num_threads;
 
-    auto verify_block_size =
-            android::base::GetUintProperty("ro.virtual_ab.verify_block_size", kBlockSizeVerify);
     while (num_threads) {
         threads.emplace_back(std::async(std::launch::async, &UpdateVerify::VerifyBlocks, this,
                                         partition_name, dm_block_device, start_offset, skip_blocks,
                                         dev_sz));
-        start_offset += verify_block_size;
+        start_offset += verify_block_size_;
         num_threads -= 1;
         if (start_offset >= dev_sz) {
             break;
@@ -218,9 +275,9 @@ bool UpdateVerify::VerifyPartition(const std::string& partition_name,
     if (ret) {
         succeeded = true;
         UpdatePartitionVerificationState(UpdateVerifyState::VERIFY_SUCCESS);
-        SNAP_LOG(INFO) << "Partition: " << partition_name << " Block-device: " << dm_block_device
-                       << " Size: " << dev_sz
-                       << " verification success. Duration : " << timer.duration().count() << " ms";
+        SNAP_LOG(INFO) << "Partition verification success: " << partition_name
+                       << " Block-device: " << dm_block_device << " Size: " << dev_sz
+                       << " Duration : " << timer.duration().count() << " ms";
         return true;
     }
 
diff --git a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h
index b300a700093c..69a334b65e9d 100644
--- a/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h
+++ b/fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_verify.h
@@ -15,6 +15,7 @@
 
 #pragma once
 
+#include <liburing.h>
 #include <stdint.h>
 #include <sys/types.h>
 
@@ -22,6 +23,7 @@
 #include <mutex>
 #include <string>
 
+#include <liburing_cpp/IoUring.h>
 #include <snapuserd/snapuserd_kernel.h>
 #include <storage_literals/storage_literals.h>
 
@@ -48,27 +50,23 @@ class UpdateVerify {
     std::mutex m_lock_;
     std::condition_variable m_cv_;
 
+    int kMinThreadsToVerify = 1;
+    int kMaxThreadsToVerify = 3;
+
     /*
-     * Scanning of partitions is an expensive operation both in terms of memory
-     * and CPU usage. The goal here is to scan the partitions fast enough without
-     * significant increase in the boot time.
-     *
-     * Partitions such as system, product which may be huge and may need multiple
-     * threads to speed up the verification process. Using multiple threads for
-     * all partitions may increase CPU usage significantly. Hence, limit that to
-     * 1 thread per partition.
+     * To optimize partition scanning speed without significantly impacting boot time,
+     * we employ O_DIRECT, bypassing the page-cache. However, O_DIRECT's memory
+     * allocation from CMA can be problematic on devices with restricted CMA space.
+     * To address this, io_uring_register_buffers() pre-registers I/O buffers,
+     * preventing CMA usage. See b/401952955 for more details.
      *
      * These numbers were derived by monitoring the memory and CPU pressure
      * (/proc/pressure/{cpu,memory}; and monitoring the Inactive(file) and
      * Active(file) pages from /proc/meminfo.
-     *
-     * Additionally, for low memory devices, it is advisable to use O_DIRECT
-     * functionality for source block device.
      */
-    int kMinThreadsToVerify = 1;
-    int kMaxThreadsToVerify = 3;
-    uint64_t kThresholdSize = 750_MiB;
-    uint64_t kBlockSizeVerify = 2_MiB;
+    uint64_t verify_block_size_ = 1_MiB;
+    uint64_t threshold_size_ = 2_GiB;
+    int queue_depth_ = 4;
 
     bool IsBlockAligned(uint64_t read_size) { return ((read_size & (BLOCK_SZ - 1)) == 0); }
     void UpdatePartitionVerificationState(UpdateVerifyState state);

From d1ca7e8017973616b4ecec16525eb87c5853a205 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= <maze@google.com>
Date: Fri, 14 Mar 2025 09:25:21 -0700
Subject: [PATCH 1468/1487] change ownership of for-system subdirs to AID_CLAT
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bug: 402962730
Test: TreeHugger
Signed-off-by: Maciej Żenczykowski <maze@google.com>
Change-Id: Id8a4de6468d96fa2ae430edb2d90547ab435f598
---
 libcutils/fs_config.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libcutils/fs_config.cpp b/libcutils/fs_config.cpp
index 00a111439105..1c66f666e9b8 100644
--- a/libcutils/fs_config.cpp
+++ b/libcutils/fs_config.cpp
@@ -75,13 +75,13 @@ static const struct fs_path_config android_dirs[] = {
     { 00751, AID_ROOT,         AID_SHELL,        0, "product/apex/*/bin" },
     { 00777, AID_ROOT,         AID_ROOT,         0, "sdcard" },
     { 00751, AID_ROOT,         AID_SDCARD_R,     0, "storage" },
-    { 00750, AID_ROOT,         AID_SYSTEM,       0, "system/apex/com.android.tethering/bin/for-system" },
+    { 00750, AID_CLAT,         AID_SYSTEM,       0, "system/apex/com.android.tethering/bin/for-system" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "system/bin" },
     { 00755, AID_ROOT,         AID_ROOT,         0, "system/etc/ppp" },
     { 00755, AID_ROOT,         AID_SHELL,        0, "system/vendor" },
     { 00750, AID_ROOT,         AID_SHELL,        0, "system/xbin" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "system/apex/*/bin" },
-    { 00750, AID_ROOT,         AID_SYSTEM,       0, "system_ext/apex/com.android.tethering/bin/for-system" },
+    { 00750, AID_CLAT,         AID_SYSTEM,       0, "system_ext/apex/com.android.tethering/bin/for-system" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "system_ext/bin" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "system_ext/apex/*/bin" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "vendor/bin" },

From 9f79a97af1e808bc136b3ec92330d74038365c04 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Fri, 14 Mar 2025 10:41:47 -0700
Subject: [PATCH 1469/1487] libsnapshot: Reinitiaze SnapshotMergeStats instance

If SnapshotManager instance merge path has changed,
then reinitialize the SnapshotMergeStats instance.

Bug: 401952955
Test: OTA on Pixel
Change-Id: I1a6b2de0274afa223f081787726cc87e787e5f30
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/include/libsnapshot/snapshot_stats.h | 2 +-
 fs_mgr/libsnapshot/snapshot_stats.cpp                   | 9 ++++++---
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/fs_mgr/libsnapshot/include/libsnapshot/snapshot_stats.h b/fs_mgr/libsnapshot/include/libsnapshot/snapshot_stats.h
index 8a7040035281..79443b226b0c 100644
--- a/fs_mgr/libsnapshot/include/libsnapshot/snapshot_stats.h
+++ b/fs_mgr/libsnapshot/include/libsnapshot/snapshot_stats.h
@@ -64,6 +64,7 @@ class SnapshotMergeStats : public ISnapshotMergeStats {
   public:
     // Not thread safe.
     static SnapshotMergeStats* GetInstance(SnapshotManager& manager);
+    SnapshotMergeStats(const std::string& path);
 
     // ISnapshotMergeStats overrides
     bool Start() override;
@@ -88,7 +89,6 @@ class SnapshotMergeStats : public ISnapshotMergeStats {
   private:
     bool ReadState();
     bool DeleteState();
-    SnapshotMergeStats(const std::string& path);
 
     std::string path_;
     SnapshotMergeReport report_;
diff --git a/fs_mgr/libsnapshot/snapshot_stats.cpp b/fs_mgr/libsnapshot/snapshot_stats.cpp
index 8e9d9c5f3bc4..e684d8798bd4 100644
--- a/fs_mgr/libsnapshot/snapshot_stats.cpp
+++ b/fs_mgr/libsnapshot/snapshot_stats.cpp
@@ -24,9 +24,12 @@ namespace android {
 namespace snapshot {
 
 SnapshotMergeStats* SnapshotMergeStats::GetInstance(SnapshotManager& parent) {
-    static SnapshotMergeStats g_instance(parent.GetMergeStateFilePath());
-    CHECK_EQ(g_instance.path_, parent.GetMergeStateFilePath());
-    return &g_instance;
+    static std::unique_ptr<SnapshotMergeStats> g_instance;
+
+    if (!g_instance || g_instance->path_ != parent.GetMergeStateFilePath()) {
+        g_instance = std::make_unique<SnapshotMergeStats>(parent.GetMergeStateFilePath());
+    }
+    return g_instance.get();
 }
 
 SnapshotMergeStats::SnapshotMergeStats(const std::string& path) : path_(path), running_(false) {}

From 84efbc566cf602e3a78be7cdf3da118c62f8203a Mon Sep 17 00:00:00 2001
From: Matt Gilbride <mattgilbride@google.com>
Date: Mon, 17 Mar 2025 12:06:35 -0700
Subject: [PATCH 1470/1487] Revert "Update trusty to use secretkeeper hal V1"

This reverts commit 7a1cf9a52d526ed265ce0a3c2ea380fb65e58bcc.

Reason for revert: Trusty prebuilt ready to use hal V2

Change-Id: Ia0a27a88ba0b1a5fbc75c1c1de060105b9a790e0
---
 trusty/secretkeeper/Android.bp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/trusty/secretkeeper/Android.bp b/trusty/secretkeeper/Android.bp
index d399bf86d005..6523edaf6942 100644
--- a/trusty/secretkeeper/Android.bp
+++ b/trusty/secretkeeper/Android.bp
@@ -27,16 +27,18 @@ rust_binary {
         "src/hal_main.rs",
     ],
     rustlibs: [
-        "android.hardware.security.secretkeeper-V1-rust",
         "libandroid_logger",
         "libauthgraph_hal",
         "libauthgraph_wire",
         "libbinder_rs",
         "liblibc",
         "liblog_rust",
-        "libsecretkeeper_hal_v1",
+        "libsecretkeeper_hal",
         "libtrusty-rs",
     ],
+    defaults: [
+        "secretkeeper_use_latest_hal_aidl_rust",
+    ],
     prefer_rlib: true,
 }
 

From 9cdca9a61d484b7defea4101c0eb3e90aff779b2 Mon Sep 17 00:00:00 2001
From: Jiyong Park <jiyong@google.com>
Date: Tue, 18 Mar 2025 13:25:29 +0900
Subject: [PATCH 1471/1487] Remove obsolete configs from fs_config.cpp

The removed lines are for configuring directories or files in the
flattened APEXes. Since flattened APEX no longer exists, these lines are
obsolete, and thus removing.

Ownership and mode of files/dirs in APEXes are configured via the
canned_fs_config files specific to the APEXes.

Bug: 402962730
Test: build the tethering APEX, check the owner ahd mode of the
for-system directory in it.

Change-Id: I58e9b67f5cedd8233e02b4d2f4d9c277d6f64f8c
---
 libcutils/fs_config.cpp | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/libcutils/fs_config.cpp b/libcutils/fs_config.cpp
index 1c66f666e9b8..0d1b7fe1203f 100644
--- a/libcutils/fs_config.cpp
+++ b/libcutils/fs_config.cpp
@@ -72,20 +72,14 @@ static const struct fs_path_config android_dirs[] = {
     { 00771, AID_SYSTEM,       AID_SYSTEM,       0, "data" },
     { 00755, AID_ROOT,         AID_SYSTEM,       0, "mnt" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "product/bin" },
-    { 00751, AID_ROOT,         AID_SHELL,        0, "product/apex/*/bin" },
     { 00777, AID_ROOT,         AID_ROOT,         0, "sdcard" },
     { 00751, AID_ROOT,         AID_SDCARD_R,     0, "storage" },
-    { 00750, AID_CLAT,         AID_SYSTEM,       0, "system/apex/com.android.tethering/bin/for-system" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "system/bin" },
     { 00755, AID_ROOT,         AID_ROOT,         0, "system/etc/ppp" },
     { 00755, AID_ROOT,         AID_SHELL,        0, "system/vendor" },
     { 00750, AID_ROOT,         AID_SHELL,        0, "system/xbin" },
-    { 00751, AID_ROOT,         AID_SHELL,        0, "system/apex/*/bin" },
-    { 00750, AID_CLAT,         AID_SYSTEM,       0, "system_ext/apex/com.android.tethering/bin/for-system" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "system_ext/bin" },
-    { 00751, AID_ROOT,         AID_SHELL,        0, "system_ext/apex/*/bin" },
     { 00751, AID_ROOT,         AID_SHELL,        0, "vendor/bin" },
-    { 00751, AID_ROOT,         AID_SHELL,        0, "vendor/apex/*/bin" },
     { 00755, AID_ROOT,         AID_SHELL,        0, "vendor" },
     {},
         // clang-format on
@@ -182,8 +176,6 @@ static const struct fs_path_config android_files[] = {
 
     // the following files have enhanced capabilities and ARE included
     // in user builds.
-    { 06755, AID_CLAT,      AID_CLAT,      0, "system/apex/com.android.tethering/bin/for-system/clatd" },
-    { 06755, AID_CLAT,      AID_CLAT,      0, "system_ext/apex/com.android.tethering/bin/for-system/clatd" },
     { 00700, AID_SYSTEM,    AID_SHELL,     CAP_MASK_LONG(CAP_BLOCK_SUSPEND),
                                               "system/bin/inputflinger" },
     { 00750, AID_ROOT,      AID_SHELL,     CAP_MASK_LONG(CAP_SETUID) |
@@ -214,23 +206,19 @@ static const struct fs_path_config android_files[] = {
     { 00644, AID_ROOT,      AID_ROOT,      0, "odm/app/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "odm/priv-app/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "product/bin/*" },
-    { 00755, AID_ROOT,      AID_SHELL,     0, "product/apex/*bin/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "product/framework/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "product/app/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "product/priv-app/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "system/bin/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "system/xbin/*" },
-    { 00755, AID_ROOT,      AID_SHELL,     0, "system/apex/*/bin/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "system/framework/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "system/app/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "system/priv-app/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "system_ext/bin/*" },
-    { 00755, AID_ROOT,      AID_SHELL,     0, "system_ext/apex/*/bin/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "system_ext/framework/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "system_ext/app/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "system_ext/priv-app/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "vendor/bin/*" },
-    { 00755, AID_ROOT,      AID_SHELL,     0, "vendor/apex/*bin/*" },
     { 00755, AID_ROOT,      AID_SHELL,     0, "vendor/xbin/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "vendor/framework/*" },
     { 00644, AID_ROOT,      AID_ROOT,      0, "vendor/app/*" },

From 0a1a8356c9477e8795d657f679e21157453a0f93 Mon Sep 17 00:00:00 2001
From: "Priyanka Advani (xWF)" <padvani@google.com>
Date: Wed, 19 Mar 2025 13:59:57 -0700
Subject: [PATCH 1472/1487] Revert^2 "Update trusty to use secretkeeper hal V1"

This reverts commit 84efbc566cf602e3a78be7cdf3da118c62f8203a.

Reason for revert: Droidmonitor created revert due to b/404901840. Will be verifying through ABTD before submission.

Change-Id: I92ac8a1868753758f082ad20fd5967da7bbb1701
---
 trusty/secretkeeper/Android.bp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/trusty/secretkeeper/Android.bp b/trusty/secretkeeper/Android.bp
index 6523edaf6942..d399bf86d005 100644
--- a/trusty/secretkeeper/Android.bp
+++ b/trusty/secretkeeper/Android.bp
@@ -27,18 +27,16 @@ rust_binary {
         "src/hal_main.rs",
     ],
     rustlibs: [
+        "android.hardware.security.secretkeeper-V1-rust",
         "libandroid_logger",
         "libauthgraph_hal",
         "libauthgraph_wire",
         "libbinder_rs",
         "liblibc",
         "liblog_rust",
-        "libsecretkeeper_hal",
+        "libsecretkeeper_hal_v1",
         "libtrusty-rs",
     ],
-    defaults: [
-        "secretkeeper_use_latest_hal_aidl_rust",
-    ],
     prefer_rlib: true,
 }
 

From 435557c989e5e32e4b3dd563dcbd8969a8d542ec Mon Sep 17 00:00:00 2001
From: Chungkai Mei <chungkai@google.com>
Date: Wed, 25 Dec 2024 06:02:16 +0000
Subject: [PATCH 1473/1487] Parallel Module Loading: Refactor threads pool and
 architecture

Instead of creating new threads in each run, reuse same threads to load the modules and we can keep the utilization of threads and cpufreq higher.

And let subthreads dedicated to loading modules in parallel or alone, main thread only needs to update independent module pool. this architecture should be simpler and more readable.

Bug: 402263126
Change-Id: If3f07a18cd7c43132ff799d32786d2466f3110f1
Signed-off-by: Chungkai Mei <chungkai@google.com>
---
 init/first_stage_init.cpp               |  18 +--
 libmodprobe/include/modprobe/modprobe.h |   8 +-
 libmodprobe/libmodprobe.cpp             | 152 +++++++++++++++---------
 3 files changed, 114 insertions(+), 64 deletions(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index 6bb0ad79df44..49af5ed5ecc4 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -211,8 +211,8 @@ std::string GetModuleLoadList(BootMode boot_mode, const std::string& dir_path) {
 }
 
 #define MODULE_BASE_DIR "/lib/modules"
-bool LoadKernelModules(BootMode boot_mode, bool want_console, bool want_parallel,
-                       int& modules_loaded) {
+bool LoadKernelModules(BootMode boot_mode, bool want_console,
+                       Modprobe::LoadParallelMode want_parallel_mode, int& modules_loaded) {
     struct utsname uts {};
     if (uname(&uts)) {
         LOG(FATAL) << "Failed to get kernel version.";
@@ -279,8 +279,9 @@ bool LoadKernelModules(BootMode boot_mode, bool want_console, bool want_parallel
     }
 
     Modprobe m({MODULE_BASE_DIR}, GetModuleLoadList(boot_mode, MODULE_BASE_DIR));
-    bool retval = (want_parallel) ? m.LoadModulesParallel(std::thread::hardware_concurrency())
-                                  : m.LoadListedModules(!want_console);
+    bool retval = (want_parallel_mode != Modprobe::LoadParallelMode::NONE) ?
+            m.LoadModulesParallel(std::thread::hardware_concurrency(), want_parallel_mode) :
+            m.LoadListedModules(!want_console);
     modules_loaded = m.GetModuleCount();
     if (modules_loaded > 0) {
         LOG(INFO) << "Loaded " << modules_loaded << " modules from " << MODULE_BASE_DIR;
@@ -437,14 +438,15 @@ int FirstStageMain(int argc, char** argv) {
     }
 
     auto want_console = ALLOW_FIRST_STAGE_CONSOLE ? FirstStageConsole(cmdline, bootconfig) : 0;
-    auto want_parallel =
-            bootconfig.find("androidboot.load_modules_parallel = \"true\"") != std::string::npos;
+    auto want_parallel_mode = Modprobe::LoadParallelMode::NONE;
+    if (bootconfig.find("androidboot.load_modules_parallel = \"true\"")
+        != std::string::npos)
+        want_parallel_mode = Modprobe::LoadParallelMode::NORMAL;
 
     boot_clock::time_point module_start_time = boot_clock::now();
     int module_count = 0;
     BootMode boot_mode = GetBootMode(cmdline, bootconfig);
-    if (!LoadKernelModules(boot_mode, want_console,
-                           want_parallel, module_count)) {
+    if (!LoadKernelModules(boot_mode, want_console, want_parallel_mode, module_count)) {
         if (want_console != FirstStageConsoleParam::DISABLED) {
             LOG(ERROR) << "Failed to load kernel modules, starting console";
         } else {
diff --git a/libmodprobe/include/modprobe/modprobe.h b/libmodprobe/include/modprobe/modprobe.h
index d33e17dddef0..de9dcd2a7a3d 100644
--- a/libmodprobe/include/modprobe/modprobe.h
+++ b/libmodprobe/include/modprobe/modprobe.h
@@ -28,10 +28,15 @@
 
 class Modprobe {
   public:
+    enum LoadParallelMode {
+      NONE = 0,
+      NORMAL,
+    };
+
     Modprobe(const std::vector<std::string>&, const std::string load_file = "modules.load",
              bool use_blocklist = true);
 
-    bool LoadModulesParallel(int num_threads);
+    bool LoadModulesParallel(int num_threads, int mode);
     bool LoadListedModules(bool strict = true);
     bool LoadWithAliases(const std::string& module_name, bool strict,
                          const std::string& parameters = "");
@@ -45,6 +50,7 @@ class Modprobe {
     bool IsBlocklisted(const std::string& module_name);
 
   private:
+    bool IsLoadSequential(const std::string& module);
     std::string MakeCanonical(const std::string& module_path);
     bool InsmodWithDeps(const std::string& module_name, const std::string& parameters);
     bool Insmod(const std::string& path_name, const std::string& parameters);
diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index bdd114c4b798..1b524e9c97bb 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -24,6 +24,7 @@
 #include <sys/wait.h>
 
 #include <algorithm>
+#include <condition_variable>
 #include <map>
 #include <set>
 #include <string>
@@ -506,9 +507,18 @@ bool Modprobe::IsBlocklisted(const std::string& module_name) {
 // repeat these steps until all modules are loaded.
 // Discard all blocklist.
 // Softdeps are taken care in InsmodWithDeps().
-bool Modprobe::LoadModulesParallel(int num_threads) {
-    bool ret = true;
-    std::map<std::string, std::vector<std::string>> mod_with_deps;
+bool Modprobe::LoadModulesParallel(int num_threads, int mode) {
+    std::map<std::string, std::vector<std::string>> mods_with_deps;
+    std::unordered_set<std::string> mods_loading;
+    std::vector<std::string> parallel_modules, sequential_modules;
+    std::vector<std::thread> threads;
+    std::atomic<bool> ret(true);
+    std::atomic<bool> finish(false);
+    std::mutex mods_to_load_lock;
+    std::condition_variable cv_update_module, cv_load_module;
+    int sleeping_threads = 0;
+
+    LOG(INFO) << "LoadParallelMode:" << mode;
 
     // Get dependencies
     for (const auto& module : module_load_) {
@@ -517,22 +527,59 @@ bool Modprobe::LoadModulesParallel(int num_threads) {
             LOG(VERBOSE) << "LMP: Blocklist: Module " << module << " skipping...";
             continue;
         }
+
         auto dependencies = GetDependencies(MakeCanonical(module));
         if (dependencies.empty()) {
             LOG(ERROR) << "LMP: Hard-dep: Module " << module
                        << " not in .dep file";
             return false;
         }
-        mod_with_deps[MakeCanonical(module)] = dependencies;
+
+        mods_with_deps[MakeCanonical(module)] = dependencies;
     }
 
-    while (!mod_with_deps.empty()) {
-        std::vector<std::thread> threads;
-        std::vector<std::string> mods_path_to_load;
-        std::mutex vector_lock;
+    // Consumers load modules in parallel or sequentially
+    auto thread_function = [&] {
+        while (!mods_with_deps.empty() && ret.load()) {
+            std::unique_lock<std::mutex> lock(mods_to_load_lock);
+
+            if (sequential_modules.empty() && parallel_modules.empty()) {
+                sleeping_threads++;
+
+                if (mode == LoadParallelMode::NORMAL && sleeping_threads == num_threads)
+                    cv_update_module.notify_one();
+
+                cv_load_module.wait(lock, [&](){
+                    return !parallel_modules.empty() ||
+                           !sequential_modules.empty() ||
+                           finish.load(); });
+
+                sleeping_threads--;
+            }
+
+            while (!sequential_modules.empty()) {
+                auto mod_to_load = std::move(sequential_modules.back());
+                sequential_modules.pop_back();
+                ret.store(ret.load() && LoadWithAliases(mod_to_load, true));
+            }
+
+            if (!parallel_modules.empty()) {
+                auto mod_to_load = std::move(parallel_modules.back());
+                parallel_modules.pop_back();
+
+                lock.unlock();
+                ret.store(ret.load() && LoadWithAliases(mod_to_load, true));
+            }
+        }
+    };
+
+    std::generate_n(std::back_inserter(threads), num_threads,
+        [&] { return std::thread(thread_function); });
 
-        // Find independent modules
-        for (const auto& [it_mod, it_dep] : mod_with_deps) {
+    // Producer check there's any independent module
+    while (!mods_with_deps.empty()) {
+        std::unique_lock<std::mutex> lock(mods_to_load_lock);
+        for (const auto& [it_mod, it_dep] : mods_with_deps) {
             auto itd_last = it_dep.rbegin();
             if (itd_last == it_dep.rend())
                 continue;
@@ -542,69 +589,51 @@ bool Modprobe::LoadModulesParallel(int num_threads) {
             if (IsBlocklisted(cnd_last)) {
                 LOG(ERROR) << "LMP: Blocklist: Module-dep " << cnd_last
                            << " : failed to load module " << it_mod;
-                return false;
+                ret.store(0);
+                break;
             }
 
-            std::string str = "load_sequential=1";
-            auto it = module_options_[cnd_last].find(str);
-            if (it != std::string::npos) {
-                module_options_[cnd_last].erase(it, it + str.size());
+            if (mods_loading.find(cnd_last) == mods_loading.end()) {
+                mods_loading.insert(cnd_last);
 
-                if (!LoadWithAliases(cnd_last, true)) {
-                    return false;
-                }
-            } else {
-                if (std::find(mods_path_to_load.begin(), mods_path_to_load.end(),
-                            cnd_last) == mods_path_to_load.end()) {
-                    mods_path_to_load.emplace_back(cnd_last);
-                }
+                if (IsLoadSequential(cnd_last))
+                    sequential_modules.emplace_back(cnd_last);
+                else
+                    parallel_modules.emplace_back(cnd_last);
             }
         }
 
-        // Load independent modules in parallel
-        auto thread_function = [&] {
-            std::unique_lock lk(vector_lock);
-            while (!mods_path_to_load.empty()) {
-                auto ret_load = true;
-                auto mod_to_load = std::move(mods_path_to_load.back());
-                mods_path_to_load.pop_back();
-
-                lk.unlock();
-                ret_load &= LoadWithAliases(mod_to_load, true);
-                lk.lock();
-                if (!ret_load) {
-                    ret &= ret_load;
-                }
-            }
-        };
-
-        std::generate_n(std::back_inserter(threads), num_threads,
-                        [&] { return std::thread(thread_function); });
-
-        // Wait for the threads.
-        for (auto& thread : threads) {
-            thread.join();
-        }
+        cv_load_module.notify_all();
+        cv_update_module.wait(lock, [&](){
+            return parallel_modules.empty() &&
+                   sequential_modules.empty(); });
 
-        if (!ret) return ret;
+        if (!ret.load())
+            break;
 
         std::lock_guard guard(module_loaded_lock_);
-        // Remove loaded module form mod_with_deps and soft dependencies of other modules
+        // Remove loaded module from mods_with_deps
         for (const auto& module_loaded : module_loaded_)
-            mod_with_deps.erase(module_loaded);
+            mods_with_deps.erase(module_loaded);
 
-        // Remove loaded module form dependencies of other modules which are not loaded yet
+        // Remove loaded module from dependency list
         for (const auto& module_loaded_path : module_loaded_paths_) {
-            for (auto& [mod, deps] : mod_with_deps) {
+            for (auto& [mod, deps] : mods_with_deps) {
                 auto it = std::find(deps.begin(), deps.end(), module_loaded_path);
-                if (it != deps.end()) {
+                if (it != deps.end())
                     deps.erase(it);
-                }
             }
         }
     }
 
-    return ret;
+    finish.store(true);
+    cv_load_module.notify_all();
+
+    for (auto& thread : threads) {
+        thread.join();
+    }
+
+    return ret.load();
 }
 
 bool Modprobe::LoadListedModules(bool strict) {
@@ -641,6 +670,19 @@ std::vector<std::string> Modprobe::ListModules(const std::string& pattern) {
     return rv;
 }
 
+bool Modprobe::IsLoadSequential(const std::string& module)
+{
+    std::string str = "load_sequential=1";
+    auto it = module_options_[module].find(str);
+
+    if (it != std::string::npos) {
+        module_options_[module].erase(it, it + str.size());
+        return true;
+    }
+
+    return false;
+}
+
 bool Modprobe::GetAllDependencies(const std::string& module,
                                   std::vector<std::string>* pre_dependencies,
                                   std::vector<std::string>* dependencies,

From 92ca277fb7c7c9d504ad68e415d5397d71388579 Mon Sep 17 00:00:00 2001
From: "T.J. Mercier" <tjmercier@google.com>
Date: Thu, 20 Mar 2025 15:10:04 -0700
Subject: [PATCH 1474/1487] libprocessgroup: memcg v2 default
 MaxActivationDepth = 3

Enable per-PID memcgs by default.

Vendor overrides to alternate MaxActivationDepths are supported in Android 16. Overrides to memcg v1 are also supported in Android 16. [1]

In Android 17 these overrides are not likely to be supported.

[1] https://source.android.com/docs/core/perf/cgroups#per-api-level-task-profiles

Bug: 386797284
Change-Id: Ia2107ac2244dcd9d05c918fe964529d0f83a13cf
---
 libprocessgroup/profiles/cgroups.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libprocessgroup/profiles/cgroups.json b/libprocessgroup/profiles/cgroups.json
index dbf736aa0915..e9345a531296 100644
--- a/libprocessgroup/profiles/cgroups.json
+++ b/libprocessgroup/profiles/cgroups.json
@@ -36,7 +36,7 @@
         "Controller": "memory",
         "Path": ".",
         "NeedsActivation": true,
-        "MaxActivationDepth": 0,
+        "MaxActivationDepth": 3,
         "Optional": true
       }
     ]

From 55bf2ffb3e8ee4143fe6c6bee0114cf5dfd08e8b Mon Sep 17 00:00:00 2001
From: Soichiro Fujii <soichirof@google.com>
Date: Fri, 21 Mar 2025 13:32:38 +0900
Subject: [PATCH 1475/1487] libprefetch: fix regex to match 5.x/6.x ftrace
 event format

`mm_filemap_add_to_page_cache` event has a different formatting
depending on whether the version of kernel is 5.x or 6.x.

1. 5.x has a `page=` section after inode, while 6.x does not.
2. 6.x has a `order=` section at the end, while 5.x does not.

Current regex only matches to 6.x versions, which causes `cargo test`
to fail as the test uses 5.x format for testing.

Fix the regex to match on both existing 5.x test input, and newly
added 6.x test input.

Bug: 365889232
Test: `cargo test` passes with mixed 5.x and 6.x test input
Test: on emulator with 6.6 kernel, observe that pack file is
generated correctly.

Change-Id: I869b5570e4d1cb2c155eceb3fd00c177ed4676f6
---
 init/libprefetch/prefetch/src/tracer/mem.rs | 44 ++++++++++++++-------
 1 file changed, 29 insertions(+), 15 deletions(-)

diff --git a/init/libprefetch/prefetch/src/tracer/mem.rs b/init/libprefetch/prefetch/src/tracer/mem.rs
index f69ae807b12f..42120da1bc5e 100644
--- a/init/libprefetch/prefetch/src/tracer/mem.rs
+++ b/init/libprefetch/prefetch/src/tracer/mem.rs
@@ -320,8 +320,8 @@ impl TraceLineInfo {
     // Convenience function to create regex. Used once per life of `record` but multiple times in
     // case of tests.
     pub fn get_trace_line_regex() -> Result<Regex, Error> {
-        // TODO: Fix this Regex expression for 5.15 kernels. This expression
-        // works only on 6.1+. Prior to 6.1, "<page>" was present in the output.
+        // `page=[hex]` entry exists in 5.x kernel format but not in 6.x.
+        // Conversely, `order=[digit]` entry exists in 6.x kernel format but not in 5.x.
         Regex::new(concat!(
             r"^\s+(?P<cmd_pid>\S+)",
             r"\s+(?P<cpu>\S+)",
@@ -330,9 +330,10 @@ impl TraceLineInfo {
             r"\s+mm_filemap_add_to_page_cache:",
             r"\s+dev\s+(?P<major>[0-9]+):(?P<minor>[0-9]+)",
             r"\s+ino\s+(?P<ino>\S+)",
-            //r"\s+(?P<page>\S+)",
+            r"(?:\s+(?P<page>page=\S+))?",
             r"\s+(?P<pfn>\S+)",
-            r"\s+ofs=(?P<offset>[0-9]+)"
+            r"\s+ofs=(?P<offset>[0-9]+)",
+            r"(?:\s+(?P<order>\S+))?"
         ))
         .map_err(|e| Error::Custom {
             error: format!("create regex for tracing failed with: {}", e),
@@ -682,22 +683,30 @@ mod tests {
 
     use super::*;
 
-    static TRACE_BUFFER: &str = r#"
- Settingide-502  [001] ....   484.360292: mm_filemap_add_to_page_CACHE: dev 254:6 ino cf1 page=68d477 pfn=59833 ofs=32768
- Settingide-502  [001] ....   484.360311: mm_filemap_add_to_page_cache: dev 254:6 ino cf1 page=759458 pfn=59827 ofs=57344
- BOX_ENTDED-3071 [001] ....   485.276715: mm_filemap_add_to_pag_ecache: dev 254:6 ino 1 page=00cc1c pfn=81748 ofs=13574144
- BOX_ENTDED-3071 [001] ....   485.276990: mm_filemap_add_to_page_cache: dev 254:6 ino cf2 page=36540b pfn=60952 ofs=0
- .gms.peent-843  [001] ....   485.545516: mm_filemap_add_to_page_cache: dev 254:6 ino 1 page=002e8b pfn=58928 ofs=13578240
- .gms.peent-843  [001] ....   485.545820: mm_filemap_add_to_page_cache: dev 254:6 ino cf3 page=6233ce pfn=58108 ofs=0
-      an.bg-459  [001] ....   494.029396: mm_filemap_add_to_page_cache: dev 254:3 ino 7cf page=c5b5c7 pfn=373933 ofs=1310720
-      an.bg-459  [001] ....   494.029398: mm_filemap_add_to_page_cache: dev 254:3 ino 7cf page=b8b9ec pfn=410074 ofs=1314816
-       "#;
+    static TRACE_BUFFER: &str = concat!(
+        // kernel 5.x
+        " Settingide-502  [001] ....   484.360292: mm_filemap_add_to_page_CACHE: dev 254:6 ino cf1 page=68d477 pfn=59833 ofs=32768\n",
+        " Settingide-502  [001] ....   484.360311: mm_filemap_add_to_page_cache: dev 254:6 ino cf1 page=759458 pfn=59827 ofs=57344\n",
+        " BOX_ENTDED-3071 [001] ....   485.276715: mm_filemap_add_to_pag_ecache: dev 254:6 ino 1 page=00cc1c pfn=81748 ofs=13574144\n",
+        " BOX_ENTDED-3071 [001] ....   485.276990: mm_filemap_add_to_page_cache: dev 254:6 ino cf2 page=36540b pfn=60952 ofs=0\n",
+        " .gms.peent-843  [001] ....   485.545516: mm_filemap_add_to_page_cache: dev 254:6 ino 1 page=002e8b pfn=58928 ofs=13578240\n",
+        " .gms.peent-843  [001] ....   485.545820: mm_filemap_add_to_page_cache: dev 254:6 ino cf3 page=6233ce pfn=58108 ofs=0\n",
+        "      an.bg-459  [001] ....   494.029396: mm_filemap_add_to_page_cache: dev 254:3 ino 7cf page=c5b5c7 pfn=373933 ofs=1310720\n",
+        "      an.bg-459  [001] ....   494.029398: mm_filemap_add_to_page_cache: dev 254:3 ino 7cf page=b8b9ec pfn=410074 ofs=1314816\n",
+
+        // kernel 6.x
+        " logcat-686     [006] ..... 148216.040320: mm_filemap_add_to_page_CACHE: dev 254:85 ino 3f15 pfn=0x213bc2 ofs=528384 order=0\n",
+        " logcat-686     [001] ..... 148217.776227: mm_filemap_add_to_page_cache: dev 254:85 ino 3f15 pfn=0x21d306 ofs=532480 order=0\n",
+        " logcat-686     [003] ..... 148219.044389: mm_filemap_add_to_pag_ecache: dev 254:85 ino 3f15 pfn=0x224b8d ofs=536576 order=0\n",
+        " logcat-686     [001] ..... 148220.780964: mm_filemap_add_to_page_cache: dev 254:85 ino 3f15 pfn=0x1bfe0a ofs=540672 order=0\n",
+        " logcat-686     [001] ..... 148223.046560: mm_filemap_add_to_page_cache: dev 254:85 ino 3f15 pfn=0x1f3d29 ofs=544768 order=0",
+    );
 
     fn sample_mem_traces() -> (String, Vec<Option<TraceLineInfo>>) {
         (
             TRACE_BUFFER.to_owned(),
             vec![
-                None,
+                // 5.x
                 None,
                 Some(TraceLineInfo::from_fields(254, 6, 0xcf1, 57344, 484360311000)),
                 None,
@@ -706,7 +715,12 @@ mod tests {
                 Some(TraceLineInfo::from_fields(254, 6, 0xcf3, 0, 485545820000)),
                 Some(TraceLineInfo::from_fields(254, 3, 0x7cf, 1310720, 494029396000)),
                 Some(TraceLineInfo::from_fields(254, 3, 0x7cf, 1314816, 494029398000)),
+                // 6.x
+                None,
+                Some(TraceLineInfo::from_fields(254, 85, 0x3f15, 532480, 148217776227000)),
                 None,
+                Some(TraceLineInfo::from_fields(254, 85, 0x3f15, 540672, 148220780964000)),
+                Some(TraceLineInfo::from_fields(254, 85, 0x3f15, 544768, 148223046560000)),
             ],
         )
     }

From 6f3c362bb91b52e09bd7c4b5fa6b47fa493751c9 Mon Sep 17 00:00:00 2001
From: Chungkai Mei <chungkai@google.com>
Date: Tue, 11 Mar 2025 02:48:34 +0000
Subject: [PATCH 1476/1487] Parallel Module Loading: Add performance mode

Add the performance mode. It improved parallel module loading performance by enabling the main thread to identify any new independent modules without waiting for subthreads to load all the old independent threads.

Bug: 385049709
Change-Id: I638bc2d7d8fea6457be503c2b7aecd975250835a
Signed-off-by: Chungkai Mei <chungkai@google.com>
---
 init/first_stage_init.cpp               | 3 +++
 libmodprobe/include/modprobe/modprobe.h | 1 +
 libmodprobe/libmodprobe.cpp             | 4 +++-
 3 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index 49af5ed5ecc4..749266e35b9f 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -442,6 +442,9 @@ int FirstStageMain(int argc, char** argv) {
     if (bootconfig.find("androidboot.load_modules_parallel = \"true\"")
         != std::string::npos)
         want_parallel_mode = Modprobe::LoadParallelMode::NORMAL;
+    else if (bootconfig.find("androidboot.load_modules_parallel_mode = \"performance\"")
+        != std::string::npos)
+        want_parallel_mode = Modprobe::LoadParallelMode::PERFORMANCE;
 
     boot_clock::time_point module_start_time = boot_clock::now();
     int module_count = 0;
diff --git a/libmodprobe/include/modprobe/modprobe.h b/libmodprobe/include/modprobe/modprobe.h
index de9dcd2a7a3d..2d5145c66e1c 100644
--- a/libmodprobe/include/modprobe/modprobe.h
+++ b/libmodprobe/include/modprobe/modprobe.h
@@ -31,6 +31,7 @@ class Modprobe {
     enum LoadParallelMode {
       NONE = 0,
       NORMAL,
+      PERFORMANCE,
     };
 
     Modprobe(const std::vector<std::string>&, const std::string load_file = "modules.load",
diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index 1b524e9c97bb..5f3419d27da3 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -546,7 +546,9 @@ bool Modprobe::LoadModulesParallel(int num_threads, int mode) {
             if (sequential_modules.empty() && parallel_modules.empty()) {
                 sleeping_threads++;
 
-                if (mode == LoadParallelMode::NORMAL && sleeping_threads == num_threads)
+                if (mode == LoadParallelMode::PERFORMANCE)
+                    cv_update_module.notify_one();
+                else if (mode == LoadParallelMode::NORMAL && sleeping_threads == num_threads)
                     cv_update_module.notify_one();
 
                 cv_load_module.wait(lock, [&](){

From a4211aeb4c6b47e9d45f5aa7b751514fc84e084b Mon Sep 17 00:00:00 2001
From: Chungkai Mei <chungkai@google.com>
Date: Mon, 10 Mar 2025 03:46:29 +0000
Subject: [PATCH 1477/1487] Parallel Module Loading: Add conservative mode

it help us to debug or load modules more conservatively.

Bug: 385049709
Change-Id: I41ebaf7298398652475918c2c3a3127c4bf6ac3f
Signed-off-by: Chungkai Mei <chungkai@google.com>
---
 init/first_stage_init.cpp               | 3 +++
 libmodprobe/include/modprobe/modprobe.h | 1 +
 libmodprobe/libmodprobe.cpp             | 6 +++++-
 3 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index 749266e35b9f..cc5f65833242 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -445,6 +445,9 @@ int FirstStageMain(int argc, char** argv) {
     else if (bootconfig.find("androidboot.load_modules_parallel_mode = \"performance\"")
         != std::string::npos)
         want_parallel_mode = Modprobe::LoadParallelMode::PERFORMANCE;
+    else if (bootconfig.find("androidboot.load_modules_parallel = \"conservative\"")
+        != std::string::npos)
+        want_parallel_mode = Modprobe::LoadParallelMode::CONSERVATIVE;
 
     boot_clock::time_point module_start_time = boot_clock::now();
     int module_count = 0;
diff --git a/libmodprobe/include/modprobe/modprobe.h b/libmodprobe/include/modprobe/modprobe.h
index 2d5145c66e1c..55931b76afd8 100644
--- a/libmodprobe/include/modprobe/modprobe.h
+++ b/libmodprobe/include/modprobe/modprobe.h
@@ -32,6 +32,7 @@ class Modprobe {
       NONE = 0,
       NORMAL,
       PERFORMANCE,
+      CONSERVATIVE,
     };
 
     Modprobe(const std::vector<std::string>&, const std::string load_file = "modules.load",
diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index 5f3419d27da3..c43ad968169a 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -548,7 +548,7 @@ bool Modprobe::LoadModulesParallel(int num_threads, int mode) {
 
                 if (mode == LoadParallelMode::PERFORMANCE)
                     cv_update_module.notify_one();
-                else if (mode == LoadParallelMode::NORMAL && sleeping_threads == num_threads)
+                else if (sleeping_threads == num_threads)
                     cv_update_module.notify_one();
 
                 cv_load_module.wait(lock, [&](){
@@ -603,6 +603,10 @@ bool Modprobe::LoadModulesParallel(int num_threads, int mode) {
                 else
                     parallel_modules.emplace_back(cnd_last);
             }
+
+            if (mode == LoadParallelMode::CONSERVATIVE &&
+                parallel_modules.size() >= num_threads)
+                break;
         }
 
         cv_load_module.notify_all();

From 23fe418cda1dbd494c230a74e017be237e6af165 Mon Sep 17 00:00:00 2001
From: Andrei Homescu <ahomescu@google.com>
Date: Mon, 25 Nov 2024 22:35:30 +0000
Subject: [PATCH 1478/1487] trusty_driver_test: Scan for new device sysfs paths

The FF-A changes add new names for the Trusty devices
(trusty-ffa and trusty-core) and expand the device hierarchy.

See https://r.android.com/3369480 and https://r.android.com/3368602
for the corresponding changes to the Trusty test-map.

Bug: 284057071
Test: adb sync data && trusty_driver_test.py
Change-Id: I509cf3a78214c3cf4a54727cc6c8d057ae2257ad
---
 trusty/test/driver/trusty_driver_test.py | 44 +++++++++++++++++-------
 1 file changed, 32 insertions(+), 12 deletions(-)

diff --git a/trusty/test/driver/trusty_driver_test.py b/trusty/test/driver/trusty_driver_test.py
index 608fd470f028..bf5e1f0d937a 100644
--- a/trusty/test/driver/trusty_driver_test.py
+++ b/trusty/test/driver/trusty_driver_test.py
@@ -31,30 +31,49 @@ def WriteFile(file_path, s):
 def IsTrustySupported():
     return os.path.exists("/dev/trusty-ipc-dev0")
 
+def MatchTrustyDevice(de: os.DirEntry, suffix: str):
+    for core in ["-core", ""]:
+        candidate = f":trusty{core}{suffix}"
+        if de.name == candidate[1:]:
+            return de
+        if de.name.endswith(candidate):
+            return de
+
+    return None
+
+def FindTrustyDevice(suffix: str):
+    with os.scandir("/sys/bus/platform/devices") as it:
+        candidates = (MatchTrustyDevice(de, suffix) for de in it)
+        final = (de.name for de in candidates if de is not None)
+        return next(final)
+
 @unittest.skipIf(not IsTrustySupported(), "Device does not support Trusty")
 class TrustyDriverTest(unittest.TestCase):
     def testIrqDriverBinding(self):
-        WriteFile("/sys/bus/platform/drivers/trusty-irq/unbind", "trusty:irq")
-        WriteFile("/sys/bus/platform/drivers/trusty-irq/bind", "trusty:irq")
+        dev = FindTrustyDevice(":irq")
+        WriteFile("/sys/bus/platform/drivers/trusty-irq/unbind", dev)
+        WriteFile("/sys/bus/platform/drivers/trusty-irq/bind", dev)
 
     def testLogDriverBinding(self):
-        WriteFile("/sys/bus/platform/drivers/trusty-log/unbind", "trusty:log")
-        WriteFile("/sys/bus/platform/drivers/trusty-log/bind", "trusty:log")
+        dev = FindTrustyDevice(":log")
+        WriteFile("/sys/bus/platform/drivers/trusty-log/unbind", dev)
+        WriteFile("/sys/bus/platform/drivers/trusty-log/bind", dev)
 
     @unittest.skip("TODO(b/142275662): virtio remove currently hangs")
     def testVirtioDriverBinding(self):
-        WriteFile("/sys/bus/platform/drivers/trusty-virtio/unbind",
-                  "trusty:virtio")
-        WriteFile("/sys/bus/platform/drivers/trusty-virtio/bind",
-                  "trusty:virtio")
+        dev = FindTrustyDevice(":virtio")
+        WriteFile("/sys/bus/platform/drivers/trusty-virtio/unbind", dev)
+        WriteFile("/sys/bus/platform/drivers/trusty-virtio/bind", dev)
 
     @unittest.skip("TODO(b/142275662): virtio remove currently hangs")
     def testTrustyDriverBinding(self):
-        WriteFile("/sys/bus/platform/drivers/trusty/unbind", "trusty")
-        WriteFile("/sys/bus/platform/drivers/trusty/bind", "trusty")
+        dev = FindTrustyDevice("")
+        WriteFile("/sys/bus/platform/drivers/trusty/unbind", dev)
+        WriteFile("/sys/bus/platform/drivers/trusty/bind", dev)
 
     def testTrustyDriverVersion(self):
-        ver = ReadFile("/sys/bus/platform/devices/trusty/trusty_version")
+        dev = FindTrustyDevice("")
+        ver = ReadFile(f"/sys/bus/platform/devices/{dev}/trusty_version")
         self.assertTrue(ver.startswith("Project:"))
 
     def testUntaintedLinux(self):
@@ -73,7 +92,8 @@ def testUntaintedLinux(self):
     # Test 10 4K shared memory objects, shared 10 times, each accessed
     # 10 times.
     def testStdCall(self):
-        test = "/sys/devices/platform/trusty/trusty:test/trusty_test_run"
+        dev = FindTrustyDevice(":test")
+        test = f"/sys/bus/platform/devices/{dev}/trusty_test_run"
         args = "0x1000 0x800000,10,2,2 0x800000,2,100,0 0x1000,10,10,10"
         WriteFile(test, args)
 

From afc80f06f2e2be08deaea472334900706bc9ce6f Mon Sep 17 00:00:00 2001
From: Andrei Homescu <ahomescu@google.com>
Date: Mon, 24 Mar 2025 23:39:09 +0000
Subject: [PATCH 1479/1487] trusty_driver_test: Filter out some tainted bits

Filter out the out-of-tree and unsigned module bits
because our CI builds always have one or both of those.

Bug: 284057071
Test: adb shell /.../trusty_driver_test
Change-Id: I2c736fbb413b44d82558e71e2a8eac66e69cbdee
---
 trusty/test/driver/trusty_driver_test.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/trusty/test/driver/trusty_driver_test.py b/trusty/test/driver/trusty_driver_test.py
index bf5e1f0d937a..d86b48b60019 100644
--- a/trusty/test/driver/trusty_driver_test.py
+++ b/trusty/test/driver/trusty_driver_test.py
@@ -77,8 +77,10 @@ def testTrustyDriverVersion(self):
         self.assertTrue(ver.startswith("Project:"))
 
     def testUntaintedLinux(self):
-        tainted = ReadFile("/proc/sys/kernel/tainted")
-        self.assertEqual(tainted, "0")
+        tainted = int(ReadFile("/proc/sys/kernel/tainted"))
+        # Filter out the out-of-tree and unsigned module bits
+        tainted &= ~0x3000
+        self.assertEqual(tainted, 0)
 
     # stdcall test with shared memory buffers.
     # Each test run takes up to 4 arguments:

From 0455ecee35417d8405e031b9ed37e508e4bd8fd5 Mon Sep 17 00:00:00 2001
From: Chungkai Mei <chungkai@google.com>
Date: Tue, 25 Mar 2025 08:30:56 +0000
Subject: [PATCH 1480/1487] Parallel module loading: Fix typo and simplify
 logic

Remove redundant `find()` call as `insert()` performs an internal search and use `load_modules_parallel` directly for all mode selection.

Bug: 402263126
Change-Id: Ib87d45843fe34df41eee33fdc72179c964061c73
Signed-off-by: Chungkai Mei <chungkai@google.com>
---
 init/first_stage_init.cpp   | 2 +-
 libmodprobe/libmodprobe.cpp | 4 +---
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index cc5f65833242..97e072be869a 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -442,7 +442,7 @@ int FirstStageMain(int argc, char** argv) {
     if (bootconfig.find("androidboot.load_modules_parallel = \"true\"")
         != std::string::npos)
         want_parallel_mode = Modprobe::LoadParallelMode::NORMAL;
-    else if (bootconfig.find("androidboot.load_modules_parallel_mode = \"performance\"")
+    else if (bootconfig.find("androidboot.load_modules_parallel = \"performance\"")
         != std::string::npos)
         want_parallel_mode = Modprobe::LoadParallelMode::PERFORMANCE;
     else if (bootconfig.find("androidboot.load_modules_parallel = \"conservative\"")
diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index c43ad968169a..2fe77a08fb45 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -595,9 +595,7 @@ bool Modprobe::LoadModulesParallel(int num_threads, int mode) {
                 break;
             }
 
-            if (mods_loading.find(cnd_last) == mods_loading.end()) {
-                mods_loading.insert(cnd_last);
-
+            if (mods_loading.insert(cnd_last).second) {
                 if (IsLoadSequential(cnd_last))
                     sequential_modules.emplace_back(cnd_last);
                 else

From 547dc31c6df75c468f652a349cb32d9788a4bb54 Mon Sep 17 00:00:00 2001
From: Sandeep Dhavale <dhavale@google.com>
Date: Tue, 25 Mar 2025 13:25:57 -0700
Subject: [PATCH 1481/1487] create_snapshot: improve copy operation by
 reordering

Sort the copy blocks so consecutive target blocks can be together.

Fix WriteOrderedSnapshots() to go through copy operations
using topological sort and re-order them so we can maximize
copy operations and reduce the replace operations further.

If we detect the cycles in dependency, convert only those blocks
to replace blocks.

Test: create_snapshot on 2 builds before and after, patch size reduced
by 10x (~900MB -> ~90MB).

Bug: 401284556

Change-Id: I4aaa02849164575d1a4dbf1578cdfc1627230c5c
Signed-off-by: Sandeep Dhavale <dhavale@google.com>
---
 .../libsnapshot_cow/cow_reader.cpp            |  2 +-
 .../libsnapshot_cow/create_cow.cpp            | 80 +++++++++++++++----
 2 files changed, 65 insertions(+), 17 deletions(-)

diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
index 127735d0147b..a2a602ae9a35 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
@@ -468,7 +468,7 @@ bool CowReader::VerifyMergeOps() {
         if (overwritten_blocks.count(block)) {
             overwrite = overwritten_blocks[block];
             LOG(ERROR) << "Invalid Sequence! Block needed for op:\n"
-                       << op << "\noverwritten by previously merged op:\n"
+                       << *op << "\noverwritten by previously merged op:\n"
                        << *overwrite;
         }
         if (misaligned && overwritten_blocks.count(block + 1)) {
diff --git a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
index b15e6ab9cbf4..eadfda8f2017 100644
--- a/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
+++ b/fs_mgr/libsnapshot/libsnapshot_cow/create_cow.cpp
@@ -376,29 +376,77 @@ bool CreateSnapshot::WriteNonOrderedSnapshots() {
     }
     return true;
 }
-
 bool CreateSnapshot::WriteOrderedSnapshots() {
-    std::unordered_map<uint64_t, uint64_t> overwritten_blocks;
-    std::vector<std::pair<uint64_t, uint64_t>> merge_sequence;
-    for (auto it = copy_blocks_.begin(); it != copy_blocks_.end(); it++) {
-        if (overwritten_blocks.count(it->second)) {
-            replace_blocks_.push_back(it->first);
-            continue;
+    // Sort copy_blocks_ by target block index so consecutive
+    // target blocks can be together
+    std::vector<std::pair<uint64_t, uint64_t>> sorted_copy_blocks_(copy_blocks_.begin(),
+                                                                   copy_blocks_.end());
+    std::sort(sorted_copy_blocks_.begin(), sorted_copy_blocks_.end());
+    std::unordered_map<uint64_t, std::vector<uint64_t>> dependency_graph;
+    std::unordered_map<uint64_t, int> in_degree;
+
+    // Initialize in-degree and build the dependency graph
+    for (const auto& [target, source] : sorted_copy_blocks_) {
+        in_degree[target] = 0;
+        if (copy_blocks_.count(source)) {
+            // this source block itself gets modified
+            dependency_graph[source].push_back(target);
+            in_degree[target]++;
         }
-        overwritten_blocks[it->first] = it->second;
-        merge_sequence.emplace_back(std::make_pair(it->first, it->second));
     }
-    // Sort the blocks so that if the blocks are contiguous, it would help
-    // compress multiple blocks in one shot based on the compression factor.
-    std::sort(replace_blocks_.begin(), replace_blocks_.end());
 
-    copy_ops_ = merge_sequence.size();
-    for (auto it = merge_sequence.begin(); it != merge_sequence.end(); it++) {
-        if (!writer_->AddCopy(it->first, it->second, 1)) {
-            return false;
+    std::vector<uint64_t> ordered_copy_ops_;
+    std::deque<uint64_t> queue;
+
+    // Add nodes with in-degree 0 (no dependency) to the queue
+    for (const auto& [target, degree] : in_degree) {
+        if (degree == 0) {
+            queue.push_back(target);
+        }
+    }
+
+    while (!queue.empty()) {
+        uint64_t current_target = queue.front();
+        queue.pop_front();
+        ordered_copy_ops_.push_back(current_target);
+
+        if (dependency_graph.count(current_target)) {
+            for (uint64_t neighbor : dependency_graph[current_target]) {
+                in_degree[neighbor]--;
+                if (in_degree[neighbor] == 0) {
+                    queue.push_back(neighbor);
+                }
+            }
+        }
+    }
+
+    // Detect cycles and change those blocks to replace blocks
+    if (ordered_copy_ops_.size() != copy_blocks_.size()) {
+        LOG(INFO) << "Cycle detected in copy operations! Converting some to replace.";
+        std::unordered_set<uint64_t> safe_targets_(ordered_copy_ops_.begin(),
+                                                   ordered_copy_ops_.end());
+        for (const auto& [target, source] : copy_blocks_) {
+            if (safe_targets_.find(target) == safe_targets_.end()) {
+                replace_blocks_.push_back(target);
+                copy_blocks_.erase(target);
+            }
         }
     }
 
+    std::reverse(ordered_copy_ops_.begin(), ordered_copy_ops_.end());
+    // Add the copy blocks
+    copy_ops_ = 0;
+    for (uint64_t target : ordered_copy_ops_) {
+        LOG(DEBUG) << "copy target: " << target << " source: " << copy_blocks_[target];
+        if (!writer_->AddCopy(target, copy_blocks_[target], 1)) {
+            return false;
+        }
+        copy_ops_++;
+    }
+    // Sort the blocks so that if the blocks are contiguous, it would help
+    // compress multiple blocks in one shot based on the compression factor.
+    std::sort(replace_blocks_.begin(), replace_blocks_.end());
+    LOG(DEBUG) << "Total copy ops: " << copy_ops_;
     return true;
 }
 

From 2a9a6b56a9df84c27f6df5aeebe8a8b9f36ff452 Mon Sep 17 00:00:00 2001
From: Junichi Uekawa <uekawa@google.com>
Date: Fri, 14 Mar 2025 11:33:41 +0900
Subject: [PATCH 1482/1487] init: flush ext4 file system on shutdown

Previously, only f2fs /data filesystems were shutdown using the
F2FS_IOC_SHUTDOWN ioctl. This change adds support for shutting down ext4
/data filesystem with the EXT4_IOC_SHUTDOWN ioctl.

Bug: 403381187
Test: Verify /data was clean after reboot on desktop
Test: Verify e2fsck returns immediately when booting on desktop

Change-Id: I08208888d839649efe54fcab5d73177e9e06ec88
---
 init/reboot.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/init/reboot.cpp b/init/reboot.cpp
index a26149f77e16..3b81cb5f7d6a 100644
--- a/init/reboot.cpp
+++ b/init/reboot.cpp
@@ -18,6 +18,7 @@
 
 #include <dirent.h>
 #include <fcntl.h>
+#include <linux/ext4.h>
 #include <linux/f2fs.h>
 #include <linux/fs.h>
 #include <linux/loop.h>
@@ -835,6 +836,15 @@ static void DoReboot(unsigned int cmd, const std::string& reason, const std::str
         } else {
             LOG(INFO) << "Shutdown /data";
         }
+    } else if (IsDataMounted("ext4")) {
+        uint32_t flag = EXT4_GOING_FLAGS_DEFAULT;
+        unique_fd fd(TEMP_FAILURE_RETRY(open("/data", O_RDONLY)));
+        int ret = ioctl(fd.get(), EXT4_IOC_SHUTDOWN, &flag);
+        if (ret) {
+            PLOG(ERROR) << "Shutdown /data: ";
+        } else {
+            LOG(INFO) << "Shutdown /data";
+        }
     }
     RebootSystem(cmd, reboot_target, reason);
     abort();

From 700dee8abc8a70549665ca58980b41918be09a30 Mon Sep 17 00:00:00 2001
From: Akilesh Kailash <akailash@google.com>
Date: Tue, 25 Mar 2025 21:40:49 -0700
Subject: [PATCH 1483/1487] snapshotctl: Check for empty directory

Test: snapshotctl apply-update <empty-directory>
Change-Id: Ieda5fe24b74182cdebf9f2c6c0c0a455cd8bfcc7
Signed-off-by: Akilesh Kailash <akailash@google.com>
---
 fs_mgr/libsnapshot/snapshotctl.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/fs_mgr/libsnapshot/snapshotctl.cpp b/fs_mgr/libsnapshot/snapshotctl.cpp
index 32c8e37612f7..454ff5e00e84 100644
--- a/fs_mgr/libsnapshot/snapshotctl.cpp
+++ b/fs_mgr/libsnapshot/snapshotctl.cpp
@@ -649,6 +649,12 @@ bool ApplyUpdate(int argc, char** argv) {
             metadata_on_super = true;
         }
     }
+
+    if (!std::filesystem::exists(path) || std::filesystem::is_empty(path)) {
+        LOG(ERROR) << path << " doesn't exist";
+        return false;
+    }
+
     MapSnapshots cow(path, metadata_on_super);
     if (!cow.ApplyUpdate()) {
         return false;
@@ -921,6 +927,11 @@ bool MapPrecreatedSnapshots(int argc, char** argv) {
     std::string path = std::string(argv[2]);
     std::vector<std::string> patchfiles;
 
+    if (!std::filesystem::exists(path) || std::filesystem::is_empty(path)) {
+        LOG(ERROR) << path << " doesn't exist";
+        return false;
+    }
+
     for (const auto& entry : std::filesystem::directory_iterator(path)) {
         if (android::base::EndsWith(entry.path().generic_string(), ".patch")) {
             patchfiles.push_back(android::base::Basename(entry.path().generic_string()));

From e5777c3a470c9383dba70769e1b891c26d751eb9 Mon Sep 17 00:00:00 2001
From: "Chung-Kai (Michael) Mei" <chungkai@google.com>
Date: Wed, 26 Mar 2025 01:54:29 -0700
Subject: [PATCH 1484/1487] Revert "Parallel module loading: Fix typo and
 simplify logic"

This reverts commit 0455ecee35417d8405e031b9ed37e508e4bd8fd5.

Reason for revert: stability issue

Bug: 406160196
Change-Id: Ia452e970add145a2a9bd6d4ea56455756c411cec
---
 init/first_stage_init.cpp   | 2 +-
 libmodprobe/libmodprobe.cpp | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index 97e072be869a..cc5f65833242 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -442,7 +442,7 @@ int FirstStageMain(int argc, char** argv) {
     if (bootconfig.find("androidboot.load_modules_parallel = \"true\"")
         != std::string::npos)
         want_parallel_mode = Modprobe::LoadParallelMode::NORMAL;
-    else if (bootconfig.find("androidboot.load_modules_parallel = \"performance\"")
+    else if (bootconfig.find("androidboot.load_modules_parallel_mode = \"performance\"")
         != std::string::npos)
         want_parallel_mode = Modprobe::LoadParallelMode::PERFORMANCE;
     else if (bootconfig.find("androidboot.load_modules_parallel = \"conservative\"")
diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index 2fe77a08fb45..c43ad968169a 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -595,7 +595,9 @@ bool Modprobe::LoadModulesParallel(int num_threads, int mode) {
                 break;
             }
 
-            if (mods_loading.insert(cnd_last).second) {
+            if (mods_loading.find(cnd_last) == mods_loading.end()) {
+                mods_loading.insert(cnd_last);
+
                 if (IsLoadSequential(cnd_last))
                     sequential_modules.emplace_back(cnd_last);
                 else

From 3a3df3dcaa4610428c9e04db2b2a1a4212eac7f4 Mon Sep 17 00:00:00 2001
From: "Chung-Kai (Michael) Mei" <chungkai@google.com>
Date: Wed, 26 Mar 2025 01:55:44 -0700
Subject: [PATCH 1485/1487] Revert "Parallel Module Loading: Add conservative
 mode"

Revert submission 3556468

Reason for revert: stability issue

Reverted changes: /q/submissionid:3556468

Bug: 406160196
Change-Id: Ic3d2c950249ed745134761bb43cd3eeb5889b303
---
 init/first_stage_init.cpp               | 3 ---
 libmodprobe/include/modprobe/modprobe.h | 1 -
 libmodprobe/libmodprobe.cpp             | 6 +-----
 3 files changed, 1 insertion(+), 9 deletions(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index cc5f65833242..749266e35b9f 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -445,9 +445,6 @@ int FirstStageMain(int argc, char** argv) {
     else if (bootconfig.find("androidboot.load_modules_parallel_mode = \"performance\"")
         != std::string::npos)
         want_parallel_mode = Modprobe::LoadParallelMode::PERFORMANCE;
-    else if (bootconfig.find("androidboot.load_modules_parallel = \"conservative\"")
-        != std::string::npos)
-        want_parallel_mode = Modprobe::LoadParallelMode::CONSERVATIVE;
 
     boot_clock::time_point module_start_time = boot_clock::now();
     int module_count = 0;
diff --git a/libmodprobe/include/modprobe/modprobe.h b/libmodprobe/include/modprobe/modprobe.h
index 55931b76afd8..2d5145c66e1c 100644
--- a/libmodprobe/include/modprobe/modprobe.h
+++ b/libmodprobe/include/modprobe/modprobe.h
@@ -32,7 +32,6 @@ class Modprobe {
       NONE = 0,
       NORMAL,
       PERFORMANCE,
-      CONSERVATIVE,
     };
 
     Modprobe(const std::vector<std::string>&, const std::string load_file = "modules.load",
diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index c43ad968169a..5f3419d27da3 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -548,7 +548,7 @@ bool Modprobe::LoadModulesParallel(int num_threads, int mode) {
 
                 if (mode == LoadParallelMode::PERFORMANCE)
                     cv_update_module.notify_one();
-                else if (sleeping_threads == num_threads)
+                else if (mode == LoadParallelMode::NORMAL && sleeping_threads == num_threads)
                     cv_update_module.notify_one();
 
                 cv_load_module.wait(lock, [&](){
@@ -603,10 +603,6 @@ bool Modprobe::LoadModulesParallel(int num_threads, int mode) {
                 else
                     parallel_modules.emplace_back(cnd_last);
             }
-
-            if (mode == LoadParallelMode::CONSERVATIVE &&
-                parallel_modules.size() >= num_threads)
-                break;
         }
 
         cv_load_module.notify_all();

From 0f62f623fb06724ad8792eac99651f670b1fa7d3 Mon Sep 17 00:00:00 2001
From: "Chung-Kai (Michael) Mei" <chungkai@google.com>
Date: Wed, 26 Mar 2025 01:55:44 -0700
Subject: [PATCH 1486/1487] Revert "Parallel Module Loading: Add performance
 mode"

Revert submission 3556468

Reason for revert: stability issue

Reverted changes: /q/submissionid:3556468

Bug: 406160196
Change-Id: I5566ccde4003b674bad51d4f8f449090fb890f67
---
 init/first_stage_init.cpp               | 3 ---
 libmodprobe/include/modprobe/modprobe.h | 1 -
 libmodprobe/libmodprobe.cpp             | 4 +---
 3 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index 749266e35b9f..49af5ed5ecc4 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -442,9 +442,6 @@ int FirstStageMain(int argc, char** argv) {
     if (bootconfig.find("androidboot.load_modules_parallel = \"true\"")
         != std::string::npos)
         want_parallel_mode = Modprobe::LoadParallelMode::NORMAL;
-    else if (bootconfig.find("androidboot.load_modules_parallel_mode = \"performance\"")
-        != std::string::npos)
-        want_parallel_mode = Modprobe::LoadParallelMode::PERFORMANCE;
 
     boot_clock::time_point module_start_time = boot_clock::now();
     int module_count = 0;
diff --git a/libmodprobe/include/modprobe/modprobe.h b/libmodprobe/include/modprobe/modprobe.h
index 2d5145c66e1c..de9dcd2a7a3d 100644
--- a/libmodprobe/include/modprobe/modprobe.h
+++ b/libmodprobe/include/modprobe/modprobe.h
@@ -31,7 +31,6 @@ class Modprobe {
     enum LoadParallelMode {
       NONE = 0,
       NORMAL,
-      PERFORMANCE,
     };
 
     Modprobe(const std::vector<std::string>&, const std::string load_file = "modules.load",
diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index 5f3419d27da3..1b524e9c97bb 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -546,9 +546,7 @@ bool Modprobe::LoadModulesParallel(int num_threads, int mode) {
             if (sequential_modules.empty() && parallel_modules.empty()) {
                 sleeping_threads++;
 
-                if (mode == LoadParallelMode::PERFORMANCE)
-                    cv_update_module.notify_one();
-                else if (mode == LoadParallelMode::NORMAL && sleeping_threads == num_threads)
+                if (mode == LoadParallelMode::NORMAL && sleeping_threads == num_threads)
                     cv_update_module.notify_one();
 
                 cv_load_module.wait(lock, [&](){

From 58473c253f53f6d32f8749494400f3f293baf6b3 Mon Sep 17 00:00:00 2001
From: "Chung-Kai (Michael) Mei" <chungkai@google.com>
Date: Wed, 26 Mar 2025 02:05:00 -0700
Subject: [PATCH 1487/1487] Revert "Parallel Module Loading: Refactor threads
 pool and architecture"

This reverts commit 435557c989e5e32e4b3dd563dcbd8969a8d542ec.

Reason for revert: stability issue
Bug: 406160196

Change-Id: Ic84dc4f6189f8950c73620a709e1ccceceb94faf
---
 init/first_stage_init.cpp               |  18 ++-
 libmodprobe/include/modprobe/modprobe.h |   8 +-
 libmodprobe/libmodprobe.cpp             | 152 +++++++++---------------
 3 files changed, 64 insertions(+), 114 deletions(-)

diff --git a/init/first_stage_init.cpp b/init/first_stage_init.cpp
index 49af5ed5ecc4..6bb0ad79df44 100644
--- a/init/first_stage_init.cpp
+++ b/init/first_stage_init.cpp
@@ -211,8 +211,8 @@ std::string GetModuleLoadList(BootMode boot_mode, const std::string& dir_path) {
 }
 
 #define MODULE_BASE_DIR "/lib/modules"
-bool LoadKernelModules(BootMode boot_mode, bool want_console,
-                       Modprobe::LoadParallelMode want_parallel_mode, int& modules_loaded) {
+bool LoadKernelModules(BootMode boot_mode, bool want_console, bool want_parallel,
+                       int& modules_loaded) {
     struct utsname uts {};
     if (uname(&uts)) {
         LOG(FATAL) << "Failed to get kernel version.";
@@ -279,9 +279,8 @@ bool LoadKernelModules(BootMode boot_mode, bool want_console,
     }
 
     Modprobe m({MODULE_BASE_DIR}, GetModuleLoadList(boot_mode, MODULE_BASE_DIR));
-    bool retval = (want_parallel_mode != Modprobe::LoadParallelMode::NONE) ?
-            m.LoadModulesParallel(std::thread::hardware_concurrency(), want_parallel_mode) :
-            m.LoadListedModules(!want_console);
+    bool retval = (want_parallel) ? m.LoadModulesParallel(std::thread::hardware_concurrency())
+                                  : m.LoadListedModules(!want_console);
     modules_loaded = m.GetModuleCount();
     if (modules_loaded > 0) {
         LOG(INFO) << "Loaded " << modules_loaded << " modules from " << MODULE_BASE_DIR;
@@ -438,15 +437,14 @@ int FirstStageMain(int argc, char** argv) {
     }
 
     auto want_console = ALLOW_FIRST_STAGE_CONSOLE ? FirstStageConsole(cmdline, bootconfig) : 0;
-    auto want_parallel_mode = Modprobe::LoadParallelMode::NONE;
-    if (bootconfig.find("androidboot.load_modules_parallel = \"true\"")
-        != std::string::npos)
-        want_parallel_mode = Modprobe::LoadParallelMode::NORMAL;
+    auto want_parallel =
+            bootconfig.find("androidboot.load_modules_parallel = \"true\"") != std::string::npos;
 
     boot_clock::time_point module_start_time = boot_clock::now();
     int module_count = 0;
     BootMode boot_mode = GetBootMode(cmdline, bootconfig);
-    if (!LoadKernelModules(boot_mode, want_console, want_parallel_mode, module_count)) {
+    if (!LoadKernelModules(boot_mode, want_console,
+                           want_parallel, module_count)) {
         if (want_console != FirstStageConsoleParam::DISABLED) {
             LOG(ERROR) << "Failed to load kernel modules, starting console";
         } else {
diff --git a/libmodprobe/include/modprobe/modprobe.h b/libmodprobe/include/modprobe/modprobe.h
index de9dcd2a7a3d..d33e17dddef0 100644
--- a/libmodprobe/include/modprobe/modprobe.h
+++ b/libmodprobe/include/modprobe/modprobe.h
@@ -28,15 +28,10 @@
 
 class Modprobe {
   public:
-    enum LoadParallelMode {
-      NONE = 0,
-      NORMAL,
-    };
-
     Modprobe(const std::vector<std::string>&, const std::string load_file = "modules.load",
              bool use_blocklist = true);
 
-    bool LoadModulesParallel(int num_threads, int mode);
+    bool LoadModulesParallel(int num_threads);
     bool LoadListedModules(bool strict = true);
     bool LoadWithAliases(const std::string& module_name, bool strict,
                          const std::string& parameters = "");
@@ -50,7 +45,6 @@ class Modprobe {
     bool IsBlocklisted(const std::string& module_name);
 
   private:
-    bool IsLoadSequential(const std::string& module);
     std::string MakeCanonical(const std::string& module_path);
     bool InsmodWithDeps(const std::string& module_name, const std::string& parameters);
     bool Insmod(const std::string& path_name, const std::string& parameters);
diff --git a/libmodprobe/libmodprobe.cpp b/libmodprobe/libmodprobe.cpp
index 1b524e9c97bb..bdd114c4b798 100644
--- a/libmodprobe/libmodprobe.cpp
+++ b/libmodprobe/libmodprobe.cpp
@@ -24,7 +24,6 @@
 #include <sys/wait.h>
 
 #include <algorithm>
-#include <condition_variable>
 #include <map>
 #include <set>
 #include <string>
@@ -507,18 +506,9 @@ bool Modprobe::IsBlocklisted(const std::string& module_name) {
 // repeat these steps until all modules are loaded.
 // Discard all blocklist.
 // Softdeps are taken care in InsmodWithDeps().
-bool Modprobe::LoadModulesParallel(int num_threads, int mode) {
-    std::map<std::string, std::vector<std::string>> mods_with_deps;
-    std::unordered_set<std::string> mods_loading;
-    std::vector<std::string> parallel_modules, sequential_modules;
-    std::vector<std::thread> threads;
-    std::atomic<bool> ret(true);
-    std::atomic<bool> finish(false);
-    std::mutex mods_to_load_lock;
-    std::condition_variable cv_update_module, cv_load_module;
-    int sleeping_threads = 0;
-
-    LOG(INFO) << "LoadParallelMode:" << mode;
+bool Modprobe::LoadModulesParallel(int num_threads) {
+    bool ret = true;
+    std::map<std::string, std::vector<std::string>> mod_with_deps;
 
     // Get dependencies
     for (const auto& module : module_load_) {
@@ -527,59 +517,22 @@ bool Modprobe::LoadModulesParallel(int num_threads, int mode) {
             LOG(VERBOSE) << "LMP: Blocklist: Module " << module << " skipping...";
             continue;
         }
-
         auto dependencies = GetDependencies(MakeCanonical(module));
         if (dependencies.empty()) {
             LOG(ERROR) << "LMP: Hard-dep: Module " << module
                        << " not in .dep file";
             return false;
         }
-
-        mods_with_deps[MakeCanonical(module)] = dependencies;
+        mod_with_deps[MakeCanonical(module)] = dependencies;
     }
 
-    // Consumers load modules in parallel or sequentially
-    auto thread_function = [&] {
-        while (!mods_with_deps.empty() && ret.load()) {
-            std::unique_lock<std::mutex> lock(mods_to_load_lock);
-
-            if (sequential_modules.empty() && parallel_modules.empty()) {
-                sleeping_threads++;
-
-                if (mode == LoadParallelMode::NORMAL && sleeping_threads == num_threads)
-                    cv_update_module.notify_one();
-
-                cv_load_module.wait(lock, [&](){
-                    return !parallel_modules.empty() ||
-                           !sequential_modules.empty() ||
-                           finish.load(); });
-
-                sleeping_threads--;
-            }
-
-            while (!sequential_modules.empty()) {
-                auto mod_to_load = std::move(sequential_modules.back());
-                sequential_modules.pop_back();
-                ret.store(ret.load() && LoadWithAliases(mod_to_load, true));
-            }
-
-            if (!parallel_modules.empty()) {
-                auto mod_to_load = std::move(parallel_modules.back());
-                parallel_modules.pop_back();
-
-                lock.unlock();
-                ret.store(ret.load() && LoadWithAliases(mod_to_load, true));
-            }
-        }
-    };
-
-    std::generate_n(std::back_inserter(threads), num_threads,
-        [&] { return std::thread(thread_function); });
+    while (!mod_with_deps.empty()) {
+        std::vector<std::thread> threads;
+        std::vector<std::string> mods_path_to_load;
+        std::mutex vector_lock;
 
-    // Producer check there's any independent module
-    while (!mods_with_deps.empty()) {
-        std::unique_lock<std::mutex> lock(mods_to_load_lock);
-        for (const auto& [it_mod, it_dep] : mods_with_deps) {
+        // Find independent modules
+        for (const auto& [it_mod, it_dep] : mod_with_deps) {
             auto itd_last = it_dep.rbegin();
             if (itd_last == it_dep.rend())
                 continue;
@@ -589,51 +542,69 @@ bool Modprobe::LoadModulesParallel(int num_threads, int mode) {
             if (IsBlocklisted(cnd_last)) {
                 LOG(ERROR) << "LMP: Blocklist: Module-dep " << cnd_last
                            << " : failed to load module " << it_mod;
-                ret.store(0);
-                break;
+                return false;
             }
 
-            if (mods_loading.find(cnd_last) == mods_loading.end()) {
-                mods_loading.insert(cnd_last);
+            std::string str = "load_sequential=1";
+            auto it = module_options_[cnd_last].find(str);
+            if (it != std::string::npos) {
+                module_options_[cnd_last].erase(it, it + str.size());
 
-                if (IsLoadSequential(cnd_last))
-                    sequential_modules.emplace_back(cnd_last);
-                else
-                    parallel_modules.emplace_back(cnd_last);
+                if (!LoadWithAliases(cnd_last, true)) {
+                    return false;
+                }
+            } else {
+                if (std::find(mods_path_to_load.begin(), mods_path_to_load.end(),
+                            cnd_last) == mods_path_to_load.end()) {
+                    mods_path_to_load.emplace_back(cnd_last);
+                }
             }
         }
 
-        cv_load_module.notify_all();
-        cv_update_module.wait(lock, [&](){
-            return parallel_modules.empty() &&
-                   sequential_modules.empty(); });
+        // Load independent modules in parallel
+        auto thread_function = [&] {
+            std::unique_lock lk(vector_lock);
+            while (!mods_path_to_load.empty()) {
+                auto ret_load = true;
+                auto mod_to_load = std::move(mods_path_to_load.back());
+                mods_path_to_load.pop_back();
+
+                lk.unlock();
+                ret_load &= LoadWithAliases(mod_to_load, true);
+                lk.lock();
+                if (!ret_load) {
+                    ret &= ret_load;
+                }
+            }
+        };
+
+        std::generate_n(std::back_inserter(threads), num_threads,
+                        [&] { return std::thread(thread_function); });
+
+        // Wait for the threads.
+        for (auto& thread : threads) {
+            thread.join();
+        }
 
-        if (!ret.load())
-            break;
+        if (!ret) return ret;
 
         std::lock_guard guard(module_loaded_lock_);
-        // Remove loaded module from mods_with_deps
+        // Remove loaded module form mod_with_deps and soft dependencies of other modules
         for (const auto& module_loaded : module_loaded_)
-            mods_with_deps.erase(module_loaded);
+            mod_with_deps.erase(module_loaded);
 
-        // Remove loaded module from dependency list
+        // Remove loaded module form dependencies of other modules which are not loaded yet
         for (const auto& module_loaded_path : module_loaded_paths_) {
-            for (auto& [mod, deps] : mods_with_deps) {
+            for (auto& [mod, deps] : mod_with_deps) {
                 auto it = std::find(deps.begin(), deps.end(), module_loaded_path);
-                if (it != deps.end())
+                if (it != deps.end()) {
                     deps.erase(it);
+                }
             }
         }
     }
 
-    finish.store(true);
-    cv_load_module.notify_all();
-
-    for (auto& thread : threads) {
-        thread.join();
-    }
-
-    return ret.load();
+    return ret;
 }
 
 bool Modprobe::LoadListedModules(bool strict) {
@@ -670,19 +641,6 @@ std::vector<std::string> Modprobe::ListModules(const std::string& pattern) {
     return rv;
 }
 
-bool Modprobe::IsLoadSequential(const std::string& module)
-{
-    std::string str = "load_sequential=1";
-    auto it = module_options_[module].find(str);
-
-    if (it != std::string::npos) {
-        module_options_[module].erase(it, it + str.size());
-        return true;
-    }
-
-    return false;
-}
-
 bool Modprobe::GetAllDependencies(const std::string& module,
                                   std::vector<std::string>* pre_dependencies,
                                   std::vector<std::string>* dependencies,