/* libs/diskconfig/diskconfig.c
*
* Copyright 2008, 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.
*/
#define LOG_TAG "diskconfig"
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <linux/fs.h>
#include <cutils/config_utils.h>
#include <log/log.h>
#include <diskconfig/diskconfig.h>
static int
parse_len(const char *str, uint64_t *plen)
{
char tmp[64];
int len_str;
uint32_t multiple = 1;
strncpy(tmp, str, sizeof(tmp));
tmp[sizeof(tmp)-1] = '\0';
len_str = strlen(tmp);
if (!len_str) {
ALOGE("Invalid disk length specified.");
return 1;
}
switch(tmp[len_str - 1]) {
case 'M': case 'm':
/* megabyte */
multiple <<= 10;
case 'K': case 'k':
/* kilobytes */
multiple <<= 10;
tmp[len_str - 1] = '\0';
break;
default:
break;
}
*plen = strtoull(tmp, NULL, 0);
if (!*plen) {
ALOGE("Invalid length specified: %s", str);
return 1;
}
if (*plen == (uint64_t)-1) {
if (multiple > 1) {
ALOGE("Size modifier illegal when len is -1");
return 1;
}
} else {
/* convert len to kilobytes */
if (multiple > 1024)
multiple >>= 10;
*plen *= multiple;
if (*plen > 0xffffffffULL) {
ALOGE("Length specified is too large!: %"PRIu64" KB", *plen);
return 1;
}
}
return 0;
}
static int
load_partitions(cnode *root, struct disk_info *dinfo)
{
cnode *partnode;
dinfo->num_parts = 0;
for (partnode = root->first_child; partnode; partnode = partnode->next) {
struct part_info *pinfo = &dinfo->part_lst[dinfo->num_parts];
const char *tmp;
/* bleh, i will leak memory here, but i DONT CARE since
* the only right thing to do when this function fails
* is to quit */
pinfo->name = strdup(partnode->name);
if(config_bool(partnode, "active", 0))
pinfo->flags |= PART_ACTIVE_FLAG;
if (!(tmp = config_str(partnode, "type", NULL))) {
ALOGE("Partition type required: %s", pinfo->name);
return 1;
}
/* possible values are: linux, fat32 */
if (!strcmp(tmp, "linux")) {
pinfo->type = PC_PART_TYPE_LINUX;
} else if (!strcmp(tmp, "fat32")) {
pinfo->type = PC_PART_TYPE_FAT32;
} else {
ALOGE("Unsupported partition type found: %s", tmp);
return 1;
}
if ((tmp = config_str(partnode, "len", NULL)) != NULL) {
uint64_t len;
if (parse_len(tmp, &len))
return 1;
pinfo->len_kb = (uint32_t) len;
} else
pinfo->len_kb = 0;
++dinfo->num_parts;
}
return 0;
}
struct disk_info *
load_diskconfig(const char *fn, char *path_override)
{
struct disk_info *dinfo;
cnode *devroot;
cnode *partnode;
cnode *root = config_node("", "");
const char *tmp;
if (!(dinfo = malloc(sizeof(struct disk_info)))) {
ALOGE("Could not malloc disk_info");
return NULL;
}
memset(dinfo, 0, sizeof(struct disk_info));
if (!(dinfo->part_lst = malloc(MAX_NUM_PARTS * sizeof(struct part_info)))) {
ALOGE("Could not malloc part_lst");
goto fail;
}
memset(dinfo->part_lst, 0,
(MAX_NUM_PARTS * sizeof(struct part_info)));
config_load_file(root, fn);
if (root->first_child == NULL) {
ALOGE("Could not read config file %s", fn);
goto fail;
}
if (!(devroot = config_find(root, "device"))) {
ALOGE("Could not find device section in config file '%s'", fn);
goto fail;
}
if (!(tmp = config_str(devroot, "path", path_override))) {
ALOGE("device path is requried");
goto fail;
}
dinfo->device = strdup(tmp);
/* find the partition scheme */
if (!(tmp = config_str(devroot, "scheme", NULL))) {
ALOGE("partition scheme is required");
goto fail;
} else if (!strcmp(tmp, "mbr")) {
dinfo->scheme = PART_SCHEME_MBR;
} else if (!strcmp(tmp, "gpt")) {
ALOGE("'gpt' partition scheme not supported yet.");
goto fail;
} else {
ALOGE("Unknown partition scheme specified: %s", tmp);
goto fail;
}
/* grab the sector size (in bytes) */
tmp = config_str(devroot, "sector_size", "512");
dinfo->sect_size = strtol(tmp, NULL, 0);
if (!dinfo->sect_size) {
ALOGE("Invalid sector size: %s", tmp);
goto fail;
}
/* first lba where the partitions will start on disk */
if (!(tmp = config_str(devroot, "start_lba", NULL))) {
ALOGE("start_lba must be provided");
goto fail;
}
if (!(dinfo->skip_lba = strtol(tmp, NULL, 0))) {
ALOGE("Invalid starting LBA (or zero): %s", tmp);
goto fail;
}
/* Number of LBAs on disk */
if (!(tmp = config_str(devroot, "num_lba", NULL))) {
ALOGE("num_lba is required");
goto fail;
}
dinfo->num_lba = strtoul(tmp, NULL, 0);
if (!(partnode = config_find(devroot, "partitions"))) {
ALOGE("Device must specify partition list");
goto fail;
}
if (load_partitions(partnode, dinfo))
goto fail;
return dinfo;
fail:
if (dinfo->part_lst)
free(dinfo->part_lst);
if (dinfo->device)
free(dinfo->device);
free(dinfo);
return NULL;
}
static int
sync_ptable(int fd)
{
struct stat stat;
int rv;
sync();
if (fstat(fd, &stat)) {
ALOGE("Cannot stat, errno=%d.", errno);
return -1;
}
if (S_ISBLK(stat.st_mode) && ((rv = ioctl(fd, BLKRRPART, NULL)) < 0)) {
ALOGE("Could not re-read partition table. REBOOT!. (errno=%d)", errno);
return -1;
}
return 0;
}
/* This function verifies that the disk info provided is valid, and if so,
* returns an open file descriptor.
*
* This does not necessarily mean that it will later be successfully written
* though. If we use the pc-bios partitioning scheme, we must use extended
* partitions, which eat up some hd space. If the user manually provisioned
* every single partition, but did not account for the extra needed space,
* then we will later fail.
*
* TODO: Make validation more complete.
*/
static int
validate(struct disk_info *dinfo)
{
int fd;
int sect_sz;
uint64_t disk_size;
uint64_t total_size;
int cnt;
struct stat stat;
if (!dinfo)
return -1;
if ((fd = open(dinfo->device, O_RDWR)) < 0) {
ALOGE("Cannot open device '%s' (errno=%d)", dinfo->device, errno);
return -1;
}
if (fstat(fd, &stat)) {
ALOGE("Cannot stat file '%s', errno=%d.", dinfo->device, errno);
goto fail;
}
/* XXX: Some of the code below is kind of redundant and should probably
* be refactored a little, but it will do for now. */
/* Verify that we can operate on the device that was requested.
* We presently only support block devices and regular file images. */
if (S_ISBLK(stat.st_mode)) {
/* get the sector size and make sure we agree */
if (ioctl(fd, BLKSSZGET, §_sz) < 0) {
ALOGE("Cannot get sector size (errno=%d)", errno);
goto fail;
}
if (!sect_sz || sect_sz != dinfo->sect_size) {
ALOGE("Device sector size is zero or sector sizes do not match!");
goto fail;
}
/* allow the user override the "disk size" if they provided num_lba */
if (!dinfo->num_lba) {
if (ioctl(fd, BLKGETSIZE64, &disk_size) < 0) {
ALOGE("Could not get block device size (errno=%d)", errno);
goto fail;
}
/* XXX: we assume that the disk has < 2^32 sectors :-) */
dinfo->num_lba = (uint32_t)(disk_size / (uint64_t)dinfo->sect_size);
} else
disk_size = (uint64_t)dinfo->num_lba * (uint64_t)dinfo->sect_size;
} else if (S_ISREG(stat.st_mode)) {
ALOGI("Requesting operation on a regular file, not block device.");
if (!dinfo->sect_size) {
ALOGE("Sector size for regular file images cannot be zero");
goto fail;
}
if (dinfo->num_lba)
disk_size = (uint64_t)dinfo->num_lba * (uint64_t)dinfo->sect_size;
else {
dinfo->num_lba = (uint32_t)(stat.st_size / dinfo->sect_size);
disk_size = (uint64_t)stat.st_size;
}
} else {
ALOGE("Device does not refer to a regular file or a block device!");
goto fail;
}
#if 1
ALOGV("Device/file %s: size=%" PRIu64 " bytes, num_lba=%u, sect_size=%d",
dinfo->device, disk_size, dinfo->num_lba, dinfo->sect_size);
#endif
/* since this is our offset into the disk, we start off with that as
* our size of needed partitions */
total_size = dinfo->skip_lba * dinfo->sect_size;
/* add up all the partition sizes and make sure it fits */
for (cnt = 0; cnt < dinfo->num_parts; ++cnt) {
struct part_info *part = &dinfo->part_lst[cnt];
if (part->len_kb != (uint32_t)-1) {
total_size += part->len_kb * 1024;
} else if (part->len_kb == 0) {
ALOGE("Zero-size partition '%s' is invalid.", part->name);
goto fail;
} else {
/* the partition requests the rest of the disk. */
if (cnt + 1 != dinfo->num_parts) {
ALOGE("Only the last partition in the list can request to fill "
"the rest of disk.");
goto fail;
}
}
if ((part->type != PC_PART_TYPE_LINUX) &&
(part->type != PC_PART_TYPE_FAT32)) {
ALOGE("Unknown partition type (0x%x) encountered for partition "
"'%s'\n", part->type, part->name);
goto fail;
}
}
/* only matters for disks, not files */
if (S_ISBLK(stat.st_mode) && total_size > disk_size) {
ALOGE("Total requested size of partitions (%"PRIu64") is greater than disk "
"size (%"PRIu64").", total_size, disk_size);
goto fail;
}
return fd;
fail:
close(fd);
return -1;
}
static int
validate_and_config(struct disk_info *dinfo, int *fd, struct write_list **lst)
{
*lst = NULL;
*fd = -1;
if ((*fd = validate(dinfo)) < 0)
return 1;
switch (dinfo->scheme) {
case PART_SCHEME_MBR:
*lst = config_mbr(dinfo);
return *lst == NULL;
case PART_SCHEME_GPT:
/* not supported yet */
default:
ALOGE("Uknown partition scheme.");
break;
}
close(*fd);
*lst = NULL;
return 1;
}
/* validate and process the disk layout configuration.
* This will cause an update to the partitions' start lba.
*
* Basically, this does the same thing as apply_disk_config in test mode,
* except that wlist_commit is not called to print out the data to be
* written.
*/
int
process_disk_config(struct disk_info *dinfo)
{
struct write_list *lst;
int fd;
if (validate_and_config(dinfo, &fd, &lst) != 0)
return 1;
close(fd);
wlist_free(lst);
return 0;
}
int
apply_disk_config(struct disk_info *dinfo, int test)
{
int fd;
struct write_list *wr_lst = NULL;
int rv;
if (validate_and_config(dinfo, &fd, &wr_lst) != 0) {
ALOGE("Configuration is invalid.");
goto fail;
}
if ((rv = wlist_commit(fd, wr_lst, test)) >= 0)
rv = test ? 0 : sync_ptable(fd);
close(fd);
wlist_free(wr_lst);
return rv;
fail:
close(fd);
if (wr_lst)
wlist_free(wr_lst);
return 1;
}
int
dump_disk_config(struct disk_info *dinfo)
{
int cnt;
struct part_info *part;
printf("Device: %s\n", dinfo->device);
printf("Scheme: ");
switch (dinfo->scheme) {
case PART_SCHEME_MBR:
printf("MBR");
break;
case PART_SCHEME_GPT:
printf("GPT (unsupported)");
break;
default:
printf("Unknown");
break;
}
printf ("\n");
printf("Sector size: %d\n", dinfo->sect_size);
printf("Skip leading LBAs: %u\n", dinfo->skip_lba);
printf("Number of LBAs: %u\n", dinfo->num_lba);
printf("Partitions:\n");
for (cnt = 0; cnt < dinfo->num_parts; ++cnt) {
part = &dinfo->part_lst[cnt];
printf("\tname = %s\n", part->name);
printf("\t\tflags = %s\n",
part->flags & PART_ACTIVE_FLAG ? "Active" : "None");
printf("\t\ttype = %s\n",
part->type == PC_PART_TYPE_LINUX ? "Linux" : "Unknown");
if (part->len_kb == (uint32_t)-1)
printf("\t\tlen = rest of disk\n");
else
printf("\t\tlen = %uKB\n", part->len_kb);
}
printf("Total number of partitions: %d\n", cnt);
printf("\n");
return 0;
}
struct part_info *
find_part(struct disk_info *dinfo, const char *name)
{
struct part_info *pinfo;
int cnt;
for (cnt = 0; cnt < dinfo->num_parts; ++cnt) {
pinfo = &dinfo->part_lst[cnt];
if (!strcmp(pinfo->name, name))
return pinfo;
}
return NULL;
}
/* NOTE: If the returned ptr is non-NULL, it must be freed by the caller. */
char *
find_part_device(struct disk_info *dinfo, const char *name)
{
switch (dinfo->scheme) {
case PART_SCHEME_MBR:
return find_mbr_part(dinfo, name);
case PART_SCHEME_GPT:
ALOGE("GPT is presently not supported");
break;
default:
ALOGE("Unknown partition table scheme");
break;
}
return NULL;
}