diff --git a/android/avd/hardware-properties.ini b/android/avd/hardware-properties.ini
index 69abdaa..5ecfcc4 100644
--- a/android/avd/hardware-properties.ini
+++ b/android/avd/hardware-properties.ini
@@ -222,26 +222,33 @@
 abstract    = Path to the ramdisk image
 description = Path to the ramdisk image.
 
-# Path to the system partition.
+# System partition image(s).
+#
+# disk.systemPartition.path points to the read/write system partition image.
+#   if empty, a temporary file will be created, initialized with the content
+#   of .initPath
+#
+# disk.systemPartition.initPath is only used when .path is empty. It must
+# then point to a read-only initialization system image file.
+#
+# disk.systemPartition.size is the ideal size of the system partition. The
+# size is ignored if the actual system partition image is larger. Otherwise,
+# it indicates the maximum size the disk image file can grow to.
+#
 name        = disk.systemPartition.path
 type        = string
-default     = <init>
-abstract    = Path to system partition image
-description = Path to read/write system partition image during emulation. If special value '<init>' is used, a temporary file will be created, populated with the content of .initPath
+default     =
+abstract    = Path to runtime system partition image
 
-# Initial path to the system partition.
 name        = disk.systemPartition.initPath
 type        = string
 default     =
 abstract    = Initial system partition image
-description = Only used if .path is '<init>', path to an initial system image that will be copied into the temporary system image file before launch.
 
-# System partition size.
 name        = disk.systemPartition.size
 type        = diskSize
 default     = 0
 abstract    = Ideal size of system partition
-description = ideal size of system partition. Ignored if smaller than the size of .path (or .initPath). Otherwise, gives the maximum size the partition is allowed to grow dynamically.
 
 # Path to the data partition.
 name        = disk.dataPartition.path
diff --git a/android/avd/hw-config-defs.h b/android/avd/hw-config-defs.h
index 6c8ccae..e2def30 100644
--- a/android/avd/hw-config-defs.h
+++ b/android/avd/hw-config-defs.h
@@ -223,23 +223,23 @@
 HWCFG_STRING(
   disk_systemPartition_path,
   "disk.systemPartition.path",
-  "<init>",
-  "Path to system partition image",
-  "Path to read/write system partition image during emulation. If special value '<init>' is used, a temporary file will be created, populated with the content of .initPath")
+  "",
+  "Path to runtime system partition image",
+  "")
 
 HWCFG_STRING(
   disk_systemPartition_initPath,
   "disk.systemPartition.initPath",
   "",
   "Initial system partition image",
-  "Only used if .path is '<init>', path to an initial system image that will be copied into the temporary system image file before launch.")
+  "")
 
 HWCFG_DISKSIZE(
   disk_systemPartition_size,
   "disk.systemPartition.size",
   "0",
   "Ideal size of system partition",
-  "ideal size of system partition. Ignored if smaller than the size of .path (or .initPath). Otherwise, gives the maximum size the partition is allowed to grow dynamically.")
+  "")
 
 HWCFG_STRING(
   disk_dataPartition_path,
@@ -260,7 +260,7 @@
   "disk.dataPartition.size",
   "0",
   "Ideal size of data partition",
-  "ideal size of data partition. Ignored if smaller than the size of .path (or .initPath). Otherwise, gives the maximum size the partition is allowed to grow dynamically.")
+  "")
 
 HWCFG_STRING(
   disk_snapStorage_path,
diff --git a/android/avd/info.c b/android/avd/info.c
index ca4f0cf..a23cd63 100644
--- a/android/avd/info.c
+++ b/android/avd/info.c
@@ -470,6 +470,7 @@
     char         temp[MAX_PATH], *p = temp, *end = p + sizeof(temp);
 
     p = bufprint(temp, end, "%s/skins/%s", skinDirRoot, skinName);
+    DD("Probing skin directory: %s", temp);
     if (p >= end || !path_exists(temp)) {
         DD("    ignore bad skin directory %s", temp);
         return NULL;
@@ -1098,31 +1099,6 @@
     return l->pPath[0];
 }
 
-/* Attempts to load an AVD image, but does not kill the process if loading
- * fails.
- */
-static void
-imageLoader_loadOptional( ImageLoader *l, AvdImageType img_type,
-                           const char *forcedPath )
-{
-    imageLoader_set (l, img_type);
-    imageLoader_load(l, IMAGE_OPTIONAL |
-                        IMAGE_IGNORE_IF_LOCKED);
-
-    /* if the file was not found, ignore it */
-    if (l->pPath[0] && !path_exists(l->pPath[0]))
-    {
-        D("ignoring non-existing %s at %s: %s",
-          l->imageText, l->pPath[0], strerror(errno));
-
-        /* if the user provided the path by hand, warn him. */
-        if (forcedPath != NULL)
-            dwarning("ignoring non-existing %s image", l->imageText);
-
-        imageLoader_setPath(l, NULL);
-    }
-}
-
 /* find the correct path of all image files we're going to need
  * and lock the files that need it.
  */
@@ -1135,14 +1111,6 @@
 
     imageLoader_init(l, i, params);
 
-    /* the system image
-     *
-     * if there is one in the content directory just lock
-     * and use it.
-     */
-    imageLoader_set ( l, AVD_IMAGE_INITSYSTEM );
-    imageLoader_load( l, IMAGE_REQUIRED | IMAGE_SEARCH_SDK | IMAGE_DONT_LOCK );
-
     /* the data partition - this one is special because if it
      * is missing, we need to copy the initial image file into it.
      *
@@ -1335,15 +1303,6 @@
 
     AFREE(srcData);
 
-    /** load the system image. read-only. the caller must
-     ** take care of checking the state
-     **/
-    imageLoader_set ( l, AVD_IMAGE_INITSYSTEM );
-    imageLoader_load( l, IMAGE_REQUIRED | IMAGE_DONT_LOCK );
-
-    /* force the system image to read-only status */
-    l->pState[0] = IMAGE_STATE_READONLY;
-
     return 0;
 }
 
