/* Copyright (C) 2011-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/main-common.h"

#include "android/avd/info.h"
#include "android/avd/util.h"
#include "android/camera/camera-list.h"
#include "android/cpu_accelerator.h"
#include "android/emulation/android_pipe_unix.h"
#include "android/emulation/bufprint_config_dirs.h"
#include "android/globals.h"
#include "android/kernel/kernel_utils.h"
#include "android/help.h"
#include "android/main-emugl.h"
#include "android/main-help.h"
#include "android/network/control.h"
#include "android/opengl/emugl_config.h"
#include "android/resource.h"
#include "android/snapshot.h"
#include "android/user-config.h"
#include "android/utils/bufprint.h"
#include "android/utils/debug.h"
#include "android/utils/dirscanner.h"
#include "android/utils/dns.h"
#include "android/utils/eintr_wrapper.h"
#include "android/utils/host_bitness.h"
#include "android/utils/path.h"
#include "android/utils/stralloc.h"
#include "android/utils/string.h"
#include "android/utils/x86_cpuid.h"
#include "android/version.h"

#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#ifdef _WIN32
#include <process.h>
#endif
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/time.h>
#include <unistd.h>

const char*  android_skin_net_speed = NULL;
const char*  android_skin_net_delay = NULL;

/***********************************************************************/
/***********************************************************************/
/*****                                                             *****/
/*****            U T I L I T Y   R O U T I N E S                  *****/
/*****                                                             *****/
/***********************************************************************/
/***********************************************************************/

#define  D(...)  do {  if (VERBOSE_CHECK(init)) dprint(__VA_ARGS__); } while (0)

// TODO(digit): Remove this!
// The plan is to move the -wipe-data and -writable-system feature to the
// top-level 'emulator' launcher program, so that the engines don't have
// to meddle with partition images, except for mounting them. The alternative
// is to add new QEMU1 and QEMU2 options to pass the corresponding flags,
// which is overkill, given this plan.
bool android_op_wipe_data = false;
bool android_op_writable_system = false;
const char *savevm_on_exit = NULL;

bool emulator_has_network_option = false;

#define ONE_MB (1024 * 1024)

unsigned convertBytesToMB( uint64_t  size )
{
    if (size == 0)
        return 0;

    size = (size + ONE_MB-1) >> 20;
    if (size > UINT_MAX)
        size = UINT_MAX;

    return (unsigned) size;
}

uint64_t convertMBToBytes( unsigned  megaBytes )
{
    return ((uint64_t)megaBytes << 20);
}

/* Return the full file path of |fileName| relative to |rootPath|.
 * Return a new heap-allocated string to be freed by the caller. Note that
 * if |fileName| is an absolute path, the function returns a copy and ignores
 * |rootPath|.
 */
static char*
_getFullFilePath(const char* rootPath, const char* fileName) {
    if (path_is_absolute(fileName)) {
        return ASTRDUP(fileName);
    } else {
        char temp[PATH_MAX], *p=temp, *end=p+sizeof(temp);

        p = bufprint(temp, end, "%s/%s", rootPath, fileName);
        if (p >= end) {
            return NULL;
        }
        return ASTRDUP(temp);
    }
}

static uint64_t
_adjustPartitionSize( const char*  description,
                      uint64_t     imageBytes,
                      uint64_t     defaultBytes,
                      int          inAndroidBuild )
{
    char      temp[64];
    unsigned  imageMB;
    unsigned  defaultMB;

    if (imageBytes <= defaultBytes)
        return defaultBytes;

    imageMB   = convertBytesToMB(imageBytes);
    defaultMB = convertBytesToMB(defaultBytes);

    if (imageMB > defaultMB) {
        snprintf(temp, sizeof temp, "(%d MB > %d MB)", imageMB, defaultMB);
    } else {
        snprintf(temp, sizeof temp, "(%" PRIu64 "  bytes > %" PRIu64 " bytes)", imageBytes, defaultBytes);
    }

    if (inAndroidBuild) {
        dwarning("%s partition size adjusted to match image file %s\n", description, temp);
    }

    return convertMBToBytes(imageMB);
}

/* this function is used to perform auto-detection of the
 * system directory in the case of a SDK installation.
 *
 * we want to deal with several historical usages, hence
 * the slightly complicated logic.
 *
 * NOTE: the function returns the path to the directory
 *       containing 'fileName'. this is *not* the full
 *       path to 'fileName'.
 */
static char*
_getSdkImagePath( const char*  fileName )
{
    char   temp[MAX_PATH];
    char*  p   = temp;
    char*  end = p + sizeof(temp);
    char*  q;
    char*  app;

    static const char* const  searchPaths[] = {
        "",                                  /* program's directory */
        "/lib/images",                       /* this is for SDK 1.0 */
        "/../platforms/android-1.1/images",  /* this is for SDK 1.1 */
        NULL
    };

    app = bufprint_app_dir(temp, end);
    if (app >= end)
        return NULL;

    do {
        int  nn;

        /* first search a few well-known paths */
        for (nn = 0; searchPaths[nn] != NULL; nn++) {
            p = bufprint(app, end, "%s", searchPaths[nn]);
            q = bufprint(p, end, "/%s", fileName);
            if (q < end && path_exists(temp)) {
                *p = 0;
                goto FOUND_IT;
            }
        }

        /* hmmm. let's assume that we are in a post-1.1 SDK
         * scan ../platforms if it exists
         */
        p = bufprint(app, end, "/../platforms");
        if (p < end) {
            DirScanner*  scanner = dirScanner_new(temp);
            if (scanner != NULL) {
                int          found = 0;
                const char*  subdir;

                for (;;) {
                    subdir = dirScanner_next(scanner);
                    if (!subdir) break;

                    q = bufprint(p, end, "/%s/images/%s", subdir, fileName);
                    if (q >= end || !path_exists(temp))
                        continue;

                    found = 1;
                    p = bufprint(p, end, "/%s/images", subdir);
                    break;
                }
                dirScanner_free(scanner);
                if (found)
                    break;
            }
        }

        /* I'm out of ideas */
        return NULL;

    } while (0);

FOUND_IT:
    //D("image auto-detection: %s/%s", temp, fileName);
    return android_strdup(temp);
}

static char*
_getSdkImage( const char*  path, const char*  file )
{
    char  temp[MAX_PATH];
    char  *p = temp, *end = p + sizeof(temp);

    p = bufprint(temp, end, "%s/%s", path, file);
    if (p >= end || !path_exists(temp))
        return NULL;

    return android_strdup(temp);
}

static char*
_getSdkSystemImage( const char*  path, const char*  optionName, const char*  file )
{
    char*  image = _getSdkImage(path, file);

    if (image == NULL) {
        derror("Your system directory is missing the '%s' image file.\n"
               "Please specify one with the '%s <filepath>' option",
               file, optionName);
        exit(2);
    }
    return image;
}

