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

435 lines
9.4 KiB
C

/* SPDX-License-Identifier: GPL-2.0-only */
/* CSE FPT tool */
#include <commonlib/endian.h>
#include <getopt.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "common.h"
#include "cse_fpt.h"
static struct params {
const char *output_dir;
const char *partition_name;
struct fpt_hdr_ops *hdr_ops;
} params;
#define FPT_ENTRY_TYPE_MASK 0x7f
#define FPT_ENTRY_TYPE_SHIFT 0
#define GET_FPT_ENTRY_TYPE(x) (((x) >> FPT_ENTRY_TYPE_SHIFT) & FPT_ENTRY_TYPE_MASK)
#define FPT_ENTRY_TYPE_CODE 0x0
#define FPT_ENTRY_TYPE_DATA 0x1
#define FPT_ENTRY_VALID_MASK 0xff
#define FPT_ENTRY_VALID_SHIFT 24
#define GET_FPT_ENTRY_VALID(x) (((x) >> FPT_ENTRY_VALID_SHIFT) & FPT_ENTRY_VALID_MASK)
#define FPT_ENTRY_INVALID 0xff
#define FPT_ENTRY_VALID 0x0
struct fpt_entry {
uint8_t name[4]; /* ASCII short name */
uint8_t rsvd1[4];
uint32_t offset; /* Offset in bytes from start of FPT binary */
uint32_t length; /* Size in bytes */
uint8_t rsvd2[12];
uint32_t flags;
} __packed;
static struct fpt {
struct buffer input_buff;
const struct fpt_hdr_ops *hdr_ops;
fpt_hdr_ptr hdr;
struct fpt_entry *entries;
} fpt;
static void usage(const char *name)
{
printf("%s: Utility for CSE FPT\n\n"
"USAGE:\n"
" %s FILE COMMAND\n\n"
"COMMANDs:\n"
" print\n"
" dump [-o OUTPUT_DIR] [-n NAME]\n"
"\nOPTIONS:\n"
" -o OUTPUT_DIR : Directory to dump the partition files in\n"
" -n NAME : Name of partition to dump\n"
"\n",
name, name);
}
void read_member(struct buffer *buff, void *dst, size_t size)
{
uint8_t *src = buffer_get(buff);
switch (size) {
case 1:
*(uint8_t *)dst = read_le8(src);
break;
case 2:
*(uint16_t *)dst = read_le16(src);
break;
case 4:
*(uint32_t *)dst = read_le32(src);
break;
case 8:
*(uint64_t *)dst = read_le64(src);
break;
default:
memcpy(dst, src, size);
}
buffer_seek(buff, size);
}
static int get_fpt_buff(struct buffer *input_buff, struct buffer *fpt_buff)
{
/*
* FPT marker is typically at offset 0x10 in the released CSE binary. Check at offset
* 0x10 first and if that fails fall back to checking offset 0.
*/
const size_t fpt_offsets[] = { 0x10, 0 };
size_t i;
for (i = 0; i < ARRAY_SIZE(fpt_offsets); i++) {
if (buffer_size(input_buff) < (strlen(FPT_MARKER) + fpt_offsets[i]))
continue;
const uint8_t *data = buffer_get(input_buff);
if (!memcmp(data + fpt_offsets[i], FPT_MARKER, strlen(FPT_MARKER)))
break;
}
if (i == ARRAY_SIZE(fpt_offsets)) {
ERROR("Could not locate FPT at known offsets.\n");
return -1;
}
buffer_clone(fpt_buff, input_buff);
buffer_seek(fpt_buff, fpt_offsets[i]);
return 0;
}
static int read_fpt_entries(struct buffer *buff)
{
size_t i;
struct fpt_entry *e;
const size_t entries = fpt.hdr_ops->get_entry_count(fpt.hdr);
const size_t fpt_entries_size = sizeof(struct fpt_entry) * entries;
if (buffer_size(buff) < fpt_entries_size) {
ERROR("Not enough bytes(actual=0x%zx, expected=0x%zx) for FPT entries!\n",
buffer_size(buff), fpt_entries_size);
return -1;
}
e = fpt.entries = malloc(fpt_entries_size);
for (i = 0; i < entries; i++, e++) {
READ_MEMBER(buff, e->name);
READ_MEMBER(buff, e->rsvd1);
READ_MEMBER(buff, e->offset);
READ_MEMBER(buff, e->length);
READ_MEMBER(buff, e->rsvd2);
READ_MEMBER(buff, e->flags);
}
return 0;
}
static const struct fpt_hdr_ops *get_fpt_hdr_ops(struct buffer *buff)
{
static const struct fpt_hdr_ops *hdr_ops[] = {
&fpt_hdr_20_ops,
&fpt_hdr_21_ops,
};
for (size_t i = 0; i < ARRAY_SIZE(hdr_ops); i++) {
if (hdr_ops[i]->match_version(buff))
return hdr_ops[i];
}
return NULL;
}
static int fpt_parse(const char *image_name)
{
struct buffer *input_buff = &fpt.input_buff;
struct buffer fpt_buff;
if (buffer_from_file(input_buff, image_name)) {
ERROR("Failed to read input file %s\n", image_name);
return -1;
}
if (get_fpt_buff(input_buff, &fpt_buff))
return -1;
fpt.hdr_ops = get_fpt_hdr_ops(&fpt_buff);
if (fpt.hdr_ops == NULL) {
ERROR("FPT header format not supported!\n");
return -1;
}
fpt.hdr = fpt.hdr_ops->read(&fpt_buff);
if (!fpt.hdr) {
ERROR("Unable to read FPT header!\n");
return -1;
}
return read_fpt_entries(&fpt_buff);
}
static bool is_partition_valid(const struct fpt_entry *e)
{
return e->offset != 0 && e->length != 0 &&
GET_FPT_ENTRY_VALID(e->flags) != FPT_ENTRY_INVALID;
}
static bool is_partition_code(const struct fpt_entry *e)
{
return GET_FPT_ENTRY_TYPE(e->flags) == FPT_ENTRY_TYPE_CODE;
}
static void print_fpt_entry(const struct fpt_entry *e)
{
printf("%-25s0x%-23x0x%-23x%c,%c (0x%.8x)\n",
e->name, e->offset, e->length,
is_partition_code(e) ? 'C' : 'D',
is_partition_valid(e) ? 'V' : 'I',
e->flags);
}
static void print_fpt_entries(const struct fpt_entry *e, size_t count)
{
printf("\n * FPT entries\n");
printf("%-25s%-25s%-25s%-25s\n", "Name", "Offset", "Size", "Flags");
printf("=============================================================="
"===============================\n");
for (size_t i = 0; i < count; i++)
print_fpt_entry(&e[i]);
printf("=============================================================="
"================================\n");
printf("Flags: I=invalid, V=valid, C=code, D=data\n");
}
static bool partition_name_match(const struct fpt_entry *e, const char *name)
{
if (!name)
return false;
return !memcmp(e->name, name, sizeof(e->name));
}
static const struct fpt_entry *get_partition_entry(const char *name)
{
for (size_t i = 0; i < fpt.hdr_ops->get_entry_count(fpt.hdr); i++) {
if (partition_name_match(&fpt.entries[i], name))
return &fpt.entries[i];
}
return NULL;
}
static int cmd_print(void)
{
if (params.partition_name == NULL) {
fpt.hdr_ops->print(fpt.hdr);
print_fpt_entries(fpt.entries, fpt.hdr_ops->get_entry_count(fpt.hdr));
} else {
const struct fpt_entry *e = get_partition_entry(params.partition_name);
if (e)
print_fpt_entry(e);
else {
ERROR("Partition %s not found!\n", params.partition_name);
return -1;
}
}
return 0;
}
static bool should_dump_partition(const struct fpt_entry *e)
{
if (!is_partition_valid(e)) {
if (partition_name_match(e, params.partition_name)) {
ERROR("Invalid partition requested to be dumped!\n");
exit(-1);
}
return false;
}
/* Dump all partitions if no name provided. */
if (params.partition_name == NULL)
return true;
return partition_name_match(e, params.partition_name);
}
static char *get_file_path(const struct fpt_entry *e)
{
size_t filename_len = sizeof(e->name) + 1;
char *filepath;
/* output_dir name followed by '/' */
if (params.output_dir)
filename_len += strlen(params.output_dir) + 1;
filepath = malloc(filename_len);
if (!filepath)
return NULL;
snprintf(filepath, filename_len, "%s%s%s",
params.output_dir ? : "",
params.output_dir ? "/" : "",
e->name);
return filepath;
}
static int write_partition_to_file(const struct fpt_entry *e)
{
size_t end_offset = e->offset + e->length - 1;
struct buffer part_buffer;
char *filepath;
if (end_offset > buffer_size(&fpt.input_buff)) {
ERROR("Offset out of bounds for the partition!\n");
return -1;
}
filepath = get_file_path(e);
if (!filepath) {
ERROR("Failed to allocate space for filepath!\n");
return -1;
}
printf("Dumping %.4s in %s\n", e->name, filepath);
buffer_splice(&part_buffer, &fpt.input_buff, e->offset, e->length);
buffer_write_file(&part_buffer, filepath);
free(filepath);
return 0;
}
static int cmd_dump(void)
{
size_t i;
bool found = false;
struct stat sb;
if (params.output_dir && (stat(params.output_dir, &sb) == -1)) {
ERROR("Failed to stat %s: %s\n", params.output_dir, strerror(errno));
return -1;
}
for (i = 0; i < fpt.hdr_ops->get_entry_count(fpt.hdr); i++) {
if (!should_dump_partition(&fpt.entries[i]))
continue;
found = true;
if (write_partition_to_file(&fpt.entries[i]))
return -1;
}
if (found == false) {
if (params.partition_name)
ERROR("%s not found!\n", params.partition_name);
ERROR("No partitions dumped!\n");
return -1;
}
return 0;
}
static struct command {
const char *name;
const char *optstring;
int (*function)(void);
} commands[] = {
{ "print", "n:?", cmd_print },
{ "dump", "n:o:?", cmd_dump },
};
static struct option long_options[] = {
{"help", required_argument, 0, 'h'},
{"partition_name", required_argument, 0, 'n'},
{"output_dir", required_argument, 0, 'o'},
{NULL, 0, 0, 0 }
};
int main(int argc, char **argv)
{
if (argc < 3) {
ERROR("Incorrect number of args(%d)!\n", argc);
usage(argv[0]);
return 1;
}
const char *prog_name = argv[0];
const char *image_name = argv[1];
const char *cmd = argv[2];
size_t i;
for (i = 0; i < ARRAY_SIZE(commands); i++) {
if (strcmp(cmd, commands[i].name))
continue;
int c;
int option_index;
while (1) {
c = getopt_long(argc, argv, commands[i].optstring,
long_options, &option_index);
if (c == -1)
break;
if (strchr(commands[i].optstring, c) == NULL) {
ERROR("Invalid option '%c'\n", c);
usage(prog_name);
return 1;
}
switch (c) {
case 'o':
params.output_dir = optarg;
break;
case 'n':
params.partition_name = optarg;
break;
case 'h':
case '?':
default:
usage(prog_name);
return 1;
}
}
break;
}
if (i == ARRAY_SIZE(commands)) {
ERROR("No command match %s\n", cmd);
usage(prog_name);
return 1;
}
if (fpt_parse(image_name))
return 1;
return commands[i].function();
}