Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 412cca95 authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 7325276 from fe1ac4d8 to sc-v2-release 

Change-Id: I6012a69f3830344295eb317e47ee91ee97877fe4
parents be3ecd01 fe1ac4d8

fs_mgr/libsnapshot/snapuserd_client.cpp

+1 −1
Original line number Diff line number Diff line
@@ -113,7 +113,7 @@ bool SnapuserdClient::ValidateConnection() { 


bool SnapuserdClient::Sendmsg(const std::string& msg) {

    LOG(DEBUG) << "Sendmsg: msg " << msg << " sockfd: " << sockfd_;

    ssize_t numBytesSent = TEMP_FAILURE_RETRY(send(sockfd_, msg.data(), msg.size(), 0));

    ssize_t numBytesSent = TEMP_FAILURE_RETRY(send(sockfd_, msg.data(), msg.size(), MSG_NOSIGNAL));

    if (numBytesSent < 0) {

        PLOG(ERROR) << "Send failed";

        return false;

fs_mgr/libsnapshot/snapuserd_server.cpp

+1 −1
Original line number Diff line number Diff line
@@ -81,7 +81,7 @@ 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(), 0));

    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;

fs_mgr/tests/fs_mgr_test.cpp

+102 −92
Original line number Diff line number Diff line
@@ -184,6 +184,36 @@ const std::vector<std::pair<std::string, std::string>> bootconfig_result_space = 
        {"androidboot.space", "sha256 5248 androidboot.nospace = nope"},

};



bool CompareFlags(FstabEntry::FsMgrFlags& lhs, FstabEntry::FsMgrFlags& rhs) {

    // clang-format off

    return lhs.wait == rhs.wait &&

           lhs.check == rhs.check &&

           lhs.crypt == rhs.crypt &&

           lhs.nonremovable == rhs.nonremovable &&

           lhs.vold_managed == rhs.vold_managed &&

           lhs.recovery_only == rhs.recovery_only &&

           lhs.verify == rhs.verify &&

           lhs.force_crypt == rhs.force_crypt &&

           lhs.no_emulated_sd == rhs.no_emulated_sd &&

           lhs.no_trim == rhs.no_trim &&

           lhs.file_encryption == rhs.file_encryption &&

           lhs.formattable == rhs.formattable &&

           lhs.slot_select == rhs.slot_select &&

           lhs.force_fde_or_fbe == rhs.force_fde_or_fbe &&

           lhs.late_mount == rhs.late_mount &&

           lhs.no_fail == rhs.no_fail &&

           lhs.verify_at_boot == rhs.verify_at_boot &&

           lhs.quota == rhs.quota &&

           lhs.avb == rhs.avb &&

           lhs.logical == rhs.logical &&

           lhs.checkpoint_blk == rhs.checkpoint_blk &&

           lhs.checkpoint_fs == rhs.checkpoint_fs &&

           lhs.first_stage_mount == rhs.first_stage_mount &&

           lhs.slot_select_other == rhs.slot_select_other &&

           lhs.fs_verity == rhs.fs_verity;

    // clang-format on

}



}  // namespace



