// Copyright 2015 The Android Open Source Project
//
// This software is licensed under the terms of the GNU General Public
// License version 2, as published by the Free Software Foundation, and
// may be copied, distributed, and modified under those terms.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

#include "android/base/containers/StringVector.h"
#include "android/base/files/PathUtils.h"
#include "android/base/Log.h"
#include "android/base/memory/ScopedPtr.h"
#include "android/base/StringFormat.h"
#include "android/base/system/System.h"


#include "android/android.h"
#include "android/avd/hw-config.h"
#include "android/cmdline-option.h"
#include "android/constants.h"
#include "android/crashreport/crash-handler.h"
#include "android/emulation/ConfigDirs.h"
#include "android/error-messages.h"
#include "android/featurecontrol/FeatureControl.h"
#include "android/filesystems/ext4_resize.h"
#include "android/filesystems/ext4_utils.h"
#include "android/globals.h"
#include "android/help.h"
#include "android/kernel/kernel_utils.h"
#include "android/main-common.h"
#include "android/main-common-ui.h"
#include "android/main-kernel-parameters.h"
#include "android/opengl/emugl_config.h"
#include "android/process_setup.h"
#include "android/utils/bufprint.h"
#include "android/utils/debug.h"
#include "android/utils/file_io.h"
#include "android/utils/path.h"
#include "android/utils/lineinput.h"
#include "android/utils/property_file.h"
#include "android/utils/filelock.h"
#include "android/utils/stralloc.h"
#include "android/utils/string.h"
#include "android/utils/tempfile.h"
#include "android/utils/win32_cmdline_quote.h"

#include "android/skin/winsys.h"

#include "config-target.h"

extern "C" {
#include "android/skin/charmap.h"
}

#include "android/ui-emu-agent.h"
#include "android-qemu2-glue/emulation/serial_line.h"
#include "android-qemu2-glue/proxy/slirp_proxy.h"
#include "android-qemu2-glue/qemu-control-impl.h"

#ifdef TARGET_AARCH64
#define TARGET_ARM64
#endif
#ifdef TARGET_I386
#define TARGET_X86
#endif

#include <algorithm>
#include <assert.h>
#include <limits.h>
#include <stdio.h>
#include <unistd.h>

#include "android/version.h"
#define  D(...)  do {  if (VERBOSE_CHECK(init)) dprint(__VA_ARGS__); } while (0)

int android_base_port;
int android_serial_number_port;

extern bool android_op_wipe_data;
extern bool android_op_writable_system;

using namespace android::base;
using android::base::System;

