Subversion Repositories HelenOS

Rev

Rev 3223 | Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
3222 svoboda 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
static char *error_codes[] = {
61
    "no error",
62
    "invalid image",
63
    "address space error",
64
    "incompatible image",
65
    "unsupported image type",
66
    "irrecoverable error"
67
};
68
 
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);
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);
73
 
74
/** Load ELF binary from a file.
75
 *
76
 * Load an ELF binary from the specified file. If the file is
77
 * an executable program, it is loaded unbiased. If it is a shared
78
 * object, it is loaded with the bias @a so_bias. Some information
79
 * extracted from the binary is stored in a elf_info_t structure
80
 * pointed to by @a info.
81
 *
82
 * @param file_name Path to the ELF file.
83
 * @param so_bias   Bias to use if the file is a shared object.
84
 * @param info      Pointer to a structure for storing information
85
 *          extracted from the binary.
86
 *
87
 * @return EOK on success or negative error code.
88
 */
89
int elf_load_file(char *file_name, size_t so_bias, elf_info_t *info)
90
{
91
    elf_ld_t elf;
92
 
93
    int fd;
94
    int rc;
95
 
96
//  printf("open and read '%s'...\n", file_name);
97
 
98
    fd = open(file_name, O_RDONLY);
99
    if (fd < 0) {
100
        printf("failed opening file\n");
101
        return -1;
102
    }
103
 
104
    elf.fd = fd;
105
    elf.info = info;
106
 
107
    rc = elf_load(&elf, so_bias);
108
 
109
    close(fd);
110
 
111
    return rc;
112
}
113
 
114
/** Run an ELF executable.
115
 *
116
 * Transfers control to the entry point of an ELF executable loaded
117
 * earlier with elf_load_file(). This function does not return.
118
 *
119
 * @param info  Info structure filled earlier by elf_load_file()
120
 */
121
void elf_run(elf_info_t *info, pcb_t *pcb)
122
{
123
    program_run(info->entry, pcb);
124
 
125
    /* not reached */
126
}
127
 
128
/** Create the program control block (PCB).
129
 *
130
 * Fills the program control block @a pcb with information from
131
 * @a info.
132
 *
133
 * @param info  Program info structure
134
 * @return EOK on success or negative error code
135
 */
136
void elf_create_pcb(elf_info_t *info, pcb_t *pcb)
137
{
138
    pcb->entry = info->entry;
139
    pcb->dynamic = info->dynamic;
140
}
141
 
142
 
143
/** Load an ELF binary.
144
 *
145
 * The @a elf structure contains the loader state, including
146
 * an open file, from which the binary will be loaded,
147
 * a pointer to the @c info structure etc.
148
 *
149
 * @param elf       Pointer to loader state buffer.
150
 * @param so_bias   Bias to use if the file is a shared object.
151
 * @return EE_OK on success or EE_xx error code.
152
 */
