365 lines
8.5 KiB
C
365 lines
8.5 KiB
C
/*
|
|
* AMD Family 17h and later BIOS compressor
|
|
*
|
|
* Copyright (C) 2019 Advanced Micro Devices, Inc.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; version 2 of the License.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <fcntl.h>
|
|
#include <sys/stat.h>
|
|
#include <getopt.h>
|
|
#include <elfparsing.h>
|
|
#include "zlib.h"
|
|
|
|
#define DEBUG_FILE 0
|
|
|
|
#define HDR_SIZE 256
|
|
#define UNCOMP_MAX 0x300000
|
|
|
|
#define DIR_UNDEF 0
|
|
#define DIR_COMP 1
|
|
#define DIR_UNCOMP 2
|
|
|
|
typedef struct _header {
|
|
uint32_t rsvd1[5];
|
|
uint32_t size;
|
|
uint32_t rsvd2[58];
|
|
} __attribute__((packed)) header;
|
|
|
|
static const char *optstring = "i:o:cm:uh";
|
|
|
|
static struct option long_options[] = {
|
|
{"infile", required_argument, 0, 'i' },
|
|
{"outfile", required_argument, 0, 'o' },
|
|
{"compress", required_argument, 0, 'c' },
|
|
{"maxsize", required_argument, 0, 'h' },
|
|
{"uncompress", required_argument, 0, 'u' },
|
|
{"help", no_argument, 0, 'h' },
|
|
};
|
|
|
|
static void usage(void)
|
|
{
|
|
printf("<name>: Extract or create a zlib compressed BIOS binary\n");
|
|
printf(" image. A compressed image contains a 256 byte\n");
|
|
printf(" header with a 32-bit size at 0x14.\n");
|
|
printf("Usage: <name> -i in_file -o out_file -[c|u]\n");
|
|
printf("-i | --infile <FILE> Input file\n");
|
|
printf("-o | --outfile <FILE> Output file\n");
|
|
printf("-c | --compress Compress\n");
|
|
printf("-m | --maxsize <HEX_VAL> Maximum uncompressed size (optional)\n");
|
|
printf(" * On compress: verify uncompressed size\n");
|
|
printf(" will be less than or equal maxsize\n");
|
|
printf(" * On uncompress: override default buffer size\n");
|
|
printf(" allocation of 0x%x bytes\n", UNCOMP_MAX);
|
|
printf("-u | --uncompress Uncompress\n");
|
|
printf("-h | --help Display this message\n");
|
|
|
|
exit(1);
|
|
}
|
|
|
|
static int do_file(char *name, size_t *size, int oflag)
|
|
{
|
|
struct stat fd_stat;
|
|
int fd;
|
|
|
|
fd = open(name, oflag, 0666);
|
|
if (fd < 0)
|
|
return -1;
|
|
|
|
if (fstat(fd, &fd_stat)) {
|
|
close(fd);
|
|
return -1;
|
|
}
|
|
|
|
if (size)
|
|
*size = fd_stat.st_size;
|
|
return fd;
|
|
}
|
|
|
|
static int parse_elf_to_xip_ram(const struct buffer *input,
|
|
struct buffer *output)
|
|
{
|
|
struct parsed_elf pelf;
|
|
|
|
if (parse_elf(input, &pelf, ELF_PARSE_ALL))
|
|
return 1;
|
|
if (buffer_create(output, pelf.phdr->p_filesz, "") != 0)
|
|
return 1;
|
|
|
|
memcpy(output->data, input->data + pelf.phdr->p_offset, output->size);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int convert_elf(struct buffer *buf)
|
|
{
|
|
struct buffer out;
|
|
|
|
if (parse_elf_to_xip_ram(buf, &out)) {
|
|
printf("\tError parsing ELF file\n");
|
|
return -1;
|
|
}
|
|
|
|
/* Discard the elf file in buf and replace with the progbits */
|
|
free(buf->data);
|
|
buf->data = out.data;
|
|
buf->size = out.size;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int iself(const void *input)
|
|
{
|
|
const Elf32_Ehdr *ehdr = input;
|
|
return !memcmp(ehdr->e_ident, ELFMAG, 4);
|
|
}
|
|
|
|
/* todo: Consider using deflate() and inflate() instead of compress() and
|
|
* decompress(), especially if memory allocation somehow becomes a problem.
|
|
* Those two functions can operate on streams and process chunks of data.
|
|
*/
|
|
|
|
/* Build the required header and follow it with the compressed image. Detect
|
|
* whether the input is an elf image, and if so, compress only the progbits.
|
|
*
|
|
* header
|
|
* 0 +------+-------+-------+-------+
|
|
* | | | | |
|
|
* +----------------------+-------+
|
|
* | | size | | |
|
|
* +----------------------+-------+
|
|
* | | | | |
|
|
* | | | ... |
|
|
* 256 +------------------------------+
|
|
* |compressed image |
|
|
* | ... |
|
|
* | ... |
|
|
* | ... |
|
|
* n +------------------------------+
|
|
*/
|
|
static void do_compress(char *outf, char *inf, size_t max_size)
|
|
{
|
|
int out_fd, in_fd;
|
|
struct buffer inbf, outbf;
|
|
int err;
|
|
|
|
in_fd = do_file(inf, &inbf.size, O_RDONLY);
|
|
if (in_fd < 0) {
|
|
printf("\tError opening input file %s\n", inf);
|
|
err = 1;
|
|
goto out;
|
|
}
|
|
|
|
out_fd = do_file(outf, 0, O_CREAT | O_WRONLY);
|
|
if (out_fd < 0) {
|
|
printf("\tError opening output file %s\n", outf);
|
|
err = 1;
|
|
goto out_close_in;
|
|
}
|
|
|
|
inbf.data = calloc(inbf.size, 1);
|
|
if (!inbf.data) {
|
|
printf("\tError allocating 0x%zx bytes for input buffer\n", inbf.size);
|
|
err = 1;
|
|
goto out_close_out;
|
|
}
|
|
|
|
if (read(in_fd, inbf.data, inbf.size) != (ssize_t)inbf.size) {
|
|
printf("\tError reading input file %s\n", inf);
|
|
err = 1;
|
|
goto out_free_in;
|
|
}
|
|
|
|
if (iself(inbf.data)) {
|
|
if (convert_elf(&inbf)) {
|
|
err = 1;
|
|
goto out_free_in;
|
|
}
|
|
}
|
|
|
|
if (max_size && inbf.size > max_size) {
|
|
printf("\tError - size (%zx) exceeds specified max_size (%zx)\n",
|
|
inbf.size, max_size);
|
|
err = 1;
|
|
goto out_free_in;
|
|
}
|
|
|
|
outbf.size = inbf.size; /* todo: tbd worst case? */
|
|
outbf.size += sizeof(header);
|
|
outbf.data = calloc(outbf.size, 1);
|
|
if (!outbf.size) {
|
|
printf("\tError allocating 0x%zx bytes for output buffer\n", outbf.size);
|
|
err = 1;
|
|
goto out_free_in;
|
|
}
|
|
|
|
err = compress((Bytef *)(outbf.data + sizeof(header)), &outbf.size,
|
|
(Bytef *)inbf.data, inbf.size);
|
|
if (err != Z_OK) {
|
|
printf("\tzlib compression error %d\n", err);
|
|
err = 1;
|
|
goto out_free_out;
|
|
}
|
|
|
|
if (DEBUG_FILE)
|
|
printf("\tCompressed 0x%zx bytes into 0x%zx\n", inbf.size,
|
|
outbf.size - sizeof(header));
|
|
|
|
((header *)outbf.data)->size = outbf.size;
|
|
|
|
if (write(out_fd, outbf.data, outbf.size + sizeof(header))
|
|
!= (ssize_t)(outbf.size + sizeof(header))) {
|
|
printf("\tError writing to %s\n", outf);
|
|
err = 1;
|
|
/* fall through to out_free_out */
|
|
}
|
|
|
|
out_free_out:
|
|
free(outbf.data);
|
|
out_free_in:
|
|
free(inbf.data);
|
|
out_close_out:
|
|
close(out_fd);
|
|
out_close_in:
|
|
close(in_fd);
|
|
out:
|
|
if (err)
|
|
exit(err);
|
|
}
|
|
|
|
static void do_uncompress(char *outf, char *inf, size_t max_size)
|
|
{
|
|
int out_fd, in_fd;
|
|
char *in_buf, *out_buf;
|
|
size_t size_unc, size_comp;
|
|
size_t bytes;
|
|
int err;
|
|
|
|
in_fd = do_file(inf, &size_comp, O_RDONLY);
|
|
if (in_fd < 0) {
|
|
printf("\tError opening input file %s\n", inf);
|
|
err = 1;
|
|
goto out;
|
|
}
|
|
|
|
out_fd = do_file(outf, 0, O_CREAT | O_WRONLY);
|
|
if (out_fd < 0) {
|
|
printf("\tError opening output file %s\n", outf);
|
|
err = 1;
|
|
goto out_close_in;
|
|
}
|
|
|
|
in_buf = calloc(size_comp, 1);
|
|
if (!in_buf) {
|
|
printf("\tError allocating 0x%zx bytes for input buffer\n", size_comp);
|
|
err = 1;
|
|
goto out_close_out;
|
|
}
|
|
|
|
bytes = read(in_fd, in_buf, size_comp);
|
|
if (bytes != size_comp) {
|
|
printf("\tError reading input file %s\n", inf);
|
|
err = 1;
|
|
goto out_free_in;
|
|
}
|
|
|
|
size_comp = ((header *)in_buf)->size;
|
|
|
|
size_unc = max_size ? max_size : UNCOMP_MAX;
|
|
out_buf = calloc(size_unc, 1);
|
|
if (!out_buf) {
|
|
printf("\tError allocating 0x%zx bytes for output buffer\n", size_unc);
|
|
err = 1;
|
|
goto out_free_in;
|
|
}
|
|
|
|
err = uncompress((Bytef *)out_buf, &size_unc,
|
|
(Bytef *)in_buf + sizeof(header), size_comp);
|
|
if (err != Z_OK) {
|
|
printf("\tzlib uncompression error %d\n", err);
|
|
err = 1;
|
|
goto out_free_out;
|
|
}
|
|
|
|
if (DEBUG_FILE)
|
|
printf("Uncompressed 0x%zx bytes into 0x%zx\n", size_comp, size_unc);
|
|
|
|
bytes = write(out_fd, out_buf, size_unc);
|
|
if (bytes != size_unc) {
|
|
printf("\tError writing to %s\n", outf);
|
|
err = 1;
|
|
/* fall through to out_free_out */
|
|
}
|
|
|
|
out_free_out:
|
|
free(out_buf);
|
|
out_free_in:
|
|
free(in_buf);
|
|
out_close_out:
|
|
close(out_fd);
|
|
out_close_in:
|
|
close(in_fd);
|
|
out:
|
|
if (err)
|
|
exit(err);
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int c;
|
|
char *inf = 0, *outf = 0, *scratch;
|
|
int direction = DIR_UNDEF;
|
|
size_t max_size = 0;
|
|
|
|
while (1) {
|
|
int optindex = 0;
|
|
|
|
c = getopt_long(argc, argv, optstring, long_options, &optindex);
|
|
if (c == -1)
|
|
break;
|
|
|
|
switch (c) {
|
|
case 'i':
|
|
inf = optarg;
|
|
break;
|
|
case 'o':
|
|
outf = optarg;
|
|
break;
|
|
case 'c':
|
|
if (direction != DIR_UNDEF)
|
|
usage();
|
|
direction = DIR_COMP;
|
|
break;
|
|
case 'u':
|
|
if (direction != DIR_UNDEF)
|
|
usage();
|
|
direction = DIR_UNCOMP;
|
|
break;
|
|
case 'm':
|
|
max_size = strtoull(optarg, &scratch, 16);
|
|
break;
|
|
case 'h':
|
|
usage();
|
|
}
|
|
}
|
|
if (!inf || !outf || direction == DIR_UNDEF)
|
|
usage();
|
|
|
|
if (direction == DIR_COMP)
|
|
do_compress(outf, inf, max_size);
|
|
else
|
|
do_uncompress(outf, inf, max_size);
|
|
|
|
return 0;
|
|
}
|