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;
}
 
/** 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;
    pcb->rtld_runtime = NULL;
}
 
 
/** 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 == "/app/dload" */
        elf->info->interp = "/app/dload";
        break;
    case PT_DYNAMIC:
        /* Record pointer to dynamic section into info structure */
        elf->info->dynamic =
            (void *)((uint8_t *)entry->p_vaddr + elf->bias);
        printf("dynamic section found at 0x%x\n",
            (uintptr_t)elf->info->dynamic);
        break;
    case 0x70000000:
        /* FIXME: MIPS reginfo */
        break;
    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 (0x%x, %d)\n",
            base+bias, mem_sz);
        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:
        break;
    default:
        break;
    }
   
    return EE_OK;
}
 
/** @}
 */
 

Rev 3690	Rev 3772
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	/** Create the program control block (PCB).	129	/** Create the program control block (PCB).
130	*	130	*
131	* Fills the program control block @a pcb with information from	131	* Fills the program control block @a pcb with information from
132	* @a info.	132	* @a info.
133	*	133	*
134	* @param info Program info structure	134	* @param info Program info structure
135	* @return EOK on success or negative error code	135	* @return EOK on success or negative error code
136	*/	136	*/
137	void elf_create_pcb(elf_info_t info, pcb_t pcb)	137	void elf_create_pcb(elf_info_t info, pcb_t pcb)
138	{	138	{
139	pcb->entry = info->entry;	139	pcb->entry = info->entry;
140	pcb->dynamic = info->dynamic;	140	pcb->dynamic = info->dynamic;
141	pcb->rtld_runtime = NULL;	141	pcb->rtld_runtime = NULL;
142	}	142	}
143		143
144		144
145	/** Load an ELF binary.	145	/** Load an ELF binary.
146	*	146	*
147	* The @a elf structure contains the loader state, including	147	* The @a elf structure contains the loader state, including
148	* an open file, from which the binary will be loaded,	148	* an open file, from which the binary will be loaded,
149	* a pointer to the @c info structure etc.	149	* a pointer to the @c info structure etc.
150	*	150	*
151	* @param elf Pointer to loader state buffer.	151	* @param elf Pointer to loader state buffer.
152	* @param so_bias Bias to use if the file is a shared object.	152	* @param so_bias Bias to use if the file is a shared object.
153	* @return EE_OK on success or EE_xx error code.	153	* @return EE_OK on success or EE_xx error code.
154	*/	154	*/
155	static unsigned int elf_load(elf_ld_t *elf, size_t so_bias)	155	static unsigned int elf_load(elf_ld_t *elf, size_t so_bias)
156	{	156	{
157	elf_header_t header_buf;	157	elf_header_t header_buf;
158	elf_header_t *header = &header_buf;	158	elf_header_t *header = &header_buf;
159	int i, rc;	159	int i, rc;
160		160
161	rc = my_read(elf->fd, header, sizeof(elf_header_t));	161	rc = my_read(elf->fd, header, sizeof(elf_header_t));
162	if (rc < 0) {	162	if (rc < 0) {
163	printf("read error\n");	163	printf("read error\n");
164	return EE_INVALID;	164	return EE_INVALID;
165	}	165	}
166		166
167	elf->header = header;	167	elf->header = header;
168		168
169	// printf("ELF-load:");	169	// printf("ELF-load:");
170	/* Identify ELF */	170	/* Identify ELF */
171	if (header->e_ident[EI_MAG0] != ELFMAG0 \|\|	171	if (header->e_ident[EI_MAG0] != ELFMAG0 \|\|
172	header->e_ident[EI_MAG1] != ELFMAG1 \|\|	172	header->e_ident[EI_MAG1] != ELFMAG1 \|\|
173	header->e_ident[EI_MAG2] != ELFMAG2 \|\|	173	header->e_ident[EI_MAG2] != ELFMAG2 \|\|
174	header->e_ident[EI_MAG3] != ELFMAG3) {	174	header->e_ident[EI_MAG3] != ELFMAG3) {
175	printf("invalid header\n");	175	printf("invalid header\n");
176	return EE_INVALID;	176	return EE_INVALID;
177	}	177	}
178		178
179	/* Identify ELF compatibility */	179	/* Identify ELF compatibility */
180	if (header->e_ident[EI_DATA] != ELF_DATA_ENCODING \|\|	180	if (header->e_ident[EI_DATA] != ELF_DATA_ENCODING \|\|
181	header->e_machine != ELF_MACHINE \|\|	181	header->e_machine != ELF_MACHINE \|\|
182	header->e_ident[EI_VERSION] != EV_CURRENT \|\|	182	header->e_ident[EI_VERSION] != EV_CURRENT \|\|
183	header->e_version != EV_CURRENT \|\|	183	header->e_version != EV_CURRENT \|\|
184	header->e_ident[EI_CLASS] != ELF_CLASS) {	184	header->e_ident[EI_CLASS] != ELF_CLASS) {
185	printf("incompatible data/version/class\n");	185	printf("incompatible data/version/class\n");
186	return EE_INCOMPATIBLE;	186	return EE_INCOMPATIBLE;
187	}	187	}
188		188
189	if (header->e_phentsize != sizeof(elf_segment_header_t)) {	189	if (header->e_phentsize != sizeof(elf_segment_header_t)) {
190	printf("e_phentsize:%d != %d\n", header->e_phentsize,	190	printf("e_phentsize:%d != %d\n", header->e_phentsize,
191	sizeof(elf_segment_header_t));	191	sizeof(elf_segment_header_t));
192	return EE_INCOMPATIBLE;	192	return EE_INCOMPATIBLE;
193	}	193	}
194		194
195	if (header->e_shentsize != sizeof(elf_section_header_t)) {	195	if (header->e_shentsize != sizeof(elf_section_header_t)) {
196	printf("e_shentsize:%d != %d\n", header->e_shentsize,	196	printf("e_shentsize:%d != %d\n", header->e_shentsize,
197	sizeof(elf_section_header_t));	197	sizeof(elf_section_header_t));
198	return EE_INCOMPATIBLE;	198	return EE_INCOMPATIBLE;
199	}	199	}
200		200
201	/* Check if the object type is supported. */	201	/* Check if the object type is supported. */
202	if (header->e_type != ET_EXEC && header->e_type != ET_DYN) {	202	if (header->e_type != ET_EXEC && header->e_type != ET_DYN) {
203	printf("Object type %d is not supported\n", header->e_type);	203	printf("Object type %d is not supported\n", header->e_type);
204	return EE_UNSUPPORTED;	204	return EE_UNSUPPORTED;
205	}	205	}
206		206
207	/* Shared objects can be loaded with a bias */	207	/* Shared objects can be loaded with a bias */
208	// printf("Object type: %d\n", header->e_type);	208	// printf("Object type: %d\n", header->e_type);
209	if (header->e_type == ET_DYN)	209	if (header->e_type == ET_DYN)
210	elf->bias = so_bias;	210	elf->bias = so_bias;
211	else	211	else
212	elf->bias = 0;	212	elf->bias = 0;
213		213
214	// printf("Bias set to 0x%x\n", elf->bias);	214	// printf("Bias set to 0x%x\n", elf->bias);
215	elf->info->interp = NULL;	215	elf->info->interp = NULL;
216	elf->info->dynamic = NULL;	216	elf->info->dynamic = NULL;
217		217
218	// printf("parse segments\n");	218	// printf("parse segments\n");
219		219
220	/* Walk through all segment headers and process them. */	220	/* Walk through all segment headers and process them. */
221	for (i = 0; i < header->e_phnum; i++) {	221	for (i = 0; i < header->e_phnum; i++) {
222	elf_segment_header_t segment_hdr;	222	elf_segment_header_t segment_hdr;
223		223
224	/* Seek to start of segment header */	224	/* Seek to start of segment header */
225	lseek(elf->fd, header->e_phoff	225	lseek(elf->fd, header->e_phoff
226	+ i * sizeof(elf_segment_header_t), SEEK_SET);	226	+ i * sizeof(elf_segment_header_t), SEEK_SET);
227		227
228	rc = my_read(elf->fd, &segment_hdr,	228	rc = my_read(elf->fd, &segment_hdr,
229	sizeof(elf_segment_header_t));	229	sizeof(elf_segment_header_t));
230	if (rc < 0) {	230	if (rc < 0) {
231	printf("read error\n");	231	printf("read error\n");
232	return EE_INVALID;	232	return EE_INVALID;
233	}	233	}
234		234
235	rc = segment_header(elf, &segment_hdr);	235	rc = segment_header(elf, &segment_hdr);
236	if (rc != EE_OK)	236	if (rc != EE_OK)
237	return rc;	237	return rc;
238	}	238	}
239		239
240	// printf("parse sections\n");	240	// printf("parse sections\n");
241		241
242	/* Inspect all section headers and proccess them. */	242	/* Inspect all section headers and proccess them. */
243	for (i = 0; i < header->e_shnum; i++) {	243	for (i = 0; i < header->e_shnum; i++) {
244	elf_section_header_t section_hdr;	244	elf_section_header_t section_hdr;
245		245
246	/* Seek to start of section header */	246	/* Seek to start of section header */
247	lseek(elf->fd, header->e_shoff	247	lseek(elf->fd, header->e_shoff
248	+ i * sizeof(elf_section_header_t), SEEK_SET);	248	+ i * sizeof(elf_section_header_t), SEEK_SET);
249		249
250	rc = my_read(elf->fd, &section_hdr,	250	rc = my_read(elf->fd, &section_hdr,
251	sizeof(elf_section_header_t));	251	sizeof(elf_section_header_t));
252	if (rc < 0) {	252	if (rc < 0) {
253	printf("read error\n");	253	printf("read error\n");
254	return EE_INVALID;	254	return EE_INVALID;
255	}	255	}
256		256
257	rc = section_header(elf, &section_hdr);	257	rc = section_header(elf, &section_hdr);
258	if (rc != EE_OK)	258	if (rc != EE_OK)
259	return rc;	259	return rc;
260	}	260	}
261		261
262	elf->info->entry =	262	elf->info->entry =
263	(entry_point_t)((uint8_t *)header->e_entry + elf->bias);	263	(entry_point_t)((uint8_t *)header->e_entry + elf->bias);
264		264
265	// printf("done\n");	265	// printf("done\n");
266		266
267	return EE_OK;	267	return EE_OK;
268	}	268	}
269		269
270	/** Print error message according to error code.	270	/** Print error message according to error code.
271	*	271	*
272	* @param rc Return code returned by elf_load().	272	* @param rc Return code returned by elf_load().
273	*	273	*
274	* @return NULL terminated description of error.	274	* @return NULL terminated description of error.
275	*/	275	*/
276	char *elf_error(unsigned int rc)	276	char *elf_error(unsigned int rc)
277	{	277	{
278	assert(rc < sizeof(error_codes) / sizeof(char *));	278	assert(rc < sizeof(error_codes) / sizeof(char *));
279		279
280	return error_codes[rc];	280	return error_codes[rc];
281	}	281	}
282		282
283	/** Process segment header.	283	/** Process segment header.
284	*	284	*
285	* @param entry Segment header.	285	* @param entry Segment header.
286	*	286	*
287	* @return EE_OK on success, error code otherwise.	287	* @return EE_OK on success, error code otherwise.
288	*/	288	*/
289	static int segment_header(elf_ld_t elf, elf_segment_header_t entry)	289	static int segment_header(elf_ld_t elf, elf_segment_header_t entry)
290	{	290	{
291	switch (entry->p_type) {	291	switch (entry->p_type) {
292	case PT_NULL:	292	case PT_NULL:
293	case PT_PHDR:	293	case PT_PHDR:
294	break;	294	break;
295	case PT_LOAD:	295	case PT_LOAD:
296	return load_segment(elf, entry);	296	return load_segment(elf, entry);
297	break;	297	break;
298	case PT_INTERP:	298	case PT_INTERP:
299	/* Assume silently interp == "/app/dload" */	299	/* Assume silently interp == "/app/dload" */
300	elf->info->interp = "/app/dload";	300	elf->info->interp = "/app/dload";
301	break;	301	break;
302	case PT_DYNAMIC:	302	case PT_DYNAMIC:
303	/* Record pointer to dynamic section into info structure */	303	/* Record pointer to dynamic section into info structure */
304	elf->info->dynamic =	304	elf->info->dynamic =
305	(void )((uint8_t )entry->p_vaddr + elf->bias);	305	(void )((uint8_t )entry->p_vaddr + elf->bias);
306	printf("dynamic section found at 0x%x\n",	306	printf("dynamic section found at 0x%x\n",
307	(uintptr_t)elf->info->dynamic);	307	(uintptr_t)elf->info->dynamic);
308	break;	308	break;
-		309	case 0x70000000:
-		310	/* FIXME: MIPS reginfo */
-		311	break;
309	case PT_SHLIB:	312	case PT_SHLIB:
310	case PT_NOTE:	313	case PT_NOTE:
311	case PT_LOPROC:	314	// case PT_LOPROC:
312	case PT_HIPROC:	315	// case PT_HIPROC:
313	default:	316	default:
314	printf("segment p_type %d unknown\n", entry->p_type);	317	printf("segment p_type %d unknown\n", entry->p_type);
315	return EE_UNSUPPORTED;	318	return EE_UNSUPPORTED;
316	break;	319	break;
317	}	320	}
318	return EE_OK;	321	return EE_OK;
319	}	322	}
320		323
321	/** Load segment described by program header entry.	324	/** Load segment described by program header entry.
322	*	325	*
323	* @param elf Loader state.	326	* @param elf Loader state.
324	* @param entry Program header entry describing segment to be loaded.	327	* @param entry Program header entry describing segment to be loaded.
325	*	328	*
326	* @return EE_OK on success, error code otherwise.	329	* @return EE_OK on success, error code otherwise.
327	*/	330	*/
328	int load_segment(elf_ld_t elf, elf_segment_header_t entry)	331	int load_segment(elf_ld_t elf, elf_segment_header_t entry)
329	{	332	{
330	void *a;	333	void *a;
331	int flags = 0;	334	int flags = 0;
332	uintptr_t bias;	335	uintptr_t bias;
333	uintptr_t base;	336	uintptr_t base;
334	size_t mem_sz;	337	size_t mem_sz;
335	int rc;	338	int rc;
336		339
337	// printf("load segment at addr 0x%x, size 0x%x\n", entry->p_vaddr,	340	// printf("load segment at addr 0x%x, size 0x%x\n", entry->p_vaddr,
338	// entry->p_memsz);	341	// entry->p_memsz);
339		342
340	bias = elf->bias;	343	bias = elf->bias;
341		344
342	if (entry->p_align > 1) {	345	if (entry->p_align > 1) {
343	if ((entry->p_offset % entry->p_align) !=	346	if ((entry->p_offset % entry->p_align) !=
344	(entry->p_vaddr % entry->p_align)) {	347	(entry->p_vaddr % entry->p_align)) {
345	printf("align check 1 failed offset%%align=%d, "	348	printf("align check 1 failed offset%%align=%d, "
346	"vaddr%%align=%d\n",	349	"vaddr%%align=%d\n",
347	entry->p_offset % entry->p_align,	350	entry->p_offset % entry->p_align,
348	entry->p_vaddr % entry->p_align	351	entry->p_vaddr % entry->p_align
349	);	352	);
350	return EE_INVALID;	353	return EE_INVALID;
351	}	354	}
352	}	355	}
353		356
354	/* Final flags that will be set for the memory area */	357	/* Final flags that will be set for the memory area */
355		358
356	if (entry->p_flags & PF_X)	359	if (entry->p_flags & PF_X)
357	flags \|= AS_AREA_EXEC;	360	flags \|= AS_AREA_EXEC;
358	if (entry->p_flags & PF_W)	361	if (entry->p_flags & PF_W)
359	flags \|= AS_AREA_WRITE;	362	flags \|= AS_AREA_WRITE;
360	if (entry->p_flags & PF_R)	363	if (entry->p_flags & PF_R)
361	flags \|= AS_AREA_READ;	364	flags \|= AS_AREA_READ;
362	flags \|= AS_AREA_CACHEABLE;	365	flags \|= AS_AREA_CACHEABLE;
363		366
364	base = ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE);	367	base = ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE);
365	mem_sz = entry->p_memsz + (entry->p_vaddr - base);	368	mem_sz = entry->p_memsz + (entry->p_vaddr - base);
366		369
367	// printf("map to p_vaddr=0x%x-0x%x...\n", entry->p_vaddr + bias,	370	// printf("map to p_vaddr=0x%x-0x%x...\n", entry->p_vaddr + bias,
368	// entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));	371	// entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));
369		372
370	/*	373	/*
371	* For the course of loading, the area needs to be readable	374	* For the course of loading, the area needs to be readable
372	* and writeable.	375	* and writeable.
373	*/	376	*/
374	a = as_area_create((uint8_t *)base + bias, mem_sz,	377	a = as_area_create((uint8_t *)base + bias, mem_sz,
375	AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE);	378	AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE);
376	if (a == (void *)(-1)) {	379	if (a == (void *)(-1)) {
377	printf("memory mapping failed\n");	380	printf("memory mapping failed (0x%x, %d)\n",
-		381	base+bias, mem_sz);
378	return EE_MEMORY;	382	return EE_MEMORY;
379	}	383	}
380		384
381	// printf("as_area_create(0x%lx, 0x%x, %d) -> 0x%lx\n",	385	// printf("as_area_create(0x%lx, 0x%x, %d) -> 0x%lx\n",
382	// entry->p_vaddr+bias, entry->p_memsz, flags, (uintptr_t)a);	386	// entry->p_vaddr+bias, entry->p_memsz, flags, (uintptr_t)a);
383		387
384	/*	388	/*
385	* Load segment data	389	* Load segment data
386	*/	390	*/
387	// printf("seek to %d\n", entry->p_offset);	391	// printf("seek to %d\n", entry->p_offset);
388	rc = lseek(elf->fd, entry->p_offset, SEEK_SET);	392	rc = lseek(elf->fd, entry->p_offset, SEEK_SET);
389	if (rc < 0) {	393	if (rc < 0) {
390	printf("seek error\n");	394	printf("seek error\n");
391	return EE_INVALID;	395	return EE_INVALID;
392	}	396	}
393		397
394	// printf("read 0x%x bytes to address 0x%x\n", entry->p_filesz, entry->p_vaddr+bias);	398	// printf("read 0x%x bytes to address 0x%x\n", entry->p_filesz, entry->p_vaddr+bias);
395	/* rc = read(fd, (void *)(entry->p_vaddr + bias), entry->p_filesz);	399	/* rc = read(fd, (void *)(entry->p_vaddr + bias), entry->p_filesz);
396	if (rc < 0) { printf("read error\n"); return EE_INVALID; }*/	400	if (rc < 0) { printf("read error\n"); return EE_INVALID; }*/
397		401
398	/* Long reads are not possible yet. Load segment picewise */	402	/* Long reads are not possible yet. Load segment picewise */
399		403
400	unsigned left, now;	404	unsigned left, now;
401	uint8_t *dp;	405	uint8_t *dp;
402		406
403	left = entry->p_filesz;	407	left = entry->p_filesz;
404	dp = (uint8_t *)(entry->p_vaddr + bias);	408	dp = (uint8_t *)(entry->p_vaddr + bias);
405		409
406	while (left > 0) {	410	while (left > 0) {
407	now = 16384;	411	now = 16384;
408	if (now > left) now = left;	412	if (now > left) now = left;
409		413
410	// printf("read %d...", now);	414	// printf("read %d...", now);
411	rc = my_read(elf->fd, dp, now);	415	rc = my_read(elf->fd, dp, now);
412	// printf("->%d\n", rc);	416	// printf("->%d\n", rc);
413		417
414	if (rc < 0) {	418	if (rc < 0) {
415	printf("read error\n");	419	printf("read error\n");
416	return EE_INVALID;	420	return EE_INVALID;
417	}	421	}
418		422
419	left -= now;	423	left -= now;
420	dp += now;	424	dp += now;
421	}	425	}
422		426
423	/*	427	/*
424	* The caller wants to modify the segments first. He will then	428	* The caller wants to modify the segments first. He will then
425	* need to set the right access mode and ensure SMC coherence.	429	* need to set the right access mode and ensure SMC coherence.
426	*/	430	*/
427	if ((elf->flags & ELDF_RW) != 0) return EE_OK;	431	if ((elf->flags & ELDF_RW) != 0) return EE_OK;
428		432
429	// printf("set area flags to %d\n", flags);	433	// printf("set area flags to %d\n", flags);
430	rc = as_area_change_flags((uint8_t *)entry->p_vaddr + bias, flags);	434	rc = as_area_change_flags((uint8_t *)entry->p_vaddr + bias, flags);
431	if (rc != 0) {	435	if (rc != 0) {
432	printf("failed to set memory area flags\n");	436	printf("failed to set memory area flags\n");
433	return EE_MEMORY;	437	return EE_MEMORY;
434	}	438	}
435		439
436	if (flags & AS_AREA_EXEC) {	440	if (flags & AS_AREA_EXEC) {
437	/* Enforce SMC coherence for the segment */	441	/* Enforce SMC coherence for the segment */
438	if (smc_coherence(entry->p_vaddr + bias, entry->p_filesz))	442	if (smc_coherence(entry->p_vaddr + bias, entry->p_filesz))
439	return EE_MEMORY;	443	return EE_MEMORY;
440	}	444	}
441		445
442	return EE_OK;	446	return EE_OK;
443	}	447	}
444		448
445	/** Process section header.	449	/** Process section header.
446	*	450	*
447	* @param elf Loader state.	451	* @param elf Loader state.
448	* @param entry Segment header.	452	* @param entry Segment header.
449	*	453	*
450	* @return EE_OK on success, error code otherwise.	454	* @return EE_OK on success, error code otherwise.
451	*/	455	*/
452	static int section_header(elf_ld_t elf, elf_section_header_t entry)	456	static int section_header(elf_ld_t elf, elf_section_header_t entry)
453	{	457	{
454	switch (entry->sh_type) {	458	switch (entry->sh_type) {
455	case SHT_PROGBITS:	459	case SHT_PROGBITS:
456	if (entry->sh_flags & SHF_TLS) {	460	if (entry->sh_flags & SHF_TLS) {
457	/* .tdata */	461	/* .tdata */
458	}	462	}
459	break;	463	break;
460	case SHT_NOBITS:	464	case SHT_NOBITS:
461	if (entry->sh_flags & SHF_TLS) {	465	if (entry->sh_flags & SHF_TLS) {
462	/* .tbss */	466	/* .tbss */
463	}	467	}
464	break;	468	break;
465	case SHT_DYNAMIC:	469	case SHT_DYNAMIC:
466	break;	470	break;
467	default:	471	default:
468	break;	472	break;
469	}	473	}
470		474
471	return EE_OK;	475	return EE_OK;
472	}	476	}
473		477
474	/** @}	478	/** @}
475	*/	479	*/
476		480

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/srv/loader/elf_load.c – Rev 3690 → 3772