You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
520 lines
13 KiB
520 lines
13 KiB
/*
|
|
* Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <inttypes.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
#include "fmap.h"
|
|
#include "futility.h"
|
|
|
|
enum { FMT_NORMAL, FMT_PRETTY, FMT_FLASHROM, FMT_HUMAN };
|
|
|
|
/* global variables */
|
|
static int opt_extract;
|
|
static int opt_format = FMT_NORMAL;
|
|
static int opt_overlap;
|
|
static char *progname;
|
|
static void *base_of_rom;
|
|
static size_t size_of_rom;
|
|
static int opt_gaps;
|
|
|
|
/* Return 0 if successful */
|
|
static int dump_fmap(const FmapHeader *fmh, int argc, char *argv[])
|
|
{
|
|
int i, retval = 0;
|
|
char buf[80]; /* DWR: magic number */
|
|
const FmapAreaHeader *ah;
|
|
ah = (const FmapAreaHeader *) (fmh + 1);
|
|
char *extract_names[argc];
|
|
char *outname = 0;
|
|
|
|
if (opt_extract) {
|
|
/* prepare the filenames to write areas to */
|
|
memset(extract_names, 0, sizeof(extract_names));
|
|
for (i = 0; i < argc; i++) {
|
|
char *a = argv[i];
|
|
char *f = strchr(a, ':');
|
|
if (!f)
|
|
continue;
|
|
if (a == f || *(f+1) == '\0') {
|
|
fprintf(stderr,
|
|
"argument \"%s\" is bogus\n", a);
|
|
retval = 1;
|
|
continue;
|
|
}
|
|
*f++ = '\0';
|
|
extract_names[i] = f;
|
|
}
|
|
if (retval)
|
|
return retval;
|
|
}
|
|
|
|
if (FMT_NORMAL == opt_format) {
|
|
snprintf(buf, FMAP_SIGNATURE_SIZE + 1, "%s",
|
|
fmh->fmap_signature);
|
|
printf("fmap_signature %s\n", buf);
|
|
printf("fmap_version: %d.%d\n",
|
|
fmh->fmap_ver_major, fmh->fmap_ver_minor);
|
|
printf("fmap_base: 0x%" PRIx64 "\n", fmh->fmap_base);
|
|
printf("fmap_size: 0x%08x (%d)\n", fmh->fmap_size,
|
|
fmh->fmap_size);
|
|
snprintf(buf, FMAP_NAMELEN + 1, "%s", fmh->fmap_name);
|
|
printf("fmap_name: %s\n", buf);
|
|
printf("fmap_nareas: %d\n", fmh->fmap_nareas);
|
|
}
|
|
|
|
for (i = 0; i < fmh->fmap_nareas; i++, ah++) {
|
|
snprintf(buf, FMAP_NAMELEN + 1, "%s", ah->area_name);
|
|
|
|
if (argc) {
|
|
int j, found = 0;
|
|
outname = NULL;
|
|
for (j = 0; j < argc; j++)
|
|
if (!strcmp(argv[j], buf)) {
|
|
found = 1;
|
|
outname = extract_names[j];
|
|
break;
|
|
}
|
|
if (!found)
|
|
continue;
|
|
}
|
|
|
|
switch (opt_format) {
|
|
case FMT_PRETTY:
|
|
printf("%s %d %d\n", buf, ah->area_offset,
|
|
ah->area_size);
|
|
break;
|
|
case FMT_FLASHROM:
|
|
if (ah->area_size)
|
|
printf("0x%08x:0x%08x %s\n", ah->area_offset,
|
|
ah->area_offset + ah->area_size - 1,
|
|
buf);
|
|
break;
|
|
default:
|
|
printf("area: %d\n", i + 1);
|
|
printf("area_offset: 0x%08x\n", ah->area_offset);
|
|
printf("area_size: 0x%08x (%d)\n", ah->area_size,
|
|
ah->area_size);
|
|
printf("area_name: %s\n", buf);
|
|
}
|
|
|
|
if (opt_extract) {
|
|
char *s;
|
|
if (!outname) {
|
|
for (s = buf; *s; s++)
|
|
if (*s == ' ')
|
|
*s = '_';
|
|
outname = buf;
|
|
}
|
|
FILE *fp = fopen(outname, "wb");
|
|
if (!fp) {
|
|
fprintf(stderr, "%s: can't open %s: %s\n",
|
|
progname, outname, strerror(errno));
|
|
retval = 1;
|
|
} else if (!ah->area_size) {
|
|
fprintf(stderr,
|
|
"%s: section %s has zero size\n",
|
|
progname, buf);
|
|
} else if (ah->area_offset + ah->area_size >
|
|
size_of_rom) {
|
|
fprintf(stderr, "%s: section %s is larger"
|
|
" than the image\n", progname, buf);
|
|
retval = 1;
|
|
} else if (1 != fwrite(base_of_rom + ah->area_offset,
|
|
ah->area_size, 1, fp)) {
|
|
fprintf(stderr, "%s: can't write %s: %s\n",
|
|
progname, buf, strerror(errno));
|
|
retval = 1;
|
|
} else {
|
|
if (FMT_NORMAL == opt_format)
|
|
printf("saved as \"%s\"\n", outname);
|
|
}
|
|
fclose(fp);
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* Stuff for human-readable form */
|
|
|
|
struct dup_s {
|
|
char *name;
|
|
struct dup_s *next;
|
|
};
|
|
|
|
struct node_s {
|
|
char *name;
|
|
uint32_t start;
|
|
uint32_t size;
|
|
uint32_t end;
|
|
struct node_s *parent;
|
|
int num_children;
|
|
struct node_s **child;
|
|
struct dup_s *alias;
|
|
};
|
|
|
|
static struct node_s *all_nodes;
|
|
|
|
static void sort_nodes(int num, struct node_s *ary[])
|
|
{
|
|
int i, j;
|
|
struct node_s *tmp;
|
|
|
|
/* bubble-sort is quick enough with only a few entries */
|
|
for (i = 0; i < num; i++) {
|
|
for (j = i + 1; j < num; j++) {
|
|
if (ary[j]->start > ary[i]->start) {
|
|
tmp = ary[i];
|
|
ary[i] = ary[j];
|
|
ary[j] = tmp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void line(int indent, char *name,
|
|
uint32_t start, uint32_t end, uint32_t size, char *append)
|
|
{
|
|
int i;
|
|
for (i = 0; i < indent; i++)
|
|
printf(" ");
|
|
printf("%-25s %08x %08x %08x%s\n", name, start, end, size,
|
|
append ? append : "");
|
|
}
|
|
|
|
static int gapcount;
|
|
static void empty(int indent, uint32_t start, uint32_t end, char *name)
|
|
{
|
|
char buf[80];
|
|
if (opt_gaps) {
|
|
sprintf(buf, " // gap in %s", name);
|
|
line(indent + 1, "", start, end, end - start, buf);
|
|
}
|
|
gapcount++;
|
|
}
|
|
|
|
static void show(struct node_s *p, int indent, int show_first)
|
|
{
|
|
int i;
|
|
struct dup_s *alias;
|
|
if (show_first) {
|
|
line(indent, p->name, p->start, p->end, p->size, 0);
|
|
for (alias = p->alias; alias; alias = alias->next)
|
|
line(indent, alias->name, p->start, p->end, p->size,
|
|
" // DUPLICATE");
|
|
}
|
|
sort_nodes(p->num_children, p->child);
|
|
for (i = 0; i < p->num_children; i++) {
|
|
if (i == 0 && p->end != p->child[i]->end)
|
|
empty(indent, p->child[i]->end, p->end, p->name);
|
|
show(p->child[i], indent + show_first, 1);
|
|
if (i < p->num_children - 1
|
|
&& p->child[i]->start != p->child[i + 1]->end)
|
|
empty(indent, p->child[i + 1]->end, p->child[i]->start,
|
|
p->name);
|
|
if (i == p->num_children - 1 && p->child[i]->start != p->start)
|
|
empty(indent, p->start, p->child[i]->start, p->name);
|
|
}
|
|
}
|
|
|
|
static int overlaps(int i, int j)
|
|
{
|
|
struct node_s *a = all_nodes + i;
|
|
struct node_s *b = all_nodes + j;
|
|
|
|
return ((a->start < b->start) && (b->start < a->end) &&
|
|
(b->start < a->end) && (a->end < b->end));
|
|
}
|
|
|
|
static int encloses(int i, int j)
|
|
{
|
|
struct node_s *a = all_nodes + i;
|
|
struct node_s *b = all_nodes + j;
|
|
|
|
return ((a->start <= b->start) && (a->end >= b->end));
|
|
}
|
|
|
|
static int duplicates(int i, int j)
|
|
{
|
|
struct node_s *a = all_nodes + i;
|
|
struct node_s *b = all_nodes + j;
|
|
|
|
return ((a->start == b->start) && (a->end == b->end));
|
|
}
|
|
|
|
static void add_dupe(int i, int j, int numnodes)
|
|
{
|
|
int k;
|
|
struct dup_s *alias;
|
|
|
|
alias = (struct dup_s *) malloc(sizeof(struct dup_s));
|
|
alias->name = all_nodes[j].name;
|
|
alias->next = all_nodes[i].alias;
|
|
all_nodes[i].alias = alias;
|
|
for (k = j; k < numnodes; k++)
|
|
all_nodes[k] = all_nodes[k + 1];
|
|
}
|
|
|
|
static void add_child(struct node_s *p, int n)
|
|
{
|
|
int i;
|
|
if (p->num_children && !p->child) {
|
|
p->child =
|
|
(struct node_s **)calloc(p->num_children,
|
|
sizeof(struct node_s *));
|
|
if (!p->child) {
|
|
perror("calloc failed");
|
|
exit(1);
|
|
}
|
|
}
|
|
for (i = 0; i < p->num_children; i++)
|
|
if (!p->child[i]) {
|
|
p->child[i] = all_nodes + n;
|
|
return;
|
|
}
|
|
}
|
|
|
|
static int human_fmap(const FmapHeader *fmh)
|
|
{
|
|
FmapAreaHeader *ah;
|
|
int i, j, errorcnt = 0;
|
|
int numnodes;
|
|
|
|
ah = (FmapAreaHeader *) (fmh + 1);
|
|
|
|
/* The challenge here is to generate a directed graph from the
|
|
* arbitrarily-ordered FMAP entries, and then to prune it until it's as
|
|
* simple (and deep) as possible. Overlapping regions are not allowed.
|
|
* Duplicate regions are okay, but may require special handling. */
|
|
|
|
/* Convert the FMAP info into our format. */
|
|
numnodes = fmh->fmap_nareas;
|
|
|
|
/* plus one for the all-enclosing "root" */
|
|
all_nodes = (struct node_s *) calloc(numnodes + 1,
|
|
sizeof(struct node_s));
|
|
if (!all_nodes) {
|
|
perror("calloc failed");
|
|
exit(1);
|
|
}
|
|
for (i = 0; i < numnodes; i++) {
|
|
char buf[FMAP_NAMELEN + 1];
|
|
strncpy(buf, ah[i].area_name, FMAP_NAMELEN);
|
|
buf[FMAP_NAMELEN] = '\0';
|
|
all_nodes[i].name = strdup(buf);
|
|
if (!all_nodes[i].name) {
|
|
perror("strdup failed");
|
|
exit(1);
|
|
}
|
|
all_nodes[i].start = ah[i].area_offset;
|
|
all_nodes[i].size = ah[i].area_size;
|
|
all_nodes[i].end = ah[i].area_offset + ah[i].area_size;
|
|
}
|
|
/* Now add the root node */
|
|
all_nodes[numnodes].name = strdup("-entire flash-");
|
|
all_nodes[numnodes].start = fmh->fmap_base;
|
|
all_nodes[numnodes].size = fmh->fmap_size;
|
|
all_nodes[numnodes].end = fmh->fmap_base + fmh->fmap_size;
|
|
|
|
/* First, coalesce any duplicates */
|
|
for (i = 0; i < numnodes; i++) {
|
|
for (j = i + 1; j < numnodes; j++) {
|
|
if (duplicates(i, j)) {
|
|
add_dupe(i, j, numnodes);
|
|
numnodes--;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Each node should have at most one parent, which is the smallest
|
|
* enclosing node. Duplicate nodes "enclose" each other, but if there's
|
|
* already a relationship in one direction, we won't create another.
|
|
*/
|
|
for (i = 0; i < numnodes; i++) {
|
|
/* Find the smallest parent, which might be the root node. */
|
|
int k = numnodes;
|
|
for (j = 0; j < numnodes; j++) { /* full O(N^2) comparison */
|
|
if (i == j)
|
|
continue;
|
|
if (overlaps(i, j)) {
|
|
printf("ERROR: %s and %s overlap\n",
|
|
all_nodes[i].name, all_nodes[j].name);
|
|
printf(" %s: 0x%x - 0x%x\n", all_nodes[i].name,
|
|
all_nodes[i].start, all_nodes[i].end);
|
|
printf(" %s: 0x%x - 0x%x\n", all_nodes[j].name,
|
|
all_nodes[j].start, all_nodes[j].end);
|
|
if (opt_overlap < 2) {
|
|
printf("Use more -h args to ignore"
|
|
" this error\n");
|
|
errorcnt++;
|
|
}
|
|
continue;
|
|
}
|
|
if (encloses(j, i)
|
|
&& all_nodes[j].size < all_nodes[k].size)
|
|
k = j;
|
|
}
|
|
all_nodes[i].parent = all_nodes + k;
|
|
}
|
|
if (errorcnt)
|
|
return 1;
|
|
|
|
/* Force those deadbeat parents to recognize their children */
|
|
for (i = 0; i < numnodes; i++) /* how many */
|
|
if (all_nodes[i].parent)
|
|
all_nodes[i].parent->num_children++;
|
|
for (i = 0; i < numnodes; i++) /* here they are */
|
|
if (all_nodes[i].parent)
|
|
add_child(all_nodes[i].parent, i);
|
|
|
|
/* Ready to go */
|
|
printf("# name start end size\n");
|
|
show(all_nodes + numnodes, 0, opt_gaps);
|
|
|
|
if (gapcount && !opt_gaps)
|
|
printf("\nWARNING: unused regions found. Use -H to see them\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* End of human-reable stuff */
|
|
/****************************************************************************/
|
|
|
|
static const char usage[] =
|
|
"\nUsage: " MYNAME " %s [OPTIONS] FLASHIMAGE [NAME...]\n\n"
|
|
"Display (and extract) the FMAP components from a BIOS image.\n"
|
|
"\n"
|
|
"Options:\n"
|
|
" -x Extract the named sections from the file\n"
|
|
" -h Use a human-readable format\n"
|
|
" -H With -h, display any gaps\n"
|
|
" -p Use a format easy to parse by scripts\n"
|
|
" -F Use the format expected by flashrom\n"
|
|
"\n"
|
|
"Specify one or more NAMEs to dump only those sections.\n"
|
|
"\n";
|
|
|
|
static void print_help(const char *name)
|
|
{
|
|
printf(usage, name);
|
|
}
|
|
|
|
static int do_dump_fmap(int argc, char *argv[])
|
|
{
|
|
int c;
|
|
int errorcnt = 0;
|
|
struct stat sb;
|
|
int fd;
|
|
const FmapHeader *fmap;
|
|
int retval = 1;
|
|
|
|
progname = argv[0];
|
|
|
|
opterr = 0; /* quiet, you */
|
|
while ((c = getopt(argc, argv, ":xpFhH")) != -1) {
|
|
switch (c) {
|
|
case 'x':
|
|
opt_extract = 1;
|
|
break;
|
|
case 'p':
|
|
opt_format = FMT_PRETTY;
|
|
break;
|
|
case 'F':
|
|
opt_format = FMT_FLASHROM;
|
|
break;
|
|
case 'H':
|
|
opt_gaps = 1;
|
|
/* fallthrough */
|
|
case 'h':
|
|
opt_format = FMT_HUMAN;
|
|
opt_overlap++;
|
|
break;
|
|
case '?':
|
|
fprintf(stderr, "%s: unrecognized switch: -%c\n",
|
|
progname, optopt);
|
|
errorcnt++;
|
|
break;
|
|
case ':':
|
|
fprintf(stderr, "%s: missing argument to -%c\n",
|
|
progname, optopt);
|
|
errorcnt++;
|
|
break;
|
|
default:
|
|
errorcnt++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (errorcnt || optind >= argc) {
|
|
print_help(progname);
|
|
return 1;
|
|
}
|
|
|
|
if (0 != stat(argv[optind], &sb)) {
|
|
fprintf(stderr, "%s: can't stat %s: %s\n",
|
|
progname, argv[optind], strerror(errno));
|
|
return 1;
|
|
}
|
|
|
|
fd = open(argv[optind], O_RDONLY);
|
|
if (fd < 0) {
|
|
fprintf(stderr, "%s: can't open %s: %s\n",
|
|
progname, argv[optind], strerror(errno));
|
|
return 1;
|
|
}
|
|
|
|
base_of_rom =
|
|
mmap(0, sb.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
|
|
if (base_of_rom == (char *)-1) {
|
|
fprintf(stderr, "%s: can't mmap %s: %s\n",
|
|
progname, argv[optind], strerror(errno));
|
|
close(fd);
|
|
return 1;
|
|
}
|
|
close(fd); /* done with this now */
|
|
size_of_rom = sb.st_size;
|
|
|
|
fmap = fmap_find(base_of_rom, size_of_rom);
|
|
if (fmap) {
|
|
switch (opt_format) {
|
|
case FMT_HUMAN:
|
|
retval = human_fmap(fmap);
|
|
break;
|
|
case FMT_NORMAL:
|
|
printf("hit at 0x%08x\n",
|
|
(uint32_t) ((char *)fmap - (char *)base_of_rom));
|
|
/* fallthrough */
|
|
default:
|
|
retval =
|
|
dump_fmap(fmap, argc - optind - 1,
|
|
argv + optind + 1);
|
|
}
|
|
}
|
|
|
|
if (0 != munmap(base_of_rom, sb.st_size)) {
|
|
fprintf(stderr, "%s: can't munmap %s: %s\n",
|
|
progname, argv[optind], strerror(errno));
|
|
return 1;
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
DECLARE_FUTIL_COMMAND(dump_fmap, do_dump_fmap,
|
|
VBOOT_VERSION_ALL,
|
|
"Display FMAP contents from a firmware image",
|
|
print_help);
|