WebSVN – HelenOS – Diff – /branches/dynload/uspace/srv/loader/elf_load.c


/*
 * Copyright (c) 2006 Sergey Bondari
 * Copyright (c) 2006 Jakub Jermar
 * Copyright (c) 2008 Jiri Svoboda
 * All rights reserved.
 *
 * 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.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 */
 
/** @addtogroup generic
 * @{
 */
 
/**
 * @file
 * @brief   Userspace ELF loader.
 *
 * This module allows loading ELF binaries (both executables and
 * shared objects) from VFS. The current implementation allocates
 * anonymous memory, fills it with segment data and then adjusts
 * the memory areas' flags to the final value. In the future,
 * the segments will be mapped directly from the file.
 */
 
#include <stdio.h>
#include <sys/types.h>
#include <align.h>
#include <assert.h>
#include <as.h>
#include <unistd.h>
#include <fcntl.h>
#include <smc.h>
#include <loader/pcb.h>
 
#include "elf.h"
#include "elf_load.h"
#include "arch.h"
 
static char *error_codes[] = {
    "no error",
    "invalid image",
    "address space error",
    "incompatible image",
    "unsupported image type",
    "irrecoverable error"
};
 
static unsigned int elf_load(elf_ld_t *elf, size_t so_bias);
static int segment_header(elf_ld_t *elf, elf_segment_header_t *entry);
static int section_header(elf_ld_t *elf, elf_section_header_t *entry);
static int load_segment(elf_ld_t *elf, elf_segment_header_t *entry);
 
/** Read until the buffer is read in its entirety. */
static int my_read(int fd, char *buf, size_t len)
{
    int cnt = 0;
    do {
        buf += cnt;
        len -= cnt;
        cnt = read(fd, buf, len);
    } while ((cnt > 0) && ((len - cnt) > 0));
 
    return cnt;
}
 
/** Load ELF binary from a file.
 *
 * Load an ELF binary from the specified file. If the file is
 * an executable program, it is loaded unbiased. If it is a shared
 * object, it is loaded with the bias @a so_bias. Some information
 * extracted from the binary is stored in a elf_info_t structure
 * pointed to by @a info.
 *
 * @param file_name Path to the ELF file.
 * @param so_bias   Bias to use if the file is a shared object.
 * @param info      Pointer to a structure for storing information
 *          extracted from the binary.
 *
 * @return EOK on success or negative error code.
 */
int elf_load_file(char *file_name, size_t so_bias, eld_flags_t flags,
    elf_info_t *info)
{
    elf_ld_t elf;
 
    int fd;
    int rc;
 
//  printf("open and read '%s'...\n", file_name);
 
    fd = open(file_name, O_RDONLY);
    if (fd < 0) {
        printf("failed opening file (error %d)\n", fd);
        return -1;
    }
 
    elf.fd = fd;
    elf.info = info;
    elf.flags = flags;
 
    rc = elf_load(&elf, so_bias);
 
    close(fd);
 
    return rc;
}
 
/** Run an ELF executable.
 *
 * Transfers control to the entry point of an ELF executable loaded
 * earlier with elf_load_file(). This function does not return.
 *
 * @param info  Info structure filled earlier by elf_load_file()
 */
void elf_run(elf_info_t *info, pcb_t *pcb)
{
    program_run(info->entry, pcb);
 
    /* not reached */
}
 
/** Create the program control block (PCB).
 *
 * Fills the program control block @a pcb with information from
 * @a info.
 *
 * @param info  Program info structure
 * @return EOK on success or negative error code
 */
void elf_create_pcb(elf_info_t *info, pcb_t *pcb)
{
    pcb->entry = info->entry;
    pcb->dynamic = info->dynamic;
}
 
 
/** Load an ELF binary.
 *
 * The @a elf structure contains the loader state, including
 * an open file, from which the binary will be loaded,
 * a pointer to the @c info structure etc.
 *
 * @param elf       Pointer to loader state buffer.
 * @param so_bias   Bias to use if the file is a shared object.
 * @return EE_OK on success or EE_xx error code.
 */