TEST(fs_mgr, fs_mgr_parse_cmdline) {
@@ -291,8 +321,7 @@ TEST(fs_mgr, fs_mgr_read_fstab_file_proc_mounts) { 
    EXPECT_EQ(i, fstab.size());

}



// TODO(124837435): enable it later when it can pass TreeHugger.

TEST(fs_mgr, DISABLED_ReadFstabFromFile_MountOptions) {

TEST(fs_mgr, ReadFstabFromFile_MountOptions) {

    TemporaryFile tf;

    ASSERT_TRUE(tf.fd != -1);

    std::string fstab_contents = R"fs(
@@ -316,88 +345,69 @@ source none5 swap rw zramsize=1073741824, 


    Fstab fstab;

    EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));

    ASSERT_EQ(11U, fstab.size());



    EXPECT_EQ("/", fstab[0].mount_point);

    EXPECT_EQ(static_cast<unsigned long>(MS_RDONLY), fstab[0].flags);

    EXPECT_EQ("barrier=1", fstab[0].fs_options);



    EXPECT_EQ("/metadata", fstab[1].mount_point);

    EXPECT_EQ(static_cast<unsigned long>(MS_NOATIME | MS_NOSUID | MS_NODEV), fstab[1].flags);

    EXPECT_EQ("discard", fstab[1].fs_options);



    EXPECT_EQ("/data", fstab[2].mount_point);

    EXPECT_EQ(static_cast<unsigned long>(MS_NOATIME | MS_NOSUID | MS_NODEV), fstab[2].flags);

    EXPECT_EQ("discard,reserve_root=32768,resgid=1065,fsync_mode=nobarrier", fstab[2].fs_options);



    EXPECT_EQ("/misc", fstab[3].mount_point);

    EXPECT_EQ(0U, fstab[3].flags);

    EXPECT_EQ("", fstab[3].fs_options);



    EXPECT_EQ("/vendor/firmware_mnt", fstab[4].mount_point);

    EXPECT_EQ(static_cast<unsigned long>(MS_RDONLY), fstab[4].flags);

    ASSERT_LE(11U, fstab.size());



    FstabEntry* entry = GetEntryForMountPoint(&fstab, "/");

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ(static_cast<unsigned long>(MS_RDONLY), entry->flags);

    EXPECT_EQ("barrier=1", entry->fs_options);



    entry = GetEntryForMountPoint(&fstab, "/metadata");

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ(static_cast<unsigned long>(MS_NOATIME | MS_NOSUID | MS_NODEV), entry->flags);

    EXPECT_EQ("discard", entry->fs_options);



    entry = GetEntryForMountPoint(&fstab, "/data");

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ(static_cast<unsigned long>(MS_NOATIME | MS_NOSUID | MS_NODEV), entry->flags);

    EXPECT_EQ("discard,reserve_root=32768,resgid=1065,fsync_mode=nobarrier", entry->fs_options);



    entry = GetEntryForMountPoint(&fstab, "/misc");

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ(0U, entry->flags);

    EXPECT_EQ("", entry->fs_options);



    entry = GetEntryForMountPoint(&fstab, "/vendor/firmware_mnt");

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ(static_cast<unsigned long>(MS_RDONLY), entry->flags);

    EXPECT_EQ(

            "shortname=lower,uid=1000,gid=1000,dmask=227,fmask=337,"

            "context=u:object_r:firmware_file:s0",

            fstab[4].fs_options);



    EXPECT_EQ("auto", fstab[5].mount_point);

    EXPECT_EQ(0U, fstab[5].flags);

    EXPECT_EQ("", fstab[5].fs_options);



    EXPECT_EQ("none", fstab[6].mount_point);

    EXPECT_EQ(0U, fstab[6].flags);

    EXPECT_EQ("", fstab[6].fs_options);



    EXPECT_EQ("none2", fstab[7].mount_point);

    EXPECT_EQ(static_cast<unsigned long>(MS_NODIRATIME | MS_REMOUNT | MS_BIND), fstab[7].flags);

    EXPECT_EQ("", fstab[7].fs_options);



    EXPECT_EQ("none3", fstab[8].mount_point);

    EXPECT_EQ(static_cast<unsigned long>(MS_UNBINDABLE | MS_PRIVATE | MS_SLAVE), fstab[8].flags);

    EXPECT_EQ("", fstab[8].fs_options);



    EXPECT_EQ("none4", fstab[9].mount_point);

    EXPECT_EQ(static_cast<unsigned long>(MS_NOEXEC | MS_SHARED | MS_REC), fstab[9].flags);

    EXPECT_EQ("", fstab[9].fs_options);



    EXPECT_EQ("none5", fstab[10].mount_point);

    EXPECT_EQ(0U, fstab[10].flags);  // rw is the same as defaults

    EXPECT_EQ("", fstab[10].fs_options);

}



