Added two new hardware properties to control AVD partition sizes.

  disk.systemPartition.size (default 66MB)
  disk.dataPartition.size   (default 66MB)

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.

5 files changed, 169 insertions, 21 deletions

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;