Google Git
Sign in
qemu-android / qemu-android / b3dcf72e75cd5489b98fe650a0b710327f286fe7 / . / android / android-emu / android / main-common.c
blob: 4accf9e930ca3a9e58fbcbe12de919bff3b1ed2c [file] [log] [blame]
/* 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;
}