Subversion Repositories HelenOS

Rev

Rev 4338 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2928 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
3101 svoboda 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.
2928 svoboda 44
 */
45
 
46
#include <stdio.h>
47
#include <sys/types.h>
48
#include <align.h>
49
#include <assert.h>
50
#include <as.h>
2962 svoboda 51
#include <unistd.h>
52
#include <fcntl.h>
3210 svoboda 53
#include <smc.h>
3160 svoboda 54
#include <loader/pcb.h>
2962 svoboda 55
 
2928 svoboda 56
#include "elf.h"
2962 svoboda 57
#include "elf_load.h"
3131 svoboda 58
#include "arch.h"
2928 svoboda 59
 
4338 svoboda 60
#define DPRINTF(...)
61
 
2928 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
 
2972 svoboda 71
static unsigned int elf_load(elf_ld_t *elf, size_t so_bias);
2964 svoboda 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);
2928 svoboda 75
 
3403 svoboda 76
/** Read until the buffer is read in its entirety. */
4691 svoboda 77
static int my_read(int fd, void *buf, size_t len)
3403 svoboda 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
 
3101 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
 */
3552 svoboda 104
int elf_load_file(char *file_name, size_t so_bias, eld_flags_t flags,
105
    elf_info_t *info)
2964 svoboda 106
{
107
    elf_ld_t elf;
2928 svoboda 108
 
2962 svoboda 109
    int fd;
110
    int rc;
111
 
3101 svoboda 112
    fd = open(file_name, O_RDONLY);
2962 svoboda 113
    if (fd < 0) {
4338 svoboda 114
        DPRINTF("failed opening file\n");
2962 svoboda 115
        return -1;
116
    }
117
 
2964 svoboda 118
    elf.fd = fd;
119
    elf.info = info;
3552 svoboda 120
    elf.flags = flags;
2964 svoboda 121
 
2972 svoboda 122
    rc = elf_load(&elf, so_bias);
2962 svoboda 123
 
124
    close(fd);
125
 
126
    return rc;
127
}
128
 
3101 svoboda 129
/** Create the program control block (PCB).
130
 *
3170 svoboda 131
 * Fills the program control block @a pcb with information from
132
 * @a info.
3101 svoboda 133
 *
134
 * @param info  Program info structure
135
 * @return EOK on success or negative error code
136
 */
3170 svoboda 137
void elf_create_pcb(elf_info_t *info, pcb_t *pcb)
2962 svoboda 138
{
2964 svoboda 139
    pcb->entry = info->entry;
2965 svoboda 140
    pcb->dynamic = info->dynamic;
3686 svoboda 141
    pcb->rtld_runtime = NULL;
2962 svoboda 142
}
143
 
144
 
3101 svoboda 145
/** Load an ELF binary.
2928 svoboda 146
 *
3101 svoboda 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.
2928 svoboda 154
 */
2972 svoboda 155
static unsigned int elf_load(elf_ld_t *elf, size_t so_bias)
2928 svoboda 156
{
2964 svoboda 157
    elf_header_t header_buf;
158
    elf_header_t *header = &header_buf;
2928 svoboda 159
    int i, rc;
160
 
3403 svoboda 161
    rc = my_read(elf->fd, header, sizeof(elf_header_t));
2928 svoboda 162
    if (rc < 0) {
4338 svoboda 163
        DPRINTF("Read error.\n");
2928 svoboda 164
        return EE_INVALID;
165
    }
166
 
2964 svoboda 167
    elf->header = header;
168
 
2928 svoboda 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) {
4338 svoboda 174
        DPRINTF("Invalid header.\n");
2928 svoboda 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) {
4338 svoboda 184
        DPRINTF("Incompatible data/version/class.\n");
2928 svoboda 185
        return EE_INCOMPATIBLE;
186
    }
187
 
2992 svoboda 188
    if (header->e_phentsize != sizeof(elf_segment_header_t)) {
4338 svoboda 189
        DPRINTF("e_phentsize:%d != %d\n", header->e_phentsize,
2992 svoboda 190
            sizeof(elf_segment_header_t));
2928 svoboda 191
        return EE_INCOMPATIBLE;
2992 svoboda 192
    }
2928 svoboda 193
 
2992 svoboda 194
    if (header->e_shentsize != sizeof(elf_section_header_t)) {
4338 svoboda 195
        DPRINTF("e_shentsize:%d != %d\n", header->e_shentsize,
2992 svoboda 196
            sizeof(elf_section_header_t));
2928 svoboda 197
        return EE_INCOMPATIBLE;
2992 svoboda 198
    }
2928 svoboda 199
 
200
    /* Check if the object type is supported. */
201
    if (header->e_type != ET_EXEC && header->e_type != ET_DYN) {
4338 svoboda 202
        DPRINTF("Object type %d is not supported\n", header->e_type);
2928 svoboda 203
        return EE_UNSUPPORTED;
204
    }
205
 
2972 svoboda 206
    /* Shared objects can be loaded with a bias */
