coreboot-kgpe-d16/util/cbfstool/fmaptool.c

297 lines
8.1 KiB
C

/* fmaptool, CLI utility for converting plaintext fmd files into fmap blobs */
/* SPDX-License-Identifier: GPL-2.0-only */
#include "common.h"
#include "cbfs_sections.h"
#include "fmap_from_fmd.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#define STDIN_FILENAME_SENTINEL "-"
#define HEADER_FMAP_OFFSET "FMAP_OFFSET"
#define HEADER_FMAP_SIZE "FMAP_SIZE"
/*
* Macro name used in the generated C header file to provide list of section names that do not
* have any sub-sections.
*/
#define HEADER_FMAP_TERMINAL_SECTIONS "FMAP_TERMINAL_SECTIONS"
enum fmaptool_return {
FMAPTOOL_EXIT_SUCCESS = 0,
FMAPTOOL_EXIT_BAD_ARGS,
FMAPTOOL_EXIT_BAD_INPUT_PATH,
FMAPTOOL_EXIT_BAD_OUTPUT_PATH,
FMAPTOOL_EXIT_FAILED_DESCRIPTOR,
FMAPTOOL_EXIT_MISSING_FMAP_SECTION,
FMAPTOOL_EXIT_MISSING_PRIMARY_CBFS,
FMAPTOOL_EXIT_FAILED_FMAP_CONVERSION,
FMAPTOOL_EXIT_UNKNOWN_FMAP_SIZE,
FMAPTOOL_EXIT_FAILED_WRITING_OUTPUT,
FMAPTOOL_EXIT_FAILED_WRITING_HEADER,
};
static void usage(const char *invoked_as)
{
fputs("fmaptool: Compiler for fmd (flashmap descriptor) files\n",
stderr);
fputs("\nUSAGE:\n", stderr);
fprintf(stderr,
"\t%s [-h <header output file>] [-R <region output file>] <fmd input file> <binary output file>\n",
invoked_as);
fputs("\nMANDATORY ARGUMENTS:\n", stderr);
fprintf(stderr,
"<fmd input file> may be '%s' to read from standard input\n",
STDIN_FILENAME_SENTINEL);
fputs("<binary output file> must be a regular file\n", stderr);
fputs("\nOPTIONAL SWITCHES:\n", stderr);
fprintf(stderr,
"-h\tAlso produce a C header defining %s to the FMAP section's flash offset.\n",
HEADER_FMAP_OFFSET);
fprintf(stderr,
"-R\tAlso produce a text file listing the CBFS regions, comma separated.\n");
fputs("\nOUTPUT:\n", stderr);
fputs("A successful invocation prints a summary of work done to standard error, and a comma-separated list\n",
stderr);
fputs("of those sections that contain CBFSes, starting with the primary such section, to standard output.\n",
stderr);
}
static void list_cbfs_section_names(FILE *out)
{
cbfs_section_iterator_t cbfs_it = cbfs_sections_iterator();
assert(cbfs_it);
bool subsequent = false;
while (cbfs_it) {
const char *cur_name =
cbfs_sections_iterator_deref(cbfs_it)->name;
if (cbfs_sections_iterator_advance(&cbfs_it) && subsequent)
fputc(',', out);
fputs(cur_name, out);
subsequent = true;
}
fputc('\n', out);
}
static void write_header_fmap_terminal_section_names(FILE *header,
const struct flashmap_descriptor *root)
{
assert(root);
if (root->list_len == 0) {
fprintf(header, "%s ", root->name);
return;
}
fmd_foreach_child(child, root)
write_header_fmap_terminal_section_names(header, child);
}
static void write_header_fmap_sections(FILE *header, const struct flashmap_descriptor *root,
unsigned int offset)
{
assert(root);
/*
* The offset may only be unknown for the root node in a system where the flash isn't
* memory-mapped.
*/
if (!root->offset_known && offset != 0)
return;
const unsigned int current_offset = offset + (root->offset_known ? root->offset : 0);
fprintf(header, "#define FMAP_SECTION_%s_START %#x\n", root->name, current_offset);
if (!root->size_known)
return;
fprintf(header, "#define FMAP_SECTION_%s_SIZE %#x\n", root->name, root->size);
fmd_foreach_child(child, root)
write_header_fmap_sections(header, child, current_offset);
}
static bool write_header(const char *out_fname,
const struct flashmap_descriptor *root,
const int fmap_size)
{
assert(out_fname);
FILE *header = fopen(out_fname, "w");
if (!header) {
fprintf(stderr, "FATAL: Unable to open file '%s' for writing\n",
out_fname);
return false;
}
unsigned fmap_offset =
fmd_calc_absolute_offset(root, SECTION_NAME_FMAP);
assert(fmap_offset != FMD_NOTFOUND);
fputs("#ifndef FMAPTOOL_GENERATED_HEADER_H_\n", header);
fputs("#define FMAPTOOL_GENERATED_HEADER_H_\n\n", header);
fprintf(header, "#define %s %#x\n", HEADER_FMAP_OFFSET, fmap_offset);
fprintf(header, "#define %s %#x\n\n", HEADER_FMAP_SIZE, fmap_size);
fprintf(header, "#define %s \"", HEADER_FMAP_TERMINAL_SECTIONS);
write_header_fmap_terminal_section_names(header, root);
fprintf(header, "\"\n\n");
write_header_fmap_sections(header, root, 0);
fputs("\n", header);
fputs("#endif\n", header);
fclose(header);
return true;
}
static void full_fmd_cleanup(struct flashmap_descriptor **victim)
{
assert(victim);
cbfs_sections_cleanup();
fmd_cleanup(*victim);
*victim = NULL;
}
int main(int argc, char **argv)
{
struct {
// Mandatory
const char *fmd_filename;
const char *fmap_filename;
// Optional
const char *header_filename;
const char *region_filename;
} args = {NULL, NULL, NULL, NULL};
bool show_usage = false;
int each_arg;
while (!show_usage && (each_arg = getopt(argc, argv, ":h:R:")) != -1) {
switch (each_arg) {
case 'h':
args.header_filename = optarg;
break;
case 'R':
args.region_filename = optarg;
break;
case ':':
fprintf(stderr, "-%c: Expected an accompanying value\n",
optopt);
show_usage = true;
break;
default:
fprintf(stderr, "-%c: Unexpected command-line switch\n",
optopt);
show_usage = true;
}
}
if (show_usage || argc - optind != 2) {
usage(argv[0]);
return FMAPTOOL_EXIT_BAD_ARGS;
}
args.fmd_filename = argv[optind];
args.fmap_filename = argv[optind + 1];
FILE *fmd_file = stdin;
if (strcmp(args.fmd_filename, STDIN_FILENAME_SENTINEL) != 0) {
fmd_file = fopen(args.fmd_filename, "r");
if (!fmd_file) {
fprintf(stderr, "FATAL: Unable to open file '%s'\n",
args.fmd_filename);
return FMAPTOOL_EXIT_BAD_INPUT_PATH;
}
}
struct flashmap_descriptor *descriptor = fmd_create(fmd_file);
fclose(fmd_file);
if (!descriptor) {
fputs("FATAL: Failed while processing provided descriptor\n",
stderr);
full_fmd_cleanup(&descriptor);
return FMAPTOOL_EXIT_FAILED_DESCRIPTOR;
}
if (!fmd_find_node(descriptor, SECTION_NAME_FMAP)) {
fprintf(stderr,
"FATAL: Flashmap descriptor must have an '%s' section\n",
SECTION_NAME_FMAP);
full_fmd_cleanup(&descriptor);
return FMAPTOOL_EXIT_MISSING_FMAP_SECTION;
}
if (!cbfs_sections_primary_cbfs_accounted_for()) {
fprintf(stderr,
"FATAL: Flashmap descriptor must have a '%s' section that is annotated with '(%s)'\n",
SECTION_NAME_PRIMARY_CBFS,
SECTION_ANNOTATION_CBFS);
full_fmd_cleanup(&descriptor);
return FMAPTOOL_EXIT_MISSING_PRIMARY_CBFS;
}
struct fmap *flashmap = fmap_from_fmd(descriptor);
if (!flashmap) {
fputs("FATAL: Failed while constructing FMAP section\n",
stderr);
full_fmd_cleanup(&descriptor);
return FMAPTOOL_EXIT_FAILED_FMAP_CONVERSION;
}
int size = fmap_size(flashmap);
if (size < 0) {
fputs("FATAL: Failed to determine FMAP section size\n",
stderr);
fmap_destroy(flashmap);
full_fmd_cleanup(&descriptor);
return FMAPTOOL_EXIT_UNKNOWN_FMAP_SIZE;
}
FILE *fmap_file = fopen(args.fmap_filename, "wb");
if (!fmap_file) {
fprintf(stderr, "FATAL: Unable to open file '%s' for writing\n",
args.fmap_filename);
fmap_destroy(flashmap);
full_fmd_cleanup(&descriptor);
return FMAPTOOL_EXIT_BAD_OUTPUT_PATH;
}
if (!fwrite(flashmap, size, 1, fmap_file)) {
fputs("FATAL: Failed to write final FMAP to file\n", stderr);
fclose(fmap_file);
fmap_destroy(flashmap);
full_fmd_cleanup(&descriptor);
return FMAPTOOL_EXIT_FAILED_WRITING_OUTPUT;
}
fclose(fmap_file);
fmap_destroy(flashmap);
if (args.header_filename &&
!write_header(args.header_filename, descriptor, size)) {
full_fmd_cleanup(&descriptor);
return FMAPTOOL_EXIT_FAILED_WRITING_HEADER;
}
fprintf(stderr, "SUCCESS: Wrote %d bytes to file '%s'%s\n", size,
args.fmap_filename,
args.header_filename ? " (and generated header)" : "");
fputs("The sections containing CBFSes are: ", stderr);
list_cbfs_section_names(stdout);
if (args.region_filename) {
FILE *region_file = fopen(args.region_filename, "w");
if (region_file == NULL)
return FMAPTOOL_EXIT_FAILED_WRITING_OUTPUT;
list_cbfs_section_names(region_file);
fclose(region_file);
}
full_fmd_cleanup(&descriptor);
return FMAPTOOL_EXIT_SUCCESS;
}