static bool CompareFlags(FstabEntry::FsMgrFlags& lhs, FstabEntry::FsMgrFlags& rhs) {

    // clang-format off

    return lhs.wait == rhs.wait &&

           lhs.check == rhs.check &&

           lhs.crypt == rhs.crypt &&

           lhs.nonremovable == rhs.nonremovable &&

           lhs.vold_managed == rhs.vold_managed &&

           lhs.recovery_only == rhs.recovery_only &&

           lhs.verify == rhs.verify &&

           lhs.force_crypt == rhs.force_crypt &&

           lhs.no_emulated_sd == rhs.no_emulated_sd &&

           lhs.no_trim == rhs.no_trim &&

           lhs.file_encryption == rhs.file_encryption &&

           lhs.formattable == rhs.formattable &&

           lhs.slot_select == rhs.slot_select &&

           lhs.force_fde_or_fbe == rhs.force_fde_or_fbe &&

           lhs.late_mount == rhs.late_mount &&

           lhs.no_fail == rhs.no_fail &&

           lhs.verify_at_boot == rhs.verify_at_boot &&

           lhs.quota == rhs.quota &&

           lhs.avb == rhs.avb &&

           lhs.logical == rhs.logical &&

           lhs.checkpoint_blk == rhs.checkpoint_blk &&

           lhs.checkpoint_fs == rhs.checkpoint_fs &&

           lhs.first_stage_mount == rhs.first_stage_mount &&

           lhs.slot_select_other == rhs.slot_select_other &&

           lhs.fs_verity == rhs.fs_verity;

    // clang-format on

            entry->fs_options);



    entry = GetEntryForMountPoint(&fstab, "auto");

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ(0U, entry->flags);

    EXPECT_EQ("", entry->fs_options);



    entry = GetEntryForMountPoint(&fstab, "none");

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ(0U, entry->flags);

    EXPECT_EQ("", entry->fs_options);



    entry = GetEntryForMountPoint(&fstab, "none2");

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ(static_cast<unsigned long>(MS_NODIRATIME | MS_REMOUNT | MS_BIND), entry->flags);

    EXPECT_EQ("", entry->fs_options);



    entry = GetEntryForMountPoint(&fstab, "none3");

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ(static_cast<unsigned long>(MS_UNBINDABLE | MS_PRIVATE | MS_SLAVE), entry->flags);

    EXPECT_EQ("", entry->fs_options);



    entry = GetEntryForMountPoint(&fstab, "none4");

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ(static_cast<unsigned long>(MS_NOEXEC | MS_SHARED | MS_REC), entry->flags);

    EXPECT_EQ("", entry->fs_options);



    entry = GetEntryForMountPoint(&fstab, "none5");

    ASSERT_NE(nullptr, entry);

    // rw is the default.

    EXPECT_EQ(0U, entry->flags);

    EXPECT_EQ("", entry->fs_options);

}



// TODO(124837435): enable it later when it can pass TreeHugger.

TEST(fs_mgr, DISABLED_ReadFstabFromFile_FsMgrFlags) {

TEST(fs_mgr, ReadFstabFromFile_FsMgrFlags) {

    TemporaryFile tf;

    ASSERT_TRUE(tf.fd != -1);

    std::string fstab_contents = R"fs(
@@ -412,10 +422,10 @@ source none5 swap defaults defaults 


    Fstab fstab;

    EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));

    ASSERT_EQ(6U, fstab.size());

    ASSERT_LE(6U, fstab.size());



    auto entry = fstab.begin();

    EXPECT_EQ("none0", entry->mount_point);

    FstabEntry* entry = GetEntryForMountPoint(&fstab, "none0");

    ASSERT_NE(nullptr, entry);

    {

        FstabEntry::FsMgrFlags flags = {};

        flags.wait = true;
@@ -426,9 +436,9 @@ source none5 swap defaults defaults 
        flags.verify = true;

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

    }

    entry++;



    EXPECT_EQ("none1", entry->mount_point);

    entry = GetEntryForMountPoint(&fstab, "none1");

    ASSERT_NE(nullptr, entry);

    {

        FstabEntry::FsMgrFlags flags = {};

        flags.avb = true;
@@ -439,9 +449,9 @@ source none5 swap defaults defaults 
        flags.no_fail = true;

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

    }

    entry++;



    EXPECT_EQ("none2", entry->mount_point);

    entry = GetEntryForMountPoint(&fstab, "none2");

    ASSERT_NE(nullptr, entry);

    {

        FstabEntry::FsMgrFlags flags = {};

        flags.first_stage_mount = true;
@@ -451,25 +461,25 @@ source none5 swap defaults defaults 
        flags.slot_select_other = true;

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

    }

    entry++;



    EXPECT_EQ("none3", entry->mount_point);

    entry = GetEntryForMountPoint(&fstab, "none3");

    ASSERT_NE(nullptr, entry);

    {

        FstabEntry::FsMgrFlags flags = {};

        flags.checkpoint_blk = true;

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

    }

    entry++;



    EXPECT_EQ("none4", entry->mount_point);

    entry = GetEntryForMountPoint(&fstab, "none4");

    ASSERT_NE(nullptr, entry);

    {

        FstabEntry::FsMgrFlags flags = {};

        flags.checkpoint_fs = true;

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

    }

    entry++;



    EXPECT_EQ("none5", entry->mount_point);

    entry = GetEntryForMountPoint(&fstab, "none5");

    ASSERT_NE(nullptr, entry);

    {

        FstabEntry::FsMgrFlags flags = {};

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

init/property_service.cpp

+10 −3
Original line number Diff line number Diff line
@@ -1218,13 +1218,20 @@ static void ProcessKernelCmdline() { 
    });

}



