WebSVN – HelenOS-historic – Diff – /kernel/trunk/generic/src/lib/elf.c


/*
 * Copyright (C) 2006 Sergey Bondari
 * Copyright (C) 2006 Jakub Jermar
 * 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   Kernel ELF loader.
 */
 
#include <elf.h>
#include <debug.h>
#include <arch/types.h>
#include <typedefs.h>
#include <mm/as.h>
#include <mm/frame.h>
#include <mm/slab.h>
#include <align.h>
#include <memstr.h>
#include <macros.h>
#include <arch.h>
 
static char *error_codes[] = {
    "no error",
    "invalid image",
    "address space error",
    "incompatible image",
    "unsupported image type",
    "irrecoverable error"
};
 
static int segment_header(elf_segment_header_t *entry, elf_header_t *elf, as_t *as);
static int section_header(elf_section_header_t *entry, elf_header_t *elf, as_t *as);
static int load_segment(elf_segment_header_t *entry, elf_header_t *elf, as_t *as);
 
/** ELF loader
 *
 * @param header Pointer to ELF header in memory
 * @param as Created and properly mapped address space
 * @return EE_OK on success
 */
int elf_load(elf_header_t *header, as_t * as)
{
    int i, rc;
 
    /* 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) {
        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) {
        return EE_INCOMPATIBLE;
    }
 
    if (header->e_phentsize != sizeof(elf_segment_header_t))
        return EE_INCOMPATIBLE;
 
    if (header->e_shentsize != sizeof(elf_section_header_t))
        return EE_INCOMPATIBLE;
 
    /* Check if the object type is supported. */
    if (header->e_type != ET_EXEC)
        return EE_UNSUPPORTED;
 
    /* Walk through all segment headers and process them. */
    for (i = 0; i < header->e_phnum; i++) {
        rc = segment_header(&((elf_segment_header_t *)(((__u8 *) header) + header->e_phoff))[i], header, as);
        if (rc != EE_OK)
            return rc;
    }
 
    /* Inspect all section headers and proccess them. */
    for (i = 0; i < header->e_shnum; i++) {
        rc = section_header(&((elf_section_header_t *)(((__u8 *) header) + header->e_shoff))[i], header, as);
        if (rc != EE_OK)
            return rc;
    }
 
    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(int rc)
{
    ASSERT(rc < sizeof(error_codes)/sizeof(char *));
 
    return error_codes[rc];
}
 
/** Process segment header.
 *
 * @param entry Segment header.
 * @param elf ELF header.
 * @param as Address space into wich the ELF is being loaded.
 *
 * @return EE_OK on success, error code otherwise.
 */
static int segment_header(elf_segment_header_t *entry, elf_header_t *elf, as_t *as)
{
    switch (entry->p_type) {
        case PT_NULL:
        case PT_PHDR:
        break;
        case PT_LOAD:
        return load_segment(entry, elf, as);
        break;
        case PT_DYNAMIC:
        case PT_INTERP:
        case PT_SHLIB:
        case PT_NOTE:
        case PT_LOPROC:
        case PT_HIPROC:
        default:
        return EE_UNSUPPORTED;
        break;
    }
    return EE_OK;
}
 
/** Load segment described by program header entry.
 *
 * @param entry Program header entry describing segment to be loaded.
 * @param elf ELF header.
 * @param as Address space into wich the ELF is being loaded.
 *
 * @return EE_OK on success, error code otherwise.
 */
int load_segment(elf_segment_header_t *entry, elf_header_t *elf, as_t *as)
{
    as_area_t *a;
    int flags = 0;
    mem_backend_data_t backend_data;
   
    backend_data.elf = elf;
    backend_data.segment = entry;
 
    if (entry->p_align > 1) {
        if ((entry->p_offset % entry->p_align) != (entry->p_vaddr % entry->p_align)) {
            return EE_INVALID;
        }
    }
 
    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;
 
    /*
     * Check if the virtual address starts on page boundary.
     */
    if (ALIGN_UP(entry->p_vaddr, PAGE_SIZE) != entry->p_vaddr)
        return EE_UNSUPPORTED;
 
    a = as_area_create(as, flags, entry->p_memsz, entry->p_vaddr, AS_AREA_ATTR_NONE,
        &elf_backend, &backend_data);
    if (!a)
        return EE_MEMORY;
   
    /*
     * The segment will be mapped on demand by elf_page_fault().
     */
 
    return EE_OK;
}
 
/** Process section header.
 *
 * @param entry Segment header.
 * @param elf ELF header.
 * @param as Address space into wich the ELF is being loaded.
 *
 * @return EE_OK on success, error code otherwise.
 */
static int section_header(elf_section_header_t *entry, elf_header_t *elf, as_t *as)
{
    switch (entry->sh_type) {
        default:
        break;
    }
   
    return EE_OK;
}
 
 /** @}
 */
 
 

Rev 1425	Rev 1702
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	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Redistribution and use in source and binary forms, with or without	6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions	7	* modification, are permitted provided that the following conditions
8	* are met:	8	* are met:
9	*	9	*
10	* - Redistributions of source code must retain the above copyright	10	* - Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.	11	* notice, this list of conditions and the following disclaimer.
12	* - Redistributions in binary form must reproduce the above copyright	12	* - Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the	13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.	14	* documentation and/or other materials provided with the distribution.
15	* - The name of the author may not be used to endorse or promote products	15	* - The name of the author may not be used to endorse or promote products
16	* derived from this software without specific prior written permission.	16	* derived from this software without specific prior written permission.
17	*	17	*
18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	*/	28	*/
29		29
-		30	/** @addtogroup generic
-		31	* @{
-		32	*/
-		33
30	/**	34	/**
31	* @file elf.c	35	* @file
32	* @brief Kernel ELF loader.	36	* @brief Kernel ELF loader.
33	*/	37	*/
34		38
35	#include <elf.h>	39	#include <elf.h>
36	#include <debug.h>	40	#include <debug.h>
37	#include <arch/types.h>	41	#include <arch/types.h>
38	#include <typedefs.h>	42	#include <typedefs.h>
39	#include <mm/as.h>	43	#include <mm/as.h>
40	#include <mm/frame.h>	44	#include <mm/frame.h>
41	#include <mm/slab.h>	45	#include <mm/slab.h>
42	#include <align.h>	46	#include <align.h>
43	#include <memstr.h>	47	#include <memstr.h>
44	#include <macros.h>	48	#include <macros.h>
45	#include <arch.h>	49	#include <arch.h>
46		50
47	static char *error_codes[] = {	51	static char *error_codes[] = {
48	"no error",	52	"no error",
49	"invalid image",	53	"invalid image",
50	"address space error",	54	"address space error",
51	"incompatible image",	55	"incompatible image",
52	"unsupported image type",	56	"unsupported image type",
53	"irrecoverable error"	57	"irrecoverable error"
54	};	58	};
55		59
56	static int segment_header(elf_segment_header_t entry, elf_header_t elf, as_t *as);	60	static int segment_header(elf_segment_header_t entry, elf_header_t elf, as_t *as);
57	static int section_header(elf_section_header_t entry, elf_header_t elf, as_t *as);	61	static int section_header(elf_section_header_t entry, elf_header_t elf, as_t *as);
58	static int load_segment(elf_segment_header_t entry, elf_header_t elf, as_t *as);	62	static int load_segment(elf_segment_header_t entry, elf_header_t elf, as_t *as);
59		63
60	/** ELF loader	64	/** ELF loader
61	*	65	*
62	* @param header Pointer to ELF header in memory	66	* @param header Pointer to ELF header in memory
63	* @param as Created and properly mapped address space	67	* @param as Created and properly mapped address space
64	* @return EE_OK on success	68	* @return EE_OK on success
65	*/	69	*/
66	int elf_load(elf_header_t header, as_t as)	70	int elf_load(elf_header_t header, as_t as)
67	{	71	{
68	int i, rc;	72	int i, rc;
69		73
70	/* Identify ELF */	74	/* Identify ELF */
71	if (header->e_ident[EI_MAG0] != ELFMAG0 \|\| header->e_ident[EI_MAG1] != ELFMAG1 \|\|	75	if (header->e_ident[EI_MAG0] != ELFMAG0 \|\| header->e_ident[EI_MAG1] != ELFMAG1 \|\|
72	header->e_ident[EI_MAG2] != ELFMAG2 \|\| header->e_ident[EI_MAG3] != ELFMAG3) {	76	header->e_ident[EI_MAG2] != ELFMAG2 \|\| header->e_ident[EI_MAG3] != ELFMAG3) {
73	return EE_INVALID;	77	return EE_INVALID;
74	}	78	}
75		79
76	/* Identify ELF compatibility */	80	/* Identify ELF compatibility */
77	if (header->e_ident[EI_DATA] != ELF_DATA_ENCODING \|\| header->e_machine != ELF_MACHINE \|\|	81	if (header->e_ident[EI_DATA] != ELF_DATA_ENCODING \|\| header->e_machine != ELF_MACHINE \|\|
78	header->e_ident[EI_VERSION] != EV_CURRENT \|\| header->e_version != EV_CURRENT \|\|	82	header->e_ident[EI_VERSION] != EV_CURRENT \|\| header->e_version != EV_CURRENT \|\|
79	header->e_ident[EI_CLASS] != ELF_CLASS) {	83	header->e_ident[EI_CLASS] != ELF_CLASS) {
80	return EE_INCOMPATIBLE;	84	return EE_INCOMPATIBLE;
81	}	85	}
82		86
83	if (header->e_phentsize != sizeof(elf_segment_header_t))	87	if (header->e_phentsize != sizeof(elf_segment_header_t))
84	return EE_INCOMPATIBLE;	88	return EE_INCOMPATIBLE;
85		89
86	if (header->e_shentsize != sizeof(elf_section_header_t))	90	if (header->e_shentsize != sizeof(elf_section_header_t))
87	return EE_INCOMPATIBLE;	91	return EE_INCOMPATIBLE;
88		92
89	/* Check if the object type is supported. */	93	/* Check if the object type is supported. */
90	if (header->e_type != ET_EXEC)	94	if (header->e_type != ET_EXEC)
91	return EE_UNSUPPORTED;	95	return EE_UNSUPPORTED;
92		96
93	/* Walk through all segment headers and process them. */	97	/* Walk through all segment headers and process them. */
94	for (i = 0; i < header->e_phnum; i++) {	98	for (i = 0; i < header->e_phnum; i++) {
95	rc = segment_header(&((elf_segment_header_t )(((__u8 ) header) + header->e_phoff))[i], header, as);	99	rc = segment_header(&((elf_segment_header_t )(((__u8 ) header) + header->e_phoff))[i], header, as);
96	if (rc != EE_OK)	100	if (rc != EE_OK)
97	return rc;	101	return rc;
98	}	102	}
99		103
100	/* Inspect all section headers and proccess them. */	104	/* Inspect all section headers and proccess them. */
101	for (i = 0; i < header->e_shnum; i++) {	105	for (i = 0; i < header->e_shnum; i++) {
102	rc = section_header(&((elf_section_header_t )(((__u8 ) header) + header->e_shoff))[i], header, as);	106	rc = section_header(&((elf_section_header_t )(((__u8 ) header) + header->e_shoff))[i], header, as);
103	if (rc != EE_OK)	107	if (rc != EE_OK)
104	return rc;	108	return rc;
105	}	109	}
106		110
107	return EE_OK;	111	return EE_OK;
108	}	112	}
109		113
110	/** Print error message according to error code.	114	/** Print error message according to error code.
111	*	115	*
112	* @param rc Return code returned by elf_load().	116	* @param rc Return code returned by elf_load().
113	*	117	*
114	* @return NULL terminated description of error.	118	* @return NULL terminated description of error.
115	*/	119	*/
116	char *elf_error(int rc)	120	char *elf_error(int rc)
117	{	121	{
118	ASSERT(rc < sizeof(error_codes)/sizeof(char *));	122	ASSERT(rc < sizeof(error_codes)/sizeof(char *));
119		123
120	return error_codes[rc];	124	return error_codes[rc];
121	}	125	}
122		126
123	/** Process segment header.	127	/** Process segment header.
124	*	128	*
125	* @param entry Segment header.	129	* @param entry Segment header.
126	* @param elf ELF header.	130	* @param elf ELF header.
127	* @param as Address space into wich the ELF is being loaded.	131	* @param as Address space into wich the ELF is being loaded.
128	*	132	*
129	* @return EE_OK on success, error code otherwise.	133	* @return EE_OK on success, error code otherwise.
130	*/	134	*/
131	static int segment_header(elf_segment_header_t entry, elf_header_t elf, as_t *as)	135	static int segment_header(elf_segment_header_t entry, elf_header_t elf, as_t *as)
132	{	136	{
133	switch (entry->p_type) {	137	switch (entry->p_type) {
134	case PT_NULL:	138	case PT_NULL:
135	case PT_PHDR:	139	case PT_PHDR:
136	break;	140	break;
137	case PT_LOAD:	141	case PT_LOAD:
138	return load_segment(entry, elf, as);	142	return load_segment(entry, elf, as);
139	break;	143	break;
140	case PT_DYNAMIC:	144	case PT_DYNAMIC:
141	case PT_INTERP:	145	case PT_INTERP:
142	case PT_SHLIB:	146	case PT_SHLIB:
143	case PT_NOTE:	147	case PT_NOTE:
144	case PT_LOPROC:	148	case PT_LOPROC:
145	case PT_HIPROC:	149	case PT_HIPROC:
146	default:	150	default:
147	return EE_UNSUPPORTED;	151	return EE_UNSUPPORTED;
148	break;	152	break;
149	}	153	}
150	return EE_OK;	154	return EE_OK;
151	}	155	}
152		156
153	/** Load segment described by program header entry.	157	/** Load segment described by program header entry.
154	*	158	*
155	* @param entry Program header entry describing segment to be loaded.	159	* @param entry Program header entry describing segment to be loaded.
156	* @param elf ELF header.	160	* @param elf ELF header.
157	* @param as Address space into wich the ELF is being loaded.	161	* @param as Address space into wich the ELF is being loaded.
158	*	162	*
159	* @return EE_OK on success, error code otherwise.	163	* @return EE_OK on success, error code otherwise.
160	*/	164	*/
161	int load_segment(elf_segment_header_t entry, elf_header_t elf, as_t *as)	165	int load_segment(elf_segment_header_t entry, elf_header_t elf, as_t *as)
162	{	166	{
163	as_area_t *a;	167	as_area_t *a;
164	int flags = 0;	168	int flags = 0;
165	mem_backend_data_t backend_data;	169	mem_backend_data_t backend_data;
166		170
167	backend_data.elf = elf;	171	backend_data.elf = elf;
168	backend_data.segment = entry;	172	backend_data.segment = entry;
169		173
170	if (entry->p_align > 1) {	174	if (entry->p_align > 1) {
171	if ((entry->p_offset % entry->p_align) != (entry->p_vaddr % entry->p_align)) {	175	if ((entry->p_offset % entry->p_align) != (entry->p_vaddr % entry->p_align)) {
172	return EE_INVALID;	176	return EE_INVALID;
173	}	177	}
174	}	178	}
175		179
176	if (entry->p_flags & PF_X)	180	if (entry->p_flags & PF_X)
177	flags \|= AS_AREA_EXEC;	181	flags \|= AS_AREA_EXEC;
178	if (entry->p_flags & PF_W)	182	if (entry->p_flags & PF_W)
179	flags \|= AS_AREA_WRITE;	183	flags \|= AS_AREA_WRITE;
180	if (entry->p_flags & PF_R)	184	if (entry->p_flags & PF_R)
181	flags \|= AS_AREA_READ;	185	flags \|= AS_AREA_READ;
182	flags \|= AS_AREA_CACHEABLE;	186	flags \|= AS_AREA_CACHEABLE;
183		187
184	/*	188	/*
185	* Check if the virtual address starts on page boundary.	189	* Check if the virtual address starts on page boundary.
186	*/	190	*/
187	if (ALIGN_UP(entry->p_vaddr, PAGE_SIZE) != entry->p_vaddr)	191	if (ALIGN_UP(entry->p_vaddr, PAGE_SIZE) != entry->p_vaddr)
188	return EE_UNSUPPORTED;	192	return EE_UNSUPPORTED;
189		193
190	a = as_area_create(as, flags, entry->p_memsz, entry->p_vaddr, AS_AREA_ATTR_NONE,	194	a = as_area_create(as, flags, entry->p_memsz, entry->p_vaddr, AS_AREA_ATTR_NONE,
191	&elf_backend, &backend_data);	195	&elf_backend, &backend_data);
192	if (!a)	196	if (!a)
193	return EE_MEMORY;	197	return EE_MEMORY;
194		198
195	/*	199	/*
196	* The segment will be mapped on demand by elf_page_fault().	200	* The segment will be mapped on demand by elf_page_fault().
197	*/	201	*/
198		202
199	return EE_OK;	203	return EE_OK;
200	}	204	}
201		205
202	/** Process section header.	206	/** Process section header.
203	*	207	*
204	* @param entry Segment header.	208	* @param entry Segment header.
205	* @param elf ELF header.	209	* @param elf ELF header.
206	* @param as Address space into wich the ELF is being loaded.	210	* @param as Address space into wich the ELF is being loaded.
207	*	211	*
208	* @return EE_OK on success, error code otherwise.	212	* @return EE_OK on success, error code otherwise.
209	*/	213	*/
210	static int section_header(elf_section_header_t entry, elf_header_t elf, as_t *as)	214	static int section_header(elf_section_header_t entry, elf_header_t elf, as_t *as)
211	{	215	{
212	switch (entry->sh_type) {	216	switch (entry->sh_type) {
213	default:	217	default:
214	break;	218	break;
215	}	219	}
216		220
217	return EE_OK;	221	return EE_OK;
218	}	222	}
-		223
-		224	/** @}
-		225	*/
-		226
219		227

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/lib/elf.c – Rev 1425 → 1702