util/cbfstool/cbfs-mkpayload.c

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <commonlib/endian.h>
   7
   8 #include "elfparsing.h"
   9 #include "common.h"
  10 #include "cbfs.h"
  11 #include "fv.h"
  12 #include "coff.h"
  13 #include "fdt.h"
  14
  15 /* serialize the seg array into the buffer.
  16  * The buffer is assumed to be large enough.
  17  */
  18 void xdr_segs(struct buffer *output,
  19         struct cbfs_payload_segment *segs, int nseg)
  20 {
  21         struct buffer outheader;
  22         int i;
  23
  24         outheader.data = output->data;
  25         outheader.size = 0;
  26
  27         for(i = 0; i < nseg; i++){
  28                 xdr_be.put32(&outheader, segs[i].type);
  29                 xdr_be.put32(&outheader, segs[i].compression);
  30                 xdr_be.put32(&outheader, segs[i].offset);
  31                 xdr_be.put64(&outheader, segs[i].load_addr);
  32                 xdr_be.put32(&outheader, segs[i].len);
  33                 xdr_be.put32(&outheader, segs[i].mem_len);
  34         }
  35 }
  36
  37 void xdr_get_seg(struct cbfs_payload_segment *out,
  38                 struct cbfs_payload_segment *in)
  39 {
  40         struct buffer inheader;
  41
  42         inheader.data = (void *)in;
  43         inheader.size = sizeof(*in);
  44
  45         out->type = xdr_be.get32(&inheader);
  46         out->compression = xdr_be.get32(&inheader);
  47         out->offset = xdr_be.get32(&inheader);
  48         out->load_addr = xdr_be.get64(&inheader);
  49         out->len = xdr_be.get32(&inheader);
  50         out->mem_len = xdr_be.get32(&inheader);
  51 }
  52
  53 int parse_elf_to_payload(const struct buffer *input, struct buffer *output,
  54                          enum cbfs_compression algo)
  55 {
  56         Elf64_Phdr *phdr;
  57         Elf64_Ehdr ehdr;
  58         char *header;
  59         int headers;
  60         int segments = 1;
  61         int isize = 0, osize = 0;
  62         int doffset = 0;
  63         struct cbfs_payload_segment *segs = NULL;
  64         int i;
  65         int ret = 0;
  66
  67         comp_func_ptr compress = compression_function(algo);
  68         if (!compress)
  69                 return -1;
  70
  71         if (elf_headers(input, &ehdr, &phdr, NULL) < 0)
  72                 return -1;
  73
  74         DEBUG("start: parse_elf_to_payload\n");
  75         headers = ehdr.e_phnum;
  76         header = input->data;
  77
  78         /* Count the number of segment headers - we only care about PT_LOAD
  79            headers, because that's what we're actually going to load */
  80         for (i = 0; i < headers; i++) {
  81                 if (phdr[i].p_type != PT_LOAD)
  82                         continue;
  83
  84                 /* Empty segments are never interesting */
  85                 if (phdr[i].p_memsz == 0)
  86                         continue;
  87
  88                 isize += phdr[i].p_filesz;
  89
  90                 segments++;
  91         }
  92         /* Allocate and initialize the segment header array */
  93         segs = calloc(segments, sizeof(*segs));
  94         if (segs == NULL) {
  95                 ret = -1;
  96                 goto out;
  97         }
  98         /* Allocate a block of memory to store the data in */
  99         if (buffer_create(output, (segments * sizeof(*segs)) + isize,
 100                           input->name) != 0) {
 101                 ret = -1;
 102                 goto out;
 103         }
 104         memset(output->data, 0, output->size);
 105
 106         doffset = (segments * sizeof(*segs));
 107
 108         /* set up for output marshaling. This is a bit
 109          * tricky as we are marshaling the headers at the front,
 110          * and the data starting after the headers. We need to convert
 111          * the headers to the right format but the data
 112          * passes through unchanged. Unlike most XDR code,
 113          * we are doing these two concurrently. The doffset is
 114          * used to compute the address for the raw data, and the
 115          * outheader is used to marshal the headers. To make it simpler
 116          * for The Reader, we set up the headers in a separate array,
 117          * then marshal them all at once to the output.
 118          */
 119         segments = 0;
 120
 121         for (i = 0; i < headers; i++) {
 122                 if (phdr[i].p_type != PT_LOAD)
 123                         continue;
 124                 if (phdr[i].p_memsz == 0)
 125                         continue;
 126                 if (phdr[i].p_filesz == 0) {
 127                         segs[segments].type = PAYLOAD_SEGMENT_BSS;
 128                         segs[segments].load_addr = phdr[i].p_paddr;
 129                         segs[segments].mem_len = phdr[i].p_memsz;
 130                         segs[segments].offset = doffset;
 131
 132                         segments++;
 133                         continue;
 134                 }
 135
 136                 if (phdr[i].p_flags & PF_X)
 137                         segs[segments].type = PAYLOAD_SEGMENT_CODE;
 138                 else
 139                         segs[segments].type = PAYLOAD_SEGMENT_DATA;
 140                 segs[segments].load_addr = phdr[i].p_paddr;
 141                 segs[segments].mem_len = phdr[i].p_memsz;
 142                 segs[segments].offset = doffset;
 143
 144                 /* If the compression failed or made the section is larger,
 145                    use the original stuff */
 146
 147                 int len;
 148                 if (compress((char *)&header[phdr[i].p_offset],
 149                              phdr[i].p_filesz, output->data + doffset, &len) ||
 150                     (unsigned int)len > phdr[i].p_filesz) {
 151                         WARN("Compression failed or would make the data bigger "
 152                              "- disabled.\n");
 153                         segs[segments].compression = 0;
 154                         segs[segments].len = phdr[i].p_filesz;
 155                         memcpy(output->data + doffset,
 156                                &header[phdr[i].p_offset], phdr[i].p_filesz);
 157                 } else {
 158                         segs[segments].compression = algo;
 159                         segs[segments].len = len;
 160                 }
 161
 162                 doffset += segs[segments].len;
 163                 osize += segs[segments].len;
 164
 165                 segments++;
 166         }
 167
 168         segs[segments].type = PAYLOAD_SEGMENT_ENTRY;
 169         segs[segments++].load_addr = ehdr.e_entry;
 170
 171         output->size = (segments * sizeof(*segs)) + osize;
 172         xdr_segs(output, segs, segments);
 173
 174 out:
 175         if (segs) free(segs);
 176         if (phdr) free(phdr);
 177         return ret;
 178 }
 179
 180 int parse_flat_binary_to_payload(const struct buffer *input,
 181                                  struct buffer *output,
 182                                  uint64_t loadaddress,
 183                                  uint64_t entrypoint,
 184                                  enum cbfs_compression algo)
 185 {
 186         comp_func_ptr compress;
 187         struct cbfs_payload_segment segs[2] = { {0} };
 188         int doffset, len = 0;
 189
 190         compress = compression_function(algo);
 191         if (!compress)
 192                 return -1;
 193
 194         DEBUG("start: parse_flat_binary_to_payload\n");
 195         if (buffer_create(output, (sizeof(segs) + input->size),
 196                           input->name) != 0)
 197                 return -1;
 198         memset(output->data, 0, output->size);
 199
 200         doffset = (2 * sizeof(*segs));
 201
 202         /* Prepare code segment */
 203         segs[0].type = PAYLOAD_SEGMENT_CODE;
 204         segs[0].load_addr = loadaddress;
 205         segs[0].mem_len = input->size;
 206         segs[0].offset = doffset;
 207
 208         if (!compress(input->data, input->size, output->data + doffset, &len) &&
 209             (unsigned int)len < input->size) {
 210                 segs[0].compression = algo;
 211                 segs[0].len = len;
 212         } else {
 213                 WARN("Compression failed or would make the data bigger "
 214                      "- disabled.\n");
 215                 segs[0].compression = 0;
 216                 segs[0].len = input->size;
 217                 memcpy(output->data + doffset, input->data, input->size);
 218         }
 219
 220         /* prepare entry point segment */
 221         segs[1].type = PAYLOAD_SEGMENT_ENTRY;
 222         segs[1].load_addr = entrypoint;
 223         output->size = doffset + segs[0].len;
 224         xdr_segs(output, segs, 2);
 225         return 0;
 226 }
 227
 228 int parse_fv_to_payload(const struct buffer *input, struct buffer *output,
 229                         enum cbfs_compression algo)
 230 {
 231         comp_func_ptr compress;
 232         struct cbfs_payload_segment segs[2] = { {0} };
 233         int doffset, len = 0;
 234         firmware_volume_header_t *fv;
 235         firmware_volume_ext_header_t *fvh_ext;
 236         ffs_file_header_t *fh;
 237         common_section_header_t *cs;
 238         dos_header_t *dh;
 239         coff_header_t *ch;
 240         int dh_offset;
 241
 242         uint32_t loadaddress = 0;
 243         uint32_t entrypoint = 0;
 244
 245         compress = compression_function(algo);
 246         if (!compress)
 247                 return -1;
 248
 249         DEBUG("start: parse_fv_to_payload\n");
 250
 251         fv = (firmware_volume_header_t *)input->data;
 252         if (fv->signature != FV_SIGNATURE) {
 253                 INFO("Not a UEFI firmware volume.\n");
 254                 return -1;
 255         }
 256
 257         fh = (ffs_file_header_t *)(input->data + fv->header_length);
 258         if (fv->ext_header_offs != 0) {
 259                 fvh_ext = (firmware_volume_ext_header_t *)((uintptr_t)fv + fv->ext_header_offs);
 260                 fh = (ffs_file_header_t *)((uintptr_t)fvh_ext + fvh_ext->ext_header_size);
 261                 fh = (ffs_file_header_t *)(((uintptr_t)fh + 7) & ~7);
 262         }
 263
 264         while (fh->file_type == FILETYPE_PAD) {
 265                 unsigned long offset = (fh->size[2] << 16) | (fh->size[1] << 8) | fh->size[0];
 266                 DEBUG("skipping %lu bytes of FV padding\n", offset);
 267                 fh = (ffs_file_header_t *)(((uintptr_t)fh) + offset);
 268         }
 269         if (fh->file_type != FILETYPE_SEC) {
 270                 ERROR("Not a usable UEFI firmware volume.\n");
 271                 INFO("First file in first FV not a SEC core.\n");
 272                 return -1;
 273         }
 274
 275         cs = (common_section_header_t *)&fh[1];
 276         while (cs->section_type == SECTION_RAW) {
 277                 unsigned long offset = (cs->size[2] << 16) | (cs->size[1] << 8) | cs->size[0];
 278                 DEBUG("skipping %lu bytes of section padding\n", offset);
 279                 cs = (common_section_header_t *)(((uintptr_t)cs) + offset);
 280         }
 281         if (cs->section_type != SECTION_PE32) {
 282                 ERROR("Not a usable UEFI firmware volume.\n");
 283                 INFO("Section type not PE32.\n");
 284                 return -1;
 285         }
 286
 287         dh = (dos_header_t *)&cs[1];
 288         if (dh->signature != DOS_MAGIC) {
 289                 ERROR("Not a usable UEFI firmware volume.\n");
 290                 INFO("DOS header signature wrong.\n");
 291                 return -1;
 292         }
 293
 294         dh_offset = (unsigned long)dh - (unsigned long)input->data;
 295         DEBUG("dos header offset = %x\n", dh_offset);
 296
 297         ch = (coff_header_t *)(((uintptr_t)dh)+dh->e_lfanew);
 298
 299         if (ch->machine == MACHINE_TYPE_X86) {
 300                 pe_opt_header_32_t *ph;
 301                 ph = (pe_opt_header_32_t *)&ch[1];
 302                 if (ph->signature != PE_HDR_32_MAGIC) {
 303                         WARN("PE header signature incorrect.\n");
 304                         return -1;
 305                 }
 306                 DEBUG("image base %x\n", ph->image_addr);
 307                 DEBUG("entry point %x\n", ph->entry_point);
 308
 309                 loadaddress = ph->image_addr - dh_offset;
 310                 entrypoint = ph->image_addr + ph->entry_point;
 311         } else if (ch->machine == MACHINE_TYPE_X64 || ch->machine == MACHINE_TYPE_ARM64) {
 312                 pe_opt_header_64_t *ph;
 313                 ph = (pe_opt_header_64_t *)&ch[1];
 314                 if (ph->signature != PE_HDR_64_MAGIC) {
 315                         WARN("PE header signature incorrect.\n");
 316                         return -1;
 317                 }
 318                 DEBUG("image base %lx\n", (unsigned long)ph->image_addr);
 319                 DEBUG("entry point %x\n", ph->entry_point);
 320
 321                 loadaddress = ph->image_addr - dh_offset;
 322                 entrypoint = ph->image_addr + ph->entry_point;
 323         } else {
 324                 ERROR("Machine type not x86, x64, or arm64.\n");
 325                 return -1;
 326         }
 327
 328         if (buffer_create(output, (sizeof(segs) + input->size),
 329                           input->name) != 0)
 330                 return -1;
 331
 332         memset(output->data, 0, output->size);
 333
 334         doffset = (sizeof(segs));
 335
 336         /* Prepare code segment */
 337         segs[0].type = PAYLOAD_SEGMENT_CODE;
 338         segs[0].load_addr = loadaddress;
 339         segs[0].mem_len = input->size;
 340         segs[0].offset = doffset;
 341
 342         if (!compress(input->data, input->size, output->data + doffset, &len) &&
 343             (unsigned int)len < input->size) {
 344                 segs[0].compression = algo;
 345                 segs[0].len = len;
 346         } else {
 347                 WARN("Compression failed or would make the data bigger "
 348                      "- disabled.\n");
 349                 segs[0].compression = 0;
 350                 segs[0].len = input->size;
 351                 memcpy(output->data + doffset, input->data, input->size);
 352         }
 353
 354         /* prepare entry point segment */
 355         segs[1].type = PAYLOAD_SEGMENT_ENTRY;
 356         segs[1].load_addr = entrypoint;
 357         output->size = doffset + segs[0].len;
 358         xdr_segs(output, segs, 2);
 359         return 0;
 360
 361 }
 362
 363 int parse_fit_to_payload(const struct buffer *input, struct buffer *output,
 364                          enum cbfs_compression algo)
 365 {
 366         struct fdt_header *fdt_h;
 367
 368         DEBUG("start: parse_fit_to_payload\n");
 369
 370         fdt_h = buffer_get(input);
 371         if (read_be32(&fdt_h->magic) != FDT_HEADER_MAGIC) {
 372                 INFO("Not a FIT payload.\n");
 373                 return -1;
 374         }
 375
 376         /**
 377          * For developers:
 378          * Compress the kernel binary you're sourcing in your its-script
 379          * manually with LZ4 or LZMA and add 'compression = "lz4"' or "lzma" to
 380          * the kernel@1 node in the its-script before assembling the image with
 381          * mkimage.
 382          */
 383         if (algo != CBFS_COMPRESS_NONE) {
 384                 ERROR("FIT images don't support whole-image compression,"
 385                       " compress the kernel component instead!\n");
 386                 return -1;
 387         }
 388
 389         if (buffer_create(output, buffer_size(input), input->name) != 0)
 390                 return -1;
 391
 392         memcpy(buffer_get(output), buffer_get(input), buffer_size(input));
 393
 394         DEBUG("done\n");
 395
 396         return 0;
 397 }