static void sanitizeOptions(AndroidOptions* opts) {
    /* legacy support: we used to use -system <dir> and -image <file>
     * instead of -sysdir <dir> and -system <file>, so handle this by checking
     * whether the options point to directories or files.
     */
    if (opts->image != NULL) {
        if (opts->system != NULL) {
            if (opts->sysdir != NULL) {
                derror( "You can't use -sysdir, -system and -image at the same time.\n"
                        "You should probably use '-sysdir <path> -system <file>'.\n" );
                exit(2);
            }
        }
        dwarning( "Please note that -image is obsolete and that -system is now used to point\n"
                  "to the system image. Next time, try using '-sysdir <path> -system <file>' instead.\n" );
        str_reset(&opts->sysdir, opts->system);
        str_reset(&opts->system, opts->image);
        str_reset_null(&opts->image);
    }
    else if (opts->system != NULL && path_is_dir(opts->system)) {
        if (opts->sysdir != NULL) {
            derror( "Option -system should now be followed by a file path, not a directory one.\n"
                    "Please use '-sysdir <path>' to point to the system directory.\n" );
            exit(1);
        }
        dwarning( "Please note that the -system option should now be used to point to the initial\n"
                  "system image (like the obsolete -image option). To point to the system directory\n"
                  "please now use '-sysdir <path>' instead.\n" );

        str_reset(&opts->sysdir, opts->system);
        str_reset_null(&opts->system);
    }

    if (opts->nojni) {
        opts->no_jni = opts->nojni;
        opts->nojni  = 0;
    }

    if (opts->nocache) {
        opts->no_cache = opts->nocache;
        opts->nocache  = 0;
    }

    if (opts->noaudio) {
        opts->no_audio = opts->noaudio;
        opts->noaudio  = 0;
    }

    if (opts->noskin) {
        opts->no_skin = opts->noskin;
        opts->noskin  = 0;
    }

    /* If -no-cache is used, ignore any -cache argument */
    if (opts->no_cache) {
        str_reset_null(&opts->cache);
    }

    /* the purpose of -no-audio is to disable sound output from the emulator,
     * not to disable Audio emulation. So simply force the 'none' backends */
    if (opts->no_audio) {
        str_reset(&opts->audio, "none");
    }

    /* without a skin, the emulator cannot know what screen dimensions are
     * approriate for the virtual device, which can result in improper
     * rendering. when creating a device through the AVD manager, a "magic"
     * skin will be created that will indicate what the appropriate screen
     * dimensions are. skins like this have a name <width>x<height>, indicating
     * the appropriate framebuffer size for the device.
     */
    if (opts->no_skin) {
        dwarning(
                "the -no-skin flag is obsolete. to have a non-skinned virtual "
                "device, create one through the AVD manager");
    }

    /* we don't accept -skindir without -skin now
     * to simplify the autoconfig stuff with virtual devices
     */
    if (opts->skindir) {
        if (!opts->skin) {
            derror( "the -skindir <path> option requires a -skin <name> option");
            exit(1);
        }
    }

    if (opts->bootchart) {
        char*  end;
        int timeout = strtol(opts->bootchart, &end, 10);
        if (timeout == 0) {
            str_reset_null(&opts->bootchart);
        } else if (timeout < 0 || timeout > 15 * 60) {
            derror( "timeout specified for -bootchart option is invalid.\n"
                    "please use integers between 1 and 900\n");
            exit(1);
        }
    }
}

static AvdInfo* createAVD(AndroidOptions* opts, int* inAndroidBuild) {
    AvdInfo* ret = NULL;
    char   tmp[MAX_PATH];
    char*  tmpend = tmp + sizeof(tmp);
    char*  android_build_root = NULL;
    char*  android_build_out  = NULL;

    /* If no AVD name was given, try to find the top of the
     * Android build tree
     */
    if (opts->avd == NULL) {
        do {
            char*  out = getenv("ANDROID_PRODUCT_OUT");

            if (out == NULL || out[0] == 0)
                break;

            if (!path_exists(out)) {
                derror("Can't access ANDROID_PRODUCT_OUT as '%s'\n"
                    "You need to build the Android system before launching the emulator",
                    out);
                exit(2);
            }

            android_build_root = getenv("ANDROID_BUILD_TOP");
            if (android_build_root == NULL || android_build_root[0] == 0)
                break;

            if (!path_exists(android_build_root)) {
                derror("Can't find the Android build root '%s'\n"
                    "Please check the definition of the ANDROID_BUILD_TOP variable.\n"
                    "It should point to the root of your source tree.\n",
                    android_build_root );
                exit(2);
            }
            android_build_out = out;
            D( "found Android build root: %s", android_build_root );
            D( "found Android build out:  %s", android_build_out );
        } while (0);
    }
    /* if no virtual device name is given, and we're not in the
     * Android build system, we'll need to perform some auto-detection
     * magic :-)
     */
    if (opts->avd == NULL && !android_build_out)
    {
        if (!opts->sysdir) {
            str_reset_nocopy(&opts->sysdir, _getSdkImagePath("system.img"));
            if (!opts->sysdir) {
                derror(
                "You did not specify a virtual device name, and the system\n"
                "directory could not be found.\n\n"
                "If you are an Android SDK user, please use '@<name>' or '-avd <name>'\n"
                "to start a given virtual device (use -list-avds to print available ones).\n\n"

                "Otherwise, follow the instructions in -help-disk-images to start the emulator\n"
                );
                exit(2);
            }
            D("autoconfig: -sysdir %s", opts->sysdir);
        }

        if (!opts->system) {
            str_reset_nocopy(
                    &opts->system,
                    _getSdkSystemImage(opts->sysdir, "-image", "system.img"));
            D("autoconfig: -system %s", opts->system);
        }

        if (!opts->kernel) {
            str_reset_nocopy(
                    &opts->kernel,
                    _getSdkSystemImage(opts->sysdir, "-kernel", "kernel-qemu"));
            D("autoconfig: -kernel %s", opts->kernel);
        }

        if (!opts->ramdisk) {
            str_reset_nocopy(&opts->ramdisk,
                             _getSdkSystemImage(opts->sysdir, "-ramdisk",
                                                "ramdisk.img"));
            D("autoconfig: -ramdisk %s", opts->ramdisk);
        }

        /* if no data directory is specified, use the system directory */
        if (!opts->datadir) {
            str_reset(&opts->datadir, opts->sysdir);
            D("autoconfig: -datadir %s", opts->sysdir);
        }

        if (!opts->data) {
            /* check for userdata-qemu.img in the data directory */
            bufprint(tmp, tmpend, "%s/userdata-qemu.img", opts->datadir);
            if (!path_exists(tmp)) {
                derror(
                "You did not provide the name of an Android Virtual Device\n"
                "with the '-avd <name>' option. Read -help-avd for more information.\n\n"

                "If you *really* want to *NOT* run an AVD, consider using '-data <file>'\n"
                "to specify a data partition image file (I hope you know what you're doing).\n"
                );
                exit(2);
            }

            str_reset(&opts->data, tmp);
            D("autoconfig: -data %s", opts->data);
        }

        if (!opts->snapstorage && opts->datadir) {
            bufprint(tmp, tmpend, "%s/snapshots.img", opts->datadir);
            if (path_exists(tmp)) {
                str_reset(&opts->snapstorage, tmp);
                D("autoconfig: -snapstorage %s", opts->snapstorage);
            }
        }
    }

    /* setup the virtual device differently depending on whether
     * we are in the Android build system or not
     */
    if (opts->avd != NULL)
    {
        ret = avdInfo_new( opts->avd, android_avdParams );
        if (ret == NULL) {
            /* an error message has already been printed */
            dprint("could not find virtual device named '%s'", opts->avd);
            exit(1);
        }
    }
    else
    {
        if (!android_build_out) {
            android_build_out = android_build_root = opts->sysdir;
        }
        ret = avdInfo_newForAndroidBuild(
                            android_build_root,
                            android_build_out,
                            android_avdParams );

        if(ret == NULL) {
            D("could not start virtual device\n");
            exit(1);
        }
    }

    if (android_build_out) {
        *inAndroidBuild = 1;
    } else {
        *inAndroidBuild = 0;
    }

    return ret;
}