153
static unsigned int elf_load(elf_ld_t *elf, size_t so_bias)
154
{
155
    elf_header_t header_buf;
156
    elf_header_t *header = &header_buf;
157
    int i, rc;
158
 
159
    rc = read(elf->fd, header, sizeof(elf_header_t));
160
    if (rc < 0) {
161
        printf("read error\n");
162
        return EE_INVALID;
163
    }
164
 
165
    elf->header = header;
166
 
167
//  printf("ELF-load:");
168
    /* Identify ELF */
169
    if (header->e_ident[EI_MAG0] != ELFMAG0 ||
170
        header->e_ident[EI_MAG1] != ELFMAG1 ||
171
        header->e_ident[EI_MAG2] != ELFMAG2 ||
172
        header->e_ident[EI_MAG3] != ELFMAG3) {
173
        printf("invalid header\n");
174
        return EE_INVALID;
175
    }
176
 
177
    /* Identify ELF compatibility */
178
    if (header->e_ident[EI_DATA] != ELF_DATA_ENCODING ||
179
        header->e_machine != ELF_MACHINE ||
180
        header->e_ident[EI_VERSION] != EV_CURRENT ||
181
        header->e_version != EV_CURRENT ||
182
        header->e_ident[EI_CLASS] != ELF_CLASS) {
183
        printf("incompatible data/version/class\n");
184
        return EE_INCOMPATIBLE;
185
    }
186
 
187
    if (header->e_phentsize != sizeof(elf_segment_header_t)) {
188
        printf("e_phentsize:%d != %d\n", header->e_phentsize,
189
            sizeof(elf_segment_header_t));
190
        return EE_INCOMPATIBLE;
191
    }
192
 
193
    if (header->e_shentsize != sizeof(elf_section_header_t)) {
194
        printf("e_shentsize:%d != %d\n", header->e_shentsize,
195
            sizeof(elf_section_header_t));
196
        return EE_INCOMPATIBLE;
197
    }
198
 
199
    /* Check if the object type is supported. */
200
    if (header->e_type != ET_EXEC && header->e_type != ET_DYN) {
201
        printf("Object type %d is not supported\n", header->e_type);
202
        return EE_UNSUPPORTED;
203
    }
204
 
205
    /* Shared objects can be loaded with a bias */
206
//  printf("Object type: %d\n", header->e_type);
207
    if (header->e_type == ET_DYN)
208
        elf->bias = so_bias;
209
    else
210
        elf->bias = 0;
211
 
212
//  printf("Bias set to 0x%x\n", elf->bias);
213
    elf->info->interp = NULL;
214
    elf->info->dynamic = NULL;
215
 
216
//  printf("parse segments\n");
217
 
218
    /* Walk through all segment headers and process them. */
219
    for (i = 0; i < header->e_phnum; i++) {
220
        elf_segment_header_t segment_hdr;
221
 
222
        /* Seek to start of segment header */
223
        lseek(elf->fd, header->e_phoff
224
                + i * sizeof(elf_segment_header_t), SEEK_SET);
225
 
226
        rc = read(elf->fd, &segment_hdr, sizeof(elf_segment_header_t));
227
        if (rc < 0) { printf("read error\n"); return EE_INVALID; }
228
 
229
        rc = segment_header(elf, &segment_hdr);
230
        if (rc != EE_OK)
231
            return rc;
232
    }
233
 
234
//  printf("parse sections\n");
235
 
236
    /* Inspect all section headers and proccess them. */
237
    for (i = 0; i < header->e_shnum; i++) {
238
        elf_section_header_t section_hdr;
239
 
240
        /* Seek to start of section header */
241
        lseek(elf->fd, header->e_shoff
242
            + i * sizeof(elf_section_header_t), SEEK_SET);
243
 
244
        rc = read(elf->fd, &section_hdr, sizeof(elf_section_header_t));
245
        if (rc < 0) { printf("read error\n"); return EE_INVALID; }
246
 
247
        rc = section_header(elf, &section_hdr);
248
        if (rc != EE_OK)
249
            return rc;
250
    }
251
 
252
    elf->info->entry =
253
        (entry_point_t)((uint8_t *)header->e_entry + elf->bias);
254
 
255
//  printf("done\n");
256
 
257
    return EE_OK;
258
}
259
 
260
/** Print error message according to error code.
261
 *
262
 * @param rc Return code returned by elf_load().
263
 *
264
 * @return NULL terminated description of error.
265
 */
266
char *elf_error(unsigned int rc)
267
{
268
    assert(rc < sizeof(error_codes) / sizeof(char *));
269
 
270
    return error_codes[rc];
271
}
272
 
273
/** Process segment header.
274
 *
275
 * @param entry Segment header.
276
 *
277
 * @return EE_OK on success, error code otherwise.
278
 */
279
static int segment_header(elf_ld_t *elf, elf_segment_header_t *entry)
280
{
281
    switch (entry->p_type) {
282
    case PT_NULL:
283
    case PT_PHDR:
284
        break;
285
    case PT_LOAD:
286
        return load_segment(elf, entry);
287
        break;
288
    case PT_INTERP:
289
        /* Assume silently interp == "/rtld.so" */
290
        elf->info->interp = "/rtld.so";
291
        break;
292
    case PT_DYNAMIC:
293
    case PT_SHLIB:
294
    case PT_NOTE:
295
    case PT_LOPROC:
296
    case PT_HIPROC:
297
    default:
298
        printf("segment p_type %d unknown\n", entry->p_type);
299
        return EE_UNSUPPORTED;
300
        break;
301
    }
302
    return EE_OK;
303
}
304
 
305
/** Load segment described by program header entry.
306
 *
307
 * @param elf   Loader state.
308
 * @param entry Program header entry describing segment to be loaded.
309
 *
310
 * @return EE_OK on success, error code otherwise.
311
 */
