aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--CHANGES.TXT24
-rw-r--r--android/avd/hardware-properties.ini12
-rw-r--r--android/avd/hw-config-defs.h14
-rw-r--r--android/avd/info.c15
-rw-r--r--android/avd/info.h5
-rw-r--r--android/main.c144
6 files changed, 193 insertions, 21 deletions
diff --git a/CHANGES.TXT b/CHANGES.TXT
index aca11fd..f04d275 100644
--- a/CHANGES.TXT
+++ b/CHANGES.TXT
@@ -28,6 +28,30 @@ IMPORTANT BUG FIXES:
- The key-bindings for the Menu button (F2 and PageUp by default) didn't work
due to a typo.
+OTHER:
+
+- Added two new hardware properties disk.systemPartition.size and
+ disk.dataPartition.size to specify the size of the system and data partition
+ in a given AVD.
+
+ If the emulator detects that an image file is larger than the corresponding
+ setting, it will do the following:
+
+ - for AVDs running from the SDK, an error message will be printed and
+ the emulator aborts. Note that this can only happen if there are some
+ serious mis-configuration of AVDs anyway.
+
+ - when launching the emulator from the Android build system, a warning
+ will be printed, and the partition size will be automatically adjusted
+ at launch.
+
+ Previously, trying to launch an over-sized system image would result in the
+ emulated system booting, but then failing to find certain files, depending on
+ how the yaffs2 disk images are built. This caused hard-to-debug issues.
+
+ Note that the option -partition-size <size> can be used to override the AVD's
+ setting at runtime.
+
==============================================================================
Changes between 1.11 and 1.10
diff --git a/android/avd/hardware-properties.ini b/android/avd/hardware-properties.ini
index c655100..09486d2 100644
--- a/android/avd/hardware-properties.ini
+++ b/android/avd/hardware-properties.ini
@@ -124,6 +124,18 @@ default = yes
abstract = SD Card support
description = Whether the device supports insertion/removal of virtual SD Cards.
+# System partition
+name = disk.systemPartition.size
+type = diskSize
+abstract = System partition size
+default = 66MB
+
+# Data partition
+name = disk.dataPartition.size
+type = diskSize
+abstract = Data partition size
+default = 66MB
+
# Cache partition
name = disk.cachePartition
type = boolean
diff --git a/android/avd/hw-config-defs.h b/android/avd/hw-config-defs.h
index 7fcf732..67bd3d3 100644
--- a/android/avd/hw-config-defs.h
+++ b/android/avd/hw-config-defs.h
@@ -122,6 +122,20 @@ HWCFG_BOOL(
"SD Card support",
"Whether the device supports insertion/removal of virtual SD Cards.")
+HWCFG_DISKSIZE(
+ disk_systemPartition_size,
+ "disk.systemPartition.size",
+ "66MB",
+ "System partition size",
+ "")
+
+HWCFG_DISKSIZE(
+ disk_dataPartition_size,
+ "disk.dataPartition.size",
+ "66MB",
+ "Data partition size",
+ "")
+
HWCFG_BOOL(
disk_cachePartition,
"disk.cachePartition",
diff --git a/android/avd/info.c b/android/avd/info.c
index 1bdb59c..10e2005 100644
--- a/android/avd/info.c
+++ b/android/avd/info.c
@@ -1358,6 +1358,21 @@ avdInfo_getImageFile( AvdInfo* i, AvdImageType imageType )
return i->imagePath[imageType];
}
+uint64_t
+avdInfo_getImageFileSize( AvdInfo* i, AvdImageType imageType )
+{
+ const char* file = avdInfo_getImageFile(i, imageType);
+ uint64_t size;
+
+ if (file == NULL)
+ return 0ULL;
+
+ if (path_get_size(file, &size) < 0)
+ return 0ULL;
+
+ return size;
+}
+
int
avdInfo_isImageReadOnly( AvdInfo* i, AvdImageType imageType )
{
diff --git a/android/avd/info.h b/android/avd/info.h
index 6cd97dc..19df807 100644
--- a/android/avd/info.h
+++ b/android/avd/info.h
@@ -131,6 +131,11 @@ const char* avdInfo_getName( AvdInfo* i );
*/
const char* avdInfo_getImageFile( 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( AvdInfo* i, AvdImageType imageType );
+
/* Returns 1 if the corresponding image file is read-only
*/
int avdInfo_isImageReadOnly( AvdInfo* i, AvdImageType imageType );
diff --git a/android/main.c b/android/main.c
index f0b9d16..104b344 100644
--- a/android/main.c
+++ b/android/main.c
@@ -234,6 +234,25 @@ sdl_set_window_icon( void )
}
+#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);
+}
+
/***********************************************************************/
/***********************************************************************/
/***** *****/
@@ -1721,6 +1740,38 @@ _forceAvdImagePath( AvdImageType imageType,
android_avdParams->forcePaths[imageType] = path;
}
+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, "(%lld bytes > %lld bytes)", imageBytes, defaultBytes);
+ }
+
+ if (!inAndroidBuild) {
+ derror("%s image file too large for device's hardware configuration %s.\n"
+ "Aborting !", description, temp);
+ exit(1);
+ }
+ dwarning("%s partition size adjusted to match image file %s\n", description, temp);
+
+ return convertMBToBytes(imageMB);
+}
+
#ifdef _WIN32
#undef main /* we don't want SDL to define main */
#endif
@@ -1740,9 +1791,12 @@ int main(int argc, char **argv)
int shell_serial = 0;
int dns_count = 0;
unsigned cachePartitionSize = 0;
- unsigned defaultPartitionSize = 0x4200000;
+ unsigned systemPartitionSize = 0;
+ unsigned dataPartitionSize = 0;
+ unsigned defaultPartitionSize = convertBytesToMB(66);
AndroidHwConfig* hw;
+ AvdInfo* avd;
//const char *appdir = get_app_dir();
char* android_build_root = NULL;
@@ -2058,9 +2112,11 @@ int main(int argc, char **argv)
}
}
+ avd = android_avdInfo;
+
/* get the skin from the virtual device configuration */
- opts->skin = (char*) avdInfo_getSkinName( android_avdInfo );
- opts->skindir = (char*) avdInfo_getSkinDir( android_avdInfo );
+ opts->skin = (char*) avdInfo_getSkinName( avd );
+ opts->skindir = (char*) avdInfo_getSkinDir( avd );
if (opts->skin) {
D("autoconfig: -skin %s", opts->skin);
@@ -2071,7 +2127,7 @@ int main(int argc, char **argv)
/* Read hardware configuration */
hw = android_hw;
- if (avdInfo_getHwConfig(android_avdInfo, hw) < 0) {
+ if (avdInfo_getHwConfig(avd, hw) < 0) {
derror("could not read hardware configuration ?");
exit(1);
}
@@ -2203,7 +2259,7 @@ int main(int argc, char **argv)
}
if (opts->trace) {
- char* tracePath = avdInfo_getTracePath(android_avdInfo, opts->trace);
+ char* tracePath = avdInfo_getTracePath(avd, opts->trace);
int ret;
if (tracePath == NULL) {
@@ -2265,38 +2321,84 @@ int main(int argc, char **argv)
n = 1;
/* generate arguments for the underlying qemu main() */
args[n++] = "-kernel";
- args[n++] = (char*) avdInfo_getImageFile(android_avdInfo, AVD_IMAGE_KERNEL);
+ args[n++] = (char*) avdInfo_getImageFile(avd, AVD_IMAGE_KERNEL);
args[n++] = "-initrd";
- args[n++] = (char*) avdInfo_getImageFile(android_avdInfo, AVD_IMAGE_RAMDISK);
+ args[n++] = (char*) avdInfo_getImageFile(avd, AVD_IMAGE_RAMDISK);
if (opts->partition_size) {
char* end;
- long size = strtol(opts->partition_size, &end, 0);
- long maxSize = LONG_MAX / (1024*1024);
- long defaultMB = (defaultPartitionSize + (512*1024)) / (1024*1024);
+ long sizeMB = strtol(opts->partition_size, &end, 0);
+ long minSizeMB = 10;
+ long maxSizeMB = LONG_MAX / ONE_MB;
- if (size < 0 || *end != 0) {
+ if (sizeMB < 0 || *end != 0) {
derror( "-partition-size must be followed by a positive integer" );
exit(1);
}
- if (size < defaultMB || size > maxSize) {
+ if (sizeMB < minSizeMB || sizeMB > maxSizeMB) {
derror( "partition-size (%d) must be between %dMB and %dMB",
- size, defaultMB, maxSize );
+ sizeMB, minSizeMB, maxSizeMB );
exit(1);
}
- defaultPartitionSize = size * 1024*1024;
+ defaultPartitionSize = sizeMB * ONE_MB;
+ }
+
+ /* 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.
+ *
+ */
+ {
+ uint64_t systemBytes = avdInfo_getImageFileSize(avd, AVD_IMAGE_INITSYSTEM);
+ uint64_t defaultBytes = hw->disk_systemPartition_size;
+
+ if (defaultBytes == 0 || opts->partition_size)
+ defaultBytes = defaultPartitionSize;
+
+ systemPartitionSize = _adjustPartitionSize("system", systemBytes, defaultBytes,
+ android_build_out != NULL);
+ }
+
+ /* Check the size of the /data partition. The only interesting cases here are:
+ * - when the USERDATA image already exists and is larger than the deffault
+ * - when we're wiping data and the INITDATA is larger than the default.
+ */
+
+ {
+ const char* dataPath = avdInfo_getImageFile(avd, AVD_IMAGE_USERDATA);
+ uint64_t defaultBytes = hw->disk_dataPartition_size;
+
+ if (defaultBytes == 0 || opts->partition_size)
+ defaultBytes = defaultPartitionSize;
+
+ if (dataPath == NULL || !path_exists(dataPath) || opts->wipe_data) {
+ dataPath = avdInfo_getImageFile(avd, AVD_IMAGE_INITDATA);
+ }
+ if (dataPath == NULL || !path_exists(dataPath)) {
+ dataPartitionSize = defaultBytes;
+ }
+ else {
+ uint64_t dataBytes;
+ path_get_size(dataPath, &dataBytes);
+
+ dataPartitionSize = _adjustPartitionSize("data", dataBytes, defaultBytes,
+ android_build_out != NULL);
+ }
}
{
const char* filetype = "file";
- if (avdInfo_isImageReadOnly(android_avdInfo, AVD_IMAGE_INITSYSTEM))
+ if (avdInfo_isImageReadOnly(avd, AVD_IMAGE_INITSYSTEM))
filetype = "initfile";
bufprint(tmp, tmpend,
- "system,size=0x%x,%s=%s", defaultPartitionSize, filetype,
- avdInfo_getImageFile(android_avdInfo, AVD_IMAGE_INITSYSTEM));
+ "system,size=0x%x,%s=%s", systemPartitionSize, filetype,
+ avdInfo_getImageFile(avd, AVD_IMAGE_INITSYSTEM));
args[n++] = "-nand";
args[n++] = strdup(tmp);
@@ -2304,14 +2406,14 @@ int main(int argc, char **argv)
bufprint(tmp, tmpend,
"userdata,size=0x%x,file=%s",
- defaultPartitionSize,
- avdInfo_getImageFile(android_avdInfo, AVD_IMAGE_USERDATA));
+ dataPartitionSize,
+ avdInfo_getImageFile(avd, AVD_IMAGE_USERDATA));
args[n++] = "-nand";
args[n++] = strdup(tmp);
if (hw->disk_cachePartition) {
- opts->cache = (char*) avdInfo_getImageFile(android_avdInfo, AVD_IMAGE_CACHE);
+ opts->cache = (char*) avdInfo_getImageFile(avd, AVD_IMAGE_CACHE);
cachePartitionSize = hw->disk_cachePartition_size;
}
else if (opts->cache) {
@@ -2334,7 +2436,7 @@ int main(int argc, char **argv)
}
if (hw->hw_sdCard != 0)
- opts->sdcard = (char*) avdInfo_getImageFile(android_avdInfo, AVD_IMAGE_SDCARD);
+ opts->sdcard = (char*) avdInfo_getImageFile(avd, AVD_IMAGE_SDCARD);
else if (opts->sdcard) {
dwarning( "Emulated hardware doesn't support SD Cards" );
opts->sdcard = NULL;
generated by cgit v1.1 at 2024-05-15 15:10:11 +0000