9 files changed, 340 insertions, 471 deletions

diff --git a/Android.mk b/Android.mk
index b0fefbd90..e6c354759 100644
--- a/Android.mk
+++ b/Android.mk
@@ -15,8 +15,6 @@ LOCAL_SRC_FILES := \
     verifier.c \
     encryptedfs_provisioning.c
 
-LOCAL_SRC_FILES += test_roots.c
-
 LOCAL_MODULE := recovery
 
 LOCAL_FORCE_STATIC_EXECUTABLE := true
@@ -37,10 +35,13 @@ ifeq ($(TARGET_RECOVERY_UI_LIB),)
 else
   LOCAL_STATIC_LIBRARIES += $(TARGET_RECOVERY_UI_LIB)
 endif
+LOCAL_STATIC_LIBRARIES += libext4_utils libz
 LOCAL_STATIC_LIBRARIES += libminzip libunz libmtdutils libmincrypt
 LOCAL_STATIC_LIBRARIES += libminui libpixelflinger_static libpng libcutils
 LOCAL_STATIC_LIBRARIES += libstdc++ libc
 
+LOCAL_C_INCLUDES += system/extras/ext4_utils
+
 include $(BUILD_EXECUTABLE)
 
 
diff --git a/bootloader.c b/bootloader.c
index 38b5651bf..7da3f4ef6 100644
--- a/bootloader.c
+++ b/bootloader.c
@@ -23,99 +23,151 @@
 #include <stdio.h>
 #include <string.h>
 
-static const char *CACHE_NAME = "CACHE:";
-static const char *MISC_NAME = "MISC:";
-static const int MISC_PAGES = 3;         // number of pages to save
-static const int MISC_COMMAND_PAGE = 1;  // bootloader command is this page
+static int get_bootloader_message_mtd(struct bootloader_message *out, const Volume* v);
+static int set_bootloader_message_mtd(const struct bootloader_message *in, const Volume* v);
+static int get_bootloader_message_block(struct bootloader_message *out, const Volume* v);
+static int set_bootloader_message_block(const struct bootloader_message *in, const Volume* v);
 