@@ -1522,6 +1481,13 @@
 }
 
 char*
+avdInfo_getSystemImagePath( AvdInfo*  i )
+{
+    const char* imageName = _imageFileNames[ AVD_IMAGE_USERSYSTEM ];
+    return _avdInfo_getContentFilePath(i, imageName);
+}
+
+char*
 avdInfo_getSystemInitImagePath( AvdInfo*  i )
 {
     const char* imageName = _imageFileNames[ AVD_IMAGE_INITSYSTEM ];
diff --git a/android/avd/info.h b/android/avd/info.h
index afc71fb..4191165 100644
--- a/android/avd/info.h
+++ b/android/avd/info.h
@@ -147,7 +147,16 @@
 char*  avdInfo_getDefaultCachePath( AvdInfo*  i );
 
 
+/* avdInfo_getSystemImagePath() will return NULL, except if the AVD content
+ * directory contains a file named "system-qemu.img".
+ */
+char*  avdInfo_getSystemImagePath( AvdInfo* i );
+
+/* avdInfo_getSystemInitImagePath() retrieves the path to the read-only
+ * initialization image for this disk image.
+ */
 char*  avdInfo_getSystemInitImagePath( AvdInfo*  i );
+
 char*  avdInfo_getDataInitImagePath( AvdInfo* i );
 
 /* Returns the path to a given AVD image file. This will return NULL if
diff --git a/android/main-common.c b/android/main-common.c
index 740f59a..9e5318d 100644
--- a/android/main-common.c
+++ b/android/main-common.c
@@ -1031,13 +1031,7 @@
 {
     unsigned  defaultPartitionSize = convertMBToBytes(66);
 
-    if (_update_hwconfig_path(&hwConfig->disk_systemPartition_initPath, avd, AVD_IMAGE_INITSYSTEM)) {
-        dprint("system path %s is invalid", hwConfig->disk_systemPartition_initPath);
-        exit(1);
-    }
-
     _update_hwconfig_path(&hwConfig->disk_dataPartition_path, avd, AVD_IMAGE_USERDATA);
-    _update_hwconfig_path(&hwConfig->disk_systemPartition_path, avd, AVD_IMAGE_USERSYSTEM);
     _update_hwconfig_path(&hwConfig->disk_dataPartition_path, avd, AVD_IMAGE_INITDATA);
 
     if (opts->partition_size) {
@@ -1057,25 +1051,6 @@
         }
         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 = defaultPartitionSize;
-
-        if (defaultBytes == 0 || opts->partition_size)
-            defaultBytes = defaultPartitionSize;
-        hwConfig->disk_systemPartition_size =
-            _adjustPartitionSize("system", systemBytes, defaultBytes, inAndroidBuild);
-    }
-
     /* Check the size of the /data partition. The only interesting cases here are:
      * - when the USERDATA image already exists and is larger than the default
      * - when we're wiping data and the INITDATA is larger than the default.
diff --git a/android/main.c b/android/main.c
index 240574a..33a96ea 100644
--- a/android/main.c
+++ b/android/main.c
@@ -108,6 +108,52 @@
     exit(1);
 }
 
+/* TODO: Put in shared source file */
+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, "(%lld bytes > %lld bytes)", imageBytes, defaultBytes);
+    }
+
+    if (inAndroidBuild) {
+        dwarning("%s partition size adjusted to match image file %s\n", description, temp);
+    }
+
+    return convertMBToBytes(imageMB);
+}
+
 int main(int argc, char **argv)
 {
     char   tmp[MAX_PATH];
@@ -126,6 +172,7 @@
     AConfig*          skinConfig;
     char*             skinPath;
     int               inAndroidBuild;
+    uint64_t          defaultPartitionSize = convertMBToBytes(66);
 
     AndroidOptions  opts[1];
     /* net.shared_net_ip boot property value. */
@@ -426,21 +473,116 @@
     hw->disk_ramdisk_path = avdInfo_getRamdiskPath(avd);
     D("autoconfig: -ramdisk %s", hw->disk_ramdisk_path);
 
-    {
-        const char*  filetype = "file";
+    /* -partition-size is used to specify the max size of both the system
+     * and data partition sizes.
+     */
+    if (opts->partition_size) {
+        char*  end;
+        long   sizeMB = strtol(opts->partition_size, &end, 0);
+        long   minSizeMB = 10;
+        long   maxSizeMB = LONG_MAX / ONE_MB;
 
-        // TODO: This should go to core
-        if (avdInfo_isImageReadOnly(avd, AVD_IMAGE_INITSYSTEM))
-            filetype = "initfile";
-
-        bufprint(tmp, tmpend,
-             "system,size=0x%x,%s=%s", (uint32_t)hw->disk_systemPartition_size,
-             filetype, avdInfo_getImageFile(avd, AVD_IMAGE_INITSYSTEM));
-
-        args[n++] = "-nand";
-        args[n++] = strdup(tmp);
+        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)) {
+            opts->sysdir = ASTRDUP(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);
+            exit(1);
+        }
+    }
+
+    {
+        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) {
+                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 */
+            hw->disk_systemPartition_path     = rwImage;
+            hw->disk_systemPartition_initPath = NULL;
+            D("Using direct system image: %s", rwImage);
+        } else if (initImage != NULL) {
+            hw->disk_systemPartition_path = NULL;
+            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);
+            exit(1);
+        }
+
+        hw->disk_systemPartition_size =
+            _adjustPartitionSize("system", systemBytes, defaultPartitionSize,
+                                 avdInfo_inAndroidBuild(avd));
+    }
+
+    /** DATA PARTITION **/
+
     bufprint(tmp, tmpend,
              "userdata,size=0x%x,file=%s",
              (uint32_t)hw->disk_dataPartition_size,
diff --git a/vl-android.c b/vl-android.c
index 04fed59..36289e4 100644
--- a/vl-android.c
+++ b/vl-android.c
@@ -60,6 +60,7 @@
 #include "android/utils/filelock.h"
 #include "android/utils/path.h"
 #include "android/utils/stralloc.h"
+#include "android/utils/tempfile.h"
 #include "android/display-core.h"
 #include "android/utils/timezone.h"
 #include "android/snapshot.h"
@@ -4841,6 +4842,41 @@
     }
 #endif  // CONFIG_NAND_LIMITS
 
