source: mainline/uspace/srv/loader/elf_load.c@ b50b5af2

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since b50b5af2 was 1ea99cc, checked in by Jiri Svoboda <jiri@…>, 16 years ago

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