efi/wrapper.c

   1 /*
   2  * Copyright (C) 2011 Intel Corporation; author Matt Fleming
   3  *
   4  * Wrap the ELF shared library in a PE32 (32bit) or PE32+ (64bit) suit.
   5  *
   6  * Syslinux plays some games with the ELF sections that are not easily
   7  * converted to a PE32 executable. For instance, Syslinux requires
   8  * that a symbol hash table be present (GNU hash or SysV) so that
   9  * symbols in ELF modules can be resolved at runtime but the EFI
  10  * firmware loader doesn't like that and refuses to load the file.
  11  *
  12  * We pretend that we have an EFI executable with a single .text
  13  * section so that the EFI loader will load it and jump to the entry
  14  * point. Once the Syslinux ELF shared object has control we can do
  15  * whatever we want.
  16  */
  17 #include <linux/elf.h>
  18 #include <sys/types.h>
  19 #include <sys/stat.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24
  25 #include "wrapper.h"
  26
  27 #if __SIZEOF_POINTER__ == 4
  28 typedef Elf32_Ehdr Elf_Ehdr;
  29 typedef Elf32_Addr Elf_Addr;
  30 #elif __SIZEOF_POINTER__ == 8
  31 typedef Elf64_Ehdr Elf_Ehdr;
  32 typedef Elf64_Addr Elf_Addr;
  33 #else
  34 #error "unsupported architecture"
  35 #endif
  36
  37 /*
  38  * 'so_memsz' is the size of the ELF shared object once loaded.
  39  * 'data_size' is the size of initialised data in the shared object.
  40  *  'class' dictates how the header is written
  41  *      For 32bit machines (class == ELFCLASS32), the optional
  42  *      header includes PE32 header fields
  43  *      For 64bit machines (class == ELFCLASS64), the optional
  44  *      header includes PE32+header fields
  45  */
  46 static void write_header(FILE *f, __uint32_t entry, size_t data_size,
  47                          __uint32_t so_memsz, __uint8_t class)
  48 {
  49         struct optional_hdr o_hdr;
  50         struct optional_hdr_pe32p o_hdr_pe32p;
  51         struct section t_sec;
  52         struct extra_hdr e_hdr;
  53         struct extra_hdr_pe32p e_hdr_pe32p;
  54         struct coff_hdr c_hdr;
  55         struct header hdr;
  56         __uint32_t total_sz = data_size;
  57         __uint32_t hdr_sz;
  58         __uint32_t reloc_start, reloc_end;
  59
  60         /*
  61          * The header size have to be a multiple of file_align, which currently
  62          * is 512
  63          */
  64         hdr_sz = 512;
  65         total_sz += hdr_sz;
  66         entry += hdr_sz;
  67
  68         memset(&hdr, 0, sizeof(hdr));
  69         hdr.msdos_signature = MSDOS_SIGNATURE;
  70
  71         /*
  72          * The relocs table pointer needs to be >= 0x40 for PE files. It
  73          * informs things like file(1) that we are not an MS-DOS
  74          * executable.
  75          */
  76         hdr.relocs_ptr = 0x40;
  77
  78         hdr.pe_hdr = OFFSETOF(struct header, pe_signature);
  79         hdr.pe_signature = PE_SIGNATURE;
  80         fwrite(&hdr, sizeof(hdr), 1, f);
  81
  82         memset(&c_hdr, 0, sizeof(c_hdr));
  83         c_hdr.nr_sections = 1;
  84         c_hdr.nr_syms = 1;
  85         if (class == ELFCLASS32) {
  86                 c_hdr.arch = IMAGE_FILE_MACHINE_I386;
  87                 c_hdr.characteristics = IMAGE_FILE_32BIT_MACHINE |
  88                         IMAGE_FILE_DEBUG_STRIPPED | IMAGE_FILE_EXECUTABLE_IMAGE |
  89                         IMAGE_FILE_LINE_NUMBERS_STRIPPED;
  90                 c_hdr.optional_hdr_sz = sizeof(o_hdr) + sizeof(e_hdr);
  91                 fwrite(&c_hdr, sizeof(c_hdr), 1, f);
  92                 memset(&o_hdr, 0, sizeof(o_hdr));
  93                 o_hdr.format = PE32_FORMAT;
  94                 o_hdr.major_linker_version = 0x02;
  95                 o_hdr.minor_linker_version = 0x14;
  96                 o_hdr.code_sz = data_size;
  97                 o_hdr.entry_point = entry;
  98                 o_hdr.initialized_data_sz = data_size;
  99                 fwrite(&o_hdr, sizeof(o_hdr), 1, f);
 100                 memset(&e_hdr, 0, sizeof(e_hdr));
 101                 e_hdr.section_align = 4096;
 102                 e_hdr.file_align = 512;
 103                 e_hdr.image_sz = hdr_sz + so_memsz;
 104                 e_hdr.headers_sz = hdr_sz;
 105                 e_hdr.subsystem = IMAGE_SUBSYSTEM_EFI_APPLICATION;
 106                 e_hdr.rva_and_sizes_nr = sizeof(e_hdr.data_directory) / sizeof(__uint64_t);
 107                 fwrite(&e_hdr, sizeof(e_hdr), 1, f);
 108         }
 109         else if (class == ELFCLASS64) {
 110                 c_hdr.arch = IMAGE_FILE_MACHINE_X86_64;
 111                 c_hdr.characteristics = IMAGE_FILE_DEBUG_STRIPPED | IMAGE_FILE_EXECUTABLE_IMAGE |
 112                         IMAGE_FILE_LINE_NUMBERS_STRIPPED;
 113                 c_hdr.optional_hdr_sz = sizeof(o_hdr_pe32p) + sizeof(e_hdr_pe32p);
 114                 fwrite(&c_hdr, sizeof(c_hdr), 1, f);
 115                 memset(&o_hdr_pe32p, 0, sizeof(o_hdr_pe32p));
 116                 o_hdr_pe32p.format = PE32P_FORMAT;
 117                 o_hdr_pe32p.major_linker_version = 0x02;
 118                 o_hdr_pe32p.minor_linker_version = 0x14;
 119                 o_hdr_pe32p.code_sz = data_size;
 120                 o_hdr_pe32p.entry_point = entry;
 121                 o_hdr.initialized_data_sz = data_size;
 122                 fwrite(&o_hdr_pe32p, sizeof(o_hdr_pe32p), 1, f);
 123                 memset(&e_hdr_pe32p, 0, sizeof(e_hdr_pe32p));
 124                 e_hdr_pe32p.section_align = 4096;
 125                 e_hdr_pe32p.file_align = 512;
 126                 e_hdr_pe32p.image_sz = hdr_sz + so_memsz;
 127                 e_hdr_pe32p.headers_sz = hdr_sz;
 128                 e_hdr_pe32p.subsystem = IMAGE_SUBSYSTEM_EFI_APPLICATION;
 129                 e_hdr_pe32p.rva_and_sizes_nr = sizeof(e_hdr_pe32p.data_directory) / sizeof(__uint64_t);
 130                 fwrite(&e_hdr_pe32p, sizeof(e_hdr_pe32p), 1, f);
 131         }
 132
 133         memset(&t_sec, 0, sizeof(t_sec));
 134         strcpy((char *)t_sec.name, ".text");
 135         t_sec.virtual_sz = data_size;
 136         t_sec.virtual_address = hdr_sz;
 137         t_sec.raw_data_sz = t_sec.virtual_sz;
 138         t_sec.raw_data = t_sec.virtual_address;
 139         t_sec.characteristics = IMAGE_SCN_CNT_CODE |
 140                 IMAGE_SCN_ALIGN_16BYTES | IMAGE_SCN_MEM_EXECUTE |
 141                 IMAGE_SCN_MEM_READ;
 142         fwrite(&t_sec, sizeof(t_sec), 1, f);
 143
 144         /*
 145          * Add some padding to align the ELF as needed
 146          */
 147         if (ftell(f) > t_sec.virtual_address) {
 148                 /* Don't rewind! hdr_sz need to be increased. */
 149                 fprintf(stderr, "PE32+ headers are too large.\n");
 150                 exit(EXIT_FAILURE);
 151         }
 152
 153         fseek(f, t_sec.virtual_address, SEEK_SET);
 154 }
 155
 156 static void usage(char *progname)
 157 {
 158         fprintf(stderr, "usage: %s <ELF shared object> <output file>\n",
 159                 progname);
 160 }
 161
 162 int main(int argc, char **argv)
 163 {
 164         Elf32_Ehdr e32_hdr;
 165         Elf64_Ehdr e64_hdr;
 166         __uint32_t entry;
 167         __uint8_t class;
 168         __uint64_t phoff = 0;
 169         __uint16_t phnum = 0, phentsize = 0;
 170         unsigned char *id;
 171         FILE *f_in, *f_out;
 172         void *buf;
 173         size_t datasz, memsz, rv;
 174
 175         if (argc < 3) {
 176                 usage(argv[0]);
 177                 exit(0);
 178         }
 179
 180         f_in = fopen(argv[1], "r");
 181         if (!f_in) {
 182                 perror("fopen");
 183                 exit(EXIT_FAILURE);
 184         }
 185
 186         f_out = fopen(argv[2], "w");
 187         if (!f_out) {
 188                 perror("fopen");
 189                 exit(EXIT_FAILURE);
 190         }
 191
 192         /*
 193          * Parse the ELF header and find the entry point.
 194          */
 195         fread((void *)&e32_hdr, sizeof(e32_hdr), 1, f_in);
 196         if (e32_hdr.e_ident[EI_CLASS] == ELFCLASS32) {
 197                 id = e32_hdr.e_ident;
 198                 class = ELFCLASS32;
 199                 entry = e32_hdr.e_entry;
 200                 phoff = e32_hdr.e_phoff;
 201                 phnum = e32_hdr.e_phnum;
 202                 phentsize = e32_hdr.e_phentsize;
 203         }
 204         else if (e32_hdr.e_ident[EI_CLASS] == ELFCLASS64) {
 205                 /* read the header again for x86_64
 206                  * note that the elf header entry point is 64bit whereas
 207                  * the entry point in PE/COFF format is 32bit!*/
 208                 class = ELFCLASS64;
 209                 rewind(f_in);
 210                 fread((void *)&e64_hdr, sizeof(e64_hdr), 1, f_in);
 211                 id = e64_hdr.e_ident;
 212                 entry = e64_hdr.e_entry;
 213                 phoff = e64_hdr.e_phoff;
 214                 phnum = e64_hdr.e_phnum;
 215                 phentsize = e64_hdr.e_phentsize;
 216         } else {
 217                 fprintf(stderr, "Unsupported architecture\n");
 218                 exit(EXIT_FAILURE);
 219         }
 220
 221         if (id[EI_MAG0] != ELFMAG0 ||
 222             id[EI_MAG1] != ELFMAG1 ||
 223             id[EI_MAG2] != ELFMAG2 ||
 224             id[EI_MAG3] != ELFMAG3) {
 225                 fprintf(stderr, "Input file not ELF shared object\n");
 226                 exit(EXIT_FAILURE);
 227         }
 228
 229         if (!phoff || !phnum) {
 230                 fprintf(stderr, "Cannot find segment table\n");
 231                 exit(EXIT_FAILURE);
 232         }
 233
 234         /*
 235          * Find the LOAD program header. Everything in this segment
 236          * is copied verbatim to the output file.
 237          * Although there may be several LOAD program headers, only
 238          * one is currently copied.
 239          */
 240         if (e32_hdr.e_ident[EI_CLASS] == ELFCLASS32) {
 241                 Elf32_Phdr phdr;
 242                 int i;
 243
 244                 /* Find the first LOAD program header */
 245                 for (i = 0; i < phnum; i++) {
 246                         fseek(f_in, phoff + i * phentsize, SEEK_SET);
 247                         fread(&phdr, sizeof(phdr), 1, f_in);
 248
 249                         if (phdr.p_type == PT_LOAD)
 250                                 break;
 251                 }
 252
 253                 datasz = phdr.p_filesz;
 254                 memsz = phdr.p_memsz;
 255         } else if (e32_hdr.e_ident[EI_CLASS] == ELFCLASS64) {
 256                 Elf64_Phdr phdr;
 257                 int i;
 258
 259                 /* Find the first LOAD program header */
 260                 for (i = 0; i < phnum; i++) {
 261                         fseek(f_in, phoff + i * phentsize, SEEK_SET);
 262                         fread(&phdr, sizeof(phdr), 1, f_in);
 263
 264                         if (phdr.p_type == PT_LOAD)
 265                                 break;
 266                 }
 267
 268                 datasz = phdr.p_filesz;
 269                 memsz = phdr.p_memsz;
 270         }
 271
 272         buf = malloc(datasz);
 273         if (!buf) {
 274                 perror("malloc");
 275                 exit(EXIT_FAILURE);
 276         }
 277
 278         write_header(f_out, entry, datasz, memsz, class);
 279
 280         /* Write out the entire ELF shared object */
 281         rewind(f_in);
 282         rv = fread(buf, datasz, 1, f_in);
 283         if (!rv && ferror(f_in)) {
 284                 fprintf(stderr, "Failed to read all bytes from input\n");
 285                 exit(EXIT_FAILURE);
 286         }
 287
 288         fwrite(buf, datasz, rv, f_out);
 289         free(buf);
 290         fclose(f_out);
 291         fclose(f_in);
 292         return 0;
 293 }