312
int load_segment(elf_ld_t *elf, elf_segment_header_t *entry)
313
{
314
    void *a;
315
    int flags = 0;
316
    uintptr_t bias;
317
    uintptr_t base;
318
    size_t mem_sz;
319
    int rc;
320
 
321
//  printf("load segment at addr 0x%x, size 0x%x\n", entry->p_vaddr,
322
//      entry->p_memsz);
323
 
324
    bias = elf->bias;
325
 
326
    if (entry->p_align > 1) {
327
        if ((entry->p_offset % entry->p_align) !=
328
            (entry->p_vaddr % entry->p_align)) {
329
            printf("align check 1 failed offset%%align=%d, vaddr%%align=%d\n",
330
            entry->p_offset % entry->p_align,
331
            entry->p_vaddr % entry->p_align
332
            );
333
            return EE_INVALID;
334
        }
335
    }
336
 
337
    /* Final flags that will be set for the memory area */
338
 
339
    if (entry->p_flags & PF_X)
340
        flags |= AS_AREA_EXEC;
341
    if (entry->p_flags & PF_W)
342
        flags |= AS_AREA_WRITE;
343
    if (entry->p_flags & PF_R)
344
        flags |= AS_AREA_READ;
345
    flags |= AS_AREA_CACHEABLE;
346
 
347
    base = ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE);
348
    mem_sz = entry->p_memsz + (entry->p_vaddr - base);
349
 
350
//  printf("map to p_vaddr=0x%x-0x%x...\n", entry->p_vaddr + bias,
351
//  entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));
352
 
353
    /*
354
     * For the course of loading, the area needs to be readable
355
     * and writeable.
356
     */
357
    a = as_area_create((uint8_t *)base + bias,
358
        mem_sz, AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
359
    if (a == (void *)(-1)) {
360
        printf("memory mapping failed\n");
361
        return EE_MEMORY;
362
    }
363
 
364
//  printf("as_area_create(0x%lx, 0x%x, %d) -> 0x%lx\n",
365
//      entry->p_vaddr+bias, entry->p_memsz, flags, (uintptr_t)a);
366
 
367
    /*
368
     * Load segment data
369
     */
370
//  printf("seek to %d\n", entry->p_offset);
371
    rc = lseek(elf->fd, entry->p_offset, SEEK_SET);
372
    if (rc < 0) { printf("seek error\n"); return EE_INVALID; }
373
 
374
//  printf("read 0x%x bytes to address 0x%x\n", entry->p_filesz, entry->p_vaddr+bias);
375
/*  rc = read(fd, (void *)(entry->p_vaddr + bias), entry->p_filesz);
376
    if (rc < 0) { printf("read error\n"); return EE_INVALID; }*/
377
 
378
    /* Long reads are not possible yet. Load segment picewise */
379
 
380
    unsigned left, now;
381
    uint8_t *dp;
382
 
383
    left = entry->p_filesz;
384
    dp = (uint8_t *)(entry->p_vaddr + bias);
385
 
386
    while (left > 0) {
387
        now = 16384;
388
        if (now > left) now = left;
389
 
390
//      printf("read %d...", now);
391
        rc = read(elf->fd, dp, now);
392
//      printf("->%d\n", rc);
393
 
394
        if (rc < 0) { printf("read error\n"); return EE_INVALID; }
395
 
396
        left -= now;
397
        dp += now;
398
    }
399
 
400
//  printf("set area flags to %d\n", flags);
401
    rc = as_area_change_flags((uint8_t *)entry->p_vaddr + bias, flags);
402
    if (rc != 0) {
403
        printf("failed to set memory area flags\n");
404
        return EE_MEMORY;
405
    }
406
 
407
    if (flags & AS_AREA_EXEC) {
408
        /* Enforce SMC coherence for the segment */
409
        if (smc_coherence(entry->p_vaddr + bias, entry->p_filesz))
410
            return EE_MEMORY;
411
    }
412
 
413
    return EE_OK;
414
}
415
 
416
/** Process section header.
417
 *
418
 * @param elf   Loader state.
419
 * @param entry Segment header.
420
 *
421
 * @return EE_OK on success, error code otherwise.
422
 */
423
static int section_header(elf_ld_t *elf, elf_section_header_t *entry)
424
{
425
    switch (entry->sh_type) {
426
    case SHT_PROGBITS:
427
        if (entry->sh_flags & SHF_TLS) {
428
            /* .tdata */
429
        }
430
        break;
431
    case SHT_NOBITS:
432
        if (entry->sh_flags & SHF_TLS) {
433
            /* .tbss */
434
        }
435
        break;
436
    case SHT_DYNAMIC:
437
        /* Record pointer to dynamic section into info structure */
438
        elf->info->dynamic =
439
            (void *)((uint8_t *)entry->sh_addr + elf->bias);
440
        printf("dynamic section found at 0x%x\n",
441
            (uintptr_t)elf->info->dynamic);
442
        break;
443
    default:
444
        break;
445
    }
446
 
447
    return EE_OK;
448
}
449
 
450
/** @}
451
 */