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



 
#include "elf.h"
#include "elf_load.h"
#include "arch.h"
 
#define DPRINTF(...)
 
static char *error_codes[] = {
    "no error",
    "invalid image",
    "address space error",
    "incompatible image",

    elf_ld_t elf;
 
    int fd;
    int rc;
 
 
 
    fd = open(file_name, O_RDONLY);
    if (fd < 0) {
        DPRINTF("failed opening file\n");
        return -1;
    }
 
    elf.fd = fd;
    elf.info = info;

    elf_header_t *header = &header_buf;
    int i, rc;
 
    rc = my_read(elf->fd, header, sizeof(elf_header_t));
    if (rc < 0) {
        DPRINTF("Read error.\n");
        return EE_INVALID;
    }
 
    elf->header = header;
 
 
    /* 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) {
        DPRINTF("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) {
        DPRINTF("Incompatible data/version/class.\n");
        return EE_INCOMPATIBLE;
    }
 
    if (header->e_phentsize != sizeof(elf_segment_header_t)) {
        DPRINTF("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)) {
        DPRINTF("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) {
        DPRINTF("Object type %d is not supported\n", header->e_type);
        return EE_UNSUPPORTED;
    }
 
    /* Shared objects can be loaded with a bias */
 
    if (header->e_type == ET_DYN)
        elf->bias = so_bias;
    else
        elf->bias = 0;
 
 
    elf->info->interp = NULL;
    elf->info->dynamic = NULL;
 
 
 
    /* 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 */

                + i * sizeof(elf_segment_header_t), SEEK_SET);
 
        rc = my_read(elf->fd, &segment_hdr,
            sizeof(elf_segment_header_t));
        if (rc < 0) {
            DPRINTF("Read error.\n");
            return EE_INVALID;
        }
 
        rc = segment_header(elf, &segment_hdr);
        if (rc != EE_OK)
            return rc;
    }
 
    DPRINTF("Parse sections.\n");
 
    /* Inspect all section headers and proccess them. */
    for (i = 0; i < header->e_shnum; i++) {
        elf_section_header_t section_hdr;
 

            + i * sizeof(elf_section_header_t), SEEK_SET);
 
        rc = my_read(elf->fd, &section_hdr,
            sizeof(elf_section_header_t));
        if (rc < 0) {
            DPRINTF("Read error.\n");
            return EE_INVALID;
        }
 
        rc = section_header(elf, &section_hdr);
        if (rc != EE_OK)

    }
 
    elf->info->entry =
        (entry_point_t)((uint8_t *)header->e_entry + elf->bias);
 
    DPRINTF("Done.\n");
 
    return EE_OK;
}
 
/** Print error message according to error code.

    case PT_SHLIB:
    case PT_NOTE:
    case PT_LOPROC:
    case PT_HIPROC:
    default:
        DPRINTF("Segment p_type %d unknown.\n", entry->p_type);
        return EE_UNSUPPORTED;
        break;
    }
    return EE_OK;
}

    uintptr_t bias;
    uintptr_t base;
    size_t mem_sz;
    int rc;
 
    DPRINTF("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)) {
            DPRINTF("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;

    flags |= AS_AREA_CACHEABLE;
   
    base = ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE);
    mem_sz = entry->p_memsz + (entry->p_vaddr - base);
 
    DPRINTF("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)) {
        DPRINTF("Memory mapping failed.\n");
        return EE_MEMORY;
    }
 
    DPRINTF("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
     */
 
    rc = lseek(elf->fd, entry->p_offset, SEEK_SET);
    if (rc < 0) {
        printf("seek error\n");
        return EE_INVALID;
    }
 
 
