/* Get the headers from the buffer.
* Return -1 in the event of an error.
* The section headers are optional; if NULL
* is passed in for pshdr they won't be parsed.
* We don't (yet) make payload parsing optional
* because we've never seen a use case.
*/
int
elf_headers(const struct buffer *pinput,
uint32_t arch,
Elf64_Ehdr *ehdr,
Elf64_Phdr **pphdr,
Elf64_Shdr **pshdr)
{
struct parsed_elf pelf;
int flags;
flags = ELF_PARSE_PHDR;
if (pshdr != NULL)
flags |= ELF_PARSE_SHDR;
if (parse_elf(pinput, &pelf, flags))
return -1;
/* Copy out the parsed elf header. */
memcpy(ehdr, &pelf.ehdr, sizeof(*ehdr));
*pphdr = calloc(ehdr->e_phnum, sizeof(Elf64_Phdr));
memcpy(*pphdr, pelf.phdr, ehdr->e_phnum * sizeof(Elf64_Phdr));
if (pshdr != NULL) {
*pshdr = calloc(ehdr->e_shnum, sizeof(Elf64_Shdr));
memcpy(*pshdr, pelf.shdr, ehdr->e_shnum * sizeof(Elf64_Shdr));
}
parsed_elf_destroy(&pelf);
return 0;
}
/* Get the headers from the buffer.
* Return -1 in the event of an error.
* The section headers are optional; if NULL
* is passed in for pshdr they won't be parsed.
* We don't (yet) make payload parsing optional
* because we've never seen a use case.
*/
int
elf_headers(const struct buffer *pinput,
uint32_t arch,
Elf64_Ehdr *ehdr,
Elf64_Phdr **pphdr,
Elf64_Shdr **pshdr)
{
struct parsed_elf pelf;
int flags;
flags = ELF_PARSE_PHDR;
if (pshdr != NULL)
flags |= ELF_PARSE_SHDR;
if (parse_elf(pinput, &pelf, flags))
return -1;
/* Copy out the parsed elf header. */
memcpy(ehdr, &pelf.ehdr, sizeof(*ehdr));
// The tool may work in architecture-independent way.
if (arch != CBFS_ARCHITECTURE_UNKNOWN &&
!((ehdr->e_machine == EM_ARM) && (arch == CBFS_ARCHITECTURE_ARMV7)) &&
!((ehdr->e_machine == EM_386) && (arch == CBFS_ARCHITECTURE_X86))) {
ERROR("The stage file has the wrong architecture\n");
return -1;
}
*pphdr = calloc(ehdr->e_phnum, sizeof(Elf64_Phdr));
memcpy(*pphdr, pelf.phdr, ehdr->e_phnum * sizeof(Elf64_Phdr));
if (pshdr != NULL) {
*pshdr = calloc(ehdr->e_shnum, sizeof(Elf64_Shdr));
memcpy(*pshdr, pelf.shdr, ehdr->e_shnum * sizeof(Elf64_Shdr));
}
parsed_elf_destroy(&pelf);
return 0;
}
void rmodule_cleanup(struct rmod_context *ctx)
{
free(ctx->emitted_relocs);
parsed_elf_destroy(&ctx->pelf);
}
int parse_elf(const struct buffer *pinput, struct parsed_elf *pelf, int flags)
{
struct xdr *xdr = &xdr_le;
int bit64 = 0;
struct buffer input;
Elf64_Ehdr *ehdr;
/* Zero out the parsed elf structure. */
memset(pelf, 0, sizeof(*pelf));
if (!iself(buffer_get(pinput))) {
ERROR("The stage file is not in ELF format!\n");
return -1;
}
buffer_clone(&input, pinput);
ehdr = &pelf->ehdr;
elf_eident(&input, ehdr);
bit64 = ehdr->e_ident[EI_CLASS] == ELFCLASS64;
/* Assume LE unless we are sure otherwise.
* We're not going to take on the task of
* fully validating the ELF file. That way
* lies madness.
*/
if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB)
xdr = &xdr_be;
elf_ehdr(&input, ehdr, xdr, bit64);
/* Relocation processing requires section header parsing. */
if (flags & ELF_PARSE_RELOC)
flags |= ELF_PARSE_SHDR;
/* String table processing requires section header parsing. */
if (flags & ELF_PARSE_STRTAB)
flags |= ELF_PARSE_SHDR;
/* Symbole table processing requires section header parsing. */
if (flags & ELF_PARSE_SYMTAB)
flags |= ELF_PARSE_SHDR;
if ((flags & ELF_PARSE_PHDR) && phdr_read(pinput, pelf, xdr, bit64))
goto fail;
if ((flags & ELF_PARSE_SHDR) && shdr_read(pinput, pelf, xdr, bit64))
goto fail;
if ((flags & ELF_PARSE_RELOC) && reloc_read(pinput, pelf, xdr, bit64))
goto fail;
if ((flags & ELF_PARSE_STRTAB) && strtab_read(pinput, pelf))
goto fail;
if ((flags & ELF_PARSE_SYMTAB) && symtab_read(pinput, pelf, xdr, bit64))
goto fail;
return 0;
fail:
parsed_elf_destroy(pelf);
return -1;
}
/* returns size of result, or -1 if error.
* Note that, with the new code, this function
* works for all elf files, not just the restricted set.
*/
int parse_elf_to_stage(const struct buffer *input, struct buffer *output,
enum comp_algo algo, uint32_t *location,
const char *ignore_section)
{
struct parsed_elf pelf;
Elf64_Phdr *phdr;
Elf64_Ehdr *ehdr;
Elf64_Shdr *shdr_ignored;
Elf64_Addr virt_to_phys;
char *buffer;
struct buffer outheader;
int ret = -1;
int headers;
int i, outlen;
uint32_t data_start, data_end, mem_end;
comp_func_ptr compress = compression_function(algo);
if (!compress)
return -1;
DEBUG("start: parse_elf_to_stage(location=0x%x)\n", *location);
int flags = ELF_PARSE_PHDR | ELF_PARSE_SHDR | ELF_PARSE_STRTAB;
if (parse_elf(input, &pelf, flags)) {
ERROR("Couldn't parse ELF\n");
return -1;
}
ehdr = &pelf.ehdr;
phdr = &pelf.phdr[0];
/* Find the section header corresponding to ignored-section */
shdr_ignored = find_ignored_section_header(&pelf, ignore_section);
if (ignore_section && (shdr_ignored == NULL))
WARN("Ignore section not found\n");
headers = ehdr->e_phnum;
/* Ignore the program header containing ignored section */
for (i = 0; i < headers; i++) {
if (is_phdr_ignored(&phdr[i], shdr_ignored))
phdr[i].p_type = PT_NULL;
}
data_start = ~0;
data_end = 0;
mem_end = 0;
virt_to_phys = 0;
for (i = 0; i < headers; i++) {
unsigned int start, mend, rend;
if (phdr[i].p_type != PT_LOAD)
continue;
/* Empty segments are never interesting */
if (phdr[i].p_memsz == 0)
continue;
/* BSS */
start = phdr[i].p_paddr;
mend = start + phdr[i].p_memsz;
rend = start + phdr[i].p_filesz;
if (start < data_start)
data_start = start;
if (rend > data_end)
data_end = rend;
if (mend > mem_end)
mem_end = mend;
if (virt_to_phys == 0)
virt_to_phys = phdr[i].p_paddr - phdr[i].p_vaddr;
}
if (data_start < *location) {
data_start = *location;
}
if (data_end <= data_start) {
ERROR("data ends (%08lx) before it starts (%08lx). Make sure "
"the ELF file is correct and resides in ROM space.\n",
(unsigned long)data_end, (unsigned long)data_start);
exit(1);
}
/* allocate an intermediate buffer for the data */
buffer = calloc(data_end - data_start, 1);
if (buffer == NULL) {
ERROR("Unable to allocate memory: %m\n");
goto err;
}
/* Copy the file data into the buffer */
for (i = 0; i < headers; i++) {
unsigned int l_start, l_offset = 0;
if (phdr[i].p_type != PT_LOAD)
continue;
if (phdr[i].p_memsz == 0)
continue;
l_start = phdr[i].p_paddr;
if (l_start < *location) {
l_offset = *location - l_start;
l_start = *location;
}
/* A legal ELF file can have a program header with
* non-zero length but zero-length file size and a
* non-zero offset which, added together, are > than
* input->size (i.e. the total file size). So we need
* to not even test in the case that p_filesz is zero.
*/
if (! phdr[i].p_filesz)
continue;
if (input->size < (phdr[i].p_offset + phdr[i].p_filesz)){
ERROR("Underflow copying out the segment."
"File has %zu bytes left, segment end is %zu\n",
input->size, (size_t)(phdr[i].p_offset + phdr[i].p_filesz));
free(buffer);
goto err;
}
memcpy(buffer + (l_start - data_start),
&input->data[phdr[i].p_offset + l_offset],
phdr[i].p_filesz - l_offset);
}
/* Now make the output buffer */
if (buffer_create(output, sizeof(struct cbfs_stage) + data_end - data_start,
input->name) != 0) {
ERROR("Unable to allocate memory: %m\n");
free(buffer);
goto err;
}
memset(output->data, 0, output->size);
/* Compress the data, at which point we'll know information
* to fill out the header. This seems backward but it works because
* - the output header is a known size (not always true in many xdr's)
* - we do need to know the compressed output size first
* If compression fails or makes the data bigger, we'll warn about it
* and use the original data.
*/
if (compress(buffer, data_end - data_start,
(output->data + sizeof(struct cbfs_stage)),
&outlen) < 0 || (unsigned)outlen > data_end - data_start) {
WARN("Compression failed or would make the data bigger "
"- disabled.\n");
memcpy(output->data + sizeof(struct cbfs_stage),
buffer, data_end - data_start);
algo = CBFS_COMPRESS_NONE;
}
free(buffer);
/* Set up for output marshaling. */
outheader.data = output->data;
outheader.size = 0;
/* Coreboot expects entry point to be physical address. Thus, adjust the
* entry point accordingly.
*/
fill_cbfs_stage(&outheader, algo, ehdr->e_entry + virt_to_phys,
data_start, outlen, mem_end - data_start);
if (*location)
*location -= sizeof(struct cbfs_stage);
output->size = sizeof(struct cbfs_stage) + outlen;
ret = 0;
err:
parsed_elf_destroy(&pelf);
return ret;
}
