tequilaOS/platform_system_core
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "Remove libdiskconfig as it is no longer used"

Browse source
This commit is contained in:
Treehugger Robot 2023-05-23 16:33:31 +00:00 committed by Gerrit Code Review
commit 280fd9f011
7 changed files with 0 additions and 1305 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
libdiskconfig/Android.bp
View file

@ -1,36 +0,0 @@
package {
default_applicable_licenses: ["Android-Apache-2.0"],
}
cc_library {
name: "libdiskconfig",
vendor_available: true,
vndk: {
enabled: true,
},
srcs: [
"diskconfig.c",
"diskutils.c",
"write_lst.c",
"config_mbr.c",
],
shared_libs: [
"libcutils",
"liblog",
],
cflags: ["-Werror"],
export_include_dirs: ["include"],
local_include_dirs: ["include"],
target: {
darwin: {
enabled: false,
},
host_linux: {
cflags: [
"-D_LARGEFILE64_SOURCE",
],
},
},
}

351
libdiskconfig/config_mbr.c
View file

@ -1,351 +0,0 @@
/* 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 "config_mbr"
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <diskconfig/diskconfig.h>
#include <log/log.h>
/* start and len are in LBA units */
static void
cfg_pentry(struct pc_partition *pentry, uint8_t status, uint8_t type,
uint32_t start, uint32_t len)
{
if (len > 0) {
/* seems that somes BIOSens can get wedged on boot while verifying
* the mbr if these are 0 */
memset(&pentry->start, 0xff, sizeof(struct chs));
memset(&pentry->end, 0xff, sizeof(struct chs));
} else {
/* zero out the c/h/s entries.. they are not used */
memset(&pentry->start, 0, sizeof(struct chs));
memset(&pentry->end, 0, sizeof(struct chs));
}
pentry->status = status;
pentry->type = type;
pentry->start_lba = start;
pentry->len_lba = len;
ALOGI("Configuring pentry. status=0x%x type=0x%x start_lba=%u len_lba=%u",
pentry->status, pentry->type, pentry->start_lba, pentry->len_lba);
}
static inline uint32_t
kb_to_lba(uint32_t len_kb, uint32_t sect_size)
{
uint64_t lba;
lba = (uint64_t)len_kb * 1024;
/* bump it up to the next LBA boundary just in case */
lba = (lba + (uint64_t)sect_size - 1) & ~((uint64_t)sect_size - 1);
lba /= (uint64_t)sect_size;
if (lba >= 0xffffffffULL)
ALOGE("Error converting kb -> lba. 32bit overflow, expect weirdness");
return (uint32_t)(lba & 0xffffffffULL);
}
static struct write_list *
mk_pri_pentry(struct disk_info *dinfo, struct part_info *pinfo, int pnum,
uint32_t *lba)
{
struct write_list *item;
struct pc_partition *pentry;
if (pnum >= PC_NUM_BOOT_RECORD_PARTS) {
ALOGE("Maximum number of primary partition exceeded.");
return NULL;
}
if (!(item = alloc_wl(sizeof(struct pc_partition)))) {
ALOGE("Unable to allocate memory for partition entry.");
return NULL;
}
{
/* DO NOT DEREFERENCE */
struct pc_boot_record *mbr = (void *)PC_MBR_DISK_OFFSET;
/* grab the offset in mbr where to write this partition entry. */
item->offset = (loff_t)((uintptr_t)((uint8_t *)(&mbr->ptable[pnum])));
}
pentry = (struct pc_partition *) &item->data;
/* need a standard primary partition entry */
if (pinfo) {
/* need this to be 64 bit in case len_kb is large */
uint64_t len_lba;
if (pinfo->len_kb != (uint32_t)-1) {
/* bump it up to the next LBA boundary just in case */
len_lba = ((uint64_t)pinfo->len_kb * 1024);
len_lba += ((uint64_t)dinfo->sect_size - 1);
len_lba &= ~((uint64_t)dinfo->sect_size - 1);
len_lba /= (uint64_t)dinfo->sect_size;
} else {
/* make it fill the rest of disk */
len_lba = dinfo->num_lba - *lba;
}
cfg_pentry(pentry, ((pinfo->flags & PART_ACTIVE_FLAG) ?
PC_PART_ACTIVE : PC_PART_NORMAL),
pinfo->type, *lba, (uint32_t)len_lba);
pinfo->start_lba = *lba;
*lba += (uint32_t)len_lba;
} else {
/* this should be made an extended partition, and should take
* up the rest of the disk as a primary partition */
cfg_pentry(pentry, PC_PART_NORMAL, PC_PART_TYPE_EXTENDED,
*lba, dinfo->num_lba - *lba);
/* note that we do not update the *lba because we now have to
* create a chain of extended partition tables, and first one is at
* *lba */
}
return item;
}
/* This function configures an extended boot record at the beginning of an
* extended partition. This creates a logical partition and a pointer to
* the next EBR.
*
* ext_lba == The start of the toplevel extended partition (pointed to by the
* entry in the MBR).
*/
static struct write_list *
mk_ext_pentry(struct disk_info *dinfo, struct part_info *pinfo, uint32_t *lba,
uint32_t ext_lba, struct part_info *pnext)
{
struct write_list *item;
struct pc_boot_record *ebr;
uint32_t len; /* in lba units */
if (!(item = alloc_wl(sizeof(struct pc_boot_record)))) {
ALOGE("Unable to allocate memory for EBR.");
return NULL;
}
/* we are going to write the ebr at the current LBA, and then bump the
* lba counter since that is where the logical data partition will start */
item->offset = ((loff_t)(*lba)) * dinfo->sect_size;
(*lba)++;
ebr = (struct pc_boot_record *) &item->data;
memset(ebr, 0, sizeof(struct pc_boot_record));
ebr->mbr_sig = PC_BIOS_BOOT_SIG;
if (pinfo->len_kb != (uint32_t)-1)
len = kb_to_lba(pinfo->len_kb, dinfo->sect_size);
else {
if (pnext) {
ALOGE("Only the last partition can be specified to fill the disk "
"(name = '%s')", pinfo->name);
goto fail;
}
len = dinfo->num_lba - *lba;
/* update the pinfo structure to reflect the new size, for
* bookkeeping */
pinfo->len_kb =
(uint32_t)(((uint64_t)len * (uint64_t)dinfo->sect_size) /
((uint64_t)1024));
}
cfg_pentry(&ebr->ptable[PC_EBR_LOGICAL_PART], PC_PART_NORMAL,
pinfo->type, 1, len);
pinfo->start_lba = *lba;
*lba += len;
/* If this is not the last partition, we have to create a link to the
* next extended partition.
*
* Otherwise, there's nothing to do since the "pointer entry" is
* already zero-filled.
*/
if (pnext) {
/* The start lba for next partition is an offset from the beginning
* of the top-level extended partition */
uint32_t next_start_lba = *lba - ext_lba;
uint32_t next_len_lba;
if (pnext->len_kb != (uint32_t)-1)
next_len_lba = 1 + kb_to_lba(pnext->len_kb, dinfo->sect_size);
else
next_len_lba = dinfo->num_lba - *lba;
cfg_pentry(&ebr->ptable[PC_EBR_NEXT_PTR_PART], PC_PART_NORMAL,
PC_PART_TYPE_EXTENDED, next_start_lba, next_len_lba);
}
return item;
fail:
free_wl(item);
return NULL;
}
static struct write_list *
mk_mbr_sig()
{
struct write_list *item;
if (!(item = alloc_wl(sizeof(uint16_t)))) {
ALOGE("Unable to allocate memory for MBR signature.");
return NULL;
}
{
/* DO NOT DEREFERENCE */
struct pc_boot_record *mbr = (void *)PC_MBR_DISK_OFFSET;
/* grab the offset in mbr where to write mbr signature. */
item->offset = (loff_t)((uintptr_t)((uint8_t *)(&mbr->mbr_sig)));
}
*((uint16_t*)item->data) = PC_BIOS_BOOT_SIG;
return item;
}
struct write_list *
config_mbr(struct disk_info *dinfo)
{
struct part_info *pinfo;
uint32_t cur_lba = dinfo->skip_lba;
uint32_t ext_lba = 0;
struct write_list *wr_list = NULL;
struct write_list *temp_wr = NULL;
int cnt = 0;
int extended = 0;
if (!dinfo->part_lst)
return NULL;
for (cnt = 0; cnt < dinfo->num_parts; ++cnt) {
pinfo = &dinfo->part_lst[cnt];
/* Should we create an extedned partition? */
if (cnt == (PC_NUM_BOOT_RECORD_PARTS - 1)) {
if (cnt + 1 < dinfo->num_parts) {
extended = 1;
ext_lba = cur_lba;
if ((temp_wr = mk_pri_pentry(dinfo, NULL, cnt, &cur_lba)))
wlist_add(&wr_list, temp_wr);
else {
ALOGE("Cannot create primary extended partition.");
goto fail;
}
}
}
/* if extended, need 1 lba for ebr */
if ((cur_lba + extended) >= dinfo->num_lba)
goto nospace;
else if (pinfo->len_kb != (uint32_t)-1) {
uint32_t sz_lba = (pinfo->len_kb / dinfo->sect_size) * 1024;
if ((cur_lba + sz_lba + extended) > dinfo->num_lba)
goto nospace;
}
if (!extended)
temp_wr = mk_pri_pentry(dinfo, pinfo, cnt, &cur_lba);
else {
struct part_info *pnext;
pnext = cnt + 1 < dinfo->num_parts ? &dinfo->part_lst[cnt+1] : NULL;
temp_wr = mk_ext_pentry(dinfo, pinfo, &cur_lba, ext_lba, pnext);
}
if (temp_wr)
wlist_add(&wr_list, temp_wr);
else {
ALOGE("Cannot create partition %d (%s).", cnt, pinfo->name);
goto fail;
}
}
/* fill in the rest of the MBR with empty parts (if needed). */
for (; cnt < PC_NUM_BOOT_RECORD_PARTS; ++cnt) {
struct part_info blank;
cur_lba = 0;
memset(&blank, 0, sizeof(struct part_info));
if (!(temp_wr = mk_pri_pentry(dinfo, &blank, cnt, &cur_lba))) {
ALOGE("Cannot create blank partition %d.", cnt);
goto fail;
}
wlist_add(&wr_list, temp_wr);
}
if ((temp_wr = mk_mbr_sig()))
wlist_add(&wr_list, temp_wr);
else {
ALOGE("Cannot set MBR signature");
goto fail;
}
return wr_list;
nospace:
ALOGE("Not enough space to add parttion '%s'.", pinfo->name);
fail:
wlist_free(wr_list);
return NULL;
}
/* Returns the device path of the partition referred to by 'name'
* Must be freed by the caller.
*/
char *
find_mbr_part(struct disk_info *dinfo, const char *name)
{
struct part_info *plist = dinfo->part_lst;
int num = 0;
char *dev_name = NULL;
int has_extended = (dinfo->num_parts > PC_NUM_BOOT_RECORD_PARTS);
for(num = 1; num <= dinfo->num_parts; ++num) {
if (!strcmp(plist[num-1].name, name))
break;
}
if (num > dinfo->num_parts)
return NULL;
if (has_extended && (num >= PC_NUM_BOOT_RECORD_PARTS))
num++;
if (!(dev_name = malloc(MAX_NAME_LEN))) {
ALOGE("Cannot allocate memory.");
return NULL;
}
num = snprintf(dev_name, MAX_NAME_LEN, "%s%d", dinfo->device, num);
if (num >= MAX_NAME_LEN) {
ALOGE("Device name is too long?!");
free(dev_name);
return NULL;
}
return dev_name;
}

