Changeset e175d69 in mainline for uspace/srv


Ignore:
Timestamp:
2011-05-01T13:08:18Z (14 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
042fbe0
Parents:
a41577e (diff), e515a827 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge dynamic linking support (ia32-only, off by default). Very limited TLS
support. Executables which use TLS should set STATIC_ONLY = y in Makefile.

Location:
uspace/srv
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/bd/rd/Makefile

    ra41577e re175d69  
    3030USPACE_PREFIX = ../../..
    3131BINARY = rd
     32STATIC_NEEDED = y
    3233
    3334SOURCES = \

  • uspace/srv/devman/Makefile

    ra41577e re175d69  
    3030USPACE_PREFIX = ../..
    3131BINARY = devman
     32STATIC_NEEDED = y
    3233
    3334SOURCES = \

  • uspace/srv/devmap/Makefile

    ra41577e re175d69  
    3030USPACE_PREFIX = ../..
    3131BINARY = devmap
     32STATIC_NEEDED = y
    3233
    3334SOURCES = \

  • uspace/srv/fs/devfs/Makefile

    ra41577e re175d69  
    3232EXTRA_CFLAGS += -I$(LIBFS_PREFIX)
    3333BINARY = devfs
     34STATIC_NEEDED = y
    3435
    3536SOURCES = \

  • uspace/srv/fs/fat/Makefile

    ra41577e re175d69  
    3232EXTRA_CFLAGS += -I$(LIBBLOCK_PREFIX) -I$(LIBFS_PREFIX)
    3333BINARY = fat
     34STATIC_NEEDED = y
    3435
    3536SOURCES = \

  • uspace/srv/fs/tmpfs/Makefile

    ra41577e re175d69  
    3232EXTRA_CFLAGS += -I$(LIBBLOCK_PREFIX) -I$(LIBFS_PREFIX)
    3333BINARY = tmpfs
     34STATIC_NEEDED = y
    3435
    3536SOURCES = \

  • uspace/srv/loader/Makefile

    ra41577e re175d69  
    4242
    4343BINARY = loader
     44STATIC_ONLY = y
    4445
    4546GENERIC_SOURCES = \

  • uspace/srv/loader/elf_load.c

    ra41577e re175d69  
    103103 *
    104104 */
    105 int elf_load_file(const char *file_name, size_t so_bias, elf_info_t *info)
     105int elf_load_file(const char *file_name, size_t so_bias, eld_flags_t flags,
     106    elf_info_t *info)
    106107{
    107108        elf_ld_t elf;
    … …  
    118119        elf.fd = fd;
    119120        elf.info = info;
     121        elf.flags = flags;
    120122
    121123        rc = elf_load(&elf, so_bias);
    … …  
    124126
    125127        return rc;
    126 }
    127 
    128 /** Run an ELF executable.
    129  *
    130  * Transfers control to the entry point of an ELF executable loaded
    131  * earlier with elf_load_file(). This function does not return.
    132  *
    133  * @param info Info structure filled earlier by elf_load_file()
    134  *
    135  */
    136 void elf_run(elf_info_t *info, pcb_t *pcb)
    137 {
    138         entry_point_jmp(info->entry, pcb);
    139 
    140         /* not reached */
    141128}
    142129
    … …  
    153140        pcb->entry = info->entry;
    154141        pcb->dynamic = info->dynamic;
     142        pcb->rtld_runtime = NULL;
    155143}
    156144
    … …  
    306294                break;
    307295        case PT_INTERP:
    308                 /* Assume silently interp == "/rtld.so" */
    309                 elf->info->interp = "/rtld.so";
     296                /* Assume silently interp == "/app/dload" */
     297                elf->info->interp = "/app/dload";
    310298                break;
    311299        case PT_DYNAMIC:
     300                /* Record pointer to dynamic section into info structure */
     301                elf->info->dynamic =
     302                    (void *)((uint8_t *)entry->p_vaddr + elf->bias);
     303                DPRINTF("dynamic section found at 0x%x\n",
     304                        (uintptr_t)elf->info->dynamic);
     305                break;
     306        case 0x70000000:
     307                /* FIXME: MIPS reginfo */
     308                break;
    312309        case PT_SHLIB:
    313         case PT_LOPROC:
    314         case PT_HIPROC:
     310//      case PT_LOPROC:
     311//      case PT_HIPROC:
    315312        default:
    316313                DPRINTF("Segment p_type %d unknown.\n", entry->p_type);
    … …  
    383380            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
    384381        if (a == (void *)(-1)) {
    385                 DPRINTF("Memory mapping failed.\n");
     382                DPRINTF("memory mapping failed (0x%x, %d)\n",
     383                        base+bias, mem_sz);
    386384                return EE_MEMORY;
    387385        }
    … …  
    425423        }
    426424
     425        /*
     426         * The caller wants to modify the segments first. He will then
     427         * need to set the right access mode and ensure SMC coherence.
     428         */
     429        if ((elf->flags & ELDF_RW) != 0) return EE_OK;
     430
     431//      printf("set area flags to %d\n", flags);
    427432        rc = as_area_change_flags(seg_ptr, flags);
    428433        if (rc != 0) {

  • uspace/srv/loader/include/elf_load.h

    ra41577e re175d69  
    4343#include "elf.h"
    4444
     45typedef enum {
     46        /** Leave all segments in RW access mode. */
     47        ELDF_RW = 1
     48} eld_flags_t;
     49
    4550/**
    4651 * Some data extracted from the headers are stored here
    … …  
    6772        uintptr_t bias;
    6873
     74        /** Flags passed to the ELF loader. */
     75        eld_flags_t flags;
     76
    6977        /** A copy of the ELF file header */
    7078        elf_header_t *header;
    … …  
    7482} elf_ld_t;
    7583
    76 int elf_load_file(const char *file_name, size_t so_bias, elf_info_t *info);
    77 void elf_run(elf_info_t *info, pcb_t *pcb);
     84int elf_load_file(const char *file_name, size_t so_bias, eld_flags_t flags,
     85    elf_info_t *info);
    7886void elf_create_pcb(elf_info_t *info, pcb_t *pcb);
    7987

  • uspace/srv/loader/main.c

    ra41577e re175d69  
    5555#include <macros.h>
    5656#include <loader/pcb.h>
     57#include <entry_point.h>
    5758#include <errno.h>
    5859#include <async.h>
    … …  
    6263#include <elf.h>
    6364#include <elf_load.h>
     65
     66#ifdef CONFIG_RTLD
     67#include <rtld/rtld.h>
     68#include <rtld/dynamic.h>
     69#include <rtld/module.h>
     70
     71static int ldr_load_dyn_linked(elf_info_t *p_info);
     72#endif
    6473
    6574#define DPRINTF(...)
    … …  
    8998
    9099static elf_info_t prog_info;
    91 static elf_info_t interp_info;
    92 
    93 static bool is_dyn_linked;
    94100
    95101/** Used to limit number of connections to one. */
    96102static bool connected = false;
     103
     104#ifdef CONFIG_RTLD
     105/** State structure of the dynamic linker. */
     106runtime_env_t dload_re;
     107static module_t prog_mod;
     108#endif
    97109
    98110static void ldr_get_taskid(ipc_callid_t rid, ipc_call_t *request)
    … …  
    283295        int rc;
    284296       
    285         rc = elf_load_file(pathname, 0, &prog_info);
     297        rc = elf_load_file(pathname, 0, 0, &prog_info);
    286298        if (rc != EE_OK) {
    287299                DPRINTF("Failed to load executable '%s'.\n", pathname);
    … …  
    302314        if (prog_info.interp == NULL) {
    303315                /* Statically linked program */
    304                 is_dyn_linked = false;
    305316                async_answer_0(rid, EOK);
    306317                return 0;
    307318        }
    308319       
    309         rc = elf_load_file(prog_info.interp, 0, &interp_info);
    310         if (rc != EE_OK) {
    311                 DPRINTF("Failed to load interpreter '%s.'\n",
    312                     prog_info.interp);
    313                 async_answer_0(rid, EINVAL);
    314                 return 1;
    315         }
    316        
    317         is_dyn_linked = true;
    318         async_answer_0(rid, EOK);
    319        
     320        DPRINTF("Binary is dynamically linked.\n");
     321#ifdef CONFIG_RTLD
     322        DPRINTF(" - pcb address: %p\n", &pcb);
     323        DPRINTF( "- prog dynamic: %p\n", prog_info.dynamic);
     324
     325        rc = ldr_load_dyn_linked(&prog_info);
     326#else
     327        rc = ENOTSUP;
     328#endif
     329        async_answer_0(rid, rc);
    320330        return 0;
    321331}
    322332
     333#ifdef CONFIG_RTLD
     334
     335static int ldr_load_dyn_linked(elf_info_t *p_info)
     336{
     337        runtime_env = &dload_re;
     338
     339        DPRINTF("Load dynamically linked program.\n");
     340
     341        /*
     342         * First we need to process dynamic sections of the executable
     343         * program and insert it into the module graph.
     344         */
     345
     346        DPRINTF("Parse program .dynamic section at %p\n", p_info->dynamic);
     347        dynamic_parse(p_info->dynamic, 0, &prog_mod.dyn);
     348        prog_mod.bias = 0;
     349        prog_mod.dyn.soname = "[program]";
     350
     351        /* Initialize list of loaded modules */
     352        list_initialize(&runtime_env->modules_head);
     353        list_append(&prog_mod.modules_link, &runtime_env->modules_head);
     354
     355        /* Pointer to program module. Used as root of the module graph. */
     356        runtime_env->program = &prog_mod;
     357
     358        /* Work around non-existent memory space allocation. */
     359        runtime_env->next_bias = 0x1000000;
     360
     361        /*
     362         * Now we can continue with loading all other modules.
     363         */
     364
     365        DPRINTF("Load all program dependencies\n");
     366        module_load_deps(&prog_mod);
     367
     368        /*
     369         * Now relocate/link all modules together.
     370         */
     371
     372        /* Process relocations in all modules */
     373        DPRINTF("Relocate all modules\n");
     374        modules_process_relocs(&prog_mod);
     375
     376        /* Pass runtime evironment pointer through PCB. */
     377        pcb.rtld_runtime = (void *) runtime_env;
     378
     379        return 0;
     380}
     381#endif
    323382
    324383/** Run the previously loaded program.
    … …  
    332391        const char *cp;
    333392       
     393        DPRINTF("Set task name\n");
     394
    334395        /* Set the task name. */
    335396        cp = str_rchr(pathname, '/');
    … …  
    337398        task_set_name(cp);
    338399       
    339         if (is_dyn_linked == true) {
    340                 /* Dynamically linked program */
    341                 DPRINTF("Run ELF interpreter.\n");
    342                 DPRINTF("Entry point: %p\n", interp_info.entry);
    343                
    344                 async_answer_0(rid, EOK);
    345                 elf_run(&interp_info, &pcb);
    346         } else {
    347                 /* Statically linked program */
    348                 async_answer_0(rid, EOK);
    349                 elf_run(&prog_info, &pcb);
    350         }
     400        /* Run program */
     401        DPRINTF("Reply OK\n");
     402        async_answer_0(rid, EOK);
     403        DPRINTF("Jump to entry point at %p\n", pcb.entry);
     404        entry_point_jmp(prog_info.entry, &pcb);
    351405       
    352406        /* Not reached */

  • uspace/srv/net/tl/icmp/Makefile

    ra41577e re175d69  
    3232EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
    3333BINARY = icmp
     34STATIC_ONLY = y
    3435
    3536SOURCES = \

  • uspace/srv/ns/Makefile

    ra41577e re175d69  
    3030USPACE_PREFIX = ../..
    3131BINARY = ns
     32STATIC_NEEDED = y
    3233
    3334SOURCES = \

  • uspace/srv/vfs/Makefile

    ra41577e re175d69  
    3030USPACE_PREFIX = ../..
    3131BINARY = vfs
     32STATIC_NEEDED = y
    3233
    3334SOURCES = \
Note: See TracChangeset for help on using the changeset viewer.