Subversion Repositories HelenOS

Rev

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