370 lines
10 KiB
C
370 lines
10 KiB
C
/*
|
|
* 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 <errno.h>
|
|
#include <stdlib.h>
|
|
#include <sys/mount.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
#include "mtdutils/mtdutils.h"
|
|
#include "mtdutils/mounts.h"
|
|
#include "minzip/Zip.h"
|
|
#include "roots.h"
|
|
#include "common.h"
|
|
|
|
#include "extendedcommands.h"
|
|
|
|
/* 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 RootInfo g_roots[] = {
|
|
{ "BOOT:", g_mtd_device, NULL, "boot", NULL, g_raw },
|
|
{ "CACHE:", CACHE_DEVICE, NULL, "cache", "/cache", CACHE_FILESYSTEM },
|
|
{ "DATA:", DATA_DEVICE, NULL, "userdata", "/data", DATA_FILESYSTEM },
|
|
#ifdef HAS_DATADATA
|
|
{ "DATADATA:", DATADATA_DEVICE, NULL, "datadata", "/datadata", DATADATA_FILESYSTEM },
|
|
#endif
|
|
{ "MISC:", g_mtd_device, NULL, "misc", NULL, g_raw },
|
|
{ "PACKAGE:", NULL, NULL, NULL, NULL, g_package_file },
|
|
{ "RECOVERY:", g_mtd_device, NULL, "recovery", "/", g_raw },
|
|
{ "SDCARD:", SDCARD_DEVICE_PRIMARY, SDCARD_DEVICE_SECONDARY, NULL, "/sdcard", "vfat" },
|
|
{ "SDEXT:", SDEXT_DEVICE, NULL, NULL, "/sd-ext", SDEXT_FILESYSTEM },
|
|
{ "SYSTEM:", g_mtd_device, NULL, "system", "/system", "yaffs2" },
|
|
{ "MBM:", g_mtd_device, NULL, "mbm", NULL, g_raw },
|
|
{ "TMP:", NULL, NULL, NULL, "/tmp", NULL },
|
|
};
|
|
#define NUM_ROOTS (sizeof(g_roots) / sizeof(g_roots[0]))
|
|
|
|
// TODO: for SDCARD:, try /dev/block/mmcblk0 if mmcblk0p1 fails
|
|
|
|
const RootInfo *
|
|
get_root_info_for_path(const char *root_path)
|
|
{
|
|
const char *c;
|
|
|
|
/* Find the first colon.
|
|
*/
|
|
c = root_path;
|
|
while (*c != '\0' && *c != ':') {
|
|
c++;
|
|
}
|
|
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;
|
|
}
|
|
|
|
static const ZipArchive *g_package = NULL;
|
|
static char *g_package_path = NULL;
|
|
|
|
int
|
|
register_package_root(const ZipArchive *package, const char *package_path)
|
|
{
|
|
if (package != NULL) {
|
|
package_path = strdup(package_path);
|
|
if (package_path == NULL) {
|
|
return -1;
|
|
}
|
|
g_package_path = (char *)package_path;
|
|
} else {
|
|
free(g_package_path);
|
|
g_package_path = NULL;
|
|
}
|
|
g_package = package;
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
is_package_root_path(const char *root_path)
|
|
{
|
|
const RootInfo *info = get_root_info_for_path(root_path);
|
|
return info != NULL && info->filesystem == g_package_file;
|
|
}
|
|
|
|
const char *
|
|
translate_package_root_path(const char *root_path,
|
|
char *out_buf, size_t out_buf_len, const ZipArchive **out_package)
|
|
{
|
|
const RootInfo *info = get_root_info_for_path(root_path);
|
|
if (info == NULL || info->filesystem != g_package_file) {
|
|
return NULL;
|
|
}
|
|
|
|
/* Strip the package root off of the path.
|
|
*/
|
|
size_t root_len = strlen(info->name);
|
|
root_path += root_len;
|
|
size_t root_path_len = strlen(root_path);
|
|
|
|
if (out_buf_len < root_path_len + 1) {
|
|
return NULL;
|
|
}
|
|
strcpy(out_buf, root_path);
|
|
*out_package = g_package;
|
|
return out_buf;
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
|
|
const RootInfo *info = get_root_info_for_path(root_path);
|
|
if (info == NULL || info->mount_point == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/* 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++;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/* 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++] = '/';
|
|
|
|
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;
|
|
}
|
|
//xxx if TMP: (or similar) just say "yes"
|
|
|
|
/* 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;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int
|
|
is_root_path_mounted(const char *root_path)
|
|
{
|
|
const RootInfo *info = get_root_info_for_path(root_path);
|
|
if (info == NULL) {
|
|
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) {
|
|
return -1;
|
|
}
|
|
|
|
int ret = internal_root_mounted(info);
|
|
if (ret >= 0) {
|
|
/* It's 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
|
|
mtd_scan_partitions();
|
|
const MtdPartition *partition;
|
|
partition = mtd_find_partition_by_name(info->partition_name);
|
|
if (partition == NULL) {
|
|
return -1;
|
|
}
|
|
return mtd_mount_partition(partition, info->mount_point,
|
|
info->filesystem, 0);
|
|
}
|
|
|
|
if (info->device == NULL || info->mount_point == NULL ||
|
|
info->filesystem == NULL ||
|
|
info->filesystem == g_raw ||
|
|
info->filesystem == g_package_file) {
|
|
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;
|
|
}
|
|
|
|
int
|
|
ensure_root_path_unmounted(const char *root_path)
|
|
{
|
|
const RootInfo *info = get_root_info_for_path(root_path);
|
|
if (info == NULL) {
|
|
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;
|
|
}
|
|
const MountedVolume *volume;
|
|
volume = find_mounted_volume_by_mount_point(info->mount_point);
|
|
if (volume == NULL) {
|
|
/* It's not mounted.
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
return unmount_mounted_volume(volume);
|
|
}
|
|
|
|
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++;
|
|
}
|
|
/*
|
|
if (c[0] != ':' || c[1] != '\0') {
|
|
LOGW("format_root_device: bad root name \"%s\"\n", root);
|
|
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);
|
|
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) {
|
|
mtd_scan_partitions();
|
|
const MtdPartition *partition;
|
|
partition = mtd_find_partition_by_name(info->partition_name);
|
|
if (partition == NULL) {
|
|
LOGW("format_root_device: can't find mtd partition \"%s\"\n",
|
|
info->partition_name);
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
return format_non_mtd_device(root);
|
|
}
|