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

Commit 94b41806 authored by Roland Levillain's avatar Roland Levillain
Browse files

Implement a tear-down phase in otapreopt_chroot. 

Collect the list of APEX packages activated by `otapreopt_chroot` and
deactivate them after executing `otapreopt` (in its own process).

Also share android::installd::Exec between `otapreopt` and
`otapreopt_chroot`.

This tear-down phase ensures loop devices associated during by
`otapreopt_chroot` are detached before `otapreopt_chroot` exits.

Test: m otapreopt_chroot
Test: A/B OTA update test (asit/dexoptota/self_full).
Bug: 113373927
Bug: 120796514
Change-Id: I236ac49bb698fb672e7a4f9de9903229e535e9c6
parent 370222c1

cmds/installd/Android.bp

+5 −1
Original line number Diff line number Diff line
@@ -136,7 +136,10 @@ cc_binary { 
    ],

    clang: true,



    srcs: ["otapreopt_chroot.cpp"],

    srcs: [

        "otapreopt_chroot.cpp",

        "otapreopt_utils.cpp",

    ],

    shared_libs: [

        "libbase",

        "liblog",
@@ -197,6 +200,7 @@ cc_binary { 
        "dexopt.cpp",

        "globals.cpp",

        "otapreopt.cpp",

        "otapreopt_utils.cpp",

        "utils.cpp",

    ],

cmds/installd/otapreopt.cpp

+0 −57
Original line number Diff line number Diff line
@@ -26,7 +26,6 @@ 
#include <sys/capability.h>

#include <sys/prctl.h>

#include <sys/stat.h>

#include <sys/wait.h>



#include <android-base/logging.h>

#include <android-base/macros.h>
@@ -58,7 +57,6 @@ 
#define REPLY_MAX     256   /* largest reply allowed */



using android::base::EndsWith;

using android::base::Join;

using android::base::Split;

using android::base::StartsWith;

using android::base::StringPrintf;
@@ -619,61 +617,6 @@ private: 
    // Helpers, mostly taken from ART //

    ////////////////////////////////////



    // Wrapper on fork/execv to run a command in a subprocess.

    static bool Exec(const std::vector<std::string>& arg_vector, std::string* error_msg) {

        const std::string command_line = Join(arg_vector, ' ');



        CHECK_GE(arg_vector.size(), 1U) << command_line;



        // Convert the args to char pointers.

        const char* program = arg_vector[0].c_str();

        std::vector<char*> args;

        for (size_t i = 0; i < arg_vector.size(); ++i) {

            const std::string& arg = arg_vector[i];

            char* arg_str = const_cast<char*>(arg.c_str());

            CHECK(arg_str != nullptr) << i;

            args.push_back(arg_str);

        }

        args.push_back(nullptr);



        // Fork and exec.

        pid_t pid = fork();

        if (pid == 0) {

            // No allocation allowed between fork and exec.



            // Change process groups, so we don't get reaped by ProcessManager.

            setpgid(0, 0);



            execv(program, &args[0]);



            PLOG(ERROR) << "Failed to execv(" << command_line << ")";

            // _exit to avoid atexit handlers in child.

            _exit(1);

        } else {

            if (pid == -1) {

                *error_msg = StringPrintf("Failed to execv(%s) because fork failed: %s",

                        command_line.c_str(), strerror(errno));

                return false;

            }



            // wait for subprocess to finish

            int status;

            pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));

            if (got_pid != pid) {

                *error_msg = StringPrintf("Failed after fork for execv(%s) because waitpid failed: "

                        "wanted %d, got %d: %s",

                        command_line.c_str(), pid, got_pid, strerror(errno));

                return false;

            }

            if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {

                *error_msg = StringPrintf("Failed execv(%s) because non-0 exit status",

                        command_line.c_str());

                return false;

            }

        }

        return true;

    }



    // Choose a random relocation offset. Taken from art/runtime/gc/image_space.cc.

    static int32_t ChooseRelocationOffsetDelta(int32_t min_delta, int32_t max_delta) {

        constexpr size_t kPageSize = PAGE_SIZE;

cmds/installd/otapreopt_chroot.cpp

+30 −10
Original line number Diff line number Diff line
@@ -195,23 +195,43 @@ static int otapreopt_chroot(const int argc, char **arg) { 
    // Note that this leaves around the loop devices created and used by

    // libapexd's code, but this is fine, as we expect to reboot soon after.

    apex::scanPackagesDirAndActivate(apex::kApexPackageSystemDir);

    // Collect activated packages.

    std::vector<apex::ApexFile> active_packages = apex::getActivePackages();



    // Now go on and run otapreopt.



    // Incoming:  cmd + status-fd + target-slot + cmd... + null      | Incoming | = argc + 1

    // Outgoing:  cmd             + target-slot + cmd... + null      | Outgoing | = argc

    const char** argv = new const char*[argc];



    argv[0] = "/system/bin/otapreopt";

    // Incoming:  cmd + status-fd + target-slot + cmd...      | Incoming | = argc

    // Outgoing:  cmd             + target-slot + cmd...      | Outgoing | = argc - 1

    std::vector<std::string> cmd;

    cmd.reserve(argc);

    cmd.push_back("/system/bin/otapreopt");



    // The first parameter is the status file descriptor, skip.

    for (size_t i = 2; i <= static_cast<size_t>(argc); ++i) {

        argv[i - 1] = arg[i];

    for (size_t i = 2; i < static_cast<size_t>(argc); ++i) {

        cmd.push_back(arg[i]);

    }



    // Fork and execute otapreopt in its own process.

    std::string error_msg;

    bool exec_result = Exec(cmd, &error_msg);

    if (!exec_result) {

        LOG(ERROR) << "Running otapreopt failed: " << error_msg;

    }



    // Tear down the work down by the apexd logic above (i.e. deactivate packages).

    for (const apex::ApexFile& apex_file : active_packages) {

        const std::string& package_path = apex_file.GetPath();

        apex::Status status = apex::deactivatePackage(package_path);

        if (!status.Ok()) {

            LOG(ERROR) << "Failed to deactivate " << package_path << ": " << status.ErrorMessage();

        }

    }



    if (!exec_result) {

        exit(213);

    }



    execv(argv[0], static_cast<char * const *>(const_cast<char**>(argv)));

    PLOG(ERROR) << "execv(OTAPREOPT) failed.";

    exit(99);

    return 0;

}



}  // namespace installd

cmds/installd/otapreopt_utils.cpp

0 → 100644
+88 −0
Original line number Diff line number Diff line 
/*

 ** Copyright 2019, The Android Open Source Project

 **

 ** Licensed under the Apache License, Version 2.0 (the "License");

 ** you may not use this file except in compliance with the License.

 ** You may obtain a copy of the License at

 **

 **     http://www.apache.org/licenses/LICENSE-2.0

 **

 ** Unless required by applicable law or agreed to in writing, software

 ** distributed under the License is distributed on an "AS IS" BASIS,

 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 ** See the License for the specific language governing permissions and

 ** limitations under the License.

 */



#include "otapreopt_utils.h"



#include <sys/types.h>

#include <sys/wait.h>

#include <unistd.h>



#include <android-base/logging.h>

#include <android-base/stringprintf.h>

#include <android-base/strings.h>



using android::base::Join;

using android::base::StringPrintf;



namespace android {

namespace installd {



bool Exec(const std::vector<std::string>& arg_vector, std::string* error_msg) {

    const std::string command_line = Join(arg_vector, ' ');



    CHECK_GE(arg_vector.size(), 1U) << command_line;



    // Convert the args to char pointers.

    const char* program = arg_vector[0].c_str();

    std::vector<char*> args;

    for (size_t i = 0; i < arg_vector.size(); ++i) {

        const std::string& arg = arg_vector[i];

        char* arg_str = const_cast<char*>(arg.c_str());

        CHECK(arg_str != nullptr) << i;

        args.push_back(arg_str);

    }

    args.push_back(nullptr);



    // Fork and exec.

    pid_t pid = fork();

    if (pid == 0) {

        // No allocation allowed between fork and exec.



        // Change process groups, so we don't get reaped by ProcessManager.

        setpgid(0, 0);



        execv(program, &args[0]);



        PLOG(ERROR) << "Failed to execv(" << command_line << ")";

        // _exit to avoid atexit handlers in child.

        _exit(1);

    } else {

        if (pid == -1) {

            *error_msg = StringPrintf("Failed to execv(%s) because fork failed: %s",

                    command_line.c_str(), strerror(errno));

            return false;

        }



        // wait for subprocess to finish

        int status;

        pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));

        if (got_pid != pid) {

            *error_msg = StringPrintf("Failed after fork for execv(%s) because waitpid failed: "

                    "wanted %d, got %d: %s",

                    command_line.c_str(), pid, got_pid, strerror(errno));

            return false;

        }

        if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {

            *error_msg = StringPrintf("Failed execv(%s) because non-0 exit status",

                    command_line.c_str());

            return false;

        }

    }

    return true;

}



}  // namespace installd

}  // namespace android

cmds/installd/otapreopt_utils.h

+5 −0
Original line number Diff line number Diff line
@@ -18,6 +18,8 @@ 
#define OTAPREOPT_UTILS_H_



#include <regex>

#include <string>

#include <vector>



namespace android {

namespace installd {
@@ -28,6 +30,9 @@ static inline bool ValidateTargetSlotSuffix(const std::string& input) { 
    return std::regex_match(input, slot_suffix_match, slot_suffix_regex);

}



// Wrapper on fork/execv to run a command in a subprocess.

bool Exec(const std::vector<std::string>& arg_vector, std::string* error_msg);



}  // namespace installd

}  // namespace android