535
libdiskconfig/diskconfig.c
View file

@ -1,535 +0,0 @@
/* 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 <linux/fs.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <unistd.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, &sect_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("Unknown 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;
}

118
libdiskconfig/diskutils.c
View file

@ -1,118 +0,0 @@
/* libs/diskconfig/diskutils.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 "diskutils"
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <log/log.h>
#include <diskconfig/diskconfig.h>
int
write_raw_image(const char *dst, const char *src, loff_t offset, int test)
{
int dst_fd = -1;
int src_fd = -1;
uint8_t buffer[2048];
ssize_t nr_bytes;
ssize_t tmp;
int done = 0;
uint64_t total = 0;
ALOGI("Writing RAW image '%s' to '%s' (offset=%llu)", src, dst, (unsigned long long)offset);
if ((src_fd = open(src, O_RDONLY)) < 0) {
ALOGE("Could not open %s for reading (errno=%d).", src, errno);
goto fail;
}
if (!test) {
if ((dst_fd = open(dst, O_RDWR)) < 0) {
ALOGE("Could not open '%s' for read/write (errno=%d).", dst, errno);
goto fail;
}
if (lseek64(dst_fd, offset, SEEK_SET) != offset) {
ALOGE("Could not seek to offset %lld in %s.", (long long)offset, dst);
goto fail;
}
}
while (!done) {
if ((nr_bytes = read(src_fd, buffer, sizeof(buffer))) < 0) {
/* XXX: Should we not even bother with EINTR? */
if (errno == EINTR)
continue;
ALOGE("Error (%d) while reading from '%s'", errno, src);
goto fail;
}
if (!nr_bytes) {
/* we're done. */
done = 1;
break;
}
total += nr_bytes;
/* skip the write loop if we're testing */
if (test)
nr_bytes = 0;
while (nr_bytes > 0) {
if ((tmp = write(dst_fd, buffer, nr_bytes)) < 0) {
/* XXX: Should we not even bother with EINTR? */
if (errno == EINTR)
continue;
ALOGE("Error (%d) while writing to '%s'", errno, dst);
goto fail;
}
if (!tmp)
continue;
nr_bytes -= tmp;
}
}
if (!done) {
ALOGE("Exited read/write loop without setting flag! WTF?!");
goto fail;
}
if (dst_fd >= 0)
fsync(dst_fd);
ALOGI("Wrote %" PRIu64 " bytes to %s @ %lld", total, dst, (long long)offset);
close(src_fd);
if (dst_fd >= 0)
close(dst_fd);
return 0;
fail:
if (dst_fd >= 0)
close(dst_fd);
if (src_fd >= 0)
close(src_fd);
return 1;
}

