| // Copyright 2014 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. |
| |
| // This source file implements emulator-arm64 and emulator64-arm64 |
| // which are used to launch QEMU binaries located under |
| // $PROGRAM_DIR/qemu/<host>/qemu-system-aarch64<exe> |
| |
| #include "android/base/containers/StringVector.h" |
| #include "android/base/files/PathUtils.h" |
| #include "android/base/Limits.h" |
| #include "android/base/Log.h" |
| #include "android/base/String.h" |
| #include "android/base/StringFormat.h" |
| |
| #include "android/cmdline-option.h" |
| #include "android/globals.h" |
| #include "android/help.h" |
| #include "android/filesystems/ext4_utils.h" |
| #include "android/kernel/kernel_utils.h" |
| #include "android/main-common.h" |
| #include "android/utils/bufprint.h" |
| #include "android/utils/debug.h" |
| #include "android/utils/path.h" |
| #include "android/utils/stralloc.h" |
| #include "android/utils/win32_cmdline_quote.h" |
| |
| #include <limits.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| |
| #define STRINGIFY(x) _STRINGIFY(x) |
| #define _STRINGIFY(x) #x |
| |
| #ifdef ANDROID_SDK_TOOLS_REVISION |
| # define VERSION_STRING STRINGIFY(ANDROID_SDK_TOOLS_REVISION)".0" |
| #else |
| # define VERSION_STRING "standalone" |
| #endif |
| |
| #define D(...) do { if (VERBOSE_CHECK(init)) dprint(__VA_ARGS__); } while (0) |
| |
| /* The execv() definition in older mingw is slightly bogus. |
| * It takes a second argument of type 'const char* const*' |
| * while POSIX mandates char** instead. |
| * |
| * To avoid compiler warnings, define the safe_execv macro |
| * to perform an explicit cast with mingw. |
| */ |
| #if defined(_WIN32) && !ANDROID_GCC_PREREQ(4,4) |
| # define safe_execv(_filepath,_argv) execv((_filepath),(const char* const*)(_argv)) |
| #else |
| # define safe_execv(_filepath,_argv) execv((_filepath),(_argv)) |
| #endif |
| |
| using namespace android::base; |
| |
| namespace { |
| |
| // The host CPU architecture. |
| #ifdef __i386__ |
| const char kHostArch[] = "x86"; |
| #elif defined(__x86_64__) |
| const char kHostArch[] = "x86_64"; |
| #else |
| #error "Your host CPU is not supported!" |
| #endif |
| |
| // The host operating system name. |
| #ifdef __linux__ |
| static const char kHostOs[] = "linux"; |
| #elif defined(__APPLE__) |
| static const char kHostOs[] = "darwin"; |
| #elif defined(_WIN32) |
| static const char kHostOs[] = "windows"; |
| #endif |
| |
| enum ImageType { |
| IMAGE_TYPE_SYSTEM = 0, |
| IMAGE_TYPE_CACHE, |
| IMAGE_TYPE_USER_DATA, |
| IMAGE_TYPE_SD_CARD, |
| }; |
| |
| const int kMaxPartitions = 4; |
| /* |
| * A structure used to model information about a given target CPU architecture. |
| * |androidArch| is the architecture name, following Android conventions. |
| * |qemuArch| is the same name, following QEMU conventions, used to locate |
| * the final qemu-system-<qemuArch> binary. |
| * |qemuCpu| is the QEMU -cpu parameter value. |
| * |ttyPrefix| is the prefix to use for TTY devices. |
| * |kernelExtraArgs|, if not NULL, is an optional string appended to the kernel |
| * parameters. |
| * |storageDeviceType| is the QEMU storage device type. |
| * |networkDeviceType| is the QEMU network device type. |
| * |imagePartitionTypes| defines the order of how the image partitions are |
| * listed in the command line, because the command line order determines which |
| * mount point the partition is attached to. For x86, the first partition |
| * listed in command line is mounted first, i.e. to /dev/block/vda, |
| * the next one to /dev/block/vdb, etc. However, for arm/mips, it's reversed; |
| * the last one is mounted to /dev/block/vda. the 2nd last to /dev/block/vdb. |
| * So far, we have 4(kMaxPartitions) types defined for system, cache, userdata |
| * and sdcard images. |
| */ |
| struct TargetInfo { |
| const char* androidArch; |
| const char* qemuArch; |
| const char* qemuCpu; |
| const char* ttyPrefix; |
| const char* kernelExtraArgs; |
| const char* storageDeviceType; |
| const char* networkDeviceType; |
| const ImageType imagePartitionTypes[kMaxPartitions]; |
| }; |
| |
| // The current target architecture information! |
| const TargetInfo kTarget = { |
| #ifdef TARGET_ARM64 |
| "arm64", |
| "aarch64", |
| "cortex-a57", |
| "ttyAMA", |
| " keep_bootcon earlyprintk=ttyAMA0", |
| "virtio-blk-device", |
| "virtio-net-device", |
| {IMAGE_TYPE_SD_CARD, IMAGE_TYPE_USER_DATA, IMAGE_TYPE_CACHE, IMAGE_TYPE_SYSTEM}, |
| #endif |
| #ifdef TARGET_MIPS64 |
| "mips64", |
| "mips64el", |
| "MIPS64R6-generic", |
| "ttyGF", |
| NULL, |
| "virtio-blk-device", |
| "virtio-net-device", |
| {IMAGE_TYPE_SD_CARD, IMAGE_TYPE_USER_DATA, IMAGE_TYPE_CACHE, IMAGE_TYPE_SYSTEM}, |
| #endif |
| }; |
| |
| String getNthParentDir(const char* path, size_t n) { |
| StringVector dir = PathUtils::decompose(path); |
| PathUtils::simplifyComponents(&dir); |
| if (dir.size() < n + 1U) { |
| return String(""); |
| } |
| dir.resize(dir.size() - n); |
| return PathUtils::recompose(dir); |
| } |
| |
| // Return the path of the QEMU executable |
| String getQemuExecutablePath(const char* programPath) { |
| StringVector path = PathUtils::decompose(programPath); |
| if (path.size() < 1) { |
| return String(); |
| } |
| // Remove program from path. |
| path.resize(path.size() - 1U); |
| |
| // Add sub-directories. |
| path.append(String("qemu")); |
| |
| String host = kHostOs; |
| host += "-"; |
| host += kHostArch; |
| path.append(host); |
| |
| String qemuProgram = "qemu-system-"; |
| qemuProgram += kTarget.qemuArch; |
| #ifdef _WIN32 |
| qemuProgram += ".exe"; |
| #endif |
| path.append(qemuProgram); |
| |
| return PathUtils::recompose(path); |
| } |
| |
| /* generate parameters for each partition by type. |
| * Param: |
| * args - array to hold parameters for qemu |
| * argsPosition - current index in the parameter array |
| * driveIndex - a sequence number for the drive parameter |
| * hw - the hardware configuration that conatains image info. |
| * type - what type of partition parameter to generate |
| */ |
| |
| void makePartitionCmd(const char** args, int* argsPosition, int* driveIndex, |
| AndroidHwConfig* hw, ImageType type) { |
| int n = *argsPosition; |
| int idx = *driveIndex; |
| |
| #if defined(TARGET_X86_64) || defined(TARGET_X86) |
| /* for x86, 'if=none' is necessary for virtio blk*/ |
| String driveParam("if=none,"); |
| #else |
| String driveParam; |
| #endif |
| String deviceParam; |
| |
| switch (type) { |
| case IMAGE_TYPE_SYSTEM: |
| driveParam += StringFormat("index=%d,id=system,file=%s", |
| idx++, |
| hw->disk_systemPartition_initPath); |
| deviceParam = StringFormat("%s,drive=system", |
| kTarget.storageDeviceType); |
| break; |
| case IMAGE_TYPE_CACHE: |
| driveParam += StringFormat("index=%d,id=cache,file=%s", |
| idx++, |
| hw->disk_cachePartition_path); |
| deviceParam = StringFormat("%s,drive=cache", |
| kTarget.storageDeviceType); |
| break; |
| case IMAGE_TYPE_USER_DATA: |
| driveParam += StringFormat("index=%d,id=userdata,file=%s", |
| idx++, |
| hw->disk_dataPartition_path); |
| deviceParam = StringFormat("%s,drive=userdata", |
| kTarget.storageDeviceType); |
| break; |
| case IMAGE_TYPE_SD_CARD: |
| if (hw->hw_sdCard_path != NULL && strcmp(hw->hw_sdCard_path, "")) { |
| driveParam += StringFormat("index=%d,id=sdcard,file=%s", |
| idx++, hw->hw_sdCard_path); |
| deviceParam = StringFormat("%s,drive=sdcard", |
| kTarget.storageDeviceType); |
| } else { |
| /* no sdcard is defined */ |
| return; |
| } |
| break; |
| default: |
| dwarning("Unknown Image type %d\n", type); |
| return; |
| } |
| args[n++] = "-drive"; |
| args[n++] = ASTRDUP(driveParam.c_str()); |
| args[n++] = "-device"; |
| args[n++] = ASTRDUP(deviceParam.c_str()); |
| /* update the index */ |
| *argsPosition = n; |
| *driveIndex = idx; |
| } |
| |
| void emulator_help( void ) { |
| STRALLOC_DEFINE(out); |
| android_help_main(out); |
| printf("%.*s", out->n, out->s); |
| stralloc_reset(out); |
| exit(1); |
| } |
| |
| 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); |
| } |
| |
| } // namespace |
| |
| extern "C" int main(int argc, char **argv, char **envp) { |
| if (argc < 1) { |
| fprintf(stderr, "Invalid invokation (no program path)\n"); |
| return 1; |
| } |
| |
| AndroidOptions opts[1]; |
| |
| if (android_parse_options(&argc, &argv, opts) < 0) { |
| return 1; |
| } |
| |
| // TODO(digit): This code is very similar to the one in main.c, |
| // refactor everything so that it fits into a single shared source |
| // file, if possible, with the least amount of dependencies. |
| |
| while (argc-- > 1) { |
| const char* opt = (++argv)[0]; |
| |
| if(!strcmp(opt, "-qemu")) { |
| argc--; |
| argv++; |
| break; |
| } |
| |
| if (!strcmp(opt, "-help")) { |
| emulator_help(); |
| } |
| |
| if (!strncmp(opt, "-help-",6)) { |
| STRALLOC_DEFINE(out); |
| opt += 6; |
| |
| if (!strcmp(opt, "all")) { |
| android_help_all(out); |
| } |
| else if (android_help_for_option(opt, out) == 0) { |
| /* ok */ |
| } |
| else if (android_help_for_topic(opt, out) == 0) { |
| /* ok */ |
| } |
| if (out->n > 0) { |
| printf("\n%.*s", out->n, out->s); |
| exit(0); |
| } |
| |
| fprintf(stderr, "unknown option: -help-%s\n", opt); |
| fprintf(stderr, "please use -help for a list of valid topics\n"); |
| exit(1); |
| } |
| |
| if (opt[0] == '-') { |
| fprintf(stderr, "unknown option: %s\n", opt); |
| fprintf(stderr, "please use -help for a list of valid options\n"); |
| exit(1); |
| } |
| |
| 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"); |
| exit(1); |
| } |
| |
| if (opts->version) { |
| printf("Android emulator version %s\n" |
| "Copyright (C) 2006-2011 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_BUILD_ID |
| VERSION_STRING " (build_id " STRINGIFY(ANDROID_BUILD_ID) ")" ); |
| #else |
| 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(0); |
| } |
| |
| sanitizeOptions(opts); |
| |
| // Ignore snapshot storage here. |
| |
| int inAndroidBuild = 0; |
| AvdInfo* avd = createAVD(opts, &inAndroidBuild); |
| |
| // Ignore skin options here. |
| |
| // Read hardware configuration, apply overrides from options. |
| AndroidHwConfig* hw = android_hw; |
| if (avdInfo_initHwConfig(avd, hw) < 0) { |
| derror("could not read hardware configuration ?"); |
| exit(1); |
| } |
| |
| /* Update CPU architecture for HW configs created from build dir. */ |
| if (inAndroidBuild) { |
| reassign_string(&android_hw->hw_cpu_arch, kTarget.androidArch); |
| } |
| |
| handleCommonEmulatorOptions(opts, hw, avd); |
| |
| if (opts->gpu) { |
| const char* gpu = opts->gpu; |
| if (!strcmp(gpu,"on") || !strcmp(gpu,"enable")) { |
| hw->hw_gpu_enabled = 1; |
| } else if (!strcmp(gpu,"off") || !strcmp(gpu,"disable")) { |
| hw->hw_gpu_enabled = 0; |
| } else if (!strcmp(gpu,"auto")) { |
| /* Nothing to do */ |
| } else { |
| derror("Invalid value for -gpu <mode> parameter: %s\n", gpu); |
| derror("Valid values are: on, off or auto\n"); |
| exit(1); |
| } |
| } |
| |
| hw->avd_name = ASTRDUP(avdInfo_getName(avd)); |
| |
| String qemuExecutable = getQemuExecutablePath(argv[0]); |
| D("QEMU EXECUTABLE=%s\n", qemuExecutable.c_str()); |
| |
| // Create userdata file from init version if needed. |
| if (!path_exists(hw->disk_dataPartition_path)) { |
| if (!path_exists(hw->disk_dataPartition_initPath)) { |
| derror("Missing initial data partition file: %s", |
| hw->disk_dataPartition_initPath); |
| exit(1); |
| } |
| D("Creating: %s\n", hw->disk_dataPartition_path); |
| |
| if (path_copy_file(hw->disk_dataPartition_path, |
| hw->disk_dataPartition_initPath) < 0) { |
| derror("Could not create %s: %s", hw->disk_dataPartition_path, |
| strerror(errno)); |
| exit(1); |
| } |
| } |
| |
| // Create cache partition image if it doesn't exist already. |
| if (!path_exists(hw->disk_cachePartition_path)) { |
| D("Creating empty ext4 cache partition: %s", |
| hw->disk_cachePartition_path); |
| int ret = android_createEmptyExt4Image( |
| hw->disk_cachePartition_path, |
| hw->disk_cachePartition_size, |
| "cache"); |
| if (ret < 0) { |
| derror("Could not create %s: %s", hw->disk_cachePartition_path, |
| strerror(-ret)); |
| exit(1); |
| } |
| } |
| |
| // Now build the QEMU parameters. |
| const char* args[128]; |
| int n = 0; |
| |
| args[n++] = qemuExecutable.c_str(); |
| |
| args[n++] = "-cpu"; |
| args[n++] = kTarget.qemuCpu; |
| args[n++] = "-machine"; |
| args[n++] = "type=ranchu"; |
| |
| // Memory size |
| args[n++] = "-m"; |
| String memorySize = StringFormat("%ld", hw->hw_ramSize); |
| args[n++] = memorySize.c_str(); |
| |
| // Command-line |
| args[n++] = "-append"; |
| |
| String kernelCommandLine = StringFormat("console=%s0,38400", |
| kTarget.ttyPrefix); |
| if (kTarget.kernelExtraArgs) { |
| kernelCommandLine += kTarget.kernelExtraArgs; |
| } |
| if (opts->selinux) { |
| kernelCommandLine += StringFormat( |
| " androidboot.selinux=%s", opts->selinux); |
| } |
| args[n++] = kernelCommandLine.c_str(); |
| |
| args[n++] = "-serial"; |
| args[n++] = "mon:stdio"; |
| |
| // Kernel image |
| args[n++] = "-kernel"; |
| args[n++] = hw->kernel_path; |
| |
| // Ramdisk |
| args[n++] = "-initrd"; |
| args[n++] = hw->disk_ramdisk_path; |
| |
| /* |
| * add partition parameters with the seqeuence |
| * pre-defined in targetInfo.imagePartitionTypes |
| */ |
| int s; |
| int drvIndex = 0; |
| for (s = 0; s < kMaxPartitions; s++) { |
| makePartitionCmd(args, &n, &drvIndex, hw, kTarget.imagePartitionTypes[s]); |
| } |
| |
| // Network |
| args[n++] = "-netdev"; |
| args[n++] = "user,id=mynet"; |
| args[n++] = "-device"; |
| String netDevice = |
| StringFormat("%s,netdev=mynet", kTarget.networkDeviceType); |
| args[n++] = netDevice.c_str(); |
| args[n++] = "-show-cursor"; |
| |
| // Graphics |
| if (opts->no_window) { |
| args[n++] = "-nographic"; |
| } |
| |
| // Data directory (for keymaps and PC Bios). |
| args[n++] = "-L"; |
| String dataDir = getNthParentDir(qemuExecutable.c_str(), 3U); |
| if (dataDir.empty()) { |
| dataDir = "lib/pc-bios"; |
| } else { |
| dataDir += "/lib/pc-bios"; |
| } |
| args[n++] = dataDir.c_str(); |
| args[n] = NULL; |
| |
| if(VERBOSE_CHECK(init)) { |
| int i; |
| printf("QEMU options list:\n"); |
| for(i = 0; i < n; i++) { |
| printf("emulator: argv[%02d] = \"%s\"\n", i, args[i]); |
| } |
| /* Dump final command-line option to make debugging the core easier */ |
| printf("Concatenated QEMU options:\n"); |
| for (i = 0; i < n; i++) { |
| /* To make it easier to copy-paste the output to a command-line, |
| * quote anything that contains spaces. |
| */ |
| if (strchr(args[i], ' ') != NULL) { |
| printf(" '%s'", args[i]); |
| } else { |
| printf(" %s", args[i]); |
| } |
| } |
| printf("\n"); |
| } |
| |
| if (!path_exists(qemuExecutable.c_str())) { |
| fprintf(stderr, "Missing QEMU executable: %s\n", |
| qemuExecutable.c_str()); |
| return 1; |
| } |
| |
| // Now launch executable. |
| #ifdef _WIN32 |
| // Take care of quoting all parameters before sending them to execv(). |
| // See the "Eveyone quotes command line arguments the wrong way" on |
| // MSDN. |
| int i; |
| for (i = 0; i < n; ++i) { |
| // Technically, this leaks the quoted strings, but we don't care |
| // since this process will terminate after the execv() anyway. |
| args[i] = win32_cmdline_quote(args[i]); |
| D("Quoted param: [%s]\n", args[i]); |
| } |
| #endif |
| |
| safe_execv(qemuExecutable.c_str(), (char* const*)args); |
| |
| fprintf(stderr, |
| "Could not launch QEMU [%s]: %s\n", |
| qemuExecutable.c_str(), |
| strerror(errno)); |
| |
| return errno; |
| } |
