util/cbfstool/amdcompress.c

   1 /* AMD Family 17h and later BIOS compressor */
   2 /* SPDX-License-Identifier: GPL-2.0-only */
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <fcntl.h>
   7 #include <sys/stat.h>
   8 #include <getopt.h>
   9 #include <elfparsing.h>
  10 #include "zlib.h"
  11
  12 #define DEBUG_FILE 0
  13
  14 #define HDR_SIZE 256
  15 #define UNCOMP_MAX 0x300000
  16
  17 #define DIR_UNDEF 0
  18 #define DIR_COMP 1
  19 #define DIR_UNCOMP 2
  20
  21 typedef struct _header {
  22         uint32_t rsvd1[5];
  23         uint32_t size;
  24         uint32_t rsvd2[58];
  25 }  __attribute__((packed)) header;
  26
  27 static const char *optstring  = "i:o:cm:uh";
  28
  29 static struct option long_options[] = {
  30         {"infile",           required_argument, 0, 'i' },
  31         {"outfile",          required_argument, 0, 'o' },
  32         {"compress",         no_argument,       0, 'c' },
  33         {"maxsize",          required_argument, 0, 'm' },
  34         {"uncompress",       no_argument,       0, 'u' },
  35         {"help",             no_argument,       0, 'h' },
  36 };
  37
  38 static void usage(void)
  39 {
  40         printf("<name>: Extract or create a zlib compressed BIOS binary\n");
  41         printf("        image.  A compressed image contains a 256 byte\n");
  42         printf("        header with a 32-bit size at 0x14.\n");
  43         printf("Usage: <name> -i in_file -o out_file -[c|u]\n");
  44         printf("-i | --infile <FILE>         Input file\n");
  45         printf("-o | --outfile <FILE>        Output file\n");
  46         printf("-c | --compress              Compress\n");
  47         printf("-m | --maxsize <HEX_VAL>     Maximum uncompressed size (optional)\n");
  48         printf("                              * On compress: verify uncompressed size\n");
  49         printf("                                will be less than or equal maxsize\n");
  50         printf("                              * On uncompress: override default buffer size\n");
  51         printf("                                allocation of 0x%x bytes\n", UNCOMP_MAX);
  52         printf("-u | --uncompress            Uncompress\n");
  53         printf("-h | --help                  Display this message\n");
  54
  55         exit(1);
  56 }
  57
  58 static int do_file(char *name, size_t *size, int oflag)
  59 {
  60         struct stat fd_stat;
  61         int fd;
  62
  63         fd = open(name, oflag, 0666);
  64         if (fd < 0)
  65                 return -1;
  66
  67         if (fstat(fd, &fd_stat)) {
  68                 close(fd);
  69                 return -1;
  70         }
  71
  72         if (size)
  73                 *size = fd_stat.st_size;
  74         return fd;
  75 }
  76
  77 static int parse_elf_to_xip_ram(const struct buffer *input,
  78                                         struct buffer *output)
  79 {
  80         struct parsed_elf pelf;
  81
  82         if (parse_elf(input, &pelf, ELF_PARSE_ALL))
  83                 return 1;
  84         if (buffer_create(output, pelf.phdr->p_filesz, "") != 0)
  85                 return 1;
  86
  87         memcpy(output->data, input->data + pelf.phdr->p_offset, output->size);
  88
  89         return 0;
  90 }
  91
  92 static int convert_elf(struct buffer *buf)
  93 {
  94         struct buffer out;
  95
  96         if (parse_elf_to_xip_ram(buf, &out)) {
  97                 printf("\tError parsing ELF file\n");
  98                 return -1;
  99         }
 100
 101         /* Discard the elf file in buf and replace with the progbits */
 102         free(buf->data);
 103         buf->data = out.data;
 104         buf->size = out.size;
 105
 106         return 0;
 107 }
 108
 109 static int iself(const void *input)
 110 {
 111         const Elf32_Ehdr *ehdr = input;
 112         return !memcmp(ehdr->e_ident, ELFMAG, 4);
 113 }
 114
 115 /* todo: Consider using deflate() and inflate() instead of compress() and
 116  * decompress(), especially if memory allocation somehow becomes a problem.
 117  * Those two functions can operate on streams and process chunks of data.
 118  */
 119
 120 /* Build the required header and follow it with the compressed image.  Detect
 121  * whether the input is an elf image, and if so, compress only the progbits.
 122  *
 123  *     header
 124  *   0 +------+-------+-------+-------+
 125  *     |      |       |       |       |
 126  *     +----------------------+-------+
 127  *     |      | size  |       |       |
 128  *     +----------------------+-------+
 129  *     |      |       |       |       |
 130  *     |      |       |          ...  |
 131  * 256 +------------------------------+
 132  *     |compressed image              |
 133  *     |   ...                        |
 134  *     |   ...                        |
 135  *     |   ...                        |
 136  *   n +------------------------------+
 137  */
 138 static void do_compress(char *outf, char *inf, size_t max_size)
 139 {
 140         int out_fd, in_fd;
 141         struct buffer inbf, outbf;
 142         int err;
 143
 144         in_fd = do_file(inf, &inbf.size, O_RDONLY);
 145         if (in_fd < 0) {
 146                 printf("\tError opening input file %s\n", inf);
 147                 err = 1;
 148                 goto out;
 149         }
 150
 151         out_fd = do_file(outf, 0, O_CREAT | O_WRONLY);
 152         if (out_fd < 0) {
 153                 printf("\tError opening output file %s\n", outf);
 154                 err = 1;
 155                 goto out_close_in;
 156         }
 157
 158         inbf.data = calloc(inbf.size, 1);
 159         if (!inbf.data) {
 160                 printf("\tError allocating 0x%zx bytes for input buffer\n", inbf.size);
 161                 err = 1;
 162                 goto out_close_out;
 163         }
 164
 165         if (read(in_fd, inbf.data, inbf.size) != (ssize_t)inbf.size) {
 166                 printf("\tError reading input file %s\n", inf);
 167                 err = 1;
 168                 goto out_free_in;
 169         }
 170
 171         if (iself(inbf.data)) {
 172                 if (convert_elf(&inbf)) {
 173                         err = 1;
 174                         goto out_free_in;
 175                 }
 176         }
 177
 178         if (max_size && inbf.size > max_size) {
 179                 printf("\tError - size (%zx) exceeds specified max_size (%zx)\n",
 180                                 inbf.size, max_size);
 181                 err = 1;
 182                 goto out_free_in;
 183         }
 184
 185         outbf.size = inbf.size; /* todo: tbd worst case? */
 186         outbf.size += sizeof(header);
 187         outbf.data = calloc(outbf.size, 1);
 188         if (!outbf.size) {
 189                 printf("\tError allocating 0x%zx bytes for output buffer\n", outbf.size);
 190                 err = 1;
 191                 goto out_free_in;
 192         }
 193
 194         err = compress((Bytef *)(outbf.data + sizeof(header)), &outbf.size,
 195                                 (Bytef *)inbf.data, inbf.size);
 196         if (err != Z_OK) {
 197                 printf("\tzlib compression error %d\n", err);
 198                 err = 1;
 199                 goto out_free_out;
 200         }
 201
 202         if (DEBUG_FILE)
 203                 printf("\tCompressed 0x%zx bytes into 0x%zx\n", inbf.size,
 204                                 outbf.size - sizeof(header));
 205
 206         ((header *)outbf.data)->size = outbf.size;
 207
 208         if (write(out_fd, outbf.data, outbf.size + sizeof(header))
 209                                 != (ssize_t)(outbf.size + sizeof(header))) {
 210                 printf("\tError writing to %s\n", outf);
 211                 err = 1;
 212                 /* fall through to out_free_out */
 213         }
 214
 215 out_free_out:
 216         free(outbf.data);
 217 out_free_in:
 218         free(inbf.data);
 219 out_close_out:
 220         close(out_fd);
 221 out_close_in:
 222         close(in_fd);
 223 out:
 224         if (err)
 225                 exit(err);
 226 }
 227
 228 static void do_uncompress(char *outf, char *inf, size_t max_size)
 229 {
 230         int out_fd, in_fd;
 231         char *in_buf, *out_buf;
 232         size_t size_unc, size_comp;
 233         size_t bytes;
 234         int err;
 235
 236         in_fd = do_file(inf, &size_comp, O_RDONLY);
 237         if (in_fd < 0) {
 238                 printf("\tError opening input file %s\n", inf);
 239                 err = 1;
 240                 goto out;
 241         }
 242
 243         out_fd = do_file(outf, 0, O_CREAT | O_WRONLY);
 244         if (out_fd < 0) {
 245                 printf("\tError opening output file %s\n", outf);
 246                 err = 1;
 247                 goto out_close_in;
 248         }
 249
 250         in_buf = calloc(size_comp, 1);
 251         if (!in_buf) {
 252                 printf("\tError allocating 0x%zx bytes for input buffer\n", size_comp);
 253                 err = 1;
 254                 goto out_close_out;
 255         }
 256
 257         bytes = read(in_fd, in_buf, size_comp);
 258         if (bytes != size_comp) {
 259                 printf("\tError reading input file %s\n", inf);
 260                 err = 1;
 261                 goto out_free_in;
 262         }
 263
 264         size_comp = ((header *)in_buf)->size;
 265
 266         size_unc = max_size ? max_size : UNCOMP_MAX;
 267         out_buf = calloc(size_unc, 1);
 268         if (!out_buf) {
 269                 printf("\tError allocating 0x%zx bytes for output buffer\n", size_unc);
 270                 err = 1;
 271                 goto out_free_in;
 272         }
 273
 274         err = uncompress((Bytef *)out_buf, &size_unc,
 275                                 (Bytef *)in_buf + sizeof(header), size_comp);
 276         if (err != Z_OK) {
 277                 printf("\tzlib uncompression error %d\n", err);
 278                 err = 1;
 279                 goto out_free_out;
 280         }
 281
 282         if (DEBUG_FILE)
 283                 printf("Uncompressed 0x%zx bytes into 0x%zx\n", size_comp, size_unc);
 284
 285         bytes = write(out_fd, out_buf, size_unc);
 286         if (bytes != size_unc) {
 287                 printf("\tError writing to %s\n", outf);
 288                 err = 1;
 289                 /* fall through to out_free_out */
 290         }
 291
 292 out_free_out:
 293         free(out_buf);
 294 out_free_in:
 295         free(in_buf);
 296 out_close_out:
 297         close(out_fd);
 298 out_close_in:
 299         close(in_fd);
 300 out:
 301         if (err)
 302                 exit(err);
 303 }
 304
 305 int main(int argc, char *argv[])
 306 {
 307         int c;
 308         char *inf = 0, *outf = 0, *scratch;
 309         int direction = DIR_UNDEF;
 310         size_t max_size = 0;
 311
 312         while (1) {
 313                 int optindex = 0;
 314
 315                 c = getopt_long(argc, argv, optstring, long_options, &optindex);
 316                 if (c == -1)
 317                         break;
 318
 319                 switch (c) {
 320                 case 'i':
 321                         inf = optarg;
 322                         break;
 323                 case 'o':
 324                         outf = optarg;
 325                         break;
 326                 case 'c':
 327                         if (direction != DIR_UNDEF)
 328                                 usage();
 329                         direction = DIR_COMP;
 330                         break;
 331                 case 'u':
 332                         if (direction != DIR_UNDEF)
 333                                 usage();
 334                         direction = DIR_UNCOMP;
 335                         break;
 336                 case 'm':
 337                         max_size = strtoull(optarg, &scratch, 16);
 338                         break;
 339                 case 'h':
 340                         usage();
 341                 }
 342         }
 343         if (!inf || !outf || direction == DIR_UNDEF)
 344                 usage();
 345
 346         if (direction == DIR_COMP)
 347                 do_compress(outf, inf, max_size);
 348         else
 349                 do_uncompress(outf, inf, max_size);
 350
 351         return 0;
 352 }