/*
 * handleCommonEmulatorOptions
 *
 * sets values in |hw| based on options set in |opts|
 *
 * Some values that may be set:
 *
 * kernel_path
 * hw_cpu_model
 * kernel_newDeviceNaming
 * kernel_supportsYaffs2
 * disk_ramdisk_path
 * disk_systemPartition_path
 * disk_systemPartition_initPath
 * disk_dataPartition_size
 * disk_cachePartition
 * disk_cachePartition_path
 * disk_cachePartition_size
 * hw_sdCard
 * hw_sdCard_path
 * hw_ramSize
 */
static bool emulator_handleCommonEmulatorOptions(AndroidOptions* opts,
                                                 AndroidHwConfig* hw,
                                                 AvdInfo* avd,
                                                 bool is_qemu2) {
    int forceArmv7 = 0;

    // Kernel options
    {
        char*  kernelFile    = opts->kernel;
        int    kernelFileLen;

        if (kernelFile == NULL) {
            kernelFile = is_qemu2 ?
                    avdInfo_getRanchuKernelPath(avd) :
                    avdInfo_getKernelPath(avd);
            if (kernelFile == NULL) {
                derror("This AVD's configuration is missing a kernel file! "
                       "Please ensure the file \"%s\" is in the same location "
                       "as your system image.",
                       is_qemu2 ? "kernel-ranchu" : "kernel-qemu");
                const char* sdkRootDir = getenv("ANDROID_SDK_ROOT");
                if (sdkRootDir) {
                    derror( "ANDROID_SDK_ROOT is defined (%s) but cannot find kernel file in "
                            "%s" PATH_SEP "system-images" PATH_SEP
                            " sub directories", sdkRootDir, sdkRootDir);
                } else {
                    derror( "ANDROID_SDK_ROOT is undefined");
                }
                return false;
            }
            D("autoconfig: -kernel %s", kernelFile);
        }
        if (!path_exists(kernelFile)) {
            derror( "Invalid or missing kernel image file: %s", kernelFile );
            free(kernelFile);
            return false;
        }

        str_reset_nocopy(&hw->kernel_path, kernelFile);

        /* If the kernel image name ends in "-armv7", then change the cpu
         * type automatically. This is a poor man's approach to configuration
         * management, but should allow us to get past building ARMv7
         * system images with dex preopt pass without introducing too many
         * changes to the emulator sources.
         *
         * XXX:
         * A 'proper' change would require adding some sort of hardware-property
         * to each AVD config file, then automatically determine its value for
         * full Android builds (depending on some environment variable), plus
         * some build system changes. I prefer not to do that for now for reasons
         * of simplicity.
         */
         kernelFileLen = strlen(kernelFile);
         if (kernelFileLen > 6 && !memcmp(kernelFile + kernelFileLen - 6, "-armv7", 6)) {
             forceArmv7 = 1;
         }
    }

    /* If the target ABI is armeabi-v7a, we can auto-detect the cpu model
     * as a cortex-a8, instead of the default (arm926) which only emulates
     * an ARMv5TE CPU.
     */
    if (!forceArmv7 && hw->hw_cpu_model[0] == '\0')
    {
        char* abi = avdInfo_getTargetAbi(avd);
        if (abi != NULL) {
            if (!strcmp(abi, "armeabi-v7a")) {
                forceArmv7 = 1;
            }
            AFREE(abi);
        }
    }

    /* If the target architecture is 'x86', ensure that the 'qemu32'
     * CPU model is used. Otherwise, the default (which is now 'qemu64')
     * will result in a failure to boot with some kernels under
     * un-accelerated emulation.
     */
    if (hw->hw_cpu_model[0] == '\0') {
        char* arch = avdInfo_getTargetCpuArch(avd);
        D("Target arch = '%s'", arch ? arch : "NULL");
        if (arch != NULL && !strcmp(arch, "x86")) {
            str_reset(&hw->hw_cpu_model, "qemu32");
            D("Auto-config: -qemu -cpu %s", hw->hw_cpu_model);
        }
        AFREE(arch);
    }

    if (forceArmv7 != 0) {
        str_reset(&hw->hw_cpu_model, "cortex-a8");
        D("Auto-config: -qemu -cpu %s", hw->hw_cpu_model);
    }

    char versionString[256];
    if (!android_pathProbeKernelVersionString(hw->kernel_path,
                                              versionString,
                                              sizeof(versionString))) {
        derror("Can't find 'Linux version ' string in kernel image file: %s",
               hw->kernel_path);
        return false;
    }

    KernelVersion kernelVersion = 0;
    if (!android_parseLinuxVersionString(versionString, &kernelVersion)) {
        derror("Can't parse 'Linux version ' string in kernel image file: '%s'",
               versionString);
        return false;
    }

    // make sure we're using the proper engine (qemu1/qemu2) for the kernel
    if (is_qemu2 && kernelVersion < KERNEL_VERSION_3_10_0) {
        derror("New emulator backend requires minimum kernel version 3.10+ (currently got lower)\n"
               "Please make sure you've got updated system images and do not force the specific "
               "kernel image together with the engine version");
        return false;
    } else if (!is_qemu2 && kernelVersion >= KERNEL_VERSION_3_10_0) {
        char* kernel_file = path_basename(hw->kernel_path);
        if (kernel_file && !strcmp(kernel_file, "kernel-ranchu")) {
            derror("This kernel requires the new emulation engine\n"
                   "Please do not force the specific kernel image together with the engine version");
            return false;
        }
        free(kernel_file);
    }

    // Auto-detect kernel device naming scheme if needed.
    if (androidHwConfig_getKernelDeviceNaming(hw) < 0) {
        const char* newDeviceNaming = "no";
        if (kernelVersion >= KERNEL_VERSION_3_10_0) {
            D("Auto-detect: Kernel image requires new device naming scheme.");
            newDeviceNaming = "yes";
        } else {
            D("Auto-detect: Kernel image requires legacy device naming scheme.");
        }
        str_reset(&hw->kernel_newDeviceNaming, newDeviceNaming);
    }

    // Auto-detect YAFFS2 partition support if needed.
    if (androidHwConfig_getKernelYaffs2Support(hw) < 0) {
        // Essentially, anything before API level 20 supports Yaffs2
        const char* newYaffs2Support = "no";
        if (avdInfo_getApiLevel(avd) < 20) {
            newYaffs2Support = "yes";
            D("Auto-detect: Kernel does support YAFFS2 partitions.");
        } else {
            D("Auto-detect: Kernel does not support YAFFS2 partitions.");
        }
        str_reset(&hw->kernel_supportsYaffs2, newYaffs2Support);
    }

    /* opts->ramdisk is never NULL (see createAVD) here */
    if (opts->ramdisk) {
        str_reset(&hw->disk_ramdisk_path, opts->ramdisk);
    }
    else if (!hw->disk_ramdisk_path[0]) {
        str_reset_nocopy(&hw->disk_ramdisk_path, avdInfo_getRamdiskPath(avd));
        D("autoconfig: -ramdisk %s", hw->disk_ramdisk_path);
    }

    /* -partition-size is used to specify the max size of both the system
     * and data partition sizes.
     */
    uint64_t defaultPartitionSize = convertMBToBytes(200);

    if (opts->partition_size) {
        char*  end;
        long   sizeMB = strtol(opts->partition_size, &end, 0);
        long   minSizeMB = 10;
        long   maxSizeMB = LONG_MAX / ONE_MB;

        if (sizeMB < 0 || *end != 0) {
            derror( "-partition-size must be followed by a positive integer" );
            exit(1);
        }
        if (sizeMB < minSizeMB || sizeMB > maxSizeMB) {
            derror( "partition-size (%d) must be between %dMB and %dMB",
                    sizeMB, minSizeMB, maxSizeMB );
            exit(1);
        }
        defaultPartitionSize = (uint64_t) sizeMB * ONE_MB;
    }


    /** SYSTEM PARTITION **/

    if (opts->sysdir == NULL) {
        if (avdInfo_inAndroidBuild(avd)) {
            str_reset(&opts->sysdir, avdInfo_getContentPath(avd));
            D("autoconfig: -sysdir %s", opts->sysdir);
        }
    }

    if (opts->sysdir != NULL) {
        if (!path_exists(opts->sysdir)) {
            derror("Directory does not exist: %s", opts->sysdir);
            return false;
        }
    }

    {
        char*  rwImage   = NULL;
        char*  initImage = NULL;

        do {
            if (opts->system == NULL) {
                /* If -system is not used, try to find a runtime system image
                * (i.e. system-qemu.img) in the content directory.
                */
                rwImage = avdInfo_getSystemImagePath(avd);
                if (rwImage != NULL) {
                    break;
                }
                /* Otherwise, try to find the initial system image */
                initImage = avdInfo_getSystemInitImagePath(avd);
                if (initImage == NULL) {
                    derror("No initial system image for this configuration!");
                    exit(1);
                }
                break;
            }

            /* If -system <name> is used, use it to find the initial image */
            if (opts->sysdir != NULL && !path_exists(opts->system)) {
                initImage = _getFullFilePath(opts->sysdir, opts->system);
            } else {
                initImage = ASTRDUP(opts->system);
            }
            if (!path_exists(initImage)) {
                derror("System image file doesn't exist: %s", initImage);
                exit(1);
            }

        } while (0);

        if (rwImage != NULL) {
            /* Use the read/write image file directly */
            str_reset_nocopy(&hw->disk_systemPartition_path, rwImage);
            str_reset_null(&hw->disk_systemPartition_initPath);
            D("Using direct system image: %s", rwImage);
        } else if (initImage != NULL) {
            str_reset_null(&hw->disk_systemPartition_path);
            str_reset_nocopy(&hw->disk_systemPartition_initPath, initImage);
            D("Using initial system image: %s", initImage);
        }

        /* Check the size of the system partition image.
        * If we have an AVD, it must be smaller than
        * the disk.systemPartition.size hardware property.
        *
        * Otherwise, we need to adjust the systemPartitionSize
        * automatically, and print a warning.
        *
        */
        const char* systemImage = hw->disk_systemPartition_path;
        uint64_t    systemBytes;

        if (systemImage == NULL)
            systemImage = hw->disk_systemPartition_initPath;

        if (path_get_size(systemImage, &systemBytes) < 0) {
            derror("Missing system image: %s", systemImage);
            return false;
        }

        hw->disk_systemPartition_size =
            _adjustPartitionSize("system", systemBytes, defaultPartitionSize,
                                 avdInfo_inAndroidBuild(avd));
    }

    /** DATA PARTITION **/

    if (opts->datadir) {
        if (!path_exists(opts->datadir)) {
            derror("Invalid -datadir directory: %s", opts->datadir);
        }
    }

    {
        char*  dataImage = NULL;
        char*  initImage = NULL;

        do {
            if (!opts->data) {
                dataImage = avdInfo_getDataImagePath(avd);
                if (dataImage != NULL) {
                    D("autoconfig: -data %s", dataImage);
                    break;
                }
                dataImage = avdInfo_getDefaultDataImagePath(avd);
                if (dataImage == NULL) {
                    derror("No data image path for this configuration!");
                    return false;
                }
                opts->wipe_data = 1;
                break;
            }

            if (opts->datadir) {
                dataImage = _getFullFilePath(opts->datadir, opts->data);
            } else {
                dataImage = ASTRDUP(opts->data);
            }
        } while (0);

        if (opts->initdata != NULL) {
            initImage = ASTRDUP(opts->initdata);
            if (!path_exists(initImage)) {
                derror("Invalid initial data image path: %s", initImage);
                return false;
            }
        } else {
            initImage = avdInfo_getDataInitImagePath(avd);
            D("autoconfig: -initdata %s", initImage);
        }

        str_reset(&hw->disk_dataPartition_path, dataImage);
        if (opts->wipe_data) {
            str_reset(&hw->disk_dataPartition_initPath, initImage);
        } else {
            str_reset_null(&hw->disk_dataPartition_initPath);
        }
        android_op_wipe_data = opts->wipe_data;
        android_op_writable_system = opts->writable_system;

        uint64_t defaultBytes = hw->disk_dataPartition_size;
        if (defaultBytes == 0 || opts->partition_size) {
            // If the -partition-size option is given that should override
            // whatever setting was in the config file.
            defaultBytes = defaultPartitionSize;
        }

        uint64_t     dataBytes;
        const char*  dataPath = hw->disk_dataPartition_initPath;

        if (dataPath == NULL)
            dataPath = hw->disk_dataPartition_path;

        path_get_size(dataPath, &dataBytes);

        hw->disk_dataPartition_size =
            _adjustPartitionSize("data", dataBytes, defaultBytes,
                                 avdInfo_inAndroidBuild(avd));
    }

    /** CACHE PARTITION **/

    if (opts->no_cache) {
        /* No cache partition at all */
        hw->disk_cachePartition = 0;
    }
    else if (!hw->disk_cachePartition) {
        if (opts->cache) {
            dwarning( "Emulated hardware doesn't support a cache partition. -cache option ignored!" );
            str_reset_null(&opts->cache);
        }
    }
    else
    {
        if (!opts->cache) {
            /* Find the current cache partition file */
            str_reset_nocopy(&opts->cache, avdInfo_getCachePath(avd));
            if (!opts->cache) {
                str_reset_nocopy(&opts->cache,
                                 avdInfo_getDefaultCachePath(avd));
            }
            if (opts->cache) {
                D("autoconfig: -cache %s", opts->cache);
            }
        }

        if (opts->cache) {
            str_reset(&hw->disk_cachePartition_path, opts->cache);
        }
    }

    str_reset(&hw->disk_encryptionKeyPartition_path, avdInfo_getEncryptionKeyImagePath(avd));

    if (hw->disk_cachePartition_path && opts->cache_size) {
        /* Set cache partition size per user options. */
        char*  end;
        long   sizeMB = strtol(opts->cache_size, &end, 0);

        if (sizeMB < 0 || *end != 0) {
            derror( "-cache-size must be followed by a positive integer" );
            return false;
        }
        hw->disk_cachePartition_size = (uint64_t) sizeMB * ONE_MB;
    }

    /** SD CARD PARTITION */

    if (!hw->hw_sdCard) {
        /* No SD Card emulation, so -sdcard will be ignored */
        if (opts->sdcard) {
            dwarning( "Emulated hardware doesn't support SD Cards. -sdcard option ignored." );
            str_reset_null(&opts->sdcard);
        }
    } else {
        /* Auto-configure -sdcard if it is not available */
        if (!opts->sdcard) {
            do {
                /* If -datadir <path> is used, look for a sdcard.img file here */
                if (opts->datadir) {
                    char tmp[PATH_MAX], *tmpend = tmp + sizeof(tmp);
                    bufprint(tmp, tmpend, "%s/%s", opts->datadir, "system.img");
                    if (path_exists(tmp)) {
                        str_reset(&opts->sdcard, tmp);
                        break;
                    }
                }

                /* Otherwise, look at the AVD's content */
                str_reset_nocopy(&opts->sdcard, avdInfo_getSdCardPath(avd));
                if (opts->sdcard != NULL) {
                    break;
                }

                /* Nothing */
            } while (0);

            if (opts->sdcard) {
                D("autoconfig: -sdcard %s", opts->sdcard);
            }
        }
    }

    if(opts->sdcard) {
        uint64_t  size;
        if (path_get_size(opts->sdcard, &size) == 0) {
            /* see if we have an sdcard image.  get its size if it exists */
            /* due to what looks like limitations of the MMC protocol, one has
             * to use an SD Card image that is equal or larger than 9 MB
             */
            if (size < 9*1024*1024ULL) {
                fprintf(stderr, "### WARNING: SD Card files must be at least 9MB, ignoring '%s'\n", opts->sdcard);
            } else {
                str_reset(&hw->hw_sdCard_path, opts->sdcard);
            }
        } else {
            dwarning("no SD Card image at '%s'", opts->sdcard);
        }
    }

    if (opts->selinux) {
        if ((strcmp(opts->selinux, "permissive") != 0)
                && (strcmp(opts->selinux, "disabled") != 0)) {
            derror("-selinux must be \"disabled\" or \"permissive\"");
            return false;
        }

        // SELinux 'disabled' mode is no longer supported starting with M.
        // See https://android-review.googlesource.com/#/c/148538/
        const int kSELinuxWithoutDisabledApiLevel = 23;
        if (!strcmp(opts->selinux, "disabled") &&
                avdInfo_getApiLevel(avd) >= kSELinuxWithoutDisabledApiLevel) {
            dwarning("SELinux 'disabled' is no longer supported starting "
                     "with API level %d, switching to 'permissive'",
                     kSELinuxWithoutDisabledApiLevel);
            str_reset(&opts->selinux, "permissive");
        }
    }

    if (opts->memory) {
        // override avd memory setting
        char*  end;
        long   ramSize = strtol(opts->memory, &end, 0);
        if (ramSize < 0 || *end != 0) {
            derror( "-memory must be followed by a positive integer" );
            return false;
        }
        hw->hw_ramSize = ramSize;
    }

    if (hw->hw_ramSize <= 0) {
        /* Compute the default RAM size based on the size of screen.
         * This is only used when the skin doesn't provide the ram
         * size through its hardware.ini (i.e. legacy ones) or when
         * in the full Android build system.
         */
        int64_t pixels  = hw->hw_lcd_width * hw->hw_lcd_height;
        /* The following thresholds are a bit liberal, but we
         * essentially want to ensure the following mappings:
         *
         *   320x480 -> 96
         *   800x600 -> 128
         *  1024x768 -> 256
         *
         * These are just simple heuristics, they could change in
         * the future.
         */
        if (pixels <= 250000)
            hw->hw_ramSize = 96;
        else if (pixels <= 500000)
            hw->hw_ramSize = 128;
        else
            hw->hw_ramSize = 256;
    }

    // all 64 bit archs we support include "64"
    bool guest_is_32_bit = strstr(hw->hw_cpu_arch, "64") == 0;
    bool host_is_32_bit = sizeof(void*) == 4;
    bool limit_is_4gb = (guest_is_32_bit || host_is_32_bit);

    // enforce CDD minimums
    int minRam = 32;
    if (avdInfo_getApiLevel(avd) >= 21) {
        if (guest_is_32_bit) {
            // TODO: adjust min based on screen size, wear, 23+
            // android wear min is actually 416 but most people boot phones
            minRam = 512;
        }
        else {
            minRam = 832;
        }
        if (!host_is_32_bit) {
            // This isn't a CDD minimum but was present in earlier versions of the emulator
            // For recent system versions, ensure a minimum of 1GB or memory, anything
            // lower is very painful during the boot process and after that.
            minRam = 1024;
        }
    }
    else if (avdInfo_getApiLevel(avd) >= 14) {
        minRam = 340;
    }
    else if (avdInfo_getApiLevel(avd) >= 9) {
        minRam = 128;
    }
    else if (avdInfo_getApiLevel(avd) >= 7) {
        minRam = 92;
    }

    if (hw->hw_ramSize < minRam) {
        D("Increasing RAM size to %iMB", minRam);
        hw->hw_ramSize = minRam;
    }
    else if (limit_is_4gb && hw->hw_ramSize > 4096) {
        D("Decreasing RAM size to 4096MB");
        hw->hw_ramSize = 4096;
    }
    else {
        D("Physical RAM size: %dMB\n", hw->hw_ramSize);
    }

    // Set the VM heap size to min vm heap per api level, but make sure we don't
    // overconstrain it - so increase it to RAM size / 4 up to 576 MB.
    // Larger VM heaps usually don't add any good, but only slow down the GC.
    // Also, we won't be able to allocate too huge single chunk or memory for a
    // heap anyway.
    const int minApiLevelVmHeapSize =
            androidHwConfig_getMinVmHeapSize(hw, avdInfo_getApiLevel(avd));
    const int minRamVmHeapSize = hw->hw_ramSize / 4;
    int vmHeapSize = minRamVmHeapSize > minApiLevelVmHeapSize
                             ? minRamVmHeapSize
                             : minApiLevelVmHeapSize;

    const int maxVmHeapSize =
            4 * minApiLevelVmHeapSize > 576 ? 576 : 4 * minApiLevelVmHeapSize;
    if (vmHeapSize > maxVmHeapSize) {
        vmHeapSize = maxVmHeapSize;
    }
    if (hw->vm_heapSize < vmHeapSize) {
        D("VM heap size %iMB is below hardware specified minimum of %iMB,"
          "setting it to that value",
          hw->vm_heapSize, vmHeapSize);

        hw->vm_heapSize = vmHeapSize;

        const int minRamSize = vmHeapSize * 2;
        if (hw->hw_ramSize < minRamSize) {
            hw->hw_ramSize = minRamSize;
            D("Increasing RAM to %iMB to accomodate min VM heap", minRamSize);
        }
    }

    const bool is_qemu1 = !is_qemu2;
    if (is_qemu1 && avdInfo_getSnapshotPresent(avd)) {
        const bool load_previous_snapshot = !opts->no_snapshot_load;
        const bool save_snapshot_on_exit = !opts->no_snapshot_save;
        if (load_previous_snapshot || save_snapshot_on_exit) {
            android_op_writable_system = true;
        }
    }

    if (!android_op_writable_system) {
        D("System image is read only");
    } else {
        dwarning("System image is writable");
    }

    return true;
}


