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


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

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/lib/elf.c – Rev 1239 → 1248