Merge "Allow product partition to have vendor_overlay" am: 69f174a4

namespace {

const auto kVendorOverlaySourceDir = "/system/vendor_overlay/"s;

// 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 = {

        "/system/vendor_overlay/",

        "/product/vendor_overlay/",

};

const auto kVndkVersionPropertyName = "ro.vndk.version"s;

const auto kVendorTopDir = "/vendor/"s;

const auto kLowerdirOption = "lowerdir="s;

std::string fs_mgr_get_vendor_overlay_top_dir() {

    // VNDK version is provided by the /vendor/default.prop

    // To read the property, it must be called at the second init stage after the default

    // properties are loaded.

    std::string vndk_version = android::base::GetProperty(kVndkVersionPropertyName, "");

    if (vndk_version.empty()) {

        return "";

    }

    return kVendorOverlaySourceDir + vndk_version;

}

std::vector<std::string> fs_mgr_get_vendor_overlay_dirs(const std::string& overlay_top) {

    std::vector<std::string> vendor_overlay_dirs;

std::vector<std::pair<std::string, std::string>> fs_mgr_get_vendor_overlay_dirs(

        const std::string& vndk_version) {

    std::vector<std::pair<std::string, std::string>> vendor_overlay_dirs;

    for (const auto& vendor_overlay_source : kVendorOverlaySourceDirs) {

        const auto overlay_top = vendor_overlay_source + vndk_version;

        std::unique_ptr<DIR, decltype(&closedir)> vendor_overlay_top(opendir(overlay_top.c_str()),

                                                                     closedir);

    if (!vendor_overlay_top) return vendor_overlay_dirs;

        if (!vendor_overlay_top) continue;

        // Vendor overlay root for current vendor version found!

        LINFO << "vendor overlay root: " << overlay_top;

        struct dirent* dp;

        while ((dp = readdir(vendor_overlay_top.get())) != nullptr) {

            if (dp->d_type != DT_DIR || dp->d_name[0] == '.') {

                continue;

            }

        vendor_overlay_dirs.push_back(dp->d_name);

            vendor_overlay_dirs.emplace_back(overlay_top, dp->d_name);

        }

    }

    return vendor_overlay_dirs;

}

bool fs_mgr_vendor_overlay_mount(const std::string& overlay_top, const std::string& mount_point) {

    const auto vendor_mount_point = kVendorTopDir + mount_point;

bool fs_mgr_vendor_overlay_mount(const std::pair<std::string, std::string>& mount_point) {

    const auto [overlay_top, mount_dir] = mount_point;

    const auto vendor_mount_point = kVendorTopDir + mount_dir;

    LINFO << "vendor overlay mount on " << vendor_mount_point;

    const auto target_context = fs_mgr_get_context(vendor_mount_point);

        PERROR << " failed: cannot find the target vendor mount point";

        return false;

    }

    const auto source_directory = overlay_top + "/" + mount_point;

    const auto source_directory = overlay_top + "/" + mount_dir;

    const auto source_context = fs_mgr_get_context(source_directory);

    if (target_context != source_context) {

        LERROR << " failed: source and target contexts do not match (source:" << source_context

// To read the properties, vendor overlay must be mounted at the second stage, right

// after "property_load_boot_defaults()" is called.

bool fs_mgr_vendor_overlay_mount_all() {

    const auto overlay_top = fs_mgr_get_vendor_overlay_top_dir();

    if (overlay_top.empty()) {

    // To read the property, it must be called at the second init stage after the default

    // properties are loaded.

    static const auto vndk_version = android::base::GetProperty(kVndkVersionPropertyName, "");

    if (vndk_version.empty()) {

        LINFO << "vendor overlay: vndk version not defined";

        return false;

    }

    const auto vendor_overlay_dirs = fs_mgr_get_vendor_overlay_dirs(overlay_top);

    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) {

        LINFO << "vendor overlay: kernel does not support overlayfs";

        return false;

    }

    // Mount each directory in /system/vendor_overlay/<ver> on /vendor

    // Mount each directory in /(system|product)/vendor_overlay/<ver> on /vendor

    auto ret = true;

    for (const auto& vendor_overlay_dir : vendor_overlay_dirs) {

        if (!fs_mgr_vendor_overlay_mount(overlay_top, vendor_overlay_dir)) {

        if (!fs_mgr_vendor_overlay_mount(vendor_overlay_dir)) {

            ret = false;

        }

    }