static unsigned int elf_load(elf_ld_t *elf, size_t so_bias)
{
    elf_header_t header_buf;
    elf_header_t *header = &header_buf;
    int i, rc;
 
    rc = my_read(elf->fd, header, sizeof(elf_header_t));
    if (rc < 0) {
        printf("read error\n");
        return EE_INVALID;
    }
 
    elf->header = header;
 
//  printf("ELF-load:");
    /* Identify ELF */
    if (header->e_ident[EI_MAG0] != ELFMAG0 ||
        header->e_ident[EI_MAG1] != ELFMAG1 ||
        header->e_ident[EI_MAG2] != ELFMAG2 ||
        header->e_ident[EI_MAG3] != ELFMAG3) {
        printf("invalid header\n");
        return EE_INVALID;
    }
   
    /* Identify ELF compatibility */
    if (header->e_ident[EI_DATA] != ELF_DATA_ENCODING ||
        header->e_machine != ELF_MACHINE ||
        header->e_ident[EI_VERSION] != EV_CURRENT ||
        header->e_version != EV_CURRENT ||
        header->e_ident[EI_CLASS] != ELF_CLASS) {
        printf("incompatible data/version/class\n");
        return EE_INCOMPATIBLE;
    }
 
    if (header->e_phentsize != sizeof(elf_segment_header_t)) {
        printf("e_phentsize:%d != %d\n", header->e_phentsize,
            sizeof(elf_segment_header_t));
        return EE_INCOMPATIBLE;
    }
 
    if (header->e_shentsize != sizeof(elf_section_header_t)) {
        printf("e_shentsize:%d != %d\n", header->e_shentsize,
            sizeof(elf_section_header_t));
        return EE_INCOMPATIBLE;
    }
 
    /* Check if the object type is supported. */
    if (header->e_type != ET_EXEC && header->e_type != ET_DYN) {
        printf("Object type %d is not supported\n", header->e_type);
        return EE_UNSUPPORTED;
    }
 
    /* Shared objects can be loaded with a bias */
//  printf("Object type: %d\n", header->e_type);
    if (header->e_type == ET_DYN)
        elf->bias = so_bias;
    else
        elf->bias = 0;
 
//  printf("Bias set to 0x%x\n", elf->bias);
    elf->info->interp = NULL;
    elf->info->dynamic = NULL;
 
//  printf("parse segments\n");
 
    /* Walk through all segment headers and process them. */
    for (i = 0; i < header->e_phnum; i++) {
        elf_segment_header_t segment_hdr;
 
        /* Seek to start of segment header */
        lseek(elf->fd, header->e_phoff
                + i * sizeof(elf_segment_header_t), SEEK_SET);
 
        rc = my_read(elf->fd, &segment_hdr,
            sizeof(elf_segment_header_t));
        if (rc < 0) {
            printf("read error\n");
            return EE_INVALID;
        }
 
        rc = segment_header(elf, &segment_hdr);
        if (rc != EE_OK)
            return rc;
    }
 
//  printf("parse sections\n");
 
    /* Inspect all section headers and proccess them. */
    for (i = 0; i < header->e_shnum; i++) {
        elf_section_header_t section_hdr;
 
        /* Seek to start of section header */
        lseek(elf->fd, header->e_shoff
            + i * sizeof(elf_section_header_t), SEEK_SET);
 
        rc = my_read(elf->fd, &section_hdr,
            sizeof(elf_section_header_t));
        if (rc < 0) {
            printf("read error\n");
            return EE_INVALID;
        }
 
        rc = section_header(elf, &section_hdr);
        if (rc != EE_OK)
            return rc;
    }
 
    elf->info->entry =
        (entry_point_t)((uint8_t *)header->e_entry + elf->bias);
 
//  printf("done\n");
 
    return EE_OK;
}
 
/** Print error message according to error code.
 *
 * @param rc Return code returned by elf_load().
 *
 * @return NULL terminated description of error.
 */
char *elf_error(unsigned int rc)
{
    assert(rc < sizeof(error_codes) / sizeof(char *));
 
    return error_codes[rc];
}
 
/** Process segment header.
 *
 * @param entry Segment header.
 *
 * @return EE_OK on success, error code otherwise.
 */
static int segment_header(elf_ld_t *elf, elf_segment_header_t *entry)
{
    switch (entry->p_type) {
    case PT_NULL:
    case PT_PHDR:
        break;
    case PT_LOAD:
        return load_segment(elf, entry);
        break;
    case PT_INTERP:
        /* Assume silently interp == "/lib/rtld" */
        elf->info->interp = "/lib/rtld";
        break;
    case PT_DYNAMIC:
    case PT_SHLIB:
    case PT_NOTE:
    case PT_LOPROC:
    case PT_HIPROC:
    default:
        printf("segment p_type %d unknown\n", entry->p_type);
        return EE_UNSUPPORTED;
        break;
    }
    return EE_OK;
}
 
/** Load segment described by program header entry.
 *
 * @param elf   Loader state.
 * @param entry Program header entry describing segment to be loaded.
 *
 * @return EE_OK on success, error code otherwise.
 */
int load_segment(elf_ld_t *elf, elf_segment_header_t *entry)
{
    void *a;
    int flags = 0;
    uintptr_t bias;
    uintptr_t base;
    size_t mem_sz;
    int rc;
 
//  printf("load segment at addr 0x%x, size 0x%x\n", entry->p_vaddr,
//      entry->p_memsz);
   
    bias = elf->bias;
 
    if (entry->p_align > 1) {
        if ((entry->p_offset % entry->p_align) !=
            (entry->p_vaddr % entry->p_align)) {
            printf("align check 1 failed offset%%align=%d, "
                "vaddr%%align=%d\n",
                entry->p_offset % entry->p_align,
                entry->p_vaddr % entry->p_align
            );
            return EE_INVALID;
        }
    }
 
    /* Final flags that will be set for the memory area */
 
    if (entry->p_flags & PF_X)
        flags |= AS_AREA_EXEC;
    if (entry->p_flags & PF_W)
        flags |= AS_AREA_WRITE;
    if (entry->p_flags & PF_R)
        flags |= AS_AREA_READ;
    flags |= AS_AREA_CACHEABLE;
   
    base = ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE);
    mem_sz = entry->p_memsz + (entry->p_vaddr - base);
 