bool handleCpuAcceleration(AndroidOptions* opts, const AvdInfo* avd,
                           CpuAccelMode* accel_mode, char** accel_status) {
    assert(accel_status != NULL);

    /* Handle CPU acceleration options. */
    if (opts->no_accel) {
        if (opts->accel) {
            if (strcmp(opts->accel, "off") != 0) {
                derror("You cannot use -no-accel and '-accel %s' at the same time",
                       opts->accel);
                exit(1);
            }
        } else {
            str_reset(&opts->accel, "off");
        }
    }

    *accel_mode = ACCEL_AUTO;
    if (opts->accel) {
        if (!strcmp(opts->accel, "off")) {
            *accel_mode = ACCEL_OFF;
        } else if (!strcmp(opts->accel, "on")) {
            *accel_mode = ACCEL_ON;
        } else if (!strcmp(opts->accel, "auto")) {
            *accel_mode = ACCEL_AUTO;
        } else {
            derror("Invalid '-accel %s' parameter, valid values are: on off auto\n",
                   opts->accel);
            exit(1);
        }
    }

    AndroidCpuAcceleration accel_capability = androidCpuAcceleration_getStatus(accel_status);
    bool accel_ok = (accel_capability == ANDROID_CPU_ACCELERATION_READY);
    // Dump CPU acceleration status.
    if (VERBOSE_CHECK(init)) {
        const char* accel_str = "DISABLED";
        if (accel_ok) {
            if (*accel_mode == ACCEL_OFF) {
                accel_str = "working, but disabled by user";
            } else {
                accel_str = "working";
            }
        }
        dprint("CPU Acceleration: %s", accel_str);
        dprint("CPU Acceleration status: %s", *accel_status);
    }

    // Special case: x86/x86_64 emulation currently requires hardware
    // acceleration, so refuse to start in 'auto' mode if it is not
    // available.
    {
        char* abi = avdInfo_getTargetAbi(avd);
        if (!strncmp(abi, "x86", 3)) {
            if (!accel_ok && *accel_mode != ACCEL_OFF) {
                derror("%s emulation currently requires hardware acceleration!\n"
                    "Please ensure %s is properly installed and usable.\n"
                    "CPU acceleration status: %s",
                    abi, kAccelerator, *accel_status);
                exit(1);
            }
            else if (*accel_mode == ACCEL_OFF) {
                // '-no-accel' of '-accel off' was used explicitly. Warn about
                // the issue but do not exit.
                dwarning("%s emulation may not work without hardware acceleration!", abi);
            }
            else {
                /* CPU acceleration is enabled and working, but if the host CPU
                 * does not support all instruction sets specified in the x86/
                 * x86_64 ABI, emulation may fail on unsupported instructions.
                 * Therefore, check the capabilities of the host CPU and warn
                 * the user if any required features are missing. */
                uint32_t ecx = 0;
                char buf[64], *p = buf, * const end = p + sizeof(buf);

                /* Execute CPUID instruction with EAX=1 and ECX=0 to get CPU
                 * feature bits (stored in EDX, ECX and EBX). */
                android_get_x86_cpuid(1, 0, NULL, NULL, &ecx, NULL);

                /* Theoretically, MMX and SSE/2/3 should be checked as well, but
                 * CPU models that do not support them are probably too old to
                 * run Android emulator. */
                if (!(ecx & CPUID_ECX_SSSE3)) {
                    p = bufprint(p, end, " SSSE3");
                }
                if (!strcmp(abi, "x86_64")) {
                    if (!(ecx & CPUID_ECX_SSE41)) {
                        p = bufprint(p, end, " SSE4.1");
                    }
                    if (!(ecx & CPUID_ECX_SSE42)) {
                        p = bufprint(p, end, " SSE4.2");
                    }
                    if (!(ecx & CPUID_ECX_POPCNT)) {
                        p = bufprint(p, end, " POPCNT");
                    }
                }

                if (p > buf) {
                    /* Using dwarning(..) would cause this message to be written
                     * to stdout and filtered out by AVD Manager. But we want
                     * the AVD Manager user to see this warning, so we resort to
                     * fprintf(..). */
                    fprintf(stderr, "emulator: WARNING: Host CPU is missing the"
                            " following feature(s) required for %s emulation:%s"
                            "\nHardware-accelerated emulation may not work"
                            " properly!\n", abi, buf);
                }
            }
        }
        AFREE(abi);
    }
    return accel_ok;
}