/*  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 piecewise. */
 
    unsigned left, now;
    uint8_t *dp;
 
    left = entry->p_filesz;

 
    while (left > 0) {
        now = 16384;
        if (now > left) now = left;
 
 
        rc = my_read(elf->fd, dp, now);
 
 
        if (rc < 0) {
            DPRINTF("Read error.\n");
            return EE_INVALID;
        }
 
        left -= now;
        dp += now;
    }
 
 
    rc = as_area_change_flags((uint8_t *)entry->p_vaddr + bias, flags);
    if (rc != 0) {
        DPRINTF("Failed to set memory area flags.\n");
        return EE_MEMORY;
    }
 
    if (flags & AS_AREA_EXEC) {
        /* Enforce SMC coherence for the segment */

        break;
    case SHT_DYNAMIC:
        /* Record pointer to dynamic section into info structure */
        elf->info->dynamic =
            (void *)((uint8_t *)entry->sh_addr + elf->bias);
        DPRINTF("Dynamic section found at 0x%x.\n",
            (uintptr_t)elf->info->dynamic);
        break;
    default:
        break;
    }

Rev 3386	Rev 4153
Line 55...	Line 55...
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	#define DPRINTF(...)
-		61
60	static char *error_codes[] = {	62	static char *error_codes[] = {
61	"no error",	63	"no error",
62	"invalid image",	64	"invalid image",
63	"address space error",	65	"address space error",
64	"incompatible image",	66	"incompatible image",
Line 104...	Line 106...
104	elf_ld_t elf;	106	elf_ld_t elf;
105		107
106	int fd;	108	int fd;
107	int rc;	109	int rc;
108		110
109	// printf("open and read '%s'...\n", file_name);	-
110		-
111	fd = open(file_name, O_RDONLY);	111	fd = open(file_name, O_RDONLY);
112	if (fd < 0) {	112	if (fd < 0) {
113	printf("failed opening file\n");	113	DPRINTF("failed opening file\n");
114	return -1;	114	return -1;
115	}	115	}
116		116
117	elf.fd = fd;	117	elf.fd = fd;
118	elf.info = info;	118	elf.info = info;
Line 169...	Line 169...
169	elf_header_t *header = &header_buf;	169	elf_header_t *header = &header_buf;
170	int i, rc;	170	int i, rc;
171		171
172	rc = my_read(elf->fd, header, sizeof(elf_header_t));	172	rc = my_read(elf->fd, header, sizeof(elf_header_t));
173	if (rc < 0) {	173	if (rc < 0) {
174	printf("read error\n");	174	DPRINTF("Read error.\n");
175	return EE_INVALID;	175	return EE_INVALID;
176	}	176	}
177		177
178	elf->header = header;	178	elf->header = header;
179		179
180	// printf("ELF-load:");	-
181	/* Identify ELF */	180	/* Identify ELF */
182	if (header->e_ident[EI_MAG0] != ELFMAG0 \|\|	181	if (header->e_ident[EI_MAG0] != ELFMAG0 \|\|
183	header->e_ident[EI_MAG1] != ELFMAG1 \|\|	182	header->e_ident[EI_MAG1] != ELFMAG1 \|\|
184	header->e_ident[EI_MAG2] != ELFMAG2 \|\|	183	header->e_ident[EI_MAG2] != ELFMAG2 \|\|
185	header->e_ident[EI_MAG3] != ELFMAG3) {	184	header->e_ident[EI_MAG3] != ELFMAG3) {
186	printf("invalid header\n");	185	DPRINTF("Invalid header.\n");
187	return EE_INVALID;	186	return EE_INVALID;
188	}	187	}
189		188
190	/* Identify ELF compatibility */	189	/* Identify ELF compatibility */
191	if (header->e_ident[EI_DATA] != ELF_DATA_ENCODING \|\|	190	if (header->e_ident[EI_DATA] != ELF_DATA_ENCODING \|\|
192	header->e_machine != ELF_MACHINE \|\|	191	header->e_machine != ELF_MACHINE \|\|
193	header->e_ident[EI_VERSION] != EV_CURRENT \|\|	192	header->e_ident[EI_VERSION] != EV_CURRENT \|\|
194	header->e_version != EV_CURRENT \|\|	193	header->e_version != EV_CURRENT \|\|
195	header->e_ident[EI_CLASS] != ELF_CLASS) {	194	header->e_ident[EI_CLASS] != ELF_CLASS) {
196	printf("incompatible data/version/class\n");	195	DPRINTF("Incompatible data/version/class.\n");
197	return EE_INCOMPATIBLE;	196	return EE_INCOMPATIBLE;
198	}	197	}
199		198
200	if (header->e_phentsize != sizeof(elf_segment_header_t)) {	199	if (header->e_phentsize != sizeof(elf_segment_header_t)) {
201	printf("e_phentsize:%d != %d\n", header->e_phentsize,	200	DPRINTF("e_phentsize:%d != %d\n", header->e_phentsize,
202	sizeof(elf_segment_header_t));	201	sizeof(elf_segment_header_t));
203	return EE_INCOMPATIBLE;	202	return EE_INCOMPATIBLE;
204	}	203	}
205		204
206	if (header->e_shentsize != sizeof(elf_section_header_t)) {	205	if (header->e_shentsize != sizeof(elf_section_header_t)) {
207	printf("e_shentsize:%d != %d\n", header->e_shentsize,	206	DPRINTF("e_shentsize:%d != %d\n", header->e_shentsize,
208	sizeof(elf_section_header_t));	207	sizeof(elf_section_header_t));
209	return EE_INCOMPATIBLE;	208	return EE_INCOMPATIBLE;
210	}	209	}
211		210
212	/* Check if the object type is supported. */	211	/* Check if the object type is supported. */
213	if (header->e_type != ET_EXEC && header->e_type != ET_DYN) {	212	if (header->e_type != ET_EXEC && header->e_type != ET_DYN) {
214	printf("Object type %d is not supported\n", header->e_type);	213	DPRINTF("Object type %d is not supported\n", header->e_type);
215	return EE_UNSUPPORTED;	214	return EE_UNSUPPORTED;
216	}	215	}
217		216
218	/* Shared objects can be loaded with a bias */	217	/* Shared objects can be loaded with a bias */
219	// printf("Object type: %d\n", header->e_type);	-
220	if (header->e_type == ET_DYN)	218	if (header->e_type == ET_DYN)
221	elf->bias = so_bias;	219	elf->bias = so_bias;
222	else	220	else
223	elf->bias = 0;	221	elf->bias = 0;
224		222
225	// printf("Bias set to 0x%x\n", elf->bias);	-
226	elf->info->interp = NULL;	223	elf->info->interp = NULL;
227	elf->info->dynamic = NULL;	224	elf->info->dynamic = NULL;
228		225
229	// printf("parse segments\n");	-
230		-
231	/* Walk through all segment headers and process them. */	226	/* Walk through all segment headers and process them. */
232	for (i = 0; i < header->e_phnum; i++) {	227	for (i = 0; i < header->e_phnum; i++) {
233	elf_segment_header_t segment_hdr;	228	elf_segment_header_t segment_hdr;
234		229
235	/* Seek to start of segment header */	230	/* Seek to start of segment header */
Line 237...	Line 232...
237	+ i * sizeof(elf_segment_header_t), SEEK_SET);	232	+ i * sizeof(elf_segment_header_t), SEEK_SET);
238		233
239	rc = my_read(elf->fd, &segment_hdr,	234	rc = my_read(elf->fd, &segment_hdr,
240	sizeof(elf_segment_header_t));	235	sizeof(elf_segment_header_t));
241	if (rc < 0) {	236	if (rc < 0) {
242	printf("read error\n");	237	DPRINTF("Read error.\n");
243	return EE_INVALID;	238	return EE_INVALID;
244	}	239	}
245		240
246	rc = segment_header(elf, &segment_hdr);	241	rc = segment_header(elf, &segment_hdr);
247	if (rc != EE_OK)	242	if (rc != EE_OK)
248	return rc;	243	return rc;
249	}	244	}
250		245
251	// printf("parse sections\n");	246	DPRINTF("Parse sections.\n");
252		247
253	/* Inspect all section headers and proccess them. */	248	/* Inspect all section headers and proccess them. */
254	for (i = 0; i < header->e_shnum; i++) {	249	for (i = 0; i < header->e_shnum; i++) {
255	elf_section_header_t section_hdr;	250	elf_section_header_t section_hdr;
256		251
Line 259...	Line 254...
259	+ i * sizeof(elf_section_header_t), SEEK_SET);	254	+ i * sizeof(elf_section_header_t), SEEK_SET);
260		255
261	rc = my_read(elf->fd, &section_hdr,	256	rc = my_read(elf->fd, &section_hdr,
262	sizeof(elf_section_header_t));	257	sizeof(elf_section_header_t));
263	if (rc < 0) {	258	if (rc < 0) {
264	printf("read error\n");	259	DPRINTF("Read error.\n");
265	return EE_INVALID;	260	return EE_INVALID;
266	}	261	}
267		262
268	rc = section_header(elf, &section_hdr);	263	rc = section_header(elf, &section_hdr);
269	if (rc != EE_OK)	264	if (rc != EE_OK)
Line 271...	Line 266...
271	}	266	}
272		267
273	elf->info->entry =	268	elf->info->entry =
274	(entry_point_t)((uint8_t *)header->e_entry + elf->bias);	269	(entry_point_t)((uint8_t *)header->e_entry + elf->bias);
275		270
276	// printf("done\n");	271	DPRINTF("Done.\n");
277		272
278	return EE_OK;	273	return EE_OK;
279	}	274	}
280		275
281	/** Print error message according to error code.	276	/** Print error message according to error code.
Line 314...	Line 309...
314	case PT_SHLIB:	309	case PT_SHLIB:
315	case PT_NOTE:	310	case PT_NOTE:
316	case PT_LOPROC:	311	case PT_LOPROC:
317	case PT_HIPROC:	312	case PT_HIPROC:
318	default:	313	default:
319	printf("segment p_type %d unknown\n", entry->p_type);	314	DPRINTF("Segment p_type %d unknown.\n", entry->p_type);
320	return EE_UNSUPPORTED;	315	return EE_UNSUPPORTED;
321	break;	316	break;
322	}	317	}
323	return EE_OK;	318	return EE_OK;
324	}	319	}
Line 337...	Line 332...
337	uintptr_t bias;	332	uintptr_t bias;
338	uintptr_t base;	333	uintptr_t base;
339	size_t mem_sz;	334	size_t mem_sz;
340	int rc;	335	int rc;
341		336
342	// printf("load segment at addr 0x%x, size 0x%x\n", entry->p_vaddr,	337	DPRINTF("Load segment at addr 0x%x, size 0x%x\n", entry->p_vaddr,
343	// entry->p_memsz);	338	entry->p_memsz);
344		339
345	bias = elf->bias;	340	bias = elf->bias;
346		341
347	if (entry->p_align > 1) {	342	if (entry->p_align > 1) {
348	if ((entry->p_offset % entry->p_align) !=	343	if ((entry->p_offset % entry->p_align) !=
349	(entry->p_vaddr % entry->p_align)) {	344	(entry->p_vaddr % entry->p_align)) {
350	printf("align check 1 failed offset%%align=%d, "	345	DPRINTF("Align check 1 failed offset%%align=%d, "
351	"vaddr%%align=%d\n",	346	"vaddr%%align=%d\n",
352	entry->p_offset % entry->p_align,	347	entry->p_offset % entry->p_align,
353	entry->p_vaddr % entry->p_align	348	entry->p_vaddr % entry->p_align
354	);	349	);
355	return EE_INVALID;	350	return EE_INVALID;
Line 367...	Line 362...
367	flags \|= AS_AREA_CACHEABLE;	362	flags \|= AS_AREA_CACHEABLE;
368		363
369	base = ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE);	364	base = ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE);
370	mem_sz = entry->p_memsz + (entry->p_vaddr - base);	365	mem_sz = entry->p_memsz + (entry->p_vaddr - base);
371		366
372	// printf("map to p_vaddr=0x%x-0x%x...\n", entry->p_vaddr + bias,	367	DPRINTF("Map to p_vaddr=0x%x-0x%x.\n", entry->p_vaddr + bias,
373	// entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));	368	entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));
374		369
375	/*	370	/*
376	* For the course of loading, the area needs to be readable	371	* For the course of loading, the area needs to be readable
377	* and writeable.	372	* and writeable.
378	*/	373	*/
379	a = as_area_create((uint8_t *)base + bias, mem_sz,	374	a = as_area_create((uint8_t *)base + bias, mem_sz,
380	AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE);	375	AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE);
381	if (a == (void *)(-1)) {	376	if (a == (void *)(-1)) {
382	printf("memory mapping failed\n");	377	DPRINTF("Memory mapping failed.\n");
383	return EE_MEMORY;	378	return EE_MEMORY;
384	}	379	}
385		380
386	// printf("as_area_create(0x%lx, 0x%x, %d) -> 0x%lx\n",	381	DPRINTF("as_area_create(0x%lx, 0x%x, %d) -> 0x%lx\n",
387	// entry->p_vaddr+bias, entry->p_memsz, flags, (uintptr_t)a);	382	entry->p_vaddr+bias, entry->p_memsz, flags, (uintptr_t)a);
388		383
389	/*	384	/*
390	* Load segment data	385	* Load segment data
391	*/	386	*/
392	// printf("seek to %d\n", entry->p_offset);	-
393	rc = lseek(elf->fd, entry->p_offset, SEEK_SET);	387	rc = lseek(elf->fd, entry->p_offset, SEEK_SET);
394	if (rc < 0) {	388	if (rc < 0) {
395	printf("seek error\n");	389	printf("seek error\n");
396	return EE_INVALID;	390	return EE_INVALID;
397	}	391	}
398		392
399	// printf("read 0x%x bytes to address 0x%x\n", entry->p_filesz, entry->p_vaddr+bias);	-
400	/* rc = read(fd, (void *)(entry->p_vaddr + bias), entry->p_filesz);	393	/* rc = read(fd, (void *)(entry->p_vaddr + bias), entry->p_filesz);
401	if (rc < 0) { printf("read error\n"); return EE_INVALID; }*/	394	if (rc < 0) { printf("read error\n"); return EE_INVALID; }*/
402		395
403	/* Long reads are not possible yet. Load segment picewise */	396	/* Long reads are not possible yet. Load segment piecewise. */
404		397
405	unsigned left, now;	398	unsigned left, now;
406	uint8_t *dp;	399	uint8_t *dp;
407		400
408	left = entry->p_filesz;	401	left = entry->p_filesz;
Line 410...	Line 403...
410		403
411	while (left > 0) {	404	while (left > 0) {
412	now = 16384;	405	now = 16384;
413	if (now > left) now = left;	406	if (now > left) now = left;
414		407
415	// printf("read %d...", now);	-
416	rc = my_read(elf->fd, dp, now);	408	rc = my_read(elf->fd, dp, now);
417	// printf("->%d\n", rc);	-
418		409
419	if (rc < 0) {	410	if (rc < 0) {
420	printf("read error\n");	411	DPRINTF("Read error.\n");
421	return EE_INVALID;	412	return EE_INVALID;
422	}	413	}
423		414
424	left -= now;	415	left -= now;
425	dp += now;	416	dp += now;
426	}	417	}
427		418
428	// printf("set area flags to %d\n", flags);	-
429	rc = as_area_change_flags((uint8_t *)entry->p_vaddr + bias, flags);	419	rc = as_area_change_flags((uint8_t *)entry->p_vaddr + bias, flags);
430	if (rc != 0) {	420	if (rc != 0) {
431	printf("failed to set memory area flags\n");	421	DPRINTF("Failed to set memory area flags.\n");
432	return EE_MEMORY;	422	return EE_MEMORY;
433	}	423	}
434		424
435	if (flags & AS_AREA_EXEC) {	425	if (flags & AS_AREA_EXEC) {
436	/* Enforce SMC coherence for the segment */	426	/* Enforce SMC coherence for the segment */
Line 463...	Line 453...
463	break;	453	break;
464	case SHT_DYNAMIC:	454	case SHT_DYNAMIC:
465	/* Record pointer to dynamic section into info structure */	455	/* Record pointer to dynamic section into info structure */
466	elf->info->dynamic =	456	elf->info->dynamic =
467	(void )((uint8_t )entry->sh_addr + elf->bias);	457	(void )((uint8_t )entry->sh_addr + elf->bias);
468	printf("dynamic section found at 0x%x\n",	458	DPRINTF("Dynamic section found at 0x%x.\n",
469	(uintptr_t)elf->info->dynamic);	459	(uintptr_t)elf->info->dynamic);
470	break;	460	break;
471	default:	461	default:
472	break;	462	break;
473	}	463	}

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/loader/elf_load.c – Rev 3386 → 4153