namespace {

enum ImageType {
    IMAGE_TYPE_SYSTEM = 0,
    IMAGE_TYPE_CACHE,
    IMAGE_TYPE_USER_DATA,
    IMAGE_TYPE_SD_CARD,
    IMAGE_TYPE_ENCRYPTION_KEY,
};

const int kMaxPartitions = 5;
const int kMaxTargetQemuParams = 16;

/*
 * A structure used to model information about a given target CPU architecture.
 * |androidArch| is the architecture name, following Android conventions.
 * |qemuArch| is the same name, following QEMU conventions, used to locate
 * the final qemu-system-<qemuArch> binary.
 * |qemuCpu| is the QEMU -cpu parameter value.
 * |ttyPrefix| is the prefix to use for TTY devices.
 * |storageDeviceType| is the QEMU storage device type.
 * |networkDeviceType| is the QEMU network device type.
 * |imagePartitionTypes| defines the order of how the image partitions are
 * listed in the command line, because the command line order determines which
 * mount point the partition is attached to.  For x86, the first partition
 * listed in command line is mounted first, i.e. to /dev/block/vda,
 * the next one to /dev/block/vdb, etc. However, for arm/mips, it's reversed;
 * the last one is mounted to /dev/block/vda. the 2nd last to /dev/block/vdb.
 * So far, we have 4(kMaxPartitions) types defined for system, cache, userdata
 * and sdcard images.
 * |qemuExtraArgs| are the qemu parameters specific to the target platform.
 * this is a NULL-terminated list of string pointers of at most
 * kMaxTargetQemuParams(16).
 */
struct TargetInfo {
    const char* androidArch;
    const char* qemuArch;
    const char* qemuCpu;
    const char* ttyPrefix;
    const char* storageDeviceType;
    const char* networkDeviceType;
    const ImageType imagePartitionTypes[kMaxPartitions];
    const char* qemuExtraArgs[kMaxTargetQemuParams];
};

// The current target architecture information!
const TargetInfo kTarget = {
#ifdef TARGET_ARM64
    "arm64",
    "aarch64",
    "cortex-a57",
    "ttyAMA",
    "virtio-blk-device",
    "virtio-net-device",
    {IMAGE_TYPE_SD_CARD, IMAGE_TYPE_ENCRYPTION_KEY, IMAGE_TYPE_USER_DATA, IMAGE_TYPE_CACHE, IMAGE_TYPE_SYSTEM},
    {NULL},
#elif defined(TARGET_ARM)
    "arm",
    "arm",
    "cortex-a15",
    "ttyAMA",
    "virtio-blk-device",
    "virtio-net-device",
    {IMAGE_TYPE_SD_CARD, IMAGE_TYPE_ENCRYPTION_KEY, IMAGE_TYPE_USER_DATA, IMAGE_TYPE_CACHE, IMAGE_TYPE_SYSTEM},
    {NULL},
#elif defined(TARGET_MIPS64)
    "mips64",
    "mips64el",
    "MIPS64R6-generic",
    "ttyGF",
    "virtio-blk-device",
    "virtio-net-device",
    {IMAGE_TYPE_SD_CARD, IMAGE_TYPE_ENCRYPTION_KEY, IMAGE_TYPE_USER_DATA, IMAGE_TYPE_CACHE, IMAGE_TYPE_SYSTEM},
    {NULL},
#elif defined(TARGET_MIPS)
    "mips",
    "mipsel",
    "74Kf",
    "ttyGF",
    "virtio-blk-device",
    "virtio-net-device",
    {IMAGE_TYPE_SD_CARD, IMAGE_TYPE_ENCRYPTION_KEY, IMAGE_TYPE_USER_DATA, IMAGE_TYPE_CACHE, IMAGE_TYPE_SYSTEM},
    {NULL},
#elif defined(TARGET_X86_64)
    "x86_64",
    "x86_64",
    "android64",
    "ttyS",
    "virtio-blk-pci",
    "virtio-net-pci",
    {IMAGE_TYPE_SYSTEM, IMAGE_TYPE_CACHE, IMAGE_TYPE_USER_DATA, IMAGE_TYPE_ENCRYPTION_KEY, IMAGE_TYPE_SD_CARD},
    {"-vga", "none", NULL},
#elif defined(TARGET_I386)  // Both i386 and x86_64 targets define this macro
    "x86",
    "i386",
    "android32",
    "ttyS",
    "virtio-blk-pci",
    "virtio-net-pci",
    {IMAGE_TYPE_SYSTEM, IMAGE_TYPE_CACHE, IMAGE_TYPE_USER_DATA, IMAGE_TYPE_ENCRYPTION_KEY, IMAGE_TYPE_SD_CARD},
    {"-vga", "none", NULL},
#else
    #error No target platform is defined
#endif
};

static std::string getNthParentDir(const char* path, size_t n) {
    StringVector dir = PathUtils::decompose(path);
    PathUtils::simplifyComponents(&dir);
    if (dir.size() < n + 1U) {
        return std::string("");
    }
    dir.resize(dir.size() - n);
    return PathUtils::recompose(dir);
}

/* generate parameters for each partition by type.
 * Param:
 *  args - array to hold parameters for qemu
 *  argsPosition - current index in the parameter array
 *  driveIndex - a sequence number for the drive parameter
 *  hw - the hardware configuration that conatains image info.
 *  type - what type of partition parameter to generate
*/

static void makePartitionCmd(const char** args, int* argsPosition, int* driveIndex,
                             AndroidHwConfig* hw, ImageType type, bool writable,
                             int apiLevel, const char* avdContentPath) {
    int n   = *argsPosition;
    int idx = *driveIndex;

#if defined(TARGET_X86_64) || defined(TARGET_I386)
    /* for x86, 'if=none' is necessary for virtio blk*/
    std::string driveParam("if=none,");
#else
    std::string driveParam;
#endif
    std::string deviceParam;
    switch (type) {
        case IMAGE_TYPE_SYSTEM:
            driveParam += StringFormat("index=%d,id=system,file=%s"
                                       PATH_SEP "system.img.qcow2",
                                        idx++,
                                        avdContentPath);
            // API 15 and under images need a read+write
            // system image.
            if (apiLevel > 15) {
                // API > 15 uses read-only system partition.
                // You can override this explicitly
                // by passing -writable-system to emulator.
                if (!writable)
                    driveParam += ",read-only";
            }
            deviceParam = StringFormat("%s,drive=system",
                                       kTarget.storageDeviceType);
            break;
        case IMAGE_TYPE_CACHE:
            driveParam += StringFormat("index=%d,id=cache,file=%s.qcow2",
                                      idx++,
                                      hw->disk_cachePartition_path);
            deviceParam = StringFormat("%s,drive=cache",
                                       kTarget.storageDeviceType);
            break;
        case IMAGE_TYPE_USER_DATA:
            driveParam += StringFormat("index=%d,id=userdata,file=%s.qcow2",
                                      idx++,
                                      hw->disk_dataPartition_path);
            deviceParam = StringFormat("%s,drive=userdata",
                                       kTarget.storageDeviceType);
            break;
        case IMAGE_TYPE_SD_CARD:
            if (hw->hw_sdCard_path != NULL && strcmp(hw->hw_sdCard_path, "")) {
               driveParam += StringFormat("index=%d,id=sdcard,file=%s.qcow2",
                                         idx++, hw->hw_sdCard_path);
               deviceParam = StringFormat("%s,drive=sdcard",
                                          kTarget.storageDeviceType);
            } else {
                /* no sdcard is defined */
                return;
            }
            break;
        case IMAGE_TYPE_ENCRYPTION_KEY:
            if (android::featurecontrol::isEnabled(android::featurecontrol::EncryptUserData) &&
                hw->disk_encryptionKeyPartition_path != NULL && strcmp(hw->disk_encryptionKeyPartition_path, "")) {
               driveParam += StringFormat("index=%d,id=encrypt,file=%s.qcow2",
                                         idx++, hw->disk_encryptionKeyPartition_path);
               deviceParam = StringFormat("%s,drive=encrypt",
                                          kTarget.storageDeviceType);
            } else {
                /* no encryption partition is defined */
                return;
            }
            break;
        default:
            dwarning("Unknown Image type %d\n", type);
            return;
    }
    args[n++] = "-drive";
    args[n++] = ASTRDUP(driveParam.c_str());
    args[n++] = "-device";
    args[n++] = ASTRDUP(deviceParam.c_str());
    /* update the index */
    *argsPosition = n;
    *driveIndex = idx;
}


}  // namespace


