You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
455 lines
17 KiB
455 lines
17 KiB
// Copyright 2020 The Android Open Source Project
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#pragma once
|
|
|
|
#include "hw-config.h"
|
|
#include "util.h"
|
|
#include "base/export.h"
|
|
|
|
class CIniFile;
|
|
|
|
/* An Android Virtual Device (AVD for short) corresponds to a
|
|
* directory containing all kernel/disk images for a given virtual
|
|
* device, as well as information about its hardware capabilities,
|
|
* SDK version number, skin, etc...
|
|
*
|
|
* Each AVD has a human-readable name and is backed by a root
|
|
* configuration file and a content directory. For example, an
|
|
* AVD named 'foo' will correspond to the following:
|
|
*
|
|
* - a root configuration file named ~/.android/avd/foo.ini
|
|
* describing where the AVD's content can be found
|
|
*
|
|
* - a content directory like ~/.android/avd/foo/ containing all
|
|
* disk image and configuration files for the virtual device.
|
|
*
|
|
* the 'foo.ini' file should contain at least one line of the form:
|
|
*
|
|
* rootPath=<content-path>
|
|
*
|
|
* it may also contain other lines that cache stuff found in the
|
|
* content directory, like hardware properties or SDK version number.
|
|
*
|
|
* it is possible to move the content directory by updating the foo.ini
|
|
* file to point to the new location. This can be interesting when your
|
|
* $HOME directory is located on a network share or in a roaming profile
|
|
* (Windows), given that the content directory of a single virtual device
|
|
* can easily use more than 100MB of data.
|
|
*
|
|
*/
|
|
|
|
|
|
/* a macro used to define the list of disk images managed by the
|
|
* implementation. This macro will be expanded several times with
|
|
* varying definitions of _AVD_IMG
|
|
*/
|
|
#define AVD_IMAGE_LIST \
|
|
_AVD_IMG(KERNEL,"kernel-qemu","kernel") \
|
|
_AVD_IMG(KERNELRANCHU,"kernel-ranchu","kernel") \
|
|
_AVD_IMG(KERNELRANCHU64,"kernel-ranchu-64","kernel") \
|
|
_AVD_IMG(RAMDISK,"ramdisk.img","ramdisk") \
|
|
_AVD_IMG(USERRAMDISK,"ramdisk-qemu.img","user ramdisk") \
|
|
_AVD_IMG(INITSYSTEM,"system.img","init system") \
|
|
_AVD_IMG(INITVENDOR,"vendor.img","init vendor") \
|
|
_AVD_IMG(INITDATA,"userdata.img","init data") \
|
|
_AVD_IMG(INITZIP,"data","init data zip") \
|
|
_AVD_IMG(USERSYSTEM,"system-qemu.img","user system") \
|
|
_AVD_IMG(USERVENDOR,"vendor-qemu.img","user vendor") \
|
|
_AVD_IMG(USERDATA,"userdata-qemu.img", "user data") \
|
|
_AVD_IMG(CACHE,"cache.img","cache") \
|
|
_AVD_IMG(SDCARD,"sdcard.img","SD Card") \
|
|
_AVD_IMG(ENCRYPTIONKEY,"encryptionkey.img","Encryption Key") \
|
|
_AVD_IMG(SNAPSHOTS,"snapshots.img","snapshots") \
|
|
_AVD_IMG(VERIFIEDBOOTPARAMS, "VerifiedBootParams.textproto","Verified Boot Parameters") \
|
|
|
|
/* define the enumared values corresponding to each AVD image type
|
|
* examples are: AVD_IMAGE_KERNEL, AVD_IMAGE_SYSTEM, etc..
|
|
*/
|
|
#define _AVD_IMG(x,y,z) AVD_IMAGE_##x ,
|
|
typedef enum {
|
|
AVD_IMAGE_LIST
|
|
AVD_IMAGE_MAX /* do not remove */
|
|
} AvdImageType;
|
|
#undef _AVD_IMG
|
|
|
|
/* AvdInfo is an opaque structure used to model the information
|
|
* corresponding to a given AVD instance
|
|
*/
|
|
typedef struct AvdInfo AvdInfo;
|
|
|
|
/* various flags used when creating an AvdInfo object */
|
|
typedef enum {
|
|
/* use to force a data wipe */
|
|
AVDINFO_WIPE_DATA = (1 << 0),
|
|
/* use to ignore the cache partition */
|
|
AVDINFO_NO_CACHE = (1 << 1),
|
|
/* use to wipe cache partition, ignored if NO_CACHE is set */
|
|
AVDINFO_WIPE_CACHE = (1 << 2),
|
|
/* use to ignore ignore SDCard image (default or provided) */
|
|
AVDINFO_NO_SDCARD = (1 << 3),
|
|
/* use to wipe the system image with new initial values */
|
|
AVDINFO_WIPE_SYSTEM = (1 << 4),
|
|
/* use to ignore state snapshot image (default or provided) */
|
|
AVDINFO_NO_SNAPSHOT_LOAD = (1 << 5),
|
|
/* use to prevent saving state on exit (set by the UI) */
|
|
AVDINFO_NO_SNAPSHOT_SAVE_ON_EXIT = (1 << 6),
|
|
/* invalidate the current quickboot snapshot */
|
|
AVDINFO_SNAPSHOT_INVALIDATE = (1 << 7),
|
|
} AvdFlags;
|
|
|
|
typedef struct {
|
|
unsigned flags;
|
|
const char* skinName;
|
|
const char* skinRootPath;
|
|
const char* forcePaths[AVD_IMAGE_MAX];
|
|
} AvdInfoParams;
|
|
|
|
/* Creates a new AvdInfo object from a name. Returns NULL if name is NULL
|
|
* or contains characters that are not part of the following list:
|
|
* letters, digits, underscores, dashes and periods
|
|
*/
|
|
AvdInfo* avdInfo_new( const char* name, AvdInfoParams* params );
|
|
|
|
/* Sets a custom ID for this AVD. */
|
|
void avdInfo_setAvdId( AvdInfo* i, const char* id );
|
|
|
|
/* Update the AvdInfo hardware config from a given skin name and path */
|
|
int avdInfo_getSkinHardwareIni( AvdInfo* i, char* skinName, char* skinDirPath);
|
|
|
|
/* A special function used to setup an AvdInfo for use when starting
|
|
* the emulator from the Android build system. In this specific instance
|
|
* we're going to create temporary files to hold all writable image
|
|
* files, and activate all hardware features by default
|
|
*
|
|
* 'androidBuildRoot' must be the absolute path to the root of the
|
|
* Android build system (i.e. the 'android' directory)
|
|
*
|
|
* 'androidOut' must be the target-specific out directory where
|
|
* disk images will be looked for.
|
|
*/
|
|
AvdInfo* avdInfo_newForAndroidBuild( const char* androidBuildRoot,
|
|
const char* androidOut,
|
|
AvdInfoParams* params );
|
|
|
|
/* Frees an AvdInfo object and the corresponding strings that may be
|
|
* returned by its getXXX() methods
|
|
*/
|
|
void avdInfo_free( AvdInfo* i );
|
|
|
|
/* Return the name of the Android Virtual Device
|
|
*/
|
|
const char* avdInfo_getName( const AvdInfo* i );
|
|
|
|
/* Get the device ID, which can be different from the AVD name
|
|
* depending on multiple instances or the specific use case. */
|
|
const char* avdInfo_getId( const AvdInfo* i );
|
|
|
|
/* Return the target API level for this AVD.
|
|
* Note that this will be some ridiculously large
|
|
* value (e.g. 1000) if this value cannot be properly
|
|
* determined (e.g. you're using an AVD from a preview SDK)
|
|
*/
|
|
static const int kUnknownApiLevel = 1000;
|
|
int avdInfo_getApiLevel( const AvdInfo* i );
|
|
|
|
/* Return the "dessert name" associated with the
|
|
* API level
|
|
*/
|
|
const char* avdInfo_getApiDessertName(int apiLevel);
|
|
|
|
/* Return the full version name associated with the
|
|
* API level
|
|
*/
|
|
void avdInfo_getFullApiName(int apiLevel, char* nameStr, int strLen);
|
|
|
|
/* Return the api level corresponding to a single-letter API code,
|
|
* e.g. 'N' -> 24
|
|
*/
|
|
int avdInfo_getApiLevelFromLetter(char letter);
|
|
|
|
/* Returns true if the AVD is on Google APIs. */
|
|
bool avdInfo_isGoogleApis( const AvdInfo* i );
|
|
|
|
/* Returns true if the AVD is a user build. */
|
|
bool avdInfo_isUserBuild(const AvdInfo* i);
|
|
|
|
/* Querying AVD flavors. */
|
|
AvdFlavor avdInfo_getAvdFlavor( const AvdInfo* i);
|
|
|
|
/* Returns the path to various images corresponding to a given AVD.
|
|
* NULL if the image cannot be found. Returned strings must be freed
|
|
* by the caller.
|
|
*/
|
|
char* avdInfo_getKernelPath( const AvdInfo* i );
|
|
char* avdInfo_getRanchuKernelPath( const AvdInfo* i );
|
|
char* avdInfo_getRamdiskPath( const AvdInfo* i );
|
|
char* avdInfo_getSdCardPath( const AvdInfo* i );
|
|
char* avdInfo_getEncryptionKeyImagePath( const AvdInfo* i );
|
|
char* avdInfo_getSnapStoragePath( const AvdInfo* i );
|
|
|
|
/* This function returns NULL if the cache image file cannot be found.
|
|
* Use avdInfo_getDefaultCachePath() to retrieve the default path
|
|
* if you intend to create the partition file there.
|
|
*/
|
|
char* avdInfo_getCachePath( const AvdInfo* i );
|
|
char* avdInfo_getDefaultCachePath( const AvdInfo* i );
|
|
|
|
/* avdInfo_getSystemImagePath() will return NULL, except if the AVD content
|
|
* directory contains a file named "system-qemu.img".
|
|
*/
|
|
char* avdInfo_getSystemImagePath( const AvdInfo* i );
|
|
|
|
/* Will return NULL, except if the AVD content
|
|
* directory contains a file named "VerifiedBootParams.textproto".
|
|
*/
|
|
char* avdInfo_getVerifiedBootParamsPath( const AvdInfo* i );
|
|
|
|
/* avdInfo_getSystemInitImagePath() retrieves the path to the read-only
|
|
* initialization image for this disk image.
|
|
*/
|
|
char* avdInfo_getSystemInitImagePath( const AvdInfo* i );
|
|
|
|
char* avdInfo_getVendorImagePath( const AvdInfo* i );
|
|
char* avdInfo_getVendorInitImagePath( const AvdInfo* i );
|
|
|
|
/*
|
|
The following two methods are used for device tree support
|
|
for early boot of O should always use the following method
|
|
to get the right path, as things may change for P and afterwards
|
|
*/
|
|
|
|
/* always returns valid string */
|
|
char* avdInfo_getSystemImageDevicePathInGuest( const AvdInfo* i );
|
|
/*
|
|
returns NULL if not applicable
|
|
*/
|
|
char* avdInfo_getVendorImageDevicePathInGuest( const AvdInfo* i );
|
|
|
|
/*
|
|
for xish: pci0000:00/0000:00:03.0
|
|
for armish: %s.virtio_mmio
|
|
*/
|
|
char* avdInfo_getDynamicPartitionBootDevice( const AvdInfo* i );
|
|
|
|
char* avdInfo_getDataImagePath( const AvdInfo* i );
|
|
char* avdInfo_getDefaultDataImagePath( const AvdInfo* i );
|
|
|
|
/* avdInfo_getDefaultSystemFeatureControlPath() returns the path to the
|
|
* per-system image feature control file
|
|
*/
|
|
char* avdInfo_getDefaultSystemFeatureControlPath(const AvdInfo* i);
|
|
|
|
/* avdInfo_getDataInitImagePath returns the path of userdata.img used
|
|
* for initialization when -wipe-data.
|
|
* Newer versions of system images shall use avdInfo_getDataInitDirPath
|
|
* to generate userdata.img when -wipe-data
|
|
*/
|
|
char* avdInfo_getDataInitImagePath( const AvdInfo* i );
|
|
|
|
/* avdInfo_getDataInitDirPath returns the path to the unpacked user data
|
|
* folder. Newer versions of system images shall use the unpacked user data
|
|
* instead of the prebuilt image to initialize userdata.img.
|
|
*/
|
|
char* avdInfo_getDataInitDirPath( const AvdInfo* i );
|
|
|
|
/* Return a reference to the boot.prop file for this AVD, if any.
|
|
* The file contains additionnal properties to inject at boot time
|
|
* into the guest system. Note that this never returns NULL, but
|
|
* the corresponding content can be empty.
|
|
*/
|
|
const FileData* avdInfo_getBootProperties(const AvdInfo* i);
|
|
|
|
/* Return a reference to the build.prop file for this AVD, if any.
|
|
* The file contains information about the system image used in the AVD.
|
|
* Note that this never returns NULL, but the corresponding content can
|
|
* be empty.
|
|
*/
|
|
const FileData* avdInfo_getBuildProperties(const AvdInfo* i);
|
|
|
|
/* Return a reference to the avd/confif.init file for this AVD.
|
|
* Note that this vaue could be NULL.
|
|
*/
|
|
CIniFile* avdInfo_getConfigIni(const AvdInfo* i);
|
|
|
|
/* Returns the path to a given AVD image file. This will return NULL if
|
|
* the file cannot be found / does not exist.
|
|
*/
|
|
const char* avdInfo_getImagePath( const AvdInfo* i, AvdImageType imageType );
|
|
|
|
/* Returns the default path of a given AVD image file. This only makes sense
|
|
* if avdInfo_getImagePath() returned NULL.
|
|
*/
|
|
const char* avdInfo_getImageDefaultPath( const AvdInfo* i, AvdImageType imageType );
|
|
|
|
|
|
/* Try to find the path of a given image file, returns NULL
|
|
* if the corresponding file could not be found. the string
|
|
* belongs to the AvdInfo object.
|
|
*/
|
|
const char* avdInfo_getImageFile( const AvdInfo* i, AvdImageType imageType );
|
|
|
|
/* Return the size of a given image file. Returns 0 if the file
|
|
* does not exist or could not be accessed.
|
|
*/
|
|
uint64_t avdInfo_getImageFileSize( const AvdInfo* i, AvdImageType imageType );
|
|
|
|
/* Returns 1 if the corresponding image file is read-only
|
|
*/
|
|
int avdInfo_isImageReadOnly( const AvdInfo* i, AvdImageType imageType );
|
|
|
|
/* lock an image file if it is writable. returns 0 on success, or -1
|
|
* otherwise. note that if the file is read-only, it doesn't need to
|
|
* be locked and the function will return success.
|
|
*/
|
|
int avdInfo_lockImageFile( const AvdInfo* i, AvdImageType imageType, int abortOnError);
|
|
|
|
/* Manually set the path of a given image file. */
|
|
void avdInfo_setImageFile( AvdInfo* i, AvdImageType imageType, const char* imagePath );
|
|
|
|
/* Manually set the path of the acpi ini path. */
|
|
void avdInfo_setAcpiIniPath( AvdInfo* i, const char* iniPath );
|
|
|
|
/* Returns the content path of the virtual device */
|
|
const char* avdInfo_getContentPath( const AvdInfo* i );
|
|
|
|
/* Returns the root ini path of the virtual device */
|
|
const char* avdInfo_getRootIniPath( const AvdInfo* i );
|
|
|
|
/* Returns the acpi configuration path of the virtual device*/
|
|
const char* avdInfo_getAcpiIniPath( const AvdInfo* i );
|
|
|
|
/* Retrieve the AVD's specific skin information.
|
|
* On exit:
|
|
* '*pSkinName' points to the skin's name.
|
|
* '*pSkinDir' points to the skin's directory.
|
|
*
|
|
* Note that the skin's content will be under <skinDir>/<skinName>.
|
|
*/
|
|
void avdInfo_getSkinInfo( const AvdInfo* i, char** pSkinName, char** pSkinDir );
|
|
|
|
/* Find a charmap file named <charmapName>.kcm for this AVD.
|
|
* Returns the path of the file on success, or NULL if not found.
|
|
* The result string must be freed by the caller.
|
|
*/
|
|
char* avdInfo_getCharmapFile( const AvdInfo* i, const char* charmapName );
|
|
|
|
/* Returns TRUE iff in the Android build system */
|
|
int avdInfo_inAndroidBuild( const AvdInfo* i );
|
|
|
|
/* Return the target CPU architecture for this AVD.
|
|
* This returns NULL if that cannot be determined, or a string that
|
|
* must be freed by the caller otherwise.
|
|
*/
|
|
char* avdInfo_getTargetCpuArch(const AvdInfo* i);
|
|
|
|
/* Returns the target ABI for the corresponding platform image.
|
|
* This may return NULL if it cannot be determined. Otherwise this is
|
|
* a string like "armeabi", "armeabi-v7a" or "x86" that must be freed
|
|
* by the caller.
|
|
*/
|
|
char* avdInfo_getTargetAbi( const AvdInfo* i );
|
|
|
|
/* A helper to quickly find out if this is a x86-compatible AVD */
|
|
bool avdInfo_is_x86ish(const AvdInfo* i);
|
|
|
|
/* Reads the AVD's hardware configuration into 'hw'. returns -1 on error, 0 otherwise */
|
|
int avdInfo_initHwConfig(const AvdInfo* i,
|
|
AndroidHwConfig* hw,
|
|
bool isQemu2);
|
|
|
|
/* Returns a *copy* of the path used to store profile 'foo'. result must be freed by caller */
|
|
char* avdInfo_getCodeProfilePath( const AvdInfo* i, const char* profileName );
|
|
|
|
/* Returns the path of the hardware.ini where we will write the AVD's
|
|
* complete hardware configuration before launching the corresponding
|
|
* core.
|
|
*/
|
|
const char* avdInfo_getCoreHwIniPath( const AvdInfo* i );
|
|
|
|
/* Returns the path of the snapshot lock file that is used to determine
|
|
* whether or not the current AVD is undergoing a snapshot operation. */
|
|
const char* avdInfo_getSnapshotLockFilePath( const AvdInfo* i );
|
|
|
|
const char* avdInfo_getMultiInstanceLockFilePath( const AvdInfo* i );
|
|
|
|
/* Describes the ways emulator may set up host adb <-> guest adbd communication:
|
|
* legacy - ADBD communicates with the emulator via forwarded TCP port 5555.
|
|
* pipe - ADBD communicates with the emulator via 'adb' pipe service.
|
|
*/
|
|
typedef enum {
|
|
ADBD_COMMUNICATION_MODE_LEGACY,
|
|
ADBD_COMMUNICATION_MODE_PIPE,
|
|
} AdbdCommunicationMode;
|
|
|
|
/* Returns mode in which ADB daemon running in the guest communicates with the
|
|
* emulator.
|
|
*/
|
|
AdbdCommunicationMode avdInfo_getAdbdCommunicationMode(const AvdInfo* i,
|
|
bool isQemu2);
|
|
|
|
/* Returns config.ini snapshot presense status.
|
|
* This routine checks if snapshots are enabled in AVD config.ini file.
|
|
* Return:
|
|
* 1 - Snapshots are enabled in AVD config.ini file.
|
|
* 0 - Snapshots are disabled in AVD config.ini file, of config.ini file is not
|
|
* found.
|
|
*/
|
|
int avdInfo_getSnapshotPresent(const AvdInfo* i);
|
|
|
|
/* Returns the incremental version number of the AVD's system image.
|
|
*/
|
|
int avdInfo_getSysImgIncrementalVersion(const AvdInfo* i);
|
|
|
|
/* Return the tag of a specific AVD in the format of "|tag.id|[|tag.display|]".
|
|
* The default value is "default [Default]". The implementation is in reference
|
|
* to
|
|
* sdk/sdkmanager/libs/sdklib/src/com/android/sdklib/internal/avd/AvdInfo.java
|
|
*/
|
|
const char* avdInfo_getTag(const AvdInfo* i);
|
|
|
|
/* Return SD card size in human readable format or NULL if the SD card doesn't
|
|
* exist.
|
|
*/
|
|
const char* avdInfo_getSdCardSize(const AvdInfo* i);
|
|
|
|
/* Returns true if the system image has problems with guest rendering. */
|
|
bool avdInfo_sysImgGuestRenderingBlacklisted(const AvdInfo* i);
|
|
|
|
/* Replace the disk.dataPartition.size in avd config.ini */
|
|
void avdInfo_replaceDataPartitionSizeInConfigIni(AvdInfo* i, int64_t sizeBytes);
|
|
|
|
bool avdInfo_isMarshmallowOrHigher(AvdInfo* i);
|
|
|
|
AEMU_EXPORT AvdInfo* avdInfo_newCustom(
|
|
const char* name,
|
|
int apiLevel,
|
|
const char* abi,
|
|
const char* arch,
|
|
bool isGoogleApis,
|
|
AvdFlavor flavor);
|
|
|
|
/* Set a custom content path. Useful for testing. */
|
|
void avdInfo_setCustomContentPath(AvdInfo* info, const char* path);
|
|
|
|
/* Set a custom core hw ini path. Useful for testing. */
|
|
void avdInfo_setCustomCoreHwIniPath(AvdInfo* info, const char* path);
|
|
|
|
void avdInfo_replaceMultiDisplayInConfigIni(AvdInfo* i, int index,
|
|
int x, int y,
|
|
int w, int h,
|
|
int dpi, int flag );
|
|
|
|
/* Maximum number of supported multi display entries in an avd. */
|
|
int avdInfo_maxMultiDisplayEntries(); |