/*
* Copyright (c) 2013-2017, Intel Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Intel Corporation nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "load_elf.h"
#include "intel-pt.h"
#include <stdio.h>
#include <elf.h>
#include <inttypes.h>
#include <errno.h>
#include <string.h>
static int load_section(struct pt_image_section_cache *iscache,
struct pt_image *image, const char *name,
uint64_t offset, uint64_t size, uint64_t vaddr)
{
if (!iscache)
return pt_image_add_file(image, name, offset, size, NULL,
vaddr);
else {
int isid;
isid = pt_iscache_add_file(iscache, name, offset, size, vaddr);
if (isid < 0)
return isid;
return pt_image_add_cached(image, iscache, isid, NULL);
}
}
static int load_elf32(struct pt_image_section_cache *iscache,
struct pt_image *image, FILE *file, uint64_t base,
const char *name, const char *prog, int verbose)
{
Elf32_Ehdr ehdr;
Elf32_Half pidx;
int64_t offset;
size_t count;
int errcode, sections;
errcode = fseek(file, 0, SEEK_SET);
if (errcode) {
fprintf(stderr,
"%s: warning: %s error seeking ELF header: %s.\n",
prog, name, strerror(errno));
return -pte_bad_config;
}
count = fread(&ehdr, sizeof(ehdr), 1, file);
if (count != 1) {
fprintf(stderr,
"%s: warning: %s error reading ELF header: %s.\n",
prog, name, strerror(errno));
return -pte_bad_config;
}
errcode = fseek(file, ehdr.e_phoff, SEEK_SET);
if (errcode) {
fprintf(stderr,
"%s: warning: %s error seeking program header: %s.\n",
prog, name, strerror(errno));
return -pte_bad_config;
}
/* Determine the load offset. */
if (!base)
offset = 0;
else {
uint64_t minaddr;
minaddr = UINT64_MAX;
for (pidx = 0; pidx < ehdr.e_phnum; ++pidx) {
Elf32_Phdr phdr;
count = fread(&phdr, sizeof(phdr), 1, file);
if (count != 1) {
fprintf(stderr,
"%s: warning: %s error reading "
"phdr %u: %s.\n",
prog, name, pidx, strerror(errno));
return -pte_bad_config;
}
if (phdr.p_type != PT_LOAD)
continue;
if (phdr.p_vaddr < minaddr)
minaddr = phdr.p_vaddr;
}
offset = base - minaddr;
}
errcode = fseek(file, ehdr.e_phoff, SEEK_SET);
if (errcode) {
fprintf(stderr,
"%s: warning: %s error seeking program header: %s.\n",
prog, name, strerror(errno));
return -pte_bad_config;
}
for (sections = 0, pidx = 0; pidx < ehdr.e_phnum; ++pidx) {
Elf32_Phdr phdr;
count = fread(&phdr, sizeof(phdr), 1, file);
if (count != 1) {
fprintf(stderr,
"%s: warning: %s error reading phdr %u: %s.\n",
prog, name, pidx, strerror(errno));
return -pte_bad_config;
}
if (phdr.p_type != PT_LOAD)
continue;
if (!phdr.p_filesz)
continue;
errcode = load_section(iscache, image, name, phdr.p_offset,
phdr.p_filesz, phdr.p_vaddr + offset);
if (errcode < 0) {
fprintf(stderr, "%s: warning: %s: failed to create "
"section for phdr %u: %s.\n", prog, name, pidx,
pt_errstr(pt_errcode(errcode)));
continue;
}
sections += 1;
if (verbose) {
printf("%s: phdr %u [%s]", prog, pidx, name);
printf(" offset=0x%" PRIx32, phdr.p_offset);
printf(" size=0x%" PRIx32, phdr.p_filesz);
printf(" vaddr=0x%" PRIx32, phdr.p_vaddr);
printf(".\n");
}
}
if (!sections)
fprintf(stderr,
"%s: warning: %s: did not find any load sections.\n",
prog, name);
return 0;
}
static int load_elf64(struct pt_image_section_cache *iscache,
struct pt_image *image, FILE *file, uint64_t base,
const char *name, const char *prog, int verbose)
{
Elf64_Ehdr ehdr;
Elf64_Half pidx;
int64_t offset;
size_t count;
int errcode, sections;
errcode = fseek(file, 0, SEEK_SET);
if (errcode) {
fprintf(stderr,
"%s: warning: %s error seeking ELF header: %s.\n",
prog, name, strerror(errno));
return -pte_bad_config;
}
count = fread(&ehdr, sizeof(ehdr), 1, file);
if (count != 1) {
fprintf(stderr,
"%s: warning: %s error reading ELF header: %s.\n",
prog, name, strerror(errno));
return -pte_bad_config;
}
errcode = fseek(file, ehdr.e_phoff, SEEK_SET);
if (errcode) {
fprintf(stderr,
"%s: warning: %s error seeking program header: %s.\n",
prog, name, strerror(errno));
return -pte_bad_config;
}
/* Determine the load offset. */
if (!base)
offset = 0;
else {
uint64_t minaddr;
minaddr = UINT64_MAX;
for (pidx = 0; pidx < ehdr.e_phnum; ++pidx) {
Elf64_Phdr phdr;
count = fread(&phdr, sizeof(phdr), 1, file);
if (count != 1) {
fprintf(stderr,
"%s: warning: %s error reading "
"phdr %u: %s.\n",
prog, name, pidx, strerror(errno));
return -pte_bad_config;
}
if (phdr.p_type != PT_LOAD)
continue;
if (phdr.p_vaddr < minaddr)
minaddr = phdr.p_vaddr;
}
offset = base - minaddr;
}
errcode = fseek(file, ehdr.e_phoff, SEEK_SET);
if (errcode) {
fprintf(stderr,
"%s: warning: %s error seeking program header: %s.\n",
prog, name, strerror(errno));
return -pte_bad_config;
}
for (sections = 0, pidx = 0; pidx < ehdr.e_phnum; ++pidx) {
Elf64_Phdr phdr;
count = fread(&phdr, sizeof(phdr), 1, file);
if (count != 1) {
fprintf(stderr,
"%s: warning: %s error reading phdr %u: %s.\n",
prog, name, pidx, strerror(errno));
return -pte_bad_config;
}
if (phdr.p_type != PT_LOAD)
continue;
if (!phdr.p_filesz)
continue;
errcode = load_section(iscache, image, name, phdr.p_offset,
phdr.p_filesz, phdr.p_vaddr + offset);
if (errcode < 0) {
fprintf(stderr, "%s: warning: %s: failed to create "
"section for phdr %u: %s.\n", prog, name, pidx,
pt_errstr(pt_errcode(errcode)));
continue;
}
sections += 1;
if (verbose) {
printf("%s: phdr %u [%s]", prog, pidx, name);
printf(" offset=0x%" PRIx64, phdr.p_offset);
printf(" size=0x%" PRIx64, phdr.p_filesz);
printf(" vaddr=0x%" PRIx64, phdr.p_vaddr);
printf(".\n");
}
}
if (!sections)
fprintf(stderr,
"%s: warning: %s: did not find any load sections.\n",
prog, name);
return 0;
}
int load_elf(struct pt_image_section_cache *iscache, struct pt_image *image,
const char *name, uint64_t base, const char *prog, int verbose)
{
uint8_t e_ident[EI_NIDENT];
FILE *file;
size_t count;
int errcode, idx;
if (!image || !name)
return -pte_invalid;
file = fopen(name, "rb");
if (!file) {
fprintf(stderr, "%s: warning: failed to open %s: %s.\n", prog,
name, strerror(errno));
return -pte_bad_config;
}
count = fread(e_ident, sizeof(e_ident), 1, file);
if (count != 1) {
fprintf(stderr,
"%s: warning: %s failed to read file header: %s.\n",
prog, name, strerror(errno));
errcode = -pte_bad_config;
goto out;
}
for (idx = 0; idx < SELFMAG; ++idx) {
if (e_ident[idx] != ELFMAG[idx]) {
fprintf(stderr,
"%s: warning: ignoring %s: not an ELF file.\n",
prog, name);
errcode = -pte_bad_config;
goto out;
}
}
switch (e_ident[EI_CLASS]) {
default:
fprintf(stderr, "%s: unsupported ELF class: %d\n",
prog, e_ident[EI_CLASS]);
errcode = -pte_bad_config;
break;
case ELFCLASS32:
errcode = load_elf32(iscache, image, file, base, name, prog,
verbose);
break;
case ELFCLASS64:
errcode = load_elf64(iscache, image, file, base, name, prog,
verbose);
break;
}
out:
fclose(file);
return errcode;
}