+    /* Initialize system partition image */
+    {
+        char        tmp[PATH_MAX+32];
+        const char* sysImage = android_hw->disk_systemPartition_path;
+        const char* initImage = android_hw->disk_systemPartition_initPath;
+        uint64_t    sysBytes = android_hw->disk_systemPartition_size;
+
+        if (sysBytes == 0) {
+            PANIC("Invalid system partition size: %" PRUd64, sysBytes);
+        }
+
+        snprintf(tmp,sizeof(tmp),"system,size=0x%" PRUx64, sysBytes);
+
+        if (sysImage && *sysImage) {
+            if (filelock_create(sysImage) == NULL) {
+                fprintf(stderr,"WARNING: System image already in use, changes will not persist!\n");
+                /* If there is no file= parameters, nand_add_dev will create
+                 * a temporary file to back the partition image. */
+            } else {
+                pstrcat(tmp,sizeof(tmp),",file=");
+                pstrcat(tmp,sizeof(tmp),sysImage);
+            }
+        }
+        if (initImage && *initImage) {
+            if (!path_exists(initImage)) {
+                PANIC("Invalid initial system image path: %s", initImage);
+            }
+            pstrcat(tmp,sizeof(tmp),",initfile=");
+            pstrcat(tmp,sizeof(tmp),initImage);
+        } else {
+            PANIC("Missing initial system image path!");
+        }
+        nand_add_dev(tmp);
+    }
+
     /* Init SD-Card stuff. For Android, it is always hda */
     /* If the -hda option was used, ignore the Android-provided one */
     if (hda_opts == NULL) {