2964 svoboda 207
    if (header->e_type == ET_DYN)
2972 svoboda 208
        elf->bias = so_bias;
2964 svoboda 209
    else
210
        elf->bias = 0;
211
 
3004 svoboda 212
    elf->info->interp = NULL;
213
    elf->info->dynamic = NULL;
2971 svoboda 214
 
2928 svoboda 215
    /* Walk through all segment headers and process them. */
216
    for (i = 0; i < header->e_phnum; i++) {
2964 svoboda 217
        elf_segment_header_t segment_hdr;
2928 svoboda 218
 
2961 svoboda 219
        /* Seek to start of segment header */
2964 svoboda 220
        lseek(elf->fd, header->e_phoff
221
                + i * sizeof(elf_segment_header_t), SEEK_SET);
2928 svoboda 222
 
3403 svoboda 223
        rc = my_read(elf->fd, &segment_hdr,
224
            sizeof(elf_segment_header_t));
225
        if (rc < 0) {
4338 svoboda 226
            DPRINTF("Read error.\n");
3403 svoboda 227
            return EE_INVALID;
228
        }
2964 svoboda 229
 
230
        rc = segment_header(elf, &segment_hdr);
2928 svoboda 231
        if (rc != EE_OK)
232
            return rc;
233
    }
234
 
4338 svoboda 235
    DPRINTF("Parse sections.\n");
2928 svoboda 236
 
237
    /* Inspect all section headers and proccess them. */
238
    for (i = 0; i < header->e_shnum; i++) {
2964 svoboda 239
        elf_section_header_t section_hdr;
2928 svoboda 240
 
2961 svoboda 241
        /* Seek to start of section header */
2964 svoboda 242
        lseek(elf->fd, header->e_shoff
243
            + i * sizeof(elf_section_header_t), SEEK_SET);
2961 svoboda 244
 
3403 svoboda 245
        rc = my_read(elf->fd, &section_hdr,
246
            sizeof(elf_section_header_t));
247
        if (rc < 0) {
4338 svoboda 248
            DPRINTF("Read error.\n");
3403 svoboda 249
            return EE_INVALID;
250
        }
2964 svoboda 251
 
252
        rc = section_header(elf, &section_hdr);
2928 svoboda 253
        if (rc != EE_OK)
2961 svoboda 254
            return rc;
2928 svoboda 255
    }
256
 
2964 svoboda 257
    elf->info->entry =
258
        (entry_point_t)((uint8_t *)header->e_entry + elf->bias);
259
 
4338 svoboda 260
    DPRINTF("Done.\n");
2928 svoboda 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
 */
271
char *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
 *
3101 svoboda 280
 * @param entry Segment header.
2928 svoboda 281
 *
282
 * @return EE_OK on success, error code otherwise.
283
 */
2964 svoboda 284
static int segment_header(elf_ld_t *elf, elf_segment_header_t *entry)
2928 svoboda 285
{
286
    switch (entry->p_type) {
287
    case PT_NULL:
288
    case PT_PHDR:
289
        break;
290
    case PT_LOAD:
2964 svoboda 291
        return load_segment(elf, entry);
2928 svoboda 292
        break;
3004 svoboda 293
    case PT_INTERP:
3681 svoboda 294
        /* Assume silently interp == "/app/dload" */
295
        elf->info->interp = "/app/dload";
3004 svoboda 296
        break;
2928 svoboda 297
    case PT_DYNAMIC:
3690 svoboda 298
        /* Record pointer to dynamic section into info structure */
299
        elf->info->dynamic =
300
            (void *)((uint8_t *)entry->p_vaddr + elf->bias);
4338 svoboda 301
        DPRINTF("dynamic section found at 0x%x\n",
3690 svoboda 302
            (uintptr_t)elf->info->dynamic);
303
        break;
3772 svoboda 304
    case 0x70000000:
305
        /* FIXME: MIPS reginfo */
306
        break;
2928 svoboda 307
    case PT_SHLIB:
308
    case PT_NOTE:
3772 svoboda 309
//  case PT_LOPROC:
310
//  case PT_HIPROC:
2928 svoboda 311
    default:
4338 svoboda 312
        DPRINTF("Segment p_type %d unknown.\n", entry->p_type);
2928 svoboda 313
        return EE_UNSUPPORTED;
314
        break;
315
    }
316
    return EE_OK;
317
}
318
 
319
/** Load segment described by program header entry.
320
 *
3101 svoboda 321
 * @param elf   Loader state.
2928 svoboda 322
 * @param entry Program header entry describing segment to be loaded.
323
 *
324
 * @return EE_OK on success, error code otherwise.
325
 */