//  printf("map to p_vaddr=0x%x-0x%x...\n", entry->p_vaddr + bias,
//  entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));
 
    /*
     * For the course of loading, the area needs to be readable
     * and writeable.
     */
    a = as_area_create((uint8_t *)base + bias, mem_sz,
        AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
    if (a == (void *)(-1)) {
        printf("memory mapping failed\n");
        return EE_MEMORY;
    }
 
//  printf("as_area_create(0x%lx, 0x%x, %d) -> 0x%lx\n",
//      entry->p_vaddr+bias, entry->p_memsz, flags, (uintptr_t)a);
 
    /*
     * Load segment data
     */
//  printf("seek to %d\n", entry->p_offset);
    rc = lseek(elf->fd, entry->p_offset, SEEK_SET);
    if (rc < 0) {
        printf("seek error\n");
        return EE_INVALID;
    }
 
//  printf("read 0x%x bytes to address 0x%x\n", entry->p_filesz, entry->p_vaddr+bias);
/*  rc = read(fd, (void *)(entry->p_vaddr + bias), entry->p_filesz);
    if (rc < 0) { printf("read error\n"); return EE_INVALID; }*/
 
    /* Long reads are not possible yet. Load segment picewise */
 
    unsigned left, now;
    uint8_t *dp;
 
    left = entry->p_filesz;
    dp = (uint8_t *)(entry->p_vaddr + bias);
 
    while (left > 0) {
        now = 16384;
        if (now > left) now = left;
 
//      printf("read %d...", now);
        rc = my_read(elf->fd, dp, now);
//      printf("->%d\n", rc);
 
        if (rc < 0) {
            printf("read error\n");
            return EE_INVALID;
        }
 
        left -= now;
        dp += now;
    }
 
    /*
     * The caller wants to modify the segments first. He will then
     * need to set the right access mode and ensure SMC coherence.
     */
    if ((elf->flags & ELDF_RW) != 0) return EE_OK;
 
//  printf("set area flags to %d\n", flags);
    rc = as_area_change_flags((uint8_t *)entry->p_vaddr + bias, flags);
    if (rc != 0) {
        printf("failed to set memory area flags\n");
        return EE_MEMORY;
    }
 
    if (flags & AS_AREA_EXEC) {
        /* Enforce SMC coherence for the segment */
        if (smc_coherence(entry->p_vaddr + bias, entry->p_filesz))
            return EE_MEMORY;
    }
 
    return EE_OK;
}
 
/** Process section header.
 *
 * @param elf   Loader state.
 * @param entry Segment header.
 *
 * @return EE_OK on success, error code otherwise.
 */
static int section_header(elf_ld_t *elf, elf_section_header_t *entry)
{
    switch (entry->sh_type) {
    case SHT_PROGBITS:
        if (entry->sh_flags & SHF_TLS) {
            /* .tdata */
        }
        break;
    case SHT_NOBITS:
        if (entry->sh_flags & SHF_TLS) {
            /* .tbss */
        }
        break;
    case SHT_DYNAMIC:
        /* Record pointer to dynamic section into info structure */
        elf->info->dynamic =
            (void *)((uint8_t *)entry->sh_addr + elf->bias);
        printf("dynamic section found at 0x%x\n",
            (uintptr_t)elf->info->dynamic);
        break;
    default:
        break;
    }
   
    return EE_OK;
}
 
/** @}
 */
 