// bootconfig does not allow to populate `key=value` simultaneously with

// `key.subkey=value` which does not work with the existing code for

// `hardware` (e.g. we want both `ro.boot.hardware=value` and

// `ro.boot.hardware.sku=value`) and for `qemu` (Android Stidio Emulator

// specific).

static bool IsAllowedBootconfigKey(const std::string_view key) {

    return (key == "hardware"sv) || (key == "qemu"sv);

}



static void ProcessBootconfig() {

    ImportBootconfig([&](const std::string& key, const std::string& value) {

        if (StartsWith(key, ANDROIDBOOT_PREFIX)) {

            InitPropertySet("ro.boot." + key.substr(ANDROIDBOOT_PREFIX.size()), value);

        } else if (key == "hardware") {

            // "hardware" in bootconfig replaces "androidboot.hardware" kernel

            // cmdline parameter

        } else if (IsAllowedBootconfigKey(key)) {

            InitPropertySet("ro.boot." + key, value);

        }

    });

libutils/SharedBuffer_test.cpp

+25 −4
Original line number Diff line number Diff line
@@ -32,10 +32,25 @@ TEST(SharedBufferTest, alloc_death) { 
    EXPECT_DEATH(android::SharedBuffer::alloc(SIZE_MAX - sizeof(android::SharedBuffer)), "");

}



TEST(SharedBufferTest, alloc_null) {

    // Big enough to fail, not big enough to abort.

TEST(SharedBufferTest, alloc_max) {

    SKIP_WITH_HWASAN;  // hwasan has a 2GiB allocation limit.



    android::SharedBuffer* buf =

            android::SharedBuffer::alloc(SIZE_MAX - sizeof(android::SharedBuffer) - 1);

    if (buf != nullptr) {

        EXPECT_NE(nullptr, buf->data());

        buf->release();

    }

}



TEST(SharedBufferTest, alloc_big) {

    SKIP_WITH_HWASAN;  // hwasan has a 2GiB allocation limit.

    ASSERT_EQ(nullptr, android::SharedBuffer::alloc(SIZE_MAX / 2));



    android::SharedBuffer* buf = android::SharedBuffer::alloc(SIZE_MAX / 2);

    if (buf != nullptr) {

        EXPECT_NE(nullptr, buf->data());

        buf->release();

    }

}



TEST(SharedBufferTest, alloc_zero_size) {
@@ -56,7 +71,13 @@ TEST(SharedBufferTest, editResize_null) { 
    // Big enough to fail, not big enough to abort.

    SKIP_WITH_HWASAN;  // hwasan has a 2GiB allocation limit.

    android::SharedBuffer* buf = android::SharedBuffer::alloc(10);

    ASSERT_EQ(nullptr, buf->editResize(SIZE_MAX / 2));

    android::SharedBuffer* buf2 = buf->editResize(SIZE_MAX / 2);

    if (buf2 == nullptr) {

        buf->release();

    } else {

        EXPECT_NE(nullptr, buf2->data());

        buf2->release();

    }

}



TEST(SharedBufferTest, editResize_zero_size) {