43
libdiskconfig/dump_diskconfig.c
View file

@ -1,43 +0,0 @@
/* libs/diskconfig/dump_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 "dump_diskconfig"
#include <stdio.h>
#include <log/log.h>
#include "diskconfig.h"
int
main(int argc, char *argv[])
{
struct disk_info *dinfo;
if (argc < 2) {
ALOGE("usage: %s <conf file>", argv[0]);
return 1;
}
if (!(dinfo = load_diskconfig(argv[1], NULL)))
return 1;
dump_disk_config(dinfo);
return 0;
}

130
libdiskconfig/include/diskconfig/diskconfig.h
View file

@ -1,130 +0,0 @@
/* system/core/include/diskconfig/diskconfig.h
*
* 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.
*/
#ifndef __LIBS_DISKCONFIG_H
#define __LIBS_DISKCONFIG_H
#include <stdint.h>
#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
#define MAX_NAME_LEN 512
#define MAX_NUM_PARTS 16
/* known partition schemes */
#define PART_SCHEME_MBR 0x1
#define PART_SCHEME_GPT 0x2
/* PC Bios partition status */
#define PC_PART_ACTIVE 0x80
#define PC_PART_NORMAL 0x0
/* Known (rather, used by us) partition types */
#define PC_PART_TYPE_LINUX 0x83
#define PC_PART_TYPE_EXTENDED 0x05
#define PC_PART_TYPE_FAT32 0x0c
#define PC_NUM_BOOT_RECORD_PARTS 4
#define PC_EBR_LOGICAL_PART 0
#define PC_EBR_NEXT_PTR_PART 1
#define PC_BIOS_BOOT_SIG 0xAA55
#define PC_MBR_DISK_OFFSET 0
#define PC_MBR_SIZE 512
#define PART_ACTIVE_FLAG 0x1
struct chs {
uint8_t head;
uint8_t sector;
uint8_t cylinder;
} __attribute__((__packed__));
/* 16 byte pc partition descriptor that sits in MBR and EPBR.
* Note: multi-byte entities have little-endian layout on disk */
struct pc_partition {
uint8_t status; /* byte 0 */
struct chs start; /* bytes 1-3 */
uint8_t type; /* byte 4 */
struct chs end; /* bytes 5-7 */
uint32_t start_lba; /* bytes 8-11 */
uint32_t len_lba; /* bytes 12-15 */
} __attribute__((__packed__));
struct pc_boot_record {
uint8_t code[440]; /* bytes 0-439 */
uint32_t disk_sig; /* bytes 440-443 */
uint16_t pad; /* bytes 444-445 */
struct pc_partition ptable[PC_NUM_BOOT_RECORD_PARTS]; /* bytes 446-509 */
uint16_t mbr_sig; /* bytes 510-511 */
} __attribute__((__packed__));
struct part_info {
char *name;
uint8_t flags;
uint8_t type;
uint32_t len_kb; /* in 1K-bytes */
uint32_t start_lba; /* the LBA where this partition begins */
};
struct disk_info {
char *device;
uint8_t scheme;
int sect_size; /* expected sector size in bytes. MUST BE POWER OF 2 */
uint32_t skip_lba; /* in sectors (1 unit of LBA) */
uint32_t num_lba; /* the size of the disk in LBA units */
struct part_info *part_lst;
int num_parts;
};
struct write_list {
struct write_list *next;
loff_t offset;
uint32_t len;
uint8_t data[0];
};
struct write_list *alloc_wl(uint32_t data_len);
void free_wl(struct write_list *item);
struct write_list *wlist_add(struct write_list **lst, struct write_list *item);
void wlist_free(struct write_list *lst);
int wlist_commit(int fd, struct write_list *lst, int test);
struct disk_info *load_diskconfig(const char *fn, char *path_override);
int dump_disk_config(struct disk_info *dinfo);
int apply_disk_config(struct disk_info *dinfo, int test);
char *find_part_device(struct disk_info *dinfo, const char *name);
int process_disk_config(struct disk_info *dinfo);
struct part_info *find_part(struct disk_info *dinfo, const char *name);
int write_raw_image(const char *dst, const char *src, loff_t offset, int test);
/* For MBR partition schemes */
struct write_list *config_mbr(struct disk_info *dinfo);
char *find_mbr_part(struct disk_info *dinfo, const char *name);
#ifdef __cplusplus
}
#endif
#endif /* __LIBS_DISKCONFIG_H */