-#ifdef LOG_VERBOSE
-static void dump_data(const char *data, int len) {
-    int pos;
-    for (pos = 0; pos < len; ) {
-        printf("%05x: %02x", pos, data[pos]);
-        for (++pos; pos < len && (pos % 24) != 0; ++pos) {
-            printf(" %02x", data[pos]);
-        }
-        printf("\n");
+int get_bootloader_message(struct bootloader_message *out) {
+    Volume* v = volume_for_path("/misc");
+    if (strcmp(v->fs_type, "mtd") == 0) {
+        return get_bootloader_message_mtd(out, v);
+    } else if (strcmp(v->fs_type, "block") == 0) {
+        return get_bootloader_message_block(out, v);
     }
+    LOGE("unknown misc partition fs_type \"%s\"\n", v->fs_type);
+    return -1;
 }
-#endif
 
-int get_bootloader_message(struct bootloader_message *out) {
+int set_bootloader_message(const struct bootloader_message *in) {
+    Volume* v = volume_for_path("/misc");
+    if (strcmp(v->fs_type, "mtd") == 0) {
+        return set_bootloader_message_mtd(in, v);
+    } else if (strcmp(v->fs_type, "block") == 0) {
+        return set_bootloader_message_block(in, v);
+    }
+    LOGE("unknown misc partition fs_type \"%s\"\n", v->fs_type);
+    return -1;
+}
+
+// ------------------------------
+// for misc partitions on MTD
+// ------------------------------
+
+static const int MISC_PAGES = 3;         // number of pages to save
+static const int MISC_COMMAND_PAGE = 1;  // bootloader command is this page
+
+static int get_bootloader_message_mtd(struct bootloader_message *out,
+                                      const Volume* v) {
     size_t write_size;
-    const MtdPartition *part = get_root_mtd_partition(MISC_NAME);
+    mtd_scan_partitions();
+    const MtdPartition *part = mtd_find_partition_by_name(v->device);
     if (part == NULL || mtd_partition_info(part, NULL, NULL, &write_size)) {
-        LOGE("Can't find %s\n", MISC_NAME);
+        LOGE("Can't find %s\n", v->device);
         return -1;
     }
 
     MtdReadContext *read = mtd_read_partition(part);
     if (read == NULL) {
-        LOGE("Can't open %s\n(%s)\n", MISC_NAME, strerror(errno));
+        LOGE("Can't open %s\n(%s)\n", v->device, strerror(errno));
         return -1;
     }
 
     const ssize_t size = write_size * MISC_PAGES;
     char data[size];
     ssize_t r = mtd_read_data(read, data, size);
-    if (r != size) LOGE("Can't read %s\n(%s)\n", MISC_NAME, strerror(errno));
+    if (r != size) LOGE("Can't read %s\n(%s)\n", v->device, strerror(errno));
     mtd_read_close(read);
     if (r != size) return -1;
 
-#ifdef LOG_VERBOSE
-    printf("\n--- get_bootloader_message ---\n");
-    dump_data(data, size);
-    printf("\n");
-#endif
-
     memcpy(out, &data[write_size * MISC_COMMAND_PAGE], sizeof(*out));
     return 0;
 }
-
-int set_bootloader_message(const struct bootloader_message *in) {
+static int set_bootloader_message_mtd(const struct bootloader_message *in,
+                                      const Volume* v) {
     size_t write_size;
-    const MtdPartition *part = get_root_mtd_partition(MISC_NAME);
+    mtd_scan_partitions();
+    const MtdPartition *part = mtd_find_partition_by_name(v->device);
     if (part == NULL || mtd_partition_info(part, NULL, NULL, &write_size)) {
-        LOGE("Can't find %s\n", MISC_NAME);
+        LOGE("Can't find %s\n", v->device);
         return -1;
     }
 
     MtdReadContext *read = mtd_read_partition(part);
     if (read == NULL) {
-        LOGE("Can't open %s\n(%s)\n", MISC_NAME, strerror(errno));
+        LOGE("Can't open %s\n(%s)\n", v->device, strerror(errno));
         return -1;
     }
 
     ssize_t size = write_size * MISC_PAGES;
     char data[size];
     ssize_t r = mtd_read_data(read, data, size);
-    if (r != size) LOGE("Can't read %s\n(%s)\n", MISC_NAME, strerror(errno));
+    if (r != size) LOGE("Can't read %s\n(%s)\n", v->device, strerror(errno));
     mtd_read_close(read);
     if (r != size) return -1;
 
     memcpy(&data[write_size * MISC_COMMAND_PAGE], in, sizeof(*in));
 
-#ifdef LOG_VERBOSE
-    printf("\n--- set_bootloader_message ---\n");
-    dump_data(data, size);
-    printf("\n");
-#endif
-
     MtdWriteContext *write = mtd_write_partition(part);
     if (write == NULL) {
-        LOGE("Can't open %s\n(%s)\n", MISC_NAME, strerror(errno));
+        LOGE("Can't open %s\n(%s)\n", v->device, strerror(errno));
         return -1;
     }
     if (mtd_write_data(write, data, size) != size) {
-        LOGE("Can't write %s\n(%s)\n", MISC_NAME, strerror(errno));
+        LOGE("Can't write %s\n(%s)\n", v->device, strerror(errno));
         mtd_write_close(write);
         return -1;
     }
     if (mtd_write_close(write)) {
-        LOGE("Can't finish %s\n(%s)\n", MISC_NAME, strerror(errno));
+        LOGE("Can't finish %s\n(%s)\n", v->device, strerror(errno));
         return -1;
     }
 
     LOGI("Set boot command \"%s\"\n", in->command[0] != 255 ? in->command : "");
     return 0;
 }
+
+
+// ------------------------------------
+// for misc partitions on block devices
+// ------------------------------------
+
+static int get_bootloader_message_block(struct bootloader_message *out,
+                                        const Volume* v) {
+    FILE* f = fopen(v->device, "rb");
+    if (f == NULL) {
+        LOGE("Can't open %s\n(%s)\n", v->device, strerror(errno));
+        return -1;
+    }
+    struct bootloader_message temp;
+    int count = fread(&temp, sizeof(temp), 1, f);
+    if (count != 1) {
+        LOGE("Failed reading %s\n(%s)\n", v->device, strerror(errno));
+        return -1;
+    }
+    if (fclose(f) != 0) {
+        LOGE("Failed closing %s\n(%s)\n", v->device, strerror(errno));
+        return -1;
+    }
+    memcpy(out, &temp, sizeof(temp));
+    return 0;
+}
+
+static int set_bootloader_message_block(const struct bootloader_message *in,
+                                        const Volume* v) {
+    FILE* f = fopen(v->device, "wb");
+    if (f == NULL) {
+        LOGE("Can't open %s\n(%s)\n", v->device, strerror(errno));
+        return -1;
+    }
+    int count = fwrite(in, sizeof(*in), 1, f);
+    if (count != 1) {
+        LOGE("Failed writing %s\n(%s)\n", v->device, strerror(errno));
+        return -1;
+    }
+    if (fclose(f) != 0) {
+        LOGE("Failed closing %s\n(%s)\n", v->device, strerror(errno));
+        return -1;
+    }
+    return 0;
+}
diff --git a/common.h b/common.h
index 0c250f4fa..97e87eec5 100644
--- a/common.h
+++ b/common.h
@@ -87,4 +87,17 @@ void ui_reset_progress();
 #define STRINGIFY(x) #x
 #define EXPAND(x) STRINGIFY(x)
 
+typedef struct {
+    const char* mount_point;  // eg. "/cache".  must live in the root directory.
+
+    const char* fs_type;      // "yaffs2" or "ext4" or "vfat"
+
+    const char* device;       // MTD partition name if fs_type == "yaffs"
+                              // block device if fs_type == "ext4" or "vfat"
+
+    const char* device2;      // alternative device to try if fs_type
+                              // == "ext4" or "vfat" and mounting
+                              // 'device' fails
+} Volume;
+
 #endif  // RECOVERY_COMMON_H
diff --git a/encryptedfs_provisioning.c b/encryptedfs_provisioning.c
index 2bcfec161..601c817de 100644
--- a/encryptedfs_provisioning.c
+++ b/encryptedfs_provisioning.c
@@ -186,7 +186,7 @@ int write_encrypted_fs_boolean_property(const char *prop_name, int value) {
 int read_encrypted_fs_info(encrypted_fs_info *encrypted_fs_data) {
     int result;
     int value;
-    result = ensure_root_path_mounted("DATA:");
+    result = ensure_path_mounted("/data");
     if (result != 0) {
         LOGE("Secure FS: error mounting userdata partition.");
         return ENCRYPTED_FS_ERROR;
@@ -221,7 +221,7 @@ int read_encrypted_fs_info(encrypted_fs_info *encrypted_fs_data) {
         return ENCRYPTED_FS_ERROR;
     }
 
-    result = ensure_root_path_unmounted("DATA:");
+    result = ensure_path_unmounted("/data");
     if (result != 0) {
         LOGE("Secure FS: error unmounting data partition.");
         return ENCRYPTED_FS_ERROR;
@@ -232,7 +232,7 @@ int read_encrypted_fs_info(encrypted_fs_info *encrypted_fs_data) {
 
 int restore_encrypted_fs_info(encrypted_fs_info *encrypted_fs_data) {
     int result;
-    result = ensure_root_path_mounted("DATA:");
+    result = ensure_path_mounted("/data");
     if (result != 0) {
         LOGE("Secure FS: error mounting userdata partition.");
         return ENCRYPTED_FS_ERROR;
@@ -273,7 +273,7 @@ int restore_encrypted_fs_info(encrypted_fs_info *encrypted_fs_data) {
         return result;
     }
 
-    result = ensure_root_path_unmounted("DATA:");
+    result = ensure_path_unmounted("/data");
     if (result != 0) {
         LOGE("Secure FS: error unmounting data partition.");
         return ENCRYPTED_FS_ERROR;
@@ -281,4 +281,3 @@ int restore_encrypted_fs_info(encrypted_fs_info *encrypted_fs_data) {
 
     return ENCRYPTED_FS_OK;
 }
-
diff --git a/install.c b/install.c
index a56dbd048..5bb3a78fa 100644
--- a/install.c
+++ b/install.c
@@ -234,26 +234,19 @@ exit:
 }
 
 int
-install_package(const char *root_path)
+install_package(const char *path)
 {
     ui_set_background(BACKGROUND_ICON_INSTALLING);
     ui_print("Finding update package...\n");
     ui_show_indeterminate_progress();
-    LOGI("Update location: %s\n", root_path);
+    LOGI("Update location: %s\n", path);
 
-    if (ensure_root_path_mounted(root_path) != 0) {
-        LOGE("Can't mount %s\n", root_path);
-        return INSTALL_CORRUPT;
-    }
-
-    char path[PATH_MAX] = "";
-    if (translate_root_path(root_path, path, sizeof(path)) == NULL) {
-        LOGE("Bad path %s\n", root_path);
+    if (ensure_path_mounted(path) != 0) {
+        LOGE("Can't mount %s\n", path);
         return INSTALL_CORRUPT;
     }
 
     ui_print("Opening update package...\n");
-    LOGI("Update file path: %s\n", path);
 
     int numKeys;
     RSAPublicKey* loadedKeys = load_keys(PUBLIC_KEYS_FILE, &numKeys);
diff --git a/recovery.c b/recovery.c
index 286f1e5a7..f5636d846 100644
--- a/recovery.c
+++ b/recovery.c
@@ -50,12 +50,12 @@ static const struct option OPTIONS[] = {
   { NULL, 0, NULL, 0 },
 };
 
-static const char *COMMAND_FILE = "CACHE:recovery/command";
-static const char *INTENT_FILE = "CACHE:recovery/intent";
-static const char *LOG_FILE = "CACHE:recovery/log";
-static const char *SDCARD_ROOT = "SDCARD:";
+static const char *COMMAND_FILE = "/cache/recovery/command";
+static const char *INTENT_FILE = "/cache/recovery/intent";
+static const char *LOG_FILE = "/cache/recovery/log";
+static const char *SDCARD_ROOT = "/sdcard";
 static const char *TEMPORARY_LOG_FILE = "/tmp/recovery.log";
-static const char *SIDELOAD_TEMP_DIR = "TMP:sideload";
+static const char *SIDELOAD_TEMP_DIR = "/tmp/sideload";
 
 /*
  * The recovery tool communicates with the main system through /cache files.
@@ -65,7 +65,7 @@ static const char *SIDELOAD_TEMP_DIR = "TMP:sideload";
  *
  * The arguments which may be supplied in the recovery.command file:
  *   --send_intent=anystring - write the text out to recovery.intent
- *   --update_package=root:path - verify install an OTA package file
+ *   --update_package=path - verify install an OTA package file
  *   --wipe_data - erase user data (and cache), then reboot
  *   --wipe_cache - wipe cache (but not user data), then reboot
  *   --set_encrypted_filesystem=on|off - enables / diasables encrypted fs
@@ -80,8 +80,8 @@ static const char *SIDELOAD_TEMP_DIR = "TMP:sideload";
  * 3. main system reboots into recovery
  * 4. get_args() writes BCB with "boot-recovery" and "--wipe_data"
  *    -- after this, rebooting will restart the erase --
- * 5. erase_root() reformats /data
- * 6. erase_root() reformats /cache
+ * 5. erase_volume() reformats /data
+ * 6. erase_volume() reformats /cache
  * 7. finish_recovery() erases BCB
  *    -- after this, rebooting will restart the main system --
  * 8. main() calls reboot() to boot main system
@@ -109,7 +109,7 @@ static const char *SIDELOAD_TEMP_DIR = "TMP:sideload";
  *    8d. bootloader tries to flash firmware
  *    8e. bootloader writes BCB with "boot-recovery" (keeping "--wipe_cache")
  *        -- after this, rebooting will reformat cache & restart main system --
- *    8f. erase_root() reformats /cache
+ *    8f. erase_volume() reformats /cache
  *    8g. finish_recovery() erases BCB
  *        -- after this, rebooting will (try to) restart the main system --
  * 9. main() calls reboot() to boot main system
@@ -125,8 +125,8 @@ static const char *SIDELOAD_TEMP_DIR = "TMP:sideload";
  * 5. read_encrypted_fs_info() retrieves encrypted file systems settings from /data
  *    Settings include: property to specify the Encrypted FS istatus and
  *    FS encryption key if enabled (not yet implemented)
- * 6. erase_root() reformats /data
- * 7. erase_root() reformats /cache
+ * 6. erase_volume() reformats /data
+ * 7. erase_volume() reformats /cache
  * 8. restore_encrypted_fs_info() writes required encrypted file systems settings to /data
  *    Settings include: property to specify the Encrypted FS status and
  *    FS encryption key if enabled (not yet implemented)
@@ -138,17 +138,11 @@ static const char *SIDELOAD_TEMP_DIR = "TMP:sideload";
 static const int MAX_ARG_LENGTH = 4096;
 static const int MAX_ARGS = 100;
 
-// open a file given in root:path format, mounting partitions as necessary
+// open a given path, mounting partitions as necessary
 static FILE*
-fopen_root_path(const char *root_path, const char *mode) {
-    if (ensure_root_path_mounted(root_path) != 0) {
-        LOGE("Can't mount %s\n", root_path);
-        return NULL;
-    }
-
-    char path[PATH_MAX] = "";
-    if (translate_root_path(root_path, path, sizeof(path)) == NULL) {
-        LOGE("Bad path %s\n", root_path);
+fopen_path(const char *path, const char *mode) {
+    if (ensure_path_mounted(path) != 0) {
+        LOGE("Can't mount %s\n", path);
         return NULL;
     }
 
@@ -205,7 +199,7 @@ get_args(int *argc, char ***argv) {
 
     // --- if that doesn't work, try the command file
     if (*argc <= 1) {
-        FILE *fp = fopen_root_path(COMMAND_FILE, "r");
+        FILE *fp = fopen_path(COMMAND_FILE, "r");
         if (fp != NULL) {
             char *argv0 = (*argv)[0];
             *argv = (char **) malloc(sizeof(char *) * MAX_ARGS);
@@ -251,7 +245,7 @@ static void
 finish_recovery(const char *send_intent) {
     // By this point, we're ready to return to the main system...
     if (send_intent != NULL) {
-        FILE *fp = fopen_root_path(INTENT_FILE, "w");
+        FILE *fp = fopen_path(INTENT_FILE, "w");
         if (fp == NULL) {
             LOGE("Can't open %s\n", INTENT_FILE);
         } else {
@@ -261,7 +255,7 @@ finish_recovery(const char *send_intent) {
     }
 
     // Copy logs to cache so the system can find out what happened.
-    FILE *log = fopen_root_path(LOG_FILE, "a");
+    FILE *log = fopen_path(LOG_FILE, "a");
     if (log == NULL) {
         LOGE("Can't open %s\n", LOG_FILE);
     } else {
@@ -285,10 +279,8 @@ finish_recovery(const char *send_intent) {
     set_bootloader_message(&boot);
 
     // Remove the command file, so recovery won't repeat indefinitely.
-    char path[PATH_MAX] = "";
-    if (ensure_root_path_mounted(COMMAND_FILE) != 0 ||
-        translate_root_path(COMMAND_FILE, path, sizeof(path)) == NULL ||
-        (unlink(path) && errno != ENOENT)) {
+    if (ensure_path_mounted(COMMAND_FILE) != 0 ||
+        (unlink(COMMAND_FILE) && errno != ENOENT)) {
         LOGW("Can't unlink %s\n", COMMAND_FILE);
     }
 
@@ -296,64 +288,54 @@ finish_recovery(const char *send_intent) {
 }
 
 static int
-erase_root(const char *root) {
+erase_volume(const char *volume) {
     ui_set_background(BACKGROUND_ICON_INSTALLING);
     ui_show_indeterminate_progress();
-    ui_print("Formatting %s...\n", root);
-    return format_root_device(root);
+    ui_print("Formatting %s...\n", volume);
+    return format_volume(volume);
 }
 
 static char*
-copy_sideloaded_package(const char* original_root_path) {
-  if (ensure_root_path_mounted(original_root_path) != 0) {
-    LOGE("Can't mount %s\n", original_root_path);
-    return NULL;
-  }
-
-  char original_path[PATH_MAX] = "";
-  if (translate_root_path(original_root_path, original_path,
-                          sizeof(original_path)) == NULL) {
-    LOGE("Bad path %s\n", original_root_path);
+copy_sideloaded_package(const char* original_path) {
+  if (ensure_path_mounted(original_path) != 0) {
+    LOGE("Can't mount %s\n", original_path);
     return NULL;
   }
 
-  if (ensure_root_path_mounted(SIDELOAD_TEMP_DIR) != 0) {
+  if (ensure_path_mounted(SIDELOAD_TEMP_DIR) != 0) {
     LOGE("Can't mount %s\n", SIDELOAD_TEMP_DIR);
     return NULL;
   }
 
-  char copy_path[PATH_MAX] = "";
-  if (translate_root_path(SIDELOAD_TEMP_DIR, copy_path,
-                          sizeof(copy_path)) == NULL) {
-    LOGE("Bad path %s\n", SIDELOAD_TEMP_DIR);
-    return NULL;
-  }
-
-  if (mkdir(copy_path, 0700) != 0) {
+  if (mkdir(SIDELOAD_TEMP_DIR, 0700) != 0) {
     if (errno != EEXIST) {
       LOGE("Can't mkdir %s (%s)\n", SIDELOAD_TEMP_DIR, strerror(errno));
       return NULL;
     }
   }
 
+  // verify that SIDELOAD_TEMP_DIR is exactly what we expect: a
+  // directory, owned by root, readable and writable only by root.
   struct stat st;
-  if (stat(copy_path, &st) != 0) {
-    LOGE("failed to stat %s (%s)\n", copy_path, strerror(errno));
+  if (stat(SIDELOAD_TEMP_DIR, &st) != 0) {
+    LOGE("failed to stat %s (%s)\n", SIDELOAD_TEMP_DIR, strerror(errno));
     return NULL;
   }
   if (!S_ISDIR(st.st_mode)) {
-    LOGE("%s isn't a directory\n", copy_path);
+    LOGE("%s isn't a directory\n", SIDELOAD_TEMP_DIR);
     return NULL;
   }
   if ((st.st_mode & 0777) != 0700) {
-    LOGE("%s has perms %o\n", copy_path, st.st_mode);
+    LOGE("%s has perms %o\n", SIDELOAD_TEMP_DIR, st.st_mode);
     return NULL;
   }
   if (st.st_uid != 0) {
-    LOGE("%s owned by %lu; not root\n", copy_path, st.st_uid);
+    LOGE("%s owned by %lu; not root\n", SIDELOAD_TEMP_DIR, st.st_uid);
     return NULL;
   }
 
+  char copy_path[PATH_MAX];
+  strcpy(copy_path, SIDELOAD_TEMP_DIR);
   strcat(copy_path, "/package.zip");
 
   char* buffer = malloc(BUFSIZ);
@@ -400,10 +382,7 @@ copy_sideloaded_package(const char* original_root_path) {
     return NULL;
   }
 
-  char* copy_root_path = malloc(strlen(SIDELOAD_TEMP_DIR) + 20);
-  strcpy(copy_root_path, SIDELOAD_TEMP_DIR);
-  strcat(copy_root_path, "/package.zip");
-  return copy_root_path;
+  return strdup(copy_path);
 }
 
 static char**
@@ -476,15 +455,14 @@ static int compare_string(const void* a, const void* b) {
 }
 
 static int
-sdcard_directory(const char* root_path) {
+sdcard_directory(const char* path) {
     const char* MENU_HEADERS[] = { "Choose a package to install:",
-                                   root_path,
+                                   path,
                                    "",
                                    NULL };
     DIR* d;
     struct dirent* de;
-    char path[PATH_MAX];
-    d = opendir(translate_root_path(root_path, path, sizeof(path)));
+    d = opendir(path);
     if (d == NULL) {
         LOGE("error opening %s: %s\n", path, strerror(errno));
         return 0;
@@ -557,20 +535,28 @@ sdcard_directory(const char* root_path) {
         } else if (item[item_len-1] == '/') {
             // recurse down into a subdirectory
             char new_path[PATH_MAX];
-            strlcpy(new_path, root_path, PATH_MAX);
+            strlcpy(new_path, path, PATH_MAX);
+            strlcat(new_path, "/", PATH_MAX);
             strlcat(new_path, item, PATH_MAX);
+            new_path[strlen(new_path)-1] = '\0';  // truncate the trailing '/'
             result = sdcard_directory(new_path);
             if (result >= 0) break;
         } else {
             // selected a zip file:  attempt to install it, and return
             // the status to the caller.
             char new_path[PATH_MAX];
-            strlcpy(new_path, root_path, PATH_MAX);
+            strlcpy(new_path, path, PATH_MAX);
             strlcat(new_path, item, PATH_MAX);
 
-            ui_print("\n-- Install %s ...\n", new_path);
+            ui_print("\n-- Install %s ...\n", path);
             set_sdcard_update_bootloader_message();
-            result = install_package(new_path);
+            char* copy = copy_sideloaded_package(new_path);
+            if (copy) {
+                result = install_package(copy);
+                free(copy);
+            } else {
+                result = INSTALL_ERROR;
+            }
             break;
         }
     } while (true);
@@ -617,8 +603,8 @@ wipe_data(int confirm) {
 
     ui_print("\n-- Wiping data...\n");
     device_wipe_data();
-    erase_root("DATA:");
-    erase_root("CACHE:");
+    erase_volume("/data");
+    erase_volume("/cache");
     ui_print("Data wipe complete.\n");
 }
 
@@ -648,7 +634,7 @@ prompt_and_wait() {
 
             case ITEM_WIPE_CACHE:
                 ui_print("\n-- Wiping cache...\n");
-                erase_root("CACHE:");
+                erase_volume("/cache");
                 ui_print("Cache wipe complete.\n");
                 if (!ui_text_visible()) return;
                 break;
@@ -686,6 +672,7 @@ main(int argc, char **argv) {
     printf("Starting recovery on %s", ctime(&start));
 
     ui_init();
+    load_volume_table();
     get_args(&argc, &argv);
 
     int previous_runs = 0;
@@ -746,10 +733,10 @@ main(int argc, char **argv) {
         }
 
         if (status != INSTALL_ERROR) {
-            if (erase_root("DATA:")) {
+            if (erase_volume("/data")) {
                 ui_print("Data wipe failed.\n");
                 status = INSTALL_ERROR;
-            } else if (erase_root("CACHE:")) {
+            } else if (erase_volume("/cache")) {
                 ui_print("Cache wipe failed.\n");
                 status = INSTALL_ERROR;
             } else if ((encrypted_fs_data.mode == MODE_ENCRYPTED_FS_ENABLED) &&
@@ -766,11 +753,11 @@ main(int argc, char **argv) {
         if (status != INSTALL_SUCCESS) ui_print("Installation aborted.\n");
     } else if (wipe_data) {
         if (device_wipe_data()) status = INSTALL_ERROR;
-        if (erase_root("DATA:")) status = INSTALL_ERROR;
-        if (wipe_cache && erase_root("CACHE:")) status = INSTALL_ERROR;
+        if (erase_volume("/data")) status = INSTALL_ERROR;
+        if (wipe_cache && erase_volume("/cache")) status = INSTALL_ERROR;
         if (status != INSTALL_SUCCESS) ui_print("Data wipe failed.\n");
     } else if (wipe_cache) {
-        if (wipe_cache && erase_root("CACHE:")) status = INSTALL_ERROR;
+        if (wipe_cache && erase_volume("/cache")) status = INSTALL_ERROR;
         if (status != INSTALL_SUCCESS) ui_print("Cache wipe failed.\n");
     } else {
         status = INSTALL_ERROR;  // No command specified
@@ -780,7 +767,7 @@ main(int argc, char **argv) {
     if (status != INSTALL_SUCCESS || ui_text_visible()) {
         // Mount the sdcard when the menu is enabled so you can "adb
         // push" packages to the sdcard and immediately install them.
-        ensure_root_path_mounted(SDCARD_ROOT);
+        ensure_path_mounted(SDCARD_ROOT);
         prompt_and_wait();
     }
 
diff --git a/roots.c b/roots.c
index a510145e5..fb495fede 100644
--- a/roots.c
+++ b/roots.c
@@ -20,300 +20,213 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <ctype.h>
 
 #include "mtdutils/mtdutils.h"
 #include "mtdutils/mounts.h"
-#include "minzip/Zip.h"
 #include "roots.h"
 #include "common.h"
+#include "make_ext4fs.h"
 
-typedef struct {
-    const char *name;
-    const char *device;
-    const char *device2;  // If the first one doesn't work (may be NULL)
-    const char *partition_name;
-    const char *mount_point;
-    const char *filesystem;
-} RootInfo;
+static int num_volumes = 0;
+static Volume* device_volumes = NULL;
 
-/* Canonical pointers.
-xxx may just want to use enums
- */
-static const char g_mtd_device[] = "@\0g_mtd_device";
-static const char g_raw[] = "@\0g_raw";
-static const char g_package_file[] = "@\0g_package_file";
-static const char g_ramdisk[] = "@\0g_ramdisk";
-
-static RootInfo g_roots[] = {
-    { "CACHE:", g_mtd_device, NULL, "cache", "/cache", "yaffs2" },
-    { "DATA:", g_mtd_device, NULL, "userdata", "/data", "yaffs2" },
-    { "MISC:", g_mtd_device, NULL, "misc", NULL, g_raw },
-    { "SDCARD:", "/dev/block/mmcblk0p1", "/dev/block/mmcblk0", NULL, "/sdcard", "vfat" },
-    { "TMP:", NULL, NULL, NULL, "/tmp", g_ramdisk },
-};
-#define NUM_ROOTS (sizeof(g_roots) / sizeof(g_roots[0]))
-
-// TODO: for SDCARD:, try /dev/block/mmcblk0 if mmcblk0p1 fails
-
-static const RootInfo *
-get_root_info_for_path(const char *root_path)
-{
-    const char *c;
+void load_volume_table() {
+    int alloc = 2;
+    device_volumes = malloc(alloc * sizeof(Volume));
 
-    /* Find the first colon.
-     */
-    c = root_path;
-    while (*c != '\0' && *c != ':') {
-        c++;
+    FILE* fstab = fopen("/etc/recovery.fstab", "r");
+    if (fstab == NULL) {
+        LOGE("failed to open /etc/recovery.fstab (%s)\n", strerror(errno));
+        return;
     }
-    if (*c == '\0') {
-        return NULL;
-    }
-    size_t len = c - root_path + 1;
-    size_t i;
-    for (i = 0; i < NUM_ROOTS; i++) {
-        RootInfo *info = &g_roots[i];
-        if (strncmp(info->name, root_path, len) == 0) {
-            return info;
-        }
-    }
-    return NULL;
-}
 
-/* Takes a string like "SYSTEM:lib" and turns it into a string
- * like "/system/lib".  The translated path is put in out_buf,
- * and out_buf is returned if the translation succeeded.
- */
-const char *
-translate_root_path(const char *root_path, char *out_buf, size_t out_buf_len)
-{
-    if (out_buf_len < 1) {
-        return NULL;
-    }
+    char buffer[1024];
+    int i;
+    while (fgets(buffer, sizeof(buffer)-1, fstab)) {
+        for (i = 0; buffer[i] && isspace(buffer[i]); ++i);
+        if (buffer[i] == '\0' || buffer[i] == '#') continue;
 
-    const RootInfo *info = get_root_info_for_path(root_path);
-    if (info == NULL || info->mount_point == NULL) {
-        return NULL;
-    }
+        char* original = strdup(buffer);
 
-    /* Find the relative part of the non-root part of the path.
-     */
-    root_path += strlen(info->name);  // strip off the "root:"
-    while (*root_path != '\0' && *root_path == '/') {
-        root_path++;
-    }
+        char* mount_point = strtok(buffer+i, " \t\n");
+        char* fs_type = strtok(NULL, " \t\n");
+        char* device = strtok(NULL, " \t\n");
+        // lines may optionally have a second device, to use if
+        // mounting the first one fails.
+        char* device2 = strtok(NULL, " \t\n");
 
-    size_t mp_len = strlen(info->mount_point);
-    size_t rp_len = strlen(root_path);
-    if (mp_len + 1 + rp_len + 1 > out_buf_len) {
-        return NULL;
+        if (mount_point && fs_type && device) {
+            while (num_volumes >= alloc) {
+                alloc *= 2;
+                device_volumes = realloc(device_volumes, alloc*sizeof(Volume));
+            }
+            device_volumes[num_volumes].mount_point = strdup(mount_point);
+            device_volumes[num_volumes].fs_type = strdup(fs_type);
+            device_volumes[num_volumes].device = strdup(device);
+            device_volumes[num_volumes].device2 =
+                device2 ? strdup(device2) : NULL;
+            ++num_volumes;
+        } else {
+            LOGE("skipping malformed recovery.fstab line: %s\n", original);
+        }
+        free(original);
     }
 
-    /* Glue the mount point to the relative part of the path.
-     */
-    memcpy(out_buf, info->mount_point, mp_len);
-    if (out_buf[mp_len - 1] != '/') out_buf[mp_len++] = '/';
+    fclose(fstab);
 
-    memcpy(out_buf + mp_len, root_path, rp_len);
-    out_buf[mp_len + rp_len] = '\0';
-
-    return out_buf;
-}
-
-static int
-internal_root_mounted(const RootInfo *info)
-{
-    if (info->mount_point == NULL) {
-        return -1;
-    }
-    if (info->filesystem == g_ramdisk) {
-      return 0;
+    printf("recovery filesystem table\n");
+    printf("=========================\n");
+    for (i = 0; i < num_volumes; ++i) {
+        Volume* v = &device_volumes[i];
+        printf("  %d %s %s %s %s\n", i, v->mount_point, v->fs_type,
+               v->device, v->device2);
     }
+    printf("\n");
+}
 
-    /* See if this root is already mounted.
-     */
-    int ret = scan_mounted_volumes();
-    if (ret < 0) {
-        return ret;
-    }
-    const MountedVolume *volume;
-    volume = find_mounted_volume_by_mount_point(info->mount_point);
-    if (volume != NULL) {
-        /* It's already mounted.
-         */
-        return 0;
+Volume* volume_for_path(const char* path) {
+    int i;
+    for (i = 0; i < num_volumes; ++i) {
+        Volume* v = device_volumes+i;
+        int len = strlen(v->mount_point);
+        if (strncmp(path, v->mount_point, len) == 0 &&
+            (path[len] == '\0' || path[len] == '/')) {
+            return v;
+        }
     }
-    return -1;
+    return NULL;
 }
 
-int
-is_root_path_mounted(const char *root_path)
-{
-    const RootInfo *info = get_root_info_for_path(root_path);
-    if (info == NULL) {
+int ensure_path_mounted(const char* path) {
+    Volume* v = volume_for_path(path);
+    if (v == NULL) {
+        LOGE("unknown volume for path [%s]\n", path);
         return -1;
     }
-    return internal_root_mounted(info) >= 0;
-}
 
-int
-ensure_root_path_mounted(const char *root_path)
-{
-    const RootInfo *info = get_root_info_for_path(root_path);
-    if (info == NULL) {
+    int result;
+    result = scan_mounted_volumes();
+    if (result < 0) {
+        LOGE("failed to scan mounted volumes\n");
         return -1;
     }
 
-    int ret = internal_root_mounted(info);
-    if (ret >= 0) {
-        /* It's already mounted.
-         */
+    const MountedVolume* mv =
+        find_mounted_volume_by_mount_point(v->mount_point);
+    if (mv) {
+        // volume is already mounted
         return 0;
     }
 
-    /* It's not mounted.
-     */
-    if (info->device == g_mtd_device) {
-        if (info->partition_name == NULL) {
-            return -1;
-        }
-//TODO: make the mtd stuff scan once when it needs to
+    mkdir(v->mount_point, 0755);  // in case it doesn't already exist
+
+    if (strcmp(v->fs_type, "yaffs2") == 0) {
+        // mount an MTD partition as a YAFFS2 filesystem.
         mtd_scan_partitions();
-        const MtdPartition *partition;
-        partition = mtd_find_partition_by_name(info->partition_name);
+        const MtdPartition* partition;
+        partition = mtd_find_partition_by_name(v->device);
         if (partition == NULL) {
+            LOGE("failed to find \"%s\" partition to mount at \"%s\"\n",
+                 v->device, v->mount_point);
             return -1;
         }
-        return mtd_mount_partition(partition, info->mount_point,
-                info->filesystem, 0);
-    }
+        return mtd_mount_partition(partition, v->mount_point, v->fs_type, 0);
+    } else if (strcmp(v->fs_type, "ext4") == 0 ||
+               strcmp(v->fs_type, "vfat") == 0) {
+        result = mount(v->device, v->mount_point, v->fs_type,
+                       MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
+        if (result == 0) return 0;
+
+        if (v->device2) {
+            LOGW("failed to mount %s (%s); trying %s\n",
+                 v->device, strerror(errno), v->device2);
+            result = mount(v->device2, v->mount_point, v->fs_type,
+                           MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
+            if (result == 0) return 0;
+        }
 
-    if (info->device == NULL || info->mount_point == NULL ||
-        info->filesystem == NULL ||
-        info->filesystem == g_raw ||
-        info->filesystem == g_package_file) {
+        LOGE("failed to mount %s (%s)\n", v->mount_point, strerror(errno));
         return -1;
     }
 
-    mkdir(info->mount_point, 0755);  // in case it doesn't already exist
-    if (mount(info->device, info->mount_point, info->filesystem,
-            MS_NOATIME | MS_NODEV | MS_NODIRATIME, "")) {
-        if (info->device2 == NULL) {
-            LOGE("Can't mount %s\n(%s)\n", info->device, strerror(errno));
-            return -1;
-        } else if (mount(info->device2, info->mount_point, info->filesystem,
-                MS_NOATIME | MS_NODEV | MS_NODIRATIME, "")) {
-            LOGE("Can't mount %s (or %s)\n(%s)\n",
-                    info->device, info->device2, strerror(errno));
-            return -1;
-        }
-    }
-    return 0;
+    LOGE("unknown fs_type \"%s\" for %s\n", v->fs_type, v->mount_point);
+    return -1;
 }
 
-int
-ensure_root_path_unmounted(const char *root_path)
-{
-    const RootInfo *info = get_root_info_for_path(root_path);
-    if (info == NULL) {
+int ensure_path_unmounted(const char* path) {
+    Volume* v = volume_for_path(path);
+    if (v == NULL) {
+        LOGE("unknown volume for path [%s]\n", path);
         return -1;
     }
-    if (info->mount_point == NULL) {
-        /* This root can't be mounted, so by definition it isn't.
-         */
-        return 0;
-    }
-//xxx if TMP: (or similar) just return error
 
-    /* See if this root is already mounted.
-     */
-    int ret = scan_mounted_volumes();
-    if (ret < 0) {
-        return ret;
+    int result;
+    result = scan_mounted_volumes();
+    if (result < 0) {
+        LOGE("failed to scan mounted volumes\n");
+        return -1;
     }
-    const MountedVolume *volume;
-    volume = find_mounted_volume_by_mount_point(info->mount_point);
-    if (volume == NULL) {
-        /* It's not mounted.
-         */
+
+    const MountedVolume* mv =
+        find_mounted_volume_by_mount_point(v->mount_point);
+    if (mv == NULL) {
+        // volume is already unmounted
         return 0;
     }
 
-    return unmount_mounted_volume(volume);
+    return unmount_mounted_volume(mv);
 }
 
-const MtdPartition *
-get_root_mtd_partition(const char *root_path)
-{
-    const RootInfo *info = get_root_info_for_path(root_path);
-    if (info == NULL || info->device != g_mtd_device ||
-            info->partition_name == NULL)
-    {
-        return NULL;
-    }
-    mtd_scan_partitions();
-    return mtd_find_partition_by_name(info->partition_name);
-}
-
-int
-format_root_device(const char *root)
-{
-    /* Be a little safer here; require that "root" is just
-     * a device with no relative path after it.
-     */
-    const char *c = root;
-    while (*c != '\0' && *c != ':') {
-        c++;
+int format_volume(const char* volume) {
+    Volume* v = volume_for_path(volume);
+    if (v == NULL) {
+        LOGE("unknown volume \"%s\"\n", volume);
+        return -1;
     }
-    if (c[0] != ':' || c[1] != '\0') {
-        LOGW("format_root_device: bad root name \"%s\"\n", root);
+    if (strcmp(v->mount_point, volume) != 0) {
+        LOGE("can't give path \"%s\" to format_volume\n", volume);
         return -1;
     }
 
-    const RootInfo *info = get_root_info_for_path(root);
-    if (info == NULL || info->device == NULL) {
-        LOGW("format_root_device: can't resolve \"%s\"\n", root);
+    if (ensure_path_unmounted(volume) != 0) {
+        LOGE("format_volume failed to unmount \"%s\"\n", v->mount_point);
         return -1;
     }
-    if (info->mount_point != NULL) {
-        /* Don't try to format a mounted device.
-         */
-        int ret = ensure_root_path_unmounted(root);
-        if (ret < 0) {
-            LOGW("format_root_device: can't unmount \"%s\"\n", root);
-            return ret;
-        }
-    }
 
-    /* Format the device.
-     */
-    if (info->device == g_mtd_device) {
+    if (strcmp(v->fs_type, "yaffs2") == 0 || strcmp(v->fs_type, "mtd") == 0) {
         mtd_scan_partitions();
-        const MtdPartition *partition;
-        partition = mtd_find_partition_by_name(info->partition_name);
+        const MtdPartition* partition = mtd_find_partition_by_name(v->device);
         if (partition == NULL) {
-            LOGW("format_root_device: can't find mtd partition \"%s\"\n",
-                    info->partition_name);
+            LOGE("format_volume: no MTD partition \"%s\"\n", v->device);
             return -1;
         }
-        if (info->filesystem == g_raw || !strcmp(info->filesystem, "yaffs2")) {
-            MtdWriteContext *write = mtd_write_partition(partition);
-            if (write == NULL) {
-                LOGW("format_root_device: can't open \"%s\"\n", root);
-                return -1;
-            } else if (mtd_erase_blocks(write, -1) == (off_t) -1) {
-                LOGW("format_root_device: can't erase \"%s\"\n", root);
-                mtd_write_close(write);
-                return -1;
-            } else if (mtd_write_close(write)) {
-                LOGW("format_root_device: can't close \"%s\"\n", root);
-                return -1;
-            } else {
-                return 0;
-            }
+
+        MtdWriteContext *write = mtd_write_partition(partition);
+        if (write == NULL) {
+            LOGW("format_volume: can't open MTD \"%s\"\n", v->device);
+            return -1;
+        } else if (mtd_erase_blocks(write, -1) == (off_t) -1) {
+            LOGW("format_volume: can't erase MTD \"%s\"\n", v->device);
+            mtd_write_close(write);
+            return -1;
+        } else if (mtd_write_close(write)) {
+            LOGW("format_volume: can't close MTD \"%s\"\n", v->device);
+            return -1;
         }
+        return 0;
     }
-//TODO: handle other device types (sdcard, etc.)
-    LOGW("format_root_device: can't handle non-mtd device \"%s\"\n", root);
+
+    if (strcmp(v->fs_type, "ext4") == 0) {
+        reset_ext4fs_info();
+        int result = make_ext4fs(v->device, NULL, NULL, 0, 0, 0);
+        if (result != 0) {
+            LOGE("format_volume: make_extf4fs failed on %s\n", v->device);
+            return -1;
+        }
+        return 0;
+    }
+
+    LOGE("format_volume: fs_type \"%s\" unsupported\n", v->fs_type);
     return -1;
 }
diff --git a/roots.h b/roots.h
index e85191d99..cf59bfdf3 100644
--- a/roots.h
+++ b/roots.h
@@ -17,33 +17,25 @@
 #ifndef RECOVERY_ROOTS_H_
 #define RECOVERY_ROOTS_H_
 
-#include "minzip/Zip.h"
-#include "mtdutils/mtdutils.h"
+#include "common.h"
 
-/* Any of the "root_path" arguments can be paths with relative
- * components, like "SYSTEM:a/b/c".
- */
-
-/* Takes a string like "SYSTEM:lib" and turns it into a string
- * like "/system/lib".  The translated path is put in out_buf,
- * and out_buf is returned if the translation succeeded.
- */
-const char *translate_root_path(const char *root_path,
-        char *out_buf, size_t out_buf_len);
+// Load and parse volume data from /etc/recovery.fstab.
+void load_volume_table();
 
-/* Returns negative on error, positive if it's mounted, zero if it isn't.
- */
-int is_root_path_mounted(const char *root_path);
-
-int ensure_root_path_mounted(const char *root_path);
+// Return the Volume* record for this path (or NULL).
+Volume* volume_for_path(const char* path);
 
-int ensure_root_path_unmounted(const char *root_path);
+// Make sure that the volume 'path' is on is mounted.  Returns 0 on
+// success (volume is mounted).
+int ensure_path_mounted(const char* path);
 
-const MtdPartition *get_root_mtd_partition(const char *root_path);
+// Make sure that the volume 'path' is on is mounted.  Returns 0 on
+// success (volume is unmounted);
+int ensure_path_unmounted(const char* path);
 
-/* "root" must be the exact name of the root; no relative path is permitted.
- * If the named root is mounted, this will attempt to unmount it first.
- */
-int format_root_device(const char *root);
+// Reformat the given volume (must be the mount point only, eg
+// "/cache"), no paths permitted.  Attempts to unmount the volume if
+// it is mounted.
+int format_volume(const char* volume);
 
 #endif  // RECOVERY_ROOTS_H_
diff --git a/test_roots.c b/test_roots.c
deleted file mode 100644
index f49f55e21..000000000
--- a/test_roots.c
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (C) 2007 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.
- */
-
-#include <sys/stat.h>
-#include "roots.h"
-#include "common.h"
-
-#define CANARY_FILE "/system/build.prop"
-#define CANARY_FILE_ROOT_PATH "SYSTEM:build.prop"
-
-int
-file_exists(const char *path)
-{
-    struct stat st;
-    int ret;
-    ret = stat(path, &st);
-    if (ret == 0) {
-        return S_ISREG(st.st_mode);
-    }
-    return 0;
-}
-
-int
-test_roots()
-{
-    int ret;
-
-    /* Make sure that /system isn't mounted yet.
-     */
-    if (file_exists(CANARY_FILE)) return -__LINE__;
-    if (is_root_path_mounted(CANARY_FILE_ROOT_PATH)) return -__LINE__;
-
-    /* Try to mount the root.
-     */
-    ret = ensure_root_path_mounted(CANARY_FILE_ROOT_PATH);
-    if (ret < 0) return -__LINE__;
-
-    /* Make sure we can see the file now and that we know the root is mounted.
-     */
-    if (!file_exists(CANARY_FILE)) return -__LINE__;
-    if (!is_root_path_mounted(CANARY_FILE_ROOT_PATH)) return -__LINE__;
-
-    /* Make sure that the root path corresponds to the regular path.
-     */
-    struct stat st1, st2;
-    char buf[128];
-    const char *path = translate_root_path(CANARY_FILE_ROOT_PATH,
-            buf, sizeof(buf));
-    if (path == NULL) return -__LINE__;
-    ret = stat(CANARY_FILE, &st1);
-    if (ret != 0) return -__LINE__;
-    ret = stat(path, &st2);
-    if (ret != 0) return -__LINE__;
-    if (st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino) return -__LINE__;
-
-    /* Try to unmount the root.
-     */
-    ret = ensure_root_path_unmounted(CANARY_FILE_ROOT_PATH);
-    if (ret < 0) return -__LINE__;
-
-    /* Make sure that we can't see the file anymore and that
-     * we don't think the root is mounted.
-     */
-    if (file_exists(CANARY_FILE)) return -__LINE__;
-    if (is_root_path_mounted(CANARY_FILE_ROOT_PATH)) return -__LINE__;
-
-    return 0;
-}