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

Commit 8971b491 authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge changes from topic "run_dex2oat_test" 

* changes:
  installd: Unit test for RunDex2oat
  installd: move background compilation check out of RunDex2oat
  installd: replace get_location_from_path with Basename
  installd: move check of jitzygote out of RunDex2oat
parents 1ae1ad7c c9821f11

cmds/installd/Android.bp

+28 −0
Original line number Diff line number Diff line
@@ -16,7 +16,9 @@ cc_defaults { 
        "InstalldNativeService.cpp",

        "QuotaUtils.cpp",

        "dexopt.cpp",

        "execv_helper.cpp",

        "globals.cpp",

        "run_dex2oat.cpp",

        "utils.cpp",

        "utils_default.cpp",

        "view_compiler.cpp",
@@ -101,6 +103,30 @@ cc_library_headers { 
    export_include_dirs: ["."],

}



//

// Unit tests

//



cc_test_host {

    name: "run_dex2oat_test",

    test_suites: ["general-tests"],

    clang: true,

    srcs: [

        "run_dex2oat_test.cpp",

        "run_dex2oat.cpp",

        "execv_helper.cpp",

    ],

    cflags: ["-Wall", "-Werror"],

    shared_libs: [

        "libbase",

        "server_configurable_flags",

    ],

    static_libs: [

        //"libinstalld",

    ],

    test_config: "run_dex2oat_test.xml",

}



//

// Executable

//
@@ -203,9 +229,11 @@ cc_binary { 


    srcs: [

        "dexopt.cpp",

        "execv_helper.cpp",

        "globals.cpp",

        "otapreopt.cpp",

        "otapreopt_utils.cpp",

        "run_dex2oat.cpp",

        "utils.cpp",

        "utils_default.cpp",

        "view_compiler.cpp",

cmds/installd/TEST_MAPPING

+3 −0
Original line number Diff line number Diff line
@@ -15,6 +15,9 @@ 
    {

      "name": "installd_utils_test"

    },

    {

      "name": "run_dex2oat_test"

    },

    // AdoptableHostTest moves packages, part of which is handled by installd

    {

      "name": "AdoptableHostTest"

cmds/installd/dexopt.cpp

+27 −386
Original line number Diff line number Diff line
@@ -50,11 +50,14 @@ 


#include "dexopt.h"

#include "dexopt_return_codes.h"

#include "execv_helper.h"

#include "globals.h"

#include "installd_deps.h"

#include "otapreopt_utils.h"

#include "run_dex2oat.h"

#include "utils.h"



using android::base::Basename;

using android::base::EndsWith;

using android::base::GetBoolProperty;

using android::base::GetProperty;
@@ -67,16 +70,6 @@ using android::base::unique_fd; 
namespace android {

namespace installd {



// Should minidebug info be included in compiled artifacts? Even if this value is

// "true," usage might still be conditional to other constraints, e.g., system

// property overrides.

static constexpr bool kEnableMinidebugInfo = true;



static constexpr const char* kMinidebugInfoSystemProperty = "dalvik.vm.dex2oat-minidebuginfo";

static constexpr bool kMinidebugInfoSystemPropertyDefault = false;

static constexpr const char* kMinidebugDex2oatFlag = "--generate-mini-debug-info";

static constexpr const char* kDisableCompactDexFlag = "--compact-dex-level=none";





// Deleter using free() for use with std::unique_ptr<>. See also UniqueCPtr<> below.

struct FreeDelete {
@@ -186,93 +179,6 @@ bool clear_primary_current_profile(const std::string& package_name, const std::s 
    return clear_current_profile(package_name, location, user, /*is_secondary_dex*/false);

}



static std::vector<std::string> SplitBySpaces(const std::string& str) {

    if (str.empty()) {

        return {};

    }

    return android::base::Split(str, " ");

}



static const char* get_location_from_path(const char* path) {

    static constexpr char kLocationSeparator = '/';

    const char *location = strrchr(path, kLocationSeparator);

    if (location == nullptr) {

        return path;

    } else {

        // Skip the separator character.

        return location + 1;

    }

}



// ExecVHelper prepares and holds pointers to parsed command line arguments so that no allocations

// need to be performed between the fork and exec.

class ExecVHelper {

  public:

    // Store a placeholder for the binary name.

    ExecVHelper() : args_(1u, std::string()) {}



    void PrepareArgs(const std::string& bin) {

        CHECK(!args_.empty());

        CHECK(args_[0].empty());

        args_[0] = bin;

        // Write char* into array.

        for (const std::string& arg : args_) {

            argv_.push_back(arg.c_str());

        }

        argv_.push_back(nullptr);  // Add null terminator.

    }



    [[ noreturn ]]

    void Exec(int exit_code) {

        execv(argv_[0], (char * const *)&argv_[0]);

        PLOG(ERROR) << "execv(" << argv_[0] << ") failed";

        exit(exit_code);

    }



    // Add an arg if it's not empty.

    void AddArg(const std::string& arg) {

        if (!arg.empty()) {

            args_.push_back(arg);

        }

    }



    // Add a runtime arg if it's not empty.

    void AddRuntimeArg(const std::string& arg) {

        if (!arg.empty()) {

            args_.push_back("--runtime-arg");

            args_.push_back(arg);

        }

    }



  protected:

    // Holder arrays for backing arg storage.

    std::vector<std::string> args_;



    // Argument poiners.

    std::vector<const char*> argv_;

};



static std::string MapPropertyToArg(const std::string& property,

                                    const std::string& format,

                                    const std::string& default_value = "") {

  std::string prop = GetProperty(property, default_value);

  if (!prop.empty()) {

    return StringPrintf(format.c_str(), prop.c_str());

  }

  return "";

}



static std::string MapPropertyToArgWithBackup(const std::string& property,

                                              const std::string& backupProperty,

                                              const std::string& format,

                                              const std::string& default_value = "") {

  std::string value = GetProperty(property, default_value);

  if (!value.empty()) {

    return StringPrintf(format.c_str(), value.c_str());

  }

  return MapPropertyToArg(backupProperty, format, default_value);

}



// Determines which binary we should use for execution (the debug or non-debug version).

// e.g. dex2oatd vs dex2oat

static const char* select_execution_binary(const char* binary, const char* debug_binary,
@@ -311,9 +217,6 @@ const char* select_execution_binary( 
static const char* RUNTIME_NATIVE_BOOT_NAMESPACE = "runtime_native_boot";

// Feature flag name for running the JIT in Zygote experiment, b/119800099.

static const char* ENABLE_JITZYGOTE_IMAGE = "enable_apex_image";

// Location of the JIT Zygote image.

static const char* kJitZygoteImage =

    "boot.art:/nonx/boot-framework.art!/system/etc/boot-image.prof";



// Phenotype property name for enabling profiling the boot class path.

static const char* PROFILE_BOOT_CLASS_PATH = "profilebootclasspath";
@@ -328,289 +231,6 @@ static bool IsBootClassPathProfilingEnable() { 
    return profile_boot_class_path == "true";

}



class RunDex2Oat : public ExecVHelper {

  public:

    RunDex2Oat(int zip_fd,

               int oat_fd,

               int input_vdex_fd,

               int output_vdex_fd,

               int image_fd,

               const char* input_file_name,

               const char* output_file_name,

               int swap_fd,

               const char* instruction_set,

               const char* compiler_filter,

               bool debuggable,

               bool post_bootcomplete,

               bool for_restore,

               bool background_job_compile,

               int profile_fd,

               const char* class_loader_context,

               const std::string& class_loader_context_fds,

               int target_sdk_version,

               bool enable_hidden_api_checks,

               bool generate_compact_dex,

               int dex_metadata_fd,

               const char* compilation_reason) {

        // Get the relative path to the input file.

        const char* relative_input_file_name = get_location_from_path(input_file_name);



        std::string dex2oat_Xms_arg = MapPropertyToArg("dalvik.vm.dex2oat-Xms", "-Xms%s");

        std::string dex2oat_Xmx_arg = MapPropertyToArg("dalvik.vm.dex2oat-Xmx", "-Xmx%s");



        std::string threads_format = "-j%s";

        std::string dex2oat_threads_arg = post_bootcomplete

                ? (for_restore

                    ? MapPropertyToArgWithBackup(

                            "dalvik.vm.restore-dex2oat-threads",

                            "dalvik.vm.dex2oat-threads",

                            threads_format)

                    : MapPropertyToArg("dalvik.vm.dex2oat-threads", threads_format))

                : MapPropertyToArg("dalvik.vm.boot-dex2oat-threads", threads_format);

        std::string cpu_set_format = "--cpu-set=%s";

        std::string dex2oat_cpu_set_arg = post_bootcomplete

                ? (for_restore

                    ? MapPropertyToArgWithBackup(

                            "dalvik.vm.restore-dex2oat-cpu-set",

                            "dalvik.vm.dex2oat-cpu-set",

                            cpu_set_format)

                    : MapPropertyToArg("dalvik.vm.dex2oat-cpu-set", cpu_set_format))

                : MapPropertyToArg("dalvik.vm.boot-dex2oat-cpu-set", cpu_set_format);



        std::string bootclasspath;

        char* dex2oat_bootclasspath = getenv("DEX2OATBOOTCLASSPATH");

        if (dex2oat_bootclasspath != nullptr) {

            bootclasspath = StringPrintf("-Xbootclasspath:%s", dex2oat_bootclasspath);

        }

        // If DEX2OATBOOTCLASSPATH is not in the environment, dex2oat is going to query

        // BOOTCLASSPATH.



        const std::string dex2oat_isa_features_key =

                StringPrintf("dalvik.vm.isa.%s.features", instruction_set);

        std::string instruction_set_features_arg =

            MapPropertyToArg(dex2oat_isa_features_key, "--instruction-set-features=%s");



        const std::string dex2oat_isa_variant_key =

                StringPrintf("dalvik.vm.isa.%s.variant", instruction_set);

        std::string instruction_set_variant_arg =

            MapPropertyToArg(dex2oat_isa_variant_key, "--instruction-set-variant=%s");



        const char* dex2oat_norelocation = "-Xnorelocate";



        const std::string dex2oat_flags = GetProperty("dalvik.vm.dex2oat-flags", "");

        std::vector<std::string> dex2oat_flags_args = SplitBySpaces(dex2oat_flags);

        ALOGV("dalvik.vm.dex2oat-flags=%s\n", dex2oat_flags.c_str());



        // If we are booting without the real /data, don't spend time compiling.

        std::string vold_decrypt = GetProperty("vold.decrypt", "");

        bool skip_compilation = vold_decrypt == "trigger_restart_min_framework" ||

                                vold_decrypt == "1";



        std::string updatable_bcp_packages =

            MapPropertyToArg("dalvik.vm.dex2oat-updatable-bcp-packages-file",

                             "--updatable-bcp-packages-file=%s");

        if (updatable_bcp_packages.empty()) {

          // Make dex2oat fail by providing non-existent file name.

          updatable_bcp_packages = "--updatable-bcp-packages-file=/nonx/updatable-bcp-packages.txt";

        }



        std::string resolve_startup_string_arg =

                MapPropertyToArg("persist.device_config.runtime.dex2oat_resolve_startup_strings",

                                 "--resolve-startup-const-strings=%s");

        if (resolve_startup_string_arg.empty()) {

          // If empty, fall back to system property.

          resolve_startup_string_arg =

                MapPropertyToArg("dalvik.vm.dex2oat-resolve-startup-strings",

                                 "--resolve-startup-const-strings=%s");

        }



        const std::string image_block_size_arg =

                MapPropertyToArg("dalvik.vm.dex2oat-max-image-block-size",

                                 "--max-image-block-size=%s");



        const bool generate_debug_info = GetBoolProperty("debug.generate-debug-info", false);



        std::string image_format_arg;

        if (image_fd >= 0) {

            image_format_arg = MapPropertyToArg("dalvik.vm.appimageformat", "--image-format=%s");

        }



        std::string dex2oat_large_app_threshold_arg =

            MapPropertyToArg("dalvik.vm.dex2oat-very-large", "--very-large-app-threshold=%s");







        // Decide whether to use dex2oat64.

        bool use_dex2oat64 = false;

        // Check whether the device even supports 64-bit ABIs.

        if (!GetProperty("ro.product.cpu.abilist64", "").empty()) {

          use_dex2oat64 = GetBoolProperty("dalvik.vm.dex2oat64.enabled", false);

        }

        const char* dex2oat_bin = select_execution_binary(

            (use_dex2oat64 ? kDex2oat64Path : kDex2oat32Path),

            (use_dex2oat64 ? kDex2oatDebug64Path : kDex2oatDebug32Path),

            background_job_compile);



        bool generate_minidebug_info = kEnableMinidebugInfo &&

                GetBoolProperty(kMinidebugInfoSystemProperty, kMinidebugInfoSystemPropertyDefault);



        std::string boot_image;

        std::string use_jitzygote_image =

            server_configurable_flags::GetServerConfigurableFlag(RUNTIME_NATIVE_BOOT_NAMESPACE,

                                                                 ENABLE_JITZYGOTE_IMAGE,

                                                                 /*default_value=*/ "");



        if (use_jitzygote_image == "true" || IsBootClassPathProfilingEnable()) {

          boot_image = StringPrintf("--boot-image=%s", kJitZygoteImage);

        } else {

          boot_image = MapPropertyToArg("dalvik.vm.boot-image", "--boot-image=%s");

        }



        // clang FORTIFY doesn't let us use strlen in constant array bounds, so we

        // use arraysize instead.

        std::string zip_fd_arg = StringPrintf("--zip-fd=%d", zip_fd);

        std::string zip_location_arg = StringPrintf("--zip-location=%s", relative_input_file_name);

        std::string input_vdex_fd_arg = StringPrintf("--input-vdex-fd=%d", input_vdex_fd);

        std::string output_vdex_fd_arg = StringPrintf("--output-vdex-fd=%d", output_vdex_fd);

        std::string oat_fd_arg = StringPrintf("--oat-fd=%d", oat_fd);

        std::string oat_location_arg = StringPrintf("--oat-location=%s", output_file_name);

        std::string instruction_set_arg = StringPrintf("--instruction-set=%s", instruction_set);

        std::string dex2oat_compiler_filter_arg;

        std::string dex2oat_swap_fd;

        std::string dex2oat_image_fd;

        std::string target_sdk_version_arg;

        if (target_sdk_version != 0) {

            target_sdk_version_arg = StringPrintf("-Xtarget-sdk-version:%d", target_sdk_version);

        }

        std::string class_loader_context_arg;

        std::string class_loader_context_fds_arg;

        if (class_loader_context != nullptr) {

            class_loader_context_arg = StringPrintf("--class-loader-context=%s",

                                                    class_loader_context);

            if (!class_loader_context_fds.empty()) {

                class_loader_context_fds_arg = StringPrintf("--class-loader-context-fds=%s",

                                                            class_loader_context_fds.c_str());

            }

        }



        if (swap_fd >= 0) {

            dex2oat_swap_fd = StringPrintf("--swap-fd=%d", swap_fd);

        }

        if (image_fd >= 0) {

            dex2oat_image_fd = StringPrintf("--app-image-fd=%d", image_fd);

        }



        // Compute compiler filter.

        bool have_dex2oat_relocation_skip_flag = false;

        if (skip_compilation) {

            dex2oat_compiler_filter_arg = "--compiler-filter=extract";

            have_dex2oat_relocation_skip_flag = true;

        } else if (compiler_filter != nullptr) {

            dex2oat_compiler_filter_arg = StringPrintf("--compiler-filter=%s", compiler_filter);

        }



        if (dex2oat_compiler_filter_arg.empty()) {

            dex2oat_compiler_filter_arg = MapPropertyToArg("dalvik.vm.dex2oat-filter",

                                                           "--compiler-filter=%s");

        }



        // Check whether all apps should be compiled debuggable.

        if (!debuggable) {

            debuggable = GetProperty("dalvik.vm.always_debuggable", "") == "1";

        }

        std::string profile_arg;

        if (profile_fd != -1) {

            profile_arg = StringPrintf("--profile-file-fd=%d", profile_fd);

        }



        // Get the directory of the apk to pass as a base classpath directory.

        std::string base_dir;

        std::string apk_dir(input_file_name);

        unsigned long dir_index = apk_dir.rfind('/');

        bool has_base_dir = dir_index != std::string::npos;

        if (has_base_dir) {

            apk_dir = apk_dir.substr(0, dir_index);

            base_dir = StringPrintf("--classpath-dir=%s", apk_dir.c_str());

        }



        std::string dex_metadata_fd_arg = "--dm-fd=" + std::to_string(dex_metadata_fd);



        std::string compilation_reason_arg = compilation_reason == nullptr

                ? ""

                : std::string("--compilation-reason=") + compilation_reason;



        ALOGV("Running %s in=%s out=%s\n", dex2oat_bin, relative_input_file_name, output_file_name);



        // Disable cdex if update input vdex is true since this combination of options is not

        // supported.

        const bool disable_cdex = !generate_compact_dex || (input_vdex_fd == output_vdex_fd);



        AddArg(zip_fd_arg);

        AddArg(zip_location_arg);

        AddArg(input_vdex_fd_arg);

        AddArg(output_vdex_fd_arg);

        AddArg(oat_fd_arg);

        AddArg(oat_location_arg);

        AddArg(instruction_set_arg);



        AddArg(instruction_set_variant_arg);

        AddArg(instruction_set_features_arg);



        AddArg(boot_image);



        AddRuntimeArg(bootclasspath);

        AddRuntimeArg(dex2oat_Xms_arg);

        AddRuntimeArg(dex2oat_Xmx_arg);



        AddArg(updatable_bcp_packages);

        AddArg(resolve_startup_string_arg);

        AddArg(image_block_size_arg);

        AddArg(dex2oat_compiler_filter_arg);

        AddArg(dex2oat_threads_arg);

        AddArg(dex2oat_cpu_set_arg);

        AddArg(dex2oat_swap_fd);

        AddArg(dex2oat_image_fd);



        if (generate_debug_info) {

            AddArg("--generate-debug-info");

        }

        if (debuggable) {

            AddArg("--debuggable");

        }

        AddArg(image_format_arg);

        AddArg(dex2oat_large_app_threshold_arg);



        if (have_dex2oat_relocation_skip_flag) {

            AddRuntimeArg(dex2oat_norelocation);

        }

        AddArg(profile_arg);

        AddArg(base_dir);

        AddArg(class_loader_context_arg);

        AddArg(class_loader_context_fds_arg);

        if (generate_minidebug_info) {

            AddArg(kMinidebugDex2oatFlag);

        }

        if (disable_cdex) {

            AddArg(kDisableCompactDexFlag);

        }

        AddRuntimeArg(target_sdk_version_arg);

        if (enable_hidden_api_checks) {

            AddRuntimeArg("-Xhidden-api-policy:enabled");

        }



        if (dex_metadata_fd > -1) {

            AddArg(dex_metadata_fd_arg);

        }



        AddArg(compilation_reason_arg);



        // Do not add args after dex2oat_flags, they should override others for debugging.

        args_.insert(args_.end(), dex2oat_flags_args.begin(), dex2oat_flags_args.end());



        PrepareArgs(dex2oat_bin);

    }

};



/*

 * Whether dexopt should use a swap file when compiling an APK.

 *
@@ -868,6 +488,7 @@ class RunProfman : public ExecVHelper { 
                  /*for_boot_image*/false);

    }



    using ExecVHelper::Exec;  // To suppress -Wno-overloaded-virtual

    void Exec() {

        ExecVHelper::Exec(DexoptReturnCodes::kProfmanExec);

    }
@@ -1022,7 +643,7 @@ bool dump_profiles(int32_t uid, const std::string& pkgname, const std::string& p 
        PLOG(ERROR) << "installd cannot open " << code_path.c_str();

        return false;

    }

    dex_locations.push_back(get_location_from_path(code_path.c_str()));

    dex_locations.push_back(Basename(code_path));

    apk_fds.push_back(std::move(apk_fd));
@@ -2220,9 +1841,29 @@ int dexopt(const char* dex_path, uid_t uid, const char* pkgname, const char* ins 
        }

    }



    std::string jitzygote_flag = server_configurable_flags::GetServerConfigurableFlag(

        RUNTIME_NATIVE_BOOT_NAMESPACE,

        ENABLE_JITZYGOTE_IMAGE,

        /*default_value=*/ "");

    bool use_jitzygote_image = jitzygote_flag == "true" || IsBootClassPathProfilingEnable();



    // Decide whether to use dex2oat64.

    bool use_dex2oat64 = false;

    // Check whether the device even supports 64-bit ABIs.

    if (!GetProperty("ro.product.cpu.abilist64", "").empty()) {

      use_dex2oat64 = GetBoolProperty("dalvik.vm.dex2oat64.enabled", false);

    }

    const char* dex2oat_bin = select_execution_binary(

        (use_dex2oat64 ? kDex2oat64Path : kDex2oat32Path),

        (use_dex2oat64 ? kDex2oatDebug64Path : kDex2oatDebug32Path),

        background_job_compile);



    auto execv_helper = std::make_unique<ExecVHelper>();



    LOG(VERBOSE) << "DexInv: --- BEGIN '" << dex_path << "' ---";



    RunDex2Oat runner(input_fd.get(),

    RunDex2Oat runner(dex2oat_bin, execv_helper.get());

    runner.Initialize(input_fd.get(),

                      out_oat_fd.get(),

                      in_vdex_fd.get(),

                      out_vdex_fd.get(),
@@ -2235,7 +1876,6 @@ int dexopt(const char* dex_path, uid_t uid, const char* pkgname, const char* ins 
                      debuggable,

                      boot_complete,

                      for_restore,

                      background_job_compile,

                      reference_profile_fd.get(),

                      class_loader_context,

                      join_fds(context_input_fds),
@@ -2243,6 +1883,7 @@ int dexopt(const char* dex_path, uid_t uid, const char* pkgname, const char* ins 
                      enable_hidden_api_checks,

                      generate_compact_dex,

                      dex_metadata_fd.get(),

                      use_jitzygote_image,

                      compilation_reason);



    pid_t pid = fork();

cmds/installd/execv_helper.cpp

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

 * 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.

 */

#define LOG_TAG "installd"



#include "execv_helper.h"



#include <stdlib.h>

#include <unistd.h>



#include <string>



#include <android-base/logging.h>

#include <android-base/properties.h>



namespace android {

namespace installd {



// Store a placeholder for the binary name.

ExecVHelper::ExecVHelper() : args_(1u, std::string()) {}



ExecVHelper::~ExecVHelper() {}



void ExecVHelper::PrepareArgs(const std::string& bin) {

    CHECK(!args_.empty());

    CHECK(args_[0].empty());

    args_[0] = bin;

    // Write char* into array.

    for (const std::string& arg : args_) {

        argv_.push_back(arg.c_str());

    }

    argv_.push_back(nullptr);  // Add null terminator.

}



void ExecVHelper::Exec(int exit_code) {

    execv(argv_[0], (char * const *)&argv_[0]);

    PLOG(ERROR) << "execv(" << argv_[0] << ") failed";

    exit(exit_code);

}



void ExecVHelper::AddArg(const std::string& arg) {

    if (!arg.empty()) {

        args_.push_back(arg);

    }

}



void ExecVHelper::AddRuntimeArg(const std::string& arg) {

    if (!arg.empty()) {

        args_.push_back("--runtime-arg");

        args_.push_back(arg);

    }

}



}  // namespace installd

}  // namespace android

cmds/installd/execv_helper.h

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

 * 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.

 */



#ifndef ANDROID_INSTALLD_EXECV_HELPER_H

#define ANDROID_INSTALLD_EXECV_HELPER_H



#include <string>

#include <vector>



namespace android {

namespace installd {



// ExecVHelper prepares and holds pointers to parsed command line arguments so that no allocations

// need to be performed between the fork and exec.

class ExecVHelper {

  public:

    ExecVHelper();

    virtual ~ExecVHelper();



    [[ noreturn ]]

    virtual void Exec(int exit_code);



    void PrepareArgs(const std::string& bin);



    // Add an arg if it's not empty.

    void AddArg(const std::string& arg);



    // Add a runtime arg if it's not empty.

    void AddRuntimeArg(const std::string& arg);



  protected:

    // Holder arrays for backing arg storage.

    std::vector<std::string> args_;



    // Argument poiners.

    std::vector<const char*> argv_;

};



}  // namespace installd

}  // namespace android



#endif  // ANDROID_INSTALLD_EXECV_HELPER_H