/*
 * Return true if software GPU is used and AVD screen is too large for it.
 * Software GPU can boot 800 X 1280 (first gen Nexus 7) or smaller due to
 * software buffer size. (It may actually boot a slightly larger screen,
 * but we set limit to this commonly seen resolution.)
 */
static bool use_software_gpu_and_screen_too_large(AndroidHwConfig* hw) {
    const int kMaxWidth = 1280;
    const int kMaxHeight = 800;

    if (!hw->hw_gpu_enabled &&
            (hw->hw_lcd_width * hw->hw_lcd_height > kMaxWidth * kMaxHeight)) {
        derror("GPU emulation is disabled.\n"
                   "Only screen size of 800 X 1280 or smaller is supported "
                   "when GPU emulation is disabled.");
        return true;
    }
    return false;
}

// _findQemuInformationalOption: search for informational QEMU options
//
// Scans the given command-line options for any informational QEMU option (see
// |qemu_info_opts| for the list of informational QEMU options). Returns the
// first matching option, or NULL if no match is found.
//
// |qemu_argc| is the number of command-line options in |qemu_argv|.
// |qemu_argv| is the array of command-line options to be searched. It is the
// caller's responsibility to ensure that all these options are intended for
// QEMU.
static char* _findQemuInformationalOption(int qemu_argc, char** qemu_argv) {
    /* Informational QEMU options, which make QEMU print some information to
     * the console and exit. */
    static const char* const qemu_info_opts[] = {
        "-h",
        "-help",
        "-version",
        "-audio-help",
        "?",           /* e.g. '-cpu ?' for listing available CPU models */
        NULL           /* denotes the end of the list */
    };
    int i = 0;

    for (; i < qemu_argc; i++) {
        char* arg = qemu_argv[i];
        const char* const* oo = qemu_info_opts;

        for (; *oo; oo++) {
            if (!strcmp(*oo, arg)) {
                return arg;
            }
        }
    }
    return NULL;
}