92
libdiskconfig/write_lst.c
View file

@ -1,92 +0,0 @@
/* libs/diskconfig/write_lst.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 "write_lst"
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <diskconfig/diskconfig.h>
#include <log/log.h>
struct write_list *
alloc_wl(uint32_t data_len)
{
struct write_list *item;
if (!(item = malloc(sizeof(struct write_list) + data_len))) {
ALOGE("Unable to allocate memory.");
return NULL;
}
item->len = data_len;
return item;
}
void
free_wl(struct write_list *item)
{
if (item)
free(item);
}
struct write_list *
wlist_add(struct write_list **lst, struct write_list *item)
{
item->next = (*lst);
*lst = item;
return item;
}
void
wlist_free(struct write_list *lst)
{
struct write_list *temp_wr;
while (lst) {
temp_wr = lst->next;
free_wl(lst);
lst = temp_wr;
}
}
int
wlist_commit(int fd, struct write_list *lst, int test)
{
for(; lst; lst = lst->next) {
if (lseek64(fd, lst->offset, SEEK_SET) != (loff_t)lst->offset) {
ALOGE("Cannot seek to the specified position (%lld).", (long long)lst->offset);
goto fail;
}
if (!test) {
if (write(fd, lst->data, lst->len) != (int)lst->len) {
ALOGE("Failed writing %u bytes at position %lld.", lst->len,
(long long)lst->offset);
goto fail;
}
} else
ALOGI("Would write %d bytes @ offset %lld.", lst->len, (long long)lst->offset);
}
return 0;
fail:
return -1;
}