extern "C" int run_qemu_main(int argc, const char **argv);

static void enter_qemu_main_loop(int argc, char **argv) {
#ifndef _WIN32
    sigset_t set;
    sigemptyset(&set);
    pthread_sigmask(SIG_SETMASK, &set, NULL);
#endif

    D("Starting QEMU main loop");
    run_qemu_main(argc, (const char**)argv);
    D("Done with QEMU main loop");

    if (android_init_error_occurred()) {
        skin_winsys_error_dialog(android_init_error_get_message(), "Error");
    }
}

#if defined(_WIN32)
// On Windows, link against qtmain.lib which provides a WinMain()
// implementation, that later calls qMain().
#define main qt_main
#endif

static bool createInitalEncryptionKeyPartition(AndroidHwConfig* hw) {
    char* userdata_dir = path_dirname(hw->disk_dataPartition_path);
    if (!userdata_dir) {
        derror("no userdata_dir");
        return false;
    }
    hw->disk_encryptionKeyPartition_path = path_join(userdata_dir, "encryptionkey.img");
    free(userdata_dir);
    if (path_exists(hw->disk_systemPartition_initPath)) {
        char* sysimg_dir = path_dirname(hw->disk_systemPartition_initPath);
        if (!sysimg_dir) {
            derror("no sysimg_dir %s", hw->disk_systemPartition_initPath);
            return false;
        }
        char* init_encryptionkey_img_path = path_join(sysimg_dir, "encryptionkey.img");
        free(sysimg_dir);
        if (path_exists(init_encryptionkey_img_path)) {
            if (path_copy_file(hw->disk_encryptionKeyPartition_path, init_encryptionkey_img_path) >= 0) {
                free(init_encryptionkey_img_path);
                return true;
            }
        } else {
            derror("no init encryptionkey.img");
        }
        free(init_encryptionkey_img_path);
    } else {
        derror("no system partition %s", hw->disk_systemPartition_initPath);
    }
    return false;
}