bool emulator_parseCommonCommandLineOptions(int* p_argc,
                                            char*** p_argv,
                                            const char* targetArch,
                                            bool is_qemu2,
                                            AndroidOptions* opts,
                                            AndroidHwConfig* hw,
                                            AvdInfo** the_avd,
                                            int* exit_status) {

    *exit_status = 1;

    if (android_parse_options(p_argc, p_argv, opts) < 0) {
        return false;
    }

    opts->ranchu = is_qemu2;

    while ((*p_argc)-- > 1) {
        const char* opt = (++*p_argv)[0];

        if(!strcmp(opt, "-qemu")) {
            --(*p_argc);
            ++(*p_argv);
            break;
        }

        int helpStatus = emulator_parseHelpOption(opt);
        if (helpStatus >= 0) {
            *exit_status = helpStatus;
            return false;
        }

        if (opt[0] == '-') {
            fprintf(stderr, "unknown option: %s\n", opt);
            fprintf(stderr, "please use -help for a list of valid options\n");
            return false;
        }

        fprintf(stderr, "invalid command-line parameter: %s.\n", opt);
        fprintf(stderr, "Hint: use '@foo' to launch a virtual device named 'foo'.\n");
        fprintf(stderr, "please use -help for more information\n");
        return false;
    }

    if (opts->version) {
      printf("Android emulator version %s\n"
             "Copyright (C) 2006-2015 The Android Open Source Project and many "
             "others.\n"
             "This program is a derivative of the QEMU CPU emulator "
             "(www.qemu.org).\n\n",
#if defined ANDROID_SDK_TOOLS_BUILD_NUMBER
             EMULATOR_VERSION_STRING " (build_id " STRINGIFY(ANDROID_SDK_TOOLS_BUILD_NUMBER) ")");
#else
             EMULATOR_VERSION_STRING);
#endif
        printf("  This software is licensed under the terms of the GNU General Public\n"
               "  License version 2, as published by the Free Software Foundation, and\n"
               "  may be copied, distributed, and modified under those terms.\n\n"
               "  This program is distributed in the hope that it will be useful,\n"
               "  but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
               "  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
               "  GNU General Public License for more details.\n\n");

        *exit_status = 0;
        return false;
    }

    if (opts->webcam_list) {
        android_camera_list_webcams();
        *exit_status = 0;
        return false;
    }

    if (opts->snapshot_list) {
        if (opts->snapstorage == NULL) {
            /* Need to find the default snapstorage */
            int inAndroidBuild = 0;
            AvdInfo* avd = createAVD(opts, &inAndroidBuild);
            str_reset(&opts->snapstorage, avdInfo_getSnapStoragePath(avd));
            avdInfo_free(avd);
            if (opts->snapstorage != NULL) {
                D("autoconfig: -snapstorage %s", opts->snapstorage);
            } else {
                if (inAndroidBuild) {
                    derror("You must use the -snapstorage <file> option to specify a snapshot storage file!\n");
                } else {
                    derror("This AVD doesn't have snapshotting enabled!\n");
                }
                return false;
            }
        }
        snapshot_print(opts->snapstorage);
        *exit_status = 0;
        return false;
    }

    // Both |argc| and |argv| have been modified by the big while loop above:
    // |argc| should now be the number of options after '-qemu', and if that is
    // positive, |argv| should point to the first option following '-qemu'.
    // Now we check if any of these QEMU options is an 'informational' option,
    // e.g. '-h', '-version', etc.
    // The extra pair of parentheses is to keep gcc happy.
    char* qemu_info_opt = _findQemuInformationalOption(*p_argc, *p_argv);
    if ( qemu_info_opt) {
        D("Found informational option '%s' after '-qemu'.\n"
          "All options before '-qemu' will be ignored!", qemu_info_opt);
        *exit_status = EMULATOR_EXIT_STATUS_POSITIONAL_QEMU_PARAMETER;
        return false;
    }

    sanitizeOptions(opts);

    if (opts->selinux) {
        if ((strcmp(opts->selinux, "permissive") != 0)
                && (strcmp(opts->selinux, "disabled") != 0)) {
            derror("-selinux must be \"disabled\" or \"permissive\"");
            return false;
        }
    }

    /* Parses options and builds an appropriate AVD. */
    int inAndroidBuild = 0;
    AvdInfo* avd = *the_avd = createAVD(opts, &inAndroidBuild);

    /* get the skin from the virtual device configuration */
    if (opts->skindir != NULL) {
        if (opts->skin == NULL) {
            /* NOTE: Normally handled by sanitizeOptions(), just be safe */
            derror("The -skindir <path> option requires a -skin <name> option");
            *exit_status = 2;
            return false;
        }
    } else {
        char* skinName;
        char* skinDir;

        avdInfo_getSkinInfo(avd, &skinName, &skinDir);

        if (opts->skin == NULL) {
            str_reset_nocopy(&opts->skin, skinName);
            D("autoconfig: -skin %s", opts->skin);
        } else {
            AFREE(skinName);
        }

        str_reset_nocopy(&opts->skindir, skinDir);
        D("autoconfig: -skindir %s", opts->skindir);
    }
    /* update the avd hw config from this new skin */
    avdInfo_getSkinHardwareIni(avd, opts->skin, opts->skindir);

    if (avdInfo_initHwConfig(avd, hw, is_qemu2) < 0) {
        derror("could not read hardware configuration ?");
        return false;
    }

    emulator_has_network_option =
            (opts->netspeed && (opts->netspeed[0] != '\0')) ||
            (opts->netdelay && (opts->netdelay[0] != '\0')) ||
            opts->netfast;

    if (!opts->netspeed && android_skin_net_speed) {
        D("skin network speed: '%s'", android_skin_net_speed);
        if (strcmp(android_skin_net_speed, NETWORK_SPEED_DEFAULT) != 0) {
            str_reset(&opts->netspeed, android_skin_net_speed);
        }
    }

    if (!opts->netdelay && android_skin_net_delay) {
        D("skin network delay: '%s'", android_skin_net_delay);
        if (strcmp(android_skin_net_delay, NETWORK_DELAY_DEFAULT) != 0) {
            str_reset(&opts->netdelay, android_skin_net_delay);
        }
    }

    /* Initialize net speed and delays stuff. */
    if (!android_network_set_speed(opts->netspeed)) {
        derror("invalid -netspeed parameter '%s'", opts->netspeed);
        return false;
    }

    if (!android_network_set_latency(opts->netdelay)) {
        derror("invalid -netdelay parameter '%s'", opts->netdelay);
        return false;
    }

    if (opts->netfast) {
        android_network_set_speed("full");
        android_network_set_latency("none");
    }

    if (opts->code_profile) {
        char* profilePath =
                avdInfo_getCodeProfilePath(avd, opts->code_profile);
        if (profilePath == NULL) {
            derror( "bad -code-profile parameter" );
            return false;
        }
        int ret = path_mkdir_if_needed(profilePath, 0755);
        if (ret < 0) {
            derror("could not create directory '%s'\n", profilePath);
            *exit_status = 2;
            return false;
        }
        str_reset_nocopy(&opts->code_profile, profilePath);
    }

    if (opts->unix_pipe) {
    }

    // Update CPU architecture for HW configs created from build directory.
    if (inAndroidBuild) {
        str_reset(&hw->hw_cpu_arch, targetArch);
    }

    if (!emulator_handleCommonEmulatorOptions(opts, hw, avd, is_qemu2)) {
        return false;
    }

    /** SNAPSHOT STORAGE HANDLING */

    /* Determine snapstorage path. -no-snapstorage disables all snapshotting
     * support. This means you can't resume a snapshot at load, save it at
     * exit, or even load/save them dynamically at runtime with the console.
     */
    if (opts->no_snapstorage) {
        if (opts->snapshot) {
            dwarning("ignoring -snapshot option due to the use of -no-snapstorage");
            str_reset_null(&opts->snapshot);
        }

        if (opts->snapstorage) {
            dwarning("ignoring -snapstorage option due to the use of -no-snapstorage");
            str_reset_null(&opts->snapstorage);
        }
    } else {
        if (!opts->snapstorage && avdInfo_getSnapshotPresent(avd)) {
            str_reset_nocopy(&opts->snapstorage,
                             avdInfo_getSnapStoragePath(avd));
            if (opts->snapstorage != NULL) {
                D("autoconfig: -snapstorage %s", opts->snapstorage);
            }
        }

        if (opts->snapstorage && !path_exists(opts->snapstorage)) {
            D("no image at '%s', state snapshots disabled", opts->snapstorage);
            str_reset_null(&opts->snapstorage);
        }
    }

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

    if (opts->snapstorage) {
        if (is_qemu2) {
            dwarning("QEMU2 does not support snapshots - option will be ignored.");
        } else {
            // QEMU2 does not support some of the flags below, and the emulator will
            // fail to start if they are passed in, so for now, ignore them.
            str_reset(&hw->disk_snapStorage_path, opts->snapstorage);

            /* -no-snapshot is equivalent to using both -no-snapshot-load
            * and -no-snapshot-save. You can still load/save snapshots dynamically
            * from the console though.
            */
            if (opts->no_snapshot) {
                opts->no_snapshot_load = 1;
                opts->no_snapshot_save = 1;
                if (opts->snapshot) {
                    dwarning("ignoring -snapshot option due to the use of -no-snapshot.");
                }
            }

            if (!opts->no_snapshot_load || !opts->no_snapshot_save) {
                if (opts->snapshot == NULL) {
                    str_reset(&opts->snapshot, "default-boot");
                    D("autoconfig: -snapshot %s", opts->snapshot);
                }
            }
        }
    }

    if (!opts->logcat || opts->logcat[0] == 0) {
        const char* env = getenv("ANDROID_LOG_TAGS");
        if (env && env[0]) {
            str_reset(&opts->logcat, env);
        } else {
            str_reset_null(&opts->logcat);
        }
    }

    /* XXXX: TODO: implement -shell and -logcat through qemud instead */
    if (!opts->shell_serial) {
#ifdef _WIN32
        str_reset(&opts->shell_serial, "con:");
#else
        str_reset(&opts->shell_serial, "stdio");
#endif
    } else {
        opts->shell = 1;
    }

    if (hw->vm_heapSize == 0) {
        /* Compute the default heap size based on the RAM size.
         * Essentially, we want to ensure the following liberal mappings:
         *
         *   96MB RAM -> 16MB heap
         *  128MB RAM -> 24MB heap
         *  256MB RAM -> 48MB heap
         */
        int  ramSize = hw->hw_ramSize;
        int  heapSize;

        if (ramSize < 100)
            heapSize = 16;
        else if (ramSize < 192)
            heapSize = 24;
        else
            heapSize = 48;

        hw->vm_heapSize = heapSize;
    }

    {
        EmuglConfig config;

        int api_level = avdInfo_getApiLevel(avd);
        char* api_arch = avdInfo_getTargetAbi(avd);
        bool isGoogle = avdInfo_isGoogleApis(avd);

        if (!androidEmuglConfigInit(&config,
                                    opts->avd,
                                    api_arch,
                                    api_level,
                                    isGoogle,
                                    opts->gpu,
                                    0,
                                    opts->no_window)) {
            derror("%s", config.status);
            return false;
        }

        // If the user is using -gpu off (not -gpu guest),
        // or if the API level is lower than 14 (Ice Cream Sandwich)
        // force 16-bit color depth.

        if (api_level < 14 || (opts->gpu && !strcmp(opts->gpu, "off"))) {
            hw->hw_lcd_depth = 16;
        }

        hw->hw_gpu_enabled = config.enabled;
        if (use_software_gpu_and_screen_too_large(hw)) {
            return false;
        }

        /* Update hw_gpu_mode with the canonical renderer name determined by
         * emuglConfig_init (host/guest/off/swiftshader etc)
         */
        str_reset(&hw->hw_gpu_mode, config.backend);
        D("%s", config.status);

#ifdef _WIN32
        // BUG: https://code.google.com/p/android/issues/detail?id=199427
        // Booting will be severely slowed down, if not disabled outright, when
        // 1. On Windows
        // 2. Using an AVD resolution of >= 1080p (can vary across host setups)
        // 3. -gpu mesa
        // What happens is that Mesa will hog the CPU, while disallowing
        // critical boot services from making progress, causing
        // the services to give up and put the emulator in a reboot loop
        // until it either fails to boot altogether or gets lucky and
        // successfully boots.
        // This workaround disables the boot animation under the above conditions,
        // which frees up the CPU enough for the device to boot.
        // ANGLE: ANGLE doesn't have GLESv1 support (for now),
        // so let's also disable the boot animation.
        const char* gpu_mode = opts->gpu ? opts->gpu : hw->hw_gpu_mode;
        if (gpu_mode && (!strcmp(gpu_mode, "mesa") ||
                         !strcmp(gpu_mode, "angle"))) {
            opts->no_boot_anim = 1;
            D("Starting AVD without boot animation.\n");
        }
#endif
    }

    /* Quit emulator on condition that both, gpu and snapstorage are on. This is
     * a temporary solution preventing the emulator from crashing until GPU state
     * can be properly saved / resored in snapshot file. */
    if (hw->hw_gpu_enabled && opts->snapstorage && (!opts->no_snapshot_load ||
                                                    !opts->no_snapshot_save)) {
        derror("Snapshots and gpu are mutually exclusive at this point. Please turn one of them off, and restart the emulator.");
        return false;
    }

    if (opts->camera_back) {
        /* Validate parameter. */
        if (memcmp(opts->camera_back, "webcam", 6) &&
            strcmp(opts->camera_back, "emulated") &&
            strcmp(opts->camera_back, "none")) {
            derror("Invalid value for -camera-back <mode> parameter: %s\n"
                   "Valid values are: 'emulated', 'webcam<N>', or 'none'\n",
                   opts->camera_back);
            return false;
        }
        str_reset(&hw->hw_camera_back, opts->camera_back);
    }

    if (opts->camera_front) {
        /* Validate parameter. */
        if (memcmp(opts->camera_front, "webcam", 6) &&
            strcmp(opts->camera_front, "emulated") &&
            strcmp(opts->camera_front, "none")) {
            derror("Invalid value for -camera-front <mode> parameter: %s\n"
                   "Valid values are: 'emulated', 'webcam<N>', or 'none'\n",
                   opts->camera_front);
            return false;
        }
        str_reset(&hw->hw_camera_front, opts->camera_front);
    }

    str_reset(&hw->avd_name, avdInfo_getName(avd));

    /* Setup screen emulation */
    if (opts->screen) {
        if (strcmp(opts->screen, "touch") &&
            strcmp(opts->screen, "multi-touch") &&
            strcmp(opts->screen, "no-touch")) {

            derror("Invalid value for -screen <mode> parameter: %s\n"
                   "Valid values are: touch, multi-touch, or no-touch\n",
                   opts->screen);
            return false;
        }
        str_reset(&hw->hw_screen, opts->screen);
    }

    // DNS server support. Validate the option if any, find the DNS
    // server IP addresses, then rewrite the option value with the
    // results.
    if (is_qemu2) {
        // Nothing to do here, everything will be handled by the glue
        // code (see android-qemu2-glue/qemu-setup-dns-servers.cpp).
    } else {
        // QEMU1 only supports IPv4 DNS servers, so use
        // android_dns_get_servers() that filters out any IPv6 server
        // from the -dns-server list.
        uint32_t dnsServers[ANDROID_MAX_DNS_SERVERS] = {};
        int dnsCount = android_dns_get_servers(opts->dns_server, dnsServers);
        if (dnsCount < 0) {
            return false;
        }
        // Rewrite the option with DNS server IPs.
        STRALLOC_DEFINE(newOption);
        int n;
        for (n = 0; n < dnsCount; ++n) {
            uint32_t ip = dnsServers[n];
            stralloc_add_format(newOption, "%s%d.%d.%d.%d", (n > 0) ? "," : "",
                                (uint8_t)(ip >> 24), (uint8_t)(ip >> 16),
                                (uint8_t)(ip >> 8), (uint8_t)(ip));
        }
        str_reset(&opts->dns_server, stralloc_cstr(newOption));
        stralloc_reset(newOption);
    }

    // Unix pipe paths
    {
        ParamList* opt = opts->unix_pipe;
        while (opt) {
            android_unix_pipes_add_allowed_path(opt->param);
            opt = opt->next;
        }
    }

    *exit_status = 0;
    return true;
}