Rev 3552	Rev 3562
1	/*	1	/*
2	* Copyright (c) 2006 Sergey Bondari	2	* Copyright (c) 2006 Sergey Bondari
3	* Copyright (c) 2006 Jakub Jermar	3	* Copyright (c) 2006 Jakub Jermar
4	* Copyright (c) 2008 Jiri Svoboda	4	* Copyright (c) 2008 Jiri Svoboda
5	* All rights reserved.	5	* All rights reserved.
6	*	6	*
7	* Redistribution and use in source and binary forms, with or without	7	* Redistribution and use in source and binary forms, with or without
8	* modification, are permitted provided that the following conditions	8	* modification, are permitted provided that the following conditions
9	* are met:	9	* are met:
10	*	10	*
11	* - Redistributions of source code must retain the above copyright	11	* - Redistributions of source code must retain the above copyright
12	* notice, this list of conditions and the following disclaimer.	12	* notice, this list of conditions and the following disclaimer.
13	* - Redistributions in binary form must reproduce the above copyright	13	* - Redistributions in binary form must reproduce the above copyright
14	* notice, this list of conditions and the following disclaimer in the	14	* notice, this list of conditions and the following disclaimer in the
15	* documentation and/or other materials provided with the distribution.	15	* documentation and/or other materials provided with the distribution.
16	* - The name of the author may not be used to endorse or promote products	16	* - The name of the author may not be used to endorse or promote products
17	* derived from this software without specific prior written permission.	17	* derived from this software without specific prior written permission.
18	*	18	*
19	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	19	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	20	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	21	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	22	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	23	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	24	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	25	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	26	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	28	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29	*/	29	*/
30		30
31	/** @addtogroup generic	31	/** @addtogroup generic
32	* @{	32	* @{
33	*/	33	*/
34		34
35	/**	35	/**
36	* @file	36	* @file
37	* @brief Userspace ELF loader.	37	* @brief Userspace ELF loader.
38	*	38	*
39	* This module allows loading ELF binaries (both executables and	39	* This module allows loading ELF binaries (both executables and
40	* shared objects) from VFS. The current implementation allocates	40	* shared objects) from VFS. The current implementation allocates
41	* anonymous memory, fills it with segment data and then adjusts	41	* anonymous memory, fills it with segment data and then adjusts
42	* the memory areas' flags to the final value. In the future,	42	* the memory areas' flags to the final value. In the future,
43	* the segments will be mapped directly from the file.	43	* the segments will be mapped directly from the file.
44	*/	44	*/
45		45
46	#include <stdio.h>	46	#include <stdio.h>
47	#include <sys/types.h>	47	#include <sys/types.h>
48	#include <align.h>	48	#include <align.h>
49	#include <assert.h>	49	#include <assert.h>
50	#include <as.h>	50	#include <as.h>
51	#include <unistd.h>	51	#include <unistd.h>
52	#include <fcntl.h>	52	#include <fcntl.h>
53	#include <smc.h>	53	#include <smc.h>
54	#include <loader/pcb.h>	54	#include <loader/pcb.h>
55		55
56	#include "elf.h"	56	#include "elf.h"
57	#include "elf_load.h"	57	#include "elf_load.h"
58	#include "arch.h"	58	#include "arch.h"
59		59
60	static char *error_codes[] = {	60	static char *error_codes[] = {
61	"no error",	61	"no error",
62	"invalid image",	62	"invalid image",
63	"address space error",	63	"address space error",
64	"incompatible image",	64	"incompatible image",
65	"unsupported image type",	65	"unsupported image type",
66	"irrecoverable error"	66	"irrecoverable error"
67	};	67	};
68		68
69	static unsigned int elf_load(elf_ld_t *elf, size_t so_bias);	69	static unsigned int elf_load(elf_ld_t *elf, size_t so_bias);
70	static int segment_header(elf_ld_t elf, elf_segment_header_t entry);	70	static int segment_header(elf_ld_t elf, elf_segment_header_t entry);
71	static int section_header(elf_ld_t elf, elf_section_header_t entry);	71	static int section_header(elf_ld_t elf, elf_section_header_t entry);
72	static int load_segment(elf_ld_t elf, elf_segment_header_t entry);	72	static int load_segment(elf_ld_t elf, elf_segment_header_t entry);
73		73
74	/** Read until the buffer is read in its entirety. */	74	/** Read until the buffer is read in its entirety. */
75	static int my_read(int fd, char *buf, size_t len)	75	static int my_read(int fd, char *buf, size_t len)
76	{	76	{
77	int cnt = 0;	77	int cnt = 0;
78	do {	78	do {
79	buf += cnt;	79	buf += cnt;
80	len -= cnt;	80	len -= cnt;
81	cnt = read(fd, buf, len);	81	cnt = read(fd, buf, len);
82	} while ((cnt > 0) && ((len - cnt) > 0));	82	} while ((cnt > 0) && ((len - cnt) > 0));
83		83
84	return cnt;	84	return cnt;
85	}	85	}
86		86
87	/** Load ELF binary from a file.	87	/** Load ELF binary from a file.
88	*	88	*
89	* Load an ELF binary from the specified file. If the file is	89	* Load an ELF binary from the specified file. If the file is
90	* an executable program, it is loaded unbiased. If it is a shared	90	* an executable program, it is loaded unbiased. If it is a shared
91	* object, it is loaded with the bias @a so_bias. Some information	91	* object, it is loaded with the bias @a so_bias. Some information
92	* extracted from the binary is stored in a elf_info_t structure	92	* extracted from the binary is stored in a elf_info_t structure
93	* pointed to by @a info.	93	* pointed to by @a info.
94	*	94	*
95	* @param file_name Path to the ELF file.	95	* @param file_name Path to the ELF file.
96	* @param so_bias Bias to use if the file is a shared object.	96	* @param so_bias Bias to use if the file is a shared object.
97	* @param info Pointer to a structure for storing information	97	* @param info Pointer to a structure for storing information
98	* extracted from the binary.	98	* extracted from the binary.
99	*	99	*
100	* @return EOK on success or negative error code.	100	* @return EOK on success or negative error code.
101	*/	101	*/
102	int elf_load_file(char *file_name, size_t so_bias, eld_flags_t flags,	102	int elf_load_file(char *file_name, size_t so_bias, eld_flags_t flags,
103	elf_info_t *info)	103	elf_info_t *info)
104	{	104	{
105	elf_ld_t elf;	105	elf_ld_t elf;
106		106
107	int fd;	107	int fd;
108	int rc;	108	int rc;
109		109
110	// printf("open and read '%s'...\n", file_name);	110	// printf("open and read '%s'...\n", file_name);
111		111
112	fd = open(file_name, O_RDONLY);	112	fd = open(file_name, O_RDONLY);
113	if (fd < 0) {	113	if (fd < 0) {
114	printf("failed opening file (error %d)\n", fd);	114	printf("failed opening file (error %d)\n", fd);
115	return -1;	115	return -1;
116	}	116	}
117		117
118	elf.fd = fd;	118	elf.fd = fd;
119	elf.info = info;	119	elf.info = info;
120	elf.flags = flags;	120	elf.flags = flags;
121		121
122	rc = elf_load(&elf, so_bias);	122	rc = elf_load(&elf, so_bias);
123		123
124	close(fd);	124	close(fd);
125		125
126	return rc;	126	return rc;
127	}	127	}
128		128
129	/** Run an ELF executable.	129	/** Run an ELF executable.
130	*	130	*
131	* Transfers control to the entry point of an ELF executable loaded	131	* Transfers control to the entry point of an ELF executable loaded
132	* earlier with elf_load_file(). This function does not return.	132	* earlier with elf_load_file(). This function does not return.
133	*	133	*
134	* @param info Info structure filled earlier by elf_load_file()	134	* @param info Info structure filled earlier by elf_load_file()
135	*/	135	*/
136	void elf_run(elf_info_t info, pcb_t pcb)	136	void elf_run(elf_info_t info, pcb_t pcb)
137	{	137	{
138	program_run(info->entry, pcb);	138	program_run(info->entry, pcb);
139		139
140	/* not reached */	140	/* not reached */
141	}	141	}
142		142
143	/** Create the program control block (PCB).	143	/** Create the program control block (PCB).
144	*	144	*
145	* Fills the program control block @a pcb with information from	145	* Fills the program control block @a pcb with information from
146	* @a info.	146	* @a info.
147	*	147	*
148	* @param info Program info structure	148	* @param info Program info structure
149	* @return EOK on success or negative error code	149	* @return EOK on success or negative error code
150	*/	150	*/
151	void elf_create_pcb(elf_info_t info, pcb_t pcb)	151	void elf_create_pcb(elf_info_t info, pcb_t pcb)
152	{	152	{
153	pcb->entry = info->entry;	153	pcb->entry = info->entry;
154	pcb->dynamic = info->dynamic;	154	pcb->dynamic = info->dynamic;
155	}	155	}
156		156
157		157
158	/** Load an ELF binary.	158	/** Load an ELF binary.
159	*	159	*
160	* The @a elf structure contains the loader state, including	160	* The @a elf structure contains the loader state, including
161	* an open file, from which the binary will be loaded,	161	* an open file, from which the binary will be loaded,
162	* a pointer to the @c info structure etc.	162	* a pointer to the @c info structure etc.
163	*	163	*
164	* @param elf Pointer to loader state buffer.	164	* @param elf Pointer to loader state buffer.
165	* @param so_bias Bias to use if the file is a shared object.	165	* @param so_bias Bias to use if the file is a shared object.
166	* @return EE_OK on success or EE_xx error code.	166	* @return EE_OK on success or EE_xx error code.
167	*/	167	*/
168	static unsigned int elf_load(elf_ld_t *elf, size_t so_bias)	168	static unsigned int elf_load(elf_ld_t *elf, size_t so_bias)
169	{	169	{
170	elf_header_t header_buf;	170	elf_header_t header_buf;
171	elf_header_t *header = &header_buf;	171	elf_header_t *header = &header_buf;
172	int i, rc;	172	int i, rc;
173		173
174	rc = my_read(elf->fd, header, sizeof(elf_header_t));	174	rc = my_read(elf->fd, header, sizeof(elf_header_t));
175	if (rc < 0) {	175	if (rc < 0) {
176	printf("read error\n");	176	printf("read error\n");
177	return EE_INVALID;	177	return EE_INVALID;
178	}	178	}
179		179
180	elf->header = header;	180	elf->header = header;
181		181
182	// printf("ELF-load:");	182	// printf("ELF-load:");
183	/* Identify ELF */	183	/* Identify ELF */
184	if (header->e_ident[EI_MAG0] != ELFMAG0 \|\|	184	if (header->e_ident[EI_MAG0] != ELFMAG0 \|\|
185	header->e_ident[EI_MAG1] != ELFMAG1 \|\|	185	header->e_ident[EI_MAG1] != ELFMAG1 \|\|
186	header->e_ident[EI_MAG2] != ELFMAG2 \|\|	186	header->e_ident[EI_MAG2] != ELFMAG2 \|\|
187	header->e_ident[EI_MAG3] != ELFMAG3) {	187	header->e_ident[EI_MAG3] != ELFMAG3) {
188	printf("invalid header\n");	188	printf("invalid header\n");
189	return EE_INVALID;	189	return EE_INVALID;
190	}	190	}
191		191
192	/* Identify ELF compatibility */	192	/* Identify ELF compatibility */
193	if (header->e_ident[EI_DATA] != ELF_DATA_ENCODING \|\|	193	if (header->e_ident[EI_DATA] != ELF_DATA_ENCODING \|\|
194	header->e_machine != ELF_MACHINE \|\|	194	header->e_machine != ELF_MACHINE \|\|
195	header->e_ident[EI_VERSION] != EV_CURRENT \|\|	195	header->e_ident[EI_VERSION] != EV_CURRENT \|\|
196	header->e_version != EV_CURRENT \|\|	196	header->e_version != EV_CURRENT \|\|
197	header->e_ident[EI_CLASS] != ELF_CLASS) {	197	header->e_ident[EI_CLASS] != ELF_CLASS) {
198	printf("incompatible data/version/class\n");	198	printf("incompatible data/version/class\n");
199	return EE_INCOMPATIBLE;	199	return EE_INCOMPATIBLE;
200	}	200	}
201		201
202	if (header->e_phentsize != sizeof(elf_segment_header_t)) {	202	if (header->e_phentsize != sizeof(elf_segment_header_t)) {
203	printf("e_phentsize:%d != %d\n", header->e_phentsize,	203	printf("e_phentsize:%d != %d\n", header->e_phentsize,
204	sizeof(elf_segment_header_t));	204	sizeof(elf_segment_header_t));
205	return EE_INCOMPATIBLE;	205	return EE_INCOMPATIBLE;
206	}	206	}
207		207
208	if (header->e_shentsize != sizeof(elf_section_header_t)) {	208	if (header->e_shentsize != sizeof(elf_section_header_t)) {
209	printf("e_shentsize:%d != %d\n", header->e_shentsize,	209	printf("e_shentsize:%d != %d\n", header->e_shentsize,
210	sizeof(elf_section_header_t));	210	sizeof(elf_section_header_t));
211	return EE_INCOMPATIBLE;	211	return EE_INCOMPATIBLE;
212	}	212	}
213		213
214	/* Check if the object type is supported. */	214	/* Check if the object type is supported. */
215	if (header->e_type != ET_EXEC && header->e_type != ET_DYN) {	215	if (header->e_type != ET_EXEC && header->e_type != ET_DYN) {
216	printf("Object type %d is not supported\n", header->e_type);	216	printf("Object type %d is not supported\n", header->e_type);
217	return EE_UNSUPPORTED;	217	return EE_UNSUPPORTED;
218	}	218	}
219		219
220	/* Shared objects can be loaded with a bias */	220	/* Shared objects can be loaded with a bias */
221	// printf("Object type: %d\n", header->e_type);	221	// printf("Object type: %d\n", header->e_type);
222	if (header->e_type == ET_DYN)	222	if (header->e_type == ET_DYN)
223	elf->bias = so_bias;	223	elf->bias = so_bias;
224	else	224	else
225	elf->bias = 0;	225	elf->bias = 0;
226		226
227	// printf("Bias set to 0x%x\n", elf->bias);	227	// printf("Bias set to 0x%x\n", elf->bias);
228	elf->info->interp = NULL;	228	elf->info->interp = NULL;
229	elf->info->dynamic = NULL;	229	elf->info->dynamic = NULL;
230		230
231	// printf("parse segments\n");	231	// printf("parse segments\n");
232		232
233	/* Walk through all segment headers and process them. */	233	/* Walk through all segment headers and process them. */
234	for (i = 0; i < header->e_phnum; i++) {	234	for (i = 0; i < header->e_phnum; i++) {
235	elf_segment_header_t segment_hdr;	235	elf_segment_header_t segment_hdr;
236		236
237	/* Seek to start of segment header */	237	/* Seek to start of segment header */
238	lseek(elf->fd, header->e_phoff	238	lseek(elf->fd, header->e_phoff
239	+ i * sizeof(elf_segment_header_t), SEEK_SET);	239	+ i * sizeof(elf_segment_header_t), SEEK_SET);
240		240
241	rc = my_read(elf->fd, &segment_hdr,	241	rc = my_read(elf->fd, &segment_hdr,
242	sizeof(elf_segment_header_t));	242	sizeof(elf_segment_header_t));
243	if (rc < 0) {	243	if (rc < 0) {
244	printf("read error\n");	244	printf("read error\n");
245	return EE_INVALID;	245	return EE_INVALID;
246	}	246	}
247		247
248	rc = segment_header(elf, &segment_hdr);	248	rc = segment_header(elf, &segment_hdr);
249	if (rc != EE_OK)	249	if (rc != EE_OK)
250	return rc;	250	return rc;
251	}	251	}
252		252
253	// printf("parse sections\n");	253	// printf("parse sections\n");
254		254
255	/* Inspect all section headers and proccess them. */	255	/* Inspect all section headers and proccess them. */
256	for (i = 0; i < header->e_shnum; i++) {	256	for (i = 0; i < header->e_shnum; i++) {
257	elf_section_header_t section_hdr;	257	elf_section_header_t section_hdr;
258		258
259	/* Seek to start of section header */	259	/* Seek to start of section header */
260	lseek(elf->fd, header->e_shoff	260	lseek(elf->fd, header->e_shoff
261	+ i * sizeof(elf_section_header_t), SEEK_SET);	261	+ i * sizeof(elf_section_header_t), SEEK_SET);
262		262
263	rc = my_read(elf->fd, &section_hdr,	263	rc = my_read(elf->fd, &section_hdr,
264	sizeof(elf_section_header_t));	264	sizeof(elf_section_header_t));
265	if (rc < 0) {	265	if (rc < 0) {
266	printf("read error\n");	266	printf("read error\n");
267	return EE_INVALID;	267	return EE_INVALID;
268	}	268	}
269		269
270	rc = section_header(elf, &section_hdr);	270	rc = section_header(elf, &section_hdr);
271	if (rc != EE_OK)	271	if (rc != EE_OK)
272	return rc;	272	return rc;
273	}	273	}
274		274
275	elf->info->entry =	275	elf->info->entry =
276	(entry_point_t)((uint8_t *)header->e_entry + elf->bias);	276	(entry_point_t)((uint8_t *)header->e_entry + elf->bias);
277		277
278	// printf("done\n");	278	// printf("done\n");
279		279
280	return EE_OK;	280	return EE_OK;
281	}	281	}
282		282
283	/** Print error message according to error code.	283	/** Print error message according to error code.
284	*	284	*
285	* @param rc Return code returned by elf_load().	285	* @param rc Return code returned by elf_load().
286	*	286	*
287	* @return NULL terminated description of error.	287	* @return NULL terminated description of error.
288	*/	288	*/
289	char *elf_error(unsigned int rc)	289	char *elf_error(unsigned int rc)
290	{	290	{
291	assert(rc < sizeof(error_codes) / sizeof(char *));	291	assert(rc < sizeof(error_codes) / sizeof(char *));
292		292
293	return error_codes[rc];	293	return error_codes[rc];
294	}	294	}
295		295
296	/** Process segment header.	296	/** Process segment header.
297	*	297	*
298	* @param entry Segment header.	298	* @param entry Segment header.
299	*	299	*
300	* @return EE_OK on success, error code otherwise.	300	* @return EE_OK on success, error code otherwise.
301	*/	301	*/
302	static int segment_header(elf_ld_t elf, elf_segment_header_t entry)	302	static int segment_header(elf_ld_t elf, elf_segment_header_t entry)
303	{	303	{
304	switch (entry->p_type) {	304	switch (entry->p_type) {
305	case PT_NULL:	305	case PT_NULL:
306	case PT_PHDR:	306	case PT_PHDR:
307	break;	307	break;
308	case PT_LOAD:	308	case PT_LOAD:
309	return load_segment(elf, entry);	309	return load_segment(elf, entry);
310	break;	310	break;
311	case PT_INTERP:	311	case PT_INTERP:
312	/* Assume silently interp == "/lib/rtld" */	312	/* Assume silently interp == "/lib/rtld" */
313	elf->info->interp = "/lib/rtld";	313	elf->info->interp = "/lib/rtld";
314	break;	314	break;
315	case PT_DYNAMIC:	315	case PT_DYNAMIC:
316	case PT_SHLIB:	316	case PT_SHLIB:
317	case PT_NOTE:	317	case PT_NOTE:
318	case PT_LOPROC:	318	case PT_LOPROC:
319	case PT_HIPROC:	319	case PT_HIPROC:
320	default:	320	default:
321	printf("segment p_type %d unknown\n", entry->p_type);	321	printf("segment p_type %d unknown\n", entry->p_type);
322	return EE_UNSUPPORTED;	322	return EE_UNSUPPORTED;
323	break;	323	break;
324	}	324	}
325	return EE_OK;	325	return EE_OK;
326	}	326	}
327		327
328	/** Load segment described by program header entry.	328	/** Load segment described by program header entry.
329	*	329	*
330	* @param elf Loader state.	330	* @param elf Loader state.
331	* @param entry Program header entry describing segment to be loaded.	331	* @param entry Program header entry describing segment to be loaded.
332	*	332	*
333	* @return EE_OK on success, error code otherwise.	333	* @return EE_OK on success, error code otherwise.
334	*/	334	*/
335	int load_segment(elf_ld_t elf, elf_segment_header_t entry)	335	int load_segment(elf_ld_t elf, elf_segment_header_t entry)
336	{	336	{
337	void *a;	337	void *a;
338	int flags = 0;	338	int flags = 0;
339	uintptr_t bias;	339	uintptr_t bias;
340	uintptr_t base;	340	uintptr_t base;
341	size_t mem_sz;	341	size_t mem_sz;
342	int rc;	342	int rc;
343		343
344	// printf("load segment at addr 0x%x, size 0x%x\n", entry->p_vaddr,	344	// printf("load segment at addr 0x%x, size 0x%x\n", entry->p_vaddr,
345	// entry->p_memsz);	345	// entry->p_memsz);
346		346
347	bias = elf->bias;	347	bias = elf->bias;
348		348
349	if (entry->p_align > 1) {	349	if (entry->p_align > 1) {
350	if ((entry->p_offset % entry->p_align) !=	350	if ((entry->p_offset % entry->p_align) !=
351	(entry->p_vaddr % entry->p_align)) {	351	(entry->p_vaddr % entry->p_align)) {
352	printf("align check 1 failed offset%%align=%d, "	352	printf("align check 1 failed offset%%align=%d, "
353	"vaddr%%align=%d\n",	353	"vaddr%%align=%d\n",
354	entry->p_offset % entry->p_align,	354	entry->p_offset % entry->p_align,
355	entry->p_vaddr % entry->p_align	355	entry->p_vaddr % entry->p_align
356	);	356	);
357	return EE_INVALID;	357	return EE_INVALID;
358	}	358	}
359	}	359	}
360		360
361	/* Final flags that will be set for the memory area */	361	/* Final flags that will be set for the memory area */
362		362
363	if (entry->p_flags & PF_X)	363	if (entry->p_flags & PF_X)
364	flags \|= AS_AREA_EXEC;	364	flags \|= AS_AREA_EXEC;
365	if (entry->p_flags & PF_W)	365	if (entry->p_flags & PF_W)
366	flags \|= AS_AREA_WRITE;	366	flags \|= AS_AREA_WRITE;
367	if (entry->p_flags & PF_R)	367	if (entry->p_flags & PF_R)
368	flags \|= AS_AREA_READ;	368	flags \|= AS_AREA_READ;
369	flags \|= AS_AREA_CACHEABLE;	369	flags \|= AS_AREA_CACHEABLE;
370		370
371	base = ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE);	371	base = ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE);
372	mem_sz = entry->p_memsz + (entry->p_vaddr - base);	372	mem_sz = entry->p_memsz + (entry->p_vaddr - base);
373		373
374	// printf("map to p_vaddr=0x%x-0x%x...\n", entry->p_vaddr + bias,	374	// printf("map to p_vaddr=0x%x-0x%x...\n", entry->p_vaddr + bias,
375	// entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));	375	// entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));
376		376
377	/*	377	/*
378	* For the course of loading, the area needs to be readable	378	* For the course of loading, the area needs to be readable
379	* and writeable.	379	* and writeable.
380	*/	380	*/
381	a = as_area_create((uint8_t *)base + bias, mem_sz,	381	a = as_area_create((uint8_t *)base + bias, mem_sz,
382	AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE);	382	AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE);
383	if (a == (void *)(-1)) {	383	if (a == (void *)(-1)) {
384	printf("memory mapping failed\n");	384	printf("memory mapping failed\n");
385	return EE_MEMORY;	385	return EE_MEMORY;
386	}	386	}
387		387
388	// printf("as_area_create(0x%lx, 0x%x, %d) -> 0x%lx\n",	388	// printf("as_area_create(0x%lx, 0x%x, %d) -> 0x%lx\n",
389	// entry->p_vaddr+bias, entry->p_memsz, flags, (uintptr_t)a);	389	// entry->p_vaddr+bias, entry->p_memsz, flags, (uintptr_t)a);
390		390
391	/*	391	/*
392	* Load segment data	392	* Load segment data
393	*/	393	*/
394	// printf("seek to %d\n", entry->p_offset);	394	// printf("seek to %d\n", entry->p_offset);
395	rc = lseek(elf->fd, entry->p_offset, SEEK_SET);	395	rc = lseek(elf->fd, entry->p_offset, SEEK_SET);
396	if (rc < 0) {	396	if (rc < 0) {
397	printf("seek error\n");	397	printf("seek error\n");
398	return EE_INVALID;	398	return EE_INVALID;
399	}	399	}
400		400
401	// printf("read 0x%x bytes to address 0x%x\n", entry->p_filesz, entry->p_vaddr+bias);	401	// printf("read 0x%x bytes to address 0x%x\n", entry->p_filesz, entry->p_vaddr+bias);
402	/* rc = read(fd, (void *)(entry->p_vaddr + bias), entry->p_filesz);	402	/* rc = read(fd, (void *)(entry->p_vaddr + bias), entry->p_filesz);
403	if (rc < 0) { printf("read error\n"); return EE_INVALID; }*/	403	if (rc < 0) { printf("read error\n"); return EE_INVALID; }*/
404		404
405	/* Long reads are not possible yet. Load segment picewise */	405	/* Long reads are not possible yet. Load segment picewise */
406		406
407	unsigned left, now;	407	unsigned left, now;
408	uint8_t *dp;	408	uint8_t *dp;
409		409
410	left = entry->p_filesz;	410	left = entry->p_filesz;
411	dp = (uint8_t *)(entry->p_vaddr + bias);	411	dp = (uint8_t *)(entry->p_vaddr + bias);
412		412
413	while (left > 0) {	413	while (left > 0) {
414	now = 16384;	414	now = 16384;
415	if (now > left) now = left;	415	if (now > left) now = left;
416		416
417	// printf("read %d...", now);	417	// printf("read %d...", now);
418	rc = my_read(elf->fd, dp, now);	418	rc = my_read(elf->fd, dp, now);
419	// printf("->%d\n", rc);	419	// printf("->%d\n", rc);
420		420
421	if (rc < 0) {	421	if (rc < 0) {
422	printf("read error\n");	422	printf("read error\n");
423	return EE_INVALID;	423	return EE_INVALID;
424	}	424	}
425		425
426	left -= now;	426	left -= now;
427	dp += now;	427	dp += now;
428	}	428	}
429		429
430	/*	430	/*
431	* The caller wants to modify the segments first. He will then	431	* The caller wants to modify the segments first. He will then
432	* need to set the right access mode and ensure SMC coherence.	432	* need to set the right access mode and ensure SMC coherence.
433	*/	433	*/
434	if ((elf->flags & ELDF_RW) != 0) return EE_OK;	434	if ((elf->flags & ELDF_RW) != 0) return EE_OK;
435		435
436	printf("set area flags to %d\n", flags);	436	// printf("set area flags to %d\n", flags);
437	rc = as_area_change_flags((uint8_t *)entry->p_vaddr + bias, flags);	437	rc = as_area_change_flags((uint8_t *)entry->p_vaddr + bias, flags);
438	if (rc != 0) {	438	if (rc != 0) {
439	printf("failed to set memory area flags\n");	439	printf("failed to set memory area flags\n");
440	return EE_MEMORY;	440	return EE_MEMORY;
441	}	441	}
442		442
443	if (flags & AS_AREA_EXEC) {	443	if (flags & AS_AREA_EXEC) {
444	/* Enforce SMC coherence for the segment */	444	/* Enforce SMC coherence for the segment */
445	if (smc_coherence(entry->p_vaddr + bias, entry->p_filesz))	445	if (smc_coherence(entry->p_vaddr + bias, entry->p_filesz))
446	return EE_MEMORY;	446	return EE_MEMORY;
447	}	447	}
448		448
449	return EE_OK;	449	return EE_OK;
450	}	450	}
451		451
452	/** Process section header.	452	/** Process section header.
453	*	453	*
454	* @param elf Loader state.	454	* @param elf Loader state.
455	* @param entry Segment header.	455	* @param entry Segment header.
456	*	456	*
457	* @return EE_OK on success, error code otherwise.	457	* @return EE_OK on success, error code otherwise.
458	*/	458	*/
459	static int section_header(elf_ld_t elf, elf_section_header_t entry)	459	static int section_header(elf_ld_t elf, elf_section_header_t entry)
460	{	460	{
461	switch (entry->sh_type) {	461	switch (entry->sh_type) {
462	case SHT_PROGBITS:	462	case SHT_PROGBITS:
463	if (entry->sh_flags & SHF_TLS) {	463	if (entry->sh_flags & SHF_TLS) {
464	/* .tdata */	464	/* .tdata */
465	}	465	}
466	break;	466	break;
467	case SHT_NOBITS:	467	case SHT_NOBITS:
468	if (entry->sh_flags & SHF_TLS) {	468	if (entry->sh_flags & SHF_TLS) {
469	/* .tbss */	469	/* .tbss */
470	}	470	}
471	break;	471	break;
472	case SHT_DYNAMIC:	472	case SHT_DYNAMIC:
473	/* Record pointer to dynamic section into info structure */	473	/* Record pointer to dynamic section into info structure */
474	elf->info->dynamic =	474	elf->info->dynamic =
475	(void )((uint8_t )entry->sh_addr + elf->bias);	475	(void )((uint8_t )entry->sh_addr + elf->bias);
476	printf("dynamic section found at 0x%x\n",	476	printf("dynamic section found at 0x%x\n",
477	(uintptr_t)elf->info->dynamic);	477	(uintptr_t)elf->info->dynamic);
478	break;	478	break;
479	default:	479	default:
480	break;	480	break;
481	}	481	}
482		482
483	return EE_OK;	483	return EE_OK;
484	}	484	}
485		485
486	/** @}	486	/** @}
487	*/	487	*/
488		488

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/srv/loader/elf_load.c – Rev 3552 → 3562