extern "C" int main(int argc, char **argv) {
    process_early_setup(argc, argv);

    if (argc < 1) {
        fprintf(stderr, "Invalid invocation (no program path)\n");
        return 1;
    }

    /* The emulator always uses the first serial port for kernel messages
     * and the second one for qemud. So start at the third if we need one
     * for logcat or 'shell'
     */
    const char* args[128];
    args[0] = argv[0];
    int n = 1;  // next parameter index

    AndroidHwConfig* hw = android_hw;
    AvdInfo* avd;
    AndroidOptions opts[1];
    int exitStatus = 0;

    if (!emulator_parseCommonCommandLineOptions(&argc,
                                                &argv,
                                                kTarget.androidArch,
                                                true,  // is_qemu2
                                                opts,
                                                hw,
                                                &android_avdInfo,
                                                &exitStatus)) {
        // Special case for QEMU positional parameters.
        if (exitStatus == EMULATOR_EXIT_STATUS_POSITIONAL_QEMU_PARAMETER) {
            // Copy all QEMU options to |args|, and set |n| to the number
            // of options in |args| (|argc| must be positive here).
            for (n = 1; n <= argc; ++n) {
                args[n] = argv[n - 1];
            }

            // Skip the translation of command-line options and jump
            // straight to qemu_main().
            enter_qemu_main_loop(n, (char**)args);
            return 0;
        }

        // Normal exit.
        return exitStatus;
    }
    // just because we know that we're in the new emulator as we got here
    opts->ranchu = 1;

    avd = android_avdInfo;

    if (!emulator_parseUiCommandLineOptions(opts, avd, hw)) {
        return 1;
    }

    char boot_prop_ip[128] = {};
    if (opts->shared_net_id) {
        char*  end;
        long   shared_net_id = strtol(opts->shared_net_id, &end, 0);
        if (end == NULL || *end || shared_net_id < 1 || shared_net_id > 255) {
            fprintf(stderr, "option -shared-net-id must be an integer between 1 and 255\n");
            return 1;
        }
        snprintf(boot_prop_ip, sizeof(boot_prop_ip),
                 "net.shared_net_ip=10.1.2.%ld", shared_net_id);
    }
    if (boot_prop_ip[0]) {
        args[n++] = "-boot-property";
        args[n++] = boot_prop_ip;
    }

#ifdef CONFIG_NAND_LIMITS
    if (opts->nand_limits) {
        args[n++] = "-nand-limits";
        args[n++] = opts->nand_limits;
    }
#endif

    if (opts->timezone) {
        args[n++] = "-timezone";
        args[n++] = opts->timezone;
    }

    if (opts->audio && !strcmp(opts->audio, "none")) {
        args[n++] = "-no-audio";
    }

    if (opts->cpu_delay) {
        args[n++] = "-cpu-delay";
        args[n++] = opts->cpu_delay;
    }

    if (opts->dns_server) {
        args[n++] = "-dns-server";
        args[n++] = opts->dns_server;
    }

    if (opts->skip_adb_auth) {
        args[n++] = "-skip-adb-auth";
    }

    /** SNAPSHOT STORAGE HANDLING */

    /* If we have a valid snapshot storage path */

    if (opts->snapstorage) {
        // NOTE: If QEMU2_SNAPSHOT_SUPPORT is not defined, a warning has been
        //       already printed by emulator_parseCommonCommandLineOptions().
#ifdef QEMU2_SNAPSHOT_SUPPORT
        /* We still use QEMU command-line options for the following since
        * they can change from one invokation to the next and don't really
        * correspond to the hardware configuration itself.
        */
        if (!opts->no_snapshot_load) {
            args[n++] = "-loadvm";
            args[n++] = ASTRDUP(opts->snapshot);
        }

        if (!opts->no_snapshot_save) {
            args[n++] = "-savevm-on-exit";
            args[n++] = ASTRDUP(opts->snapshot);
        }

        if (opts->no_snapshot_update_time) {
            args[n++] = "-snapshot-no-time-update";
        }
#endif  // QEMU2_SNAPSHOT_SUPPORT
    }

    {
        // Always setup a single serial port, that can be connected
        // either to the 'null' chardev, or the -shell-serial one,
        // which by default will be either 'stdout' (Posix) or 'con:'
        // (Windows).
        const char* serial =
                (opts->shell || opts->logcat || opts->show_kernel)
                ? opts->shell_serial : "null";
        args[n++] = "-serial";
        args[n++] = serial;
    }

    if (opts->radio) {
        args[n++] = "-radio";
        args[n++] = opts->radio;
    }

    if (opts->gps) {
        args[n++] = "-gps";
        args[n++] = opts->gps;
    }

    if (opts->code_profile) {
        args[n++] = "-code-profile";
        args[n++] = opts->code_profile;
    }

    /* Pass boot properties to the core. First, those from boot.prop,
     * then those from the command-line */
    const FileData* bootProperties = avdInfo_getBootProperties(avd);
    if (!fileData_isEmpty(bootProperties)) {
        PropertyFileIterator iter[1];
        propertyFileIterator_init(iter,
                                  bootProperties->data,
                                  bootProperties->size);
        while (propertyFileIterator_next(iter)) {
            char temp[MAX_PROPERTY_NAME_LEN + MAX_PROPERTY_VALUE_LEN + 2];
            snprintf(temp, sizeof temp, "%s=%s", iter->name, iter->value);
            args[n++] = "-boot-property";
            args[n++] = ASTRDUP(temp);
        }
    }

    if (opts->prop != NULL) {
        ParamList*  pl = opts->prop;
        for ( ; pl != NULL; pl = pl->next ) {
            args[n++] = "-boot-property";
            args[n++] = pl->param;
        }
    }

    if (opts->ports) {
        args[n++] = "-android-ports";
        args[n++] = opts->ports;
    }

    if (opts->port) {
        int console_port = -1;
        int adb_port = -1;
        if (!android_parse_port_option(opts->port, &console_port, &adb_port)) {
            return 1;
        }
        std::string portsOption = StringFormat("%d,%d",
                                               console_port, adb_port);
        args[n++] = "-android-ports";
        args[n++] = strdup(portsOption.c_str());
    }

    if (opts->report_console) {
        args[n++] = "-android-report-console";
        args[n++] = opts->report_console;
    }

    if (opts->http_proxy) {
        if (!qemu_android_setup_http_proxy(opts->http_proxy)) {
            return 1;
        }
    }

    if (!opts->charmap) {
        /* Try to find a valid charmap name */
        char* charmap = avdInfo_getCharmapFile(avd, hw->hw_keyboard_charmap);
        if (charmap != NULL) {
            D("autoconfig: -charmap %s", charmap);
            opts->charmap = charmap;
        }
    }

    if (opts->charmap) {
        char charmap_name[SKIN_CHARMAP_NAME_SIZE];

        if (!path_exists(opts->charmap)) {
            derror("Charmap file does not exist: %s", opts->charmap);
            return 1;
        }
        /* We need to store the charmap name in the hardware configuration.
         * However, the charmap file itself is only used by the UI component
         * and doesn't need to be set to the emulation engine.
         */
        kcm_extract_charmap_name(opts->charmap, charmap_name,
                                 sizeof(charmap_name));
        reassign_string(&hw->hw_keyboard_charmap, charmap_name);
    }

// TODO: imement network
#if 0
    /* Set up the interfaces for inter-emulator networking */
    if (opts->shared_net_id) {
        unsigned int shared_net_id = atoi(opts->shared_net_id);
        char nic[37];

        args[n++] = "-net";
        args[n++] = "nic,vlan=0";
        args[n++] = "-net";
        args[n++] = "user,vlan=0";

        args[n++] = "-net";
        snprintf(nic, sizeof nic, "nic,vlan=1,macaddr=52:54:00:12:34:%02x", shared_net_id);
        args[n++] = strdup(nic);
        args[n++] = "-net";
        args[n++] = "socket,vlan=1,mcast=230.0.0.10:1234";
    }
#endif

    // Create userdata file from init version if needed.
    if (android_op_wipe_data || !path_exists(hw->disk_dataPartition_path)) {
        std::unique_ptr<char[]> initDir(avdInfo_getDataInitDirPath(avd));
        if (path_exists(initDir.get())) {
            std::string dataPath = PathUtils::join(
                    avdInfo_getContentPath(avd), "data");
            path_copy_dir(dataPath.c_str(), initDir.get());
            std::string adbKeyPath = PathUtils::join(
                    android::ConfigDirs::getUserDirectory(), "adbkey.pub");
            if (path_is_regular(adbKeyPath.c_str())
                    && path_can_read(adbKeyPath.c_str())) {
                std::string guestAdbKeyDir = PathUtils::join(
                        dataPath, "misc", "adb");
                std::string guestAdbKeyPath = PathUtils::join(
                        guestAdbKeyDir, "adb_keys");
                path_mkdir_if_needed(guestAdbKeyDir.c_str(), 0777);
                path_copy_file(
                        guestAdbKeyPath.c_str(),
                        adbKeyPath.c_str());
                android_chmod(guestAdbKeyPath.c_str(), 0777);
            } else {
                dwarning("cannot read adb public key file: %d",
                         adbKeyPath.c_str());
            }
            android_createExt4ImageFromDir(hw->disk_dataPartition_path,
                    dataPath.c_str(),
                    android_hw->disk_dataPartition_size,
                    "data");
            // TODO: remove dataPath folder
        } else if (path_exists(hw->disk_dataPartition_initPath)) {
            D("Creating: %s\n", hw->disk_dataPartition_path);

            if (path_copy_file(hw->disk_dataPartition_path,
                               hw->disk_dataPartition_initPath) < 0) {
                derror("Could not create %s: %s", hw->disk_dataPartition_path,
                       strerror(errno));
                return 1;
            }

            resizeExt4Partition(android_hw->disk_dataPartition_path,
                                android_hw->disk_dataPartition_size);
        } else {
            derror("Missing initial data partition file: %s",
                   hw->disk_dataPartition_initPath);
        }
    }
    else {
        // Resize userdata-qemu.img if the size is smaller than what config.ini
        // says.
        // This can happen as user wants a larger data partition without wiping
        // it.
        // b.android.com/196926
        System::FileSize current_data_size;
        if (System::get()->pathFileSize(hw->disk_dataPartition_path,
                                        &current_data_size)) {
            System::FileSize partition_size = static_cast<System::FileSize>(
                    android_hw->disk_dataPartition_size);
            if (android_hw->disk_dataPartition_size > 0 &&
                    current_data_size < partition_size) {
                dwarning("userdata partition is resized from %d M to %d M\n",
                         (int)(current_data_size / (1024 * 1024)),
                         (int)(partition_size / (1024 * 1024)));
                resizeExt4Partition(android_hw->disk_dataPartition_path,
                                    android_hw->disk_dataPartition_size);
            }
        }
    }

    //create encryptionkey.img file if needed
    if (android::featurecontrol::isEnabled(android::featurecontrol::EncryptUserData)) {
        if (hw->disk_encryptionKeyPartition_path == NULL) {
            if(!createInitalEncryptionKeyPartition(hw)) {
                derror("Encryption is requested but failed to create encrypt partition.");
                return 1;
            }
        }
    } else {
        dwarning("encryption is off");
    }

    bool createEmptyCacheFile = false;

    // Make sure there's a temp cache partition if there wasn't a permanent one
    if (!hw->disk_cachePartition_path ||
        strcmp(hw->disk_cachePartition_path, "") == 0) {
        str_reset(&hw->disk_cachePartition_path,
                  tempfile_path(tempfile_create()));
        createEmptyCacheFile = true;
    }

    createEmptyCacheFile |= !path_exists(hw->disk_cachePartition_path);

    if (createEmptyCacheFile) {
        D("Creating empty ext4 cache partition: %s",
          hw->disk_cachePartition_path);
        int ret = android_createEmptyExt4Image(
                hw->disk_cachePartition_path,
                hw->disk_cachePartition_size,
                "cache");
        if (ret < 0) {
            derror("Could not create %s: %s", hw->disk_cachePartition_path,
                   strerror(-ret));
            return 1;
        }
    }

    // Make sure we always use the custom Android CPU definition.
    args[n++] = "-cpu";
    args[n++] = kTarget.qemuCpu;

#if defined(TARGET_X86_64) || defined(TARGET_I386)
    char* accel_status = NULL;
    CpuAccelMode accel_mode = ACCEL_AUTO;
    const bool accel_ok = handleCpuAcceleration(opts, avd,
                                                &accel_mode, &accel_status);

    if (accel_mode == ACCEL_ON) {  // 'accel on' is specified'
        if (!accel_ok) {
            derror("CPU acceleration is not supported on this machine!");
            derror("Reason: %s", accel_status);
            return 1;
        }
        args[n++] = ASTRDUP(kEnableAccelerator);
    } else if (accel_mode == ACCEL_AUTO) {
        if (accel_ok) {
            args[n++] = ASTRDUP(kEnableAccelerator);
        }
    } // else accel is off and we don't need to add anything else

    AFREE(accel_status);
#else   // !TARGET_X86_64 && !TARGET_I386
    args[n++] = "-machine";
    args[n++] = "type=ranchu";
#endif  // !TARGET_X86_64 && !TARGET_I386

#if defined(TARGET_X86_64) || defined(TARGET_I386)
    // SMP Support.
    std::string ncores;
    if (hw->hw_cpu_ncore > 1) {
        args[n++] = "-smp";

#ifdef _WIN32
        if (hw->hw_cpu_ncore > 16) {
            dwarning("HAXM does not support more than 16 cores. Number of cores set to 16");
            hw->hw_cpu_ncore = 16;
        }
#endif
        ncores = StringFormat("cores=%ld", hw->hw_cpu_ncore);
        args[n++] = ncores.c_str();
    }
#endif  // !TARGET_X86_64 && !TARGET_I386

    // Memory size
    args[n++] = "-m";
    std::string memorySize = StringFormat("%ld", hw->hw_ramSize);
    args[n++] = memorySize.c_str();

    // Kernel command-line parameters.
    AndroidGlesEmulationMode glesMode = kAndroidGlesEmulationOff;
    if (hw->hw_gpu_enabled) {
        if (!strcmp(hw->hw_gpu_mode, "guest")) {
            glesMode = kAndroidGlesEmulationGuest;
        } else {
            glesMode = kAndroidGlesEmulationHost;
        }
    }

    uint64_t glesFramebufferCMA = 0ULL;
    if ((glesMode == kAndroidGlesEmulationGuest) ||
        (opts->gpu && !strcmp(opts->gpu, "guest")) ||
        !hw->hw_gpu_enabled) {
        // Set CMA (continguous memory allocation) to values that depend on
        // the desired resolution.
        // We will assume a double buffered 32-bit framebuffer
        // in the calculation.
        int framebuffer_width = hw->hw_lcd_width;
        int framebuffer_height = hw->hw_lcd_height;
        uint64_t bytes = framebuffer_width * framebuffer_height * 4;
        const uint64_t one_MB = 1024ULL * 1024;
        glesFramebufferCMA = (2 * bytes + one_MB - 1) / one_MB;
        VERBOSE_PRINT(init, "Adjusting Contiguous Memory Allocation "
                            "of %dx%d framebuffer for software renderer to %"
                            PRIu64 "MB.", framebuffer_width, framebuffer_height,
                            glesFramebufferCMA);
    } else {
        VERBOSE_PRINT(init, "Using default value for kernel "
                            "Contiguous Memory Allocation.");
    }


    int apiLevel = avd ? avdInfo_getApiLevel(avd) : 1000;

    char* kernel_parameters = emulator_getKernelParameters(
            opts, kTarget.androidArch, apiLevel, kTarget.ttyPrefix,
            hw->kernel_parameters, glesMode, glesFramebufferCMA,
            true  // isQemu2
            );
    if (!kernel_parameters) {
        return 1;
    }

    args[n++] = "-append";
    args[n++] = kernel_parameters;

    // Support for changing default lcd-density
    std::string lcd_density;
    if (hw->hw_lcd_density) {
        args[n++] = "-lcd-density";
        lcd_density = StringFormat("%d", hw->hw_lcd_density);
        args[n++] = lcd_density.c_str();
    }

    // Kernel image
    args[n++] = "-kernel";
    args[n++] = hw->kernel_path;

    // Ramdisk
    args[n++] = "-initrd";
    args[n++] = hw->disk_ramdisk_path;

    /*
     * add partition parameters with the sequence
     * pre-defined in targetInfo.imagePartitionTypes
     */
    int s;
    int drvIndex = 0;
    for (s = 0; s < kMaxPartitions; s++) {
        bool writable = (kTarget.imagePartitionTypes[s] == IMAGE_TYPE_SYSTEM) ?
                    android_op_writable_system : true;
        makePartitionCmd(args, &n, &drvIndex, hw,
                         kTarget.imagePartitionTypes[s], writable, apiLevel,
                         avdInfo_getContentPath(avd));
    }

    // Network
    args[n++] = "-netdev";
    args[n++] = "user,id=mynet";
    args[n++] = "-device";
    std::string netDevice =
            StringFormat("%s,netdev=mynet", kTarget.networkDeviceType);
    args[n++] = netDevice.c_str();
    args[n++] = "-show-cursor";

    // TODO: the following *should* re-enable -tcpdump in QEMU2 when we have
    // rebased to at least QEMU 2.5 - the standard -tcpdump flag
    // See http://wiki.qemu.org/ChangeLog/2.5#Network_2 and
    // http://wiki.qemu.org/download/qemu-doc.html#index-_002dobject
//    std::string tcpdumpArg;
//    if (opts->tcpdump) {
//        args[n++] = "-object";
//        tcpdumpArg = StringFormat("filter-dump,id=mytcpdump,netdev=mynet,file=%s",
//                                  opts->tcpdump);
//        args[n++] = tcpdumpArg.c_str();
//    }

    if (opts->tcpdump) {
        dwarning("The -tcpdump flag is not supported in QEMU2 yet and will "
                 "be ignored.");
    }

    // Graphics
    if (opts->no_window) {
        args[n++] = "-nographic";
        // also disable the qemu monitor which will otherwise grab stdio
        args[n++] = "-monitor";
        args[n++] = "none";
    }

    // Data directory (for keymaps and PC Bios).
    args[n++] = "-L";
    std::string dataDir = getNthParentDir(args[0], 3U);
    if (dataDir.empty()) {
        dataDir = "lib/pc-bios";
    } else {
        dataDir += "/lib/pc-bios";
    }
    args[n++] = dataDir.c_str();

    // Audio enable hda by default for x86 and x64 platforms
#if defined(TARGET_X86_64) || defined(TARGET_I386)
    args[n++] = "-soundhw";
    args[n++] = "hda";
#endif

    /* append extra qemu parameters if any */
    for (int idx = 0; kTarget.qemuExtraArgs[idx] != NULL; idx++) {
        args[n++] = kTarget.qemuExtraArgs[idx];
    }

    /* append the options after -qemu */
    for (int i = 0; i < argc; ++i) {
        args[n++] = argv[i];
    }

    /* Generate a hardware-qemu.ini for this AVD. The real hardware
     * configuration is ususally stored in several files, e.g. the AVD's
     * config.ini plus the skin-specific hardware.ini.
     *
     * The new file will group all definitions and will be used to
     * launch the core with the -android-hw <file> option.
     */
    {
        const char* coreHwIniPath = avdInfo_getCoreHwIniPath(avd);
        const auto hwIni = android::base::makeCustomScopedPtr(
                         iniFile_newEmpty(NULL), iniFile_free);
        androidHwConfig_write(hw, hwIni.get());

        if (filelock_create(coreHwIniPath) == NULL) {
            // The AVD is already in use
            derror("There's another emulator instance running with "
                   "the current AVD '%s'. Exiting...\n", avdInfo_getName(avd));
            return 1;
        }

        /* While saving HW config, ignore valueless entries. This will not break
         * anything, but will significantly simplify comparing the current HW
         * config with the one that has been associated with a snapshot (in case
         * VM starts from a snapshot for this instance of emulator). */
        if (iniFile_saveToFileClean(hwIni.get(), coreHwIniPath) < 0) {
            derror("Could not write hardware.ini to %s: %s", coreHwIniPath, strerror(errno));
            return 2;
        }
        args[n++] = "-android-hw";
        args[n++] = strdup(coreHwIniPath);

        crashhandler_copy_attachment(CRASH_AVD_HARDWARE_INFO, coreHwIniPath);

        /* In verbose mode, dump the file's content */
        if (VERBOSE_CHECK(init)) {
            FILE* file = fopen(coreHwIniPath, "rt");
            if (file == NULL) {
                derror("Could not open hardware configuration file: %s\n",
                       coreHwIniPath);
            } else {
                LineInput* input = lineInput_newFromStdFile(file);
                const char* line;
                printf("Content of hardware configuration file:\n");
                while ((line = lineInput_getLine(input)) !=  NULL) {
                    printf("  %s\n", line);
                }
                printf(".\n");
                lineInput_free(input);
                fclose(file);
            }
        }
    }

    args[n] = NULL;
    // Check if we had enough slots in |args|.
    assert(n < (int)(sizeof(args)/sizeof(args[0])));

    if(VERBOSE_CHECK(init)) {
        int i;
        printf("QEMU options list:\n");
        for(i = 0; i < n; i++) {
            printf("emulator: argv[%02d] = \"%s\"\n", i, args[i]);
        }
        /* Dump final command-line option to make debugging the core easier */
        printf("Concatenated QEMU options:\n");
        for (i = 0; i < n; i++) {
            /* To make it easier to copy-paste the output to a command-line,
             * quote anything that contains spaces.
             */
            if (strchr(args[i], ' ') != NULL) {
                printf(" '%s'", args[i]);
            } else {
                printf(" %s", args[i]);
            }
        }
        printf("\n");
    }

    qemu2_android_serialline_init();

    static UiEmuAgent uiEmuAgent;
    uiEmuAgent.battery = gQAndroidBatteryAgent;
    uiEmuAgent.cellular = gQAndroidCellularAgent;
    uiEmuAgent.clipboard = gQAndroidClipboardAgent;
    uiEmuAgent.finger = gQAndroidFingerAgent;
    uiEmuAgent.location = gQAndroidLocationAgent;
    uiEmuAgent.sensors = gQAndroidSensorsAgent;
    uiEmuAgent.telephony = gQAndroidTelephonyAgent;
    uiEmuAgent.userEvents = gQAndroidUserEventAgent;
    uiEmuAgent.window = gQAndroidEmulatorWindowAgent;

    // for now there's no uses of SettingsAgent, so we don't set it
    uiEmuAgent.settings = NULL;

    /* Setup SDL UI just before calling the code */
#ifndef _WIN32
    sigset_t set;
    sigfillset(&set);
    pthread_sigmask(SIG_SETMASK, &set, NULL);
#endif  // !_WIN32
    skin_winsys_init_args(argc, argv);
    if (!emulator_initUserInterface(opts, &uiEmuAgent)) {
        return 1;
    }

    skin_winsys_spawn_thread(opts->no_window, enter_qemu_main_loop, n, (char**)args);
    skin_winsys_enter_main_loop(opts->no_window);

    emulator_finiUserInterface();

    process_late_teardown();
    return 0;
}