2964 svoboda 326
int load_segment(elf_ld_t *elf, elf_segment_header_t *entry)
2928 svoboda 327
{
328
    void *a;
329
    int flags = 0;
2932 svoboda 330
    uintptr_t bias;
3010 svoboda 331
    uintptr_t base;
4691 svoboda 332
    void *seg_ptr;
333
    uintptr_t seg_addr;
3010 svoboda 334
    size_t mem_sz;
2928 svoboda 335
    int rc;
336
 
2964 svoboda 337
    bias = elf->bias;
2928 svoboda 338
 
4691 svoboda 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
 
2928 svoboda 345
    if (entry->p_align > 1) {
346
        if ((entry->p_offset % entry->p_align) !=
4691 svoboda 347
            (seg_addr % entry->p_align)) {
4338 svoboda 348
            DPRINTF("Align check 1 failed offset%%align=%d, "
3403 svoboda 349
                "vaddr%%align=%d\n",
350
                entry->p_offset % entry->p_align,
4691 svoboda 351
                seg_addr % entry->p_align
2928 svoboda 352
            );
353
            return EE_INVALID;
354
        }
355
    }
356
 
2992 svoboda 357
    /* Final flags that will be set for the memory area */
358
 
2985 svoboda 359
    if (entry->p_flags & PF_X)
2928 svoboda 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;
3010 svoboda 366
 
367
    base = ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE);
368
    mem_sz = entry->p_memsz + (entry->p_vaddr - base);
2985 svoboda 369
 
4691 svoboda 370
    DPRINTF("Map to seg_addr=0x%x-0x%x.\n", seg_addr,
4338 svoboda 371
    entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));
2928 svoboda 372
 
2985 svoboda 373
    /*
374
     * For the course of loading, the area needs to be readable
375
     * and writeable.
376
     */
3403 svoboda 377
    a = as_area_create((uint8_t *)base + bias, mem_sz,
378
        AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
2928 svoboda 379
    if (a == (void *)(-1)) {
4338 svoboda 380
        DPRINTF("memory mapping failed (0x%x, %d)\n",
3772 svoboda 381
            base+bias, mem_sz);
2928 svoboda 382
        return EE_MEMORY;
383
    }
384
 
4338 svoboda 385
    DPRINTF("as_area_create(0x%lx, 0x%x, %d) -> 0x%lx\n",
4691 svoboda 386
        base + bias, mem_sz, flags, (uintptr_t)a);
2928 svoboda 387
 
388
    /*
389
     * Load segment data
390
     */
2964 svoboda 391
    rc = lseek(elf->fd, entry->p_offset, SEEK_SET);
3403 svoboda 392
    if (rc < 0) {
393
        printf("seek error\n");
394
        return EE_INVALID;
395
    }
2928 svoboda 396
 
2949 svoboda 397
/*  rc = read(fd, (void *)(entry->p_vaddr + bias), entry->p_filesz);
398
    if (rc < 0) { printf("read error\n"); return EE_INVALID; }*/
3101 svoboda 399
 
4338 svoboda 400
    /* Long reads are not possible yet. Load segment piecewise. */
3101 svoboda 401
 
2949 svoboda 402
    unsigned left, now;
403
    uint8_t *dp;
2928 svoboda 404
 
2949 svoboda 405
    left = entry->p_filesz;
4691 svoboda 406
    dp = seg_ptr;
2949 svoboda 407
 
408
    while (left > 0) {
2977 svoboda 409
        now = 16384;
3101 svoboda 410
        if (now > left) now = left;
411
 
3403 svoboda 412
        rc = my_read(elf->fd, dp, now);
3101 svoboda 413
 
3403 svoboda 414
        if (rc < 0) {
4338 svoboda 415
            DPRINTF("Read error.\n");
3403 svoboda 416
            return EE_INVALID;
417
        }
3101 svoboda 418
 
2949 svoboda 419
        left -= now;
420
        dp += now;
421
    }
422
 
3552 svoboda 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
 
3562 svoboda 429
//  printf("set area flags to %d\n", flags);
4691 svoboda 430
    rc = as_area_change_flags(seg_ptr, flags);
2985 svoboda 431
    if (rc != 0) {
4338 svoboda 432
        DPRINTF("Failed to set memory area flags.\n");
2985 svoboda 433
        return EE_MEMORY;
434
    }
435
 
3210 svoboda 436
    if (flags & AS_AREA_EXEC) {
437
        /* Enforce SMC coherence for the segment */
4691 svoboda 438
        if (smc_coherence(seg_ptr, entry->p_filesz))
3210 svoboda 439
            return EE_MEMORY;
440
    }
441
 
2928 svoboda 442
    return EE_OK;
443
}
444
 
445
/** Process section header.
446
 *
3101 svoboda 447
 * @param elf   Loader state.
2928 svoboda 448
 * @param entry Segment header.
449
 *
450
 * @return EE_OK on success, error code otherwise.
451
 */
2964 svoboda 452
static int section_header(elf_ld_t *elf, elf_section_header_t *entry)
2928 svoboda 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;
2961 svoboda 465
    case SHT_DYNAMIC:
466
        break;
2928 svoboda 467
    default:
468
        break;
469
    }
470
 
471
    return EE_OK;
472
}
473
 
474
/** @}
475
 */