android/android-emu/android/filesystems/partition_config.cpp - qemu-android - Git at Google

 // Copyright 2015 The Android Open Source Project
 //
 // This software is licensed under the terms of the GNU General Public
 // License version 2, as published by the Free Software Foundation, and
 // may be copied, distributed, and modified under those terms.
 //
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.

 #include "android/filesystems/partition_config.h"

 #include "android/base/system/System.h"
 #include "android/filesystems/internal/PartitionConfigBackend.h"
 #include "android/utils/debug.h"

 #include <errno.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 using android::internal::PartitionConfigBackend;
 using android::base::System;

 // State structure shared by several functions.
 typedef struct {
     char** error_message;
     AndroidPartitionSetupFunction setup_func;
     void* setup_opaque;
     PartitionConfigBackend* backend;
 } PartitionConfigState;

 // Helper function used to record an error message into the |state|,
 // then return false. |format| is a typical printf()-like formatting
 // string followed by optional arguments. Always return false to
 // indicate an error.
 static bool partition_config_error(PartitionConfigState* state,
                                    const char* format,
                                    ...) {
     va_list args;
     va_start(args, format);
     vasprintf(state->error_message, format, args);
     va_end(args);
     return false;
 }

 // Extract the partition type/format of a given partition image
 // from the content of fstab.goldfish.
 // |fstab| is the address of the fstab.goldfish data in memory.
 // |fstabSize| is its size in bytes.
 // |partitionName| is the name of the partition for debugging
 // purposes (e.g. 'userdata').
 // |partitionPath| is the partition path as it appears in the
 // fstab file (e.g. '/data').
 // On success, sets |*partitionType| to an appropriate value,
 // on failure (i.e. |partitionPath| does not appear in the fstab
 // file), leave the value untouched.
 static void extractPartitionFormat(PartitionConfigState* state,
                                    const std::string& fstab,
                                    const char* partitionName,
                                    const char* partitionPath,
                                    AndroidPartitionType* partitionType) {
     std::string partFormat;
     if (!state->backend->parsePartitionFormat(fstab, partitionPath,
                                               &partFormat)) {
         VERBOSE_PRINT(init, "Could not extract format of %s partition!",
                       partitionName);
         return;
     }
     VERBOSE_PRINT(init, "Found format of %s partition: '%s'", partitionName,
                   partFormat.c_str());
     *partitionType = androidPartitionType_fromString(partFormat.c_str());
 }

 // List of value describing how to handle partition images in
 // addNandImage() below, when no initial partition image
 // file is provided.
 //
 // MUST_EXIST means that the partition image must exist, otherwise
 // dump an error message and exit.
 //
 // CREATE_IF_NEEDED means that if the partition image doesn't exist, an
 // empty partition file should be created on demand.
 //
 // MUST_WIPE means that the partition image should be wiped cleaned,
 // even if it exists. This is useful to implement the -wipe-data option.
 typedef enum {
     ANDROID_PARTITION_OPEN_MODE_MUST_EXIST,
     ANDROID_PARTITION_OPEN_MODE_CREATE_IF_NEEDED,
     ANDROID_PARTITION_OPEN_MODE_MUST_WIPE,
 } AndroidPartitionOpenMode;

 // Add a NAND partition image to the hardware configuration.
 //
 // |part_name| is a string indicating the type of partition, i.e. "system",
 // "userdata" or "cache".
 // |part_type| is an enum describing the type of partition. If it is
 // DISK_PARTITION_TYPE_PROBE, then try to auto-detect the type directly
 // from the content of |part_file| or |part_init_file|.
 // |part_mode| is an enum describing how to handle the partition image,
 // see AndroidPartitionOpenMode for details.
 // |part_size| is the partition size in bytes.
 // |part_file| is the partition file path, can be NULL if |path_init_file|
 // is not NULL.
 // |part_init_file| is an optional path to the initialization partition file.
 //
 // The NAND partition will be backed by |part_file|, except in the following
 // cases:
 //    - |part_file| is NULL, or its value is "<temp>", indicating that a
 //      new temporary image file must be used instead.
 //
 //    - |part_file| is not NULL, but the function fails to lock the file,
 //      indicating it's already used by another instance. A warning should
 //      be printed to warn the user, and a new temporary image should be
 //      used.
 //
 // If |part_file| is not NULL and can be locked, if the partition image does
 // not exit, then the file must be created as an empty partition.
 //
 // If |part_init_file| is not NULL, its content will be used to erase
 // the content of the main partition image. This is automatically handled
 // by the NAND code though.
 //
 // If |readonly| is true, then either the |part_file| or |part_init_file| will
 // be mounted as read-only devices. This also prevents locking the partition
 // image and creation of temporary copies.
 //
 static bool addNandImage(PartitionConfigState* state,
                          const char* part_name,
                          AndroidPartitionType part_type,
                          AndroidPartitionOpenMode part_mode,
                          uint64_t part_size,
                          const char* part_file,
                          const char* part_init_file,
                          bool readonly) {
     // Sanitize parameters, an empty string must be the same as NULL.
     if (part_file && !*part_file) {
         part_file = NULL;
     }
     if (part_init_file && !*part_init_file) {
         part_init_file = NULL;
     }

     // Sanity checks.
     if (part_size == 0) {
         return partition_config_error(
                 state, "Invalid %s partition size 0x%" PRIx64,
                 part_name, part_size);
     }

     if (part_init_file && !state->backend->pathExists(part_init_file)) {
         return partition_config_error(state, "Missing initial %s image: %s",
                                       part_name, part_init_file);
     }

     // In read-only mode, the initial partition image can be treated as
     // the main one.
     if (readonly && !part_file && part_init_file) {
         part_file = part_init_file;
         part_init_file = nullptr;
     }

     // As a special case, a |part_file| of '<temp>' means a temporary
     // partition is needed.
     if (part_file && !strcmp(part_file, "<temp>")) {
         part_file = NULL;
     }

     // Verify partition type, or probe it if needed.
     {
         // First determine which image file to probe.
         const char* image_file = NULL;
         if (part_file && state->backend->pathExists(part_file)) {
             image_file = part_file;
         } else if (part_init_file) {
             image_file = part_init_file;
         } else if (part_type == ANDROID_PARTITION_TYPE_UNKNOWN) {
             return partition_config_error(
                     state,
                     "Cannot determine type of %s partition: no image files!",
                     part_name);
         }

         if (part_type == ANDROID_PARTITION_TYPE_UNKNOWN) {
             VERBOSE_PRINT(init, "Probing %s image file for partition type: %s",
                           part_name, image_file);

             part_type = state->backend->probePartitionFileType(image_file);
         } else if (image_file) {
             // Probe the current image file to check that it is of the
             // right partition format.
             AndroidPartitionType image_type =
                     state->backend->probePartitionFileType(image_file);
             if (image_type == ANDROID_PARTITION_TYPE_UNKNOWN) {
                 return partition_config_error(
                         state, "Cannot determine %s partition type of: %s",
                         part_name, image_file);
             }

             if (image_type != part_type) {
                 // The image file exists, but is not in the proper format!
                 // This can happen in certain cases, e.g. a KitKat/x86 AVD
                 // created with SDK 23.0.2 and started with the
                 // corresponding emulator will create a cache.img in 'yaffs2'
                 // format, while the system really expect it to be 'ext4',
                 // as listed in the ramdisk.img.
                 //
                 // To work-around the problem, simply re-create the file
                 // by wiping it when allowed.

                 if (part_mode == ANDROID_PARTITION_OPEN_MODE_MUST_EXIST) {
                     return partition_config_error(
                             state,
                             "Invalid %s partition image type: %s (expected %s)",
                             part_name,
                             androidPartitionType_toString(image_type),
                             androidPartitionType_toString(part_type));
                 }
                 VERBOSE_PRINT(init,
                               "Image type mismatch for %s partition: "
                               "%s (expected %s)",
                               part_name,
                               androidPartitionType_toString(image_type),
                               androidPartitionType_toString(part_type));

                 part_mode = ANDROID_PARTITION_OPEN_MODE_MUST_WIPE;
             }
         }
     }

     VERBOSE_PRINT(init, "%s partition format: %s", part_name,
                   androidPartitionType_toString(part_type));

     bool need_make_empty = (part_mode == ANDROID_PARTITION_OPEN_MODE_MUST_WIPE);

     // Must be here to avoid freeing the string too early.
     std::string tempFile;

     if (readonly) {
         if (!state->backend->pathExists(part_file)) {
             return partition_config_error(
                     state, "Missing read-only %s partition image: %s",
                     part_name, part_file);
         }
         need_make_empty = false;
     } else {
         bool need_temp_partition = true;

         if (part_init_file) {
             need_make_empty = true;
         }

         if (part_file) {
             if (!state->backend->pathLockFile(part_file)) {
                 dwarning("%s image already in use, changes will not persist!\n",
                          part_name);
             } else {
                 need_temp_partition = false;

                 // If the partition image is missing, create it.
                 if (!state->backend->pathExists(part_file)) {
                     if (part_mode == ANDROID_PARTITION_OPEN_MODE_MUST_EXIST) {
                         return partition_config_error(
                                 state, "Missing %s partition image: %s",
                                 part_name, part_file);
                     }
                     if (!state->backend->pathEmptyFile(part_file) < 0) {
                         return partition_config_error(
                                 state, "Cannot create %s image file at %s: %s",
                                 part_name, part_file, strerror(errno));
                     }
                     need_make_empty = true;
                 }
             }
         }

         // Do we need a temporary partition image ?
         if (need_temp_partition) {
             if (!state->backend->pathCreateTempFile(&tempFile)) {
                 return partition_config_error(state,
                                               "Could not create temp file for "
                                               "%s partition image: %s\n",
                                               part_name, strerror(errno));
             }
             part_file = tempFile.c_str();
             VERBOSE_PRINT(init, "Mapping '%s' partition image to %s", part_name,
                           part_file);

             need_make_empty = true;
         }

         // Do we need to copy the initial partition file into the real one?
         if (part_init_file) {
             if (!state->backend->pathCopyFile(part_file, part_init_file)) {
                 return partition_config_error(
                         state,
                         "Could not copy initial %s partition "
                         "image to real one: %s\n",
                         part_name, strerror(errno));
             }
             need_make_empty = false;
         }
     }

     // Do we need to make the partition image empty?
     if (need_make_empty) {
         VERBOSE_PRINT(init, "Creating empty %s partition image at: %s",
                       part_name, part_file);
         int ret = state->backend->makeEmptyPartition(part_type, part_size,
                                                      part_file);
         if (ret < 0) {
             return partition_config_error(
                     state, "Could not create %s image file at %s: %s",
                     part_name, part_file, strerror(-ret));
         }
     }

     (*state->setup_func)(state->setup_opaque, part_name, part_size, part_file,
                          part_type, readonly);

     return true;
 }

 bool android_partition_configuration_setup(
         const AndroidPartitionConfiguration* config,
         AndroidPartitionSetupFunction setup_func,
         void* setup_opaque,
         char** error_message) {
     // Setup shared state.
     PartitionConfigState state[1] = {{
             .error_message = error_message,
             .setup_func = setup_func,
             .setup_opaque = setup_opaque,
             .backend = PartitionConfigBackend::get(),
     }};

     // Determine format of all partition images, if possible.
     // Note that _UNKNOWN means the file, if it exists, will be probed.
     AndroidPartitionType system_partition_type = ANDROID_PARTITION_TYPE_UNKNOWN;
     AndroidPartitionType userdata_partition_type =
             ANDROID_PARTITION_TYPE_UNKNOWN;
     AndroidPartitionType cache_partition_type = ANDROID_PARTITION_TYPE_UNKNOWN;

     {
         // Starting with Android 4.4.x, the ramdisk.img contains
         // an fstab.goldfish file that lists the format of each partition.
         // If the file exists, parse it to get the appropriate values.
         std::string fstab;

         if (state->backend->extractRamdiskFile(config->ramdisk_path,
                                                config->fstab_name, &fstab)) {
             VERBOSE_PRINT(init, "Ramdisk image contains %s file",
                           config->fstab_name);

             extractPartitionFormat(state, fstab, "system", "/system",
                                    &system_partition_type);

             extractPartitionFormat(state, fstab, "userdata", "/data",
                                    &userdata_partition_type);

             extractPartitionFormat(state, fstab, "cache", "/cache",
                                    &cache_partition_type);
         } else {
             VERBOSE_PRINT(init, "No %s file in ramdisk image",
                           config->fstab_name);
         }
     }

     // Initialize system partition image.
     if (!addNandImage(
                 state, "system", system_partition_type,
                 ANDROID_PARTITION_OPEN_MODE_MUST_EXIST,
                 config->system_partition.size, config->system_partition.path,
                 config->system_partition.init_path, !config->writable_system)) {
         return false;
     }

     // Initialize data partition image.
     AndroidPartitionOpenMode userdata_partition_mode = config->wipe_data ?
             ANDROID_PARTITION_OPEN_MODE_MUST_WIPE :
             ANDROID_PARTITION_OPEN_MODE_CREATE_IF_NEEDED;

     if (!addNandImage(state, "userdata", userdata_partition_type,
                       userdata_partition_mode, config->data_partition.size,
                       config->data_partition.path,
                       config->data_partition.init_path, false)) {
         return false;
     }

     // Extend the userdata-qemu.img to the desired size - resize2fs can only
     // extend partitions to fill available space.
     // Resize userdata-qemu.img if the size is smaller than what config.ini
     // says.
     // This can happen as user wants a larger data partition without wiping it.
     // b.android.com/196926
     System::FileSize current_data_size(config->data_partition.size);
     System::get()->pathFileSize(config->data_partition.path,
                                 &current_data_size);
     if ((config->wipe_data ||
          current_data_size < config->data_partition.size) &&
         userdata_partition_type == ANDROID_PARTITION_TYPE_EXT4) {
         if (current_data_size < config->data_partition.size) {
             VERBOSE_PRINT(init,
                           "userdata partition is resized from %d M to %d M\n",
                           current_data_size / (1024 * 1024),
                           config->data_partition.size / (1024 * 1024));
         }
         state->backend->resizeExt4Partition(config->data_partition.path,
                                             config->data_partition.size);
     }

     // Initialize cache partition image, if any. Its type depends on the
     // kernel version. For anything >= 3.10, it must be EXT4, or
     // YAFFS2 otherwise.
     if (config->cache_partition.path) {
         if (cache_partition_type == ANDROID_PARTITION_TYPE_UNKNOWN) {
             cache_partition_type = config->kernel_supports_yaffs2
                                            ? ANDROID_PARTITION_TYPE_YAFFS2
                                            : ANDROID_PARTITION_TYPE_EXT4;
         }

         AndroidPartitionOpenMode cache_partition_mode =
                 (config->wipe_data
                          ? ANDROID_PARTITION_OPEN_MODE_MUST_WIPE
                          : ANDROID_PARTITION_OPEN_MODE_CREATE_IF_NEEDED);

         if (!addNandImage(state, "cache", cache_partition_type,
                           cache_partition_mode, config->cache_partition.size,
                           config->cache_partition.path, NULL, false)) {
             return false;
         }
     }

     return true;
 }
	// Copyright 2015 The Android Open Source Project
	//
	// This software is licensed under the terms of the GNU General Public
	// License version 2, as published by the Free Software Foundation, and
	// may be copied, distributed, and modified under those terms.
	//
	// This program is distributed in the hope that it will be useful,
	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	// GNU General Public License for more details.

	#include "android/filesystems/partition_config.h"

	#include "android/base/system/System.h"
	#include "android/filesystems/internal/PartitionConfigBackend.h"
	#include "android/utils/debug.h"

	#include <errno.h>
	#include <limits.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	using android::internal::PartitionConfigBackend;
	using android::base::System;

	// State structure shared by several functions.
	typedef struct {
	char** error_message;
	AndroidPartitionSetupFunction setup_func;
	void* setup_opaque;
	PartitionConfigBackend* backend;
	} PartitionConfigState;

	// Helper function used to record an error message into the \|state\|,
	// then return false. \|format\| is a typical printf()-like formatting
	// string followed by optional arguments. Always return false to
	// indicate an error.
	static bool partition_config_error(PartitionConfigState* state,
	const char* format,
	...) {
	va_list args;
	va_start(args, format);
	vasprintf(state->error_message, format, args);
	va_end(args);
	return false;
	}

	// Extract the partition type/format of a given partition image
	// from the content of fstab.goldfish.
	// \|fstab\| is the address of the fstab.goldfish data in memory.
	// \|fstabSize\| is its size in bytes.
	// \|partitionName\| is the name of the partition for debugging
	// purposes (e.g. 'userdata').
	// \|partitionPath\| is the partition path as it appears in the
	// fstab file (e.g. '/data').
	// On success, sets \|*partitionType\| to an appropriate value,
	// on failure (i.e. \|partitionPath\| does not appear in the fstab
	// file), leave the value untouched.
	static void extractPartitionFormat(PartitionConfigState* state,
	const std::string& fstab,
	const char* partitionName,
	const char* partitionPath,
	AndroidPartitionType* partitionType) {
	std::string partFormat;
	if (!state->backend->parsePartitionFormat(fstab, partitionPath,
	&partFormat)) {
	VERBOSE_PRINT(init, "Could not extract format of %s partition!",
	partitionName);
	return;
	}
	VERBOSE_PRINT(init, "Found format of %s partition: '%s'", partitionName,
	partFormat.c_str());
	*partitionType = androidPartitionType_fromString(partFormat.c_str());
	}

	// List of value describing how to handle partition images in
	// addNandImage() below, when no initial partition image
	// file is provided.
	//
	// MUST_EXIST means that the partition image must exist, otherwise
	// dump an error message and exit.
	//
	// CREATE_IF_NEEDED means that if the partition image doesn't exist, an
	// empty partition file should be created on demand.
	//
	// MUST_WIPE means that the partition image should be wiped cleaned,
	// even if it exists. This is useful to implement the -wipe-data option.
	typedef enum {
	ANDROID_PARTITION_OPEN_MODE_MUST_EXIST,
	ANDROID_PARTITION_OPEN_MODE_CREATE_IF_NEEDED,
	ANDROID_PARTITION_OPEN_MODE_MUST_WIPE,
	} AndroidPartitionOpenMode;

	// Add a NAND partition image to the hardware configuration.
	//
	// \|part_name\| is a string indicating the type of partition, i.e. "system",
	// "userdata" or "cache".
	// \|part_type\| is an enum describing the type of partition. If it is
	// DISK_PARTITION_TYPE_PROBE, then try to auto-detect the type directly
	// from the content of \|part_file\| or \|part_init_file\|.
	// \|part_mode\| is an enum describing how to handle the partition image,
	// see AndroidPartitionOpenMode for details.
	// \|part_size\| is the partition size in bytes.
	// \|part_file\| is the partition file path, can be NULL if \|path_init_file\|
	// is not NULL.
	// \|part_init_file\| is an optional path to the initialization partition file.
	//
	// The NAND partition will be backed by \|part_file\|, except in the following
	// cases:
	// - \|part_file\| is NULL, or its value is "<temp>", indicating that a
	// new temporary image file must be used instead.
	//
	// - \|part_file\| is not NULL, but the function fails to lock the file,
	// indicating it's already used by another instance. A warning should
	// be printed to warn the user, and a new temporary image should be
	// used.
	//
	// If \|part_file\| is not NULL and can be locked, if the partition image does
	// not exit, then the file must be created as an empty partition.
	//
	// If \|part_init_file\| is not NULL, its content will be used to erase
	// the content of the main partition image. This is automatically handled
	// by the NAND code though.
	//
	// If \|readonly\| is true, then either the \|part_file\| or \|part_init_file\| will
	// be mounted as read-only devices. This also prevents locking the partition
	// image and creation of temporary copies.
	//
	static bool addNandImage(PartitionConfigState* state,
	const char* part_name,
	AndroidPartitionType part_type,
	AndroidPartitionOpenMode part_mode,
	uint64_t part_size,
	const char* part_file,
	const char* part_init_file,
	bool readonly) {
	// Sanitize parameters, an empty string must be the same as NULL.
	if (part_file && !*part_file) {
	part_file = NULL;
	}
	if (part_init_file && !*part_init_file) {
	part_init_file = NULL;
	}

	// Sanity checks.
	if (part_size == 0) {
	return partition_config_error(
	state, "Invalid %s partition size 0x%" PRIx64,
	part_name, part_size);
	}

	if (part_init_file && !state->backend->pathExists(part_init_file)) {
	return partition_config_error(state, "Missing initial %s image: %s",
	part_name, part_init_file);
	}

	// In read-only mode, the initial partition image can be treated as
	// the main one.
	if (readonly && !part_file && part_init_file) {
	part_file = part_init_file;
	part_init_file = nullptr;
	}

	// As a special case, a \|part_file\| of '<temp>' means a temporary
	// partition is needed.
	if (part_file && !strcmp(part_file, "<temp>")) {
	part_file = NULL;
	}

	// Verify partition type, or probe it if needed.
	{
	// First determine which image file to probe.
	const char* image_file = NULL;
	if (part_file && state->backend->pathExists(part_file)) {
	image_file = part_file;
	} else if (part_init_file) {
	image_file = part_init_file;
	} else if (part_type == ANDROID_PARTITION_TYPE_UNKNOWN) {
	return partition_config_error(
	state,
	"Cannot determine type of %s partition: no image files!",
	part_name);
	}

	if (part_type == ANDROID_PARTITION_TYPE_UNKNOWN) {
	VERBOSE_PRINT(init, "Probing %s image file for partition type: %s",
	part_name, image_file);

	part_type = state->backend->probePartitionFileType(image_file);
	} else if (image_file) {
	// Probe the current image file to check that it is of the
	// right partition format.
	AndroidPartitionType image_type =
	state->backend->probePartitionFileType(image_file);
	if (image_type == ANDROID_PARTITION_TYPE_UNKNOWN) {
	return partition_config_error(
	state, "Cannot determine %s partition type of: %s",
	part_name, image_file);
	}

	if (image_type != part_type) {
	// The image file exists, but is not in the proper format!
	// This can happen in certain cases, e.g. a KitKat/x86 AVD
	// created with SDK 23.0.2 and started with the
	// corresponding emulator will create a cache.img in 'yaffs2'
	// format, while the system really expect it to be 'ext4',
	// as listed in the ramdisk.img.
	//
	// To work-around the problem, simply re-create the file
	// by wiping it when allowed.

	if (part_mode == ANDROID_PARTITION_OPEN_MODE_MUST_EXIST) {
	return partition_config_error(
	state,
	"Invalid %s partition image type: %s (expected %s)",
	part_name,
	androidPartitionType_toString(image_type),
	androidPartitionType_toString(part_type));
	}
	VERBOSE_PRINT(init,
	"Image type mismatch for %s partition: "
	"%s (expected %s)",
	part_name,
	androidPartitionType_toString(image_type),
	androidPartitionType_toString(part_type));

	part_mode = ANDROID_PARTITION_OPEN_MODE_MUST_WIPE;
	}
	}
	}

	VERBOSE_PRINT(init, "%s partition format: %s", part_name,
	androidPartitionType_toString(part_type));

	bool need_make_empty = (part_mode == ANDROID_PARTITION_OPEN_MODE_MUST_WIPE);

	// Must be here to avoid freeing the string too early.
	std::string tempFile;

	if (readonly) {
	if (!state->backend->pathExists(part_file)) {
	return partition_config_error(
	state, "Missing read-only %s partition image: %s",
	part_name, part_file);
	}
	need_make_empty = false;
	} else {
	bool need_temp_partition = true;

	if (part_init_file) {
	need_make_empty = true;
	}

	if (part_file) {
	if (!state->backend->pathLockFile(part_file)) {
	dwarning("%s image already in use, changes will not persist!\n",
	part_name);
	} else {
	need_temp_partition = false;

	// If the partition image is missing, create it.
	if (!state->backend->pathExists(part_file)) {
	if (part_mode == ANDROID_PARTITION_OPEN_MODE_MUST_EXIST) {
	return partition_config_error(
	state, "Missing %s partition image: %s",
	part_name, part_file);
	}
	if (!state->backend->pathEmptyFile(part_file) < 0) {
	return partition_config_error(
	state, "Cannot create %s image file at %s: %s",
	part_name, part_file, strerror(errno));
	}
	need_make_empty = true;
	}
	}
	}

	// Do we need a temporary partition image ?
	if (need_temp_partition) {
	if (!state->backend->pathCreateTempFile(&tempFile)) {
	return partition_config_error(state,
	"Could not create temp file for "
	"%s partition image: %s\n",
	part_name, strerror(errno));
	}
	part_file = tempFile.c_str();
	VERBOSE_PRINT(init, "Mapping '%s' partition image to %s", part_name,
	part_file);

	need_make_empty = true;
	}

	// Do we need to copy the initial partition file into the real one?
	if (part_init_file) {
	if (!state->backend->pathCopyFile(part_file, part_init_file)) {
	return partition_config_error(
	state,
	"Could not copy initial %s partition "
	"image to real one: %s\n",
	part_name, strerror(errno));
	}
	need_make_empty = false;
	}
	}

	// Do we need to make the partition image empty?
	if (need_make_empty) {
	VERBOSE_PRINT(init, "Creating empty %s partition image at: %s",
	part_name, part_file);
	int ret = state->backend->makeEmptyPartition(part_type, part_size,
	part_file);
	if (ret < 0) {
	return partition_config_error(
	state, "Could not create %s image file at %s: %s",
	part_name, part_file, strerror(-ret));
	}
	}

	(*state->setup_func)(state->setup_opaque, part_name, part_size, part_file,
	part_type, readonly);

	return true;
	}

	bool android_partition_configuration_setup(
	const AndroidPartitionConfiguration* config,
	AndroidPartitionSetupFunction setup_func,
	void* setup_opaque,
	char** error_message) {
	// Setup shared state.
	PartitionConfigState state[1] = {{
	.error_message = error_message,
	.setup_func = setup_func,
	.setup_opaque = setup_opaque,
	.backend = PartitionConfigBackend::get(),
	}};

	// Determine format of all partition images, if possible.
	// Note that _UNKNOWN means the file, if it exists, will be probed.
	AndroidPartitionType system_partition_type = ANDROID_PARTITION_TYPE_UNKNOWN;
	AndroidPartitionType userdata_partition_type =
	ANDROID_PARTITION_TYPE_UNKNOWN;
	AndroidPartitionType cache_partition_type = ANDROID_PARTITION_TYPE_UNKNOWN;

	{
	// Starting with Android 4.4.x, the ramdisk.img contains
	// an fstab.goldfish file that lists the format of each partition.
	// If the file exists, parse it to get the appropriate values.
	std::string fstab;

	if (state->backend->extractRamdiskFile(config->ramdisk_path,
	config->fstab_name, &fstab)) {
	VERBOSE_PRINT(init, "Ramdisk image contains %s file",
	config->fstab_name);

	extractPartitionFormat(state, fstab, "system", "/system",
	&system_partition_type);

	extractPartitionFormat(state, fstab, "userdata", "/data",
	&userdata_partition_type);

	extractPartitionFormat(state, fstab, "cache", "/cache",
	&cache_partition_type);
	} else {
	VERBOSE_PRINT(init, "No %s file in ramdisk image",
	config->fstab_name);
	}
	}

	// Initialize system partition image.
	if (!addNandImage(
	state, "system", system_partition_type,
	ANDROID_PARTITION_OPEN_MODE_MUST_EXIST,
	config->system_partition.size, config->system_partition.path,
	config->system_partition.init_path, !config->writable_system)) {
	return false;
	}

	// Initialize data partition image.
	AndroidPartitionOpenMode userdata_partition_mode = config->wipe_data ?
	ANDROID_PARTITION_OPEN_MODE_MUST_WIPE :
	ANDROID_PARTITION_OPEN_MODE_CREATE_IF_NEEDED;

	if (!addNandImage(state, "userdata", userdata_partition_type,
	userdata_partition_mode, config->data_partition.size,
	config->data_partition.path,
	config->data_partition.init_path, false)) {
	return false;
	}

	// Extend the userdata-qemu.img to the desired size - resize2fs can only
	// extend partitions to fill available space.
	// Resize userdata-qemu.img if the size is smaller than what config.ini
	// says.
	// This can happen as user wants a larger data partition without wiping it.
	// b.android.com/196926
	System::FileSize current_data_size(config->data_partition.size);
	System::get()->pathFileSize(config->data_partition.path,
	&current_data_size);
	if ((config->wipe_data \|\|
	current_data_size < config->data_partition.size) &&
	userdata_partition_type == ANDROID_PARTITION_TYPE_EXT4) {
	if (current_data_size < config->data_partition.size) {
	VERBOSE_PRINT(init,
	"userdata partition is resized from %d M to %d M\n",
	current_data_size / (1024 * 1024),
	config->data_partition.size / (1024 * 1024));
	}
	state->backend->resizeExt4Partition(config->data_partition.path,
	config->data_partition.size);
	}

	// Initialize cache partition image, if any. Its type depends on the
	// kernel version. For anything >= 3.10, it must be EXT4, or
	// YAFFS2 otherwise.
	if (config->cache_partition.path) {
	if (cache_partition_type == ANDROID_PARTITION_TYPE_UNKNOWN) {
	cache_partition_type = config->kernel_supports_yaffs2
	? ANDROID_PARTITION_TYPE_YAFFS2
	: ANDROID_PARTITION_TYPE_EXT4;
	}

	AndroidPartitionOpenMode cache_partition_mode =
	(config->wipe_data
	? ANDROID_PARTITION_OPEN_MODE_MUST_WIPE
	: ANDROID_PARTITION_OPEN_MODE_CREATE_IF_NEEDED);

	if (!addNandImage(state, "cache", cache_partition_type,
	cache_partition_mode, config->cache_partition.size,
	config->cache_partition.path, NULL, false)) {
	return false;
	}
	}

	return true;
	}